Advertisement
Guest User

Untitled

a guest
Jun 30th, 2016
71
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 28.28 KB | None | 0 0
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <time.h>
  5. #include <math.h>
  6.  
  7. #define MOLTIPLICATORE_PEDAGGIO 1
  8. #define TABELLONE 40
  9. #define CORRIDOIO 20
  10. #define BATCAVERNA 30
  11. #define BAGNI 10
  12. #define VIA 0
  13. #define SCRIVANIA 1
  14. #define TENDA 2
  15. #define NUMERO_SFIGHE 39
  16.  
  17. //Enum Tipologia_Terreno è un enumerazione con al suo interno tutti i tipi di terreno che ci sono
  18.  
  19. typedef enum{Terreno, Sfiga, Tasse, Corridoio, Via, Batcaverna} Tipologia_Terreno;
  20.  
  21. //Terreno_Struttura serve per definire come sarà fatto un terreno
  22.  
  23. typedef struct Terreno_Struttura{
  24. char Nome[50 + 1];
  25. Tipologia_Terreno Tipo;
  26. float Valore;
  27. int Posizione;
  28. int Proprietario;
  29. int Costruzioni;
  30. } Terreno_Struttura;
  31.  
  32. //La struttura Giocatore è una struttura con all'interno gli elementi principali di ogni giocatore.
  33.  
  34. typedef struct Giocatore{
  35. char Nome[100 + 1];
  36. float Credito;
  37. int Posizione;
  38. int Turni_Prigione;
  39. int Fallimento;
  40. } Giocatore;
  41.  
  42. // La struttura Sfiga_Struttura é la struttura relativa alle carte della sfiga che possono essere pescate nella casella apposita mentre si gioca
  43.  
  44. typedef struct Sfiga_Struttura{
  45. int Moltiplicatore_Terreni;
  46. int Moltiplicatore_Scrivanie;
  47. int Moltiplicatore_Tende;
  48. float Pagamento;
  49. int Salta_a;
  50. char Testo_Sfiga[500 + 1];
  51. int Tipo_Sfiga;
  52. } Sfiga_Struttura;
  53.  
  54. Terreno_Struttura Tabellone[TABELLONE];
  55.  
  56. Sfiga_Struttura Sfighe[NUMERO_SFIGHE];
  57.  
  58.  
  59. //Tira_Dado restituisce un intero casuale compreso tra 1 e 6.
  60.  
  61. int Tira_Dado(){
  62. int dado = 0;
  63. dado = rand()% 6+1;
  64. return dado;
  65. }
  66.  
  67. //Ottieni_Tipologia_Terreno serve per dare il tipo di terreno al relativo terreno in modo che, in base alla tipologia, si esegua un azione diversa.
  68.  
  69. Tipologia_Terreno Ottieni_Tipologia_Terreno(int indice_terreno){
  70. Tipologia_Terreno tipo;
  71. if(indice_terreno == VIA){
  72. tipo = Via;
  73. }
  74. else if(indice_terreno == BAGNI || indice_terreno == CORRIDOIO){
  75. tipo = Corridoio;
  76. }
  77. else if(indice_terreno == 2 || indice_terreno == 7 || indice_terreno == 12 || indice_terreno == 17 || indice_terreno == 22 || indice_terreno == 27 || indice_terreno == 32 || indice_terreno == 37){
  78. tipo = Sfiga;
  79. }
  80. else if(indice_terreno == 5 || indice_terreno == 15 || indice_terreno == 25 || indice_terreno == 35){
  81. tipo = Tasse;
  82. }
  83. else if(indice_terreno == BATCAVERNA){
  84. tipo = Batcaverna;
  85. }
  86. else{
  87. tipo = Terreno;
  88. }
  89. return tipo;
  90. }
  91.  
  92. //Questa funzione serve per avere un char al posto degli interi a seguito dell'enumerazione
  93.  
  94. char* Ottieni_Nome_Tipo(Tipologia_Terreno Tipo){
  95. switch(Tipo){
  96. case Terreno: return "Terreno Normale";
  97. case Sfiga: return "Sfiga";
  98. case Tasse: return "Tasse";
  99. case Corridoio: return "Corridoio";
  100. case Via: return "Via";
  101. case Batcaverna: return "Batcaverna";
  102. }
  103. return "Terreno Normale";
  104. }
  105.  
  106. //La funzione Stampa_Tabellone serve per stampare il tabellone nella sua interezza
  107.  
  108. void Stampa_Tabellone(Terreno_Struttura *tabellone){
  109. int i = 0;
  110. for(i = 0; i < TABELLONE; i++){
  111. printf("Nome Terreno: %s\n", Tabellone[i].Nome);
  112. printf("Tipologia Terreno: %s\n", Ottieni_Nome_Tipo(Tabellone[i].Tipo));
  113. printf("Valore Terreno: %f\n", Tabellone[i].Valore);
  114. printf("Posizione Terreno: %d\n", Tabellone[i].Posizione + 1);
  115. printf("Numero Giocatore Proprietario Terreno: %d\n", Tabellone[i].Proprietario);
  116. printf("Costruzioni Terreno: ");
  117. switch(Tabellone[i].Costruzioni){
  118. case 0:{
  119. printf("Niente\n\n");
  120. break;
  121. }
  122. case 1:{
  123. printf("Scrivania\n\n");
  124. break;
  125. }
  126. case 2:{
  127. printf("Tenda\n\n");
  128. break;
  129. }
  130. }
  131. }
  132. }
  133.  
  134. //La funzione Carica_Sfighe serve per caricare le sfighe da file e metterle all'interno del programma, andando a riempire un vettore di tipo Sfiga_Struttura
  135.  
  136. void Carica_Sfighe(){
  137. FILE *fp = NULL;
  138. int i = 0;
  139. int j = 0;
  140. char buffer[255];
  141. char testo[255];
  142. float pagamento = 0;
  143. int TipoSfighe1 = 0, TipoSfighe2 = 0, TipoSfighe3 = 0, TipoSfighe4 = 0;
  144. fp = fopen("ListaSfighe.txt", "r");
  145. if(fp == NULL){
  146. exit(0);
  147. }
  148. fgets(buffer, 255, fp);
  149. sscanf(buffer, "%d %d %d %d", &TipoSfighe1, &TipoSfighe2, &TipoSfighe3, &TipoSfighe4);
  150. i = 0;
  151. for(j = 0; j < TipoSfighe1; j++){
  152. fgets(buffer, 255, fp);
  153. sscanf(buffer, "%f %[^\n]", &pagamento, &testo);
  154. Sfighe[i].Pagamento = pagamento;
  155. strcpy(Sfighe[i].Testo_Sfiga, testo);
  156. Sfighe[i].Moltiplicatore_Scrivanie = 0;
  157. Sfighe[i].Moltiplicatore_Tende = 0;
  158. Sfighe[i].Moltiplicatore_Terreni = 0;
  159. Sfighe[i].Salta_a = -1;
  160. Sfighe[i].Tipo_Sfiga = 1;
  161. i++;
  162. }
  163. for(j = 0; j < TipoSfighe2; j++){
  164. fgets(buffer, 255, fp);
  165. sscanf(buffer, "%d %d %d %[^\n]", &Sfighe[i].Moltiplicatore_Terreni, &Sfighe[i].Moltiplicatore_Scrivanie, &Sfighe[i].Moltiplicatore_Tende, &Sfighe[i].Testo_Sfiga);
  166. Sfighe[i].Tipo_Sfiga = 2;
  167. Sfighe[i].Salta_a = -1;
  168. Sfighe[i].Pagamento = 0;
  169. i++;
  170. }
  171. for(j = 0; j < TipoSfighe3; j++){
  172. fgets(buffer, 255, fp);
  173. sscanf(buffer, "%[^\n]", &Sfighe[i].Testo_Sfiga);
  174. Sfighe[i].Moltiplicatore_Scrivanie = 0;
  175. Sfighe[i].Moltiplicatore_Tende = 0;
  176. Sfighe[i].Moltiplicatore_Terreni = 0;
  177. Sfighe[i].Salta_a = -1;
  178. Sfighe[i].Tipo_Sfiga = 3;
  179. Sfighe[i].Pagamento = 0;
  180. i++;
  181. }
  182. for(j = 0; j < TipoSfighe4; j++){
  183. fgets(buffer, 255, fp);
  184. sscanf(buffer, "%d %[^\n]", &Sfighe[i].Salta_a, &Sfighe[i].Testo_Sfiga);
  185. Sfighe[i].Moltiplicatore_Scrivanie = 0;
  186. Sfighe[i].Moltiplicatore_Tende = 0;
  187. Sfighe[i].Moltiplicatore_Terreni = 0;
  188. Sfighe[i].Tipo_Sfiga = 4;
  189. Sfighe[i].Pagamento = 0;
  190. i++;
  191. }
  192. fclose(fp);
  193. }
  194.  
  195. // La funzione Stampa_Sfighe serve invece per stampare tutte le Sfighe del gioco. Non viene usata per non rovinare la sorpresa al giocatore, ma esiste per scopo di debug
  196.  
  197. void Stampa_Sfighe(){
  198. int i = 0, terreno = 0;
  199. for(i = 0; i < NUMERO_SFIGHE; i++){
  200. printf("Numero Sfiga: %d\n", i + 1);
  201. printf("%s\n", Sfighe[i].Testo_Sfiga);
  202. printf("Tipo Sfiga: %d\n", Sfighe[i].Tipo_Sfiga);
  203. switch(Sfighe[i].Tipo_Sfiga){
  204. case 1:{
  205. printf("Pagamento: %f\n", Sfighe[i].Pagamento);
  206. break;
  207. }
  208. case 2:{
  209. printf("Moltiplicatore terreni: %d\n", Sfighe[i].Moltiplicatore_Terreni);
  210. printf("Moltiplicatore scrivanie: %d\n", Sfighe[i].Moltiplicatore_Scrivanie);
  211. printf("Moltiplicatore tende: %d\n", Sfighe[i].Moltiplicatore_Tende);
  212. break;
  213. }
  214. case 4:{
  215. terreno = Sfighe[i].Salta_a;
  216. printf("Spostamento al terreno: %d, %s\n", terreno, Tabellone[terreno].Nome);
  217. }
  218. }
  219. printf("\n");
  220. }
  221. }
  222.  
  223. //Azione_Tipo é la struttura che rappresenta il cuore del gioco. Infatti, in base al determinato tipo di terreno nel quale finirá il giocatore, Azione_Tipo fará un azione diversa
  224.  
  225. void Azione_Tipo(Giocatore *Giocatori, int x, int i, int numero_giocatori){
  226. int y = 0, z = 0;
  227. float transazioni = 0;
  228. char scelta_menu;
  229. if(Tabellone[x].Tipo == Via){
  230. Giocatori[i].Credito = Giocatori[i].Credito + (20 * MOLTIPLICATORE_PEDAGGIO);
  231. }
  232. else if(Tabellone[x].Tipo == Batcaverna){
  233. Giocatori[i].Posizione = BAGNI;
  234. printf("\nSei Finito nella Batcaverna, complimenti! Fila a pulire i bagni\n\n");
  235. Giocatori[i].Turni_Prigione = 3;
  236. }
  237. else if(Tabellone[x].Tipo == Tasse){
  238. switch(Tabellone[x].Posizione){
  239. case 5:{
  240. printf("Tasse! Devi pagare 100 crediti\n\n");
  241. Giocatori[i].Credito = Giocatori[i].Credito - (100 * MOLTIPLICATORE_PEDAGGIO);
  242. break;
  243. }
  244. case 15:{
  245. printf("Tasse! Devi pagare 150 crediti\n\n");
  246. Giocatori[i].Credito = Giocatori[i].Credito - (150 * MOLTIPLICATORE_PEDAGGIO);
  247. printf("\nOra ti rimangono %f crediti\n\n", Giocatori[i].Credito);
  248. break;
  249. }
  250. case 25:{
  251. printf("Tasse! Devi pagare 250 crediti\n\n");
  252. Giocatori[i].Credito = Giocatori[i].Credito - (250 * MOLTIPLICATORE_PEDAGGIO);
  253. printf("\nOra ti rimangono %f crediti\n\n", Giocatori[i].Credito);
  254. break;
  255. }
  256. case 35:{
  257. printf("Tasse! Devi pagare 350 crediti\n\n");
  258. Giocatori[i].Credito = Giocatori[i].Credito - (350 * MOLTIPLICATORE_PEDAGGIO);
  259. printf("\nOra ti rimangono %f crediti\n\n", Giocatori[i].Credito);
  260. break;
  261. }
  262. }
  263. }
  264. else if(Tabellone[x].Tipo == Sfiga){
  265. int sfiga_random = 0, moltiplicatore_terreni = 0, moltiplicatore_scrivanie = 0, moltiplicatore_tende = 0, indice_terreni = 0;
  266. srand(time(NULL));
  267. sfiga_random = rand() % NUMERO_SFIGHE + 1;
  268. switch(Sfighe[sfiga_random].Tipo_Sfiga){
  269. case 1:{
  270. printf("%s\n\n", Sfighe[sfiga_random].Testo_Sfiga);
  271. Giocatori[i].Credito = Giocatori[i].Credito - (Sfighe[sfiga_random].Pagamento * MOLTIPLICATORE_PEDAGGIO);
  272. break;
  273. }
  274. case 2:{
  275. moltiplicatore_terreni = 0;
  276. moltiplicatore_scrivanie = 0;
  277. moltiplicatore_tende = 0;
  278. indice_terreni = 0;
  279. printf("%s\n\n", Sfighe[sfiga_random].Testo_Sfiga);
  280. for(indice_terreni = 0; indice_terreni < TABELLONE; indice_terreni++){
  281. if(Tabellone[indice_terreni].Proprietario == i + 1){
  282. if(Tabellone[indice_terreni].Costruzioni == 0){
  283. moltiplicatore_terreni++;
  284. }
  285. else if(Tabellone[indice_terreni].Costruzioni == 1){
  286. moltiplicatore_scrivanie++;
  287. }
  288. else if(Tabellone[indice_terreni].Costruzioni == 2){
  289. moltiplicatore_tende++;
  290. }
  291. }
  292. }
  293. printf("Hai %d Aule, %d Scrivanie e %d Tende. Dovrai pagare %d crediti\n\n", moltiplicatore_terreni, moltiplicatore_scrivanie, moltiplicatore_tende, ((moltiplicatore_terreni * Sfighe[x].Moltiplicatore_Terreni) * MOLTIPLICATORE_PEDAGGIO) + ((moltiplicatore_scrivanie * Sfighe[x].Moltiplicatore_Scrivanie) * MOLTIPLICATORE_PEDAGGIO) + ((moltiplicatore_tende * Sfighe[x].Moltiplicatore_Tende) * MOLTIPLICATORE_PEDAGGIO));
  294. Giocatori[i].Credito = Giocatori[i].Credito - ((moltiplicatore_terreni * Sfighe[x].Moltiplicatore_Terreni) * MOLTIPLICATORE_PEDAGGIO);
  295. Giocatori[i].Credito = Giocatori[i].Credito - ((moltiplicatore_scrivanie * Sfighe[x].Moltiplicatore_Scrivanie) * MOLTIPLICATORE_PEDAGGIO);
  296. Giocatori[i].Credito = Giocatori[i].Credito - ((moltiplicatore_tende * Sfighe[x].Moltiplicatore_Tende) * MOLTIPLICATORE_PEDAGGIO);
  297. break;
  298. }
  299. case 3:{
  300. printf("%s\n\n", Sfighe[sfiga_random].Testo_Sfiga);
  301. break;
  302. }
  303. case 4:{
  304. printf("%s\n\n", Sfighe[sfiga_random].Testo_Sfiga);
  305. Giocatori[i].Posizione = Sfighe[sfiga_random].Salta_a;
  306. break;
  307. }
  308. }
  309. }
  310. else if(Tabellone[x].Tipo == Terreno){
  311. if(Tabellone[x].Proprietario == i + 1){
  312. printf("Il terreno e' di tua proprieta'\n\n");
  313. if(Tabellone[x].Costruzioni == 0 && Giocatori[i].Credito >= (50 * MOLTIPLICATORE_PEDAGGIO)){
  314. printf("Nel terreno non e' presente niente, vuoi costruire una scrivania? Costo %d crediti\n\n'S' - Si\n'N' - No\n\n", MOLTIPLICATORE_PEDAGGIO * 50);
  315. scanf("%c", &scelta_menu);
  316. getchar();
  317. while(scelta_menu != 'S' && scelta_menu != 's' && scelta_menu != 'N' && scelta_menu != 'n'){
  318. printf("\nHai sbagliato scelta. Premi S per costruire una scrivania o N per non costruirla\n\n");
  319. scanf("%c", &scelta_menu);
  320. getchar();
  321. }
  322. if(scelta_menu == 'S' || scelta_menu == 's'){
  323. Giocatori[i].Credito = Giocatori[i].Credito - (50 * MOLTIPLICATORE_PEDAGGIO);
  324. Tabellone[x].Costruzioni = 1;
  325. printf("\nHai comprato una scrivania! Ora ti rimangono %f crediti\n\n", Giocatori[i].Credito);
  326. }
  327. }
  328. else if(Tabellone[x].Costruzioni == 1 && Giocatori[i].Credito >= (100 * MOLTIPLICATORE_PEDAGGIO)){
  329. printf("Nel terreno e' presente una scrivania, vuoi costruire una tenda? Costo %d crediti\n\n'S' - Si\n'N' - No\n\n", MOLTIPLICATORE_PEDAGGIO * 100);
  330. scanf("%c", &scelta_menu);
  331. getchar();
  332. while(scelta_menu != 'S' && scelta_menu != 's' && scelta_menu != 'N' && scelta_menu != 'n'){
  333. printf("\nHai sbagliato scelta. Premi S per costruire una tenda o N per non costruirla\n\n");
  334. scanf("%c", &scelta_menu);
  335. getchar();
  336. }
  337. if(scelta_menu == 'S' || scelta_menu == 's'){
  338. Giocatori[i].Credito = Giocatori[i].Credito - (100 * MOLTIPLICATORE_PEDAGGIO);
  339. Tabellone[x].Costruzioni = 1;
  340. printf("\nHai comprato una tenda! Ora ti rimangono %f crediti\n\n", Giocatori[i].Credito);
  341. }
  342. }
  343. else if(Tabellone[x].Costruzioni == 2){
  344. printf("Hai gia'costruito tutto il massimo consentito, non puoi costruire altro\n\n");
  345. }
  346. else{
  347. printf("Il tuo credito residuo non ti permettere di costruire nulla su questo terreno, pezzente\n\n");
  348. }
  349. }
  350. else if(Tabellone[x].Proprietario == 0){
  351. if(Giocatori[i].Credito >= (Tabellone[x].Valore * MOLTIPLICATORE_PEDAGGIO)){
  352. printf("Questo terreno, %s, non e'di nessuno e costa &f. Vuoi comprarlo?\n\n'S' - Si\n'N' - No\n\n", Tabellone[x].Nome, (Tabellone[x].Valore * MOLTIPLICATORE_PEDAGGIO));
  353. scanf("%c", &scelta_menu);
  354. getchar();
  355. while(scelta_menu != 'S' && scelta_menu != 's' && scelta_menu != 'N' && scelta_menu != 'n'){
  356. printf("\nHai sbagliato scelta. Premi S per comprare il terreno o N per non comprarlo\n\n");
  357. scanf("%c", &scelta_menu);
  358. getchar();
  359. }
  360. if(scelta_menu == 'S' || scelta_menu == 's'){
  361. Giocatori[i].Credito = Giocatori[i].Credito - (Tabellone[x].Valore * MOLTIPLICATORE_PEDAGGIO);
  362. Tabellone[x].Proprietario = i + 1;
  363. printf("\nHai acquistato il terreno! Ti rimangono %f crediti\n\n", Giocatori[i].Credito);
  364. }
  365. }
  366. else{
  367. printf("\n\n");
  368. }
  369. }
  370. else{
  371. z = Tabellone[x].Proprietario - 1;
  372. printf("Il terreno e' del giocatore %d, ovvero %s\n\n", Tabellone[x].Proprietario, Giocatori[z].Nome);
  373. if(Tabellone[x].Costruzioni == 0){
  374. transazioni = Tabellone[x].Valore / 20;
  375. Giocatori[i].Credito = Giocatori[i].Credito - (transazioni * MOLTIPLICATORE_PEDAGGIO);
  376. Giocatori[z].Credito = Giocatori[z].Credito + (transazioni * MOLTIPLICATORE_PEDAGGIO);
  377. printf("Nel terreno non sono presenti costruzioni, quindi dovrai pagare %f crediti. Ti rimangono %f crediti\n\n", transazioni * MOLTIPLICATORE_PEDAGGIO, Giocatori[i].Credito);
  378. }
  379. else if(Tabellone[x].Costruzioni == 1){
  380. transazioni = Tabellone[x].Valore / 10;
  381. Giocatori[i].Credito = Giocatori[i].Credito - (transazioni * MOLTIPLICATORE_PEDAGGIO);
  382. Giocatori[z].Credito = Giocatori[z].Credito + (transazioni * MOLTIPLICATORE_PEDAGGIO);
  383. printf("Nel terreno e' presente una scrivania, quindi dovrai pagare %f crediti. Ti rimangono %f crediti\n\n", transazioni * MOLTIPLICATORE_PEDAGGIO, Giocatori[i].Credito);
  384. }
  385. else if(Tabellone[x].Costruzioni == 2){
  386. transazioni = Tabellone[x].Valore / 5;
  387. Giocatori[i].Credito = Giocatori[i].Credito - (transazioni * MOLTIPLICATORE_PEDAGGIO);
  388. Giocatori[z].Credito = Giocatori[z].Credito + (transazioni * MOLTIPLICATORE_PEDAGGIO);
  389. printf("Nel terreno e' presente una tenda, quindi dovrai pagare %f crediti. Ti rimangono %f crediti\n\n", transazioni * MOLTIPLICATORE_PEDAGGIO, Giocatori[i].Credito);
  390. }
  391. }
  392. }
  393. }
  394.  
  395. //Assegna_Terreni é una funzione il quale scopo é quello di assegnare randomicamente i terreni ai vari giocatori
  396.  
  397. void Assegna_Terreni(int numero_giocatori, Giocatore *Giocatori){
  398. int j = 0, y = 0, x = 0, divisore_terreni = 0, i = 0, terreni_da_dare = 0, terreni_random[24], scala_soldi = 0;
  399. int terreni_ordinati[24] = {1,3,4,6,8,9,11,13,14,16,18,19,21,23,24,26,28,29,31,33,34,36,38,39};
  400. int randomRange = 23;
  401. divisore_terreni = 24 / numero_giocatori;
  402. //avvio scamble dei terreni
  403. srand(time(NULL));
  404. i = 0;
  405. for(i = 0; i < 24; i++){
  406. //estraggo terreno a caso
  407. if(randomRange > 0){
  408. x = rand() % randomRange + 1;
  409. }
  410. else{
  411. x = 0;
  412. }
  413. terreni_random[i] = terreni_ordinati[x];
  414. terreni_ordinati[x] = 0;
  415. Compatta_Vettore(terreni_ordinati);
  416. randomRange--;
  417. if(randomRange < 0){
  418. randomRange = 0;
  419. }
  420. }
  421. j = 0;
  422. for(i = 0; i < numero_giocatori; i++){
  423. scala_soldi = 0;
  424. for(x = 0; x < divisore_terreni; x++){
  425. scala_soldi = scala_soldi + Tabellone[y].Valore;
  426. y = terreni_random[j];
  427. Tabellone[y].Proprietario = i + 1;
  428. j++;
  429. }
  430. Giocatori[i].Credito = Giocatori[i].Credito - scala_soldi;
  431. }
  432. Stampa_Tabellone(Tabellone);
  433. }
  434.  
  435. //La funzione Compatta_Vettore serve per spostare tutti gli zeri dalla parte sinistra alla parte destra, in modo da avere i numeri dei terreni da assegnare nella parte sinistra del vettore
  436.  
  437. void Compatta_Vettore(int* vettore){
  438. int vettore_compattato[24];
  439. int i, tmp = 0;
  440. for (i = 0; i < 24; i++){
  441. vettore_compattato[i] = 0;
  442. }
  443. tmp = 0;
  444. for(i = 0; i < 24; i++){
  445. if(vettore[i] != 0){
  446. vettore_compattato[tmp] = vettore[i];
  447. tmp++;
  448. }
  449. }
  450. for(i = 0; i < 24; i++){
  451. vettore[i] = vettore_compattato[i];
  452. }
  453. }
  454.  
  455. //La funzione Sposta_Giocatori ha lo scopo di spostare la posizione del giocatore all'interno del tabellone di gioco
  456.  
  457. void Sposta_Giocatore(Giocatore *Giocatori, int somma_dadi, int i, int numero_giocatori){
  458. int x = 0;
  459. Giocatori[i].Posizione = Giocatori[i].Posizione + somma_dadi;
  460. if(Giocatori[i].Posizione > 39){
  461. Giocatori[i].Posizione = Giocatori[i].Posizione - 40;
  462. Giocatori[i].Credito = Giocatori[i].Credito + 20;
  463. }
  464. x = Giocatori[i].Posizione;
  465. printf("\n%s, sei in posizione %d\n\n", Giocatori[i].Nome, Giocatori[i].Posizione);
  466. printf("Sei finito nel terreno: %s\n\n", Tabellone[x].Nome);
  467. Azione_Tipo(Giocatori, x, i, numero_giocatori);
  468. }
  469.  
  470. //La funzione Avvia_Partita serve a dare appunto l'avvio alla partita. Da qua iniziera' (o continuera') il viaggio nel Palazzo delle Scienze
  471.  
  472. void Avvia_Partita(int numero_giocatori, Giocatore *Giocatori, int scelta_menu){
  473. int dado1 = 0, dado2 = 0, i = 0, ingioco = numero_giocatori, somma_dadi = 0, dadi_uguali = 0, turni_fallimento[numero_giocatori], y = 0, contatore_turni = 0;
  474. char scelta_gioco;
  475. if(scelta_menu == 2){
  476. Carica_Partita(numero_giocatori, contatore_turni, i);
  477. }
  478. while(ingioco != 0){
  479. for(i = 0; i < numero_giocatori; i++){
  480. if(Giocatori[i].Fallimento == 0){
  481. if(Giocatori[i].Turni_Prigione == 0){
  482. printf("\nGiocatore %d, %s\n\n", i + 1, Giocatori[i].Nome);
  483. printf("Premi T per tirare i dadi, S per salvare la partita\n\n");
  484. scanf("%c", &scelta_gioco);
  485. getchar();
  486. while(scelta_gioco != 'T' && scelta_gioco != 't' && scelta_gioco != 'S' && scelta_gioco != 's'){
  487. printf("\nHai sbagliato scelta. Premi T per tirare i dadi, S per salvare la partita\n\n");
  488. scanf("%c", &scelta_gioco);
  489. getchar();
  490. }
  491. printf("\n\n");
  492. if(scelta_gioco == 'S' || scelta_gioco == 's'){
  493. Salva_Partita(numero_giocatori, contatore_turni, i);
  494. }
  495. else if(scelta_gioco == 'T' || scelta_gioco == 't'){
  496. dado1 = 0;
  497. dado2 = 0;
  498. dadi_uguali = 0;
  499. srand(time(NULL));
  500. do{
  501. dado1 = Tira_Dado();
  502. dado2 = Tira_Dado();
  503. printf("\nIl primo dado ha fatto %d, il secondo dado ha fatto %d\n\n", dado1, dado2);
  504. somma_dadi = dado1 + dado2;
  505. Sposta_Giocatore(Giocatori, somma_dadi, i, numero_giocatori);
  506. if(dado1 == dado2 && dadi_uguali < 3){
  507. printf("Hai fatto coppia, ritira!\n\n");
  508. dadi_uguali++;
  509. }
  510. if(dadi_uguali == 3){
  511. printf("Hai fatto per la terza volta i dadi uguali, quindi finirai in prigione\n\n");
  512. Giocatori[i].Turni_Prigione = 3;
  513. Giocatori[i].Posizione = BAGNI;
  514. dado1 = 1;
  515. dado2 = 0;
  516. }
  517. }
  518. while(dado1 == dado2);
  519. }
  520. if(Giocatori[i].Credito < 0){
  521. turni_fallimento[i]++;
  522. printf("Hai finito questo turno in bancarotta, stai per rischiare di fallire. Fallirai se rimarrai 3 turni consecutivi in bancarotta. Attualmente sei al turono %d su 3\n\n", turni_fallimento[i]);
  523. }
  524. if(turni_fallimento[i] == 3){
  525. printf("Sei in bancarotta da 3 turni. Hai perso\n\n");
  526. Giocatori[i].Fallimento == 1;
  527. ingioco--;
  528. for(y = 0; y < TABELLONE; y++){
  529. if(Tabellone[y].Proprietario == i + 1){
  530. Tabellone[y].Proprietario = 0;
  531. }
  532. }
  533. }
  534. }
  535. else{
  536. Giocatori[i].Turni_Prigione--;
  537. printf("Giocatore %d, ovvero %s, sei in prigione, e ti restano altri %d turni\n\n", i + 1, Giocatori[i].Nome,Giocatori[i].Turni_Prigione);
  538. }
  539. }
  540. printf("Il tuo turno e' finito\n\n");
  541. contatore_turni++;
  542. Cancella_Schermo();
  543. }
  544. }
  545. }
  546.  
  547. void Salva_Partita(int numero_giocatori, int contatore_turni, int i){
  548. FILE * fp = fopen("Salvataggio.dat", "wb");
  549. if(fp == NULL){
  550. printf("Impossibile salvare il gioco/n/n");
  551. exit(0);
  552. }
  553. fwrite(numero_giocatori, sizeof(int), 1, fp);
  554. fwrite(contatore_turni, sizeof(int), 1, fp);
  555. fwrite(i, sizeof(int), 1, fp);
  556. fclose(fp);
  557. }
  558.  
  559. void Carica_Partita(int numero_giocatori, int contatore_turni, int i){
  560. FILE * fp = fopen("Salvataggio.dat", "rb");
  561. if(fp == NULL){
  562. printf("Impossibile caricare il gioco/n/n");
  563. exit(0);
  564. }
  565. fread(numero_giocatori, sizeof(int), 1, fp);
  566. fread(contatore_turni, sizeof(int), 1, fp);
  567. fread(i, sizeof(int), 1, fp);
  568. fclose(fp);
  569. }
  570.  
  571. //Cancella_Schermo é una funzione con un unico scopo: fare un po' di pulizia all'interno dello schermo
  572.  
  573. void Cancella_Schermo(){
  574. printf("\nPremi INVIO per continuare\n\n");
  575. getchar();
  576. system("cls");
  577. }
  578.  
  579. int main()
  580. {
  581. int numero_giocatori = 0,i = 0, j = 0, scelta_menu = 0, dado1 = 0, dado2 = 0;
  582. float costo_terreno[TABELLONE] = {0,60,0,60,80,0,100,0,100,120,0,140,0,140,160,0,180,0,180,200,0,220,0,220,240,0,260,0,260,280,0,300,0,300,320,0,360,0,360,400};
  583. char nome_terreno[TABELLONE][50+1] = {"VIA!", "AULA G", "SFIGA!", "AULA C", "AULA F", "TASSE!", "AULA STUDIO", "SFIGA!", "SIMAZ", "LAB T", "BAGNI", "VAX", "SFIGA!", "G.A.R.", "BIBLIOTECA", "TASSE!", "AULA B", "SFIGA!", "SEGRETERIA", "AULA A", "CORRIDOIO", "UFFICIO SCATENI", "SFIGA!", "BAGNO PROF.", "AULA D", "TASSE!", "LAB 3", "SFIGA!", "LAB 4", "LAB M", "BATCAVERNA!", "AULA M FISICA", "SFIGA!", "AULA M CHIMICA", "AULA M MATEMATICA", "TASSE!", "BAR ROTONDO", "SFIGA!", "AULA ANATOMICA", "AULA COSTA"};
  584. Giocatore Giocatori[numero_giocatori];
  585. printf("Monopoly: Palazzo delle Scienze Edition\n\n");
  586. printf("1 - Nuova Partita\n2 - Carica Partita\n\n");
  587. scanf("%d", &scelta_menu);
  588. getchar();
  589. while(scelta_menu != 1 && scelta_menu != 2){
  590. printf("\nScelta non valida, inserisci 1 per iniziare una nuova partita o 2 per caricare una vecchia partita\n\n");
  591. scanf("%d", &scelta_menu);
  592. getchar();
  593. }
  594. Cancella_Schermo();
  595. if(scelta_menu == 1){
  596. printf("\n\nHai scelto di iniziare una nuova partita! Inserisci il numero dei giocatori, assicurandoti che sia un numero compreso tra 2 e 8\n\n");
  597. scanf("%d", &numero_giocatori);
  598. getchar();
  599. while(numero_giocatori < 2 || numero_giocatori > 8){
  600. printf("\nScelta non valida, inserisci un valore tra 2 e 8\n\n");
  601. scanf("%d", &numero_giocatori);
  602. getchar();
  603. }
  604. // Inizializzo i terreni da zero
  605. for(i = 0; i < TABELLONE; i++){
  606. strcpy(Tabellone[i].Nome, nome_terreno[i]);
  607. Tabellone[i].Tipo = Ottieni_Tipologia_Terreno(i);
  608. Tabellone[i].Valore = costo_terreno[i];
  609. Tabellone[i].Posizione = i;
  610. Tabellone[i].Costruzioni = 0;
  611. Tabellone[i].Proprietario = 0;
  612. }
  613. // Inizializzo i giocatori da zero
  614. for(i = 0; i < numero_giocatori; i++){
  615. printf("\nGiocatore %d, inserisci il tuo nome\n\n", i+1);
  616. scanf("%s", &Giocatori[i].Nome);
  617. getchar();
  618. Giocatori[i].Credito = 12000/numero_giocatori;
  619. Giocatori[i].Posizione = 0;
  620. Giocatori[i].Turni_Prigione = 0;
  621. Giocatori[i].Fallimento = 0;
  622. }
  623. Cancella_Schermo();
  624. printf("\nVuoi che i terreni siano assegnati casualmente?\n\n1 = Si, 2 = No\n\n");
  625. scanf("%d", &scelta_menu);
  626. getchar();
  627. while(scelta_menu != 1 && scelta_menu != 2){
  628. printf("\nScelta non valida, inserisci 1 per assegnare i terreni casualmente o 2 per non assegnare nessun terreno\n\n");
  629. scanf("%d", &scelta_menu);
  630. getchar();
  631. }
  632. Cancella_Schermo();
  633. if(scelta_menu == 1){
  634. Assegna_Terreni(numero_giocatori, Giocatori);
  635. }
  636. }
  637. Cancella_Schermo();
  638. printf("Caricamento in corso, attendere...\n\n");
  639. Carica_Sfighe();
  640. printf("Tutto e' pronto, buona partita!\n\n");
  641. Cancella_Schermo();
  642. Avvia_Partita(numero_giocatori, Giocatori,scelta_menu);
  643. return 0;
  644. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement