API tools faq
paste
Advertisement
nigu

difesa-aerea-modificato

nigu
Nov 30th, 2014
152
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 8.05 KB | None | 0 0
raw download clone embed print report
  1. /* difesa-aerea-1b.c - RS-2014 [impiego di fork e pipes] */
  2.  
  3. #include <stdio.h>
  4. #include <curses.h>
  5. #include <stdlib.h>
  6. #include <unistd.h>
  7.  
  8. #define UP 65   /* Cursore sopra */
  9. #define DW 66   /* Cursore sotto */
  10. #define SX 68   /* Cursore sinistra */
  11. #define DX 67   /* Cursore destra */
  12. #define MAXX 80 /* Dimensione dello schermo di output (colonne) */
  13. #define MAXY 20 /* Dimensione dello schermo di output (righe)   */
  14. #define DELAY 50000   /* Ritardo nel movimento degli aerei nemici (da adattare) */
  15.  
  16. /* Prototipi delle funzioni adoperate */
  17. void Nemico(int pipeout);
  18. void Amico(int pipeout);
  19. void Area(int pipein);
  20.  
  21.  
  22. /* Struttura adoperata per veicolare le coordinate */
  23. struct position {
  24.   char c;   /* Identificatore dell'entità che invia i dati */
  25.   int  x;    /* Coordinata X */
  26.   int  y;    /* Coordinata Y */
  27. };
  28.  
  29.  
  30. /*
  31. ----------------------------------------------------------------------
  32.  Funzione principale del programma
  33. ----------------------------------------------------------------------
  34. */
  35. int main() {
  36.     int p[2]; /* Descrittori pipe */
  37.     int pidN; /* Pid processo figlio 'Nemico' */
  38.     int pidA; /* Pid processo figlio 'Amico   */
  39.  
  40.     initscr(); /* Inizializza schermo di output */
  41.     noecho(); /* Imposta modalità della tastiera */
  42.     curs_set(0); /* Nasconde il cursore */
  43.    
  44.     pipe(p);    /* Creazione pipe */
  45.  
  46.     srand(time(NULL)); /* Inizializza generatore di numeri casuali */
  47.  
  48.     pidN = fork();  /* Creo il primo processo figlio 'Nemico' */
  49.  
  50.     if(pidN==0) {   /* Se il pid == 0 -> si tratta del processo 'Nemico' */
  51.         Nemico(p[1]); /* ed eseguo quindi la relativa funzione di gestione */        
  52.     }      
  53.     else {     
  54.         pidA=fork(); /* Altrimenti sono ancora nel processo padre e creo il processo 'amico' */
  55.         if(pidA==0) { /* Se il pid == 0 -> si tratta del processo 'amico' */
  56.             mvprintw(MAXY/2,MAXX/2,"#"); /* Visualizzo amico nella posizione iniziale */
  57.             refresh();
  58.             Amico(p[1]); /* ed eseguo quindi la relativa funzione di gestione */
  59.         }
  60.         else {
  61.             Area(p[0]); /* Sono ancora nel processo padre e invoco la funzione Area() */
  62.         }
  63.     }
  64.  
  65.     kill(pidN,1);   /* Termino i processi Nemico e Amico */
  66.     kill(pidA,1);  
  67.  
  68.     endwin();       /* Ripristino la modalità di funzionamento usuale */
  69.  
  70.     printf("\n\n\nGAME OVER\n\n\n");            /* Termino il gioco ed esco dal programma */
  71.  
  72.     return 0;      
  73. }
  74.  
  75. /*
  76. ----------------------------------------------------------------------
  77.  Funzione 'Aereo Nemico'
  78. ----------------------------------------------------------------------
  79. */
  80. void Nemico(int pipeout) {
  81.     struct position nemico;
  82.     int YX=0;               /* Variabile per direzione movimento aereo */
  83.  
  84.     nemico.x = 1;  /* Coordinata X iniziale */
  85.     nemico.y = 1;  /* Coordinata Y iniziale */
  86.     nemico.c ='+';  /* Carattere identificativo */
  87.    
  88.     write(pipeout,&nemico,sizeof(nemico)); /* Comunico le coordinate iniziali al processo padre */
  89.  
  90.     while(1) {
  91.         if(random()<RAND_MAX/2)
  92.             YX=0;
  93.         else
  94.             YX=1;  
  95.    
  96.         if(YX==0) {
  97.             nemico.y = random()%MAXY;
  98.             for(nemico.x=2;nemico.x<MAXX;nemico.x++) { /* Effettuo il percorso da x=0 a x=MAXX */
  99.                 write(pipeout,&nemico,sizeof(nemico)); /* Comunico le coordinate correnti al processo padre */
  100.                 usleep(DELAY); /* Inserisco una pausa per rallentare il movimento */
  101.             }
  102.         }
  103.         else {
  104.             nemico.x = random()%MAXX; /* Genero casualmente una posizione x di partenza */
  105.             for(nemico.y=2;nemico.y<MAXY;nemico.y++) { /* Effettuo il percorso da y=0 a y=MAXY */
  106.                 write(pipeout,&nemico,sizeof(nemico)); /* Comunico le coordinate correnti al processo padre */
  107.                 usleep(DELAY); /* Inserisco una pausa per rallentare il movimento */
  108.             }
  109.         }
  110.      }
  111. }
  112.  
  113. /*
  114. ----------------------------------------------------------------------
  115.  Funzione 'Aereo Amico' - Movimento tramite i tasti cursore
  116. ----------------------------------------------------------------------
  117. */
  118. void Amico(int pipeout) {
  119.     struct position amico;
  120.     char c;
  121.  
  122.     amico.x = MAXX/2;  /* Coordinata X iniziale */
  123.     amico.y = MAXY/2;  /* Coordinata Y iniziale */
  124.     amico.c ='#';   /* Carattere identificativo */
  125.  
  126.     write(pipeout,&amico,sizeof(amico)); /* Comunico le coordinate iniziali al processo padre */
  127.  
  128.    
  129.     while(1) { /* Lettura dei tasti cursore */
  130.         c = getch();
  131.         if(c==UP && amico.y > 0)
  132.             amico.y-=1;
  133.         if(c==DW && amico.y < MAXY-1)
  134.             amico.y+=1;
  135.         if(c==SX && amico.x > 0)                       
  136.             amico.x-=1;                
  137.         if(c==DX && amico.x < MAXX-1)  
  138.             amico.x+=1;
  139.         write(pipeout,&amico,sizeof(amico)); /* Comunico al processo padre le coordinate dell'aereo amico */
  140.     }
  141. }
  142.  
  143. /*
  144. ----------------------------------------------------------------------
  145.  Funzione relativa al processo di visualizzazione e controllo
  146. ----------------------------------------------------------------------
  147. */
  148. void Area(int pipein) {
  149.     struct position nemico, amico, dato_letto;
  150.     struct position bonus1, told1;     
  151.     struct position bonus2, told2; 
  152.     struct position bonus3, told3; 
  153.     int i=0, max_collision=3, collision=0;
  154.  
  155.     mvprintw(0,1,"%3d",max_collision); /* Visualizzo collisioni concesse all'aereo amico */
  156.  
  157.     do {
  158.         read(pipein,&dato_letto,sizeof(dato_letto)); /* Leggo dalla pipe */
  159.         if(dato_letto.c=='+') {     /* nemico */   
  160.             mvaddch(nemico.y,nemico.x,' '); /* Cancello il precedente carattere visualizzato */
  161.             nemico=dato_letto; /* Aggiorno le coordinate relative alla nuova posizione */
  162.         }  
  163.         else {      /* amico */
  164.             mvaddch(amico.y,amico.x,' '); /* Cancello il precedente carattere visualizzato */
  165.             amico=dato_letto; /* Aggiorno le coordinate relative alla nuova posizione */
  166.         }
  167.         mvaddch(dato_letto.y,dato_letto.x,dato_letto.c);  /* Visualizzo gli oggetti sulle coordinate correnti */   
  168.        
  169.         if(!(i++%100)) {
  170.             mvaddch(told1.y,told1.x,' '); /* Cancello i precedenti palloni visualizzati */
  171.             mvaddch(told2.y,told2.x,' ');
  172.             mvaddch(told3.y,told3.x,' ');
  173.  
  174.                      /* Genero casualmente le nuove coordinate dei 3 bonus verificando che
  175.                                     le nuove coordinate non siano uguali alle precedenti o agli altri palloni */
  176.             do {
  177.                 bonus1.x = rand()%MAXX;
  178.                 bonus1.y = rand()%MAXY;
  179.             } while (((bonus1.x == amico.x) && (bonus1.y == amico.y)) ||
  180.                      (bonus1.x == nemico.x) && (bonus1.y == nemico.y) ||
  181.                      (bonus1.x == told1.x) && (bonus1.y == told1.y) ||
  182.                      (bonus1.x == told2.x) && (bonus1.y == told2.y) ||
  183.                      (bonus1.x == told3.x) && (bonus1.y == told3.y));
  184.  
  185.             do{
  186.                 bonus2.x = rand()%MAXX;
  187.                 bonus2.y = rand()%MAXY;
  188.             } while((bonus2.x == bonus1.x) && (bonus2.y == bonus1.y));
  189.  
  190.             do{
  191.                 bonus3.x = rand()%MAXX;
  192.                 bonus3.y = rand()%MAXY;
  193.             } while((bonus3.x == bonus2.x) && (bonus3.y == bonus2.y));  
  194.  
  195.              /* Visualizzo i nuovi bonus */                
  196.             mvaddch(bonus1.y,bonus1.x,'1');
  197.             mvaddch(bonus2.y,bonus2.x,'2');
  198.             mvaddch(bonus3.y,bonus3.x,'3');
  199.  
  200.             /* Memorizzo le coordinate dei palloni visualizzati */
  201.             told1.x = bonus1.x;
  202.             told1.y = bonus1.y;
  203.             told2.x = bonus2.x;
  204.             told2.y = bonus2.y;
  205.             told3.x = bonus3.x;
  206.             told3.y = bonus3.y;
  207.         }
  208.  
  209.         /* Visualizzo le possibili collisioni rimaste all'aereo amico */
  210.         mvprintw(0,1,"%3d",max_collision);
  211.  
  212.         /* Nascondo il cursore */
  213.         curs_set(0);
  214.  
  215.         /* Aggiorno lo schermo di output per visualizzare le modifiche */
  216.         refresh();
  217.  
  218.         /* Segnalo collisione e tipo (nemico/amico oppure nemico/bonus)
  219.         (con meccanismo per evitare il rilevamento multiplo della stessa collisione) */
  220.         if(amico.x == nemico.x && amico.y == nemico.y){
  221.             if(amico.x < MAXX)
  222.                 amico.x++;
  223.             else
  224.                 amico.x--;         
  225.              max_collision--;
  226.             /* Esce quando terminano le possibili collisioni ed avviene una nuova collisione */
  227.             if(max_collision < 0)
  228.                 collision=1;
  229.         }
  230.  
  231.         if( nemico.x == bonus1.x && nemico.y == bonus1.y ||
  232.             nemico.x == bonus2.x && nemico.y == bonus2.y ||
  233.             nemico.x == bonus3.x && nemico.y == bonus3.y )  {
  234.      
  235.             if(nemico.x < MAXX)
  236.                 nemico.x++;
  237.             else
  238.                 nemico.x--;
  239.             max_collision=3;
  240.         }
  241.  
  242.        
  243.  
  244.     /* Il ciclo si ripete finchè non si verifica una collisione amico/nemico */
  245.     } while(!collision);
  246. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!