Visualizzazione e spostamento su una matrice in C

di
Sn1mpul3
il
11 risposte
S
Sn1mpul3
Pochi posts
Iscritto da
gen, 2019
Messaggi:
16

Visualizzazione e spostamento su una matrice in C

Buona giornata,
avrei bisogno di chiedervi delle informazioni riguardo un esercizio in C che mi assilla la mente da qualche giorno
La traccia dell'esercizio presa dal mio manuale che vorrei risolvere e' la seguente:

Si vuole sviluppare un programma per la simulazione di un gioco che prevede
un’auto su un percorso che deve evitare degli oggetti.
Supponiamo di aver un percorso dove sul fondo è presente un’auto 
che può andare a destra o sinistra a scelta dell’utente.
L’auto deve evitare gli oggetti (3) che incontra durante il percorso. 
Gli oggetti vengono creati uno ad ogni passo in una posizione casuale sulla prima riga. 
L’oggetto si muove di una singola posizione casuale in base alla posizione dell’auto. 
La partita finisce o quando l’auto si scontra con un oggetto o quando sono passati 100 passi.
Il mio problema riguarda la generazione e il movimento degli ostacoli, in quanto anche generandone uno solo e in una posizione fissa, si genera una "O" anche nella posizione dell'ultima riga e prima colonna, non so per quale motivo.
Inoltre vorrei sapere come muovermi per generare questi ostacoli casualmente sulla prima riga e farli muovere tutti insieme verso l'auto.

Allego sotto cosa intendo con il problema dellla "O" in basso.
Questa e' la mia attuale realizzazione per ora:

Main.c: 

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX_PASSI 100
#define RAND_MAX 30

