Pr Pim89 : RPG - Page 1

Voilà tu me demandais pour les déplacements.

Bon tu as plusieurs possibilités, évidement si tu utilise les coordonées du sprites pour aller dans la matrice, comme ce que tu disais, y'a 9 chances sur 10 pour tomber 'entre 2 coordonnées'...

Donc, il y a plusieurs solutions. La plus simple, utilisée dans DarkHole et CMS2, consiste à diviser les coordonnées du sprite par la taille de tes 'tiles' (voir definition de liquid).

Prenons un exemple simple : le perso, situé en 0,0, va se déplacer en 15,15 Et bien si sur l'écran ça correspond à un déplacement de 15 pixels, dans la matrice si tu divise par 16 tu retombera sur des bonnes coordonnées.

Perso en x=32,y=16 -> Mat[y/16,x/16].

Bon bien sur ça ne t'autorise que des déplacements en case par case, mais sinon c'est plus compliqué.

Si tu ne veux vraiment pas des déplacements case par case, il y a encore une solution pas trop compliquées, mais je trouve assez inutile, sinon pour le plaisir d'arreter son perso entre 2 cases

Il suffit que tu ailles chercher la matrice mat[perso_y/16,perso_x/16] en arondisant, de manière a ce que n'importe quelle position intermédiaire te rammene à la case de la matrice qui "correspond le plus" à ta position. Il faut aussi que tu empeche le perso d'aller à droite ou à gauche si il est entre 2 cases placées dans le sens de la hauteur, sinon c'est encore plus le bordel

Bon je n'ai pas l'impression d'avoir été très clair, mais je suis un peu fatigué, désolé, j'espere que ça répond quand même à ta question
[edit]Edité par Bob 64 le 09-02-2002 à 19:55:11[/edit]

autre solution pour les deplacements pixel par pixel:
si tu vas vers le haut tu prends le coin haut gauche et le coin haut droite de ton perso (xg,yg) et (xd,yd) tu divises par 16 et tu gardes la partie entiere....tu regardes si en te deplacant vers le haut ces deux coordonnées de case (xgc,ygc) et (xdc,ydc) vont sur une case de la matrice qui est un mur ou pas !

bon c pas tres clair donc si tu comprends tjs pas je te ferai un dessin

liquid > oui ça c exactement ma technique...

arretez de mettre un H à Darkhole, c une perte de temps

Wahou, un topic conçacré à mon effigie !!!!

Merci Bob et liquid, y'avait ce genre de petit truc que je comprenais pas, maintenant ça devrait aller mieux (car mon prob c'était que le bonhomme tombe souvent entre 2 case de la matrice, vu que c'est programmé en C, donc je suis pas obligé de faire du déplacement case par case pour que ce soit fluide).

En tout cas j'ai bien capté, merci !!!!


je reviendrais peut-être poser qq question ici de temps en temps sur ce fonctionnement RPG.

Ah oui, pour votre moteur sur l'affichage, vous faite quoi ????
Au début de la scène de déplacement, vous faite une boucle qui mettra tout l'affichage précisé dans la matrice_décor et vous placer le perso ensuite ??

ex :

Début_boucle

If mat[x,y]=0
Afficher Sprite_mur,x*10,y*6

If mat[x,y]=1
Afficher Sprite_maison,x*10,y*6

EndBoucle

Ou vous faite tout à la main :

Afficher Sprite_maison,0,30
Afficer Sprite_mur,0,10



Perso je prendrais la 1ère, car juste à partir de la matrice on fait tout mais peut-être que vous avez trouvé mieux ...

g pas compris ta question mais moi pour afficher une map je fais ça:
void mapaff(void)
{
unsigned short x,y;
ClearGrayScreen2B(virtu0,virtu1);
for (x=0;x<10;x++) {for(y=0;y<6;y++){GraySprite16_OR(x*16,y*16,16,w[wor[mapy*6+y][mapx*10+x][0]*2],w[wor[mapy*6+y][mapx*10+x][0]*2+1],virtu0,virtu1);}}
}


