PDA

Visualizza la versione completa : [C] Limiti di un mappa


francesco1985
19-05-2012, 20:39
ciao a tutti raga. oggi ho da proporvi un bel quesito tosto tosto :D
allora voi tutti sapete che sto facendo il giochino del tetris, alcune funzioni le ho gi postate in post precedenti..., adesso per mi manca l ultima funzione, quella piu difficile e cioe i limiti della mappa su cui scorre il mio pezzo.
int movimentopossibile()
{
int i,j;
for (i=pezzo.asse_verticale; i<altezza_righe;i++)
{
for (j=pezzo.asse_orizzontale;j<larghezza_colonne;j++)
{

if (mappa2[i][j==10]==1)
{
return 0;
}
//else
{
return 1;
}
}
}
} allora... so benissimo che questa funzione cosi non dice nulla, per dando una certa interpretazione posso dire che: per ogni i il cui elemento j uguale a 10 se ce presente 1 in quella posizione la funzione restituisce 0 se no 1.
adesso..... la mia domanda questa: il mio ragionamento esatto? da premettere che la funzione non fa quello che dico io.

oregon
19-05-2012, 20:46
Non si capisce quasi nulla ...

Qual il problema che vuoi affrontare e risolvere con quella funzione?

Cosa mappa e cosa contiene?

francesco1985
19-05-2012, 20:48
ciao oregon, ti ricordi il mio bel progettino del tetris postato piu di una volta. la mappa una matrice 20x10 se vuoi ti posto tutto cosi fai mente locale

oregon
19-05-2012, 20:56
Ricordo ma non c' bisogno di tutto il codice ...

Ripeto le domande ...

francesco1985
19-05-2012, 20:59
allora... il pezzo in questione deve fermarsi quando incontra degli 1 sulla mappa oppure quando tocca i bordi della mappa stessa. per adesso mi limito a fermare il pezzo non appena tocca i bordi.

Who am I
19-05-2012, 22:04
Questo codice non ha senso, stai facendo due for che teoricamente si dovrebbero ripetere altezza_tighe*larghezza_colonne volte, per alla prima iterazione ritorna 1 oppure 0.
Non ha molto senso, hai fatto bene ad assegnare il significato 1=occupato, 0=libero, per dovresti perlomeno passare le coordinate x e y come argomenti, altrimenti calcolerebbe solo se il movimento possibile per 0,0 (oppure 0,1 se pezzo.asse_orizzontale uguale a 10).



int movimentopossibile(int x, int y)
{
return x<altezza_righe && x>=0 && y<larghezza_colonne && y>=0 && mappa[i][j]==0;
}

francesco1985
19-05-2012, 22:12
sinceramene non che ho capito un gran che

francesco1985
19-05-2012, 22:14
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define larghezza_colonne 10
#define altezza_righe 20
#define dimpezzo 3
int pezzo2 [3][3] ={ {0, 0, 0},
{1, 1, 1},
{0, 1, 0},};


int mappa2[altezza_righe][larghezza_colonne]={ {0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,1,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,1,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0},
{1,0,0,0,1,1,1,1,1,1} };

struct blocco{
int asse_verticale,asse_orizzontale;
int array[dimpezzo][dimpezzo];
}pezzo;
int mappa[altezza_righe][larghezza_colonne]={0};
int indice_mappai,indice_mappaj,indice_pezzoi=0,indice _pezzoj=0,posizione,righe,colonne,tasto;
void stampa_mappa();
void stampa_pezzo();
void azzera_mappa();
void nuovo_pezzo();
int gameover(int);
void azzera_pezzo();
void controllariga();
void cancellariga();
void piazza_pezzo();
void ruota_pezzo();
int movimentopossibile();
void muovi();
void main()
{
pezzo.asse_verticale=0;
pezzo.asse_orizzontale=0;
for (indice_pezzoi=0;indice_pezzoi<dimpezzo;indice_pezzoi++)//pezzo
{
for (indice_pezzoj=0;indice_pezzoj<dimpezzo;indice_pezzoj++)
{
pezzo.array[indice_pezzoi][indice_pezzoj]= pezzo2[indice_pezzoi][indice_pezzoj];
}
}//fine pezzo

printf("\n--------------------\n");

stampa_mappa();
stampa_pezzo();

while(1)
{
switch (getchar())
{
case('s'):
azzera_pezzo();
pezzo.asse_verticale++;
if(!movimentopossibile(pezzo.asse_verticale,pezzo. asse_orizzontale))
{
pezzo.asse_verticale--;
piazza_pezzo();
controllariga();
nuovo_pezzo();
}
muovi();
stampa_mappa();
stampa_pezzo();
break;
case('d'):
azzera_pezzo();
pezzo.asse_orizzontale++;// pezzo.asse_orizzontale il movimento in orizzontale
if(!movimentopossibile(pezzo.asse_verticale,pezzo. asse_orizzontale))
{
pezzo.asse_orizzontale--;//se nn possibile torna indietro
controllariga();
}
muovi();
stampa_mappa();
stampa_pezzo();
break;
case('a'):
azzera_pezzo();
pezzo.asse_orizzontale--;
if(!movimentopossibile(pezzo.asse_verticale,pezzo. asse_orizzontale))
{
pezzo.asse_orizzontale++;
controllariga();
}
muovi();
stampa_mappa();
stampa_pezzo();
break;
case ('w'):
azzera_pezzo();
ruota_pezzo();
muovi();
stampa_mappa();
stampa_pezzo();
printf("\n");
break;
default: printf("\n pezzoverticale=%d pezzoorizzontale=%d\n",pezzo.asse_verticale,pezzo.asse_orizzontale);
break;
}// fine switch

}//fine while

}// fine main

francesco1985
19-05-2012, 22:15
int gameover(int posizione_riga)
{
int i;
for (i=posizione_riga;i<altezza_righe;i--)
if (i<0)
return 1;
return 0;
}//fine game over

void nuovo_pezzo()
{
int i,j;
for (i=0; i<dimpezzo;i++)
{
for (j=0; j<dimpezzo;j++)
pezzo.array[i][j] = pezzo2[i][j];
pezzo.asse_verticale=0;
pezzo.asse_orizzontale=5;
}
}//fine nuovo pezzo
void ruota_pezzo()
{
int i,j;
int pezzo1[dimpezzo][dimpezzo];
pezzo1[0][0]=pezzo.array[2][0];
pezzo1[0][1]=pezzo.array[1][0];
pezzo1[0][2]=pezzo.array[0][0];
pezzo1[1][0]=pezzo.array[2][1];
pezzo1[1][1]=pezzo.array[1][1];
pezzo1[1][2]=pezzo.array[0][1];
pezzo1[2][0]=pezzo.array[2][2];
pezzo1[2][1]=pezzo.array[1][2];
pezzo1[2][2]=pezzo.array[0][2];
for (i=0;i<dimpezzo;i++)
{
for (j=0;j<dimpezzo;j++)
pezzo.array[i][j]=pezzo1[i][j];
}
}//fine ruota pezzo
void cancellariga(int posizione_righe)
{
int i,j;
for (i=posizione_righe;i>=0;i--)
{
for(j=0; j<larghezza_colonne;j++)
{

if(i<altezza_righe)
mappa2[i][j]=mappa2[i-1][j];

}
}
}//fine cancellariga
void controllariga()
{
int i,j,cont=0;
for(i=0;i<altezza_righe;i++)
{
for(j=0; j<larghezza_colonne;j++)
{
if(mappa2[i][j]==1)
cont++;
}//fine for
if(cont<10)
cont=0;
else if(cont==10)
{
cancellariga(i);
cont=0;

}
}
}//fine controlla riga
int movimentopossibile()
{
int i,j;
for (i=pezzo.asse_verticale; i<20;i++)
{
for (j=pezzo.asse_orizzontale;j<10;j++)
{

if (mappa2[i][j==10])
// if (pezzo.array[i][j]==1)
{
return 0;
}
//else
{
return 1;
}
}
}
}

void stampa_mappa() //stampa la mappa
{
int i,j;
for(i=0;i<altezza_righe;i++)
{
for(j=0;j<larghezza_colonne ;j++)
{
printf("%d ",mappa2[i][j]);
}
printf("\n");
}
printf("\n");
}//fine stampa mappa
void stampa_pezzo() //stampa la mappa
{
int i,j;
for(i=0;i<dimpezzo;i++)
{
for(j=0;j<dimpezzo;j++)
{
printf("%d ",pezzo.array[i][j]);
}
printf("\n");
}
}
void azzera_mappa()// porta gli elementi di mappa a 0
{
int i,j;
for(i=0;i<altezza_righe;i++)
{
for(j=0;j<larghezza_colonne ;j++)
{
mappa[i][j]=0;
}
}
}//fine azzera mappa
void piazza_pezzo()//modificato muovi
{
int i,j;
for(i=pezzo.asse_verticale;i<pezzo.asse_verticale+dimpezzo;i++)
{
for(j=pezzo.asse_orizzontale;j<pezzo.asse_orizzontale+dimpezzo;j++)
{
if (pezzo.array[i-pezzo.asse_verticale][j-pezzo.asse_orizzontale]==1)
{
mappa2[i][j]=pezzo.array[i-pezzo.asse_verticale][j-pezzo.asse_orizzontale];
}
}
}
}//fine muovi
void muovi()//modificato muovi
{
int i,j;
for(i=pezzo.asse_verticale;i<pezzo.asse_verticale+dimpezzo;i++)
{
for(j=pezzo.asse_orizzontale;j<pezzo.asse_orizzontale+dimpezzo;j++)
{
if (pezzo.array[i-pezzo.asse_verticale][j-pezzo.asse_orizzontale]==1)
{
mappa2[i][j]=pezzo.array[i-pezzo.asse_verticale][j-pezzo.asse_orizzontale];
}
}
}
}//fine muovi
void azzera_pezzo()// porta gli elementi di mappa a 0
{
int i,j;
int pezzo_1[3][3];
for(i=pezzo.asse_verticale;i<pezzo.asse_verticale+dimpezzo;i++)
{
for(j=pezzo.asse_orizzontale;j<pezzo.asse_orizzontale+dimpezzo;j++)
{
pezzo_1[i-pezzo.asse_verticale][j-pezzo.asse_orizzontale]=0;
if (pezzo.array[i-pezzo.asse_verticale][j-pezzo.asse_orizzontale]==1)
{
mappa2[i][j]=pezzo_1[i-pezzo.asse_verticale][j-pezzo.asse_orizzontale];
}
}
}
}

francesco1985
19-05-2012, 22:16
questo tutto quello kche ho fatto fin ora.

Loading