1/*	$NetBSD: klmove.c,v 1.8 2009/05/24 21:44:56 dholland 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
35static char sccsid[] = "@(#)klmove.c	8.1 (Berkeley) 5/31/93";
36#else
37__RCSID("$NetBSD: klmove.c,v 1.8 2009/05/24 21:44:56 dholland Exp $");
38#endif
39#endif /* not lint */
40
41#include <stdio.h>
42#include "trek.h"
43
44/*
45**  Move Klingons Around
46**
47**	This is a largely incomprehensible block of code that moves
48**	Klingons around in a quadrant.  It was written in a very
49**	"program as you go" fashion, and is a prime candidate for
50**	rewriting.
51**
52**	The flag `fl' is zero before an attack, one after an attack,
53**	and two if you are leaving a quadrant.  This serves to
54**	change the probability and distance that it moves.
55**
56**	Basically, what it will try to do is to move a certain number
57**	of steps either toward you or away from you.  It will avoid
58**	stars whenever possible.  Nextx and nexty are the next
59**	sector to move to on a per-Klingon basis; they are roughly
60**	equivalent to Ship.sectx and Ship.secty for the starship.  Lookx and
61**	looky are the sector that you are going to look at to see
62**	if you can move their.  Dx and dy are the increment.  Fudgex
63**	and fudgey are the things you change around to change your
64**	course around stars.
65*/
66
67void
68klmove(int fl)
69{
70	int			n;
71	struct kling	*k;
72	double			dx, dy;
73	int			nextx, nexty;
74	int		lookx, looky;
75	int			motion;
76	int			fudgex, fudgey;
77	int			qx, qy;
78	double			bigger;
79	int			i;
80
81#ifdef xTRACE
82	if (Trace)
83		printf("klmove: fl = %d, Etc.nkling = %d\n", fl, Etc.nkling);
84#endif
85	for (n = 0; n < Etc.nkling; n++) {
86		k = &Etc.klingon[n];
87		i = 100;
88		if (fl)
89			i = 100.0 * k->power / Param.klingpwr;
90		if (ranf(i) >= Param.moveprob[2 * Move.newquad + fl])
91			continue;
92		/* compute distance to move */
93		motion = ranf(75) - 25;
94		motion *= k->avgdist * Param.movefac[2 * Move.newquad + fl];
95		/* compute direction */
96		dx = Ship.sectx - k->x + ranf(3) - 1;
97		dy = Ship.secty - k->y + ranf(3) - 1;
98		bigger = dx;
99		if (dy > bigger)
100			bigger = dy;
101		if (bigger == 0.0)
102			bigger = 1.0;
103		dx = dx / bigger + 0.5;
104		dy = dy / bigger + 0.5;
105		if (motion < 0) {
106			motion = -motion;
107			dx = -dx;
108			dy = -dy;
109		}
110		fudgex = fudgey = 1;
111		/* try to move the klingon */
112		nextx = k->x;
113		nexty = k->y;
114		for (; motion > 0; motion--) {
115			lookx = nextx + dx;
116			looky = nexty + dy;
117			if (lookx < 0 || lookx >= NSECTS ||
118			    looky < 0 || looky >= NSECTS) {
119				/* new quadrant */
120				qx = Ship.quadx;
121				qy = Ship.quady;
122				if (lookx < 0)
123					qx -= 1;
124				else
125					if (lookx >= NSECTS)
126						qx += 1;
127				if (looky < 0)
128					qy -= 1;
129				else
130					if (looky >= NSECTS)
131						qy += 1;
132				if (qx < 0 || qx >= NQUADS ||
133				    qy < 0 || qy >= NQUADS ||
134				    Quad[qx][qy].stars < 0 ||
135				    Quad[qx][qy].klings > MAXKLQUAD - 1)
136					break;
137				if (!damaged(SRSCAN)) {
138					printf("Klingon at %d,%d escapes to "
139					       "quadrant %d,%d\n",
140						k->x, k->y, qx, qy);
141					motion = Quad[qx][qy].scanned;
142					if (motion >= 0 && motion < 1000)
143						Quad[qx][qy].scanned += 100;
144					motion = Quad[Ship.quadx][Ship.quady]
145						.scanned;
146					if (motion >= 0 && motion < 1000)
147						Quad[Ship.quadx][Ship.quady]
148							.scanned -= 100;
149				}
150				Sect[k->x][k->y] = EMPTY;
151				Quad[qx][qy].klings += 1;
152				Etc.nkling -= 1;
153				*k = Etc.klingon[Etc.nkling];
154				Quad[Ship.quadx][Ship.quady].klings -= 1;
155				k = 0;
156				break;
157			}
158			if (Sect[lookx][looky] != EMPTY) {
159				lookx = nextx + fudgex;
160				if (lookx < 0 || lookx >= NSECTS)
161					lookx = nextx + dx;
162				if (Sect[lookx][looky] != EMPTY) {
163					fudgex = -fudgex;
164					looky = nexty + fudgey;
165					if (looky < 0 || looky >= NSECTS ||
166					    Sect[lookx][looky] != EMPTY) {
167						fudgey = -fudgey;
168						break;
169					}
170				}
171			}
172			nextx = lookx;
173			nexty = looky;
174		}
175		if (k && (k->x != nextx || k->y != nexty)) {
176			if (!damaged(SRSCAN))
177				printf("Klingon at %d,%d moves to %d,%d\n",
178					k->x, k->y, nextx, nexty);
179			Sect[k->x][k->y] = EMPTY;
180			Sect[k->x = nextx][k->y = nexty] = KLINGON;
181		}
182	}
183	compkldist(0);
184}
185