/* 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 _SWORD2_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 _SWORD2_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 _SWORD2_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; slowInFrameNowalk_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 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 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 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= 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