// // Copyright 2020 Electronic Arts Inc. // // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free // software: you can redistribute it and/or modify it under the terms of // the GNU General Public License as published by the Free Software Foundation, // either version 3 of the License, or (at your option) any later version. // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed // in the hope that it will be useful, but with permitted additional restrictions // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT // distributed with this program. You should have received a copy of the // GNU General Public License along with permitted additional restrictions // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection /* $Header: /CounterStrike/INLINE.H 1 3/03/97 10:24a Joe_bostic $ */ /*********************************************************************************************** *** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S *** *********************************************************************************************** * * * Project Name : Command & Conquer * * * * File Name : INLINE.H * * * * Programmer : Joe L. Bostic * * * * Start Date : 08/21/96 * * * * Last Update : September 30, 1996 [JLB] * * * *---------------------------------------------------------------------------------------------* * Functions: * * Adjacent_Cell -- Calculate the adjacent cell in the direction specified. * * Adjacent_Cell -- Calculate the adjacent cell in the direction specified. * * Cell_Coord -- Convert a cell to a coordinate value. * * Cell_To_Lepton -- Convert a cell distance into a lepton distance. * * Cell_X -- Fetch the X cell component from the cell value. * * Cell_Y -- Fetch the Y cell component from the cell value specified. * * Coord_Add -- Adds coordinates together. * * Coord_Fraction -- Discards all but the sub-cell components of the coordinate. * * Coord_Mid -- Finds the midpoint between two coordinates. * * Coord_Snap -- Coerce coordinate to refer to center of a cell. * * Coord_Sub -- Subtracts one coordinate from another. * * Coord_Whole -- Discards the sub-cell components of the coordinate. * * Coord_X -- Fetches the X lepton component from a coordinate value. * * Coord_XCell -- Fetch the X cell component from a coordinate value. * * Coord_XLepton -- Fetch the X sub-cell lepton component from the coordinate. * * Coord_Y -- Fetch the Y lepton component from the coordinate value. * * Coord_YCell -- Fetch the Y cell component from a coordinate. * * Coord_YLepton -- Fetches the Y lepton sub-cell component from the coordinate. * * Dir_Facing -- Convert a DirType into a FacingType value. * * Dir_To_16 -- Convert a facing to a 0..15 value. * * Dir_To_32 -- Convert a DirType into a 0..31 value. * * Dir_To_8 -- Convert a DirType into a value from 0 to 7. * * Direction -- Calculates the DirType from one cell to another. * * Direction -- Determines the facing value from one coordinate to another. * * Direction256 -- Calculate the facing value from one coordinate to another. * * Direction8 -- Fetches the direction from one coordinate to another. * * Distance -- Finds the distance between two arbitrary points. * * Facing_Dir -- Convert a FacingType into a DirType. * * Lepton_To_Cell -- Convert lepton distance to cell distance. * * Lepton_To_Pixel -- Convert a lepton value into pixel value. * * Percent_Chance -- Calculate a percentage chance event. * * Pixel_To_Lepton -- Convert pixel value into lepton equivalent. * * Random_Pick -- Pick a random number in a specified range. * * Sim_Percent_Chance -- Calculates a percentage chance event for local events. * * Sim_Random_Pick -- Picks a random number that will not affect the game. * * Text_String -- Convert a text number into a text pointer. * * XYP_COORD -- Convert pixel components into a coordinate value. * * XYP_Coord -- Combine pixel values into a coordinate. * * XY_Cell -- Create a cell from X and Y cell components. * * XY_Coord -- Convert X Y lepton components into a COORD. * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #ifndef INLINE_H #define INLINE_H /*********************************************************************************************** * Lepton_To_Pixel -- Convert a lepton value into pixel value. * * * * Use this routine to convert the specified lepton value into it's pixel corresponding * * value. The pixel value returned will be the closest pixel value to the lepton value. It * * will round up or down as necessary. * * * * INPUT: lepton -- The lepton value to convert into a pixel value. * * * * OUTPUT: Returns with the lepton value rounded to the nearest pixel component. * * * * WARNINGS: Precision is not maintained by this routine. Thus, if a value is converted to * * pixel and then back to leptons, the value will probably not be the same. * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline int Lepton_To_Pixel(LEPTON lepton) { return (((int)(signed short)lepton * ICON_PIXEL_W) + (ICON_LEPTON_W / 2) - ((lepton < 0) ? (ICON_LEPTON_W - 1) : 0)) / ICON_LEPTON_W; } /*********************************************************************************************** * Pixel_To_Lepton -- Convert pixel value into lepton equivalent. * * * * This routine will take the specified pixel value and convert it into lepton value. * * * * INPUT: pixel -- The pixel value to convert. * * * * OUTPUT: Returns with the lepton equivalent of the pixel value specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline LEPTON Pixel_To_Lepton(int pixel) { return (LEPTON)(((pixel * ICON_LEPTON_W) + (ICON_PIXEL_W / 2) - ((pixel < 0) ? (ICON_PIXEL_W - 1) : 0)) / ICON_PIXEL_W); } /*********************************************************************************************** * XY_Coord -- Convert X Y lepton components into a COORD. * * * * This routine will take the specified X and Y lepton components and combine them into * * a coordinate value. * * * * INPUT: x,y -- The X and Y lepton components to combine. * * * * OUTPUT: Returns with a coordinate value that is created from the X and Y lepton components.* * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE XY_Coord(LEPTON x, LEPTON y) { COORD_COMPOSITE coord; coord.Sub.X.Raw = x; coord.Sub.Y.Raw = y; return(coord.Coord); } /*********************************************************************************************** * XYP_COORD -- Convert pixel components into a coordinate value. * * * * This routine will take the specified pixel components and convert and combine them into * * a coordinate value. * * * * INPUT: x,y -- The X and Y pixel components to coerce into a coordinate value. * * * * OUTPUT: Returns with the coordinate value that matches the pixel values specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE XYP_COORD(int x, int y) { return(XY_Coord(Pixel_To_Lepton(x), Pixel_To_Lepton(y))); } /*********************************************************************************************** * Coord_XCell -- Fetch the X cell component from a coordinate value. * * * * This routine will extract the X cell component from the coordinate value specified and * * return the value. * * * * INPUT: coord -- The coordinate value to extract the X component from. * * * * OUTPUT: Returns with the X cell component of the coordinate value. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline CELL Coord_XCell(COORDINATE coord) { return(((COORD_COMPOSITE &)coord).Sub.X.Sub.Cell); } /*********************************************************************************************** * Coord_YCell -- Fetch the Y cell component from a coordinate. * * * * This routine will extract the Y cell component from the coordinate value specified. * * * * INPUT: coord -- The coordinate to extract the Y cell from. * * * * OUTPUT: Returns with just the Y cell component of the coordinate value. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline CELL Coord_YCell(COORDINATE coord) { return(((COORD_COMPOSITE &)coord).Sub.Y.Sub.Cell); } /*********************************************************************************************** * XY_Cell -- Create a cell from X and Y cell components. * * * * This routine will construct a cell value by taking the X and Y cell value components * * and combining them appropriately. * * * * INPUT: x,y -- The X and Y cell components to combine. * * * * OUTPUT: Returns with the CELL value created from the specified components. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline CELL XY_Cell(int x, int y) { CELL_COMPOSITE cell; cell.Cell = 0; cell.Sub.X = x; cell.Sub.Y = y; return(cell.Cell); } /*********************************************************************************************** * Cell_To_Lepton -- Convert a cell distance into a lepton distance. * * * * This routine will take the cell distance specified and convert it into a lepton distance.* * * * INPUT: cell_distance -- The distance in cells to convert. * * * * OUTPUT: Returns with the lepton equivalent of the cell distance specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline LEPTON Cell_To_Lepton(int cell_distance) { LEPTON_COMPOSITE lepton; lepton.Sub.Cell = (unsigned char)cell_distance; lepton.Sub.Lepton = 0; return(lepton.Raw); } /*********************************************************************************************** * Lepton_To_Cell -- Convert lepton distance to cell distance. * * * * This routine will convert the specified lepton distance into the closest cell distance * * possible. This might require rounding up or down as necessary. * * * * INPUT: lepton_distance -- The lepton distance to convert. * * * * OUTPUT: Returns with the cell distance that most closely corresponds to the lepton * * distance specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline int Lepton_To_Cell(LEPTON lepton_distance) { if (((LEPTON_COMPOSITE &)lepton_distance).Sub.Lepton >= (CELL_LEPTON_W/2)) { return(((LEPTON_COMPOSITE &)lepton_distance).Sub.Cell + 1); } return(((LEPTON_COMPOSITE &)lepton_distance).Sub.Cell); } /*********************************************************************************************** * Coord_X -- Fetches the X lepton component from a coordinate value. * * * * This routine will extract the X lepton component from the coordinate. * * * * INPUT: coord -- The coordinate to extract the X lepton equivalent from. * * * * OUTPUT: Returns with the X lepton portion of the coordinate value specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline LEPTON Coord_X(COORDINATE coord) { return(((COORD_COMPOSITE &)coord).Sub.X.Raw); } /*********************************************************************************************** * Coord_Y -- Fetch the Y lepton component from the coordinate value. * * * * This routine will extract the Y lepton component from the coordinate value specified. * * * * INPUT: coord -- The coordinate value to dissect. * * * * OUTPUT: Returns with the Y lepton component from the specified coordinate value. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline LEPTON Coord_Y(COORDINATE coord) { return(((COORD_COMPOSITE &)coord).Sub.Y.Raw); } /*********************************************************************************************** * Cell_X -- Fetch the X cell component from the cell value. * * * * This routine will extract the X cell component from the cell value specified. * * * * INPUT: cell -- The cell to extract. * * * * OUTPUT: Returns with the X cell component portion of the cell value specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline int Cell_X(CELL cell) { return(((CELL_COMPOSITE &)cell).Sub.X); } /*********************************************************************************************** * Cell_Y -- Fetch the Y cell component from the cell value specified. * * * * This routine will extract the Y cell component from the cell value. * * * * INPUT: cell -- The cell value to extract from. * * * * OUTPUT: Returns with the Y cell component of the cell value specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline int Cell_Y(CELL cell) { return(((CELL_COMPOSITE &)cell).Sub.Y); } /*********************************************************************************************** * Coord_XLepton -- Fetch the X sub-cell lepton component from the coordinate. * * * * This routine will extract just the X sub cell lepton component from the coordinate * * specified. * * * * INPUT: coord -- The coordinate value to extract from. * * * * OUTPUT: Returns with the X lepton component of the coordinate that is part of the cell. * * Thus, a coordinate that exactly lines up on the left edge of a cell would return * * zero. One that exactly lines up on the right edge would return CELL_LEPTON_W. * * * * WARNINGS: none * * * * HISTORY: * * 08/21/1996 JLB : Created. * *=============================================================================================*/ inline int Coord_XLepton(COORDINATE coord) { return(((COORD_COMPOSITE &)coord).Sub.X.Sub.Lepton); } /*********************************************************************************************** * Coord_YLepton -- Fetches the Y lepton sub-cell component from the coordinate. * * * * This routine will extract the sub-cell Y lepton portion of the coordinate. * * * * INPUT: coord -- The coordinate to dissect. * * * * OUTPUT: Returns with just the Y lepton portion of the coordinate and only for the sub-cell * * it refers to. * * * * WARNINGS: none * * * * HISTORY: * * 08/23/1996 JLB : Created. * *=============================================================================================*/ inline int Coord_YLepton(COORDINATE coord) { return(((COORD_COMPOSITE &)coord).Sub.Y.Sub.Lepton); } /*********************************************************************************************** * XYP_Coord -- Combine pixel values into a coordinate. * * * * This will convert X and Y pixel values into a coordinate. Primarily this is used for * * converting mouse clicks into coordinate values. * * * * INPUT: x,y -- The X and Y pixel coordinates to convert. Origin is upper left corner. * * * * OUTPUT: Returns with the coordinate that most closely corresponds to the pixel values * * specified. * * * * WARNINGS: The coordinate is relative to the upper left corner (0,0). To conver the * * coordinate to a game relative one, it must be biased by the display coordinate * * of the tactical map and the screen position of the tactical display. * * * * HISTORY: * * 08/23/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE XYP_Coord(int x, int y) { COORD_COMPOSITE coord; coord.Sub.X.Raw = Pixel_To_Lepton(x); coord.Sub.Y.Raw = Pixel_To_Lepton(y); return(coord.Coord); } /*********************************************************************************************** * Cell_Coord -- Convert a cell to a coordinate value. * * * * This routine will convert the specified cell into a coordinat value. The coordinate * * will refer to the center of the cell specified. * * * * INPUT: cell -- The cell to convert into a coordinate. * * * * OUTPUT: Returns with the coordinate that refers to the center of the cell specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/23/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE Cell_Coord(CELL cell) { COORD_COMPOSITE coord; coord.Sub.X.Sub.Cell = (unsigned char)(((CELL_COMPOSITE &)cell).Sub.X); coord.Sub.X.Sub.Lepton = (unsigned char)(CELL_LEPTON_W / 2); coord.Sub.Y.Sub.Cell = (unsigned char)(((CELL_COMPOSITE &)cell).Sub.Y); coord.Sub.Y.Sub.Lepton = (unsigned char)(CELL_LEPTON_W / 2); return(coord.Coord); } /*********************************************************************************************** * Coord_Snap -- Coerce coordinate to refer to center of a cell. * * * * This routine will take the specified coordinate and force it to refer to the center of * * the cell. * * * * INPUT: coord -- The coordinate to modify. * * * * OUTPUT: Returns with the specified coordinate after it has been modified to refer to the * * center of the cell. * * * * WARNINGS: none * * * * HISTORY: * * 08/23/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE Coord_Snap(COORDINATE coord) { ((COORD_COMPOSITE &)coord).Sub.X.Sub.Lepton = CELL_LEPTON_W/2; ((COORD_COMPOSITE &)coord).Sub.Y.Sub.Lepton = CELL_LEPTON_W/2; return(coord); } /*********************************************************************************************** * Coord_Fraction -- Discards all but the sub-cell components of the coordinate. * * * * Use this routine to discard the cell components of the coordinate, leaving only the * * sub-cell component. * * * * INPUT: coord -- The coordinate to modify. * * * * OUTPUT: Returns with just the sub-cell components intact from the supplied coordinate. * * * * WARNINGS: none * * * * HISTORY: * * 08/23/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE Coord_Fraction(COORDINATE coord) { ((COORD_COMPOSITE &)coord).Sub.X.Sub.Cell = 0; ((COORD_COMPOSITE &)coord).Sub.Y.Sub.Cell = 0; return(coord); } /*********************************************************************************************** * Coord_Whole -- Discards the sub-cell components of the coordinate. * * * * This routine will discard the sub-cell components, leaving only the whole cell portion. * * * * INPUT: coord -- The coordinate to modify. * * * * OUTPUT: Returns with only the whole cell components of the coordinate intact. The * * resulting coordinate will refer to the upper left corner of the cell. * * * * WARNINGS: none * * * * HISTORY: * * 08/23/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE Coord_Whole(COORDINATE coord) { ((COORD_COMPOSITE &)coord).Sub.X.Sub.Lepton = 0; ((COORD_COMPOSITE &)coord).Sub.Y.Sub.Lepton = 0; return(coord); } /*********************************************************************************************** * Coord_Add -- Adds coordinates together. * * * * This routine will add one coordinate to another. Actually, it adds the X and Y components* * separately (signed) and then recombines them back into a coordinate. * * * * INPUT: coord1 -- One coordinate to add. * * * * coord2 -- The other coordinate to add. * * * * OUTPUT: Returns with the logical add of the two coordinates. * * * * WARNINGS: none * * * * HISTORY: * * 08/23/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE Coord_Add(COORDINATE coord1, COORDINATE coord2) { COORD_COMPOSITE coord; coord.Sub.X.Raw = (LEPTON)((int)(short)((COORD_COMPOSITE &)coord1).Sub.X.Raw + (int)(short)((COORD_COMPOSITE &)coord2).Sub.X.Raw); coord.Sub.Y.Raw = (LEPTON)((int)(short)((COORD_COMPOSITE &)coord1).Sub.Y.Raw + (int)(short)((COORD_COMPOSITE &)coord2).Sub.Y.Raw); return(coord.Coord); } /*********************************************************************************************** * Coord_Sub -- Subtracts one coordinate from another. * * * * This routine will subtract one coordinate from the other. The coordinates are broken * * up into their X and Y components, the subtraction is performed, and then they are * * recombined back into a coordinate to be returned. * * * * INPUT: coord1 -- The coordinate to be subtracted from. * * * * coord2 -- The coordinate to subtract. * * * * OUTPUT: Returns with the result of subtracting coord2 from coord1. * * * * WARNINGS: none * * * * HISTORY: * * 08/23/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE Coord_Sub(COORDINATE coord1, COORDINATE coord2) { COORD_COMPOSITE coord; coord.Sub.X.Raw = (LEPTON)((int)(short)((COORD_COMPOSITE &)coord1).Sub.X.Raw - (int)(short)((COORD_COMPOSITE &)coord2).Sub.X.Raw); coord.Sub.Y.Raw = (LEPTON)((int)(short)((COORD_COMPOSITE &)coord1).Sub.Y.Raw - (int)(short)((COORD_COMPOSITE &)coord2).Sub.Y.Raw); return(coord.Coord); } /*********************************************************************************************** * Coord_Mid -- Finds the midpoint between two coordinates. * * * * This will find the coordinate that is exactly between the two coordinates specified. * * * * INPUT: coord1 -- The first coordinate. * * * * coord2 -- The second coordinate. * * * * OUTPUT: Returns with the midpoint between the two coordinates. * * * * WARNINGS: none * * * * HISTORY: * * 08/23/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE Coord_Mid(COORDINATE coord1, COORDINATE coord2) { COORD_COMPOSITE coord; coord.Sub.X.Raw = (LEPTON)(((int)((COORD_COMPOSITE &)coord1).Sub.X.Raw + (int)((COORD_COMPOSITE &)coord2).Sub.X.Raw) / 2); coord.Sub.Y.Raw = (LEPTON)(((int)((COORD_COMPOSITE &)coord1).Sub.Y.Raw + (int)((COORD_COMPOSITE &)coord2).Sub.Y.Raw) / 2); return(coord.Coord); } /*********************************************************************************************** * Dir_Facing -- Convert a DirType into a FacingType value. * * * * Use this routine to convert the specified DirType value into the closest FacingType * * value that matches it. * * * * INPUT: facing -- The DirType to convert. * * * * OUTPUT: Returns with a FacingType value that most closely matches the DirType specified. * * * * WARNINGS: Precision of direction is lost by this transformation. * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline FacingType Dir_Facing(DirType facing) { return (FacingType)(((unsigned char)((int)facing+0x10)&0xFF)>>5); } /*********************************************************************************************** * Facing_Dir -- Convert a FacingType into a DirType. * * * * This will conver the specified FacingType value into the DirType that exactly matches * * it. * * * * INPUT: facing -- The FacingType to convert. * * * * OUTPUT: Returns with the DirType that exactly matches the facing. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline DirType Facing_Dir(FacingType facing) { return (DirType)((int)facing << 5); } /*********************************************************************************************** * Dir_To_16 -- Convert a facing to a 0..15 value. * * * * Use this routine to convert a DirType into a 0 through 15 value. * * * * INPUT: facing -- The DirType to convert into a 0..15 value. * * * * OUTPUT: Returns with the facing converted into a value where 0 equals North, 4 equals * * East, 8 equals South, etc. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline int Dir_To_16(DirType facing) { return Facing16[facing]; } /*********************************************************************************************** * Dir_To_32 -- Convert a DirType into a 0..31 value. * * * * This will convert the DirType specified, into a 0 through 31 value where zero is North, * * and rotates clockwise. The return value is baised to take into consideration the * * distortion caused by 3D studio upon the game vehicle objects. * * * * INPUT: facing -- The DirType to convert. * * * * OUTPUT: Returns with the facing converted into a value from zero to 31. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline int Dir_To_32(DirType facing) { return Facing32[facing]; } /*********************************************************************************************** * Direction256 -- Calculate the facing value from one coordinate to another. * * * * This will calculate the facing from the first coordinate to the second. * * * * INPUT: coord1 -- The first coordinate that facing will be calculated from. * * * * coord2 -- The second coordinate that facing will be calcuated to. * * * * OUTPUT: Returns with the DirType that is the facing from coord1 to coord2. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline DirType Direction256(COORDINATE coord1, COORDINATE coord2) { return (Desired_Facing256(Coord_X(coord1), Coord_Y(coord1), Coord_X(coord2), Coord_Y(coord2))); } /*********************************************************************************************** * Direction -- Determines the facing value from one coordinate to another. * * * * This will determine the DirType from the first coordinate to the second. * * * * INPUT: coord1 -- The first coordinate that facing will be calculated from. * * * * coord2 -- The second coordinate to calculate facing to. * * * * OUTPUT: Returns with the DirType that represents the facing from coordinate 1 to coordinate* * 2. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline DirType Direction(COORDINATE coord1, COORDINATE coord2) { return (Desired_Facing256(Coord_X(coord1), Coord_Y(coord1), Coord_X(coord2), Coord_Y(coord2))); } /*********************************************************************************************** * Direction8 -- Fetches the direction from one coordinate to another. * * * * This will calculate the facing from the first coordinate to the second. The return value * * is of limited accuracy, but the calculation is fast. * * * * INPUT: coord1 -- The coordinate to calculate the facing from. * * * * coord2 -- The coordinate to figure the facing to. * * * * OUTPUT: Returns with the DirType to get from coordinate 1 to coordinate 2. * * * * WARNINGS: The return DirType is only accurate to the 8 primary compass rose directions. * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline DirType Direction8(COORDINATE coord1, COORDINATE coord2) { return (Desired_Facing8(Coord_X(coord1), Coord_Y(coord1), Coord_X(coord2), Coord_Y(coord2))); } /*********************************************************************************************** * Direction -- Calculates the DirType from one cell to another. * * * * This routine will calculate the facing to get from one cell to another. Since dealing * * with cells is much less precise than with coordinates, the return value is only * * accurate to 8 facings. * * * * INPUT: cell1 -- The cell to calculate the DirType from. * * * * cell2 -- The cell to calculate the DirType to. * * * * OUTPUT: Returns with the DirType to get from the first cell to the second. * * * * WARNINGS: The return value is only accurate to the 8 primary compass rose directions. * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline DirType Direction(CELL cell1, CELL cell2) { return (Desired_Facing8(Cell_X(cell1), Cell_Y(cell1), Cell_X(cell2), Cell_Y(cell2))); } /*********************************************************************************************** * Adjacent_Cell -- Calculate the adjacent cell in the direction specified. * * * * This will coerce the coordinate specified so that it will refer to the immediately * * adjacent cell in the direction specified. * * * * INPUT: coord -- The coordinate to calculate the adjacency from. * * * * dir -- The direction to travel to calculate the adjacent cell. * * * * OUTPUT: Returns with the coordinate the refers to the adjacent cell in the direciton * * specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE Adjacent_Cell(COORDINATE coord, FacingType dir) { return (Coord_Snap(Coord_Add(AdjacentCoord[(int)dir & 0x07], coord))); } /*********************************************************************************************** * Adjacent_Cell -- Calculate the adjacent cell in the direction specified. * * * * This will coerce the coordinate specified so that it will refer to the immediately * * adjacent cell in the direction specified. * * * * INPUT: coord -- The coordinate to calculate the adjacency from. * * * * dir -- The direction to travel to calculate the adjacent cell. * * * * OUTPUT: Returns with the coordinate the refers to the adjacent cell in the direciton * * specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline COORDINATE Adjacent_Cell(COORDINATE coord, DirType dir) { return Adjacent_Cell(coord, Dir_Facing(dir)); } /*********************************************************************************************** * Adjacent_Cell -- Calculate the adjacent cell in the direction specified. * * * * This routine will take the specified cell and coerce it to refer to the immediately * * adjacent cell in the direction specified. * * * * INPUT: cell -- The cell to coerce into an adjacent cell. * * * * dir -- The direction to determine the adjacent cell. * * * * OUTPUT: Returns with the cell value that represents the adjacent cell in the direction * * specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline CELL Adjacent_Cell(CELL cell, FacingType dir) { return (CELL)(cell + AdjacentCell[dir]); } /*********************************************************************************************** * Adjacent_Cell -- Calculate the adjacent cell in the direction specified. * * * * This routine will take the specified cell and coerce it to refer to the immediately * * adjacent cell in the direction specified. * * * * INPUT: cell -- The cell to coerce into an adjacent cell. * * * * dir -- The direction to determine the adjacent cell. * * * * OUTPUT: Returns with the cell value that represents the adjacent cell in the direction * * specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline CELL Adjacent_Cell(CELL cell, DirType dir) { return (CELL)(cell + AdjacentCell[Dir_Facing(dir)]); } /*********************************************************************************************** * Dir_To_8 -- Convert a DirType into a value from 0 to 7. * * * * This routine will convert a DirType value into a facing number from 0 to 7. * * * * INPUT: facing -- The DirType to convert. * * * * OUTPUT: Returns with the DirType converted to a number from 0 to 7 with 0 being North and * * rotating clockwise. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline FacingType Dir_To_8(DirType facing) { return (FacingType)(((unsigned char)((int)facing|0x10))>>5); } /*********************************************************************************************** * Text_String -- Convert a text number into a text pointer. * * * * This routine will convert text numbers (as generated elsewhere) into an actual text * * pointer that can be used for normal purposes. * * * * INPUT: string -- The text number to extract a pointer to. * * * * OUTPUT: Returns with a pointer to the text that represents the text number specified. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline char const * Text_String(int string) { #ifdef FIXIT_NAME_OVERRIDE if (string < 0 && abs(string) < ARRAY_SIZE(NameOverride)) { return(NameOverride[-(string+1)]); } #endif if (string < 1000) return(Extract_String(SystemStrings, string)); return(Extract_String(DebugStrings, string-1000)); } /*********************************************************************************************** * Random_Pick -- Pick a random number in a specified range. * * * * This routine is used to pick a game influencing random number between (inclusive) the * * range specified. * * * * INPUT: a -- Low limit of range to pick from. * * * * b -- High limit of range to pick from. * * * * OUTPUT: Returns with a random number picked between (inclusive) the range of values * * specified. * * * * WARNINGS: none * * * * HISTORY: * * 09/30/1996 JLB : Created. * *=============================================================================================*/ template inline T Random_Pick(T a, T b) { return T(Scen.RandomNumber((int)a, (int)b)); }; /*********************************************************************************************** * Percent_Chance -- Calculate a percentage chance event. * * * * This will calculate a percentage chance and return with 'true' as likely as the * * chance value would occur (or less) on a random pick from 1 to 100. Thus a * * Percent_Chance(50) would return 'true' 50 percent of the time. Percent_Chance(25) would * * return 'true' 25% of the time, etc. * * * * INPUT: percent -- The percent value to calculate the chance upon. * * * * OUTPUT: Returns with 'true' in the same percentage as the percentage number supplied. * * * * WARNINGS: This affects the game syncronization random number generator and should be used * * for those events that could affect the game engine. * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline bool Percent_Chance(int percent) { return (Scen.RandomNumber(0, 99) < percent); } /*********************************************************************************************** * Sim_Random_Pick -- Picks a random number that will not affect the game. * * * * Use this routine to pick a random number such that it will be used so that it won't * * actually affect the outcome of the game. It is critical to use this routine for any * * random need that won't be needed on other machines in a multiplayer game. The result * * can be freely used as long as it doesn't affect the outcome of the game. * * * * INPUT: a -- Low range of the random number to pick. * * * * b -- High range of the random number to pick. * * * * OUTPUT: Returns with a random number between (inclusive) the range limit values * * specified. * * * * WARNINGS: none * * * * HISTORY: * * 09/30/1996 JLB : Created. * *=============================================================================================*/ extern RandomClass NonCriticalRandomNumber; template inline T Sim_Random_Pick(T a, T b) { return T(NonCriticalRandomNumber((int)a, (int)b)); }; /*********************************************************************************************** * Sim_Percent_Chance -- Calculates a percentage chance event for local events. * * * * This routine is similar to the normal Percent_Chance() routine except that it doesn't * * alter the main random number gerenator sequence. As such, this routine should be used * * for those events that should have a random character, but will either not affect the * * game engine or are only calculated on one machine in a multiplayer game. * * * * INPUT: percent -- The percent chance to calculate the possible return of 'true' on. * * * * OUTPUT: Returns 'true' with the same percentage chance as the percent number specified. * * A percent value of 50 means 50%, 25 means 25%, etc. * * * * WARNINGS: none * * * * HISTORY: * * 08/26/1996 JLB : Created. * *=============================================================================================*/ inline bool Sim_Percent_Chance(int percent) { return (NonCriticalRandomNumber(0, 99) < percent); } /*********************************************************************************************** * Distance -- Finds the distance between two arbitrary points. * * * * This finds the (Dragon Strike) distance between two arbitrary points in flat space. * * It does this by adding 1/2 the smaller absolute axis difference to the other absolute * * axis distance. The result is rough but quick to calculate. * * * * INPUT: x1,y1 -- Coordinate location for point 1. * * * * x2,y2 -- Coordinate location for point 2. * * * * OUTPUT: Returns with the rough distance between the two points. The value returned is * * expressed in the same units as the parameters were specified in. * * * * WARNINGS: none * * * * HISTORY: * * 09/30/1996 JLB : Created. * *=============================================================================================*/ inline int Distance(int x1, int y1, int x2, int y2) { int diff1 = y1 - y2; if (diff1 < 0) diff1 = -diff1; int diff2 = x1 - x2; if (diff2 < 0) diff2 = -diff2; if (diff1 > diff2) { return(diff1 + ((unsigned)diff2 / 2)); } return(diff2 + ((unsigned)diff1 / 2)); } #endif