1: /*      $NetBSD: warp.c,v 1.8 2003/08/07 09:37:55 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[] = "@(#)warp.c      8.1 (Berkeley) 5/31/93";
   36: #else
   37: __RCSID("$NetBSD: warp.c,v 1.8 2003/08/07 09:37:55 agc Exp $");
   38: #endif
   39: #endif /* not lint */
   40: 
   41: #include <stdio.h>
   42: #include <math.h>
   43: #include <string.h>
   44: #include <unistd.h>
   45: #include "trek.h"
   46: #include "getpar.h"
   47: 
   48: /*
   49: **  MOVE UNDER WARP POWER
   50: **
   51: **      This is both the "move" and the "ram" commands, differing
   52: **      only in the flag 'fl'.  It is also used for automatic
   53: **      emergency override mode, when 'fl' is < 0 and 'c' and 'd'
   54: **      are the course and distance to be moved.  If 'fl' >= 0,
   55: **      the course and distance are asked of the captain.
   56: **
   57: **      The guts of this routine are in the routine move(), which
   58: **      is shared with impulse().  Also, the working part of this
   59: **      routine is very small; the rest is to handle the slight chance
   60: **      that you may be moving at some riduculous speed.  In that
   61: **      case, there is code to handle time warps, etc.
   62: */
   63: 
   64: void
   65: dowarp(fl)
   66:         int fl;
   67: {
   68:         int c;
   69:         double d;
   70: 
   71:         if (getcodi(&c, &d))
   72:                 return;
   73:         warp(fl, c, d);
   74: }
   75: 
   76: void
   77: warp(fl, c, d)
   78: int     fl, c;
   79: double  d;
   80: {
   81:         char          *p;
   82:         int            course;
   83:         double         power;
   84:         double         dist;
   85:         double         time;
   86:         double         speed;
   87:         double         frac;
   88:         int            percent;
   89:         int            i;
   90: 
   91:         if (Ship.cond == DOCKED) {
   92:                 printf("%s is docked\n", Ship.shipname);
   93:                 return;
   94:         }
   95:         if (damaged(WARP))
   96:         {
   97:                 out(WARP);
   98:                 return;
   99:         }
  100: 
  101:         course = c;
  102:         dist = d;
  103: 
  104:         /* check to see that we are not using an absurd amount of power */
  105:         power = (dist + 0.05) * Ship.warp3;
  106:         percent = 100 * power / Ship.energy + 0.5;
  107:         if (percent >= 85)
  108:         {
  109:                 printf("Scotty: That would consume %d%% of our remaining energy.\n",
  110:                         percent);
  111:                 if (!getynpar("Are you sure that is wise"))
  112:                         return;
  113:         }
  114: 
  115:         /* compute the speed we will move at, and the time it will take */
  116:         speed = Ship.warp2 / Param.warptime;
  117:         time = dist / speed;
  118: 
  119:         /* check to see that that value is not ridiculous */
  120:         percent = 100 * time / Now.time + 0.5;
  121:         if (percent >= 85)
  122:         {
  123:                 printf("Spock: That would take %d%% of our remaining time.\n",
  124:                         percent);
  125:                 if (!getynpar("Are you sure that is wise"))
  126:                         return;
  127:         }
  128: 
  129:         /* compute how far we will go if we get damages */
  130:         if (Ship.warp > 6.0 && ranf(100) < 20 + 15 * (Ship.warp - 6.0))
  131:         {
  132:                 frac = franf();
  133:                 dist *= frac;
  134:                 time *= frac;
  135:                 damage(WARP, (frac + 1.0) * Ship.warp * (franf() + 0.25) * 0.20);
  136:         }
  137: 
  138:         /* do the move */
  139:         Move.time = move(fl, course, time, speed);
  140: 
  141:         /* see how far we actually went, and decrement energy appropriately */
  142:         dist = Move.time * speed;
  143:         Ship.energy -= dist * Ship.warp3 * (Ship.shldup + 1);
  144: 
  145:         /* test for bizarre events */
  146:         if (Ship.warp <= 9.0)
  147:                 return;
  148:         printf("\n\n  ___ Speed exceeding warp nine ___\n\n");
  149:         sleep(2);
  150:         printf("Ship's safety systems malfunction\n");
  151:         sleep(2);
  152:         printf("Crew experiencing extreme sensory distortion\n");
  153:         sleep(4);
  154:         if (ranf(100) >= 100 * dist)
  155:         {
  156:                 printf("Equilibrium restored -- all systems normal\n");
  157:                 return;
  158:         }
  159: 
  160:         /* select a bizzare thing to happen to us */
  161:         percent = ranf(100);
  162:         if (percent < 70)
  163:         {
  164:                 /* time warp */
  165:                 if (percent < 35 || !Game.snap)
  166:                 {
  167:                         /* positive time warp */
  168:                         time = (Ship.warp - 8.0) * dist * (franf() + 1.0);
  169:                         Now.date += time;
  170:                         printf("Positive time portal entered -- it is now Stardate %.2f\n",
  171:                                 Now.date);
  172:                         for (i = 0; i < MAXEVENTS; i++)
  173:                         {
  174:                                 percent = Event[i].evcode;
  175:                                 if (percent == E_FIXDV || percent == E_LRTB)
  176:                                         Event[i].date += time;
  177:                         }
  178:                         return;
  179:                 }
  180: 
  181:                 /* s/he got lucky: a negative time portal */
  182:                 time = Now.date;
  183:                 p = (char *) Etc.snapshot;
  184:                 memcpy(p, Quad, sizeof Quad);
  185:                 p += sizeof Quad;
  186:                 memcpy(p, Event, sizeof Event);
  187:                 p += sizeof Event;
  188:                 memcpy(p, &Now, sizeof Now);
  189:                 printf("Negative time portal entered -- it is now Stardate %.2f\n",
  190:                         Now.date);
  191:                 for (i = 0; i < MAXEVENTS; i++)
  192:                         if (Event[i].evcode == E_FIXDV)
  193:                                 reschedule(&Event[i], Event[i].date - time);
  194:                 return;
  195:         }
  196: 
  197:         /* test for just a lot of damage */
  198:         if (percent < 80)
  199:                 lose(L_TOOFAST);
  200:         printf("Equilibrium restored -- extreme damage occurred to ship systems\n");
  201:         for (i = 0; i < NDEV; i++)
  202:                 damage(i, (3.0 * (franf() + franf()) + 1.0) * Param.damfac[i]);
  203:         Ship.shldup = 0;
  204: }