avec:
unsigned short wor [12][20][2]={ {{31},{31},{31},{31},{31},{31},{31},{31},{31},{31},{31},{171},{163},{173},{171},{172},{173},{171},{172},{173}}
,{{31},{8},{8},{171},{172},{173},{8},{8},{8},{8},{8},{174},{180},{176},{174},{166},{176},{174},{170},{176}}
,{{217},{84},{216},{174},{175},{176},{8},{8},{8},{8},{8},{168},{82},{179},{168},{82},{169},{168},{82},{169}}
,{{31},{216},{216},{177},{82},{179},{8},{8},{8},{8},{8},{250},{216},{216},{216},{8},{216},{8},{8},{250}}
,{{31},{8},{217},{217},{8},{217},{217},{8},{8},{8},{8},{8},{8},{8},{8},{8},{8},{217},{217},{8}}
,{{31},{8},{8},{8},{8},{8},{8},{8},{8},{8},{8},{216},{250},{250},{216},{8},{217},{217},{8},{8}}
,{{31},{8},{8},{8},{8},{8},{8},{8},{8},{8},{8},{145},{146},{147},{216},{8},{217},{217},{8},{8}}
,{{31},{8},{8},{8},{8},{8},{216},{216},{8},{250},{250},{148},{149},{150},{8},{8},{8},{8},{217},{8}}
,{{31},{8},{8},{8},{8},{8},{8},{8},{250},{250},{250},{152},{58},{152},{8},{8},{8},{8},{217},{8}}
,{{31},{216},{112},{8},{112},{8},{8},{216},{250},{250},{250},{8},{8},{8},{8},{250},{8},{216},{8},{216}}
,{{217},{216},{113},{8},{113},{217},{216},{250},{250},{250},{250},{8},{8},{8},{250},{84},{8},{8},{216},{8}}
,{{217},{217},{31},{31},{31},{216},{250},{250},{250},{250},{250},{250},{250},{250},{250},{8},{8},{216},{216},{216}}};


et:

unsigned short w[][16]={
{},//light
{},//dark

{ 0x0, 0x0, 0x3100, 0xA00, 0xA40, 0x208, 0xA, 0x8, 0x8000, 0x5000, 0x4020, 0x10, 0x194, 0x50, 0x0, 0x0},
{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},

{ 0x0, 0x2000, 0x3200, 0x1600, 0xC400, 0x6000, 0x0, 0x0, 0x0, 0x10, 0x19, 0xB, 0x62, 0x30, 0x0, 0x0},
{},

{},
{ 0xEC, 0x7EEF, 0x7EEF, 0x780F, 0x7BC0, 0x3DB, 0xDBDB, 0xDBDB, 0xDBC3, 0xD83B, 0xDDBB, 0x1B8, 0xFBBD, 0xFBBD, 0xFBBD, 0xFB01},

{},
{},

{ 0x0, 0xFFFF, 0x0, 0xDDDD, 0xDDDD, 0xDDDD, 0xDDDD, 0xDDDD, 0xDDDD, 0xDDDD, 0xDDDD, 0xDDDD, 0xDDDD, 0x0, 0xFFFF, 0x0},
{ 0xFFFF, 0x0, 0xFFFF, 0x2222, 0x2222, 0x2222, 0x2222, 0x2222, 0x2222, 0x2222, 0x2222, 0x2222, 0x2222, 0xFFFF, 0x0, 0xFFFF},

{ 0x5FFA, 0x4002, 0x5FFA, 0x5FFA, 0x5FFA, 0x4002, 0x5FFA, 0x5FFA, 0x5FFA, 0x4002, 0x5FFA, 0x5FFA, 0x5FFA, 0x4002, 0x5FFA, 0x5FFA},
{ 0xA005, 0xBFFD, 0xA005, 0xA005, 0xA005, 0xBFFD, 0xA005, 0xA005, 0xA005, 0xBFFD, 0xA005, 0xA005, 0xA005, 0xBFFD, 0xA005, 0xA005},

{ 0x0, 0x2020, 0x0, 0x202, 0x0, 0x4040, 0x204, 0x0, 0x0, 0x2020, 0x0, 0x102, 0x0, 0x4040, 0x404, 0x0},
{},

{ 0x0, 0x800, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0x2000, 0x4, 0x0, 0x0},
{},

{},
{ 0x180, 0x240, 0x420, 0x810, 0x1008, 0x2004, 0x4002, 0x8001, 0x8001, 0x4002, 0x2004, 0x1008, 0x810, 0x420, 0x240, 0x180},

{ 0x660, 0xC30, 0x1998, 0x324C, 0x6426, 0xC913, 0x9009, 0x2004, 0x2404, 0x9049, 0xC813, 0x6426, 0x324C, 0x1998, 0xC30, 0x660},
{ 0x990, 0x13C8, 0x2664, 0x4DB2, 0x9BD9, 0x36EC, 0x6FF6, 0xDFFB, 0xDBFB, 0x6FB6, 0x37EC, 0x9BD9, 0x4DB2, 0x2664, 0x13C8, 0x990},

{ 0xD34B, 0xD3DB, 0x9FF8, 0x7E6, 0xF3CF, 0xF819, 0xFBDB, 0xFBCE, 0xFBEB, 0xD809, 0x97ED, 0xF627, 0x65F0, 0xD99, 0xDFFB, 0xD66A},
{ 0x2CB4, 0x2C24, 0x6007, 0xF819, 0xC30, 0x7E6, 0x424, 0x431, 0x414, 0x27F6, 0x6812, 0x9D8, 0x9A0F, 0xF266, 0x2004, 0x2995},

{ 0xF01F, 0xCFE3, 0x3FF8, 0x7C3E, 0x6186, 0x4DB4, 0xADB5, 0xADB5, 0xADB5, 0xADB5, 0xB81D, 0x67E6, 0x1FFA, 0x381C, 0x67EE, 0x1FF0},
{ 0xFFFF, 0xF01F, 0xC007, 0x83C1, 0x9E79, 0xB24B, 0x524A, 0x524A, 0x524A, 0x524A, 0x47E2, 0x9819, 0xE005, 0xC7E3, 0x9FF1, 0xFFFF},

{ 0x8001, 0x6006, 0x6FF6, 0x6006, 0x6FF6, 0x6FF6, 0x6006, 0x6FF6, 0x6FF6, 0x6006, 0x6FF6, 0x6FF6, 0x6006, 0x6FF6, 0x6006, 0x8001},
{ 0x7FFE, 0x9FF9, 0x9009, 0x9FF9, 0x9009, 0x9009, 0x9FF9, 0x9009, 0x9009, 0x9FF9, 0x9009, 0x9009, 0x9FF9, 0x9009, 0x9FF9, 0x7FFE},

{},
{ 0x8001, 0x8001, 0xFFFF, 0xFFFF, 0x8001, 0x8001, 0xFFFF, 0xFFFF, 0x8001, 0x8001, 0xFFFF, 0xFFFF, 0x8001, 0x8001, 0xFFFF, 0xFFFF},

{},
{ 0xFFFF, 0xCCCC, 0xCCCC, 0xCCCC, 0xCCCC, 0xCCCC, 0xCCCC, 0xCCCC, 0xCCCC, 0xCCCC, 0xCCCC, 0xCCCC, 0xCCCC, 0xCCCC, 0xCCCC, 0xFFFF},

{},
{ 0xFFFF, 0x3333, 0x3333, 0x3333, 0x3333, 0x3333, 0x3333, 0x3333, 0x3333, 0x3333, 0x3333, 0x3333, 0x3333, 0x3333, 0x3333, 0xFFFF},

{},
{ 0xFFFF, 0xFFFF, 0x8001, 0x8001, 0xFFFF, 0xFFFF, 0x8001, 0x8001, 0xFFFF, 0xFFFF, 0x8001, 0x8001, 0xFFFF, 0xFFFF, 0x8001, 0x8001},

{},
{}};

