Solution élégante pour colorer les tuiles d'échecs

Je suis en train de re-développer un jeu d'échecs que j'ai écrit en Java et je me demandais s'il y avait un algorithme élégant pour colorer les tuiles d'échecs sur un échiquier numéroté.

À l'heure actuelle, ma solution utilise les instructions if else pour déterminer si la tuile est sur une ligne paire ou impaire, et sur cette base, si elle doit être un carré clair ou sombre.

La façon la plus élégante à laquelle je peux penser, étant donné que vous avez les indices rowet column, est la suivante:

bool isLight = (row % 2) == (column % 2);

ou, inversement:

bool isDark = (row % 2) != (column % 2);

Fondamentalement, une tuile sur un échiquier est claire partout où la colonne et la ligne sont mutuellement impaires ou paires, et est sombre sinon.

bool isLight = ((row ^ column) & 1) == 0;

XOR ensemble les indices de ligne et de colonne et regardez le bit le moins significatif. La modification de l'index d'une ligne ou d'une colonne inversera le résultat, d'où la génération d'un motif de vérificateur.

Une autre suggestion, très simple:

isLight = (row + column) % 2 == 0;

L'ajout de la ligne et de la colonne donne le nombre de pas horizontaux et verticaux à l'écart de la tuile supérieure gauche.

Un nombre pair d'étapes donne une couleur claire.
Un nombre impair d'étapes donne une couleur sombre.

Celui-ci suppose que nos carrés sont numérotés dans la plage [0..63].

bool IsLight(int i)
{
    return 0!=(i>>3^i)&1;
}

Comprendre pourquoi cela fonctionne est la moitié du plaisir. :)

1. Numérotez les tuiles. Vous pouvez obtenir ces informations en calculant la ligne * 8 + colonne ou quelque chose de similaire.

2. Prenez le module 16 du numéro de grille. (Il y a 16 positions avant la répétition des tuiles.)

3. Colorez la tuile en fonction de son nombre pair ou impair. Inversez la couleur de la tuile si le résultat est supérieur à 7.

Code pour les indices de base zéro:

int cellNum = (row*8+column) % 16;
bool isSecondRow = cellNum > 7;
if(cellNum % 2 == 0 ^ isSecondRow){ //XOR operator
    setColor(Color.White);
}else{
    setColor(Color.Charcoal);
}

Bien que cette approche ne soit pas vraiment nécessaire pour quelque chose d'aussi simple qu'un échiquier, quand je pense à une manière élégante de rendre quelque chose lié à la vue, je veux rendre aussi simple que possible la modification de la vue rendue. Par exemple, supposons que vous ayez décidé d'alterner le noir et le blanc sur chaque ligne, mais pas sur chaque colonne. Les lignes simples utilisées jusqu'à présent dans les réponses devraient être réécrites.

Si je devais aller aussi loin que possible avec cela et rendre aussi facile que possible la refonte du motif sur l'échiquier, voici ce que je ferais:

1) Je créerais un fichier indiquant la couleur de chaque case de l'échiquier.

Par exemple, je pourrais créer un fichier chess_board_pattern.configqui ressemble à ceci:

bwbwbwbw
wbwbwbwb
bwbwbwbw
wbwbwbwb
bwbwbwbw
wbwbwbwb
bwbwbwbw
wbwbwbwb

2) J'écrirais une classe / composant / tout ce qui peut lire ce fichier et créer une sorte d'objet qui représente le modèle de carte:

public class BoardPattern {
    private Color[][] pattern;

    public BoardPattern(File patternFile)
    {
        pattern = new Color[8][8];
        //Parse the file and fill in the values of pattern
    }

    public Color[][] getPattern {
        return pattern;
    }
}

3) J'utiliserais alors cette classe dans la fonction qui dessine réellement le tableau.

File patternFile = new File("chess_board_pattern.ini");
Color[][] pattern = new BoardPattern(patternFile).getPattern();
ChessBoardDrawable chessBoard = new ChessBoardDrawable();

for(int row = 0; row < 8; row++) {
    for(int column; column < 8; column++) {
        chessBoard.drawSquare(row, column, Color[row][column]);
    }
}

Encore une fois, c'est beaucoup plus difficile que nécessaire pour un échiquier. Je pense qu'en général, cependant, lorsque vous travaillez sur des projets plus compliqués, il est préférable de proposer des solutions généralisées comme celle-ci au lieu d'écrire du code difficile à modifier plus tard.