// Common header stuff to prevent redefinition errors
//  if the header is included more than once
#ifndef OUTPOST2DLL_H
#define OUTPOST2DLL_H

#define OP2 __declspec(dllimport)


#define plr_all -1

// Mining beacon's
#define beacon_common 0
#define beacon_rare 1

// Yield Type's
#define yield_3 0
#define yield_2 1
#define yield_1 2

// Marker Types
#define marker_cir 0 // circular
#define marker_dna 1 // dna strand
#define marker_lab 2 // beaker

// ********************************** Enums **********************************

enum map_id {
	map_None = 0,
	map_Cargo_Truck,			// 01
	map_ConVec,					// 02
	map_Spider,					// 03
	map_Scorpion,				// 04
	map_Lynx,					// 05
	map_Panther,				// 06
	map_Tiger,					// 07
	map_Robo_Surveyor,			// 08
	map_Robo_Miner,				// 09
	map_GeoCon,					// 0A
	map_Scout,					// 0B
	map_Robo_Dozer,				// 0C
	map_Evacuation_Transport,	// 0D
	map_Repair_Vehicle,			// 0E
	map_Earthworker,			// 0F
	map_SmallCapacityAirTransport,	// Crashes game when it moves (looks like a scout)
	
	map_Tube = 0x11,
	map_Wall,					// 12
	map_Lava_Wall,				// 13
	map_Microbe_Wall,			// 14
	map_Mine = 0x15,
	map_Guard_Post = 0x17,
	map_Light_Tower,			// 18
	map_Common_Storage,			// 19
	map_Rare_Storage,			// 1A
	map_Forum,					// 1B
	map_Command_Center,			// 1C
	map_MHD_Generator,			// 1D
	map_Residence,				// 1E
	map_Robot_Command,			// 1F
	map_Trade_Center,			// 20
	map_Basic_Lab,				// 21
	map_Medical_Center,			// 22
	map_Nursury,				// 23
	map_Solar_Power_Array,		// 24
	map_Recreation_Facility,	// 25
	map_University,				// 26
	map_Agridome,				// 27
	map_DIRT,					// 28
	map_Garage,					// 29
	map_Magma_Well,				// 2A
	map_Meteor_Defense,			// 2B
	map_Geothermal_Plant,		// 2C
	map_Arachnid_Factory,		// 2D
	map_Consumer_Factory,		// 2E
	map_Structure_Factory,		// 2F
	map_Vehicle_Factory,		// 30
	map_Standard_Lab,			// 31
	map_Advanced_Lab,			// 32
	map_Observatory,			// 33
	map_Reinforced_Residence,	// 34
	map_Advanced_Residence,		// 35
	map_Common_Ore_Smelter,		// 36
	map_Spaceport,				// 37
	map_Rare_Ore_Smelter,		// 38
	map_GORF,					// 39
	map_Tokamak,				// 3A

	map_Acid_Cloud = 0x3B,		// 3B
	map_EMP,					// 3C
	map_Laser,					// 3D
	map_Microwave,				// 3E
	map_Rail_Gun,				// 3F
	map_RPG,					// 40
	map_Starflare,				// 41
	map_Supernova,				// 42
	map_ESG = 0x46,				
	map_Stickyfoam,				// 47
	map_Thors_Hammer,			// 48
	map_Energy_Cannon,			// 49

	map_Mining_Beacon = 0x51,
	map_Magma_Vent,				// 52
	map_Fumarole,				// 53

	map_Disasterous_Building_Explosion = 0x55,
	map_Catastrophic_Building_Explosion,	// 56
	map_Athiest_Building_Explosion,			// 57

