CnC_Remastered_Collection/TIBERIANDAWN/CELL.H

//
// 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.h_v   2.20   16 Oct 1995 16:45:36   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.H                                                       *
 *                                                                                             *
 *                   Programmer : Joe L. Bostic                                                *
 *                                                                                             *
 *                   Start Date : April 29, 1994                                               *
 *                                                                                             *
 *                  Last Update : April 29, 1994   [JLB]                                       *
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#ifndef CELL_H
#define CELL_H

#include	"building.h"
#include	"unit.h"
#include	"template.h"


/****************************************************************************
**	Each cell on the map is controlled by the following structure.
*/
class CellClass
{
	public:
		/*
		**	Does this cell need to be updated on the radar map?  If something changes in the cell
		**	that might change the radar map imagery, then this flag will be set. It gets cleared
		**	when the cell graphic is updated to the radar map.
		*/
		unsigned IsPlot:1;

		/*
		**	Does this cell contain the special placement cursor graphic?  This graphic is
		**	present when selecting a site for building placement.
		*/
		unsigned IsCursorHere:1;

		/*
		**	Is this cell mapped by the player?  A mapped cell is visible. An unmapped cell
		**	is covered in a dark shroud. In addition to visibility, mapped cells are the only
		**	legal place for transports to land.
		*/
		unsigned IsMapped:1;

		/*
		**	If any part of this cell is visible (even just peeking out from under the shadow),
		**	this this flag will be true. Mapped cells always have this flag set, but unmapped
		**	cells might not -- it depends on where the shadow edge is located.
		*/
		unsigned IsVisible:1;

		/*
		** Every cell can be assigned a trigger. The same trigger can be assigned to
		** multiple cells. This bitflag indicates whether this cell has a trigger.
		** The trigger pointers for all cells must be stored elsewhere.
		*/
		unsigned IsTrigger:1;

		/*
		** Every cell can be assigned a waypoint.  A waypoint can only be assigned
		** to one cell, and vice-versa.  This bit simply indicates whether this
		** cell is assigned a waypoint or not.
		*/
		unsigned IsWaypoint:1;

		/*
		** Is this cell currently under the radar map cursor?  If so then it
		**   needs to be updated whenever the map is updated.
		*/
		unsigned IsRadarCursor:1;

		/*
		**	If this cell contains a house flag, then this will be true. The actual house
		**	flag it contains is specified by the Owner field.
		*/
		unsigned IsFlagged:1;

		/*
		**	This contains the icon number and set to use for the base
		**	of the terrain. All rendering on an icon occurs AFTER the icon
		**	specified by this element is rendered. It is the lowest of the low.
		*/
		TemplateType TType;
		unsigned char TIcon;

		/*
		**	The second layer of 'terrain' icons is represented by a simple
		**	type number and a value byte. This is sufficient for handling
		**	concrete and walls.
		*/
		OverlayType Overlay;
		unsigned char OverlayData;

		/*
		**	This is used to specify any special 'stain' overlay icon. This
		**	typically includes infantry bodies or other temporary marks.
		*/
		SmudgeType Smudge;
		unsigned char SmudgeData;

		/*
		**	Smudges and walls need to record ownership values. For walls, this
		**	allows adjacent building placement logic to work. For smudges, it
		**	allows building over smudges that are no longer attached to buildings
		**	in addition to fixing the adjacent placement logic.
		*/
		HousesType Owner;

		/*
		** This flag tells you what type of infantry currently occupy the
		** cell or are moving into it.
		*/
		HousesType InfType;

		/*
		**	These point to the object(s) that are located in this cell or overlap
		**	this cell.
		*/
		ObjectClass *OccupierPtr;
		ObjectClass *Overlapper[3];


		/*
		**	Per-player view of whether a cell is mapped. One bit for each house type. ST - 3/5/2019 3:00PM
		*/
		unsigned int IsMappedByPlayerMask;

		/*
		**	Per-player view of whether a cell is visible. One bit for each house type. ST - 3/5/2019 3:00PM
		*/
		unsigned int IsVisibleByPlayerMask;


		/*
		**	This array of bit flags is used to indicate which sub positions
		**	within the cell are either occupied or are soon going to be
		**	occupied. For vehicles, the cells that the vehicle is passing over
		**	will be flagged with the vehicle bit. For infantry, the the sub
		**	position the infantry is stopped at or headed toward will be marked.
		**	The sub positions it passes over will NOT be marked.
		*/
		union {
			struct {
				unsigned Center:1;
				unsigned NW:1;
				unsigned NE:1;
				unsigned SW:1;
				unsigned SE:1;
				unsigned Vehicle:1;		// Reserved for vehicle occupation.
				unsigned Monolith:1;		// Some immovable blockage is in cell.
				unsigned Building:1;		// A building of some time (usually blocks movement).
			} Occupy;
			unsigned char Composite;
		} Flag;

