diff --git a/res/ASCII-Table.svg b/lib/ASCII-Table.svg similarity index 100% rename from res/ASCII-Table.svg rename to lib/ASCII-Table.svg diff --git a/res/ProjetL12024.pdf b/lib/ProjetL12024.pdf similarity index 100% rename from res/ProjetL12024.pdf rename to lib/ProjetL12024.pdf diff --git a/src/Characters/Mouvements.java b/src/Characters/Mouvements.java new file mode 100644 index 0000000..56b8748 --- /dev/null +++ b/src/Characters/Mouvements.java @@ -0,0 +1,63 @@ +package Characters; + +/** + * 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 editCoordinate(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}; + } +} diff --git a/src/Characters/Personnage.java b/src/Characters/Personnage.java new file mode 100644 index 0000000..820df2e --- /dev/null +++ b/src/Characters/Personnage.java @@ -0,0 +1,136 @@ +package Characters; + +import java.util.ArrayList; + +import Objects.Snake; + +/** + * Cet classe est la classe precurseur de tout les heritage pour creer un + * personnage jouable. + */ +public class Personnage { + private int n; + private int round; + private int size = 0; + private Snake head = Snake.HEAD; + + /** + *

la liste de toute les coordonnées en fonction de N. Si N = 2, + * tout les deux tours, la taille du serpent augmente de 1. Si N = 3, + * tous les 3 tours, ça va augmenter de 1. On peut l'ecrire comme + * Round/N (les deux variables en int). + *

Le premier index est la coordonnée de la tête et les autres + * sont les coordonnées de son corps. + */ + private ArrayList coordinate; + + /** + *

le constructor definie un arrayList pour {@link #coordinate} + * et defini n. + * + * @param name est le nom du personnage. + * @param n est une variable qui contient le nombre de tour avant + * l'augmentation de taille. + * @param coordinate est la variable qui contient les coordonnées + * qui sont placé par la suite dans {@link #coordinate}[0] + */ + protected Personnage(int n, int[] coordinate) { + this.coordinate = new ArrayList(); + this.coordinate.add(coordinate); + + this.n = n; + } + + /** + * cette fonction retourne la premiere coordonnée de la liste {@link + * #coordinate} qui la tête du personnage + * @return la tête du personnage. + */ + public int[] getPrimaryCoordinate() { + return coordinate.get(0); + } + + /** + * cette fonction retourne toute la liste {@link #coordinate} de + * coordonnée du serpent. + * @return toute la liste des coordonnées du serpent + */ + public ArrayList getCoordinate() { + return coordinate; + } + + /** + * @return augmente le tour après que le personnage a jouer + */ + public int incrementRound() { + return ++this.round; + } + + /** + * @return retourn un bool pour savoir si la taille s'est + * aggrandi + */ + public boolean isIncreaseSize() { + int size = this.round/n; + if (this.size < size) { + this.size = size; + return true; + } + return false; + } + + /** + * @return retourn un bool pour savoir si la taille s'est + * retreci. + */ + public boolean isDecreaseSize() { + int size = this.round/n; + if (this.size > size) { + this.size = size; + return true; + } + return false; + } + + /** + *

cette fonction est très pratique aggrandir le serpent + * car elle garde la derniere coordonnée et si on la fusionne + * avec {@link #moveToLatestCoordinate()}, on peut l'utiliser + * ajouter la coordonnée pour justement l'aggrandir. + * @return garde la derniere coordonnée du serpent (sa queue) + */ + public int[] keepLatestCoordinate() { + return this.coordinate.get(getCoordinate().size()-1); + } + + /** + *

ajoute au dernier index, la valeur en parametre, très utile + * en combinant avec {@link #keepLatestCoordinate()} pour aggrandir + * le serpent. + * @param coordinate ajout de la nouvelle coordonnée + */ + public void moveToLatestCoordinate(int[] coordinate) { + this.coordinate.add(coordinate); + } + + /** + *

modifie toute la liste {@link #coordinate} pour deplacer tout le + * serpent. + * @param mouvements le mouvement utilisé pour deplacer le serpent + */ + protected void moveSnake(Mouvements mouvements) { + for (int[] coordinate : this.coordinate) { + mouvements.editCoordinate(coordinate); + } + } + + public Mouvements getMouvement(int keys) { + switch (keys) { + case 0x77: return Mouvements.HAUT; // w + case 0x73: return Mouvements.BAS; // s + case 0x61: return Mouvements.GAUCHE; // a + case 0x64: return Mouvements.DROITE; // d + default: return null; + } + } +} diff --git a/src/Characters/Players.java b/src/Characters/Players.java new file mode 100644 index 0000000..7e69f35 --- /dev/null +++ b/src/Characters/Players.java @@ -0,0 +1,23 @@ +package Characters; + +public class Players extends Personnage { + public Players(int[] coordinate, int n) { + super(n, coordinate); + } + + public Integer changeCoordinate(String input) { + if (input.length() > 0) { + return (int)input.charAt(0); + } + return null; + } + + public boolean moveCoordinate(int keys) { + Mouvements value = getMouvement(keys); + if (value != null) { + moveSnake(value); + return true; + } + return false; + } +} diff --git a/src/Characters/Robot.java b/src/Characters/Robot.java new file mode 100644 index 0000000..ddc6640 --- /dev/null +++ b/src/Characters/Robot.java @@ -0,0 +1,9 @@ +package Characters; + +public class Robot extends Personnage { + + protected Robot(int[] coordinate, int n) { + super(n, coordinate); + } + +} diff --git a/src/Reseau.java b/src/Connexion/Reseau.java similarity index 99% rename from src/Reseau.java rename to src/Connexion/Reseau.java index c54b61c..6d4d397 100644 --- a/src/Reseau.java +++ b/src/Connexion/Reseau.java @@ -1,3 +1,5 @@ +package Connexion; + import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; diff --git a/src/Environnement/Map.java b/src/Environnement/Map.java new file mode 100644 index 0000000..3677c7c --- /dev/null +++ b/src/Environnement/Map.java @@ -0,0 +1,145 @@ +package Environnement; + +import java.util.ArrayList; +import java.util.Random; + +import Characters.Personnage; +import Objects.*; + +/** + *

cette classe est la classe qui cree et genere + * tout ce qui est important pour la Map du jeu + */ +public class Map { + /** + *

cette variable est toute la grille où se + * passe tout le jeu. + */ + private Object[][] grid; + + /** + *

cette variable recupere tout les objects stockés + */ + private ArrayList ObjectItems; + + /** + *

cette variable recupere tout les coordonnées des + * objects stockés + */ + private ArrayList coordinateItems; + + private int longueur; + private int largeur; + + /** + *

le constructeur crée une grille "vide" qui + * contient uniquement l'enumerateur Items.VOID + * avec la longueur et la largeur en paramètre. + * + * @param longueur pour la grille du jeu + * @param largeur pour la grille du jeu + */ + public Map(int longueur, int largeur) { + this.longueur = longueur; + this.largeur = largeur; + + this.grid = new Object[this.longueur][this.largeur]; + this.fillGrid(); + } + + /** + *

cette fonction clear toute la grille qui + * contient le jeu. + */ + public void clearMap() { + this.fillGrid(); + } + + /** + *

cette fonction renvoie toute la grille Object[][] + * qui contient tout la grille du jeu + * @return la grille du jeu + */ + public Object[][] getGrid() { + return grid; + } + + /** + *

cette fonction ajoute les bordures sur la grille + */ + public void addEdges() { + for(int i = 0; i < this.grid.length; i++) { + for(int k = 0; k < this.grid[0].length; k++) { + if (i == 0 || i == this.grid.length - 1 || k == 0 || k == this.grid[0].length - 1) { + this.grid[i][k] = Items.WALL; + } + } + } + } + + /** + *

cette fonction ajoute dans {@link #grid} les + * objects contenu dans {@link #coordinateItems} + * et {@link #ObjectItems}. + * @param objects prend le type d'objets que vous voulez + * mettre dedans. + * @param number prend le nombre d'objets global que + * vous voulez mettre dedans. + */ + public void addObjects(Object[] objects, int number) { + int lengthObjects = objects.length-1; + Random random = new Random(); + + for(int i = 0; i cette fonction place les objets dans la grille du + * jeu. + */ + public void placeObjects() { + for(int i = 0; i= 0 && x < grid[0].length && y >= 0 && y < grid.length) { - return (Items)grid[y][x]; - } - return null; - } - - public Items getItems(int[] coordinate) { - return (Items)getGrid()[coordinate[1]][coordinate[0]]; - } - - public boolean isGameOver(int[] coordinate) { - Items item = getCoordinate(coordinate[0], coordinate[1]); - - if (item != null) { - Effects effect = item.getEffects(); - return effect == Effects.IMPASSABLE; - } - return true; - } - - public String getStringGrid() { - StringBuffer stringGrid = new StringBuffer(); - - for(Object[] listValue : this.grid) { - for(Object value : listValue) { - stringGrid.append(value); - } - stringGrid.append("\n"); - } - - return stringGrid.toString(); - } - - public void addItems(Items[] items, int number) { - int lengthItems = (items.length-1); - for(int i = 0; iCeci 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 à 1 et le prochain tour quand N = 3, il sera égal à 1 (division - * d'entier). - */ - BOOST, - - /** - *

pouvoir etre invincible pendant le prochain round. - */ - INVINCIBILITY, - - /** - *

impossible à passer à travers. - */ - IMPASSABLE, - - VOID; -} diff --git a/src/Item/Items.java b/src/Item/Items.java deleted file mode 100644 index 6a575ee..0000000 --- a/src/Item/Items.java +++ /dev/null @@ -1,44 +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), - HEAD("tete", Effects.IMPASSABLE), - - VOID("void", Effects.VOID), - - FRAISE("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 22a868b..2cf0210 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,15 +1,31 @@ -import environnements.Map; -import personnages.Personnage; -import personnages.Player; +import Characters.*; +import Display.Terminal; +import Environnement.Map; public class Main { - public static void main(String[] args) { - int n = 2; - - Personnage[] players = new Personnage[] { - new Player("player1", n, new int[]{2, 2}) - }; + // public static void print(Players player) { + // for (int[] coordinate : player.getCoordinate()) { + // for(int value : coordinate) { + // System.out.print(value + " "); + // } + // System.out.println(); + // } + // System.out.println(); + // } - display.Terminal.run(players, new Map(10, 10), 2); + public static void main(String[] args) { + // Players player = new Players(new int[] {-1, 1}, 2); + + // while(true) { + // int[] value = player.keepLatestCoordinate(); + + // player.incrementRound(); + // print(player); + // if (player.isIncreaseSize()) player.moveToLatestCoordinate(value); + // } + + Terminal.run(new Personnage[]{ + new Players(new int[] {1, 1}, 2) + }, new Map(10, 10), 2); } } diff --git a/src/Objects/Effects.java b/src/Objects/Effects.java new file mode 100644 index 0000000..051a4eb --- /dev/null +++ b/src/Objects/Effects.java @@ -0,0 +1,6 @@ +package Objects; + +public enum Effects { + VOID, + IMPASSABLE; +} diff --git a/src/Objects/Fruits.java b/src/Objects/Fruits.java new file mode 100644 index 0000000..377c740 --- /dev/null +++ b/src/Objects/Fruits.java @@ -0,0 +1,31 @@ +package Objects; + +public enum Fruits { + FRAISE("fraise", Effects.VOID); + + private final String NAME; + private final Effects EFFECT; + + Fruits(String name, Effects effect) { + this.NAME = name; + this.EFFECT = effect; + } + + /** + *

type de variable pour recuperer le nom des fruits: + * 

String name = Item.FRAISE.getName()
+ * @return Avoir le nom de l'item + */ + public String getName() { + return this.NAME; + } + + /** + *

type de variable pour recuperer l'effet des fruits: + * 

Effects effect = Item.FRAISE.getEffects()
+ * @return Avoir l'effet de l'item + */ + public Effects getEffects() { + return this.EFFECT; + } +} diff --git a/src/Objects/Items.java b/src/Objects/Items.java new file mode 100644 index 0000000..fbb4bb5 --- /dev/null +++ b/src/Objects/Items.java @@ -0,0 +1,32 @@ +package Objects; + +public enum Items { + WALL("WALL", Effects.IMPASSABLE), + VOID("VOID", Effects.VOID); + + 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/Objects/Snake.java b/src/Objects/Snake.java new file mode 100644 index 0000000..9dd57c9 --- /dev/null +++ b/src/Objects/Snake.java @@ -0,0 +1,32 @@ +package Objects; + +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/display/Terminal.java b/src/display/Terminal.java index 91115bc..e049a02 100644 --- a/src/display/Terminal.java +++ b/src/display/Terminal.java @@ -1,63 +1,42 @@ -package display; +package Display; import java.util.Scanner; -import environnements.Map; -import item.Items; -import personnages.Personnage; -import personnages.Player; +import Characters.Mouvements; +import Characters.Personnage; +import Characters.Players; +import Environnement.Map; +import Objects.Fruits; +import Objects.Items; +import Objects.Snake; public class Terminal { + /** + * cette fonction clear le terminal et le remet en + * haut a gauche de la ligne. + */ private static void clearTerminal() { System.out.println("\u001b[2J \u001b[H"); } - private static void showMap(Object[][] grid) { - for (int i = 0; i taille du serpent. - */ - private int size; - private int n; // N - - /** - *

une variable pour changer le round pour chaque fois - * que la manche est fini seulement pour le personnage. - */ - private int round; - - private String nom; - - /** - *

la liste de toute les coordonnées en fonction de N. Si N = 2, - * tout les deux tours, la taille du serpent augmente de 1. Si N = 3, - * tous les 3 tours, ça va augmenter de 1. On peut l'ecrire comme Round/N - * (les deux variables en int). - *

Le premier index est la coordonnée de la tête et les autres - * sont les coordonnées de son corps. - */ - protected ArrayList coordinate; - - /** - *

le constructor definie un arrayList pour {@link #coordinate} - * et defini n. - * - * @param name est le nom du personnage. - * @param n est une variable qui contient le nombre de tour avant - * l'augmentation de taille. - * @param coordinate est la variable qui contient les coordonnées - * qui sont placé par la suite dans {@link #coordinate}[0] - */ - protected Personnage(String name, int n, int[] coordinate) { - this.coordinate = new ArrayList(); - this.coordinate.add(coordinate); - - this.n = n; - } - - public String getName() { - return nom; - } - - public int incrementRound() { - return ++this.round; - } - - public int[] getCoordinate() { - return coordinate.get(0); - } -} diff --git a/src/personnages/Player.java b/src/personnages/Player.java deleted file mode 100644 index 09fa174..0000000 --- a/src/personnages/Player.java +++ /dev/null @@ -1,42 +0,0 @@ -package personnages; - -import static java.util.Arrays.toString; - -import java.util.Scanner; - -/** - *

la classe Player est la classe principale pour l'utilisation de toute - * input et output que l'utilisateur peut faire. - */ -public class Player extends Personnage { - /** - *

le constructor definie les coordonnées de la tête et defini n. - * - * @param n est une variable qui contient le nombre detour avant - * l'augmentation de taille. - * @param coordinate est un array de 2 entiers qui - * est représenté comme {x, y} et qui represente les - * coordonnées de la tête du personnage. - */ - public Player(String name, int n, int[] coordinate) { - super(name, n, coordinate); - } - - public boolean changeCoordinate(String input) { - if (input.length() > 0) { - return moveCoordinate(input.charAt(0)); - } - return false; - } - - private boolean moveCoordinate(int keys) { - switch (keys) { - case 0x77: Mouvement.HAUT.editCoordinate(getCoordinate()); break; // w - case 0x73: Mouvement.BAS.editCoordinate(getCoordinate()); break; // s - case 0x61: Mouvement.GAUCHE.editCoordinate(getCoordinate()); break; // a - case 0x64: Mouvement.DROITE.editCoordinate(getCoordinate()); break; // d - default: return false; - } - return true; - } -} diff --git a/src/personnages/Robot.java b/src/personnages/Robot.java deleted file mode 100644 index 33601a5..0000000 --- a/src/personnages/Robot.java +++ /dev/null @@ -1,7 +0,0 @@ -package personnages; - -public class Robot extends Personnage { - public Robot(String name, int size, int[] coordinate) { - super(name, size, coordinate); - } -} \ No newline at end of file