/Monster
Documentation - Monstres
Vue d'ensemble
Le système de monstres gère tous les ennemis du jeu. Chaque monstre possède une template de base et peut avoir jusqu'à 12 grades (niveaux) différents.
Architecture
Hiérarchie des Classes
Monster (Template de monstre)
├── MobGrade (Grades 1-12)
│ ├── Statistiques
│ ├── Sorts
│ └── Résistances
└── MobGroup (Groupes de monstres)
└── Instances en combat
Monster - Template de Monstre
Définition
La classe Monster représente un type de monstre avec ses propriétés de base.
Localisation: src/main/java/entity/monster/Monster.java
Propriétés
private int id; // ID unique
private int gfxId; // ID du sprite graphique
private int align; // Alignement (PvP)
private String colors; // Couleurs du monstre
private int ia; // Type d'IA
private int minKamas; // Kamas minimum
private int maxKamas; // Kamas maximum
private Map<Integer, MobGrade> grades; // Grades 1-12
private ArrayList<Drop> drops; // Table de loot
private boolean isCapturable; // Peut être capturé
private int aggroDistance; // Distance d'agression
private String name; // Nom du monstre
Types d'IA
| Type | Description | Comportement |
|---|---|---|
| 0 | Passif | N'attaque pas |
| 1 | Agressif | Attaque à vue |
| 2 | Défensif | Attaque si attaqué |
| 3 | Intelligent | Stratégie adaptée |
| 4 | Fuyant | Fuit si blessé |
| 5 | Invocateur | Invoque des alliés |
Chargement depuis la Base de Données
Table: monsters
SELECT * FROM monsters WHERE id = ?
Colonnes:
id: INT - ID uniquegfxID: INT - ID du spritealign: INT - Alignementcolors: VARCHAR - Couleurs (format: "FF0000;00FF00;0000FF")grades: VARCHAR - Grades (format: "1@resist1|2@resist2|...")spells: VARCHAR - Sorts (format: "1;2;3|4;5;6|...")stats: VARCHAR - Stats (format: "force,sage,inte,chan,agil|...")statsInfos: VARCHAR - Infos stats (format: "doma;perdom;soin;sum|...")pdvs: VARCHAR - PV max (format: "100|150|200|...")points: VARCHAR - PA/PM (format: "3;3|4;4|...")inits: VARCHAR - Initiative (format: "10|15|20|...")name: VARCHAR - Nom du monstreminKamas: INT - Kamas minimummaxKamas: INT - Kamas maximumexps: VARCHAR - XP (format: "100|150|200|...")AI_Type: INT - Type d'IAcapturable: BOOLEAN - Peut être capturéaggroDistance: INT - Distance d'agression
Constructeur
public Monster(int id, int gfxId, int align, String colors, String thisGrades,
String thisSpells, String thisStats, String thisStatsInfos,
String thisPdvs, String thisPoints, String thisInit,
int minKamas, int maxKamas, String thisXp, int ia,
boolean capturable, int aggroDistance, String name)
Exemple de Monstre
// Créer un monstre: Gobelin
Monster goblin = new Monster(
1, // ID
10, // Sprite ID
0, // Alignement
"FF0000;00FF00;0000FF", // Couleurs
"1@10,10,10,10,10|2@15,15,15,15,15|...", // Grades
"1;2|3;4|...", // Sorts
"10,10,10,10,10|15,15,15,15,15|...", // Stats
"5;5;5;5|10;10;10;10|...", // Infos stats
"50|75|100|...", // PV max
"3;3|4;4|...", // PA/PM
"10|15|20|...", // Initiative
10, // Kamas min
50, // Kamas max
"100|150|200|...", // XP
1, // IA: Agressif
true, // Capturable
5, // Distance d'agression
"Gobelin" // Nom
);
MobGrade - Grades de Monstre
Définition
La classe MobGrade représente une variante de niveau d'un monstre.
Localisation: src/main/java/entity/monster/MobGrade.java
Propriétés
private Monster template; // Référence au template
private int grade; // Grade (1-12)
private int level; // Niveau
private int pdv; // PV actuels
private int pdvMax; // PV maximum
private int inFightId; // ID en combat
private int init; // Initiative
private int pa; // Points d'Action
private int pm; // Points de Mouvement
private int size; // Taille du sprite
private int baseXp; // XP de base
private String _resistencias; // Résistances
private String _spells; // Sorts
private Map<Integer, Integer> stats; // Statistiques
private Map<Integer, SortStats> spells; // Sorts avec stats
private ArrayList<Integer> statsInfos; // Infos stats
private ArrayList<SpellEffect> fightBuffs; // Buffs en combat
Grades et Niveaux
| Grade | Niveau | Difficulté |
|---|---|---|
| 1 | 1-10 | Très facile |
| 2 | 11-20 | Facile |
| 3 | 21-30 | Normal |
| 4 | 31-40 | Moyen |
| 5 | 41-50 | Difficile |
| 6 | 51-60 | Très difficile |
| 7 | 61-70 | Expert |
| 8 | 71-80 | Expert+ |
| 9 | 81-90 | Légendaire |
| 10 | 91-100 | Légendaire+ |
| 11 | 101-110 | Mythique |
| 12 | 111-120 | Mythique+ |
Constructeur
public MobGrade(Monster template, int grade, int level, int pa, int pm,
String resists, String stats, String statsInfos,
String allSpells, int pdvMax, int aInit, int xp, int n)
Paramètres:
template: Référence au templategrade: Grade (1-12)level: Niveaupa: Points d'Actionpm: Points de Mouvementresists: Résistances (format: "neu,ter,feu,eau,air,aflee,mflee")stats: Statistiques (format: "force,sage,inte,chan,agil")statsInfos: Infos stats (format: "doma;perdom;soin;sum")allSpells: Sorts (format: "1;2;3")pdvMax: PV maximumaInit: Initiativexp: XP à gagnern: Numéro pour calcul de taille
Statistiques
Les statistiques sont stockées dans une Map avec les codes suivants:
STATS_ADD_FORC = 0x01 // Force
STATS_ADD_SAGE = 0x02 // Sagesse
STATS_ADD_INTE = 0x03 // Intelligence
STATS_ADD_CHAN = 0x04 // Chance
STATS_ADD_AGIL = 0x05 // Agilité
STATS_ADD_DOMA = 0x06 // Dommages
STATS_ADD_PERDOM = 0x07 // Perte de dommages
STATS_ADD_SOIN = 0x08 // Soins
STATS_ADD_RP_NEU = 0x09 // Résistance Neutre
STATS_ADD_RP_TER = 0x0A // Résistance Terre
STATS_ADD_RP_FEU = 0x0B // Résistance Feu
STATS_ADD_RP_EAU = 0x0C // Résistance Eau
STATS_ADD_RP_AIR = 0x0D // Résistance Air
STATS_ADD_AFLEE = 0x0E // Esquive d'attaque
STATS_ADD_MFLEE = 0x0F // Esquive de magie
Résistances
Les résistances réduisent les dégâts reçus:
Dégâts finaux = Dégâts de base * (100 - Résistance) / 100
Exemple de Grade
// Grade 1 du Gobelin
MobGrade goblinGrade1 = new MobGrade(
goblin, // Template
1, // Grade
5, // Niveau
3, // PA
3, // PM
"10,10,10,10,10,5,5", // Résistances
"10,10,10,10,10", // Stats
"5;5;5;5", // Infos stats
"1;2", // Sorts
50, // PV max
10, // Initiative
100, // XP
0 // Numéro
);
MobGroup - Groupes de Monstres
Définition
La classe MobGroup représente un groupe de monstres sur une carte.
Localisation: src/main/java/entity/monster/MobGroup.java
Propriétés
private int id; // ID unique
private int mapId; // Carte
private int cellId; // Cellule
private ArrayList<MobGrade> mobs; // Monstres du groupe
private int level; // Niveau du groupe
private boolean isFixed; // Groupe fixe
private int respawnTime; // Temps de respawn
private long lastRespawn; // Dernier respawn
Chargement depuis la Base de Données
Table: mobgroups_fix ou mobgroups
SELECT * FROM mobgroups_fix WHERE mapid = ? AND cellid = ?
Colonnes:
mapid: INT - ID de la cartecellid: INT - ID de la cellulegroupData: VARCHAR - Données du groupe (format: "1,1;2,2;3,1")Donjon: VARCHAR - Donjon (optionnel)Salle: VARCHAR - Salle (optionnel)Timer: INT - Temps de respawn
Format des Données de Groupe
monsterId,grade;monsterId,grade;...
Exemple:
1,1;1,2;2,1
Signifie:
- Monstre 1 grade 1
- Monstre 1 grade 2
- Monstre 2 grade 1
Exemple de Groupe
// Créer un groupe: 2 Gobelins grade 1 et 1 Gobelin grade 2
MobGroup group = new MobGroup(
1, // ID
10, // Carte
50, // Cellule
true, // Groupe fixe
300 // Respawn: 5 minutes
);
// Ajouter les monstres
group.addMob(goblin.getGrade(1));
group.addMob(goblin.getGrade(1));
group.addMob(goblin.getGrade(2));
Combat avec les Monstres
Étape 1: Rencontrer un Groupe
// Le joueur rencontre un groupe de monstres
MobGroup group = map.getMobGroup(cellId);
if (group != null) {
// Créer un combat
Fight fight = new Fight(player, group);
// Ajouter les combattants
for (MobGrade mob : group.getMobs()) {
fight.addFighter(mob);
}
// Démarrer le combat
fight.start();
}
Étape 2: Combattre
// Le combat se déroule par tours
while (fight.isRunning()) {
// Tour du joueur
if (fight.getCurrentFighter() == player) {
// Le joueur attaque
Spell spell = Main.world.getSort(1);
Fighter target = fight.getRandomEnemy(player);
// Appliquer les dégâts
int damage = Formulas.calculateDamage(
player.getStats(),
spell.getSortStats(1).getMinDamage(),
spell.getSortStats(1).getMaxDamage()
);
target.takeDamage(damage);
} else {
// Tour du monstre
Fighter mob = fight.getCurrentFighter();
// IA du monstre
switch (mob.getTemplate().getIA()) {
case 1: // Agressif
Fighter target = fight.getRandomEnemy(mob);
mob.attack(target);
break;
case 2: // Défensif
if (mob.getHealth() < mob.getMaxHealth() / 2) {
mob.heal(50);
} else {
mob.attack(fight.getRandomEnemy(mob));
}
break;
}
}
// Passer au tour suivant
fight.nextTurn();
}
Étape 3: Fin du Combat
// Le combat est terminé
if (fight.isWon()) {
// Gagner les récompenses
int totalXp = 0;
int totalKamas = 0;
for (Fighter mob : fight.getEnemies()) {
totalXp += mob.getTemplate().getBaseXp();
totalKamas += Formulas.randomInt(
mob.getTemplate().getMinKamas(),
mob.getTemplate().getMaxKamas()
);
}
// Ajouter les récompenses
player.addXP(totalXp);
player.addKamas(totalKamas);
// Ajouter le loot
for (Fighter mob : fight.getEnemies()) {
ArrayList<Drop> drops = mob.getTemplate().getDrops();
for (Drop drop : drops) {
if (Math.random() * 100 < drop.getChance()) {
player.addItem(drop.getItemId(), drop.getQuantity());
}
}
}
System.out.println("Combat gagné! XP: " + totalXp + ", Kamas: " + totalKamas);
} else {
// Combat perdu
player.setHealth(1);
player.teleport(lastSafeCell);
System.out.println("Combat perdu!");
}
Table de Loot
Définition
La table de loot définit les items que les monstres peuvent dropper.
Structure
private int itemId; // ID de l'item
private int quantity; // Quantité
private double chance; // Chance de drop (0-100)
private int minLevel; // Niveau minimum du monstre
private int maxLevel; // Niveau maximum du monstre
Exemple
// Ajouter un drop au monstre
Drop drop = new Drop(
100, // Item ID
1, // Quantité
50.0, // 50% de chance
1, // Niveau min
10 // Niveau max
);
goblin.addDrop(drop);
Exemple Complet - Créer un Monstre
1. Créer le Monstre en Base de Données
-- Créer le monstre
INSERT INTO monsters (
id, gfxID, align, colors, grades, spells, stats, statsInfos,
pdvs, points, inits, name, minKamas, maxKamas, exps, AI_Type,
capturable, aggroDistance
) VALUES (
1, -- ID
10, -- Sprite ID
0, -- Alignement
"FF0000;00FF00;0000FF", -- Couleurs
"1@10,10,10,10,10|2@15,15,15,15,15|3@20,20,20,20,20|4@25,25,25,25,25|5@30,30,30,30,30|6@35,35,35,35,35|7@40,40,40,40,40|8@45,45,45,45,45|9@50,50,50,50,50|10@55,55,55,55,55|11@60,60,60,60,60|12@65,65,65,65,65",
"1;2|3;4|5;6|7;8|9;10|11;12|13;14|15;16|17;18|19;20|21;22|23;24",
"10,10,10,10,10|15,15,15,15,15|20,20,20,20,20|25,25,25,25,25|30,30,30,30,30|35,35,35,35,35|40,40,40,40,40|45,45,45,45,45|50,50,50,50,50|55,55,55,55,55|60,60,60,60,60|65,65,65,65,65",
"5;5;5;5|10;10;10;10|15;15;15;15|20;20;20;20|25;25;25;25|30;30;30;30|35;35;35;35|40;40;40;40|45;45;45;45|50;50;50;50|55;55;55;55|60;60;60;60",
"50|75|100|125|150|175|200|225|250|275|300|325",
"3;3|4;4|5;5|6;6|7;7|8;8|9;9|10;10|11;11|12;12|13;13|14;14",
"10|15|20|25|30|35|40|45|50|55|60|65",
"Gobelin",
10,
50,
"100|150|200|250|300|350|400|450|500|550|600|650",
1,
1,
5
);
-- Créer les drops
INSERT INTO monster_drops (monster_id, item_id, quantity, chance, minLevel, maxLevel)
VALUES
(1, 100, 1, 50.0, 1, 10),
(1, 101, 1, 30.0, 1, 10),
(1, 102, 1, 20.0, 1, 10);
2. Charger le Monstre
// Charger le monstre
Monster goblin = Main.world.getMobTemplate(1);
// Afficher les infos
System.out.println("Monstre: " + goblin.getName());
System.out.println("Sprite: " + goblin.getGfxId());
// Afficher les grades
for (int grade = 1; grade <= 12; grade++) {
MobGrade mobGrade = goblin.getGrade(grade);
System.out.println("Grade " + grade + ": Niveau " + mobGrade.getLevel() +
", PV=" + mobGrade.getPdvMax() +
", XP=" + mobGrade.getBaseXp());
}
3. Créer un Groupe de Monstres
// Créer un groupe
MobGroup group = new MobGroup(1, 10, 50, true, 300);
// Ajouter les monstres
group.addMob(goblin.getGrade(1));
group.addMob(goblin.getGrade(1));
group.addMob(goblin.getGrade(2));
// Ajouter à la carte
map.addMobGroup(group);
4. Rencontrer le Groupe
// Le joueur rencontre le groupe
MobGroup group = map.getMobGroup(50);
if (group != null) {
// Créer un combat
Fight fight = new Fight(player, group);
// Ajouter les combattants
for (MobGrade mob : group.getMobs()) {
fight.addFighter(mob);
}
// Démarrer le combat
fight.start();
System.out.println("Combat contre " + group.getMobs().size() + " monstres!");
}
Gestion des Erreurs
Validations Courantes
// Vérifier le grade
if (grade < 1 || grade > 12) {
throw new Exception("Grade invalide");
}
// Vérifier le niveau
if (level < 1 || level > 200) {
throw new Exception("Niveau invalide");
}
// Vérifier les PV
if (pdvMax <= 0) {
throw new Exception("PV invalides");
}
// Vérifier les stats
if (stats.isEmpty()) {
throw new Exception("Stats manquantes");
}
Conclusion
Le système de monstres offre une grande flexibilité pour créer des ennemis variés avec des niveaux de difficulté progressifs. Les 12 grades permettent une progression naturelle du jeu.