2 team Capture the Bag

/*

	Zombie Grinder
	Copyright (C) 2012 Binary Phoenix

	This software is provided 'as-is' with no warrenty, either expressed
	Or implied. Any problems Or errors resulting from the use of this
	software is entirely at your risk. You assume all neccessary costs
	of repairs, servicing Or correction.

*/

// To make a CTB map you need to make sure several things exist in the map;
//
// - Each player needs to be contained in a small area with a door, the door
//   must be set to locked and must be named PlayerXPenDoor (with X changed
//   for the name).
//
// - There must be one bag pickup in the map!
//
// - There must be a touch trigger by for a zone for each player to deposit
//   a bag. This zone must have event OnPlayerXDrop, and must
//   be set to only trigger when the correct player is on it.

// ------------------------------------------------------------
// Game Mode Properties.
// ------------------------------------------------------------
var Name 	= "Capture The Bag";
var Description = "First team to capture 5 bags!";

// ------------------------------------------------------------
// Resources
// ------------------------------------------------------------
var bagHUDImage = LoadAnimImage("pak::Bin\\Graphics\\HUD\\Game Modes\\Capture The Bag\\bags.png", 11, 14, 1, 1);

var captureLoseSound = LoadSound("pak::Bin\\Audio\\SFX\\Game Modes\\Capture The Bag\\capture_lose.wav", 0);
var captureWinSound = LoadSound("pak::Bin\\Audio\\SFX\\Game Modes\\Capture The Bag\\capture_win.wav", 0);
var gameLoseSound = LoadSound("pak::Bin\\Audio\\SFX\\Game Modes\\Capture The Bag\\lose.wav", 0);
var gameWinSound = LoadSound("pak::Bin\\Audio\\SFX\\Game Modes\\Capture The Bag\\win.wav", 0);

// ------------------------------------------------------------
// Variables!
// ------------------------------------------------------------
const DIFFICULTY_CURVE = 1.5;

const BAG_BLINK_INTERVAL = 150;

const ROUND_START_DELAY = 10000.0;
const OPEN_DOOR_DELAY = 3000.0;
const RESTART_MAP_DELAY = 15000.0;
const RESPAWN_BAG_DELAY = 15000.0;

const RESPAWN_DELAY = 3000.0;

const MIN_PLAYERS = 2;
const MAX_PLAYERS = 16;

const ROUND_COUNT = 5;

var player1PenDoor;
var player2PenDoor;
// var player3PenDoor;
// var player4PenDoor;

var roundStartTimer;

var InRound;

var OpenDoorTimer;
var DoorsOpen;
var WaitingForDoorOpen;

var GameOver;
var RestartTimer;
var WinningClient;

var RespawnBagTimer;
var RespawnBag;

var BagRespawnDelayTimer;
var BagAvailOld;

var oldScore;
var oldTotalScore;

var oldGameOver;

var clientEverBeenAlive;

var LocalKilled;
var LocalKillTimer;

var arrowObjective;
var oldObjectiveTarget;

// ------------------------------------------------------------
// General functionality :3
// ------------------------------------------------------------
function OpenDoors()
{
	if (player1PenDoor != NULL)
	{
		SetDoorLocked(player1PenDoor, false);
		SetDoorAlwaysOpen(player1PenDoor, true);
	}
	if (player2PenDoor != NULL)
	{
		SetDoorLocked(player2PenDoor, false);
		SetDoorAlwaysOpen(player2PenDoor, true);
	}
	/*
	if (player3PenDoor != NULL)
	{
		SetDoorLocked(player3PenDoor, false);
		SetDoorAlwaysOpen(player3PenDoor, true);
	}
	if (player4PenDoor != NULL)
	{
		SetDoorLocked(player4PenDoor, false);
		SetDoorAlwaysOpen(player4PenDoor, true);
	}
	*/

	DoorsOpen = true;
}

