Codice di pulizia per la funzione generatore di mosse per il gioco in c++

Question

Sto lavorando al mio gioco di scacchi in cui ho bisogno di generare mosse per un certo pezzo sulla scacchiera. Questa scheda è rappresentata nel seguente formato;

    int board[8][8];

Ogni numero in questo tabellone rappresenta un certo pezzo del gioco. Dato che ci sono due lati negli scacchi, quello è il giocatore bianco e il giocatore nero. Ho ottenuto valori negativi anche in questo array.

Ad esempio, il White Bishop è rappresentato con il numero intero 2

Pertanto, quello nero, sarà rappresentato con l'intero -2

Questo mi lascia con una condizione molto semplice per verificare se si tratta di un pezzo bianco o nero

• Se numero > 0, il pezzo è bianco
• Se numero < 0, il pezzo è nero
• Se il numero È 0, non ci sono pezzi sulla scacchiera per quella posizione

Tornando alla domanda, supponiamo che io debba generare mosse per un pedone

Per quelli di voi che non conoscono le regole degli scacchi, un pedone può muoversi di 1 casella in diagonale se c'è un pezzo Avversario sulla nuova casella.

Io sono il giocatore bianco. Ora la mia condizione è;

if (number < 0)

Io sono il giocatore nero. Ora la mia condizione è;

if (number > 0)

Vedi il problema? Questa condizione va applicata per tutti i pezzi e per tutte le possibili posizioni che possono muovere. Che è un numero davvero enorme. Il problema ora è che devo duplicare il mio codice per il giocatore bianco, creare un'altra funzione per il giocatore nero e incollarlo in quella. E cambia solo quella singola condizione qua e là, poiché tutte le altre regole degli scacchi sono le stesse per entrambi i giocatori. Invece di avere 6 funzioni. ora ne avrò 12

Come posso raggiungere questo obiettivo senza dover duplicare il mio codice?

Il mio codice attuale utilizza due funzioni separate. Ho pensato di passare attraverso ogni elemento dell'array e cambiare il segno se genero per il nero, ma questo lo rende molto inefficiente

Ecco un esempio compilabile, ho cercato di mantenerlo il più minimo possibile pur dando chiarezza:

#include<iostream>
#include<vector>

int board[8][8] = {
    {0,0,0,0,0,0,0,0},
    {0,0,-1,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,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,1,0,0,0,0,0},
    {0,0,0,0,0,0,0,0}
};
// This board is the chess board and the little one representing the white pawn, and -1:black
std::vector < std::vector <int> > generatemovesPawn_white(int row,int col){
    std::vector<std::vector<int>> moves;
    std::vector<int> Move;
    if (board[row-1][col-1] < 0) {
        Move.push_back(row-1);
        Move.push_back(col-1);
        moves.push_back(Move);
    }
    return moves;
}

int main (){
    std::vector<std::vector<int>> moves = generatemovesPawn_white(6,1);
    return 1;
}

Ora, per il nero tutto ciò di cui ho bisogno è cambiare la condizione da:

if (board[row-1][col-1] < 0)

a

if (board[row-1][col-1] > 0)

Spero che tu veda il mio problema

Answer 1

Puoi estrarre la condizione in un boolparametro:

std::vector<std::vector<int>> 
  generatemovesPawn(int row, int col, bool white_or_black)
{
    std::vector<std::vector<int>> moves;
    std::vector<int> Move;
    if (white_or_black) {
        Move.push_back(row-1);
        Move.push_back(col-1);
        moves.push_back(Move);
    }
    return moves;
}

e aggiungi un livello di indirezione:

std::vector<std::vector<int>> 
  generatemovesPawn_white(int row, int col)
{
  if (board[row-1][col-1] < 0)
    return generatemovesPawn(row, col, true);
  if (board[row-1][col-1] > 0)
    return generatemovesPawn(row, col, false);
  return {};
}

Answer 2

Aggiungi un bool che indica se è bianco o nero agli argomenti della funzione e aggiungi un'istruzione if per controllare il bool

std::vector < std::vector <int> > generatemovesPawn(int row,int col, bool wb)
{
//...


    if (wb && board[row-1][col-1] < 0)
    {
        //... do white stuff
    }
    else if (!wb && board[row-1][col-1] > 0)
    {
        //... do black stuff
    }
    //...
}

Answer 3

Devi rendere il tuo codice dipendente da una variabile, invece di codificare un colore.

Ad esempio, senza provarlo, ho cambiato il tuo codice, di seguito. Prende un colore e regola il suo comportamento in base al colore. Usa una variabile dx,dy per memorizzare le pedine di direzione di ogni mossa di colore.

// This board is the chess board and the little one representing the white pawn, and -1:black

std::vector < std::vector <int> > generatemovesPawn(int row, int col, bool whiteToPlay)
{
    int dx = -1;
    int dy = whiteToPlay ? 1 : -1;
    int pawnId = whiteToPlay ? 1 : -1;

    std::vector<std::vector<int>> moves;
    std::vector<int> Move;
    if (board[row + dx][col + dy] == pawnId) 
    {
        Move.push_back(row + dx);
        Move.push_back(col + dy);
        moves.push_back(Move);
    }
    return moves;
 }

Ma il mio suggerimento iniziale è valido: chiedi purehttps://codereview.stackexchange.com. Questo è il posto giusto per queste domande.