int main()
{
    int riga, colonna, vite=1, passi=0, stato=1,i,j;
    register char direzione;
    char percorso[30][30]={{'*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'},
                           {'*',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','*'}};

    //Introduzione
    info();
    system("PAUSE");
    system("cls");
    regole();
    system("PAUSE");
    system("cls");
    comandi();
    system("PAUSE");
    system("cls");

    //Inizializzo il generatore di numeri pseudocasuali
    srand(time(NULL));

    //Genero l'auto in una colonna casuale sulla riga 29.
    riga=29;
    colonna=1+rand()%29;
    percorso[riga][colonna]='V';

    crea_campo(percorso);

    //Movimento dell'auto sul percorso
    do
    {
    fflush(stdin);
    genera_ostacoli(percorso);
    direzione=getchar();
    switch(direzione)
    {
    case 'a':
    case 'A':
        passi+=1;

        percorso[riga][colonna]=' ';
        colonna--;

        if (percorso[riga][colonna]=='*')
        {
            printf("Non puoi andare qui!\n");
            colonna++;
            system("PAUSE");
        }
        percorso[riga][colonna]='V';

        break;

    case 'd':
    case 'D':
        passi+=1;
        percorso[riga][colonna]=' ';
        colonna++;
        if (percorso[riga][colonna]=='*')
        {
            printf("Non puoi andare qui!\n");
            colonna--;
            system("PAUSE");
        }

        percorso[riga][colonna]='V';

        break;
    }
    system("cls");
    crea_campo(percorso);
    }
while (vite!=0);

Functions.c:

#include <stdio.h>

#define RIG 30
#define COL 30

//Stampa del campo di gioco
void crea_campo(char percorso[30][30])
{
    register int i,j;
    for (i=0; i < RIG; i++)
    {
        for (j=0; j < COL; j++)
        {
            printf("%c ", percorso[i][j]);
            fflush(stdout);
        }
        printf("\n");
        fflush(stdout);
    }
}

//Generatore ostacoli  [ATTUALMENTE NON FUNZIONANTE, RISULTA SBAGLIATO ANCHE DANDO UNA POSIZIONE FISSA ALL'OSTACOLO]
void genera_ostacoli(char percorso[30][30])
{
    register int rigaost,colonnaost, conta=0;
    rigaost=3;
    colonnaost=10;
    percorso[rigaost][colonnaost]='O';
    printf("%c ", percorso[rigaost][colonnaost]);
}
//Informazioni sul gioco
void info()
{
    printf("---------------\n");
    printf("| GIOCO 'AUTO' |\n");
    printf("---------------\n");
}

void regole()
{
    printf("----------------\n");
    printf("|    REGOLE    |\n");
    printf("----------------\n\n");
    printf("* Il gioco consiste nel far muovere la vettura ('A') \n");
    printf("* per 100 passi, evitando gli ostacoli presenti a schermo!\n");
    printf("* Se la vettura colpische un ostacolo, la partita termina. \n");
}

void comandi()
{
    printf("---------------\n");
    printf("|   COMANDI   |\n");
    printf("---------------\n");
    printf("E' possibile muovere la vettura a destra e sinistra, rispettivamente\n");
    printf("con i tasti D e A.\n");
}
Grazie per l'attenzione!
Allegati:
25533_94e2ba20dca0dcb7df77c7adb2276d2b.png
25533_94e2ba20dca0dcb7df77c7adb2276d2b.png

11 Risposte

  • O
    oregon
    Super Famoso
    Iscritto da
    nov, 2011
    Messaggi:
    21552

    Re: Visualizzazione e spostamento su una matrice in C

    Non devi utilizzare la printf nella funzione, toglila.
  • Nippolo
    Nippolo
    Molto attivo
    Iscritto da
    mar, 2018
    Messaggi:
    1241

    Re: Visualizzazione e spostamento su una matrice in C

    Sinceramente anche leggendo la traccia continuo a non capire in cosa consiste questo gioco... l'unica interpretazione che sono riuscito a darmi è quella di una sorta di "pioggia di ostacoli" che cade dall'alto e che l'auto deve schivare spostandosi a destra e sinistra.
    E' corretto?

    Purtroppo se non capisco bene quello che stai cercando di fare, diventa difficile aiutarti!
  • S
    Sn1mpul3
    Pochi posts
    Iscritto da
    gen, 2019
    Messaggi:
    16

    Re: Visualizzazione e spostamento su una matrice in C

    Nippolo ha scritto:

    Sinceramente anche leggendo la traccia continuo a non capire in cosa consiste questo gioco... l'unica interpretazione che sono riuscito a darmi è quella di una sorta di "pioggia di ostacoli" che cade dall'alto e che l'auto deve schivare spostandosi a destra e sinistra.
    E' corretto?

    Purtroppo se non capisco bene quello che stai cercando di fare, diventa difficile aiutarti!
    Dovrebbe essere una pioggia di ostacoli appunto, esatto!
    Dalla riga 1, colonna casuale che scendono verso l’auto che si sposta a destra e sinistra.

    Per la risposta di @oregon invece, provo appena torno a casa, grazie mille.
  • Nippolo
    Nippolo
    Molto attivo
    Iscritto da
    mar, 2018
    Messaggi:
    1241

    Re: Visualizzazione e spostamento su una matrice in C

    Premesso che non ho letto il codice in modo approfondito, credo che la cosa più semplice sia quella di creare n (dove n rappresenta l'altezza della griglia) oggetti di tipo ostacolo definiti da un'ascissa x e un'ordinata y:
    - l'ascissa x viene fissata in modo casuale ogni volta che y==0 (apice della griglia) e rimane costante per y!=0;
    - l'ordinata y aumenta di 1 ad ogni spostamento dell'auto per poi ritornare a 0 quando viene raggiunto il fondo della griglia.
  • S
    Sn1mpul3
    Pochi posts
    Iscritto da
    gen, 2019
    Messaggi:
    16

    Re: Visualizzazione e spostamento su una matrice in C

    oregon ha scritto:

    Non devi utilizzare la printf nella funzione, toglila.
    Perfetto, ora un ostacolo viene visualizzato correttamente intanto!
    Il problema e' che compie un solo passo e si ferma li', non arrivando mai all'auto.

    Nippolo ha scritto:

    Premesso che non ho letto il codice in modo approfondito, credo che la cosa più semplice sia quella di creare n (dove n rappresenta l'altezza della griglia) oggetti di tipo ostacolo definiti da un'ascissa x e un'ordinata y:
    - l'ascissa x viene fissata in modo casuale ogni volta che y==0 (apice della griglia) e rimane costante per y!=0;
    - l'ordinata y aumenta di 1 ad ogni spostamento dell'auto per poi ritornare a 0 quando viene raggiunto il fondo della griglia.
    Ci provo in questo momento.
    In questo modo, gli ostacoli che vanno a generarsi sulla prima riga si spostano alla seconda in modo da sembrare che si avvicinino all'auto, giusto?
  • S
    Sn1mpul3
    Pochi posts
    Iscritto da
    gen, 2019
    Messaggi:
    16

    Re: Visualizzazione e spostamento su una matrice in C

    Nippolo ha scritto:

    Premesso che non ho letto il codice in modo approfondito, credo che la cosa più semplice sia quella di creare n (dove n rappresenta l'altezza della griglia) oggetti di tipo ostacolo definiti da un'ascissa x e un'ordinata y:
    - l'ascissa x viene fissata in modo casuale ogni volta che y==0 (apice della griglia) e rimane costante per y!=0;
    - l'ordinata y aumenta di 1 ad ogni spostamento dell'auto per poi ritornare a 0 quando viene raggiunto il fondo della griglia.
    Per lo scrivere il codice, è stato un fallimento totale ahahah.
    Mi sono trovato con muri di “O” in orizzontale e in verticale, poi con la matrice piena di “O” e con degli ostacoli che muovevano 10 passi avanti direttamente, senza “cadere” durante i miei test.
    Se qualcuno può indicarmi il codice corretto per integrare questo passaggio, gliene sarei molto grato!
  • O
    oregon
    Super Famoso
    Iscritto da
    nov, 2011
    Messaggi:
    21552

    Re: Visualizzazione e spostamento su una matrice in C

    Scrivere il codice al posto tuo no. Mostra quello che hai fatto.
  • S
    Sn1mpul3
    Pochi posts
    Iscritto da
    gen, 2019
    Messaggi:
    16

    Re: Visualizzazione e spostamento su una matrice in C

    oregon ha scritto:

    Scrivere il codice al posto tuo no. Mostra quello che hai fatto.
    Perfetto, vi faccio una "sintesi" dei vari tentativi.

    Questo e' errato perche' la funzione genera_ostacoli e' richiamata nel main in un do-while, quindi a quanto ho capito mi va a resettare continuamente il valore di rigaost a 1, rendendo senza senso quell'if(rigaost==1).
    
//Generatore ostacoli  [ATTUALMENTE NON FUNZIONANTE]
void genera_ostacoli(char percorso[30][30], int rigaost, int colonnaost, int conta)
{
    rigaost=1;
    colonnaost=1+rand()%28;

        if (percorso[rigaost][colonnaost]!='V')
        {
            if (rigaost==1)
            {
                percorso[rigaost][colonnaost]=' ';
                rigaost++;
                colonnaost=1+rand()%28;
                percorso[rigaost][colonnaost]='O';
            }
            if (rigaost!=1)
            {
                percorso[rigaost][colonnaost]=' ';
                rigaost++;
                percorso[rigaost][colonnaost]='O';

            }



        }
}
    Allora ho provato a definire rigaost=1 e colonnaost=1+rand()%28 nel main togliendole dalla function ma lasciando gli if.
    Cosi' ho avuto un altro risultato errato, in quanto si ha una situazione nella quale viene visualizzato il primo ostacolo in rigaost=1, colonnaost random, ma poi appena si fa un passo con l'auto gli ostacoli si spostano alla riga 3 e diventano molti di piu', su colonne random.

    Successivamente, ho provato con un for(rigaost=1; rigaost<20; rigaost++) ma e' un altro errore peggiore.
    Con for(colonnaost=1; colonnaost<29; colonnaost++) si genera la diagonale della matrice con le "O", ma non e' proprio il risultato che vorrei ottenere.
  • Nippolo
    Nippolo
    Molto attivo
    Iscritto da
    mar, 2018
    Messaggi:
    1241

    Re: Visualizzazione e spostamento su una matrice in C

    Riflettendo un po' sull'esercizio mi sono reso conto può essere risolto restando nell'ambito del "monodimensionale", ossia senza utilizzare una griglia (che nel tuo caso chiami percorso) bidimensionale.
    Ho provato ad implementare il tutto e sembra funzionare benone.



    Nel caso fossi interessato posso illustrarti qual è l'idea di fondo, in modo che tu possa cimentarti nell'implementazione.
  • S
    Sn1mpul3
    Pochi posts
    Iscritto da
    gen, 2019
    Messaggi:
    16

    Re: Visualizzazione e spostamento su una matrice in C

    Nippolo ha scritto:

    Riflettendo un po' sull'esercizio mi sono reso conto può essere risolto restando nell'ambito del "monodimensionale", ossia senza utilizzare una griglia (che nel tuo caso chiami percorso) bidimensionale.
    Ho provato ad implementare il tutto e sembra funzionare benone.



    Nel caso fossi interessato posso illustrarti qual è l'idea di fondo, in modo che tu possa cimentarti nell'implementazione.
    Appena puoi, illustrami il tuo procedimento e vedo di cercare di procedere all’implementazione nel mio programma.
    Grazie mille!
  • Nippolo
    Nippolo
    Molto attivo
    Iscritto da
    mar, 2018
    Messaggi:
    1241

    Re: Visualizzazione e spostamento su una matrice in C

    Magari è più di un semplice input, ma davvero non sapevo come spiegarlo a parole... 
    #include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define RIG 20
#define COL 30

void mostra_riga(unsigned int ostacolo)
{
    //IN RIFERIMENTO ALLA SINGOLA RIGA DEL "CAMPO" LA FUNZIONE DEVE OCCUPARSI DI STAMPARE I BORDI LATERALI E
    //IL CARATTERE ASSOCIATO ALL'OSTACOLO NELLA POSIZIONE DATA DALLA VARIABILE ostacolo.
}

int main()
{
    srand(time(0));
    unsigned int ostacoli[RIG];
    unsigned int i;
    unsigned int j = 0;
    for(i = 0; i < RIG; ++i)
    {
        ostacoli[i] = COL;
    }
    while(1)
    {
        ostacoli[j] = rand() % COL;
        for(i = 0 ; i < RIG - 1; ++i)
        {
            mostra_riga(ostacoli[j]);
            j = (j + 1) % RIG;
        }
        mostra_riga(ostacoli[j]);
        system("PAUSE");
        system("CLS");
    }
}
    Il suddetto codice, una volta implementata la funzione mostra_riga(), si limita a simulare la "pioggia di ostacoli". Il resto lo lascio fare a te!

    P.S.
    Fammi sapere se hai capito il meccanismo che ho utilizzato per simulare la pioggia che cade.
Devi accedere o registrarti per scrivere nel forum
11 risposte