Projets

Livre Jeu


// Squelette Livre Jeu

// Matrice de description du graphe
// chaque ligne correspond à un état
// {{{x,y},... x:futur état possible si action y réalisée
//             x=-1 si action impossible
int[][][] descGraph= {
  {
    {0,0}, {1,1}, {2,2}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}
  }
  , 
  {
    {0,3}, {1,0}, {2,4}, {3,5}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}
  }
  , 
  {
    {0,6}, {1,7}, {2,0}, {3,8}, {4,9}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}
  }
  , 
  {
    {0,1}, {1,2}, {2,3}, {3,0}, {4,4}, {5,5}, {-1,0}, {-1,0}, {-1,0}, {-1,0}
  }
  , 
  {
    {-1,0}, {-1,0}, {2,6}, {3,7}, {4,0}, {5,8}, {6,9}, {-1,0}, {-1,0}, {-1,0}
  }
  , 
  {
    {-1,0}, {-1,0}, {-1,0}, {3,1}, {4,2}, {5,0}, {6,3}, {-1,0}, {8,4}, {-1,0}
  }
  , 
  {
    {-1,0}, {-1,0}, {-1,0}, {-1,0}, {4,5}, {5,6}, {6,0}, {7,7}, {8,8}, {-1,0}
  }
  , 
  {
    {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {6,9}, {7,0}, {8,1}, {9,2}
  }
  , 
  {
    {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {5,3}, {6,4}, {7,5}, {8,0}, {-1,0}
  }
  , 
  {
    {0,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {-1,0}, {9,0}
  }
};

// description des états x
String[] descStates = {
  "Situation0", "Situation1", "Situation2", "Situation3", "Situation4","Situation5", "Situation6", "Situation7", "Situation8", "Situation8"
}; 

// description des actions y
String[] descActions = {
 "action1","action2","action3","action4","action5","action6","action7","action8","action9","action10"
};

// localisation disques
int[][] rounds = {
 {300,60},{120,120},{480,120},{300,180},{480,240},{300,300},{480,360},{120,360},{300,420},{120,480}
};

//n° de l'etat courant
int state=0;
//n° de l'etat à atteindre
int endState=9; 
//n° de l'etat initial
int lastState=0;
//n° de l'etat fatal
int killState=5; 

boolean init=false;

// initialisation du jeu
void setup() {
  size(600, 600);
  smooth();
  background(255);
  drawGraph();
  println("::::::::::::::::::::: Jeu lancé ! ::::::::::: ");
  // affichge de l'état
  println("Etat["+state+"]:"+descStates[state]);
  // affichage des actions possibles
  printActions(extractLinks(descGraph, state));
}

void draw() {
  strokeWeight(1);
  noStroke();
  fill(155,255,155);
  ellipse(rounds[lastState][0],rounds[lastState][1],35,35);
  ellipse(rounds[state][0],rounds[state][1],30,30);
  fill(217,0,0);
  ellipse(rounds[state][0],rounds[state][1],30,30);
}

// réaction à une touche pressée
void keyPressed()
{
  int choice;
  lastState=state;

  // conversion du code clavier en entier
  choice=int(key)-49;  

  // si le choix est possible, on calcul le nouvel état
  if ((choice>=0)&&(choice< descGraph.length))
    state=extractLinks(descGraph, state)[choice][0];
  
  // on affiche le choix retenu  
  println("Choix retenu : ["+(choice+1)+"]");

  if ((state>0)&&(state< descGraph.length))
  {
    
    if ((state==endState)||(state==killState)) {
      // fin de la partie
      if (state==endState) println(">BRAVO !!!");
      else println(">PERDU !!!");
    }
    
    if ((lastState==endState)||(lastState==killState)) {
      // fin de la partie
      println("::::::::::::::::::::: Jeu relancé :::::::::::");
      state=0;
    }
    // on affiche le nouvel état
    println("Etat["+state+"] :"+descStates[state]);
  }
  else
  { 
    // choix non valide, on garde le n° d'état précédent
    state=lastState;
  }
  // on affiche les nouvelles actions possibles
  printActions(extractLinks(descGraph, state));
}

// procédure d'affichage des actions possibles
void printActions (int[][] matrix)
{
  for (int i=0 ; i< matrix.length ; i++)
  {
    if (matrix[i][0]>0)
      print("Choix["+(i+1)+"]:"+descActions[matrix[i][1]]+"; ");
  }
  println();
}

// fonction qui renvoie un tableau 2d contenant les liens possibles à la ligne val d'une matrice 3d
int[][] extractLinks(int[][][] matriceLinks, int val) {
  int[][] result;
  result = new int[matriceLinks[val].length][2];
  int j=0;
  for (int i=0 ; i< matriceLinks[val].length ; i++)
  {
    if (matriceLinks[val][i][0]>0)
    {
      result[j][0]=matriceLinks[val][i][0];
      result[j][1]=matriceLinks[val][i][1];
      j++;
    }
  }
  return result;
}


// procédure pour dessiner le graphe
void drawGraph()
{
  
  stroke(0,177,0);
  strokeWeight(4);
  fill(0);
  textSize(28);
  // dessin des liens
  for (int i=0 ; i< descGraph.length ; i++)
  {
    for (int j=0 ; j< descGraph[0].length ; j++)
    {
      int link=descGraph[i][j][0];
      if (link>0) line(rounds[i][0],rounds[i][1],rounds[link][0],rounds[link][1]);
    } 
  }

  stroke(0,177,0);
  strokeWeight(4);
  // dessin des noeuds
  for (int i=0 ; i< rounds.length ; i++)
  {
    stroke(0,177,0);
    if (i==killState) stroke(0);
    if (i==endState) stroke(217,0,0);
    fill(155,255,155);
    ellipse(rounds[i][0],rounds[i][1],60,60);
    fill(0);
    text(i, rounds[i][0]-40,rounds[i][1]-30); 
  }  
  
}