#include "general.h"
#include "BuildingRevival.h"

#include "scripts.h"
#include "engine.h"
#include "engine_da.h"
#include "da.h"
#include "GameObjManager.h"

#include "da_chatcommand.h"
#include "da_player.h"

//Chat Command AccessLevel 
int ModLevel = DAAccessLevel::ADMINISTRATOR;

#define GDI 1
#define NOD 0

static const char PowerOnSounds[2][2][50] = {
	{
		"M00EVAN_DSGN0007I1EVAN_snd.wav",
		"M00EVAG_DSGN0003I1EVAG_snd.wav"
	},
	{
		"M00EVAN_DSGN0006I1EVAN_snd.wav",
		"M00EVAG_DSGN0001I1EVAG_snd.wav"
	}
};

static const char PowerOffSounds[2][2][50] = {
	{
		"M00EVAN_DSGN0069I1EVAN_snd.wav",
		"M00EVAG_DSGN0065I1EVAG_snd.wav"
	},
	{
		"M00EVAN_DSGN0068I1EVAN_snd.wav",
		"M00EVAG_DSGN0064I1EVAG_snd.wav"
	}
};

//Revive_Building, dup of Restore_Building with a few other bits
void Revive_Building(GameObject* obj)
{
	if (!obj && !obj->As_BuildingGameObj())
		return;

	BuildingGameObj* building = obj->As_BuildingGameObj();
	if (!building || !building->Is_Destroyed()) {
		return;
	}

	Console_Output("Reviving Building %s\n", building->Get_Definition().Get_Name());
	int Team = building->Get_Player_Type();
	BaseControllerClass *b = BaseControllerClass::Find_Base(Team);
	if (b){
		if (building->As_SoldierFactoryGameObj())
			b->Set_Can_Generate_Soldiers(true);

		if (building->As_VehicleFactoryGameObj())
			b->Set_Can_Generate_Vehicles(true);

		b->Set_Object_Dirty_Bit(NetworkObjectClass::BIT_RARE, true);
	}

	// Set Alive
	building->Set_Is_Destroyed(false);

	// Restore building health
	float max = Commands->Get_Max_Health(building);
	Commands->Set_Health(building, max);

	// Still do this to wake everything up.
	// This is needed to update the state of a building from 'dead' to 'alive on the client
	Commands->Apply_Damage(building, 1.0f, "Explosive", 0);
	Update_Network_Object(building);

	// If we're a Power Plant turn on base power
	if (building->As_BuildingGameObj()->As_PowerPlantGameObj()) Power_Base(Team, true);

	// Set building power
	if (Is_Base_Powered(Team)) { Commands->Set_Building_Power(building, true); }
	else { Commands->Set_Building_Power(building, false); }

}

void Revive_SoliderFactory(int Team)
{
	BuildingGameObj *SF = BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_SOLDIER_FACTORY);
	if (SF->Is_Destroyed()) {
		Revive_Building(SF);
		if (Team == GDI)
		{
			DA::Create_2D_Sound_Team(GDI, "M00BGIB_DSGN0008I1EVAG_SND.wav");
			DA::Create_2D_Sound_Team(NOD, "m00bgib_dsgn0009i1evan_snd.wav");
		}
		else if (Team == NOD)
		{
			DA::Create_2D_Sound_Team(GDI, "m00bnhn_dsgn0015i1evag_snd.wav");
			DA::Create_2D_Sound_Team(NOD, "M00BNHN_DSGN0016I1EVAN_SND.wav");
		}
	}
	else {
		DA::Create_2D_Sound_Team(GDI, PowerOnSounds[Team][1]);
		DA::Create_2D_Sound_Team(NOD, PowerOnSounds[Team][0]);
	}
}