	map_EDWARD_Satellite = 0x58,	// Lynx (in Cargo Truck)
	map_Solar_Satellite,			// Wreckage (in Cargo Truck)
	map_Ion_Drive_Module,			// Gene Bank 5 (in Cargo Truck)
	map_Fusion_Drive_Module,	// 5B
	map_Command_Module,			// 5C
	map_Fueling_Systems,		// 5D
	map_Habitat_Ring,			// 5E
	map_Sensor_Package,			// 5F
	map_Skydock,				// 60
	map_Stasis_Systems,			// 61
	map_Orbital_Package,		// 62
	map_Pheonix_Module,			// 63

	map_Rare_Metals_Cargo,		// 64
	map_Common_Metals_Cargo,	// 65
	map_Food_Cargo,				// 66
	map_Evacuation_Module,		// 67
	map_Children_Module,		// 68

	map_SULV,					// 69
	map_RLV,					// 6A
	map_EMP_Missile,			// 6B

	map_Impulse_Items = 0x6C,
	map_Wares,					// 6D
	map_Luxury_Wares,			// 6E

	map_Inter_Colony_Shuttle = 0x6F,
	map_Spider_3_Pack,			// 70
	map_Scorpion_3_Pack,		// 71

	map_Pretty_Art = 0x72
};

enum compare_mode {
	cmp_Default = 0,
	cmp_Equal = 0,
	cmp_Lower_Equal,
	cmp_Greater_Equal,
	cmp_Lower = 3,
	cmp_Greater = 4
};
enum trig_res {
	res_common_ore = 0x01,
	res_rare_ore
};

enum FoodStatus {};

enum MoraleLevels {};

enum UnitClassifactions {
	cls_Attack = 0,
	cls_ESG,
	cls_EMP,
	cls_Stickyfoam,
	cls_Convecs = 5,
	cls_Cargo_Trucks = 7,
	cls_Earthworkers = 8,
	cls_Robo_Dozers = 9,
	cls_test = 4 // No special need
};
// cls_Attack applies to all units with the following weapons:
//  Microwave
//  Laser
//  Rail Gun
//  Starflare
//  Supernova
//  RPG
//  Acid Cloud
//  Thor's Hammer
//  Energy Cannon (Scorpions)


enum SongIds {};

enum Truck_Cargo {
	trck_Empty = 0x00,
	trck_Food,
	trck_Common_Ore,
	trck_Rare_Ore,
	trck_Common_Metal,
	trck_Rare_Metal,
	trck_Common_Rubble = 0x06,
	trck_Rare_Rubble,
	trck_Spaceport = 0x08,
	trck_Garbage = 0x09,
	trck_Unit = 0x03F8
};



// ***************************** Structures (exported) *****************************

struct OP2 LOCATION
{
public:
	LOCATION(int x, int y)	{ this->x = x; this->y = y; };
	LOCATION()			{ this->x = 0; this->y = 0; };
	struct LOCATION & operator = (struct LOCATION const &);
	void Add(struct LOCATION const &);
	void Clip();
	static struct LOCATION __fastcall Difference(struct LOCATION const &, struct LOCATION const &);
	int Norm();

	int x, y;
};

struct OP2 MAP_RECT
{
public:
	MAP_RECT(struct LOCATION const &topLeft, struct LOCATION const &bottomRight); // Map tiles
	MAP_RECT(int x1, int y1, int x2, int y2);		// Map tile coordinates: Top left (x1, y1)
													//  bottom right (x2, y2)
	MAP_RECT();
	struct MAP_RECT & operator = (struct MAP_RECT const &);
	int Check(struct LOCATION &);
	void ClipToMap();
	void FromPtSize(struct LOCATION const &, struct LOCATION const &);
	int Height() const;
	void Inflate(int, int);
	void Offset(int, int);
	struct LOCATION RandPt() const;
	struct LOCATION Size() const;
	int Width() const;

	int x1, y1, x2, y2;		// Top left (x1, y1), bottom right (x2, y2)
};

// *********************** Implied Structures (not exported) ***********************

struct OP2 PatrolRoute {
};

struct OP2 MrRec {
};

