Java Tableau Game - Jeu de logique Concept

Question

Je veux créer un jeu qui commence par 3 points verts sur la gauche et 3 points rouges sur la droite avec un espace entre eux. La fin de partie devrait avoir les couleurs des côtés changés. Les règles du jeu sont que, s'il y a un espace à côté d'un point, il devrait être capable de s'y déplacer, même si une couleur opposée est à côté de lui - il devrait être capable de sauter par-dessus si il y a un espace derrière la couleur opposée.

Ma question se trouve sous le code.

Voici le code:

//import mind.*; 
import javax.swing.*; 
import java.util.*; 
import java.lang.*; 
import java.awt.*; 

public class Drive { 
String[] middle = new String[7]; 

public Drive() { 
    int player1, player2; 
    boolean gameEnd, checkempty, checkempty2, enemy, enemy2; 
    // Gamepieces 
    String gr,rd,tom; 
    gr="G"; rd="R"; tom=" "; 
    // beginning of the game, endgame and the updating array 
    String[] begin = {gr,gr,gr,tom,rd,rd,rd}; 
    String[] mellan = new String[7]; 
    String[] end = {rd,rd,rd,tom,gr,gr,gr}; 
    Scanner in = new Scanner(System.in); 
    while (mellan!=end) { 
     mellan=begin; 
     for(int i=0; i<mellan.length; i++) { 
      System.out.print(mellan[i]); 
     } 
     System.out.print("  Choose 0-6: "); 
     int digits = in.nextInt(); 

     //BOOLEAN for game rules!!! 
     checkempty = mellan[digits+1]==tom; 
     checkempty2 = mellan[digits-1]==tom; 
     enemy = (mellan[digits]==gr && mellan[digits+1]==rd && mellan[digits+2]==tom); 
     enemy2 = (mellan[digits]==rd && mellan[digits-1]==gr && mellan[digits-2]==tom); 

     if(checkempty) { 
      mellan[digits+1]=mellan[digits]; 
      mellan[digits]=tom; 
     } else if (checkempty2) { 
      mellan[digits-1]=mellan[digits]; 
      mellan[digits]=tom; 
     } else if (enemy) { 
      mellan[digits+2]=mellan[digits]; 
      mellan[digits]=tom; 
     } else if (enemy2) { 
      mellan[digits-2]=mellan[digits]; 
      mellan[digits]=tom; 
     } 
    } 
    System.out.print("Nicely Done"); 
} 

// Test Drive! 
public static void main(String args[]) { 
    new Drive(); 
} 
} 

Problème:
En ce moment, il est fait la logique du jeu. Si les points n'étaient pas en mesure de reculer, j'aurais fait la tâche. Mais puisqu'ils sont capables de reculer, cela me donne l'erreur quand le code vérifie en dehors du tableau (compréhensible).

La solution au-dessus de ma tête est de rendre le tableau plus avec des signes insignifiants pour ne pas obtenir l'erreur. Mais je demande s'il y a un autre moyen? Parce que, la façon dont il est maintenant, je ne peux pas déplacer mes premiers et derniers points les chiffres du milieu fonctionnent comme il se doit!

Answer 1

Le problème se produit lorsque digits est soit 0, soit l'indice maximum de la matrice. Vous ne pouvez pas vérifier mellan[digits-1] quand digits est 0, et vous ne pouvez pas vérifier mellan[digits+1] quand digits est l'indice maximum pour le tableau.

Donc, vous devez vérifier ces situations avant d'essayer d'accéder au tableau. Vous pouvez essayer quelque chose comme ceci:

checkempty2 = (digits > 0) && (mellan[digits-1] == tom); 

Comme Java utilise évaluation de court-circuit pour les opérations booléennes comme celle-ci, la deuxième partie de cette expression ne sera évaluée que si la première partie est évaluée à true. Par conséquent, mellan[digits-1] ne sera accessible que si digits est supérieur à 0.

De toute évidence, vous devez également gérer la position 2 espaces à gauche ou à droite, mais le même principe pourrait s'appliquer là aussi.

Answer 2

Vérifiez simplement si digits + n est supérieur ou égal à 0 (et inférieur à mellan.length). par exemple .:

if(digits-2 >= 0) 
{ 
    //put core here 
} 

Answer 3

Vous pouvez envisager une des options suivantes:

1) Pad les deux côtés avec 2 points vert (ou rouge). Ils vont travailler comme des barrières.

2) Ajouter des conditions chaque fois que vous vérifiez la position suivante/précédente du tableau.

Je choisirais la deuxième approche ...

Je propose également refactorisation un peu le code. Vous pouvez extraire le code qui valide un saut (à droite ou à gauche) dans une méthode séparée, qui reçoit une direction (+ 1/-1, mieux comme une énumération) comme paramètre.