1. Accueil
  2. Forum Codes-Sources
  3. C / C++ / C++.NET
Sujet Précédent Sujet Suivant

Limite d'un pointeur Turbo C++ ?

Signaler
Messages postés
30
Date d'inscription
lundi 6 décembre 2004
Statut
Membre
Dernière intervention
21 juin 2005
 -
Messages postés
30
Date d'inscription
lundi 6 décembre 2004
Statut
Membre
Dernière intervention
21 juin 2005
 -
salut a tous j'ai un une question concernent les pointeurs, je compile avec turbo c++ 3.0

j'ai fait un tableau pour enregistrer mes sprites, mais j'ai l'impression que mon pointeur arrive a c'est limite. Si une bonne âme pouvait me guidé merci d'avance

je mais disposition une partie de mon code a qui voudra.

A++.

2 réponses

Réponse 1 / 2
Messages postés
933
Date d'inscription
dimanche 1 avril 2001
Statut
Membre
Dernière intervention
9 janvier 2012
 2
Salut,

Explique un peu plus ton problème car un pointeur contient une adresse mémoire donc je comprend pas trop.

@+
Arnotic,
Admin CS, MVP Visual C++
Réponse 2 / 2
Messages postés
30
Date d'inscription
lundi 6 décembre 2004
Statut
Membre
Dernière intervention
21 juin 2005
Salut Arnotic.

Voila je t'explique mon pb, je débute en prog ou presque j'aimerais faire un petit jeux,

