Jogo de Xadrez

[andrepadez]

Pois é, depois do temporizador de Blinds para poker ( o meu "Hello World" em C# e em *****), decidi agarrar um projecto mais complexo. Por enquanto está tudo a correr bem, tirando alguns precalços já ultrapassados.
A minha dúvida prende-se com optimização e redundância, vou tentar ser o mais resumido possível.

//contem as propriedades de um quadrado do tabuleiro
//ambas as classes têm métodos públicos Get (ex GetHostOf) para retornar o valor das instâncias
Public Square {
    private int x, y;  // coordenadas cartesianas na matriz [8,8] de Squares que é o tabuleiro
    private Piece hostOf; "indica qual a instância da classe Piece que ocupa este square
}
//Contém todas as propriedades inerentes a cada peça em jogo
Public Piece {
    private Square location; //localização da peça na matriz de Squares
    //variáveis para Côr (enum), Tipo (enum cavalo, rei, peão), e ordem (peãoBranco0, CavaloPreto1)
 
//Construtor: 
    public Piece (Square local, Type tipo, Cor color, order)
}
 
//Classe que cria um tabuleiro de xadrez, coloca as peças nas posições iniciais, inicia o jogo
//cada instância de ChessBoard é um match
Public ChessBoard
{
private Square squares = new Square [8,8];
private Piece blackPawns = new Piece [8];
private Piece whitePawns = new Piece [8];
private Piece blackPawns = new Piece [8];
private Piece whiteKnights = new Piece[2];
//já perceberam a ideia.
 
//Classe construtora
public ChessBoard()
{
//1º uso um for quadrático para criar new Squares por toda a matriz, atribuindo coords XY
 
//Colocar as Peças (ex. Peões Brancos) - é aqui a dúvida
 
for (rank = 0; rank < 8; rank++)
    {
         whitePawns[1] = new Piece (squares[rank, 1], Type.Pawn, Color.White);
         squares[rank,1].HostOf = whitePawns[1];
    }
 
(...e para todas as outras peças o mesmo...)
}

A minha dúvida prende-se na redundância da atribuição de peças a quadrados. E sei que vai acontecer outra vez ao longo do jogo, sempre que se mover uma peça; eu vou ter de:
- Atribuir o quadrado 2 à localização da peça movida
- indicar ao quadrado 1 que a variável hostOf = null
- indicar ao quadrado 2 que a variàvel hostOf = peçaMovida;

Parece-me tudo extremamente redundante.


Alguma sugestão??? Obrigado pela atenção.

 

[selipequenote]

Parece-me que teres um array de peças do mesmo tipo não faz muito sentido. O que tu queres é saber que está um peão no quadrado XY, se é o peão 1, 2 ou 3 é perfeitamente indiferente.

Tens um objecto peça que tem um determinado comportamento, uma determinada cor e pode ser de um determinado tipo. Um dos atributos do objecto quadrado é uma peça que pode estar a null caso não esteja lá nenhuma.

Parece-me fazer mais sentido por aí.

Já agora atenção à coerência entre português/inglês.

Espero ter ajudado, cumps.

 

[andrepadez]

Primeiro, obrigado pela resposta.
Quanto à coerência no código, o que postei não é copy paste, mas foi batido de memória. O código fonte está todo em inglês, assim como os comentários, como costumo fazer.

Pelo que percebi, achas irrelevante a criação de Arrays para os conjuntos de Peças?
Se sim, posso só assignar a Square.HostOf = new Piece (args)???

Vou experimentar e dou feedback.

Ok, a primeira parte correu pacificamente, larguei os arrays e usei

square[x,y] = new Piece (args);

De qq maneira, fico com dois objectos que tenho de manipular com os três passos que descrevi no fim do 1º post. Se alguem tiver alguma sugestão...

O que pensei não é muito elegante, mas funciona certamente:

{
    casas[origem].HostOf = null;
    casas[destino].HostOf = Peça;
    Peça.location = casas[destino].location
}

Mais uma vez agradeço a atenção