function AwardScore(client)
{
	var bag = GetClientInventoryItem(client, "TBagPickup");
	RemoveClientInventoryItem(client, bag);

	var score = GetClientScore(client) + 1;
	SetClientScore(client, score);

	// Time delay for respawn.
	RespawnBagTimer = Millisecs();
	RespawnBag = bag;

	var teamName = "";
	switch (GetClientTeamID(client))
	{
		case 0:
			teamName = "[c=248,0,0]Red[/c] team";
			break;
		case 1:
			teamName = "[c=24,128,248]Blue[/c] team";
			break;
		/*
		case 2:
			teamName = "[c=16,168,64]Green[/c] team";
			break;
		case 3:
			teamName = "[c=255,240,25]Yellow[/c] team";
			break;
		*/
	}
	BroadcastChat(teamName+" captured the bag!", -1, -1, 2);

	if (GetTeamScore(GetClientTeamID(client)) >= ROUND_COUNT)
	{
		BroadcastChat(teamName+" wins the game!", -1, -1, 2);
		GameFinished();
	}
}

function GameFinished()
{
	InRound = false;
	WaitingForDoorOpen = false;
	GameOver = true;
	RestartTimer = Millisecs();

	// Despawn all the players!
	for (var i = 0; i < GetClientCount(); i++)
	{
		var client = GetClientByIndex(i);
		if (!IsClientDead(client))
		{
			KillClient(client);
		}
	}
}

function StartRound()
{
	// Respawn all the players!
	for (var i = 0; i < GetClientCount(); i++)
	{
		var client = GetClientByIndex(i);
		if (IsClientDead(client))
		{
			RespawnClient(client);
		}
	}

	InRound = true;
	WaitingForDoorOpen = true;

	OpenDoorTimer = Millisecs();
}

function RestartMap()
{
	RestartCurrentMap();
}

// ------------------------------------------------------------
// Events to track when shit happens :3.
// ------------------------------------------------------------
event OnPlayer1Drop(invoker, extra)
{
	if (extra != NULL)
	{
		if (CountClientInventory(extra, "TBagPickup") > 0)
		{
			AwardScore(extra);
		}
	}
}
event OnPlayer2Drop(invoker, extra)
{
	if (extra != NULL)
	{
		if (CountClientInventory(extra, "TBagPickup") > 0)
		{
			AwardScore(extra);
		}
	}
}
/*
event OnPlayer3Drop(invoker, extra)
{
	if (extra != NULL)
	{
		if (CountClientInventory(extra, "TBagPickup") > 0)
		{
			AwardScore(extra);
		}
	}
}
event OnPlayer4Drop(invoker, extra)
{
	if (extra != NULL)
	{
		if (CountClientInventory(extra, "TBagPickup") > 0)
		{
			AwardScore(extra);
		}
	}
}
*/

event OnPlayerKilled(client, weapon, zombie)
{
	var bag = GetClientInventoryItem(client, "TBagPickup");
	if (IsServer())
	{
		if (bag != NULL)
		{
			RemoveClientInventoryItem(client, bag);
		}
	}

	// Time delay for respawn.
	if (RespawnBag == NULL && bag != NULL)
	{
		RespawnBagTimer = Millisecs();
		RespawnBag = bag;
	}

	if (client == GetLocalClient())
	{
		LocalKilled = true;
		LocalKillTimer = millisecs();
	}
}

event OnClientDisconnect(client)
{
	var bag = GetClientInventoryItem(client, "TBagPickup");
	if (IsServer())
	{
		if (bag != NULL)
		{
			RemoveClientInventoryItem(client, bag);
		}
	}

	// Time delay for respawn.
	if (RespawnBag == NULL && bag != NULL)
	{
		RespawnBagTimer = Millisecs();
		RespawnBag = bag;
	}
}

