home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume9 / wanderer3 / part02 / monsters.c < prev    next >
C/C++ Source or Header  |  1990-05-21  |  7KB  |  255 lines
  1. #include "wand_head.h"
  2.  
  3. typedef struct { int d[2] } direction;
  4.  
  5. #ifdef    LINT_ARGS    /* M001 */
  6. direction new_direction(int, int, int, int);
  7. #else
  8. direction new_direction();
  9. #endif
  10.  
  11. extern void draw_symbol();
  12. extern int debug_disp;
  13. extern int edit_mode;
  14. extern char screen[NOOFROWS][ROWLEN+1];
  15.  
  16. /* Add a spirit to the chain */
  17. /* Maintain a doubly linked list to make reuse possible.
  18.    tail_of_list is *NOT* the last monster allocated, but
  19.    the last monster alloted to a screen.  start_of_list
  20.    is a dummy entry to ease processing. last_of_list
  21.    is the last entry allocated. */
  22.  
  23. extern struct mon_rec *last_of_list, *tail_of_list;
  24. extern struct mon_rec start_of_list;
  25.  
  26. struct mon_rec *make_monster(x,y)
  27. int x,y;
  28. {
  29. char *malloc();
  30. #define MALLOC (struct mon_rec *)malloc(sizeof(struct mon_rec))
  31. struct mon_rec *monster;
  32. if(tail_of_list->next == NULL)
  33.     {
  34.     if((last_of_list = MALLOC) == NULL)
  35.     return NULL;
  36.     tail_of_list->next = last_of_list;
  37.     last_of_list->prev = tail_of_list;
  38.     last_of_list->next = NULL;
  39.     }
  40. monster = tail_of_list = tail_of_list->next;
  41. monster->x = x;
  42. monster->y = y;
  43. monster->mx = 1;      /* always start moving RIGHT. (fix later)  */
  44. monster->my = 0;
  45. monster->under = ' ';
  46. return monster;
  47. }
  48.  
  49. /* 'follow lefthand wall' algorithm for baby monsters */
  50.  
  51. direction new_direction(x,y,bx,by)
  52. int x,y,bx,by;
  53. {
  54. direction out;
  55. if(viable((x+by),(y-bx)))
  56.     {
  57.     out.d[0] = by;
  58.     out.d[1] = -bx;
  59.     return out;
  60.     }
  61. if(viable((x+bx),(y+by)))
  62.     {
  63.     out.d[0] = bx;
  64.     out.d[1] = by;
  65.     return out;
  66.     }
  67. if(viable((x-by),(y+bx)))
  68.     {
  69.     out.d[0] = -by;
  70.     out.d[1] = bx;
  71.     return out;
  72.     }
  73. if(viable((x-bx),(y-by)))
  74.     {
  75.     out.d[0] = -bx;
  76.     out.d[1] = -by;
  77.     return out;
  78.     }
  79. out.d[0] = -bx;
  80. out.d[1] = -by;
  81. return out;
  82. }
  83.  
  84. int move_monsters(mxp, myp, score, howdead, sx, sy, nf, bell, x, y, diamonds)
  85. int *mxp, *myp, *score, sx, sy, nf, bell, x, y, diamonds;
  86. char *howdead;
  87. {
  88. int xdirection, ydirection, hd, vd;
  89. int deadyet = 0;
  90. int bx, by, nbx, nby, tmpx,tmpy;
  91. direction new_disp;
  92. struct mon_rec *monster,*current;
  93. char buffer[25];
  94.  
  95. /* big monster first */
  96. if(*mxp == -2)                          /* has the monster been killed ? */
  97.     {
  98.     *score+=100;
  99.     *mxp = *myp = -1;
  100.     move(3,48);
  101.     sprintf(buffer,"%d\t %d\t",*score,nf);
  102.     (void) addstr(buffer);
  103.     draw_symbol(50,11,' ');
  104.     move(12,56); addstr("              ");
  105.     move(13,56); addstr("              ");
  106.     move(16,0);
  107.     refresh();
  108.     }                                     /* if monster still alive */
  109. if(*mxp != -1)                              /* then move that monster ! */
  110.     {
  111.     screen[*myp][*mxp] = ' ';
  112.     if(*mxp>x)
  113.         xdirection = -1;
  114.     else
  115.         xdirection = 1;
  116.     if(!debug_disp)
  117.     {
  118.         if((*myp<(sy+4))&&(*myp>(sy-4))&&(*mxp<(sx+6))&&(*mxp>(sx-6)))
  119.             draw_symbol((*mxp-sx+5)*3,(*myp-sy+3)*2,' ');
  120.     }
  121.     else
  122.     {
  123.     move(*myp+1,*mxp+1);
  124.     addch(' ');
  125.     }
  126.     if((hd = (*mxp-x))<0)
  127.     hd = -hd;
  128.     if((vd = (*myp-y))<0)
  129.     vd = -vd;
  130.     if((hd>vd)&&((*mxp+xdirection)<ROWLEN)&&((screen[*myp][*mxp+xdirection] == ' ')||(screen[*myp][*mxp+xdirection] == '@')))
  131.     *mxp+=xdirection;
  132.     else
  133.         {
  134.         if(*myp>y)
  135.             ydirection = -1;
  136.     else
  137.             ydirection = 1;
  138.         if(((*myp+ydirection)<NOOFROWS)&& ((screen[*myp+ydirection][*mxp]
  139. == ' ')||(screen[*myp+ydirection][*mxp] == '@')))
  140.         *myp+=ydirection;
  141.     else
  142.             if(((*mxp+xdirection)<ROWLEN)&&(screen[*myp][*mxp+xdirection] == ' ')||(screen[*myp][*mxp+xdirection] == '@'))
  143.     *mxp+=xdirection;
  144.     }
  145.     if(!debug_disp)
  146.     {
  147.         if((*myp<(sy+4))&&(*myp>(sy-4))&&(*mxp<(sx+6))&&(*mxp>(sx-6)))
  148.             draw_symbol((*mxp-sx+5)*3,(*myp-sy+3)*2,'M');
  149.     }
  150.     else
  151.     {
  152.     move(*myp+1,*mxp+1);
  153.     addch('M');
  154.     }
  155.     if(screen[*myp][*mxp] == '@')                     /* ha! gottim! */
  156.     {
  157.     strcpy(howdead,"a hungry monster");
  158.         move(16,0);
  159.     refresh();
  160.         deadyet = 1;
  161.     }
  162.     screen[*myp][*mxp] = 'M';
  163.     move(16,0);
  164.     refresh();
  165.     }
  166.  
  167. current = &start_of_list;                         /* baby monsters now */
  168. while((current != tail_of_list)&&(!deadyet))
  169.     /* deal with those little monsters */
  170.     {
  171.     monster = current->next;
  172.     new_disp = new_direction( monster->x, monster->y, monster->mx, monster->my );
  173.     if(monster->under!='S')             /* if on top of another baby */
  174.     {
  175.         screen[monster->y][monster->x] = monster->under;
  176.         if(!debug_disp)
  177.         {
  178.             if((monster->y < (sy+4)) && (monster->y > (sy-4)) && (monster->x < (sx+6)) && (monster->x > (sx-6)))
  179.                 draw_symbol((monster->x-sx+5)*3,(monster->y-sy+3)*2,monster->under);
  180.         }
  181.         else
  182.         {
  183.             move(monster->y+1,monster->x+1);
  184.             addch(monster->under);
  185.         }
  186.         if(monster->under == ' ')
  187.          deadyet+=check(&*mxp,&*myp,monster->x,monster->y,new_disp.d[0],new_disp.d[1],sx,sy,howdead);
  188.     }
  189.     else
  190.     monster->under=' ';
  191.     monster->mx = new_disp.d[0];
  192.     monster->my = new_disp.d[1];
  193.     monster->x += monster->mx;
  194.     monster->y += monster->my;
  195.     monster->under = screen[monster->y][monster->x];
  196.     screen[monster->y][monster->x] = 'S';        /* move into new space */
  197.     if(!debug_disp)
  198.     {
  199.         if((monster->y < (sy+4)) && (monster->y > (sy-4)) && (monster->x < (sx+6)) && (monster->x > (sx-6)))
  200.             draw_symbol((monster->x-sx+5)*3,(monster->y-sy+3)*2,'S');
  201.     }
  202.     else
  203.     {
  204.     move(monster->y+1,monster->x+1);
  205.     addch('S');
  206.     }
  207.     if(monster->under == '@')                     /* monster hit you? */
  208.         {
  209.     strcpy(howdead,"the little monsters");
  210.     move(16,0);
  211.     refresh();
  212.     deadyet = 1;
  213.     monster->under = ' ';
  214.         }
  215.     if(monster->under == '+')                    /* monster hit cage? */
  216.         {
  217. #ifdef NOISY
  218.     if(bell) printf("\007");
  219. #endif
  220.     *score +=20;
  221.     move(3,48);
  222.         sprintf(buffer,"%d\t %d\t %d ",*score,nf,diamonds);
  223.         (void) addstr(buffer);
  224.         /* remove from chain, and insert at the end (at last_of_list) */
  225.     if(monster == tail_of_list)
  226.         tail_of_list = tail_of_list->prev;
  227.     else
  228.         {
  229.           current->next = monster-> next;
  230.         current->next->prev = current;
  231.         monster->next = NULL;
  232.         monster->prev = last_of_list;
  233.         last_of_list->next = monster;
  234.         last_of_list = monster;
  235.         }
  236.     screen[monster->y][monster->x] = '*';
  237.     if(!debug_disp)
  238.         {
  239.             if((monster->y < (sy+4)) && (monster->y > (sy-4)) && (monster->x < (sx+6)) && (monster->x > (sx-6)))
  240.                     draw_symbol((monster->x-sx+5)*3,(monster->y-sy+3)*2,'*');
  241.         }
  242.     else
  243.         {
  244.         move(monster->y+1,monster->x+1);
  245.         addch('*');
  246.         }
  247.         }
  248.     else
  249.     current = monster;
  250.     move(16,0);
  251.     refresh();
  252.     }
  253.     return deadyet;
  254. }
  255.