Tiro al Bersaglio

Function.c

#include "header.h"

//****************************gioco***********************************************

**************************************************

//Dati di input:il vettore a[7][5] che rappresenta il bersaglio,la variabile struttura Tiratore[]

relativa

// alla struct TIRATORE,il vettore Vet che rappresenta le vittorie di una partita di 50 turni,nx

che è il

//numero di righe del bersaglio e my che è il numero di colonne del bersaglio.

//Dati di output:la visualizzazione del bersaglio con i relativi punteggi posizionali,la posizione

in

//righe-colonne di dove è stato colpito il bersaglio da ogni singolo giocatore,il punteggio

posizione fatto

//da ogni giocatore,il punteggio massimo fatto alla fine di ogni turno,il numero del turno

corrente e

//il numero del giocatore/i che hanno vinto.

//Caratteristiche:questa procedura ci consente di svolgere tutte le parti principali che

riguardano il gioco:vedere il bersaglio

//facendo uso di un ciclo annidato for ,generare 5 posizioni casuali sulle caselle con la function

rand, assegnare il punteggio

//posizionale ai giocatori,vedere quale è stato il punteggio massimo all'interno di ogni

turno,stabilire la vittoria del

//giocatore/i utilizzando principalmente un ciclo for che considera la variabile Giocatore come

indice e altri relativi cicli

// che consentono il corretto funzionamento del programma.

//*******************************************************************************

***************************************************

void gioco(char a[][5],struct TIRATORE Tiratore[], int Vet[],int nx,int my)

