//
// 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\smudge.cpv 2.18 16 Oct 1995 16:52:06 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 : SMUDGE.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : August 9, 1994 *
* *
* Last Update : July 24, 1995 [JLB] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* SmudgeClass::Init -- Initialize the smudge tracking system. *
* SmudgeClass::SmudgeClass -- Constructor for smudge objects. *
* SmudgeClass::operator delete -- Deletes the smudge from the tracking system. *
* SmudgeClass::operator new -- Creator of smudge objects. *
* SmudgeClass::Mark -- Marks a smudge down on the map. *
* SmudgeClass::Read_INI -- Reads smudge data from an INI file. *
* SmudgeClass::Write_INI -- Writes the smudge data to an INI file. *
* SmudgeClass::Disown -- Disowns (removes) a building bib piece. *
* SmudgeClass::Validate -- validates smudge pointer *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "function.h"
#include "smudge.h"
/*
** This contains the value of the Virtual Function Table Pointer
*/
void * SmudgeClass::VTable;
HousesType SmudgeClass::ToOwn = HOUSE_NONE;
/***********************************************************************************************
* SmudgeClass::Validate -- validates smudge pointer *
* *
* INPUT: *
* none. *
* *
* OUTPUT: *
* 1 = ok, 0 = error *
* *
* WARNINGS: *
* none. *
* *
* HISTORY: *
* 08/09/1995 BRR : Created. *
*=============================================================================================*/
#ifdef CHEAT_KEYS
int SmudgeClass::Validate(void) const
{
int num;
num = Smudges.ID(this);
if (num < 0 || num >= SMUDGE_MAX) {
Validate_Error("SMUDGE");
return (0);
}
else
return (1);
}
#else
#define Validate()
#endif
/***********************************************************************************************
* SmudgeClass::operator new -- Creator of smudge objects. *
* *
* This routine will allocate a smudge object from the smudge tracking pool. *
* *
* INPUT: none *
* *
* OUTPUT: Returns with a pointer to a newly allocated smudge object. If one couldn't be *
* found, then NULL is returned. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/01/1994 JLB : Created. *
*=============================================================================================*/
void * SmudgeClass::operator new(size_t )
{
void * ptr = Smudges.Allocate();
if (ptr) {
((SmudgeClass *)ptr)->Set_Active();
}
return(ptr);
}
/***********************************************************************************************
* SmudgeClass::operator delete -- Deletes the smudge from the tracking system. *
* *
* This routine is used to remove the smudge from the tracking system. *
* *
* INPUT: ptr -- Pointer to the smudge to delete. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/01/1994 JLB : Created. *
*=============================================================================================*/
void SmudgeClass::operator delete(void *ptr)
{
if (ptr) {
((SmudgeClass *)ptr)->IsActive = false;
}
Smudges.Free((SmudgeClass *)ptr);
//Map.Validate();
}
/***********************************************************************************************
* SmudgeClass::SmudgeClass -- Constructor for smudge objects. *
* *
* This is the typical constructor for smudge objects. If the position to place the *
* smudge is not given, then the smudge will be initialized in a limbo state. If the *
* smudge is placed on the map, then this operation causes the smudge object itself to be *
* deleted and special map values updated to reflect the presence of a smudge. *
* *
* INPUT: type -- The type of smudge to construct. *
* *
* pos -- The position to place the smudge. If -1, then the smudge is initialized *
* into a limbo state. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/01/1994 JLB : Created. *
*=============================================================================================*/
SmudgeClass::SmudgeClass(SmudgeType type, COORDINATE pos, HousesType house) :
Class(&SmudgeTypeClass::As_Reference(type))
{
if (pos != -1) {
ToOwn = house;
if (!Unlimbo(pos)) {
Delete_This();
}
ToOwn = HOUSE_NONE;
}
}
/***********************************************************************************************
* SmudgeClass::Init -- Initialize the smudge tracking system. *
* *
* This routine is used during the scenario clearing process to initialize the smudge *
* object tracking system to a null state. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/01/1994 JLB : Created. *
*=============================================================================================*/
void SmudgeClass::Init(void)
{
SmudgeClass *ptr;
Smudges.Free_All();
ptr = new SmudgeClass();
VTable = ((void **)(((char *)ptr) + sizeof(AbstractClass) - 4))[0];
delete ptr;
}
/***********************************************************************************************
* SmudgeClass::Mark -- Marks a smudge down on the map. *
* *
* This routine will place the smudge on the map. If the map cell allows. *
* *
* INPUT: mark -- The type of marking to perform. Only MARK_DOWN is supported. *
* *
* OUTPUT: bool; Was the smudge marked successfully? Failure occurs if the smudge isn't *
* marked DOWN. *
* *
* WARNINGS: The smudge object is DELETED by this routine. *
* *
* HISTORY: *
* 09/22/1994 JLB : Created. *
* 12/23/1994 JLB : Checks low level legality before proceeding. *
*=============================================================================================*/
bool SmudgeClass::Mark(MarkType mark)
{
Validate();
if (ObjectClass::Mark(mark)) {
if (mark == MARK_DOWN) {
CELL origin = Coord_Cell(Coord);
for (int w = 0; w < Class->Width; w++) {
for (int h = 0; h < Class->Height; h++) {
CELL newcell = origin + w + (h*MAP_CELL_W);
if (Map.In_Radar(newcell)) {
CellClass * cell = &Map[newcell];
if (Class->IsBib) {
cell->Smudge = Class->Type;
cell->SmudgeData = w + (h*Class->Width);
cell->Owner = ToOwn;
} else {
if (cell->Is_Generally_Clear()) {
if (Class->IsCrater && cell->Smudge != SMUDGE_NONE && SmudgeTypeClass::As_Reference(cell->Smudge).IsCrater) {
cell->SmudgeData++;
cell->SmudgeData = (int)MIN((int)cell->SmudgeData, (int)4);
}
if (cell->Smudge == SMUDGE_NONE) {
/*
** Special selection of a crater that starts as close to the
** specified coordinate as possible.
*/
if (Class->IsCrater) {
cell->Smudge = (SmudgeType)(SMUDGE_CRATER1 + CellClass::Spot_Index(Coord));
} else {
cell->Smudge = Class->Type;
}
cell->SmudgeData = 0;
}
}
}
/*
** Flag everything that might be overlapping this cell to redraw itself.
*/
cell->Redraw_Objects();
}
}
}
/*
** Whether it was successful in placing, or not, delete the smudge object. It isn't
** needed once the map has been updated with the proper smudge data.
*/
Delete_This();
return(true);
}
}
return(false);
}
/***********************************************************************************************
* SmudgeClass::Read_INI -- Reads smudge data from an INI file. *
* *
* This routine is used by the scenario loader to read the smudge data in an INI file and *
* create the appropriate smudge objects on the map. *
* *
* INPUT: buffer -- Pointer to the INI file staging buffer. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/01/1994 JLB : Created. *
* 07/24/1995 JLB : Sets the smudge data value as well. *
*=============================================================================================*/
void SmudgeClass::Read_INI(char *buffer)
{
char buf[128]; // Working string staging buffer.
int len = strlen(buffer) + 2;
char * tbuffer = buffer + len;
WWGetPrivateProfileString(INI_Name(), NULL, NULL, tbuffer, ShapeBufferSize-len, buffer);
while (*tbuffer != '\0') {
SmudgeType smudge; // Smudge type.
WWGetPrivateProfileString(INI_Name(), tbuffer, NULL, buf, sizeof(buf)-1, buffer);
smudge = SmudgeTypeClass::From_Name(strtok(buf, ","));
if (smudge != SMUDGE_NONE) {
char * ptr = strtok(NULL, ",");
if (ptr) {
int data = 0;
CELL cell = atoi(ptr);
ptr = strtok(NULL, ",");
if (ptr) data = atoi(ptr);
new SmudgeClass(smudge, Cell_Coord(cell));
if (Map[cell].Smudge == smudge && data) {
Map[cell].SmudgeData = data;
}
}
}
tbuffer += strlen(tbuffer)+1;
}
}
/***********************************************************************************************
* SmudgeClass::Write_INI -- Writes the smudge data to an INI file. *
* *
* This routine is used by the scenario editor to write the smudge data to an INI file. *
* *
* INPUT: buffer -- Pointer to the INI file staging buffer. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 09/01/1994 JLB : Created. *
* 07/24/1995 JLB : Records the smudge data as well. *
*=============================================================================================*/
void SmudgeClass::Write_INI(char *buffer)
{
char uname[10];
char buf[127];
char *tbuffer; // Accumulation buffer of unit IDs.
/*
** First, clear out all existing template data from the ini file.
*/
tbuffer = buffer + strlen(buffer) + 2;
WWGetPrivateProfileString(INI_Name(), NULL, NULL, tbuffer, ShapeBufferSize-strlen(buffer), buffer);
while (*tbuffer != '\0') {
WWWritePrivateProfileString(INI_Name(), tbuffer, NULL, buffer);
tbuffer += strlen(tbuffer)+1;
}
/*
** Find all templates and write them to the file.
*/
for (CELL index = 0; index < MAP_CELL_TOTAL; index++) {
CellClass * ptr;
ptr = &Map[index];
if (ptr->Smudge != SMUDGE_NONE) {
SmudgeTypeClass const * stype = &SmudgeTypeClass::As_Reference(ptr->Smudge);
if (!stype->IsBib) {
sprintf(uname, "%03d", index);
sprintf(buf, "%s,%d,%d", stype->IniName, index, ptr->SmudgeData);
WWWritePrivateProfileString(INI_Name(), uname, buf, buffer);
}
}
}
}
/***********************************************************************************************
* SmudgeClass::Disown -- Disowns (removes) a building bib piece. *
* *
* This routine is used when a building is removed from the game. If there was any bib *
* attached, this routine will be called to disown the cells and remove the bib artwork. *
* *
* INPUT: cell -- The origin cell for this bib removal. *
* *
* OUTPUT: none *
* *
* WARNINGS: This is actually working on a temporary bib object. It is created for the sole *
* purpose of calling this routine. It will be deleted immediately afterward. *
* *
* HISTORY: *
* 07/04/1995 JLB : Created. *
*=============================================================================================*/
void SmudgeClass::Disown(CELL cell)
{
Validate();
if (Class->IsBib) {
for (int w = 0; w < Class->Width; w++) {
for (int h = 0; h < Class->Height; h++) {
CellClass & cellptr = Map[cell + w + (h*MAP_CELL_W)];
if (cellptr.Overlay == OVERLAY_NONE || !OverlayTypeClass::As_Reference(cellptr.Overlay).IsWall) {
cellptr.Smudge = SMUDGE_NONE;
cellptr.SmudgeData = 0;
cellptr.Owner = HOUSE_NONE;
cellptr.Redraw_Objects();
}
}
}
}
}