Subversion Repositories shark

/*--------------------------------------------------------------*/

/*                        DEFENDER GAME                         */

/*--------------------------------------------------------------*/

#include <kernel/kern.h>

#include <drivers/glib.h>

#include <drivers/keyb.h>

#include <semaphore.h>

#include <stdlib.h>

#include <math.h>

#define YMENU    10             /* menu level                   */

#define XMIN     50

#define XMAX     600

#define YMIN     100

#define YMAX     450

#define VEL      3              /* linear velocity (def. = 3)   */

#define ANG      30             /* angolo massimo sterzata (30) */

#define D        3              /* raggio alieno                */

#define DD       6              /* diametro alieno              */

#define ESC      27             /* ASCII code of ESCAPE key     */

#define MAX_ALIEN    30         /* max number of aliens         */

#define MAX_MISSIL   10         /* numero massimo di missili    */

#define M_GROUP        1

#define ALIEN_GROUP    2

#define MISSILE_GROUP  3

#define STUPID   2

#define NORMAL   14

#define BAD      13

#define BASTARD  4

int tipo[4] = {STUPID,NORMAL,BAD,BASTARD};

#define PRODUCED    1

#define CONSUMED    0

#define Ix       16

#define Iy       16

char command_astro ; // comandi astronave

int  AstroCmdState ;

struct argAlien {

  int orig_x ; // coordinate iniziali

  int orig_y ;

  int a_type ; // tipo di alieno

};

int     mother_period =   50000 ;     /* task period                  */

int     mother_wcet   =   10000 ;     /* task wcet                    */

int     Alien_period =    40000 ;     /* task period                  */

int     Alien_wcet   =     1000 ;     /* task wcet                    */

int     Astro_period =    40000 ;     /* task period                  */

int     Astro_wcet =       2000 ;     /* task wcet                    */

int     missile_period =  40000 ;

int     missile_wcet =     1000 ;

PID     pid_Madre, pid_Alien, pid_Astro, pid_Missile, pid_Monitor ;

sem_t   grx_mutex, keyb_mutex, astro_mutex, alien_mutex, score_mutex;

sem_t   missile_mutex[MAX_MISSIL];

/*--------------------------------------------------------------*/

// Risorse condivise

struct s_Astronave {

  int x, y, FlagCollisione, FlagAstronave ;

} AstronavePosition ;

struct s_Missile {

  int x, y, FlagCollisione ;

} MissilePosition[MAX_MISSIL] ;

struct s_Score {

  int total, type[5] ;

} Score ;

int alieni_vivi ;  // numero di alieni attualmente in vita

/*--------------------------------------------------------------*/

// Disegna l'astronave a partire dalla "poppa" x,y di colore c

void    draw_Astronave(int x, int y, int c)

{

  // Il disegno degli oggetti e' fatto sotto mutex per migliorare

  // l'aspetto del sistema.

  if (x < 3) x = 3;

  if (y < 8) y = 8;

  sem_wait(&grx_mutex);

    grx_line(x, y-8, x, y+8, c);

    grx_line(x, y-8, x+5, y-4, c);

    grx_line(x, y+8, x+5, y+4, c);

    grx_line(x+5, y-4, x+10, y-4, c);

    grx_line(x+5, y+4, x+10, y+4, c);

    grx_line(x+10, y-4, x+15, y, c);

    grx_line(x+10, y+4, x+15, y, c);

    grx_line(x+15, y, x+17, y, c);

    grx_box(x-3, y-6, x, y-2, c);

    grx_box(x-3, y+2, x, y+6, c);

    grx_box(x+8, y-3, x+10, y-1, c);

    grx_box(x+8, y+1, x+10, y+3, c);

    grx_line(x+3, y-4, x+8, y-1, c);

    grx_line(x+3, y+4, x+8, y+1, c);

  sem_post(&grx_mutex);

}

// disegno del generico alieno "centro" x,y colore

void    draw_Alieno(int x, int y, int c)

{

  if (x < DD) x = DD;

  if (y < 0) y = 0;

  sem_wait(&grx_mutex);

    grx_disc(x, y, D, c); // disco

    grx_line(x-DD, y, x+DD, y, c); // linea

  sem_post(&grx_mutex);

}

// disegno della madre alieni

void    draw_Mother(int x, int y, int c, int d)

