NetBSD-5.0.2/games/robots/auto.c
/* $NetBSD: auto.c,v 1.8 2008/04/28 20:22:54 martin Exp $ */
/*-
* Copyright (c) 1999 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Christos Zoulas.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Automatic move.
* intelligent ?
* Algo :
* IF scrapheaps don't exist THEN
* IF not in danger THEN
* stay at current position
* ELSE
* move away from the closest robot
* FI
* ELSE
* find closest heap
* find closest robot
* IF scrapheap is adjacent THEN
* move behind the scrapheap
* ELSE
* take the move that takes you away from the
* robots and closest to the heap
* FI
* FI
*/
#include "robots.h"
#define ABS(a) (((a)>0)?(a):-(a))
#define MIN(a,b) (((a)>(b))?(b):(a))
#define MAX(a,b) (((a)<(b))?(b):(a))
#define CONSDEBUG(a)
static int distance(int, int, int, int);
static int xinc(int);
static int yinc(int);
static const char *find_moves(void);
static COORD *closest_robot(int *);
static COORD *closest_heap(int *);
static char move_towards(int, int);
static char move_away(COORD *);
static char move_between(COORD *, COORD *);
static int between(COORD *, COORD *);
/* distance():
* return "move" number distance of the two coordinates
*/
static int
distance(x1, y1, x2, y2)
int x1, y1, x2, y2;
{
return MAX(ABS(ABS(x1) - ABS(x2)), ABS(ABS(y1) - ABS(y2)));
} /* end distance */
/* xinc():
* Return x coordinate moves
*/
static int
xinc(dir)
int dir;
{
switch(dir) {
case 'b':
case 'h':
case 'y':
return -1;
case 'l':
case 'n':
case 'u':
return 1;
case 'j':
case 'k':
default:
return 0;
}
}
/* yinc():
* Return y coordinate moves
*/
static int
yinc(dir)
int dir;
{
switch(dir) {
case 'k':
case 'u':
case 'y':
return -1;
case 'b':
case 'j':
case 'n':
return 1;
case 'h':
case 'l':
default:
return 0;
}
}
/* find_moves():
* Find possible moves
*/
static const char *
find_moves()
{
int x, y;
COORD test;
const char *m;
char *a;
static const char moves[] = ".hjklyubn";
static char ans[sizeof moves];
a = ans;
for(m = moves; *m; m++) {
test.x = My_pos.x + xinc(*m);
test.y = My_pos.y + yinc(*m);
move(test.y, test.x);
switch(winch(stdscr)) {
case ' ':
case PLAYER:
for(x = test.x - 1; x <= test.x + 1; x++) {
for(y = test.y - 1; y <= test.y + 1; y++) {
move(y, x);
if(winch(stdscr) == ROBOT)
goto bad;
}
}
*a++ = *m;
}
bad:;
}
*a = 0;
if(ans[0])
return ans;
else
return "t";
}
/* closest_robot():
* return the robot closest to us
* and put in dist its distance
*/
static COORD *
closest_robot(dist)
int *dist;
{
COORD *rob, *end, *minrob = NULL;
int tdist, mindist;
mindist = 1000000;
end = &Robots[MAXROBOTS];
for (rob = Robots; rob < end; rob++) {
tdist = distance(My_pos.x, My_pos.y, rob->x, rob->y);
if (tdist < mindist) {
minrob = rob;
mindist = tdist;
}
}
*dist = mindist;
return minrob;
} /* end closest_robot */
/* closest_heap():
* return the heap closest to us
* and put in dist its distance
*/
static COORD *
closest_heap(dist)
int *dist;
{
COORD *hp, *end, *minhp = NULL;
int mindist, tdist;
mindist = 1000000;
end = &Scrap[MAXROBOTS];
for (hp = Scrap; hp < end; hp++) {
if (hp->x == 0 && hp->y == 0)
break;
tdist = distance(My_pos.x, My_pos.y, hp->x, hp->y);
if (tdist < mindist) {
minhp = hp;
mindist = tdist;
}
}
*dist = mindist;
return minhp;
} /* end closest_heap */
/* move_towards():
* move as close to the given direction as possible
*/
static char
move_towards(dx, dy)
int dx, dy;
{
char ok_moves[10], best_move;
char *ptr;
int move_judge, cur_judge, mvx, mvy;
(void)strcpy(ok_moves, find_moves());
best_move = ok_moves[0];
if (best_move != 't') {
mvx = xinc(best_move);
mvy = yinc(best_move);
move_judge = ABS(mvx - dx) + ABS(mvy - dy);
for (ptr = &ok_moves[1]; *ptr != '\0'; ptr++) {
mvx = xinc(*ptr);
mvy = yinc(*ptr);
cur_judge = ABS(mvx - dx) + ABS(mvy - dy);
if (cur_judge < move_judge) {
move_judge = cur_judge;
best_move = *ptr;
}
}
}
return best_move;
} /* end move_towards */
/* move_away():
* move away form the robot given
*/
static char
move_away(rob)
COORD *rob;
{
int dx, dy;
dx = sign(My_pos.x - rob->x);
dy = sign(My_pos.y - rob->y);
return move_towards(dx, dy);
} /* end move_away */
/* move_between():
* move the closest heap between us and the closest robot
*/
static char
move_between(rob, hp)
COORD *rob;
COORD *hp;
{
int dx, dy;
float slope, cons;
/* equation of the line between us and the closest robot */
if (My_pos.x == rob->x) {
/*
* me and the robot are aligned in x
* change my x so I get closer to the heap
* and my y far from the robot
*/
dx = - sign(My_pos.x - hp->x);
dy = sign(My_pos.y - rob->y);
CONSDEBUG(("aligned in x"));
}
else if (My_pos.y == rob->y) {
/*
* me and the robot are aligned in y
* change my y so I get closer to the heap
* and my x far from the robot
*/
dx = sign(My_pos.x - rob->x);
dy = -sign(My_pos.y - hp->y);
CONSDEBUG(("aligned in y"));
}
else {
CONSDEBUG(("no aligned"));
slope = (My_pos.y - rob->y) / (My_pos.x - rob->x);
cons = slope * rob->y;
if (ABS(My_pos.x - rob->x) > ABS(My_pos.y - rob->y)) {
/*
* we are closest to the robot in x
* move away from the robot in x and
* close to the scrap in y
*/
dx = sign(My_pos.x - rob->x);
dy = sign(((slope * ((float) hp->x)) + cons) -
((float) hp->y));
}
else {
dx = sign(((slope * ((float) hp->x)) + cons) -
((float) hp->y));
dy = sign(My_pos.y - rob->y);
}
}
CONSDEBUG(("me (%d,%d) robot(%d,%d) heap(%d,%d) delta(%d,%d)",
My_pos.x, My_pos.y, rob->x, rob->y, hp->x, hp->y, dx, dy));
return move_towards(dx, dy);
} /* end move_between */
/* between():
* Return true if the heap is between us and the robot
*/
int
between(rob, hp)
COORD *rob;
COORD *hp;
{
/* I = @ */
if (hp->x > rob->x && My_pos.x < rob->x)
return 0;
/* @ = I */
if (hp->x < rob->x && My_pos.x > rob->x)
return 0;
/* @ */
/* = */
/* I */
if (hp->y < rob->y && My_pos.y > rob->y)
return 0;
/* I */
/* = */
/* @ */
if (hp->y > rob->y && My_pos.y < rob->y)
return 0;
return 1;
} /* end between */
/* automove():
* find and do the best move if flag
* else get the first move;
*/
char
automove()
{
#if 0
return find_moves()[0];
#else
COORD *robot_close;
COORD *heap_close;
int robot_dist, robot_heap, heap_dist;
robot_close = closest_robot(&robot_dist);
if (robot_dist > 1)
return('.');
if (!Num_scrap)
/* no scrap heaps just run away */
return move_away(robot_close);
heap_close = closest_heap(&heap_dist);
robot_heap = distance(robot_close->x, robot_close->y,
heap_close->x, heap_close->y);
if (robot_heap <= heap_dist && !between(robot_close, heap_close)) {
/*
* robot is closest to us from the heap. Run away!
*/
return move_away(robot_close);
}
return move_between(robot_close, heap_close);
#endif
} /* end automove */