mirror of
https://github.com/electronicarts/CNC_TS_and_RA2_Mission_Editor.git
synced 2025-04-30 09:01:41 -04:00
6b62120f74
* refined common data of techno types among map objects, making the handling consistent . * status bar enhancement . * simplified 'GetStdxxxData' .
660 lines
No EOL
13 KiB
C++
660 lines
No EOL
13 KiB
C++
/*
|
||
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 MouseActionType : unsigned {
|
||
AddInfantry = 1,
|
||
AddStructure = 2,
|
||
AddAircraft = 3,
|
||
AddVehicle = 4,
|
||
AddTerrain = 5,
|
||
ManageOverlay = 6,
|
||
ChangeOwner = 7,
|
||
AddSmudge = 8,
|
||
};
|
||
|
||
enum class TechnoType : int {
|
||
Building,
|
||
Unit,
|
||
Infantry,
|
||
Aircraft,
|
||
None = -1,
|
||
};
|
||
|
||
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;
|
||
const 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 = false; // already tried to load this? - superseded by global array missingimages
|
||
bool bHouseColor = false;
|
||
|
||
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
|
||
|
||
/**
|
||
* Condtion Type enum
|
||
*/
|
||
enum ConditionType {
|
||
COND_TYPE_NONE = 0,
|
||
COND_TYPE_ENEMY_OWNS,
|
||
COND_TYPE_SELF_OWNS,
|
||
COND_TYPE_ENEMY_YELLOW_POWR,
|
||
COND_TYPE_ENEMY_RED_POWR,
|
||
COND_TYPE_ENEMY_OWNS_SOME_MONEY,
|
||
COND_TYPE_IRON_CURTAIN_READY,
|
||
COND_TYPE_CHRONO_SPHERE_READY,
|
||
COND_TYPE_NEUTRAL_OWNS,
|
||
};
|
||
|
||
/**
|
||
* Condition Operator enumeration
|
||
*/
|
||
enum ConditionOpEnum {
|
||
COND_OP_LT = 0, // less than
|
||
COND_OP_LE, // less than or equal to
|
||
COND_OP_EQ, // equal to
|
||
COND_OP_GE, // greater than or equal to
|
||
COND_OP_GT, // greater than
|
||
COND_OP_NE, // not equal to
|
||
COND_OP_COUNT
|
||
};
|
||
|
||
struct AITrigInfo
|
||
{
|
||
union {
|
||
struct {
|
||
int Number;
|
||
ConditionOpEnum 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) * sizeof(WCHAR));
|
||
|
||
size_t convertedSize = 0;
|
||
mbstowcs_s(&convertedSize, wString, len + 1, 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;
|
||
size_t 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
|
||
};
|
||
|
||
struct TECHNODATA
|
||
{
|
||
STDOBJECTDATA basic;
|
||
CString direction;
|
||
CString tag;
|
||
};
|
||
|
||
/*
|
||
STRUCTURE
|
||
|
||
Data for a structure
|
||
*/
|
||
struct STRUCTURE: TECHNODATA {
|
||
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 : TECHNODATA {
|
||
CString pos; // 6
|
||
CString action; // 7
|
||
CString flag1; // 10
|
||
CString group; // 11
|
||
CString flag3; // 12
|
||
CString flag4; // 13
|
||
CString flag5; // 14
|
||
unsigned deleted : 1;
|
||
};
|
||
|
||
struct UNIT : TECHNODATA {
|
||
CString action; // 7
|
||
CString flag1; // 9
|
||
CString group; // 10
|
||
CString flag3; // 11
|
||
CString flag4; // 12
|
||
CString flag5; // 13
|
||
CString flag6; // 14
|
||
unsigned deleted : 1;
|
||
};
|
||
|
||
struct AIRCRAFT : TECHNODATA {
|
||
CString action; // 7
|
||
CString flag1; // 9
|
||
CString group; // 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 |