void Revive_PowerPlant(int Team)
{
	BuildingGameObj *PP = BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_POWER_PLANT);
	if (PP->Is_Destroyed()) {
		Revive_Building(PP);
		if (Team == GDI) {
			DA::Create_2D_Sound_Team(GDI, "m00bgpp_dsgn0009i1evag_snd.wav");
			DA::Create_2D_Sound_Team(NOD, "m00bgpp_dsgn0010i1evan_snd.wav");
		}
		else {
			DA::Create_2D_Sound_Team(GDI, "m00bnpp_dsgn0009i1evag_snd.wav");
			DA::Create_2D_Sound_Team(NOD, "m00bnpp_dsgn0010i1evan_snd.wav");
		}
	}
	else {
		DA::Create_2D_Sound_Team(GDI, PowerOnSounds[Team][1]);
		DA::Create_2D_Sound_Team(NOD, PowerOnSounds[Team][0]);
	}
}

void Revive_Conyard(int Team)
{
	BuildingGameObj *CY = (BuildingGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_CONYARD);
	if (CY->Is_Destroyed()) {
		Revive_Building(CY);
		if (Team == GDI) {
			DA::Create_2D_Sound_Team(GDI, "m00bgcy_dsgn0009i1evag_snd.wav");
			DA::Create_2D_Sound_Team(NOD, "m00bgcy_dsgn0010i1evan_snd.wav");
		}
		else {
			DA::Create_2D_Sound_Team(GDI, "m00bncy_dsgn0008i1evag_snd.wav");
			DA::Create_2D_Sound_Team(NOD, "m00bncy_dsgn0009i1evan_snd.wav");
		}
	}
	else {
		DA::Create_2D_Sound_Team(GDI, PowerOnSounds[Team][1]);
		DA::Create_2D_Sound_Team(NOD, PowerOnSounds[Team][0]);
	}
}


void Revive_Refinery(int Team)
{
	BuildingGameObj *REF = BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_REFINERY);
	if (REF->Is_Destroyed()) {
		Revive_Building(REF);
		if (Team == GDI) {
			if (stristr(Commands->Get_Preset_Name(REF), "Silo")) {
				DA::Create_2D_Sound_Team(GDI, "M00BGTS_DSGN0001I1EVAG_SND.wav");
				DA::Create_2D_Sound_Team(NOD, "M00BGTS_DSGN0002I1EVAN_SND.wav");
			}
			else {
				DA::Create_2D_Sound_Team(GDI, "m00bgtr_dsgn0009i1evag_snd.wav");
				DA::Create_2D_Sound_Team(NOD, "m00bgtr_dsgn0010i1evan_snd.wav");
			}
		}
		else {
			if (stristr(Commands->Get_Preset_Name(REF), "Silo")) {
				DA::Create_2D_Sound_Team(GDI, "M00BNTS_DSGN0001I1EVAG_SND.wav");
				DA::Create_2D_Sound_Team(NOD, "M00BNTS_DSGN0002I1EVAN_SND.wav");
			}
			else {
				DA::Create_2D_Sound_Team(GDI, "m00bntr_dsgn0009i1evag_snd.wav");
				DA::Create_2D_Sound_Team(NOD, "m00bntr_dsgn0010i1evan_snd.wav");
			}
		}
	}
	else {
		DA::Create_2D_Sound_Team(GDI, PowerOnSounds[Team][1]);
		DA::Create_2D_Sound_Team(NOD, PowerOnSounds[Team][0]);
	}
}

GameObject *Find_Silo(int Team)
{
	for (SLNode<BuildingGameObj> *z = GameObjManager::BuildingGameObjList.Head(); z; z = z->Next()) {
		BuildingGameObj *SILO = z->Data()->As_BuildingGameObj();
		if (SILO && Get_Object_Type(SILO) == Team) {
			if (stristr(Commands->Get_Preset_Name(SILO), "Silo")) {
				return SILO;
			}
		}
	}
	return 0;
}

void Revive_Silo(int Team)
{
	bool revived = false;
	for (SLNode<BuildingGameObj> *z = GameObjManager::BuildingGameObjList.Head(); z; z = z->Next()) {
		BuildingGameObj *SILO = z->Data()->As_BuildingGameObj();
		if (SILO && Get_Object_Type(SILO) == Team) {
			if (stristr(Commands->Get_Preset_Name(SILO), "Silo")) {
				if (SILO->As_BuildingGameObj()->Is_Destroyed()) {
					revived = true;
					Revive_Building(SILO);
				}
			}
		}
	}
	if (revived == true) {
		if (Team == GDI) {
			DA::Create_2D_Sound_Team(GDI, "M00BGTS_DSGN0001I1EVAG_SND.wav");
			DA::Create_2D_Sound_Team(NOD, "M00BGTS_DSGN0002I1EVAN_SND.wav");
		}
		else
		{
			DA::Create_2D_Sound_Team(GDI, "M00BNTS_DSGN0001I1EVAG_SND.wav");
			DA::Create_2D_Sound_Team(NOD, "M00BNTS_DSGN0002I1EVAN_SND.wav");
		}
	}
}

