(23-03-2011, 01:59 PM)Zapetino Ha scritto: 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
}

(23-03-2011, 03:25 PM)Zapetino Ha scritto: 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

(23-03-2011, 05:57 PM)steve Ha scritto: 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 


(23-03-2011, 10:02 PM)steve Ha scritto: 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.

(24-03-2011, 09:43 AM)TheFedex87 Ha scritto: 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...

(24-03-2011, 01:12 PM)steve Ha scritto: 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.

(24-03-2011, 01:48 PM)steve Ha scritto: 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;
} 


(25-03-2011, 04:17 PM)Zapetino Ha scritto: 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ì

(25-03-2011, 04:26 PM)steve Ha scritto: 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.

(25-03-2011, 04:52 PM)TheFedex87 Ha scritto: 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...

(25-03-2011, 05:06 PM)steve Ha scritto: 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

(25-03-2011, 09:26 AM)TheFedex87 Ha scritto: 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:

(03-04-2011, 10:26 AM)Jonathan Archer Ha scritto: 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)

(04-04-2011, 10:36 PM)steve Ha scritto: 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?