struct OP2 PWDef {
};

struct OP2 CommandPacket {
};

struct OP2 UnitRecord {
	map_id Type;
	int X, Y;
	int unknown1, unknown2;
	map_id Weapon;
	int unknown3;
	short Cargo;
	short Attrib;
};


// ********************************** Classes **********************************

class OP2 ScStub
{
public:
	ScStub();
	~ScStub();
	class ScStub & operator=(class ScStub const &);
	// void * ScStub::`vector deleting destructor'(unsigned int);
	// void * ScStub::`scalar deleting destructor'(unsigned int);
	void Destroy();
	void Disable();
	void Enable();
	int Id() const;
	int IsEnabled();
	int IsInitialized();
	void SetId(int);

private:
	int ID;
};

class OP2 Trigger : public ScStub
{
public:
	Trigger();
	~Trigger() {};
	class Trigger & operator=(class Trigger const &);
	// void * Trigger::`vector deleting destructor'(unsigned int);
	// void * Trigger::`scalar deleting destructor'(unsigned int);
	void Disable();
	void Enable();
	int HasFired(int);
};

class OP2 Pinwheel : public ScStub
{
public:
	Pinwheel();
	~Pinwheel() {};
	class Pinwheel & operator=(class Pinwheel const &);
	// void * Pinwheel::`vector deleting destructor'(unsigned int);
	// void * Pinwheel::`scalar deleting destructor'(unsigned int);
	void SendWaveNow(int);
	void SetAttackComp(int,int,struct MrRec *);
	void SetAttackFraction(int);
	void SetContactDelay(int);
	void SetGuardComp(int,int,struct MrRec *);
	void SetNoRange(int,int);
	void SetPoints(struct PWDef *);
	void SetSapperComp(int,int,struct MrRec *);
	void SetWavePeriod(int,int);
};

class OP2 ScGroup : public ScStub
{
public:
	ScGroup();
	~ScGroup() {};
	class ScGroup & operator=(class ScGroup const &);
	// void * ScGroup::`vector deleting destructor'(unsigned int);
	// void * ScGroup::`scalar deleting destructor'(unsigned int);
	void AddUnits(class UnitBlock &unitsToAdd);
	void ClearTargCount();
	int GetFirstOfType(class Unit &returnedUnit, enum UnitClassifactions unitType);
	int GetFirstOfType(class Unit &returnedUnit, enum map_id unitType, enum map_id weaponType);
	int HasBeenAttacked();
	void RemoveUnit(class Unit unitToRemove);
	void SetDeleteWhenEmpty(int);
	void SetLights(int boolOn);
	void SetTargCount(class UnitBlock &);
	void SetTargCount(enum map_id,enum map_id,int);
	void TakeAllUnits(class ScGroup &);
	void TakeUnit(class Unit);
	int TotalUnitCount();
	int UnitCount(enum UnitClassifactions);
};

class OP2 BuildingGroup : public ScGroup
{
public:
	BuildingGroup();
	~BuildingGroup() {};
	class BuildingGroup & operator=(class BuildingGroup const &);
	// void * BuildingGroup::`vector deleting destructor'(unsigned int);
	// void * BuildingGroup::`scalar deleting destructor'(unsigned int);
	void RecordBuilding(struct LOCATION &,enum map_id,enum map_id);
	void RecordBuilding(struct LOCATION &,enum map_id,enum map_id,class ScGroup &);
	void RecordTube(struct LOCATION &);
	void RecordTubesTouching(struct LOCATION &);
	void RecordUnitBlock(class UnitBlock &);
	void RecordUnitBlock(class UnitBlock &,class ScGroup &);
	void RecordVehReinforceGroup(class ScGroup &,int);
	void RecordWall(struct LOCATION &,enum map_id);
	void SetRect(struct MAP_RECT &);
	void UnRecordVehGroup(class ScGroup &);
};