void Revive_RepairBay(int Team)
{
	BuildingGameObj *RB = BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_REPAIR_BAY);
	if (RB->Is_Destroyed()) {
		Revive_Building(RB);
		if (Team == GDI) {
			//DA::Create_2D_Sound_Team( GDI, "M00BGWF_DSGN0009I1EVAG_SND.wav");
			//DA::Create_2D_Sound_Team( NOD, "m00bgwf_dsgn0010i1evan_snd.wav");
		}
		else {
			//DA::Create_2D_Sound_Team( GDI, "m00bnaf_dsgn0009i1evag_snd.wav");
			//DA::Create_2D_Sound_Team( NOD, "M00BNAF_DSGN0010I1EVAN_SND.wav");
		}
	}
	else {
		DA::Create_2D_Sound_Team(GDI, PowerOnSounds[Team][1]);
		DA::Create_2D_Sound_Team(NOD, PowerOnSounds[Team][0]);
	}
}

void Revive_NavalFactory(int Team)
{
	BuildingGameObj *NF = BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_NAVAL_FACTORY);
	if (NF->Is_Destroyed()) {
		Revive_Building(NF);
		if (Team == GDI) {
			//DA::Create_2D_Sound_Team( GDI, "M00BGWF_DSGN0009I1EVAG_SND.wav");
			//DA::Create_2D_Sound_Team( NOD, "m00bgwf_dsgn0010i1evan_snd.wav");
		}
		else {
			//DA::Create_2D_Sound_Team( GDI, "m00bnaf_dsgn0009i1evag_snd.wav");
			//DA::Create_2D_Sound_Team( NOD, "M00BNAF_DSGN0010I1EVAN_SND.wav");
		}
	}
	else {
		DA::Create_2D_Sound_Team(GDI, PowerOnSounds[Team][1]);
		DA::Create_2D_Sound_Team(NOD, PowerOnSounds[Team][0]);
	}
}

void Revive_AirFactory(int Team)
{
	BuildingGameObj *AF = BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_HELIPAD);
	if (AF->Is_Destroyed()) {
		Revive_Building(AF);
		if (Team == GDI) {
			//DA::Create_2D_Sound_Team( GDI, "M00BGWF_DSGN0009I1EVAG_SND.wav");
			//DA::Create_2D_Sound_Team( NOD, "m00bgwf_dsgn0010i1evan_snd.wav");
		}
		else {
			//DA::Create_2D_Sound_Team( GDI, "m00bnaf_dsgn0009i1evag_snd.wav");
			//DA::Create_2D_Sound_Team( NOD, "M00BNAF_DSGN0010I1EVAN_SND.wav");
		}
	}
	else {
		DA::Create_2D_Sound_Team(GDI, PowerOnSounds[Team][1]);
		DA::Create_2D_Sound_Team(NOD, PowerOnSounds[Team][0]);
	}
}

void Revive_VehicleFactory(int Team)
{
	BuildingGameObj *VF = BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_VEHICLE_FACTORY);
	if (VF->Is_Destroyed()) {
		Revive_Building(VF);
		if (Team == GDI) {
			DA::Create_2D_Sound_Team(GDI, "M00BGWF_DSGN0009I1EVAG_SND.wav");
			DA::Create_2D_Sound_Team(NOD, "m00bgwf_dsgn0010i1evan_snd.wav");
		}
		else {
			DA::Create_2D_Sound_Team(GDI, "m00bnaf_dsgn0009i1evag_snd.wav");
			DA::Create_2D_Sound_Team(NOD, "M00BNAF_DSGN0010I1EVAN_SND.wav");
		}
	}
	else {
		DA::Create_2D_Sound_Team(GDI, PowerOnSounds[Team][1]);
		DA::Create_2D_Sound_Team(NOD, PowerOnSounds[Team][0]);
	}
}


