home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Games / warp / us.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  9.9 KB  |  511 lines
  1. /* $Header: us.c,v 7.0.1.3 87/01/13 17:13:21 lwall Exp $ */
  2.  
  3. /* $Log:    us.c,v $
  4.  * Revision 7.0.1.3  87/01/13  17:13:21  lwall
  5.  * Partially fixed ^S behavior.  It now just ignores ^S.
  6.  * 
  7.  * Revision 7.0.1.2  86/12/12  17:06:09  lwall
  8.  * Baseline for net release.
  9.  * 
  10.  * Revision 7.0.1.1  86/10/16  10:53:50  lwall
  11.  * Added Damage.  Fixed random bugs.
  12.  * 
  13.  * Revision 7.0  86/10/08  15:14:21  lwall
  14.  * Split into separate files.  Added amoebas and pirates.
  15.  * 
  16.  */
  17.  
  18. #include "EXTERN.h"
  19. #include "warp.h"
  20. #include "bang.h"
  21. #include "object.h"
  22. #include "play.h"
  23. #include "sig.h"
  24. #include "term.h"
  25. #include "util.h"
  26. #include "weapon.h"
  27. #include "INTERN.h"
  28. #include "us.h"
  29.  
  30. void
  31. us_init()
  32. {
  33.     ;
  34. }
  35.  
  36. void
  37. do_direction(dy,dx)
  38. int dy, dx;
  39. {
  40.     Reg1 int decr;
  41.     Reg2 OBJECT *obj;
  42.  
  43.     if (status < 2) {
  44.     if (cloaking) {
  45.         char ch;
  46.         
  47.         cloaked = FALSE;
  48.         ch = (ent->energy >= 500?'E':'e');
  49.         if (ch != ent->image) {
  50.         setimage(ent, ch);
  51.         }
  52.     }
  53.     decr = 5+abs(evely)+abs(evelx)+tractor*tractor;
  54.     if (ent->energy >= decr) {
  55.         ent->energy -= decr;
  56.         if (tractor) {
  57.         if (!damage || !damflag[NOTRACTORS]) {
  58.             if (!rand_mod(50)) {
  59.             damage++;
  60.             damflag[NOTRACTORS] = rand_mod(smarts+10)+2;
  61.             }
  62.             if (tract(ent,dy,dx,tractor)) {
  63.             evely += tractor*dy;
  64.             evelx += tractor*dx;
  65.             }
  66.         }
  67.         }
  68.         else if (!damage ||
  69.           (!entmode && !damflag[NOIMPULSE]) ||
  70.           (entmode && !damflag[NOWARP]) ) {
  71.         if (!rand_mod(30+500/(abs(evely)+abs(evelx)+1))) {
  72.             damage++;
  73.             damflag[entmode?NOWARP:NOIMPULSE] = rand_mod(smarts+10)+2;
  74.         }
  75.         evely += dy;
  76.         evelx += dx;
  77.         }
  78.         if (inumthols &&
  79.           (obj=occupant[(ent->posy+evely+YSIZE00)%YSIZE]
  80.                [(ent->posx+evelx+XSIZE00)%XSIZE] ) &&
  81.           obj->type == Web)
  82.         evely = evelx = 0;
  83.     }
  84.     }
  85.     else if (status == 2) {
  86.     decr = 500+abs(bvely)*5+abs(bvelx)*5+tractor*tractor*100;
  87.     if (base->energy >= decr) {
  88.         base->energy -= decr;
  89.         if (tractor) {
  90.         if (tract(base,dy,dx,tractor)) {
  91.             bvely += tractor*dy;
  92.             bvelx += tractor*dx;
  93.         }
  94.         }
  95.         else {
  96.         bvely += dy;
  97.         bvelx += dx;
  98.         }
  99.         if (inumthols &&
  100.           (obj=occupant[(base->posy+bvely+YSIZE00)%YSIZE]
  101.                [(base->posx+bvelx+XSIZE00)%XSIZE] ) &&
  102.           obj->type == Web)
  103.         bvely = bvelx = 0;
  104.     }
  105.     }
  106.     tractor = 0;
  107. }
  108.  
  109. void
  110. ctrl_direction(dy,dx)
  111. int dy, dx;
  112. {
  113.     if (status < 2) {
  114.     if (cloaking) {
  115.         char ch;
  116.         
  117.         cloaked = FALSE;
  118.         ch = (ent->energy >= 500?'E':'e');
  119.         if (ch != ent->image) {
  120.         setimage(ent, ch);
  121.         }
  122.     }
  123.     if (!damage || !damflag[NOPHASERS]) {
  124.         if (!rand_mod(200)) {
  125.         damage++;
  126.         damflag[NOPHASERS] = rand_mod(smarts+10)+2;
  127.         }
  128.         fire_phaser(ent, dy, dx);
  129.     }
  130.     }
  131.     else if (status == 2)
  132.     fire_phaser(base, dy, dx);
  133. }
  134.  
  135. void
  136. shift_direction(dy,dx)
  137. int dy, dx;
  138. {
  139.     if (status < 2) {
  140.     if (cloaking) {
  141.         char ch;
  142.         
  143.         cloaked = FALSE;
  144.         ch = (ent->energy >= 500?'E':'e');
  145.         if (ch != ent->image) {
  146.         setimage(ent, ch);
  147.         }
  148.     }
  149.     if (!damage || !damflag[NOTORPS]) {
  150.         if (!rand_mod(300)) {
  151.         damage++;
  152.         damflag[NOTORPS] = rand_mod(smarts+10)+2;
  153.         }
  154.         fire_torp(ent, dy, dx);
  155.     }
  156.     }
  157.     else if (status == 2)
  158.     fire_torp(base, dy, dx);
  159. }
  160.  
  161. void
  162. get_commands(done)
  163. bool *done;
  164. {
  165.     static char ch[80];
  166.     Reg1 int i;
  167.     Reg2 int count;
  168.     Reg3 bool ctrla = FALSE;
  169.     char numdestructs = 0, numzaps = 0;
  170.  
  171. top:
  172.     while (count = read_nd(ch,(sizeof ch))) {
  173.     for (i=0; i<count; i++) {
  174.         if (ch[i] == 'Q') {
  175.         bombed_out = TRUE;
  176.         *done = TRUE;
  177.         keepgoing = FALSE;
  178.         return;
  179.         }
  180.         if (ch[i] == 'q' || ch[i] == BREAKCH || ch[i] == INTRCH) {
  181.         int x;
  182.         static char quest[] = "Do you wish to escape from reality? ";
  183.  
  184.         if (timer >= whenok) {
  185.             mvaddstr(12,22,quest);
  186.             do {
  187.             getcmd(&ch[i]);
  188.             } while (ch[i] != 'y' && ch[i] != 'n');
  189.             if (ch[i] == 'y') {
  190.             bombed_out = TRUE;
  191.             *done = TRUE;
  192.             return;
  193.             }
  194.             else {
  195.             for (x=11; x<=28; x++) {
  196.                 mvaddch(12,x*2,
  197.                 occupant[11][x]
  198.                    ? occupant[11][x]->image
  199.                    : numamoebas
  200.                       ? amb[11][x]
  201.                       : ' ');
  202.                 addspace();
  203.             }
  204.             roundsleep(2);
  205.             whenok = timer + 10;
  206.             goto top;
  207.             }
  208.         }
  209.         else {
  210.             write(1,"\07",1);
  211.             goto top;
  212.         }
  213.         }
  214.     }
  215.     for (i=0; i<count; i++) {
  216.         if (ctrla) {
  217.         switch (ch[i]) {
  218.         case '1': case 'b':
  219.             ctrl_direction(1, -1);
  220.             break;
  221.         case '2': case 'j':
  222.             ctrl_direction(1, 0);
  223.             break;
  224.         case '3': case 'n':
  225.             ctrl_direction(1, 1);
  226.             break;
  227.         case '4': case 'h':
  228.             ctrl_direction(0, -1);
  229.             break;
  230.         case '6': case 'l':
  231.             ctrl_direction(0, 1);
  232.             break;
  233.         case '7': case 'y':
  234.             ctrl_direction(-1, -1);
  235.             break;
  236.         case '8': case 'k':
  237.             ctrl_direction(-1, 0);
  238.             break;
  239.         case '9': case 'u':
  240.             ctrl_direction(-1, 1);
  241.             break;
  242.         case 'r':
  243.             rewrite();
  244.             roundsleep(3);
  245.             ctrla = FALSE;
  246.             goto top;
  247.         case 'w':
  248.             clear();
  249.             while (!input_pending())
  250.             sleep(1);
  251.             rewrite();
  252.             roundsleep(3);
  253.             ctrla = FALSE;
  254.             goto top;
  255. #ifdef SIGTSTP
  256.         case 'z':
  257.             clear();
  258.             mytstp();
  259.             sleep(4);
  260.             ctrla = FALSE;
  261.             goto top;
  262. #endif
  263.         default:
  264.             break;
  265.         }
  266.         ctrla = FALSE;
  267.         }
  268.         else {
  269.         switch (ch[i]) {
  270.         case 'Z':
  271.             clear();
  272.             mytstp();
  273.             sleep(4);
  274.             goto top;
  275.         case 'i':
  276.             if (ent && (!damage || !damflag[NOIMPULSE])) {
  277.             entmode = 0;
  278.             status = 0;
  279.             }
  280.             break;
  281.         case 'w':
  282.             if (ent && (!damage || !damflag[NOWARP])) {
  283.             entmode = 1;
  284.             status = 1;
  285.             }
  286.             break;
  287.         case 'p':
  288.             if (base) {
  289.             status = 2;
  290.             }
  291.             break;
  292.         case 'o':
  293.             if (status < 2) {
  294.             if (base)
  295.                 status = 2;
  296.             }
  297.             else if (status == 2) {
  298.             if (ent)
  299.                 status = entmode;
  300.             }
  301.             break;
  302.         case 'v':
  303.             if (ent) {
  304.             status = entmode;
  305.             }
  306.             cloaking=FALSE;
  307.             cloaked=FALSE;
  308.             break;
  309.         case 'c':
  310.             if (ent) {
  311.             status = entmode;
  312.             if (ent->energy >= 250)
  313.                 cloaking = TRUE;
  314.             }
  315.             break;
  316.         case 'z':
  317.             if (ent && (!damage || !damflag[NOZAPPER])) {
  318.             ++numzaps;
  319.             if (!rand_mod(100/numzaps)) {
  320.                 damage++;
  321.                 damflag[NOZAPPER] = rand_mod(smarts+10)+2;
  322.             }
  323.             if (nxtbang && bangm[nxtbang-1] < 0)
  324.                 --nxtbang;    /* consolidate zaps */
  325.             make_blast(evely*2+ent->posy,evelx*2+ent->posx,
  326.                 -5000000L, 3*numzaps);
  327.             ent->energy /= 2;
  328.             }
  329.             break;
  330.         case 'D':
  331.             if (status < 2 && (!damage || !damflag[NODESTRUCT])) {
  332.             if (ent && !rand_mod(10)) {
  333.                 damage++;
  334.                 damflag[NODESTRUCT] = rand_mod(smarts+10)+2;
  335.             }
  336.             if (++numdestructs <= 2)
  337.                 make_blast(evely*2+ent->posy,evelx*2+ent->posx,
  338.                 15000L, 3);
  339.             ent->energy /= 4;
  340.             }
  341.             else if (status == 2) {
  342.             if (numdestructs)
  343.                 base->energy = base->energy / 2;
  344.             if (++numdestructs <= 2)
  345.                 make_blast(base->posy, base->posx, 15000L, 5);
  346.             }
  347.             break;
  348.         case 'd':
  349.             if ((!damage || !damflag[NODESTRUCT]) && (base||ent)) {
  350.             Reg4 OBJECT *obj;
  351.             int x, y;
  352.  
  353.             if (ent && !rand_mod(200)) {
  354.                 damage++;
  355.                 damflag[NODESTRUCT] = rand_mod(smarts+10)+2;
  356.             }
  357.             for (obj = root.prev;
  358.               obj != &root;
  359.               obj = obj->prev) {
  360.                 if (obj->image == '+') {
  361.                 blast[y=(obj->posy+obj->vely+YSIZE00)%YSIZE]
  362.                      [x=(obj->posx+obj->velx+XSIZE00)%XSIZE]
  363.                      += 1;
  364.                 yblasted[y] |= 1;
  365.                 xblasted[x] |= 1;
  366.                 blasted = TRUE;
  367.                 obj->mass = (massacre?3000:4000);
  368.                 }
  369.             }
  370.             }
  371.             break;
  372.         case 's':
  373.             if ((!damage || !damflag[NODESTRUCT]) && (base||ent)) {
  374.             Reg4 OBJECT *obj;
  375.             if (ent && !rand_mod(200)) {
  376.                 damage++;
  377.                 damflag[NODESTRUCT] = rand_mod(smarts+10)+2;
  378.             }
  379.             for (obj = root.prev;
  380.               obj->type == Torp || obj->type == Web ||
  381.               obj->type == Star;
  382.               obj = obj->prev) {
  383.                 if (obj->image == '+')
  384.                 obj->vely = obj->velx = 0;
  385.             }
  386.             }
  387.             break;
  388.         case '\001':
  389.             ctrla = TRUE;
  390.             break;
  391.         case '\002':
  392.         case '\003':
  393.         case '\004':
  394.         case '\005':
  395.         case '\006':
  396.         case '\007':
  397.         case '\010':
  398.         case '\011':
  399.         case '\012':
  400.         case '\013':
  401.         case '\014':
  402.         case '\015':
  403.         case '\016':
  404.         case '\017':
  405.         case '\020':
  406.         case '\021':
  407.         case '\022':
  408.         case '\023':
  409.         case '\024':
  410.         case '\025':
  411.         case '\026':
  412.         case '\027':
  413.         case '\030':
  414.         case '\031':
  415.         case '\032':
  416.             ch[i] += 96;
  417.             i--;
  418.             ctrla = TRUE;
  419.             break;
  420.         case '\033':
  421.             tractor = 0;
  422.             break;
  423.         case 'a':
  424.             tractor++;
  425.             break;
  426.         case 'r':
  427.             tractor--;
  428.             break;
  429.         case '1': case 'b':
  430.             do_direction(1,-1);
  431.             break;
  432.         case '2': case 'j':
  433.             do_direction(1,0);
  434.             break;
  435.         case '3': case 'n':
  436.             do_direction(1,1);
  437.             break;
  438.         case '4': case 'h':
  439.             do_direction(0,-1);
  440.             break;
  441.         case '6': case 'l':
  442.             do_direction(0,1);
  443.             break;
  444.         case '7': case 'y':
  445.             do_direction(-1,-1);
  446.             break;
  447.         case '8': case 'k':
  448.             do_direction(-1,0);
  449.             break;
  450.         case '9': case 'u':
  451.             do_direction(-1,1);
  452.             break;
  453.         case '0': case 'S':
  454.             if (status < 2) {
  455.             evely = 0;
  456.             evelx = 0;
  457.             }
  458.             break;
  459.         case '-':
  460.             if (status < 2 && ent->energy >= 10) {
  461.             evely *= -1;
  462.             evelx *= -1;
  463.             ent->energy -= 10;
  464.             }
  465.             break;
  466.         case '%': case '\177': case '_':
  467.             shift_direction(0, -1);
  468.             shift_direction(0, 1);
  469.             shift_direction(-1, 0);
  470.             shift_direction(1, 0);
  471.             shift_direction(-1, -1);
  472.             shift_direction(-1, 1);
  473.             shift_direction(1, -1);
  474.             shift_direction(1, 1);
  475.             break;
  476.         case '!': case 'B':
  477.             shift_direction(1, -1);
  478.             break;
  479.         case '@': case 'J':
  480.             shift_direction(1, 0);
  481.             break;
  482.         case '#': case 'N':
  483.             shift_direction(1, 1);
  484.             break;
  485.         case '$': case 'H':
  486.             shift_direction(0, -1);
  487.             break;
  488.         case '^': case 'L':
  489.             shift_direction(0, 1);
  490.             break;
  491.         case '&': case 'Y':
  492.             shift_direction(-1, -1);
  493.             break;
  494.         case '*': case 'K':
  495.             shift_direction(-1, 0);
  496.             break;
  497.         case '(': case 'U':
  498.             shift_direction(-1, 1);
  499.             break;
  500.         case '?':
  501.             helper();
  502.             roundsleep(3);
  503.             goto top;
  504.         default:
  505.             break;
  506.         }
  507.         }
  508.     }
  509.     }
  510. }
  511.