comme je te l'ai dit, j'ai fait un tableau pour enregistrer mais sprite mais quand je fais trop de sprite mon prog ne se lance plus je te mais mon code (la fonction lir()enregistre les sprites, et la fonction Put() le sort sur l'ecran enfin je crois je reste a ta dispo si tu a des question.

#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <dos.h>
#include <stdlib.h>
#include <ctype.h>



#define Planche_X 8
#define Planche_Y 8
#define Largeur_X 32
#define Hauteur_Y 32
#define Carte_X 128
#define Carte_Y 128
#define CarteM_X 128
#define CarteM_Y 8
#define CarteMo_X 64
#define CarteMo_Y 64
#define CarteA_X 64
#define CarteA_Y 64
#define CarteB_X 64
#define CarteB_Y 64
#define CarteC_X 64
#define CarteC_Y 64
#define CarteD_X 64
#define CarteD_Y 64
#define Mont_X 32
#define Mont_Y 32
#define Monde_X 320
#define Monde_Y 200
#define Nuage_X 32
#define Nuage_Y 32
#define Perso_X 32
#define Perso_Y 60
#define Arb_X 32
#define Arb_Y 32
#define Arb2_X 32
#define Arb2_Y 32
#define Arb3_X 32
#define Arb3_Y 32
#define Barr_X 320
#define Barr_Y 36



struct Sprite
{
char* Graph;
int X;
int Y;
};


char* Bitmap;
Sprite Beast[25];
Sprite Fond[63];
Sprite Mont[63];
Sprite Arb1[63];
Sprite Arb2[63];
Sprite Arb3[63];
Sprite Statue[63];
Sprite Nuages[63];
Sprite Nuages1[63];
Sprite Nuages3[63];
Sprite Nuages4[63];
Sprite Nuages5[63];
Sprite Herbes1[63];
Sprite Herbes2[63];
Sprite Herbes3[63];
Sprite Herbes4[63];
Sprite Herbes5[63];
Sprite Barriere[63];



char* realscreen=(char*)(0XA0000000L);
char* fakescreen=new char[64000L];
unsigned char Carte[Carte_X][Carte_Y];
unsigned char CarteM[CarteM_X][CarteM_Y];
unsigned char CarteMo[CarteMo_X][CarteMo_Y];
unsigned char CarteA[CarteA_X][CarteA_Y];
unsigned char CarteB[CarteB_X][CarteB_Y];
unsigned char CarteC[CarteC_X][CarteC_Y];
unsigned char CarteD[CarteD_X][CarteD_Y];
unsigned char Planche[Planche_X][Planche_Y];


void cpyvirt(void)
{
memcpy(realscreen,fakescreen,64000L);
}


void ModeVGA()
{
_AX=0x13;
geninterrupt(0x10);
memset(fakescreen,0,64000L);
}


void GenPAL(char Index,char R,char G,char B)
{
outportb(0x3C8,Index);
outportb(0x3C9,R);
outportb(0x3C9,G);
outportb(0x3C9,B);
}



void PCX(char *nomfich, unsigned long taille,char *bitmap)
{
unsigned char data, nb_octets, palette[768];
unsigned long index = 0;
unsigned int index_rle;
FILE *pcxfile;
pcxfile = fopen(nomfich, "rb");
fseek(pcxfile, -768, SEEK_END);
fread(&palette, 768, 1, pcxfile);
for (int coul=0;coul<=255;coul++)
GenPAL(coul,palette[coul*3]>>2,palette[coul*3+1]>>2,palette[coul*3+2]>>2);
fseek(pcxfile, 128, SEEK_SET);
do
{
fread(&data, 1, 1, pcxfile);
if ((data & 0xC0) == 0xC0)
{
nb_octets = (data & 0x3F);
fread(&data, 1, 1, pcxfile);
for (index_rle=1; index_rle<=nb_octets; index_rle++)
bitmap[index++] = data;
}
else bitmap[index++] = data;
} while(index < taille);
fclose(pcxfile);
}


void Lir(unsigned VX,unsigned VY,unsigned Largeur,unsigned Hauteur,Sprite* sprite)
{
sprite->Graph=new char[Largeur*Hauteur];
for (int X=0;X<Largeur;X++)
for (int Y=0;Y<Hauteur;Y++)
sprite->Graph[Y*Largeur+X]=Bitmap[(VY+Y)*320+VX+X];
}



void PutPerso(int VX,int VY,Sprite* Beast)
{
int Neutre;
for (int X=0;XGraph[Y*Perso_X+X];
if (Neutre)fakescreen[(VY+Y)*320+VX+X]=Neutre;
}
}



void Put(int VX,int VY,Sprite* Fond)
{
int Neutre;
int Xdeb = 0;
int Ydeb = 0;
int Xfin = Largeur_X;
int Yfin = Hauteur_Y;
if (VX > Monde_X-Xfin) Xfin = Monde_X-VX;
if (VX < 0) Xdeb += -VX;
if (VY > Monde_Y-Yfin) Yfin = Monde_Y-VY;
if (VY < 0) Ydeb += -VY;


for (int X=Xdeb;X<Xfin;X++)
for (int Y=Ydeb;Y<Yfin;Y++)
{
Neutre=Fond->Graph[Y*Largeur_X+X];
if (Neutre)fakescreen[(VY+Y)*320+VX+X]=Neutre;
}
}



void PutMont(int VX,int VY,Sprite* Mont)
{
int Neutre;
int Xdeb = 0;
int Ydeb = 0;
int Xfin = Mont_X;
int Yfin = Mont_Y;
if (VX > Monde_X-Xfin) Xfin = Monde_X-VX;
if (VX < 0) Xdeb += -VX;
if (VY > Monde_Y-Yfin) Yfin = Monde_Y-VY;
if (VY < 0) Ydeb += -VY;


for (int X=Xdeb;X<Xfin;X++)
for (int Y=Ydeb;Y<Yfin;Y++)
{
Neutre=Mont->Graph[Y*Mont_X+X];
if (Neutre)fakescreen[(VY+Y)*320+VX+X]=Neutre;
}
}


void PutArb1(int VX,int VY,Sprite* Arb1)
{
int Neutre;
int Xdeb = 0;
int Ydeb = 0;
int Xfin = Arb_X;
int Yfin = Arb_Y;
if (VX > Monde_X-Xfin) Xfin = Monde_X-VX;
if (VX < 0) Xdeb += -VX;
if (VY > Monde_Y-Yfin) Yfin = Monde_Y-VY;
if (VY < 0) Ydeb += -VY;


for (int X=Xdeb;X<Xfin;X++)
for (int Y=Ydeb;Y<Yfin;Y++)
{
Neutre=Arb1->Graph[Y*Arb_X+X];
if (Neutre)fakescreen[(VY+Y)*320+VX+X]=Neutre;
}
}


void PutArb2(int VX,int VY,Sprite* Arb2)
{
int Neutre;
int Xdeb = 0;
int Ydeb = 0;
int Xfin = Arb2_X;
int Yfin = Arb2_Y;
if (VX > Monde_X-Xfin) Xfin = Monde_X-VX;
if (VX < 0) Xdeb += -VX;
if (VY > Monde_Y-Yfin) Yfin = Monde_Y-VY;
if (VY < 0) Ydeb += -VY;


for (int X=Xdeb;X<Xfin;X++)
for (int Y=Ydeb;Y<Yfin;Y++)
{
Neutre=Arb2->Graph[Y*Arb2_X+X];
if (Neutre)fakescreen[(VY+Y)*320+VX+X]=Neutre;
}
}


void PutArb3(int VX,int VY,Sprite* Arb3)
{
int Neutre;
int Xdeb = 0;
int Ydeb = 0;
int Xfin = Arb3_X;
int Yfin = Arb3_Y;
if (VX > Monde_X-Xfin) Xfin = Monde_X-VX;
if (VX < 0) Xdeb += -VX;
if (VY > Monde_Y-Yfin) Yfin = Monde_Y-VY;
if (VY < 0) Ydeb += -VY;


for (int X=Xdeb;X<Xfin;X++)
for (int Y=Ydeb;Y<Yfin;Y++)
{
Neutre=Arb3->Graph[Y*Arb3_X+X];
if (Neutre)fakescreen[(VY+Y)*320+VX+X]=Neutre;
}
}


void PutNu(int VX,int VY,Sprite* Nuages)
{
int Neutre;
int Xdeb = 0;
int Ydeb = 0;
int Xfin = Nuage_X;
int Yfin = Nuage_Y;
if (VX > Monde_X-Xfin) Xfin = Monde_X-VX;
if (VX < 0) Xdeb += -VX;
if (VY > Monde_Y-Yfin) Yfin = Monde_Y-VY;
if (VY < 0) Ydeb += -VY;


for (int X=Xdeb;X<Xfin;X++)
for (int Y=Ydeb;Y<Yfin;Y++)
{
Neutre=Nuages->Graph[Y*Nuage_X+X];
if (Neutre)fakescreen[(VY+Y)*320+VX+X]=Neutre;
}
}


void PutBarr(int VX,int VY,Sprite* Barriere)
{
int Neutre;
int Xdeb = 0;
int Ydeb = 0;
int Xfin = Barr_X;
int Yfin = Barr_Y;
if (VX > Monde_X-Xfin) Xfin = Monde_X-VX;
if (VX < 0) Xdeb += -VX;
if (VY > Monde_Y-Yfin) Yfin = Monde_Y-VY;
if (VY < 0) Ydeb += -VY;


for (int X=Xdeb;X<Xfin;X++)
for (int Y=Ydeb;Y<Yfin;Y++)
{
Neutre=Barriere->Graph[Y*Barr_X+X];
if (Neutre)fakescreen[(VY+Y)*320+VX+X]=Neutre;
}
}



void Map()
{
FILE *map;
map=fopen("Plan.map","rb");
for (int X=0;X<Carte_X;X++)
for (int Y=0;Y<Carte_Y;Y++)
Carte[Y][X]=fgetc(map);
}


void MapM()
{
FILE *map2;
map2=fopen("Mont.map","rb");
for (int X=0;X<CarteMo_X;X++)
for (int Y=0;Y<CarteMo_Y;Y++)
CarteMo[Y][X]=fgetc(map2);
}


void MapA()
{
FILE *mapA;
mapA=fopen("coup1.map","rb");
for (int X=0;X<CarteA_X;X++)
for (int Y=0;Y<CarteA_Y;Y++)
CarteA[Y][X]=fgetc(mapA);
}


void MapB()
{
FILE *mapB;
mapB=fopen("coup2.map","rb");
for (int X=0;X<CarteB_X;X++)
for (int Y=0;Y<CarteB_Y;Y++)
CarteB[Y][X]=fgetc(mapB);
}


void MapC()
{
FILE *mapC;
mapC=fopen("coup3.map","rb");
for (int X=0;X<CarteC_X;X++)
for (int Y=0;Y<CarteC_Y;Y++)
CarteC[Y][X]=fgetc(mapC);
}


void MapD()
{
FILE *mapD;
mapD=fopen("Plan2.map","rb");
for (int X=0;X<CarteD_X;X++)
for (int Y=0;Y<CarteD_Y;Y++)
CarteD[Y][X]=fgetc(mapD);
}


void Ini()
{


Bitmap=new char[64000L];
Map();
PCX("Arbres.pcx",64000L,Bitmap);
for (int X=0;X<10;X++)
for (int Y=0;Y<6;Y++)
Lir((Largeur_X*X),(Hauteur_Y*Y),Largeur_X,Hauteur_Y,&Fond[(Y*10)+X]);
//delete[] Bitmap;


{
//Bitmap=new char[64000L];
MapM();
PCX("Monta.pcx",64000L,Bitmap);
for (int X=0;X<10;X++)
for (int Y=0;Y<3;Y++)
Lir((Mont_X*X),(Mont_Y*Y),Mont_X,Mont_Y,&Mont[(Y*10)+X]);
//delete[] Bitmap;
}


{
//Bitmap=new char[64000L];
MapA();
PCX("Coup1.pcx",64000L,Bitmap);
for (int X=0;X<10;X++)
for (int Y=0;Y<6;Y++)
Lir((Arb_X*X),(Arb_Y*Y),Arb_X,Arb_Y,&Arb1[(Y*10)+X]);
//delete[] Bitmap;
}


{
//Bitmap=new char[64000L];
MapB();
PCX("Coup2.pcx",64000L,Bitmap);
for (int X=0;X<10;X++)
for (int Y=0;Y<6;Y++)
Lir((Arb2_X*X),(Arb2_Y*Y),Arb2_X,Arb2_Y,&Arb2[(Y*10)+X]);
//delete[] Bitmap;
}


{
//Bitmap=new char[64000L];
MapC();
PCX("Coup3.pcx",64000L,Bitmap);
for (int X=0;X<10;X++)
for (int Y=0;Y<6;Y++)
Lir((Arb3_X*X),(Arb3_Y*Y),Arb3_X,Arb3_Y,&Arb3[(Y*10)+X]);
//delete[] Bitmap;
}


/*
{
//Bitmap=new char[64000L];
PCX("Marches.pcx",64000L,Bitmap);
for (int X=0;X<6;X++)
for (int Y=0;Y<2;Y++)
Lir((Perso_X*X),(Perso_Y*Y),Perso_X,Perso_Y,&Beast[(Y*10)+X]);
//delete[] Bitmap;
}
*/


{
//Bitmap=new char[64000L];
PCX("barriere.pcx",64000L,Bitmap);
for (int X=0;X<1;X++)
for (int Y=0;Y<1;Y++)
Lir((Barr_X*X),(Barr_Y*Y),Barr_X,Barr_Y,&Barriere[(Y*10)+X]);
//delete[] Bitmap;
}


{
//Bitmap=new char[64000L];
PCX("Nuages3.pcx",64000L,Bitmap);
for (int X=0;X<1;X++)
for (int Y=0;Y<1;Y++)
Lir((Barr_X*X),(Barr_Y*Y),Barr_X,Barr_Y,&Nuages3[(Y*10)+X]);
//delete[] Bitmap;
}


{
//Bitmap=new char[64000L];
PCX("Nuages2.pcx",64000L,Bitmap);
for (int X=0;X<1;X++)
for (int Y=0;Y<1;Y++)
Lir((Barr_X*X),(Barr_Y*Y),Barr_X,Barr_Y,&Nuages[(Y*10)+X]);
//delete[] Bitmap;
}


{
//Bitmap=new char[64000L];
PCX("Nuages1.pcx",64000L,Bitmap);
for (int X=0;X<1;X++)
for (int Y=0;Y<1;Y++)
Lir((Barr_X*X),(Barr_Y*Y),Barr_X,Barr_Y,&Nuages1[(Y*10)+X]);
//delete[] Bitmap;
}


{
//Bitmap=new char[64000L];
PCX("Nuages4.pcx",64000L,Bitmap);
for (int X=0;X<1;X++)
for (int Y=0;Y<1;Y++)
Lir((Barr_X*X),(Barr_Y*Y),Barr_X,Barr_Y,&Nuages4[(Y*10)+X]);
//delete[] Bitmap;
}


{
//Bitmap=new char[64000L];
PCX("Nuages5.pcx",64000L,Bitmap);
for (int X=0;X<1;X++)
for (int Y=0;Y<1;Y++)
Lir((Barr_X*X),(Barr_Y*Y),Barr_X,Barr_Y,&Nuages5[(Y*10)+X]);
//delete[] Bitmap;
}


{
//Bitmap=new char[64000L];
PCX("Herbes1.pcx",64000L,Bitmap);
for (int X=0;X<1;X++)
for (int Y=0;Y<1;Y++)
Lir((Nuage_X*X),(Nuage_Y*Y),Nuage_X,Nuage_Y,&Herbes1[(Y*10)+X]);
//delete[] Bitmap;
}


/*
{
//Bitmap=new char[64000L];
MapD();
PCX("Statue.pcx",64000L,Bitmap);
for (int X=0;X<10;X++)
for (int Y=0;Y<6;Y++)
Lir((Nuage_X*X),(Nuage_Y*Y),Nuage_X,Nuage_Y,&Statue[(Y*10)+X]);
//delete[] Bitmap;
}
*/
{
//Bitmap=new char[64000L];
PCX("Herbes2.pcx",64000L,Bitmap);
for (int X=0;X<1;X++)
for (int Y=0;Y<1;Y++)
Lir((Nuage_X*X),(Nuage_Y*Y),Nuage_X,Nuage_Y,&Herbes2[(Y*10)+X]);
//delete[] Bitmap;
}


{
//Bitmap=new char[64000L];
PCX("Herbes3.pcx",64000L,Bitmap);
for (int X=0;X<1;X++)
for (int Y=0;Y<1;Y++)
Lir((Nuage_X*X),(Nuage_Y*Y),Nuage_X,Nuage_Y,&Herbes3[(Y*10)+X]);
//delete[] Bitmap;
}


{
//Bitmap=new char[64000L];
PCX("Herbes4.pcx",64000L,Bitmap);
for (int X=0;X<1;X++)
for (int Y=0;Y<1;Y++)
Lir((Nuage_X*X),(Nuage_Y*Y),Nuage_X,Nuage_Y,&Herbes4[(Y*10)+X]);
//delete[] Bitmap;
}



{
//Bitmap=new char[64000L];
PCX("Herbes5.pcx",64000L,Bitmap);
for (int X=0;X<1;X++)
for (int Y=0;Y<1;Y++)
Lir((Nuage_X*X),(Nuage_Y*Y),Nuage_X,Nuage_Y,&Herbes5[(Y*10)+X]);


//delete[] Bitmap;
}



//Bitmap=new char[64000L];
PCX("fond.pcx",64000L,Bitmap);
//delete[] Bitmap;


}



void main()
{
int Exit=1;
int Touche;
ModeVGA();
Ini();



do
{
if (kbhit)
Touche=toupper(getch());
{


if (Touche==77)
{
Fond->X+=4; Mont->X+=2; Nuages->X+=4; Nuages1->X+=3; Nuages3->X+=6;Nuages4->X+=5; Nuages5->X+=2; Herbes1->X+=3; Herbes2->X+=2;
Herbes3->X+=4; Herbes4->X+=7; Herbes5->X+=5; Barriere->X+=9; Arb1->X+=4; Arb2->X+=4; Arb3->X+=4; Statue->X+=4;
if (Planche[Beast->X][Beast->Y]>=5)
{
Planche[Beast->X][Beast->Y]=0;
}else
Planche[Beast->X][Beast->Y]++;


}
if (Touche==75)
{
Fond->X-=4; Mont->X--; Nuages->X-=4; Nuages1->X-=3; Nuages3->X-=6; Herbes1->X-=3; Herbes2->X-=2; Arb1->X-=4; Arb2->X-=4; Arb3->X-=4;
Herbes3->X-=4; Herbes4->X-=7; Herbes5->X-=5; Barriere->X-=9; Nuages4->X-=5; Nuages5->X-=2; Statue->X-=4;
if (Planche[Beast->X][Beast->Y]<=10)
{
Planche[Beast->X][Beast->Y]=14;
}else
Planche[Beast->X][Beast->Y]--;


}
if (Touche==27)
{
Exit=3;
}
}


memcpy(fakescreen,Bitmap,65535L);


{
int Debx=Nuages->X/Barr_X;
int Deby=Nuages->Y/Barr_Y;
int FinX=Nuages->X-Debx*Barr_X;
int FinY=Nuages->Y-Deby*Barr_Y;
for (int X=0;X<2;X++)
for (int Y=0;Y<1;Y++)
PutBarr((Barr_X*X-FinX),(Barr_Y*Y-FinY+40),&Nuages[CarteM[Debx+X][Deby+Y]]);
}


{
int Debx=Nuages4->X/Barr_X;
int Deby=Nuages4->Y/Barr_Y;
int FinX=Nuages4->X-Debx*Barr_X;
int FinY=Nuages4->Y-Deby*Barr_Y;
for (int X=0;X<2;X++)
for (int Y=0;Y<1;Y++)
PutBarr((Barr_X*X-FinX),(Barr_Y*Y-FinY+20),&Nuages4[CarteM[Debx+X][Deby+Y]]);
}


{
int Debx=Nuages1->X/Barr_X;
int Deby=Nuages1->Y/Barr_Y;
int FinX=Nuages1->X-Debx*Barr_X;
int FinY=Nuages1->Y-Deby*Barr_Y;
for (int X=0;X<2;X++)
for (int Y=0;Y<1;Y++)
PutBarr((Barr_X*X-FinX),(Barr_Y*Y-FinY+60),&Nuages1[CarteM[Debx+X][Deby+Y]]);
}


{
int Debx=Nuages3->X/Barr_X;
int Deby=Nuages3->Y/Barr_Y;
int FinX=Nuages3->X-Debx*Barr_X;
int FinY=Nuages3->Y-Deby*Barr_Y;
for (int X=0;X<2;X++)
for (int Y=0;Y<1;Y++)
PutBarr((Barr_X*X-FinX),(Barr_Y*Y-FinY-8),&Nuages3[CarteM[Debx+X][Deby+Y]]);
}


{
int Debx=Nuages5->X/Barr_X;
int Deby=Nuages5->Y/Barr_Y;
int FinX=Nuages5->X-Debx*Barr_X;
int FinY=Nuages5->Y-Deby*Barr_Y;
for (int X=0;X<2;X++)
for (int Y=0;Y<1;Y++)
PutBarr((Barr_X*X-FinX),(Barr_Y*Y-FinY+83),&Nuages5[CarteM[Debx+X][Deby+Y]]);
}


{
int Debx=Mont->X/Mont_X;
int Deby=Mont->Y/Mont_Y;
int FinX=Mont->X-Debx*Mont_X;
int FinY=Mont->Y-Deby*Mont_Y;
for (int X=0;X<11;X++)
for (int Y=0;Y<7;Y++)
PutMont((Mont_X*X-FinX),(Mont_Y*Y-FinY+64),&Mont[CarteMo[Debx+X][Deby+Y]]);
}


{
int Debx=Herbes1->X/Nuage_X;
int Deby=Herbes1->Y/Nuage_Y;
int FinX=Herbes1->X-Debx*Nuage_X;
int FinY=Herbes1->Y-Deby*Nuage_Y;
for (int X=0;X<11;X++)
for (int Y=0;Y<1;Y++)
PutNu((Nuage_X*X-FinX),(Nuage_Y*Y-FinY+167),&Herbes1[CarteM[Debx+X][Deby+Y]]);
}


{
int Debx=Herbes2->X/Nuage_X;
int Deby=Herbes2->Y/Nuage_Y;
int FinX=Herbes2->X-Debx*Nuage_X;
int FinY=Herbes2->Y-Deby*Nuage_Y;
for (int X=0;X<11;X++)
for (int Y=0;Y<1;Y++)
PutNu((Nuage_X*X-FinX),(Nuage_Y*Y-FinY+160),&Herbes2[CarteM[Debx+X][Deby+Y]]);
}
/*
{
int Debx=Statue->X/Nuage_X;
int Deby=Statue->Y/Nuage_Y;
int FinX=Statue->X-Debx*Nuage_X;
int FinY=Statue->Y-Deby*Nuage_Y;
for (int X=0;X<11;X++)
for (int Y=0;Y<7;Y++)
PutNu((Nuage_X*X-FinX),(Nuage_Y*Y-FinY-19),&Statue[CarteD[Debx+X][Deby+Y]]);
}
*/
{
int Debx=Herbes3->X/Nuage_X;
int Deby=Herbes3->Y/Nuage_Y;
int FinX=Herbes3->X-Debx*Nuage_X;
int FinY=Herbes3->Y-Deby*Nuage_Y;
for (int X=0;X<11;X++)
for (int Y=0;Y<1;Y++)
PutNu((Nuage_X*X-FinX),(Nuage_Y*Y-FinY+173),&Herbes3[CarteM[Debx+X][Deby+Y]]);
}


{
int Debx=Herbes5->X/Nuage_X;
int Deby=Herbes5->Y/Nuage_Y;
int FinX=Herbes5->X-Debx*Nuage_X;
int FinY=Herbes5->Y-Deby*Nuage_Y;
for (int X=0;X<11;X++)
for (int Y=0;Y<1;Y++)
PutNu((Nuage_X*X-FinX),(Nuage_Y*Y-FinY+180),&Herbes5[CarteM[Debx+X][Deby+Y]]);
}


{
int Debx=Herbes4->X/Nuage_X;
int Deby=Herbes4->Y/Nuage_Y;
int FinX=Herbes4->X-Debx*Nuage_X;
int FinY=Herbes4->Y-Deby*Nuage_Y;
for (int X=0;X<11;X++)
for (int Y=0;Y<1;Y++)
PutNu((Nuage_X*X-FinX),(Nuage_Y*Y-FinY+190),&Herbes4[CarteM[Debx+X][Deby+Y]]);
}


{
int Debx=Arb1->X/Arb_X;
int Deby=Arb1->Y/Arb_Y;
int FinX=Arb1->X-Debx*Arb_X;
int FinY=Arb1->Y-Deby*Arb_Y;
for (int X=0;X<11;X++)
for (int Y=0;Y<7;Y++)
PutArb1((Arb_X*X-FinX),(Arb_Y*Y-FinY),&Arb1[CarteA[Debx+X][Deby+Y]]);
}


{
int Debx=Arb2->X/Arb2_X;
int Deby=Arb2->Y/Arb2_Y;
int FinX=Arb2->X-Debx*Arb2_X;
int FinY=Arb2->Y-Deby*Arb2_Y;
for (int X=0;X<11;X++)
for (int Y=0;Y<7;Y++)
PutArb2((Arb2_X*X-FinX),(Arb2_Y*Y-FinY),&Arb2[CarteB[Debx+X][Deby+Y]]);
}


{
int Debx=Arb3->X/Arb3_X;
int Deby=Arb3->Y/Arb3_Y;
int FinX=Arb3->X-Debx*Arb3_X;
int FinY=Arb3->Y-Deby*Arb3_Y;
for (int X=0;X<11;X++)
for (int Y=0;Y<7;Y++)
PutArb3((Arb3_X*X-FinX),(Arb3_Y*Y-FinY),&Arb3[CarteC[Debx+X][Deby+Y]]);
}



{
int Debx=Fond->X/Largeur_X;
int Deby=Fond->Y/Hauteur_Y;
int FinX=Fond->X-Debx*Largeur_X;
int FinY=Fond->Y-Deby*Hauteur_Y;
for (int X=0;X<11;X++)
for (int Y=0;Y<7;Y++)
Put((Largeur_X*X-FinX),(Hauteur_Y*Y-FinY-41),&Fond[Carte[Debx+X][Deby+Y]]);
}


/*
{
PutPerso(130,126,&Beast[Planche[Beast->X][Beast->Y]]);
}
*/
{
int Debx=Barriere->X/Barr_X;
int Deby=Barriere->Y/Barr_Y;
int FinX=Barriere->X-Debx*Barr_X;
int FinY=Barriere->Y-Deby*Barr_Y;
for (int X=0;X<2;X++)
for (int Y=0;Y<1;Y++)
PutBarr((Barr_X*X-FinX),(Barr_Y*Y-FinY+179),&Barriere[CarteM[Debx+X][Deby+Y]]);
}


cpyvirt();


}while(Exit<2);
}

Merci d'avance.
Répondre Posez votre question