oulà ...
je comprend les lignes de codes mais pas leur but ...

tu pourrais m'expliquer un peu plus le role de tes matrice stp (pourquoi déjà wor [12][20][2], pourquoi 3 indiquations pour la mat, C pas wor[x][y] qu'il faut mettre ?).

Ca fait que 6 jours que je programme en C, faut que je commence un peu pus doucement.

En fait tu as répondu à mes questions, mais avec un code trop optimisé pour moi pour débuter en C.


Merci !!!!!
[edit]Edité par Pim89 le 10-02-2002 à 11:37:47[/edit]

w[wor[mapy*6+y][mapx*10+x][0]*2]



bon: w[X] correspond à un pointage sur une chaine de sprite
wor[y][x][z] correpond au numero de la map, ne t'occupes pas du 3e indice, il ne sert pas ici

ah ok, je crois que je viens de comprendre ...

En fait tu as stocké tous tes codes de sprites dans une matrice pour pouvoir optimiser ton code lors de l'affichage ... nan ?

ben c imperatif en C, il faut faire ça tu as pas le choix

si, on peut définir tout à part, mais après faut rajouter des test et ça allourdi tout.
merci !

evidemment mais ça c de la programmation de nioobi

Bohhhh vous êtes partis dans vos délires sur le C moi j'abandonne

oui mais moi je suis un nioubi en C ...

Bah c déjà pas mal...

arf mais ça pas dur et puis qd ça marche pas moi je bidouille jusqu'a ce que ça marche

pkoi ??? t'as abandonné toi ???

C clair, les premiers jours t'arrive à presque rien fait de toi même (faut qq truc pompé sur le tuto de squale92), mais après qq temps (1 semaine) tu peux faire qq animation, mais moi y'a encore bcp de chose classique que je ne sais pas faire ...

Il me manque les INDIRECTION !!!!!!!

mais non c pas indispensable en C, tu fais des tableaux

je c po faire
et c'est pas expliqué ds le totu de squale

Et puis bon le basic quand je veux faire qq chose je le fait, alors qu'en C je passe 3 heures par lignes pour que ça marche correctement.

regarde mon post 6,il est pourtant clair

heu... ah bon ?
k je le copie, je regarderais ça calmement

arf, c tellement simple qu'en 2 min tu dois comprendre, donc regarde tt de suite

Mais... Je pense pas connaitre suffisement le C !

Ah si ok... Mais bon les indirection t'as pas besoin de tout rentrer à l'avance, et c'est bien là l'avantage !

Ah ok ça y est g tt comprit (ouééé) mais on dira ce qu'on voudra c quand même bien le bordel...

Ah oui au fait :
Quand on développe sous TIGCC, est-ce qu'il y a moyen de foutre ces lignes horribles dans un endroit à part, séparé du reste du code ?

bien sur

si tu définie tes matrice en dehors d'une fonction, bonjour la taille du programme ...

en basic ou en c ?

en C ... en BASIC ça change presque rien