{

  int i;

  if (x < 10) x = 10;

  if (y < 8) y = 8;

  sem_wait(&grx_mutex);

    grx_box(x-10, y-10, x-5, y+5, c); // box

    grx_box(x+5, y-10, x+10, y+5, c); // box

    grx_disc(x, y, 5, c); // disco

    grx_line(x, y+8, x, y-8, c); // linea

    for (i = 0; i < d ; i++) {

      grx_disc(x + (rand()%20)-10, y + (rand()%10)-5, d/2, 0);

    }

  sem_post(&grx_mutex);

}

void    draw_Missile(int x, int y, int c)

{

  if (y < 3) y = 3;

  sem_wait(&grx_mutex);

    grx_box (x, y-1, x+6, y+1, c);

    grx_line(x+1, y-3, x+1, y+3, c);

    grx_line(x+1, y+3, x+3, y, c);

    grx_line(x+1, y-3, x+3, y, c);

    grx_disc(x+6, y, 1, c);

  sem_post(&grx_mutex);

}

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

// ------------------------------------------------------------------->

//                              ALIENO

// ------------------------------------------------------------------->

TASK    Alieno(void *arg)

{

  int     x, y          ;

  int     xa1, ya1      ;

  int     ox, oy        ;

  int     x1 = 0        ;   /* variabile di appoggio */

  int     dx, dy, da    ;

  int     teta = 0      ;

  int     col           ;

  int     outx, outy    ;

  double  r             ;

  int     j = 0         ;

  int     morto = FALSE ;

  int     score = 0     ;

  int x_MissilePosition ;

  int y_MissilePosition ;

  int FlagCollisione    ;

  int x_AstronavePosition ;

  int y_AstronavePosition ;

  int xi,yi ;

  int FlagAstro ;

  float Kp = 0.01     ;

  float Ki = 0.005    ;

  float Kd = 0.00005  ;

  float ex_k, ey_k, ex_sum, ey_sum, ex_km1, ey_km1 ;

  ex_k = ey_k = ex_sum = ey_sum = ex_km1 = ey_km1 = 0 ;

  struct argAlien *arg_Alieno = (struct argAlien *)arg ;

  // Punto di partenza dell'alieno

  x = ox = arg_Alieno->orig_x ;

  y = oy = arg_Alieno->orig_y ;

  col = arg_Alieno->a_type    ;   /* tipo alieno */

  // Ciclo infinito

  while (1) {

    // Lettura valori Astronave

    sem_wait(&astro_mutex);

      x_AstronavePosition = AstronavePosition.x   ;

      y_AstronavePosition = AstronavePosition.y   ;

      FlagAstro = AstronavePosition.FlagAstronave ;

    sem_post(&astro_mutex);

    switch (col)

    {

      case STUPID :

      {    // Parametri di spostamento

        dx = -VEL;

        x += dx;

        if (x <= XMIN + DD) x = XMAX - DD;

        score = 1 ;

      }

      break;

      case NORMAL :

      {  // Spostamento oggetto

        dx = -VEL                ;

        dy = VEL * (rand()%3 -1) ;

        x += dx                  ;

        y += dy                  ;

        outy = (y >= YMAX) || (y <= YMIN);

        if (outy) y = y - dy;

        if (x <= XMIN + DD) x = XMAX - DD;

        score = 2 ;

      }

      break;

      case BAD :

      {

        da = rand()%(2*ANG) - ANG;  /*  da = [-ANG,ANG] */

        teta += da;

        if (teta > 360) teta -= 360;

        if (teta < 0) teta += 360;

        r = (double)teta * PI / 180.;

        dx = (float)(-VEL * cos(r));

        dy = (float)(VEL * sin(r));

        x += dx;

        y += dy;

        outx = (x >= XMAX-DD) || (x <= XMIN+DD);

        outy = (y >= YMAX) || (y <= YMIN);

        if (outy) {

          y = y - dy;

          teta = -teta;

          if (teta > 360) teta -= 360;

          if (teta < 0) teta += 360;

          r = (double)teta * PI / 180.;

          dy = (float)(VEL * sin(r));

          y += dy;

        }

        if (outx) {

          x = x - dx;

          if (x+dx >= XMAX-DD) x1 = XMIN + DD;

          if (x <= XMIN+DD) x1 = XMAX - DD;

          x = x1 + dx;

        }

        score = 3 ;

      }

      break;

      case BASTARD : // alieno bastardo

      {

          xa1 = x_AstronavePosition ;

          ya1 = y_AstronavePosition ;

        if (!FlagAstro) col = BAD;

// PID di inseguimento asse X

        ex_k =(float) (xa1 - x);

        if (ex_k >  50) ex_k =  50 ; // saturazione simmetrica dell'errore

        if (ex_k < -50) ex_k = -50 ;

        ex_sum = ex_sum + ex_k ;       // aggiornamento dell'errore integrale

        dx = (int) ( ex_k * Kp + ex_sum * Ki + (ex_k - ex_km1) *Kd ); // PID classico

        ex_km1 = ex_k ; // salvataggio dell'errore vecchio x il termine derivativo

// PID di inseguimento asse Y

        ey_k = (float) (ya1 - y);

        if (ey_k >  50) ey_k =  50 ; // saturazione simmetrica dell'errore

        if (ey_k < -50) ey_k = -50 ;

        ey_sum = ey_sum + ey_k ;       // aggiornamento dell'errore integrale

        dy = (int) ( ey_k * Kp + ey_sum * Ki + (ey_k-ey_km1) *Kd ) ;

        ey_km1 = ey_k ;

        x = x + dx ; // aggiornamento delle posizioni

        y = y + dy ;

        outx = (x >= XMAX-DD) || (x <= XMIN+DD); // flag di schianto

        outy = (y >= YMAX) || (y <= YMIN);

        if (outy)

        {

            y = y - dy;

            ey_sum = 0;

        }

        if (outx)

        {

            x = x - dx;

            if (x+dx >= XMAX-DD) x1 = XMIN + DD;

            if (x <= XMIN+DD) x1 = XMAX - DD;

             x = x1 + dx;

        }

        score = 4 ;

      } // chiude il CASE BASTARD

      break;

    } //chiude lo switch

    // Disegno l'alieno

    draw_Alieno(ox, oy, 0);             /* cancello il vecchio alieno */

    // Rilevatore di collisioni con l'Astronave

    if (FlagAstro)

    {

        // verifica della presenza dell'astronave nell'intorno

           xi = ( (abs(x - x_AstronavePosition)) < Ix ) ;

           yi = ( (abs(y - y_AstronavePosition)) < Iy ) ;

        if (xi && yi)

          {

             sem_wait(&astro_mutex)   ;

                AstronavePosition.FlagCollisione = TRUE    ;

             sem_post(&astro_mutex)   ;

         break ; // morto x collisione astronave

          }

     }

    // Controllo di collisione dell'ALIENO con i missili

    for (j = 0; j < MAX_MISSIL; j++)

      {

      sem_wait(&missile_mutex[j]);

        x_MissilePosition = MissilePosition[j].x ;

        y_MissilePosition = MissilePosition[j].y ;

        FlagCollisione = MissilePosition[j].FlagCollisione;

      sem_post(&missile_mutex[j]);

      if (FlagCollisione == FALSE) {

        // verifica della presenza nell'intorno

        xi = ( (x - x_MissilePosition) > 0 && (x - x_MissilePosition) < Ix ) ;

        yi = ( (abs(y - y_MissilePosition)) < Iy )                           ;

        if (xi && yi) {

          sem_wait(&missile_mutex[j])   ;

            MissilePosition[j].FlagCollisione = TRUE    ;

          sem_post(&missile_mutex[j])   ;

          morto = TRUE ;

        }

      }

      else break ;  // esco dal ciclo for

    }

    if (morto == TRUE) break ;  // esco dal ciclo while

    draw_Alieno(x, y, col);             /* disegno il nuovo alieno */

    ox = x; oy = y;

    task_endcycle();    /* fine del ciclo */

  } // chiusura del while

     sem_wait(&alien_mutex) ;

       alieni_vivi--        ;

     sem_post(&alien_mutex) ;

     sem_wait(&score_mutex) ;

       Score.total+=score   ;

       Score.type[score-1]++;

     sem_post(&score_mutex) ;

     pid_Alien = NIL ;

  return 0 ; // morte dell'alieno

}

