mirrors
/
CnC_Remastered_Collection
mirror of https://github.com/electronicarts/CnC_Remastered_Collection.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/INLINE.H

1067 lines
77 KiB
C++
Raw Normal View History

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 20:16:20 +01:00
//
// 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