void Revive_Shrine(int Team)
{
	BuildingGameObj *SH = BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_SHRINE);
	if (SH->Is_Destroyed()) {
		Revive_Building(SH);
		if (Team == GDI) {
			DA::Create_2D_Sound_Team(NOD, "m00bgcc_dsgn0002i1evan_snd.wav");
			DA::Create_2D_Sound_Team(GDI, "m00bgcc_dsgn0001i1evag_snd.wav");
		}
		else {
			DA::Create_2D_Sound_Team(NOD, "M00BNsn_DSGN0014I1EVAN_SND.wav");
			DA::Create_2D_Sound_Team(GDI, "m00bnsn_dsgn0013i1evag_snd.wav");
		}
	}
	else {
		DA::Create_2D_Sound_Team(GDI, PowerOnSounds[Team][1]);
		DA::Create_2D_Sound_Team(NOD, PowerOnSounds[Team][0]);
	}
}

void Revive_ComCenter(int Team)
{
	BuildingGameObj *CC = BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_COM_CENTER);
	if (CC->Is_Destroyed()) {
		Revive_Building(CC);
		if (Team == GDI) {
			DA::Create_2D_Sound_Team(NOD, "m00bgcc_dsgn0002i1evan_snd.wav");
			DA::Create_2D_Sound_Team(GDI, "m00bgcc_dsgn0001i1evag_snd.wav");
		}
		else {
			DA::Create_2D_Sound_Team(NOD, "m00bncc_dsgn0010i1evan_snd.wav");
			DA::Create_2D_Sound_Team(GDI, "m00bncc_dsgn0009i1evag_snd.wav");
		}
	}
	else {
		DA::Create_2D_Sound_Team(GDI, PowerOnSounds[Team][1]);
		DA::Create_2D_Sound_Team(NOD, PowerOnSounds[Team][0]);
	}
}

void Revive_BaseDefense(int Team) {
	BuildingGameObj *BD = (BuildingGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_BASE_DEFENSE);
	if (BD->Is_Destroyed()) {
		Revive_Building(BD);
		if (Team == GDI) {
			DA::Create_2D_Sound_Team(NOD, "m00bgat_dsgn0008i1evan_snd.wav");
			DA::Create_2D_Sound_Team(GDI, "m00bgat_dsgn0007i1evag_snd.wav");
		}
		else
		{
			DA::Create_2D_Sound_Team(NOD, "m00bnol_dsgn0008i1evan_snd.wav");
			DA::Create_2D_Sound_Team(GDI, "m00bnol_dsgn0007i1evag_snd.wav");
		}
	}
	else {
		DA::Create_2D_Sound_Team(GDI, PowerOnSounds[Team][1]);
		DA::Create_2D_Sound_Team(NOD, PowerOnSounds[Team][0]);
	}
}

void Destroy_BaseDefense(int Team) {
	for (SLNode<BuildingGameObj> *z = GameObjManager::BuildingGameObjList.Head(); z; z = z->Next()) {
		BuildingGameObj *Defense = z->Data()->As_BuildingGameObj();
		if (Defense && Building_Type(Defense) == TYPE_BASE_DEFENSE && Get_Object_Type(Defense) == Team)
			Commands->Apply_Damage(Defense, 9999.9f, "None", 0);
	}
}

void Destroy_Buildings()
{
	for (SLNode<BuildingGameObj> *z = GameObjManager::BuildingGameObjList.Head(); z; z = z->Next()) {
		BuildingGameObj *Building = z->Data()->As_BuildingGameObj();
		Commands->Apply_Damage(Building, 9999.9f, "None", 0);
		//Commands->Destroy_Object(o);
	}
}
///////////////////////////////////////////////////////////////////////
//Let Dragonade handle Creation/Destruction of chat/console commands.
///////////////////////////////////////////////////////////////////////

class DESTROYBUILDINGSCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Destroy_Buildings();
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYBUILDINGSCommand, "!destroybuildings");


class REVIVEBARCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		//DA::Host_Message("Player Access Level is %d mode level is %d", Player->Get_DA_Player()->Get_Access_Level(), ModLevel);
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_SoliderFactory(GDI);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEBARCommand, "!revivebar");

class REVIVEBARConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivebar"; }
	const char *Get_Alias() { return "rb"; }
	const char* Get_Help() { return "REVIVEBAR - Revives the GDI Barracks."; }
	void Activate(const char *ArgumentsString) {
		Revive_SoliderFactory(GDI);
	}
};
Register_Console_Function(REVIVEBARConsole);

class REVIVEHONCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_SoliderFactory(NOD);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEHONCommand, "!revivehon");

class REVIVEHONConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivehon"; }
	const char *Get_Alias() { return "rh"; }
	const char* Get_Help() { return "REVIVEHON - Revives the Hand of Nod."; }
	void Activate(const char *ArgumentsString) {
		Revive_SoliderFactory(NOD);
	}
};
Register_Console_Function(REVIVEHONConsole);

class REVIVEGDIPPCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_PowerPlant(GDI);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEGDIPPCommand, "!revivegdipp");

class REVIVEGDIPPConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivegdipp"; }
	const char *Get_Alias() { return "rgpp"; }
	const char* Get_Help() { return "REVIVEGDIPP - Revives the GDI Power Plant."; }
	void Activate(const char *ArgumentsString) {
		Revive_PowerPlant(GDI);
	}
};
Register_Console_Function(REVIVEGDIPPConsole);

class REVIVENODPPCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_PowerPlant(NOD);
		return false;
	}
};

Register_Simple_Chat_Command(REVIVENODPPCommand, "!revivenodpp");

class REVIVENODPPConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivenodpp"; }
	const char *Get_Alias() { return "rnpp"; }
	const char* Get_Help() { return "REVIVENODPP - Revives the Nod Power Plant."; }
	void Activate(const char *ArgumentsString) {
		Revive_PowerPlant(NOD);
	}
};
Register_Console_Function(REVIVENODPPConsole);

class REVIVEGDICYCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_Conyard(GDI);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEGDICYCommand, "!revivegdicy");

class REVIVEGDICYConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivegdicy"; }
	const char *Get_Alias() { return "rgcy"; }
	const char* Get_Help() { return "REVIVEGDICY - Revives the GDI Construction Yard."; }
	void Activate(const char *ArgumentsString) {
		Revive_Conyard(GDI);
	}
};
Register_Console_Function(REVIVEGDICYConsole);

class REVIVENODCYCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_Conyard(NOD);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVENODCYCommand, "!revivenodcy");

class REVIVENODCYConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivenodcy"; }
	const char *Get_Alias() { return "rncy"; }
	const char* Get_Help() { return "REVIVENODCY - Revives the Nod Construction Yard."; }
	void Activate(const char *ArgumentsString) {
		Revive_Conyard(NOD);
	}
};
Register_Console_Function(REVIVENODCYConsole);

class REVIVEGDIREFCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_Refinery(GDI);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEGDIREFCommand, "!revivegdiref");


class REVIVEGDIREFConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivegdiref"; }
	const char *Get_Alias() { return "rgref"; }
	const char* Get_Help() { return "REVIVEGDIREF - Revives the GDI Refinery."; }
	void Activate(const char *ArgumentsString) {
		Revive_Refinery(GDI);
	}
};
Register_Console_Function(REVIVEGDIREFConsole);

class REVIVENODREFCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_Refinery(NOD);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVENODREFCommand, "!revivenodref");

class REVIVENODREFConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivenodref"; }
	const char *Get_Alias() { return "rnref"; }
	const char* Get_Help() { return "REVIVENODREF - Revives the Nod Refinery."; }
	void Activate(const char *ArgumentsString) {
		Revive_Refinery(NOD);
	}
};
Register_Console_Function(REVIVENODREFConsole);

class REVIVEGDISILOCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_Silo(GDI);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEGDISILOCommand, "!revivegdisilo");

class REVIVEGDISILOConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivegdisilo"; }
	const char *Get_Alias() { return "rgsilo"; }
	const char* Get_Help() { return "REVIVEGDISILO - Revives the GDI Silo."; }
	void Activate(const char *ArgumentsString) {
		Revive_Silo(GDI);
	}
};
Register_Console_Function(REVIVEGDISILOConsole);

class REVIVENODSILOCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_Silo(NOD);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVENODSILOCommand, "!revivenodsilo");


class REVIVENODSILOConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivenodsilo"; }
	const char *Get_Alias() { return "rnsilo"; }
	const char* Get_Help() { return "REVIVENODSILO - Revives the Nod Silo."; }
	void Activate(const char *ArgumentsString) {
		Revive_Silo(NOD);
	}
};
Register_Console_Function(REVIVENODSILOConsole);

class REVIVEGDIREPAIRBAYCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_RepairBay(GDI);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEGDIREPAIRBAYCommand, "!revivegdirepair");


class REVIVEGDIREPAIRBAYConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivegdirepbay"; }
	const char *Get_Alias() { return "rgrb"; }
	const char* Get_Help() { return "REVIVEGDIREPBAY - Revives the GDI Repair Bay."; }
	void Activate(const char *ArgumentsString) {
		Revive_RepairBay(GDI);
	}
};
Register_Console_Function(REVIVEGDIREPAIRBAYConsole);

class REVIVENODREPAIRBAYCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_RepairBay(NOD);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVENODREPAIRBAYCommand, "!revivegdirepair");


class REVIVENODREPAIRBAYConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivenodrepbay"; }
	const char *Get_Alias() { return "rnrb"; }
	const char* Get_Help() { return "REVIVENODREPBAY - Revives the Nod Repair Bay."; }
	void Activate(const char *ArgumentsString) {
		Revive_RepairBay(NOD);
	}
};
Register_Console_Function(REVIVENODREPAIRBAYConsole);

class REVIVEGDISHRINECommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_Shrine(GDI);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEGDISHRINECommand, "!revivegdishrine");


class REVIVEGDISHRINEConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivegdishrine"; }
	const char *Get_Alias() { return "rnshrine"; }
	const char* Get_Help() { return "REVIVEGDISHRINE - Revives the GDI Superweapon Facility."; }
	void Activate(const char *ArgumentsString) {
		Revive_Shrine(GDI);
	}
};
Register_Console_Function(REVIVEGDISHRINEConsole);

class REVIVENODSHRINECommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_Shrine(NOD);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVENODSHRINECommand, "!revivenodshrine");


class REVIVENODSHRINEConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivenodshrine"; }
	const char *Get_Alias() { return "rnshrine"; }
	const char* Get_Help() { return "REVIVENODSHRINE - Revives the GDI Superweapon Facility."; }
	void Activate(const char *ArgumentsString) {
		Revive_Shrine(NOD);
	}
};
Register_Console_Function(REVIVENODSHRINEConsole);


class REVIVEWFCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_VehicleFactory(GDI);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEWFCommand, "!revivewf");

class REVIVEWFConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivewf"; }
	const char *Get_Alias() { return "rwf"; }
	const char* Get_Help() { return "REVIVEWF - Revives the GDI Weapons Factory."; }
	void Activate(const char *ArgumentsString) {
		Revive_VehicleFactory(GDI);
	}
};
Register_Console_Function(REVIVEWFConsole);

class REVIVEAIRCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_VehicleFactory(NOD);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEAIRCommand, "!reviveair");

class REVIVEAIRConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "reviveair"; }
	const char *Get_Alias() { return "rair"; }
	const char* Get_Help() { return "REVIVEAIR - Revives the Nod Airstrip."; }
	void Activate(const char *ArgumentsString) {
		Revive_VehicleFactory(NOD);
	}
};
Register_Console_Function(REVIVEAIRConsole);

class REVIVEGDICCCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_ComCenter(GDI);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEGDICCCommand, "!revivegdicc");

class REVIVEGDICCConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivegdicc"; }
	const char *Get_Alias() { return "rgcc"; }
	const char* Get_Help() { return "REVIVEGDICC - Revives the GDI Communications Center."; }
	void Activate(const char *ArgumentsString) {
		Revive_VehicleFactory(GDI);
	}
};
Register_Console_Function(REVIVEGDICCConsole);

class REVIVENODCCCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_ComCenter(NOD);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVENODCCCommand, "!revivenodcc");

class REVIVENODCCConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "revivenodcc"; }
	const char *Get_Alias() { return "rncc"; }
	const char* Get_Help() { return "REVIVENODCC - Revives the Nod Communications Center."; }
	void Activate(const char *ArgumentsString) {
		Revive_ComCenter(NOD);
	}
};
Register_Console_Function(REVIVENODCCConsole);

class REVIVEAGTCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_BaseDefense(GDI);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEAGTCommand, "!reviveagt");

class REVIVEAGTConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "reviveagt"; }
	const char *Get_Alias() { return "ragt"; }
	const char* Get_Help() { return "REVIVEAGT - Revives the GDI Advanced Guard Tower."; }
	void Activate(const char *ArgumentsString) {
		Revive_BaseDefense(GDI);
	}
};
Register_Console_Function(REVIVEAGTConsole);

class REVIVEOBCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Revive_BaseDefense(NOD);
		return false;
	}
};
Register_Simple_Chat_Command(REVIVEOBCommand, "!reviveob");

class REVIVEOBConsole : public ConsoleFunctionClass {
public:
	const char *Get_Name() { return "reviveob"; }
	const char *Get_Alias() { return "rob"; }
	const char* Get_Help() { return "REVIVEOB - Revives the Nod Obelisk."; }
	void Activate(const char *ArgumentsString) {
		Revive_BaseDefense(NOD);
	}
};
Register_Console_Function(REVIVEOBConsole);

////////////////////////////////////////////////////////
//Destroy Building Commands
/////////////////////////////////////////////////////////

class DESTROYBARCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Soldier_Factory(GDI), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYBARCommand, "!destroybar");

class DESTROYHONCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Soldier_Factory(NOD), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYHONCommand, "!destroyhon");

class DESTROYGDIPPCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Power_Plant(GDI), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYGDIPPCommand, "!destroygdipp");

class DESTROYNODPPCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Power_Plant(NOD), 9999.9f, "None", 0);
		return false;
	}
};

Register_Simple_Chat_Command(DESTROYNODPPCommand, "!destroynodpp");

class DESTROYGDICYCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Construction_Yard(GDI), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYGDICYCommand, "!destroygdicy");

class DESTROYNODCYCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Construction_Yard(NOD), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYNODCYCommand, "!destroynodcy");

class DESTROYGDIREFCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Refinery(GDI), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYGDIREFCommand, "!destroygdiref");

class DESTROYNODREFCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Refinery(NOD), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYNODREFCommand, "!destroynodref");

class DESTROYGDISILOCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Silo(GDI), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYGDISILOCommand, "!destroygdisilo");

class DESTROYNODSILOCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Silo(NOD), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYNODSILOCommand, "!destroynodsilo");

class DESTROYGDIREPAIRBAYCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Repair_Bay(GDI), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYGDIREPAIRBAYCommand, "!destroygdirepair");

class DESTROYNODREPAIRBAYCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Repair_Bay(NOD), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYNODREPAIRBAYCommand, "!destroynodrepair");

class DESTROYGDISHRINECommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Shrine(GDI), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYGDISHRINECommand, "!destroygdishrine");

class DESTROYNODSHRINECommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Shrine(NOD), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYNODSHRINECommand, "!destroynodshrine");

class DESTROYWFCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Vehicle_Factory(GDI), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYWFCommand, "!destroywf");


class DESTROYAIRCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Vehicle_Factory(NOD), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYAIRCommand, "!destroyair");

class DESTROYGDICCCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Com_Center(GDI), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYGDICCCommand, "!destroygdicc");

class DESTROYNODCCCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Commands->Apply_Damage(Find_Com_Center(NOD), 9999.9f, "None", 0);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYNODCCCommand, "!destroynodcc");

class DESTROYAGTCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Destroy_BaseDefense(GDI);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYAGTCommand, "!destroyagt");

