API tools faq
paste
Advertisement
nigu

difesa_aerea_thread

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