home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / games / trek / attack.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-08  |  5.8 KB  |  189 lines
  1. /*
  2.  * Copyright (c) 1980 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *    This product includes software developed by the University of
  16.  *    California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  */
  33.  
  34. #ifndef lint
  35. static char sccsid[] = "@(#)attack.c    5.4 (Berkeley) 6/1/90";
  36. #endif /* not lint */
  37.  
  38. # include    "trek.h"
  39.  
  40. /*
  41. **  Klingon Attack Routine
  42. **
  43. **    This routine performs the Klingon attack provided that
  44. **    (1) Something happened this move (i.e., not free), and
  45. **    (2) You are not cloaked.  Note that if you issue the
  46. **    cloak command, you are not considered cloaked until you
  47. **    expend some time.
  48. **
  49. **    Klingons are permitted to move both before and after the
  50. **    attack.  They will tend to move toward you before the
  51. **    attack and away from you after the attack.
  52. **
  53. **    Under certain conditions you can get a critical hit.  This
  54. **    sort of hit damages devices.  The probability that a given
  55. **    device is damaged depends on the device.  Well protected
  56. **    devices (such as the computer, which is in the core of the
  57. **    ship and has considerable redundancy) almost never get
  58. **    damaged, whereas devices which are exposed (such as the
  59. **    warp engines) or which are particularly delicate (such as
  60. **    the transporter) have a much higher probability of being
  61. **    damaged.
  62. **
  63. **    The actual amount of damage (i.e., how long it takes to fix
  64. **    it) depends on the amount of the hit and the "damfac[]"
  65. **    entry for the particular device.
  66. **
  67. **    Casualties can also occur.
  68. */
  69.  
  70. attack(resting)
  71. int    resting;    /* set if attack while resting */
  72. {
  73.     register int        hit, i, l;
  74.     int            maxhit, tothit, shldabsb;
  75.     double            chgfac, propor, extradm;
  76.     double            dustfac, tothe;
  77.     int            cas;
  78.     int            hitflag;
  79.  
  80.     if (Move.free)
  81.         return;
  82.     if (Etc.nkling <= 0 || Quad[Ship.quadx][Ship.quady].stars < 0)
  83.         return;
  84.     if (Ship.cloaked && Ship.cloakgood)
  85.         return;
  86.     /* move before attack */
  87.     klmove(0);
  88.     if (Ship.cond == DOCKED)
  89.     {
  90.         if (!resting)
  91.             printf("Starbase shields protect the %s\n", Ship.shipname);
  92.         return;
  93.     }
  94.     /* setup shield effectiveness */
  95.     chgfac = 1.0;
  96.     if (Move.shldchg)
  97.         chgfac = 0.25 + 0.50 * franf();
  98.     maxhit = tothit = 0;
  99.     hitflag = 0;
  100.  
  101.     /* let each Klingon do his damndest */
  102.     for (i = 0; i < Etc.nkling; i++)
  103.     {
  104.         /* if he's low on power he won't attack */
  105.         if (Etc.klingon[i].power < 20)
  106.             continue;
  107.         if (!hitflag)
  108.         {
  109.             printf("\nStardate %.2f: Klingon attack:\n",
  110.                 Now.date);
  111.             hitflag++;
  112.         }
  113.         /* complete the hit */
  114.         dustfac = 0.90 + 0.01 * franf();
  115.         tothe = Etc.klingon[i].avgdist;
  116.         hit = Etc.klingon[i].power * pow(dustfac, tothe) * Param.hitfac;
  117.         /* deplete his energy */
  118.         dustfac = Etc.klingon[i].power;
  119.         Etc.klingon[i].power = dustfac * Param.phasfac * (1.0 + (franf() - 0.5) * 0.2);
  120.         /* see how much of hit shields will absorb */
  121.         shldabsb = 0;
  122.         if (Ship.shldup || Move.shldchg)
  123.         {
  124.             propor = Ship.shield;
  125.             propor /= Param.shield;
  126.             shldabsb = propor * chgfac * hit;
  127.             if (shldabsb > Ship.shield)
  128.                 shldabsb = Ship.shield;
  129.             Ship.shield -= shldabsb;
  130.         }
  131.         /* actually do the hit */
  132.         printf("HIT: %d units", hit);
  133.         if (!damaged(SRSCAN))
  134.             printf(" from %d,%d", Etc.klingon[i].x, Etc.klingon[i].y);
  135.         cas = (shldabsb * 100) / hit;
  136.         hit -= shldabsb;
  137.         if (shldabsb > 0)
  138.             printf(", shields absorb %d%%, effective hit %d\n",
  139.                 cas, hit);
  140.         else
  141.             printf("\n");
  142.         tothit += hit;
  143.         if (hit > maxhit)
  144.             maxhit = hit;
  145.         Ship.energy -= hit;
  146.         /* see if damages occurred */
  147.         if (hit >= (15 - Game.skill) * (25 - ranf(12)))
  148.         {
  149.             printf("CRITICAL HIT!!!\n");
  150.             /* select a device from probability vector */
  151.             cas = ranf(1000);
  152.             for (l = 0; cas >= 0; l++)
  153.                 cas -= Param.damprob[l];
  154.             l -= 1;
  155.             /* compute amount of damage */
  156.             extradm = (hit * Param.damfac[l]) / (75 + ranf(25)) + 0.5;
  157.             /* damage the device */
  158.             damage(l, extradm);
  159.             if (damaged(SHIELD))
  160.             {
  161.                 if (Ship.shldup)
  162.                     printf("Sulu: Shields knocked down, captain.\n");
  163.                 Ship.shldup = 0;
  164.                 Move.shldchg = 0;
  165.             }
  166.         }
  167.         if (Ship.energy <= 0)
  168.             lose(L_DSTRYD);
  169.     }
  170.  
  171.     /* see what our casualities are like */
  172.     if (maxhit >= 200 || tothit >= 500)
  173.     {
  174.         cas = tothit * 0.015 * franf();
  175.         if (cas >= 2)
  176.         {
  177.             printf("McCoy: we suffered %d casualties in that attack.\n",
  178.                 cas);
  179.             Game.deaths += cas;
  180.             Ship.crew -= cas;
  181.         }
  182.     }
  183.  
  184.     /* allow Klingons to move after attacking */
  185.     klmove(1);
  186.  
  187.     return;
  188. }
  189.