Logica del gioco

• 4 minuti

In questa unità verranno illustrati alcuni concetti, ad esempio il funzionamento del gioco "Forza quattro" e i costrutti di Blazor che è necessario conoscere per generare un gioco.

Forza quattro

Nel gioco "Forza quattro" un giocatore deve allineare 4 pedine orizzontalmente, verticalmente o diagonalmente prima che lo faccia l'avversario. Gli aspetti da considerare quando si implementa questo gioco includono il monitoraggio dello stato corrente delle pedine del gioco, gli avversari e il rilevamento di un vincitore. È utile quando si programma un ciclo di gioco, un set di azioni che è necessario ripetere fino a quando non è possibile dichiarare un vincitore. Qualcosa di analogo a quanto segue:

1. Si inizia con uno stato reimpostato, ovvero un tabellone vuoto senza pedine.
2. L'utente inserisce una parte del gioco.
3. L'avversario mette un pezzo di gioco.
4. Verificare la presenza di vincitori:
   1. Se è presente un vincitore, dichiarare vincitore e terminare il gioco o riavviare il gioco.
   2. Se nessun vincitore, ripetere il passaggio 2.

Rappresentazione dello stato nel codice

Prima di tutto, che cos'è lo stato? Lo stato nei giochi è quello che si svolge nel gioco, quanti punti hai, dove vengono posizionati i tuoi posti di gioco e così via.

Una guida importante quando si tratta di stato nello sviluppo di giochi consiste nel mantenere lo stato separato dall'interfaccia utente in quanto semplifica la modifica e il codice è più facile da leggere tra gli altri vantaggi.

Nel contesto di Blazor, questo significa che lo stato e la logica intorno allo stato devono trovarsi nella propria classe C#, come indicato di seguito:

class State
{
    Player [] players;
    int gameRoundsPlayed;
    bool gameOver;

    State()
    {
        players = new Players[]
        {
            new Player() { Name= "Player", Points = 0 },
            new Player() { Name= "Opponent", Points = 0 }
        };
        gameRoundsPlayed = 0;
        gameOver = false;
    }

    void ResetGame() 
    {
        gameOver = false;
        players[0].Points = 0;
        players[1].Points = 0;
    }

    void EndGame()
    {
        gameOver = true;
        gameRoundsPlayed++;
        // award winner..
    } 
}

La State classe contiene informazioni su chi sta giocando il gioco, su quanti round sono stati eseguiti, se il gioco è ancora attivo e così via.

Puoi usare un'istanza di questa State classe nei componenti Blazor per disegnare una lavagna ed eseguire altre azioni man mano che il gioco avanza.

Reimpostare lo stato del gioco in OnInitialized

In Blazor è presente un metodo che viene chiamato quando il componente viene inizializzato, prima di qualsiasi altra operazione. Questo metodo è un buon punto in cui inserire il codice che consente di impostare il gioco in uno stato di "reimpostazione", ad esempio la creazione della lavagna, i giocatori e la reimpostazione di eventuali punteggi, se necessario, dalle sessioni di gioco precedenti.

Il metodo che gestisce questa inizializzazione del componente viene chiamato OnInitialized.

Un OnInitialized metodo che gestisce la reimpostazione dello stato del gioco potrebbe essere simile al seguente:

void OnInitialized() 
{
    state.ResetGame();
}

L'utente dovrà stabilire cosa inserire qui, ma il codice presentato aiuta a comprendere meglio.

Gestione delle interazioni dei giocatori tramite eventi

Quando l'utente o i suoi avversari fanno una mossa, è necessario acquisire questa interazione. È possibile codificare le interazioni utente come eventi a cui l'app o il gioco deve rispondere.

Ad esempio, è possibile selezionare un pulsante o eseguire un movimento di trascinamento per spostare una pedina del gioco.

Ecco l'aspetto che può avere nel codice:

<span title="Click to play a piece" @onclick="() => PlayPiece(0)">🔽</span>

Nel codice precedente, l'attributo @onclick di direttiva specifica un gestore per l'evento click , ad esempio un utente ha selezionato questo elemento. L'evento viene gestito dal codice () => PlayPiece(0) che richiama la funzione PlayPiece(0).

Modifica dello stato

Un'azione che si verifica nel gioco deve interessare lo stato del gioco. Nell'esempio precedente in cui viene richiamato PlayPiece(), è necessario modificare lo stato per dire che questo pezzo della scheda è ora occupato da un pezzo. Ciò significa che, data la classe di esempio State, è necessario un modo per rappresentare le pedine del gioco, come illustrato di seguito:

class State 
{
    // other code omitted
    Piece [] pieces;

    State()
    {
        pieces = new Piece[25]; // 5x5 board
    }

    void PlayPiece(int position)
    {
        pieces[position] = true; // true = occupied
    }
}