Discussion :

[Sosuk]

Bonjour à tous,

Je suis actuellement dans le secteur informatique, et j'ai un mini projet à réaliser ce premier semestre en binôme. Nous avons un petit jeu à réaliser (une sorte de variante de go) sous AlgoScript (une variante de JavaScript avec du français).

Moi et mon binôme n'avons jamais fait d'informatique ou de code auparavant. Pour ma part seulement de l'HTML et du SQL.

Nous avons pour le moment que le coté graphique de notre projet, avec un quadrillage de 15 sur 15 avec un design de feuille grand carreaux. Et un système de saisie des points tours à tours via les coordonnés x de 0 à 15 et y de 0 à 15. (Créant des points bleus et rouges sur le graphique.)

Bref, le problème étant que désormais nous arrivons à la partie compliqué. Car le jeu est censé servir de support de jeu et de comptabiliser les points et de créer les zones gagnés par les joueurs. Ces zones pouvant être plus ou moins grandes mais minimum constitués de 4 points et les points servant à faire la zone doivent être au maximum à 1 carreaux des autres en diagonale pour former la zone.

Du coup pour avancer je me pose des questions. Comment faire en sorte que le programme puisse comprendre qu'avec les coordonnées saisies précédemment telle ou telle zone à été créée ?

Tout d'abord, dois-je stocker les valeurs saisies par les joueurs dans un tableau pour les exploiter ?
Quel type de boucle pourrais me permette de calculer à chaque coup si le nouvelle saisie à permit de capturer une zone ?

Avez-vous besoin d'une explication plus précise des règles ?

Je vous remercie de l'aide que vous pourrez peut être m'apporter. A noter que je n'ai pas tout à disposition avec cette variante de Javascript.

[Watilin]

Salut,

