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/TIBERIANDAWN/CELL.CPP

2735 lines
119 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: F:\projects\c&c\vcs\code\cell.cpv 2.18 16 Oct 1995 16:49:20 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 : CELL.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : April 29, 1994 *
* *
* Last Update : August 17, 1995 [JLB] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* CellClass::Adjacent_Cell -- Determines the adjacent cell according to facing. *
* CellClass::Adjust_Threat -- Allows adjustment of threat at cell level *
* CellClass::CellClass -- Constructor for cell objects. *
* CellClass::Cell_Building -- Return with building at specified cell. *
* CellClass::Cell_Color -- Determine what radar color to use for this cell. *
* CellClass::Cell_Coord -- Returns the coordinate of this cell. *
* CellClass::Cell_Find_Object -- Returns ptr to RTTI type occupying cell *
* CellClass::Cell_Infantry -- Returns with pointer of first infantry unit. *
* CellClass::Cell_Object -- Returns with clickable object in cell. *
* CellClass::Cell_Techno -- Return with the unit/building at specified cell. *
* CellClass::Cell_Terrain -- Determines terrain object in cell. *
* CellClass::Cell_Unit -- Returns with pointer to unit occupying cell. *
* CellClass::Clear_Icon -- Calculates what the clear icon number should be. *
* CellClass::Closest_Free_Spot -- returns free spot closest to given coord *
* CellClass::Concrete_Calc -- Calculates the concrete icon to use for the cell. *
* CellClass::Draw_It -- Draws the cell imagery at the location specified. *
* CellClass::Flag_Place -- Places a house flag down on the cell. *
* CellClass::Flag_Remove -- Removes the house flag from the cell. *
* CellClass::Cell_Occupier -- Fetches the occupier for the cell. *
* CellClass::Get_Trigger -- retrieves reference to the cell's trigger *
* CellClass::Goodie_Check -- Performs crate discovery logic. *
* CellClass::Incoming -- Causes objects in cell to "run for cover". *
* CellClass::Is_Generally_Clear -- Determines if cell can be built upon. *
* CellClass::Occupy_Down -- Flag occupation of specified cell. *
* CellClass::Occupy_Unit -- Marks cell as unit occupied. *
* CellClass::Occupy_Up -- Removes occupation flag from the specified cell. *
* CellClass::Overlap_Down -- This routine is used to mark a cell as being spilled over (overla*
* CellClass::Overlap_Unit -- Marks cell as being overlapped by unit. *
* CellClass::Overlap_Up -- Removes overlap flag for the cell. *
* CellClass::Read -- Reads a particular cell value from a save game file. *
* CellClass::Recalc_Attributes -- Recalculates the ground type attributes for the cell. *
* CellClass::Redraw_Objects -- Redraws all objects overlapping this cell. *
* CellClass::Reduce_Tiberium -- Reduces the tiberium in the cell by the amount specified. *
* CellClass::Reduce_Wall -- Damages a wall, if damage is high enough. *
* CellClass::Reserve_Cell -- Marks a cell as being occupied by the specified unit ID. *
* CellClass::Shimmer -- Causes all objects in the cell to shimmer. *
* CellClass::Spot_Index -- returns cell sub-coord index for given COORD *
* CellClass::Tiberium_Adjust -- Adjust the look of the Tiberium for smooth. *
* CellClass::Validate -- validates cell's number *
* CellClass::Wall_Update -- Updates the imagery for wall objects in cell. *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
/*
** New sidebar for GlyphX multiplayer. ST - 3/26/2019 12:24PM
*/
#include "SidebarGlyphx.h"
#define FIXUP 0
/***********************************************************************************************
* CellClass::Validate -- validates cell's number *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* 1 = ok, 0 = error *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 08/09/1995 BRR : Created. *
*=============================================================================================*/
#ifdef CHEAT_KEYS
int CellClass::Validate(void) const
{
int num;
num = Cell_Number();
if (num < 0 || num > 4095) {
Validate_Error("CELL");
return (0);
}
else
return (1);
}
#else
#define Validate()
#endif
/***********************************************************************************************
* CellClass::CellClass -- Constructor for cell objects. *
* *
* A cell object is constructed into an empty state. It contains no specific objects, *
* templates, or overlays. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/09/1994 JLB : Created. *
*=============================================================================================*/
CellClass::CellClass(void)
{
memset(this, 0, sizeof(CellClass));
Overlay = OVERLAY_NONE;
Smudge = SMUDGE_NONE;
TType = TEMPLATE_NONE;
Owner = HOUSE_NONE;
InfType = HOUSE_NONE;
OverrideLand = LAND_COUNT;
}
/***********************************************************************************************
* CellClass::Cell_Color -- Determine what radar color to use for this cell. *
* *
* Use this routine to determine what radar color to render a radar *
* pixel with. This routine is called many many times to render the *
* radar map, so it must be fast. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the color to display the radar pixel with. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/01/1994 JLB : Created. *
* 04/30/1994 JLB : Converted to member function. *
* 05/31/1994 JLB : Takes into account any stealth characteristics of object. *
*=============================================================================================*/
int CellClass::Cell_Color(bool override) const
{
Validate();
BuildingClass * object = Cell_Building();
if (object) {
return(object->House->Class->Color);
}
if (override) {
return(TBLACK);
}
return(::Ground[Land_Type()].Color);
}
/***********************************************************************************************
* CellClass::Cell_Techno -- Return with the unit/building at specified cell. *
* *
* Returns an object located in the cell. If there is a *
* building present, it returns a pointer to that, otherwise it returns *
* a pointer to one of the units there. If nothing is present in the *
* specified cell, then it returns NULL. *
* *
* INPUT: x,y -- Coordinate offset (from upper left corner) to use as an aid in selecting *
* the desired object within the cell. *
* *
* OUTPUT: Returns a pointer to a building or unit located in cell. If *
* nothing present, just returns NULL. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/05/1992 JLB : Created. *
* 04/30/1994 JLB : Converted to member function. *
*=============================================================================================*/
TechnoClass * CellClass::Cell_Techno(int x, int y) const
{
Validate();
ObjectClass * object;
COORDINATE click; // Coordinate of click relative to cell corner.
TechnoClass * close = NULL;
long distance = 0; // Recorded closest distance.
/*
** Create a coordinate value that represent the pixel location within the cell. This is
** actually the lower significant bits (leptons) of a regular coordinate value.
*/
click = XY_Coord(Pixel_To_Lepton(x), Pixel_To_Lepton(y));
if (Cell_Occupier()) {
object = Cell_Occupier();
while (object) {
if (object->Is_Techno()) {
COORDINATE coord; // Coordinate relative to cell corner.
long dist;
coord = object->Center_Coord() & 0x00FF00FFL;
dist = Distance(coord, click);
if (!close || dist < distance) {
close = (TechnoClass *)object;
distance = dist;
}
}
object = object->Next;
}
}
return(close);
}
/***************************************************************************
* CellClass::Cell_Find_Object -- Returns ptr to RTTI type occupying cell *
* *
* INPUT: RTTIType the RTTI type we are searching for *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/17/1995 PWG : Created. *
* 06/12/1995 JLB : Returns object class pointer. *
*=========================================================================*/
ObjectClass * CellClass::Cell_Find_Object(RTTIType rtti) const
{
Validate();
ObjectClass * object = Cell_Occupier();
while (object) {
if (object->What_Am_I() == rtti) {
return(object);
}
object = object->Next;
}
return(NULL);
}
/***********************************************************************************************
* CellClass::Cell_Building -- Return with building at specified cell. *
* *
* Given a cell, determine if there is a building associated *
* and return with a pointer to this building. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with a pointer to the building associated with the *
* cell. If there is no building associated, then NULL is *
* returned. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/05/1992 JLB : Created. *
* 04/30/1994 JLB : Converted to member function. *
*=============================================================================================*/
BuildingClass * CellClass::Cell_Building(void) const
{
Validate();
return((BuildingClass *)Cell_Find_Object(RTTI_BUILDING));
}
/***********************************************************************************************
* CellClass::Cell_Terrain -- Determines terrain object in cell. *
* *
* This routine is used to determine the terrain object (if any) that *
* overlaps this cell. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with a pointer to the terrain object that overlaps *
* this cell. If there is no terrain object present, then NULL *
* is returned. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/18/1994 JLB : Created. *
*=============================================================================================*/
TerrainClass * CellClass::Cell_Terrain(void) const
{
Validate();
return((TerrainClass *)Cell_Find_Object(RTTI_TERRAIN));
}
/***********************************************************************************************
* CellClass::Cell_Object -- Returns with clickable object in cell. *
* *
* This routine is used to determine which object is to be selected *
* by a player click upon the cell. Not all objects that overlap the *
* cell are selectable by the player. This routine sorts out which *
* is which and returns with the appropriate object pointer. *
* *
* INPUT: x,y -- Coordinate (from upper left corner of cell) to use as a guide when *
* selecting the object within the cell. This plays a role in those cases *
* where several objects (such as infantry) exist within the same cell. *
* *
* OUTPUT: Returns with pointer to the object clickable within the *
* cell. NULL is returned if there is no clickable object *
* present. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/13/1994 JLB : Created. *
*=============================================================================================*/
ObjectClass * CellClass::Cell_Object(int x, int y) const
{
Validate();
ObjectClass * ptr;
/*
** Hack so that aircraft landed on helipads can still be selected if directly
** clicked on.
*/
ptr = (ObjectClass *)Cell_Find_Object(RTTI_AIRCRAFT);
if (ptr) {
return(ptr);
}
ptr = Cell_Techno(x, y);
if (ptr) {
return(ptr);
}
ptr = Cell_Terrain();
if (ptr) return(ptr);
return(ptr);
}
/***********************************************************************************************
* CellClass::Redraw_Objects -- Redraws all objects overlapping this cell. *
* *
* This is a low level routine that marks all objects that overlap this *
* cell to be redrawn. It is necessary to call this routine whenever *
* the underlying icon has to be redrawn. *
* *
* INPUT: forced -- Should this redraw be forced even if flags *
* indicate that it would be redundant? *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/18/1994 JLB : Created. *
* 06/20/1994 JLB : Simplified to use object pointers. *
* 12/24/1994 JLB : Only checks if cell is in view and not flagged already. *
*=============================================================================================*/
void CellClass::Redraw_Objects(bool forced)
{
Validate();
CELL cell = Cell_Number();
if (Map.In_View(cell) && (forced || !Map.Is_Cell_Flagged(cell))) {
/*
** Flag the icon to be redrawn.
*/
Map.Flag_Cell(cell);
/*
** Flag the main object in the cell to be redrawn.
*/
if (Cell_Occupier()) {
ObjectClass * optr = Cell_Occupier();
while (optr) {
optr->Mark(MARK_CHANGE);
optr = optr->Next;
}
}
/*
** Flag any overlapping object in this cell to be redrawn.
*/
for (int index = 0; index < sizeof(Overlapper)/sizeof(Overlapper[0]); index++) {
if (Overlapper[index]) {
if (!Overlapper[index]->IsActive) {
Overlapper[index] = 0;
} else {
Overlapper[index]->Mark(MARK_CHANGE);
}
}
}
}
}
/***********************************************************************************************
* CellClass::Is_Generally_Clear -- Determines if cell can be built upon. *
* *
* This determines if the cell can become a proper foundation for *
* building placement. *
* *
* INPUT: none *
* *
* OUTPUT: bool; Can the cell be built upon? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/18/1994 JLB : Created. *
*=============================================================================================*/
bool CellClass::Is_Generally_Clear(bool ignore_cloaked) const
{
Validate();
if (ScenarioInit) return(true);
if (Flag.Composite || IsFlagged || Cell_Occupier()) {
if (!ignore_cloaked || (Cell_Occupier() && Cell_Occupier()->Is_Techno() && ((TechnoClass *)Cell_Occupier())->Cloak != CLOAKED)) {
return(false);
}
}
if (Smudge != SMUDGE_NONE && SmudgeTypeClass::As_Reference(Smudge).IsBib && Owner != HOUSE_NONE) {
return(false);
}
if (Overlay != OVERLAY_NONE && (Overlay == OVERLAY_FLAG_SPOT || OverlayTypeClass::As_Reference(Overlay).IsWall)) {
return(false);
}
#ifdef ADVANCED
/*
** Building certain kinds of terrain is prohibited -- bridges in particular.
*/
switch (TType) {
case TEMPLATE_BRIDGE1:
case TEMPLATE_BRIDGE1D:
case TEMPLATE_BRIDGE2:
case TEMPLATE_BRIDGE2D:
case TEMPLATE_BRIDGE3:
case TEMPLATE_BRIDGE3D:
case TEMPLATE_BRIDGE4:
case TEMPLATE_BRIDGE4D:
case TEMPLATE_FORD1:
case TEMPLATE_FORD2:
return(false);
default:
break;
}
#endif
return(::Ground[Land_Type()].Build);
}
/***********************************************************************************************
* CellClass::Recalc_Attributes -- Recalculates the ground type attributes for the cell. *
* *
* This routine recalculates the ground type in the cell. The speeds the find path *
* algorithm and other determinations of the cell type. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/29/1994 JLB : Created. *
* 06/20/1994 JLB : Knows about template pointer in cell object. *
*=============================================================================================*/
void CellClass::Recalc_Attributes(void)
{
Validate();
/*
** Check for wall effects.
*/
if (Overlay != OVERLAY_NONE) {
Land = OverlayTypeClass::As_Reference(Overlay).Land;
if (Land != LAND_CLEAR) return;
}
/*
** If there is a template associated with this cell, then scan
** through the template exception list checking to see if this cell
** is one of the exception types. If it is, then return that ground type,
** otherwise return the template's default type.
*/
if (TType != TEMPLATE_NONE) {
TemplateTypeClass const *ttype = &TemplateTypeClass::As_Reference(TType);
/*
** If there is an exception type list for the icons of this template, then
** find out if the current icon is one of them. If so, apply the exception
** ground type to the cell.
*/
char const *ptr = ttype->AltIcons;
if (ptr) {
int icon = TIcon;
while (*ptr != -1) {
if (icon == *ptr++) {
Land = ttype->AltLand;
return;
}
}
}
/*
** No exception found, so just return the default ground type for this template.
*/
Land = ttype->Land;
return;
}
/*
** No template is the same as clear terrain.
*/
Land = TemplateTypeClass::As_Reference(TEMPLATE_CLEAR1).Land;
}
/***********************************************************************************************
* CellClass::Occupy_Down -- Flag occupation of specified cell. *
* *
* This routine is used to mark the cell as being occupied by the specified object. *
* *
* INPUT: object -- The object that is to occupy the cell *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/18/1994 JLB : Created. *
* 11/29/1994 JLB : Simplified. *
*=============================================================================================*/
void CellClass::Occupy_Down(ObjectClass * object)
{
Validate();
ObjectClass * optr;
/*
** If the specified object is already part of the occupation list, then don't add
** it again -- bail instead.
*/
if (Cell_Occupier()) {
optr = Cell_Occupier();
while (optr) {
if (optr == object) {
return;
}
if (!optr->Next) break;
optr = optr->Next;
}
}
optr = Cell_Occupier();
object->Next = optr;
OccupierPtr = object;
Map.Radar_Pixel(Cell_Number());
/*
** If being placed down on a visible square, then flag this
** techno object as being revealed to the player.
*/
// Changes for GlyphX multiplayer. ST - 4/17/2019 3:02PM
//if (IsVisible || GameToPlay != GAME_NORMAL) {
// object->Revealed(PlayerPtr);
//}
if (GameToPlay != GAME_GLYPHX_MULTIPLAYER) {
if (IsVisible || GameToPlay != GAME_NORMAL) {
object->Revealed(PlayerPtr);
}
} else {
for (int i = 0; i < MPlayerCount; i++) {
HousesType house_type = MPlayerHouses[i];
if (Is_Visible(house_type)) {
HouseClass *house = HouseClass::As_Pointer(house_type);
object->Revealed(house);
}
}
}
/*
** Special occupy bit set.
*/
switch (object->What_Am_I()) {
case RTTI_BUILDING:
Flag.Occupy.Building = true;
break;
case RTTI_AIRCRAFT:
case RTTI_UNIT:
Flag.Occupy.Vehicle = true;
break;
case RTTI_TERRAIN:
Flag.Occupy.Monolith = true;
break;
default:
break;
}
}
/***********************************************************************************************
* CellClass::Occupy_Up -- Removes occupation flag from the specified cell. *
* *
* This routine will lift the object from the cell and free the cell to be occupied by *
* another object. Only if the cell was previously marked with the object specified, will *
* the object be lifted off. This routine is the counterpart to Occupy_Down(). *
* *
* INPUT: object -- The object that is being lifted off. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/18/1994 JLB : Created. *
* 11/29/1994 JLB : Fixed to handle next pointer in previous object. *
*=============================================================================================*/
void CellClass::Occupy_Up(ObjectClass * object)
{
Validate();
ObjectClass * optr = NULL; // Working pointer to the objects in the chain.
if (Cell_Occupier()) {
optr = Cell_Occupier();
}
if (optr == object) {
OccupierPtr = object->Next;
object->Next = 0;
} else {
while (optr) {
if (optr->Next == object) {
optr->Next = object->Next;
object->Next = 0;
break;
}
if (!optr->Next) break;
optr = optr->Next;
}
}
Map.Radar_Pixel(Cell_Number());
/*
** Special occupy bit clear.
*/
switch (object->What_Am_I()) {
case RTTI_BUILDING:
Flag.Occupy.Building = false;
break;
case RTTI_AIRCRAFT:
case RTTI_UNIT:
Flag.Occupy.Vehicle = false;
#ifdef NEVER
int x,y;
if (Map.Coord_To_Pixel(Cell_Coord(), x, y)) {
SeenBuff.Put_Pixel(x, y, BLUE);
}
#endif
break;
case RTTI_TERRAIN:
Flag.Occupy.Monolith = false;
break;
default:
break;
}
}
/***********************************************************************************************
* CellClass::Overlap_Down -- This routine is used to mark a cell as being spilled over (overla*
* *
* Most game objects can often have their graphic imagery spill into more than one cell *
* even though they are considered to "occupy" only one cell. All cells overlapped are *
* flagged by this routine. Using this information it is possible to keep the tactical map *
* display correct. *
* *
* INPUT: object -- The object to mark as overlapping this cell. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/18/1994 JLB : Created. *
* 07/04/1995 JLB : Ensures that buildings are always marked down. *
*=============================================================================================*/
void CellClass::Overlap_Down(ObjectClass * object)
{
Validate();
ObjectClass **ptr = 0;
if (!object) return;
int index;
for (index = 0; index < sizeof(Overlapper)/sizeof(Overlapper[0]); index++) {
if (Overlapper[index] == object) return;
if (!Overlapper[index]) ptr = &Overlapper[index];
}
/*
** Buildings must ALWAYS succeed in marking the cell as overlapped. Bump somebody
** else out in this case.
*/
if (!ptr && object->What_Am_I() == RTTI_BUILDING) {
for (index = 0; index < sizeof(Overlapper)/sizeof(Overlapper[0]); index++) {
switch (Overlapper[index]->What_Am_I()) {
case RTTI_BUILDING:
case RTTI_TERRAIN:
break;
default:
Overlapper[index] = object;
index = sizeof(Overlapper)/sizeof(Overlapper[0]);
break;
}
}
}
if (ptr) *ptr = object;
/*
** If being placed down on a visible square, then flag this
** techno object as being revealed to the player.
*/
// Changes for GlyphX multiplayer. ST - 4/18/2019 9:50AM
//if (IsVisible) {
// object->Revealed(PlayerPtr);
//}
if (GameToPlay != GAME_GLYPHX_MULTIPLAYER) {
if (IsVisible) {
object->Revealed(PlayerPtr);
}
} else {
if (object->Is_Techno()) {
TechnoClass *tech = static_cast<TechnoClass*>(object);
object->Revealed(tech->House);
} else {
for (int i = 0; i < MPlayerCount; i++) {
HousesType house_type = MPlayerHouses[i];
HouseClass *house = HouseClass::As_Pointer(house_type);
object->Revealed(house);
}
}
}
}
/***********************************************************************************************
* CellClass::Overlap_Up -- Removes overlap flag for the cell. *
* *
* This is the counterpart to Overlap_Down and is used to remove the overlap flag for the *
* specified unit on the cell. *
* *
* INPUT: object -- The object to remove the overlap flag for. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/18/1994 JLB : Created. *
*=============================================================================================*/
void CellClass::Overlap_Up(ObjectClass *object)
{
Validate();
for (int index = 0; index < sizeof(Overlapper)/sizeof(Overlapper[0]); index++) {
if (Overlapper[index] == object) {
Overlapper[index] = 0;
break;
}
}
//Map.Validate();
}
/***********************************************************************************************
* CellClass::Cell_Unit -- Returns with pointer to unit occupying cell. *
* *
* This routine will determine if a unit is occupying the cell and if so, return a pointer *
* to it. If there is no unit occupying the cell, then NULL is returned. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with pointer to unit occupying cell, else NULL. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/18/1994 JLB : Created. *
*=============================================================================================*/
UnitClass * CellClass::Cell_Unit(void) const
{
Validate();
return((UnitClass*)Cell_Find_Object(RTTI_UNIT));
}
/***********************************************************************************************
* CellClass::Cell_Infantry -- Returns with pointer of first infantry unit occupying the cell. *
* *
* This routine examines the cell and returns a pointer to the first infantry unit *
* that occupies it. If there is no infantry unit in the cell, then NULL is returned. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with pointer to infantry unit occupying the cell or NULL if none are *
* present. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/21/1994 JLB : Created. *
*=============================================================================================*/
InfantryClass * CellClass::Cell_Infantry(void) const
{
Validate();
return((InfantryClass*)Cell_Find_Object(RTTI_INFANTRY));
}
/***********************************************************************************************
* CellClass::Get_Template_Info -- Get some info about a template for external use *
* *
* *
* *
* *
* INPUT: Ref to info required *
* *
* OUTPUT: True if image info available *
* *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 1/10/2019 5:57PM ST : Created. *
*=============================================================================================*/
bool CellClass::Get_Template_Info(char *template_name, int &icon, void *&image_data)
{
TemplateTypeClass const *ttype = NULL;
if (TType != TEMPLATE_NONE) {
ttype = &TemplateTypeClass::As_Reference(TType);
icon = TIcon;
} else {
ttype = &TemplateTypeClass::As_Reference(TEMPLATE_CLEAR1);
icon = Clear_Icon();
}
if (ttype) {
strcpy(template_name, ttype->IniName);
image_data = (void*) ttype->ImageData;
return true;
}
return false;
}
/***********************************************************************************************
* CellClass::Draw_It -- Draws the cell imagery at the location specified. *
* *
* This is the gruntwork cell rendering code. It draws the cell at the screen location *
* specified. This routine doesn't draw any overlapping or occupying units. It only *
* deals with the ground (cell) layer -- icon level. *
* *
* INPUT: x,y -- The screen coordinates to render the cell imagery at. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/18/1994 JLB : Created. *
* 08/21/1994 JLB : Revised for simple template objects. *
* 11/01/1994 BRR : Updated placement cursor; draws actual object *
* 11/14/1994 BRR : Added remapping code to show passable areas *
* 12/02/1994 BRR : Added trigger display *
* 12/11/1994 JLB : Mixes up clear terrain through pseudo-random table. *
* 04/25/1995 JLB : Smudges drawn BELOW overlays. *
*=============================================================================================*/
void CellClass::Draw_It(int x, int y, int draw_type) const
{
Validate();
TemplateTypeClass const *ttype = 0;
int icon; // The icon number to use from the template set.
CELL cell = Cell_Number();
void * remap = NULL;
#ifdef SCENARIO_EDITOR
TemplateTypeClass * tptr;
TriggerClass * trig;
int i;
char waypt[2];
#endif
/*
** Fetch a pointer to the template type associated with this cell.
*/
if (TType != TEMPLATE_NONE) {
ttype = &TemplateTypeClass::As_Reference(TType);
icon = TIcon;
} else {
ttype = &TemplateTypeClass::As_Reference(TEMPLATE_CLEAR1);
icon = Clear_Icon();
}
/*
** Draw the stamp of the template.
*/
if (Debug_Icon) {
LogicPage->Fill_Rect(Map.TacPixelX+x, Map.TacPixelY+y, Map.TacPixelX+x+ICON_PIXEL_W-1, Map.TacPixelY+y+ICON_PIXEL_H-1, Sim_Random_Pick(1, 254));
FontXSpacing -= 2;
Fancy_Text_Print("%d\r%2X%c\r%02X.%02X", Map.TacPixelX+x+(ICON_PIXEL_W>>1), Map.TacPixelY+y, WHITE, TBLACK, TPF_6POINT|TPF_NOSHADOW|TPF_CENTER, cell, Flag.Composite, (Cell_Occupier() ? '*' : ' '), Overlay, OverlayData);
FontXSpacing += 2;
} else {
if (!draw_type || draw_type == CELL_BLIT_ONLY){
#ifdef SCENARIO_EDITOR
/*
** Set up the remap table for this icon.
*/
if (Debug_Map && Debug_Passable) {
if (::Ground[Land].Cost[0] == 0 || (Cell_Occupier() != NULL &&
Cell_Occupier()->What_Am_I() != RTTI_INFANTRY)) { // impassable
remap = Map.FadingRed;
} else {
if (::Ground[Land].Cost[0] > 0x70) { // pretty passable
remap = Map.FadingGreen;
} else {
remap = Map.FadingYellow; // moderately passable
}
}
}
#endif
// ****** maybe this icon shouldn't be drawn if it is known that the cell will be covered
// with shadow.
/*
** This is the underlying terrain icon.
*/
if (ttype->Get_Image_Data()) {
LogicPage->Draw_Stamp(ttype->Get_Image_Data(), icon, x, y, NULL, WINDOW_TACTICAL);
if (remap) {
LogicPage->Remap(x+Map.TacPixelX, y+Map.TacPixelY, ICON_PIXEL_W, ICON_PIXEL_H, remap);
}
}
#ifdef SCENARIO_EDITOR
/*
** Draw the map editor's "current" cell. This is the cell that can be
** assigned attributes such as tag labels.
** This must be draw before the placement cursor, but after drawing the
** objects in the cell.
*/
if (Debug_Map && CurrentCell == Cell_Number()) {
LogicPage->Draw_Rect(x+Map.TacPixelX, y+Map.TacPixelY, Map.TacPixelX + x + CELL_PIXEL_W - 1, Map.TacPixelY + y + CELL_PIXEL_H - 1, YELLOW);
}
#endif
#ifdef NEVER
/*
** Special concrete render. It always renders over the underlying
** terrain unless this concrete piece will cover the entire terrain
** piece.
*/
if (Concrete) {
LogicPage->Draw_Stamp(TemplateTypeClass::As_Pointer(TEMPLATE_CONCRETE_GDI)->Get_Image_Data(), Concrete-1, x, y, NULL, WINDOW_TACTICAL);
}
#endif
}
/*
** Redraw any smudge.
*/
if (Smudge != SMUDGE_NONE) {
#ifdef NEVER
switch (Smudge) {
case SMUDGE_BIB1:
CC_Draw_Shape(Bib1, SmudgeData, x, y, WINDOW_TACTICAL, SHAPE_WIN_REL);
break;
case SMUDGE_BIB2:
CC_Draw_Shape(Bib2, SmudgeData, x, y, WINDOW_TACTICAL, SHAPE_WIN_REL);
break;
case SMUDGE_BIB3:
CC_Draw_Shape(Bib3, SmudgeData, x, y, WINDOW_TACTICAL, SHAPE_WIN_REL);
break;
}
#endif
SmudgeTypeClass::As_Reference(Smudge).Draw_It(x, y, SmudgeData);
}
if (!draw_type || draw_type == CELL_DRAW_ONLY){
/*
** Draw the overlay object.
*/
if (Overlay != OVERLAY_NONE) {
OverlayTypeClass const & otype = OverlayTypeClass::As_Reference(Overlay);
IsTheaterShape = (bool)otype.IsTheater;
CC_Draw_Shape(otype.Get_Image_Data(), OverlayData, (x+(CELL_PIXEL_W>>1)), (y+(CELL_PIXEL_H>>1)), WINDOW_TACTICAL, SHAPE_CENTER|SHAPE_WIN_REL|SHAPE_GHOST, NULL, Map.UnitShadow);
IsTheaterShape = false;
}
#ifdef SCENARIO_EDITOR
if (Debug_Map) {
/*
** Draw the cell's Trigger mnemonic, if it has a trigger
*/
if (IsTrigger) {
trig = Get_Trigger();
Fancy_Text_Print(trig->Get_Name(), x+Map.TacPixelX, y+Map.TacPixelY, PINK, TBLACK, TPF_NOSHADOW|TPF_6POINT);
}
/*
** Draw the cell's Waypoint designation if there is one.
*/
if (IsWaypoint) {
for (i = 0; i < 26; i++) {
if (Waypoint[i]==Cell_Number()) {
waypt[0] = 'A' + i;
waypt[1] = 0;
Fancy_Text_Print(waypt, Map.TacPixelX + x + CELL_PIXEL_W / 2,
Map.TacPixelY + y + (CELL_PIXEL_H / 2) - 3, YELLOW, TBLACK,
TPF_NOSHADOW | TPF_6POINT | TPF_CENTER);
break;
}
}
if (Waypoint[WAYPT_HOME] == Cell_Number()) {
Fancy_Text_Print("Home", Map.TacPixelX + x, Map.TacPixelY + y + (CELL_PIXEL_H) - 7,
WHITE, TBLACK, TPF_NOSHADOW | TPF_6POINT);
}
if (Waypoint[WAYPT_REINF] == Cell_Number()) {
Fancy_Text_Print("Reinf", Map.TacPixelX + x, Map.TacPixelY + y + (CELL_PIXEL_H) - 7,
WHITE, TBLACK, TPF_NOSHADOW | TPF_6POINT);
}
}
}
#endif
/*
** Draw the placement cursor:
** - First, draw the hash-mark cursor, so it will appear underneath
** any cursor being drawn
** - If the PendingObject is a template, overlay, or smudge, draw it
** - Otherwise, it's up to the Display.Refresh_Map() routine to draw it
*/
if (IsCursorHere) {
/*
** Draw the hash-mark cursor:
*/
if (Map.ProximityCheck && Is_Generally_Clear()) {
LogicPage->Draw_Stamp(Map.TransIconset, 0, x, y, NULL, WINDOW_TACTICAL);
} else {
LogicPage->Draw_Stamp(Map.TransIconset, 2, x, y, NULL, WINDOW_TACTICAL);
}
#ifdef SCENARIO_EDITOR
if (Debug_Map && Map.PendingObject) {
switch (Map.PendingObject->What_Am_I()) {
/*
** Draw a template:
** - Compute the icon offset of this cell for this template, using
** ZoneCell+ZoneOffset to get the upper-left corner of the placement
** cursor
** - Draw the icon
*/
case RTTI_TEMPLATETYPE:
tptr = (TemplateTypeClass *)Map.PendingObject;
if (tptr->Get_Image_Data()) {
icon = (Cell_X(cell) - Cell_X(Map.ZoneCell + Map.ZoneOffset)) +
(Cell_Y(cell) - Cell_Y(Map.ZoneCell + Map.ZoneOffset)) *
tptr->Width;
LogicPage->Draw_Stamp(tptr->Get_Image_Data(), icon, x, y, NULL, WINDOW_TACTICAL);
}
break;
/*
** Draw an overlay; just use the existing 'OverlayData' even though
** it means nothing.
*/
case RTTI_OVERLAYTYPE:
OverlayTypeClass::As_Reference(((OverlayTypeClass *)Map.PendingObject)->Type).Draw_It(x, y, OverlayData);
break;
/*
** Draw a smudge
*/
case RTTI_SMUDGETYPE:
SmudgeTypeClass::As_Reference(((SmudgeTypeClass *)Map.PendingObject)->Type).Draw_It(x, y, 0);
break;
}
}
#endif
}
/*
** Draw the flag if there is one located at this cell.
*/
if (IsFlagged) {
void const * remap = HouseClass::As_Pointer(Owner)->Remap_Table(false, false);
CC_Draw_Shape(MixFileClass::Retrieve("FLAGFLY.SHP"), Frame % 14, x+(ICON_PIXEL_W/2), y+(ICON_PIXEL_H/2), WINDOW_TACTICAL, SHAPE_CENTER|SHAPE_GHOST|SHAPE_FADING, remap, Map.UnitShadow);
}
}
}
}
/***********************************************************************************************
* CellClass::Concrete_Calc -- Calculates the concrete icon to use for the cell. *
* *
* This routine examines the cells around the current one and from this, determines what *
* concrete icon shape to use (if any). The cell data is adjusted and the cell is marked *
* for redraw if the icon changed. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/01/1994 JLB : Created. *
*=============================================================================================*/
void CellClass::Concrete_Calc(void)
{
Validate();
static FacingType _even[5] = {FACING_N, FACING_S, FACING_SW, FACING_W, FACING_NW};
static FacingType _odd[5] = {FACING_N, FACING_NE, FACING_E, FACING_SE, FACING_S};
FacingType *ptr; // Working pointer into adjacent cell list.
int index; // Constructed bit index.
int icon; // Icon number.
bool isodd; // Is this for the odd column?
#define OF_N 0x01
#define OF_NE 0x02
#define OF_E 0x04
#define OF_SE 0x08
#define OF_S 0x10
#define EF_N 0x01
#define EF_NW 0x10
#define EF_W 0x08
#define EF_SW 0x04
#define EF_S 0x02
/*
** Determine if the even or odd row logic is necessary.
*/
isodd = ((Cell_Number() & 0x01) != 0);
/*
** Fetch correct pointer depending on whether this is for an
** odd or even row.
*/
ptr = (isodd) ? _odd : _even;
/*
** Build an index according to the presence of concrete in the special
** adjacent cells. This is a short list of adjacent cell flags since
** only 5 adjacent cells need to be examined. The choice of which 5
** depends on whether this is for an even or odd column.
*/
index = 0;
for (int i = 0; i < (sizeof(_even)/sizeof(_even[0])); i++) {
CellClass & cellptr = Adjacent_Cell(*ptr++);
// if ((cellptr->IsConcrete) ||
// cellptr->Concrete == C_UPDOWN_RIGHT ||
// cellptr->Concrete == C_UPDOWN_LEFT) {
if (cellptr.Overlay == OVERLAY_CONCRETE) {
index |= (1<<i);
}
}
/*
** Special logic occurs for cells that are concrete filled.
*/
if (Overlay == OVERLAY_CONCRETE) {
/*
** Process the index value and place the appropriate concrete icon
** in the cell.
*/
if (isodd) {
switch (index) {
case OF_NE:
case OF_N|OF_NE:
case OF_E|OF_N:
case OF_E|OF_NE:
case OF_N|OF_NE|OF_E:
case OF_S|OF_N|OF_NE:
icon = C_RIGHT_UP; // right - up
break;
case OF_SE:
case OF_E|OF_SE:
case OF_S|OF_SE:
case OF_S|OF_E:
case OF_S|OF_SE|OF_E:
case OF_S|OF_SE|OF_N:
icon = C_RIGHT_DOWN; // right - down
break;
case OF_SE|OF_NE:
case OF_SE|OF_NE|OF_N:
case OF_SE|OF_NE|OF_S:
case OF_SE|OF_NE|OF_S|OF_N:
case OF_SE|OF_E|OF_N:
case OF_SE|OF_E|OF_NE|OF_N:
case OF_S|OF_E|OF_N:
case OF_S|OF_E|OF_NE:
case OF_S|OF_E|OF_NE|OF_N:
case OF_S|OF_SE|OF_E|OF_N:
case OF_S|OF_SE|OF_E|OF_NE|OF_N:
case OF_S|OF_SE|OF_E|OF_NE:
icon = C_RIGHT_UPDOWN; // right - up - down
break;
default:
icon = C_RIGHT; // right
break;
}
} else {
switch (index) {
case EF_NW:
case EF_NW|EF_N:
case EF_W|EF_N:
case EF_NW|EF_W|EF_N:
case EF_NW|EF_W:
case EF_NW|EF_S|EF_N:
icon = C_LEFT_UP; // left - up
break;
case EF_SW:
case EF_SW|EF_S:
case EF_W|EF_S:
case EF_W|EF_SW|EF_S:
case EF_W|EF_SW:
case EF_SW|EF_S|EF_N:
icon = C_LEFT_DOWN; // left - down
break;
case EF_NW|EF_SW:
case EF_NW|EF_SW|EF_N:
case EF_NW|EF_SW|EF_S:
case EF_NW|EF_SW|EF_S|EF_N:
case EF_W|EF_S|EF_N:
case EF_W|EF_SW|EF_N:
case EF_W|EF_SW|EF_S|EF_N:
case EF_NW|EF_W|EF_S:
case EF_NW|EF_W|EF_S|EF_N:
case EF_NW|EF_W|EF_SW|EF_S|EF_N:
case EF_NW|EF_W|EF_SW|EF_N:
case EF_NW|EF_W|EF_SW|EF_S:
icon = C_LEFT_UPDOWN; // left - up - down
break;
default:
icon = C_LEFT; // left
break;
}
}
} else {
// Presume that no concrete piece is needed.
icon = C_NONE;
if (isodd) {
index &= ~(OF_NE|OF_SE); // Ignore diagonals.
switch (index) {
case OF_N|OF_E:
icon = C_UP_RIGHT; // up right
break;
case OF_E|OF_S:
icon = C_DOWN_RIGHT; // down right
break;
case OF_N|OF_E|OF_S:
icon = C_UPDOWN_RIGHT; // up/down right
break;
default:
break;
}
} else {
index &= ~(EF_NW|EF_SW); // Ignore diagonals.
switch (index) {
case EF_N|EF_W:
icon = C_UP_LEFT; // up left
break;
case EF_W|EF_S:
icon = C_DOWN_LEFT; // down left
break;
case EF_N|EF_W|EF_S:
icon = C_UPDOWN_LEFT; // up/down left
break;
default:
break;
}
}
/*
** If any kind of fixup piece is needed, then add concrete
** to this location RECURSIVELY!
*/
if (icon != C_NONE) {
OverlayTypeClass::As_Reference(OVERLAY_CONCRETE).Create_And_Place(Cell_Number());
icon = C_NONE;
}
}
/*
** Update the icon on the map.
*/
if (icon != C_NONE && OverlayData != icon) {
OverlayData = icon;
//Array[cell].Base = 0;
Redraw_Objects();
}
}
/***********************************************************************************************
* CellClass::Wall_Update -- Updates the imagery for wall objects in cell. *
* *
* This routine will examine the cell and the adjacent cells to determine what the wall *
* should look like with the cell. It will then update the wall's imagery value and flag *
* the cell to be redrawn if necessary. This routine should be called whenever the wall *
* or an adjacent wall is created or destroyed. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/19/1994 JLB : Created. *
* 09/19/1994 BWG : Updated to handle partially-damaged walls. *
*=============================================================================================*/
void CellClass::Wall_Update(void)
{
Validate();
static FacingType _offsets[5] = {FACING_N, FACING_E, FACING_S, FACING_W, FACING_NONE};
if (Overlay == OVERLAY_NONE) {
return;
}
OverlayTypeClass const & wall = OverlayTypeClass::As_Reference(Overlay);
if (!wall.IsWall) {
return;
}
for (unsigned index = 0; index < (sizeof(_offsets)/sizeof(_offsets[0])); index++) {
CellClass & newcell = Adjacent_Cell(_offsets[index]);
if (newcell.Overlay != OVERLAY_NONE && OverlayTypeClass::As_Reference(newcell.Overlay).IsWall) {
int icon = 0;
/*
** Build the icon number according to walls located in the adjacent
** cells.
*/
for (unsigned i = 0; i < 4; i++) {
if (newcell.Adjacent_Cell(_offsets[i]).Overlay == newcell.Overlay) {
icon |= 1 << i;
}
}
newcell.OverlayData = (newcell.OverlayData & 0xFFF0) | icon;
// newcell.OverlayData = icon;
/*
** Handle special cases for the incomplete damaged wall sets. If a damage stage
** is calculated, but there is no artwork for it, then consider the wall to be
** completely destroyed.
*/
if (newcell.Overlay == OVERLAY_BRICK_WALL && newcell.OverlayData == 48) {
newcell.Overlay = OVERLAY_NONE;
newcell.OverlayData = 0;
ObjectClass::Detach_This_From_All(::As_Target(newcell.Cell_Number()), true);
}
if (newcell.Overlay == OVERLAY_SANDBAG_WALL && newcell.OverlayData == 16) {
newcell.Overlay = OVERLAY_NONE;
newcell.OverlayData = 0;
ObjectClass::Detach_This_From_All(::As_Target(newcell.Cell_Number()), true);
}
if (newcell.Overlay == OVERLAY_CYCLONE_WALL && newcell.OverlayData == 32) {
newcell.Overlay = OVERLAY_NONE;
newcell.OverlayData = 0;
ObjectClass::Detach_This_From_All(::As_Target(newcell.Cell_Number()), true);
}
if (newcell.Overlay == OVERLAY_BARBWIRE_WALL && newcell.OverlayData == 16) {
newcell.Overlay = OVERLAY_NONE;
newcell.OverlayData = 0;
ObjectClass::Detach_This_From_All(::As_Target(newcell.Cell_Number()), true);
}
newcell.Recalc_Attributes();
newcell.Redraw_Objects();
}
}
}
/***********************************************************************************************
* CellClass::Cell_Coord -- Returns the coordinate of this cell. *
* *
* This support function will determine the coordinate of this cell and return it. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with coordinate value of cell. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/19/1994 JLB : Created. *
*=============================================================================================*/
COORDINATE CellClass::Cell_Coord(void) const
{
Validate();
return(::Cell_Coord(Cell_Number()));
}
/***********************************************************************************************
* CellClass::Reduce_Tiberium -- Reduces the tiberium in the cell by the amount specified. *
* *
* This routine will lower the tiberium level in the cell. It is used by the harvesting *
* process as well as by combat damage to the tiberium fields. *
* *
* INPUT: levels -- The number of levels to reduce the tiberium. *
* *
* OUTPUT: bool; Was the tiberium level reduced by at least one level? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/19/1994 JLB : Created. *
*=============================================================================================*/
int CellClass::Reduce_Tiberium(int levels)
{
Validate();
int reducer = 0;
if (levels && Land == LAND_TIBERIUM) {
if (OverlayData > levels) {
OverlayData -= levels;
reducer = levels;
} else {
Overlay = OVERLAY_NONE;
reducer = OverlayData;
OverlayData = 0;
Recalc_Attributes();
}
}
return(reducer);
}
/***********************************************************************************************
* CellClass::Reduce_Wall -- Damages a wall, if damage is high enough. *
* *
* This routine will change the wall shape used for a wall if it's damaged. *
* *
* *
* INPUT: damage -- The number of damage points the wall was hit with. *
* *
* OUTPUT: bool; Was the wall destroyed? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 03/15/1995 BWG : Created. *
* 03/19/1995 JLB : Updates cell information if wall was destroyed. *
*=============================================================================================*/
int CellClass::Reduce_Wall(int damage)
{
Validate();
if (Overlay != OVERLAY_NONE) {
bool destroyed = false;
OverlayTypeClass const & wall = OverlayTypeClass::As_Reference(Overlay);
if (wall.IsWall) {
/*
** If the damage was great enough to ensure wall destruction, reduce the wall by one
** level (no more). Otherwise determine wall reduction based on a percentage chance
** proportional to the damage received and the wall's strength.
*/
if (damage >= wall.DamagePoints) {
destroyed = true;
} else {
destroyed = Random_Pick(0, wall.DamagePoints) < damage;
}
if (destroyed) {
OverlayData+=16;
if ((OverlayData>>4) >= wall.DamageLevels) {
ObjectClass::Detach_This_From_All(As_Target());
Owner = HOUSE_NONE;
Overlay = OVERLAY_NONE;
OverlayData = 0;
Recalc_Attributes();
Redraw_Objects();
Adjacent_Cell(FACING_N).Wall_Update();
Adjacent_Cell(FACING_W).Wall_Update();
Adjacent_Cell(FACING_S).Wall_Update();
Adjacent_Cell(FACING_E).Wall_Update();
return(true);
}
}
}
}
return(false);
}
/***********************************************************************************************
* CellClass::Get_Trigger -- retrieves reference to the cell's trigger *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* TriggerClass reference *
* *
* WARNINGS: *
* Never call this function unless the IsTrigger flag is set for the cell! *
* *
* HISTORY: *
* 12/01/1994 BR : Created. *
*=============================================================================================*/
TriggerClass * CellClass::Get_Trigger(void) const
{
Validate();
if (IsTrigger) {
return(CellTriggers[Cell_Number()]);
}
return(NULL);
}
/***********************************************************************************************
* CellClass::Spot_Index -- returns cell sub-coord index for given COORD *
* *
* INPUT: *
* coord COORD to compute index for *
* *
* OUTPUT: *
* index into StoppingCoord that's closest to this coord *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/21/1994 BR : Created. *
* 12/10/1994 JLB : Uses alternate sub-position algorithm. *
*=============================================================================================*/
int CellClass::Spot_Index(COORDINATE coord)
{
COORDINATE rel = coord & 0x00FF00FFL; // Sub coordinate value within cell.
/*
** If the coordinate is close enough to the center of the cell, then return
** the center position index.
*/
if (Distance(rel, 0x00800080L) < 60) {
return(0);
}
/*
** Since the center cell position has been eliminated, a simple comparison
** as related to the center of the cell can be used to determine the sub
** position. Take advantage of the fact that the sub positions are organized
** from left to right, top to bottom.
*/
int index = 0;
if (Coord_X(rel) > 0x80) index |= 0x01;
if (Coord_Y(rel) > 0x80) index |= 0x02;
return(index+1);
}
/***********************************************************************************************
* CellClass::Closest_Free_Spot -- returns free spot closest to given coord *
* *
* Similar to the CellClass::Free_Spot; this routine finds the spot in *
* the cell closest to the given coordinate, and returns the COORD of *
* that spot if it's available, NULL if it's not. *
* *
* INPUT: *
* coord coordinate to check (only sub cell position examined) *
* *
* any -- If only the closest spot is desired regardless of whether it is free or *
* not, then this parameter will be true. *
* *
* OUTPUT: *
* COORD of free spot, NULL if none. The coordinate return value does not alter the cell *
* coordinate data portions of the coordinate passed in. Only the lower sub-cell *
* data is altered. *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 11/08/1994 BR : Created. *
* 12/10/1994 JLB : Picks best of closest stopping positions. *
* 12/21/1994 JLB : Adds a mix-up factor if center location is occupied. *
*=============================================================================================*/
COORDINATE CellClass::Closest_Free_Spot(COORDINATE coord, bool any) const
{
Validate();
int spot_index = Spot_Index(coord);
/*
** This precalculated sequence table records the closest spots to any given spot. Sequential
** examination of these spots for availability ensures that the closes available one is
** discovered first.
*/
static unsigned char _sequence[5][4] = {
{1,2,3,4},
{0,2,3,4},
{0,1,4,3},
{0,1,4,2},
{0,2,3,1}
};
/*
** In the case of the center coordinate being requested, but is occupied, then all other
** sublocations are equidistant. Instead of picking a static sequence of examination, the
** order is mixed up by way of this table.
*/
static unsigned char _alternate[4][4] = {
{1,2,3,4},
{2,3,4,1},
{3,4,1,2},
{4,1,2,3},
};
coord &= 0xFF00FF00L;
/*
** Cells occupied by buildings or vehicles don't have any free spots.
*/
if (!any && (Flag.Occupy.Vehicle || Flag.Occupy.Monolith)) {
return(NULL);
}
/*
** If just the nearest position is desired regardless of whether occupied or not,
** then just return with the stopping coordinate value.
*/
if (any || Is_Spot_Free(spot_index)) {
return(Coord_Add(coord, StoppingCoordAbs[spot_index]));
}
/*
** Scan through all available sub-locations in the cell in order to determine
** the closest one to the coordinate requested. Use precalculated table so that
** when the first free position is found, bail.
*/
unsigned char *sequence;
if (spot_index == 0) {
sequence = &_alternate[Random_Pick(0,3)][0];
} else {
sequence = &_sequence[spot_index][0];
}
for (int index = 0; index < 4; index++) {
int pos = *sequence++;
if (Is_Spot_Free(pos)) {
return(Coord_Add(coord, StoppingCoordAbs[pos]));
}
}
/*
** No free spot could be found so return a NULL coordinate.
*/
return(0x00000000L);
}
/***********************************************************************************************
* CellClass::Clear_Icon -- Calculates what the clear icon number should be. *
* *
* This support routine will determine what the clear icon number would be for the cell. *
* The icon number is determined by converting the cell number into an index into a *
* lookup table. This yields what appears to be a randomized map without the necessity of *
* generating and recording randomized map numbers. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with the icon number for clear terrain if it were displayed at the *
* cell. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/26/1994 JLB : Created. *
* 06/09/1995 JLB : Uses 16 entry scramble algorithm. *
*=============================================================================================*/
int CellClass::Clear_Icon(void) const
{
Validate();
CELL cell = Cell_Number();
return((cell & 0x03) | ((cell>>4) & 0x0C));
}
/***********************************************************************************************
* CellClass::Incoming -- Causes objects in cell to "run for cover". *
* *
* This routine is called whenever a great, but slow moving, threat is presented to the *
* occupants of a cell. The occupants will, in most cases, stop what they are doing and *
* try to get out of the way. *
* *
* INPUT: threat -- The coordinate source of the threat. *
* *
* forced -- If this threat is so major that the occupants should stop what *
* they are doing, then this parameter should be set to true. *
* *
* nokidding -- Override the scatter to also affect human controlled objects. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 01/10/1995 JLB : Created. *
*=============================================================================================*/
void CellClass::Incoming(COORDINATE threat, bool forced, bool nokidding)
{
Validate();
ObjectClass * object = NULL;
object = Cell_Occupier();
while (object) {
/*
** Special check to make sure that friendly units never scatter.
*/
if (nokidding || Special.IsScatter || (object->Is_Techno() && !((TechnoClass *)object)->House->IsHuman)) {
if (object->What_Am_I() == RTTI_INFANTRY) {
object->Scatter(threat, forced, nokidding);
} else {
object->Scatter(threat, forced, nokidding);
// object->Scatter(threat, false);
}
}
object = object->Next;
}
}
/***********************************************************************************************
* CellClass::Adjacent_Cell -- Determines the adjacent cell according to facing. *
* *
* Use this routine to return a reference to the adjacent cell in the direction specified. *
* *
* INPUT: face -- The direction to use when determining the adjacent cell. *
* *
* OUTPUT: Returns with a reference to the adjacent cell. *
* *
* WARNINGS: If the facing value is invalid, then a reference to the same cell is returned. *
* *
* HISTORY: *
* 03/19/1995 JLB : Created. *
*=============================================================================================*/
CellClass const & CellClass::Adjacent_Cell(FacingType face) const
{
Validate();
if ((unsigned)face >= FACING_COUNT) {
return(*this);
}
CELL id = Cell_Number();
//The top row doesn't have any adjacent cells to the north. - LLL
if (id < MAP_CELL_W && (face == FACING_N || face == FACING_NE || face == FACING_NW)) {
return (*this);
}
//The bottom row doesn't have any adjacent cells to the south. - LLL
if ((id > MAP_CELL_TOTAL - MAP_CELL_W) && (face == FACING_S || face == FACING_SE || face == FACING_SW)) {
return (*this);
}
CellClass const * ptr = this + AdjacentCell[face];
if (ptr->Cell_Number() & 0xF000) return(*this);
return(*ptr);
// return(*(this + AdjacentCell[face]));
}
/***************************************************************************
* CellClass::Adjust_Threat -- Allows adjustment of threat at cell level *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 04/24/1995 PWG : Created. *
*=========================================================================*/
void CellClass::Adjust_Threat(HousesType house, int threat_value)
{
Validate();
int region = Map.Cell_Region(Cell_Number());
for (HousesType lp = HOUSE_FIRST; lp < HOUSE_COUNT; lp ++) {
if (lp == house) continue;
HouseClass *house_ptr = HouseClass::As_Pointer(lp);
if (house_ptr && (!house_ptr->IsHuman || !house_ptr->Is_Ally(house))) {
house_ptr->Adjust_Threat(region, threat_value);
}
}
if (Debug_Threat) {
Map.Flag_To_Redraw(true);
}
}
/***********************************************************************************************
* CellClass::Tiberium_Adjust -- Adjust the look of the Tiberium for smoothing purposes. *
* *
* This routine will adjust the level of the Tiberium in the cell so that it will *
* smoothly blend with the adjacent Tiberium. This routine should only be called for *
* new Tiberium cells. Existing cells that contain Tiberium follow a different growth *
* pattern. *
* *
* INPUT: pregame -- Is this a pregame call? Such a call will mixup the Tiberium overlay *
* used. *
* *
* OUTPUT: Returns with the added Tiberium value that is now available for harvesting. *
* *
* WARNINGS: The return value is only valid for the initial placement. Tiberium growth will *
* increase the net worth of the existing Tiberium. *
* *
* HISTORY: *
* 05/16/1995 JLB : Created. *
*=============================================================================================*/
long CellClass::Tiberium_Adjust(bool pregame)
{
Validate();
if (Overlay != OVERLAY_NONE) {
if (OverlayTypeClass::As_Reference(Overlay).Land == LAND_TIBERIUM) {
static int _adj[9] = {0,1,3,4,6,7,8,10,11};
int count = 0;
/*
** Mixup the Tiberium overlays so that they don't look the same.
*/
if (pregame) {
Overlay = Random_Pick(OVERLAY_TIBERIUM1, OVERLAY_TIBERIUM12);
}
/*
** Add up all adjacent cells that contain tiberium.
** (Skip those cells which aren't on the map)
*/
for (FacingType face = FACING_FIRST; face < FACING_COUNT; face++) {
CELL cell = Cell_Number() + AdjacentCell[face];
if ((unsigned)cell >= MAP_CELL_TOTAL) continue;
CellClass & adj = Adjacent_Cell(face);
if (adj.Overlay != OVERLAY_NONE &&
OverlayTypeClass::As_Reference(adj.Overlay).Land == LAND_TIBERIUM) {
count++;
}
}
OverlayData = _adj[count];
return((OverlayData+1) * UnitTypeClass::TIBERIUM_STEP);
}
}
return(0);
}
/***********************************************************************************************
* CellClass::Goodie_Check -- Performs crate discovery logic. *
* *
* Call this routine whenever an object enters a cell. It will check for the existance *
* of a crate and generate any "goodie" it might contain. *
* *
* INPUT: object -- Pointer to the object that is triggering this crate. *
* *
* OUTPUT: Can the object continue to enter this cell? A false return value means that the *
* cell is now occupied and must not be entered. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/22/1995 JLB : Created. *
* 07/08/1995 JLB : Added a bunch of goodies to the crates. *
*=============================================================================================*/
bool CellClass::Goodie_Check(FootClass * object)
{
Validate();
enum {
MONEY, // Cash award.
UNIT, // A free unit.
NUKE, // A nuclear device that explodes.
ION, // Calls forth an ion blast on discoverer.
NUKE_MISSILE, // Gets a one time nuclear missile options.
ION_BLAST, // Gets a one time ion blast option.
AIR_STRIKE, // Gets a one time air strike option.
HEAL_BASE, // Heals the player's entire base.
CLOAK, // Units in region gain cloak ability.
EXPLOSION, // Conventional explosion.
NAPALM, // A napalm explosion.
SQUAD, // A mixed squad of friendly infantry appear.
VISCEROID, // A visceroid appears!
DARKNESS, // Shroud the entire map.
REVEAL, // Reveal the entire map.
TOTAL_CRATES,
};
static int _what[] = {
DARKNESS,DARKNESS,
REVEAL,REVEAL,
NUKE,
// ION,ION,
NUKE_MISSILE,
ION_BLAST,ION_BLAST,
AIR_STRIKE,AIR_STRIKE,AIR_STRIKE,AIR_STRIKE,
HEAL_BASE,HEAL_BASE,
CLOAK,CLOAK,
EXPLOSION,EXPLOSION,EXPLOSION,EXPLOSION,
NAPALM,NAPALM,NAPALM,
SQUAD,SQUAD,SQUAD,SQUAD,SQUAD,
UNIT,UNIT,UNIT,UNIT,UNIT,
VISCEROID
};
/*
** Crate types are only defined here so it needs to match my new global crate total ST - 6/4/96 2:16PM
*/
#if (TOTAL_CRATES) == (TOTAL_CRATE_TYPES)
#else
//Huge_Errrrror..... Oh NO!
#endif
if (object && Overlay != OVERLAY_NONE && OverlayTypeClass::As_Reference(Overlay).IsCrate) {
bool steel = (Overlay == OVERLAY_STEEL_CRATE);
COORDINATE coord; // Temporary working coordinate value.
/*
** A triggered crate is automatically destroyed regardless of who or how
** it was triggered.
*/
Redraw_Objects();
Overlay = OVERLAY_NONE;
OverlayData = 0;
if (steel) {
if (object->Owner() == HOUSE_BAD) {
object->House->Add_Nuke_Piece();
new AnimClass(ANIM_CRATE_EMPULSE, Cell_Coord());
}
} else {
int index;
UnitClass * unit = 0;
unsigned damage = 0;
int what = MONEY;
if (GameToPlay != GAME_NORMAL && (Random_Pick(1, 2) == 1 || !object->House->BScan)) {
what = -1;
/*
** If the player has a construction yeard and practically no money and no legitmate means
** to make any more money, then give money to build a refinery.
*/
if ((object->House->BScan & (STRUCTF_CONST|STRUCTF_REFINERY)) == STRUCTF_CONST &&
object->House->Available_Money() < BuildingTypeClass::As_Reference(STRUCT_REFINERY).Cost) {
what = MONEY;
}
/*
** If the player should get an MCV replacement, then give it now (probably).
*/
if (Random_Pick(0, 1) == 0 &&
MPlayerBases &&
!(object->House->UScan & UNITF_MCV) &&
object->House->BScan == 0 &&
object->House->Available_Money() > ((BuildingTypeClass::As_Reference(STRUCT_REFINERY).Cost + BuildingTypeClass::As_Reference(STRUCT_POWER).Cost) * object->House->CostBias)) {
what = UNIT;
}
bool allow_super = true;
if (GameToPlay == GAME_GLYPHX_MULTIPLAYER && !Rule.AllowSuperWeapons) {
allow_super = false;
}
while (what == -1) {
what = _what[Random_Pick((unsigned)0, sizeof(_what)/sizeof(_what[0])-1)];
if (what == REVEAL && object->House->IsVisionary) what = -1;
if (what == AIR_STRIKE && (!allow_super || object->House->AirStrike.Is_Present())) what = -1;
if (what == NUKE_MISSILE && (!allow_super || object->House->NukeStrike.Is_Present())) what = -1;
if (what == ION_BLAST && (!allow_super || object->House->IonCannon.Is_Present())) what = -1;
if (what == CLOAK && object->IsCloakable) what = -1;
}
}
/*
** Keep track of the number of each type of crate found
*/
if (GameToPlay == GAME_INTERNET){
object->House->TotalCrates->Increment_Unit_Total(what);
}
/*
** Update the crate count and when all the crates have been discovered, flag
** to generate a new one.
*/
CrateCount--;
if (!CrateMaker && CrateCount <= 0 && GameToPlay != GAME_NORMAL) {
CrateMaker = true;
CrateTimer = 1;
}
/*
** Create the effect requested.
*/
switch (what) {
default:
/*
** Give the player money.
*/
case MONEY:
new AnimClass(ANIM_CRATE_DOLLAR, Cell_Coord());
if (GameToPlay == GAME_NORMAL) {
HouseClass::As_Pointer(object->Owner())->Refund_Money(2000);
} else {
HouseClass::As_Pointer(object->Owner())->Refund_Money(100 + (Random_Pick(0,19)*100));
}
break;
/*
** Shroud the world in blackness.
*/
case DARKNESS:
{
new AnimClass(ANIM_CRATE_EMPULSE, Cell_Coord());
bool shroud = false;
if (GameToPlay != GAME_GLYPHX_MULTIPLAYER) {
if (object->House == PlayerPtr) {
shroud = true;
}
} else {
if (object->House->IsHuman) {
shroud = true;
}
}
if (shroud) {
for (CELL cell = 0; cell < MAP_CELL_TOTAL; cell++) {
CellClass * cellptr = &Map[cell];
if (cellptr->Is_Mapped(object->House) || cellptr->Is_Visible(object->House)) {
cellptr->Redraw_Objects();
cellptr->Set_Mapped(object->House, false);
cellptr->Set_Visible(object->House, false);
}
}
HouseClass *find_house = object->House;
for (int index = 0; index < Map.Layer[LAYER_GROUND].Count(); index++) {
ObjectClass * object = Map.Layer[LAYER_GROUND][index];
if (object && object->Is_Techno() && ((TechnoClass *)object)->House == find_house) {
object->Look();
}
}
Map.Flag_To_Redraw(true);
}
break;
}
/*
** Reveal the entire map.
*/
case REVEAL:
{
bool reveal = false;
if (GameToPlay != GAME_GLYPHX_MULTIPLAYER) {
if (object->House == PlayerPtr) {
reveal = true;
}
} else {
if (object->House->IsHuman) {
reveal = true;
}
}
new AnimClass(ANIM_CRATE_EMPULSE, Cell_Coord());
object->House->IsVisionary = true;
if (reveal) {
for (CELL cell = 0; cell < MAP_CELL_TOTAL; cell++) {
Map.Map_Cell(cell, object->House, true);
}
}
break;
}
/*
** Try to create a unit where the crate was.
*/
case UNIT: {
UnitTypeClass const * utp = NULL;
/*
** Give the player an MCV if he has no base left but does have more than enough
** money to rebuild a new base. Of course, if he already has an MCV, then don't
** give him another one.
*/
if (MPlayerBases &&
!(object->House->UScan & UNITF_MCV) &&
object->House->BScan == 0 &&
object->House->Available_Money() > (BuildingTypeClass::As_Reference(STRUCT_REFINERY).Cost + BuildingTypeClass::As_Reference(STRUCT_POWER).Cost)) {
utp = &UnitTypeClass::As_Reference(UNIT_MCV);
}
/*
** If the player has a base and a refinery, but no harvester, then give him
** a free one.
*/
if (!utp && (object->House->BScan & STRUCTF_REFINERY) && !(object->House->UScan & UNITF_HARVESTER)) {
utp = &UnitTypeClass::As_Reference(UNIT_HARVESTER);
}
while (!utp) {
UnitType utype = Random_Pick(UNIT_FIRST, (UnitType)(UNIT_COUNT-1));
if (utype != UNIT_MCV || MPlayerBases) {
utp = &UnitTypeClass::As_Reference(utype);
if (utp->IsCrateGoodie && (utp->Ownable & (1 << object->Owner())) && utp->Level <= BuildLevel+2) break;
utp = NULL;
}
}
UnitClass * unit = (UnitClass *)utp->Create_One_Of(object->House);
if (unit) {
if (unit->Unlimbo(Cell_Coord())) {
return(false);
}
delete unit;
}
}
break;
/*
** Create a squad of miscellanous composition.
*/
case SQUAD:
for (index = 0; index < 5; index++) {
static InfantryType _inf[] = {
INFANTRY_E1,INFANTRY_E1,INFANTRY_E1,INFANTRY_E1,INFANTRY_E1,INFANTRY_E1,
INFANTRY_E2,
INFANTRY_E3,
INFANTRY_E4,
INFANTRY_E5,
INFANTRY_E7,
INFANTRY_RAMBO
};
InfantryTypeClass::As_Reference(_inf[Random_Pick((unsigned)0, sizeof(_inf)/sizeof(_inf[0])-1)]).Create_And_Place(Cell_Number(), object->Owner());
}
return(false);
/*
** Sometimes an explosion of great magnitude occurs.
*/
case NUKE:
new AnimClass(ANIM_ATOM_BLAST, Cell_Coord());
break;
/*
** Sometimes an explosion of great magnitude occurs.
*/
case ION:
new AnimClass(ANIM_ION_CANNON, Cell_Coord());
break;
/*
** A nuclear missile was discovered. Add it to the sidebar.
*/
case NUKE_MISSILE:
new AnimClass(ANIM_CRATE_MISSILE, Cell_Coord());
if (object->House->NukeStrike.Enable(true)) {
// Add to Glyphx multiplayer sidebar. ST - 3/22/2019 1:50PM
if (GameToPlay == GAME_GLYPHX_MULTIPLAYER) {
if (object->House->IsHuman) {
Sidebar_Glyphx_Add(RTTI_SPECIAL, SPC_NUCLEAR_BOMB, object->House);
}
} else {
if (object->IsOwnedByPlayer) {
Map.Add(RTTI_SPECIAL, SPC_NUCLEAR_BOMB);
Map.Column[1].Flag_To_Redraw();
}
}
}
break;
/*
** A one time ion blast was discovered. Add it to the sidebar.
*/
case ION_BLAST:
new AnimClass(ANIM_CRATE_EARTH, Cell_Coord());
if (object->House->IonCannon.Enable(true)) {
// Add to Glyphx multiplayer sidebar. ST - 3/22/2019 1:50PM
if (GameToPlay == GAME_GLYPHX_MULTIPLAYER) {
if (object->House->IsHuman) {
Sidebar_Glyphx_Add(RTTI_SPECIAL, SPC_ION_CANNON, object->House);
}
} else {
if (object->IsOwnedByPlayer) {
Map.Add(RTTI_SPECIAL, SPC_ION_CANNON);
Map.Column[1].Flag_To_Redraw();
}
}
}
break;
/*
** A one time air strike can be called int. Add it to the sidebar.
*/
case AIR_STRIKE:
new AnimClass(ANIM_CRATE_DEVIATOR, Cell_Coord());
if (object->House->AirStrike.Enable(true)) {
// Add to Glyphx multiplayer sidebar. ST - 3/22/2019 1:50PM
if (GameToPlay == GAME_GLYPHX_MULTIPLAYER) {
if (object->House->IsHuman) {
Sidebar_Glyphx_Add(RTTI_SPECIAL, SPC_AIR_STRIKE, object->House);
}
} else {
if (object->IsOwnedByPlayer) {
Map.Add(RTTI_SPECIAL, SPC_AIR_STRIKE);
Map.Column[1].Flag_To_Redraw();
}
}
}
break;
/*
** A group of explosions are triggered around the crate.
*/
case EXPLOSION:
damage = 400;
object->Take_Damage((int&)damage, 0, WARHEAD_HE);
for (index = 0; index < 5; index++) {
COORDINATE coord = Coord_Scatter(Cell_Coord(), Random_Pick(0, 0x0200));
new AnimClass(ANIM_FBALL1, coord);
damage = 400;
Explosion_Damage(coord, damage, NULL, WARHEAD_HE);
}
break;
/*
** A napalm blast is triggered.
*/
case NAPALM:
coord = Coord_Mid(Cell_Coord(), object->Center_Coord());
new AnimClass(ANIM_NAPALM3, coord);
damage = 600;
Explosion_Damage(coord, damage, NULL, WARHEAD_FIRE);
break;
/*
** A visceroid appears and, boy, he's angry!
*/
case VISCEROID:
unit = new UnitClass(UNIT_VICE, HOUSE_JP);
if (unit) {
if (unit->Unlimbo(Cell_Coord())) {
return(false);
}
delete unit;
}
break;
/*
** All objects within a certain range will gain the ability to cloak.
*/
case CLOAK:
new AnimClass(ANIM_CRATE_STEALTH, Cell_Coord());
for (index = 0; index < Map.Layer[LAYER_GROUND].Count(); index++) {
ObjectClass * obj = Map.Layer[LAYER_GROUND][index];
if (obj && obj->Is_Techno() && Distance(Cell_Coord(), obj->Center_Coord()) < 0x0300) {
((TechnoClass *)obj)->IsCloakable = true;
}
}
break;
/*
** All of the player's objects heal up.
*/
case HEAL_BASE:
new AnimClass(ANIM_CRATE_INVUN, Cell_Coord());
for (index = 0; index < Logic.Count(); index++) {
ObjectClass * obj = Logic[index];
if (obj && object->Is_Techno() && object->House->Class->House == obj->Owner()) {
obj->Strength = obj->Class_Of().MaxStrength;
}
}
break;
}
}
}
return(true);
}
/***********************************************************************************************
* CellClass::Flag_Place -- Places a house flag down on the cell. *
* *
* This routine will place the house flag at this cell location. *
* *
* INPUT: house -- The house that is having its flag placed here. *
* *
* OUTPUT: Was the flag successfully placed here? *
* *
* WARNINGS: Failure to place means that the cell is impassable for some reason. *
* *
* HISTORY: *
* 05/23/1995 JLB : Created. *
*=============================================================================================*/
bool CellClass::Flag_Place(HousesType house)
{
Validate();
if (!IsFlagged && Is_Generally_Clear()) {
IsFlagged = true;
Owner = house;
Redraw_Objects();
return(true);
}
return(false);
}
/***********************************************************************************************
* CellClass::Flag_Remove -- Removes the house flag from the cell. *
* *
* This routine will free the cell of any house flag that may be located there. *
* *
* INPUT: none *
* *
* OUTPUT: Was there a flag here that was removed? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 05/23/1995 JLB : Created. *
*=============================================================================================*/
bool CellClass::Flag_Remove(void)
{
Validate();
if (IsFlagged) {
IsFlagged = false;
Owner = HOUSE_NONE;
Redraw_Objects();
return(true);
}
return(false);
}
/***********************************************************************************************
* CellClass::Shimmer -- Causes all objects in the cell to shimmer. *
* *
* This routine is called when some event would cause a momentary disruption in the *
* cloaking device. All objects that are cloaked in the cell will have their cloaking *
* device shimmer. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/29/1995 JLB : Created. *
*=============================================================================================*/
void CellClass::Shimmer(void)
{
Validate();
ObjectClass * object = Cell_Occupier();
while (object) {
object->Do_Shimmer();
object = object->Next;
}
}
/***********************************************************************************************
* CellClass::Cell_Occupier -- Fetches the occupier for the cell. *
* *
* This routine returns with the first recorded occupier of this cell. A special validity *
* check is performed to ensure that there are no dead objects still marked on the *
* map. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with a pointer to the first occupier object. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 08/17/1995 JLB : Created. *
*=============================================================================================*/
ObjectClass * CellClass::Cell_Occupier(void) const
{
ObjectClass * ptr = OccupierPtr;
while (ptr && !ptr->IsActive) {
ptr = ptr->Next;
((ObjectClass *&)OccupierPtr) = 0;
}
return(ptr);
}
/*
** Additions to CellClass to track visibility per-player. ST - 3/5/2019 3:08PM
**
**
**
**
**
*/
/***********************************************************************************************
* CellClass::Set_Mapped -- Set the cell mapped for the given player *
* *
* *
* HISTORY: *
* 3/5/2019 3:09PM - ST *
*=============================================================================================*/
void CellClass::Set_Mapped(HousesType house, bool set)
{
int shift = (int) house;
if (set) {
IsMappedByPlayerMask |= (1 << shift);
} else {
IsMappedByPlayerMask &= ~(1 << shift);
}
}
/***********************************************************************************************
* CellClass::Set_Mapped -- Set the cell mapped for the given player *
* *
* *
* HISTORY: *
* 3/5/2019 3:09PM - ST *
*=============================================================================================*/
void CellClass::Set_Mapped(HouseClass *player, bool set)
{
if (player && player->Class) {
Set_Mapped(player->Class->House, set);
if (GameToPlay == GAME_NORMAL && player->IsHuman) {
IsMapped = set; // Also set the regular flag in single player
}
}
}
/***********************************************************************************************
* CellClass::Is_Mapped -- Is the cell mapped for the given player *
* *
* *
* HISTORY: *
* 3/5/2019 3:13PM - ST *
*=============================================================================================*/
bool CellClass::Is_Mapped(HousesType house) const
{
int shift = (int) house;
return (IsMappedByPlayerMask & (1 << shift)) ? true : false;
}
/***********************************************************************************************
* CellClass::Is_Mapped -- Is the cell mapped for the given player *
* *
* *
* HISTORY: *
* 3/5/2019 3:13PM - ST *
*=============================================================================================*/
bool CellClass::Is_Mapped(HouseClass *player) const
{
if (player && player->Class) {
return Is_Mapped(player->Class->House);
}
return false;
}
/***********************************************************************************************
* CellClass::Set_Visible -- Set the cell visible for the given player *
* *
* *
* HISTORY: *
* 3/5/2019 3:16PM - ST *
*=============================================================================================*/
void CellClass::Set_Visible(HousesType house, bool set)
{
int shift = (int) house;
if (set) {
IsVisibleByPlayerMask |= (1 << shift);
} else {
IsVisibleByPlayerMask &= ~(1 << shift);
}
}
/***********************************************************************************************
* CellClass::Set_Visible -- Set the cell visible for the given player *
* *
* *
* HISTORY: *
* 3/5/2019 3:16PM - ST *
*=============================================================================================*/
void CellClass::Set_Visible(HouseClass *player, bool set)
{
if (player && player->Class) {
Set_Visible(player->Class->House, set);
if (GameToPlay == GAME_NORMAL && player->IsHuman) {
IsVisible = set; // Also set the regular flag in single player. This is needed for rendering
}
}
}
/***********************************************************************************************
* CellClass::Is_Visible -- Is the cell visible for the given player *
* *
* *
* HISTORY: *
* 3/5/2019 3:16PM - ST *
*=============================================================================================*/
bool CellClass::Is_Visible(HousesType house) const
{
int shift = (int) house;
return (IsVisibleByPlayerMask & (1 << shift)) ? true : false;
}
/***********************************************************************************************
* CellClass::Is_Visible -- Is the cell visible for the given player *
* *
* *
* HISTORY: *
* 3/5/2019 3:16PM - ST *
*=============================================================================================*/
bool CellClass::Is_Visible(HouseClass *player) const
{
if (player && player->Class) {
return Is_Visible(player->Class->House);
}
return false;
}
void CellClass::Override_Land_Type(LandType type)
{
OverrideLand = type;
}
#ifdef USE_RA_AI
/*
** Addition from Red Alert for AI. ST - 7/24/2019 5:33PM
*/
/***********************************************************************************************
* CellClass::Is_Clear_To_Move -- Determines if the cell is generally clear for travel *
* *
* This routine is called when determining general passability for purposes of zone *
* calculation. Only blockages that cannot be circumvented are considered to make a cell *
* impassable. All other obstructions can either be destroyed or are temporary. *
* *
* INPUT: loco -- The locomotion type to use when determining passablility. *
* *
* ignoreinfantry -- Should infantry in the cell be ignored for movement purposes? *
* *
* ignorevehicles -- If vehicles should be ignored, then this flag will be true. *
* *
* zone -- If specified, the zone must match this value or else movement is *
* presumed disallowed. *
* *
* check -- This specifies the zone type that this check applies to. *
* *
* OUTPUT: Is the cell generally passable to ground targeting? *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/25/1995 JLB : Created. *
* 06/25/1996 JLB : Uses tracked vehicles as a basis for zone check. *
* 10/05/1996 JLB : Allows checking for crushable blockages. *
*=============================================================================================*/
bool CellClass::Is_Clear_To_Move(bool ignoreinfantry, bool ignorevehicles) const
{
//assert((unsigned)Cell_Number() <= MAP_CELL_TOTAL);
/*
** Flying objects always consider every cell passable since they can fly over everything.
*/
//if (loco == SPEED_WINGED) {
// return(true);
//}
/*
** If a zone was specified, then see if the cell is in a legal
** zone to allow movement.
*/
//if (zone != -1) {
// if (zone != Zones[check]) {
// return(false);
// }
//}
/*
** Check the occupy bits for passable legality. If ignore infantry is true, then
** don't consider infnatry.
*/
int composite = Flag.Composite;
if (ignoreinfantry) {
composite &= 0xE0; // Drop the infantry occupation bits.
}
if (ignorevehicles) {
composite &= 0x5F; // Drop the vehicle/building bit.
}
if (composite != 0) {
return(false);
}
/*
** Fetch the land type of the cell -- to be modified and used later.
*/
//LandType land = Land_Type();
/*
** Walls are always considered to block the terrain for general passability
** purposes unless this is a wall crushing check or if the checking object
** can destroy walls.
*/
OverlayTypeClass const * overlay = NULL;
if (Overlay != OVERLAY_NONE) {
overlay = &OverlayTypeClass::As_Reference(Overlay);
}
if (overlay != NULL && overlay->IsWall) {
//if (check != MZONE_DESTROYER && (check != MZONE_CRUSHER || !overlay->IsCrushable)) {
return(false);
//}
/*
** Crushing objects consider crushable walls as clear rather than the
** typical LAND_WALL setting.
*/
//land = LAND_CLEAR;
}
/*
** See if the ground type is impassable to this locomotion type and if
** so, return the error condition.
*/
//if (::Ground[land].Cost[loco] == 0) {
// return(false);
//}
/*
** All checks passed, so this cell must be passable.
*/
return(true);
}
#endif //USE_RA_AI