CodeMirror
/
CnC_Remastered_Collection
mirror of https://github.com/electronicarts/CnC_Remastered_Collection
1
0
Fork 0
Code Issues Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/FINDPATH.CPP

1308 lines
46 KiB
C++
Raw Permalink Blame History

//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
/* $Header: /CounterStrike/FINDPATH.CPP 1 3/03/97 10:24a Joe_bostic $ */
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : Command & Conquer *
* *
* File Name : FINDPATH.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : September 10, 1993 *
* *
* Last Update : May 25, 1995 [PWG] *
* *
* The path algorithm works by following a LOS path to the target. If it *
* collides with an impassable spot, it uses an Edge following routine to *
* get around it. The edge follower moves along the edge in a clockwise or *
* counter clockwise fashion until finding the destination spot. The *
* destination is determined by Find_Path. It is the first passable that *
* can be reached (so it will handle the doughnut case, where there is *
* a passable in the center of an unreachable area). *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* Clear_Path_Overlap -- clears the path overlap list *
* Find_Path -- Find a path from point a to point b. *
* Find_Path_Cell -- Finds a given cell on a specified path *
* Follow_Edge -- Follow an edge to get around an impassable spot. *
* FootClass::Unravel_Loop -- Unravels a loop in the movement path *
* Get_New_XY -- Get the new x,y based on current position and direction. *
* Optimize_Moves -- Optimize the move list. *
* Set_Path_Overlap -- Sets the overlap bit for given cell *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
//#include <string.h>
/*
** When an edge search is started, it can be performed CLOCKwise or
** COUNTERCLOCKwise direction.
*/
#define CLOCK (FacingType)1 // Clockwise.
#define COUNTERCLOCK (FacingType)-1 // Counterclockwise.
/*
** If defined, diagonal moves are allowed, else no diagonals.
*/
#define DIAGONAL
/*
** This is the marker to signify the end of the path list.
*/
#define END FACING_NONE
/*
** "- 1" test for bit manipulation.
*/
#define TEST
/*
** If memory is more important than speed, set this define to
** true. It will then perform intermediate optimizations to get the most
** milage out of a limited movement list staging area. If this value
** is true then it figures paths a bit more intelligently.
*/
#define SAVEMEM true
/*
** Modify this macro so that given two cell values, it will return
** a value between 0 and 7, with 0 being North and moving
** clockwise (just like map degrees).
*/
#define CELL_FACING(a, b) Dir_Facing(::Direction((a), (b)))
/*-------------------------------------------------------------------------*/
/*
** Cells values are really indexes into the 'map'. The following value is
** the X width of the map.
*/
#define MODULO MAP_CELL_W
/*
** Maximum lookahead cells. Twice this value in bytes will be
** reserved on the stack. The smaller this number, the faster the processing.
*/
#define MAX_MLIST_SIZE 300
#define THREAT_THRESHOLD 5
#define MAX_PATH_EDGE_FOLLOW 400
#ifdef NEVER
typedef enum {
FACING_N, // North
FACING_NE, // North-East
FACING_E, // East
FACING_SE, // South-East
FACING_S, // South
FACING_SW, // South-West
FACING_W, // West
FACING_NW, // North-West
FACING_COUNT // Total of 8 directions (0..7).
} FacingType;
#endif
/*-------------------------------------------------------------------------*/
//static bool DrawPath;
inline FacingType Opposite(FacingType face)
{
return( (FacingType) (face ^ 4));
}
inline static FacingType Next_Direction(FacingType facing, FacingType dir)
{
facing = facing + dir;
#ifndef DIAGONAL
facing = (FacingType)(facing & 0x06);
#endif
return(facing);
}
/*=========================================================================*/
/* Define a couple of variables which are private to the module they are */
/* declared in. */
/*=========================================================================*/
static unsigned long MainOverlap[MAP_CELL_TOTAL/32]; // overlap list for the main path
static unsigned long LeftOverlap[MAP_CELL_TOTAL/32]; // overlap list for the left path
static unsigned long RightOverlap[MAP_CELL_TOTAL/32]; // overlap list for the right path
//static CELL MoveMask = 0;
static CELL DestLocation;
static CELL StartLocation;
/***************************************************************************
* Point_Relative_To_Line -- Relation between a point and a line *
* *
* If a point is on a line then the following function holds true: *
* (x - x2)(z1 - z2) = (z - z2)(x1 - x2) given x,z a point on the *
* line (x1,z1),(x2,z2). *
* If the right side is > then the left side then the point is on one *
* side of the line and if the right side is < the the left side, then*
* the point is on the other side of the line. By subtracting one side*
* from the other we can determine on what side (if any) the point is on*
* by testing the side of the resulting subtraction. *
* *
* INPUT: *
* int x - x pos of point. *
* int z - z pos of point. *
* int x1 - x pos of first end of line segment. *
* int z1 - z pos of first end of line segment. *
* int x1 - x pos of second end of line segment. *
* int z1 - z pos of second end of line segment. *
* *
* OUTPUT: *
* Assuming (x1,z1) is north, (x2,z2) is south: *
* 0 : point is on line. *
* > 0 : point is east of line. *
* < 0 : point is west of line. *
* *
* WARNINGS: *
* Remember that int means that assumes 16 bits of precision. *
* *
* HISTORY: *
* 10/28/1994 SKB : Created. *
*=========================================================================*/
int Point_Relative_To_Line(int x, int z, int x1, int z1, int x2, int z2)
{
return((((long)x - (long)x2) * ((long)z1 - (long)z2)) - (((long)z - (long)z2) * ((long)x1 - (long)x2)));
}
/***************************************************************************
* FootClass::Unravel_Loop -- Unravels a loop in the movement path *
* *
* While in the midst of the Follow Edge logic, it is possible (due to the *
* fact that we support diagonal movement) to begin looping around a *
* column of some type. The Unravel loop function will scan backward *
* through the list and fixup the path to try to prevent the loop. *
* *
* INPUT: path - pointer to the generated path so we can pull the *
* commands out of it. *
* cell - the cell we tried to enter that generated the *
* double overlap condition. *
* dir - the direction we tried to enter from when we *
* generated the double overlap condition *
* startx - the start x position of this path segment *
* starty - the start y position of this path segment *
* destx - the dest x position for this path segment *
* desty - the dest y position for this path segment *
* *
* OUTPUT: TRUE - loop has been successfully unravelled *
* FALSE - loop can not be unravelled so abort follow edge *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/25/1995 PWG : Created. *
*=========================================================================*/
bool FootClass::Unravel_Loop(PathType * path, CELL &cell, FacingType &dir, int sx, int sy, int dx, int dy, MoveType threshhold)
{
/*
** Walk back to the actual cell before we advanced our position
*/
FacingType curr_dir = dir;
CELL curr_pos = Adjacent_Cell(cell, Opposite(curr_dir));
int idx = path->Length; // start at the last position
FacingType * list = &path->Command[idx-1]; // point to the last command
int checkx;
int checky;
int last_was_line = false;
/*
** loop backward through the list searching for a point that is
** on the line. If the point was a diagonal move then adjust
** it.
*/
while (idx) {
checkx = Cell_X(curr_pos);
checky = Cell_Y(curr_pos);
if (!Point_Relative_To_Line(checkx, checky, sx, sy, dx, dy) || last_was_line) {
/*
** We have now found a point on the line. Now we must check to see
** if we left the line on a diagonal. If we did then we need to fix
** it up.
*/
if (curr_dir & 1 && curr_pos != path->LastFixup) {
cell = curr_pos;
dir = *(list-1);
path->Length = idx;
path->LastFixup = curr_pos;
return(true);
}
last_was_line = !last_was_line;
}
/*
** Since this cell will not be in the list, then pull out its cost
*/
path->Cost -= Passable_Cell(curr_pos, *list, -1, threshhold);
/*
** Remove this cells flag from the overlap list for the path
*/
#ifdef TEST
path->Overlap[curr_pos >> 5] &= ~(1 << ((curr_pos & 31)));
#else
path->Overlap[curr_pos >> 5] &= ~(1 << ((curr_pos & 31) - 1));
#endif
/*
** Adjust to the next list position and direction.
*/
curr_dir = *list--;
curr_pos = Adjacent_Cell(curr_pos, Opposite(curr_dir));
idx--;
}
/*
** If we can't modify the list to eliminate the problem, then we have
** a larger problem in that we have deleted all of the cells in the
** list.
*/
return(false);
}
/***************************************************************************
* Register_Cell -- registers a cell on our path and check for backtrack *
* *
* This function adds a new cell to our path. If the cell has already *
* been recorded as part of our path, then this function moves back down *
* the list truncating it at the point we registered that cell. This *
* function will eliminate all backtracking from the list. *
* *
* INPUT: long * list - the list to set the overlap bit for *
* CELL cell - the cell to mark on the overlap list *
* *
* OUTPUT: BOOL - TRUE if bit has been set, FALSE if bit already set *
* *
* HISTORY: *
* 05/23/1995 PWG : Created. *
*=========================================================================*/
bool FootClass::Register_Cell(PathType * path, CELL cell, FacingType dir, int cost, MoveType threshhold)
{
FacingType * list;
int pos = cell >> 5;
#ifdef TEST
int bit = (cell & 31);
#else
int bit = (cell & 31) - 1;
#endif
/*
** See if this point has already been registered as on the list. If so
** we need to truncate the list back to this point and register the
** new direction.
*/
if (path->Overlap[pos] & (1 << bit)) {
/*
** If this is not a case of immediate back tracking then handle
** by searching the list to see what we find. However is this is
** an immediate back track, then pop of the last direction
** and unflag the cell we are in (not the cell we are moving to).
** Note: That we do not check for a zero length cell because we
** could not have a duplicate unless there are cells in the list.
*/
if (path->Command[path->Length - 1] == Opposite(dir)) {
CELL pos = Adjacent_Cell(cell, Opposite(dir));
#ifdef TEST
path->Overlap[pos >> 5] &= ~(1 << ((pos & 31)));
#else
path->Overlap[pos >> 5] &= ~(1 << ((pos & 31) - 1));
#endif
path->Length--;
} else {
/*
** If this overlap is in the same place as we had our last overlap
** then we are in a loop condition. We need to signify that we
** cannot register this cell.
*/
if (path->LastOverlap == cell) {
return(false);
} else {
path->LastOverlap = cell;
}
CELL pos = path->Start;
int newlen = 0;
int idx = 0;
list = path->Command;
/*
** Note that the cell has to be in this list, so theres no sense
** in checking whether we found it (famous last words).
**
** PWG 8/16/95 - However there is no sense searching the list if
** the cell we have overlapped on is the cell we
** started in.
*/
if (pos != cell) {
while (idx < path->Length) {
pos = Adjacent_Cell(pos, *list);
if (pos == cell) {
idx++;
list++;
break;
}
idx++;
list++;
}
newlen = idx;
}
/*
** Now we are pointing at the next command in the list. From here on
** out we need to unmark the fact that we have entered these cells and
** adjust the cost of our path to reflect that we have not entered
** then.
*/
while (idx < path->Length) {
pos = Adjacent_Cell(pos, *list);
path->Cost -= Passable_Cell(pos, *list, -1, threshhold);
#ifdef TEST
path->Overlap[pos >> 5] &= ~(1 << ((pos & 31)));
#else
path->Overlap[pos >> 5] &= ~(1 << ((pos & 31) - 1));
#endif
idx++;
list++;
}
path->Length = newlen;
}
} else {
/*
** Now we need to register the new direction, updating the cell structure
** and the cost.
*/
int cpos = path->Length++;
path->Command[cpos] = dir; // save of the direction we moved
path->Cost += cost; // figure new cost for cell
path->Overlap[pos] |= (1 << bit); // mark the we have entered point
}
return(true);
}
/***********************************************************************************************
* Find_Path -- Find a path from point a to point b. *
* *
* INPUT: int source x,y, int destination x,y, char *final moves *
* array to store moves, int maximum moves we may attempt *
* *
* OUTPUT: int number of moves it took (IMPOSSIBLE_MOVES if we could *
* not reach the destination *
* *
* WARNINGS: This algorithm assumes that the target is NOT situated *
* inside an impassable. If this case may arise, the do-while *
* statement inside the inner while (true) must be changed *
* to include a check to se if the next_x,y is equal to the *
* dest_x,y. If it is, then return(IMPOSSIBLE_MOVES). *
* *
* HISTORY: *
* 07/08/1991 CY : Created. *
*=============================================================================================*/
PathType * FootClass::Find_Path(CELL dest, FacingType * final_moves, int maxlen, MoveType threshhold)
{
CELL source = Coord_Cell(Coord); // Source expressed as cell
static PathType path; // Main path control.
CELL next; // Next cell to enter
CELL startcell; // Cell we started in
FacingType direction; // Working direction of look ahead.
FacingType newdir; // Tentative facing value.
bool left=false, // Was leftward path legal?
right=false; // Was rightward path legal?
int len; // Length of detour command list.
int unit_threat; // Calculated unit threat rating
int cost; // Cost to enter the square
FacingType moves_left[MAX_MLIST_SIZE+2], // Counterclockwise move list.
moves_right[MAX_MLIST_SIZE+2]; // Clockwise move list.
PathType pleft,pright; // Path control structures.
PathType * which; // Which path to actually use.
int threat = 0; //
int threat_stage = 0; //These weren't initialized. ST - 1/8/2019 12:03PM
/*
** If we have been provided an illegal place to store our final moves
** then forget it.
*/
if (!final_moves) return(NULL);
BStart(BENCH_FINDPATH);
PathCount++;
if (Team && Team->Class->IsRoundAbout) {
unit_threat = (Team) ? Team->Risk : Risk();
threat_stage = 0;
threat = 0;
} else {
unit_threat = threat = -1;
}
StartLocation = source;
DestLocation = dest;
/*
** Initialize the path structure so that we can keep track of the
** path.
*/
path.Start = source;
path.Cost = 0;
path.Length = 0;
path.Command = final_moves;
path.Command[0] = END;
path.Overlap = MainOverlap;
path.LastOverlap = -1;
path.LastFixup = -1;
memset(path.Overlap, 0, sizeof(MainOverlap));
/*
** Clear the over lap list and then make sure that our starting position is marked
** on the overlap list. (Otherwise the harvesters will drive in circles... )
*/
#ifdef TEST
path.Overlap[source >> 5] |= (1 << ((source & 31)));
#else
path.Overlap[source >> 5] |= (1 << ((source & 31) - 1));
#endif
startcell = source;
/*
** Account for trailing end of list command, so reduce the maximum
** allowed legal commands to reflect this.
*/
maxlen--;
/*
** As long as there is room to put commands in the movement command list,
** then put commands in it. We build the path using the following
** methodology.
**
** 1. Scan through the desired straight line path until we either hit an
** impassable or have created a valid path.
**
** 2. If we have hit an impassable, walk through the impassable to make
** sure that there is a passable on the other side. If there is not
** and we can not change the impassable, then this list is dead.
**
** 3. Walk around the impassable on both the left and right edges and
** take the shorter of the two paths.
**
** 4. Taking the new location as our start location start again with
** step #1.
*/
while (path.Length < maxlen) {
top_of_list:
/*
** Have we reached the destination already? If so abort any further
** command building.
*/
if (startcell == dest) {
break;
}
/*
** Find the absolute correct direction to reach the next straight
** line cell and what cell it is.
*/
direction = CELL_FACING(startcell, dest);
next = Adjacent_Cell(startcell, direction);
/*
** If we can move here, then make this our next move.
*/
cost = Passable_Cell(next, direction, threat, threshhold);
if (cost) {
Register_Cell(&path, next, direction, cost, threshhold);
} else {
/*
** If the impassable location is actually the destination,
** then stop here and consider this "good enough".
*/
if (next == dest) break;
/*
** We could not move to the next cell, so follow through the
** impassable until we find a passable spot that can be reached.
** Once we find a passable, figure out the shortest path to it.
** Since we have variable passable conditions this is not as
** simple as it used to be. The limiter loop below allows us to
** step through ten doughnuts before we give up.
*/
for (int limiter = 0; limiter < 5; limiter++) {
/*
** Get the next passable position by zipping through the
** impassable positions until a passable position is found
** or the destination is reached.
*/
for (;;) {
/*
** Move one step closer toward destination.
*/
newdir = CELL_FACING(next, dest);
next = Adjacent_Cell(next, newdir);
/*
** If the cell is passable then we have been completely
** successful. If the cell is not passable then continue.
*/
if (Passable_Cell(next, FACING_NONE, threat, threshhold)) {
// if ((Passable_Cell(next, FACING_NONE, threat, threshhold)) || (next == dest)) {
break;
}
/*
** If we reached destination while in this loop, we
** know that either the destination is impassible (if
** we are ignoring) or that we need to up our threat
** tolerance and try again.
*/
if (next == dest) {
if (threat != -1) {
switch (threat_stage++) {
case 0:
threat = unit_threat >> 1;
break;
case 1:
threat += unit_threat;
break;
case 2:
threat = -1;
break;
}
goto top_of_list;
}
goto end_of_list;
}
}
/*
** Try to find a path to the passable position by following
** the edge of the blocking object in both CLOCKwise and
** COUNTERCLOCKwise fashions.
*/
int follow_len = maxlen + (maxlen >> 1);
Mem_Copy(&path, &pleft, sizeof(PathType));
pleft.Command = &moves_left[0];
pleft.Overlap = LeftOverlap;
Mem_Copy(path.Command, pleft.Command, path.Length);
Mem_Copy(path.Overlap, pleft.Overlap, sizeof(LeftOverlap));
// MBL 09.30.2019: We hit a runtime bounds crash where END (-1 / 0xFF) was being poked into +1 just past the end of the moves_right[] array;
// The FacingType moves_left[] and moves_right[] arrays already have MAX_MLIST_SIZE+2 as their size, which may have been a previous attempted fix;
// We are now passing MAX_MLIST_SIZE, since the sizeof calculations included the +2 buffering;
#if 0
left = Follow_Edge(startcell, next, &pleft, COUNTERCLOCK, direction, threat, threat_stage, sizeof(moves_left)/sizeof(moves_left[0]), threshhold);
// left = Follow_Edge(startcell, next, &pleft, COUNTERCLOCK, direction, threat, threat_stage, follow_len, threshhold);
#endif
left = Follow_Edge(startcell, next, &pleft, COUNTERCLOCK, direction, threat, threat_stage, MAX_MLIST_SIZE, threshhold);
if (left) {
follow_len = min(maxlen, pleft.Length + (pleft.Length >> 1));
}
Mem_Copy(&path, &pright, sizeof(PathType));
pright.Command = &moves_right[0];
pright.Overlap = RightOverlap;
Mem_Copy(path.Command, pright.Command, path.Length);
Mem_Copy(path.Overlap, pright.Overlap, sizeof(RightOverlap));
// MBL 09.30.2019: We hit a runtime bounds crash where END (-1 / 0xFF) was being poked into +1 just past the end of the moves_right[] array;
// The FacingType moves_left[] and moves_right[] arrays already have MAX_MLIST_SIZE+2 as their size, which may have been a previous attempted fix;
// We are now passing MAX_MLIST_SIZE, since the sizeof calculations included the +2 buffering;
#if 0
right = Follow_Edge(startcell, next, &pright, CLOCK, direction, threat, threat_stage, sizeof(moves_right)/sizeof(moves_right[0]), threshhold);
// right = Follow_Edge(startcell, next, &pright, CLOCK, direction, threat, threat_stage, follow_len, threshhold);
#endif
right = Follow_Edge(startcell, next, &pright, CLOCK, direction, threat, threat_stage, MAX_MLIST_SIZE, threshhold);
/*
** If we could find a path, break from this loop. Otherwise this
** means that we have found a "hole" of passable terrain that
** cannot be reached by normal means. Scan forward looking for
** the other side of the "doughnut".
*/
if (left || right) break;
/*
** If no path can be found to the intermediate cell, then
** presume we have found a doughnut of some sort. Scan
** forward until the next impassable is found and then
** process this loop again.
*/
do {
/*
** If we reached destination while in this loop, we
** know that either the destination is impassible (if
** we are ignoring) or that we need to up our threat
** tolerance and try again.
*/
if (next == dest) {
if (threat != -1) {
switch (threat_stage++) {
case 0:
threat = unit_threat >> 1;
break;
case 1:
threat += unit_threat;
break;
case 2:
threat = -1;
break;
}
goto top_of_list;
}
goto end_of_list;
}
newdir = CELL_FACING(next, dest);
next = Adjacent_Cell(next, newdir);
} while (Passable_Cell(next, newdir, threat, threshhold));
}
if (!left && !right) break;
/*
** We found a path around the impassable locations, so figure out
** which one was the smallest and copy those moves into the
** path.Command array.
*/
which = &pleft;
if (right) {
which = &pright;
if (left) {
if (pleft.Length < pright.Length) {
which = &pleft;
} else {
which = &pright;
}
}
}
/*
** Record as much as possible of the shorter of the two
** paths. The trailing EOL command is not copied because
** this may not be the end of the find path logic.
*/
len = which->Length;
len = min(len, maxlen);
if (len > 0) {
memcpy(&path.Overlap[0], &which->Overlap[0], sizeof(LeftOverlap));
memcpy(&path.Command[0], &which->Command[0], len * sizeof(FacingType));
path.Length = len;
path.Cost = which->Cost;
path.LastOverlap = -1;
path.LastFixup = -1;
} else {
break;
}
}
startcell = next;
}
end_of_list:
/*
** Poke in the stop command.
*/
if (path.Length < maxlen) {
path.Command[path.Length++] = END;
}
/*
** Optimize the move list but only necessary if
** diagonal moves are allowed.
*/
#ifdef DIAGONAL
Optimize_Moves(&path, threshhold);
#endif
BEnd(BENCH_FINDPATH);
return(&path);
}
/***********************************************************************************************
* Follow_Edge -- Follow an edge to get around an impassable spot. *
* *
* INPUT: start -- cell to head from *
* *
* target -- Target cell to head to. *
* *
* path -- Pointer to path list structure. *
* *
* search -- Direction of search (1=clock, -1=counterclock). *
* *
* olddir -- Facing impassible direction from start. *
* *
* callback -- Function pointer for determining if a cell is *
* passable or not. *
* *
* OUTPUT: bool: Could a path be found to the desired cell? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/08/1991 CY : Created. *
* 06/01/1992 JLB : Optimized & commented. *
*=============================================================================================*/
bool FootClass::Follow_Edge(CELL start, CELL target, PathType * path, FacingType search, FacingType olddir, int threat, int , int max_cells, MoveType threshhold)
{
FacingType newdir; // Direction of facing before surrounding cell check.
CELL oldcell, // Current cell.
newcell; // Tentative new cell.
int cost; // Working cost value.
int startx;
int starty;
int online=true;
int targetx;
int targety;
int oldval = 0;
int cellcount=0;
int forceout = false;
FacingType firstdir = (FacingType)-1;
CELL firstcell = -1;
bool stepped_off_line = false;
startx = Cell_X(start);
starty = Cell_Y(start);
targetx = Cell_X(target);
targety = Cell_Y(target);
if (!path) return(false);
path->LastOverlap = -1;
path->LastFixup = -1;
#ifndef DIAGONAL
/*
** The edge following algorithm doesn't "do" diagonals. Force initial facing
** to be an even 90 degree value. Adjust it in the direction it should be
** rotating.
*/
if (olddir & 0x01) {
olddir = Next_Direction(olddir, search);
}
#endif
newdir = Next_Direction(olddir, search);
oldcell = start;
newcell = Adjacent_Cell(oldcell, newdir);
/*
** Continue until we find our target, find our original starting spot,
** or run out of moves.
*/
while (path->Length < max_cells) {
/*
** Look in all the adjacent cells to determine a passable one that
** most closely matches the desired direction (working in the specified
** direction).
*/
newdir = olddir;
for (;;) {
bool forcefail; // Is failure forced?
forcefail = false;
#ifdef DIAGONAL
/*
** Rotate 45/90 degrees in desired direction.
*/
newdir = Next_Direction(newdir, search);
/*
** If facing a diagonal we must check the next 90 degree location
** to make sure that we don't walk right by the destination. This
** will happen if the destination it is at the corner edge of an
** impassable that we are moving around.
*/
if (newdir & FACING_NE) {
CELL checkcell; // Non-diagonal check cell.
//int x,y;
checkcell = Adjacent_Cell(oldcell, Next_Direction(newdir, search));
if (checkcell == target) {
/*
** This only works if in fact, it is possible to move to the
** cell from the current location.
*/
cost = Passable_Cell(checkcell, Next_Direction(newdir, search), threat, threshhold);
if (cost) {
/*
** YES! The destination is at the corner of an impassable, so
** set the direction to point directly at it and then the
** scanning will terminate later.
*/
newdir = Next_Direction(newdir, search);
newcell = Adjacent_Cell(oldcell, newdir);
break;
}
}
/*
** Perform special diagonal check. If the edge follower would cross the
** diagonal or fall on the diagonal line from the source, then consider
** that cell impassible. Otherwise, the find path algorithm will fail
** when there are two impassible locations located on a diagonal
** that is lined up between the source and destination location.
**
** P.S. It might help if you check the right cell rather than using
** the value that just happened to be in checkcell.
*/
checkcell = Adjacent_Cell(oldcell, newdir);
int checkx = Cell_X(checkcell);
int checky = Cell_Y(checkcell);
int checkval = Point_Relative_To_Line(checkx, checky, startx, starty, targetx, targety);
if (checkval && !online) {
forcefail = ((checkval ^ oldval) < 0);
} else {
forcefail = false;
}
/*
** The only exception to the above is when we are directly backtracking
** because we could be trying to escape from a culdesack!
*/
if (forcefail && path->Length > 0 && (FacingType)(newdir ^ 4) == path->Command[path->Length - 1]) {
forcefail = false;
}
}
#else
newdir = Next_Direction(newdir, search*2);
#endif
/*
** If we have just checked the same heading we started with,
** we are surrounded by impassable characters and we exit.
*/
if (newdir == olddir) {
return(false);
}
/*
** Get the new cell.
*/
newcell = Adjacent_Cell(oldcell, newdir);
/*
** If we found a passable position, this is where we should move.
*/
if (!forcefail && ((cost = Passable_Cell(newcell, newdir, threat, threshhold)) != 0)) {
break;
} else {
if (newcell == target) {
forceout = true;
break;
}
}
}
/*
** Record the direction.
*/
if (!forceout) {
/*
** Mark the cell because this is where we need to be. If register
** cell fails then the list has been shortened and we need to adjust
** the new direction.
*/
if (!Register_Cell(path, newcell, newdir, cost, threshhold)) {
/*
** The only reason we could not register a cell is that we are in
** a looping situation. So we need to try and unravel the loop if
** we can.
*/
if (!Unravel_Loop(path, newcell, newdir, startx, starty, targetx, targety, threshhold)) {
return(false);
}
/*
** Since we need to eliminate a diagonal we must pretend the upon
** attaining this square, we were moving turned further in the
** search direction then we really were.
*/
newdir = Next_Direction(newdir, (FacingType)(search*2));
}
/*
** Find out which side of the line this cell is on. If it is on
** a side, then store off that side.
*/
int newx = Cell_X(newcell);
int newy = Cell_Y(newcell);
int val = Point_Relative_To_Line(newx, newy, startx, starty, targetx, targety);
if (val) {
oldval = val;
online = false;
} else {
online = true;
}
cellcount++;
if (cellcount == MAX_PATH_EDGE_FOLLOW) {
return(false);
}
}
/*
** If we have found the target spot, we are done.
*/
if (newcell == target) {
path->Command[path->Length] = END;
return(true);
}
/*
** If we make a full circle back to our original spot, get out.
*/
if (newcell == firstcell && newdir == firstdir) {
return(false);
}
if (firstcell == -1) {
firstcell = newcell;
firstdir = newdir;
}
/*
** Because we moved, our facing is now incorrect. We want to face toward
** the impassable edge we are following (well, not actually toward, but
** a little past so that we can turn corners). We have to turn 45/90 degrees
** more than expected in anticipation of the pending 45/90 degree turn at
** the start of this loop.
*/
#ifdef DIAGONAL
olddir = Next_Direction(newdir, (FacingType)(-(int)search*3));
#else
olddir = Next_Direction(newdir, (FacingType)(-(int)search*4));
#endif
oldcell = newcell;
}
/*
** The maximum search path is exhausted... abort with a failure.
*/
return(false);
}
/***********************************************************************************************
* Optimize_Moves -- Optimize the move list. *
* *
* INPUT: char *moves to optimize *
* *
* OUTPUT: none (list is optimized) *
* *
* WARNINGS: EMPTY moves are used to hold the place of eliminated *
* commands. Also, NEVER call this routine with a list that *
* contains illegal commands. The list MUST be terminated *
* with a EOL command *
* *
* HISTORY: *
* 07/08/1991 CY : Created. *
* 06/01/1992 JLB : Optimized and commented. *
*=============================================================================================*/
#define EMPTY (FacingType)-2
int FootClass::Optimize_Moves(PathType * path, MoveType threshhold)
//int Optimize_Moves(PathType *path, int (*callback)(CELL, FacingType), int threshold)
{
/*
** Facing command pair adjustment table. Compare the facing difference between
** the two commands. 0 means no optimization is possible. 3 means backtracking
** so eliminate both commands. Any other value adjusts the first command facing.
*/
#ifdef DIAGONAL
static FacingType _trans[FACING_COUNT] = {(FacingType)0, (FacingType)0, (FacingType)1, (FacingType)2, (FacingType)3, (FacingType)-2, (FacingType)-1, (FacingType)0}; // Smoothing.
#else
static FacingType _trans[FACING_COUNT] = {(FacingType)0, (FacingType)0, (FacingType)0, (FacingType)2, (FacingType)3, (FacingType)-2, (FacingType)0, (FacingType)0};
#endif
FacingType * cmd1, // Floating first command pointer.
* cmd2, // Floating second command pointer.
newcmd; // Calculated new optimized command.
FacingType newdir; // Tentative new direction for smoothing.
CELL cell; // Working cell (as it moves along path).
/*
** Abort if there is any illegal parameter.
*/
if (!path || !path->Command) return(0);
/*
** Optimization loop -- start scanning with the
** first pair of commands (if there are at least two
** in the command list).
*/
path->Command[path->Length] = END; // Force end of list.
if (path->Length == 0) return(0);
cell = path->Start;
if (path->Length > 1) {
cmd2 = path->Command + 1;
while (*cmd2 != END) {
/*
** Set the cmd1 pointer to point to the valid command closest, but
** previous to cmd2. Be sure not to go previous to the head of the
** command list.
*/
cmd1 = cmd2-1;
while (*cmd1 == EMPTY && cmd1 != path->Command) {
cmd1--;
}
/*
** If there isn't any valid previous command, then bump the
** cmd pointers to the next command pair and continue...
*/
if (*cmd1 == EMPTY) {
cmd2++;
continue;
}
/*
** Fetch precalculated command change value. 0 means leave
** command set alone, 3 means backtrack and eliminate two
** commands. Any other value is new direction and eliminate
** one command.
*/
newcmd = (FacingType)(*cmd2 - *cmd1);
if (newcmd < FACING_N) newcmd = (FacingType)(newcmd + FACING_COUNT);
newcmd = _trans[newcmd];
/*
** Check for backtracking. If this occurs, then eliminate the
** two commands. This is the easiest optimization.
*/
if (newcmd == FACING_SE) {
*cmd1 = EMPTY;
*cmd2++ = EMPTY;
continue;
}
/*
** If an optimization code was found the process it. The command is a facing
** offset to more directly travel toward the immediate destination cell.
*/
if (newcmd) {
/*
** Optimizations differ when dealing with diagonals. Especially when dealing
** with diagonals of 90 degrees. In such a case, 90 degree optimizations can
** only be optimized if the intervening cell is passable. The distance travelled
** is the same, but the path is less circuitous.
*/
if (*cmd1 & FACING_NE) {
/*
** Diagonal optimizations are always only 45
** degree adjustments.
*/
newdir = Next_Direction(*cmd1, (newcmd < FACING_N) ? (FacingType)-1 : (FacingType)1);
/*
** Diagonal 90 degree changes can be smoothed, although
** the path isn't any shorter.
*/
if (ABS((int)newcmd) == 1) {
if (Passable_Cell(Adjacent_Cell(cell, newdir), newdir, -1, threshhold)) {
*cmd2 = newdir;
*cmd1 = newdir;
}
// BOB 16.12.92
cell = Adjacent_Cell(cell, *cmd1);
cmd2++;
continue;
}
} else {
newdir = Next_Direction(*cmd1, newcmd);
}
/*
** Allow shortening turn only on right angle moves that are based on
** 90 degrees. Always allow 135 degree optimizations.
*/
*cmd2 = newdir;
*cmd1 = EMPTY;
/*
** Backup what it thinks is the current cell.
*/
while (*cmd1 == EMPTY && cmd1 != path->Command) {
cmd1--;
}
if (*cmd1 != EMPTY) {
cell = Adjacent_Cell(cell, Next_Direction(*cmd1, FACING_S));
} else {
cell = path->Start;
}
continue;
}
/*
** Since we could not make an optimization, we move our
** head pointer forward.
*/
cell = Adjacent_Cell(cell, *cmd1);
cmd2++;
}
}
/*
** Pack the command list to remove any EMPTY command entries.
*/
cmd1 = path->Command;
cmd2 = path->Command;
cell = path->Start;
path->Cost = 0;
path->Length = 0;
while (*cmd2 != END) {
if (*cmd2 != EMPTY) {
cell = Adjacent_Cell(cell, *cmd2);
path->Cost+= Passable_Cell(cell, *cmd2, -1, threshhold);
path->Length++;
*cmd1++ = *cmd2;
}
cmd2++;
}
path->Length++;
*cmd1 = END;
return(path->Length);
}
CELL FootClass::Safety_Point(CELL src, CELL dst, int start, int max)
{
FacingType dir;
CELL next;
int lp;
dir = (FacingType)(CELL_FACING(src, dst) ^ 4) - 1;
/*
** Loop through the different acceptable distances.
*/
for (int dist = start; dist < max; dist ++) {
/*
** Move to the starting location.
*/
next = dst;
for (lp = 0; lp < dist; lp ++) {
next = Adjacent_Cell(next, dir);
}
if (dir & 1) {
/*
** If our direction is diagonal than we need to check
** only one side which is as long as both of the old sides
** together.
*/
for (lp = 0; lp < dist << 1; lp ++) {
next = Adjacent_Cell(next, dir + 3);
if (!Can_Enter_Cell(next)) {
return(next);
}
}
} else {
/*
** If our direction is not diagonal than we need to check two
** sides so that we are checking a corner like location.
*/
for (lp = 0; lp < dist; lp ++) {
next = Adjacent_Cell(next, dir + 2);
if (!Can_Enter_Cell(next)) {
return(next);
}
}
for (lp = 0; lp < dist; lp ++) {
next = Adjacent_Cell(next, dir + 4);
if (!Can_Enter_Cell(next)) {
return(next);
}
}
}
}
return(-1);
}
int FootClass::Passable_Cell(CELL cell, FacingType face, int threat, MoveType threshhold)
{
MoveType move = Can_Enter_Cell(cell, face);
if (move < MOVE_MOVING_BLOCK && Distance(Cell_Coord(cell)) > 0x0100) threshhold = MOVE_MOVING_BLOCK;
if (move > threshhold) return(0);
if (Session.Type == GAME_NORMAL) {
if (threat != -1) {
if (::Distance(Cell_Coord(cell), Cell_Coord(DestLocation)) > (THREAT_THRESHOLD * CELL_LEPTON_W)) {
// if (Map.Cell_Distance(cell, DestLocation) > THREAT_THRESHOLD) {
if (Map.Cell_Threat(cell, Owner()) > threat)
return(0);
}
}
}
static int _value[MOVE_COUNT] = {
1, // MOVE_OK
1, // MOVE_CLOAK
3, // MOVE_MOVING_BLOCK
8, // MOVE_DESTROYABLE
10, // MOVE_TEMP
0 // MOVE_NO
};
return(_value[move]);
}
Reference in New Issue View Git Blame Copy Permalink