git.hungrycats.org Git - xscreensaver/blob - hacks/penetrate.c

   1 /* Copyright (c) 1999 Adam Miller adum@aya.yale.edu
   2  *
   3  * Permission to use, copy, modify, distribute, and sell this software and its
   4  * documentation for any purpose is hereby granted without fee, provided that
   5  * the above copyright notice appear in all copies and that both that
   6  * copyright notice and this permission notice appear in supporting
   7  * documentation.  No representations are made about the suitability of this
   8  * software for any purpose.  It is provided "as is" without express or
   9  * implied warranty.
  10
  11  * penetrate simulates the arcade classic with the cities and the stuff
  12  * shooting down from the sky and stuff. The computer plays against itself,
  13  * desperately defending the forces of good against those thingies raining
  14  * down. Bonus cities are awarded at ever-increasing intervals. Every five
  15  * levels appears a bonus round. The computer player gets progressively
  16  * more intelligent as the game progresses. Better aim, more economical with
  17  * ammo, and better target selection. Points are in the bottom right, and
  18  * high score is in the bottom left. Start with -smart to have the computer
  19  * player skip the learning process.
  20
  21  Version: 0.2
  22  -- fixed an AI bug that was keeping the computer player a tad weak
  23  Version: 0.1
  24  -- first release
  25
  26  */
  27
  28 #include "screenhack.h"
  29
  30 #define kSleepTime 10000
  31
  32 #define font_height(font)               (font->ascent + font->descent)
  33
  34 #define kCityPause 500000
  35 #define kLevelPause 1
  36 #define SCORE_MISSILE 100
  37 #define kFirstBonus 5000
  38 #define kMinRate 30
  39 #define kMaxRadius 100
  40
  41 typedef struct {
  42   int alive;
  43   int x, y;
  44   int startx, starty;
  45   int endx, endy;
  46   int dcity;
  47   float pos;
  48   int enemies;
  49   int jenis;
  50   int splits;
  51   XColor color;
  52 } Missile;
  53
  54 typedef struct {
  55   int alive;
  56   int x, y, rad, oflaser;
  57   int max, outgoing;
  58   XColor color;
  59 } Boom;
  60
  61 typedef struct {
  62   int alive;
  63   int x;
  64   XColor color;
  65 } City;
  66
  67 typedef struct {
  68   int alive;
  69   int x, y;
  70   int startx, starty;
  71   int endx, endy;
  72   int oldx, oldy;
  73   int oldx2, oldy2;
  74   float velx, vely, fposx, fposy;
  75   float lenMul;
  76   XColor color;
  77   int target;
  78 } Laser;
  79
  80 #define kMaxMissiles 256
  81 #define kMaxBooms 512
  82 #define kMaxLasers 128
  83 #define kBoomRad 40
  84 #define kNumCities 5
  85
  86 #define kLaserLength 12
  87
  88 #define kMissileSpeed 0.003
  89 #define kLaserSpeed (kMissileSpeed * 6)
  90
  91
  92 struct state {
  93   Display *dpy;
  94   Window window;
  95
  96    XFontStruct *font, *scoreFont;
  97    GC draw_gc, erase_gc, level_gc;
  98    unsigned int default_fg_pixel;
  99    XColor scoreColor;
 100
 101    int bgrowth;
 102    int lrate, startlrate;
 103    long loop;
 104    long score, highscore;
 105    long nextBonus;
 106    int numBonus;
 107    int bround;
 108    long lastLaser;
 109    int gamez;
 110    int aim;
 111    int econpersen;
 112    int choosypersen;
 113    int carefulpersen;
 114    int smart;
 115    Colormap cmap;
 116
 117    Missile missile[kMaxMissiles];
 118    Boom boom[kMaxBooms];
 119    City city[kNumCities];
 120    Laser laser[kMaxLasers];
 121    int blive[kNumCities];
 122
 123    int level, levMissiles, levFreq;
 124
 125    int draw_xlim, draw_ylim;
 126    int draw_reset;
 127 };
 128
 129
 130 static void Explode(struct state *st, int x, int y, int max, XColor color, int oflaser)
 131 {
 132   int i;
 133   Boom *m = 0;
 134   for (i=0;i<kMaxBooms;i++)
 135          if (!st->boom[i].alive) {
 136                 m = &st->boom[i];
 137                 break;
 138          }
 139   if (!m)
 140          return;
 141
 142   m->alive = 1;
 143   m->x = x;
 144   m->y = y;
 145   m->rad = 0;
 146   if (max > kMaxRadius)
 147          max = kMaxRadius;
 148   m->max = max;
 149   m->outgoing = 1;
 150   m->color = color;
 151   m->oflaser = oflaser;
 152 }
 153
 154 static void launch (struct state *st, int xlim, int ylim, int src)
 155 {
 156   int i;
 157   Missile *m = 0, *msrc;
 158   for (i=0;i<kMaxMissiles;i++)
 159          if (!st->missile[i].alive) {
 160                 m = &st->missile[i];
 161                 break;
 162          }
 163   if (!m)
 164          return;
 165
 166   m->alive = 1;
 167   m->startx = (random() % xlim);
 168   m->starty = 0;
 169   m->endy = ylim;
 170   m->pos = 0.0;
 171   m->jenis = random() % 360;
 172   m->splits = 0;
 173   if (m->jenis < 50) {
 174     int j = ylim * 0.4;
 175     if (j) {
 176          m->splits = random() % j;
 177          if (m->splits < ylim * 0.08)
 178                 m->splits = 0;
 179     }
 180   }
 181
 182   /* special if we're from another missile */
 183   if (src >= 0) {
 184          int dc = random() % (kNumCities - 1);
 185          msrc = &st->missile[src];
 186          if (dc == msrc->dcity)
 187                 dc++;
 188          m->dcity = dc;
 189          m->startx = msrc->x;
 190          m->starty = msrc->y;
 191          if (m->starty > ylim * 0.4 || m->splits <= m->starty)
 192                 m->splits = 0;  /* too far down already */
 193          m->jenis = msrc->jenis;
 194   }
 195   else
 196          m->dcity = random() % kNumCities;
 197   m->endx = st->city[m->dcity].x + (random() % 20) - 10;
 198   m->x = m->startx;
 199   m->y = m->starty;
 200   m->enemies = 0;
 201
 202   if (!mono_p) {
 203          hsv_to_rgb (m->jenis, 1.0, 1.0,
 204                                          &m->color.red, &m->color.green, &m->color.blue);
 205          m->color.flags = DoRed | DoGreen | DoBlue;
 206          if (!XAllocColor (st->dpy, st->cmap, &m->color)) {
 207                 m->color.pixel = WhitePixel (st->dpy, DefaultScreen (st->dpy));
 208                 m->color.red = m->color.green = m->color.blue = 0xFFFF;
 209          }
 210   }
 211 }
 212
 213 #define kExpHelp 0.2
 214 #define kSpeedDiff 3.5
 215 #define kMaxToGround 0.75
 216 static int fire(struct state *st, int xlim, int ylim)
 217 {
 218   int i, j, cnt = 0;
 219   int dcity;
 220   long dx, dy, ex, ey;
 221   Missile *mis = 0;
 222   Laser *m = 0;
 223   int untargeted = 0;
 224   int choosy = 0, economic = 0, careful = 0;
 225   int suitor[kMaxMissiles];
 226   int livecity = 0;
 227   int ytargetmin = ylim * 0.75;
 228   int deepest = 0;
 229   int misnum = 0;
 230
 231   choosy = (random() % 100) < st->choosypersen;
 232   economic = (random() % 100) < st->econpersen;
 233   careful = (random() % 100) < st->carefulpersen;
 234
 235   /* count our cities */
 236   for (i=0;i<kNumCities;i++)
 237          livecity += st->city[i].alive;
 238   if (livecity == 0)
 239          return 1;  /* no guns */
 240
 241   for (i=0;i<kMaxLasers;i++)
 242          if (!st->laser[i].alive) {
 243                 m = &st->laser[i];
 244                 break;
 245          }
 246   if (!m)
 247          return 1;
 248
 249   /* if no missiles on target, no need to be choosy */
 250   if (choosy) {
 251          int choo = 0;
 252          for (j=0;j<kMaxMissiles;j++) {
 253                 mis = &st->missile[j];
 254                 if (!mis->alive || (mis->y > ytargetmin))
 255                   continue;
 256                 if (st->city[mis->dcity].alive)
 257                   choo++;
 258          }
 259          if (choo == 0)
 260                 choosy = 0;
 261   }
 262
 263   for (j=0;j<kMaxMissiles;j++) {
 264          mis = &st->missile[j];
 265          suitor[j] = 0;
 266          if (!mis->alive || (mis->y > ytargetmin))
 267                 continue;
 268          if (choosy && (st->city[mis->dcity].alive == 0))
 269                 continue;
 270          ey = mis->starty + ((float) (mis->endy - mis->starty)) * (mis->pos + kExpHelp + (1.0 - mis->pos) / kSpeedDiff);
 271          if (ey > ylim * kMaxToGround)
 272                 continue;  /* too far down */
 273          cnt++;
 274          suitor[j] = 1;
 275   }
 276
 277   /* count missiles that are on target and not being targeted */
 278   if (choosy && economic)
 279          for (j=0;j<kMaxMissiles;j++)
 280                 if (suitor[j] && st->missile[j].enemies == 0)
 281                   untargeted++;
 282
 283   if (economic)
 284          for (j=0;j<kMaxMissiles;j++) {
 285                 if (suitor[j] && cnt > 1)
 286                   if (st->missile[j].enemies > 0)
 287                          if (st->missile[j].enemies > 1 || untargeted == 0) {
 288                                 suitor[j] = 0;
 289                                 cnt--;
 290                          }
 291                 /* who's closest? biggest threat */
 292                 if (suitor[j] && st->missile[j].y > deepest)
 293                   deepest = st->missile[j].y;
 294          }
 295
 296   if (deepest > 0 && careful) {
 297          /* only target deepest missile */
 298          cnt = 1;
 299          for (j=0;j<kMaxMissiles;j++)
 300                 if (suitor[j] && st->missile[j].y != deepest)
 301                   suitor[j] = 0;
 302   }
 303
 304   if (cnt == 0)
 305          return 1;  /* no targets available */
 306   cnt = random() % cnt;
 307   for (j=0;j<kMaxMissiles;j++)
 308          if (suitor[j])
 309                 if (cnt-- == 0) {
 310                   mis = &st->missile[j];
 311                   misnum = j;
 312                   break;
 313                 }
 314
 315   if (mis == 0)
 316          return 1;  /* shouldn't happen */
 317
 318   dcity = random() % livecity;
 319   for (j=0;j<kNumCities;j++)
 320          if (st->city[j].alive)
 321                 if (dcity-- == 0) {
 322                   dcity = j;
 323                   break;
 324                 }
 325   m->startx = st->city[dcity].x;
 326   m->starty = ylim;
 327   ex = mis->startx + ((float) (mis->endx - mis->startx)) * (mis->pos + kExpHelp + (1.0 - mis->pos) / kSpeedDiff);
 328   ey = mis->starty + ((float) (mis->endy - mis->starty)) * (mis->pos + kExpHelp + (1.0 - mis->pos) / kSpeedDiff);
 329   m->endx = ex + random() % 16 - 8 + (random() % st->aim) - st->aim / 2;
 330   m->endy = ey + random() % 16 - 8 + (random() % st->aim) - st->aim / 2;
 331   if (ey > ylim * kMaxToGround)
 332          return 0;  /* too far down */
 333   mis->enemies++;
 334   m->target = misnum;
 335   m->x = m->startx;
 336   m->y = m->starty;
 337   m->oldx = -1;
 338   m->oldy = -1;
 339   m->oldx2 = -1;
 340   m->oldy2 = -1;
 341   m->fposx = m->x;
 342   m->fposy = m->y;
 343   dx = (m->endx - m->x);
 344   dy = (m->endy - m->y);
 345   m->velx = dx / 100.0;
 346   m->vely = dy / 100.0;
 347   m->alive = 1;
 348   /* m->lenMul = (kLaserLength * kLaserLength) / (m->velx * m->velx + m->vely * m->vely); */
 349   m->lenMul = -(kLaserLength / m->vely);
 350
 351   if (!mono_p) {
 352          m->color.blue = 0x0000;
 353          m->color.green = 0xFFFF;
 354          m->color.red = 0xFFFF;
 355          m->color.flags = DoRed | DoGreen | DoBlue;
 356          if (!XAllocColor (st->dpy, st->cmap, &m->color)) {
 357                 m->color.pixel = WhitePixel (st->dpy, DefaultScreen (st->dpy));
 358                 m->color.red = m->color.green = m->color.blue = 0xFFFF;
 359          }
 360   }
 361   return 1;
 362 }
 363
 364 static void *
 365 penetrate_init (Display *dpy, Window window)
 366 {
 367   struct state *st = (struct state *) calloc (1, sizeof(*st));
 368   int i;
 369   const char *levelfont = "-*-courier-*-r-*-*-*-380-*-*-*-*-*-*";
 370   const char *scorefont = "-*-helvetica-*-r-*-*-*-180-*-*-*-*-*-*";
 371   XGCValues gcv;
 372   XWindowAttributes xgwa;
 373
 374   st->dpy = dpy;
 375   st->window = window;
 376
 377   XGetWindowAttributes (st->dpy, st->window, &xgwa);
 378   st->cmap = xgwa.colormap;
 379
 380   st->lrate = 80;
 381   st->nextBonus = kFirstBonus;
 382   st->aim = 180;
 383
 384   st->smart = get_boolean_resource(st->dpy, "smart","Boolean");
 385   st->bgrowth = get_integer_resource (st->dpy, "bgrowth", "Integer");
 386   st->lrate = get_integer_resource (st->dpy, "lrate", "Integer");
 387   if (st->bgrowth < 0) st->bgrowth = 2;
 388   if (st->lrate < 0) st->lrate = 2;
 389   st->startlrate = st->lrate;
 390
 391   st->font = XLoadQueryFont(st->dpy, levelfont);
 392   if (!st->font) {
 393     fprintf (stderr, "%s: could not load font %s.\n", progname, levelfont);
 394     st->font = XLoadQueryFont(st->dpy, scorefont);
 395     if (! st->font)
 396       st->font = XLoadQueryFont(st->dpy, "fixed");
 397     if (! st->font) abort();
 398   }
 399
 400   st->scoreFont = XLoadQueryFont(st->dpy, scorefont);
 401   if (!st->scoreFont) {
 402     fprintf (stderr, "%s: could not load font %s.\n", progname, scorefont);
 403     st->scoreFont = XLoadQueryFont(st->dpy, levelfont);
 404     if (! st->scoreFont)
 405       st->scoreFont = XLoadQueryFont(st->dpy, "fixed");
 406     if (! st->scoreFont) abort();
 407   }
 408
 409   for (i = 0; i < kMaxMissiles; i++)
 410     st->missile[i].alive = 0;
 411
 412   for (i = 0; i < kMaxLasers; i++)
 413     st->laser[i].alive = 0;
 414
 415   for (i = 0; i < kMaxBooms; i++)
 416     st->boom[i].alive = 0;
 417
 418   for (i = 0; i < kNumCities; i++) {
 419          City *m = &st->city[i];
 420     m->alive = 1;
 421          m->color.red = m->color.green = m->color.blue = 0xFFFF;
 422          m->color.blue = 0x1111; m->color.green = 0x8888;
 423          m->color.flags = DoRed | DoGreen | DoBlue;
 424          if (!XAllocColor (st->dpy, st->cmap, &m->color)) {
 425                 m->color.pixel = WhitePixel (st->dpy, DefaultScreen (st->dpy));
 426                 m->color.red = m->color.green = m->color.blue = 0xFFFF;
 427          }
 428   }
 429
 430   gcv.foreground = st->default_fg_pixel =
 431     get_pixel_resource(st->dpy, st->cmap, "foreground", "Foreground");
 432   gcv.font = st->scoreFont->fid;
 433   st->draw_gc = XCreateGC(st->dpy, st->window, GCForeground | GCFont, &gcv);
 434   gcv.font = st->font->fid;
 435   st->level_gc = XCreateGC(st->dpy, st->window, GCForeground | GCFont, &gcv);
 436   XSetForeground (st->dpy, st->level_gc, st->city[0].color.pixel);
 437   gcv.foreground = get_pixel_resource(st->dpy, st->cmap, "background", "Background");
 438   st->erase_gc = XCreateGC(st->dpy, st->window, GCForeground, &gcv);
 439
 440 # ifdef HAVE_JWXYZ
 441   jwxyz_XSetAntiAliasing (st->dpy, st->erase_gc, False);
 442   jwxyz_XSetAntiAliasing (st->dpy, st->draw_gc, False);
 443 # endif
 444
 445
 446   /* make a gray color for score */
 447   if (!mono_p) {
 448          st->scoreColor.red = st->scoreColor.green = st->scoreColor.blue = 0xAAAA;
 449          st->scoreColor.flags = DoRed | DoGreen | DoBlue;
 450          if (!XAllocColor (st->dpy, st->cmap, &st->scoreColor)) {
 451                 st->scoreColor.pixel = WhitePixel (st->dpy, DefaultScreen (st->dpy));
 452                 st->scoreColor.red = st->scoreColor.green = st->scoreColor.blue = 0xFFFF;
 453          }
 454   }
 455
 456   XClearWindow(st->dpy, st->window);
 457   return st;
 458 }
 459
 460 static void DrawScore(struct state *st, int xlim, int ylim)
 461 {
 462   char buf[16];
 463   int width, height;
 464   sprintf(buf, "%ld", st->score);
 465   width = XTextWidth(st->scoreFont, buf, strlen(buf));
 466   height = font_height(st->scoreFont);
 467   XSetForeground (st->dpy, st->draw_gc, st->scoreColor.pixel);
 468   XFillRectangle(st->dpy, st->window, st->erase_gc,
 469                                   xlim - width - 6, ylim - height - 2, width + 6, height + 2);
 470   XDrawString(st->dpy, st->window, st->draw_gc, xlim - width - 2, ylim - 2,
 471                     buf, strlen(buf));
 472
 473   sprintf(buf, "%ld", st->highscore);
 474   width = XTextWidth(st->scoreFont, buf, strlen(buf));
 475   XFillRectangle(st->dpy, st->window, st->erase_gc,
 476                                   4, ylim - height - 2, width + 4, height + 2);
 477   XDrawString(st->dpy, st->window, st->draw_gc, 4, ylim - 2,
 478                     buf, strlen(buf));
 479 }
 480
 481 static void AddScore(struct state *st, int xlim, int ylim, long dif)
 482 {
 483   int i, sumlive = 0;
 484   for (i=0;i<kNumCities;i++)
 485          sumlive += st->city[i].alive;
 486   if (sumlive == 0)
 487          return;   /* no cities, not possible to score */
 488
 489   st->score += dif;
 490   if (st->score > st->highscore)
 491          st->highscore = st->score;
 492   DrawScore(st, xlim, ylim);
 493 }
 494
 495 static void DrawCity(struct state *st, int x, int y, XColor col)
 496 {
 497          XSetForeground (st->dpy, st->draw_gc, col.pixel);
 498          XFillRectangle(st->dpy, st->window, st->draw_gc,
 499                                   x - 30, y - 40, 60, 40);
 500          XFillRectangle(st->dpy, st->window, st->draw_gc,
 501                                                  x - 20, y - 50, 10, 10);
 502          XFillRectangle(st->dpy, st->window, st->draw_gc,
 503                                   x + 10, y - 50, 10, 10);
 504 }
 505
 506 static void DrawCities(struct state *st, int xlim, int ylim)
 507 {
 508   int i, x;
 509   for (i = 0; i < kNumCities; i++) {
 510          City *m = &st->city[i];
 511          if (!m->alive)
 512                 continue;
 513          x = (i + 1) * (xlim / (kNumCities + 1));
 514          m->x = x;
 515
 516          DrawCity(st, x, ylim, m->color);
 517   }
 518 }
 519
 520 static void LoopMissiles(struct state *st, int xlim, int ylim)
 521 {
 522   int i, j, max = 0;
 523   for (i = 0; i < kMaxMissiles; i++) {
 524          int old_x, old_y;
 525          Missile *m = &st->missile[i];
 526          if (!m->alive)
 527                 continue;
 528          old_x = m->x;
 529          old_y = m->y;
 530          m->pos += kMissileSpeed;
 531          m->x = m->startx + ((float) (m->endx - m->startx)) * m->pos;
 532          m->y = m->starty + ((float) (m->endy - m->starty)) * m->pos;
 533
 534       /* erase old one */
 535
 536          XSetLineAttributes(st->dpy, st->draw_gc, 4, 0,0,0);
 537     XSetForeground (st->dpy, st->draw_gc, m->color.pixel);
 538          XDrawLine(st->dpy, st->window, st->draw_gc,
 539                                   old_x, old_y, m->x, m->y);
 540
 541          /* maybe split off a new missile? */
 542          if (m->splits && (m->y > m->splits)) {
 543                 m->splits = 0;
 544                 launch(st, xlim, ylim, i);
 545          }
 546
 547          if (m->y >= ylim) {
 548                 m->alive = 0;
 549                 if (st->city[m->dcity].alive) {
 550                   st->city[m->dcity].alive = 0;
 551                   Explode(st, m->x, m->y, kBoomRad * 2, m->color, 0);
 552                 }
 553          }
 554
 555          /* check hitting explosions */
 556          for (j=0;j<kMaxBooms;j++) {
 557                 Boom *b = &st->boom[j];
 558                 if (!b->alive)
 559                   continue;
 560                 else {
 561                   int dx = abs(m->x - b->x);
 562                   int dy = abs(m->y - b->y);
 563                   int r = b->rad + 2;
 564                   if ((dx < r) && (dy < r))
 565                          if (dx * dx + dy * dy < r * r) {
 566                                 m->alive = 0;
 567                                 max = b->max + st->bgrowth - kBoomRad;
 568                                 AddScore(st, xlim, ylim, SCORE_MISSILE);
 569                   }
 570                 }
 571          }
 572
 573          if (m->alive == 0) {
 574                 float my_pos;
 575                 /* we just died */
 576                 Explode(st, m->x, m->y, kBoomRad + max, m->color, 0);
 577                 XSetLineAttributes(st->dpy, st->erase_gc, 4, 0,0,0);
 578                 /* In a perfect world, we could simply erase a line from
 579                    (m->startx, m->starty) to (m->x, m->y). This is not a
 580                    perfect world. */
 581                 old_x = m->startx;
 582                 old_y = m->starty;
 583                 my_pos = kMissileSpeed;
 584                 while (my_pos <= m->pos) {
 585                         m->x = m->startx + ((float) (m->endx - m->startx)) * my_pos;
 586                         m->y = m->starty + ((float) (m->endy - m->starty)) * my_pos;
 587                         XDrawLine(st->dpy, st->window, st->erase_gc, old_x, old_y, m->x, m->y);
 588                         old_x = m->x;
 589                         old_y = m->y;
 590                         my_pos += kMissileSpeed;
 591                 }
 592          }
 593   }
 594 }
 595
 596 static void LoopLasers(struct state *st, int xlim, int ylim)
 597 {
 598   int i, j, miny = ylim * 0.8;
 599   int x, y;
 600   for (i = 0; i < kMaxLasers; i++) {
 601          Laser *m = &st->laser[i];
 602          if (!m->alive)
 603                 continue;
 604
 605          if (m->oldx != -1) {
 606                  XSetLineAttributes(st->dpy, st->erase_gc, 2, 0,0,0);
 607                  XDrawLine(st->dpy, st->window, st->erase_gc,
 608                                   m->oldx2, m->oldy2, m->oldx, m->oldy);
 609          }
 610
 611          m->fposx += m->velx;
 612          m->fposy += m->vely;
 613          m->x = m->fposx;
 614          m->y = m->fposy;
 615
 616          x = m->fposx + (-m->velx * m->lenMul);
 617          y = m->fposy + (-m->vely * m->lenMul);
 618
 619          m->oldx = x;
 620          m->oldy = y;
 621
 622          XSetLineAttributes(st->dpy, st->draw_gc, 2, 0,0,0);
 623     XSetForeground (st->dpy, st->draw_gc, m->color.pixel);
 624          XDrawLine(st->dpy, st->window, st->draw_gc,
 625                                   m->x, m->y, x, y);
 626
 627          m->oldx2 = m->x;
 628          m->oldy2 = m->y;
 629          m->oldx = x;
 630          m->oldy = y;
 631
 632          if (m->y < m->endy) {
 633                 m->alive = 0;
 634          }
 635
 636          /* check hitting explosions */
 637          if (m->y < miny)
 638                 for (j=0;j<kMaxBooms;j++) {
 639                   Boom *b = &st->boom[j];
 640                   if (!b->alive)
 641                          continue;
 642                   else {
 643                          int dx = abs(m->x - b->x);
 644                          int dy = abs(m->y - b->y);
 645                          int r = b->rad + 2;
 646                          if (b->oflaser)
 647                                 continue;
 648                          if ((dx < r) && (dy < r))
 649                                 if (dx * dx + dy * dy < r * r) {
 650                                   m->alive = 0;
 651                                   /* one less enemy on this missile -- it probably didn't make it */
 652                                   if (st->missile[m->target].alive)
 653                                          st->missile[m->target].enemies--;
 654                                 }
 655                   }
 656                 }
 657
 658          if (m->alive == 0) {
 659                 /* we just died */
 660                 XDrawLine(st->dpy, st->window, st->erase_gc,
 661                                   m->x, m->y, x, y);
 662                 Explode(st, m->x, m->y, kBoomRad, m->color, 1);
 663          }
 664   }
 665 }
 666
 667 static void LoopBooms(struct state *st, int xlim, int ylim)
 668 {
 669   int i;
 670   for (i = 0; i < kMaxBooms; i++) {
 671          Boom *m = &st->boom[i];
 672          if (!m->alive)
 673                 continue;
 674
 675          if (st->loop & 1) {
 676                 if (m->outgoing) {
 677                   m->rad++;
 678                   if (m->rad >= m->max)
 679                          m->outgoing = 0;
 680                   XSetLineAttributes(st->dpy, st->draw_gc, 1, 0,0,0);
 681                   XSetForeground (st->dpy, st->draw_gc, m->color.pixel);
 682                   XDrawArc(st->dpy, st->window, st->draw_gc, m->x - m->rad, m->y - m->rad, m->rad * 2, m->rad * 2, 0, 360 * 64);
 683                 }
 684                 else {
 685                   XSetLineAttributes(st->dpy, st->erase_gc, 1, 0,0,0);
 686                   XDrawArc(st->dpy, st->window, st->erase_gc, m->x - m->rad, m->y - m->rad, m->rad * 2, m->rad * 2, 0, 360 * 64);
 687                   m->rad--;
 688                   if (m->rad <= 0)
 689                          m->alive = 0;
 690                 }
 691          }
 692   }
 693 }
 694
 695
 696 /* after they die, let's change a few things */
 697 static void Improve(struct state *st)
 698 {
 699   if (st->smart)
 700          return;
 701   if (st->level > 20)
 702          return;  /* no need, really */
 703   st->aim -= 4;
 704   if (st->level <= 2) st->aim -= 8;
 705   if (st->level <= 5) st->aim -= 6;
 706   if (st->gamez < 3)
 707          st->aim -= 10;
 708   st->carefulpersen += 6;
 709   st->choosypersen += 4;
 710   if (st->level <= 5) st->choosypersen += 3;
 711   st->econpersen += 4;
 712   st->lrate -= 2;
 713   if (st->startlrate < kMinRate) {
 714          if (st->lrate < st->startlrate)
 715                 st->lrate = st->startlrate;
 716   }
 717   else {
 718          if (st->lrate < kMinRate)
 719                 st->lrate = kMinRate;
 720   }
 721   if (st->level <= 5) st->econpersen += 3;
 722   if (st->aim < 1) st->aim = 1;
 723   if (st->choosypersen > 100) st->choosypersen = 100;
 724   if (st->carefulpersen > 100) st->carefulpersen = 100;
 725   if (st->econpersen > 100) st->econpersen = 100;
 726 }
 727
 728 static void NewLevel(struct state *st, int xlim, int ylim)
 729 {
 730   char buf[32];
 731   int width, i, sumlive = 0;
 732   int liv[kNumCities];
 733   int freecity = 0;
 734
 735   if (st->level == 0) {
 736          st->level++;
 737          goto END_LEVEL;
 738   }
 739
 740   /* check for a free city */
 741   if (st->score >= st->nextBonus) {
 742          st->numBonus++;
 743          st->nextBonus += kFirstBonus * st->numBonus;
 744          freecity = 1;
 745   }
 746
 747   for (i=0;i<kNumCities;i++) {
 748          if (st->bround)
 749                 st->city[i].alive = st->blive[i];
 750          liv[i] = st->city[i].alive;
 751          sumlive += liv[i];
 752          if (!st->bround)
 753                 st->city[i].alive = 0;
 754   }
 755
 756   /* print out screen */
 757   XFillRectangle(st->dpy, st->window, st->erase_gc,
 758                                   0, 0, xlim, ylim);
 759   if (st->bround)
 760          sprintf(buf, "Bonus Round Over");
 761   else {
 762          if (sumlive || freecity)
 763                 sprintf(buf, "Level %d Cleared", st->level);
 764          else
 765                 sprintf(buf, "GAME OVER");
 766   }
 767   if (st->level > 0) {
 768          width = XTextWidth(st->font, buf, strlen(buf));
 769          XDrawString(st->dpy, st->window, st->level_gc, xlim / 2 - width / 2, ylim / 2 - font_height(st->font) / 2,
 770                                          buf, strlen(buf));
 771          XSync(st->dpy, False);
 772          usleep(1000000);
 773   }
 774
 775   if (!st->bround) {
 776          if (sumlive || freecity) {
 777                 int sumwidth;
 778                 /* draw live cities */
 779                 XFillRectangle(st->dpy, st->window, st->erase_gc,
 780                                                         0, ylim - 100, xlim, 100);
 781
 782                 sprintf(buf, "X %ld", st->level * 100L);
 783                 /* how much they get */
 784                 sumwidth = XTextWidth(st->font, buf, strlen(buf));
 785                 /* add width of city */
 786                 sumwidth += 60;
 787                 /* add spacer */
 788                 sumwidth += 40;
 789                 DrawCity(st, xlim / 2 - sumwidth / 2 + 30, ylim * 0.70, st->city[0].color);
 790                 XDrawString(st->dpy, st->window, st->level_gc, xlim / 2 - sumwidth / 2 + 40 + 60, ylim * 0.7, buf, strlen(buf));
 791                 for (i=0;i<kNumCities;i++) {
 792                   if (liv[i]) {
 793                          st->city[i].alive = 1;
 794                          AddScore(st, xlim, ylim, 100 * st->level);
 795                          DrawCities(st, xlim, ylim);
 796                          XSync(st->dpy, False);
 797                          usleep(kCityPause);
 798                   }
 799                 }
 800          }
 801          else {
 802                 /* we're dead */
 803                 usleep(3000000);
 804
 805                 /* start new */
 806                 st->gamez++;
 807                 Improve(st);
 808                 for (i=0;i<kNumCities;i++)
 809                   st->city[i].alive = 1;
 810                 st->level = 0;
 811                 st->loop = 1;
 812                 st->score = 0;
 813                 st->nextBonus = kFirstBonus;
 814                 st->numBonus = 0;
 815                 DrawCities(st, xlim, ylim);
 816          }
 817   }
 818
 819   /* do free city part */
 820   if (freecity && sumlive < 5) {
 821          int ncnt = random() % (5 - sumlive) + 1;
 822          for (i=0;i<kNumCities;i++)
 823                 if (!st->city[i].alive)
 824                   if (!--ncnt)
 825                          st->city[i].alive = 1;
 826          strcpy(buf, "Bonus City");
 827          width = XTextWidth(st->font, buf, strlen(buf));
 828          XDrawString(st->dpy, st->window, st->level_gc, xlim / 2 - width / 2, ylim / 4, buf, strlen(buf));
 829          DrawCities(st, xlim, ylim);
 830          XSync(st->dpy, False);
 831          usleep(1000000);
 832   }
 833
 834   XFillRectangle(st->dpy, st->window, st->erase_gc,
 835                                           0, 0, xlim, ylim - 100);
 836
 837   if (!st->bround)
 838          st->level++;
 839   if (st->level == 1) {
 840          st->nextBonus = kFirstBonus;
 841   }
 842
 843   if (st->level > 3 && (st->level % 5 == 1)) {
 844          if (st->bround) {
 845                 st->bround = 0;
 846                 DrawCities(st, xlim, ylim);
 847          }
 848          else {
 849                 /* bonus round */
 850                 st->bround = 1;
 851                 st->levMissiles = 20 + st->level * 10;
 852                 st->levFreq = 10;
 853                 for (i=0;i<kNumCities;i++)
 854                   st->blive[i] = st->city[i].alive;
 855                 sprintf(buf, "Bonus Round");
 856                 width = XTextWidth(st->font, buf, strlen(buf));
 857                 XDrawString(st->dpy, st->window, st->level_gc, xlim / 2 - width / 2, ylim / 2 - font_height(st->font) / 2, buf, strlen(buf));
 858                 XSync(st->dpy, False);
 859                 usleep(1000000);
 860                 XFillRectangle(st->dpy, st->window, st->erase_gc,
 861                                                         0, 0, xlim, ylim - 100);
 862          }
 863   }
 864
 865  END_LEVEL: ;
 866
 867   if (!st->bround) {
 868          st->levMissiles = 5 + st->level * 3;
 869          if (st->level > 5)
 870                 st->levMissiles += st->level * 5;
 871          /*  levMissiles = 2; */
 872          st->levFreq = 120 - st->level * 5;
 873          if (st->levFreq < 30)
 874                 st->levFreq = 30;
 875   }
 876
 877   /* ready to fire */
 878   st->lastLaser = 0;
 879 }
 880
 881
 882 static unsigned long
 883 penetrate_draw (Display *dpy, Window window, void *closure)
 884 {
 885   struct state *st = (struct state *) closure;
 886   XWindowAttributes xgwa;
 887
 888   if (st->draw_reset)
 889     {
 890       st->draw_reset = 0;
 891       DrawCities(st, st->draw_xlim, st->draw_ylim);
 892     }
 893
 894   XGetWindowAttributes(st->dpy, st->window, &xgwa);
 895   st->draw_xlim = xgwa.width;
 896   st->draw_ylim = xgwa.height;
 897
 898   /* see if just started */
 899   if (st->loop == 0) {
 900          if (st->smart) {
 901                 st->choosypersen = st->econpersen = st->carefulpersen = 100;
 902                 st->lrate = kMinRate; st->aim = 1;
 903          }
 904          NewLevel(st, st->draw_xlim, st->draw_ylim);
 905          DrawScore(st, st->draw_xlim, st->draw_ylim);
 906   }
 907
 908   st->loop++;
 909
 910   if (st->levMissiles == 0) {
 911          /* see if anything's still on the screen, to know when to end level */
 912          int i;
 913          for (i=0;i<kMaxMissiles;i++)
 914                 if (st->missile[i].alive)
 915                   goto END_CHECK;
 916          for (i=0;i<kMaxBooms;i++)
 917                 if (st->boom[i].alive)
 918                   goto END_CHECK;
 919          for (i=0;i<kMaxLasers;i++)
 920                 if (st->laser[i].alive)
 921                   goto END_CHECK;
 922          /* okay, nothing's alive, start end of level countdown */
 923          usleep(kLevelPause*1000000);
 924          NewLevel(st, st->draw_xlim, st->draw_ylim);
 925          goto END;
 926   END_CHECK: ;
 927   }
 928   else if ((random() % st->levFreq) == 0) {
 929          launch(st, st->draw_xlim, st->draw_ylim, -1);
 930          st->levMissiles--;
 931   }
 932
 933   if (st->loop - st->lastLaser >= st->lrate) {
 934          if (fire(st, st->draw_xlim, st->draw_ylim))
 935                 st->lastLaser = st->loop;
 936   }
 937
 938   if ((st->loop & 7) == 0)
 939     st->draw_reset = 1;
 940
 941   LoopMissiles(st, st->draw_xlim, st->draw_ylim);
 942   LoopLasers(st, st->draw_xlim, st->draw_ylim);
 943   LoopBooms(st, st->draw_xlim, st->draw_ylim);
 944
 945  END:
 946   return kSleepTime;
 947 }
 948
 949 static void
 950 penetrate_reshape (Display *dpy, Window window, void *closure,
 951                  unsigned int w, unsigned int h)
 952 {
 953   XClearWindow (dpy, window);
 954 }
 955
 956 static Bool
 957 penetrate_event (Display *dpy, Window window, void *closure, XEvent *event)
 958 {
 959   return False;
 960 }
 961
 962 static void
 963 penetrate_free (Display *dpy, Window window, void *closure)
 964 {
 965   struct state *st = (struct state *) closure;
 966   free (st);
 967 }
 968
 969
 970 static const char *penetrate_defaults [] = {
 971   ".lowrez:     true",
 972   ".background: black",
 973   ".foreground: white",
 974   "*fpsTop:     true",
 975   "*fpsSolid:   true",
 976   "*bgrowth:    5",
 977   "*lrate:      80",
 978   "*smart:      False",
 979   0
 980 };
 981
 982 static XrmOptionDescRec penetrate_options [] = {
 983   { "-bgrowth",         ".bgrowth",     XrmoptionSepArg, 0 },
 984   { "-lrate",           ".lrate",       XrmoptionSepArg, 0 },
 985   {"-smart",            ".smart",       XrmoptionNoArg, "True" },
 986   { 0, 0, 0, 0 }
 987 };
 988
 989 XSCREENSAVER_MODULE ("Penetrate", penetrate)