1: /*      $NetBSD: events.c,v 1.7 2003/08/07 09:37:51 agc Exp $        */
    2: 
    3: /*
    4:  * Copyright (c) 1980, 1993
    5:  *      The Regents of the University of California.  All rights reserved.
    6:  *
    7:  * Redistribution and use in source and binary forms, with or without
    8:  * modification, are permitted provided that the following conditions
    9:  * are met:
   10:  * 1. Redistributions of source code must retain the above copyright
   11:  *    notice, this list of conditions and the following disclaimer.
   12:  * 2. Redistributions in binary form must reproduce the above copyright
   13:  *    notice, this list of conditions and the following disclaimer in the
   14:  *    documentation and/or other materials provided with the distribution.
   15:  * 3. Neither the name of the University nor the names of its contributors
   16:  *    may be used to endorse or promote products derived from this software
   17:  *    without specific prior written permission.
   18:  *
   19:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   20:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   23:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29:  * SUCH DAMAGE.
   30:  */
   31: 
   32: #include <sys/cdefs.h>
   33: #ifndef lint
   34: #if 0
   35: static char sccsid[] = "@(#)events.c    8.1 (Berkeley) 5/31/93";
   36: #else
   37: __RCSID("$NetBSD: events.c,v 1.7 2003/08/07 09:37:51 agc Exp $");
   38: #endif
   39: #endif /* not lint */
   40: 
   41: #include <stdio.h>
   42: #include <string.h>
   43: #include <math.h>
   44: #include "getpar.h"
   45: #include "trek.h"
   46: 
   47: /*
   48: **  CAUSE TIME TO ELAPSE
   49: **
   50: **      This routine does a hell of a lot.  It elapses time, eats up
   51: **      energy, regenerates energy, processes any events that occur,
   52: **      and so on.
   53: */
   54: 
   55: 
   56: int
   57: events(warp)
   58: int     warp;               /* set if called in a time warp */
   59: {
   60:         int            i;
   61:         char                   *p;
   62:         int                    j = 0;
   63:         struct kling           *k;
   64:         double                 rtime;
   65:         double                 xdate;
   66:         double                 idate;
   67:         struct event           *ev = NULL;
   68:         int                    ix, iy;
   69:         struct quad    *q;
   70:         struct event   *e;
   71:         int                    evnum;
   72:         int                    restcancel;
   73: 
   74:         /* if nothing happened, just allow for any Klingons killed */
   75:         if (Move.time <= 0.0)
   76:         {
   77:                 Now.time = Now.resource / Now.klings;
   78:                 return (0);
   79:         }
   80: 
   81:         /* indicate that the cloaking device is now working */
   82:         Ship.cloakgood = 1;
   83: 
   84:         /* idate is the initial date */
   85:         idate = Now.date;
   86: 
   87:         /* schedule attacks if resting too long */
   88:         if (Move.time > 0.5 && Move.resting)
   89:                 schedule(E_ATTACK, 0.5, 0, 0, 0);
   90: 
   91:         /* scan the event list */
   92:         while (1)
   93:         {
   94:                 restcancel = 0;
   95:                 evnum = -1;
   96:                 /* xdate is the date of the current event */
   97:                 xdate = idate + Move.time;
   98: 
   99:                 /* find the first event that has happened */
  100:                 for (i = 0; i < MAXEVENTS; i++)
  101:                 {
  102:                         e = &Event[i];
  103:                         if (e->evcode == 0 || (e->evcode & E_GHOST))
  104:                                 continue;
  105:                         if (e->date < xdate)
  106:                         {
  107:                                 xdate = e->date;
  108:                                 ev = e;
  109:                                 evnum = i;
  110:                         }
  111:                 }
  112:                 e = ev;
  113: 
  114:                 /* find the time between events */
  115:                 rtime = xdate - Now.date;
  116: 
  117:                 /* decrement the magic "Federation Resources" pseudo-variable */
  118:                 Now.resource -= Now.klings * rtime;
  119:                 /* and recompute the time left */
  120:                 Now.time = Now.resource / Now.klings;
  121: 
  122:                 /* move us up to the next date */
  123:                 Now.date = xdate;
  124: 
  125:                 /* check for out of time */
  126:                 if (Now.time <= 0.0)
  127:                         lose(L_NOTIME);
  128: #               ifdef xTRACE
  129:                 if (evnum >= 0 && Trace)
  130:                         printf("xdate = %.2f, evcode %d params %d %d %d\n",
  131:                                 xdate, e->evcode, e->x, e->y, e->systemname);
  132: #               endif
  133: 
  134:                 /* if evnum < 0, no events occurred  */
  135:                 if (evnum < 0)
  136:                         break;
  137: 
  138:                 /* otherwise one did.  Find out what it is */
  139:                 switch (e->evcode & E_EVENT)
  140:                 {
  141: 
  142:                   case E_SNOVA:                       /* supernova */
  143:                         /* cause the supernova to happen */
  144:                         snova(-1, 0);
  145:                         /* and schedule the next one */
  146:                         xresched(e, E_SNOVA, 1);
  147:                         break;
  148: 
  149:                   case E_LRTB:                        /* long range tractor beam */
  150:                         /* schedule the next one */
  151:                         xresched(e, E_LRTB, Now.klings);
  152:                         /* LRTB cannot occur if we are docked */
  153:                         if (Ship.cond != DOCKED)
  154:                         {
  155:                                 /* pick a new quadrant */
  156:                                 i = ranf(Now.klings) + 1;
  157:                                 for (ix = 0; ix < NQUADS; ix++)
  158:                                 {
  159:                                         for (iy = 0; iy < NQUADS; iy++)
  160:                                         {
  161:                                                 q = &Quad[ix][iy];
  162:                                                 if (q->stars >= 0)
  163:                                                         if ((i -= q->klings) <= 0)
  164:                                                                 break;
  165:                                         }
  166:                                         if (i <= 0)
  167:                                                 break;
  168:                                 }
  169: 
  170:                                 /* test for LRTB to same quadrant */
  171:                                 if (Ship.quadx == ix && Ship.quady == iy)
  172:                                         break;
  173: 
  174:                                 /* nope, dump him in the new quadrant */
  175:                                 Ship.quadx = ix;
  176:                                 Ship.quady = iy;
  177:                                 printf("\n%s caught in long range tractor beam\n", Ship.shipname);
  178:                                 printf("*** Pulled to quadrant %d,%d\n", Ship.quadx, Ship.quady);
  179:                                 Ship.sectx = ranf(NSECTS);
  180:                                 Ship.secty = ranf(NSECTS);
  181:                                 initquad(0);
  182:                                 /* truncate the move time */
  183:                                 Move.time = xdate - idate;
  184:                         }
  185:                         break;
  186: 
  187:                   case E_KATSB:                       /* Klingon attacks starbase */
  188:                         /* if out of bases, forget it */
  189:                         if (Now.bases <= 0)
  190:                         {
  191:                                 unschedule(e);
  192:                                 break;
  193:                         }
  194: 
  195:                         /* check for starbase and Klingons in same quadrant */
  196:                         for (i = 0; i < Now.bases; i++)
  197:                         {
  198:                                 ix = Now.base[i].x;
  199:                                 iy = Now.base[i].y;
  200:                                 /* see if a Klingon exists in this quadrant */
  201:                                 q = &Quad[ix][iy];
  202:                                 if (q->klings <= 0)
  203:                                         continue;
  204: 
  205:                                 /* see if already distressed */
  206:                                 for (j = 0; j < MAXEVENTS; j++)
  207:                                 {
  208:                                         e = &Event[j];
  209:                                         if ((e->evcode & E_EVENT) != E_KDESB)
  210:                                                 continue;
  211:                                         if (e->x == ix && e->y == iy)
  212:                                                 break;
  213:                                 }
  214:                                 if (j < MAXEVENTS)
  215:                                         continue;
  216: 
  217:                                 /* got a potential attack */
  218:                                 break;
  219:                         }
  220:                         e = ev;
  221:                         if (i >= Now.bases)
  222:                         {
  223:                                 /* not now; wait a while and see if some Klingons move in */
  224:                                 reschedule(e, 0.5 + 3.0 * franf());
  225:                                 break;
  226:                         }
  227:                         /* schedule a new attack, and a destruction of the base */
  228:                         xresched(e, E_KATSB, 1);
  229:                         e = xsched(E_KDESB, 1, ix, iy, 0);
  230: 
  231:                         /* report it if we can */
  232:                         if (!damaged(SSRADIO))
  233:                         {
  234:                                 printf("\nUhura:  Captain, we have received a distress signal\n");
  235:                                 printf("  from the starbase in quadrant %d,%d.\n",
  236:                                         ix, iy);
  237:                                 restcancel++;
  238:                         }
  239:                         else
  240:                                 /* SSRADIO out, make it so we can't see the distress call */
  241:                                 /* but it's still there!!! */
  242:                                 e->evcode |= E_HIDDEN;
  243:                         break;
  244: 
  245:                   case E_KDESB:                       /* Klingon destroys starbase */
  246:                         unschedule(e);
  247:                         q = &Quad[e->x][e->y];
  248:                         /* if the base has mysteriously gone away, or if the Klingon
  249:                            got tired and went home, ignore this event */
  250:                         if (q->bases <=0 || q->klings <= 0)
  251:                                 break;
  252:                         /* are we in the same quadrant? */
  253:                         if (e->x == Ship.quadx && e->y == Ship.quady)
  254:                         {
  255:                                 /* yep, kill one in this quadrant */
  256:                                 printf("\nSpock: ");
  257:                                 killb(Ship.quadx, Ship.quady);
  258:                         }
  259:                         else
  260:                                 /* kill one in some other quadrant */
  261:                                 killb(e->x, e->y);
  262:                         break;
  263: 
  264:                   case E_ISSUE:               /* issue a distress call */
  265:                         xresched(e, E_ISSUE, 1);
  266:                         /* if we already have too many, throw this one away */
  267:                         if (Ship.distressed >= MAXDISTR)
  268:                                 break;
  269:                         /* try a whole bunch of times to find something suitable */
  270:                         for (i = 0; i < 100; i++)
  271:                         {
  272:                                 ix = ranf(NQUADS);
  273:                                 iy = ranf(NQUADS);
  274:                                 q = &Quad[ix][iy];
  275:                                 /* need a quadrant which is not the current one,
  276:                                    which has some stars which are inhabited and
  277:                                    not already under attack, which is not
  278:                                    supernova'ed, and which has some Klingons in it */
  279:                                 if (!((ix == Ship.quadx && iy == Ship.quady) || q->stars < 0 ||
  280:                                     (q->qsystemname & Q_DISTRESSED) ||
  281:                                     (q->qsystemname & Q_SYSTEM) == 0 || q->klings <= 0))
  282:                                         break;
  283:                         }
  284:                         if (i >= 100)
  285:                                 /* can't seem to find one; ignore this call */
  286:                                 break;
  287: 
  288:                         /* got one!!  Schedule its enslavement */
  289:                         Ship.distressed++;
  290:                         e = xsched(E_ENSLV, 1, ix, iy, q->qsystemname);
  291:                         q->qsystemname = (e - Event) | Q_DISTRESSED;
  292: 
  293:                         /* tell the captain about it if we can */
  294:                         if (!damaged(SSRADIO))
  295:                         {
  296:                                 printf("\nUhura: Captain, starsystem %s in quadrant %d,%d is under attack\n",
  297:                                         Systemname[e->systemname], ix, iy);
  298:                                 restcancel++;
  299:                         }
  300:                         else
  301:                                 /* if we can't tell him, make it invisible */
  302:                                 e->evcode |= E_HIDDEN;
  303:                         break;
  304: 
  305:                   case E_ENSLV:               /* starsystem is enslaved */
  306:                         unschedule(e);
  307:                         /* see if current distress call still active */
  308:                         q = &Quad[e->x][e->y];
  309:                         if (q->klings <= 0)
  310:                         {
  311:                                 /* no Klingons, clean up */
  312:                                 /* restore the system name */
  313:                                 q->qsystemname = e->systemname;
  314:                                 break;
  315:                         }
  316: 
  317:                         /* play stork and schedule the first baby */
  318:                         e = schedule(E_REPRO, Param.eventdly[E_REPRO] * franf(), e->x, e->y, e->systemname);
  319: 
  320:                         /* report the disaster if we can */
  321:                         if (!damaged(SSRADIO))
  322:                         {
  323:                                 printf("\nUhura:  We've lost contact with starsystem %s\n",
  324:                                         Systemname[e->systemname]);
  325:                                 printf("  in quadrant %d,%d.\n",
  326:                                         e->x, e->y);
  327:                         }
  328:                         else
  329:                                 e->evcode |= E_HIDDEN;
  330:                         break;
  331: 
  332:                   case E_REPRO:               /* Klingon reproduces */
  333:                         /* see if distress call is still active */
  334:                         q = &Quad[e->x][e->y];
  335:                         if (q->klings <= 0)
  336:                         {
  337:                                 unschedule(e);
  338:                                 q->qsystemname = e->systemname;
  339:                                 break;
  340:                         }
  341:                         xresched(e, E_REPRO, 1);
  342:                         /* reproduce one Klingon */
  343:                         ix = e->x;
  344:                         iy = e->y;
  345:                         if (Now.klings == 127)
  346:                                 break;              /* full right now */
  347:                         if (q->klings >= MAXKLQUAD)
  348:                         {
  349:                                 /* this quadrant not ok, pick an adjacent one */
  350:                                 for (i = ix - 1; i <= ix + 1; i++)
  351:                                 {
  352:                                         if (i < 0 || i >= NQUADS)
  353:                                                 continue;
  354:                                         for (j = iy - 1; j <= iy + 1; j++)
  355:                                         {
  356:                                                 if (j < 0 || j >= NQUADS)
  357:                                                         continue;
  358:                                                 q = &Quad[i][j];
  359:                                                 /* check for this quad ok (not full & no snova) */
  360:                                                 if (q->klings >= MAXKLQUAD || q->stars < 0)
  361:                                                         continue;
  362:                                                 break;
  363:                                         }
  364:                                         if (j <= iy + 1)
  365:                                                 break;
  366:                                 }
  367:                                 if (j > iy + 1)
  368:                                         /* cannot create another yet */
  369:                                         break;
  370:                                 ix = i;
  371:                                 iy = j;
  372:                         }
  373:                         /* deliver the child */
  374:                         q->klings++;
  375:                         Now.klings++;
  376:                         if (ix == Ship.quadx && iy == Ship.quady)
  377:                         {
  378:                                 /* we must position Klingon */
  379:                                 sector(&ix, &iy);
  380:                                 Sect[ix][iy] = KLINGON;
  381:                                 k = &Etc.klingon[Etc.nkling++];
  382:                                 k->x = ix;
  383:                                 k->y = iy;
  384:                                 k->power = Param.klingpwr;
  385:                                 k->srndreq = 0;
  386:                                 compkldist(Etc.klingon[0].dist == Etc.klingon[0].avgdist ? 0 : 1);
  387:                         }
  388: 
  389:                         /* recompute time left */
  390:                         Now.time = Now.resource / Now.klings;
  391:                         break;
  392: 
  393:                   case E_SNAP:                /* take a snapshot of the galaxy */
  394:                         xresched(e, E_SNAP, 1);
  395:                         p = (char *) Etc.snapshot;
  396:                         memcpy(p, Quad, sizeof (Quad));
  397:                         p += sizeof(Quad);
  398:                         memcpy(p, Event, sizeof (Event));
  399:                         p += sizeof(Event);
  400:                         memcpy(p, &Now, sizeof (Now));
  401:                         Game.snap = 1;
  402:                         break;
  403: 
  404:                   case E_ATTACK:      /* Klingons attack during rest period */
  405:                         if (!Move.resting)
  406:                         {
  407:                                 unschedule(e);
  408:                                 break;
  409:                         }
  410:                         attack(1);
  411:                         reschedule(e, 0.5);
  412:                         break;
  413: 
  414:                   case E_FIXDV:
  415:                         i = e->systemname;
  416:                         unschedule(e);
  417: 
  418:                         /* de-damage the device */
  419:                         printf("%s reports repair work on the %s finished.\n",
  420:                                 Device[i].person, Device[i].name);
  421: 
  422:                         /* handle special processing upon fix */
  423:                         switch (i)
  424:                         {
  425: 
  426:                           case LIFESUP:
  427:                                 Ship.reserves = Param.reserves;
  428:                                 break;
  429: 
  430:                           case SINS:
  431:                                 if (Ship.cond == DOCKED)
  432:                                         break;
  433:                                 printf("Spock has tried to recalibrate your Space Internal Navigation System,\n");
  434:                                 printf("  but he has no standard base to calibrate to.  Suggest you get\n");
  435:                                 printf("  to a starbase immediately so that you can properly recalibrate.\n");
  436:                                 Ship.sinsbad = 1;
  437:                                 break;
  438: 
  439:                           case SSRADIO:
  440:                                 restcancel = dumpssradio();
  441:                                 break;
  442:                         }
  443:                         break;
  444: 
  445:                   default:
  446:                         break;
  447:                 }
  448: 
  449:                 if (restcancel && Move.resting && getynpar("Spock: Shall we cancel our rest period"))
  450:                         Move.time = xdate - idate;
  451: 
  452:         }
  453: 
  454:         /* unschedule an attack during a rest period */
  455:         if ((e = Now.eventptr[E_ATTACK]) != NULL)
  456:                 unschedule(e);
  457: 
  458:         if (!warp)
  459:         {
  460:                 /* eat up energy if cloaked */
  461:                 if (Ship.cloaked)
  462:                         Ship.energy -= Param.cloakenergy * Move.time;
  463: 
  464:                 /* regenerate resources */
  465:                 rtime = 1.0 - exp(-Param.regenfac * Move.time);
  466:                 Ship.shield += (Param.shield - Ship.shield) * rtime;
  467:                 Ship.energy += (Param.energy - Ship.energy) * rtime;
  468: 
  469:                 /* decrement life support reserves */
  470:                 if (damaged(LIFESUP) && Ship.cond != DOCKED)
  471:                         Ship.reserves -= Move.time;
  472:         }
  473:         return (0);
  474: }