mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-04-29 09:52:36 +12:00
1596 lines
75 KiB
C++
1596 lines
75 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: F:\projects\c&c\vcs\code\map.cpv 2.17 16 Oct 1995 16:52:22 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 : MAP.CPP *
|
|
* *
|
|
* Programmer : Joe L. Bostic *
|
|
* *
|
|
* Start Date : September 10, 1993 *
|
|
* *
|
|
* Last Update : August 20, 1995 [JLB] *
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* MapClass::Cell_Distance -- Determines the distance between two cells. *
|
|
* MapClass::Cell_Region -- Determines the region from a specified cell number. *
|
|
* MapClass::Cell_Threat -- Gets a houses threat value for a cell *
|
|
* MapClass::Close_Object -- Finds a clickable close object to the specified coordinate. *
|
|
* MapClass::In_Radar -- Is specified cell in the radar map? *
|
|
* MapClass::Init -- clears all cells *
|
|
* MapClass::Logic -- Handles map related logic functions. *
|
|
* MapClass::One_Time -- Performs special one time initializations for the map. *
|
|
* MapClass::Overlap_Down -- computes & marks object's overlap cells *
|
|
* MapClass::Overlap_Up -- Computes & clears object's overlap cells *
|
|
* MapClass::Overpass -- Performs any final cleanup to a freshly constructed map. *
|
|
* MapClass::Pick_Up -- Removes specified object from the map. *
|
|
* MapClass::Place_Down -- Places the specified object onto the map. *
|
|
* MapClass::Place_Random_Crate -- Places a crate at random location on map. *
|
|
* MapClass::Read_Binary -- reads the map's binary image file *
|
|
* MapClass::Set_Map_Dimensions -- Initialize the map. *
|
|
* MapClass::Sight_From -- Mark as visible the cells within a specified radius. *
|
|
* MapClass::Validate -- validates every cell on the map *
|
|
* MapClass::Write_Binary -- writes the map's binary image file *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#include "function.h"
|
|
|
|
#define MCW MAP_CELL_W
|
|
int const MapClass::RadiusOffset[] = {
|
|
/* 0 */ 0,
|
|
/* 1 */ (-MCW*1)-1,(-MCW*1)+0,(-MCW*1)+1,-1,1,(MCW*1)-1,(MCW*1)+0,(MCW*1)+1,
|
|
/* 2 */ (-MCW*2)-1,(-MCW*2)+0,(-MCW*2)+1,(-MCW*1)-2,(-MCW*1)+2,-2,2,(MCW*1)-2,(MCW*1)+2,(MCW*2)-1,(MCW*2)+0,(MCW*2)+1,
|
|
/* 3 */ (-MCW*3)-1,(-MCW*3)+0,(-MCW*3)+1,(-MCW*2)-2,(-MCW*2)+2,(-MCW*1)-3,(-MCW*1)+3,-3,3,(MCW*1)-3,(MCW*1)+3,(MCW*2)-2,(MCW*2)+2,(MCW*3)-1,(MCW*3)+0,(MCW*3)+1,
|
|
/* 4 */ (-MCW*4)-1,(-MCW*4)+0,(-MCW*4)+1,(-MCW*3)-3,(-MCW*3)-2,(-MCW*3)+2,(-MCW*3)+3,(-MCW*2)-3,(-MCW*2)+3,(-MCW*1)-4,(-MCW*1)+4,-4,4,(MCW*1)-4,(MCW*1)+4,(MCW*2)-3,(MCW*2)+3,(MCW*3)-3,(MCW*3)-2,(MCW*3)+2,(MCW*3)+3,(MCW*4)-1,(MCW*4)+0,(MCW*4)+1,
|
|
/* 5 */ (-MCW*5)-1,(-MCW*5)+0,(-MCW*5)+1,(-MCW*4)-3,(-MCW*4)-2,(-MCW*4)+2,(-MCW*4)+3,(-MCW*3)-4,(-MCW*3)+4,(-MCW*2)-4,(-MCW*2)+4,(-MCW*1)-5,(-MCW*1)+5,-5,5,(MCW*1)-5,(MCW*1)+5,(MCW*2)-4,(MCW*2)+4,(MCW*3)-4,(MCW*3)+4,(MCW*4)-3,(MCW*4)-2,(MCW*4)+2,(MCW*4)+3,(MCW*5)-1,(MCW*5)+0,(MCW*5)+1,
|
|
/* 6 */ (-MCW*6)-1,(-MCW*6)+0,(-MCW*6)+1,(-MCW*5)-3,(-MCW*5)-2,(-MCW*5)+2,(-MCW*5)+3,(-MCW*4)-4,(-MCW*4)+4,(-MCW*3)-5,(-MCW*3)+5,(-MCW*2)-5,(-MCW*2)+5,(-MCW*1)-6,(-MCW*1)+6,-6,6,(MCW*1)-6,(MCW*1)+6,(MCW*2)-5,(MCW*2)+5,(MCW*3)-5,(MCW*3)+5,(MCW*4)-4,(MCW*4)+4,(MCW*5)-3,(MCW*5)-2,(MCW*5)+2,(MCW*5)+3,(MCW*6)-1,(MCW*6)+0,(MCW*6)+1,
|
|
/* 7 */ (-MCW*7)-1,(-MCW*7)+0,(-MCW*7)+1,(-MCW*6)-3,(-MCW*6)-2,(-MCW*6)+2,(-MCW*6)+3,(-MCW*5)-5,(-MCW*5)-4,(-MCW*5)+4,(-MCW*5)+5,(-MCW*4)-5,(-MCW*4)+5,(-MCW*3)-6,(-MCW*3)+6,(-MCW*2)-6,(-MCW*2)+6,(-MCW*1)-7,(-MCW*1)+7,-7,7,(MCW*1)-7,(MCW*1)+7,(MCW*2)-6,(MCW*2)+6,(MCW*3)-6,(MCW*3)+6,(MCW*4)-5,(MCW*4)+5,(MCW*5)-5,(MCW*5)-4,(MCW*5)+4,(MCW*5)+5,(MCW*6)-3,(MCW*6)-2,(MCW*6)+2,(MCW*6)+3,(MCW*7)-1,(MCW*7)+0,(MCW*7)+1,
|
|
/* 8 */ (-MCW*8)-1,(-MCW*8)+0,(-MCW*8)+1,(-MCW*7)-3,(-MCW*7)-2,(-MCW*7)+2,(-MCW*7)+3,(-MCW*6)-5,(-MCW*6)-4,(-MCW*6)+4,(-MCW*6)+5,(-MCW*5)-6,(-MCW*5)+6,(-MCW*4)-6,(-MCW*4)+6,(-MCW*3)-7,(-MCW*3)+7,(-MCW*2)-7,(-MCW*2)+7,(-MCW*1)-8,(-MCW*1)+8,-8,8,(MCW*1)-8,(MCW*1)+8,(MCW*2)-7,(MCW*2)+7,(MCW*3)-7,(MCW*3)+7,(MCW*4)-6,(MCW*4)+6,(MCW*5)-6,(MCW*5)+6,(MCW*6)-5,(MCW*6)-4,(MCW*6)+4,(MCW*6)+5,(MCW*7)-3,(MCW*7)-2,(MCW*7)+2,(MCW*7)+3,(MCW*8)-1,(MCW*8)+0,(MCW*8)+1,
|
|
/* 9 */ (-MCW*9)-1,(-MCW*9)+0,(-MCW*9)+1,(-MCW*8)-3,(-MCW*8)-2,(-MCW*8)+2,(-MCW*8)+3,(-MCW*7)-5,(-MCW*7)-4,(-MCW*7)+4,(-MCW*7)+5,(-MCW*6)-6,(-MCW*6)+6,(-MCW*5)-7,(-MCW*5)+7,(-MCW*4)-7,(-MCW*4)+7,(-MCW*3)-8,(-MCW*3)+8,(-MCW*2)-8,(-MCW*2)+8,(-MCW*1)-9,(-MCW*1)+9,-9,9,(MCW*1)-9,(MCW*1)+9,(MCW*2)-8,(MCW*2)+8,(MCW*3)-8,(MCW*3)+8,(MCW*4)-7,(MCW*4)+7,(MCW*5)-7,(MCW*5)+7,(MCW*6)-6,(MCW*6)+6,(MCW*7)-5,(MCW*7)-4,(MCW*7)+4,(MCW*7)+5,(MCW*8)-3,(MCW*8)-2,(MCW*8)+2,(MCW*8)+3,(MCW*9)-1,(MCW*9)+0,(MCW*9)+1,
|
|
/* 10 */ (-MCW*10)-1,(-MCW*10)+0,(-MCW*10)+1,(-MCW*9)-3,(-MCW*9)-2,(-MCW*9)+2,(-MCW*9)+3,(-MCW*8)-5,(-MCW*8)-4,(-MCW*8)+4,(-MCW*8)+5,(-MCW*7)-7,(-MCW*7)-6,(-MCW*7)+6,(-MCW*7)+7,(-MCW*6)-7,(-MCW*6)+7,(-MCW*5)-8,(-MCW*5)+8,(-MCW*4)-8,(-MCW*4)+8,(-MCW*3)-9,(-MCW*3)+9,(-MCW*2)-9,(-MCW*2)+9,(-MCW*1)-10,(-MCW*1)+10,-10,10,(MCW*1)-10,(MCW*1)+10,(MCW*2)-9,(MCW*2)+9,(MCW*3)-9,(MCW*3)+9,(MCW*4)-8,(MCW*4)+8,(MCW*5)-8,(MCW*5)+8,(MCW*6)-7,(MCW*6)+7,(MCW*7)-7,(MCW*7)-6,(MCW*7)+6,(MCW*7)+7,(MCW*8)-5,(MCW*8)-4,
|
|
(MCW*8)+4,(MCW*8)+5,(MCW*9)-3,(MCW*9)-2,(MCW*9)+2,(MCW*9)+3,(MCW*10)-1,(MCW*10)+0,(MCW*10)+1,
|
|
};
|
|
|
|
int const MapClass::RadiusCount[11] = {1,9,21,37,61,89,121,161,205,253,309};
|
|
|
|
|
|
CellClass *BlubCell;
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::One_Time -- Performs special one time initializations for the map. *
|
|
* *
|
|
* This routine is used by the game initialization function in order to perform any one *
|
|
* time initializations required for the map. This includes allocation of the map and *
|
|
* setting up its default dimensions. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: This routine MUST be called once and only once. *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/31/1994 JLB : Created. *
|
|
* 12/01/1994 BR : Added CellTriggers initialization *
|
|
*=============================================================================================*/
|
|
void MapClass::One_Time(void)
|
|
{
|
|
GScreenClass::One_Time();
|
|
|
|
XSize = MAP_CELL_W;
|
|
YSize = MAP_CELL_H;
|
|
Size = XSize * YSize;
|
|
|
|
/*
|
|
** Allocate the cell array.
|
|
*/
|
|
Alloc_Cells();
|
|
|
|
/*
|
|
** Init the CellTriggers array to the required size.
|
|
*/
|
|
CellTriggers.Resize(MAP_CELL_TOTAL);
|
|
}
|
|
|
|
////////////////////////////////////////////////////
|
|
// Added this function to allow the editor to setup the map without setting up the entire system. - 06/18/2019 JAS
|
|
void MapClass::One_Time_Editor(void)
|
|
{
|
|
XSize = MAP_CELL_W;
|
|
YSize = MAP_CELL_H;
|
|
Size = XSize * YSize;
|
|
|
|
/*
|
|
** Allocate the cell array.
|
|
*/
|
|
Alloc_Cells();
|
|
|
|
/*
|
|
** Init the CellTriggers array to the required size.
|
|
*/
|
|
CellTriggers.Resize(MAP_CELL_TOTAL);
|
|
}
|
|
// End of change. - 06/15/2019 JAS
|
|
////////////////////////////////////////////////////
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Init_Clear -- clears the map & buffers to a known state *
|
|
* *
|
|
* INPUT: *
|
|
* none. *
|
|
* *
|
|
* OUTPUT: *
|
|
* none. *
|
|
* *
|
|
* WARNINGS: *
|
|
* none. *
|
|
* *
|
|
* HISTORY: *
|
|
* 03/17/1995 BRR : Created. *
|
|
*=============================================================================================*/
|
|
void MapClass::Init_Clear(void)
|
|
{
|
|
GScreenClass::Init_Clear();
|
|
Init_Cells();
|
|
TiberiumScan = 0;
|
|
IsForwardScan = true;
|
|
TiberiumGrowthCount = 0;
|
|
TiberiumSpreadCount = 0;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Alloc_Cells -- allocates the cell array *
|
|
* *
|
|
* This routine should be called at One_Time, and after loading the Map object from a save *
|
|
* game, but prior to loading the cell objects. *
|
|
* *
|
|
* INPUT: *
|
|
* none. *
|
|
* *
|
|
* OUTPUT: *
|
|
* none. *
|
|
* *
|
|
* WARNINGS: *
|
|
* none. *
|
|
* *
|
|
* HISTORY: *
|
|
* 03/17/1995 BRR : Created. *
|
|
*=============================================================================================*/
|
|
void MapClass::Alloc_Cells(void)
|
|
{
|
|
/*
|
|
** Assume that whatever the contents of the VectorClass are is garbage
|
|
** (it may have been loaded from a save-game file), so zero it out first.
|
|
*/
|
|
Vector = 0;
|
|
VectorMax = 0;
|
|
IsAllocated = 0;
|
|
Resize(Size);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Free_Cells -- frees the cell array *
|
|
* *
|
|
* This routine is used by the Load_Game routine to free the map's cell array before loading *
|
|
* the map object from disk; the array is then re-allocated & cleared before the cell objects *
|
|
* are loaded. *
|
|
* *
|
|
* INPUT: *
|
|
* none. *
|
|
* *
|
|
* OUTPUT: *
|
|
* none. *
|
|
* *
|
|
* WARNINGS: *
|
|
* none. *
|
|
* *
|
|
* HISTORY: *
|
|
* 03/17/1995 BRR : Created. *
|
|
*=============================================================================================*/
|
|
void MapClass::Free_Cells(void)
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Init_Cells -- Initializes the cell array to a fresh state. *
|
|
* *
|
|
* This routine is used by Init_Clear to set the cells to a known state; it's also used by *
|
|
* the Load_Game routine to init all cells before loading a set of cells from disk, so it *
|
|
* needs to be called separately from the other Init_xxx() routines. *
|
|
* *
|
|
* INPUT: *
|
|
* none. *
|
|
* *
|
|
* OUTPUT: *
|
|
* none. *
|
|
* *
|
|
* WARNINGS: *
|
|
* none. *
|
|
* *
|
|
* HISTORY: *
|
|
* 03/17/1995 BRR : Created. *
|
|
*=============================================================================================*/
|
|
void MapClass::Init_Cells(void)
|
|
{
|
|
TotalValue = 0;
|
|
#ifdef NEVER
|
|
Free_Cells();
|
|
Alloc_Cells();
|
|
#else
|
|
for (int index = 0; index < MAP_CELL_TOTAL; index++) {
|
|
Map[index] = CellClass();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Set_Map_Dimensions -- Set map dimensions. *
|
|
* *
|
|
* This routine is used to set the legal limits and position of the *
|
|
* map as it relates to the overall map array. Typically, this is *
|
|
* called by the scenario loading code. *
|
|
* *
|
|
* INPUT: x,y -- The X and Y coordinate of the "upper left" corner *
|
|
* of the map. *
|
|
* *
|
|
* w,h -- The width and height of the legal map. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/14/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
void MapClass::Set_Map_Dimensions(int x, int y, int w, int h)
|
|
{
|
|
MapCellX = x;
|
|
MapCellY = y;
|
|
MapCellWidth = w;
|
|
MapCellHeight = h;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Sight_From -- Mark as visible the cells within a specified radius. *
|
|
* *
|
|
* This routine is used to reveal the cells around a specific location. *
|
|
* Typically, as a unit moves or is deployed, this routine will be *
|
|
* called. Since it deals with MANY cells, it needs to be extremely *
|
|
* fast. *
|
|
* *
|
|
* INPUT: house -- Player to perform the visibility update for *
|
|
* *
|
|
* cell -- The coordinate that the sighting originates from. *
|
|
* *
|
|
* sightrange-- The distance in cells that sighting extends. *
|
|
* *
|
|
* incremental-- Is this an incremental sighting. In other *
|
|
* words, has this function been called before where *
|
|
* the center coordinate is no more than one cell *
|
|
* distant from the last time? *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/19/1992 JLB : Created. *
|
|
* 03/08/1994 JLB : Updated to use sight table and incremental flag. *
|
|
* 05/18/1994 JLB : Converted to member function. *
|
|
* 03/06/2019 ST : Added HouseClass pointer parameter for new multiplayer code *
|
|
*=============================================================================================*/
|
|
void MapClass::Sight_From(HouseClass *house, CELL cell, int sightrange, bool incremental)
|
|
{
|
|
int xx; // Center cell X coordinate (bounds checking).
|
|
int const *ptr; // Offset pointer.
|
|
int count; // Counter for number of offsets to process.
|
|
|
|
// Added. ST - 3/6/2019 1:50PM
|
|
if ((house == NULL || house->IsHuman == false) && !ShareAllyVisibility) {
|
|
return;
|
|
}
|
|
|
|
/*
|
|
** Units that are off-map cannot sight.
|
|
*/
|
|
if (!In_Radar(cell)) return;
|
|
if (!sightrange || sightrange > 10) return;
|
|
|
|
/*
|
|
** Determine logical cell coordinate for center scan point.
|
|
*/
|
|
xx = Cell_X(cell);
|
|
|
|
/*
|
|
** Incremental scans only scan the outer rings. Full scans
|
|
** scan all internal cells as well.
|
|
*/
|
|
count = RadiusCount[sightrange];
|
|
ptr = &RadiusOffset[0];
|
|
if (incremental) {
|
|
if (sightrange > 1) {
|
|
ptr += RadiusCount[sightrange-2];
|
|
count -= RadiusCount[sightrange-2];
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Process all offsets required for the desired scan.
|
|
*/
|
|
while (count--) {
|
|
CELL newcell; // New cell with offset.
|
|
int xdiff; // New cell's X coordinate distance from center.
|
|
|
|
newcell = cell + *ptr++;
|
|
|
|
/*
|
|
** Determine if the map edge has been wrapped. If so,
|
|
** then don't process the cell.
|
|
*/
|
|
if ((unsigned)newcell >= MAP_CELL_TOTAL) continue;
|
|
xdiff = Cell_X(newcell) - xx;
|
|
xdiff = ABS(xdiff);
|
|
if (xdiff > sightrange) continue;
|
|
if (Distance(newcell, cell) > sightrange) continue;
|
|
|
|
/*
|
|
** Map the cell. For incremental scans, then update
|
|
** adjacent cells as well. For full scans, just update
|
|
** the cell itself.
|
|
*/
|
|
// Pass the house through, instead of assuming it's the local player. ST - 3/6/2019 10:26AM
|
|
//Map.Map_Cell(newcell, PlayerPtr);
|
|
Map.Map_Cell(newcell, house, true);
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Cell_Distance -- Determines the distance between two cells. *
|
|
* *
|
|
* This routine will return with the calculated "straight line" *
|
|
* distance between the two cells specified. It uses the dragon strike *
|
|
* method of distance calculation. *
|
|
* *
|
|
* INPUT: cell1 -- First cell. *
|
|
* *
|
|
* cell2 -- Second cell. *
|
|
* *
|
|
* OUTPUT: Returns with the "cell" distance between the two cells *
|
|
* specified. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 04/29/1994 JLB : Created. *
|
|
* 04/30/1994 JLB : Converted to member function. *
|
|
*=============================================================================================*/
|
|
int MapClass::Cell_Distance(CELL cell1, CELL cell2)
|
|
{
|
|
register int x,y; // Difference on X and Y axis.
|
|
|
|
x = Cell_X(cell1) - Cell_X(cell2);
|
|
y = Cell_Y(cell1) - Cell_Y(cell2);
|
|
|
|
if (x < 0) x = -x;
|
|
if (y < 0) y = -y;
|
|
|
|
if (x > y) {
|
|
return(x + (y>>1));
|
|
}
|
|
return(y + (x>>1));
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::In_Radar -- Is specified cell in the radar map? *
|
|
* *
|
|
* This determines if the specified cell can be within the navigable *
|
|
* bounds of the map. Technically, this means, any cell that can be *
|
|
* scanned by radar. If a cell returns false from this function, then *
|
|
* the player could never move to or pass over this cell. *
|
|
* *
|
|
* INPUT: cell -- The cell to examine. *
|
|
* *
|
|
* OUTPUT: bool; Is this cell possible to be displayed on radar? *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/07/1992 JLB : Created. *
|
|
* 04/30/1994 JLB : Converted to member function. *
|
|
* 05/01/1994 JLB : Speeded up. *
|
|
*=============================================================================================*/
|
|
bool MapClass::In_Radar(CELL cell) const
|
|
{
|
|
if (cell & 0xF000) return(false);
|
|
return((unsigned)(Cell_X(cell) - MapCellX) < (unsigned)MapCellWidth && (unsigned)(Cell_Y(cell) - MapCellY) < (unsigned)MapCellHeight);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Place_Down -- Places the specified object onto the map. *
|
|
* *
|
|
* This routine is used to place an object onto the map. It updates the "occupier" of the *
|
|
* cells that this object covers. The cells are determined from the Occupy_List function *
|
|
* provided by the object. Only one cell can have an occupier and this routine is the only *
|
|
* place that sets this condition. *
|
|
* *
|
|
* INPUT: cell -- The cell to base object occupation around. *
|
|
* *
|
|
* object -- The object to place onto the map. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/31/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
void MapClass::Place_Down(CELL cell, ObjectClass * object)
|
|
{
|
|
if (!object) return;
|
|
|
|
short const *list = object->Occupy_List();
|
|
while (*list != REFRESH_EOL) {
|
|
CELL newcell = cell + *list++;
|
|
if ((unsigned)newcell < MAP_CELL_TOTAL) {
|
|
(*this)[newcell].Occupy_Down(object);
|
|
(*this)[newcell].Recalc_Attributes();
|
|
(*this)[newcell].Redraw_Objects();
|
|
}
|
|
}
|
|
|
|
list = object->Overlap_List();
|
|
while (*list != REFRESH_EOL) {
|
|
CELL newcell = cell + *list++;
|
|
if ((unsigned)newcell < MAP_CELL_TOTAL) {
|
|
(*this)[newcell].Overlap_Down(object);
|
|
(*this)[newcell].Redraw_Objects();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Pick_Up -- Removes specified object from the map. *
|
|
* *
|
|
* The object specified is removed from the map by this routine. This will remove the *
|
|
* occupation flag for all the cells that the object covers. The cells that are covered *
|
|
* are determined from the Occupy_List function. *
|
|
* *
|
|
* INPUT: cell -- The cell that the object is centered about. *
|
|
* *
|
|
* object -- Pointer to the object that will be removed. *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/31/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
void MapClass::Pick_Up(CELL cell, ObjectClass * object)
|
|
{
|
|
if (!object) return;
|
|
|
|
short const *list = object->Occupy_List();
|
|
while (*list != REFRESH_EOL) {
|
|
CELL newcell = cell + *list++;
|
|
if ((unsigned)newcell < MAP_CELL_TOTAL) {
|
|
(*this)[newcell].Occupy_Up(object);
|
|
(*this)[newcell].Recalc_Attributes();
|
|
(*this)[newcell].Redraw_Objects();
|
|
}
|
|
}
|
|
|
|
list = object->Overlap_List();
|
|
while (*list != REFRESH_EOL) {
|
|
CELL newcell = cell + *list++;
|
|
if ((unsigned)newcell < MAP_CELL_TOTAL) {
|
|
(*this)[newcell].Overlap_Up(object);
|
|
(*this)[newcell].Redraw_Objects();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Overlap_Down -- computes & marks object's overlap cells *
|
|
* *
|
|
* This routine is just like Place_Down, but it doesn't mark the cell's Occupier. *
|
|
* This routine is used to implement MARK_OVERLAP_DOWN, which is useful for changing *
|
|
* an object's render size, but not its logical size (ie when it's selected or an *
|
|
* animation is attached to it). *
|
|
* *
|
|
* INPUT: *
|
|
* cell -- The cell to base object overlap around. *
|
|
* object -- The object to place onto the map. *
|
|
* *
|
|
* OUTPUT: *
|
|
* none. *
|
|
* *
|
|
* WARNINGS: *
|
|
* none. *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/12/1995 BRR : Created. *
|
|
*=============================================================================================*/
|
|
void MapClass::Overlap_Down(CELL cell, ObjectClass * object)
|
|
{
|
|
if (!object) return;
|
|
|
|
short const *list = object->Overlap_List();
|
|
while (*list != REFRESH_EOL) {
|
|
CELL newcell = cell + *list++;
|
|
if ((unsigned)newcell < MAP_CELL_TOTAL) {
|
|
(*this)[newcell].Overlap_Down(object);
|
|
(*this)[newcell].Redraw_Objects();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Overlap_Up -- Computes & clears object's overlap cells *
|
|
* *
|
|
* This routine is just like Pick_Up, but it doesn't mark the cell's Occupier. *
|
|
* This routine is used to implement MARK_OVERLAP_UP, which is useful for changing *
|
|
* an object's render size, but not its logical size (ie when it's selected or an *
|
|
* animation is attached to it). *
|
|
* *
|
|
* INPUT: *
|
|
* cell -- The cell to base object overlap around. *
|
|
* object -- The object to place onto the map. *
|
|
* *
|
|
* OUTPUT: *
|
|
* none. *
|
|
* *
|
|
* WARNINGS: *
|
|
* none. *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/12/1995 BRR : Created. *
|
|
*=============================================================================================*/
|
|
void MapClass::Overlap_Up(CELL cell, ObjectClass * object)
|
|
{
|
|
if (!object) return;
|
|
|
|
short const *list = object->Overlap_List();
|
|
while (*list != REFRESH_EOL) {
|
|
CELL newcell = cell + *list++;
|
|
if ((unsigned)newcell < MAP_CELL_TOTAL) {
|
|
(*this)[newcell].Overlap_Up(object);
|
|
(*this)[newcell].Redraw_Objects();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Overpass -- Performs any final cleanup to a freshly constructed map. *
|
|
* *
|
|
* This routine will clean up anything necessary with the presumption that the map has *
|
|
* been freshly created. Such things to clean up include various tiberium concentrations. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns the total credit value of the tiberium on the map. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/19/1994 JLB : Created. *
|
|
* 02/13/1995 JLB : Returns total tiberium worth. *
|
|
* 02/15/1995 JLB : Optimal scan. *
|
|
*=============================================================================================*/
|
|
long MapClass::Overpass(void)
|
|
{
|
|
long value = 0;
|
|
|
|
/*
|
|
** Smooth out Tiberium. Cells that are not surrounded by other tiberium
|
|
** will be reduced in density.
|
|
*/
|
|
for (int y = 0; y < MapCellHeight-1; y++) {
|
|
for (int x = 0; x < MapCellWidth; x++) {
|
|
value += (*this)[(MapCellY+y) * MAP_CELL_W + (MapCellX+x)].Tiberium_Adjust(true);
|
|
}
|
|
}
|
|
return(value);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Read_Binary -- reads the map's binary image file *
|
|
* *
|
|
* INPUT: *
|
|
* root root filename for scenario *
|
|
* crc ptr to CRC value to update *
|
|
* *
|
|
* OUTPUT: *
|
|
* 1 = success, 0 = failure *
|
|
* *
|
|
* WARNINGS: *
|
|
* none. *
|
|
* *
|
|
* HISTORY: *
|
|
* 11/14/1994 BR : Created. *
|
|
* 01/08/1995 JLB : Fixup any obsolete icons detected. *
|
|
*=============================================================================================*/
|
|
#ifdef DEMO
|
|
bool MapClass::Read_Binary(char const * root, unsigned long *)
|
|
#else
|
|
bool MapClass::Read_Binary(char const * root, unsigned long *crc)
|
|
#endif
|
|
{
|
|
CCFileClass file;
|
|
char fname[_MAX_FNAME+_MAX_EXT];
|
|
int i;
|
|
char *map;
|
|
void *rawmap;
|
|
void const * shape;
|
|
|
|
/*
|
|
** Filename = INI name with BIN extension.
|
|
*/
|
|
sprintf(fname,"%s.BIN",root);
|
|
|
|
/*
|
|
** Create object & open file.
|
|
*/
|
|
file.Set_Name(fname);
|
|
if (!file.Is_Available()) {
|
|
return(false);
|
|
}
|
|
file.Open(READ);
|
|
|
|
/*
|
|
** Loop through all cells.
|
|
*/
|
|
CellClass * cellptr = &Map[0];
|
|
for (i = 0; i < MAP_CELL_TOTAL; i++) {
|
|
struct {
|
|
TemplateType TType; // Template type.
|
|
unsigned char TIcon; // Template icon number.
|
|
} temp;
|
|
|
|
if (file.Read(&temp, sizeof(temp)) != sizeof(temp)) break;
|
|
if (temp.TType == (TemplateType)255) {
|
|
temp.TType = TEMPLATE_NONE;
|
|
}
|
|
|
|
/*
|
|
** Verify that the template type actually contains the template number specified. If
|
|
** an illegal icon was specified, then replace it with clear terrain.
|
|
*/
|
|
if (temp.TType != TEMPLATE_CLEAR1 && temp.TType != TEMPLATE_NONE) {
|
|
TemplateTypeClass const &ttype = TemplateTypeClass::As_Reference(temp.TType);
|
|
shape = ttype.Get_Image_Data();
|
|
if (shape) {
|
|
rawmap = Get_Icon_Set_Map(shape);
|
|
if (rawmap) {
|
|
map = (char*)rawmap;
|
|
if ((temp.TIcon >= (ttype.Width * ttype.Height)) || (map[temp.TIcon] == -1)) {
|
|
temp.TIcon = 0;
|
|
temp.TType = TEMPLATE_NONE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
cellptr->TType = temp.TType;
|
|
cellptr->TIcon = temp.TIcon;
|
|
cellptr->Recalc_Attributes();
|
|
|
|
#ifndef DEMO
|
|
Add_CRC(crc, (unsigned long)cellptr->TType);
|
|
Add_CRC(crc, (unsigned long)cellptr->TIcon);
|
|
#endif
|
|
|
|
cellptr++;
|
|
}
|
|
|
|
/*
|
|
** Close the file.
|
|
*/
|
|
file.Close();
|
|
|
|
return(i == MAP_CELL_TOTAL);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Read_BinaryRead_Binary_File -- reads the map's binary image file *
|
|
* *
|
|
* INPUT: *
|
|
* fname file path for scenario *
|
|
* crc ptr to CRC value to update *
|
|
* *
|
|
* OUTPUT: *
|
|
* 1 = success, 0 = failure *
|
|
* *
|
|
* WARNINGS: *
|
|
* none. *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/28/2019 JAS : Created. *
|
|
*=============================================================================================*/
|
|
bool MapClass::Read_Binary_File(char const * fname, unsigned long *crc)
|
|
{
|
|
CCFileClass file;
|
|
|
|
int i;
|
|
char *map;
|
|
void *rawmap;
|
|
void const * shape;
|
|
|
|
/*
|
|
** Create object & open file.
|
|
*/
|
|
file.Set_Name(fname);
|
|
if (!file.Is_Available()) {
|
|
return(false);
|
|
}
|
|
file.Open(READ);
|
|
|
|
/*
|
|
** Loop through all cells.
|
|
*/
|
|
CellClass * cellptr = &Map[0];
|
|
for (i = 0; i < MAP_CELL_TOTAL; i++) {
|
|
struct {
|
|
TemplateType TType; // Template type.
|
|
unsigned char TIcon; // Template icon number.
|
|
} temp;
|
|
|
|
if (file.Read(&temp, sizeof(temp)) != sizeof(temp)) break;
|
|
if (temp.TType == (TemplateType)255) {
|
|
temp.TType = TEMPLATE_NONE;
|
|
}
|
|
|
|
/*
|
|
** Verify that the template type actually contains the template number specified. If
|
|
** an illegal icon was specified, then replace it with clear terrain.
|
|
*/
|
|
if (temp.TType != TEMPLATE_CLEAR1 && temp.TType != TEMPLATE_NONE) {
|
|
shape = TemplateTypeClass::As_Reference(temp.TType).Get_Image_Data();
|
|
if (shape) {
|
|
rawmap = Get_Icon_Set_Map(shape);
|
|
if (rawmap) {
|
|
map = (char*)rawmap;
|
|
if (map[temp.TIcon] == -1) {
|
|
temp.TIcon = 0;
|
|
temp.TType = TEMPLATE_NONE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
cellptr->TType = temp.TType;
|
|
cellptr->TIcon = temp.TIcon;
|
|
cellptr->Recalc_Attributes();
|
|
|
|
#ifndef DEMO
|
|
Add_CRC(crc, (unsigned long)cellptr->TType);
|
|
Add_CRC(crc, (unsigned long)cellptr->TIcon);
|
|
#endif
|
|
|
|
cellptr++;
|
|
}
|
|
|
|
/*
|
|
** Close the file.
|
|
*/
|
|
file.Close();
|
|
|
|
return(i == MAP_CELL_TOTAL);
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Write_Binary -- writes the map's binary image file *
|
|
* *
|
|
* INPUT: *
|
|
* root root filename for scenario *
|
|
* *
|
|
* OUTPUT: *
|
|
* 1 = success, 0 = failure *
|
|
* *
|
|
* WARNINGS: *
|
|
* none. *
|
|
* *
|
|
* HISTORY: *
|
|
* 11/14/1994 BR : Created. *
|
|
*=============================================================================================*/
|
|
bool MapClass::Write_Binary(char const * root)
|
|
{
|
|
CCFileClass *file;
|
|
char fname[_MAX_FNAME+_MAX_EXT];
|
|
int i;
|
|
|
|
/*
|
|
** Filename = INI name with BIN extension.
|
|
*/
|
|
sprintf(fname,"%s.BIN",root);
|
|
|
|
/*
|
|
** Create object & open file.
|
|
*/
|
|
file = new CCFileClass(fname);
|
|
file->Open(WRITE);
|
|
|
|
/*
|
|
** Loop through all cells.
|
|
*/
|
|
for (i = 0; i < MAP_CELL_TOTAL; i++) {
|
|
/*
|
|
** Save TType.
|
|
*/
|
|
if (file->Write (&(Map[i].TType), sizeof(TemplateType)) != sizeof(TemplateType)) {
|
|
file->Close();
|
|
delete file;
|
|
return(false);
|
|
}
|
|
|
|
/*
|
|
** Save TIcon.
|
|
*/
|
|
if (file->Write (&(Map[i].TIcon), sizeof(unsigned char)) != sizeof(unsigned char)) {
|
|
file->Close();
|
|
delete file;
|
|
return(false);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Close the file.
|
|
*/
|
|
file->Close();
|
|
delete file;
|
|
|
|
return(true);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Logic -- Handles map related logic functions. *
|
|
* *
|
|
* Manages tiberium growth and spread. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/11/1995 JLB : Created. *
|
|
* 07/09/1995 JLB : Handles two directional scan. *
|
|
* 08/01/1995 JLB : Gives stronger weight to blossom trees. *
|
|
*=============================================================================================*/
|
|
void MapClass::Logic(void)
|
|
{
|
|
if (Debug_Force_Crash) { *((int *)0) = 1; }
|
|
|
|
/*
|
|
** Bail early if there is no allowed growth or spread of Tiberium.
|
|
*/
|
|
if (!Special.IsTGrowth && !Special.IsTSpread) return;
|
|
|
|
/*
|
|
** Scan another block of the map in order to accumulate the potential
|
|
** Tiberium cells that can grow or spread.
|
|
*/
|
|
int subcount = 30;
|
|
int index;
|
|
for (index = TiberiumScan; index < MAP_CELL_TOTAL; index++) {
|
|
CELL cell = index;
|
|
if (!IsForwardScan) cell = (MAP_CELL_TOTAL-1) - index;
|
|
CellClass *ptr = &(*this)[cell];
|
|
|
|
if (Special.IsTGrowth && ptr->Land_Type() == LAND_TIBERIUM && ptr->OverlayData < 11) {
|
|
if (TiberiumGrowthCount < sizeof(TiberiumGrowth)/sizeof(TiberiumGrowth[0])) {
|
|
TiberiumGrowth[TiberiumGrowthCount++] = cell;
|
|
} else {
|
|
TiberiumGrowth[Random_Pick(0, TiberiumGrowthCount-1)] = cell;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Heavy Tiberium growth can spread.
|
|
*/
|
|
TerrainClass * terrain = ptr->Cell_Terrain();
|
|
if (Special.IsTSpread &&
|
|
(ptr->Land_Type() == LAND_TIBERIUM && ptr->OverlayData > 6) ||
|
|
(terrain && terrain->Class->IsTiberiumSpawn)) {
|
|
|
|
int tries = 1;
|
|
if (terrain) tries = 3;
|
|
for (int i = 0; i < tries; i++) {
|
|
if (TiberiumSpreadCount < sizeof(TiberiumSpread)/sizeof(TiberiumSpread[0])) {
|
|
TiberiumSpread[TiberiumSpreadCount++] = cell;
|
|
} else {
|
|
TiberiumSpread[Random_Pick(0, TiberiumSpreadCount-1)] = cell;
|
|
}
|
|
}
|
|
}
|
|
subcount--;
|
|
if (!subcount) break;
|
|
}
|
|
TiberiumScan = index;
|
|
|
|
if (TiberiumScan >= MAP_CELL_TOTAL) {
|
|
int tries = 1;
|
|
if (Special.IsTFast || GameToPlay != GAME_NORMAL) tries = 2;
|
|
|
|
/*
|
|
** Use the Tiberium setting as a multiplier on growth rate. ST - 7/1/2020 3:05PM
|
|
*/
|
|
if (GameToPlay == GAME_GLYPHX_MULTIPLAYER) {
|
|
if (MPlayerTiberium > 1) {
|
|
tries += (MPlayerTiberium - 1) << 1;
|
|
}
|
|
}
|
|
TiberiumScan = 0;
|
|
IsForwardScan = (IsForwardScan == false);
|
|
|
|
/*
|
|
** Growth logic.
|
|
*/
|
|
if (TiberiumGrowthCount) {
|
|
for (int i = 0; i < tries; i++) {
|
|
int pick = Random_Pick(0, TiberiumGrowthCount-1);
|
|
CELL cell = TiberiumGrowth[pick];
|
|
CellClass * newcell = &(*this)[cell];
|
|
if (newcell->Land_Type() == LAND_TIBERIUM && newcell->OverlayData < 12-1) {
|
|
newcell->OverlayData++;
|
|
}
|
|
TiberiumGrowth[pick] = TiberiumGrowth[TiberiumGrowthCount - 1];
|
|
TiberiumGrowthCount--;
|
|
if (TiberiumGrowthCount <= 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
TiberiumGrowthCount = 0;
|
|
|
|
/*
|
|
** Spread logic.
|
|
*/
|
|
if (TiberiumSpreadCount) {
|
|
for (int i = 0; i < tries; i++) {
|
|
int pick = Random_Pick(0, TiberiumSpreadCount-1);
|
|
CELL cell = TiberiumSpread[pick];
|
|
|
|
/*
|
|
** Find a pseudo-random adjacent cell that doesn't contain any tiberium.
|
|
*/
|
|
if (Map.In_Radar(cell)) {
|
|
FacingType offset = Random_Pick(FACING_N, FACING_NW);
|
|
for (FacingType index = FACING_N; index < FACING_COUNT; index++) {
|
|
CellClass *newcell = (*this)[cell].Adjacent_Cell(index+offset);
|
|
|
|
if (newcell && newcell->Cell_Object() == NULL && newcell->Land_Type() == LAND_CLEAR && newcell->Overlay == OVERLAY_NONE) {
|
|
bool found = false;
|
|
|
|
switch (newcell->TType) {
|
|
case TEMPLATE_BRIDGE1:
|
|
case TEMPLATE_BRIDGE2:
|
|
case TEMPLATE_BRIDGE3:
|
|
case TEMPLATE_BRIDGE4:
|
|
break;
|
|
|
|
default:
|
|
found = true;
|
|
new OverlayClass(Random_Pick(OVERLAY_TIBERIUM1, OVERLAY_TIBERIUM12), newcell->Cell_Number());
|
|
newcell->OverlayData = 1;
|
|
break;
|
|
|
|
}
|
|
if (found) break;
|
|
}
|
|
}
|
|
}
|
|
TiberiumSpread[pick] = TiberiumSpread[TiberiumSpreadCount - 1];
|
|
TiberiumSpreadCount--;
|
|
if (TiberiumSpreadCount <= 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
TiberiumSpreadCount = 0;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Cell_Region -- Determines the region from a specified cell number. *
|
|
* *
|
|
* Use this routine to determine what region a particular cell lies in. *
|
|
* *
|
|
* INPUT: cell -- The cell number to examine. *
|
|
* *
|
|
* OUTPUT: Returns with the region that the specified cell occupies. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 03/15/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
int MapClass::Cell_Region(CELL cell)
|
|
{
|
|
return((Cell_X(cell) / REGION_WIDTH) + 1) + (((Cell_Y(cell) / REGION_HEIGHT) + 1) * MAP_REGION_WIDTH);
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
* MapClass::Cell_Threat -- Gets a houses threat value for a cell *
|
|
* *
|
|
* INPUT: CELL cell - the cell number to check *
|
|
* HouseType house - the house to check *
|
|
* *
|
|
* OUTPUT: *
|
|
* *
|
|
* WARNINGS: *
|
|
* *
|
|
* HISTORY: *
|
|
* 04/25/1995 PWG : Created. *
|
|
*=========================================================================*/
|
|
int MapClass::Cell_Threat(CELL cell, HousesType house)
|
|
{
|
|
int threat = HouseClass::As_Pointer(house)->Regions[Map.Cell_Region(Map[cell].Cell_Number())].Threat_Value();
|
|
//using function for IsVisible so we have different results for different players - JAS 2019/09/30
|
|
if (!threat && Map[cell].Is_Visible(house)) {
|
|
threat = 1;
|
|
}
|
|
return(threat);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Place_Random_Crate -- Places a crate at random location on map. *
|
|
* *
|
|
* This routine will place a crate at a random location on the map. This routine will only *
|
|
* make a limited number of attempts to place and if unsuccessful, it will not place any. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Was a crate successfully placed? *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/08/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
bool MapClass::Place_Random_Crate(void)
|
|
{
|
|
int old = ScenarioInit;
|
|
ScenarioInit = 0;
|
|
for (int index = 0; index < 100; index++) {
|
|
int x = Random_Pick(0, MapCellWidth-1);
|
|
int y = Random_Pick(0, MapCellHeight-1);
|
|
CELL cell = XY_Cell(MapCellX+x, MapCellY+y);
|
|
|
|
CellClass * ptr = &(*this)[cell];
|
|
if (ptr->Is_Generally_Clear() && ptr->Overlay == OVERLAY_NONE) {
|
|
ptr->Overlay = OVERLAY_WOOD_CRATE;
|
|
ptr->OverlayData = 0;
|
|
ptr->Redraw_Objects();
|
|
ScenarioInit = old;
|
|
return(true);
|
|
}
|
|
}
|
|
ScenarioInit = old;
|
|
return(false);
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
* MapClass::Validate -- validates every cell on the map *
|
|
* *
|
|
* This is a debugging routine, designed to detect memory trashers that *
|
|
* alter the map. This routine is slow, but thorough. *
|
|
* *
|
|
* INPUT: *
|
|
* none. *
|
|
* *
|
|
* OUTPUT: *
|
|
* true = map is OK, false = an error was found *
|
|
* *
|
|
* WARNINGS: *
|
|
* none. *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/08/1995 BRR : Created. *
|
|
*=========================================================================*/
|
|
int MapClass::Validate(void)
|
|
{
|
|
CELL cell;
|
|
TemplateType ttype;
|
|
unsigned char ticon;
|
|
//TemplateTypeClass const *tclass;
|
|
//unsigned char map[13*8];
|
|
OverlayType overlay;
|
|
SmudgeType smudge;
|
|
ObjectClass *obj;
|
|
LandType land;
|
|
int i;
|
|
|
|
BlubCell = &((*this)[797]);
|
|
|
|
if (BlubCell->Overlapper[1]) {
|
|
obj = BlubCell->Overlapper[1];
|
|
if (obj) {
|
|
if (obj->IsInLimbo)
|
|
obj = obj;
|
|
}
|
|
}
|
|
|
|
/*------------------------------------------------------------------------
|
|
Check every cell on the map, even those that aren't displayed,
|
|
in the hopes of detecting a memory trasher.
|
|
------------------------------------------------------------------------*/
|
|
for (cell = 0; cell < MAP_CELL_TOTAL; cell++) {
|
|
/*.....................................................................
|
|
Validate Template & Icon data
|
|
.....................................................................*/
|
|
ttype = (*this)[cell].TType;
|
|
ticon = (*this)[cell].TIcon;
|
|
if (ttype >= TEMPLATE_COUNT && ttype != TEMPLATE_NONE)
|
|
return(false);
|
|
|
|
/*.....................................................................
|
|
To validate the icon value, we have to get a copy of the template's
|
|
"icon map"; this map will have 0xff's in spots where there is no
|
|
icon. If the icon value is out of range or points to an invalide spot,
|
|
return an error.
|
|
.....................................................................*/
|
|
#if (0)
|
|
if (ttype != TEMPLATE_NONE) {
|
|
tclass = &TemplateTypeClass::As_Reference(ttype);
|
|
ticon = (*this)[cell].TIcon;
|
|
Mem_Copy(Get_Icon_Set_Map(tclass->Get_Image_Data()), map,
|
|
tclass->Width * tclass->Height);
|
|
if (ticon < 0 ||
|
|
ticon >= (tclass->Width * tclass->Height) ||
|
|
map[ticon]==0xff)
|
|
return (false);
|
|
}
|
|
#endif
|
|
/*.....................................................................
|
|
Validate Overlay
|
|
.....................................................................*/
|
|
overlay = (*this)[cell].Overlay;
|
|
if (overlay < OVERLAY_NONE || overlay >= OVERLAY_COUNT)
|
|
return(false);
|
|
|
|
/*.....................................................................
|
|
Validate Smudge
|
|
.....................................................................*/
|
|
smudge = (*this)[cell].Smudge;
|
|
if (smudge < SMUDGE_NONE || smudge >= SMUDGE_COUNT)
|
|
return(false);
|
|
|
|
/*.....................................................................
|
|
Validate LandType
|
|
.....................................................................*/
|
|
land = (*this)[cell].Land_Type();
|
|
if (land < LAND_CLEAR || land >= LAND_COUNT)
|
|
return(false);
|
|
|
|
/*.....................................................................
|
|
Validate Occupier
|
|
.....................................................................*/
|
|
obj = (*this)[cell].Cell_Occupier();
|
|
if (obj) {
|
|
|
|
volatile TARGET target = obj->As_Target(); // This will do some internal verification
|
|
|
|
if (!obj->IsActive) {
|
|
return false;
|
|
}
|
|
|
|
if (obj->IsInLimbo) {
|
|
return false;
|
|
}
|
|
|
|
if (((unsigned int)Coord_Cell(obj->Coord) > 4095)) {
|
|
return (false);
|
|
}
|
|
}
|
|
|
|
/*.....................................................................
|
|
Validate Overlappers
|
|
.....................................................................*/
|
|
for (i = 0; i < 3; i++) {
|
|
obj = (*this)[cell].Overlapper[i];
|
|
if (obj) {
|
|
|
|
volatile TARGET target = obj->As_Target(); // This will do some internal verification
|
|
|
|
if (!obj->IsActive) {
|
|
return false;
|
|
}
|
|
|
|
if (obj->IsInLimbo) {
|
|
return false;
|
|
}
|
|
|
|
if (((unsigned int)Coord_Cell(obj->Coord) > 4095)) {
|
|
return (false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (true);
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Clean -- Clean up dangling pointers caused by bugs in the originl code. *
|
|
* *
|
|
* Ideally, we'd fix the underlying cause of the overlappers not being cleared *
|
|
* but we can afford the CPU time now *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 4/14/2020 11:48AM ST : Created. *
|
|
*=============================================================================================*/
|
|
void MapClass::Clean(void)
|
|
{
|
|
CELL cell;
|
|
ObjectClass *obj;
|
|
int i;
|
|
#ifndef NDEBUG
|
|
char debug_message[256];
|
|
#endif
|
|
bool active_fail = false;
|
|
bool limbo_fail = false;
|
|
const char *type_text = NULL;
|
|
const char *ini_name = NULL;
|
|
AbstractClass abstract_object;
|
|
unsigned long abstract_vtable = *(unsigned long*)&abstract_object;
|
|
|
|
/*------------------------------------------------------------------------
|
|
Check every cell on the map, even those that aren't displayed.
|
|
------------------------------------------------------------------------*/
|
|
for (cell = 0; cell < MAP_CELL_TOTAL; cell++) {
|
|
|
|
/*.....................................................................
|
|
Validate Occupier
|
|
.....................................................................*/
|
|
(*this)[cell].Cell_Occupier();
|
|
|
|
/*.....................................................................
|
|
Validate Overlappers
|
|
.....................................................................*/
|
|
for (i = 0; i < 3; i++) {
|
|
obj = (*this)[cell].Overlapper[i];
|
|
if (obj) {
|
|
|
|
if (!obj->IsActive) {
|
|
(*this)[cell].Overlapper[i] = NULL;
|
|
active_fail = true;
|
|
}
|
|
|
|
if (!active_fail && obj->IsInLimbo) {
|
|
(*this)[cell].Overlapper[i] = NULL;
|
|
limbo_fail = true;
|
|
}
|
|
|
|
if (active_fail || limbo_fail) {
|
|
#ifndef NDEBUG
|
|
/*
|
|
** This object is likely deleted.
|
|
*/
|
|
if (abstract_vtable == *(unsigned long*)obj) {
|
|
type_text = "Abstract";
|
|
ini_name = "UNKNOWN";
|
|
} else {
|
|
|
|
RTTIType type = obj->What_Am_I();
|
|
|
|
switch (type) {
|
|
default:
|
|
type_text = "Unknown";
|
|
break;
|
|
|
|
case RTTI_INFANTRY:
|
|
type_text = "Infantry";
|
|
break;
|
|
|
|
case RTTI_UNIT:
|
|
type_text = "Unit";
|
|
break;
|
|
|
|
case RTTI_AIRCRAFT:
|
|
type_text = "Aircraft";
|
|
break;
|
|
|
|
case RTTI_BUILDING:
|
|
type_text = "Building";
|
|
break;
|
|
|
|
case RTTI_BULLET:
|
|
type_text = "Bullet";
|
|
break;
|
|
|
|
case RTTI_ANIM:
|
|
type_text = "Anim";
|
|
break;
|
|
|
|
case RTTI_SMUDGE:
|
|
type_text = "Smudge";
|
|
break;
|
|
|
|
case RTTI_TERRAIN:
|
|
type_text = "Terrain";
|
|
break;
|
|
}
|
|
|
|
ini_name = obj->Class_Of().IniName;
|
|
}
|
|
|
|
sprintf_s(debug_message, sizeof(debug_message) - 1, "Cleaned %s overlapper in cell %08X. Type=%s, IniName=%s", active_fail ? "inactive" : "limbo", cell, type_text, ini_name);
|
|
GlyphX_Debug_Print(debug_message);
|
|
#endif //NDEBUG
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Close_Object -- Finds a clickable close object to the specified coordinate. *
|
|
* *
|
|
* This routine is used by the mouse input processing code to find a clickable object *
|
|
* close to coordinate specified. This is for targeting as well as selection determination. *
|
|
* *
|
|
* INPUT: coord -- The coordinate to scan for close object from. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to an object that is nearby the specified coordinate. *
|
|
* *
|
|
* WARNINGS: There could be a cloaked object at the location, but it won't be considered *
|
|
* if it is not owned by the player. *
|
|
* *
|
|
* HISTORY: *
|
|
* 08/20/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
ObjectClass * MapClass::Close_Object(COORDINATE coord) const
|
|
{
|
|
ObjectClass * object = 0;
|
|
int distance = 0;
|
|
CELL cell = Coord_Cell(coord);
|
|
|
|
/*
|
|
** Scan through current and adjacent cells, looking for the
|
|
** closest object (within reason) to the specified coordinate.
|
|
*/
|
|
static int _offsets[] = {0, -1, 1, -MAP_CELL_W, MAP_CELL_W, MAP_CELL_W-1, MAP_CELL_W+1, -(MAP_CELL_W-1), -(MAP_CELL_W+1)};
|
|
for (int index = 0; index < (sizeof(_offsets) / sizeof(_offsets[0])); index++) {
|
|
|
|
/*
|
|
** Examine the cell for close object. Make sure that the cell actually is a
|
|
** legal one.
|
|
*/
|
|
CELL newcell = cell + _offsets[index];
|
|
if (In_Radar(newcell)) {
|
|
|
|
/*
|
|
** Search through all objects that occupy this cell and then
|
|
** find the closest object. Check against any previously found object
|
|
** to ensure that it is actually closer.
|
|
*/
|
|
ObjectClass * o = (*this)[newcell].Cell_Occupier();
|
|
while (o) {
|
|
|
|
/*
|
|
** Special case check to ignore cloaked object if not allied with the player.
|
|
*/
|
|
// Changed for multiplayer. ST - 3/13/2019 5:38PM
|
|
if (!o->Is_Techno() || !((TechnoClass *)o)->Is_Cloaked(PlayerPtr)) {
|
|
//if (!o->Is_Techno() || ((TechnoClass *)o)->IsOwnedByPlayer || ((TechnoClass *)o)->Cloak != CLOAKED) {
|
|
int d=-1;
|
|
if (o->What_Am_I() == RTTI_BUILDING) {
|
|
d = Distance(coord, Cell_Coord(newcell));
|
|
if (d > 0x00C0) d = -1;
|
|
} else {
|
|
d = Distance(coord, o->Center_Coord());
|
|
}
|
|
if (d >= 0 && (!object || d < distance)) {
|
|
distance = d;
|
|
object = o;
|
|
}
|
|
}
|
|
o = o->Next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Handle aircraft selection separately, since they aren't tracked in cells while flying
|
|
*/
|
|
for (int index = 0; index < Aircraft.Count(); index++) {
|
|
AircraftClass * aircraft = Aircraft.Ptr(index);
|
|
|
|
if (aircraft->In_Which_Layer() != LAYER_GROUND) {
|
|
if (!aircraft->Is_Cloaked(PlayerPtr)) {
|
|
int d = Distance(coord, Coord_Add(aircraft->Center_Coord(), XY_Coord(0, -Pixel_To_Lepton(aircraft->Altitude))));
|
|
if (d >= 0 && (!object || d < distance)) {
|
|
distance = d;
|
|
object = aircraft;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Only return the object if it is within 1/4 cell distance from the specified
|
|
** coordinate.
|
|
*/
|
|
if (object && distance > 0xC0) {
|
|
object = 0;
|
|
}
|
|
return(object);
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef USE_RA_AI
|
|
|
|
/*
|
|
** Nearby_Location pulled in from RA for AI. ST - 7/24/2019 5:54PM
|
|
*/
|
|
#ifndef ARRAY_SIZE
|
|
#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
|
|
#endif
|
|
|
|
/***********************************************************************************************
|
|
* MapClass::Nearby_Location -- Finds a generally clear location near a specified cell. *
|
|
* *
|
|
* This routine is used to find a location that probably will be ok to move to that is *
|
|
* located as close as possible to the specified cell. The computer uses this when it has *
|
|
* determined the ideal location for an object, but then needs to give a valid movement *
|
|
* destination to a unit. *
|
|
* *
|
|
* INPUT: cell -- The cell that scanning should radiate out from. *
|
|
* *
|
|
* zone -- The zone that must be matched to find a legal location (value of -1 means *
|
|
* any zone will do). *
|
|
* *
|
|
* *
|
|
* check -- The type of zone to check against. Only valid if a zone value is given. *
|
|
* *
|
|
* OUTPUT: Returns with the cell that is generally clear (legal to move to) that is close *
|
|
* to the specified cell. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/05/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
CELL MapClass::Nearby_Location(CELL cell) const //, SpeedType speed, int zone, MZoneType check) const
|
|
{
|
|
CELL topten[10];
|
|
int count = 0;
|
|
int xx = Cell_X(cell);
|
|
int yy = Cell_Y(cell);
|
|
|
|
/*
|
|
** Determine the limits of the scanning in the four directions so that
|
|
** it won't scan past the edge of the world.
|
|
*/
|
|
int left = MapCellX;
|
|
int right = MapCellX + MapCellWidth - 1;
|
|
int top = MapCellY;
|
|
int bottom = MapCellY + MapCellHeight - 1;
|
|
|
|
/*
|
|
** Radiate outward from the specified location, looking for the closest
|
|
** location that is generally clear.
|
|
*/
|
|
for (int radius = 0; radius < MAP_CELL_W; radius++) {
|
|
CELL newcell;
|
|
CellClass const * cellptr;
|
|
|
|
/*
|
|
** Scan the top and bottom rows of the "box".
|
|
*/
|
|
for (int x = xx-radius; x <= xx+radius; x++) {
|
|
if (x >= left && x <= right) {
|
|
int y = yy-radius;
|
|
if (y >= top) {
|
|
newcell = XY_Cell(x, y);
|
|
cellptr = &Map[newcell];
|
|
if (Map.In_Radar(newcell) && cellptr->Is_Clear_To_Move(false, false)) {
|
|
topten[count++] = newcell;
|
|
}
|
|
}
|
|
if (count == ARRAY_SIZE(topten)) break;
|
|
|
|
y = yy+radius;
|
|
if (y <= bottom) {
|
|
newcell = XY_Cell(x, y);
|
|
cellptr = &Map[newcell];
|
|
if (Map.In_Radar(newcell) && cellptr->Is_Clear_To_Move(false, false)) {
|
|
topten[count++] = newcell;
|
|
}
|
|
}
|
|
if (count == ARRAY_SIZE(topten)) break;
|
|
}
|
|
}
|
|
|
|
if (count == ARRAY_SIZE(topten)) break;
|
|
|
|
/*
|
|
** Scan the left and right columns of the "box".
|
|
*/
|
|
for (int y = yy-radius; y <= yy+radius; y++) {
|
|
if (y >= top && y <= bottom) {
|
|
int x = xx-radius;
|
|
if (x >= left) {
|
|
newcell = XY_Cell(x, y);
|
|
cellptr = &Map[newcell];
|
|
if (Map.In_Radar(newcell) && cellptr->Is_Clear_To_Move(false, false)) {
|
|
topten[count++] = newcell;
|
|
}
|
|
}
|
|
if (count == ARRAY_SIZE(topten)) break;
|
|
|
|
x = xx+radius;
|
|
if (x <= right) {
|
|
newcell = XY_Cell(x, y);
|
|
cellptr = &Map[newcell];
|
|
if (Map.In_Radar(newcell) && cellptr->Is_Clear_To_Move(false, false)) {
|
|
topten[count++] = newcell;
|
|
}
|
|
}
|
|
if (count == ARRAY_SIZE(topten)) break;
|
|
}
|
|
}
|
|
|
|
if (count > 0) break;
|
|
}
|
|
|
|
if (count > 0) {
|
|
return(topten[Frame % count]);
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
#endif // USE_RA_AI
|