Remastered-Collection/REDALERT/SDATA.CPP

//
// Copyright 2020 Electronic Arts Inc.
//
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
// software: you can redistribute it and/or modify it under the terms of 
// the GNU General Public License as published by the Free Software Foundation, 
// either version 3 of the License, or (at your option) any later version.

// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
// in the hope that it will be useful, but with permitted additional restrictions 
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
// distributed with this program. You should have received a copy of the 
// GNU General Public License along with permitted additional restrictions 
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection

/* $Header: /CounterStrike/SDATA.CPP 1     3/03/97 10:25a 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 : SDATA.CPP                                                    *
 *                                                                                             *
 *                   Programmer : Joe L. Bostic                                                *
 *                                                                                             *
 *                   Start Date : August 9, 1994                                               *
 *                                                                                             *
 *                  Last Update : July 9, 1996 [JLB]                                           *
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 *   SmudgeTypeClass::As_Reference -- Fetches a reference to the smudge type specified.        *
 *   SmudgeTypeClass::Create_And_Place -- Creates and places on map, a smudge object.          *
 *   SmudgeTypeClass::Create_One_Of -- Creates a smudge object of this type.                   *
 *   SmudgeTypeClass::Display -- Draws a generic version of this smudge type.                  *
 *   SmudgeTypeClass::Draw_It -- Renders the smudge image at the coordinate specified.         *
 *   SmudgeTypeClass::From_Name -- Converts an ASCII name into a smudge type.                  *
 *   SmudgeTypeClass::Init -- Performs theater specific initializations.                       *
 *   SmudgeTypeClass::Init_Heap -- Initialize the smudge type class object heap.               *
 *   SmudgeTypeClass::One_Time -- Performs one-time initialization                             *
 *   SmudgeTypeClass::Prep_For_Add -- Prepares the scenario editor for adding a smudge object. *
 *   SmudgeTypeClass::SmudgeTypeClass -- Constructor for smudge type objects.                  *
 *   SmudgeTypeClass::operator delete -- Returns a smudge type class object to the pool.       *
 *   SmudgeTypeClass::operator new -- Allocate a smudge type object from the memory pool.      *
 *   SmudgetypeClass::Occupy_List -- Determines occupation list for smudge object.             *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include	"function.h"
#include	"type.h"


static SmudgeTypeClass const Crater1 (
	SMUDGE_CRATER1,
	"CR1",
	TXT_CRATER,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	true							// Is this a crater smudge?
);
static SmudgeTypeClass const Crater2 (
	SMUDGE_CRATER2,
	"CR2",
	TXT_CRATER,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	true							// Is this a crater smudge?
);
static SmudgeTypeClass const Crater3 (
	SMUDGE_CRATER3,
	"CR3",
	TXT_CRATER,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	true							// Is this a crater smudge?
);
static SmudgeTypeClass const Crater4 (
	SMUDGE_CRATER4,
	"CR4",
	TXT_CRATER,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	true							// Is this a crater smudge?
);
static SmudgeTypeClass const Crater5 (
	SMUDGE_CRATER5,
	"CR5",
	TXT_CRATER,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	true							// Is this a crater smudge?
);
static SmudgeTypeClass const Crater6 (
	SMUDGE_CRATER6,
	"CR6",
	TXT_CRATER,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	true							// Is this a crater smudge?
);
static SmudgeTypeClass const Scorch1 (
	SMUDGE_SCORCH1,
	"SC1",
	TXT_SCORCH,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	false							// Is this a crater smudge?
);
static SmudgeTypeClass const Scorch2 (
	SMUDGE_SCORCH2,
	"SC2",
	TXT_SCORCH,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	false							// Is this a crater smudge?
);
static SmudgeTypeClass const Scorch3 (
	SMUDGE_SCORCH3,
	"SC3",
	TXT_SCORCH,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	false							// Is this a crater smudge?
);
static SmudgeTypeClass const Scorch4 (
	SMUDGE_SCORCH4,
	"SC4",
	TXT_SCORCH,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	false							// Is this a crater smudge?
);
static SmudgeTypeClass const Scorch5 (
	SMUDGE_SCORCH5,
	"SC5",
	TXT_SCORCH,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	false							// Is this a crater smudge?
);
static SmudgeTypeClass const Scorch6 (
	SMUDGE_SCORCH6,
	"SC6",
	TXT_SCORCH,
	1,1,							// Width and height of smudge (in icons).
	false,						// Is this a building bib?
	false							// Is this a crater smudge?
);

static SmudgeTypeClass const Bibx1 (
	SMUDGE_BIB1,
	"BIB1",
	TXT_BIB,
	4,2,							// Width and height of smudge (in icons).
	true,							// Is this a building bib?
	false							// Is this a crater smudge?
);
static SmudgeTypeClass const Bibx2 (
	SMUDGE_BIB2,
	"BIB2",
	TXT_BIB,
	3,2,							// Width and height of smudge (in icons).
	true,							// Is this a building bib?
	false							// Is this a crater smudge?
);
static SmudgeTypeClass const Bibx3 (
	SMUDGE_BIB3,
	"BIB3",
	TXT_BIB,
	2,2,							// Width and height of smudge (in icons).
	true,							// Is this a building bib?
	false							// Is this a crater smudge?
);


/***********************************************************************************************
 * SmudgeTypeClass::SmudgeTypeClass -- Constructor for smudge type objects.                    *
 *                                                                                             *
 *    This constructor is used to create the smudge type objects. These type objects contain   *
 *    static information about the various smudge types supported in the game.                 *
 *                                                                                             *
 * INPUT:   see below...                                                                       *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/12/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
SmudgeTypeClass::SmudgeTypeClass(
	SmudgeType smudge,
	char const * ininame,
	int fullname,
	int width,
	int height,
	bool isbib,
	bool iscrater) :
		ObjectTypeClass(
			RTTI_SMUDGETYPE,
			int(smudge),
			false,
			true,
			false,
			false,
			true,
			true,
			false,
			fullname,
			ininame),
	Type(smudge),
	Width(width),
	Height(height),
	IsCrater(iscrater),
	IsBib(isbib)
{
}


/***********************************************************************************************
 * SmudgeTypeClass::operator new -- Allocate a smudge type object from the memory pool.        *
 *                                                                                             *
 *    This will allocate a smudge type class object from the special memory pool for that      *
 *    purpose.                                                                                 *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with the newly allocated smudge type class object. If there is insufficient*
 *          memory in the pool to fulfill the request, then NULL is returned.                  *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/09/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void * SmudgeTypeClass::operator new(size_t)
{
	return(SmudgeTypes.Alloc());
}


/***********************************************************************************************
 * SmudgeTypeClass::operator delete -- Returns a smudge type class object to the pool.         *
 *                                                                                             *
 *    This will return the smudge type class object back to the memory pool from whence it     *
 *    was originally allocated.                                                                *
 *                                                                                             *
 * INPUT:   pointer  -- Pointer to the smudge type class object to return the pool.            *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/09/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void SmudgeTypeClass::operator delete(void * pointer)
{
	SmudgeTypes.Free((SmudgeTypeClass *)pointer);
}


/***********************************************************************************************
 * SmudgeTypeClass::Init_Heap -- Initialize the smudge type class object heap.                 *
 *                                                                                             *
 *    This will initialize the special heap for smudge type class objects, by pre-allocated    *
 *    all known smudge types.                                                                  *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   Call this routine only once and before the rules.ini file is processed.         *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/09/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
void SmudgeTypeClass::Init_Heap(void)
{
	/*
	**	These smudge type class objects must be allocated in the exact order that they
	**	are specified in the SmudgeType enumeration. This is necessary because the heap
	**	allocation block index serves double duty as the type number index.
	*/
	new SmudgeTypeClass(Crater1);			// SMUDGE_CRATER1
	new SmudgeTypeClass(Crater2);			// SMUDGE_CRATER2
	new SmudgeTypeClass(Crater3);			// SMUDGE_CRATER3
	new SmudgeTypeClass(Crater4);			// SMUDGE_CRATER4
	new SmudgeTypeClass(Crater5);			// SMUDGE_CRATER5
	new SmudgeTypeClass(Crater6);			// SMUDGE_CRATER6
	new SmudgeTypeClass(Scorch1);			// SMUDGE_SCORCH1
	new SmudgeTypeClass(Scorch2);			// SMUDGE_SCORCH2
	new SmudgeTypeClass(Scorch3);			// SMUDGE_SCORCH3
	new SmudgeTypeClass(Scorch4);			// SMUDGE_SCORCH4
	new SmudgeTypeClass(Scorch5);			// SMUDGE_SCORCH5
	new SmudgeTypeClass(Scorch6);			// SMUDGE_SCORCH6
	new SmudgeTypeClass(Bibx1);			// SMUDGE_BIB1
	new SmudgeTypeClass(Bibx2);			//	SMUDGE_BIB2
	new SmudgeTypeClass(Bibx3);			// SMUDGE_BIB3
}