class OP2 FightGroup : public ScGroup
{
public:
	FightGroup();
	~FightGroup() {};
	class FightGroup & operator=(class FightGroup const &);
	// void * FightGroup::`vector deleting destructor'(unsigned int);
	// void * FightGroup::`scalar deleting destructor'(unsigned int);
	void AddGuardedRect(struct MAP_RECT &);
	void ClearCombineFire();
	void ClearGuarderdRects();
	void ClearPatrolMode();
	void DoAttackEnemy();
	void DoAttackUnit();
	void DoExitMap();
	void DoGuardGroup();
	void DoGuardRect();
	void DoGuardUnit();
	void DoPatrolOnly();
	void SetAttackType(enum map_id);
	void SetCombineFire();
	void SetFollowMode(int);
	void SetPatrolMode(struct PatrolRoute &);
	void SetRect(struct MAP_RECT &);
	void SetTargetGroup(class ScGroup);
	void SetTargetUnit(class Unit);
};

class OP2 MiningGroup : public ScGroup
{
public:
	MiningGroup();
	~MiningGroup() {};
	class MiningGroup & operator=(class MiningGroup const &);
	// void * MiningGroup::`vector deleting destructor'(unsigned int);
	// void * MiningGroup::`scalar deleting destructor'(unsigned int);
	void Setup(struct LOCATION &,struct LOCATION &,struct MAP_RECT &);
	void Setup(struct LOCATION &,struct LOCATION &,enum map_id,enum map_id,struct MAP_RECT &);
	void Setup(class Unit,class Unit,struct MAP_RECT &);
};



class OP2 Unit
{
public:
	Unit() { unitID = 0; };
	class Unit & operator=(class Unit const &);
	int operator == (class Unit const &)const;
	void ClearSpecialTarget();
	void DoAttack(class Unit);
	void DoBuild(enum map_id,struct LOCATION);
	void DoDeath();
	void DoDevelop(enum map_id);
	void DoIdle();
	void DoInfect();
	void DoLaunch(int,int,int);
	void DoMove(struct LOCATION);
	void DoSelfDestruct();
	void DoSetLights(int boolOn);
	void DoStop();
	void DoTransfer(int);
	void DoUnIdle();
	enum map_id GetCargo() const;
	enum map_id GetObjectOnPad() const;
	enum map_id GetType() const;
	enum map_id GetWeapon() const;
	int HasOccupiedBay() const;
	int IsBuilding() const;
	int IsBusy() const;
	int IsLive();
	int IsVehicle() const;
	struct LOCATION Location() const;
	int OwnerID() const;
	void PutInGarage(int,int,int);
	void SetCargo(enum map_id cargoType, enum map_id weaponType);
	void SetDamage(int);
	void SetFactoryCargo(int bay, enum map_id unitType, enum map_id weaponType);
	void SetId(int);
	void SetOppFiredUpon(int);
	void SetTruckCargo(enum Truck_Cargo cargoType, int amount);
	void SetWeapon(enum map_id);
	int isDiscovered() const;
	int isEMPed() const;
protected:
	void DoSimpleCommand(int);
private:
	char* StoreSelf(struct CommandPacket &) const;

	int unitID;
};

class OP2 UnitBlock
{
public:
	UnitBlock(struct UnitRecord *);
	class UnitBlock & operator=(class UnitBlock const &);
	int CreateUnits(int, int) const;
private:
	void SortAndInit(struct UnitRecord *);

	int unknown[34];
};