{ int turno;//questa è la variabile turno che useremo in un ciclo for da cui si uscirà se il

turno è maggiore di 50

int i,j;//contatori rispettivamente relativi al numero di righe e colonne del bersaglio

int Pos_max=0; //questa variabile che viene inizializzata a zero ci serve per assegnare il

valore del punteggio posizione ai giocatori

int Punteggio_max=0;

int Giocatore=0; // la variabile Giocatore è un indice

for(turno=0;turno<50&&Punteggio_max<100;turno++)//facciamo un ciclo che deve

terminare o dopo 50 turni o dopo che uno dei giocatori fa 100 punti

{ printf("\n!!!PICCOLA ANNOTAZIONE!!!= Quando il punteggio posizione vale o

1 o 2, \nil punteggio assegnato al giocatore e' sempre 1.\nPer il resto il punteggio posizione

coincide con il punteggio assegnato.");

printf("\n\n");

//questo ciclo for serve per visualizzare il bersaglio di 7 righe x 5 colonne

for(i=0;i<7;i++)

{ for(j=0;j<5;j++)

{ printf("[_%c_]",a[i][j]);

}

printf("\n");

}

//Stabilisco il valore "posizionale" dei punteggi dei turni

//(N.B. Le righe vanno lette dal numero 0 al numero 6 e le colonne vanno lette dal

numero 0 al numero 4)

//con il relativo punteggio di posizione

for(Giocatore=0;Giocatore<5;Giocatore++)

{ Tiratore[Giocatore].Punteggio_Posizione=0;//inizializziamo a zero la

variabile Punteggio_posizione interna alla struct

nx=rand()%7;//sulle righe vengono generate posizioni casuali da 0 a 6

my=rand()%5;//sulle colonne vengono generate posizioni casuali da 0 a 4

Tiratore[Giocatore].Punteggio_Posizione=a[nx][my]-48;// dato che il

vettore a è di tipo char e contiene caratteri numerici ricaviamo l'equivalente intero sottraendo

il valore del char a 48 perchè in C i caratteri sono trattati mediante il codice ASCII

//48 è il codice ASCII dello zero

printf("\nIl %d-simo giocatore ha colpito la casella nella posizione=[%d]

[%d]\n",Giocatore,nx,my);

printf("Il giocatore numero %d ha fatto questo punteggio posizione:

%d\n", Giocatore,Tiratore[Giocatore].Punteggio_Posizione);

}

//Finiti i turni, stabiliamo il vincitore assegnando

//il valore del "colore" al giocatore che ha buttato la freccetta

//piu vicina al centro,quindi la variabile Pos_max dovrà coincidere con la

variabile Punteggio_Posizione relativa a Tiratore[]

Pos_max=0;

for(Giocatore=0;Giocatore<5;Giocatore++)

{ if(Tiratore[Giocatore].Punteggio_Posizione>Pos_max)

Pos_max=Tiratore[Giocatore].Punteggio_Posizione; //Non conservo

la posizione max perche' piu' persone potrebbero fare lo stesso punteggio

}

//Assegno il punto o assegniamo i punti ai giocatori vincitori

for(Giocatore=0;Giocatore<5;Giocatore++)

{ if(Tiratore[Giocatore].Punteggio_Posizione==Pos_max)

{

if(Pos_max>=1&&Pos_max<=2)Tiratore[Giocatore].Punteggio+=1;//come abbiamo già

detto le celle che hanno il valore posizionale di 1 e 2 possono dare solo 1 punto al giocatore che

vince il turno else Tiratore[Giocatore].Punteggio+=Pos_max;//per il resto il valore

posizionale coincide con il punteggio assegnato: valore posizionale=3 ->punteggio=3;valore

posizionale=6 ->punteggio=6

}

}

//Vedo chi e' il punteggio totale massimo fatto durante ogni turno

Punteggio_max=-1;

for(Giocatore=0;Giocatore<5;Giocatore++)

{ if(Tiratore[Giocatore].Punteggio>Punteggio_max)

Punteggio_max=Tiratore[Giocatore].Punteggio;

}

printf("\nIL PUNTEGGIO MASSIMO FATTO FINO AD ORA E':

%d\n\nSIAMO NEL TURNO NUMERO :%d", Punteggio_max, turno);

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

}

//La posizione del vettore corrisponde al numero di giocatore.

//il contenuto della posizione del vettore corrisponderà alla vittoria.

//esempio: Giocatore 0 ha vinto? Se ha vet[0]=1, significa che ha vinto, altrimenti

Vet[0]=0, ha perso

for(Giocatore=0;Giocatore<5;Giocatore++)

if(Tiratore[Giocatore].Punteggio==Punteggio_max) Vet[Giocatore]=1;

}

//****************************Inizializza*******************************************

****************************************

//Dati di input:la variabile struttura Tiratore[] relativa alla struct TIRATORE.

//Dati di output:pone uguale a zero le variabili Giocatore e punteggio interne alla struct

TIRATORE.

//Caratteristiche:questa è la procedura che inizializza a zero il punteggio dei giocatori e il

numero dei giocatori

//facendo uso di un contatore i che va da 0 a 4 visto che 5 è il numero totale dei giocatori.

//*******************************************************************************

******************************************

void Inizializza(struct TIRATORE Tiratore[])

{ int i;

for(i=0;i<N_GIOCATORI;i++)

{ Tiratore[i].Giocatore=i;

Tiratore[i].Punteggio=0;

}

}

//**************************************regole************************************

**********

//Dati di input:nessuno.

//Dati di output:restituisce la visualizzazione delle regole del gioco.

//Caratteristiche:questa è la procedura che contiene le regole del gioco e il

//bersaglio con i punteggi(1 oppure 3 oppure 6)relativi alla casella alla quale appartiene

//un determinato colore(arancione oppure verde oppure rosso).

//*******************************************************************************

***********

void regole()

{ printf("\nLe regole sono queste:\n");

printf("\n* Giocano 5 giocatori ");

printf("\n* Vince chi fa 100 punti");

printf("\n* Il gioco termina dopo 50 turni");

printf("\n* I punteggi sono questi:");

printf("\n [6 punti per la cella rossa]");

printf("\n [3 punti per le celle verdi]");

printf("\n [1 punto per le celle arancioni]\n");

printf("\n");

printf("ECCO IL BERSAGLIO CON I PUNTI E I COLORI:\n");

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

printf("| 1_arancione || 1_arancione || 1_arancione || 1_arancione || 1_arancione|");

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

printf("| 1_arancione || 1_arancione || 1_arancione || 1_arancione || 1_arancione|");

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

printf("| 1_arancione || 3_verde || 3_verde || 3_verde || 1_arancione|");

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

printf("| 1_arancione || 3_verde || 6_rosso || 3_verde || 1_arancione|");

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

printf("| 1_arancione || 3_verde || 3_verde || 3_verde || 1_arancione|");

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

printf("| 1_arancione || 1_arancione || 1_arancione || 1_arancione || 1_arancione|");

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

printf("| 1_arancione || 1_arancione || 1_arancione || 1_arancione || 1_arancione|");

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

}

MAIN.c

/* Nome del progetto:Tiro al bersaglio

Descrizione:Si vuole sviluppare un programma per la simulazione di un gioco di tiro a

bersaglio.

Si suppone di avere 5 giocatori che si alternano nel tirare una freccetta verso un

bersaglio. Il bersaglio è formato da celle di diverso colore come nella seguente

figura. Ad ogni colore è associato un punteggio: 6 rosso, 3 verde e 1 arancione. A ogni

turno un giocatore tira la sua freccetta che cade in una certa cella in modo casuale. Dopo il

turno di tutti i giocatori il punteggio viene assegnato solo al giocatore che ha la

freccetta più vicina al centro. In caso di parità si assegna lo stesso punteggio a tutti i

giocatori. Il gioco termina o quando uno dei giocatori è arrivato a 100 o quando sono

terminati 50 turni.

*/

#include "header.h"

void main()

{ int nx,my,i;//nx=numero di righe del bersaglio, my=numero di colonne del bersaglio, i=

contatore

struct TIRATORE Tiratore[N_GIOCATORI]; //questa è la dichiarazione del vettore

struttura Tiratore[N_GIOCATORI] che,relativo alla struct TIRATORE,è un array che

contiene la struct di 5 elementi visto che i giocatori che partecipano al gioco sono 5

char a[7][5]={{'1','1','1','1','1'},{'1','2','2','2','1'},{'1','3','3','3','1'},{'1','3','6','3','1'},

{'1','3','3','3','1'},{'1','2','2','2','1'},{'1','1','1','1','1'}};//questo è l'array che permette all'utente

di conoscere il valore posizionale delle celle

int Vet[5]={0,0,0,0,0}; //questo è il vettore che indica le vittorie di una partita di 50 turni

e che viene inizializzato a zer