Forum de Ti-Gen.org, le site francophone des TI

Bienvenue Invité ! Se connecter Mes sujets	Administrer
Utilisateurs actifs : Aucun membre + 1 visiteur

Avant de poster sur le forum, il y a des régles de bases à respecter pour une bonne entente et un respect de tous.
Veuillez lire la charte du forum.

:: Index » Forum Ti68K » Programmation C » stocker des sprites (10 réponse(s))

./POST DE DEPART (post n°0) Marquer comme non lu.

Xantares

Ecrit le: Vendredi 14 juillet 2006 à 22:31

Membre: Habitué

Messages: 63

Membre n°875

Inscrit le 09 juin 2005

bonjour

j'ai plusieurs sprites, avec pour chacune 4 exemplaires pour les 4 orientations possibles

je déclare :

typedef unsigned char sprite[8]

(sprites 8 par

j'ai besoin d'un tableau pour les n sprites avec chacunes leur 4 sens :

sprite model[n][4]

je voudrais directement assigner une sprite
alors je fais :

model[1][0]={
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000};

mais là le compilo le prend pas

mais si je déclare une sprite avec

static unsigned char spr1[]={
0b00000000
...
0b00000000};

et que je la copie :

memcpy(model[1][0],spr1,sizeof(sprite));

là ca marche

pourquoi le compilo ne veut pas prendre la premiere affectation ?

./Post n°1 Marquer comme non lu.

Onur

Ecrit le: Samedi 15 juillet 2006 à 00:20

Membre: Maître Ultime

Groupe: Orage Studio

Messages: 1604

Membre n°341

Inscrit le 02 juillet 2004

les = { ... } sont utilisés uniquement pour l'initialisation au moment de la déclaration.

Si tu veux faire des agrégats du genre
tableau[2..5] = (4,53,98,42);

il faut faire du Ada.

Je ne veux pas faire quelque chose de bien, je cherche l'excellence:ETP Studio...

et autres projets à finir avant 2010

./Post n°2 Marquer comme non lu.

Onur

Ecrit le: Samedi 15 juillet 2006 à 00:21

Membre: Maître Ultime

Groupe: Orage Studio

Messages: 1604

Membre n°341

Inscrit le 02 juillet 2004

en fait, le compilo reserve de la place statique avec ce que tu as mis entre les accolades.
les agrégats en Ada cachent du memcpy derriere.

sinon... tetris?

regarde comment a fait yuri pour les déclarer statiquement et réussir à utiliser un tableau virtuel pour y acceder avec des indices

http://www.ticalc.org/archives/files/fileinfo/192/19239.html
-Edité le Samedi 15 juillet 2006 à 00:25 par Onur-
-Edité le Samedi 15 juillet 2006 à 00:26 par Onur-

Je ne veux pas faire quelque chose de bien, je cherche l'excellence:ETP Studio...

et autres projets à finir avant 2010

./Post n°3 Marquer comme non lu.

Jfg

Ecrit le: Samedi 15 juillet 2006 à 01:07

Administrateur

Groupe: Staff de Ti-Gen

Groupe: Orage Studio

Messages: 1260

Membre n°60

Inscrit le 23 février 2004

Xantares> Dans ton cas, je pense que tu devrais faire un tableau à 3 dimensions:
char tousMesSprites[nombreDeSprites][4][hauteurDesSprites] =
{ { { ... } } };

exemple d'initialisation de tableau de 3 dimensions:

char array3Dimensions[4][3][2] =
{
{{0,0}, {0,0}, {0,0}},
{{0,0}, {0,0}, {0,0}},
{{0,0}, {0,0}, {0,0}},
{{0,0}, {0,0}, {0,0}}
};

pour accéder à un sprite:
char* leSpriteQueJeVeux = tousMesSprites[numéroDuSprite][orientationDuSprite];
-Edité le Samedi 15 juillet 2006 à 01:10 par Jfg-

Kill Mario

./Post n°4 Marquer comme non lu.

geogeo

Ecrit le: Samedi 15 juillet 2006 à 01:56

Fondateur

Groupe: Staff de Ti-Gen

Groupe: Orage Studio

Messages: 4256

Membre n°3

Inscrit le 29 janvier 2004

des tableaux de pointeurs ça serait pas mieux ?

Webmaster du site.
Programmeur sur TI68K. Arkanoid, Nebulus, GFA-Basic.

Plus d'informations sur GFA-Basic (un langage Basic pour TI68K).
http://www.tigen.org/gfabasic

./Post n°5 Marquer comme non lu.

Kevin Kofler

Ecrit le: Samedi 15 juillet 2006 à 07:49

Administrateur

Groupe: Staff de Ti-Gen

Messages: 4814

Membre n°40

Inscrit le 08 février 2004

Xantares :
alors je fais :

model[1][0]={
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000};

mais là le compilo le prend pas

Normal, parce que la bonne syntaxe est:
memcpy(model[1}[0],(const unsigned char [n][4]){0b00000000,...},n*4*sizeof(unsigned char));

Mais ce n'est pas une bonne idée d'affecter des sprites comme ça, mieux vaut utiliser des pointeurs, parce que si tu fais des memcpy, tu copies les sprites pour rien!

Donc:
static const unsigned char spr1[]={
0b00000000
...
0b00000000};
const unsigned char (*model)[4]=spr1;
ou si tu veux:
const unsigned char (*model)[4]=(const unsigned char [n][4]){0b00000000,...};
(Les sprites sont constants, donc tu es censé les déclarer const.)

Membre de l'équipe de TIGCC: http://tigcc.ticalc.org
Mainteneur du portage Linux/Unix de TIGCC: http://tigcc.ticalc.org/linux/
Membre de l'équipe de CalcForge: http://www.calcforge.org:70/

Participez à la reprise de Ti-Gen!

./Post n°6 Marquer comme non lu.

Xantares

Ecrit le: Dimanche 16 juillet 2006 à 09:00

Membre: Habitué

Messages: 63

Membre n°875

Inscrit le 09 juin 2005

en fait ce que je voudrais : que une sprite de chaque soit assignée,

puis qu'ensuite les sprites symetyrique calculées

tout en pouvant y acceder par tableaux

pour l'instant ca marche mais je dois recopier les sprites statiques dans cette structure

au démarrage puis calculer les sprites dans les 3 autres sens ce qui fait que le programme est

très lent à démarrer

> jfg : ta solution implique d'initialiser tout le tableau je crois. mais 3/4 des sprites sont calculées après en fait donc ca me fait mettre plein de zeros...

> onur : j'ai essayé de comprendre le code du tetris.
je comprends pas du tout. les pieces sont pas les pieces normales declarées. il plante lorsqu'on essaye de tourner une piece.

-Edité le Dimanche 16 juillet 2006 à 13:51 par Xantares-

./Post n°7 Marquer comme non lu.

Onur

Ecrit le: Dimanche 16 juillet 2006 à 19:47

Membre: Maître Ultime

Groupe: Orage Studio

Messages: 1604

Membre n°341

Inscrit le 02 juillet 2004

En fait, il déclare des trucs à la suite:

int  figure0[FIG_H][FIG_H]= {
  {1,1,0,0},
  {1,1,0,0},
  {0,0,0,0},
  {0,0,0,0} };
int  figure1[FIG_H][FIG_H]= {
  {0,1,1,0},
  {1,1,0,0},
  {0,0,0,0},

(ces données ne sont pas au format que tu veux mais cest pour te montrer la méthode, donc tu peux pas faire de copier-coller)

Lui, il recopie sur un truc fig

copyFig(fig, &figure0[FIG_H*i]);

mais tu ne dois pas faire comme ca, ce n'est pas ce que tu veux (à moins que tu veuilles faire ton calcul de symétrie pendant l'execution), mais tu vois qu'il fait pointer au bon endroit avec l'astuce &figure0[FIG_H*i]);
Donc si toi tu déclares fig, avec