// ------------------------------------------------------------------->

//                              MADRE ALIENI

// ------------------------------------------------------------------->

TASK    MadreAlieni(void *arg)

{

  int v = 0;

  int a_v ;

  int i = 150;

  int conta_spari = 0;

  int xi, yi;

  int j = 0;

  int x_MissilePosition ;

  int y_MissilePosition ;

  int FlagCollisione ;

  int x_AstronavePosition ;

  int y_AstronavePosition ;

  int FlagAstro ;

  int     x, y;

  int     ox, oy;

  int     dx, dy, da;

  int     teta = 0;

  int     outx, outy;

  double  r;

  struct argAlien arg_Alieno;

  struct argAlien *p_Alien;

  p_Alien = &arg_Alieno;

  HARD_TASK_MODEL Alien;

  // Punto di partenza della Madre alieni

  x = ox = (rand()%XMIN) + (rand()%(XMAX-2*XMIN)) + XMIN;

  y = oy = (rand()%YMIN) + (rand()%(YMAX-2*YMIN)) + YMIN;

  // Ciclo infinito

  while (1)

    {

    // Punto di partenza dell'alieno (dal culo della Madre alieni)

    arg_Alieno.orig_x = x;

    arg_Alieno.orig_y = y + 15;

    // Tipo alieno casuale

    v = rand()%4;

    arg_Alieno.a_type = tipo[v];

    sem_wait(&alien_mutex) ;

      a_v = alieni_vivi   ;

    sem_post(&alien_mutex) ;

    if ((a_v < MAX_ALIEN) && (i == 0))

      {

      hard_task_default_model(Alien);

      hard_task_def_ctrl_jet (Alien);

      hard_task_def_arg      (Alien, (void *)p_Alien);

      hard_task_def_wcet     (Alien, Alien_wcet);

      hard_task_def_mit      (Alien, Alien_period);

      hard_task_def_group    (Alien, ALIEN_GROUP);

      hard_task_def_usemath  (Alien);

      pid_Alien = task_create("Alieno", Alieno, &Alien, NULL);

      if (pid_Alien == NIL)

        {

        grx_text("pid_Alien == NIL", 200, 80 ,  4, 0);

        return 0;

        //grx_close();

        //perror("Could not create task <Alieno>\n");

        //sys_abort(1);

      }

      task_activate(pid_Alien);

      i = 40 ; // count down alla generarazione di un alieno

      sem_wait(&alien_mutex) ;

        alieni_vivi++   ;

      sem_post(&alien_mutex) ;

    }

    // Spostamento madre alieni

    da = rand()%(2*ANG) - ANG;  /*  da = [-ANG,ANG] */

    teta += da;

    if (teta > 360) teta -= 360;

    if (teta < 0) teta += 360;

    r = (double)teta * PI / 180.;

    dx = (float)(2 * cos(r));

    dy = (float)(2 * sin(r));

    x += dx;

    y += dy;

    outx = (x >= XMAX - 20) || (x <= XMIN + 20);

    outy = (y >= YMAX - 20) || (y <= YMIN + 20);

    if (outx || outy)

      {

      x = x - dx;

      y = y - dy;

      if (outx) teta = 180 - teta;

      if (outy) teta = -teta;

      if (teta > 360) teta -= 360;

      if (teta < 0) teta += 360;

      r = (double)teta * PI / 180.;

      dx = (float)(2 * cos(r));

      dy = (float)(2 * sin(r));

      x += dx;

      y += dy;

    }

    draw_Mother(ox, oy, 0, 0);

    // Controllo di collisione della MADRE con i missili

    for (j = 0; j < MAX_MISSIL; j++)

      {

      sem_wait(&missile_mutex[j]);

        x_MissilePosition = MissilePosition[j].x ;

        y_MissilePosition = MissilePosition[j].y ;

        FlagCollisione = MissilePosition[j].FlagCollisione;

      sem_post(&missile_mutex[j]);

      if (FlagCollisione == FALSE)

        {

        // verifica della presenza nell'intorno

        xi = ( (x - x_MissilePosition) > 0 && (x - x_MissilePosition) < Ix ) ;

        yi = ( (abs(y - y_MissilePosition)) < Iy )                           ;

        if (xi && yi)

          {

          sem_wait(&missile_mutex[j])   ;

            MissilePosition[j].FlagCollisione = TRUE    ;

          sem_post(&missile_mutex[j])   ;

          conta_spari++;

        }

      }

      if (FlagCollisione == TRUE) break ;  // esco dal ciclo for

    }

    if (conta_spari == 5) {

      sem_wait(&score_mutex) ;

        Score.total+=10      ;

        Score.type[4]++      ;

      sem_post(&score_mutex) ;

      pid_Madre = NIL ;

      return 0 ;

    }

    // Controllo di collisione della madre con l'astronave

    // Lettura valori Astronave

    sem_wait(&astro_mutex);

      x_AstronavePosition = AstronavePosition.x ;

      y_AstronavePosition = AstronavePosition.y ;

      FlagAstro = AstronavePosition.FlagAstronave ;

    sem_post(&astro_mutex);

    if (FlagAstro)

      {

      // verifica della presenza dell'astronave nell'intorno

      xi = ( (abs(x - x_AstronavePosition)) < Ix ) ;

      yi = ( (abs(y - y_AstronavePosition)) < Iy ) ;

      if (xi && yi)

        {

        sem_wait(&astro_mutex)   ;

          AstronavePosition.FlagCollisione = TRUE    ;

        sem_post(&astro_mutex)   ;

        conta_spari++ ;

      }

    }

    if (conta_spari == 5) {

      sem_wait(&score_mutex) ;

        Score.total+=10      ;

        Score.type[4]++      ;

      sem_post(&score_mutex) ;

      pid_Madre = NIL ;

      return 0 ;

    }

    draw_Mother(x, y, 15, conta_spari);

    ox = x; oy = y;

    i-- ;

    task_endcycle();    /* fine del ciclo while */

  }

}

