warp/us.c

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