class OP2 _Player
{
public:
	_Player(int);
	class _Player & operator=(class _Player const &);
	void AllyWith(int);
	void CaptureRLV(int);
	void CenterViewOn(int,int);
	int Difficulty() const;
	int FoodStored() const;
	enum FoodStatus FoodSupply() const;
	class ScGroup GetDefaultGroup();
	int GetPlayerStrength(struct MAP_RECT &);
	int GetRLVCount();
	int GetTotalPlayerStrength();
	void GoAI();
	void GoEden();
	void GoHuman();
	void GoPlymouth();
	int HasTechnology(int) const;
	int IsEden();
	int IsHuman();
	int Kids() const;
	void MarkResearchComplete(int);
	enum MoraleLevels MoraleLevel() const;
	int Ore() const;
	int RareOre() const;
	int Scientists() const;
	void SetColorNumber(int);
	void SetDefaultGroup(class ScGroup &);
	void SetFoodStored(int);
	void SetKids(int);
	void SetOre(int);
	void SetRareOre(int);
	void SetScientists(int);
	void SetSolarSat(int);
	void SetTechLevel(int);
	void SetWorkers(int numWorkers);
	int Workers() const;
	int canAccumulateOre();
	int canAccumulateRareOre();
	int canBuildBuilding();
	int canBuildSpace();
	int canBuildVehicle(int);
	int canDoResearch(int);
	int hasActiveCommand();
	int hasVehicle(enum map_id,enum map_id);
	void resetChecks();

private:
	int playerNum, unknown2, unknown3;
};



class OP2 GameMap
{
public:
	class GameMap & operator=(class GameMap const &);
	static int __fastcall GetCellType(struct LOCATION location);
	static int __fastcall GetTile(struct LOCATION location);
	static void __fastcall InitialSetTile(struct LOCATION, int);
	static void __fastcall SetCellType(struct LOCATION, int);
	static void __fastcall SetInitialLightLevel(int);
	static void __fastcall SetLavaPossible(struct LOCATION, int);
	static void __fastcall SetTile(struct LOCATION, int);
	static void __fastcall SetVirusUL(struct LOCATION, int);
};

class OP2 TethysGame
{
public:
	class TethysGame & operator = (class TethysGame const &);
	static void __fastcall AddGameSound(int voiceId, int);
	static void __fastcall AddMapSound(int, struct LOCATION location);
	static void __fastcall AddMessage(int pixelX, int pixelY, char *message, int recipientPlayerNum, int soundToPlay);
	static void __fastcall AddMessage(class Unit, char *message, int recipientPlayerNum, int soundToPlay);
	static int __fastcall CanAllowCheats();
	static int __fastcall CanHaveDisasters();
	static int __fastcall CreateBeacon(enum map_id beaconType, int x, int y, 
			int commonRareType, int barYield, int barVariant);
	static int __fastcall CreateUnit(class Unit &returnedUnit, enum map_id unitType, 
			struct LOCATION location, int playerNum, enum map_id weaponCargoType, int rotation);
	static int __fastcall CreateUnitBlock(class _Player &, char const *text, int);
	static int __fastcall CreateWallOrTube(int x, int y, int, enum map_id wallTubeType);
	static int __fastcall CreateWreck(int x, int y, enum map_id techNum, int boolAllPlayers);
	static struct LOCATION  __fastcall FindEMPMissleTarget(int,int,int,int,int);
	static void __fastcall ForceMoraleGood(int playerNum);
	static void __fastcall ForceMoraleGreat(int playerNum);
	static void __fastcall ForceMoraleOK(int playerNum);
	static void __fastcall ForceMoralePoor(int playerNum);
	static void __fastcall ForceMoraleRotten(int playerNum);
	static void __fastcall FreeMoraleLevel(int playerNum);
	static int __fastcall GetRand(int range);		// Returns a number from 0 to (range-1)
	static int __fastcall InitialUnits();
	static void __fastcall LoadGame(char const *);
	static int __fastcall LocalPlayer();			// Return local player number
	static int __fastcall NoPlayers();				// Returns number of players (including comp)
	static int __fastcall PlaceMarker(class Unit &, int x, int y, int markerType);
	static void __fastcall SaveGame(char const *);
	static void __fastcall SetCheatFastProduction(int);			// Useless
	static void __fastcall SetCheatFastUnits(int);				// Useless
	static void __fastcall SetCheatProduceAll(int);				// Useless
	static void __fastcall SetCheatUnlimitedResources(int);		// Useless
	static void __fastcall SetDaylightEverywhere(int);
	static void __fastcall SetDaylightMoves(int);
	static void __fastcall SetEMPMissile(int launchTileX, int launchTileY, int, int 
			destTileX, int destTileY); // Set third param to 0
	static void __fastcall SetEarthquake(int tileX, int tileY, int);
	static void __fastcall SetEruption(int tileX, int tileY, int);
	static void __fastcall SetLavaSpeed(int);
	static void __fastcall SetLightning(int tileX, int tileY, int duration, int, int);
	static void __fastcall SetMeteor(int tileX, int tileY, int);
	static void __fastcall SetMicrobeSpreadSpeed(int);
	static void __fastcall SetMusicPlayList(int, int, enum SongIds *);
	static void __fastcall SetSeed(unsigned int);				// ?Set random number seed?
	static void __fastcall SetTornado(int tileX, int tileY, int duration, int, int, int boolNoIdea);
	static int __fastcall Tick();
	static int __fastcall Time();
	static int __fastcall UsesDayNight();
	static int __fastcall UsesMorale();
private:
	static void __fastcall sIssueOptPacket(int, int);
};


