2 * Copyright (c) 1980, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
33 * @(#)phaser.c 8.1 (Berkeley) 5/31/93
34 * $FreeBSD: src/games/trek/phaser.c,v 1.5.2.1 2000/07/20 10:35:07 kris Exp $
35 * $DragonFly: src/games/trek/phaser.c,v 1.3 2006/09/07 21:19:44 pavalos Exp $
41 /* factors for phaser hits; see description below */
43 # define ALPHA 3.0 /* spread */
44 # define BETA 3.0 /* franf() */
45 # define GAMMA 0.30 /* cos(angle) */
46 # define EPSILON 150.0 /* dist ** 2 */
47 # define OMEGA 10.596 /* overall scaling factor */
49 /* OMEGA ~= 100 * (ALPHA + 1) * (BETA + 1) / (EPSILON + 1) */
54 ** There are up to NBANKS phaser banks which may be fired
55 ** simultaneously. There are two modes, "manual" and
56 ** "automatic". In manual mode, you specify exactly which
57 ** direction you want each bank to be aimed, the number
58 ** of units to fire, and the spread angle. In automatic
59 ** mode, you give only the total number of units to fire.
61 ** The spread is specified as a number between zero and
62 ** one, with zero being minimum spread and one being maximum
63 ** spread. You will normally want zero spread, unless your
64 ** short range scanners are out, in which case you probably
65 ** don't know exactly where the Klingons are. In that case,
66 ** you really don't have any choice except to specify a
67 ** fairly large spread.
69 ** Phasers spread slightly, even if you specify zero spread.
74 struct cvntab Matab[] =
76 { "m", "anual", (void (*)(int))1, 0 },
77 { "a", "utomatic", (void (*)(int))0, 0 },
78 { NULL, NULL, NULL, 0 }
90 phaser(__unused int unused)
96 double anglefactor, distfactor;
98 int manual, flag, extra = 0;
103 struct banks bank[NBANKS];
106 if (Ship.cond == DOCKED) {
107 printf("Phasers cannot fire through starbase shields\n");
110 if (damaged(PHASER)) {
115 printf("Sulu: Captain, we cannot fire through shields.\n");
120 printf("Sulu: Captain, surely you must realize that we cannot fire\n");
121 printf(" phasers with the cloaking device up.\n");
125 /* decide if we want manual or automatic mode */
129 if (damaged(COMPUTER))
131 printf("%s", Device[COMPUTER].name);
137 printf("%s", Device[SRSCAN].name);
141 printf(" damaged, manual mode selected\n");
146 ptr = getcodpar("Manual or automatic", Matab);
147 manual = (long) ptr->value;
149 if (!manual && damaged(COMPUTER))
151 printf("Computer damaged, manual selected\n");
156 /* initialize the bank[] array */
158 for (i = 0; i < NBANKS; i++)
162 /* collect manual mode statistics */
165 printf("%d units available\n", Ship.energy);
168 for (i = 0; i < NBANKS; i++)
171 printf("\nBank %d:\n", i);
172 hit = getintpar("units");
178 if (extra > Ship.energy)
180 printf("available energy exceeded. ");
186 hit = getintpar("course");
187 if (hit < 0 || hit > 360)
189 b->angle = hit * 0.0174532925;
190 b->spread = getfltpar("spread");
191 if (b->spread < 0 || b->spread > 1)
194 Ship.energy -= extra;
200 /* automatic distribution of power */
201 if (Etc.nkling <= 0) {
202 printf("Sulu: But there are no Klingons in this quadrant\n");
205 printf("Phasers locked on target. ");
208 printf("%d units available\n", Ship.energy);
209 hit = getintpar("Units to fire");
212 if (hit > Ship.energy)
214 printf("available energy exceeded. ");
224 tot = n * (n + 1) / 2;
225 for (i = 0; i < n; i++)
229 distfactor = k->dist;
230 anglefactor = ALPHA * BETA * OMEGA / (distfactor * distfactor + EPSILON);
231 anglefactor *= GAMMA;
232 distfactor = k->power;
233 distfactor /= anglefactor;
234 hitreqd[i] = distfactor + 0.5;
235 dx = Ship.sectx - k->x;
236 dy = k->y - Ship.secty;
237 b->angle = atan2(dy, dx);
239 b->units = ((n - i) / tot) * extra;
243 printf("b%d hr%d u%d df%.2f af%.2f\n",
244 i, hitreqd[i], b->units,
245 distfactor, anglefactor);
249 hit = b->units - hitreqd[i];
257 /* give out any extra energy we might have around */
260 for (i = 0; i < n; i++)
263 hit = hitreqd[i] - b->units;
272 b->units = hitreqd[i];
276 printf("%d units overkill\n", extra);
284 for (i = 0; i < NBANKS; i++)
287 printf("b%d u%d", i, b->units);
289 printf(" a%.2f s%.2f\n", b->angle, b->spread);
296 /* actually fire the shots */
298 for (i = 0; i < NBANKS; i++)
305 printf("\nPhaser bank %d fires:\n", i);
308 for (j = 0; j < n; j++)
313 ** The formula for hit is as follows:
315 ** zap = OMEGA * [(sigma + ALPHA) * (rho + BETA)]
316 ** / (dist ** 2 + EPSILON)]
317 ** * [cos(delta * sigma) + GAMMA]
320 ** where sigma is the spread factor,
321 ** rho is a random number (0 -> 1),
322 ** GAMMA is a crud factor for angle (essentially
323 ** cruds up the spread factor),
324 ** delta is the difference in radians between the
325 ** angle you are shooting at and the actual
326 ** angle of the klingon,
327 ** ALPHA scales down the significance of sigma,
328 ** BETA scales down the significance of rho,
329 ** OMEGA is the magic number which makes everything
330 ** up to "* hit" between zero and one,
331 ** dist is the distance to the klingon
332 ** hit is the number of units in the bank, and
333 ** zap is the amount of the actual hit.
335 ** Everything up through dist squared should maximize
336 ** at 1.0, so that the distance factor is never
337 ** greater than one. Conveniently, cos() is
338 ** never greater than one, but the same restric-
341 distfactor = BETA + franf();
342 distfactor *= ALPHA + b->spread;
344 anglefactor = k->dist;
345 distfactor /= anglefactor * anglefactor + EPSILON;
346 distfactor *= b->units;
347 dx = Ship.sectx - k->x;
348 dy = k->y - Ship.secty;
349 anglefactor = atan2(dy, dx) - b->angle;
350 anglefactor = cos((anglefactor * b->spread) + GAMMA);
351 if (anglefactor < 0.0)
356 hit = anglefactor * distfactor + 0.5;
358 printf("%d unit hit on Klingon", hit);
359 if (!damaged(SRSCAN))
360 printf(" at %d,%d", k->x, k->y);
372 /* compute overkill */
373 for (i = 0; i < NBANKS; i++)
374 extra += bank[i].units;
376 printf("\n%d units expended on empty space\n", extra);