1067 lines
77 KiB
C++
1067 lines
77 KiB
C++
//
|
|
// 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
|
|
|