Solução elegante para colorir azulejos de xadrez

Estou re-desenvolvendo um jogo de xadrez que escrevi em Java e fiquei imaginando se existe um algoritmo elegante para colorir peças de xadrez em um tabuleiro de xadrez numerado.

No momento, minha solução usa instruções if else para determinar se o bloco está em uma linha par ou ímpar e, com base nisso, se deve ser um quadrado claro ou escuro.

A maneira mais elegante em que consigo pensar, considerando que você tem os índices rowe column, é a seguinte:

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

ou, inversamente:

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

Basicamente, um ladrilho em um tabuleiro de xadrez é leve onde quer que a coluna quanto a linha sejam mutuamente ímpares ou pares e, caso contrário, é escuro.

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

XOR juntos os índices de linha e coluna e observe o bit menos significativo. Alterar o índice de linha ou coluna por um irá inverter o resultado, portanto, gera um padrão de verificador.

Outra sugestão, muito direta:

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

Adicionar a linha e a coluna fornece o número de etapas horizontais e verticais do bloco superior esquerdo.

Um número par de etapas fornece cores claras.
Um número ímpar de etapas fornece cores escuras.

Este assume que nossos quadrados são numerados no intervalo [0..63].

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

Descobrir por que funciona é metade da diversão. :)

1. Numere as peças. Você pode derivar essas informações calculando a linha * 8 + coluna ou algo semelhante.

2. Tome o módulo 16 do número da grade. (Existem 16 posições antes da repetição das peças.)

3. Pinte o ladrilho com base se ele tiver um número par ou ímpar. Vire a cor do ladrilho se o resultado for maior que 7.

Código para índices baseados em zero:

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

Embora essa abordagem não seja realmente necessária para algo tão simples quanto um tabuleiro de xadrez, quando penso em uma maneira elegante de renderizar algo relacionado à vista, desejo facilitar o máximo possível a alteração da exibição renderizada. Por exemplo, suponha que você tenha decidido alternar preto e branco em cada linha, mas não em cada coluna. Os one-liners usados ​​nas respostas até agora teriam que ser reescritos.

Se eu fosse o mais longe possível e tornasse mais fácil redesenhar o padrão possível no tabuleiro de xadrez, eis o que eu faria:

1) Eu faria um arquivo que indica qual a cor de cada quadrado no tabuleiro de xadrez.

Por exemplo, eu poderia criar um arquivo chess_board_pattern.configparecido com este:

bwbwbwbw
wbwbwbwb
bwbwbwbw
wbwbwbwb
bwbwbwbw
wbwbwbwb
bwbwbwbw
wbwbwbwb

2) Eu escreveria uma classe / componente / qualquer coisa que possa ler este arquivo e criaria algum tipo de objeto que represente o padrão do quadro:

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) Eu usaria essa classe na função que realmente chama a atenção.

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]);
    }
}

Novamente, isso é muito mais difícil do que o necessário para um tabuleiro de xadrez. Penso que, em geral, ao trabalhar em projetos mais complicados, é melhor apresentar soluções generalizadas como essa, em vez de escrever código difícil de mudar mais tarde.