tiberium/CNC_TS_and_RA2_Mission_Editor
1
0
Fork 0
mirror of https://github.com/electronicarts/CNC_TS_and_RA2_Mission_Editor.git synced 2025-07-18 04:06:42 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

TS_RA2_Mission_Editor_sourcecode_23.02.2023_1

Browse source 
TS_RA2_Mission_Editor_sourcecode_23.02.2023_1
This commit is contained in:
brbarnesEA 2024-03-05 11:56:45 -08:00
commit a547a31a37
377 changed files with 90136 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

658
MissionEditor/Structs.h Normal file
View file

@ -0,0 +1,658 @@
/*
FinalSun/FinalAlert 2 Mission Editor
Copyright (C) 1999-2024 Electronic Arts, Inc.
Authored by Matthias Wagner
This program 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.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
/**************************************
Global structs here
**************************************/
#ifndef GLOBALSTRUCTS_H_INCLUDED
#define GLOBALSTRUCTS_H_INCLUDED
#include "defines.h"
#include <vector>
#include <memory>
#include <cstdint>
#include "MissionEditorPackLib.h"
#include "Vec2.h"
class MapTool;
enum class TheaterChar : char
{
T = 'T',
A = 'A',
U = 'U',
N = 'N',
D = 'D',
L = 'L',
Generic = 'G',
None = 0
};
inline TheaterChar toTheaterChar(char c)
{
switch (c)
{
case 'T':
return TheaterChar::T;
case 'A':
return TheaterChar::A;
case 'U':
return TheaterChar::U;
case 'N':
return TheaterChar::N;
case 'D':
return TheaterChar::D;
case 'L':
return TheaterChar::L;
case 'G':
return TheaterChar::Generic;
default:
return TheaterChar::None;
}
}
struct CLIPBOARD_MAPCOPY_ENTRY
{
BOOL bRedrawTerrain;
BYTE overlay;
BYTE overlaydata;
WORD wGround;
WORD bMapData;
BYTE bSubTile;
BYTE bHeight;
BYTE bMapData2;
// for RA2<->TS conversion:
WORD wTileSet;
BYTE bTile;
};
struct CLIPBOARD_DATA
{
DWORD dwType;
DWORD dwVersion;
DWORD dwReserved;
BYTE bGame; // 0 TS, 1 RA2
UINT iWidth;
UINT iHeight;
};
struct VBORDER
{
short left;
short right;
};
/*
picdata
Holds information for every picture:
a directdraw surface, and additional data
*/
struct PICDATA{
PICDATA() = default;
PICDATA(const PICDATA& c) = default;
PICDATA& operator=(const PICDATA& c) = default;
~PICDATA() = default;
#ifndef NOSURFACES_OBJECTS
LPDIRECTDRAWSURFACE4 pic;
#else
void* pic = nullptr; // BYTE* to image, exception: if bType==PICDATA_TYPE_BMP then this is a LPDIRECTDRAWSURFACE!
VBORDER* vborder = nullptr;
int* pal = nullptr;
std::shared_ptr<std::vector<BYTE>> lighting;
std::shared_ptr<std::vector<BYTE>> rawPic;
std::shared_ptr<std::vector<VBORDER>> _vBorder;
#endif
FSunPackLib::VoxelNormalClass normalClass = FSunPackLib::VoxelNormalClass::Unknown;
short x = 0; // for SHPs (starting point of main graphic inside surface)
short y = 0; // for SHPs (starting point of main graphic inside surface)
WORD wWidth = 0; // for non-shps: size of whole surface, else size of main graphic
WORD wHeight = 0; // for non-shps: size of whole surface, else size of main graphic
WORD wMaxWidth = 0; // for SHPs (size of whole surface)
WORD wMaxHeight = 0; // for SHPs (size of whole surface)
BYTE bType = 0; // is loaded from voxel, shp, bmp, etc... (for drawing logic)
TheaterChar bTerrain = TheaterChar::None;
BOOL bTried = 0; // already tried to load this? - superseded by global array missingimages
inline ProjectedVec drawOffset() const
{
return ProjectedVec(x, y);
}
#ifdef NOSURFACES_OBJECTS
void createVBorder();
#endif
};
/*
TILEPIC / TILEDATA
Holds information for every tile/subtile in TS.
*/
struct SUBTILE{
#ifndef NOSURFACES
LPDIRECTDRAWSURFACE4 pic;
#else
#ifdef NOSURFACES_EXTRACT
BOOL bNotExtracted; // pic is not extracted, even if NOSURFACES_EXTRACT is specifed. Probably there is inner transparency!
#endif
BYTE* pic; // optionally use direct blitting? This is either a palette index array or non-palette data (if NOSURFACES_EXTRACT is specified)
VBORDER * vborder;
#endif
WORD wWidth; // width of tile
WORD wHeight; // height "
short sX; // x starting pos
short sY; // y starting pos
BYTE bZHeight; // z difference from tile ground surface (1unit == f_y/2pixel == 12pixel)
BYTE bDirection; // for ramps for example
BYTE bTerrainType; // water, etc...
RGBTRIPLE rgbLeft;
RGBTRIPLE rgbRight;
BYTE bHackedTerrainType; // same like bTerrainType, except some shore pieces that were hacked in fsdata.ini
std::shared_ptr<PICDATA> anim;
inline ProjectedVec drawOffset() const
{
return ProjectedVec(sX, sY);
}
};
struct TILEDATA{
TILEDATA() = default;
~TILEDATA();
WORD wTileSet = 0;
SUBTILE* tiles = nullptr; // the different tiles
WORD wTileCount = 0; // number of tiles
WORD cx = 0;
WORD cy = 0;
BOOL bAllowTiberium = 0;
BOOL bAllowToPlace = TRUE;
BOOL bMorphable = FALSE; // morphable using lower/raise ground function?
BOOL bHide = FALSE; // for user interface only
BOOL bMarbleMadness = FALSE;
WORD wMarbleGround = 0xFFFF;
public:
RECT rect = { 0 };
TILEDATA* lpReplacements = nullptr;
BYTE bReplacementCount = 0;
};
/*
actiondata
CViewObjects sets this data struct,
and CIsoView uses it to interact with the user´s CViewObjects and terrain editing choice
*/
struct ACTIONDATA{
DWORD mode;
DWORD type;
DWORD data;
DWORD data2;
DWORD data3;
int z_data;
CString data_s;
std::unique_ptr<MapTool> tool;
~ACTIONDATA();
void reset();
};
struct SIDEINFO{
CString name;
int orig_n;
};
struct HOUSEINFO{
CString name;
SIDEINFO* side; // side is used for rules.ini owner= settings
RGBTRIPLE color;
BOOL bPlayable;
};
/**********************
Unittype infos
**********************/
/*
building infos
*/
struct BUILDING_INFO
{
PICDATA pic[8];
int pic_count;
BYTE w;
BYTE h;
BOOL bTemp;
BOOL bSnow;
BOOL bUrban;
};
struct TREE_INFO
{
PICDATA pic;
BYTE w;
BYTE h;
};
#ifdef SMUDGE_SUPP
struct SMUDGE_INFO
{
PICDATA pic;
//BYTE w;
//BYTE h;
};
#endif
/*
** Condition enumeration
*/
enum ConditionEnum {
COND_LT = 0, // less than
COND_LE, // less than or equal to
COND_EQ, // equal to
COND_GE, // greater than or equal to
COND_GT, // greater than
COND_NE, // not equal to
COND_COUNT
};
struct AITrigInfo
{
union{
struct{
int Number;
ConditionEnum Condition;
};
char Padding[32];
};
};
/*
Struct for string items
*/
struct XCString
{
XCString()
{
//wString=new(WCHAR[2]);
//memset(wString, 0, 4);
wString=NULL;
bUsedDefault=FALSE;
len=0;
}
~XCString()
{
if(wString) delete[] wString;
len=0;
wString=NULL;
}
void SetString(const CHAR* cString)
{
len=strlen(cString);
this->cString=cString;
if(wString) delete[] wString;
bUsedDefault=FALSE;
wString=new(WCHAR[len+1]);
memset(wString, 0, (len+1)*2);
//MultiByteToWideChar(CP_ACP, WC_COMPOSITECHECK, cString, len, wString, len+1);
mbstowcs(wString, cString, len);
}
void SetString(const WCHAR* wString, int len)
{
this->len=len;
if(this->wString) delete[] this->wString;
bUsedDefault=FALSE;
this->wString=new(WCHAR[len+1]);
memset(this->wString, 0, (len+1)*2);
memcpy(this->wString, wString, len*2);
auto bufferSize = WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, this->wString, len + 1, nullptr, 0, NULL, &bUsedDefault);
if (bufferSize == 0)
{
cString = "";
return; // failed
}
std::vector<BYTE> bByte(bufferSize + 4, 0);
if (WideCharToMultiByte(CP_ACP, WC_COMPOSITECHECK, this->wString, len + 1, (LPSTR)bByte.data(), bufferSize, NULL, &bUsedDefault) == 0)
{
cString = "";
return; // failed
}
cString = bByte.data();
}
CString cString;
WCHAR* wString;
BOOL bUsedDefault;
int len;
};
/**********************
Map stuff structs
***********************/
/*
AITRIGGERTYPE{};
Data for ai trigger types
*/
struct AITRIGGERTYPE{
CString ID; // ai trigger id
CString name; // param 1
CString teamtype1; // param 2
CString owner; // param 3
CString techlevel; // flag 1/ param 4
CString type; // param 5
CString unittype; // param 6
CString data; // param 7
CString float1; // param 8
CString float2; // param 9
CString float3; // param 10
CString skirmish; // param 11
CString flag4; // param 12
CString multihouse; // param 13
CString basedefense; // param 14
CString teamtype2; // param 15
CString easy; // param 16
CString medium; // param 17
CString hard; // param 18
};
/*
STDOBJECTDATA
Data for Trees, Units, Infantry, Aircraft & Structures
This should be used for painting procedure...
except if you want to draw the upgrades on buildings
*/
struct STDOBJECTDATA
{
CString house; // 1
CString type; // 2
CString strength; // 3
CString y; // 4
CString x; // 5
};
/*
STRUCTURE
Data for a structure
*/
struct STRUCTURE{
CString house; // 1
CString type; // 2
CString strength; // 3
CString y; // 4
CString x; // 5
CString direction; // 6
CString tag; // 7
CString flag1; // 8
CString flag2; // 9
CString energy; // 10
CString upgradecount; // 11
CString spotlight; // 12
CString upgrade1; // 13
CString upgrade2; // 14
CString upgrade3; // 15
CString flag3; // 16
CString flag4; // 17
unsigned deleted:1;
};
// structure data especially for painting
struct STRUCTUREPAINT{
COLORREF col;
CString type;
short x;
short y;
short direction;
BYTE strength;
BYTE upradecount;
CString upgrade1;
CString upgrade2;
CString upgrade3;
};
/*
struct INFANTRY{};
Data for an infantry unit
*/
struct INFANTRY{
CString house; // 1
CString type; // 2
CString strength; // 3
CString y; // 4
CString x; // 5
CString pos; // 6
CString action; // 7
CString direction; // 8
CString tag; // 9
CString flag1; // 10
CString flag2; // 11
CString flag3; // 12
CString flag4; // 13
CString flag5; // 14
unsigned deleted:1;
};
struct UNIT{
CString house; // 1
CString type; // 2
CString strength; // 3
CString y; // 4
CString x; // 5
CString direction; // 6
CString action; // 7
CString tag; // 8
CString flag1; // 9
CString flag2; // 10
CString flag3; // 11
CString flag4; // 12
CString flag5; // 13
CString flag6; // 14
unsigned deleted:1;
};
struct AIRCRAFT{
CString house; // 1
CString type; // 2
CString strength; // 3
CString y; // 4
CString x; // 5
CString direction; // 6
CString action; // 7
CString tag; // 8
CString flag1; // 9
CString flag2; // 10
CString flag3; // 11
CString flag4; // 12
unsigned deleted:1;
};
struct TERRAIN{
CString type;
int x;
int y;
unsigned deleted:1;
};
// MW 08/07/01: Smudge
#ifdef SMUDGE_SUPP
struct SMUDGE{
CString type;
int x;
int y;
unsigned deleted:1;
};
#endif
/*
NODE
Data for a node
*/
struct NODE{
CString house;
CString type;
CString x;
CString y;
};
struct RA2STRFILEHEAD
{
DWORD dwFlag1;
DWORD dwCount1;
DWORD dwCount2;
DWORD dwUnused;
DWORD dwFlag2;
};
#define RA2STRFILEHEADSIZE 20
struct RA2STRINGENTRY
{
RA2STRINGENTRY(){
//memset(this, 0, sizeof(RA2STRINGENTRY));
id=NULL;
value=NULL;
value_asc=0;
value_asc_size=0;
dwFlag = 0;
id_size = 0;
value_size = 0;
}
~RA2STRINGENTRY(){
if(value) delete[] value;
if(id) delete[] id;
if(value_asc) delete[] value_asc;
value=NULL;
value_size=0;
id=NULL;
id_size=0;
value_asc=0;
value_asc_size=0;
}
RA2STRINGENTRY(RA2STRINGENTRY& ref)
{
value=NULL;
value_size=0;
id=NULL;
id_size = 0;
value_asc=0;
value_asc_size=0;
if(ref.value_size && ref.value)
{
value_size=ref.value_size;
value=new(WCHAR[value_size+1]);
memcpy(value, ref.value, value_size*sizeof(WCHAR));
value[value_size]=0;
}
if(ref.id_size && ref.id)
{
id_size=ref.id_size;
id=new(CHAR[id_size+1]);
memcpy(id, ref.id, id_size*sizeof(CHAR));
id[id_size]=0;
}
if(ref.value_asc_size && ref.value_asc)
{
value_asc_size=ref.value_asc_size;
value_asc=new(CHAR[value_asc_size+1]);
memcpy(value_asc, ref.value_asc, value_asc_size*sizeof(CHAR));
value_asc[value_asc_size]=0;
}
dwFlag=ref.dwFlag;
}
RA2STRINGENTRY& operator=(RA2STRINGENTRY& ref)
{
if(value) delete[] value;
if(id) delete[] id;
value=NULL;
value_size=0;
id=NULL;
value_asc=0;
value_asc_size=0;
if(ref.value_size)
{
value_size=ref.value_size;
value=new(WCHAR[value_size+1]);
memcpy(value, ref.value, value_size*sizeof(WCHAR));
value[value_size]=0;
}
if(ref.id_size)
{
id_size=ref.id_size;
id=new(CHAR[id_size+1]);
memcpy(id, ref.id, id_size*sizeof(CHAR));
id[id_size]=0;
}
if(ref.value_asc_size)
{
value_asc_size=ref.value_asc_size;
value_asc=new(CHAR[value_asc_size+1]);
memcpy(value_asc, ref.value_asc, value_asc_size*sizeof(CHAR));
value_asc[value_asc_size]=0;
}
dwFlag=ref.dwFlag;
return *this;
}
DWORD dwFlag;
CHAR* id;
DWORD id_size;
DWORD value_size;
WCHAR* value;
CHAR* value_asc;
DWORD value_asc_size;
};
#endif