[TheFedex87]

Ah ok, adesso mi è un po' più chiaro il funzionamento.
Comunque, ipotizziamo che si riuscisse a ottenere più di un id: dovresti comunque differenziare i mattoni in modo da capire se stai collidendo con il mattone a destra, a sinistra, in alto o in basso; in caso contrario non potresti bloccare una direzione precisa. Quindi oltre a conoscere il mattone devi anche conoscere la sua posizione rispetto al personaggio.
Mi sembra necessario avere qualche informazione in più per gestire le collisioni.
La velocità del codice non credo che sia un grosso problema, anche dbSpriteCollision(int SP1, 0) fa un controllo per ogni sprite (suppongo).

Io creerei quattro funzioni diverse (una per ogni direzione) che ritornano true se c'è una collisione verso quella posizione.
Qualcosa del tipo: bool collisioneSx(); bool collisioneDx(); bool collisioneUp(); bool collisioneDw(); (più avanti anche collisioneNemico())
Per verificare se ci sono collisioni verso destra e sinistra è necessario fare qualche accorgimento, visto che il personaggio si sposta su quest'asse.
Una volta fatto ciò diventa semplice gestire i movimenti: if(dbRightKey() && !collisioneDx()) muovi_a_destra;

Se sono stato poco chiaro fammi sapere che vedo di spiegarmi meglio...

Prova ad ipotizzare come funzioneranno queste quattro funzioni, in caso hai problemi provo a darti una mano.

GRANDEEEE steve!!!! è l'ennesima volta che pensiamo le stesse cose...proprio ora ho finito di scrivere quello che hai detto tu, anche se leggermente in maniera differente, ad esempio ho scritto tutto in un asola funzione...ecco il codice!!!!!

Codice:

void checkCollision(int idSpriteHero, int idSprites[],int statiCollisione[])
{    
    //int statiCollisione[4];
    statiCollisione[0]=0;
    statiCollisione[1]=0;
    statiCollisione[2]=0;
    statiCollisione[3]=0;

    int tolleranzaPixel = 7;

    int minXHero = dbSpriteX(idSpriteHero);
    int maxXHero = dbSpriteX(idSpriteHero) + dbSpriteWidth(idSpriteHero);
    int minYHero = dbSpriteY(idSpriteHero);
    int maxYHero = dbSpriteY(idSpriteHero) + dbSpriteHeight(idSpriteHero);

    int minXSprite = 0;
    int maxXSprite = 0;
    int minYSprite = 0;
    int maxYSprite = 0;

    int ind = 0;
    while (idSprites[ind] != -1)
    {
        bool collide = dbSpriteCollision(3, idSprites[ind]);
        if (collide)
        {
            minXSprite = dbSpriteX(idSprites[ind]);
            maxXSprite = dbSpriteX(idSprites[ind]) + dbSpriteWidth(idSprites[ind]);
            minYSprite = dbSpriteY(idSprites[ind]);
            maxYSprite = dbSpriteY(idSprites[ind]) + dbSpriteHeight(idSprites[ind]);

            //Controllo se ho una sprite a sinistra di hero
            if (minXHero <= maxXSprite && minXHero >= maxXSprite - tolleranzaPixel)
            {
                if ((minYHero > minYSprite && minYHero <= maxYSprite - tolleranzaPixel)
                    || (maxYHero < maxYSprite && maxYHero >= minYSprite + tolleranzaPixel)
                    || (minYSprite <= minYHero && maxYSprite >= maxYHero)
                    || (minYSprite >= minYHero && maxYSprite <= maxYHero))

                    statiCollisione[0]=1;
            }

            //Controllo se ho una sprite sotto hero
            if (maxYHero >= minYSprite && maxYHero < minYSprite + tolleranzaPixel)
            {
                if ((minXHero > minXSprite && minXHero <= maxXSprite - tolleranzaPixel)
                    || (maxXHero < maxXSprite && maxXHero >= minXSprite + tolleranzaPixel)
                    || (minXSprite <= minXHero && maxXSprite >= maxXHero)
                    || (minXSprite >= minXHero && maxXSprite <= maxXHero))
                {
                    statiCollisione[1] = 1;
                    dbSprite(idSpriteHero, dbSpriteX(idSpriteHero), minYSprite - (maxYHero-minYHero), idSpriteHero);
                }

            }

            //Controllo se ho una sprite a destra di hero
            if (maxXHero >= minXSprite && maxXHero <= minXSprite + tolleranzaPixel)
            {
                if ((minYHero > minYSprite && minYHero <= maxYSprite - tolleranzaPixel)
                    || (maxYHero < maxYSprite && maxYHero >= minYSprite + tolleranzaPixel)
                    || (minYSprite <= minYHero && maxYSprite >= maxYHero)
                    || (minYSprite >= minYHero && maxYSprite <= maxYHero))

                    statiCollisione[2]=1;
            }            
        }
        ind++;
    }

    //return statiCollisione;
}

come vedi è molto simile a quello detto da te...ora devo ancora gestire le collisioni superiori (per quando salta), ma almeno fin qua sembra funzionare!!!!!!


EDIT:
OK..editato il codice, ora gestisco anche le collisioni superiori e sembra fungere!!!!!!