[TheFedex87]

Ciao ragazzi, ecco le prime vere domande "rottura" che inizio a porvi......
Allora mettiamo di volere realizzare un qualcosa di simile al vecchio ma sempre amatissimo Super Mario (EPICO)...Bene, da dove si parte??Ditemi se cio che vado a dire è corretto o sono solo un mare infinito di cagaxe...

Innanzitutto essendo perlappunto un 2D, tutto cio che a video (passatemi l'espressione) si muove lo dobbiamo gestire come sprite...Dico bene??A partire dal nostro "eroe", per passare ai nemici...Ora qui mi sorgonoi primi dubbi....Come cavolo faccio a muovere l'omino? A parte il gestire l'animazione della camminata, quello non dovrebbe essere complesso grazie ai metodi:
dbCreateAnimatedSprite
dbPlaySprite
Quello che non capisco è proprio come spostare la sprite...Infatti ci sarebbe il comodissimo comando dbMoveSprite, ma il suo funzionamento non sembra molto logico, infatti non permette di gestire il vettore di movimento, si muove sempre dal verso in cui è orientata la sprite, quindi per intenderci, se io volessi muovere la sprite da destra verso sinistra, o viceversa, sarei costretto prima a ruotare l'immagine di 90°, poi a usare il metodo dbMoveSprite...capite da soli che cio non ha molto senso, perchè mi ritroverei con la sprite del mio omino messa per orizzontale e non per verticale (come dovrebbe essere quando è normalmente in piedi). Quindi diciamo che già qui nascono i miei primi dubbi, poi ne ho anche altri, ma per ora vorrei chiarire questo punto...C'è qualche anima pia che mi sappia dare una mano??
Vi ringrazio in anticipo per ogni eventuale chiarimento...

[Zapetino]

Allora io ora non ho installato DarkGDK ma ti posso dare una mano(ho lavorato pochissimo con il 2d)
se non sbaglio ci sono due metodi: dbSpriteXposition e dbSpriteYposition o una cosa del genere......
basta assegnarli ad le variabili x ed y della sprite e fare per esempio:

Codice:

dbLoadSprite "Image/ciccio.png",1 //1= id della sprite
float X = dbSpritepositionX(1)
float Y = dbSpritepositionY(1)

if (dbRightKey()==1)//per muoversi a destra
{
X=+1
}
else
{
X=X
}
if (dbRightKey()==1)//per muoversi a sinistra
{
X=-1
}
else
{
X=X
}

[TheFedex87]

Allora io ora non ho installato DarkGDK ma ti posso dare una mano(ho lavorato pochissimo con il 2d)
se non sbaglio ci sono due metodi: dbSpriteXposition e dbSpriteYposition o una cosa del genere......
basta assegnarli ad le variabili x ed y della sprite e fare per esempio:

Codice:

dbLoadSprite "Image/ciccio.png",1 //1= id della sprite
float X = dbSpritepositionX(1)
float Y = dbSpritepositionY(1)

if (dbRightKey()==1)//per muoversi a destra
{
X=+1
}
else
{
X=X
}
if (dbRightKey()==1)//per muoversi a sinistra
{
X=-1
}
else
{
X=X
}

Intanto grazie per la risposta...però il problema è che non ho i 2 metodi da te suggeriti...Ci sono i metodi dbSpriteX e dbSpriteY, ma sono in sola lettura e ti restituiscono la posizione X,Y della sprite, ma non te la fanno settare...Guarando nella documentazione sono gli unici 2 metodi + vicini a quanto descritto da te...
Poi scusa una cosa, ma non mi è chiaro cio che hai scritto tu...Tu salvi la posizione X in una variabile, poi modifichi tale variabile, ma in questo modo come può la sprite effettivamente muoversi???

[Zapetino]

in effetti è una cosa buttata un po lì su due piedi senza pensare......
allora prova dbMoveSprite(1,10) per spostarti a destra e dbMovesprite(1,-10)per farlo a sinistra

[TheFedex87]

in effetti è una cosa buttata un po lì su due piedi senza pensare......
allora prova dbMoveSprite(1,10) per spostarti a destra e dbMovesprite(1,-10)per farlo a sinistra

Il problema è proprio questo....Se gli passo 10 o -10, lui si muove dal verso della sprite...Mi spiego meglio, all'inizio quando carico l'immagine questa non ha rotazione. Quindi se io faccio un dbMoveSprite, questa si muove o in su (-10) o in giù(10), mentre se voglio farla muovere a destra o a sinistra dovrei fare prima un dbRotateSprite(1,90), allora si muove a destra(10) o a sinistra(-10), ma non mi va bene perchè chiaramente non può ruotarmi l'immagine!!!! Allora ho anche pensato di ruotare l'immagine del personaggio io, cioè appena si apre sta ruotato in orizzontale, poi passandogli dbRotateSprite la ruoto di 90° (in modo che a quel punto ho l'immagine in verticale, e dbMoveSprite me la muove a destra o sinistra), ma non va bene di nuovo perchè non potrei comunque gestire l'omino che salta...

---

Ok ragazzi, dovrei avere trovato la soluzione al problema, sembra funzionare e si riesce a gestireanche il salto, vi riporto il codice nel caso qualcuno ne abbia bisogno:

Codice:

if ( dbRightKey())
{    
    dbRotateSprite(3,90);
    dbMoveSprite(3,3);
    dbRotateSprite(3,0);
}
if ( dbLeftKey())
{    
    dbRotateSprite(3,90);
    dbMoveSprite(3,-3);
    dbRotateSprite(3,0);
}

Ci sentiamo presto...

[steve]

Premetto che non ho mai usato ne darkbasic ne darkgdk, quindi è possibile (se non probabile) che ti stia per dire un sacco di boiate XD
Guardando la documentazione online mi pare di aver capito che c'è più di una funzione per spostare gli sprite, prova con questa: void dbSprite ( int iSprite, int iX, int iY, int iImage )
Prova a fare qualcosa del genere (abbozzo un po' di codice pur non conoscendo darkgdk, è facile che ci siano errori, ma l'importante è capire il concetto)

Codice PHP:

// bla bla bla
dbLoadSprite "Image/ciccio.png",1 //1= id della sprite
int speed = 5; // costante di movimento (1 passo = 5 pixel)
// main loop per refreshare
// bla bla bla
if (dbRightKey()==1)//per muoversi a destra
{
    dbSprite(1, dbSpritepositionX(1) + speed, dbSpritepositionY(1), 1);
}
// else if (altri tasti)
// bla bla bla 


[TheFedex87]

Premetto che non ho mai usato ne darkbasic ne darkgdk, quindi è possibile (se non probabile) che ti stia per dire un sacco di boiate XD
Guardando la documentazione online mi pare di aver capito che c'è più di una funzione per spostare gli sprite, prova con questa: void dbSprite ( int iSprite, int iX, int iY, int iImage )
Prova a fare qualcosa del genere (abbozzo un po' di codice pur non conoscendo darkgdk, è facile che ci siano errori, ma l'importante è capire il concetto)

Codice PHP:

// bla bla bla
dbLoadSprite "Image/ciccio.png",1 //1= id della sprite
int speed = 5; // costante di movimento (1 passo = 5 pixel)
// main loop per refreshare
// bla bla bla
if (dbRightKey()==1)//per muoversi a destra
{
    dbSprite(1, dbSpritepositionX(1) + speed, dbSpritepositionY(1), 1);
}
// else if (altri tasti)
// bla bla bla 


Si, infatti hai ragione, mi sono accorto poco fa che richiamando la stessa funzione che visualizza le sprite (dbSprite), e ripassandogli lo stesso indice ma con posizioni differenti si ottiene lo spostamento...TY comunque...

Ragazzi ora vorrei chiedervi altre cose....Allora come gestire il terreno dove l'omino cammina?? Io per ora ho pensato fare così: ho preso da internet il disegno di un mattone, poi ho generato tante sprite ognuna larga quanto il mattone. Ho dovuto fare cos' perchè altrimenti non avrei un riscontro di quando ad esempio l'omino passa sopra un buco e quindi dovrebbe cadere...Invece essendo anche queste sprite, ho la funzione dbSpriteCollision, e quindi so che se questa funzione mi restituisce 0 l'omino non sta toccando nessuna sprite(comprese le sprite del terreno perlappunto) e quindi so che sta precipitando...secondo voi ha senso la cosa??

[steve]

Il tuo metodo funziona sicuramente funzionerà, ma non so quanto possa essere pratico...
Leggendo su internet noto che dbSpriteCollision() utilizza il bounding rectangle, ma esiste anche dbSpriteHit() che usa (da quel che ho capito) la per-pixel. Prova a darci un occhiata.

[TheFedex87]

Guarda, avevo già visto che c'era sia la dbSpriteCollision che la dbSpriteHit, ma ti dico la verità non avevo capito la differenza, anzi grazie per avermela fatta capire...

Il problema è che non sono convinto di come sto cercando di gestire le cose...Purtroppo si riscontrano dei grossi problemi che non so come superare...Ho anche googlato ma non sono riuscito a venirne a capo...Ora cerco di spiegarvi:

Vi posta questa immagine così riesco a farmi capire meglio



Quello che ho fatto io è stato di controllare se il mio omino è a contatto con qualcosa, se ottengo che è a contatto con le sprite dei muri del terreno non faccio nulla, altrimenti se arrivo in una buca ottengo che dbSpriteCollision non mi da risultati quindi so che l'omino sta cadendo, per fare cio ho semplicemente scritto:

Codice:

int risColl = dbSpriteCollision(3, 0);
if ((risColl == 0 || risColl==1) && !jumping)
{
    dbMoveSprite(3, -5);
}

Fin qui sembra che la cosa, con qualche accorgimento possa funzionare...Il problema sorge quando arriviamo in corrispondenza del blocco 6, li, attraverso questo codice:

Codice:

if ( dbRightKey())
{    
    bool collisione=false;
    int risColl = dbSpriteCollision(3, 0);
    if (risColl !=0)
    {
        int xH=dbSpriteX(3);        
        if (dbSpriteX(3) < dbSpriteX(risColl) && dbSpriteY(risColl) < dbSpriteY(3)+dbSpriteHeight(3))
            collisione=true;
    }

    if (collisione==false)
    {
        dbRotateSprite(3,90);
        dbMoveSprite(3,3);
        dbRotateSprite(3,0);
    }

}

Volevo fare in modo che si bloccasse in corrispondenza di quel blocco...Il problema è questo:
la funzione dbSpriteCollision (e anche la dbSpriteHit), restituiscono una sola collisione per volta, dando la priorità alla sprite generata per prima, quindi quando sono in collisione con il blocco 6, lo sono anche con il 5, e la funzione mi restituisce l'indice 5 non facendosi avverare le condizioni scritte nel codice sopra e quindi l'omino non si ferma ...Non so se sono riuscito a farmi capire, ma prorio non riesco a venirne fuori...Forse sono totalmente fuori strada con il metodo di gestione che ho adottato...
Sapreste dirmi qualcosa sul problema che ho esposto, o un consiglio su un'altra soluzione da adottare per gestire i terreni dove l'omino cammina??

[steve]

Mi sembra di aver capito che la funzione dbSpriteCollision funzioni così:
bool dbSpriteCollision(int sprite1, int sprite2)
{
// se collide: return 1;
// se non collide: return 0;
}

Correggimi se sbaglio, non ho trovato la reference su internet (tu da dove la prendi?). Se è vero quello che ho scritto sopra, dovrebbe andar bene un codice simile (ti ricordo che sto perlopiù tirando a indovinare):

Codice PHP:

// omino/mario da muovere
dbLoadSprite "Image/ciccio.png",100
dbSprite(100, posX, posY, 100);
// carico e posiziono i primi 5 cubetti
int x; // numro del cubetto
for(x=0; x<5; x++)
{
dbLoadSprite "Image/mattone.png", x;
dbSprite(x, x*dbSpriteWidth(x), altezza_terreno, x);
}
// carico il sesto cubetto, lo posiziono dove l'hai messo tu
x++
dbLoadSprite "Image/mattone.png", x;
dbSprite(x, x*dbSpriteWidth(x), altezza_terreno+dbSpriteHeight(x), x);
// verifico se collide con il terreno (collisione orizzontale) // sarebbe più opportuno dividere collisioni nord sud est ovest, ma semplifico
int collisione_terreno=false;
for(int y=0; y<5; y++) if(dbSpriteCollision(100, y)) collisione_terreno=true;
// verifico se collide con le pareti (collisione verticale)
int collisione_parete=false;
if(dbSpriteCollision(100, 5) collisione_parete=true;
// movimenti
if(!collisione_terreno) dbMoveSprite(100,5); // se non collide con il terreno: precipita
if(dbRightKey() && !collisione_parete) dbSprite(100, dbSpritepositionX(100) + 5, dbSpritepositionY(100), 100); 


Il codice probabilmente è sbagliato, però la logica credo che si capisca.

[TheFedex87]

Mi sembra di aver capito che la funzione dbSpriteCollision funzioni così:
bool dbSpriteCollision(int sprite1, int sprite2)
{
// se collide: return 1;
// se non collide: return 0;
}

Correggimi se sbaglio, non ho trovato la reference su internet (tu da dove la prendi?). Se è vero quello che ho scritto sopra, dovrebbe andar bene un codice simile (ti ricordo che sto perlopiù tirando a indovinare):

Codice PHP:

// omino/mario da muovere
dbLoadSprite "Image/ciccio.png",100
dbSprite(100, posX, posY, 100);
// carico e posiziono i primi 5 cubetti
int x; // numro del cubetto
for(x=0; x<5; x++)
{
dbLoadSprite "Image/mattone.png", x;
dbSprite(x, x*dbSpriteWidth(x), altezza_terreno, x);
}
// carico il sesto cubetto, lo posiziono dove l'hai messo tu
x++
dbLoadSprite "Image/mattone.png", x;
dbSprite(x, x*dbSpriteWidth(x), altezza_terreno+dbSpriteHeight(x), x);
// verifico se collide con il terreno (collisione orizzontale) // sarebbe più opportuno dividere collisioni nord sud est ovest, ma semplifico
int collisione_terreno=false;
for(int y=0; y<5; y++) if(dbSpriteCollision(100, y)) collisione_terreno=true;
// verifico se collide con le pareti (collisione verticale)
int collisione_parete=false;
if(dbSpriteCollision(100, 5) collisione_parete=true;
// movimenti
if(!collisione_terreno) dbMoveSprite(100,5); // se non collide con il terreno: precipita
if(dbRightKey() && !collisione_parete) dbSprite(100, dbSpritepositionX(100) + 5, dbSpritepositionY(100), 100); 


Il codice probabilmente è sbagliato, però la logica credo che si capisca.

Scusa se rispondo solo ora, allora; intanto ti dico che è come dici te, utilizzando al funzione come da te descritto
dbSpriteCollision(int SP1, int SP2) restituisce 0 se nn collide 1 se collide, mentre utilizzando la funzione
dbSpriteCollision(int SP1, 0) restituisce l'ID della sprite con la quale SP1 sta collidendo...Ma qui nasceva il mio problema in quanto se c'è più di una collisione ne restituisce solo e soltanto 1...
Comunque il codice da te riportate dovrebbe funzionare, ma c'è un problema, facendo così, tu sei costretto ad effettuare un controllo, in ogni momento, con tutte le sprite che ci sono nel livello, e non solo, sei anche costretto a differenziare i mattoni del pavimento da quelli del muro...alla fine fatto così diventa troppo elaborata la gestione...
Hai qualche consiglio su come poter gestire le cose differentemente??


EDIT: ah comunque io le reference le prendo dalla documentazione del DarkGDK che mi ha intallato lui stesso...

[steve]

dbSpriteCollision(int SP1, int SP2) restituisce 0 se nn collide 1 se collide, mentre utilizzando la funzione
dbSpriteCollision(int SP1, 0) restituisce l'ID della sprite con la quale SP1 sta collidendo...Ma qui nasceva il mio problema in quanto se c'è più di una collisione ne restituisce solo e soltanto 1...
Comunque il codice da te riportate dovrebbe funzionare, ma c'è un problema, facendo così, tu sei costretto ad effettuare un controllo, in ogni momento, con tutte le sprite che ci sono nel livello, e non solo, sei anche costretto a differenziare i mattoni del pavimento da quelli del muro...alla fine fatto così diventa troppo elaborata la gestione...
Hai qualche consiglio su come poter gestire le cose differentemente??


EDIT: ah comunque io le reference le prendo dalla documentazione del DarkGDK che mi ha intallato lui stesso...

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.

[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!!!!!!

[steve]

Complimenti!
Volendo avresti potuto accorciare il codice visto hai già una funzione che ti verifica la presenza di collisioni, avresti potuto sfruttarla.
Io avrei dedicato (per esempio) gli id dal 2 al 999 per i nemici (1 è il pg), dal 1000 al 1999 per i pavimenti, dal 2000 al 2999 per i soffitti e dal 3000 al 5000 per i muri.
Poi bastava una cosa del genere (abbozzo tutto senza ide, quindi è facile che ci siano errori):

Codice PHP:

bool collisioneDw(int max) // max è il numero di mattoni del pavimento
{
for(int x=1000; 1000+max; x++) if(dbSpriteCollision(1,x)) return 1;
return 0;
}

bool collisioneUp(int max) // max è il numero di mattoni del soffitto
{
for(int x=2000; 2000+max; x++) if(dbSpriteCollision(1,x)) return 1;
return 0;
}

bool collisioneDx(int max) // max è il numero di mattoni delle pareti
{
for(int x=3000; 3000+max; x++) 
{
if(dbSpriteCollision(1,x))
{
if(dbSpriteX(1) < dbSpriteX(x)) return 1;
}
}
return 0;
}

bool collisioneSx(int max) // max è il numero di mattoni delle pareti
{
for(int x=3000; 3000+max; x++) 
{
if(dbSpriteCollision(1,x))
{
if(dbSpriteX(1) > dbSpriteX(x)) return 1;
}
}
return 0;
} 


[TheFedex87]

Complimenti!
Volendo avresti potuto accorciare il codice visto hai già una funzione che ti verifica la presenza di collisioni, avresti potuto sfruttarla.
Io avrei dedicato (per esempio) gli id dal 2 al 999 per i nemici (1 è il pg), dal 1000 al 1999 per i pavimenti, dal 2000 al 2999 per i soffitti e dal 3000 al 5000 per i muri.
Poi bastava una cosa del genere (abbozzo tutto senza ide, quindi è facile che ci siano errori):

Codice PHP:

bool collisioneDw(int max) // max è il numero di mattoni del pavimento
{
for(int x=1000; 1000+max; x++) if(dbSpriteCollision(1,x)) return 1;
return 0;
}

bool collisioneUp(int max) // max è il numero di mattoni del soffitto
{
for(int x=2000; 2000+max; x++) if(dbSpriteCollision(1,x)) return 1;
return 0;
}

bool collisioneDx(int max) // max è il numero di mattoni delle pareti
{
for(int x=3000; 3000+max; x++) 
{
if(dbSpriteCollision(1,x))
{
if(dbSpriteX(1) < dbSpriteX(x)) return 1;
}
}
return 0;
}

bool collisioneSx(int max) // max è il numero di mattoni delle pareti
{
for(int x=3000; 3000+max; x++) 
{
if(dbSpriteCollision(1,x))
{
if(dbSpriteX(1) > dbSpriteX(x)) return 1;
}
}
return 0;
} 


si si..tranqui è già tutto predisposto...1 è il BG, dal 100 al 999 i muri, dal 1000 in avanti i nemici!!!! TY, sei davvero gentile...ci risentiamo presto!!!!

[Zapetino]

scusate leggo solo ora XD grazie di avermi sostituito steve non avrei atto di meglio

[TheFedex87]

E rieccomi qua!!!!!! Stavolta vi chiedo un consiglio su come effettuare lo scrolling video...Io l'unico modo che ho pensato (e forse l'unico possibile...boh) è di muovere ogni singola sprite dello schermo inbase alla direzione di movimento...Cioè se ora quando premo tasto destro o sinistro passo il comando di movimento omino:
dbSpriteMove(idHeroSprite, vel),
per lo scrolling farei una cosa di questo tipo:

Codice:

for (int i = minIndSpriteWall; i <= maxIndSpriteWall; i++)
  dbSpriteMove(i, vel)

Secondo voi è corretto agire in questa maniera?? Si potrebbero adottare soluzioni più efficienti?? È un codice troppo pesante che potrebbe creare problemi?? In fin dei conti per creare un intero livello ci vanno centinaia e centinaia di sprite, e ogni volta bisognerebbe ciclarsele tutte per spostarle!!!!!! Boh, non mi rendo conto se possa essere un problema...consigli??

OT: ma mi dite che cosa sono quei 2 piccoli oggetti che vedo vicino ad alcuni utenti?? Intendo il quadrifoglio e il tao...a che cosa servono???

[Zapetino]

secondo me è troppo pesante come sistema se aspetti un po mi riscarico dark gdk e vedo di provare un po di sistemi .............anzi cerco la documentazione e vedo di darti una mano da lì

[steve]

Visto che hai un motore grafico 3d suppongo (poi è da verificare) che si possa sfruttare anche nel 2d. Il tuo modo è più orientato al 2d classico, e va bene.
Renderizzare il 2d non richiede molto tempo, quindi per quanto ti possa sembrare un lavoro concettualmente lungo, il computer lo fa in un attimo.

OT: https://www.making-videogames.net/giochi/...ction=shop

---

secondo me è troppo pesante come sistema se aspetti un po mi riscarico dark gdk e vedo di provare un po di sistemi .............anzi cerco la documentazione e vedo di darti una mano da lì

Se è contenuta in un solo file me la posti sul forum? Ogni tanto per aiutare qualcuno provo a documentarmi sul web, ma non si trova praticamente niente.

[TheFedex87]

Visto che hai un motore grafico 3d suppongo (poi è da verificare) che si possa sfruttare anche nel 2d. Il tuo modo è più orientato al 2d classico, e va bene.
Renderizzare il 2d non richiede molto tempo, quindi per quanto ti possa sembrare un lavoro concettualmente lungo, il computer lo fa in un attimo.

ecco qua il file con la documentazione del Dark GDK come chiedevi...
http://www.megaupload.com/?d=E91QC6V0
Comunque sto provando ad implementarlo, ma mi sembra troppo pesante come sistema...

[steve]

ecco qua il file con la documentazione del Dark GDK come chiedevi...
http://www.megaupload.com/?d=E91QC6V0
Comunque sto provando ad implementarlo, ma mi sembra troppo pesante come sistema...

Purtroppo il file non funziona, probabilmente c'è altra roba che mi devi passare. No problem, tanto non è niente di indispensabile...
Prova a farlo, vedrai che non ci saranno problemi di velocità, sono solo sprite

[TheFedex87]

Purtroppo il file non funziona, probabilmente c'è altra roba che mi devi passare. No problem, tanto non è niente di indispensabile...
Prova a farlo, vedrai che non ci saranno problemi di velocità, sono solo sprite

Vai sulle propeietà del file, e clikka annulla blocco...dovrebbe funzionarti dopo....
Comunque finisco di implementarlo e ti faccio sapere...

[steve]

Perfetto, grazie mille

[TheFedex87]

Ciao raga...allora steve, ti informo che avevi ragione!!!!! Ho fatto come dicevo l'altro giorno per lo scrolling video, e sembra funzionare piuttosto bene...Sono ad un buon punto ora...Devo aggiungere i nemici e qualche oggetto nel livello, poi posso presentarvi il primo livello....Ci sentiamo presto...

[Alche]

non vedo l'ora che esca il primo livello ^^
sono curioso di vedere come è xD

[Jonathan Archer]

E rieccomi qua!!!!!! Stavolta vi chiedo un consiglio su come effettuare lo scrolling video...Io l'unico modo che ho pensato (e forse l'unico possibile...boh) è di muovere ogni singola sprite dello schermo inbase alla direzione di movimento...Cioè se ora quando premo tasto destro o sinistro passo il comando di movimento omino:
dbSpriteMove(idHeroSprite, vel),
per lo scrolling farei una cosa di questo tipo:

Premetto che io uso DBPro e non GDR tuttavia i concetti son quelli. Io penso che caricare il gioco con 5000 sprite (un livello piuttosto corto direi) bisognerebbe automatizzare meglio il codice. Mi spiego meglio:

Se non ricordo male nelle prime versioni di Mario lui si muoveva soltanto verso destra e non verso sinistra impossibilitandoti a tornare indietro. La proposta é questa:

Ammettiamo di riservare degli ID ai singoli personaggi/oggetti:
Sprite di Mario: 1-100
Sprite dei nemici: 101-200
Sprite terreno: 201-1000
Sprite zone sospese: 1000-2000

La cosa più ovvia che abbiamo esposto per muovere la scena é lasciar fermo il personaggio (come nel vecchio gioco). Lo sprite di Mario si aggiorna, nel senso che da la sensazione della corsa, in realtà é la mappa che si muove.

Tramite FOR e NEXT puoi far in modo di processare (spostare verso sinistra di 1) tutti gli ID del terreno e delle zone sospese in pochissime righe di codice, tenendo ovviamente in considerazione quando Mario si muove o meno.

Tutti gli sprite (indistintamente) che escono dalla scena (sulla sinistra) ovvero che hanno una posizione 0 sottratta quella della propria larghezza vengono cancellati per alleggerire il gioco (sempre usando FOR e NEXT) dato che il personaggio non torna indietro.

Se poi vuoi ulteriormente alleggerire il carico anche della VGA puoi optare per gli sprite compressi (richiedono una scheda video compatibile)

[TheFedex87]

Premetto che io uso DBPro e non GDR tuttavia i concetti son quelli. Io penso che caricare il gioco con 5000 sprite (un livello piuttosto corto direi) bisognerebbe automatizzare meglio il codice. Mi spiego meglio:

Se non ricordo male nelle prime versioni di Mario lui si muoveva soltanto verso destra e non verso sinistra impossibilitandoti a tornare indietro. La proposta é questa:

Ammettiamo di riservare degli ID ai singoli personaggi/oggetti:
Sprite di Mario: 1-100
Sprite dei nemici: 101-200
Sprite terreno: 201-1000
Sprite zone sospese: 1000-2000

La cosa più ovvia che abbiamo esposto per muovere la scena é lasciar fermo il personaggio (come nel vecchio gioco). Lo sprite di Mario si aggiorna, nel senso che da la sensazione della corsa, in realtà é la mappa che si muove.

Tramite FOR e NEXT puoi far in modo di processare (spostare verso sinistra di 1) tutti gli ID del terreno e delle zone sospese in pochissime righe di codice, tenendo ovviamente in considerazione quando Mario si muove o meno.

Tutti gli sprite (indistintamente) che escono dalla scena (sulla sinistra) ovvero che hanno una posizione 0 sottratta quella della propria larghezza vengono cancellati per alleggerire il gioco (sempre usando FOR e NEXT) dato che il personaggio non torna indietro.

Se poi vuoi ulteriormente alleggerire il carico anche della VGA puoi optare per gli sprite compressi (richiedono una scheda video compatibile)

Ciao, intanto grazie dei pareri...comunque è proprio cio che ho già fatto.......solo che ho dato anche la possibilità di tornare indietro facendo si che le sprite ritornino visibili all'avvicinarsi di 0...e la stessa cosa l'ho gestita anche sulla destra, rendendo visibili solo le sprite al disotto di una certaquota X...Tutto cio mi alleggerisce anche la gestione delle collisioni, in quanto faccio il controllo solo sulle sprite attualmente visibili, in quanto sono certo che solo con quelle hero può collidere....
Comunque appena trovo un attimo di tempo carico su la gestioni di qualche nemico ed il primo livello dovrebbe essere pronto...Poi per come l'ho stutturato, gestire e creare + livelli non dovrebbe essere un problema in quanto tutto il livello, viene caricato da una matrice...Non se se è chiaro cio che intendo...

[steve]

Non penso che ci sia un gran guadagno in prestazioni rendendo invisibili gli sprite fuori schermo, si suppone che ci pensi già l'engine a fare queste ottimizzazioni (almeno... per ogre è cosi, sia nel 2d che nel 3d). Però effettivamente con questo metodo puoi diminuire notevolmente i controlli sulle collisioni.

Per matrice intendi un array multidimensionale?

[TheFedex87]

Non penso che ci sia un gran guadagno in prestazioni rendendo invisibili gli sprite fuori schermo, si suppone che ci pensi già l'engine a fare queste ottimizzazioni (almeno... per ogre è cosi, sia nel 2d che nel 3d). Però effettivamente con questo metodo puoi diminuire notevolmente i controlli sulle collisioni.

Per matrice intendi un array multidimensionale?

esatto...per farti capire meglio ti posto uno screenshot:


Praticamente modificando questa matrice modifico il livello di gioco...Gli '#' rappresentano i muri, le 'a' rappresentano i nemici numero 1, e via dicendo...

[ossen97]

wooow come hai fatto!?