Spostare i giocatori nello stesso riquadro contemporaneamente?

Considera una griglia 2 x 2 di quadrati. Un giocatore può spostarsi su una casella se:

• nessun altro giocatore vuole muoversi nella casella il prossimo turno
• nessun altro giocatore ha aspettato e sta ancora occupando la casella in questo turno

Ho incluso l'immagine sopra per descrivere il mio problema.

I giocatori si muovono contemporaneamente.

Se 2 (o più) giocatori provano a muoversi nella stessa casella, nessuno dei due si muove.

1. Contrassegna tutti i giocatori come fermi o in movimento, a seconda che abbiano inviato una mossa in questo turno.
2. Passa attraverso l'elenco delle mosse. Se due mosse puntano nella stessa posizione, rimuovile dall'elenco e metti i giocatori fermi.
3. Scorri la lista rimuovendo tutte le mosse che indicano un giocatore fermo o un altro ostacolo. Fallo ripetutamente fino a quando l'elenco non cambia quando lo attraversi.
4. Sposta tutti i giocatori.

Penso che dovrebbe funzionare. Funziona sicuramente per il caso che hai pubblicato, e un paio di altri casi banali su cui l'ho provato.

Risoluzione delle collisioni, anziché prevenzione delle collisioni.

Basta spostare gli oggetti, quindi verificare se ci sono state delle collisioni. Se c'è stata una collisione con un altro blocco, torna alla casella precedente o, a seconda del tipo di gioco, una casella diversa.

Move all players according to their request.
while there are still some squares multiply occupied:
    For each square that is now multiply occupied:
        For each player in that square that moved there this turn:
            Return them to their previous square
            Mark them as having not moved this turn

Ciò richiede che ogni giocatore si ricordi da dove si sono appena mossi, in modo che possano essere restituiti, e anche ricordare se si sono mossi in questo turno. Questo secondo controllo indica che ogni pezzo dovrà essere restituito una sola volta e dovrebbe garantire che l'algoritmo venga terminato correttamente. Assicura inoltre che vengano restituiti solo i giocatori che si sono mossi: l'occupante originale rimane perché non vengono considerati per la rimozione.

Un'altra soluzione è utilizzare una mappa 2 volte più grande di quella che stai mostrando. ogni volta che vuoi spostare i giocatori, li sposti due volte in modo che i giocatori finiscano sempre su tessere con valore pari sia per X che per Y. di nuovo ci saranno alcuni rari casi che richiedono più attenzione ma la maggior parte dei casi possibili vengono risolti (come quello che tu descritto) senza pensarci due volte.

Registra tutte le mosse richieste usando un array o una mappa.

In caso di conflitto, ripristinare la richiesta di spostamento in questione. Se restituisce l'oggetto a un quadrato che un altro oggetto sta tentando di occupare, ripristina la richiesta dell'oggetto richiedente.

Pseudo codice:

int[][] game; // game board

var doMoves() {
    int[][] dest = [][]; // destinations; cleared each run

    for (obj in gameObjects)
        if (obj.moveRequest) {
            var o = dest[obj.moveX][obj.moveY];
            if (o) {
                // collision!
                o.doNotMove = true;
                obj.doNotMove = true;
            } else {
                dest[obj.moveX][obj.moveY] = obj;
            }
        }
    }

    // check move validity
    for (obj in gameObjects) {
        if (obj.doNotMove) continue;

        var o = game[obj.moveX][obj.moveY];
        if (o and o.doNotMove)
            revertRequest(obj, dest);
    }

    // process moves
    //etc
}

// recursive function to back up chained moves
var revertRequest(obj, dest) {
    if (!obj.doNotMove) {
        obj.doNotMove = true;
        var next = dest[obj.x][obj.y];
        if (next)
            revertRequest(next, dest);
    }
}

Sulla base della risposta di SimonW , ecco un algoritmo esplicito:

Sia squaresuna matrice indicizzata dalle posizioni dei giocatori e contenente, per ogni possibile posizione, l'indice di un'altra posizione o il valore speciale NULL. (È possibile che si desideri memorizzare questo come un array sparse.) I possibili valori delle voci in questo array possono essere interpretati come segue:

• Se squares[S]è NULL, il quadratoS è libera di spostarsi.
• Se squares[S] == S, il giocatore a Snon può o non si sposta, o due (o più) giocatori hanno tentato di spostarsiS contemporaneamente e vengono entrambi negati.
• Altrimenti, squares[S]conterrà l'indice del quadrato da cui un giocatore vuole passare al quadrato S.

Ad ogni turno, inizializzare tutte le voci di squaresto NULLe quindi eseguire il seguente algoritmo:

for each player:
   current := the player's current location;
   target := the location the player wants to move to (may equal current);
   if squares[target] is NULL:
      squares[target] := current;  // target is free, mark planned move
   else
      // mark the target square as contested, and if necessary, follow
      // the pointers to cancel any moves affected by this:
      while not (target is NULL or squares[target] == target):
         temp := squares[target];
         squares[target] := target;
         target := temp;
      end while
      // mark this player as stationary, and also cancel any moves that
      // would require some else to move to this square
      while not (current is NULL or squares[current] == current):
         temp := squares[current];
         squares[current] := current;
         current := temp;
      end while
   end if
end for

Successivamente, ripeti l'elenco dei giocatori e sposta quelli che sono in grado di farlo:

for each player:
   current := the player's current location;
   if not squares[current] == current:
       move player;
   end if
end for

Poiché ogni mossa può essere pianificata una sola volta e annullata al massimo una volta, questo algoritmo verrà eseguito in tempo O ( n ) per n giocatori anche nel caso peggiore.

(Ahimè, questo algoritmo non impedirà ai giocatori di cambiare posto o attraversare percorsi in diagonale. Potrebbe essere possibile adattare il trucco in due fasi di Gajet , ma il modo completamente ingenuo per farlo non funzionerà e sono troppo stanco per capire un modo migliore proprio ora.)