Ceci est l'enumération où il y aura tout les effets disponible dans le projet.
- */
-public enum Effects {
- /**
- * pouvoir faire un dash de 4 ligne pendant le round prochain après
- * la recupération.
- */
- POWER,
-
- /**
- *
Modifie la valeur de N pendant 2 tours en le multipliant par 2
- *
Exemple : si N = 2, il va être *2 donc N sera
- * egal à 4 et le prochain tour quand N = 3, il sera égal à 6.
- */
- BOOST,
-
- /**
- *
pouvoir etre invincible pendant le prochain round.
- */
- INVINCIBILITY,
-
- /**
- *
impossible à passer à travers.
- */
- IMPASSABLE;
-}
diff --git a/src/Item/Items.java b/src/Item/Items.java
deleted file mode 100644
index 0651bff..0000000
--- a/src/Item/Items.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package Item;
-
-/**
- * Cette enumération contient tout les items à effets disponnible dans le jeu.
- */
-public enum Items {
- Mur("mur", Effects.IMPASSABLE),
- Body("corps", Effects.IMPASSABLE),
-
- ABRICOT("fraise", Effects.INVINCIBILITY),
- ORANGE("orange", Effects.POWER),
- BANANE("banane", Effects.BOOST);
-
- private final String nom;
- private final Effects effect;
-
- Items(String nom, Effects effects) {
- this.nom = nom;
- this.effect = effects;
- }
-
- /**
- *
type de variable pour recuperer le nom :
- *
String name = Item.FRAISE.getName()
- * @return Avoir le nom de l'item
- */
- public String getName() {
- return this.nom;
- }
-
- /**
- * type de variable pour recuperer l'effet :
- *
Effects effect = Item.FRAISE.getEffects()
- * @return Avoir l'effet de l'item
- */
- public Effects getEffects() {
- return effect;
- }
-}
-
diff --git a/src/Main.java b/src/Main.java
index 7b6214c..edc31a2 100644
--- a/src/Main.java
+++ b/src/Main.java
@@ -1,8 +1,21 @@
-import Item.Items;
-import personnages.*;
+import Display.Terminal;
+import Environnements.Map;
+import Objets.Items;
+import Personnages.Personnage;
+import Personnages.Player;
public class Main {
public static void main(String[] args) {
-
- }
+ Personnage.n = 2;
+
+ Map map = new Map(12, 30);
+
+ map.addObjects(Items.FRAISE, 5, 5);
+
+ Personnage[] personnages = new Personnage[] {
+ new Player(new int[] {0, 0}, "Phillipe")
+ };
+
+ new Terminal(map, personnages);
+ }
}
diff --git a/src/Objets/Effects.java b/src/Objets/Effects.java
new file mode 100644
index 0000000..b0ff4a2
--- /dev/null
+++ b/src/Objets/Effects.java
@@ -0,0 +1,23 @@
+package Objets;
+
+/**
+ * cette enumérateur {@link Effects} contient tout les effets
+ * necessaire pour le bon déroulement du jeu et quelque effets
+ * amusant qui pousse un peu plus les mecaniques du jeu.
+ */
+public enum Effects {
+ /**
+ * reduis le corps de 1.
+ */
+ DECREASESIZE,
+
+ /**
+ * tue le joueur si contact.
+ */
+ IMPASSABLE,
+
+ /**
+ * le vide.
+ */
+ VOID;
+}
diff --git a/src/Objets/Items.java b/src/Objets/Items.java
new file mode 100644
index 0000000..7287705
--- /dev/null
+++ b/src/Objets/Items.java
@@ -0,0 +1,34 @@
+package Objets;
+
+public enum Items {
+ WALL("WALL", Effects.IMPASSABLE),
+ VOID("VOID", Effects.VOID),
+
+ FRAISE("FRAISE", Effects.DECREASESIZE);
+
+ private final String NAME;
+ private final Effects EFFECT;
+
+ Items(String name, Effects effect) {
+ this.NAME = name;
+ this.EFFECT = effect;
+ }
+
+ /**
+ * type de variable pour recuperer le nom de l'item:
+ *
String name = Item.WALL.getName()
+ * @return Avoir le nom de l'item
+ */
+ public String getName() {
+ return this.NAME;
+ }
+
+ /**
+ * type de variable pour recuperer l'effet de l'item:
+ *
Effects effect = Item.WALL.getEffects()
+ * @return Avoir l'effet de l'item
+ */
+ public Effects getEffects() {
+ return this.EFFECT;
+ }
+}
diff --git a/src/Personnages/Mouvements.java b/src/Personnages/Mouvements.java
new file mode 100644
index 0000000..1752cd3
--- /dev/null
+++ b/src/Personnages/Mouvements.java
@@ -0,0 +1,63 @@
+package Personnages;
+
+/**
+ * Cet enumerateur prend en charge tout les mouvements possible
+ * pour le serpent, il a uniquement la possibilité de se déplacer
+ * grâce a {@link Mouvements} pour la classe Player et Robot.
+ */
+public enum Mouvements {
+ /**
+ * HAUT prend comme coordonnée (0, -1) pour se déplacer.
+ * @param x = 0
+ * @param y = -1
+ */
+ HAUT(0, -1),
+
+ /**
+ * BAS prend comme coordonnée (0, 1) pour se déplacer.
+ * @param x = 0
+ * @param y = 1
+ */
+ BAS(0, 1),
+
+ /**
+ * GAUCHE prend comme coordonnée (1, 0) pour se déplacer.
+ * @param x = -1
+ * @param y = 0
+ */
+ GAUCHE(-1, 0),
+
+ /**
+ * @DROITE prend comme coordonnée (-1, 0) pour se déplacer.
+ * @param x = 1
+ * @param y = 0
+ */
+ DROITE(1, 0);
+
+ private final int deltaX;
+ private final int deltaY;
+
+ Mouvements(int deltaX, int deltaY) {
+ this.deltaX = deltaX;
+ this.deltaY = deltaY;
+ }
+
+ /**
+ * Cette fonction prend les coordonnées mis en paramètre et
+ * modifie avec les coordonnées de l'enum.
+ * @param coordinate prend principalement les coordonnées du
+ * personnage
+ */
+ public void updateCoordinate(int[] coordinate) {
+ coordinate[0] += this.deltaX;
+ coordinate[1] += this.deltaY;
+ }
+
+ /**
+ * Cette fonction retourne les coordonnées des valeurs du mouvement.
+ * @return la liste qui contient [0] = x et [1] = y
+ */
+ public int[] getCoordinate() {
+ return new int[] {this.deltaX, this.deltaY};
+ }
+}
\ No newline at end of file
diff --git a/src/Personnages/Personnage.java b/src/Personnages/Personnage.java
new file mode 100644
index 0000000..fe635dc
--- /dev/null
+++ b/src/Personnages/Personnage.java
@@ -0,0 +1,175 @@
+package Personnages;
+
+import java.util.ArrayList;
+
+import Objets.Effects;
+
+/**
+ * Cette classe est la primitive des classes
+ * {@link Player} et {@link Robot}. Elle contient
+ * tout le necessaire pour tout les personnages
+ * jouable du jeu.
+ */
+public class Personnage {
+ /**
+ * cette variable contient la valeur dans laquelle on sait
+ * quand le corps du snake grandi. il est le même pour tout
+ * les personnages du jeu et c'est pour ça que c'est un
+ * static. on peut le changer directement dans le main en
+ * faisant la commande par exemple :
+ * Personnage.n = 2
sans appeler
+ * player ou robot, les deux valeurs vont "automatiquement"
+ * changer.
+ */
+ public static int n;
+
+ /**
+ * cette variable est le nombre de round fait par le snake,
+ * il s'incremente tout les tours quand le snake avance.
+ */
+ private int round;
+
+ /**
+ * cette variable est le nom du snake présent dans le tournois,
+ * il peut etre un mot aléatoire ou quelque chose de personnalisé
+ */
+ protected String name;
+
+ /**
+ * cette variable accumule toute les coordonnées du serpent, elle
+ * contient le corps et la tête et la première coordonnées est la tête.
+ * Le programme peut ajouter des coordonnées en fonction de round et n,
+ * exemple :
+ *
+ * si n > 0 et round > 0 ->
+ * retourner round%n == 0
+ * sinon
+ * retourner faux
+ *
+ */
+ private ArrayList coordinate;
+
+ /**
+ * Le constructor initialise la variable {@link
+ * #coordinate} et prend en paramètre
+ * personnageCoordinate qui est la tête
+ * de notre snake. Il place dans la liste {@link
+ * #coordinate} la coordonnée. Nous pourrons
+ * recuperer les coordonnées de la tête en
+ * utilisant la fonction {@link #getHeadCoordinate()}.
+ */
+ protected Personnage(int[] personnageCoordinate) {
+ coordinate = new ArrayList<>();
+ coordinate.add(personnageCoordinate);
+ }
+
+ /**
+ * cette fonction applique tout les effets defini dans
+ * {@link Effects} et en même temps, sert de fermeture
+ * du programme avec le boolean si l'effet choisi est
+ * IMPASSABLE.
+ * @param effect est la variable qui contient tout les
+ * effets de {@link Effects}
+ * @return
+ * si effect == IMPASSABLE ->
+ * retourner true
+ *sinon
+ * retourner false
+ *
+ */
+ public boolean applyEffects(Effects effect) {
+ switch (effect) {
+ case DECREASESIZE: this.coordinate.removeLast(); break;
+
+ case VOID: break;
+ case IMPASSABLE: return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * cette fonction renvoie la tête du snake mais en clone
+ * donc elle fait une copie de la position existante pour
+ * eviter de prendre l'adresse mémoire de la liste et pouvoir
+ * utiliser celle là comme on veut sans affecter la liste.
+ */
+ public int[] getHeadCoordinate() {
+ return this.coordinate.getFirst().clone();
+ }
+
+ /**
+ * cette fonction renvoie la queue du snake mais en clone
+ * donc elle fait une copie de la position existante pour
+ * eviter de prendre l'adresse mémoire de la liste et pouvoir
+ * utiliser celle là comme on veut sans affecter la liste.
+ */
+ public int[] getLatestCoordinate() {
+ return this.coordinate.getLast().clone();
+ }
+
+ /**
+ * cette fonction renvoie un clone de la liste de coordonnée
+ * donc elle fait une copie des positions existante pour
+ * eviter de prendre l'adresse mémoire de l'ArrayList et pouvoir
+ * utiliser celle là comme on veut sans affecter l'ArrayList.
+ */
+ public ArrayList getCoordinate() {
+ return new ArrayList<>(this.coordinate);
+ }
+
+ /**
+ * cette fonction incremente la variable {@link #round}.
+ */
+ public void increaseRound() {
+ ++this.round;
+ }
+
+ /**
+ * cette fonction renvoie la variable {@link #round}.
+ */
+ public int getRound() {
+ return round;
+ }
+
+ /**
+ * cette fonction renvoie la variable {@link #name}.
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * cette fonction renvoie la longueur de {@link #getCoordinate()}.
+ */
+ public int getSize() {
+ return this.getCoordinate().size();
+ }
+
+ /**
+ * cette fonction change tout les coordonnées du serpent en mettant
+ * la coordonnée de celui d'avant, il prend [1, 2, 3, 4] et fais en
+ * premier temps [1, 1, 2, 3] puis modifie la premiere coordonnée
+ * avec Mouvement, si il y a -1, ça fait [0, 1, 2, 3].
+ * @param mouvement est le mouvement du personnage, comme HAUT, BAS,
+ * GAUCHE et DROITE.
+ */
+ public void moveSnake(Mouvements mouvement) {
+ int[] latestCoordinate = getLatestCoordinate();
+
+ for (int i = this.coordinate.size() - 1; i > 0; i--) {
+ this.coordinate.set(i, this.coordinate.get(i - 1).clone());
+ }
+
+ mouvement.updateCoordinate(this.coordinate.getFirst());
+ increaseSnake(latestCoordinate);
+ }
+
+ /**
+ * ajoute la coordonnée mis en paramètre dans le dernier emplacement si
+ * round > 0 et n > 0 et round%n = 0.
+ */
+ private void increaseSnake(int[] coordinate) {
+ if(round > 0 && n > 0) if (round%n == 0) this.coordinate.add(coordinate);
+ }
+}
diff --git a/src/Personnages/Player.java b/src/Personnages/Player.java
new file mode 100644
index 0000000..60be3b8
--- /dev/null
+++ b/src/Personnages/Player.java
@@ -0,0 +1,45 @@
+package Personnages;
+
+/**
+ * la classe Player a comme classe parent {@link Personnage}
+ * et qui contient tout les besoins primaire pour le bon
+ * fonctionnement de la classe Player. cette classse est très
+ * utile pour qu'un humain puisse jouer.
+ */
+public class Player extends Personnage {
+ /**
+ * la classe Player a comme classe parent {@link Personnage}
+ * et qui contient tout les besoins primaire pour le bon
+ * fonctionnement de la classe Player. Il comporte les coordonnées
+ * initiales pour placer correctement le personnage dans la grille
+ * du jeu.
+ * @param coordinate
+ * @param name
+ */
+ public Player(int[] coordinate, String name) {
+ super(coordinate);
+
+ this.name = name;
+ }
+
+ public boolean moveCoordinate(int keys) {
+ Mouvements value = getMouvement(keys);
+
+ if (value != null) {
+ moveSnake(value);
+ return true;
+ }
+ return false;
+ }
+
+ public Mouvements getMouvement(Integer keys) {
+ switch (keys) {
+ case 0x77: case 0x7A: return Mouvements.HAUT; // w ou z
+ case 0x73: return Mouvements.BAS; // s
+ case 0x61: case 0x71: return Mouvements.GAUCHE; // a ou q
+ case 0x64: return Mouvements.DROITE; // d
+ case null: return null;
+ default: return null;
+ }
+ }
+}
diff --git a/src/Personnages/Robot.java b/src/Personnages/Robot.java
new file mode 100644
index 0000000..64435a1
--- /dev/null
+++ b/src/Personnages/Robot.java
@@ -0,0 +1,7 @@
+package Personnages;
+
+public class Robot extends Personnage {
+ public Robot(int[] coordinate) {
+ super(coordinate);
+ }
+}
diff --git a/src/Personnages/Snake.java b/src/Personnages/Snake.java
new file mode 100644
index 0000000..58a6535
--- /dev/null
+++ b/src/Personnages/Snake.java
@@ -0,0 +1,34 @@
+package Personnages;
+
+import Objets.Effects;
+
+public enum Snake {
+ HEAD("TETE", Effects.IMPASSABLE),
+ BODY("BODY", Effects.IMPASSABLE);
+
+ private final String NAME;
+ private final Effects EFFECT;
+
+ Snake(String name, Effects effect) {
+ this.NAME = name;
+ this.EFFECT = effect;
+ }
+
+ /**
+ * type de variable pour recuperer le nom du corps du snake:
+ *
String name = Snake.HEAD.getName()
+ * @return Avoir le nom de l'item
+ */
+ public String getName() {
+ return this.NAME;
+ }
+
+ /**
+ * type de variable pour recuperer l'effet du corps du snake:
+ *
Effects effect = Snake.HEAD.getEffects()
+ * @return Avoir l'effet de l'item
+ */
+ public Effects getEffects() {
+ return this.EFFECT;
+ }
+}
diff --git a/src/Tests.java b/src/Tests.java
new file mode 100644
index 0000000..4f5e8fb
--- /dev/null
+++ b/src/Tests.java
@@ -0,0 +1,65 @@
+import Objets.Effects;
+import Objets.Items;
+import Display.Display;
+import Environnements.Map;
+import Personnages.Mouvements;
+import Personnages.Personnage;
+import Personnages.Player;
+
+public class Tests {
+ public static void avancerPersonnage() {
+ Player player = new Player(new int[]{1, 1}, "test");
+
+ player.moveSnake(Mouvements.HAUT); // si la position s'est avancé, c'est normal
+ int[] coordinate = player.getHeadCoordinate();
+
+ System.out.println(coordinate[0] + " " + coordinate[1]);
+ }
+
+ public static void taillePersonnage() {
+ Personnage.n = 2;
+
+ Player player = new Player(new int[]{1, 1}, "test");
+ player.increaseRound();
+ player.moveSnake(Mouvements.HAUT); // si il y a 2 valeurs, c'est normal
+
+ for (int[] coordinate : player.getCoordinate()) {
+ System.out.println(coordinate[0] + " " + coordinate[1]);
+ }
+ }
+
+ public static void effectsPersonnage() {
+ Personnage.n = 2;
+
+ Player player = new Player(new int[]{1, 1}, "test");
+ player.applyEffects(Effects.DECREASESIZE); // si c'est vide c'est que ça marche
+
+ System.out.println(player.getCoordinate());
+ }
+
+ public static void creationMap() {
+ Map map = new Map(30, 30);
+ map.addObjects(Items.FRAISE, 29, 29);
+ map.placeObjects();
+
+ Display.printMap(map.addEdges());
+ }
+
+ public static void drawMap() {
+ Map map = new Map(30, 30);
+ Display.printMap(map.addEdges(), null);
+ }
+
+ public static void placePersonnageMap() {
+ Map map = new Map(30, 30);
+ map.placePersonnages(new Player(new int[]{1, 1}, "null"));
+
+ Display.printMap(map.addEdges(), new Personnage[] {new Player(new int[]{1, 1}, "null")});
+ }
+
+ public static void effects() {
+ Map map = new Map(5, 1);
+ Player player = new Player(new int[] {0, 0}, "null");
+ map.addObjects(Items.FRAISE, 1, 0);
+ }
+}
\ No newline at end of file
diff --git a/src/display/Display.java b/src/display/Display.java
new file mode 100644
index 0000000..e28dfbb
--- /dev/null
+++ b/src/display/Display.java
@@ -0,0 +1,152 @@
+package Display;
+
+import java.util.ArrayList;
+
+import Environnements.Map;
+import Objets.Items;
+import Personnages.Personnage;
+import Personnages.Snake;
+
+public class Display {
+ /**
+ * cette fonction clear le terminal et le remet en
+ * haut a gauche de la ligne.
+ */
+ public static void clearTerminal() {
+ System.out.println("\u001b[2J \u001b[H");
+ }
+
+ /**
+ * cette fonction dessine la grille avec des noms
+ * pour chaque items.
+ */
+ public static void printMap(Object[][] map) {
+ for (Object[] object : map) {
+ for (Object value : object) {
+ System.out.print(value.toString() + " ");
+ }
+ System.out.println();
+ }
+ }
+
+ /**
+ * cette fonction print le snake dans le terminal avec des
+ * caracteres speciaux, (du utf-8).
+ * @param map
+ * @param personnages
+ */
+ public static void printMap(Object[][] map, Personnage[] personnages) {
+ for (int i = 0; i 0) ? map[y - 1][x] == Items.WALL : false,
+ (y < map.length - 1) ? map[y+1][x] == Items.WALL : false,
+ (x > 0) ? map[y][x - 1] == Items.WALL : false,
+ (x < map[y].length - 1) ? map[y][x + 1] == Items.WALL : false,
+ };
+
+ System.out.print(whichWall(position));
+ }
+
+ private static String whichWall(boolean[] isWall) {
+ String positionWall = new String();
+
+ if (isWall[0] && isWall[1] && isWall[2] && isWall[3]) positionWall = "\u2550\u256C\u2550";
+
+ else if (isWall[0] && isWall[1] && isWall[3]) positionWall = "\u2560";
+ else if (isWall[0] && isWall[1] && isWall[2]) positionWall = "\u2563";
+ else if (isWall[0] && isWall[2] && isWall[3]) positionWall = "\u2550\u2569\u2550";
+ else if (isWall[1] && isWall[2] && isWall[3]) positionWall = "\u2550\u2566\u2550";
+
+ else if (isWall[0] && isWall[1]) positionWall = "\u2551";
+ else if (isWall[2] && isWall[3]) positionWall = "\u2550\u2550\u2550";
+ else if (isWall[0] && isWall[2]) positionWall = "\u255D ";
+ else if (isWall[0] && isWall[3]) positionWall = "\u255A";
+ else if (isWall[1] && isWall[2]) positionWall = "\u2557 ";
+ else if (isWall[1] && isWall[3]) positionWall = "\u2554";
+
+ else positionWall = "\u2550\u256C\u2550";
+
+ return positionWall;
+ }
+
+ private static void printHead(Personnage[] personnages, int x, int y) {
+ Personnage personnage = searchSnake(personnages, x, y);
+
+ if (personnage != null) {
+ ArrayList personnageCoordinate = personnage.getCoordinate();
+
+ int[] primaryCoordinate = personnage.getHeadCoordinate();
+
+ if (personnageCoordinate.size() > 1) {
+ int[] secondCoordinate = personnageCoordinate.get(1);
+
+ // UP DOWN LEFT RIGHT
+ boolean[] isHead = new boolean[] {
+ primaryCoordinate[0] == secondCoordinate[0] && primaryCoordinate[1] > secondCoordinate[1], // UP
+ primaryCoordinate[0] == secondCoordinate[0] && primaryCoordinate[1] < secondCoordinate[1], // DOWN
+ primaryCoordinate[1] == secondCoordinate[1] && primaryCoordinate[0] > secondCoordinate[0], // LEFT
+ primaryCoordinate[1] == secondCoordinate[1] && primaryCoordinate[0] < secondCoordinate[0] // RIGHT
+ };
+
+ if (isHead[0]) {System.out.print(" \u21E9 ");return;}
+ else if (isHead[1]) {System.out.print(" \u21E7 ");return;}
+ else if (isHead[2]) {System.out.print("\u21E8 ");return;}
+ else if (isHead[3]) {System.out.print(" \u21E6");return;}
+ }
+ }
+ System.out.print(" \u25CF ");
+ }
+
+ private static Personnage searchSnake(Personnage[] personnages, int x, int y) {
+ for (Personnage personnage : personnages) {
+ int[] primaryCoordinate = personnage.getHeadCoordinate();
+
+ int primaryY = primaryCoordinate[1] + 1;
+ int primaryX = primaryCoordinate[0] + 1;
+
+ if (primaryX == x && primaryY == y) {
+ return personnage;
+ }
+ }
+ return null;
+ }
+}
diff --git a/src/display/Terminal.java b/src/display/Terminal.java
new file mode 100644
index 0000000..13821b4
--- /dev/null
+++ b/src/display/Terminal.java
@@ -0,0 +1,146 @@
+package Display;
+
+import java.util.Scanner;
+
+import Environnements.Map;
+import Objets.Effects;
+import Objets.Items;
+import Personnages.Mouvements;
+import Personnages.Personnage;
+import Personnages.Player;
+import Personnages.Robot;
+
+public class Terminal {
+ private int round = 0;
+
+ private static Map map;
+ private static Personnage[] personnages;
+
+ private static Scanner scanner;
+
+
+ public Terminal(Map m, Personnage[] personnage) {
+ scanner = new Scanner(System.in);
+ personnages = personnage;
+ map = m;
+
+ run();
+ }
+
+ /**
+ * Cette fonction est uniquement destiné pour la classe
+ * Players pour recuperer l'input dans le terminal.
+ * @param player
+ * @return il retourne int qui est le char en ascii
+ */
+ private static int getInput(Player player) {
+ String value = new String();
+ Integer input = null;
+
+ do {
+ value = scanner.nextLine();
+ input = changeCoordinate(value);
+ }while(player.getMouvement(input) == null);
+
+ return input.intValue();
+ }
+
+ /**
+ * transforme le String en prennant le premier char et
+ * le mets en ascii dans la classe Integer.
+ * @param input
+ * @return
+ */
+ private static Integer changeCoordinate(String input) {
+ if (input.length() > 0) {
+ return (int)input.charAt(0);
+ }
+ return null;
+ }
+
+ /**
+ * place tout les personnages dans la fonction {@link #map.placePersonnages()}
+ * @param personnages
+ */
+ private static void placePersonnages(Personnage[] personnages) {
+ for(Personnage personnage : personnages) {
+ map.placePersonnages(personnage);
+ }
+ }
+
+ /**
+ * cette fonction est spécialement conçu pour gerer le gameplay du joueur.
+ * @param player
+ * @return
+ */
+ private static boolean playerRound(Player player) {
+ int input = getInput(player);
+ player.moveCoordinate(input);
+
+ int[] coordinate = player.getHeadCoordinate();
+ if(map.isGameOver(player.getHeadCoordinate()) || player.applyEffects(map.getEffect(coordinate))) return true;
+
+ player.increaseRound();
+ return false;
+ }
+
+ /**
+ * cette fonction est spécialement conçu pour gerer le gameplay du robot.
+ * @param player
+ * @return
+ */
+ private static boolean robotRound(Robot robot) {
+ return false;
+ }
+
+ /**
+ * cette fonction cherche si le personnage mis en paramètre
+ * est un {@link Player} ou un {@link Robot}.
+ * @param player
+ * @return
+ */
+ private static boolean instancePersonnage(Personnage personnage) {
+ if (personnage instanceof Player) {
+ // tour du Player
+ return playerRound((Player)personnage);
+ }
+
+ if (personnage instanceof Robot) {
+ // tour du robot
+ return robotRound((Robot)personnage);
+ }
+
+ return false;
+ }
+
+ /**
+ * la fonction principal qui lance tout le jeu en terminal.
+ */
+ private void run() {
+ boolean isGameOver = false;
+ int i = 0;
+
+ while(!isGameOver) {
+ for (i = 0; i effectsList;
-
- protected Personnage(int size, int[] coordinate) {
- this.coordinate = coordinate;
- this.size = size;
- }
-
- public int getSize() {
- return size;
- }
-
- public void incrementSize(long size) {
- this.size += size;
- }
-
- public void addEffects(Effects effect) {
- this.effectsList.add(effect);
- }
-
- public ArrayList getEffects() {
- return this.effectsList;
- }
-
- public boolean haveEffect(Effects effect) {
- return effectsList.contains(effect);
- }
-}
diff --git a/src/personnages/Player.java b/src/personnages/Player.java
deleted file mode 100644
index eea16c5..0000000
--- a/src/personnages/Player.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package personnages;
-
-public class Player extends Personnage {
- public Player(int size, int[] coordinate) {
- super(size, coordinate);
- }
-
- public void moveCoordinate(int keys) {
- switch (keys) {
- case 77: // w
- this.coordinate[1]++;
- break;
-
- case 73: // s
- this.coordinate[1]--;
- break;
-
- case 61: // a
- this.coordinate[0]--;
- break;
-
- case 64: // d
- this.coordinate[0]++;
- break;
-
- default: // autre
- break;
- }
- }
-}
diff --git a/src/personnages/Robot.java b/src/personnages/Robot.java
deleted file mode 100644
index 038e100..0000000
--- a/src/personnages/Robot.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package personnages;
-
-public class Robot extends Personnage {
- public Robot(int size, int[] coordinate) {
- super(size, coordinate);
- }
-}
\ No newline at end of file