// *************************** Enumerator Classes ***************************

class OP2 GroupEnumerator
{
public:
	GroupEnumerator(class ScGroup &);
	class GroupEnumerator & operator = (class GroupEnumerator const &);
	int GetNext(class Unit &);
private:
	int unknown;
};

class OP2 PlayerVehicleEnum
{
public:
	PlayerVehicleEnum(int playerNum);
	class PlayerVehicleEnum & operator = (class PlayerVehicleEnum const &);
	int GetNext(class Unit &currentUnit);	// Returns 0 when done
private:
	int unknown;
};

class OP2 PlayerBuildingEnum
{
public:
	PlayerBuildingEnum(int playerNum, map_id buildingType);
	class PlayerBuildingEnum & operator = (class PlayerBuildingEnum const &);
	int GetNext(class Unit &currentUnit);	// Returns 0 when done
private:
	int unknown1, unknown2;
};

class OP2 PlayerUnitEnum
{
public:
	PlayerUnitEnum(int);
	class PlayerUnitEnum & operator = (class PlayerUnitEnum const &);
	int GetNext(class Unit &currentUnit);	// Returns 0 when done
private:
	int unknown1, unknown2;
};

class OP2 ClosestEnumerator
{
public:
	ClosestEnumerator(struct LOCATION const &);
	class ClosestEnumerator & operator = (class ClosestEnumerator const &);
	int GetNext(class Unit &,unsigned long &);
private:
	int unknown[13];
};

class OP2 InRangeEnumerator
{
public:
	InRangeEnumerator(struct LOCATION const &,int);
	class InRangeEnumerator & operator = (class InRangeEnumerator const &);
	int GetNext(class Unit &);
private:
	int unknown[13];
};

class OP2 InRectEnumerator
{
public:
	InRectEnumerator(struct MAP_RECT const &);
	class InRectEnumerator & operator = (class InRectEnumerator const &);
	int GetNext(class Unit &);
private:
	int unknown[13];
};

class OP2 LocationEnumerator
{
public:
	LocationEnumerator(struct LOCATION const &);
	class LocationEnumerator & operator = (class LocationEnumerator const &);
	int GetNext(class Unit &);
private:
	int unknown[13];
};


// ************************* Exported Functions *************************

OP2 class BuildingGroup __fastcall CreateBuildingGroup(class _Player);
OP2 class FightGroup __fastcall CreateFightGroup(class _Player);
OP2 class MiningGroup __fastcall CreateMiningGroup(class _Player);
OP2 class Pinwheel __fastcall CreatePinwheel(class _Player &);

