Giochino cars

di il
7 risposte

Giochino cars

Dovrei creare un gioco in c in cui si simula una car race.
Le 3 cars si trovana su un percorso rettangolare
Ogni cars ha un tot di diesel,essa può muoversi da 2 a 6 posizioni
Se una car si trova dietro l'altra davanti ad una curva l'avanzamento scala di uno.
Ad ogni giro si perde un po' di gasolio
Se termina il diesel(preghi di avere soldi in tasca) e ti fermi alla pompa di benzina e farai un tot di rifornimento (restarà ferma un turno)
Fare 20 giri e visualizzare ad ogni giro la posizione delle cars.
Ora ho bisogno di idee.

Avevo pensato di usare una struct
In cui dichiaro
Il nome del pilota
Benzina a disposizione

Ora nn saprei come poter simulare la mappa
E la presenza di una curva.
(avevo provato a scrivere qualcosa, domani dal pc posto il codice)
Considerando che devo stampare la mappa ad ogni turno nn si provoca lag?
N.B Ovviamente deve essere qualcosa di semplice nulla di complicato

7 Risposte

  • Re: Giochino cars

    Riposto!
  • Re: Giochino cars

    Perché delle biciclette diesel vanno a benzina?
  • Re: Giochino cars

    AldoBaldo ha scritto:


    Perché delle biciclette diesel vanno a benzina?
    le mie si sono truccate
    scherzi a parte
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    #include <string.h>
    
    typedef enum{p,c}tipo; /*p=percorso  c=curva*/
    struct cars {
    char nome[10];
    int posizione; /*Indica a quale posizione del percorso si trova*/
    int diesel; /*benzina che si ha*/
    int giro; /*Tiene traccia del numero di giro che sta percorrendo*/
    };
    struct ciclopercorso {
    tipo tratta; /*0 percorso,  1 curva*/
    };
    
    /*INIZIO MAIN*/
    void main(){
    
    int c; /*Variabile utilizzata per la generazione del passo di 3*/
    int a; /*Variabile utilizzata per la generazione del passo di 2*/
    int g; /*Variabile utilizzata per la generazione del passo di 1*/
    int i; /*Variabile utilizzata per la stampa del circuito*/
    int j; /*Variabile utilizzata per la stampa del circuito*/
    int inizio; /*Variabile utilizzata per dare inizio alla gara*/
    int k; /*Variabile utilizzata per la stampa dell'andamento del circuito*/
    int posizione_iniziale; /*Variabile che contiene il numero corrispondete alla posizione iniziale nel circuito*/
    int posizione_finale; /*Variabile che contiene il numero corrispondente alla posizione finale nel circuito*/
    int numerogiri=8; /*Variabile che contiene il numero di giri complessivi della gara*/
    char primo[10]={" "}, secondo[10]={" "}, terzo[10]={" "}; /*Variabili che conterranno i nomi  a seconda del loro arrivo al traguardo*/
    
    /*Inizializzazione dell'array 2D che rappresenta il circuito*/
    int circuito[7][82]={ {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'},
                          {'|',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','|'},
                          {'|',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','|'},
                          {'|',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','|'},
                          {'|',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','|'},
                          {'|',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','|'},
                          {'-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-'}
    };
    
    /*Creazione e inizializzazione dell'array di struct percorso del tipo Percorso alal fine c'è curva*/
    typedef struct  ciclopercorso Percorso[80]; /*Definisco un array di struct Percorso del tipo ciclistipercoso di size 80*/
    typedef struct cars concorrente[3]; /*Definisco un array di struct Corridori del tipo corridore*/
    Percorso percorso={{p,0},{p,0},{p,1},{p,2},{p,3},{p,4},{p,5},{p,6},{c,0},{p,0},{p,1},{p,2},{p,3},{p,4},{p,5},{p,6},{c,0},{c,0},{p,0},{p,1},{p,2},{p,3},{p,4},{p,5},{p,6},{c,0},{p,1},{p,2},{p,3},{p,4},{p,5},{p,6},{c,0},{p,0},{p,1},{p,2},{p,3},{p,4},{p,5},{p,6},{c,0},{p,0},{p,1},{p,2},{p,3},{p,4},{p,5},{p,6},{c,0},{p,0},{p,1},{p,2},{p,3},{p,4},{p,5},{p,6},{c,0},{p,0},{p,1},{p,2},{p,3},{p,4},{p,5},{p,6},{c,0},{p,0},{p,1},{p,2},{p,3},{p,4},{p,5},{p,6},{c,0},{p,0},{p,1},{p,2},{p,3},{p,4},{p,5},{c,0}};
    
    /*Creazione e inizializzazione dell'array di struct concorrente del tipo guidatore*/
     concorrente guidatore={{"Mario",0,0,0},{"Pippo",0,0,0},{"Dexter",0,0,0}};
    
    srand(time(NULL)); /*Passiamo alla funzione srand l'orario del sistema per generare valori pseudocasuali per il passo dei ciclisti ogni volta diversi*/
    
    
    posizione_iniziale=2;  /*La posizione nel circuito (array2D) all'inizio di ogni giro è posizione_iniziale=2*/
    posizione_finale=80;
    
    guidatore[0].posizione=posizione_iniziale; /*Alla partenza tutti hanno la posizione iniziale nel circuito =2*/
    guidatore[1].posizione=posizione_iniziale;
    guidatore[2].posizione=posizione_iniziale;
    
    guidatore[0].giro=0; /*N.ro di giri iniziali = 0 (N.B. il n.ro di giri è gia stato inizializzato a zero nell'inizializzazione dell'array di struct, è stato reinizializzato solo per maggiore chiarezza nella lettura del programma)*/
    guidatore[1].giro=0;
    guidatore[2].giro=0;
    
    circuito[1][guidatore[0].posizione-1]='M'; /*in posizione di partenza! */
    circuito[3][guidatore[0].posizione-1]='P';
    circuito[5][guidatore[0].posizione-1]='D';
    
    
    printf("Benvenuti nel programma che simula la corsa di 3 auto ");
    printf("\n\n");
    printf("corrono:\n");
    printf("mario=M\n p=Pippo\n D=Dexter\n ");
    
    printf("\n\nGara n.ro giri: %d\n\n",numerogiri+1);
    printf("-p=percorso c=curva\n");
    
    /*Stampa percorso*/
        for(i=0; i<7; i++){
            for(j=0; j<82; j++)
                printf("%c",circuito[i][j]);
            printf("\n");
        }
    }
    
    ho stampato il tabellone e messo in partenza i guidatori ora devo usare la generazione di numeri casuali per benzina,avanzamento di posizione, e farle muovere
    consigli?
  • Re: Giochino cars

    Francamente, fatico a capire la dinamica di quel che vorresti ottenere.
  • Re: Giochino cars

    AldoBaldo ha scritto:


    Francamente, fatico a capire la dinamica di quel che vorresti ottenere.
    devo far muovere quelle macchinine nel rettangolo come devo fare?
  • Re: Giochino cars

    Se ti riferisci all'aspetto grafico, prova collocando nella matrice del percorso dei segnaposizione che rappresentino i concorrenti, quindi ad ogni "mossa" aggiorni la loro posizione, cancellando quella vecchia e sostituendola con quella nuova, e provvedi a ri-visualizzare la matrice (magari con una funzione che si occupi solo di quello).
  • Re: Giochino cars

    Secondo me conviene (piuttosto che aggiornare in continuazione la matrice) stampare il '-' se la posizione non è occupata da una macchina (che hai già calcolato e salvato precedentemente) o altrimenti fare un segnalino diverso. Basta un ciclo che scorre la matrice e un if che si assicura sia o meno una macchinina. Ti consiglio di spezzare il codice in più funzioni
Devi accedere o registrarti per scrivere nel forum
7 risposte