// ------------------------------------------------------------------->

//                              ASTRONAVE

// ------------------------------------------------------------------->

TASK    Astronave(void *arg)

{

  int     x, y;

  int     ox, oy;

  int     dx, dy;

  int     col;

  int     outy;

  char          c;

  int FlagCollisione ;

  x = ox = XMIN + 10;

  y = oy = (YMIN+YMAX)/2;

  col = 15;

  while (1) {

    sem_wait(&keyb_mutex);

       if (AstroCmdState == PRODUCED)

         {

           c = command_astro;

           AstroCmdState = CONSUMED ;

         }

        else

         {

           c = 0 ;

         }

    sem_post(&keyb_mutex);

    dx = VEL ;

    dy = 0   ;

    switch (c)

    {

      case 'w' :

      {

        dy = -VEL;

      }

      break;

      case 's' :

      {

        dy = VEL;

      }

      break;

     }

    x += dx;

    y += dy;

    outy = (y >= YMAX-DD) || (y <= YMIN+DD);

    if (outy) y = y - dy;

    if (x >= XMAX - DD) x = XMIN + DD;

    sem_wait(&astro_mutex);

      AstronavePosition.x = x   ;

      AstronavePosition.y = y   ;

      FlagCollisione = AstronavePosition.FlagCollisione ;

    sem_post(&astro_mutex);

    draw_Astronave(ox, oy, 0);

    if (FlagCollisione)

       break ;

    draw_Astronave(x, y, col);

    ox = x; oy = y;

    task_endcycle();

  } // chiusura del while

    sem_wait(&astro_mutex)                   ;

       AstronavePosition.FlagCollisione = FALSE  ;

       AstronavePosition.FlagAstronave  = FALSE  ;

    sem_post(&astro_mutex)                   ;

       pid_Astro = NIL ; // cleanup

  return 0 ;

} // chiusura dell'astronave