// ------------------------------------------------------------
// Start of game mode. Disable all zombies until our waves start!
// ------------------------------------------------------------
event OnInit()
{
	player1PenDoor = FindEntityByName("player1PenDoor");
	player2PenDoor = FindEntityByName("player2PenDoor");
	// player3PenDoor = FindEntityByName("player3PenDoor");
	// player4PenDoor = FindEntityByName("player4PenDoor");

	SetDifficultyCurve			(DIFFICULTY_CURVE);
	SetObjectiveHUDText			("Capture The Bag", 0.0);
	SetShowScoreHUD				(false);
	SetShowRemotePlayerStatsHUD	(false);
	SetFriendlyFire				(true);
	SetManualSpawning			(true);
	SetManualDeathScreen		(false);
	SetDrawPlayerCompassPips	(false);
	SetSpawnFodderZombies		(false);
	SetSpawnGroundZombies		(false);
	SetSpawnZombies				(false);
	SetPVP						(true);
	SetTeamBased				(true);
	SetAllowRevives				(false);
	SetTeamCount				(2);
	DisableRoomGrid();

	roundStartTimer = Millisecs();

	SetLocalCompassTarget(NULL);
}

// ------------------------------------------------------------
// Update wave each frame :3
// ------------------------------------------------------------
event OnTick()
{
	var client;
	var i;
	var hasBag 	= false;
	var otherHasBag = false;

	// Start round?
	if (IsServer())
	{
		if (InRound == false)
		{
			if (GameOver == false)
			{
				if ((millisecs() - roundStartTimer > ROUND_START_DELAY && GetClientCount() >= MIN_PLAYERS && GetActiveTeamCount() >= 2) || (GetClientCount() >= MAX_PLAYERS && GetActiveTeamCount() >= 2))
				{
					StartRound();
				}
			}
			else
			{
				SetGameOver(true);
				if (millisecs() - RestartTimer > RESTART_MAP_DELAY)
				{
					RestartMap();
				}
			}
		}
		else
		{
			if (WaitingForDoorOpen == true && DoorsOpen == false && (Millisecs() - OpenDoorTimer) > OPEN_DOOR_DELAY)
			{
				OpenDoors();
			}

			if (RespawnBag != NULL && millisecs() - RespawnBagTimer > RESPAWN_BAG_DELAY)
			{
				RespawnPickup(RespawnBag);
				RespawnBag = NULL;
			}

			// Respawn players.
			for (i = 0; i < GetClientCount(); i++)
			{
				client = GetClientByIndex(i);
				if (IsClientDead(client))
				{
					var respawnTimer = (millisecs() - GetClientDeathTime(client));
					if (respawnTimer > RESPAWN_DELAY)
					{
						RespawnClient(client);
					}
				}
			}
		}
	}
	else
	{
		// Work out how long till bag respawns.
		var localClient	= GetLocalClient();
		var ourTeamID = GetClientTeamID(localClient);
		var pickupAvail = PickupAvailable("TBagPickup");
		var secsRemainTillSpawn = 0;
		var playerWithBag;
		var ourTeamHasBag;

		if (BagAvailOld != pickupAvail)
		{
			BagRespawnDelayTimer = millisecs();
		}
		if (pickupAvail == false)
		{
			secsRemainTillSpawn = (RESPAWN_BAG_DELAY - (millisecs() - BagRespawnDelayTimer)) / 1000;
		}

		// Do other players have the bag at the moment?
		for (i = 0; i < GetClientCount(); i++)
		{
			client = GetClientByIndex(i);
			var clientTeamID = GetClientTeamID(client);
			var count = (CountClientInventory(client, "TBagPickup") > 0);
			if (count > 0)
			{
				if (ourTeamID == clientTeamID)
				{
					ourTeamHasBag = true;
				}

				if (client == localClient)
				{
					hasBag = true;
				}
				else
				{
					otherHasBag = true;
					playerWithBag = GetClientPlayer(client);
				}
			}
			if (GetTeamScore(clientTeamID) >= ROUND_COUNT)
			{
				GameOver = true;
				WinningClient = client;
			}
		}

		// Did another play get a bag? :(
		var totalScore = GetTotalScore();
		var score = GetTeamScore(ourTeamID);
		if (score != oldScore)
		{
			PlaySound(captureWinSound);
		}
		else
		{
			if (totalScore > oldTotalScore)
			{
				PlaySound(captureLoseSound);
			}
		}
		oldScore = score;
		oldTotalScore = totalScore;

		if (GameOver == true)
		{
			SetGameOver(true);
		}

		if (GameOver == true && GameOver != OldGameOver)
		{
			if (GetClientTeamID(WinningClient) == ourTeamID)
			{
				PlaySound(gameWinSound);
			}
			else
			{
				PlaySound(gameLoseSound);
			}
		}
		OldGameOver = GameOver;

		var objectiveTarget = NULL;
		if (GameOver == true || ClientEverBeenAlive == false)
		{
			SetObjectiveHUDText("", 0.0);
		}
		else if (hasBag == true)
		{
			SetObjectiveHUDText("[c=128,255,128]Return To Your Base[/c]", 0.0);
			objectiveTarget = FindEntityByName("player"+(GetClientTeamID(localClient) + 1)+"PenDoor");
		}
		else if (ourTeamHasBag == true)
		{
			SetObjectiveHUDText("[c=128,255,128]Protect The Bag Carrier[/c]", 0.0);
			objectiveTarget = playerWithBag;
		}
		else if (otherHasBag == true)
		{
			SetObjectiveHUDText("[c=255,128,128]Retrieve The Bag![/c]", 0.0);
			objectiveTarget = playerWithBag;
		}
		else if (pickupAvail == false)
		{
			SetObjectiveHUDText("Bag Respawning In "+ceil(abs(secsRemainTillSpawn))+" ...", 0.0);
		}
		else
		{
			SetObjectiveHUDText("[c=128,128,255]Capture The Bag[/c]", 0.0);
			objectiveTarget = FindEntityByType("TBagPickup");
		}

		// Objective target changed?
		if (objectiveTarget != oldObjectiveTarget)
		{
			SetLocalCompassTarget(objectiveTarget);
		}
		oldObjectiveTarget = objectiveTarget;
	}
}

// ------------------------------------------------------------
// Render the CTF hud.
// ------------------------------------------------------------
event OnRenderClientHUD(client, absX, x, y, width, height)
{
	var localClient      = GetLocalClient();
	var clientID 	     = GetClientID(client);
	var nonLocalClientID = GetClientTeamID(client);
	var clientTeamID     = GetClientTeamID(localClient);
	var clientTeamScore  = GetTeamScore(clientTeamID);

	var carryingBag	     = false;//(CountClientInventory(client, "TBagPickup") > 0);

	for (i = 0; i < GetClientCount(); i++)
	{
		var other 	= GetClientByIndex(i);
		var teamID 	= GetClientTeamID(other);
		if (teamID == clientTeamID)
		{
			var count = (CountClientInventory(other, "TBagPickup") > 0);
			if (count > 0)
			{
				carryingBag = true;
			}
		}
	}

	// DRAW MONIES!
	for (var i = 0; i < ROUND_COUNT; i++)
	{
		var drawx, drawy;

		// We have to draw our local clients moniez a bit higher and right aligned.
		if (client == localClient)
		{
			drawx = ((x + width) - 2) - ((ROUND_COUNT - i) * (ImageWidth(bagHUDImage) - 1));
			drawy = (y - 12) - ImageHeight(bagHUDImage);
		}
		else
		{
			drawx = x + (i * (ImageWidth(bagHUDImage) - 1));
			drawy = (y + height) - ImageHeight(bagHUDImage);
		}

		if (i < clientTeamScore)
		{
			DrawImage(bagHUDImage, drawx, drawy, nonLocalClientID + 1);
		}
		else
		{
			if (i == clientTeamScore && carryingBag == true)
			{
				if ((Millisecs() / BAG_BLINK_INTERVAL) % 2 == 0)
				{
					DrawImage(bagHUDImage, drawx, drawy, nonLocalClientID + 1);
				}
				else
				{
					DrawImage(bagHUDImage, drawx, drawy, 0);
				}
			}
			else
			{
				DrawImage(bagHUDImage, drawx, drawy, 0);
			}
		}
	}

	// Draw game over screen?
	if ((GameOver == true && WinningClient != NULL) == false && IsClientDead(localClient) == false)
	{
		LocalKilled = false;
		ClientEverBeenAlive = true;
	}
}