warp/init.c

   1 /* Header: init.c,v 7.0.1.4 86/12/12 16:58:03 lwall Exp */
   2
   3 /* Log: init.c,v
   4  * Revision 7.0.1.4  86/12/12  16:58:03  lwall
   5  * Baseline for net release.
   6  *
   7  * Revision 7.0.1.3  86/10/20  14:35:31  lwall
   8  * Picked some lint.
   9  *
  10  * Revision 7.0.1.2  86/10/17  15:53:30  lwall
  11  * Added random walk star fields.
  12  *
  13  * Revision 7.0.1.1  86/10/16  10:51:19  lwall
  14  * Added Damage.  Fixed random bugs.
  15  *
  16  * Revision 7.0  86/10/08  15:12:10  lwall
  17  * Split into separate files.  Added amoebas and pirates.
  18  *
  19  */
  20
  21 #include "EXTERN.h"
  22 #include "warp.h"
  23 #include "bang.h"
  24 #include "object.h"
  25 #include "move.h"
  26 #include "play.h"
  27 #include "score.h"
  28 #include "term.h"
  29 #include "them.h"
  30 #include "us.h"
  31 #include "util.h"
  32 #include "weapon.h"
  33 #include "INTERN.h"
  34 #include "init.h"
  35
  36 void
  37 initialize()
  38 {
  39     Reg1 int i;
  40     Reg2 int x;
  41     Reg3 int y;
  42     Reg4 int dist;
  43     Reg5 int ydist;
  44     Reg6 int xdist;
  45     long e;
  46     int yoff, xoff, ypred, xpred;
  47     Reg7 OBJECT *obj;
  48     char ch;
  49     FILE *mapfp = NULL;
  50     bool tmptholspec;
  51     int inhabjackpot;
  52     long inhenergy;
  53     int walksplit = 200;
  54     static char *distname[] =
  55         {" #"," -"," \\"," /",
  56          " |"," *"," `"," '"};
  57
  58     cloaking = madgorns = FALSE;
  59     deados = madfriends = 0;
  60     curscore = possiblescore = 0L;
  61     yamblast = xamblast = ambsize = 0;
  62     if (smarts > 90)
  63         massacre = TRUE;
  64     scandist = (massacre?20:15);
  65     antibase = (smarts>60?1:(smarts>40?2:(smarts>25?4:100)));
  66     sm35 = (smarts>35?35:smarts);
  67     sm45 = (smarts>45?45:smarts);
  68     sm50 = (smarts>50?50:smarts);
  69     sm55 = (smarts>55?55:smarts);
  70     sm80 = (smarts>80?80:smarts);
  71     sm95 = (smarts>95?95:smarts);
  72     super = (smarts>50?smarts-50:0);
  73     enemshields = 10 + super/2;         /* (scaled by 10) 1 @ 50 .. 3 @ 90 */
  74     if (smarts>90)
  75         enemshields += (smarts-90)*10;  /* lay it on thick: ~13 @ 99 */
  76     entmax = (smarts>=75?5000:(smarts>=50?4000:(smarts>=40?3000:2000)));
  77     basemax = (smarts>=75?20000:(smarts>=50?15000:(smarts>=40?12500:10000)));
  78
  79     clear();
  80     while (root.next != &root) {
  81         root.next = root.next->next;
  82         free_object(root.next->prev);
  83     }
  84     root.prev = &root;
  85     enemies = movers = NULL;
  86     numos = numxes = 0;
  87 #if defined(vax) && XYSIZEx4 == 3680
  88     asm("movc5 $0,_occupant,$0,$3680,_occupant");
  89     asm("movc5 $0,_blast,$0,$3680,_blast");     /* 3680 = XYSIZEx4 */
  90     asm("movc5 $0,_amb,$32,$920,_amb");
  91 #else
  92     for (y=0;y<YSIZE;y++)
  93         for (x=0;x<XSIZE;x++) {
  94             occupant[y][x] = 0;
  95             blast[y][x] = 0;
  96             amb[y][x] = ' ';
  97         }
  98 #endif
  99     for (y=0; y<YSIZE; y++)
 100         yblasted[y] = 0;
 101     for (x=0; x<XSIZE; x++)
 102         xblasted[x] = 0;
 103     blasted = FALSE;
 104     if (!starspec)
 105         if (smarts < 15)
 106             inumstars = 50 + rand_mod(50);
 107         else if (smarts < 50 || smarts > 85)
 108             inumstars = exdis(800) + rand_mod(100) + 1;
 109         else /* too few stars makes 50..85 too hard */
 110             inumstars = exdis(700) + rand_mod(150-super*2) + 50+super*2;
 111     tmptholspec = (smarts > 15 && inumstars < 450 && ! rand_mod(90-sm80));
 112     if (!klingspec) {
 113         inumenemies = rand_mod((smarts+1)/2) + 1;
 114         if (massacre || tmptholspec)
 115             inumenemies += 10;
 116     }
 117     if (!friendspec)
 118         inumfriends = rand_mod(smarts/8+1);
 119     if (!piratespec)
 120         inumpirates = rand_mod(inumfriends/2+1);
 121     if (inumfriends+inumenemies+inumstars > YSIZE*XSIZE-20)
 122         inumstars = YSIZE*XSIZE-20 - inumenemies - inumfriends;
 123     if (inumstars < 0) {
 124         inumfriends += inumstars;
 125         inumstars = 0;
 126     }
 127     if (inumfriends < 0) {
 128         inumenemies += inumfriends;
 129         inumfriends = 0;
 130     }
 131     if (inumenemies < 0)
 132         inumenemies = 0;
 133     numstars = inumstars;
 134     inuminhab = numinhab = 0;
 135     inumroms = inumthols = inumgorns = 0;
 136     numapollos = apolspec || massacre ? 1 :
 137        ((!numstars || rand_mod(2) || smarts < 10) ? 0 : 1);
 138     inumapollos = apolloflag = 0;
 139     realapollo = NULL;
 140     inumcrushes = numcrushes =
 141         crushspec||massacre?1:(rand_mod(2000) < inumstars);
 142     inumenemies += inumcrushes;
 143     inumamoebas = numamoebas = (amoebaspec ? 1 :
 144         !rand_mod(inumcrushes?3-massacre:8) );  /* < and & are fun together */
 145     inumenemies += inumamoebas;
 146     if (!rand_mod(40)) {
 147         inhabjackpot = 32767;
 148         inumfriends += rand_mod(10);
 149         inumpirates += rand_mod(10);
 150     }
 151     else
 152         inhabjackpot = inumpirates;
 153     inhenergy = 30000-super*150;
 154     if (!rand_mod(10))
 155         inhenergy = 50000;
 156     if (!rand_mod(4))
 157         inhenergy += rand_mod(3500+super*150);
 158     numfriends = inumfriends;
 159     numpirates = inumpirates;
 160     numenemies = inumenemies;
 161     deadmudds = 0;
 162
 163     /* do stars */
 164
 165 stars_again:
 166     if (prespec)
 167         dist = 4;
 168     else if (numstars > 750)
 169         dist = 0;
 170     else
 171         dist = rand_mod(starspec||smarts<=5?3:5);
 172     if (debugging) {
 173         real_y = real_x = -100;
 174         printf("\r\n");
 175     }
 176     switch (dist) {
 177     case 0:                             /* uniform random */
 178         ydist = xdist = 0;
 179         if (inumstars < 700 && !rand_mod(3-(inumstars<50))) {
 180             ydist = xdist = 6;          /* well, maybe not so random */
 181             y = rand_mod(YSIZE);
 182             x = rand_mod(XSIZE);
 183             if (rand_mod(2))
 184                 walksplit = inumstars/(exdis(40)+1);
 185         }
 186         if (debugging)
 187             printf(" R\r\n");
 188         break;
 189     case 1: case 2:     /* clumped, maybe skewed, maybe superposed */
 190         ydist = rand_mod(4);
 191         xdist = rand_mod(2);
 192         if (debugging)
 193             printf("%s\r\n",distname[ydist+4*xdist]);
 194         yoff = rand_mod(YSIZE);
 195         xoff = rand_mod(XSIZE);
 196         if (dist == 2)
 197             dist = numstars/2 + exdis(numstars/2) - exdis(numstars/2);
 198         else
 199             dist = 0;
 200         break;
 201     case 3: case 4:                     /* predefined or residual */
 202       scenario_again:
 203         if (debugging)
 204             printf(" P\r\n");
 205         dist = 0;
 206         Sprintf(spbuf,"smap.%d",
 207             (prescene>=0?prescene:rand_mod(MAPS)) );
 208         if ((mapfp = fopen(spbuf,"r")) != NULL &&
 209             fgets(spbuf,10,mapfp) != NULL ) {
 210             inumstars = numstars = atoi(spbuf);
 211             if (inumenemies+inumstars > YSIZE*XSIZE-20)
 212                 inumstars = numstars = YSIZE*XSIZE-20 - inumenemies;
 213             ydist = rand_mod(2) + 4;    /* flip y axis? */
 214             xdist = rand_mod(2) + 4;    /* flip x axis? */
 215             yoff = rand_mod(YSIZE);     /* how much to shift y */
 216             xoff = rand_mod(XSIZE);     /* how much to shift x */
 217         }
 218         else {
 219             prespec = FALSE;
 220             prescene = -1;
 221             if (rand_mod(2))
 222                 goto scenario_again;
 223             goto stars_again;
 224         }
 225         break;
 226     }
 227     for (i = 1; i <= numstars; i++) {
 228         if (dist && i == dist) {        /* flip to another skewing? */
 229             ydist = rand_mod(4);
 230             xdist = rand_mod(2);
 231             if (!rand_mod(4)) {
 232                 ydist = xdist = 6;
 233                 if (debugging)
 234                     printf("&\r\n");
 235             }
 236             else if (debugging)
 237                 printf("%s\r\n",distname[ydist+4*xdist]);
 238             yoff = rand_mod(YSIZE);
 239             xoff = rand_mod(XSIZE);
 240             dist = 0;
 241         }
 242         do {                            /* until an open spot found */
 243             switch (xdist) {
 244             case 0:
 245                 x = rand_mod(XSIZE);    /* pick from 0..39, uniform */
 246                 break;
 247             case 1: case 2: case 3:
 248 #ifndef lint
 249                 x = (int)((((double)(myrand()-HALFRAND)) *
 250                            ((double)(myrand()-HALFRAND))/RANDRAND)
 251                           * 20.0) + xoff;       /* pick from -20..20, clumped */
 252 #endif
 253                 break;
 254             case 4:
 255                 if (fscanf(mapfp,"%d %d\n",&ypred,&xpred) == EOF)
 256                     ydist = xdist = 0;
 257                 x = xpred + xoff;
 258                 break;
 259             case 5:
 260                 if (fscanf(mapfp,"%d %d\n",&ypred,&xpred) == EOF)
 261                     ydist = xdist = 0;
 262                 x = -xpred + xoff;
 263                 break;
 264             case 6:
 265                 x += rand_mod(3) - 1;
 266                 break;
 267             }
 268             switch (ydist) {
 269             case 0:
 270                 y = rand_mod(YSIZE);
 271                 break;
 272             case 1:
 273 #ifndef lint
 274                 y = (int)((((double)(myrand()-HALFRAND)) *
 275                            ((double)(myrand()-HALFRAND))/RANDRAND)
 276                           * 12.0) + yoff;       /* pick from -12..12, clumped */
 277 #endif
 278                 break;
 279             case 2:
 280 #ifndef lint
 281                 y = (int)((((double)(myrand()-HALFRAND)) *
 282                            ((double)(myrand()-HALFRAND))/RANDRAND)
 283                           * 12.0) + yoff + x*YSIZE/XSIZE;
 284                                                 /* clumped & skewed */
 285 #endif
 286                 break;
 287             case 3:
 288 #ifndef lint
 289                 y = (int)((((double)(myrand()-HALFRAND)) *
 290                            ((double)(myrand()-HALFRAND))/RANDRAND)
 291                           * 12.0) + yoff - x*YSIZE/XSIZE;
 292                                                 /* clumped & skewed */
 293 #endif
 294                 break;
 295             case 4:
 296                 y = ypred + yoff;
 297                 break;
 298             case 5:
 299                 y = -ypred + yoff;
 300                 break;
 301             case 6:
 302                 y += rand_mod(3) - 1;
 303 #ifdef lint
 304                 walksplit = walksplit;
 305 #endif
 306                 if (!rand_mod(walksplit)) {
 307                     y = rand_mod(YSIZE);
 308                     x = rand_mod(XSIZE);
 309                 }
 310                 break;
 311             }
 312             while (x<0) x += XSIZE00;
 313             while (y<0) y += YSIZE00;
 314             x %= XSIZE;
 315             y %= YSIZE;
 316         } while (occupant[y][x]);
 317         e = rand_mod(32768);
 318         if (--inhabjackpot > 0 || e >= inhenergy) {
 319             ch = '@';
 320             if (inhabjackpot && e < 10000)
 321                 e += 10000;
 322             inuminhab = ++numinhab;
 323         }
 324         else {
 325             ch = '*';
 326         }
 327         obj = make_object(Star,ch,y,x,0,0,e+rand_mod(super*100+1),e/4,&root);
 328         obj->flags |= STATIC;
 329     }
 330     if (inumstars > 30 && inhabjackpot <= 0 &&
 331          !rand_mod(3 - (inumstars > 400) - (inhenergy > 32768)) ) {
 332         int initx;
 333         int inity;
 334
 335         x = initx = obj->posx;
 336         y = inity = obj->posy;
 337         while (rand_mod(2) && inuminhab < inumstars/2) {
 338             for (i=rand_mod(smarts)*2+20; i; i--) {
 339                 if ((obj = occupant[y][x]) && obj->image == '*') {
 340                     setimage(obj,'@');
 341                     if (obj->energy < 10000)
 342                         obj->energy += 20000; /* the benefits of civilization */
 343                     inuminhab = ++numinhab;
 344                 }
 345                 if (i&15) {
 346                     y = (y + rand_mod(3) + YSIZE99) % YSIZE;
 347                     x = (x + rand_mod(3) + XSIZE99) % XSIZE;
 348                 }
 349                 else {                  /* don't wander too far */
 350                     y = inity;
 351                     x = initx;
 352                 }
 353             }
 354             x = initx = rand_mod(XSIZE);
 355             y = inity = rand_mod(YSIZE);
 356         }
 357     }
 358     if (mapfp != NULL)
 359         Fclose(mapfp);
 360     if (numcrushes) {
 361         do {
 362             x = rand_mod(XSIZE);
 363             y = rand_mod(YSIZE);
 364         } while (occupant[y][x]);
 365         movers = make_object(Crusher,'<',y,x,0,1,32767L,32768L,&root);
 366         possiblescore += 10000;
 367     }
 368     ient = (numents != 0);
 369     if (ient) {
 370         do {
 371             x = rand_mod(XSIZE);
 372             y = rand_mod(YSIZE);
 373         } while (occupant[y][x]);
 374         e = entmax;
 375         ent = make_object(Enterprise,'E',y,x,0,0,e,e/2,&root);
 376         if (!movers)
 377             movers = ent;
 378     }
 379     ibase = (numbases != 0);
 380     if (ibase) {
 381         e = 52-super;
 382         do {
 383             x = rand_mod(XSIZE);
 384             y = rand_mod(YSIZE);
 385         } while (occupant[y][x] || lookaround(y,x,Star) * 7 < e--);
 386         e = basemax;
 387         base = make_object(Base, 'B',y,x,0,0,e,e/4,&root);
 388         if (!movers)
 389             movers = base;
 390     }
 391     if (numamoebas) {
 392         do {
 393             x = rand_mod(XSIZE);
 394             y = rand_mod(YSIZE);
 395         } while (occupant[y][x]);
 396         nuke = make_object(Enemy,'&',y,x,0,0,32767L,
 397           (long)entmax+entmax+rand_mod(entmax),&root);
 398         possiblescore += 10000;
 399         amb[y][x] = '~';
 400         if (rand_mod(2))
 401             modify_amoeba(y,x,2,'~',(int)rand_mod(smarts<<1));/* just make blob */
 402         else {
 403             for (i=smarts/10+1; i; i--) {
 404                 nuke->strategy = rand_mod(256);         /* random direction */
 405                 modify_amoeba(y,x,2,'~',(int)rand_mod(5));
 406                 modify_amoeba(y,x,2,'~',(int)rand_mod(5));
 407                 modify_amoeba(y,x,2,'~',(int)rand_mod(5));
 408                 modify_amoeba(y,x,2,'~',(int)rand_mod(5));      /* extend pseudopod */
 409             }
 410         }
 411         if (!enemies)
 412             enemies = nuke;
 413         if (!movers)
 414             movers = nuke;
 415     }
 416     if (rand_mod(27-sm50/2) && !romspec && !gornspec)
 417         dist = 27-sm50/2;
 418     else
 419         dist = rand_mod(4) + 1;
 420     for (i = 1+inumcrushes+inumamoebas; i <= numenemies; i++) {
 421         do {
 422             x = rand_mod(XSIZE);
 423             y = rand_mod(YSIZE);
 424         } while (occupant[y][x]);
 425         if (rand_mod(dist)) {
 426             if (!tholspec && !tmptholspec && rand_mod((inumstars*3)/sm50+2))
 427                 ch = 'K';
 428             else {
 429                 ch = 'T';
 430                 inumthols++;
 431             }
 432         }
 433         else {
 434             if (romspec == gornspec)
 435                 e = 50;
 436             else if (gornspec)
 437                 e = 10;
 438             else
 439                 e = 90;
 440             if (rand_mod(100) < e) {
 441                 ch = 'R';
 442                 inumroms++;
 443             }
 444             else {
 445                 ch = 'G';
 446                 inumgorns++;
 447             }
 448         }
 449         if (possiblescore > ENTBOUNDARY - 10000)
 450             e = (ENTBOUNDARY - possiblescore) / 5;
 451         else
 452             e = 250 + (sm50-1) * 30 * 20 / numenemies+1;
 453 #ifndef lint
 454         e = exdis((int)e) + e - exdis((int)e);
 455         obj = make_object(Enemy,ch,y,x,0,0,
 456             e + rand_mod(super*200+2) + 10000*massacre,e/4,&root);
 457 #endif
 458         e /= 4;
 459         switch (ch) {
 460         case 'K':
 461             possiblescore += e;
 462             break;
 463         case 'T':
 464             possiblescore += e*3/2;
 465             break;
 466         case 'G':
 467             possiblescore += e*2;
 468             break;
 469         case 'R':
 470             possiblescore += e*3;
 471             obj->flags |= CLOAKS;
 472             break;
 473         }
 474         if (!enemies)
 475             enemies = obj;
 476         if (!movers)
 477             movers = obj;
 478     }
 479     numgorns = inumgorns;
 480     for (i=0; i<numfriends; i++) {
 481         do {
 482             x = rand_mod(XSIZE);
 483             y = rand_mod(YSIZE);
 484         } while (occupant[y][x]);
 485         e = 250 + (sm50-1) * 30 * 20 / numenemies+1;
 486 #ifndef lint
 487         e = exdis((int)e) + e - exdis((int)e);
 488 #endif
 489         {
 490             static char let[] = "QWYUISDHJLZVMFFFFFFFFF";
 491
 492             dist = rand_mod(20);
 493             ch = let[dist];
 494         }               /* grr, venix doesn't like indexing into string */
 495         obj = make_object(Enemy,ch,y,x,0,0,
 496             e + rand_mod(super*200+2),e/4,&root);
 497         if (numpirates-- > 0) {
 498             obj->flags |= PIRATE;
 499             if (smarts >= 20 && !rand_mod(10-smarts/10))
 500                 obj->flags |= CLOAKS;
 501         }
 502         obj->flags |= FRIENDLY;
 503         if (!enemies)
 504             enemies = obj;
 505         if (!movers)
 506             movers = obj;
 507     }
 508     if (!movers)
 509         movers = &root;
 510     if (!enemies)
 511         enemies = &root;
 512     if (ent)
 513         mvaddch(ent->posy+1, ent->posx*2, ent->image);
 514     if (base)
 515         mvaddch(base->posy+1, base->posx*2, base->image);
 516     sleep(2);
 517     {
 518         Reg7 OBJECT *curobj;
 519
 520         for (curobj = root.next; curobj != &root; curobj = curobj->next) {
 521             mvaddch(curobj->posy+1, curobj->posx*2, curobj->image);
 522         }
 523     }
 524
 525     for (i=0;i<2;i++) for (y=0;y<3;y++) for (x=0;x<3;x++)
 526     isatorp[i][y][x]=0;
 527
 528     whenok = 0;
 529     timer = 0;
 530     finish = 0;
 531     bombed_out = FALSE;
 532     if (ent)
 533         entmode = status = 0;
 534     else
 535         if (base)
 536             status = 2;
 537         else
 538             status = 3;
 539
 540     Sprintf(spbuf,
 541     "%-4s E: %4d %2d B: %5d %3d Enemies: %-3d Stars: %-3d Stardate%5d.%1d %9ld",
 542         "   ", 0, 0, 0, 0, 0, 0, smarts * 100, 0, 0L);
 543     mvaddstr(0,0,spbuf);
 544     oldeenergy = oldbenergy = oldcurscore =
 545     oldstatus = oldetorp = oldbtorp = oldstrs = oldenemies = -1;
 546                                         /* force everything to fill in */
 547     damage = olddamage = 0;
 548     for (i=0; i<MAXDAMAGE; i++)
 549         damflag[i] = 0;
 550     btorp = 500;
 551     etorp = 50;
 552 }