mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-18 07:39:08 +00:00
3091 lines
84 KiB
C++
3091 lines
84 KiB
C++
/* Copyright (C) 1994-2003 Revolution Software Ltd
|
|
*
|
|
* This program 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 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* $Header$
|
|
*/
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
// ROUTER.CPP by James
|
|
|
|
// A rehash of Jeremy's original jrouter.c, containing low-level system routines
|
|
// for calculating routes between points inside a walk-grid, and constructing
|
|
// walk animations from mega-sets.
|
|
|
|
// jrouter.c undwent 2 major reworks from the original:
|
|
// (1) Restructured to allow more flexibility in the mega-sets, ie. more info taken from the walk-data
|
|
// - the new George & Nico mega-sets & walk-data were then tested & tweaked in the Sword1 system
|
|
// (2) Updated for the new Sword2 system, ie. new object structures
|
|
// - now compatible with Sword2, the essential code already having been tested
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
|
|
/****************************************************************************
|
|
* JROUTER.C polygon router with modular walks
|
|
* using a tree of modules
|
|
* 21 july 94
|
|
* 3 november 94
|
|
* System currently works by scanning grid data and coming up with a ROUTE
|
|
* as a series of way points(nodes), the smoothest eight directional PATH
|
|
* through these nodes is then found, and a WALK created to fit the PATH.
|
|
*
|
|
* Two funtions are called by the user, RouteFinder creates a route as a
|
|
* module list, HardWalk creates an animation list from the module list.
|
|
* The split is only provided to allow the possibility of turning the
|
|
* autorouter over two game cycles.
|
|
****************************************************************************
|
|
*
|
|
* Routine timings on osborne 486
|
|
*
|
|
* Read floor resource (file already loaded) 112 pixels
|
|
*
|
|
* Read mega resource (file already loaded) 112 pixels
|
|
*
|
|
*
|
|
*
|
|
****************************************************************************
|
|
*
|
|
* Modified 12 Oct 95
|
|
*
|
|
* Target Points within 1 pixel of a line are ignored ???
|
|
*
|
|
* Modules split into Points within 1 pixel of a line are ignored ???
|
|
*
|
|
****************************************************************************
|
|
*
|
|
* TOTALLY REHASHED BY JAMES FOR NEW MEGAS USING OLD SYSTEM
|
|
* THEN REINCARNATED BY JAMES FOR NEW MEGAS USING NEW SYSTEM
|
|
*
|
|
****************************************************************************
|
|
****************************************************************************/
|
|
|
|
|
|
//#define PLOT_PATHS 1
|
|
|
|
|
|
/*
|
|
* Include Files
|
|
*/
|
|
|
|
|
|
#include "stdafx.h"
|
|
#include "driver/driver96.h"
|
|
#include "console.h"
|
|
#include "debug.h"
|
|
#include "defs.h"
|
|
#include "header.h"
|
|
#include "interpreter.h"
|
|
#include "memory.h"
|
|
#include "object.h"
|
|
#include "resman.h"
|
|
#include "router.h"
|
|
|
|
//#ifdef PLOT_PATHS
|
|
//#include "grengine.h"
|
|
//#endif
|
|
|
|
#define MAX_FRAMES_PER_CYCLE 16
|
|
#define NO_DIRECTIONS 8
|
|
#define MAX_FRAMES_PER_CHAR (MAX_FRAMES_PER_CYCLE * NO_DIRECTIONS)
|
|
#define ROUTE_END_FLAG 255
|
|
|
|
|
|
|
|
|
|
//---------------------------------------
|
|
// TEMP!
|
|
int8 forceSlidy; // 1 = force the use of slidy router (so solid path not used when ending walk in ANY direction)
|
|
//---------------------------------------
|
|
|
|
/*
|
|
* Type Defines
|
|
*/
|
|
|
|
#define O_WALKANIM_SIZE 600 // max number of nodes in router output
|
|
#define O_GRID_SIZE 200 // max 200 lines & 200 points
|
|
#define EXTRA_GRID_SIZE 20 // max 20 lines & 20 points
|
|
#define O_ROUTE_SIZE 50 // max number of modules in a route
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int16 x1;
|
|
int16 y1;
|
|
int16 x2;
|
|
int16 y2;
|
|
int16 xmin;
|
|
int16 ymin;
|
|
int16 xmax;
|
|
int16 ymax;
|
|
int16 dx; // x2 - x1
|
|
int16 dy; // y2 - y1
|
|
int32 co; // co = (y1 *dx)- (x1*dy) from an equation for a line y*dx = x*dy + co
|
|
}_barData;
|
|
|
|
typedef struct
|
|
{
|
|
int16 x;
|
|
int16 y;
|
|
int16 level;
|
|
int16 prev;
|
|
int16 dist;
|
|
}_nodeData;
|
|
|
|
typedef struct
|
|
{
|
|
int32 nbars;
|
|
_barData *bars;
|
|
int32 nnodes;
|
|
_nodeData *node;
|
|
} _floorData;
|
|
|
|
typedef struct
|
|
{
|
|
int32 x;
|
|
int32 y;
|
|
int32 dirS;
|
|
int32 dirD;
|
|
} _routeData;
|
|
|
|
typedef struct
|
|
{
|
|
int32 x;
|
|
int32 y;
|
|
int32 dir;
|
|
int32 num;
|
|
} _pathData;
|
|
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
//--------------------------------------------------------------------------------------
|
|
// Function prototypes
|
|
|
|
int32 GetRoute(void);
|
|
void ExtractRoute(void);
|
|
void LoadWalkGrid(void);
|
|
void SetUpWalkGrid(Object_mega *ob_mega, int32 x, int32 y, int32 dir);
|
|
void LoadWalkData(Object_walkdata *ob_walkdata);
|
|
void PlotCross(int16 x, int16 y, uint8 colour);
|
|
|
|
int32 Scan(int32);
|
|
int32 NewCheck(int32, int32 , int32 , int32 , int32);
|
|
int32 LineCheck(int32 , int32 , int32 , int32);
|
|
int32 VertCheck(int32 , int32 , int32);
|
|
int32 HorizCheck(int32 , int32 , int32);
|
|
int32 Check(int32 , int32 , int32 , int32);
|
|
int32 CheckTarget(int32 , int32);
|
|
|
|
int32 SmoothestPath();
|
|
int32 SlidyPath();
|
|
int32 SolidPath();
|
|
|
|
int32 SmoothCheck(int32 best, int32 p, int32 dirS, int32 dirD);
|
|
|
|
int32 AddSlowInFrames(_walkData *walkAnim);
|
|
void AddSlowOutFrames(_walkData *walkAnim);
|
|
void SlidyWalkAnimator(_walkData *walkAnim);
|
|
int32 SolidWalkAnimator(_walkData *walkAnim);
|
|
void RouteLine(int32 x1,int32 y1,int32 x2,int32 y2 ,int32 colour);
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
#define MAX_WALKGRIDS 10
|
|
|
|
int32 walkGridList[MAX_WALKGRIDS];
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
#define TOTAL_ROUTE_SLOTS 2 // because we only have 2 megas in the game!
|
|
|
|
mem *route_slots[TOTAL_ROUTE_SLOTS]; // stores pointers to mem blocks containing routes created & used by megas (NULL if slot not in use)
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
// Local Variables
|
|
|
|
static int32 nbars;
|
|
static int32 nnodes;
|
|
static _barData bars[O_GRID_SIZE+EXTRA_GRID_SIZE]; // because extra bars will be copied into here afer walkgrid loaded
|
|
static _nodeData node[O_GRID_SIZE+EXTRA_GRID_SIZE];
|
|
|
|
// area for extra route data to block parts of floors and enable routing round mega charaters
|
|
static int32 nExtraBars = 0;
|
|
static int32 nExtraNodes = 0;
|
|
static _barData extraBars[EXTRA_GRID_SIZE];
|
|
static _nodeData extraNode[EXTRA_GRID_SIZE];
|
|
|
|
static int32 startX;
|
|
static int32 startY;
|
|
static int32 startDir;
|
|
static int32 targetX;
|
|
static int32 targetY;
|
|
static int32 targetDir;
|
|
static int32 scaleA;
|
|
static int32 scaleB;
|
|
static _routeData route[O_ROUTE_SIZE];
|
|
static _pathData smoothPath[O_ROUTE_SIZE];
|
|
static _pathData modularPath[O_ROUTE_SIZE];
|
|
static int32 routeLength;
|
|
|
|
|
|
int32 framesPerStep;
|
|
int32 framesPerChar;
|
|
|
|
uint8 nWalkFrames; // no. of frames per walk cycle
|
|
uint8 usingStandingTurnFrames; // any standing turn frames?
|
|
uint8 usingWalkingTurnFrames; // any walking turn frames?
|
|
uint8 usingSlowInFrames; // any slow-in frames?
|
|
uint8 usingSlowOutFrames; // any slow-out frames?
|
|
int32 dx[NO_DIRECTIONS + MAX_FRAMES_PER_CHAR];
|
|
int32 dy[NO_DIRECTIONS + MAX_FRAMES_PER_CHAR];
|
|
int8 modX[NO_DIRECTIONS];
|
|
int8 modY[NO_DIRECTIONS];
|
|
int32 diagonalx = 0;
|
|
int32 diagonaly = 0;
|
|
|
|
int32 firstStandFrame;
|
|
|
|
int32 firstStandingTurnLeftFrame;
|
|
int32 firstStandingTurnRightFrame;
|
|
|
|
int32 firstWalkingTurnLeftFrame; // left walking turn
|
|
int32 firstWalkingTurnRightFrame; // right walking turn
|
|
|
|
uint32 firstSlowInFrame[NO_DIRECTIONS];
|
|
uint32 numberOfSlowInFrames[NO_DIRECTIONS];
|
|
|
|
uint32 leadingLeg[NO_DIRECTIONS];
|
|
|
|
int32 firstSlowOutFrame;
|
|
int32 numberOfSlowOutFrames; // number of slow-out frames on for each leading-leg in each direction
|
|
|
|
|
|
int32 stepCount;
|
|
|
|
int32 moduleX;
|
|
int32 moduleY;
|
|
int32 currentDir;
|
|
int32 lastCount;
|
|
int32 frame;
|
|
|
|
// ie. total number of slow-out frames = (numberOfSlowOutFrames * 2 * NO_DIRECTIONS)
|
|
|
|
/*
|
|
* CODE
|
|
*/
|
|
|
|
// **************************************************************************
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
//--------------------------------------------------------------------------------------
|
|
uint8 CheckForCollision(void)
|
|
{
|
|
// static uint32 player_pc;
|
|
// static uint32 non_player_pc;
|
|
|
|
|
|
uint8 collision=0;
|
|
|
|
return (collision);
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
uint8 ReturnSlotNo(uint32 megaId)
|
|
{
|
|
if (ID==CUR_PLAYER_ID) // George (8)
|
|
return(0);
|
|
else // One of Nico's mega id's
|
|
return(1);
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
void AllocateRouteMem(void)
|
|
{
|
|
// uint8 slotNo=0;
|
|
uint8 slotNo;
|
|
|
|
//------------------------------------------
|
|
// removed (James23June96)
|
|
/*
|
|
while (route_slots[slotNo] > 0)
|
|
{
|
|
slotNo++;
|
|
|
|
#ifdef _BS2_DEBUG
|
|
if (slotNo == TOTAL_ROUTE_SLOTS)
|
|
Con_fatal_error("ERROR: route_slots[] full in AllocateRouteMem() (%s line %u)",__FILE__,__LINE__);
|
|
#endif
|
|
}
|
|
*/
|
|
//------------------------------------------
|
|
// added (James23June96)
|
|
// Player character always always slot 0, while the other mega (normally Nico) always uses slot 1
|
|
// Better this way, so that if mega object removed from memory while in middle of route,
|
|
// the old route will be safely cleared from memory just before they create a new one
|
|
|
|
slotNo = ReturnSlotNo(ID);
|
|
|
|
// if this slot is already used, then it can't be needed any more
|
|
// because this id is creating a new route!
|
|
if (route_slots[slotNo])
|
|
{
|
|
FreeRouteMem();
|
|
}
|
|
//------------------------------------------
|
|
|
|
route_slots[slotNo] = Twalloc( 4800, MEM_locked, UID_walk_anim );
|
|
// 12000 bytes were used for this in Sword1 mega compacts, based on 20 bytes per '_walkData' frame
|
|
// ie. allowing for 600 frames including end-marker
|
|
// Now '_walkData' is 8 bytes, so 8*600 = 4800 bytes.
|
|
// Note that a 600 frame walk lasts about 48 seconds! (600fps / 12.5s = 48s)
|
|
|
|
// megaObject->route_slot_id = slotNo+1; // mega keeps note of which slot contains the pointer to it's walk animation mem block
|
|
// +1 so that '0' can mean "not walking"
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
_walkData* LockRouteMem(void)
|
|
{
|
|
uint8 slotNo = ReturnSlotNo(ID);
|
|
|
|
Lock_mem( route_slots[slotNo] );
|
|
return (_walkData *)route_slots[slotNo]->ad;
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
void FloatRouteMem(void)
|
|
{
|
|
uint8 slotNo = ReturnSlotNo(ID);
|
|
|
|
Float_mem( route_slots[slotNo] );
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
void FreeRouteMem(void)
|
|
{
|
|
uint8 slotNo = ReturnSlotNo(ID);
|
|
|
|
Free_mem( route_slots[slotNo] ); // free the mem block pointed to from this entry of route_slots[]
|
|
route_slots[slotNo] = NULL; // clear this route_slots[] entry
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
void FreeAllRouteMem(void)
|
|
{
|
|
uint8 slotNo;
|
|
|
|
for (slotNo=0; slotNo < TOTAL_ROUTE_SLOTS; slotNo++)
|
|
{
|
|
if (route_slots[slotNo])
|
|
{
|
|
Free_mem( route_slots[slotNo] ); // free the mem block pointed to from this entry of route_slots[]
|
|
route_slots[slotNo] = NULL;
|
|
}
|
|
}
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
// **************************************************************************
|
|
// **************************************************************************
|
|
// **************************************************************************
|
|
// **************************************************************************
|
|
|
|
int32 RouteFinder(Object_mega *ob_mega, Object_walkdata *ob_walkdata, int32 x, int32 y, int32 dir)
|
|
{
|
|
/****************************************************************************
|
|
* RouteFinder.C polygon router with modular walks
|
|
* 21 august 94
|
|
* 3 november 94
|
|
* RouteFinder creates a list of modules that enables HardWalk to create
|
|
* an animation list.
|
|
*
|
|
* RouteFinder currently works by scanning grid data and coming up with a ROUTE
|
|
* as a series of way points(nodes), the smoothest eight directional PATH
|
|
* through these nodes is then found, this information is made available to
|
|
* HardWalk for a WALK to be created to fit the PATH.
|
|
*
|
|
* 30 november 94 return values modified
|
|
*
|
|
* return 0 = failed to find a route
|
|
*
|
|
* 1 = found a route
|
|
*
|
|
* 2 = mega already at target
|
|
*
|
|
****************************************************************************/
|
|
|
|
int32 routeFlag = 0;
|
|
int32 solidFlag = 0;
|
|
_walkData *walkAnim;
|
|
|
|
// megaId = id;
|
|
|
|
|
|
SetUpWalkGrid(ob_mega, x, y, dir);
|
|
LoadWalkData(ob_walkdata);
|
|
|
|
walkAnim = LockRouteMem(); // lock the _walkData array (NB. AFTER loading walkgrid & walkdata!)
|
|
|
|
// **************************************************************************
|
|
// All route data now loaded start finding a route
|
|
// **************************************************************************
|
|
// **************************************************************************
|
|
// Check if we can get a route through the floor changed 12 Oct95 JPS
|
|
// **************************************************************************
|
|
|
|
routeFlag = GetRoute();
|
|
|
|
|
|
if (routeFlag == 2) //special case for zero length route
|
|
{
|
|
if (targetDir >7)// if target direction specified as any
|
|
{
|
|
targetDir = startDir;
|
|
}
|
|
// just a turn on the spot is required set an end module for the route let the animator deal with it
|
|
// modularPath is normally set by ExtractRoute
|
|
modularPath[0].dir = startDir;
|
|
modularPath[0].num = 0;
|
|
modularPath[0].x = startX;
|
|
modularPath[0].y = startY;
|
|
modularPath[1].dir = targetDir;
|
|
modularPath[1].num = 0;
|
|
modularPath[1].x = startX;
|
|
modularPath[1].y = startY;
|
|
modularPath[2].dir = 9;
|
|
modularPath[2].num = ROUTE_END_FLAG;
|
|
|
|
SlidyWalkAnimator(walkAnim);
|
|
routeFlag = 2;
|
|
}
|
|
else if (routeFlag == 1) // a normal route
|
|
{
|
|
SmoothestPath();//Converts the route to an exact path
|
|
// The Route had waypoints and direction options
|
|
// The Path is an exact set of lines in 8 directions that reach the target.
|
|
// The path is in module format, but steps taken in each direction are not accurate
|
|
// if target dir = 8 then the walk isn't linked to an anim so
|
|
// we can create a route without sliding and miss the exact target
|
|
|
|
if (!forceSlidy)
|
|
{
|
|
if (targetDir == 8) // can end facing ANY direction (ie. exact end position not vital) - so use SOLID walk to avoid sliding to exact position
|
|
{
|
|
SolidPath();
|
|
solidFlag = SolidWalkAnimator(walkAnim);
|
|
}
|
|
}
|
|
|
|
if(!solidFlag) // if we failed to create a SOLID route, do a SLIDY one instead
|
|
{
|
|
SlidyPath();
|
|
SlidyWalkAnimator(walkAnim);
|
|
}
|
|
}
|
|
else // Route didn't reach target so assume point was off the floor
|
|
{
|
|
// routeFlag = 0;
|
|
}
|
|
|
|
|
|
#ifdef PLOT_PATHS
|
|
#ifdef _WIN32
|
|
RenderScreenGDK( screenDef.buffer, scroll_offset_x, scroll_offset_y, screenDef.width * XBLOCKSIZE );
|
|
#else
|
|
RenderOffScreenBuffer( scroll_offset_x, scroll_offset_y, SCREEN_WIDTH, SCREEN_DEPTH );
|
|
#endif
|
|
FlipScreens();
|
|
|
|
FlushMouseEvents(); // clear mouse buffer
|
|
while (!TestForMouseEvent()); // wait for a button press or release
|
|
FlushMouseEvents(); // clear mouse buffer again to prevent rapid fire!
|
|
#endif
|
|
|
|
|
|
FloatRouteMem(); // float the _walkData array again
|
|
|
|
return routeFlag; // send back null route
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*******************************************************************************
|
|
* GET A ROUTE
|
|
*******************************************************************************
|
|
*******************************************************************************/
|
|
|
|
|
|
int32 GetRoute(void)
|
|
{
|
|
/****************************************************************************
|
|
* GetRoute.C extract a path from walk grid
|
|
* 12 october 94
|
|
*
|
|
* GetRoute currently works by scanning grid data and coming up with a ROUTE
|
|
* as a series of way points(nodes).
|
|
* static _routeData route[O_ROUTE_SIZE];
|
|
*
|
|
* return 0 = failed to find a route
|
|
*
|
|
* 1 = found a route
|
|
*
|
|
* 2 = mega already at target
|
|
*
|
|
* 3 = failed to find a route because target was on a line
|
|
*
|
|
****************************************************************************/
|
|
int32 routeGot = 0;
|
|
int32 level;
|
|
int32 changed;
|
|
|
|
if ((startX == targetX) && (startY == targetY))
|
|
routeGot = 2;
|
|
|
|
else // 'else' added by JEL (23jan96) otherwise 'routeGot' affected even when already set to '2' above - causing some 'turns' to walk downwards on the spot
|
|
routeGot = CheckTarget(targetX,targetY);// returns 3 if target on a line ( +- 1 pixel )
|
|
|
|
|
|
if (routeGot == 0) //still looking for a route check if target is within a pixel of a line
|
|
{
|
|
// scan through the nodes linking each node to its nearest neighbour until no more nodes change
|
|
// This is the routine that finds a route using Scan()
|
|
level = 1;
|
|
do
|
|
{
|
|
changed = Scan(level);
|
|
level =level + 1;
|
|
}
|
|
while(changed == 1);
|
|
|
|
// Check to see if the route reached the target
|
|
if (node[nnodes].dist < 9999)
|
|
{
|
|
routeGot = 1;
|
|
ExtractRoute(); // it did so extract the route as nodes and the directions to go between each node
|
|
// route.X,route.Y and route.Dir now hold all the route infomation with the target dir or route continuation
|
|
}
|
|
}
|
|
|
|
return routeGot;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*******************************************************************************
|
|
* THE SLIDY PATH ROUTINES
|
|
*******************************************************************************
|
|
*******************************************************************************/
|
|
|
|
|
|
int32 SmoothestPath()
|
|
{
|
|
/*
|
|
* This is the second big part of the route finder and the the only bit that tries to be clever
|
|
* (the other bits are clever).
|
|
* This part of the autorouter creates a list of modules from a set of lines running across the screen
|
|
* The task is complicated by two things;
|
|
* Firstly in choosing a route through the maze of nodes the routine tries to minimise the amount of each
|
|
* individual turn avoiding 90 degree and greater turns (where possible) and reduces the total number of
|
|
* turns (subject to two 45 degree turns being better than one 90 degree turn).
|
|
* Secondly when walking in a given direction the number of steps required to reach the end of that run
|
|
* is not calculated accurately. This is because I was unable to derive a function to relate number of
|
|
* steps taken between two points to the shrunken step size
|
|
*
|
|
*/
|
|
int32 p;
|
|
int32 dirS;
|
|
int32 dirD;
|
|
int32 dS;
|
|
int32 dD;
|
|
int32 dSS;
|
|
int32 dSD;
|
|
int32 dDS;
|
|
int32 dDD;
|
|
int32 SS;
|
|
int32 SD;
|
|
int32 DS;
|
|
int32 DD;
|
|
int32 i;
|
|
int32 j;
|
|
int32 temp;
|
|
int32 steps;
|
|
int32 option;
|
|
int32 options;
|
|
int32 lastDir;
|
|
int32 nextDirS;
|
|
int32 nextDirD;
|
|
int32 tempturns[4];
|
|
int32 turns[4];
|
|
int32 turntable[NO_DIRECTIONS] = {0,1,3,5,7,5,3,1};
|
|
|
|
// route.X route.Y and route.Dir start at far end
|
|
smoothPath[0].x = startX;
|
|
smoothPath[0].y = startY;
|
|
smoothPath[0].dir = startDir;
|
|
smoothPath[0].num = 0;
|
|
p = 0;
|
|
lastDir = startDir;
|
|
// for each section of the route
|
|
do
|
|
{
|
|
|
|
dirS = route[p].dirS;
|
|
dirD = route[p].dirD;
|
|
nextDirS = route[p+1].dirS;
|
|
nextDirD = route[p+1].dirD;
|
|
|
|
// Check directions into and out of a pair of nodes
|
|
// going in
|
|
dS = dirS - lastDir;
|
|
if ( dS < 0)
|
|
dS = dS + NO_DIRECTIONS;
|
|
|
|
dD = dirD - lastDir;
|
|
if ( dD < 0)
|
|
dD = dD + NO_DIRECTIONS;
|
|
|
|
// coming out
|
|
dSS = dirS - nextDirS;
|
|
if ( dSS < 0)
|
|
dSS = dSS + NO_DIRECTIONS;
|
|
|
|
dDD = dirD - nextDirD;
|
|
if ( dDD < 0)
|
|
dDD = dDD + NO_DIRECTIONS;
|
|
|
|
dSD = dirS - nextDirD;
|
|
if ( dSD < 0)
|
|
dSD = dSD + NO_DIRECTIONS;
|
|
|
|
dDS = dirD - nextDirS;
|
|
if ( dDS < 0)
|
|
dDS = dDS + NO_DIRECTIONS;
|
|
|
|
// Determine the amount of turning involved in each possible path
|
|
dS = turntable[dS];
|
|
dD = turntable[dD];
|
|
dSS = turntable[dSS];
|
|
dDD = turntable[dDD];
|
|
dSD = turntable[dSD];
|
|
dDS = turntable[dDS];
|
|
// get the best path out ie assume next section uses best direction
|
|
if (dSD < dSS)
|
|
{
|
|
dSS = dSD;
|
|
}
|
|
if (dDS < dDD)
|
|
{
|
|
dDD = dDS;
|
|
}
|
|
// rate each option
|
|
SS = dS + dSS + 3; // Split routes look crap so weight against them
|
|
SD = dS + dDD;
|
|
DS = dD + dSS;
|
|
DD = dD + dDD + 3;
|
|
// set up turns as a sorted array of the turn values
|
|
tempturns[0] = SS;
|
|
turns[0] = 0;
|
|
tempturns[1] = SD;
|
|
turns[1] = 1;
|
|
tempturns[2] = DS;
|
|
turns[2] = 2;
|
|
tempturns[3] = DD;
|
|
turns[3] = 3;
|
|
i = 0;
|
|
do
|
|
{
|
|
j = 0;
|
|
do
|
|
{
|
|
if (tempturns[j] > tempturns[j + 1])
|
|
{
|
|
temp = turns[j];
|
|
turns[j] = turns[j+1];
|
|
turns[j+1] = temp;
|
|
temp = tempturns[j];
|
|
tempturns[j] = tempturns[j+1];
|
|
tempturns[j+1] = temp;
|
|
}
|
|
j = j + 1;
|
|
}
|
|
while (j < 3);
|
|
i = i + 1;
|
|
}
|
|
while (i < 3);
|
|
|
|
// best option matched in order of the priority we would like to see on the screen
|
|
// but each option must be checked to see if it can be walked
|
|
|
|
options = NewCheck(1, route[p].x, route[p].y, route[p + 1].x, route[p + 1].y);
|
|
|
|
#ifdef _BS2_DEBUG
|
|
if (options == 0)
|
|
{
|
|
Zdebug("BestTurns fail %d %d %d %d",route[p].x, route[p].y, route[p + 1].x, route[p + 1].y);
|
|
Zdebug("BestTurns fail %d %d %d %d",turns[0],turns[1],turns[2],options);
|
|
Con_fatal_error("BestTurns failed (%s line %u)",__FILE__,__LINE__);
|
|
}
|
|
#endif
|
|
|
|
i = 0;
|
|
steps = 0;
|
|
do
|
|
{
|
|
option = 1 << turns[i];
|
|
if (option & options)
|
|
steps = SmoothCheck(turns[i],p,dirS,dirD);
|
|
i = i + 1;
|
|
}
|
|
while ((steps == 0) && (i < 4));
|
|
|
|
#ifdef PLOT_PATHS // plot the best path
|
|
if (steps != 0)
|
|
{
|
|
i = 0;
|
|
do
|
|
{
|
|
RouteLine(smoothPath[i].x, smoothPath[i].y, smoothPath[i+1].x, smoothPath[i+1].y, 228);
|
|
i = i + 1;
|
|
}
|
|
while (i < steps);
|
|
}
|
|
#endif
|
|
|
|
|
|
#ifdef _BS2_DEBUG
|
|
if (steps == 0)
|
|
{
|
|
Zdebug("BestTurns failed %d %d %d %d",route[p].x, route[p].y, route[p + 1].x, route[p + 1].y);
|
|
Zdebug("BestTurns failed %d %d %d %d",turns[0],turns[1],turns[2],options);
|
|
Con_fatal_error("BestTurns failed (%s line %u)",__FILE__,__LINE__);
|
|
}
|
|
#endif
|
|
|
|
// route.X route.Y route.dir and bestTurns start at far end
|
|
p = p + 1;
|
|
|
|
|
|
}
|
|
while (p < (routeLength));
|
|
// best turns will end heading as near as possible to target dir rest is down to anim for now
|
|
smoothPath[steps].dir = 9;
|
|
smoothPath[steps].num = ROUTE_END_FLAG;
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
|
|
int32 SmoothCheck(int32 best, int32 p, int32 dirS, int32 dirD)
|
|
/****************************************************************************
|
|
* Slip sliding away
|
|
* This path checker checks to see if a walk that exactly follows the path
|
|
* would be valid. This should be inherently true for atleast one of the turn
|
|
* options.
|
|
* No longer checks the data it only creates the smoothPath array JPS
|
|
****************************************************************************/
|
|
{
|
|
static int32 k;
|
|
int32 tempK;
|
|
int32 x;
|
|
int32 y;
|
|
int32 x2;
|
|
int32 y2;
|
|
int32 ldx;
|
|
int32 ldy;
|
|
int32 dsx;
|
|
int32 dsy;
|
|
int32 ddx;
|
|
int32 ddy;
|
|
int32 dirX;
|
|
int32 dirY;
|
|
int32 ss0;
|
|
int32 ss1;
|
|
int32 ss2;
|
|
int32 sd0;
|
|
int32 sd1;
|
|
int32 sd2;
|
|
|
|
|
|
if (p == 0)
|
|
{
|
|
k = 1;
|
|
}
|
|
tempK = 0;
|
|
x = route[p].x;
|
|
y = route[p].y;
|
|
x2 = route[p + 1].x;
|
|
y2 = route[p + 1].y;
|
|
ldx = x2 - x;
|
|
ldy = y2 - y;
|
|
dirX = 1;
|
|
dirY = 1;
|
|
if (ldx < 0)
|
|
{
|
|
ldx = -ldx;
|
|
dirX = -1;
|
|
}
|
|
|
|
if (ldy < 0)
|
|
{
|
|
ldy = -ldy;
|
|
dirY = -1;
|
|
}
|
|
|
|
// set up sd0-ss2 to reflect possible movement in each direction
|
|
if ((dirS == 0) || (dirS == 4))// vert and diag
|
|
{
|
|
ddx = ldx;
|
|
ddy = (ldx*diagonaly)/diagonalx;
|
|
dsy = ldy - ddy;
|
|
ddx = ddx * dirX;
|
|
ddy = ddy * dirY;
|
|
dsy = dsy * dirY;
|
|
dsx = 0;
|
|
|
|
sd0 = (ddx + modX[dirD]/2)/ modX[dirD];
|
|
ss0 = (dsy + modY[dirS]/2) / modY[dirS];
|
|
sd1 = sd0/2;
|
|
ss1 = ss0/2;
|
|
sd2 = sd0 - sd1;
|
|
ss2 = ss0 - ss1;
|
|
}
|
|
else
|
|
{
|
|
ddy = ldy;
|
|
ddx = (ldy*diagonalx)/diagonaly;
|
|
dsx = ldx - ddx;
|
|
ddy = ddy * dirY;
|
|
ddx = ddx * dirX;
|
|
dsx = dsx * dirX;
|
|
dsy = 0;
|
|
|
|
sd0 = (ddy + modY[dirD]/2)/ modY[dirD];
|
|
ss0 = (dsx + modX[dirS]/2)/ modX[dirS];
|
|
sd1 = sd0/2;
|
|
ss1 = ss0/2;
|
|
sd2 = sd0 - sd1;
|
|
ss2 = ss0 - ss1;
|
|
}
|
|
|
|
if (best == 0) //halfsquare, diagonal, halfsquare
|
|
{
|
|
smoothPath[k].x = x+dsx/2;
|
|
smoothPath[k].y = y+dsy/2;
|
|
smoothPath[k].dir = dirS;
|
|
smoothPath[k].num = ss1;
|
|
k = k + 1;
|
|
smoothPath[k].x = x+dsx/2+ddx;
|
|
smoothPath[k].y = y+dsy/2+ddy;
|
|
smoothPath[k].dir = dirD;
|
|
smoothPath[k].num = sd0;
|
|
k = k + 1;
|
|
smoothPath[k].x = x+dsx+ddx;
|
|
smoothPath[k].y = y+dsy+ddy;
|
|
smoothPath[k].dir = dirS;
|
|
smoothPath[k].num = ss2;
|
|
k = k + 1;
|
|
tempK = k;
|
|
}
|
|
else if (best == 1) //square, diagonal
|
|
{
|
|
smoothPath[k].x = x+dsx;
|
|
smoothPath[k].y = y+dsy;
|
|
smoothPath[k].dir = dirS;
|
|
smoothPath[k].num = ss0;
|
|
k = k + 1;
|
|
smoothPath[k].x = x2;
|
|
smoothPath[k].y = y2;
|
|
smoothPath[k].dir = dirD;
|
|
smoothPath[k].num = sd0;
|
|
k = k + 1;
|
|
tempK = k;
|
|
}
|
|
else if (best == 2) //diagonal square
|
|
{
|
|
smoothPath[k].x = x+ddx;
|
|
smoothPath[k].y = y+ddy;
|
|
smoothPath[k].dir = dirD;
|
|
smoothPath[k].num = sd0;
|
|
k = k + 1;
|
|
smoothPath[k].x = x2;
|
|
smoothPath[k].y = y2;
|
|
smoothPath[k].dir = dirS;
|
|
smoothPath[k].num = ss0;
|
|
k = k + 1;
|
|
tempK = k;
|
|
}
|
|
else //halfdiagonal, square, halfdiagonal
|
|
{
|
|
smoothPath[k].x = x+ddx/2;
|
|
smoothPath[k].y = y+ddy/2;
|
|
smoothPath[k].dir = dirD;
|
|
smoothPath[k].num = sd1;
|
|
k = k + 1;
|
|
smoothPath[k].x = x+dsx+ddx/2;
|
|
smoothPath[k].y = y+dsy+ddy/2;
|
|
smoothPath[k].dir = dirS;
|
|
smoothPath[k].num = ss0;
|
|
k = k + 1;
|
|
smoothPath[k].x = x2;
|
|
smoothPath[k].y = y2;
|
|
smoothPath[k].dir = dirD;
|
|
smoothPath[k].num = sd2;
|
|
k = k + 1;
|
|
tempK = k;
|
|
}
|
|
|
|
return tempK;
|
|
}
|
|
|
|
int32 SlidyPath()
|
|
{
|
|
/****************************************************************************
|
|
* SlidyPath creates a path based on part steps with no sliding to get
|
|
* as near as possible to the target without any sliding this routine is
|
|
* currently unused, but is intended for use when just clicking about.
|
|
*
|
|
* produce a module list from the line data
|
|
*
|
|
****************************************************************************/
|
|
int32 smooth;
|
|
int32 slidy;
|
|
int32 scale;
|
|
int32 stepX;
|
|
int32 stepY;
|
|
int32 deltaX;
|
|
int32 deltaY;
|
|
|
|
// strip out the short sections
|
|
slidy = 1;
|
|
smooth = 1;
|
|
modularPath[0].x = smoothPath[0].x;
|
|
modularPath[0].y = smoothPath[0].y;
|
|
modularPath[0].dir = smoothPath[0].dir;
|
|
modularPath[0].num = 0;
|
|
|
|
while (smoothPath[smooth].num < ROUTE_END_FLAG)
|
|
{
|
|
scale = scaleA * smoothPath[smooth].y + scaleB;
|
|
deltaX = smoothPath[smooth].x - modularPath[slidy-1].x;
|
|
deltaY = smoothPath[smooth].y - modularPath[slidy-1].y;
|
|
stepX = modX[smoothPath[smooth].dir];
|
|
stepY = modY[smoothPath[smooth].dir];
|
|
stepX = stepX * scale;
|
|
stepY = stepY * scale;
|
|
stepX = stepX >> 19;// quarter a step minimum
|
|
stepY = stepY >> 19;
|
|
if ((abs(deltaX)>=abs(stepX)) && (abs(deltaY)>=abs(stepY)))
|
|
{
|
|
modularPath[slidy].x = smoothPath[smooth].x;
|
|
modularPath[slidy].y = smoothPath[smooth].y;
|
|
modularPath[slidy].dir = smoothPath[smooth].dir;
|
|
modularPath[slidy].num = 1;
|
|
slidy += 1;
|
|
}
|
|
smooth += 1;
|
|
}
|
|
// in case the last bit had no steps
|
|
if (slidy > 1)
|
|
{
|
|
modularPath[slidy-1].x = smoothPath[smooth-1].x;
|
|
modularPath[slidy-1].y = smoothPath[smooth-1].y;
|
|
}
|
|
// set up the end of the walk
|
|
modularPath[slidy].x = smoothPath[smooth-1].x;
|
|
modularPath[slidy].y = smoothPath[smooth-1].y;
|
|
modularPath[slidy].dir = targetDir;
|
|
modularPath[slidy].num = 0;
|
|
slidy += 1;
|
|
modularPath[slidy].x = smoothPath[smooth-1].x;
|
|
modularPath[slidy].y = smoothPath[smooth-1].y;
|
|
modularPath[slidy].dir = 9;
|
|
modularPath[slidy].num = ROUTE_END_FLAG;
|
|
return 1;
|
|
|
|
}
|
|
|
|
//****************************************************************************
|
|
// SLOW IN
|
|
|
|
int32 AddSlowInFrames(_walkData *walkAnim)
|
|
{
|
|
uint32 slowInFrameNo;
|
|
|
|
|
|
if ((usingSlowInFrames) && (modularPath[1].num > 0))
|
|
{
|
|
for (slowInFrameNo=0; slowInFrameNo<numberOfSlowInFrames[currentDir]; slowInFrameNo++)
|
|
{
|
|
walkAnim[stepCount].frame = firstSlowInFrame[currentDir] + slowInFrameNo;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = currentDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
}
|
|
return(1);
|
|
}
|
|
else
|
|
{
|
|
return(0);
|
|
}
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
void EarlySlowOut(Object_mega *ob_mega, Object_walkdata *ob_walkdata)
|
|
{
|
|
int32 slowOutFrameNo;
|
|
int32 walk_pc;
|
|
_walkData *walkAnim;
|
|
|
|
|
|
//Zdebug("\nEARLY SLOW-OUT");
|
|
|
|
LoadWalkData(ob_walkdata);
|
|
|
|
//Zdebug("********************************");
|
|
//Zdebug("framesPerStep =%d",framesPerStep); // 6;
|
|
//Zdebug("numberOfSlowOutFrames =%d",numberOfSlowOutFrames); // 7;
|
|
//Zdebug("firstWalkingTurnLeftFrame =%d",firstWalkingTurnLeftFrame); // 120;
|
|
//Zdebug("firstWalkingTurnRightFrame =%d",firstWalkingTurnRightFrame); // 216;
|
|
//Zdebug("firstSlowOutFrame =%d",firstSlowOutFrame); // 344;
|
|
//Zdebug("********************************");
|
|
|
|
|
|
walk_pc = ob_mega->walk_pc;
|
|
|
|
walkAnim = LockRouteMem(); // lock the _walkData array (NB. AFTER loading walkgrid & walkdata!)
|
|
|
|
|
|
if (usingSlowOutFrames) // if this mega does actually have slow-out frames
|
|
{
|
|
do // overwrite the next step (half a cycle) of the walk (ie .step - 0..5
|
|
{
|
|
//Zdebug("\nSTEP NUMBER: walkAnim[%d].step = %d",walk_pc,walkAnim[walk_pc].step);
|
|
//Zdebug("ORIGINAL FRAME: walkAnim[%d].frame = %d",walk_pc,walkAnim[walk_pc].frame);
|
|
// map from existing walk frame across to correct frame number of slow-out - remember, there may be more slow-out frames than walk-frames!
|
|
|
|
if (walkAnim[walk_pc].frame >= firstWalkingTurnRightFrame) // if it's a walking turn-right, rather than a normal step
|
|
{
|
|
walkAnim[walk_pc].frame -= firstWalkingTurnRightFrame; // then map it to a normal step frame first
|
|
//Zdebug("MAPPED TO WALK: walkAnim[%d].frame = %d (walking turn-right frame --> walk frame)",walk_pc,walkAnim[walk_pc].frame);
|
|
}
|
|
|
|
else if (walkAnim[walk_pc].frame >= firstWalkingTurnLeftFrame) // if it's a walking turn-left, rather than a normal step
|
|
{
|
|
walkAnim[walk_pc].frame -= firstWalkingTurnLeftFrame; // then map it to a normal step frame first
|
|
//Zdebug("MAPPED TO WALK: walkAnim[%d].frame = %d (walking turn-left frame --> walk frame)",walk_pc,walkAnim[walk_pc].frame);
|
|
}
|
|
|
|
walkAnim[walk_pc].frame += firstSlowOutFrame + ((walkAnim[walk_pc].frame / framesPerStep) * (numberOfSlowOutFrames-framesPerStep));
|
|
walkAnim[walk_pc].step = 0;
|
|
//Zdebug("SLOW-OUT FRAME: walkAnim[%d].frame = %d",walk_pc,walkAnim[walk_pc].frame);
|
|
walk_pc += 1;
|
|
}
|
|
while(walkAnim[walk_pc].step > 0 );
|
|
|
|
//Zdebug("\n");
|
|
|
|
for (slowOutFrameNo=framesPerStep; slowOutFrameNo < numberOfSlowOutFrames; slowOutFrameNo++) // add stationary frame(s) (OPTIONAL)
|
|
{
|
|
walkAnim[walk_pc].frame = walkAnim[walk_pc-1].frame + 1;
|
|
//Zdebug("EXTRA FRAME: walkAnim[%d].frame = %d",walk_pc,walkAnim[walk_pc].frame);
|
|
walkAnim[walk_pc].step = 0;
|
|
walkAnim[walk_pc].dir = walkAnim[walk_pc-1].dir;
|
|
walkAnim[walk_pc].x = walkAnim[walk_pc-1].x;
|
|
walkAnim[walk_pc].y = walkAnim[walk_pc-1].y;
|
|
walk_pc++;
|
|
}
|
|
}
|
|
else // this mega doesn't have slow-out frames
|
|
{
|
|
walkAnim[walk_pc].frame = firstStandFrame + walkAnim[walk_pc-1].dir; // stand in current direction
|
|
walkAnim[walk_pc].step = 0;
|
|
walkAnim[walk_pc].dir = walkAnim[walk_pc-1].dir;
|
|
walkAnim[walk_pc].x = walkAnim[walk_pc-1].x;
|
|
walkAnim[walk_pc].y = walkAnim[walk_pc-1].y;
|
|
walk_pc++;
|
|
}
|
|
|
|
walkAnim[walk_pc].frame = 512; // end of sequence
|
|
walkAnim[walk_pc].step = 99; // so that this doesn't happen again while 'george_walking' is still '2'
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
// SLOW OUT
|
|
|
|
void AddSlowOutFrames(_walkData *walkAnim)
|
|
{
|
|
int32 slowOutFrameNo;
|
|
|
|
|
|
if ((usingSlowOutFrames)&&(lastCount>=framesPerStep)) // if the mega did actually walk, we overwrite the last step (half a cycle) with slow-out frames + add any necessary stationary frames
|
|
{
|
|
// place stop frames here
|
|
// slowdown at the end of the last walk
|
|
|
|
slowOutFrameNo = lastCount - framesPerStep;
|
|
|
|
|
|
//Zdebug("SLOW OUT: slowOutFrameNo(%d) = lastCount(%d) - framesPerStep(%d)",slowOutFrameNo,lastCount,framesPerStep);
|
|
|
|
do // overwrite the last step (half a cycle) of the walk
|
|
{
|
|
// map from existing walk frame across to correct frame number of slow-out - remember, there may be more slow-out frames than walk-frames!
|
|
walkAnim[slowOutFrameNo].frame += firstSlowOutFrame + ((walkAnim[slowOutFrameNo].frame / framesPerStep) * (numberOfSlowOutFrames-framesPerStep));
|
|
walkAnim[slowOutFrameNo].step = 0; // because no longer a normal walk-step
|
|
//Zdebug("walkAnim[%d].frame = %d",slowOutFrameNo,walkAnim[slowOutFrameNo].frame);
|
|
slowOutFrameNo += 1;
|
|
}
|
|
while(slowOutFrameNo < lastCount );
|
|
|
|
for (slowOutFrameNo=framesPerStep; slowOutFrameNo < numberOfSlowOutFrames; slowOutFrameNo++) // add stationary frame(s) (OPTIONAL)
|
|
{
|
|
walkAnim[stepCount].frame = walkAnim[stepCount-1].frame + 1;
|
|
//Zdebug("EXTRA FRAMES: walkAnim[%d].frame = %d",stepCount,walkAnim[stepCount].frame);
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = walkAnim[stepCount-1].dir;
|
|
walkAnim[stepCount].x = walkAnim[stepCount-1].x;
|
|
walkAnim[stepCount].y = walkAnim[stepCount-1].y;
|
|
stepCount += 1;
|
|
}
|
|
}
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
|
|
void SlidyWalkAnimator(_walkData *walkAnim)
|
|
/****************************************************************************
|
|
* Skidding every where HardWalk creates an animation that exactly fits the
|
|
* smoothPath and uses foot slipping to fit whole steps into the route
|
|
* Parameters: georgeg,mouseg
|
|
* Returns: rout
|
|
*
|
|
* produce a module list from the line data
|
|
*
|
|
****************************************************************************/
|
|
{
|
|
static int32 left = 0;
|
|
int32 p;
|
|
int32 lastDir;
|
|
int32 lastRealDir;
|
|
int32 turnDir;
|
|
int32 scale;
|
|
int32 step;
|
|
int32 module;
|
|
int32 moduleEnd;
|
|
int32 module16X;
|
|
int32 module16Y;
|
|
int32 stepX;
|
|
int32 stepY;
|
|
int32 errorX;
|
|
int32 errorY;
|
|
int32 lastErrorX;
|
|
int32 lastErrorY;
|
|
int32 frameCount;
|
|
int32 frames;
|
|
|
|
|
|
p = 0;
|
|
lastDir = modularPath[0].dir;
|
|
currentDir = modularPath[1].dir;
|
|
if (currentDir == NO_DIRECTIONS)
|
|
{
|
|
currentDir = lastDir;
|
|
}
|
|
moduleX = startX;
|
|
moduleY = startY;
|
|
module16X = moduleX << 16;
|
|
module16Y = moduleY << 16;
|
|
stepCount = 0;
|
|
|
|
//****************************************************************************
|
|
// SLIDY
|
|
// START THE WALK WITH THE FIRST STANDFRAME THIS MAY CAUSE A DELAY
|
|
// BUT IT STOPS THE PLAYER MOVING FOR COLLISIONS ARE DETECTED
|
|
//****************************************************************************
|
|
//Zdebug("\nSLIDY: STARTING THE WALK");
|
|
module = framesPerChar + lastDir;
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = lastDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
|
|
//****************************************************************************
|
|
// SLIDY
|
|
// TURN TO START THE WALK
|
|
//****************************************************************************
|
|
//Zdebug("\nSLIDY: TURNING TO START THE WALK");
|
|
// rotate if we need to
|
|
if (lastDir != currentDir)
|
|
{
|
|
// get the direction to turn
|
|
turnDir = currentDir - lastDir;
|
|
if ( turnDir < 0)
|
|
turnDir += NO_DIRECTIONS;
|
|
|
|
if (turnDir > 4)
|
|
turnDir = -1;
|
|
else if (turnDir > 0)
|
|
turnDir = 1;
|
|
|
|
// rotate to new walk direction
|
|
// for george and nico put in a head turn at the start
|
|
if (usingStandingTurnFrames)
|
|
{
|
|
if ( turnDir < 0) // new frames for turn frames 29oct95jps
|
|
{
|
|
module = firstStandingTurnLeftFrame + lastDir;
|
|
}
|
|
else
|
|
{
|
|
module = firstStandingTurnRightFrame + lastDir;
|
|
}
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = lastDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
}
|
|
|
|
// rotate till were facing new dir then go back 45 degrees
|
|
while (lastDir != currentDir)
|
|
{
|
|
lastDir += turnDir;
|
|
if ( turnDir < 0) // new frames for turn frames 29oct95jps
|
|
{
|
|
if ( lastDir < 0)
|
|
lastDir += NO_DIRECTIONS;
|
|
module = firstStandingTurnLeftFrame + lastDir;
|
|
}
|
|
else
|
|
{
|
|
if ( lastDir > 7)
|
|
lastDir -= NO_DIRECTIONS;
|
|
module = firstStandingTurnRightFrame + lastDir;
|
|
}
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = lastDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
}
|
|
// the back 45 degrees bit
|
|
stepCount -= 1;// step back one because new head turn for george takes us past the new dir
|
|
}
|
|
// his head is in the right direction
|
|
lastRealDir = currentDir;
|
|
|
|
//****************************************************************************
|
|
// SLIDY: THE SLOW IN
|
|
|
|
AddSlowInFrames(walkAnim);
|
|
//****************************************************************************
|
|
|
|
//****************************************************************************
|
|
// SLIDY
|
|
// THE WALK
|
|
//****************************************************************************
|
|
|
|
//Zdebug("\nSLIDY: THE WALK");
|
|
|
|
//---------------------------------------------------
|
|
// start the walk on the left or right leg, depending on how the slow-in frames were drawn
|
|
|
|
if (leadingLeg[currentDir]==0) // (0=left; 1=right)
|
|
left = 0; // start the walk on the left leg (ie. at beginning of the first step of the walk cycle)
|
|
else
|
|
left = framesPerStep; // start the walk on the right leg (ie. at beginning of the second step of the walk cycle)
|
|
//---------------------------------------------------
|
|
|
|
|
|
lastCount = stepCount;
|
|
lastDir = 99;// this ensures that we don't put in turn frames for the start
|
|
currentDir = 99;// this ensures that we don't put in turn frames for the start
|
|
do
|
|
{
|
|
while (modularPath[p].num == 0)
|
|
{
|
|
p = p + 1;
|
|
if (currentDir != 99)
|
|
lastRealDir = currentDir;
|
|
lastDir = currentDir;
|
|
lastCount = stepCount;
|
|
}
|
|
//calculate average amount to lose in each step on the way to the next node
|
|
currentDir = modularPath[p].dir;
|
|
if (currentDir < NO_DIRECTIONS)
|
|
{
|
|
module = currentDir * framesPerStep * 2 + left;
|
|
if (left == 0)
|
|
left = framesPerStep;
|
|
else
|
|
left = 0;
|
|
moduleEnd = module + framesPerStep;
|
|
step = 0;
|
|
scale = (scaleA * moduleY + scaleB);
|
|
do
|
|
{
|
|
module16X += dx[module]*scale;
|
|
module16Y += dy[module]*scale;
|
|
moduleX = module16X >> 16;
|
|
moduleY = module16Y >> 16;
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = step; // normally 0,1,2,3,4,5,0,1,2,etc
|
|
walkAnim[stepCount].dir = currentDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
step += 1;
|
|
module += 1;
|
|
}
|
|
while( module < moduleEnd) ;
|
|
stepX = modX[modularPath[p].dir];
|
|
stepY = modY[modularPath[p].dir];
|
|
errorX = modularPath[p].x - moduleX;
|
|
errorX = errorX * stepX;
|
|
errorY = modularPath[p].y - moduleY;
|
|
errorY = errorY * stepY;
|
|
if ((errorX < 0) || (errorY < 0))
|
|
{
|
|
modularPath[p].num = 0; // the end of the path
|
|
// okay those last steps took us past our target but do we want to scoot or moonwalk
|
|
frames = stepCount - lastCount;
|
|
errorX = modularPath[p].x - walkAnim[stepCount-1].x;
|
|
errorY = modularPath[p].y - walkAnim[stepCount-1].y;
|
|
|
|
if (frames > framesPerStep)
|
|
{
|
|
lastErrorX = modularPath[p].x - walkAnim[stepCount-7].x;
|
|
lastErrorY = modularPath[p].y - walkAnim[stepCount-7].y;
|
|
if (stepX==0)
|
|
{
|
|
if (3*abs(lastErrorY) < abs(errorY)) //the last stop was closest
|
|
{
|
|
stepCount -= framesPerStep;
|
|
if (left == 0)
|
|
left = framesPerStep;
|
|
else
|
|
left = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (3*abs(lastErrorX) < abs(errorX)) //the last stop was closest
|
|
{
|
|
stepCount -= framesPerStep;
|
|
if (left == 0)
|
|
left = framesPerStep;
|
|
else
|
|
left = 0;
|
|
}
|
|
}
|
|
}
|
|
errorX = modularPath[p].x - walkAnim[stepCount-1].x;
|
|
errorY = modularPath[p].y - walkAnim[stepCount-1].y;
|
|
// okay we've reached the end but we still have an error
|
|
if (errorX != 0)
|
|
{
|
|
frameCount = 0;
|
|
frames = stepCount - lastCount;
|
|
do
|
|
{
|
|
frameCount += 1;
|
|
walkAnim[lastCount + frameCount - 1].x += errorX*frameCount/frames;
|
|
}
|
|
while(frameCount<frames);
|
|
}
|
|
if (errorY != 0)
|
|
{
|
|
frameCount = 0;
|
|
frames = stepCount - lastCount;
|
|
do
|
|
{
|
|
frameCount += 1;
|
|
walkAnim[lastCount + frameCount-1].y += errorY*frameCount/frames;
|
|
}
|
|
while(frameCount<frames);
|
|
}
|
|
// Now is the time to put in the turn frames for the last turn
|
|
if (frames < framesPerStep)
|
|
currentDir = 99;// this ensures that we don't put in turn frames for this walk or the next
|
|
if (currentDir != 99)
|
|
lastRealDir = currentDir;
|
|
// check each turn condition in turn
|
|
if (((lastDir != 99) && (currentDir != 99)) && (usingWalkingTurnFrames)) // only for george
|
|
{
|
|
lastDir = currentDir - lastDir;//1 and -7 going right -1 and 7 going left
|
|
if (((lastDir == -1) || (lastDir == 7)) || ((lastDir == -2) || (lastDir == 6)))
|
|
{
|
|
// turn at the end of the last walk
|
|
frame = lastCount - framesPerStep;
|
|
do
|
|
{
|
|
walkAnim[frame].frame += firstWalkingTurnLeftFrame; //was 104; //turning left
|
|
frame += 1;
|
|
}
|
|
while(frame < lastCount );
|
|
}
|
|
if (((lastDir == 1) || (lastDir == -7)) || ((lastDir == 2) || (lastDir == -6)))
|
|
{
|
|
// turn at the end of the current walk
|
|
frame = lastCount - framesPerStep;
|
|
do
|
|
{
|
|
walkAnim[frame].frame += firstWalkingTurnRightFrame; // was 200; // turning right
|
|
frame += 1;
|
|
}
|
|
while(frame < lastCount );
|
|
}
|
|
lastDir = currentDir;
|
|
}
|
|
// all turns checked
|
|
|
|
lastCount = stepCount;
|
|
moduleX = walkAnim[stepCount-1].x;
|
|
moduleY = walkAnim[stepCount-1].y;
|
|
module16X = moduleX << 16;
|
|
module16Y = moduleY << 16;
|
|
}
|
|
}
|
|
}
|
|
while (modularPath[p].dir < NO_DIRECTIONS);
|
|
|
|
|
|
|
|
#ifdef _BS2_DEBUG
|
|
if (lastRealDir == 99)
|
|
{
|
|
Con_fatal_error("SlidyWalkAnimatorlast direction error (%s line %u)",__FILE__,__LINE__);
|
|
}
|
|
#endif
|
|
|
|
//****************************************************************************
|
|
// SLIDY: THE SLOW OUT
|
|
AddSlowOutFrames(walkAnim);
|
|
|
|
//****************************************************************************
|
|
// SLIDY
|
|
// TURNS TO END THE WALK ?
|
|
//****************************************************************************
|
|
|
|
// We've done the walk now put in any turns at the end
|
|
|
|
|
|
if (targetDir == 8) // ANY direction -> stand in the last direction
|
|
{
|
|
module = firstStandFrame + lastRealDir;
|
|
targetDir = lastRealDir;
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = lastRealDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
}
|
|
if (targetDir == 9) // 'stance' was non-zero
|
|
{
|
|
if (stepCount == 0)
|
|
{
|
|
module = framesPerChar + lastRealDir;
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = lastRealDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
}
|
|
}
|
|
else if (targetDir != lastRealDir) // rotate to targetDir
|
|
{
|
|
// rotate to target direction
|
|
turnDir = targetDir - lastRealDir;
|
|
if ( turnDir < 0)
|
|
turnDir += NO_DIRECTIONS;
|
|
|
|
if (turnDir > 4)
|
|
turnDir = -1;
|
|
else if (turnDir > 0)
|
|
turnDir = 1;
|
|
|
|
// rotate to target direction
|
|
// for george and nico put in a head turn at the start
|
|
if (usingStandingTurnFrames)
|
|
{
|
|
if ( turnDir < 0) // new frames for turn frames 29oct95jps
|
|
{
|
|
module = firstStandingTurnLeftFrame + lastDir;
|
|
}
|
|
else
|
|
{
|
|
module = firstStandingTurnRightFrame + lastDir;
|
|
}
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = lastRealDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
}
|
|
|
|
// rotate if we need to
|
|
while (lastRealDir != targetDir)
|
|
{
|
|
lastRealDir += turnDir;
|
|
if ( turnDir < 0) // new frames for turn frames 29oct95jps
|
|
{
|
|
if ( lastRealDir < 0)
|
|
lastRealDir += NO_DIRECTIONS;
|
|
module = firstStandingTurnLeftFrame + lastRealDir;
|
|
}
|
|
else
|
|
{
|
|
if ( lastRealDir > 7)
|
|
lastRealDir -= NO_DIRECTIONS;
|
|
module = firstStandingTurnRightFrame + lastRealDir;
|
|
}
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = lastRealDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
}
|
|
module = firstStandFrame + lastRealDir;
|
|
walkAnim[stepCount-1].frame = module;
|
|
}
|
|
else // just stand at the end
|
|
{
|
|
module = firstStandFrame + lastRealDir;
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = lastRealDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
}
|
|
|
|
walkAnim[stepCount].frame = 512;
|
|
walkAnim[stepCount].step = 99;
|
|
stepCount += 1;
|
|
walkAnim[stepCount].frame = 512;
|
|
walkAnim[stepCount].step = 99;
|
|
stepCount += 1;
|
|
walkAnim[stepCount].frame = 512;
|
|
walkAnim[stepCount].step = 99;
|
|
|
|
|
|
//-------------------------------------------
|
|
// write all the frames to "debug.txt"
|
|
|
|
//Zdebug("\nTHE WALKDATA:");
|
|
for (frame=0; frame<=stepCount; frame++)
|
|
{
|
|
//Zdebug("walkAnim[%d].frame=%d",frame,walkAnim[frame].frame);
|
|
}
|
|
//-------------------------------------------
|
|
|
|
|
|
// Zdebug("RouteFinder RouteSize is %d", stepCount);
|
|
return;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*******************************************************************************
|
|
* THE SOLID PATH ROUTINES
|
|
*******************************************************************************
|
|
*******************************************************************************/
|
|
|
|
int32 SolidPath()
|
|
{
|
|
/****************************************************************************
|
|
* SolidPath creates a path based on whole steps with no sliding to get
|
|
* as near as possible to the target without any sliding this routine is
|
|
* currently unused, but is intended for use when just clicking about.
|
|
*
|
|
* produce a module list from the line data
|
|
*
|
|
****************************************************************************/
|
|
int32 smooth;
|
|
int32 solid;
|
|
int32 scale;
|
|
int32 stepX;
|
|
int32 stepY;
|
|
int32 deltaX;
|
|
int32 deltaY;
|
|
|
|
// strip out the short sections
|
|
solid = 1;
|
|
smooth = 1;
|
|
modularPath[0].x = smoothPath[0].x;
|
|
modularPath[0].y = smoothPath[0].y;
|
|
modularPath[0].dir = smoothPath[0].dir;
|
|
modularPath[0].num = 0;
|
|
|
|
do
|
|
{
|
|
scale = scaleA * smoothPath[smooth].y + scaleB;
|
|
deltaX = smoothPath[smooth].x - modularPath[solid-1].x;
|
|
deltaY = smoothPath[smooth].y - modularPath[solid-1].y;
|
|
stepX = modX[smoothPath[smooth].dir];
|
|
stepY = modY[smoothPath[smooth].dir];
|
|
stepX = stepX * scale;
|
|
stepY = stepY * scale;
|
|
stepX = stepX >> 16;
|
|
stepY = stepY >> 16;
|
|
if ((abs(deltaX)>=abs(stepX)) && (abs(deltaY)>=abs(stepY)))
|
|
{
|
|
modularPath[solid].x = smoothPath[smooth].x;
|
|
modularPath[solid].y = smoothPath[smooth].y;
|
|
modularPath[solid].dir = smoothPath[smooth].dir;
|
|
modularPath[solid].num = 1;
|
|
solid += 1;
|
|
}
|
|
smooth += 1;
|
|
}
|
|
while (smoothPath[smooth].num < ROUTE_END_FLAG);
|
|
// in case the last bit had no steps
|
|
if (solid == 1) //there were no paths so put in a dummy end
|
|
{
|
|
solid = 2;
|
|
modularPath[1].dir = smoothPath[0].dir;
|
|
modularPath[1].num = 0;
|
|
}
|
|
modularPath[solid-1].x = smoothPath[smooth-1].x;
|
|
modularPath[solid-1].y = smoothPath[smooth-1].y;
|
|
// set up the end of the walk
|
|
modularPath[solid].x = smoothPath[smooth-1].x;
|
|
modularPath[solid].y = smoothPath[smooth-1].y;
|
|
modularPath[solid].dir = 9;
|
|
modularPath[solid].num = ROUTE_END_FLAG;
|
|
return 1;
|
|
|
|
}
|
|
|
|
int32 SolidWalkAnimator(_walkData *walkAnim)
|
|
{
|
|
/****************************************************************************
|
|
* SolidWalk creates an animation based on whole steps with no sliding to get
|
|
* as near as possible to the target without any sliding this routine is
|
|
* is intended for use when just clicking about.
|
|
*
|
|
* produce a module list from the line data
|
|
*
|
|
* returns 0 if solid route not found
|
|
****************************************************************************/
|
|
|
|
int32 p;
|
|
int32 i;
|
|
int32 left;
|
|
int32 lastDir;
|
|
int32 turnDir;
|
|
int32 scale;
|
|
int32 step;
|
|
int32 module;
|
|
int32 module16X;
|
|
int32 module16Y;
|
|
int32 errorX;
|
|
int32 errorY;
|
|
int32 moduleEnd;
|
|
int32 slowStart=0;
|
|
|
|
|
|
|
|
// start at the beginning for a change
|
|
lastDir = modularPath[0].dir;
|
|
p = 1;
|
|
currentDir = modularPath[1].dir;
|
|
module = framesPerChar + lastDir;
|
|
moduleX = startX;
|
|
moduleY = startY;
|
|
module16X = moduleX << 16;
|
|
module16Y = moduleY << 16;
|
|
stepCount = 0;
|
|
|
|
//****************************************************************************
|
|
// SOLID
|
|
// START THE WALK WITH THE FIRST STANDFRAME THIS MAY CAUSE A DELAY
|
|
// BUT IT STOPS THE PLAYER MOVING FOR COLLISIONS ARE DETECTED
|
|
//****************************************************************************
|
|
|
|
//Zdebug("\nSOLID: STARTING THE WALK");
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = lastDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
|
|
//****************************************************************************
|
|
// SOLID
|
|
// TURN TO START THE WALK
|
|
//****************************************************************************
|
|
//Zdebug("\nSOLID: TURNING TO START THE WALK");
|
|
// rotate if we need to
|
|
if (lastDir != currentDir)
|
|
{
|
|
// get the direction to turn
|
|
turnDir = currentDir - lastDir;
|
|
if ( turnDir < 0)
|
|
turnDir += NO_DIRECTIONS;
|
|
|
|
if (turnDir > 4)
|
|
turnDir = -1;
|
|
else if (turnDir > 0)
|
|
turnDir = 1;
|
|
|
|
// rotate to new walk direction
|
|
// for george and nico put in a head turn at the start
|
|
if (usingStandingTurnFrames)
|
|
{
|
|
if ( turnDir < 0) // new frames for turn frames 29oct95jps
|
|
{
|
|
module = firstStandingTurnLeftFrame + lastDir;
|
|
}
|
|
else
|
|
{
|
|
module = firstStandingTurnRightFrame + lastDir;
|
|
}
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = lastDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
}
|
|
|
|
// rotate till were facing new dir then go back 45 degrees
|
|
while (lastDir != currentDir)
|
|
{
|
|
lastDir += turnDir;
|
|
if ( turnDir < 0) // new frames for turn frames 29oct95jps
|
|
{
|
|
if ( lastDir < 0)
|
|
lastDir += NO_DIRECTIONS;
|
|
module = firstStandingTurnLeftFrame + lastDir;
|
|
}
|
|
else
|
|
{
|
|
if ( lastDir > 7)
|
|
lastDir -= NO_DIRECTIONS;
|
|
module = firstStandingTurnRightFrame + lastDir;
|
|
}
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = lastDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
}
|
|
// the back 45 degrees bit
|
|
stepCount -= 1;// step back one because new head turn for george takes us past the new dir
|
|
}
|
|
|
|
//****************************************************************************
|
|
// SOLID: THE SLOW IN
|
|
|
|
slowStart = AddSlowInFrames(walkAnim);
|
|
|
|
//****************************************************************************
|
|
// SOLID
|
|
// THE WALK
|
|
//****************************************************************************
|
|
|
|
//Zdebug("\nSOLID: THE WALK");
|
|
|
|
//---------------------------------------------------
|
|
// start the walk on the left or right leg, depending on how the slow-in frames were drawn
|
|
|
|
if (leadingLeg[currentDir]==0) // (0=left; 1=right)
|
|
left = 0; // start the walk on the left leg (ie. at beginning of the first step of the walk cycle)
|
|
else
|
|
left = framesPerStep; // start the walk on the right leg (ie. at beginning of the second step of the walk cycle)
|
|
//---------------------------------------------------
|
|
|
|
|
|
lastCount = stepCount;
|
|
lastDir = 99;// this ensures that we don't put in turn frames for the start
|
|
currentDir = 99;// this ensures that we don't put in turn frames for the start
|
|
|
|
do
|
|
{
|
|
while(modularPath[p].num > 0)
|
|
{
|
|
currentDir = modularPath[p].dir;
|
|
if (currentDir< NO_DIRECTIONS)
|
|
{
|
|
|
|
module = currentDir * framesPerStep * 2 + left;
|
|
if (left == 0)
|
|
left = framesPerStep;
|
|
else
|
|
left = 0;
|
|
moduleEnd = module + framesPerStep;
|
|
step = 0;
|
|
scale = (scaleA * moduleY + scaleB);
|
|
do
|
|
{
|
|
module16X += dx[module]*scale;
|
|
module16Y += dy[module]*scale;
|
|
moduleX = module16X >> 16;
|
|
moduleY = module16Y >> 16;
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = step; // normally 0,1,2,3,4,5,0,1,2,etc
|
|
walkAnim[stepCount].dir = currentDir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
module += 1;
|
|
step += 1;
|
|
}
|
|
while( module < moduleEnd) ;
|
|
errorX = modularPath[p].x - moduleX;
|
|
errorX = errorX * modX[modularPath[p].dir];
|
|
errorY = modularPath[p].y - moduleY;
|
|
errorY = errorY * modY[modularPath[p].dir];
|
|
if ((errorX < 0) || (errorY < 0))
|
|
{
|
|
modularPath[p].num = 0;
|
|
stepCount -= framesPerStep;
|
|
if (left == 0)
|
|
left = framesPerStep;
|
|
else
|
|
left = 0;
|
|
// Okay this is the end of a section
|
|
moduleX = walkAnim[stepCount-1].x;
|
|
moduleY = walkAnim[stepCount-1].y;
|
|
module16X = moduleX << 16;
|
|
module16Y = moduleY << 16;
|
|
modularPath[p].x =moduleX;
|
|
modularPath[p].y =moduleY;
|
|
// Now is the time to put in the turn frames for the last turn
|
|
if ((stepCount - lastCount) < framesPerStep)// no step taken
|
|
{
|
|
if (slowStart == 1)// clean up if a slow in but no walk
|
|
{
|
|
//stepCount -= 3;
|
|
stepCount -= numberOfSlowInFrames[currentDir]; // (James08sep97)
|
|
//lastCount -= 3;
|
|
lastCount -= numberOfSlowInFrames[currentDir]; // (James08sep97)
|
|
slowStart = 0;
|
|
}
|
|
currentDir = 99;// this ensures that we don't put in turn frames for this walk or the next
|
|
}
|
|
// check each turn condition in turn
|
|
if (((lastDir != 99) && (currentDir != 99)) && (usingWalkingTurnFrames)) // only for george
|
|
{
|
|
lastDir = currentDir - lastDir;//1 and -7 going right -1 and 7 going left
|
|
if (((lastDir == -1) || (lastDir == 7)) || ((lastDir == -2) || (lastDir == 6)))
|
|
{
|
|
// turn at the end of the last walk
|
|
frame = lastCount - framesPerStep;
|
|
do
|
|
{
|
|
walkAnim[frame].frame += firstWalkingTurnLeftFrame; // was 104; //turning left
|
|
frame += 1;
|
|
}
|
|
while(frame < lastCount );
|
|
}
|
|
if (((lastDir == 1) || (lastDir == -7)) || ((lastDir == 2) || (lastDir == -6)))
|
|
{
|
|
// turn at the end of the current walk
|
|
frame = lastCount - framesPerStep;
|
|
do
|
|
{
|
|
walkAnim[frame].frame += firstWalkingTurnRightFrame; // was 200; // turning right
|
|
frame += 1;
|
|
}
|
|
while(frame < lastCount );
|
|
}
|
|
}
|
|
// all turns checked
|
|
lastCount = stepCount;
|
|
}
|
|
}
|
|
}
|
|
p = p + 1;
|
|
lastDir = currentDir;
|
|
slowStart = 0; //can only be valid first time round
|
|
}
|
|
while (modularPath[p].dir < NO_DIRECTIONS);
|
|
|
|
|
|
//****************************************************************************
|
|
// SOLID: THE SLOW OUT
|
|
AddSlowOutFrames(walkAnim);
|
|
|
|
//****************************************************************************
|
|
|
|
module = framesPerChar + modularPath[p-1].dir;
|
|
walkAnim[stepCount].frame = module;
|
|
walkAnim[stepCount].step = 0;
|
|
walkAnim[stepCount].dir = modularPath[p-1].dir;
|
|
walkAnim[stepCount].x = moduleX;
|
|
walkAnim[stepCount].y = moduleY;
|
|
stepCount += 1;
|
|
|
|
walkAnim[stepCount].frame = 512;
|
|
walkAnim[stepCount].step = 99;
|
|
stepCount += 1;
|
|
walkAnim[stepCount].frame = 512;
|
|
walkAnim[stepCount].step = 99;
|
|
stepCount += 1;
|
|
walkAnim[stepCount].frame = 512;
|
|
walkAnim[stepCount].step = 99;
|
|
|
|
//-------------------------------------------
|
|
// write all the frames to "debug.txt"
|
|
|
|
//Zdebug("\nTHE WALKDATA:");
|
|
for (frame=0; frame<=stepCount; frame++)
|
|
{
|
|
//Zdebug("walkAnim[%d].frame=%d",frame,walkAnim[frame].frame);
|
|
}
|
|
//-------------------------------------------
|
|
|
|
//****************************************************************************
|
|
// SOLID
|
|
// NO END TURNS
|
|
//****************************************************************************
|
|
|
|
// Zdebug("RouteFinder RouteSize is %d", stepCount);
|
|
// now check the route
|
|
i = 0;
|
|
do
|
|
{
|
|
if (!Check(modularPath[i].x, modularPath[i].y, modularPath[i+1].x, modularPath[i+1].y))
|
|
p=0;
|
|
#ifdef PLOT_PATHS
|
|
RouteLine(modularPath[i].x, modularPath[i].y, modularPath[i+1].x, modularPath[i+1].y, 227);
|
|
#endif
|
|
i += 1;
|
|
}
|
|
while(i<p-1);
|
|
if (p != 0)
|
|
{
|
|
targetDir = modularPath[p-1].dir;
|
|
}
|
|
if (p != 0)
|
|
{
|
|
if (CheckTarget(moduleX,moduleY) == 3)// new target on a line
|
|
{
|
|
p = 0;
|
|
//Zdebug("Solid walk target was on a line %d %d", moduleX, moduleY);
|
|
}
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*******************************************************************************
|
|
* THE SCAN ROUTINES
|
|
*******************************************************************************
|
|
*******************************************************************************/
|
|
|
|
int32 Scan(int32 level)
|
|
/*******************************************************************************
|
|
* Called successively from RouteFinder until no more changes take place in the
|
|
* grid array ie he best path has been found
|
|
*
|
|
* Scans through every point in the node array and checks if there is a route
|
|
* between each point and if this route gives a new route.
|
|
*
|
|
* This routine could probably halve its processing time if it doubled up on the
|
|
* checks after each route check
|
|
*
|
|
*******************************************************************************/
|
|
{
|
|
int32 i;
|
|
int32 k;
|
|
int32 x1;
|
|
int32 y1;
|
|
int32 x2;
|
|
int32 y2;
|
|
int32 distance;
|
|
int32 changed = 0;
|
|
// For all the nodes that have new values and a distance less than enddist
|
|
// ie dont check for new routes from a point we checked before or from a point
|
|
// that is already further away than the best route so far.
|
|
i = 0;
|
|
do
|
|
{
|
|
if ((node[i].dist < node[nnodes].dist) && (node[i].level == level))
|
|
{
|
|
x1 = node[i].x;
|
|
y1 = node[i].y;
|
|
k=nnodes;
|
|
do
|
|
{
|
|
if (node[k].dist > node[i].dist)
|
|
{
|
|
x2 = node[k].x;
|
|
y2 = node[k].y;
|
|
|
|
if (abs(x2-x1)>(4.5*abs(y2-y1)))
|
|
{
|
|
distance = (8*abs(x2-x1)+18*abs(y2-y1))/(54*8)+1;
|
|
}
|
|
else
|
|
{
|
|
distance = (6*abs(x2-x1)+36*abs(y2-y1))/(36*14)+1;
|
|
}
|
|
|
|
if ((distance + node[i].dist < node[nnodes].dist) && (distance + node[i].dist < node[k].dist))
|
|
{
|
|
if (NewCheck(0, x1,y1,x2,y2))
|
|
{
|
|
node[k].level = level + 1;
|
|
node[k].dist = distance + node[i].dist;
|
|
node[k].prev = i;
|
|
changed = 1;
|
|
}
|
|
}
|
|
}
|
|
k-=1;
|
|
}
|
|
while(k > 0);
|
|
}
|
|
i=i+1;
|
|
}
|
|
while(i < nnodes);
|
|
return changed;
|
|
}
|
|
|
|
|
|
int32 NewCheck(int32 status, int32 x1 , int32 y1 , int32 x2 ,int32 y2)
|
|
/*******************************************************************************
|
|
* NewCheck routine checks if the route between two points can be achieved
|
|
* without crossing any of the bars in the Bars array.
|
|
*
|
|
* NewCheck differs from check in that that 4 route options are considered
|
|
* corresponding to actual walked routes.
|
|
*
|
|
* Note distance doesnt take account of shrinking ???
|
|
*
|
|
* Note Bars array must be properly calculated ie min max dx dy co
|
|
*******************************************************************************/
|
|
{
|
|
int32 ldx;
|
|
int32 ldy;
|
|
int32 dlx;
|
|
int32 dly;
|
|
int32 dirX;
|
|
int32 dirY;
|
|
int32 step1;
|
|
int32 step2;
|
|
int32 step3;
|
|
int32 steps;
|
|
int32 options;
|
|
|
|
steps = 0;
|
|
options = 0;
|
|
ldx = x2 - x1;
|
|
ldy = y2 - y1;
|
|
dirX = 1;
|
|
dirY = 1;
|
|
if (ldx < 0)
|
|
{
|
|
ldx = -ldx;
|
|
dirX = -1;
|
|
}
|
|
|
|
if (ldy < 0)
|
|
{
|
|
ldy = -ldy;
|
|
dirY = -1;
|
|
}
|
|
|
|
//make the route options
|
|
if ((diagonaly * ldx) > (diagonalx * ldy)) // dir = 1,2 or 2,3 or 5,6 or 6,7
|
|
{
|
|
dly = ldy;
|
|
dlx = (ldy*diagonalx)/diagonaly;
|
|
ldx = ldx - dlx;
|
|
dlx = dlx * dirX;
|
|
dly = dly * dirY;
|
|
ldx = ldx * dirX;
|
|
ldy = 0;
|
|
|
|
//options are
|
|
//square, diagonal a code 1 route
|
|
step1 = Check(x1, y1, x1+ldx, y1);
|
|
if (step1 != 0)
|
|
{
|
|
step2 = Check(x1+ldx, y1, x2, y2);
|
|
if (step2 != 0)
|
|
{
|
|
steps = step1 + step2; // yes
|
|
options = options + 2;
|
|
#ifdef PLOT_PATHS
|
|
if (status == 1)
|
|
{
|
|
RouteLine(x1, y1, x1+ldx, y1, 231);
|
|
RouteLine(x1+ldx, y1, x2, y2, 231);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
//diagonal, square a code 2 route
|
|
if ((steps == 0) || (status == 1))
|
|
{
|
|
step1 = Check(x1, y1, x1+dlx,y1+dly);
|
|
if (step1 != 0)
|
|
{
|
|
step2 = Check(x1+dlx, y2, x2, y2);
|
|
if (step2 != 0)
|
|
{
|
|
steps = step1 + step2; // yes
|
|
options = options + 4;
|
|
#ifdef PLOT_PATHS
|
|
if (status == 1)
|
|
{
|
|
RouteLine(x1, y1, x1+dlx,y1+dly, 231);
|
|
RouteLine(x1+dlx, y2, x2, y2, 231);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
//halfsquare, diagonal, halfsquare a code 0 route
|
|
if ((steps == 0) || (status == 1))
|
|
{
|
|
step1 = Check(x1, y1, x1+ldx/2, y1);
|
|
if (step1 != 0)
|
|
{
|
|
step2 = Check(x1+ldx/2, y1, x1+ldx/2+dlx, y2);
|
|
if (step2 != 0)
|
|
{
|
|
step3 = Check(x1+ldx/2+dlx, y2, x2, y2);
|
|
if (step3 != 0)
|
|
{
|
|
steps = step1 + step2 + step3; // yes
|
|
options = options + 1;
|
|
#ifdef PLOT_PATHS
|
|
if (status == 1)
|
|
{
|
|
RouteLine(x1, y1, x1+ldx/2, y1, 231);
|
|
RouteLine(x1+ldx/2, y1, x1+ldx/2+dlx, y2, 231);
|
|
RouteLine(x1+ldx/2+dlx, y2, x2, y2, 231);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//halfdiagonal, square, halfdiagonal a code 3 route
|
|
if ((steps == 0) || (status == 1))
|
|
{
|
|
step1 = Check(x1, y1, x1+dlx/2, y1+dly/2);
|
|
if (step1 != 0)
|
|
{
|
|
step2 = Check(x1+dlx/2, y1+dly/2, x1+ldx+dlx/2, y1+dly/2);
|
|
if (step2 != 0)
|
|
{
|
|
step3 = Check(x1+ldx+dlx/2, y1+dly/2, x2, y2);
|
|
if (step3 != 0)
|
|
{
|
|
steps = step1 + step2 + step3; // yes
|
|
#ifdef PLOT_PATHS
|
|
if (status == 1)
|
|
{
|
|
RouteLine(x1, y1, x1+dlx/2, y1+dly/2, 231);
|
|
RouteLine(x1+dlx/2, y1+dly/2, x1+ldx+dlx/2, y1+dly/2, 231);
|
|
RouteLine(x1+ldx+dlx/2, y1+dly/2, x2, y2, 231);
|
|
}
|
|
#endif
|
|
options = options + 8;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else // dir = 7,0 or 0,1 or 3,4 or 4,5
|
|
{
|
|
dlx = ldx;
|
|
dly = (ldx*diagonaly)/diagonalx;
|
|
ldy = ldy - dly;
|
|
dlx = dlx * dirX;
|
|
dly = dly * dirY;
|
|
ldy = ldy * dirY;
|
|
ldx = 0;
|
|
|
|
//options are
|
|
//square, diagonal a code 1 route
|
|
step1 = Check(x1 ,y1 ,x1 ,y1+ldy );
|
|
if (step1 != 0)
|
|
{
|
|
step2 = Check(x1 ,y1+ldy ,x2,y2);
|
|
if (step2 != 0)
|
|
{
|
|
steps = step1 + step2; // yes
|
|
#ifdef PLOT_PATHS
|
|
if (status == 1)
|
|
{
|
|
RouteLine(x1 ,y1 ,x1 ,y1+ldy, 231);
|
|
RouteLine(x1 ,y1+ldy ,x2, y2, 231);
|
|
}
|
|
#endif
|
|
options = options + 2;
|
|
}
|
|
}
|
|
//diagonal, square a code 2 route
|
|
if ((steps == 0) || (status == 1))
|
|
{
|
|
step1 = Check(x1, y1, x2, y1+dly);
|
|
if (step1 != 0)
|
|
{
|
|
step2 = Check(x2, y1+dly, x2, y2);
|
|
if (step2 != 0)
|
|
{
|
|
steps = step1 + step2; // yes
|
|
#ifdef PLOT_PATHS
|
|
if (status == 1)
|
|
{
|
|
RouteLine(x1, y1, x2, y1+dly, 231);
|
|
RouteLine(x2, y1+dly, x2, y2, 231);
|
|
}
|
|
#endif
|
|
options = options + 4;
|
|
}
|
|
}
|
|
}
|
|
//halfsquare, diagonal, halfsquare a code 0 route
|
|
if ((steps == 0) || (status == 1))
|
|
{
|
|
step1 = Check(x1, y1, x1, y1+ldy/2);
|
|
if (step1 != 0)
|
|
{
|
|
step2 = Check(x1, y1+ldy/2, x2, y1+ldy/2+dly);
|
|
if (step2 != 0)
|
|
{
|
|
step3 = Check(x2, y1+ldy/2+dly, x2, y2);
|
|
if (step3 != 0)
|
|
{
|
|
steps = step1 + step2 + step3; // yes
|
|
#ifdef PLOT_PATHS
|
|
if (status == 1)
|
|
{
|
|
RouteLine(x1, y1, x1, y1+ldy/2, 231);
|
|
RouteLine(x1, y1+ldy/2, x2, y1+ldy/2+dly, 231);
|
|
RouteLine(x2, y1+ldy/2+dly, x2, y2, 231);
|
|
}
|
|
#endif
|
|
options = options + 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//halfdiagonal, square, halfdiagonal a code 3 route
|
|
if ((steps == 0) || (status == 1))
|
|
{
|
|
step1 = Check(x1, y1, x1+dlx/2, y1+dly/2);
|
|
if (step1 != 0)
|
|
{
|
|
step2 = Check(x1+dlx/2, y1+dly/2, x1+dlx/2, y1+ldy+dly/2);
|
|
if (step2 != 0)
|
|
{
|
|
step3 = Check(x1+dlx/2, y1+ldy+dly/2, x2, y2);
|
|
if (step3 != 0)
|
|
{
|
|
steps = step1 + step2 + step3; // yes
|
|
options = options + 8;
|
|
#ifdef PLOT_PATHS
|
|
if (status == 1)
|
|
{
|
|
RouteLine(x1, y1, x1+dlx/2, y1+dly/2, 231);
|
|
RouteLine(x1+dlx/2, y1+dly/2, x1+dlx/2, y1+ldy+dly/2, 231);
|
|
RouteLine(x1+dlx/2, y1+ldy+dly/2, x2, y2, 231);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (status == 0)
|
|
{
|
|
status = steps;
|
|
}
|
|
else
|
|
{
|
|
status = options;
|
|
}
|
|
return status;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*******************************************************************************
|
|
* CHECK ROUTINES
|
|
*******************************************************************************
|
|
*******************************************************************************/
|
|
|
|
|
|
int32 Check(int32 x1 , int32 y1 , int32 x2 ,int32 y2)
|
|
{
|
|
//call the fastest line check for the given line
|
|
//returns 1 if line didn't cross any bars
|
|
int32 steps;
|
|
|
|
if ((x1 == x2) && (y1 == y2))
|
|
{
|
|
steps = 1;
|
|
}
|
|
else if (x1 == x2)
|
|
{
|
|
steps = VertCheck(x1, y1, y2);
|
|
}
|
|
else if (y1 == y2)
|
|
{
|
|
steps = HorizCheck(x1, y1, x2);
|
|
}
|
|
else
|
|
{
|
|
steps = LineCheck(x1, y1, x2, y2);
|
|
}
|
|
return steps;
|
|
|
|
}
|
|
|
|
|
|
int32 LineCheck(int32 x1 , int32 y1 , int32 x2 ,int32 y2)
|
|
{
|
|
int32 dirx;
|
|
int32 diry;
|
|
int32 co;
|
|
int32 slope;
|
|
int32 i;
|
|
int32 xc;
|
|
int32 yc;
|
|
int32 xmin;
|
|
int32 ymin;
|
|
int32 xmax;
|
|
int32 ymax;
|
|
int32 linesCrossed = 1;
|
|
|
|
|
|
if (x1 > x2)
|
|
{
|
|
xmin = x2;
|
|
xmax = x1;
|
|
}
|
|
else
|
|
{
|
|
xmin = x1;
|
|
xmax = x2;
|
|
}
|
|
if (y1 > y2)
|
|
{
|
|
ymin = y2;
|
|
ymax = y1;
|
|
}
|
|
else
|
|
{
|
|
ymin = y1;
|
|
ymax = y2;
|
|
}
|
|
//line set to go one step in chosen direction
|
|
//so ignore if it hits anything
|
|
dirx = x2 - x1;
|
|
diry = y2 - y1;
|
|
co = (y1 *dirx)- (x1*diry); //new line equation
|
|
|
|
i = 0;
|
|
do
|
|
{
|
|
// this is the inner inner loop
|
|
if ((xmax >= bars[i].xmin) && ( xmin <= bars[i].xmax)) //skip if not on module
|
|
{
|
|
if ((ymax >= bars[i].ymin) && ( ymin <= bars[i].ymax)) //skip if not on module
|
|
{
|
|
// okay its a valid line calculate an intersept
|
|
// wow but all this arithmatic we must have loads of time
|
|
slope = (bars[i].dx * diry) - (bars[i].dy *dirx);// slope it he slope between the two lines
|
|
if (slope != 0)//assuming parallel lines don't cross
|
|
{
|
|
//calculate x intercept and check its on both lines
|
|
xc = ((bars[i].co * dirx) - (co * bars[i].dx)) / slope;
|
|
|
|
if ((xc >= xmin-1) && (xc <= xmax+1)) //skip if not on module
|
|
{
|
|
if ((xc >= bars[i].xmin-1) && (xc <= bars[i].xmax+1)) //skip if not on line
|
|
{
|
|
|
|
yc = ((bars[i].co * diry) - (co * bars[i].dy)) / slope;
|
|
|
|
if ((yc >= ymin-1) && (yc <= ymax+1)) //skip if not on module
|
|
{
|
|
if ((yc >= bars[i].ymin-1) && (yc <= bars[i].ymax+1)) //skip if not on line
|
|
{
|
|
linesCrossed = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
i = i + 1;
|
|
}
|
|
while((i < nbars) && linesCrossed);
|
|
|
|
return linesCrossed;
|
|
}
|
|
|
|
|
|
int32 HorizCheck(int32 x1 , int32 y , int32 x2)
|
|
{
|
|
int32 ldy;
|
|
int32 i;
|
|
int32 xc;
|
|
int32 xmin;
|
|
int32 xmax;
|
|
int32 linesCrossed = 1;
|
|
|
|
if (x1 > x2)
|
|
{
|
|
xmin = x2;
|
|
xmax = x1;
|
|
}
|
|
else
|
|
{
|
|
xmin = x1;
|
|
xmax = x2;
|
|
}
|
|
//line set to go one step in chosen direction
|
|
//so ignore if it hits anything
|
|
|
|
i = 0;
|
|
do
|
|
{
|
|
// this is the inner inner loop
|
|
if ((xmax >= bars[i].xmin) && ( xmin <= bars[i].xmax)) //skip if not on module
|
|
{
|
|
if ((y >= bars[i].ymin) && ( y <= bars[i].ymax)) //skip if not on module
|
|
{
|
|
// okay its a valid line calculate an intersept
|
|
// wow but all this arithmatic we must have loads of time
|
|
if (bars[i].dy == 0)
|
|
{
|
|
linesCrossed = 0;
|
|
}
|
|
else
|
|
{
|
|
ldy = y-bars[i].y1;
|
|
xc = bars[i].x1 + (bars[i].dx * ldy)/bars[i].dy;
|
|
if ((xc >= xmin-1) && (xc <= xmax+1)) //skip if not on module
|
|
{
|
|
linesCrossed = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
i = i + 1;
|
|
}
|
|
while((i < nbars) && linesCrossed);
|
|
|
|
return linesCrossed;
|
|
}
|
|
|
|
|
|
int32 VertCheck(int32 x, int32 y1, int32 y2)
|
|
{
|
|
int32 ldx;
|
|
int32 i;
|
|
int32 yc;
|
|
int32 ymin;
|
|
int32 ymax;
|
|
int32 linesCrossed = 1;
|
|
|
|
if (y1 > y2)
|
|
{
|
|
ymin = y2;
|
|
ymax = y1;
|
|
}
|
|
else
|
|
{
|
|
ymin = y1;
|
|
ymax = y2;
|
|
}
|
|
//line set to go one step in chosen direction
|
|
//so ignore if it hits anything
|
|
i = 0;
|
|
do // this is the inner inner loop
|
|
{
|
|
if ((x >= bars[i].xmin) && ( x <= bars[i].xmax)) //overlapping
|
|
{
|
|
if ((ymax >= bars[i].ymin) && ( ymin <= bars[i].ymax)) //skip if not on module
|
|
{
|
|
// okay its a valid line calculate an intersept
|
|
// wow but all this arithmatic we must have loads of time
|
|
if (bars[i].dx == 0)//both lines vertical and overlap in x and y so they cross
|
|
{
|
|
linesCrossed = 0;
|
|
}
|
|
else
|
|
{
|
|
ldx = x-bars[i].x1;
|
|
yc = bars[i].y1 + (bars[i].dy * ldx)/bars[i].dx;
|
|
if ((yc >= ymin-1) && (yc <= ymax+1)) //the intersept overlaps
|
|
{
|
|
linesCrossed = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
i = i + 1;
|
|
}
|
|
while((i < nbars) && linesCrossed);
|
|
|
|
return linesCrossed;
|
|
}
|
|
|
|
int32 CheckTarget(int32 x , int32 y)
|
|
/*******************************************************************************
|
|
*******************************************************************************/
|
|
{
|
|
int32 ldx;
|
|
int32 ldy;
|
|
int32 i;
|
|
int32 xc;
|
|
int32 yc;
|
|
int32 xmin;
|
|
int32 xmax;
|
|
int32 ymin;
|
|
int32 ymax;
|
|
int32 onLine = 0;
|
|
|
|
xmin = x - 1;
|
|
xmax = x + 1;
|
|
ymin = y - 1;
|
|
ymax = y + 1;
|
|
|
|
// check if point +- 1 is on the line
|
|
//so ignore if it hits anything
|
|
|
|
i = 0;
|
|
do
|
|
{
|
|
|
|
// this is the inner inner loop
|
|
|
|
if ((xmax >= bars[i].xmin) && ( xmin <= bars[i].xmax)) //overlapping line
|
|
{
|
|
if ((ymax >= bars[i].ymin) && ( ymin <= bars[i].ymax)) //overlapping line
|
|
{
|
|
|
|
// okay this line overlaps the target calculate an y intersept for x
|
|
|
|
if (bars[i].dx == 0)// vertical line so we know it overlaps y
|
|
{
|
|
yc = 0;
|
|
}
|
|
else
|
|
{
|
|
ldx = x-bars[i].x1;
|
|
yc = bars[i].y1 + (bars[i].dy * ldx)/bars[i].dx;
|
|
}
|
|
|
|
if ((yc >= ymin) && (yc <= ymax)) //overlapping point for y
|
|
{
|
|
onLine = 3;// target on a line so drop out
|
|
//Zdebug("RouteFail due to target on a line %d %d",x,y);
|
|
}
|
|
else
|
|
{
|
|
if (bars[i].dy == 0)// vertical line so we know it overlaps y
|
|
{
|
|
xc = 0;
|
|
}
|
|
else
|
|
{
|
|
ldy = y-bars[i].y1;
|
|
xc = bars[i].x1 + (bars[i].dx * ldy)/bars[i].dy;
|
|
}
|
|
|
|
if ((xc >= xmin) && (xc <= xmax)) //skip if not on module
|
|
{
|
|
onLine = 3;// target on a line so drop out
|
|
//Zdebug("RouteFail due to target on a line %d %d",x,y);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
i = i + 1;
|
|
}
|
|
while((i < nbars) && (onLine == 0));
|
|
|
|
|
|
return onLine;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*******************************************************************************
|
|
* THE SETUP ROUTINES
|
|
*******************************************************************************
|
|
*******************************************************************************/
|
|
//------------------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------------------
|
|
|
|
void LoadWalkData(Object_walkdata *ob_walkdata)
|
|
{
|
|
uint8 direction;
|
|
uint16 firstFrameOfDirection;
|
|
uint16 walkFrameNo;
|
|
uint32 frameCounter = 0; // starts at frame 0 of mega set (16sep96 JEL)
|
|
|
|
|
|
nWalkFrames = ob_walkdata->nWalkFrames;
|
|
usingStandingTurnFrames = ob_walkdata->usingStandingTurnFrames;
|
|
usingWalkingTurnFrames = ob_walkdata->usingWalkingTurnFrames;
|
|
usingSlowInFrames = ob_walkdata->usingSlowInFrames;
|
|
usingSlowOutFrames = ob_walkdata->usingSlowOutFrames;
|
|
numberOfSlowOutFrames = usingSlowOutFrames; // 0 = not using slow out frames; non-zero = using that many frames for each leading leg for each direction
|
|
|
|
memcpy(&numberOfSlowInFrames[0],ob_walkdata->nSlowInFrames,NO_DIRECTIONS*sizeof(numberOfSlowInFrames[0]));
|
|
memcpy(&leadingLeg[0],ob_walkdata->leadingLeg,NO_DIRECTIONS*sizeof(leadingLeg[0]));
|
|
memcpy(&dx[0],ob_walkdata->dx,NO_DIRECTIONS*(nWalkFrames+1)*sizeof(dx[0]));
|
|
memcpy(&dy[0],ob_walkdata->dy,NO_DIRECTIONS*(nWalkFrames+1)*sizeof(dy[0]));
|
|
|
|
//---------------------------------------------------------
|
|
|
|
for (direction=0; direction<NO_DIRECTIONS; direction++)
|
|
{
|
|
firstFrameOfDirection = direction * nWalkFrames;
|
|
|
|
modX[direction]=0;
|
|
modY[direction]=0;
|
|
|
|
for (walkFrameNo=firstFrameOfDirection; walkFrameNo < (firstFrameOfDirection + (nWalkFrames/2)); walkFrameNo++ )
|
|
{
|
|
modX[direction] += dx[walkFrameNo]; // eg. modX[0] is the sum of the x-step sizes for the first half of the walk cycle for direction 0
|
|
modY[direction] += dy[walkFrameNo];
|
|
}
|
|
}
|
|
|
|
diagonalx = modX[3];
|
|
diagonaly = modY[3];
|
|
|
|
//----------------------------------------------------
|
|
// interpret the walk data
|
|
//----------------------------------------------------
|
|
|
|
framesPerStep = nWalkFrames/2;
|
|
framesPerChar = nWalkFrames * NO_DIRECTIONS;
|
|
|
|
// offset pointers added Oct 30 95 JPS
|
|
// mega id references removed 16sep96 by JEL
|
|
|
|
//---------------------
|
|
// WALK FRAMES
|
|
// start on frame 0
|
|
frameCounter += framesPerChar;
|
|
|
|
//---------------------
|
|
// STAND FRAMES
|
|
firstStandFrame = frameCounter; // stand frames come after the walk frames
|
|
frameCounter += NO_DIRECTIONS; // one stand frame for each direction
|
|
|
|
//---------------------
|
|
// STANDING TURN FRAMES - OPTIONAL!
|
|
if (usingStandingTurnFrames)
|
|
{
|
|
firstStandingTurnLeftFrame = frameCounter; // standing turn-left frames come after the slow-out frames
|
|
frameCounter += NO_DIRECTIONS; // one for each direction
|
|
|
|
firstStandingTurnRightFrame = frameCounter; // standing turn-left frames come after the standing turn-right frames
|
|
frameCounter += NO_DIRECTIONS; // one for each direction
|
|
}
|
|
else
|
|
{
|
|
firstStandingTurnLeftFrame = firstStandFrame; // refer instead to the normal stand frames
|
|
firstStandingTurnRightFrame = firstStandFrame; // -"-
|
|
}
|
|
//---------------------
|
|
// WALKING TURN FRAMES - OPTIONAL!
|
|
if (usingWalkingTurnFrames)
|
|
{
|
|
firstWalkingTurnLeftFrame = frameCounter; // walking left-turn frames come after the stand frames
|
|
frameCounter += framesPerChar;
|
|
|
|
firstWalkingTurnRightFrame = frameCounter; // walking right-turn frames come after the walking left-turn frames
|
|
frameCounter += framesPerChar;
|
|
}
|
|
else
|
|
{
|
|
firstWalkingTurnLeftFrame = 0;
|
|
firstWalkingTurnRightFrame = 0;
|
|
}
|
|
//---------------------
|
|
// SLOW-IN FRAMES - OPTIONAL!
|
|
|
|
if (usingSlowInFrames) // slow-in frames come after the walking right-turn frames
|
|
{
|
|
for (direction=0; direction<NO_DIRECTIONS; direction++)
|
|
{
|
|
firstSlowInFrame[direction] = frameCounter; // make note of frame number of first slow-in frame for each direction
|
|
frameCounter += numberOfSlowInFrames[direction]; // can be a different number of slow-in frames in each direction
|
|
}
|
|
}
|
|
//---------------------
|
|
// SLOW-OUT FRAMES - OPTIONAL!
|
|
|
|
if (usingSlowOutFrames)
|
|
{
|
|
firstSlowOutFrame = frameCounter; // slow-out frames come after the slow-in frames
|
|
}
|
|
//---------------------
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*******************************************************************************
|
|
* THE ROUTE EXTRACTOR
|
|
*******************************************************************************
|
|
*******************************************************************************/
|
|
|
|
void ExtractRoute()
|
|
/****************************************************************************
|
|
* ExtractRoute gets route from the node data after a full scan, route is
|
|
* written with just the basic way points and direction options for heading
|
|
* to the next point.
|
|
****************************************************************************/
|
|
{
|
|
int32 prev;
|
|
int32 prevx;
|
|
int32 prevy;
|
|
int32 last;
|
|
int32 point;
|
|
int32 p;
|
|
int32 dirx;
|
|
int32 diry;
|
|
int32 dir;
|
|
int32 ldx;
|
|
int32 ldy;
|
|
|
|
|
|
// extract the route from the node data
|
|
prev = nnodes;
|
|
last = prev;
|
|
point = O_ROUTE_SIZE - 1;
|
|
route[point].x = node[last].x;
|
|
route[point].y = node[last].y;
|
|
do
|
|
{
|
|
point = point - 1;
|
|
prev = node[last].prev;
|
|
prevx = node[prev].x;
|
|
prevy = node[prev].y;
|
|
route[point].x = prevx;
|
|
route[point].y = prevy;
|
|
last = prev;
|
|
}
|
|
while (prev > 0);
|
|
|
|
// now shuffle route down in the buffer
|
|
routeLength = 0;
|
|
do
|
|
{
|
|
route[routeLength].x = route[point].x;
|
|
route[routeLength].y = route[point].y;
|
|
point = point + 1;
|
|
routeLength = routeLength + 1;
|
|
}
|
|
while (point < O_ROUTE_SIZE);
|
|
routeLength = routeLength - 1;
|
|
|
|
// okay the route exists as a series point now put in some directions
|
|
p = 0;
|
|
do
|
|
{
|
|
#ifdef PLOT_PATHS
|
|
BresenhamLine(route[p+1].x-128,route[p+1].y-128, route[p].x-128,route[p].y-128, (uint8*)screen_ad, true_pixel_size_x, pixel_size_y, ROUTE_END_FLAG);
|
|
#endif
|
|
ldx = route[p+1].x - route[p].x;
|
|
ldy = route[p+1].y - route[p].y;
|
|
dirx = 1;
|
|
diry = 1;
|
|
if (ldx < 0)
|
|
{
|
|
ldx = -ldx;
|
|
dirx = -1;
|
|
}
|
|
if (ldy < 0)
|
|
{
|
|
ldy = -ldy;
|
|
diry = -1;
|
|
}
|
|
|
|
if ((diagonaly * ldx) > (diagonalx * ldy)) // dir = 1,2 or 2,3 or 5,6 or 6,7
|
|
{
|
|
dir = 4 - 2 * dirx; // 2 or 6
|
|
route[p].dirS = dir;
|
|
dir = dir + diry * dirx; // 1,3,5 or 7
|
|
route[p].dirD = dir;
|
|
}
|
|
else // dir = 7,0 or 0,1 or 3,4 or 4,5
|
|
{
|
|
dir = 2 + 2 * diry; // 0 or 4
|
|
route[p].dirS = dir;
|
|
dir = 4 - 2 * dirx; // 2 or 6
|
|
dir = dir + diry * dirx; // 1,3,5 or 7
|
|
route[p].dirD = dir;
|
|
}
|
|
p = p + 1;
|
|
}
|
|
while (p < (routeLength));
|
|
// set the last dir to continue previous route unless specified
|
|
if (targetDir == 8) // ANY direction
|
|
{
|
|
route[p].dirS = route[p-1].dirS;
|
|
route[p].dirD = route[p-1].dirD;
|
|
}
|
|
else
|
|
{
|
|
route[p].dirS = targetDir;
|
|
route[p].dirD = targetDir;
|
|
}
|
|
return;
|
|
}
|
|
|
|
//*******************************************************************************
|
|
|
|
void RouteLine(int32 x1,int32 y1,int32 x2,int32 y2 ,int32 colour)
|
|
{
|
|
if (x1);
|
|
if (x2);
|
|
if (y1);
|
|
if (y2);
|
|
if (colour);
|
|
// BresenhamLine(x1-128, y1-128, x2-128, y2-128, (uint8*)screen_ad, true_pixel_size_x, pixel_size_y, colour);
|
|
return;
|
|
}
|
|
|
|
//*******************************************************************************
|
|
|
|
void SetUpWalkGrid(Object_mega *ob_mega, int32 x, int32 y, int32 dir)
|
|
{
|
|
int32 i;
|
|
|
|
|
|
LoadWalkGrid(); // get walk grid file + extra grid into 'bars' & 'node' arrays
|
|
|
|
|
|
// copy the mega structure into the local variables for use in all subroutines
|
|
|
|
startX = ob_mega->feet_x;
|
|
startY = ob_mega->feet_y;
|
|
startDir = ob_mega->current_dir;
|
|
targetX = x;
|
|
targetY = y;
|
|
targetDir = dir;
|
|
|
|
scaleA = ob_mega->scale_a;
|
|
scaleB = ob_mega->scale_b;
|
|
|
|
|
|
// mega's current position goes into first node
|
|
node[0].x = startX;
|
|
node[0].y = startY;
|
|
node[0].level = 1;
|
|
node[0].prev = 0;
|
|
node[0].dist = 0;
|
|
|
|
// reset other nodes
|
|
for (i=1; i<nnodes; i++)
|
|
{
|
|
node[i].level = 0;
|
|
node[i].prev = 0;
|
|
node[i].dist = 9999;
|
|
}
|
|
|
|
// target position goes into final node
|
|
node[nnodes].x = targetX;
|
|
node[nnodes].y = targetY;
|
|
node[nnodes].level = 0;
|
|
node[nnodes].prev = 0;
|
|
node[nnodes].dist = 9999;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------------------
|
|
void PlotWalkGrid(void)
|
|
{
|
|
int32 j;
|
|
|
|
|
|
LoadWalkGrid(); // get walk grid file + extra grid into 'bars' & 'node' arrays
|
|
|
|
//-------------------------------
|
|
// lines
|
|
|
|
for (j=0; j<nbars; j++)
|
|
{
|
|
DrawLine(bars[j].x1,bars[j].y1, bars[j].x2,bars[j].y2, 254);
|
|
}
|
|
//-------------------------------
|
|
// nodes
|
|
|
|
for (j=1; j<nnodes; j++) // leave node 0 for start node
|
|
{
|
|
PlotCross(node[j].x,node[j].y, 184);
|
|
}
|
|
//-------------------------------
|
|
}
|
|
//------------------------------------------------------------------------------------------
|
|
void PlotCross(int16 x, int16 y, uint8 colour)
|
|
{
|
|
DrawLine(x-1, y-1, x+1, y+1, colour);
|
|
DrawLine(x+1, y-1, x-1, y+1, colour);
|
|
}
|
|
//------------------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------------------
|
|
|
|
void LoadWalkGrid(void)
|
|
{
|
|
// _standardHeader header;
|
|
_walkGridHeader floorHeader;
|
|
uint32 j;
|
|
uint8 *fPolygrid;
|
|
int entry;
|
|
uint32 theseBars;
|
|
uint32 theseNodes;
|
|
|
|
|
|
nbars = 0; // reset counts
|
|
nnodes = 1; // leave node 0 for start-node
|
|
|
|
//-------------------------------
|
|
// STATIC GRIDS (added/removed by object logics)
|
|
|
|
for (entry=0; entry < MAX_WALKGRIDS; entry++) // go through walkgrid list
|
|
{
|
|
if (walkGridList[entry])
|
|
{
|
|
fPolygrid = res_man.Res_open(walkGridList[entry]); // open walk grid file
|
|
|
|
// memmove( (uint8*)&header, fPolygrid, sizeof(_standardHeader) );
|
|
fPolygrid += sizeof(_standardHeader);
|
|
|
|
memmove( (uint8*)&floorHeader, fPolygrid, sizeof(_walkGridHeader) );
|
|
fPolygrid += sizeof(_walkGridHeader);
|
|
|
|
//-------------------------------
|
|
// how many bars & nodes are we getting from this walkgrid file
|
|
|
|
theseBars = floorHeader.numBars;
|
|
theseNodes = floorHeader.numNodes;
|
|
|
|
//-------------------------------
|
|
// check that we're not going to exceed the max allowed in the complete walkgrid arrays
|
|
|
|
#ifdef _BS2_DEBUG
|
|
if ((nbars+theseBars) >= O_GRID_SIZE)
|
|
Con_fatal_error("Adding walkgrid(%d): %d+%d bars exceeds max %d (%s line %u)", walkGridList[entry], nbars, theseBars, O_GRID_SIZE, __FILE__, __LINE__);
|
|
|
|
if ((nnodes+theseNodes) >= O_GRID_SIZE)
|
|
Con_fatal_error("Adding walkgrid(%d): %d+%d nodes exceeds max %d (%s line %u)", walkGridList[entry], nnodes, theseBars, O_GRID_SIZE, __FILE__, __LINE__);
|
|
#endif
|
|
|
|
//-------------------------------
|
|
// lines
|
|
|
|
memmove( (uint8*)&bars[nbars], fPolygrid, theseBars*sizeof(_barData) );
|
|
fPolygrid += theseBars*sizeof(_barData);//move pointer to start of node data
|
|
|
|
//-------------------------------
|
|
// nodes
|
|
|
|
for (j=0; j<theseNodes; j++) // leave node 0 for start node
|
|
{
|
|
memmove( (uint8*)&node[nnodes+j].x, fPolygrid, 2*sizeof(int16) );
|
|
fPolygrid += 2*sizeof(int16);
|
|
}
|
|
|
|
//-------------------------------
|
|
|
|
res_man.Res_close(walkGridList[entry]); // close walk grid file
|
|
|
|
nbars += theseBars; // increment counts of total bars & nodes in whole walkgrid
|
|
nnodes += theseNodes;
|
|
}
|
|
}
|
|
|
|
//-------------------------------
|
|
// EXTRA GRIDS (moveable grids added by megas)
|
|
|
|
// Note that these will be checked against allowed max at the time of creating them
|
|
|
|
//-------------------------------
|
|
// extra lines
|
|
|
|
memmove((uint8 *) &bars[nbars], (uint8 *) &extraBars[0], nExtraBars*sizeof(_barData));
|
|
nbars += nExtraBars;
|
|
|
|
//-------------------------------
|
|
// extra nodes
|
|
|
|
memmove((uint8 *) &node[nnodes], (uint8 *) &extraNode[0], nExtraNodes*sizeof(_nodeData));
|
|
nnodes += nExtraNodes;
|
|
|
|
//-------------------------------
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------
|
|
void ClearWalkGridList(void)
|
|
{
|
|
int entry;
|
|
|
|
for (entry=0; entry < MAX_WALKGRIDS; entry++)
|
|
walkGridList[entry] = 0;
|
|
}
|
|
//------------------------------------------------------------------------------------------
|
|
// called from FN_add_walkgrid
|
|
void AddWalkGrid(int32 gridResource)
|
|
{
|
|
int entry;
|
|
|
|
// first, scan list to see if this grid is already included
|
|
entry=0;
|
|
while ((entry < MAX_WALKGRIDS) && (walkGridList[entry] != gridResource))
|
|
entry++;
|
|
|
|
if (entry == MAX_WALKGRIDS) // if this new resource isn't already in the list, then add it, (otherwise finish)
|
|
{
|
|
// scan the list for a free slot
|
|
entry=0;
|
|
while ((entry < MAX_WALKGRIDS) && (walkGridList[entry]))
|
|
entry++;
|
|
|
|
if (entry < MAX_WALKGRIDS) // if we found a free slot
|
|
walkGridList[entry] = gridResource;
|
|
else
|
|
Con_fatal_error("ERROR: walkGridList[] full in %s line %d",__FILE__,__LINE__);
|
|
}
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
// called from FN_remove_walkgrid
|
|
void RemoveWalkGrid(int32 gridResource)
|
|
{
|
|
int entry;
|
|
|
|
// first, scan list to see if this grid is actually there
|
|
entry=0;
|
|
while ((entry < MAX_WALKGRIDS) && (walkGridList[entry] != gridResource))
|
|
entry++;
|
|
|
|
if (entry < MAX_WALKGRIDS) // if we've found it in the list, reset entry to zero (otherwise just ignore the request)
|
|
walkGridList[entry] = 0;
|
|
}
|
|
//--------------------------------------------------------------------------------------
|
|
|