Rilevamento efficiente delle collisioni basato su piastrelle per molti quadrati?

attualmente sto lavorando alla mia versione di un gioco basato su tessere (pensa Terraria, ma meno fantastico (penso che sia una parola? Scusa se non lo è)).

Ad ogni modo, attualmente sto lavorando al rilevamento delle collisioni (anche per casi angolari!) Che è stato un grande passo per me. C'è qualcosa di estremamente gratificante nel vedere uno sprite non attraversare un blocco. Ma poi ho avuto l'idea di fare un benchmark. Cattiva idea.

1.000 quadrati, nessun problema. 10.000 quadrati, per 3 personaggi era un po 'ritardato. 100.000 quadrati (mappa davvero enorme), per 3 personaggi era ingiocabile.

Sto riscontrando il problema per cui non voglio nemmeno prendere in considerazione i blocchi che sono troppo lontani dal giocatore, dai personaggi, dagli oggetti, ecc., Ma non voglio caricare costantemente questi in-out di memoria.

Ecco il mio algoritmo finora, sentiti libero di criticare.

foreach (Block in level)
{
    if (distance from block to player > a specified amount)
        ignore this block;
    else
    {
        get the intersection depth between the two bounding boxes
        if (depth of intersection != Zero-vector)
        {
            check y size vs x size
            resolve on smallest axis
        }
    }
}

Come noterai, quando la dimensione del livello aumenta, l'ordine di questo algoritmo cresce di N blocchi. Non vorrei nemmeno prendere in considerazione blocchi che non sono nemmeno vicini al giocatore.

Sto forse pensando di usare un doppio array di blocchi da (0,0) a (mapWidth, mapHeight) anziché un elenco, calcolando una zona di pericolo in base alla posizione della persona, ad es. Se la posizione del giocatore è a (10, 20) guarderà da (0, 10) a (20, 30) o così via.

Qualsiasi pensiero e considerazione sono fantastici, grazie.

Sì, stai pensando correttamente. Dovresti usare una matrice 2D di tessere poiché ti consente di indicizzare le tessere per posizione.

Block[,] level = new Block[width, height];

E poiché il giocatore può solo scontrarsi con le sue tessere circostanti, il numero di controlli di collisione che devi fare è molto piccolo. Questo ovviamente dipende dalle dimensioni del giocatore. L' esempio Platformer funziona in questo modo:

int leftTile = (int)Math.Floor((float)characterBounds.Left / tileWidth);
int rightTile = (int)Math.Ceiling(((float)characterBounds.Right / tileWidth)) - 1;
int topTile = (int)Math.Floor((float)characterBounds.Top / tileHeight);
int bottomTile = (int)Math.Ceiling(((float)characterBounds.Bottom / tileHeight)) - 1;

for (int y = topTile; y <= bottomTile; ++y)
{
    for (int x = leftTile; x <= rightTile; ++x)
    {
        // Handle collisions with the tile level[x,y] just like you were doing!
    }
}

Controlla l'esempio se hai ancora problemi.

Immagino che la mia risposta sarebbe la tua risposta! ;-)

Se hai la posizione (e le dimensioni) del giocatore puoi calcolare gli indici delle tessere circostanti (che sono le uniche da controllare in dettaglio). In questo modo dovrebbe essere irrilevante quanto sia grande la tua mappa, dipende solo dalle dimensioni effettive del tuo giocatore, risultando in più potenziali tessere da controllare.

Magari controlla il tutorial sulle collisioni su riemers.net se non l'hai già fatto.

Quando si ha a che fare con un gran numero di collisioni, di solito si desidera adottare una struttura più avanzata , come Quadtree o Hashmap per verificare tali collisioni.

Poiché le piastrelle sono statiche, suggerirei di utilizzare un Quadtree. Un albero quad è composto da quad. Ogni quadratino è composto da quattro rettangoli e ciascuno di questi rettangoli è quadruplo. Questo continua ricorsivamente fino a una dimensione specificata. Ogni quadratino può contenere un elenco di tessere che popolano quell'area dello schermo. In questo modo, quando si verificano le collisioni, è possibile

1. Limitare i controlli a quelli nelle immediate vicinanze
2. Limitare i controlli solo agli oggetti che si stanno muovendo

Ora se non vuoi nemmeno guardare le tessere fuori dallo schermo, allora potresti fare qualcosa del genere

public bool CheckCollision(myPosition) {
    if(quadNodes.Count > 0) {
        // This is not a leaf, keep checking
        foreach(Quad node in quadNodes) {
            if(node.Position is insideViewport && nearPlayer)
                // Continue recursion
            }
        }
    }
    else {
        // This is a leaf, do checks
        foreach(Tile tile in tileList) {
            if(collision)
                return true;
        }
        return false;
    }
}