×

Welcome to TagMyCode

Please login or create account to add a snippet.
0
0
 
0
Language: Pascal
Posted by: Massimo Zappino
Added: Feb 15, 2011 8:10 AM
Views: 146
  1. {*********************************************************************************************
  2. PROGRAM NAME     : funghi_nascosti
  3.  
  4. PROGRAMMERS      : Massimo Zappino
  5.  
  6. DESCRIPTION      : Programma in grado di riprodurre il gioco funghi nascosti il cui scopo è quello di
  7.                                    riuscire ad individuare tutti i funghi senza calpestarli. E' anche possibile salvare
  8.                                    una partita per riprenderla in futuro ed è possibile salvare una partita giocata da rivedere       
  9.  
  10. DATE             : Iniziato il 16/06/2003;
  11.                    Terminato il 25/06/2003.
  12.              
  13. COMPILE          : Irie Pascal for Windows    
  14.  
  15. SYSTEM           : Windows XP
  16.              
  17. BUGS             : il programma va in crash se i file aperti in lettura non esistono
  18.  
  19. *********************************************************************************************}
  20. program funghi_nascosti (f,input,output);
  21. const
  22.         max_colonne=20;         {valore massimo delle colonne della matrice}
  23.         max_righe=20;           {valore massimo delle righe della matrice}
  24.         num_righe=9;            {valore di default per l'altezza della matrice}
  25.         num_colonne=9;          {valore di default per la larghezza della matrice}
  26.  
  27. type
  28.         matrice_campo=array[1..max_righe,1..max_colonne] of char; {definisce il tipo della matrice di gioco}
  29.         lista=^nodo;
  30.         nodo=record              {dichiarazione della lista}
  31.                 val_x:char;
  32.                 val_y:char;
  33.                 next:lista;
  34.         end;
  35.  
  36. var
  37.         numero_menu: char;                              {variabile usata per memorizzare la scelta del menu}
  38.         matrice: matrice_campo;                 {matrice contenente i valori del gioco}
  39.         matricegioco: matrice_campo;    {matrice contenente i valori del gioco}
  40.     p,head:lista;                                       {puntatori della lista contenente le coordinate}
  41.         righe,colonne,funghi:integer;   {valori globali delle righe, colonne e funghi}
  42.         f: text;                                                {variabile utilizzata per il salvataggio su file delle partite}
  43.  
  44.  
  45. {**************************************************************************************************************************}
  46.  
  47.  
  48. {PROCEDURE PULISCI_SCHERMO
  49.  
  50.  SCOPO:cancella tutti i dati presenti a video
  51.  
  52.  EFFETTI COLLATERALI:nessuno}
  53.  procedure pulisci_schermo;
  54.  begin
  55.         clrscr;
  56.  end;
  57.  
  58.  
  59. {**************************************************************************************************************************}
  60.  
  61.  
  62. {PROCEDURE STAMPA_VALORI_GIOCO
  63.  
  64.  SCOPO: stampa a video l'intestazione della partita in corso
  65.  
  66.  EFFETTI COLLATERALI:
  67.  
  68.  CALLED BY: nuova_partita, avvia_gioco  
  69.  
  70.  PARAMETERS: }
  71.  
  72. procedure stampa_valori_gioco;
  73. begin {stampa_valori_gioco}
  74.     writeln;
  75.         writeln("Righe: ",righe:1,"    Colonne: ",colonne:1,"    Funghi: ",funghi:1);
  76.         writeln;
  77.  
  78. end; {stampa_valori_gioco}
  79.  
  80.  
  81. {********************************************************************************************}
  82.  
  83.  
  84. {PROCEDURE DISEGNA_MATRICE
  85.  
  86.  SCOPO: stampare a video la matrice passata alla procedura
  87.  
  88.  EFFETTI COLLATERALI:
  89.  
  90.  CALLED BY: avvia_gioco,nuova_partita  
  91.  
  92.  PARAMETERS: matrice_passata = matrice da stampare a video }
  93.  
  94. procedure disegna_matrice(matrice_passata:matrice_campo);
  95. var
  96.         i,j : integer;
  97.         c: char;
  98.  
  99. begin {disegna_matrice}
  100.         c:=pred("a");
  101.         write(" ");
  102.     for i:=1 to colonne do begin                 {scrive la prima riga di lettere}
  103.         write(succ(c));
  104.         c:=succ(c);
  105.     end;
  106.         writeln;
  107.         c:=pred("a");
  108.     for j:=1 to righe do begin
  109.                 write(succ(c));                         {scrive la prima colonna di lettere}
  110.                 c:=succ(c);
  111.         for i:=1 to colonne do begin
  112.                         write(matrice_passata[i,j]);
  113.             end;
  114.             writeln;
  115.         end;
  116. end; {disegna_matrice}
  117.  
  118.  
  119. {********************************************************************************************}
  120.  
  121.  
  122. {PROCEDURE INIZIALIZZA_MATRICE_GIOCO
  123.  
  124.  SCOPO: inserisce un asterisco * per ogni cella della matrice gioco
  125.  EFFETTI COLLATERALI:
  126.  
  127.  CALLED BY: nuova_partita,carica_partita  
  128.  
  129.  PARAMETERS: }
  130.  
  131.  
  132. procedure inizializza_matrice_gioco;
  133. var
  134.         i,j:integer;
  135.  
  136. begin  {inizializza_matrice_gioco}
  137.         for i:=1 to max_righe do begin
  138.                 for j:=1 to max_colonne do
  139.                         matricegioco[i,j]:="*";
  140.         end;
  141. end;  {inizializza_matrice_gioco}
  142.  
  143.  
  144. {********************************************************************************************}
  145.  
  146.  
  147. {PROCEDURE AVVIA_GIOCO
  148.  
  149.  SCOPO: avviare la partita prendendo come input le coordinate e stampando a video la matrice
  150.  
  151.  EFFETTI COLLATERALI:
  152.  
  153.  CALLED BY: nuova_partita,carica_partita
  154.  
  155.  PARAMETERS: ripristino_partita,rivedi = booleani che indicano il tipo di partita }
  156.  
  157. procedure avvia_gioco(ripristino_partita,rivedi:boolean);
  158. var
  159.         x,y:char;               {valori letterali corrispondenti alle coordinate}
  160.         i,j,mosse:integer;
  161.         vinto,perso,soluzione,termina:boolean;
  162.         c:char;                 {selettore menu}
  163.  
  164. {************************************************}
  165.  
  166.  
  167. {PROCEDURE SALVA_PARTITA
  168.  
  169.  SCOPO: salvare su file la partita in corso (rivedi o ripristina)
  170.  
  171.  EFFETTI COLLATERALI:
  172.  
  173.  CALLED BY: avvia_gioco
  174.  
  175.  PARAMETERS: tipo = identifica se è "rivedi" o "ripristina"}
  176.  
  177. procedure salva_partita(tipo:string);
  178. var
  179.         nomefile: string;       {variabile che conterrà il nome del file da salvare}
  180.         i,j:integer ;
  181.        
  182. begin {salva_partita}
  183.         clrscr;
  184.         writeln("Salvataggio partita");
  185.         writeln;
  186.         writeln;
  187.         p:=head;
  188.         repeat
  189.                 write("Scrivi il nome del file da salvare: ");
  190.                 readln(nomefile);
  191.         until nomefile<>"";
  192.         rewrite(f,nomefile);
  193.         writeln(f,tipo);
  194.         writeln(f,"#");
  195.         for i:=1 to righe do begin
  196.                 for j:=1 to colonne do
  197.                         write(f, matrice[j,i]);
  198.                 writeln(f);
  199.         end;    
  200.         writeln(f,"#");
  201.         while p^.next<>nil do begin
  202.                 writeln(f,p^.val_x,p^.val_y);
  203.                 p:=p^.next;
  204.         end;
  205.         writeln;
  206.         writeln("Il file '",nomefile,"' e' stato salvato correttamente.");
  207.         writeln("Premere INVIO per continuare...");
  208.         rewrite(f,"temp_file");     {viene fatto puntare f ad un file temporaneo per far si che il file da salvare venga chiuso
  209.                                                                         e sia quindi possibile scrivere i dati al suo interno}
  210.         readln;
  211.        
  212. end {salva_partita};
  213.  
  214.  
  215. {************************************************}
  216.  
  217.  
  218. {FUNCTION CONTA_FOGLIE_RIMASTE
  219.  
  220. SCOPO: restituire il numero di foglie rimaste nella matrice gioco
  221.  
  222. EFFETTI COLLATERALI:
  223.  
  224. CALLED BY: avvia_gioco  
  225.  
  226.  PARAMETERS: matrice_passata = matrice gioco}                  
  227.  
  228. function conta_foglie_rimaste(matrice_passata:matrice_campo):integer;
  229. var
  230.         i,j,contatore:integer;
  231.        
  232. begin {conta_foglie_rimaste}
  233.         contatore:=0;
  234.         for i:=1 to righe do
  235.                 for j:=1 to colonne do
  236.                         if matrice_passata[i,j]="*" then
  237.                                 contatore:=contatore+1;
  238.         conta_foglie_rimaste:=contatore;
  239. end; {conta_foglie_rimaste}
  240.  
  241.  
  242. {************************************************}
  243.  
  244.  
  245. {FUNCTION CONTROLLA_INPUT_COORDINATE
  246.  
  247. SCOPO: restituire true se le coordinate inserite sono corrette
  248.  
  249. EFFETTI COLLATERALI:
  250.  
  251. CALLED BY: avvia_gioco
  252.  
  253.  PARAMETERS: i = carattere inserito, parametro = intero che identifica la grandezza massima di righa o colonna }       
  254.                                                        
  255. function controlla_input_coordinate(i:char;parametro:integer):boolean;
  256.  
  257. begin {controlla_input_coordinate}
  258.         if (i>="a") and (i<=(chr(ord(parametro)+96))) or (i="0") then
  259.         begin
  260.                 controlla_input_coordinate:=true
  261.         end
  262.         else
  263.                 controlla_input_coordinate:=false;
  264. end; {controlla_input_coordinate}
  265.  
  266.  
  267. {************************************************}
  268.  
  269.  
  270. {PROCEDURE APRI_MENU_RAPIDO
  271.  
  272. SCOPO: visualizza sullo schermo il menu rapido durante la partita
  273.  
  274. EFFETTI COLLATERALI:
  275.  
  276. CALLED BY:  avvia_gioco
  277.  
  278.  PARAMETERS: }         
  279.  
  280. procedure apri_menu_rapido;
  281. var
  282.         c:char;
  283. begin {apri_menu_rapido}
  284.         repeat
  285.           pulisci_schermo;
  286.                 writeln;
  287.                 writeln("*** Menu Rapido ***");
  288.                 writeln;
  289.                 writeln(" 1 Salva Partita");
  290.                 writeln(" 2 Mostra soluzione");
  291.                 writeln(" 3 Termina partita");
  292.                 writeln(" 0 Ritorna alla Partita");
  293.                 writeln;
  294.                 write("Opera una scelta: ");
  295.                 readln(c);
  296.         until (c="1") or (c="2") or (c="3") or (c="0");
  297.    if c="3" then termina:=true;
  298.         if c="2" then begin
  299.                 soluzione:=true;
  300.                 termina:=false;
  301.         end;
  302.         if c="1" then begin
  303.                 p^.next:=nil;
  304.                 salva_partita("riprendi")
  305.         end;
  306. end; {apri_menu_rapido}
  307.  
  308.  
  309. {************************************************}
  310.  
  311.  
  312. {PROCEDURE SCOPRI_CASELLE
  313.  
  314. SCOPO: scopre le celle vuote adiacenti tra loro e quelle confinanti conteneti un numero
  315.                 tramite la ricorsione della procedura
  316.  
  317. EFFETTI COLLATERALI:
  318.  
  319. CALLED BY: avvia_gioco;
  320.  
  321.  PARAMETERS: i,j= coordinate che indicano la cella in questione}       
  322.  
  323. procedure scopri_caselle(i,j:integer);
  324. var
  325.         x,x1,x2,y,y1,y2: integer;
  326.        
  327. begin {scopri_caselle}
  328.                                 matricegioco[i,j]:=" ";
  329.                                 if i<>1 then x1:=i-1 else x1:=i;
  330.                                 if i<>colonne then x2:=i+1 else x2:=i;
  331.                                 if j<>1 then y1:=j-1 else y1:=j;
  332.                                 if j<>righe then y2:=j+1 else y2:=j;                           
  333.                                 for x:=x1 to x2 do begin
  334.                                         for y:=y1 to y2 do
  335.                                                 if matricegioco[x,y]<>" " then
  336.                                                 begin
  337.                                                         if matrice[x,y]<>" " then
  338.                                                                 matricegioco[x,y]:=matrice[x,y]
  339.                                                         else
  340.                                                                 scopri_caselle(x,y)
  341.                                                 end;
  342.                                 end;
  343.                
  344. end; {scopri_caselle}
  345.  
  346.  
  347. {************************************************}
  348.  
  349.  
  350. {PROCEDURE ESEGUI_MOSSE_SALVATE
  351.  
  352. SCOPO: esegue in automatico le mosse di una partita salvata lette dalla lista
  353.  
  354. EFFETTI COLLATERALI:
  355.  
  356. CALLED BY: avvia_gioco  
  357.  
  358.  PARAMETERS: ripristino_partita = parametro che indica se la partita era salvata}      
  359.  
  360. procedure esegui_mosse_salvate(var ripristino_partita:boolean);
  361. var
  362.         j,i:integer;
  363.         x,y:char;
  364.  
  365. begin {esegui_mosse_salvate}
  366.         p:=head;
  367.         while p^.next<>nil do begin
  368.        x:=p^.val_x;
  369.                 y:=p^.val_y;
  370.                 i:=ord(x)-96;         {trasforma la lettera inserita nel numero della riga corrispondente}
  371.                 j:=ord(y)-96;             {trasforma la lettera inserita nel numero della colonna corrispondente}                                      
  372.                 if matricegioco[i,j]<>"*" then begin
  373.                         writeln("La cella che hai selezionata e' già scoperta.");
  374.                         readln;
  375.                 end
  376.                 else
  377.                 begin
  378.                         if matrice[i,j]=" " then
  379.                         begin
  380.                                 scopri_caselle(i,j);
  381.                                 mosse:=mosse+1
  382.                         end
  383.                         else
  384.                         begin
  385.                                 matricegioco[i,j]:=matrice[i,j];
  386.                                 mosse:=mosse+1;
  387.                         end;
  388.                 end;
  389.     p:=p^.next;
  390.         end;
  391.         ripristino_partita:=false;
  392.         {ora il puntatore della lista punta all'ultima posizione cioè alla coda della lista}
  393. end; {esegui_mosse_salvate}
  394.  
  395.  
  396. {************************************************}
  397.  
  398.  
  399. {PROCEDURE CANCELLA_LISTA
  400.  
  401.  SCOPO: esegue in automatico le mosse di una partita salvata lette dalla lista
  402.  
  403.  EFFETTI COLLATERALI:
  404.  
  405.  CALLED BY: avvia_gioco  
  406.  
  407.  PARAMETERS: } 
  408.    
  409. procedure cancella_lista;
  410. var
  411.         q:lista;
  412. begin {cancella_lista}
  413.                 p:=head;
  414.                 while p<>nil do begin
  415.                         q:=p^.next;
  416.                         dispose(p);
  417.                         p:=q;
  418.                 end;
  419. end; {cancella_lista}
  420.  
  421.  
  422. {************************************************}     
  423.  
  424. begin {avvia_gioco}
  425.                 mosse:=0;
  426.                 vinto:=false;
  427.                 perso:=false;
  428.                 termina:=false;      
  429.                 soluzione:=false;
  430.                 p:=head;        
  431.                
  432.                 if ripristino_partita=true then                  {vengono eseguite le mosse precedentemente salvate nella lista}
  433.                         esegui_mosse_salvate(ripristino_partita);
  434.                        
  435.                 while (perso=false) and (vinto=false) and (termina=false) and (soluzione=false) do begin;
  436.                         pulisci_schermo;
  437.                         writeln("AVVIO PARTITA");
  438.                         stampa_valori_gioco;
  439.                         disegna_matrice(matricegioco);
  440.                         writeln;
  441.                         writeln("Numero mosse: ",mosse:1);
  442.                         writeln;
  443.                        
  444.                         if rivedi=false then begin     {se la partita si sta giocando richiedi le coordinate da tastiera}
  445.                                 writeln("Inserisci le coordinate (Scrivi 0 per il Menu rapido): ");
  446.                                 repeat
  447.                                         write("Riga: ");
  448.                                         readln(y);
  449.                                 until controlla_input_coordinate(y,righe)=true;          
  450.                 repeat
  451.                                         write("Colonna: ");
  452.                                         readln(x);
  453.                                 until controlla_input_coordinate(x,colonne)=true;
  454.                         end;
  455.                        
  456.                         if rivedi=true then begin     {se la partita è da rivedere legge le coordinate dalla lista}
  457.                         x:=p^.val_x;
  458.                                 y:=p^.val_y;
  459.                         p:=p^.next;
  460.                         writeln("Riga: ",x:1);
  461.                         writeln("Colonna: ",y:1);
  462.                         readln;                   {attende l'input utente}
  463.                         end;
  464.  
  465.                         if (x="0") or (y="0") then  {apre il menu rapido se una coordinata è uguale a 0}
  466.                 apri_menu_rapido
  467.                         else
  468.                         begin {Else}
  469.                                 i:=ord(x)-96;         {trasforma la lettera inserita nel numero della riga corrispondente}
  470.                                 j:=ord(y)-96;             {trasforma la lettera inserita nel numero della colonna corrispondente}                      
  471.                         if matrice[i,j]="@" then
  472.                                 perso:=true
  473.                                 else
  474.                                 begin
  475.                                         if matricegioco[i,j]<>"*" then begin                     {fa ripetere l'inserimento se la cella è già scoperta}
  476.                                                 writeln("La cella che hai selezionata e' già scoperta.");
  477.                                                 readln;
  478.                                         end
  479.                                         else
  480.                                         begin
  481.                                                 if matrice[i,j]=" " then {se la matrice dati è vuota allora chiama la procedura scopri_caselle}
  482.                                                 begin
  483.                                                         scopri_caselle(i,j);
  484.                                                         mosse:=mosse+1
  485.                                                 end
  486.                                                 else
  487.                                                 begin
  488.                                                         matricegioco[i,j]:=matrice[i,j]; {se la matrice dati contiene un valore non vuoto e senza @ allora mostra la cella}
  489.                                                         mosse:=mosse+1;
  490.                                                 end;
  491.                                         end;
  492.                                 end;
  493.                         if rivedi=false then begin             
  494.                                 p^.val_x:=x;            {salva nella prima variabile del record il valore di x}
  495.                                 p^.val_y:=y;                    {salva nella seconda variabile del record il valore di y}
  496.                                 new(p^.next);           {crea una nuova variabile dinamica che conterrà le prossime coordinate}
  497.                                 p:=p^.next;             {sposta il puntatore p alla nuova cella di memoria creata}
  498.                         end;
  499.                                        
  500.                         if conta_foglie_rimaste(matricegioco)=funghi then   {verifica che il numero di foglie rimaste e i funghi da scoprire siano uguali}
  501.                                 vinto:=true;                                                                    {se è vero allora la partita è vinta}        
  502.                     end; {Else}
  503.         end {While};
  504.        
  505.     p^.next:=nil;               {termina la lista}
  506.            
  507.     pulisci_schermo;            {se la partita è terminata viene eseguita questa parte codice}
  508.         if termina=false then begin
  509.                 writeln("AVVIO PARTITA");
  510.                 stampa_valori_gioco;
  511.                 disegna_matrice(matrice);   {viene richiamata la matrice di codice contenente i valori di gioco}
  512.                 writeln;
  513.                 writeln("Numero mosse: ",mosse:1);
  514.                 writeln;
  515.                 if soluzione=false then
  516.                 begin
  517.                         if vinto=true then
  518.                                 writeln("HAI VINTO!")
  519.                         else
  520.                                 writeln("HAI PERSO!"); 
  521.                         repeat
  522.                                 write("Desideri salvare questa partita per visionarla in futuro? (S/N): ");
  523.                                 readln(c);
  524.                         until (c="s") or (c="S") or (c="n") or (c="N");
  525.                         case c of
  526.                         "s","S": salva_partita("rivedi");
  527.                         otherwise
  528.                         end      
  529.                 end
  530.                 else
  531.                 begin
  532.                         writeln("Hai deciso di mostrare la soluzione di questa partita.");
  533.                         write("Partita terminata. Premi INVIO per tornare al menu principale");
  534.                         readln;
  535.                 end;
  536.         end
  537.         else
  538.         begin
  539.                 write("Partita terminata. Premere INVIO per tornare al menu principale");
  540.                 readln
  541.         end;
  542. cancella_lista;                 {chiama la procedura che cancella la lista creata}             
  543. end; {avvia_gioco}
  544.  
  545.  
  546. {********************************************************************************************}
  547.  
  548.  
  549. {PROCEDURE NUOVA_PARTITA
  550.  
  551. SCOPO: avviare una nuova partita prendendo come parametri i valori della matrice di default
  552.  
  553. EFFETTI COLLATERALI:
  554.  
  555. CALLED BY: main
  556.  
  557. PARAMETERS: righe,colonne,funghi=parametri che indicano le generalità della matrice}
  558.  
  559. procedure nuova_partita(var righe,colonne,funghi:integer);
  560. var
  561.         d:char;                                 {variabile contenente la selezione del menu}
  562.         inizio_gioco: boolean;          {vittoria: sarà true quando la partita sarà vinta}
  563.         mosse:integer;
  564.        
  565. {************************************************}
  566.        
  567. {PROCEDURE CAMBIA_PARAMETRI
  568.  
  569. SCOPO: modificare i parametri di gioco (righe, colonne e funghi)
  570.  
  571. EFFETTI COLLATERALI:
  572.  
  573. CALLED BY: nuova_partita
  574.  
  575. PARAMETERS: righe,colonne,funghi=parametri che indicano le generalità della matrice}
  576.  
  577. procedure cambia_parametri(var righe,colonne,funghi:integer);
  578.  
  579. begin
  580.    pulisci_schermo;
  581.         writeln("Cambia parametri di gioco");
  582.         writeln;
  583.         repeat
  584.         write("Inserisci la dimensione della larghezza (2-",(max_colonne):1,"): ");
  585.                         readln(colonne);
  586.         until (colonne > 1) and (colonne < (max_colonne+1));
  587.         writeln("--------------------------------");
  588.         repeat
  589.                 write("Inserisci la dimensione dell'altezza (2-",(max_righe):1,"): ");
  590.                 readln(righe);
  591.         until (righe > 1) and (righe < (max_righe+1));
  592.        
  593.         writeln("--------------------------------");
  594.  
  595.         repeat
  596.                 write("Inserisci il numero di funghi (2-",(righe*colonne-2):1,"): ");
  597.                 readln(funghi);
  598.         until (funghi < (righe*colonne-1)) and (funghi > 1);
  599.     pulisci_schermo;
  600. end;  {cambia_parametri;}
  601.  
  602. {************************************************}
  603.  
  604. {PROCEDURE GENERA_MATRICE
  605.  SCOPO: creare la matrice contenente i funghi e il numero dei funghi contenuti nelle celle confinanti
  606.  
  607.  EFFETTI COLLATERALI:
  608.  
  609.  CALLED BY: nuova_partita
  610.  
  611.  PARAMETERS: righe,colonne,funghi=parametri che indicano le generalità della matrice}
  612.  
  613. procedure genera_matrice (righe,colonne,funghi:integer);
  614. var
  615.         x,x1,x2,y,y1,y2,i,j,num_funghi:integer;
  616.        
  617. begin {genera_matrice;}
  618. for i:=1 to max_righe do begin  {cancella tutti gli elementi della matrice}
  619.         for j:=1 to max_colonne do
  620.         matrice[i,j]:=" "
  621. end;
  622.         randomize;
  623.         num_funghi:=0;
  624.         while num_funghi<>funghi do begin             {inserisce un fungo in una cella casuale finchè non viene raggiunto il numero di funghi totale}
  625.                 i:=random(colonne)+1;
  626.                 j:=random(righe)+1;              
  627.                         if matrice[i,j]<>"@" then begin
  628.                                 matrice[i,j]:="@";
  629.                                 num_funghi:=num_funghi + 1;            
  630.                         end;
  631.         end;
  632.        
  633.         for i:=1 to colonne do                                                          {aggiunge gli "1" attorno al fungo sommando eventualmente i numeri precedenti}
  634.                 for j:=1 to righe do begin
  635.                         if matrice[i,j]="@" then begin
  636.                                 if i<>1 then x1:=i-1 else x1:=i;        {considera le celle perimetrali della matrice}
  637.                                 if i<>colonne then x2:=i+1 else x2:=i;
  638.                                 if j<>1 then y1:=j-1 else y1:=j;
  639.                                 if j<>righe then y2:=j+1 else y2:=j;                           
  640.                                 for x:=x1 to x2 do                             
  641.                                         for y:=y1 to y2 do
  642.                                                 if matrice[x,y]<>"@" then
  643.                                                         if matrice[x,y]=" " then
  644.                                                                 matrice[x,y]:="1"
  645.                                                         else
  646.                                                                 matrice[x,y]:=chr(ord(matrice[x,y])+1);
  647.                                         end;
  648.      end;
  649.  
  650. end;  {genera_matrice;}
  651.  
  652.        
  653. {************************************************}
  654.  
  655.  
  656. begin {nuova_partita}
  657. inizio_gioco:=false;
  658.  
  659. while not inizio_gioco=true do begin
  660.         pulisci_schermo;
  661.         writeln("NUOVA PARTITA");      
  662.     stampa_valori_gioco;
  663.         inizializza_matrice_gioco;
  664.         disegna_matrice(matricegioco);
  665.         writeln;
  666.         repeat 
  667.                 write("Desideri cambiare parametri di gioco (S/N)? ");
  668.                 readln(d);
  669.     until (d="s") or (d="S") or (d="n") or (d="N");
  670.     if (d="s") or (d="S") then
  671.                 cambia_parametri(righe,colonne,funghi)    
  672.     else begin
  673.             inizio_gioco:=true;
  674.             genera_matrice(righe,colonne,funghi);
  675.             inizializza_matrice_gioco;
  676.             mosse:=0;
  677.                 avvia_gioco(false,false);              
  678.         end;
  679. end;
  680.  
  681. end; {nuova_partita}
  682.  
  683.  
  684. {************************************************}
  685.  
  686.  
  687. {PROCEDURE CONTROLLA_LETTURA_FILE
  688.  SCOPO: controllare che il file che si sta leggendo è valido
  689.  
  690.  EFFETTI COLLATERALI: se il file richiesto non esiste il programma da un errore; se non esiste nessun file da caricare il programma non permette il ritorno al menu principale
  691.  
  692.  CALLED BY: carica_partita
  693.  
  694.  PARAMETERS: f=variabile di testo contenente il file da leggere, x= stringa contenente una linea del file}
  695.  
  696. procedure controlla_lettura_file(var f:text; var x:string);
  697. var
  698.         nomefile:string;        {variabile contenente il nome del file}
  699.        
  700. begin  {controlla_lettura_file}
  701.                 repeat                          {viene ripetuto il ciclo finchè il file non contiene come prima riga la stringa "riprendi" o "rivedi"}
  702.                         pulisci_schermo;  
  703.                         writeln("Aprertura file");
  704.                         writeln;
  705.                         write("Inserire il nome del file da caricare: ");
  706.                         readln(nomefile);
  707.                         reset(f,nomefile);
  708.                         readln(f,x);
  709.                         if (x<>"rivedi") and (x<>"riprendi") then begin       {se x non è uguale a tipo mostra messaggio di errore}
  710.                                 writeln;
  711.                                 writeln("Il file che stai tentando di caricare non e' valido.");
  712.                                 readln;
  713.                         end;
  714.                 until (x="rivedi") or (x="riprendi");
  715.                 readln(f);
  716.                 writeln;
  717.                 write("Il file caricato e' di tipo: ");
  718.                 if x="rivedi" then
  719.                         writeln("Rivedi Partita")
  720.             else
  721.                 writeln("Riprendi Partita")
  722. end; {controlla_lettura_file}
  723.  
  724.  
  725. {************************************************}
  726.  
  727.  
  728. {PROCEDURE CARICA_MATRICE
  729.  SCOPO: inserire i dati letti dal file nella matrice dati
  730.  
  731.  EFFETTI COLLATERALI:
  732.  
  733.  CALLED BY: carica_partita
  734.  
  735.  PARAMETERS: f = variabile di testo contenente il file da leggere}
  736.  
  737. procedure carica_matrice(var f:text);
  738. var
  739.         stop:boolean;
  740.         temp_colonne:integer;
  741.         t:char;
  742.        
  743. begin {carica_matrice}
  744.         temp_colonne:=0;        {variabile ausiliaria che permette il conteggio temporaneo delle colonne}
  745.         righe:=0;
  746.     colonne:=0;
  747.     stop:=false;
  748.     funghi:=0;
  749.         while stop=false do begin                                                               {viene ripetuto il ciclo finche non viene letto il carattere "#"}
  750.                 while not eoln(f) do begin                                              {legge tutti i caratteri della riga}
  751.                     read(f,t);
  752.                     if t="#" then stop:=true                                            {se il carattere è "#" ferma il loop while}
  753.                     else begin
  754.                         if t="@" then funghi:=funghi+1;
  755.                                         temp_colonne:=temp_colonne+1;                           {incrementa di 1 il numero di colonne temporanee}
  756.                                         matrice[temp_colonne,righe+1]:=t;                       {reimposta le celle della matrice dati}
  757.                                         colonne:=colonne+1;
  758.                                 end;
  759.                 end;
  760.         righe:=righe+1;                                                                         {incrementa di 1 il numero di righe}
  761.         readln(f);
  762.         temp_colonne:=0;                                       
  763.     end;         
  764.  
  765.     righe:=righe-1;                                                                                     {viene sottratta la riga contenente "#"}
  766.     colonne:=colonne div righe;    
  767.  
  768. end; {carica_matrice}
  769.  
  770.  
  771. {************************************************}
  772.  
  773.  
  774. {PROCEDURE INSERISCI_MOSSE_IN_LISTA
  775.  SCOPO: inserire le mosse lette dal file nella lista creata
  776.  
  777.  EFFETTI COLLATERALI:
  778.  
  779.  CALLED BY: carica_partita
  780.  
  781.  PARAMETERS: f = variabile di testo contenente il file da leggere}
  782.  
  783. procedure inserisci_mosse_in_lista(var f:text);
  784. var
  785.         t:char;
  786. begin {inserisci_mosse_in_lista}
  787.     while not eof(f) do begin
  788.                 read(f,t);
  789.                 p^.val_x:=t;
  790.                 read(f,t);
  791.                 p^.val_y:=t;
  792.                 readln(f);
  793.                 new(p^.next);
  794.                 p:=p^.next;
  795.     end;
  796.     p^.next:=nil;
  797. end; {inserisci_mosse_in_lista}
  798.  
  799.  
  800. {********************************************************************************************}
  801.  
  802.  
  803. {PROCEDURE CARICA PARTITA
  804.  SCOPO: caricare da un file di testo le informazioni necessare per ripristinare una partita precedentemente salvata.
  805.                 Viene inizializzata la matrice dati con in valori contenuti nel file, vengono calcolati numero righe, numero colonne,
  806.                 numero funghi della matrice e inoltre vengono salvate nella lista le mosse effettuate prima del salvataggio.
  807.         Il programma riconosce in automatico se il file è un "Rivedi Partita" o un "Ripristina Partita"
  808.  
  809.  EFFETTI COLLATERALI:
  810.  
  811.  CALLED BY: main
  812.  
  813.  PARAMETERS: }
  814.  
  815. procedure carica_partita;
  816. var
  817.         f:text;
  818.         x:string;
  819. begin {carica_partita}
  820.         x:="";
  821.         controlla_lettura_file(f,x);                            {chiama la procedura per effettuare il controllo del file}     
  822.     carica_matrice(f);                                                  {copia la matrice contenuta nel file nella matrice dati del programma e modifica i parametri
  823.                                                                                                 righe,colonne,funghi}    
  824.     inserisci_mosse_in_lista(f);
  825.     writeln("Informazioni di gioco:");      
  826.     writeln;
  827.     writeln("Righe: ",righe:1);
  828.     writeln("Colonne: ",colonne:1);
  829.     writeln("Funghi: ",funghi:1);
  830.     writeln;
  831.     writeln("Premi INVIO per proseguire...");
  832.  
  833.         readln;
  834.         inizializza_matrice_gioco;
  835.    
  836.     if x="rivedi" then
  837.         avvia_gioco(false,true)
  838.     else
  839.         avvia_gioco(true,false)
  840.  
  841. end; {carica_partita}
  842.  
  843. {********************************************************************************************}
  844.  
  845. begin {main}
  846.  
  847. while not (numero_menu in ['0'..'2']) do begin   {Ripete il ciclo finchè non viene inserito un valore corretto}
  848.  
  849.         repeat
  850.                 righe:=num_righe;
  851.                 colonne:=num_colonne;
  852.                 funghi:=10;
  853.                 p:=nil;                 {porta il puntatore della lista a nil}
  854.                 new(p);         {crea una nuova variabile dinamica che è anche la testa della lista}
  855.                 head:=p;                {head corrisponde alla testa della lista}
  856.  
  857.                 pulisci_schermo;
  858.                 writeln;
  859.                 writeln("* FUNGHI NASCOSTI *");
  860.                 writeln;
  861.                 writeln("1. Nuova partita");
  862.                 writeln("2. Apri file salvato");
  863.                 writeln("0. Esci dal gioco");
  864.                 writeln;
  865.                 write("Opera una scelta: ");    
  866.                 readln(numero_menu);
  867.                 writeln;
  868.                 case numero_menu of
  869.                         '0': ;
  870.                         '1': nuova_partita(righe,colonne,funghi);        {passa alla procedura le dimensioni di default del campo}
  871.                         '2': carica_partita;      
  872.                 otherwise
  873.                 end;   
  874.         until numero_menu='0';                  {esci se il valore inserito è '0'}
  875.         end;
  876. end. {main}
  877.