class DESTROYOBCommand : public DAChatCommandClass {
	bool Activate(cPlayer *Player, const DATokenClass &Text, TextMessageEnum ChatType) {
		if (Player->Get_DA_Player()->Get_Access_Level() < ModLevel) { return false; }
		Destroy_BaseDefense(NOD);
		return false;
	}
};
Register_Simple_Chat_Command(DESTROYOBCommand, "!destroyob");

////////////////////////////////////////
//Useful info so leave as comments
///////////////////////////////////////

/*
Find_Building_By_Type(int Team)

GameObject SCRIPTS_API *Find_Power_Plant(int Team)
BuildingConstants::TYPE_POWER_PLANT

GameObject SCRIPTS_API *Find_Construction_Yard(int Team)
BuildingConstants::TYPE_CONYARD

GameObject SCRIPTS_API *Find_Refinery(int Team)
BuildingConstants::TYPE_REFINERY

GameObject SCRIPTS_API *Find_Repair_Bay(int Team)
BuildingConstants::TYPE_REPAIR_BAY

GameObject SCRIPTS_API *Find_Soldier_Factory(int Team)
BuildingConstants::TYPE_SOLDIER_FACTORY

GameObject SCRIPTS_API *Find_Vehicle_Factory(int Team)
BuildingConstants::TYPE_VEHICLE_FACTORY

GameObject SCRIPTS_API *Find_Shrine(int Team)
BuildingConstants::TYPE_SHRINE

GameObject SCRIPTS_API *Find_Helipad(int Team)
BuildingConstants::TYPE_HELIPAD

GameObject SCRIPTS_API *Find_Tech_Center(int Team)
BuildingConstants::TYPE_TECH_CENTER

GameObject SCRIPTS_API *Find_Naval_Factory(int Team)
BuildingConstants::TYPE_NAVAL_FACTORY

GameObject SCRIPTS_API *Find_Special(int Team)
BuildingConstants::TYPE_SPECIAL

GameObject SCRIPTS_API *Find_Com_Center(int Team)
BuildingConstants::TYPE_COM_CENTER

BuildingConstants::TYPE_BASE_DEFENSE
*/

/*
virtual	BuildingGameObj	*		As_BuildingGameObj( void )			{ return this; }
virtual	DamageableGameObj	*		As_DamageableGameObj( void )		{ return this; }
virtual	PowerPlantGameObj *		As_PowerPlantGameObj (void)		{ return NULL; }
virtual	SoldierFactoryGameObj *	As_SoldierFactoryGameObj (void)	{ return NULL; }
virtual	VehicleFactoryGameObj *	As_VehicleFactoryGameObj (void)	{ return NULL; }
virtual	AirStripGameObj *			As_AirStripGameObj (void)			{ return NULL; }
virtual	WarFactoryGameObj *		As_WarFactoryGameObj (void)		{ return NULL; }
virtual	RefineryGameObj *			As_RefineryGameObj (void)			{ return NULL; }
virtual	ComCenterGameObj *		As_ComCenterGameObj (void)			{ return NULL; }
virtual	RepairBayGameObj *		As_RepairBayGameObj (void)			{ return NULL; }
*/

//Find all them buildings!!
/*
AirFactoryGameObj *AF = (AirFactoryGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_HELIPAD);
NavalFactoryGameObj *NF = (NavalFactoryGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_NAVAL_FACTORY);
VehicleFactoryGameObj *VF = (VehicleFactoryGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_VEHICLE_FACTORY);
SoldierFactoryGameObj *SF = (SoldierFactoryGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_SOLDIER_FACTORY);
PowerPlantGameObj *PP = (PowerPlantGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_POWER_PLANT);
RefineryGameObj *REF = (RefineryGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_REFINERY);
ComCenterGameObj *CC = (ComCenterGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_COM_CENTER);
RepairBayGameObj *RB = (RepairBayGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_REPAIR_BAY);
BuildingGameObj *BD = (RepairBayGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_BASE_DEFENSE);
BuildingGameObj *CY = (BuildingGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_CONYARD);
BuildingGameObj *SH = (BuildingGameObj*)BaseControllerClass::Find_Base(Team)->Find_Building(BuildingConstants::TYPE_SHRINE);
*/