		//----------------------------------------------------------------
		CellClass(void);
		~CellClass(void) {};

		int operator == (CellClass const & cell) const {return &cell == this;};

		/*
		**	Query functions.
		*/
		ObjectClass *  Cell_Occupier(void) const;
		static int  Spot_Index(COORDINATE coord);
		bool  Is_Spot_Free(int spot_index) const {return (! (Flag.Composite & (1 << spot_index)) ); }
		COORDINATE  Closest_Free_Spot(COORDINATE coord, bool any=false) const;
		COORDINATE  Free_Spot(void) const {return Closest_Free_Spot(Cell_Coord());};
		bool  Is_Generally_Clear(bool ignore_cloaked = false) const;
		TARGET  As_Target(void) const {return ::As_Target(Cell_Number());};
		BuildingClass *  Cell_Building(void) const;
		CellClass const *  Adjacent_Cell(FacingType face) const;
		CellClass *  Adjacent_Cell(FacingType face) {return (CellClass *)((*((CellClass const *)this)).Adjacent_Cell(face));};
		COORDINATE  Cell_Coord(void) const;
		int  Cell_Color(bool override=false) const;
		CELL  Cell_Number(void) const;
		LandType  Land_Type(void) const {return((OverrideLand != LAND_COUNT) ? OverrideLand : Land);};
		ObjectClass *  Cell_Find_Object(RTTIType rtti) const;
		ObjectClass *  Cell_Object(int x=0, int y=0) const;
		TechnoClass *  Cell_Techno(int x=0, int y=0) const;
		TerrainClass *  Cell_Terrain(void) const;
		UnitClass *  Cell_Unit(void) const;
		InfantryClass *  Cell_Infantry(void) const;
		TriggerClass *  Get_Trigger(void) const;
		int  Clear_Icon(void) const;
		bool  Goodie_Check(FootClass * object, bool check_steel = false);
		ObjectClass *  Fetch_Occupier(void) const;
		bool Get_Template_Info(char *template_name, int &icon, void *&image_data);

		/*
		**	Object placement and removal flag operations.
		*/
		void  Occupy_Down(ObjectClass * object);
		void  Occupy_Up(ObjectClass * object);
		void  Overlap_Down(ObjectClass * object);
		void  Overlap_Up(ObjectClass * object);
		bool  Flag_Place(HousesType house);
		bool  Flag_Remove(void);
		void  Flag_Update(void);
		void  Flag_Create(void);
		void  Flag_Destroy(void);

		/*
		**	File I/O.
		*/
		bool  Should_Save(void) const;
		bool  Save(FileClass & file);
		bool  Load(FileClass & file);
		void  Code_Pointers(void);
		void  Decode_Pointers(void);

		/*
		**	Display and rendering controls.
		*/
		void  Draw_It(int x, int y, int draw_flags = 0) const;
		void  Redraw_Objects(bool forced=false);
		void  Shimmer(void);

		/*
		**	Maintenance calculation support.
		*/
		long  Tiberium_Adjust(bool pregame=false);
		void  Wall_Update(void);
		void  Concrete_Calc(void);
		void  Recalc_Attributes(void);
		int   Reduce_Tiberium(int levels);
		int   Reduce_Wall(int damage);
		void  Incoming(COORDINATE threat=0, bool forced = false, bool nokidding = false);
		void  Adjust_Threat(HousesType house, int threat_value);

		int operator != (CellClass const &) const {return 0;};

		int Validate(void) const;


		/*
		**	Additional per-player functionality is needed for multiplayer. ST - 3/5/2019 3:03PM 
		*/
		void Set_Mapped(HousesType house, bool set = true);
		void Set_Mapped(HouseClass *player, bool set = true);
		bool Is_Mapped(HousesType house) const;
		bool Is_Mapped(HouseClass *player) const;
		void Set_Visible(HousesType house, bool set = true);
		void Set_Visible(HouseClass *player, bool set = true);
		bool Is_Visible(HousesType house) const;
		bool Is_Visible(HouseClass *player) const;

		/*
		**	Override land type to fix passability issues on some maps
		*/
		void Override_Land_Type(LandType type);

#ifdef USE_RA_AI
		/*
		** Imported from RA for AI. ST - 7/24/2019 5:36PM
		*/
		bool Is_Clear_To_Move(bool ignoreinfantry, bool ignorevehicles) const;
#endif

	private:
		CellClass (CellClass const &) {};

		LandType Land;		// The land type of this cell.

		LandType OverrideLand;	// The overriden land type of this cell.

		/*
		**	Points to the flag animation on this cell in CTF games.
		*/
		AnimClass* CTFFlag;

		/*
		** Some additional padding in case we need to add data to the class and maintain backwards compatibility for save/load
		*/
		unsigned char SaveLoadPadding[28];
};

#endif