1: /*      $NetBSD: attack.c,v 1.5 2003/08/07 09:37:49 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[] = "@(#)attack.c    8.1 (Berkeley) 5/31/93";
   36: #else
   37: __RCSID("$NetBSD: attack.c,v 1.5 2003/08/07 09:37:49 agc Exp $");
   38: #endif
   39: #endif /* not lint */
   40: 
   41: #include <stdio.h>
   42: #include <math.h>
   43: #include "trek.h"
   44: 
   45: /*
   46: **  Klingon Attack Routine
   47: **
   48: **      This routine performs the Klingon attack provided that
   49: **      (1) Something happened this move (i.e., not free), and
   50: **      (2) You are not cloaked.  Note that if you issue the
   51: **      cloak command, you are not considered cloaked until you
   52: **      expend some time.
   53: **
   54: **      Klingons are permitted to move both before and after the
   55: **      attack.  They will tend to move toward you before the
   56: **      attack and away from you after the attack.
   57: **
   58: **      Under certain conditions you can get a critical hit.  This
   59: **      sort of hit damages devices.  The probability that a given
   60: **      device is damaged depends on the device.  Well protected
   61: **      devices (such as the computer, which is in the core of the
   62: **      ship and has considerable redundancy) almost never get
   63: **      damaged, whereas devices which are exposed (such as the
   64: **      warp engines) or which are particularly delicate (such as
   65: **      the transporter) have a much higher probability of being
   66: **      damaged.
   67: **
   68: **      The actual amount of damage (i.e., how long it takes to fix
   69: **      it) depends on the amount of the hit and the "damfac[]"
   70: **      entry for the particular device.
   71: **
   72: **      Casualties can also occur.
   73: */
   74: 
   75: void
   76: attack(resting)
   77: int     resting;    /* set if attack while resting */
   78: {
   79:         int            hit, i, l;
   80:         int            maxhit, tothit, shldabsb;
   81:         double         chgfac, propor, extradm;
   82:         double         dustfac, tothe;
   83:         int            cas;
   84:         int            hitflag;
   85: 
   86:         if (Move.free)
   87:                 return;
   88:         if (Etc.nkling <= 0 || Quad[Ship.quadx][Ship.quady].stars < 0)
   89:                 return;
   90:         if (Ship.cloaked && Ship.cloakgood)
   91:                 return;
   92:         /* move before attack */
   93:         klmove(0);
   94:         if (Ship.cond == DOCKED)
   95:         {
   96:                 if (!resting)
   97:                         printf("Starbase shields protect the %s\n", Ship.shipname);
   98:                 return;
   99:         }
  100:         /* setup shield effectiveness */
  101:         chgfac = 1.0;
  102:         if (Move.shldchg)
  103:                 chgfac = 0.25 + 0.50 * franf();
  104:         maxhit = tothit = 0;
  105:         hitflag = 0;
  106: 
  107:         /* let each Klingon do his damndest */
  108:         for (i = 0; i < Etc.nkling; i++)
  109:         {
  110:                 /* if he's low on power he won't attack */
  111:                 if (Etc.klingon[i].power < 20)
  112:                         continue;
  113:                 if (!hitflag)
  114:                 {
  115:                         printf("\nStardate %.2f: Klingon attack:\n",
  116:                                 Now.date);
  117:                         hitflag++;
  118:                 }
  119:                 /* complete the hit */
  120:                 dustfac = 0.90 + 0.01 * franf();
  121:                 tothe = Etc.klingon[i].avgdist;
  122:                 hit = Etc.klingon[i].power * pow(dustfac, tothe) * Param.hitfac;
  123:                 /* deplete his energy */
  124:                 dustfac = Etc.klingon[i].power;
  125:                 Etc.klingon[i].power = dustfac * Param.phasfac * (1.0 + (franf() - 0.5) * 0.2);
  126:                 /* see how much of hit shields will absorb */
  127:                 shldabsb = 0;
  128:                 if (Ship.shldup || Move.shldchg)
  129:                 {
  130:                         propor = Ship.shield;
  131:                         propor /= Param.shield;
  132:                         shldabsb = propor * chgfac * hit;
  133:                         if (shldabsb > Ship.shield)
  134:                                 shldabsb = Ship.shield;
  135:                         Ship.shield -= shldabsb;
  136:                 }
  137:                 /* actually do the hit */
  138:                 printf("HIT: %d units", hit);
  139:                 if (!damaged(SRSCAN))
  140:                         printf(" from %d,%d", Etc.klingon[i].x, Etc.klingon[i].y);
  141:                 cas = (shldabsb * 100) / hit;
  142:                 hit -= shldabsb;
  143:                 if (shldabsb > 0)
  144:                         printf(", shields absorb %d%%, effective hit %d\n",
  145:                                 cas, hit);
  146:                 else
  147:                         printf("\n");
  148:                 tothit += hit;
  149:                 if (hit > maxhit)
  150:                         maxhit = hit;
  151:                 Ship.energy -= hit;
  152:                 /* see if damages occurred */
  153:                 if (hit >= (15 - Game.skill) * (25 - ranf(12)))
  154:                 {
  155:                         printf("CRITICAL HIT!!!\n");
  156:                         /* select a device from probability vector */
  157:                         cas = ranf(1000);
  158:                         for (l = 0; cas >= 0; l++)
  159:                                 cas -= Param.damprob[l];
  160:                         l -= 1;
  161:                         /* compute amount of damage */
  162:                         extradm = (hit * Param.damfac[l]) / (75 + ranf(25)) + 0.5;
  163:                         /* damage the device */
  164:                         damage(l, extradm);
  165:                         if (damaged(SHIELD))
  166:                         {
  167:                                 if (Ship.shldup)
  168:                                         printf("Sulu: Shields knocked down, captain.\n");
  169:                                 Ship.shldup = 0;
  170:                                 Move.shldchg = 0;
  171:                         }
  172:                 }
  173:                 if (Ship.energy <= 0)
  174:                         lose(L_DSTRYD);
  175:         }
  176: 
  177:         /* see what our casualities are like */
  178:         if (maxhit >= 200 || tothit >= 500)
  179:         {
  180:                 cas = tothit * 0.015 * franf();
  181:                 if (cas >= 2)
  182:                 {
  183:                         printf("McCoy: we suffered %d casualties in that attack.\n",
  184:                                 cas);
  185:                         Game.deaths += cas;
  186:                         Ship.crew -= cas;
  187:                 }
  188:         }
  189: 
  190:         /* allow Klingons to move after attacking */
  191:         klmove(1);
  192: 
  193:         return;
  194: }