CodeMirror/CnC_Remastered_Collection
1
0
Fork 0
mirror of https://github.com/electronicarts/CnC_Remastered_Collection synced 2024-04-27 08:52:32 +12:00
Code Issues Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/INLINE.H
PG-SteveT 03416d24e1 Initial Source Code commit 
Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
2020-05-27 12:16:20 -07:00

1067 lines
77 KiB
C++
Raw Permalink Blame History

//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free
// software: you can redistribute it and/or modify it under the terms of
// the GNU General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
// in the hope that it will be useful, but with permitted additional restrictions
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
// distributed with this program. You should have received a copy of the
// GNU General Public License along with permitted additional restrictions
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
/* $Header: /CounterStrike/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<class T> 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<class T> 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
Reference in a new issue View git blame Copy permalink