// ------------------------------------------------------------------->

//                              MISSILE

// ------------------------------------------------------------------->

TASK    Missile(void *arg)

{

  int     x, y;

  int     ox, oy;

  int     dx;

  int     col;

  int     xa1;

  int     ya1;

  int     FlagCollisione ;

  int     i = (int)arg;

  // Punto di partenza del missile (la punta dell'astronave)

  col = 15;                    /* colore missile (bianco) */

  sem_wait(&astro_mutex);

     xa1 = AstronavePosition.x ;

     ya1 = AstronavePosition.y ;

  sem_post(&astro_mutex);

  x = ox = xa1 + 15;

  y = oy = ya1;

  // Ciclo infinito

  while (1) {

    // Parametri di spostamento

    dx = 2*VEL;

    x += dx;

    sem_wait(&missile_mutex[i])                           ;

       MissilePosition[i].x = x ; // aggiorno posizione

       MissilePosition[i].y = y ;

       FlagCollisione = MissilePosition[i].FlagCollisione ; // leggo collisione

    sem_post(&missile_mutex[i])   ;

    // Esplosione del missile : a) per raggimento del bordo dx

    //                          b) per collisione con un alieno

    // Disegno l'alieno

    draw_Missile(ox, oy, 0);            /* cancello il vecchio missile */