1: /*      $NetBSD: torped.c,v 1.8 2004/01/27 20:30:31 jsm 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[] = "@(#)torped.c    8.1 (Berkeley) 5/31/93";
   36: #else
   37: __RCSID("$NetBSD: torped.c,v 1.8 2004/01/27 20:30:31 jsm Exp $");
   38: #endif
   39: #endif /* not lint */
   40: 
   41: #include <stdio.h>
   42: #include <stdlib.h>
   43: #include <math.h>
   44: #include "trek.h"
   45: #include "getpar.h"
   46: 
   47: /*
   48: **  PHOTON TORPEDO CONTROL
   49: **
   50: **      Either one or three photon torpedoes are fired.  If three
   51: **      are fired, it is called a "burst" and you also specify
   52: **      a spread angle.
   53: **
   54: **      Torpedoes are never 100% accurate.  There is always a random
   55: **      cludge factor in their course which is increased if you have
   56: **      your shields up.  Hence, you will find that they are more
   57: **      accurate at close range.  However, they have the advantage that
   58: **      at long range they don't lose any of their power as phasers
   59: **      do, i.e., a hit is a hit is a hit, by any other name.
   60: **
   61: **      When the course spreads too much, you get a misfire, and the
   62: **      course is randomized even more.  You also have the chance that
   63: **      the misfire damages your torpedo tubes.
   64: */
   65: 
   66: static int randcourse(int);
   67: 
   68: /*ARGSUSED*/
   69: void
   70: torped(v)
   71:         int v __attribute__((__unused__));
   72: {
   73:         int            ix, iy;
   74:         double         x, y, dx, dy;
   75:         double         angle;
   76:         int            course, course2;
   77:         int            k;
   78:         double         bigger;
   79:         double         sectsize;
   80:         int            burst;
   81:         int            n;
   82: 
   83:         if (Ship.cloaked)
   84:         {
   85:                 printf("Federation regulations do not permit attack while cloaked.\n");
   86:                 return;
   87:         }
   88:         if (check_out(TORPED))
   89:                 return;
   90:         if (Ship.torped <= 0)
   91:         {
   92:                 printf("All photon torpedos expended\n");
   93:                 return;
   94:         }
   95: 
   96:         /* get the course */
   97:         course = getintpar("Torpedo course");
   98:         if (course < 0 || course > 360)
   99:                 return;
  100:         burst = -1;
  101: 
  102:         /* need at least three torpedoes for a burst */
  103:         if (Ship.torped < 3)
  104:         {
  105:                 printf("No-burst mode selected\n");
  106:                 burst = 0;
  107:         }
  108:         else
  109:         {
  110:                 /* see if the user wants one */
  111:                 if (!testnl())
  112:                 {
  113:                         k = ungetc(cgetc(0), stdin);
  114:                         if (k >= '0' && k <= '9')
  115:                                 burst = 1;
  116:                 }
  117:         }
  118:         if (burst < 0)
  119:         {
  120:                 burst = getynpar("Do you want a burst");
  121:         }
  122:         if (burst)
  123:         {
  124:                 burst = getintpar("burst angle");
  125:                 if (burst <= 0)
  126:                         return;
  127:                 if (burst > 15) {
  128:                         printf("Maximum burst angle is 15 degrees\n");
  129:                         return;
  130:                 }
  131:         }
  132:         sectsize = NSECTS;
  133:         n = -1;
  134:         if (burst)
  135:         {
  136:                 n = 1;
  137:                 course -= burst;
  138:         }
  139:         for (; n && n <= 3; n++)
  140:         {
  141:                 /* select a nice random course */
  142:                 course2 = course + randcourse(n);
  143:                 angle = course2 * 0.0174532925;                       /* convert to radians */
  144:                 dx = -cos(angle);
  145:                 dy =  sin(angle);
  146:                 bigger = fabs(dx);
  147:                 x = fabs(dy);
  148:                 if (x > bigger)
  149:                         bigger = x;
  150:                 dx /= bigger;
  151:                 dy /= bigger;
  152:                 x = Ship.sectx + 0.5;
  153:                 y = Ship.secty + 0.5;
  154:                 if (Ship.cond != DOCKED)
  155:                         Ship.torped -= 1;
  156:                 printf("Torpedo track");
  157:                 if (n > 0)
  158:                         printf(", torpedo number %d", n);
  159:                 printf(":\n%6.1f\t%4.1f\n", x, y);
  160:                 while (1)
  161:                 {
  162:                         ix = x += dx;
  163:                         iy = y += dy;
  164:                         if (x < 0.0 || x >= sectsize || y < 0.0 || y >= sectsize)
  165:                         {
  166:                                 printf("Torpedo missed\n");
  167:                                 break;
  168:                         }
  169:                         printf("%6.1f\t%4.1f\n", x, y);
  170:                         switch (Sect[ix][iy])
  171:                         {
  172:                           case EMPTY:
  173:                                 continue;
  174:         
  175:                           case HOLE:
  176:                                 printf("Torpedo disappears into a black hole\n");
  177:                                 break;
  178: 
  179:                           case KLINGON:
  180:                                 for (k = 0; k < Etc.nkling; k++)
  181:                                 {
  182:                                         if (Etc.klingon[k].x != ix || Etc.klingon[k].y != iy)
  183:                                                 continue;
  184:                                         Etc.klingon[k].power -= 500 + ranf(501);
  185:                                         if (Etc.klingon[k].power > 0)
  186:                                         {
  187:                                                 printf("*** Hit on Klingon at %d,%d: extensive damages\n",
  188:                                                         ix, iy);
  189:                                                 break;
  190:                                         }
  191:                                         killk(ix, iy);
  192:                                         break;
  193:                                 }
  194:                                 break;
  195:         
  196:                           case STAR:
  197:                                 nova(ix, iy);
  198:                                 break;
  199:         
  200:                           case INHABIT:
  201:                                 kills(ix, iy, -1);
  202:                                 break;
  203:         
  204:                           case BASE:
  205:                                 killb(Ship.quadx, Ship.quady);
  206:                                 Game.killb += 1;
  207:                                 break;
  208:                           default:
  209:                                 printf("Unknown object %c at %d,%d destroyed\n",
  210:                                         Sect[ix][iy], ix, iy);
  211:                                 Sect[ix][iy] = EMPTY;
  212:                                 break;
  213:                         }
  214:                         break;
  215:                 }
  216:                 if (damaged(TORPED) || Quad[Ship.quadx][Ship.quady].stars < 0)
  217:                         break;
  218:                 course += burst;
  219:         }
  220:         Move.free = 0;
  221: }
  222: 
  223: 
  224: /*
  225: **  RANDOMIZE COURSE
  226: **
  227: **      This routine randomizes the course for torpedo number 'n'.
  228: **      Other things handled by this routine are misfires, damages
  229: **      to the tubes, etc.
  230: */
  231: 
  232: static int
  233: randcourse(n)
  234: int     n;
  235: {
  236:         double                 r;
  237:         int            d;
  238: 
  239:         d = ((franf() + franf()) - 1.0) * 20;
  240:         if (abs(d) > 12)
  241:         {
  242:                 printf("Photon tubes misfire");
  243:                 if (n < 0)
  244:                         printf("\n");
  245:                 else
  246:                         printf(" on torpedo %d\n", n);
  247:                 if (ranf(2))
  248:                 {
  249:                         damage(TORPED, 0.2 * abs(d) * (franf() + 1.0));
  250:                 }
  251:                 d *= 1.0 + 2.0 * franf();
  252:         }
  253:         if (Ship.shldup || Ship.cond == DOCKED)
  254:         {
  255:                 r = Ship.shield;
  256:                 r = 1.0 + r / Param.shield;
  257:                 if (Ship.cond == DOCKED)
  258:                         r = 2.0;
  259:                 d *= r;
  260:         }
  261:         return (d);
  262: }