OP2 class Trigger __fastcall CreateSpecialTarget(int, int, class Unit &, enum map_id, char const *);
OP2 class Trigger __fastcall CreateVictoryCondition(int boolEnable, int , class Trigger &victoryTrigger, char const *missionObjective);
OP2 class Trigger __fastcall CreateFailureCondition(int boolEnable, int ignoredParam, class Trigger &failureTrigger, char const *);

OP2 class Trigger __fastcall CreateBuildingCountTrigger(int boolEnable, int boolNoRepeat, int playerNum, int refCount, enum compare_mode, char const *triggerFunction);
OP2 class Trigger __fastcall CreateVehicleCountTrigger(int boolEnable, int boolNoRepeat, int playerNum, int refCount, enum compare_mode compareType, char const *triggerFunction);
OP2 class Trigger __fastcall CreateCountTrigger(int boolEnable, int boolNoRepeat, int playerNum, enum map_id unitType, enum map_id, int refCount, enum compare_mode compareType, char const *triggerFunction);
OP2 class Trigger __fastcall CreateAttackedTrigger(int boolEnable, int boolNoRepeat, class ScGroup &, char const *triggerFunction);
OP2 class Trigger __fastcall CreateDamagedTrigger(int boolEnable, int boolNoRepeat, class ScGroup &, int, char const *triggerFunction);
OP2 class Trigger __fastcall CreateEscapeTrigger(int boolEnable, int boolNoRepeat, int playerNum, int x, int y, int width, int height, int refValue, enum map_id unitType, int cargoType, int unknown, char const *triggerFunction);
OP2 class Trigger __fastcall CreateEvacTrigger(int boolEnable, int boolNoRepeat, int refValue, char const *triggerFunction);
OP2 class Trigger __fastcall CreateKitTrigger(int boolEnable, int boolNoRepeat, int, enum map_id, int, char const *triggerFunction);
OP2 class Trigger __fastcall CreateMidasTrigger(int boolEnable, int boolNoRepeat, int time, char const *triggerFunction);
OP2 class Trigger __fastcall CreateOnePlayerLeftTrigger(int boolEnable, int boolNoRepeat, char const *triggerFunction);
OP2 class Trigger __fastcall CreateOperationalTrigger(int boolEnable, int boolNoRepeat, int playerNum, enum map_id buildingType, int refValue, enum compare_mode compareType, char const *triggerFunction);
OP2 class Trigger __fastcall CreatePointTrigger(int boolEnable, int boolNoRepeat, int playerNum, int x, int y, char const *triggerFunction);
OP2 class Trigger __fastcall CreateRectTrigger(int boolEnable, int boolNoRepeat, int playerNum, int x, int y, int width, int height, char const *triggerFunction);
OP2 class Trigger __fastcall CreateResearchTrigger(int boolEnable, int boolNoRepeat, int techID, int playerNum, char const *triggerFunction);
OP2 class Trigger __fastcall CreateResourceTrigger(int boolEnable, int boolNoRepeat, enum trig_res resourceType, int refAmount, int playerNum, enum compare_mode compareType, char const *triggerFunction);
OP2 class Trigger __fastcall CreateTimeTrigger(int boolEnable, int boolNoRepeat, int timeMin, int timeMax, char const *triggerFunction);
OP2 class Trigger __fastcall CreateTimeTrigger(int boolEnable, int boolNoRepeat, int time, char const *triggerFunction);
OP2 class Trigger __cdecl CreateSetTrigger(int boolEnable, int, int, int, char const *,...);

OP2 void __fastcall GetSpecialTargetData(class Trigger &, class Unit &);
OP2 int __cdecl scr_snprintf(char *writeBuffer, unsigned int bufferLength, char const *formatString, ...);	// See the "snprintf" documentation in C


// ************************* Exported Data *************************

OP2 class _Player Player[7];

#endif	// End of redefinition error protection