C# / VB.NET - Gestire mosse dei pezzi di scacchi [C# - XNA]

salve, e` un po' di tempo che sto lavorando ad un bel progetto, che spero di portare a termine il prima possibile. tale progetto e`, come fa supporre il titolo, un programma di scacchi con il quale si possa giocare contro il computer, con un discreto livello di difficolta`. Per fare cio` mi sono documentato e ho trovato le giuste informazioni per riuscire a cominciare a lavorare al progetto, scegliendo XNA per sviluppare la GUI.
per chi volesse dare un'occhiata al progetto e, magari, dare dei consigli/critiche (vi invito a farlo per qualunque motivo), puo` farlo alla mia repository su GitHub:
github.com/crybot/…

Detto questo posso passare al mio effettivo problema:
Dopo aver delineato l'architettura del gioco all'interno del progetto e sviluppato la GUI in xna, ho deciso di dedicarmi alla parte logica del programma, incagliandomi in un problema che ritengo alquanto complesso.
il problema consiste nel come implementare le regole di movimento dei vari pezzi in maniera logica. Mi spiego meglio:
sappiamo tutti, almeno spero, che i diversi pezzi degli scacchi possono muoversi in modi differenti e che devono rispettare delle regole, per esempio il pedone si muove di una sola casa in avanti, mangia in diagonale e cattura in "en-passant" compiendo un movimento verticale di due case; il cavallo invece si muove ad "L" (due movimenti in orizzontale e uno in verticale o viceversa).
Il problema infatti si pone quando devo implementare tali regole nel programma, non sapendo proprio che pesci pigliare.

Per chi si ricorda, tempo fa avevo pubblicato un programma in C++ che calcolava i movimenti che il cavallo doveva compiere per girare tutta la scacchiera. il suo movimento l'avevo implementato cosi`:
pastebin.com/…

tuttavia, seppur questo potrebbe andare bene per il cavallo, non va bene per gli altri pezzi, che possono disporre di combinazioni di movimenti molto piu` numerose.
arrivo al punto della domanda, finalmente:
qualcuno potrebbe gentilmente dirmi come fare, o almeno darmi qualche dritta, su come fare per implementare le regole di movimento dei vari pezzi?

grazie mille

P.S. se avete qualche critica sulla correttezza del progetto (linkato sopra), perfavore scrivete pure

Premetto che non conosco C#, però provo a darti una mano perché non è un problema di codice ma di logica.
Secondo me potresti dichiarare una enumerazione, chiamata per esempio PezziScacchiera che contiene i vari nomi dei pezzi. Esempio:

enum PezziScacchiera { Pedone, Cavallo, Alfiere, Torre, Re, Regina };

Suppongo che tu abbia usato un array per la scacchiera.
Quando il giocatore sceglie che tipo di pezzo muovere tu gli proponi tutte le possibilità. Cioè che il pedone può muoversi in

Scacchiera[posizionePedone+1][posizionePedone]

oppure se è il primo turno

Scacchiera[poszionePedone+2][posizionePedone]

Supponendo che Scacchiera sia l'array della scacchiera appunto

Ovviamente stando attento a non far uscire i pezzi dalla scacchiera!

Spero di esserti stato d'aiuto!
P.S.: Comunque davvero molto bello il progetto che stai portando avanti!

Ciao,

tempo fa feci un programma che gestiva il gioco degli scacchi tra due giocatori umani, era in Delphi, ma la logica e' quella, se ti puo' servire dagli un'occhiata.

pierotofy.it/pages/sorgenti/dettagli/18139-ChessGame/

Ciao.

probabilmente non hai visto il progetto, perche` se l'avessi fatto avresti visto che in realta` l'enum esiste gia`.
in ogni caso, grazie della risposta, ma non penso proprio che sia il metodo giusto per definire le regole dei vari pezzi.
Pensa alla regina che puo` muoversi in tutte le direzioni di quante case vuole...
grazie comunque




grazie anche a te della risposta, non riesco a trovare cio` che voglio nel tuo progetto, non potresti semplicemente postare la parte in cui implementi le regole di movimento dei pezzi?
grazie.

Ciao,

prendi il sorgente, in particolare il file MainChess.pas

e guardati le funzioni

TPezzo.MossaRe(X, Y, DestX, DestY);
TPezzo.MossaDonna(X, Y, DestX, DestY);
TPezzo.MossaTorre(X, Y, DestX, DestY);
TPezzo.MossaAlfiere(X, Y, DestX, DestY);
TPezzo.MossaCavallo(X, Y, DestX, DestY);
TPezzo.MossaPedone(X, Y, DestX, DestY);

che servono appunto a verificare se effettivamente si puo' effettuare una delle suddette mosse partendo dalla casa (X, Y) per arrivare alla casa (DestX, DestY);

tengono conto di eventuali ostacoli (per torre, alfiere e donna) ma non controllano se la mossa mette il proprio re sotto scacco, infatti questa verifica la faccio in seguito.

Ciao.

Ciao!

Potresti implementare un'interfaccia che espone le possibili azioni di un pezzo: es.
muovi, controllamossa, mangia, etc...

poi crei una serie di classi una per ogni pezzo che implementano l'interfaccia in questione. Così puoi benissimo implementare le differenti regole in ogni classe pur avendo una Collection di oggetti uguali, che puoi iterare per i necessari aggiornamenti ad ogni turno.

interface pezzoScacchi
{
    void Muovi(Scacchiera s);
    bool ControllaMossa(Scacchiera s);
    void Mangia(Scacchiera s);
    // etc...
}

public class Pedone : pezzoScacchi
{
    public void Muovi(Scacchiera s)
    {
          // gestione della mossa
    }

    // resto dell'implementazione dell'interfaccia
}


/// quindi ora puoi avere una List<pezzoScacchi> da utilizzare a piacimento.

Ciaociao!!

ciao, grazie della risposta, ma probabilmente non hai capito la mia domanda, e non hai neanche guardato il progetto.