IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Développement Web en Java Discussion :

[Sujet sérieux ] Plateforme jeu de rôle


Sujet :

Développement Web en Java

  1. #1
    Candidat au Club
    Homme Profil pro
    Développeur .NET
    Inscrit en
    Mars 2018
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 32
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur .NET

    Informations forums :
    Inscription : Mars 2018
    Messages : 2
    Par défaut [Sujet sérieux ] Plateforme jeu de rôle
    Salut à tous ,

    Je viens vers vous aujourd'hui car je dois réaliser une plateforme de jeu de rôle avec le langage JAVA . Je vous poste le sujet ci-dessous avec que vous compreniez bien

    Il s’agit d’un mini jeu de plateau tour après tour. Le plateau est un rectangle de NxM case. Le héro se déplace de manière différente sur les cases (droite/gauche, haut/bas, et diagonale case par case). Il se déplace de manière aléatoire sur l'ensemble de la carte. Les monstres restent tel qu'ils sont lors de l’initialisation ( il ne bougent pas). Un nombre aléatoire de monstre “apparaît” aléatoirement sur une case non occupé à chaque tour et y reste. Un monstre reste sur une case N tours (15 par exemple) et décède.
    Si le héro touche un des monstres présent sur la grille, il perd la partie. Le but du héro est d’aller secourir la princesse qui est sur la carte. Si le héro arrive jusqu’à la
    princesse, la partie est gagné.

    Lors de initialisation de la partie
    La princesse est toujours tout en bas à droite de la carte et Le héro commence la partie tout en haut à gauche de la carte (coordonnée 0,0)
    Il existe dès le début de partie un nombre aléatoirement de monstre sur la carte qui représente environ 30 % des carte total
    En fin de partie : il faudra afficher si le héro à lost ou win et le nb de tour affiché.
    Petite aide: Un plateau est un ensemble de cellule. Une cellule contient un Personnage.


    Après plusieurs semaines se travaille , voici mon résultat , mais bien entendu je n'arrive pas à relier toutes mes classes dans le main , il y a pas mal de messages d'erreurs ...

    Plateau.java
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    	public class plateau {
    		public void map {
    			System.out.println("A B C D E F G H I J");
    		    for(int i=0; i<10; i++){ 
    		        System.out.print((char)('A'+i)+" ");
    		        for(int j=0; j<10; j++){
    		            System.out.print("- ");
    		    }
    }
    Hero.java
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    import java.util.*;
     
    public class Hero1 {
     
     private int hitPoints;      // life meter
     private Random rand;
     
     // creates a default hero who starts at 100 hit points
     public Hero1() {
         hitPoints = 100;
         rand = new Random();
     }
     
     // returns the amount of damage an attack should inflict
     // on an enemy
     public int getAttack() {
         return 10;
     }
     
     // retourne vrai si le héro est vivant
     public boolean isAlive() {
         return hitPoints > 0;
     }
     
     // returns a String representation of the object in form of the
     // hit points left
     public String toString() {
         return "HP: " + hitPoints;
     }
     
     public int getHitPoints() {
         return hitPoints;
     }
     
     // private method that can only be used within the Hero class
     private void takeDamage() {
         hitPoints -= 10;
     }
     
     // duel against a different hero
     // with 50% probability, I will damage the other person
     // with 50% probability, the other person damages me
     // returns true if I attacked, false otherwise
     public boolean duel(Hero1 other) {
         int turn = rand.nextInt(2);
     
         if (turn == 0) {    // the other person takes damage
             other.takeDamage();
             return true;
         } else { // I take damage
             this.takeDamage();
             // could also just say:
             // takeDamage();
             return false;
         }
     }
     
    }
    MAIN.java
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    import java.io.BufferedReader;
    	import java.io.IOException;
    	import java.io.InputStreamReader;
     
    public class main {
     
    	    public static void solution(String[] args) throws IOException
    	    {
    	        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    	        int m = Integer.parseInt(br.readLine());
     
    	        char grid[][] = new char[m][m];
    	        for(int i = 0; i < m; i++)
    	        {
    	            String line = br.readLine();
    	            grid[i] = (line.trim()).toCharArray();
    	        }
     
    	        displayPathtoPrincess(m, grid);
    	    }
     
    	    static void displayPathtoPrincess(int m, char[][] grid)
    	    {
    	        int botRow = 0, botCol = 0, princessRow = 0, princessCol = 0;
     
    	        // Get bot and princess coordinates
    	        for (int r = 0; r < m; r++)
    	        {
    	            for (int c = 0; c < grid.length; c++)
    	            {
    	                if (grid[r][c] == 'm' || grid[r][c] == 'M')
    	                {
    	                    botRow = r;
    	                    botCol = c;
    	                }
    	                else if (grid[r][c] == 'p' || grid[r][c] == 'P')
    	                {
    	                    princessRow = r;
    	                    princessCol = c;
    	                }
    	            }
    	        }
     
    	        // Move the bot up or down till bot reaches same row
    	        if( princessRow < botRow )
    	        {
    	            while(botRow != princessRow)
    	            {
    	                botRow--;
    	                System.out.println("UP");
    	            }
    	        }
    	        else if( princessRow > botRow )
    	        {
    	            while(botRow != princessRow)
    	            {
    	                botRow++;
    	                System.out.println("DOWN");
    	            }
    	        }
     
    	        // Move the bot left or right till bot reaches same column
    	        if( princessCol < botCol )
    	        {
    	            while(botCol != princessCol)
    	            {
    	                botCol--;
    	                System.out.println("LEFT");
    	            }
    	        }
    	        else if( princessCol > botCol )
    	        {
    	            while(botCol != princessCol)
    	            {
    	                botCol++;
    	                System.out.println("RIGHT");
    	            }
    	        }
     
    	    }
    	}
    Monstre.JAVA
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
     
    public class monstre {
    	    private int health;
    	    public monstre(int health) {
    	        this.health = health;
    	    }
     
    	    public void hit(int damage) {
    	        health -= damage;
    	    }
     
    	    public int getHealth() {
    	        return health;
    	    }
    	}
    Pour la princesse je n'ai pas trouvé


    Merci beaucoup à tous

  2. #2
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    Septembre 2009
    Messages
    12 430
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 55
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2009
    Messages : 12 430
    Billets dans le blog
    2
    Par défaut
    Salut,

    Citation Envoyé par actufeedly Voir le message
    il y a pas mal de messages d'erreurs ...
    Ah, oui ? Lesquelles ?

    Citation Envoyé par actufeedly Voir le message
    Pour la princesse je n'ai pas trouvé
    Trouvé quoi ?

    1. Déjà public void map { ne compile pas parce qu'il manque des parenthèses
      Et à quoi sert cette classe ?

    2. Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      	        int m = Integer.parseInt(br.readLine());
      	        char grid[][] = new char[m][m];
      Dans le sujet, on parle d'un plateau de N*M... pourquoi dans le code ci-dessus le tableau est-il carré ?
      Au passage, la classe Scanner permet de simplifier un peu la lecture.

      Pourquoi lit-on le plateau depuis le clavier ? On parle dans le sujet d'une génération aléatoire de montres pour le premier tour (30%). Il suffit de lire au clavier n et m, de créer un tableau de n*m, de calculer 30% de n*m, de s'en servir de borne pour placer des monstres dans les cases vides. Et on place le héro et la princesse à l'endroit voulu.

    3. On parle de déplacement aléatoire du héro. Alors que ton déplacement est "dirigé", on part en ligne droite en y pour aller sur la ligne de la princess puis en ligne droite en horizontal.

    4. Code : Sélectionner tout - Visualiser dans une fenêtre à part
      static void displayPathtoPrincess(int m, char[][] grid)
      Pas besoin de passer M, ni N : les dimensions du tableau sont suffisantes (grid.length, grid[0].length)

    5. Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      3
      4
      5
      6
      7
      for (int r = 0; r < m; r++){
      	            for (int c = 0; c < grid.length; c++) {
       
              if (grid[r][c] == 'm' || grid[r][c] == 'M') {
              }
      }
      }
      Avec un tableau rectangulaire, le code ci-dessus planterait. La taille du tableau est la première dimension (donc borne r pas c).
    6. C'est bizarre d'avoir un tableau de char alors qu'on a des classes pour représenter les montres. On pourrait avoir un tableau de personnages (interface ou classe abstraite) et des classes montre, princesse et héro à placer dans ce tableau. Avec un tableau de char tu es obligé d'avoir une structure à part qui liste tous les personnages avec leur coordonnée dans le tableau, et le tableau char ne sert plus à grand chose du coup.
      Par ailleurs, dans le sujet initial, je ne vois d'histoire de HP, de dommage, etc. Je ne lis que "lorsque le héro touche un monstre, il meurt", enfin non "il perd la partie", mais c'est ce que ça veut dire pour moi.

    7. Dans la classe Hero1
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      public boolean duel(Hero1 other) {
      Il y a plusieurs héro, qui pourrait faire des combats entre eux ? Je n'ai pas vu ça dans le sujet.
    8. Je ne parle pas de l'apparition (à interval régulier) et de la disparition des monstres (au bout d'un certain nombre de tours).
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

  3. #3
    Candidat au Club
    Homme Profil pro
    Développeur .NET
    Inscrit en
    Mars 2018
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 32
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur .NET

    Informations forums :
    Inscription : Mars 2018
    Messages : 2
    Par défaut
    Merci infiniment pour ta réponse qui m'a permis de voir beaucoup plus clair , j'ai repris sur un sujet et un nouveau projet propre :

    Pour l'instant j'ai
    Mon plateau.java

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
     
    package main;
     
    public class Plateau {
     
        private int nbrelign ;
        private int nbrecol;
        private char [][] grille;
     
        public Plateau(int n,int p ){
             nbrelign = n;
             nbrecol = p;
             grille = new char[nbrelign][nbrecol];
     
             for(int i=0; i< nbrelign; i++){
                for(int j =0; j< nbrecol; j++){
                 grille[i][j] = '*';
               }
            }
        }
     
        public void afficher(){
           System.out.println();
           for(int i=0; i< nbrelign; i++){
                for(int j  =0; j< nbrecol; j++){
     
                 System.out.print(" | " + grille[i][j]);
               }
                System.out.println(" | " );
           }
           System.out.println();
       }
     
    }


    et mon main.java

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package main;
     
    public class Main {
     
        public static void main(String[] args) {
            Plateau pl = new Plateau(8,5);
            pl.afficher();
        }
     
    }
    grâce à toi tout fonctionne niquel mais par contre pour faire la classe princesse , héros et monstre je suis un peu perturbé maintenant si quelqu'un aurait quelque piste

    merci

  4. #4
    Modérateur
    Avatar de joel.drigo
    Homme Profil pro
    Ingénieur R&D - Développeur Java
    Inscrit en
    Septembre 2009
    Messages
    12 430
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 55
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Ingénieur R&D - Développeur Java
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2009
    Messages : 12 430
    Billets dans le blog
    2
    Par défaut
    Il y'a différentes approches, mais parmi les plus simples, on peut citer :

    1. Une classe Plateau avec un tableau de char comme tu as fait, et des attributs pour représenter les personnages : avec une classe Personnage, qui a 2 coordonnées x et y, pour son emplacement dans la carte, et un caractère de représentation, plus l'age qui permet de gérer la disparition du monstre au bout de n tours. Donc 3 attributs, un pour le héro, un pour la princesse, et une liste de monstres. Cette solution à l'avantage de permettre une gestion directe des personnages. Mais le défaut est qu'il est plutôt compliqué d'afficher le plateau, car pour chaque case de la carte, il faut chercher si l'un des attributs "perso" est sur la case en question.
    2. La seconde approche repose sur le même type de classe que dans le cas 1, mais le tableau est un tableau d'éléments de cette classe. Ainsi, le dessin du plateau est simple (un parcours du tableau), mais on peut continuer à gérer facilement les personnages. Il est juste important de bien synchroniser les coordonnées et l'emplacement dans la carte.

      Par exemple :
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      public class Personnage {
       
      	public int x;
      	public int y;
      	public char c;
      	public int age;
       
      	public Personnage(char c) {
      		this.c=c;
      	}
       
      }
      Et pour le plateau (attention, il y a des parties non codées...)
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
      100
      101
      102
      103
      104
      105
      106
      107
      108
      109
      110
      111
      112
      113
      114
      115
      116
      117
      118
      119
      120
      121
      122
      123
      124
      125
      126
      127
      128
      129
      130
      131
      132
      133
      134
      135
      136
      137
      138
      139
      140
      141
      142
      143
      144
      145
      146
      147
      148
      149
      150
      151
      152
      153
      154
      155
      156
      157
      158
      159
      160
      161
      162
      163
      164
      165
      166
      public class Plateau {
       
      	private static final int AGE_MONSTRE = 15; // les monstres vivent 15 tours avant de disparaitre
      	private static final char HERO = 'H'; // caractère d'affichage pour le héro
      	private static final char PRINCESSE = 'P'; // caractère d'affichage pour la princesse
      	private static final char MONSTRE = 'M'; // caractère d'affichage pour le monstre
       
      	private static final char HERO_MORT = '+'; // caractère d'affichage pour le héro qui a rencontré un monstre
      	private static final char HERO_PRINCESSE = 'V'; // caractère d'affichage pour le héro qui a rencontré la princesse
       
      	private int largeur;
      	private int hauteur;
       
      	private Personnage[][] carte;
       
      	private Personnage hero;
      	private Personnage princesse;
      	private List<Personnage> monstres;
       
      	private int etatPartie; // par exemple : 0 jeu non terminé, 1 héro à gagner, -1 hero a perdu
       
      	private Random random = new Random();
       
      	public Plateau(int largeur, int hauteur) {
      		this.largeur=largeur;
      		this.hauteur=hauteur;
      		initialiser();
      	}
       
      	public int getEtatPartie() {
      		return etatPartie;
      	}
       
      	public boolean heroGagne() {
      		return etatPartie==1;
      	}
       
      	public boolean heroPerdu() {
      		return etatPartie==-1;
      	}
       
      	public void initialiser() {
      		etatPartie=0;
      		carte = new Personnage[hauteur][largeur];
      		hero = new Personnage(HERO);
      		princesse = new Personnage(PRINCESSE);
      		placer(0,0, hero); // hero en 0,0 (en haut à gauche)
      		placer(largeur-1,hauteur-1, princesse); // princesse en bas à droite
      		monstres = new ArrayList<>();
      		ajouterMonstres((hauteur*largeur*30)/100); // 30% de monstres au départ
      	}
       
      	public void afficherCarte() {
      		for(Personnage[] ligne : carte) {
      			for(Personnage personnage : ligne) {
      				if ( personnage==null ) { // case vide
      					System.out.print(" ");
      				}
      				else {
      					System.out.print(personnage.c);
      				}
      			}
      			System.out.println();// fin de ligne
      		}
      	}
       
      	public void nouveauTour(int numeroTour) {
      		// à faire
      		// déplacer hero
      		// veillir monstre
      		// créer nouveaux monstres
      	}
       
       
      	/**
               * retourne le personnage sur la case
               * @param x abscisee de la case
               * @param y ordonnée de la case
               * @return le personnage sur la case ou null si la case est vide
               */
      	private Personnage getPersonnage(int x, int y) {
      		return carte[y][x];
      	}
       
              /**
                * Placer le personnage dans la case et synchroniser ses coordonnées
                */
      	private void placer(int x, int y, Personnage personnage) {
      		carte[y][x] = personnage;
      		personnage.x = x;
      		personnage.y = y;
      	}
       
      	private void deplacerHero() {
      		// on détermine un déplacement aléatoire
      		int nouveaux;
      		int nouveauy;
      		do {
      			int dx = random.nextInt(3)-1; // tire un nombre entre -1 et 1
      			nouveaux=hero.x+dx;
      			int dy = random.nextInt(3)-1; // tire un nombre entre -1 et 1
      			nouveauy=hero.y+dy;
      		}
      		while( !estDansCarte(nouveaux,nouveauy));
      		Personnage rencontre = getPersonnage(nouveaux, nouveauy);
      		if ( monstres.contains(rencontre) ) {
      			// le héro rencontre un monstre... à faire ce qu'on doit
      		}
      		else if ( rencontre==princesse ) {
      			// le héro rejoint la princesse... à faire ce qu'on doit
      		}
      		else {
      			// le héro se déplace
      			supprimer(hero);
      			placer(nouveaux, nouveauy, hero);
      		}
      	}
       
      	private boolean estDansCarte(int x, int y) {
      		return x>=0 && x<largeur && y>=0 && y<hauteur;
      	}
       
      	private void supprimer(Personnage personnage) {
      		carte[personnage.y][personnage.x] = null;  // on vide la case
      	}
       
      	/**
               * AJoute des monstrs aléatoirement dans la carte
               * @param nombre nombre de monstres à ajouter
               */
      	private void ajouterMonstres(int nombre) {
      		for(int i=0; i<nombre; i++) {
      			if ( monstres.size()>= hauteur*largeur+2 ) {
      				// il n'y a plus aucune place libre
      				break;
      			}
      			int x;
      			int y;
      			// on détermine aléatoirement une case vide pour le monstre
      			do {
      				x = random.nextInt(largeur);
      				y = random.nextInt(hauteur);
      			}
      			while( getPersonnage(x,y)!=null); // tant que la case n'est pas vide
      			Personnage monstre = new Personnage(MONSTRE);
      			monstre.age=AGE_MONSTRE;
      			monstres.add(monstre); // on ajoute le monstre à la liste
      			placer(x,y, monstre);
      		}
      	}
       
      	/**
               * Fait vieillir les monstres et les fait mourir si leur age atteint 0
               */
      	private void veillirMonstre() {
      		for(Iterator<Personnage> monstreIterator = monstres.iterator(); monstreIterator.hasNext(); ) {
      			Personnage monstre = monstreIterator.next();
      			monstre.age--; // on décrémente l'age du monstre
      			if ( monstre.age<=0 ) { // si le monstre meurt
      				supprimer(monstre); // on le supprime de la carte
      				monstreIterator.remove(); // on le supprime de la liste de monstres
      			}
      		}
      	}
       
      }
      Bon, en testant on s'aperçoit que 30% de monstres au départ, c'est un peu (beaucoup) trop pour avoir une chance de gagner... surtout qu'on en ajoute à chaque tour, alors qu'ils mettent du temps à mourir...

      Avec un main :

      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      Plateau plateau = new Plateau(nbLignes, nbColonnes);
      plateau.afficherCarte();
      for(int nbTours=0;;nbTours++) {
         plateau.nouveauTour(nbTours);
         plateau.afficherCarte();
         if ( plateau.heroGagne() ) {
            System.out.println("gagné / " + nbTours + " tour(s)");
            break;
         }
         else if ( plateau.heroPerdu() ) {
            System.out.println("perdu / " + nbTours + " tour(s)");
            break;
         }
      }
      Si tu ne connais pas List et ArrayList, ou que tu ne peux pas t'en servir, tu peux utiliser la carte elle-même pour parcourir les monstres. Il te faut juste un int pour compter les monstres et tester une rencontre avec un monstre en testant si la case n'est pas vide et n'est pas la princesse...

      tous les commentaires d'explication ne sont pas reportés dans le code suivant
      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
      100
      101
      102
      103
      104
      105
      106
      107
      108
      109
      110
      111
      112
      113
      114
      115
      116
      117
      118
      119
      120
      121
      122
      123
      124
      125
      126
      127
      128
      129
      130
      131
      132
      133
      134
      135
      136
      137
      138
      139
      140
      141
      142
      143
      144
      145
      146
      147
      148
      149
      150
      151
      152
      153
      154
      155
      156
      157
      158
      159
      160
      161
      162
      163
      164
      165
      166
      167
      168
      169
      170
       
      public class Plateau {
       
      	private static final int AGE_MONSTRE = 15; // les monstres vivent 15 tours avant de disparaitre
      	private static final char HERO = 'H'; // caractère d'affichage pour le héro
      	private static final char PRINCESSE = 'P'; // caractère d'affichage pour la princesse
      	private static final char MONSTRE = 'M'; // caractère d'affichage pour le monstre
       
      	private static final char HERO_MORT = '+'; // caractère d'affichage pour le héro qui a rencontré un monstre
      	private static final char HERO_PRINCESSE = 'V'; // caractère d'affichage pour le héro qui a rencontré la princesse
       
      	private int largeur;
      	private int hauteur;
       
      	private Personnage[][] carte;
       
      	private Personnage hero;
      	private Personnage princesse;
      	private int nbMonstres;
       
      	private int etatPartie; // par exemple : 0 jeu non terminé, 1 héro à gagner, -1 hero a perdu
       
      	private Random random = new Random();
       
      	public Plateau(int largeur, int hauteur) {
      		this.largeur=largeur;
      		this.hauteur=hauteur;
      		initialiser();
      	}
       
      	public int getEtatPartie() {
      		return etatPartie;
      	}
       
      	public boolean heroGagne() {
      		return etatPartie==1;
      	}
       
      	public boolean heroPerdu() {
      		return etatPartie==-1;
      	}
       
      	public void initialiser() {
      		etatPartie=0;
      		carte = new Personnage[hauteur][largeur];
      		hero = new Personnage(HERO);
      		princesse = new Personnage(PRINCESSE);
      		placer(0,0, hero); // hero en 0,0 (en haut à gauche)
      		placer(largeur-1,hauteur-1, princesse); // princesse en bas à droite
      		nbMonstres=0;
      		ajouterMonstres((hauteur*largeur*30)/100); // 30% de monstres au départ
      	}
       
      	public void afficherCarte() {
      		for(Personnage[] ligne : carte) {
      			for(Personnage personnage : ligne) {
      				if ( personnage==null ) { // case vide
      					System.out.print(" ");
      				}
      				else {
      					System.out.print(personnage.c);
      				}
      			}
      			System.out.println();// fin de ligne
      		}
      	}
       
      	public void nouveauTour(int numeroTour) {
      		// à faire
      		// déplacer hero
      		// veillir monstre
      		// créer nouveaux monstres
      	}
       
       
      	/**
               * retourne le personnage sur la case
               * @param x abscisee de la case
               * @param y ordonnée de la case
               * @return le personnage sur la case ou null si la case est vide
               */
      	public Personnage getPersonnage(int x, int y) {
      		return carte[y][x];
      	}
       
      	private void placer(int x, int y, Personnage personnage) {
      		carte[y][x] = personnage;
      		personnage.x = x;
      		personnage.y = y;
      	}
       
      	private void deplacerHero() {
      		// on détermine un déplacement aléatoire
      		int nouveaux;
      		int nouveauy;
      		do {
      			int dx = random.nextInt(3)-1; // tire un nombre entre è1 et 1
      			nouveaux=hero.x+dx;
      			int dy = random.nextInt(3)-1; // tire un nombre entre è1 et 1
      			nouveauy=hero.y+dy;
      		}
      		while( !estDansCarte(nouveaux,nouveauy));
      		Personnage rencontre = getPersonnage(nouveaux, nouveauy);
                      if ( rencontre==null ) { // la case est vide
      			// le héro se déplace
      			supprimer(hero);
      			placer(nouveaux, nouveauy, hero);
                      }
      		else if ( rencontre==princesse ) {
      			// le héro rejoint la princesse... à faire ce qu'on doit
      		}
                      else {
                           // le héro rencontre un monstre... à faire ce qu'on doit
      		}
      	}
       
      	private boolean estDansCarte(int x, int y) {
      		return x>=0 && x<largeur && y>=0 && y<hauteur;
      	}
       
      	private void supprimer(Personnage personnage) {
      		carte[personnage.y][personnage.x] = null;  // on vide la case
      	}
       
      	/**
               * AJoute des monstrs aléatoirement dans la carte
               * @param nombre nombre de monstres à ajouter
               */
      	private void ajouterMonstres(int nombre) {
      		for(int i=0; i<nombre; i++) {
      			if ( nbMonstres>= hauteur*largeur+2 ) {
      				// il n'y a plus aucune place libre
      				break;
      			}
      			int x;
      			int y;
      			// on détermine aléatoirement une case vide pour le monstre
      			do {
      				x = random.nextInt(largeur);
      				y = random.nextInt(hauteur);
      			}
      			while( getPersonnage(x,y)!=null); // tant que la case n'est pas vide
      			Personnage monstre = new Personnage(MONSTRE);
      			monstre.age=AGE_MONSTRE;
      			nbMonstres--; // on ajoute le monstre à la liste
      			placer(x,y, monstre);
      		}
      	}
       
      	/**
               * Fait vieillir les monstres et les fait mourir si leur age atteint 0
               */
      	private void veillirMonstre() {
      		if( nbMonstres>0 ) {
      			for(Personnage[] ligne : carte) {
      				for(int i=0; i<ligne.length; i++) {
      					if ( ligne[i]!=null && ligne[i].c==MONSTRE ) {
      						Personnage monstre = ligne[i];
      						monstre.age--; // on décrémente l'age du monstre
      						if ( monstre.age<=0 ) { // si le monstre meurt
      							supprimer(monstre); // on le supprime de la carte
      							nbMonstres--; // on le supprime de la liste de monstres
      						}
      					}
      				}
      			}
      		}
      	}
       
      }



    A noter, enfin, que, sauf si tu as mal placé ta discussion, cet exemple, c'est juste pour le principe globale : en web, il faudra forcément adapter l'affichage, entre autres...
    L'expression "ça marche pas" ne veut rien dire. Indiquez l'erreur, et/ou les comportements attendus et obtenus, et donnez un Exemple Complet Minimal qui permet de reproduire le problème.
    La plupart des réponses à vos questions sont déjà dans les FAQs ou les Tutoriels, ou peut-être dans une autre discussion : utilisez la recherche interne.
    Des questions sur Java : consultez le Forum Java. Des questions sur l'EDI Eclipse ou la plateforme Eclipse RCP : consultez le Forum Eclipse.
    Une question correctement posée et rédigée et vous aurez plus de chances de réponses adaptées et rapides.
    N'oubliez pas de mettre vos extraits de code entre balises CODE (Voir Mode d'emploi de l'éditeur de messages).
    Nouveau sur le forum ? Consultez Les Règles du Club.

Discussions similaires

  1. [MCD] personnages de jeu de rôle
    Par Loric dans le forum Schéma
    Réponses: 6
    Dernier message: 16/04/2008, 16h06
  2. [Outil] Jeu de Rôle Creator
    Par -4ian- dans le forum Contribuez
    Réponses: 19
    Dernier message: 27/12/2007, 12h35
  3. [Jeu de Rôle] Livres dont vous êtes le héros
    Par flo_flo dans le forum Lectures
    Réponses: 55
    Dernier message: 13/11/2007, 14h07
  4. [MySQL] Optimisation d'un jeu de rôle
    Par Metallic-84s dans le forum PHP & Base de données
    Réponses: 3
    Dernier message: 08/05/2007, 09h37

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo