[C] Limiti di un mappa

[francesco1985]

ciao a tutti raga. oggi ho da proporvi un bel quesito tosto tosto
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]

Non si capisce quasi nulla ...

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

Cosa è mappa e cosa contiene?

[francesco1985]

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]

Ricordo ma non c'è bisogno di tutto il codice ...

Ripeto le domande ...

[francesco1985]

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]

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]

sinceramene non è che ho capito un gran che

[francesco1985]

#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]

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]

questo è tutto quello kche ho fatto fin ora.