je propose une solution courante dans le domaine de la reconnaissance de forme (en analyse d'image). Il suffit d'une liste de taille variable (appelons-la liste) et d'un marqueur booléen sur chaque point, qu'on pourrait appeler par exemple vu. Il faut également un compteur : tailleZone.

Je ne sais pas quels types vous pouvez utiliser en AlgoScript, mais en JS, liste peut être modélisée par un simple tableau : var liste = [];.

L'idée, pour reconnaître une zone, est de commencer par choisir arbitrairement un point de cette zone et le placer dans liste (en JS, on peut utiliser liste.push()). C'est l'initialisation de l'agorithme. On initialise également tailleZone à 0. Ensuite, on boucle :

Code pseudocode :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
tant que (liste non vide):
    variable p = 1er point de liste, et on le retire en même temps ( en JS, p = liste.shift(); )
    ajouter 1 à tailleZone
    marquer p comme vu ( p.vu = true; )
    pour tout point q à côté de p:
        si q n'a pas encore été vu ( if (!q.vu) { ):
            ajouter q à liste
        fin si
    fin pour tout
fin tant que

Je suis resté volontairement flou sur la partie « pour tout point q à côté de p ». Ce n'est pas difficile alors je vous laisse chercher un peu sinon c'est pas drôle. À cet endroit il y a en tout 8 points q à vérifier. Vous pouvez écrire les 8 vérifications une par une, ou bien ruser et utiliser des boucles for.

L'idée derrière cet algorithme, c'est une sorte d'incendie ou de virus qui se propage à partir d'un point de départ. Les points marqués comme vus sont des points « brûlés » ou « consommés » par l'algo et quand on est passé dessus une fois, on n'y revient pas. Pour donner un exemple, je l'ai utilisé pour faire un démineur rudimentaire : quand on clique sur une case vide, le clic se « propage » à toutes les cases autour jusqu'à rencontrer un chiffre.

Un point important : pour pouvoir utiliser l'ago plusieurs fois, il faut effacer tous les marqueurs vu entre deux utilisations. Le plus simple est de parcourir toute la grille avec une double boucle for.

À la fin de l'ago, le compteur tailleZone vous donne la taille de la zone. (sans déconner ? ) Il ne reste plus qu'à comparer à 4 et stocker ça quelque part si besoin…

Bon courage !

[Sosuk]

Merci pour le temps accordé pour la réponse (:

En effet, j'étais aussi parti sur la base comparer la saisie avec les 8cases périphériques. Et de faire une boucle jusqu'à ce que et allant de points en points on retombe sur la dernière saisie.

Le problème étant que il y a deux joueurs, les rouges et les bleus. Et que il est possible qu'une zone créer par son adversaire empêche la création de la zone. (car avec un triangle on peux rentrer dans une zone en en sortir. Du coup malgré que la boucle pour la forme soit validé elle n'est pas possiblement validable. :s

Donc pour résumer les joueurs bleu et rouge joue à tour de rôle.

Je dois donc créer un tableau pour chaque joueurs. Mémorisant les saisies des cases. Est ce que cela est possible de créer une valeur interdite dans un tableau ? Par exemple via un booléen ? Par exemple (1,1) Vrai pour rouge mais Faux pour bleu ?

J'ai du mal à comprendre comment une boucle puisse comprendre qu'une forme a été créée ? Car les formes peuvent être au final multiples non ?
Je ne sais pas comment marche les listes de plus :/


La j'ai l'impression que je vais avoir une boucle énorme à la fin, avec des dizaines de si à la suite dans la partie des saisies de jeu. :0

[Watilin]

Ça dépend. Comment avez-vous choisi de représenter vos points ? Et la partie graphique, elle est réalisée comment ? C'est du HTML ?

L'important c'est de choisir la bonne représentation de vos concepts. Le concept de grille, le concept de joueur, le concept de point, etc. Moi par exemple, je mettrais tous les points (les bleus et les rouges) dans le même tableau, un tableau à deux dimensions (15 * 15). Et je représenterais leur couleur par une chaîne, c'est plus parlant qu'un booléen. Exemple : p.couleur = "rouge";. On ne fait pas du C embarqué, on ne cherche pas à glaner le moindre petit octet…

C'est même possible que vous n'ayez besoin de rien d'autre que de l'information de couleur de vos points. Dans ce cas vous pouvez simplement stocker des chaînes ("rouge" ou "bleu") dans votre tableau à deux dimensions. Dans le cas contraire, le plus simple est de créer des objets vide quand vous en avez besoin :
var p = {};.

J'ai oublié de gérer la couleur dans mon algo, désolé "^^ Avec ceci ça sera peut-être plus clair :

Code pseudocode :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
tant que (liste non vide):
    variable p = 1er point de liste, et on le retire en même temps
    ajouter 1 à tailleZone
    marquer p comme vu
    pour tout point q à côté de p:
        si q n'a pas encore été vu et si q.couleur === couleurZone:
            ajouter q à liste
        fin si
    fin pour tout
fin tant que

couleurZone étant la couleur du premier point, celui qui a été choisi arbitrairement.

J'imagine qu'il y a encore beaucoup de zones d'ombre dans vos têtes, c'est normal quand on n'a pas fait beaucoup d'informatique. L'important c'est de réussir à définir clairement ses concepts de base. Après, le reste vient tout seul.

[SylvainPV]

Hello,

Sur mon jeu de puissance4 (http://syllab.fr/projets/games/p4/), j'ai utilisé un tableau d'entiers. 0=vide, 1=joueur rouge, 2=joueur jaune. C'est le plus simple, après s'il faut gérer des états particuliers pour les points, mieux vaut passer par un objet comme le suggère Watlin.

La logique du jeu va venir tester et manipuler ce tableau à chaque fois qu'un tour est joué. Une fois la grille passée à la moulinette, on teste les conditions de victoire. Enfin, tant que le jeu n'est pas fini, on actualise l'affichage de la grille et on autorise la saisie suivante.

Commence par le commencement, essaie d'écrire la fonction de dessin de ta grille. Voilà un premier exemple très basique pour t'aider

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
var grid = [[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0]] ;
 
dessinerGrille(monElementHTMLConteneur, grid);
 
function dessinerGrille(container, grid){
var out="";
for(var col=0; col<grid.length; col++){
for(var row=0; row<grid[col].length; row++){
out+="<div class='case'>"+grid[col][row]+"</div>";
}
out+="<br>";
}
container.innerHTML = out;
}

[Sosuk]

Le tableau à été fait avec les fonctions à disposition. C'est à dire des tracer de lignes avec des boucles. Il à l'aspect d'une feuille de papier de 15 Carreaux sur 15 et les points sont jouables sur les intersections. Il Commence à x=50 et y=50. (Point 0,0) puis tout les 25 sur x ou y on gagne un point de coordonné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
// Quadrillage 
 
// Variables
 
var x0;
var i;
var x1;
var y0;
var i;
var y1;
 
//Initialisation de la sortie graphisme
 
Initialiser();
Viewport(0, 0, 800, 800, 1);
 
// Debut du quadrillage
 
// Lignes verticales
 
x0=50; // Initialisation des variables
x1=50;
 
// Tracage sur la sortie graphisme
 
for (i=1; i<=15; i=i+1){
 
  x0=x0+25;
  x1=x1+25;
  Ligne(x0,50,x1,425,rgba(50,180,25,1)); }
 
// Lignes horizontales
 
y0=50; // Initialisation des variables
y1=50;
 
// Tracage sur la sortie graphisme
 
for (i=1; i<=15; i=i+1){
 
  y0=y0+25;
  y1=y1+25;
  Ligne(425,y0,50,y1,rgba(50,180,25,1)); }
 
// Lignes plus fines
 
y0=50; // Initialisation des variables
y1=50;
// Tracage sur la sortie graphisme
 
for (i=1; i<=75; i=i+1){
 
  y0=y0+5;
  y1=y1+5;
  Ligne(425,y0,50,y1,rgba(180,10,50,0.25)); }
 
// Fond
 
RectanglePlein(50,50,375,375,rgba(50,10,250,0.15));

Donc voilà, les coordonnées de ma grille sont connues. Je vais travailler avec mon binôme demain suite aux conseils que vous m'avez donner. On vas se creuser les méninges et essayer d'avancer. Le but est de comprendre par nous même pour progresser.

Merci beaucoup je posterai dans les prochains jours l'avancée