// // 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\sdata.cpv 2.17 16 Oct 1995 16:52:10 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 : August 12, 1994 [JLB] * * * *---------------------------------------------------------------------------------------------* * Functions: * * SmudgeTypeClass::Draw_It -- Renders the smudge image at the coordinate specified. * * SmudgeTypeClass::Create_One_Of -- Creates a smudge object of this type. * * SmudgeTypeClass::Create_And_Place -- Creates and places on map, a smudge object. * * SmudgeTypeClass::Prep_For_Add -- Prepares the scenario editor for adding a smudge object. * * SmudgeTypeClass::Init -- Performs theater specific initializations. * * SmudgeTypeClass::Display -- Draws a generic version of this smudge type. * * SmudgetypeClass::Occupy_List -- Determines occupation list for smudge object. * * SmudgeTypeClass::From_Name -- Converts an ASCII name into a smudge type. * * SmudgeTypeClass::SmudgeTypeClass -- Constructor for smudge type objects. * * SmudgeTypeClass::One_Time -- Performs one-time initialization * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #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? ); /* ** The watcom code optimiser screws up the last constructor call. Making it 'volatile' reduces the ** level of optimisation enough for the problem not to manifest. */ volatile 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? ); /* ** Working array to the smudge control objects types. This routine is ** used for quick conversion from a SmudgeType number into an actual ** smudge type object pointer. */ SmudgeTypeClass const * const SmudgeTypeClass::Pointers[SMUDGE_COUNT] = { &Crater1, // SMUDGE_CRATER1 &Crater2, // SMUDGE_CRATER2 &Crater3, // SMUDGE_CRATER3 &Crater4, // SMUDGE_CRATER4 &Crater5, // SMUDGE_CRATER5 &Crater6, // SMUDGE_CRATER6 &Scorch1, // SMUDGE_SCORCH1 &Scorch2, // SMUDGE_SCORCH2 &Scorch3, // SMUDGE_SCORCH3 &Scorch4, // SMUDGE_SCORCH4 &Scorch5, // SMUDGE_SCORCH5 &Scorch6, // SMUDGE_SCORCH6 &Bibx1, // SMUDGE_BIB1 &Bibx2, // SMUDGE_BIB2 (SmudgeTypeClass const * const)&Bibx3 // SMUDGE_BIB3 }; /*********************************************************************************************** * 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(false, false, false, true, false, false, true, true, fullname, ininame, ARMOR_NONE, 0) { IsBib = isbib; Width = width; Height = height; IsCrater = iscrater; Type = smudge; } /*********************************************************************************************** * 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) { 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) = MixFileClass::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] << 3; y += WindowList[window][WINDOWY]; if (ptr) { for (int w = 0; w < Width; w++) { for (int h = 0; h < Height; h++) { CC_Draw_Shape(ptr, 0, x + w*ICON_PIXEL_W, y + h*ICON_PIXEL_H, WINDOW_TACTICAL, SHAPE_WIN_REL); //LogicPage->Draw_Stamp(ptr, w + (h*Width), x + w*ICON_PIXEL_W, y + h*ICON_PIXEL_H, NULL, WINDOW_TACTICAL); } } } } /*********************************************************************************************** * 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) { IsTheaterShape = true; // Smudges are theater specific CC_Draw_Shape(ptr, data, x, y, WINDOW_TACTICAL, SHAPE_WIN_REL); IsTheaterShape = false; // LogicPage->Draw_Stamp(ptr, data, x, y, NULL, WINDOW_TACTICAL); } } /*********************************************************************************************** * SmudgeTypeClass::One_Time -- Performs one-time initialization * * * * INPUT: none * * * * OUTPUT: none * * * * WARNINGS: none * * * * HISTORY: * * 08/12/1994 JLB : Created. * *=============================================================================================*/ void SmudgeTypeClass::One_Time(void) { }