type_de_figure0** fig = &figure0;
...
sprite_actuel=fig[model][tour] ;

cela suppose bien sur que le compilo mette les figure0, figure1, etc.. dans l'ordre, les uns à la suite des ordres.

donc dans ton cas, ca revient à faire:

// remplacer les 0 par les valeurs
sprite model0_orientation1={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model0_orientation2={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model0_orientation3={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model0_orientation4={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model1_orientation1={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model1_orientation2={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
sprite model1_orientation3={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};

sprite model[][4]=(sprite**)&orientation1;

note: peut etre un truc du genre sprite* model[4] = .. est mieux, à tester.

edit: bon ca marche pas ce que j'ai écrit, mais cest pas loin, je te post le code correct au retour, je dois sortir là
-Edité le Dimanche 16 juillet 2006 à 20:02 par Onur-

Je ne veux pas faire quelque chose de bien, je cherche l'excellence:ETP Studio...

et autres projets à finir avant 2010

./Post n°8 Marquer comme non lu.

Jfg

Ecrit le: Dimanche 16 juillet 2006 à 21:01

Administrateur

Groupe: Staff de Ti-Gen

Groupe: Orage Studio

Messages: 1260

Membre n°60

Inscrit le 23 février 2004

Xantares :
puis qu'ensuite les sprites symetyrique calculées
tout en pouvant y acceder par tableaux

ah ok.
Du coup, je pense qu'il faudrait commencer par allouer assez de mémoire pour stoquer tout tes sprites dans les 4 directions.
Puis copier tout tes sprites dans le 1er quart de la mémoire allouée
Puis calculer les sprites symétriques verticalement du 1er quart dans le 2e quart
Puis calculer les sprites symétriques horizontalement de la 1ere motiée dans la 2e moitiée

Puis caster le pointeur vers la mémoire allouée en tableau à 3 dimensions pour pouvoir accéder facilement à chaque sprite.
-Edité le Dimanche 16 juillet 2006 à 21:02 par Jfg-

Kill Mario

./Post n°9 Marquer comme non lu.

Xantares

Ecrit le: Lundi 24 juillet 2006 à 11:49

Membre: Habitué

Messages: 63

Membre n°875

Inscrit le 09 juin 2005

oui j'ai finalement fait un peu comme ca :

typedef unsigned char sprite[8];

je reserve un

sprite model[6][4]

puis à l'initialisation je recopie avec des

memcpy(model[0][0],(sprite){
0b11100000,
0b10100000,
0b11100000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000},sizeof(sprite));

puis je les symetrise avec symbin(a,n) qui rend le symetrique binaire de a sur n bits

for(i=0;i<5;i++)
  {
    for(j=0;j<8;j++)
    {
      model[1][j]=symbin(model[i][0][j],;
      model[i][2][j]=model[i][0][7-j];
      model[i][3][j]=symbin(model[i][0][7-j],;
    }
  }

là pas besoin de pointeurs
merci à vous
[i]-Edité le Lundi 24 juillet 2006 à 11:50 par Xantares-

./Post n°10 Marquer comme non lu.

Kevin Kofler

Ecrit le: Lundi 24 juillet 2006 à 16:37

Administrateur

Groupe: Staff de Ti-Gen

Messages: 4814

Membre n°40

Inscrit le 08 février 2004

Tu es censé mettre (const sprite){...}, pas (sprite){...}. (Sinon, selon le standard C99, le compilateur est obligé de recopier tes données, ce qui est débile vu que le memcpy les recopie une autre fois. TIGCC ne le fait pas actuellement, mais ça pourrait changer un jour.)