/***********************************************************************************************
 * SmudgeTypeClass::From_Name -- Converts an ASCII name into a smudge type.                    *
 *                                                                                             *
 *    This converts an ASCII name into a smudge type number. This is typically necessary       *
 *    when processing scenario INI files and not used otherwise.                               *
 *                                                                                             *
 * INPUT:   name  -- Pointer to the name to convert.                                           *
 *                                                                                             *
 * OUTPUT:  Returns with the SmudgeType number that matches the name supplied. If no match     *
 *          was found, then SMUDGE_NONE is returned.                                           *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/12/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
SmudgeType SmudgeTypeClass::From_Name(char const * name)
{
	if (name != NULL) {
		for (SmudgeType index = SMUDGE_FIRST; index < SMUDGE_COUNT; index++) {
			if (stricmp(As_Reference(index).IniName, name) == 0) {
				return(index);
			}
		}
	}
	return(SMUDGE_NONE);
}


/***********************************************************************************************
 * SmudgetypeClass::Occupy_List -- Determines occupation list for smudge object.               *
 *                                                                                             *
 *    Smudges are always only one icon in dimension, so this routine always returns a cell     *
 *    occupation offset list of the center cell.                                               *
 *                                                                                             *
 * INPUT:   placement   -- Is this for placement legality checking only? The normal condition  *
 *                         is for marking occupation flags.                                    *
 *                                                                                             *
 * OUTPUT:  Returns occupation list specifying all the cells that the overlay occupies. This   *
 *          is just the center cell.                                                           *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/12/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
short const * SmudgeTypeClass::Occupy_List(bool) const
{
	static short _occupy[4*4];
	short * ptr = &_occupy[0];

	for (int x = 0; x < Width; x++) {
		for (int y = 0; y < Height; y++) {
			*ptr++ = x + (y*MAP_CELL_W);
		}
	}
	*ptr = REFRESH_EOL;
	return(_occupy);
}


/***********************************************************************************************
 * SmudgeTypeClass::Init -- Performs theater specific initializations.                         *
 *                                                                                             *
 *    Smudge object imagery varies between theaters. This routine will load the appropriate    *
 *    imagery for the theater specified.                                                       *
 *                                                                                             *
 * INPUT:   theater  -- The theater to prepare for.                                            *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/12/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
void SmudgeTypeClass::Init(TheaterType theater)
{
	if (theater != LastTheater) {
		for (SmudgeType index = SMUDGE_FIRST; index < SMUDGE_COUNT; index++) {
			SmudgeTypeClass const & smudge = As_Reference(index);
			char fullname[_MAX_FNAME+_MAX_EXT];	// Fully constructed smudge data set name.

			_makepath(fullname, NULL, NULL, smudge.IniName, Theaters[theater].Suffix);
			((void const *&)smudge.ImageData) = MFCD::Retrieve(fullname);
		}
	}
}


#ifdef SCENARIO_EDITOR
/***********************************************************************************************
 * SmudgeTypeClass::Display -- Draws a generic version of this smudge type.                    *
 *                                                                                             *
 *    The scenario object editor will call this routine to display a typical imagery of this   *
 *    smudge object for graphical identification purposes.                                     *
 *                                                                                             *
 * INPUT:   x,y   -- Coordinate to render the smudge at.                                       *
 *                                                                                             *
 *          window-- The window to base the coordinate rendering upon.                         *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/12/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
void SmudgeTypeClass::Display(int x, int y, WindowNumberType window, HousesType ) const
{
	void const * ptr = Get_Image_Data();

	x += WindowList[window][WINDOWX];
	y += WindowList[window][WINDOWY];

	IsTheaterShape = true;		// Smudges are theater specific
	if (ptr != NULL) {
		for (int w = 0; w < Width; w++) {
			for (int h = 0; h < Height; h++) {
				CC_Draw_Shape(ptr, w + (h*Width), x + w*ICON_PIXEL_W, y + h*ICON_PIXEL_H, WINDOW_TACTICAL, SHAPE_WIN_REL);
			}
		}
	}
	IsTheaterShape = false;
}


/***********************************************************************************************
 * SmudgeTypeClass::Prep_For_Add -- Prepares the scenario editor for adding a smudge object.   *
 *                                                                                             *
 *    This routine adds smudge objects to the list of objects that the scenario editor can     *
 *    place upon the ground. It is only called from the scenario editor.                       *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/12/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
void SmudgeTypeClass::Prep_For_Add(void)
{
	for (SmudgeType index = SMUDGE_FIRST; index < SMUDGE_COUNT; index++) {
		if (As_Reference(index).Get_Image_Data()) {
			Map.Add_To_List(&As_Reference(index));
		}
	}
}
#endif


/***********************************************************************************************
 * SmudgeTypeClass::Create_And_Place -- Creates and places on map, a smudge object.            *
 *                                                                                             *
 *    This routine will, in one motion, create a smudge object and place it upon the map.      *
 *    Since placing a smudge on the map will destroy the object, this routine will leave the   *
 *    smudge object count unchanged. Typically, this routine is used by the scenario editor    *
 *    for creating smudges and placing them on the map.                                        *
 *                                                                                             *
 * INPUT:   cell  -- The cell to place the smudge object.                                      *
 *                                                                                             *
 * OUTPUT:  bool; Was the placement successful?                                                *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/12/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
bool SmudgeTypeClass::Create_And_Place(CELL cell, HousesType ) const
{
	if (new SmudgeClass(Type, Cell_Coord(cell))) {
		return(true);
	}
	return(false);
}


/***********************************************************************************************
 * SmudgeTypeClass::Create_One_Of -- Creates a smudge object of this type.                     *
 *                                                                                             *
 *    This routine will create a smudge object of the appropriate type. Smudge objects are     *
 *    transitory in nature. They exist only from the point of creation until they are given    *
 *    a spot on the map to reside. At that time the map data is updated and the smudge         *
 *    object is destroyed.                                                                     *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  Returns with a pointer to a created smudge object. If none could be created, then  *
 *          NULL is returned.                                                                  *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/12/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
ObjectClass * SmudgeTypeClass::Create_One_Of(HouseClass *) const
{
	return(new SmudgeClass(Type, -1));
}


/***********************************************************************************************
 * SmudgeTypeClass::Draw_It -- Renders the smudge image at the coordinate specified.           *
 *                                                                                             *
 *    This routine will draw the smudge overlay image at the coordinate (upper left)           *
 *    specified. The underlying terrain icon is presumed to have already been rendered.        *
 *                                                                                             *
 * INPUT:   x,y   -- Coordinate of the upper left corner of icon to render the smudge object.  *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/12/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
void SmudgeTypeClass::Draw_It(int x, int y, int data) const
{
	void const * ptr = Get_Image_Data();
	if (ptr != NULL) {
		IsTheaterShape = true;		// Smudges are theater specific
		CC_Draw_Shape(ptr, data, x, y, WINDOW_TACTICAL, SHAPE_WIN_REL);
		IsTheaterShape = false;
	}
}


/***********************************************************************************************
 * SmudgeTypeClass::One_Time -- Performs one-time initialization                               *
 *                                                                                             *
 * INPUT:   none                                                                               *
 *                                                                                             *
 * OUTPUT:  none                                                                               *
 *                                                                                             *
 * WARNINGS:   none                                                                            *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   08/12/1994 JLB : Created.                                                                 *
 *=============================================================================================*/
void SmudgeTypeClass::One_Time(void)
{
}


/***********************************************************************************************
 * SmudgeTypeClass::As_Reference -- Fetches a reference to the smudge type specified.          *
 *                                                                                             *
 *    Use this routine to get a reference to the smudge type class object when given just      *
 *    the smudge type identifier.                                                              *
 *                                                                                             *
 * INPUT:   type  -- The smudge type identifier to convert into a reference.                   *
 *                                                                                             *
 * OUTPUT:  Returns with a reference to the smudge type class object.                          *
 *                                                                                             *
 * WARNINGS:   Be sure that the smudge type specified is legal. An illegal type value will     *
 *             produce undefined results.                                                      *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   07/09/1996 JLB : Created.                                                                 *
 *=============================================================================================*/
SmudgeTypeClass & SmudgeTypeClass::As_Reference(SmudgeType type)
{
	return(*SmudgeTypes.Ptr(type));
}