WormbotReporter.MutWormbot

/******************************************************************************
Copyright (c) 2005-2006 by Wormbo <wormbo@onlinehome.de>
$Id$

Wormbo's IRC Reporter Bot.
******************************************************************************/


class MutWormbot extends Mutator
		dependson(WIR_IRCConnection);


//=============================================================================
// Structs
//=============================================================================

struct TItemName {
	var config name   ItemClass;
	var config string ItemName;
	var config bool   Important;
	var config byte   IRCColor;
};

struct TPickupBase {
	var xPickupBase Base;
	var string      LocationName;
};

struct TPlayerInfo {
	var Controller Player;
	var bool bWasSpectator;
	var TeamInfo LastTeam;
	var PlayerReplicationInfo PRI;
	var string LastName;
	var int LastScore;
	var int FlakKills;
	var int ComboKills;
	var int HeadshotKills;
	var int RunoverKills;
	var int ScoringSpree;
};

struct TCustomDisconnect {
	var Controller Player;
	var string     Reason;
};

struct TAmpRun {
	var Pawn Player;
	var float StartTime;
	var int Kills;
};


//=============================================================================
// Localization
//=============================================================================

// for reporter bot
var localized string MsgGameReset;
var localized string MsgGameRoundEnded;
var localized string MsgGameEnded;
var localized string MsgGameEvent;
var localized string MsgQuitMapChange;

var localized string MsgPlayerConnected;
var localized string MsgPlayerConnectedSpectator;
var localized string MsgPlayerDisconnected;
var localized string MsgPlayerWasKicked;
var localized string MsgPlayerChangedTeam;
var localized string MsgPlayerChangedName;
var localized string MsgPlayerChat;
var localized string MsgPlayerScoredKill;
var localized string MsgPlayerSuicided;
var localized string MsgPlayerTeamKilled;
var localized string MsgPlayerPickup;

var localized string MsgPlayerIsFlakMonkey;
var localized string MsgPlayerIsComboWhore;
var localized string MsgPlayerIsHeadHunter;
var localized string MsgPlayerIsOnRoadRampage;
var localized string MsgPlayerFinishedAmpRun;
var localized string MsgPlayerFinishedAmpRunNoKills;
var localized string MsgPlayerFinishedAmpRunOneKill;

var localized string MsgTeamScored;
var localized string MsgTeamScoredTied;
var localized string MsgTeamScoredTakesLead;
var localized string MsgTeamScoredIncreasesLead;
var localized string MsgLeadersTied;
var localized string MsgTakesLead;
//var localized string StringTeamIsBehind;

var localized string StringMsgSuffix;
var localized string StringSuffixHattrick;
var localized string StringComboKill;
var localized string StringAmpRunStopped;
var localized string StringAmpRunStoppedNoKills;
var localized string StringAmpRunStoppedOneKill;
var localized string StringPlayerIsOut;
var localized string StringSuffixWeapon;
var localized string StringSuffixWeaponAmped;
var localized string StringSuffixPush;
var localized string StringSuffixTelefrag;
var localized string StringSuffixLocation;
var localized string StringSuicide;
var localized string StringSuicideDrowned;
var localized string StringSuicideFell;
var localized string StringSuicideLava;

var localized string StringNameGame;
var localized string StringNameSpectators;
var localized string StringNameWildcardBase;

// for chat proxy
var localized string TemplateMessage;
var localized string TemplateAction;
var localized string TemplateNick;
var localized string TemplateJoin;
var localized string TemplatePart;
var localized string TemplateQuit;
var localized string TemplateKick;
var localized string TemplateWait;

// Webadmin
var localized string ReporterGroup, ChatRelayGroup;

var localized string lblEnableReporter;
var localized string lblReportServerName;
var localized string lblReportServerPort;
var localized string lblReportServerPassword;
var localized string lblReportUserNick;
var localized string lblReportUserIdent;
var localized string lblReportChannel;
var localized string lblReportChannelKey;
var localized string lblReportStripCodes;
var localized string lblSetReportChannelTopic;
var localized string lblReportChannelTopicTemplate;
var localized string lblReportChannelTopicBotPart;
var localized string lblReportChannelTopicBotIdle;
var localized string lblReportChannelTopicUserPart;
var localized string lblMaxLevelChangeDelay;
var localized string lblEnableChatbot;
var localized string lblEnableTwoWayChat;
var localized string lblChatToGameAsTeamSay;
var localized string lblChatThroughReporter;
var localized string lblChatServerName;
var localized string lblChatServerPort;
var localized string lblChatServerPassword;
var localized string lblChatUserNick;
var localized string lblChatUserIdent;
var localized string lblChatChannel;
var localized string lblChatChannelKey;
var localized string lblChatStripCodes;
var localized string lblChatTrigger;
var localized string lblSpecOnlyChatTrigger;
var localized string lblChatReceiveOnlyText;
var localized string lblColorCodeReplacements;
var localized string lblAuth;
var localized string lblChallengeAuth;
var localized string lblHideRealHost;
var localized string lblAuthNick;
var localized string lblAuthPassword;
var localized string lblFloodProtectCommandPenalty;
var localized string lblFloodProtectMessagePenalty;
var localized string lblFloodProtectMaxPenalty;
var localized string lblFloodProtectBytes;
var localized string lblFloodProtectBytesDuration;
var localized string lblMaxLenMessageQueue;
var localized string lblAutoReconnect;
var localized string lblReconnectDelay;
var localized string lblAutoRejoin;
var localized string lblConnectTimeout;
var localized string lblDebugLogFileName;
var localized string lblDebugStartMatch;
var localized string lblItems;

var localized string descEnableReporter;
var localized string descReportServerName;
var localized string descReportServerPort;
var localized string descReportServerPassword;
var localized string descReportUserNick;
var localized string descReportUserIdent;
var localized string descReportChannel;
var localized string descReportChannelKey;
var localized string descReportStripCodes;
var localized string descSetReportChannelTopic;
var localized string descReportChannelTopicTemplate;
var localized string descReportChannelTopicBotPart;
var localized string descReportChannelTopicBotIdle;
var localized string descReportChannelTopicUserPart;
var localized string descMaxLevelChangeDelay;
var localized string descEnableChatbot;
var localized string descEnableTwoWayChat;
var localized string descChatToGameAsTeamSay;
var localized string descChatThroughReporter;
var localized string descChatServerName;
var localized string descChatServerPort;
var localized string descChatServerPassword;
var localized string descChatUserNick;
var localized string descChatUserIdent;
var localized string descChatChannel;
var localized string descChatChannelKey;
var localized string descChatStripCodes;
var localized string descChatTrigger;
var localized string descSpecOnlyChatTrigger;
var localized string descChatReceiveOnlyText;
var localized string descColorCodeReplacements;
var localized string descAuth;
var localized string descChallengeAuth;
var localized string descHideRealHost;
var localized string descAuthNick;
var localized string descAuthPassword;
var localized string descFloodProtectCommandPenalty;
var localized string descFloodProtectMessagePenalty;
var localized string descFloodProtectMaxPenalty;
var localized string descFloodProtectBytes;
var localized string descFloodProtectBytesDuration;
var localized string descMaxLenMessageQueue;
var localized string descAutoReconnect;
var localized string descReconnectDelay;
var localized string descAutoRejoin;
var localized string descConnectTimeout;
var localized string descDebugLogFileName;
var localized string descDebugStartMatch;
var localized string descItems;

var localized string dataStripCodes;


//=============================================================================
// Configuration
//=============================================================================

var config bool   bEnableReporter;
var config string ReportServerName;
var config int    ReportServerPort;
var config string ReportServerPassword;
var config string ReportUserNick;
var config string ReportUserIdent;
var config string ReportChannel;
var config string ReportChannelKey;
var config byte   ReportStripCodes;
var config bool   bSetReportChannelTopic;
var config string ReportChannelTopicTemplate;
var config string ReportChannelTopicBotPart;
var config string ReportChannelTopicBotIdle;
var config string ReportChannelTopicUserPart;
var config int    MaxLevelChangeDelay;

var config bool   bEnableChatbot;
var config bool   bEnableTwoWayChat;
var config bool   bChatToGameAsTeamSay;
var config bool   bChatThroughReporter;
var config string ChatServerName;
var config int    ChatServerPort;
var config string ChatServerPassword;
var config string ChatUserNick;
var config string ChatUserIdent;
var config string ChatChannel;
var config string ChatChannelKey;
var config byte   ChatStripCodes;
var config string ChatTrigger;
var config string SpecOnlyChatTrigger;
var config bool   bChatReceiveOnlyText;
var config string ColorCodeReplacements;

var config bool   bAuth;
var config bool   bChallengeAuth;
var config bool   bHideRealHost;
var config string AuthNick;
var config string AuthPassword;

// flood protection
var config int FloodProtectCommandPenalty;
var config int FloodProtectMessagePenalty;
var config int FloodProtectMaxPenalty;
var config int FloodProtectBytes;
var config int FloodProtectBytesDuration;
var config int MaxLenMessageQueue;

// automatically restore connections
var config bool bAutoReconnect;
var config int  ReconnectDelay;
var config bool bAutoRejoin;
var config int  ConnectTimeout;

var config array<TItemName> Items;

// debug logging
var globalconfig string DebugLogFileName;
var globalconfig bool   bDebugStartMatch;


//=============================================================================
// Variables
//=============================================================================

var() const editconst string Build;

var WIR_GameRules     MyGameRules;
var WIR_IRCConnection ReportConnection;
var WIR_IRCConnection ChatConnection;
var WIR_ChatSpectator MyChatSpectator;
var WIR_GameHandler   MyGameHandler;

var array<TPickupBase>  PickupBases;
var array<Volume>       Volumes;
var array<TeamInfo>     Teams;
var array<int>          TeamScores;
var array<int>          ReportedScores;
var array<TPlayerInfo>  Players;
var array<TCustomDisconnect>  Disconnects;
var array< class<WIR_ModHandler> >  ModHandlerClasses;

var string GameEndReason;
var array<string> ChatColorCodes;

// game state
var bool bMatchStarted, bMatchEnded;
var bool bVolumesInitialized;
var bool bScoreTeamKills;
var bool bNewRound, bReportScoreboard;
var int LastNumLeaders;
var float NextScoreReportTime;
var float LevelChangeDelay;

var array<TAmpRun> AmpRuns;


//== PreBeginPlay =============================================================
/**
Update the mutators list before webadmin initializes its list of active mutators.
*/
//=============================================================================

function PreBeginPlay()
{
	local array<string> MutatorClassNames;
	local int i;
	local string MutatorsList;
	local MutWormbot OtherWormbot;
	local string tmp;
	local bool bUpdated;

	foreach AllActors(class'MutWormbot', OtherWormbot) {
		if ( OtherWormbot != Self && OtherWormbot.bUserAdded ) {
			Destroy();
			return;
		}
	}

	Super.PreBeginPlay();

	Split(GetURLOption("mutator"), ",", MutatorClassNames);
	for (i = 0; i < MutatorClassNames.Length; ++i) {
		if ( MutatorClassNames[i] ~= string(Class) )
			return; // already in the list
	}

	// for running Wormbot as ServerActor
	Level.Game.BaseMutator.AddMutator(Self);
	bUserAdded = True;

	MutatorClassNames[MutatorClassNames.Length] = string(Class);
	MutatorsList = MutatorClassNames[0];
	for (i = 1; i < MutatorClassNames.Length; ++i)
		MutatorsList $= "," $ MutatorClassNames[i];

	UpdateURL("mutator", MutatorsList, False);

	tmp = class'WIR_Util'.static.EscapeIRCCodes(ReportChannelTopicTemplate);
	if (tmp != ReportChannelTopicTemplate) {
		ReportChannelTopicTemplate = tmp;
		bUpdated = True;
	}
	tmp = class'WIR_Util'.static.EscapeIRCCodes(ReportChannelTopicBotPart);
	if (tmp != ReportChannelTopicBotPart) {
		ReportChannelTopicBotPart = tmp;
		bUpdated = True;
	}
	tmp = class'WIR_Util'.static.EscapeIRCCodes(ReportChannelTopicBotIdle);
	if (tmp != ReportChannelTopicBotIdle) {
		ReportChannelTopicBotIdle = tmp;
		bUpdated = True;
	}
	tmp = class'WIR_Util'.static.EscapeIRCCodes(ReportChannelTopicUserPart);
	if (tmp != ReportChannelTopicUserPart) {
		ReportChannelTopicUserPart = tmp;
		bUpdated = True;
	}

	if (bUpdated)
		SaveConfig();

	if (ColorCodeReplacements != "")
		Split(ColorCodeReplacements, " ", ChatColorCodes);
}


//== static GetGameHandlerClass ===============================================
/**
Returns the WIR_GameHandler class for the specified GameInfo class.
*/
//=============================================================================

static function class<WIR_GameHandler> GetGameHandlerClass(class<GameInfo> GameClass)
{
	local class<WIR_GameHandler> HandlerClass;
	local int i;
	local string HandlerName;

	if ( GameClass != None )
		for (i = 0; i < class'WIR_GameHandler'.default.GameHandler.Length; ++i)
			if ( class'WIR_GameHandler'.default.GameHandler[i].Game ~= string(GameClass)
					|| class'WIR_GameHandler'.default.GameHandler[i].Game ~= string(GameClass.Name) ) {
				HandlerName = class'WIR_GameHandler'.default.GameHandler[i].Handler;

				if ( InStr(HandlerName, ".") != -1 )
					HandlerClass = class<WIR_GameHandler>(DynamicLoadObject(HandlerName, class'Class'));
				else
					HandlerClass = class<WIR_GameHandler>(DynamicLoadObject(class'WIR_GameHandler'.Outer $ "." $ HandlerName,
							class'Class'));

				if ( HandlerClass != None )
					return HandlerClass;
			}

	return class'WIR_GameHandler_Other';
}


//== static GetModHandlerClass ===============================================
/**
Returns the WIR_ModHandler class for the specified Info class or None.
*/
//=============================================================================

static function class<WIR_ModHandler> GetModHandlerClass(class<Info> ActorClass)
{
	local class<WIR_ModHandler> HandlerClass;
	local int i;

	if ( ActorClass != None )
		for (i = 0; i < class'WIR_ModHandler'.default.ModHandler.Length; ++i)
			if ( class'WIR_ModHandler'.default.ModHandler[i].ActorClass ~= string(ActorClass)
					|| class'WIR_ModHandler'.default.ModHandler[i].ActorClass ~= string(ActorClass.Name) ) {
				HandlerClass = class<WIR_ModHandler>(DynamicLoadObject(
						class'WIR_ModHandler'.default.ModHandler[i].Handler, class'Class'));

				if ( HandlerClass != None )
					return HandlerClass;
			}

	return None;
}


//== state Init ===============================================================
/**
Initialize the mutator.
*/
//=============================================================================

auto state Init
{
	function CreateGameHandler()
	{
		MyGameHandler = Spawn(GetGameHandlerClass(Level.Game.Class), self);

		if ( MyGameHandler == None ) {
			log("Using default game handler class.", Name);
			MyGameHandler = Spawn(class'WIR_GameHandler', self);
		}

		if ( bMatchStarted )
			MyGameHandler.bMatchStarted = True;
		log("Game handler:" @ MyGameHandler.Class, Name);
	}

	function CreateModHandlers()
	{
		local Info thisInfo;
		local WIR_ModHandler ModHandler;
		local class<WIR_ModHandler> HandlerClass;

		default.ModHandlerClasses.Length = 0;

		foreach DynamicActors(class'Info', thisInfo) {
			if ( GameInfo(thisInfo) == None && WIR_ModHandler(thisInfo) == None ) {
				HandlerClass = GetModHandlerClass(thisInfo.Class);
				ModHandler = None;
				foreach DynamicActors(class'WIR_ModHandler', ModHandler)
					if ( ModHandler.Class == HandlerClass )
						break;
				if ( ModHandler == None || ModHandler.Class != HandlerClass )
					ModHandler = Spawn(HandlerClass, Self);
				if ( ModHandler != None ) {
					MyGameHandler.AddHandler(ModHandler);
					default.ModHandlerClasses[default.ModHandlerClasses.Length] = HandlerClass;
					log("Mod handler for" @ thisInfo.Class $ ":" @ ModHandler.Class, Name);
				}
			}
		}
	}

	function CreateConnections()
	{
		local class<WIR_RegistrationHandler> RegistrationHandlerClass;

		class'WIR_IRCConnection'.default.bAutoReconnect             = bAutoReconnect;
		class'WIR_IRCConnection'.default.bAutoRejoin                = bAutoRejoin;
		class'WIR_IRCConnection'.default.ConnectTimeout             = ConnectTimeout;
		class'WIR_IRCConnection'.default.ReconnectDelay             = ReconnectDelay;
		class'WIR_IRCConnection'.default.FloodProtectCommandPenalty = FloodProtectCommandPenalty;
		class'WIR_IRCConnection'.default.FloodProtectMessagePenalty = FloodProtectMessagePenalty;
		class'WIR_IRCConnection'.default.FloodProtectMaxPenalty     = FloodProtectMaxPenalty;
		class'WIR_IRCConnection'.default.FloodProtectBytes          = FloodProtectBytes;
		class'WIR_IRCConnection'.default.FloodProtectBytesDuration  = FloodProtectBytesDuration;
		class'WIR_IRCConnection'.default.MaxLenMessageQueue         = MaxLenMessageQueue;
		class'WIR_IRCConnection'.default.DebugLogFileName           = DebugLogFileName;
		class'WIR_IRCConnection'.default.bDebugStartMatch           = bDebugStartMatch;

		if ( bAuth ) {
			RegistrationHandlerClass = class'WIR_RegistrationQuakeNet';
			class'WIR_RegistrationQuakeNet'.default.bAuth           = bAuth;
			class'WIR_RegistrationQuakeNet'.default.bChallengeAuth  = bChallengeAuth;
			class'WIR_RegistrationQuakeNet'.default.bHideRealHost   = bHideRealHost;
			class'WIR_RegistrationQuakeNet'.default.AuthNick        = AuthNick;
			class'WIR_RegistrationQuakeNet'.default.AuthPassword    = AuthPassword;
		}
		else
			RegistrationHandlerClass = class'WIR_RegistrationHandler';

		if (ReportUserNick == "" || ChatUserNick == "" || ReportUserNick ~= "Wormbot" || ChatUserNick ~= "Wormbot") {
			if (ReportUserNick == "" || ReportUserNick ~= "Wormbot") {
				ReportUserNick = "RenameMe";
			}
			if (ChatUserNick == "" || ChatUserNick ~= "Wormbot") {
				ChatUserNick = "RenameMe";
			}
			SaveConfig();
		}
		if (InStr(ReportChannel, ",") != -1) {
			ReportChannel = Left(ReportChannel, InStr(ReportChannel, ","));
			log("Only a single report channel may be specified.", Name);
			SaveConfig();
		}
		if (InStr(ChatChannel, ",") != -1) {
			ChatChannel = Left(ChatChannel, InStr(ChatChannel, ","));
			log("Only a single chat channel may be specified.", Name);
			SaveConfig();
		}
		if ( bEnableReporter && ReportConnection == None && ReportChannel != "" ) {
			ReportConnection = Spawn(class'WIR_IRCConnection', Self);
			if ( ReportConnection != None ) {
				ReportConnection.SetConnection(ReportServerName, ReportServerPort, ReportServerPassword, ReportUserNick, ReportUserIdent);
				//RegistrationHandlerClass = class<WIR_RegistrationHandler>(DynamicLoadObject(ReportRegistrationHandler,
				//    class'Class'));
				ReportConnection.SetRegistrationDetails(RegistrationHandlerClass, "");
				ReportConnection.JoinChannel(ReportChannel, ReportChannelKey);
				if ( ReportStripCodes > 0 )
					ReportConnection.bNoChannelColor = True;
				if ( ReportStripCodes > 1 )
					ReportConnection.bNoChannelCodes = True;
			}
		} // if bEnableReporter

		if ( bEnableChatbot && ChatConnection == None ) {
			if ( bChatThroughReporter && ReportConnection != None )
				ChatConnection = ReportConnection;
			else if (ChatChannel != "") {
				ChatConnection = Spawn(class'WIR_IRCConnection', Self);
				if ( ChatConnection != None ) {
					ChatConnection.SetConnection(ChatServerName, ChatServerPort, ChatServerPassword, ChatUserNick, ChatUserIdent);
					//RegistrationHandlerClass = class<WIR_RegistrationHandler>(DynamicLoadObject(ChatRegistrationHandler,
					//    class'Class'));
					ChatConnection.SetRegistrationDetails(RegistrationHandlerClass, "");
					ChatConnection.JoinChannel(ChatChannel, ChatChannelKey);
					if ( ChatStripCodes > 0 )
						ChatConnection.bNoChannelColor = True;
					if ( ChatStripCodes > 1 )
						ChatConnection.bNoChannelCodes = True;
				}
			}
			if ( ChatConnection != None && bEnableTwoWayChat ) {
				ChatConnection.OnChat = ReceivedChatMessage;
				ChatConnection.OnMode = ReceivedModeMessage;
			}
		} // if bEnableChatbot
	}

	function FindTeams()
	{
		local TeamInfo T;

		if ( Level.Game.bTeamGame ) {
			foreach DynamicActors(class'TeamInfo', T)
				if ( T.TeamIndex < 4 ) {
					Teams[T.TeamIndex] = T;
					//log("Team"@T.TeamIndex$":"@T.GetHumanReadableName()@T, Name);
				}
			TeamScores.Length = Teams.Length;
			bScoreTeamKills = bool(Level.Game.GetPropertyText("bScoreTeamKills"));
		}
	}

Begin:
	if ( LifeSpan != 0 )
		Stop;

	MyGameRules = Spawn(class'WIR_GameRules', self);
	MyChatSpectator = Spawn(class'WIR_ChatSpectator', Self);

	CreateGameHandler();
	CreateModHandlers();
	CreateConnections();
	FindTeams();
}


//== state PreTravel ==========================================================
/**
The server wants to switch to the next map. Delay the map change until the final scores have been reported.
*/
//=============================================================================

state PreTravel
{
	function ReportTravel(string NextURL)
	{
		local string NextMap;
		local string NextGame;
		local int i;
		local string Msg;
		local class<GameInfo> NextGameClass;

		if ( NextURL ~= "?restart" ) {
			NextMap = string(Outer.Name);
			NextGame = string(Level.Game.Class);
		}
		else {
			i = InStr(NextURL, "?");
			if ( i > 0 ) {
				NextMap = Left(NextURL, i);
				NextURL = Mid(NextURL, i);
			}
			else if ( i == -1 && NextURL != "" )
				NextMap = NextURL;
			else
				NextMap = string(Outer.Name);

			if ( Level.Game.HasOption(NextURL, "game") )
				NextGame = Level.Game.ParseOption(NextURL, "game");
			else
				NextGame = string(Level.Game.Class);
		}

		if ( NextGame ~= string(Level.Game.Class) )
			NextGame = Level.Game.GameName;
		else {
			NextGameClass = class<GameInfo>(DynamicLoadObject(NextGame, class'Class'));
			if ( NextGameClass != None )
				NextGame = NextGameClass.default.GameName;
			else
				NextGame = GetItemName(NextGame);
		}
		Msg = Repl(MsgQuitMapChange, "%g", NextGame, True);
		Msg = Repl(Msg,              "%m", NextMap, True);

		log("Disconnecting from IRC...", Name);
		if ( ChatConnection != None ) {
			ChatConnection.Disconnect(False, Msg);
		}
		if ( ReportConnection != None && ReportConnection != ChatConnection ) {
			ReportConnection.Disconnect(False, Msg);
		}
	} // ReportTravel

	function DebugDumpMessageQueue()
	{
		local int i;

		log("-- DebugDumpMessageQueue, current timestamp:"@ReportConnection.TimeStampNow, 'DevGarbage');

		for (i = 0; i < ReportConnection.MessageQueue.Length; ++i)
			log(i @ ReportConnection.MessageQueue[i].bImportant
					@ ReportConnection.MessageQueue[i].Timestamp
					@ ReportConnection.MessageQueue[i].Message, 'DevGarbage');

		log("-- End Of Message Queue", 'DevGarbage');
	}

Begin:
	if ( bMatchEnded && ReportConnection != None && ReportConnection.IsInState('InChannel')
			&& ReportConnection.ImportantMessagesQueued() ) {
		log("Delaying Servertravel to finish reporting...", Name);
		MyChatSpectator.ServerSay(TemplateWait);
	}
	LevelChangeDelay = MaxLevelChangeDelay;

	if ( Level.NextSwitchCountdown < 2.0 )
		Level.NextSwitchCountdown = 2.0;

	while (bMatchEnded && ReportConnection != None && ReportConnection.IsInState('InChannel')
			&& ReportConnection.ImportantMessagesQueued() && LevelChangeDelay > 0 && Level.NextSwitchCountdown >= 0.5) {
		if ( Level.NextSwitchCountdown <= 1.5 ) {
			DebugDumpMessageQueue();
			Level.NextSwitchCountdown = 2.5;
		}
		Sleep(0.1);
		LevelChangeDelay -= 0.1 / Level.TimeDilation;
	}

	if ( Level.NextSwitchCountdown < 1.0 )
		Level.NextSwitchCountdown = 1.0;
	ReportTravel(Level.NextURL);
}


//== AddMutator ===============================================================
/**
Prevent self-adding.
*/
//=============================================================================

function AddMutator(Mutator M)
{
	if ( M != Self ) {
		if ( M.Class != Class ) {
			Super.AddMutator(M);
		}
		else {
			M.LifeSpan = 0.1;
		}
	}
}


//== FindLeadingTeams =========================================================
/**
Returns the teams with the highes scores.
*/
//=============================================================================

function FindLeadingTeams(out array<TeamInfo> Leaders, optional bool bLastTickLeaders)
{
	local int i;
	local int MaxScore;

	MaxScore = ~MaxInt;
	Leaders.Length = 0;
	if ( bLastTickLeaders ) {
		for (i = 0; i < Teams.Length; ++i)
			if ( TeamScores[i] > MaxScore )
				MaxScore = TeamScores[i];

		for (i = 0; i < Teams.Length; ++i)
			if ( TeamScores[i] ~= MaxScore )
				Leaders[Leaders.Length] = Teams[i];
	}
	else {
		for (i = 0; i < Teams.Length; ++i)
			if ( Teams[i].Score > MaxScore )
				MaxScore = Teams[i].Score;

		for (i = 0; i < Teams.Length; ++i)
			if ( Teams[i].Score ~= MaxScore )
				Leaders[Leaders.Length] = Teams[i];
	}
}


//== CheckTeamScores ==========================================================
/**
Check the team scores.
*/
//=============================================================================

function CheckTeamScores()
{
	local int i, j;
	local string Msg;
	local array<TeamInfo> Leaders, LastLeaders;
	local array<string> LeaderStrings;
	local bool bTeamIsLeader, bLeadersChanged;

	if ( !Level.Game.bTeamGame )
		return;

	FindLeadingTeams(Leaders);
	if ( !bScoreTeamKills ) {
		for (i = 0; i < Teams.Length; ++i) {
			if ( Teams[i] != None ) {
				if ( TeamScores[i] != Teams[i].Score ) {
					bTeamIsLeader = False;
					LeaderStrings.Length = 0;
					for (j = 0; j < Leaders.Length; ++j) {
						if ( Leaders[j] == Teams[i] )
							bTeamIsLeader = True;
						else
							LeaderStrings[LeaderStrings.Length] = class'WIR_Util'.static.FormatTeamName(Leaders[j], False);
					}
					if ( !bTeamIsLeader )
						Msg = MsgTeamScored;
					else if ( LeaderStrings.Length > 0 )
						Msg = Repl(MsgTeamScoredTied, "%l", class'WIR_Util'.static.ConcatWithSeparator(LeaderStrings), True);
					else if ( LastNumLeaders > 1 )
						Msg = MsgTeamScoredTakesLead;
					else
						Msg = MsgTeamScoredIncreasesLead;
					Msg = Repl(Msg, "%d", string(int(Teams[i].Score - TeamScores[i])), True);
					Msg = Repl(Msg, "%s", string(int(Teams[i].Score)), True);
					Msg = Repl(Msg, "%r", MyGameHandler.GetRemainingTime(), True);
					Msg = Repl(Msg, "%t", class'WIR_Util'.static.FormatTeamName(Teams[i], False), True);
					ReportConnection.SendMessage(Msg, True);
					if ( !MyGameHandler.bScoreEndsRound )
						NextScoreReportTime = MyGameHandler.ScoreReportDelay;
					else
						bReportScoreboard = True;
				}
			}
		} // for Teams
	}
	else if ( Leaders.Length > 0 ) {
		FindLeadingTeams(LastLeaders, True);
		if ( LastLeaders.Length != Leaders.Length )
			bLeadersChanged = True;
		else {
			for (i = 0; i < LastLeaders.Length; ++i)
				if ( LastLeaders[i] != Leaders[i] ) {
					bLeadersChanged = True;
					break;
				}
		}
		if ( bLeadersChanged ) {
			if ( Leaders.Length > 1 )
				Msg = MsgLeadersTied;
			else
				Msg = MsgTakesLead;

			for (i = 0; i < Leaders.Length; ++i)
				LeaderStrings[LeaderStrings.Length] = class'WIR_Util'.static.FormatTeamName(Leaders[i], False);

			Msg = Repl(Msg, "%t", class'WIR_Util'.static.ConcatWithSeparator(LeaderStrings), True);
			Msg = Repl(Msg, "%s", string(int(Leaders[0].Score)), True);
			Msg = Repl(Msg, "%r", MyGameHandler.GetRemainingTime(), True);
			ReportConnection.SendMessage(Msg);
			NextScoreReportTime = MyGameHandler.ScoreReportDelay;
		}
	}

	LastNumLeaders = Leaders.Length;
	for (i = 0; i < Teams.Length; ++i) {
		if ( Teams[i] != None )
			TeamScores[i] = Teams[i].Score;
	}

	if ( !bLeadersChanged && NextScoreReportTime <= 0 ) {
		if ( ReportedScores.Length != TeamScores.Length )
			ReportedScores.Length = TeamScores.Length;
		for (j = 0; j < ReportedScores.Length; ++j)
			if ( ReportedScores[j] != TeamScores[j] ) {
				bReportScoreboard = True;
				NextScoreReportTime = MyGameHandler.ScoreReportDelay;
				ReportedScores = TeamScores;
				break;
			}
	}
}


//== Tick =====================================================================
/**
Initialize the IRC Reporter (if neccessary) and look for new controllers.
*/
//=============================================================================

event Tick(float DeltaTime)
{
	local int i, j;
	local string Msg, Reason;
	local GameReplicationInfo GRI;
	local TeamPlayerReplicationInfo TPRI;

	GRI = Level.GRI;

	if (MyGameHandler == None)
		return;

	if ( ReportConnection != None ) {
		if ( NextScoreReportTime > 0 )
			NextScoreReportTime -= DeltaTime / Level.TimeDilation;
		CheckTeamScores();

		if ( MyGameHandler.bReportSpecial )
			for (i = 0; i < Players.Length; ++i) {
				if ( TeamPlayerReplicationInfo(Players[i].PRI) == None )
					continue;
				TPRI = TeamPlayerReplicationInfo(Players[i].PRI);
				if ( (bReportScoreboard || NextScoreReportTime <= 0)
						&& int(Players[i].PRI.Score) != Players[i].LastScore ) {
					bReportScoreboard = True;
					Players[i].LastScore = int(Players[i].PRI.Score);
				}

				if ( Players[i].FlakKills < TPRI.flakcount ) {
					Players[i].FlakKills = TPRI.flakcount;
					if ( TPRI.flakcount == 15 ) {
						Msg = Repl(MsgPlayerIsFlakMonkey, "%r", MyGameHandler.GetRemainingTime(), True);
						Msg = Repl(Msg, "%p", MyGameHandler.FormatPlayerName(TPRI, True), True);
						ReportConnection.SendMessage(Msg);
					}
				}

				if ( Players[i].ComboKills < TPRI.combocount ) {
					Players[i].ComboKills = TPRI.combocount;
					if ( TPRI.combocount == 15 ) {
						Msg = Repl(MsgPlayerIsComboWhore, "%r", MyGameHandler.GetRemainingTime(), True);
						Msg = Repl(Msg, "%p", MyGameHandler.FormatPlayerName(TPRI, True), True);
						ReportConnection.SendMessage(Msg);
					}
				}

				if ( Players[i].HeadshotKills < TPRI.headcount ) {
					Players[i].HeadshotKills = TPRI.headcount;
					if ( TPRI.headcount == 15 ) {
						Msg = Repl(MsgPlayerIsHeadHunter, "%r", MyGameHandler.GetRemainingTime(), True);
						Msg = Repl(Msg, "%p", MyGameHandler.FormatPlayerName(TPRI, True), True);
						ReportConnection.SendMessage(Msg);
					}
				}

				if ( Players[i].RunoverKills < TPRI.ranovercount ) {
					Players[i].RunoverKills = TPRI.ranovercount;
					if ( TPRI.ranovercount == 10 ) {
						Msg = Repl(MsgPlayerIsOnRoadRampage, "%r", MyGameHandler.GetRemainingTime(), True);
						Msg = Repl(Msg, "%p", MyGameHandler.FormatPlayerName(TPRI, True), True);
						ReportConnection.SendMessage(Msg);
					}
				}

				if ( Players[i].Player != None && Players[i].Player.Pawn != None ) {
					if ( Players[i].Player.Pawn.HasUDamage() ) {
						for (j = 0; j < AmpRuns.Length; j++) {
							if (AmpRuns[j].Player == Players[i].Player.Pawn)
								break;
						}
						if ( j == AmpRuns.Length ) {
							AmpRuns.Length = j + 1;
							AmpRuns[j].Player = Players[i].Player.Pawn;
							AmpRuns[j].StartTime = Level.TimeSeconds;
						}
					}
					else {
						for (j = 0; j < AmpRuns.Length; j++) {
							if (AmpRuns[j].Player == Players[i].Player.Pawn) {
								if (AmpRuns[j].Kills == 0) {
									Msg = Repl(MsgPlayerFinishedAmpRunNoKills, "%r", MyGameHandler.GetRemainingTime(), True);
								}
								else if (AmpRuns[j].Kills == 1) {
									Msg = Repl(MsgPlayerFinishedAmpRunOneKill, "%r", MyGameHandler.GetRemainingTime(), True);
								}
								else {
									Msg = Repl(MsgPlayerFinishedAmpRun, "%r", MyGameHandler.GetRemainingTime(), True);
									Msg = Repl(Msg, "%k", AmpRuns[j].Kills, True);
								}
								Msg = Repl(Msg, "%p", MyGameHandler.FormatPlayerName(TPRI, True), True);
								ReportConnection.SendMessage(Msg);
								AmpRuns.Remove(j--, 1);
							}
							else if ( AmpRuns[j].Player == None )
								AmpRuns.Remove(j--, 1);
						}
					}
				}
			} // for Players
	} // if ReportConnection

	if ( !bMatchEnded && Level.Game.bGameEnded ) {
		bMatchEnded = True;
		if ( ReportConnection != None && !MyGameHandler.HandleEndGame(Reason) ) {
			Msg = Repl(MsgGameEnded, "%r", MyGameHandler.GetRemainingTime(), True);
			if ( Reason != "" )
				Msg $= Repl(StringMsgSuffix, "%m", Reason, True);
			ReportConnection.SendMessage(Msg, True);
			bReportScoreboard = True;
		}
	}
	else if ( bNewRound ) {
		if ( ReportConnection != None && !MyGameHandler.HandleNewRound() )
			ReportConnection.SendMessage(Repl(MsgGameReset, "%r", MyGameHandler.GetRemainingTime(), True), True);
		bNewRound = False;
	}
	else if ( bMatchEnded && !Level.Game.bGameEnded ) {
		bMatchEnded = False;
	}

	for (i = 0; i < Players.Length; ++i) {
		if ( Players[i].Player == None ) {
			Players.Remove(i--, 1);
			continue;
		}

		if ( Players[i].PRI == None ) { // new player
			if ( Players[i].Player.PlayerReplicationInfo == None )
				continue;
			if ( !class'WIR_Util'.static.IsPlayer(Players[i].Player) ) {
				Players.Remove(i--, 1);
				continue; // ignore non-player controllers
			}
			Players[i].PRI            = Players[i].Player.PlayerReplicationInfo;
			Players[i].bWasSpectator  = Players[i].PRI.bOnlySpectator;
			Players[i].LastName       = Players[i].Player.GetHumanReadableName();
			Players[i].LastTeam       = Players[i].PRI.Team;
			Players[i].LastScore      = int(Players[i].PRI.Score);

			// report new player
			if ( Players[i].bWasSpectator )
				Msg = MsgPlayerConnectedSpectator;
			else
				Msg = MsgPlayerConnected;
			Msg = Repl(Msg, "%r", MyGameHandler.GetRemainingTime(), True);
			Msg = Repl(Msg, "%p", MyGameHandler.FormatPlayerName(Players[i].Player, True), True);
			SendMessageOnce(Msg);

		} // if new player

		if ( Players[i].LastName != Players[i].Player.GetHumanReadableName() ) {
			if ( Players[i].PRI.bBot )
				Msg = class'WIR_Util'.default.StringPrefixBot
						$ Players[i].LastName
						$ class'WIR_Util'.default.StringSuffixBot;
			else
				Msg = class'WIR_Util'.default.StringPrefixHuman
						$ Players[i].LastName
						$ class'WIR_Util'.default.StringSuffixHuman;

			if ( Players[i].PRI.bOnlySpectator || Players[i].PRI.bOutOfLives && Players[i].Player.Pawn == None )
				Msg = class'WIR_Util'.default.StringPrefixSpectator $ Msg;
			else if ( Players[i].PRI.Team != None && Players[i].PRI.Team.TeamIndex >= 0
					&& Players[i].PRI.Team.TeamIndex < ArrayCount(class'WIR_Util'.default.StringPrefixTeamIndex) )
				Msg = class'WIR_Util'.default.StringPrefixTeamIndex[Players[i].PRI.Team.TeamIndex] $ Msg;
			else
				Msg = class'WIR_Util'.default.StringPrefixNeutral $ Msg;
			Msg = Repl(MsgPlayerChangedName, "%o", Msg, True);
			Msg = Repl(Msg, "%r", MyGameHandler.GetRemainingTime(), True);
			Msg = Repl(Msg, "%n", MyGameHandler.FormatPlayerName(Players[i].Player, True), True);
			SendMessageOnce(Msg);

			Players[i].LastName = Players[i].Player.GetHumanReadableName();

		} // if name change

		if ( Players[i].bWasSpectator != Players[i].PRI.bOnlySpectator || Players[i].LastTeam != Players[i].PRI.Team ) {
			Msg = Repl(MsgPlayerChangedTeam, "%r", MyGameHandler.GetRemainingTime(), True);
			if ( Players[i].PRI.bOnlySpectator ) {
				// changed to spectators
				Msg = Repl(Msg, "%t", StringNameSpectators, True);
			}
			else if ( !Level.Game.bTeamGame ) {
				Msg = Repl(Msg, "%t", StringNameGame, True);
			}
			else if ( Players[i].LastTeam != Players[i].PRI.Team ) {
				Msg = Repl(Msg, "%t", class'WIR_Util'.static.FormatTeamName(Players[i].PRI.Team, False), True);
			}
			Msg = Repl(Msg, "%p", MyGameHandler.FormatPlayerName(Players[i].Player, True), True);
			SendMessageOnce(Msg);

			Players[i].bWasSpectator = Players[i].PRI.bOnlySpectator;
			Players[i].LastTeam = Players[i].PRI.Team;

		} // if team or spectator change
	}

	if ( bReportScoreboard ) {
		MyGameHandler.ReportScores();
		NextScoreReportTime = MyGameHandler.ScoreReportDelay;
		bReportScoreboard = False;
	}
	Tag = '';

} // Tick


//== NotifyLogin ==============================================================
/**
Report a connect.
*/
//=============================================================================

function NotifyLogin(Controller Entering)
{
	local string Msg;

	if ( Entering == None || Entering.PlayerReplicationInfo == None )
		return;

	if ( Entering.PlayerReplicationInfo.bOnlySpectator )
		Msg = MsgPlayerConnectedSpectator;
	else
		Msg = MsgPlayerConnected;

	Msg = Repl(Msg, "%r", MyGameHandler.GetRemainingTime(), True);
	Msg = Repl(Msg, "%p", MyGameHandler.FormatPlayerName(Entering, True), True);
	SendMessageOnce(Msg);
}


//== NotifyLogout =============================================================
/**
Report a disconnect.
*/
//=============================================================================

function NotifyLogout(Controller Exiting)
{
	local string Msg;
	local int i;

	Super.NotifyLogout(Exiting);

	for (i = 0; i < Disconnects.Length; ++i) {
		if ( Disconnects[i].Player == Exiting ) {
			Msg = Disconnects[i].Reason;
			Disconnects.Remove(i, 1);
			break;
		}
	}
	if ( Msg == "" )
		Msg = MsgPlayerDisconnected;
	Msg = Repl(Msg, "%r", MyGameHandler.GetRemainingTime(), True);
	Msg = Repl(Msg, "%p", MyGameHandler.FormatPlayerName(Exiting, True), True);
	SendMessageOnce(Msg);
}


//== Mutate ===================================================================
/**
Propagate Mutate commands to handlers.
*/
//=============================================================================

function Mutate(string MutateString, PlayerController Sender)
{
	local array<string> SplittedString;

	Super.Mutate(MutateString, Sender);
	if ( MyGameHandler.Mutate(MutateString, Sender) )
		return;

	if ( Sender == None ) {
		if ( Left(MutateString, 8) ~= "KickedBy" ) {
			MutateString = Mid(MutateString, 9);
			Split(MutateString, Chr(254), SplittedString);

			if ( SplittedString.Length >= 2 ) {
				Sender = PlayerController(FindPlayerByName(SplittedString[1]));
				if ( Sender != None )
					AddDisconnectReason(Sender, Repl(MsgPlayerWasKicked, "%m", SplittedString[0], True));
			}
		}
	}
}


//== FindPlayerByName =========================================================
/**
Returns the Controller of the player with the specified name.
*/
//=============================================================================

function Controller FindPlayerByName(string PlayerName)
{
	local int i;
	local GameReplicationInfo GRI;

	GRI = Level.Game.GameReplicationInfo;
	if ( GRI == None )
		return None; // can't work without GRI

	// search for exact name
	for (i = 0; i < GRI.PRIArray.Length; i++) {
		if ( GRI.PRIArray[i] != None && GRI.PRIArray[i].PlayerName ~= PlayerName
				&& class'WIR_Util'.static.IsPlayer(GRI.PRIArray[i]) )
			return Controller(GRI.PRIArray[i].Owner);
	}

	// search for the first name containing the string
	for (i = 0; i < GRI.PRIArray.Length; i++) {
		if ( GRI.PRIArray[i] != None && class'WIR_Util'.static.IsPlayer(GRI.PRIArray[i])
				&& InStr(Caps(GRI.PRIArray[i].PlayerName), Caps(PlayerName)) != -1 )
			return Controller(GRI.PRIArray[i].Owner);
	}

	return None; // no player found
}


//== AddDisconnectReason ======================================================
/**
Associates a custom disconnect text with a player.
*/
//=============================================================================

function AddDisconnectReason(Controller Exiting, string Reason)
{
	local int i;

	if ( Exiting == None )
		return;

	for (i = 0; i < Disconnects.Length; ++i) {
		if ( Disconnects[i].Player == None )
			Disconnects.Remove(i--, 1);
		else if ( Disconnects[i].Player == Exiting ) {
			if ( Reason == "" ) {
				Disconnects.Remove(i, 1);
				return;
			}
			else
				break;
		}
	}
	if ( i == Disconnects.Length )
		Disconnects.Length = i + 1;
	Disconnects[i].Player = Exiting;
	Disconnects[i].Reason = Reason;
}


//== Trigger ==================================================================
/**
Catch actual item pickups.
*/
//=============================================================================

event Trigger(Actor Other, Pawn EventInstigator)
{
	if ( Pickup(Other) != None && class'WIR_Util'.static.IsPlayer(EventInstigator) && ReportConnection != None )
		Pickup(EventInstigator.Controller, Pickup(Other));
}


//== InGameEvent ==============================================================
/**
Called when receiving ingame event messages.
*/
//=============================================================================

function InGameEvent(class<LocalMessage> Message, optional int Switch, optional PlayerReplicationInfo RelatedPRI_1, optional PlayerReplicationInfo RelatedPRI_2, optional Object OptionalObject)
{
	local string Msg;

	if ( ReportConnection != None ) {
		Msg = class'WIR_Util'.static.Trim(Message.Static.GetString(Switch, RelatedPRI_1, RelatedPRI_2, OptionalObject));
		if ( Msg == "" )
			return; // nothing to send

		Msg = Repl(MsgGameEvent, "%m", Msg, True);
		Msg = Repl(Msg, "%r", MyGameHandler.GetRemainingTime(), True);
		ReportConnection.SendMessage(Msg);
	}
}


//== InGameChat ===============================================================
/**
Called when receiving an ingame chat message.
*/
//=============================================================================

function InGameChat(PlayerReplicationInfo PRI, string Message, bool bTeamSay)
{
	local string Msg;
	local int i;

	if ( ChatConnection != None ) {
		if (ChatColorCodes.Length > 0) {
			do {
				Message = Repl(Message, "^" $ i, ChatColorCodes[i]);
			} until (++i == ChatColorCodes.Length);
			Message = Repl(Message, "^r", ChatColorCodes[Rand(ChatColorCodes.Length)]);
		}
		Msg = class'WIR_Util'.static.ReplOnce(MsgPlayerChat, "%r", MyGameHandler.GetRemainingTime(), True);
		Msg = class'WIR_Util'.static.ReplOnce(Msg,           "%m", Message, True);
		Msg = class'WIR_Util'.static.ReplOnce(Msg,           "%p", MyGameHandler.FormatPlayerName(PRI, True), True);
		ChatConnection.SendMessage(Msg);
	}
}


//== ReceivedChatMessage ======================================================
/**
Called when receiving an IRC chat message.
*/
//=============================================================================

function ReceivedChatMessage(string Nick, string Message)
{
	local bool bIsAction, bSpectatorsOnly;

	if (ReportConnection != None && Nick ~= ReportConnection.UserNick) {
		return;
	}

	if (Left(Message, 8) == (Chr(1) $ "ACTION ") && Right(Message, 1) == Chr(1)) {
		Message = Mid(Message, 8, Len(Message) - 9);
		bIsAction = True;
	}
	else if (Left(Message, 1) == Chr(1))
		return;

	if (InStr(Message, ChatTrigger) == 0) {
		if (ChatTrigger != "")
			Message = Mid(Message, Len(ChatTrigger));
	}
	else if (InStr(Message, SpecOnlyChatTrigger) == 0) {
		if (SpecOnlyChatTrigger != "") {
			Message = Mid(Message, Len(SpecOnlyChatTrigger));
			bSpectatorsOnly = True;
		}
		else if (ChatTrigger != "")
			return;   // empty spec-only chat trigger should not override chat trigger
	}
	else
		return; // no trigger found

	if (bIsAction)
		Message = Repl(TemplateAction, "%m", Message, True);
	else
		Message = Repl(TemplateMessage, "%m", Message, True);

	Message = Repl(class'WIR_Util'.static.StripIRCCodes(Message), "%u", Nick, True);

	if (bChatToGameAsTeamSay || bSpectatorsOnly)
		MyChatSpectator.ServerTeamSay(Message);
	else
		MyChatSpectator.ServerSay(Message);
}


//== ReceivedModeMessage ======================================================
/**
Called when receiving a mode change.
*/
//=============================================================================

function ReceivedModeMessage(WIR_IRCConnection.EModeType Type, string Nick, string Parameters)
{
	local string S;

	if ( bChatReceiveOnlyText )
		return;

	switch (Type) {
		case MT_Join:
			if (bChatToGameAsTeamSay)
				MyChatSpectator.ServerTeamSay(Repl(TemplateJoin, "%u", Nick, True));
			else
				MyChatSpectator.ServerSay(Repl(TemplateJoin, "%u", Nick, True));
			break;
		case MT_Part:
			if (bChatToGameAsTeamSay)
				MyChatSpectator.ServerTeamSay(Repl(TemplatePart, "%u", Nick, True));
			else
				MyChatSpectator.ServerSay(Repl(TemplatePart, "%u", Nick, True));
			break;
		case MT_Quit:
			if (bChatToGameAsTeamSay)
				MyChatSpectator.ServerTeamSay(Repl(TemplateQuit, "%u", Nick, True));
			else
				MyChatSpectator.ServerSay(Repl(TemplateQuit, "%u", Nick, True));
			break;
		case MT_Kick:
			Divide(Parameters, " ", S, Parameters);
			if (bChatToGameAsTeamSay)
				MyChatSpectator.ServerTeamSay(Repl(Repl(TemplateKick, "%k", S, True), "%u", Nick, True));
			else
				MyChatSpectator.ServerSay(Repl(Repl(TemplateKick, "%k", S, True), "%u", Nick, True));
			break;
		case MT_Nick:
			if (bChatToGameAsTeamSay)
				MyChatSpectator.ServerTeamSay(Repl(Repl(TemplateNick, "%n", Parameters, True), "%u", Nick, True));
			else
				MyChatSpectator.ServerSay(Repl(Repl(TemplateNick, "%n", Parameters, True), "%u", Nick, True));
			break;
	}
}


//== SendMessageOnce ==========================================================
/**
Send a chat message to the IRC connection(s), but only to one of them if they are in the same channel.
*/
//=============================================================================

function SendMessageOnce(string Msg)
{
	if ( ReportConnection != None )
		ReportConnection.SendMessage(Msg);
	if ( ChatConnection != None && (ReportConnection == None || ChatConnection != ReportConnection
			&& (ChatConnection.ServerName != ReportConnection.ServerName
			|| ChatConnection.ChannelName != ReportConnection.ChannelName)) )
		ChatConnection.SendMessage(Msg);
}


//== CheckReplacement =========================================================
/**
Detect a Controller spawning.
*/
//=============================================================================

function bool CheckReplacement(Actor Other, out byte bSuperRelevant)
{
	if ( Controller(Other) != None ) {
		Players.Insert(0, 1);
		Players[0].Player = Controller(Other);
	}
	return Super.CheckReplacement(Other, bSuperRelevant);
}


//== InitPickupBaseCache ======================================================
/**
Initializes the pickup base cache.
*/
//=============================================================================

function InitPickupBaseCache()
{
	local xPickupBase B;
	local string LocationName;

	PickupBases.Length = 0;
	foreach AllActors(class'xPickupBase', B)
		if ( B.PowerUp != None ) {
			LocationName = GetLocationNameFor(B);
			if ( LocationName != "" ) {
				PickupBases.Insert(0, 1);
				PickupBases[0].Base = B;
				PickupBases[0].LocationName = LocationName;
			}
		}
} // InitPickupBaseCache


//== GetLocationNameFor =======================================================
/**
Returns a location name for the specified actor.
*/
//=============================================================================

function string GetLocationNameFor(Actor A)
{
	local Volume V;
	local int i;
	local string LocName;

	if ( !bVolumesInitialized ) {
		bVolumesInitialized = True;
		MyGameHandler.UpdateLocationNames();
		Volumes.Length = 0;

		// initialize the Volumes list
		foreach AllActors(class'Volume', V) {
			if ( V.LocationName == "" || V.LocationName == class'Volume'.Default.LocationName )
				continue; // skip volumes without location name

			// find volume with highest priority lower than or equal to this volume's priority
			for (i = 0; i < Volumes.Length; ++i)
				if ( Volumes[i].LocationPriority <= V.LocationPriority )
					break;
			Volumes.Insert(i, 1);
			Volumes[i] = V;
		}
		V = None;
	}

	if ( MyGameHandler.GetLocationNameFor(A, LocName) )
		return LocName;

	for (i = 0; i < Volumes.Length; ++i)
		if ( Volumes[i].Encompasses(A) ) {
			V = Volumes[i];
			break;
		}

	if ( V != None )
		return V.LocationName;
	else if ( A.Region.Zone != None && A.Region.Zone != Level && A.Region.Zone.LocationName != "" )
		return A.Region.Zone.LocationName;

	return "";

} // GetLocationNameFor


//== GetLocationName ==========================================================
/**
Returns a location name for the specified controller's pawn.
*/
//=============================================================================

function string GetLocationName(Controller Who)
{
	local float bestDist, currDist;
	local Actor Closest;
	local string near, bestNear, where, locName, ObjName;
	local xPickupBase B;
	local int i;

	if ( Who.Pawn == None )
		return Who.PlayerReplicationInfo.StringSpectating;

	Closest = MyGameHandler.GetClosestGameObjective(Who.Pawn.Location);
	if ( Closest != None )
		bestDist = VSize(Closest.Location - Who.Pawn.Location);
	else
		bestDist = 10000.0;

	// If our closest gameobjective is more than 1024UU away, look for nearby pickup base
	if ( bestDist > 750 ) { // Look for closer objects
		if ( PickupBases.Length == 0 )
			InitPickupBaseCache();
		for (i = 0; i < PickupBases.Length; i++) {
			B = PickupBases[i].Base;
			currDist = VSize(B.Location - Who.Pawn.Location);
			if ( currDist < FMin(bestDist, 2000) ) {
				if ( B.IsA('WildCardBase') || B.IsA('MultiPickupBase') )
					near = StringNameWildcardBase;
				else if ( B.Powerup != None && B.Powerup.default.InventoryType != None )
					near = B.Powerup.default.InventoryType.static.StaticItemName();
				else if ( B.Powerup != None )
					near = GetPickupName(B.Powerup);
				else
					near = "";

				if ( near != "" ) {
					bestDist = currDist;
					bestNear = near;
					Closest = B;
				}
			}
		}
	}

	if ( Who != None && Who.Pawn != None ) {
		locName = class'WIR_Util'.static.Trim(GetLocationNameFor(Who.Pawn));
		if ( locName != "" )
			locName = "(" $ locName $ ")";
	}
	if ( Closest != None ) {
		if ( GameObjective(Closest) != None ) {
			ObjName = MyGameHandler.GetObjectiveName(GameObjective(Closest));
			if ( locName == "" || InStr(locName, ObjName) != -1 )
				return class'TeamGame'.Default.NearString @ ObjName;
			return class'TeamGame'.Default.NearString @ ObjName @ locName;
		}
		else if ( xPickupBase(Closest) != None && xPickupBase(Closest).Powerup != None ) {
			where = Level.Game.FindTeamDesignation(Level.Game.GameReplicationInfo, Closest);

			if ( locName == "" )
				return class'TeamGame'.Default.NearString @ where $ bestNear;
			return class'TeamGame'.Default.NearString @ where $ bestNear @ locName;
		}
	}
	return locName;

} // GetLocationName


//=============================================================================
// GetPickupName
//
// Returns a localized string for a pickup's name.
//=============================================================================

function string GetPickupName(class<Pickup> PickupClass)
{
	local int i;

	for (i = 0; i < Items.Length; i++) {
		if ( Items[i].ItemClass == PickupClass.Name )
			return Items[i].ItemName;
	}
	if ( PickupClass.default.InventoryType != None )
		return PickupClass.default.InventoryType.static.StaticItemName();
	return "";
}


//== GetPickupLocationName ===========================================================
/**
Returns a pickup base's location name.
*/
//=============================================================================

function string GetPickupLocationName(xPickupBase Base)
{
	local int i;

	if ( Base == None )
		return "";

	if ( PickupBases.Length == 0 )
		InitPickupBaseCache();

	for (i = 0; i < PickupBases.Length; i++) {
		if ( Base == PickupBases[i].Base && PickupBases[i].LocationName != "" ) {
			if ( Base.IsA('WildCardBase') || Base.IsA('MultiPickupBase') )
				return "(" $ StringNameWildcardBase $ "/" $ class'WIR_Util'.static.Trim(PickupBases[i].LocationName) $ ")";
			return "(" $ class'WIR_Util'.static.Trim(PickupBases[i].LocationName) $ ")";
		}
	}
	if ( Base.IsA('WildCardBase') || Base.IsA('MultiPickupBase') )
		return "(" $ StringNameWildcardBase $ ")";
	return "";
}


//== Reset ====================================================================
/**
Report a game reset.
*/
//=============================================================================

function Reset()
{
	bNewRound = True;
	bVolumesInitialized = False;  // power link setup might have changed, which involves renaming locations
}


//== ServerTraveling ==========================================================
/**
Detect an upcoming map change.
*/
//=============================================================================

function ServerTraveling(string NextURL, bool bItems)
{
	Super.ServerTraveling(NextURL, bItems);

	GotoState('PreTravel');
} // ServerTraveling


//== MatchStarting ============================================================
/**
Called when the match starts.
*/
//=============================================================================

function MatchStarting()
{
	bMatchStarted = True;
	NextScoreReportTime = MyGameHandler.ScoreReportDelay;
	if ( bSetReportChannelTopic && ReportConnection != None && ReportConnection.IsInState('InChannel') )
		ReportConnection.UpdateTopic();
}


//-----------------------------------------------------------------------------
// GameRules interface functions
//-----------------------------------------------------------------------------

//== RoundHasEnded ============================================================
/**
Report the end of a round.
*/
//=============================================================================

function RoundHasEnded()
{
	local string Msg, Reason;

	if ( ReportConnection != None && !MyGameHandler.HandleEndRound(Reason) ) {
		Msg = Repl(MsgGameRoundEnded, "%r", MyGameHandler.GetRemainingTime(), True);
		if ( Reason != "" )
			Msg $= Repl(StringMsgSuffix, "%m", Reason, True);
		ReportConnection.SendMessage(Msg, True);
		bReportScoreboard = True;
	}
}


//== ScoreKill ================================================================
/**
Report a kill.
*/
//=============================================================================

function ScoreKill(Controller Killer, Controller Killed, optional class<DamageType> DamageType)
{
	local string Msg, MsgSuffix, LocName;
	local class<Weapon> Weapon;
	local int i, AmpRunIndexKiller, AmpRunIndexKilled;

	if ( Killed != None && Killed.PlayerReplicationInfo != None && Killed.PlayerReplicationInfo.bOutOfLives )
		GameEndReason = "LastMan";

	if ( ReportConnection == None || MyGameHandler.HandleKill(Killer, Killed, DamageType, MsgSuffix) ) {
		if ( Killer == None )
			Killer = Killed;
		if ( AmpRuns.Length > 0 && Killed != None && Killer != Killed && !Killer.SameTeamAs(Killed) && Killed.bIsPlayer ) {
			AmpRunIndexKiller = -1;
			AmpRunIndexKilled = -1;
			for (i = 0; i < AmpRuns.Length; i++) {
				if (AmpRuns[i].Player == Killer.Pawn)
					AmpRunIndexKiller = i;
				if (AmpRuns[i].Player == Killed.Pawn)
					AmpRunIndexKilled = i;
			}
			if ( class<Fell>(DamageType) != None && class<DamTypeTelefragged>(DamageType) != None && AmpRunIndexKilled != AmpRunIndexKiller )
				AmpRuns[AmpRunIndexKiller].Kills++;
		}
		return;
	}
	if ( MyGameHandler.bReportWeapons && class<WeaponDamageType>(DamageType) != None && (Killer == None || Killer.Pawn == None || !Killer.Pawn.IsA('ONSMobileAssaultStation') || DamageType != class'DamTypeRocket') ) {
		// fix for Leviathan kills being reported as rocket launcher kills
		Weapon = class<WeaponDamageType>(DamageType).default.WeaponClass;
	}

	if ( Killer == None )
		Killer = Killed;
	if ( ReportConnection != None && Killed != None ) {
		if ( Killed == Killer ) {
			Msg = MsgPlayerSuicided;
			if ( class<FellLava>(DamageType) != None )
				Msg = Repl(Msg, "%s", StringSuicideLava, True);
			else if ( class<Fell>(DamageType) != None )
				Msg = Repl(Msg, "%s", StringSuicideFell, True);
			else if ( class<Drowned>(DamageType) != None )
				Msg = Repl(Msg, "%s", StringSuicideDrowned, True);
			else
				Msg = Repl(Msg, "%s", StringSuicide, True);
		}
		else if ( Killer.SameTeamAs(Killed) )
			Msg = MsgPlayerTeamKilled;
		else if ( Killed.bIsPlayer )
			Msg = MsgPlayerScoredKill;
		else return;

		AmpRunIndexKiller = -1;
		AmpRunIndexKilled = -1;
		for (i = 0; i < AmpRuns.Length; i++) {
			if (AmpRuns[i].Player == Killer.Pawn)
				AmpRunIndexKiller = i;
			if (AmpRuns[i].Player == Killed.Pawn)
				AmpRunIndexKilled = i;
		}

		if ( Weapon != None ) {
			if ( AmpRunIndexKiller != -1 ) {
				Msg $= Repl(StringSuffixWeaponAmped, "%w", Weapon.static.StaticItemName(), True);
				if ( AmpRunIndexKilled != AmpRunIndexKiller )
					AmpRuns[AmpRunIndexKiller].Kills++;
			}
			else
				Msg $= Repl(StringSuffixWeapon, "%w", Weapon.static.StaticItemName(), True);
		}
		else if ( Killer != Killed ) {
			if ( class<Fell>(DamageType) != None )
				Msg $= StringSuffixPush;
			else if ( class<DamTypeTelefragged>(DamageType) != None )
				Msg $= StringSuffixTelefrag;
			else if ( AmpRunIndexKilled != AmpRunIndexKiller )
				AmpRuns[AmpRunIndexKiller].Kills++;
		}

		if ( MyGameHandler.bReportLocations ) {
			LocName = class'WIR_Util'.static.Trim(GetLocationName(Killed));
			if ( LocName != "" )
				Msg $= Repl(StringSuffixLocation, "%l", LocName, True);
		}
		Msg = Repl(Msg, "%r", MyGameHandler.GetRemainingTime(), True);

		if ( MyGameHandler.bReportSpecial && Killer != Killed ) {
			if ( class<DamTypeRoadkill>(DamageType) != None && DamageType.default.MessageClass != None ) {
				Msg $= Repl(StringMsgSuffix, "%m", DamageType.default.MessageClass.static.GetString(
						Rand(class<DamTypeRoadkill>(DamageType).default.NumMessages)
						+ class<DamTypeRoadkill>(DamageType).default.MessageSwitchBase), True);
			}
			else if ( class<DamTypeAttackCraftPlasma>(DamageType) != None
					|| class<DamTypeAttackCraftMissle>(DamageType) != None ) {
				if ( Killed != None && Killer != Killed && Vehicle(Killed.Pawn) != None && Vehicle(Killed.Pawn).bCanFly )
					Msg $= Repl(StringMsgSuffix, "%m", class'ONSVehiclekillMessage'.static.GetString(6), True);
			}
			else if ( class<DamTypeTankShell>(DamageType) != None ) {
				if ( Killed != None && Killer != Killed && Vehicle(Killed.Pawn) != None && Vehicle(Killed.Pawn).bCanFly )
					Msg $= Repl(StringMsgSuffix, "%m", class'ONSVehiclekillMessage'.static.GetString(5), True);
			}
			else if ( class<DamTypeShockCombo>(DamageType) != None ) {
				Msg $= Repl(StringMsgSuffix, "%m", StringComboKill);
			}
			else if ( DamageType != None && DamageType.default.bAlwaysSevers && DamageType.default.bSpecial ) {
				Msg $= Repl(StringMsgSuffix, "%m", class'SpecialKillMessage'.static.GetString(), True);
			}
		}
		if ( UnrealPlayer(Killer) != None && UnrealPlayer(Killer).MultiKillLevel > 0 )
			Msg $= Repl(StringMsgSuffix, "%m", class'MultiKillMessage'.static.GetString(UnrealPlayer(Killer).MultiKillLevel), True);

		Msg = Repl(Msg, "%k", MyGameHandler.FormatPlayerName(Killer,, MyGameHandler.StringScoreTemplate), True);
		Msg = Repl(Msg, "%o", MyGameHandler.FormatPlayerName(Killed,, MyGameHandler.StringScoreTemplate), True);

		if ( MsgSuffix != "" )
			Msg $= Repl(StringMsgSuffix, "%m", MsgSuffix, True);

		if ( AmpRunIndexKilled != -1 ) {
			if ( AmpRuns[AmpRunIndexKilled].Kills == 0 )
				Msg $= Repl(StringAmpRunStoppedNoKills, "%t", int(Round((Level.TimeSeconds - AmpRuns[AmpRunIndexKilled].StartTime) / Level.TimeDilation)), True);
			else if ( AmpRuns[AmpRunIndexKilled].Kills == 1 )
				Msg $= Repl(StringAmpRunStoppedOneKill, "%t", int(Round((Level.TimeSeconds - AmpRuns[AmpRunIndexKilled].StartTime) / Level.TimeDilation)), True);
			else
				Msg $= Repl(Repl(StringAmpRunStopped, "%k", AmpRuns[AmpRunIndexKilled].Kills, True), "%t", int(Round((Level.TimeSeconds - AmpRuns[AmpRunIndexKilled].StartTime) / Level.TimeDilation)), True);
			AmpRuns.Remove(AmpRunIndexKilled, 1);
		}

		if ( Killed.PlayerReplicationInfo != None && Killed.PlayerReplicationInfo.bOutOfLives && MyGameHandler.bAnnounceOutOfLives )
			Msg $= Repl(StringPlayerIsOut, "%p", MyGameHandler.FormatPlayerName(Killed, True), True);

		ReportConnection.SendMessage(Msg);
	}
} // ScoreKill


//== ScoreObjective ===========================================================
/**
Report a goal, capture, etc.
*/
//=============================================================================

function ScoreObjective(Controller Scorer, int Score)
{
	if ( MyGameHandler != None )
		MyGameHandler.ScoreObjective(Scorer, Score);
}


//== Pickup ===================================================================
/**
Report a pickup.
*/
//=============================================================================

function Pickup(Controller Other, Pickup Item)
{
	local int i;
	local string Msg;
	local bool bColor;

	if ( Other == None || Other.PlayerReplicationInfo == None || Item == None || MyGameHandler.ReportPickups == 0 )
		return;

	for (i = 0; i < Items.Length; i++)
		if ( Item.IsA(Items[i].ItemClass) && (MyGameHandler.ReportPickups > 1 || Items[i].Important) ) {
			Msg = Repl(MsgPlayerPickup, "%i", Items[i].ItemName, True);
			bColor = True;
			break;
		}
	if ( Msg == "" && Item.IsSuperItem() && MyGameHandler.ReportPickups > 1 )
		Msg = Repl(MsgPlayerPickup, "%i", Item.InventoryType.static.StaticItemName(), True);

	if ( Msg != "" ) {
		if ( bColor )
			Msg = Repl(Msg, "%c", Items[i].IRCColor, True);
		else
			Msg = Repl(Msg, "%c", "", True);
		Msg = Repl(Msg, "%r", MyGameHandler.GetRemainingTime(), True);
		if ( MyGameHandler.bReportLocations )
			Msg $= Repl(StringSuffixLocation, "%l", GetPickupLocationName(Item.PickupBase), True);
		Msg = Repl(Msg, "%p", MyGameHandler.FormatPlayerName(Other,, MyGameHandler.StringScoreTemplate), True);
		ReportConnection.SendMessage(Msg);
	}
} // Pickup


//== static FillPlayInfo ======================================================
/**
Add the configuration options to the PlayInfo.
*/
//=============================================================================

static function FillPlayInfo(PlayInfo PlayInfo)
{
	local int i;

	GetGameHandlerClass(PlayInfo.GetGameInfo()).static.FillPlayInfo(PlayInfo);
	PlayInfo.PopClass();

	class'WIR_ModHandler'.static.FillPlayInfo(PlayInfo);
	PlayInfo.PopClass();

	for (i = 0; i < default.ModHandlerClasses.Length; ++i) {
		default.ModHandlerClasses[i].static.FillPlayInfo(PlayInfo);
		PlayInfo.PopClass();
	}

	Super.FillPlayInfo(PlayInfo);

	// Reporter Bot
	PlayInfo.AddSetting(default.ReporterGroup, "bEnableReporter",            default.lblEnableReporter, 4, 10, "Check");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportServerName",           default.lblReportServerName, 4, 16, "Text", "60");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportServerPort",           default.lblReportServerPort, 4, 18, "Text", "5;1:65535");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportServerPassword",       default.lblReportServerPassword, 4, 20, "Text", "20");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportUserNick",             default.lblReportUserNick, 4, 22, "Text", "30");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportUserIdent",            default.lblReportUserIdent, 4, 24, "Text", "10");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportChannel",              default.lblReportChannel, 4, 28, "Text", "60");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportChannelKey",           default.lblReportChannelKey, 4, 29, "Text", "60");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportStripCodes",           default.lblReportStripCodes, 4, 30, "Select", default.dataStripCodes);
	PlayInfo.AddSetting(default.ReporterGroup, "bSetReportChannelTopic",     default.lblSetReportChannelTopic, 4, 31, "Check");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportChannelTopicTemplate", default.lblReportChannelTopicTemplate, 4, 32, "Text", "200");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportChannelTopicBotPart",  default.lblReportChannelTopicBotPart, 4, 33, "Text", "100");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportChannelTopicBotIdle",  default.lblReportChannelTopicBotIdle, 4, 34, "Text", "150");
	PlayInfo.AddSetting(default.ReporterGroup, "ReportChannelTopicUserPart", default.lblReportChannelTopicUserPart, 4, 35, "Text", "150");
	PlayInfo.AddSetting(default.ReporterGroup, "MaxLevelChangeDelay",        default.lblMaxLevelChangeDelay, 4, 36, "Text", "3;0:120");

	PlayInfo.AddSetting(default.ReporterGroup, "Items", default.lblItems, 4, 36, "Text");

	// Chat Relay Bot
	PlayInfo.AddSetting(default.ChatRelayGroup, "bEnableChatbot",           default.lblEnableChatbot, 4, 40, "Check");
	PlayInfo.AddSetting(default.ChatRelayGroup, "bEnableTwoWayChat",        default.lblEnableTwoWayChat, 4, 42, "Check");
	PlayInfo.AddSetting(default.ChatRelayGroup, "bChatToGameAsTeamSay",     default.lblChatToGameAsTeamSay, 4, 43, "Check");
	PlayInfo.AddSetting(default.ChatRelayGroup, "bChatThroughReporter",     default.lblChatThroughReporter, 4, 44, "Check");
	PlayInfo.AddSetting(default.ChatRelayGroup, "ChatServerName",           default.lblChatServerName, 4, 46, "Text", "60");
	PlayInfo.AddSetting(default.ChatRelayGroup, "ChatServerPort",           default.lblChatServerPort, 4, 48, "Text", "5;1:65535");
	PlayInfo.AddSetting(default.ChatRelayGroup, "ChatServerPassword",       default.lblChatServerPassword, 4, 50, "Text", "20");
	PlayInfo.AddSetting(default.ChatRelayGroup, "ChatUserNick",             default.lblChatUserNick, 4, 52, "Text", "30");
	PlayInfo.AddSetting(default.ChatRelayGroup, "ChatUserIdent",            default.lblChatUserIdent, 4, 54, "Text", "10");
	PlayInfo.AddSetting(default.ChatRelayGroup, "ChatChannel",              default.lblChatChannel, 4, 58, "Text", "60");
	PlayInfo.AddSetting(default.ChatRelayGroup, "ChatChannelKey",           default.lblChatChannelKey, 4, 59, "Text", "60");
	PlayInfo.AddSetting(default.ChatRelayGroup, "ChatStripCodes",           default.lblChatStripCodes, 4, 60, "Select", default.dataStripCodes);
	PlayInfo.AddSetting(default.ChatRelayGroup, "ChatTrigger",              default.lblChatTrigger, 4, 61, "Text", "10");
	PlayInfo.AddSetting(default.ChatRelayGroup, "SpecOnlyChatTrigger",      default.lblSpecOnlyChatTrigger, 4, 62, "Text", "10");
	PlayInfo.AddSetting(default.ChatRelayGroup, "bChatReceiveOnlyText",     default.lblChatReceiveOnlyText, 4, 63, "Check");
	PlayInfo.AddSetting(default.ChatRelayGroup, "ColorCodeReplacements",    default.lblColorCodeReplacements, 4, 64, "Text", "60");

	// Connection Settings
	PlayInfo.AddSetting(default.FriendlyName, "FloodProtectCommandPenalty", default.lblFloodProtectCommandPenalty, 4, 80, "Text", "4;0:9999");
	PlayInfo.AddSetting(default.FriendlyName, "FloodProtectMessagePenalty", default.lblFloodProtectMessagePenalty, 4, 81, "Text", "4;0:9999");
	PlayInfo.AddSetting(default.FriendlyName, "FloodProtectMaxPenalty",     default.lblFloodProtectMaxPenalty, 4, 82, "Text", "2;0:30");
	PlayInfo.AddSetting(default.FriendlyName, "FloodProtectBytes",          default.lblFloodProtectBytes, 4, 83, "Text", "4;128:1024");
	PlayInfo.AddSetting(default.FriendlyName, "FloodProtectBytesDuration",  default.lblFloodProtectBytesDuration, 4, 84, "Text", "2;0:30");
	PlayInfo.AddSetting(default.FriendlyName, "MaxLenMessageQueue",         default.lblMaxLenMessageQueue, 4, 85, "Text", "3;0:100");
	PlayInfo.AddSetting(default.FriendlyName, "bAutoReconnect",             default.lblAutoReconnect, 4, 86, "Check");
	PlayInfo.AddSetting(default.FriendlyName, "ReconnectDelay",             default.lblReconnectDelay, 4, 88, "Text", "3;1:600");
	PlayInfo.AddSetting(default.FriendlyName, "bAutoRejoin",                default.lblAutoRejoin, 4, 87, "Check");
	PlayInfo.AddSetting(default.FriendlyName, "ConnectTimeout",             default.lblConnectTimeout, 4, 88, "Text", "3;10:600");
	PlayInfo.AddSetting(default.FriendlyName, "DebugLogFileName",           default.lblDebugLogFileName, 254, 254, "Text", "100");
	PlayInfo.AddSetting(default.FriendlyName, "bDebugStartMatch",           default.lblDebugStartMatch, 4, 255, "Check");

	// Auth
	PlayInfo.AddSetting(default.FriendlyName, "bAuth",          default.lblAuth,          4, 91, "Check");
	PlayInfo.AddSetting(default.FriendlyName, "bChallengeAuth", default.lblChallengeAuth, 4, 92, "Check");
	PlayInfo.AddSetting(default.FriendlyName, "bHideRealHost",  default.lblHideRealHost,  4, 93, "Check");
	PlayInfo.AddSetting(default.FriendlyName, "AuthNick",       default.lblAuthNick,      254, 94, "Text", "15", "A");
	PlayInfo.AddSetting(default.FriendlyName, "AuthPassword",   default.lblAuthPassword,  254, 95, "Text", "15", "A");

} // FillPlayInfo


//== static GetDescriptionText ================================================
/**
Returns a description for the specified configuration option.
*/
//=============================================================================

static event string GetDescriptionText(string PropertyName)
{
	switch (PropertyName) {
		case "bEnableReporter":             return default.descEnableReporter;
		case "ReportServerName":            return default.descReportServerName;
		case "ReportServerPort":            return default.descReportServerPort;
		case "ReportServerPassword":        return default.descReportServerPassword;
		case "ReportUserNick":              return default.descReportUserNick;
		case "ReportUserIdent":             return default.descReportUserIdent;
		case "ReportChannel":               return default.descReportChannel;
		case "ReportChannelKey":            return default.descReportChannelKey;
		case "ReportStripCodes":            return default.descReportStripCodes;
		case "bSetReportChannelTopic":      return default.descSetReportChannelTopic;
		case "ReportChannelTopicTemplate":  return default.descReportChannelTopicTemplate;
		case "ReportChannelTopicBotPart":   return default.descReportChannelTopicBotPart;
		case "ReportChannelTopicBotIdle":   return default.descReportChannelTopicBotIdle;
		case "ReportChannelTopicUserPart":  return default.descReportChannelTopicUserPart;
		case "MaxLevelChangeDelay":         return default.descMaxLevelChangeDelay;

		case "bEnableChatbot":        return default.descEnableChatbot;
		case "bEnableTwoWayChat":     return default.descEnableTwoWayChat;
		case "bChatToGameAsTeamSay":  return default.descChatToGameAsTeamSay;
		case "bChatThroughReporter":  return default.descChatThroughReporter;
		case "ChatServerName":        return default.descChatServerName;
		case "ChatServerPort":        return default.descChatServerPort;
		case "ChatServerPassword":    return default.descChatServerPassword;
		case "ChatUserNick":          return default.descChatUserNick;
		case "ChatUserIdent":         return default.descChatUserIdent;
		case "ChatChannel":           return default.descChatChannel;
		case "ChatChannelKey":        return default.descChatChannelKey;
		case "ChatStripCodes":        return default.descChatStripCodes;
		case "ChatTrigger":           return default.descChatTrigger;
		case "SpecOnlyChatTrigger":   return default.descSpecOnlyChatTrigger;
		case "bChatReceiveOnlyText":  return default.descChatReceiveOnlyText;
		case "ColorCodeReplacements": return default.descColorCodeReplacements;

		case "FloodProtectCommandPenalty":  return default.descFloodProtectCommandPenalty;
		case "FloodProtectMessagePenalty":  return default.descFloodProtectMessagePenalty;
		case "FloodProtectMaxPenalty":      return default.descFloodProtectMaxPenalty;
		case "FloodProtectBytes":           return default.descFloodProtectBytes;
		case "FloodProtectBytesDuration":   return default.descFloodProtectBytesDuration;
		case "MaxLenMessageQueue":          return default.descMaxLenMessageQueue;
		case "bAutoReconnect":              return default.descAutoReconnect;
		case "ReconnectDelay":              return default.descReconnectDelay;
		case "bAutoRejoin":                 return default.descAutoRejoin;
		case "ConnectTimeout":              return default.descConnectTimeout;
		case "DebugLogFileName":            return default.descDebugLogFileName;
		case "bDebugStartMatch":            return default.descDebugStartMatch;

		case "bAuth":           return default.descAuth;
		case "bChallengeAuth":  return default.descChallengeAuth;
		case "bHideRealHost":   return default.descHideRealHost;
		case "AuthNick":        return default.descAuthNick;
		case "AuthPassword":    return default.descAuthPassword;

		case "Items":           return default.descItems;
	}

	return Super.GetDescriptionText(PropertyName);

} // GetDescriptionText


//=============================================================================
// Default properties
//=============================================================================

defaultproperties
{
	FriendlyName  = "Wormbot v3"
	GroupName     = "IRC Reporter"
	Description   = "Wormbo's IRC Reporter Bot"
	Build         = "%%%%-%%-%% %%:%%"

	bEnableReporter           = False
	ReportServerName          = "irc.quakenet.org"
	ReportServerPort          = 6667
	ReportServerPassword      = ""
	ReportUserNick            = "RenameMe"
	ReportUserIdent           = "wormbot"
	ReportChannel             = ""
	ReportChannelKey          = ""
	bSetReportChannelTopic      = False
	ReportChannelTopicTemplate  = "%%userpart%%[^O] [^B]|[^B] Reporting: %%botpart%%"
	ReportChannelTopicBotPart   = "[^B]%%game%%[^B] on [^B]%%map%%[^B]"
	ReportChannelTopicBotIdle   = "No match in progress."
	ReportChannelTopicUserPart  = "No user topic set."
	MaxLevelChangeDelay         = 60

	bEnableChatBot          = False
	bEnableTwoWayChat       = False
	bChatToGameAsTeamSay    = False
	bChatThroughReporter    = True
	ChatServerName          = "irc.quakenet.org"
	ChatServerPort          = 6667
	ChatServerPassword      = ""
	ChatUserNick            = "RenameMe"
	ChatUserIdent           = "wormbot"
	ChatChannel             = ""
	ChatChannelKey          = ""
	ChatTrigger             = ""
	SpecOnlyChatTrigger     = ""
	bChatReceiveOnlyText    = True
	ColorCodeReplacements   = "[^K]14 [^K]04 [^K]03 [^K]07 [^K]12 [^K]13 [^K]10 [^K]15"

	bAutoReconnect  = True
	ReconnectDelay  = 10
	bAutoRejoin     = True
	ConnectTimeout  = 60

	DebugLogFileName = ""
	bDebugStartMatch = False

	FloodProtectCommandPenalty  = 2000
	FloodProtectMessagePenalty  = 2750
	FloodProtectMaxPenalty      = 10
	FloodProtectBytes           = 512
	FloodProtectBytesDuration   = 10
	MaxLenMessageQueue          = 30

	bAuth           = False
	bChallengeAuth  = True
	bHideRealHost   = True
	AuthNick        = ""
	AuthPassword    = ""

	Items[0]  = (ItemClass=UDamagePack,ItemName="Double Damage",Important=True,IRCColor=13)
	Items[1]  = (ItemClass=ShieldPack,ItemName="Shield Pack",Important=False,IRCColor=7)
	Items[2]  = (ItemClass=SuperShieldPack,ItemName="Super Shield Pack",Important=True,IRCColor=7)
	Items[3]  = (ItemClass=SuperHealthPack,ItemName="Big Keg O' Health",Important=True,IRCColor=12)
	Items[4]  = (ItemClass=RedeemerPickup,ItemName="Redeemer",Important=True,IRCColor=10)
	Items[5]  = (ItemClass=PainterPickup,ItemName="Ion Painter",Important=True,IRCColor=10)
	Items[6]  = (ItemClass=GravBeltPickup,ItemName="Grav Belt",Important=True,IRCColor=14)
	Items[7]  = (ItemClass=JumpbootsPickup,ItemName="Jump Boots",Important=True,IRCColor=12)
	Items[8]  = (ItemClass=VortexPickup,ItemName="Gravity Vortex",Important=True,IRCColor=10)
	Items[9]  = (ItemClass=ChaosRelicPickup_Armor,ItemName="Chaos Relic of Protection",Important=True,IRCColor=7)
	Items[10] = (ItemClass=ChaosRelicPickup_Damage,ItemName="Chaos Relic of Strength",Important=True,IRCColor=4)
	Items[11] = (ItemClass=ChaosRelicPickup_Regen,ItemName="Chaos Relic of Regeneration",Important=True,IRCColor=3)
	Items[12] = (ItemClass=ChaosRelicPickup_Speed,ItemName="Chaos Relic of Speed",Important=True,IRCColor=12)
	Items[13] = (ItemClass=ChaosRelicPickup_Vampire,ItemName="Chaos Relic of Vampirism",Important=True,IRCColor=6)
	Items[14] = (ItemClass=ChaosRelicPickup_Vengeance,ItemName="Chaos Relic of Vengeance",Important=True,IRCColor=7)

	// templates for reporter bot
	MsgGameReset      = "[^B][%r] A new round has begun[^B]"
	MsgGameRoundEnded = "[^B][%r] The round has ended[^B]"
	MsgGameEnded      = "[^B][%r] The match has ended[^B]"
	MsgGameEvent      = "[%r] - [^B]%m[^B]"
	MsgQuitMapChange  = "Next match: [^B]%g[^B] on [^B]%m[^B]"

	MsgPlayerConnected              = "[%r] %p[^O] connected to the server"
	MsgPlayerConnectedSpectator     = "[%r] %p[^O] connected as spectator"
	MsgPlayerDisconnected           = "[%r] %p[^O] disconnected from the server"
	MsgPlayerWasKicked              = "[%r] %p[^O] was kicked from the server by %m"
	MsgPlayerChangedTeam            = "[%r] %p[^O] has joined [^B]%t[^O]"
	MsgPlayerChangedName            = "[%r] %o[^O] changed nick to %n[^O]"
	MsgPlayerChat                   = "(%r) %p[^O]: %m"
	MsgPlayerScoredKill             = "[%r] %k[^O] killed %o[^O]"
	MsgPlayerSuicided               = "[%r] %k[^O] %s"
	MsgPlayerTeamKilled             = "[%r] %k[^O] team-killed %o[^O]"
	MsgPlayerPickup                 = "[%r] %p[^O] picked up the [^K]%c[^B]%i[^O]"

	MsgPlayerIsFlakMonkey     = "[%r] - %p[^O] is a [^B]Flak Monkey[^B]"
	MsgPlayerIsComboWhore     = "[%r] - %p[^O] is a [^B]Combo Whore[^B]"
	MsgPlayerIsHeadHunter     = "[%r] - %p[^O] is a [^B]Head Hunter[^B]"
	MsgPlayerIsOnRoadRampage  = "[%r] - %p[^O] is on a [^B]Road Rampage[^B]"
	MsgPlayerFinishedAmpRun   = "[%r] - %p[^O] finished the [^B][^K]13Amp Run[^K][^B] after %k kills"
	MsgPlayerFinishedAmpRunNoKills  = "[%r] - %p[^O] wasted the [^B][^K]13Amp Run[^K][^B]"
	MsgPlayerFinishedAmpRunOneKill  = "[%r] - %p[^O] finished the [^B][^K]13Amp Run[^K][^B] after only one kill"

	MsgTeamScored               = "[^B][%r][^B] %t scored [^B]%d[^B] and now has [^B]%s[^B]"
	MsgTeamScoredTied           = "[^B][%r][^B] %t scored [^B]%d[^B] and is now tied for the lead with %l at [^B]%s[^B]"
	MsgTeamScoredTakesLead      = "[^B][%r][^B] %t scored [^B]%d[^B] and takes the lead with [^B]%s[^B]"
	MsgTeamScoredIncreasesLead  = "[^B][%r][^B] %t increases the lead by [^B]%d[^B] and now has [^B]%s[^B]"
	//MsgTeamScoredBehind         = "[^B][%r][^B] %t scored [^B]%d[^B] and now has [^B]%s[^B]"
	MsgLeadersTied              = "[^B][%r][^B] %t are tied for the lead with [^B]%s[^B]"
	MsgTakesLead                = "[^B][%r][^B] %t takes the lead with [^B]%s[^B]"

	StringMsgSuffix         = " - [^B]%m[^O]"
	StringSuffixHattrick    = "Hattrick!"
	StringComboKill         = "Combo Kill"
	StringAmpRunStopped     = " - [^B][^K]13Amp Run[^K] stopped[^B] after %t seconds (%k kills)"
	StringAmpRunStoppedOneKill  = " - [^B][^K]13Amp Run[^K] stopped[^B] after %t seconds (1 kill)"
	StringAmpRunStoppedNoKills  = " - [^B][^K]13Amp Run[^K] stopped[^B] after %t seconds (no kills)"
	StringPlayerIsOut       = " - %p[^O] is [^B]OUT[^B]"
	StringSuffixWeapon      = " with the [^B]%w[^B]"
	StringSuffixWeaponAmped = " with the [^K]13[^B]%w[^O]"
	StringSuffixPush        = " with a little push"
	StringSuffixTelefrag    = " with a [^B]telefrag[^B]"
	StringSuffixLocation    = " %l"
	StringSuicide           = "suicided"
	StringSuicideDrowned    = "drowned"
	StringSuicideFell       = "left a small crater"
	StringSuicideLava       = "crashed and burned"
	StringNameGame          = "the game"
	StringNameSpectators    = "the spectators"
	StringNameWildcardBase  = "Wildcard Pickup Base"

	// templates for chat proxy
	TemplateMessage = "<%u> %m"
	TemplateAction  = "* %u %m"
	TemplateNick    = "*** %u is now %n"
	TemplateJoin    = "*** %u joined the channel"
	TemplatePart    = "*** %u left the channel"
	TemplateQuit    = "*** %u left IRC"
	TemplateKick    = "*** %k was kicked by %u"
	TemplateWait    = "*** Waiting for the IRC reporter bot to finish..."

	// webadmin labels
	ReporterGroup   = "Wormbot Reporter"
	ChatRelayGroup  = "Wormbot Chat"

	lblEnableReporter             = "Enable IRC Reporter Bot"
	lblReportServerName           = "IRC server address"
	lblReportServerPort           = "IRC server port"
	lblReportServerPassword       = "IRC server password"
	lblReportUserNick             = "Nick"
	lblReportUserIdent            = "Ident"
	lblReportChannel              = "IRC channel"
	lblReportChannelKey           = "IRC channel key"
	lblReportStripCodes           = "Strip codes"
	lblSetReportChannelTopic      = "Set report channel topic"
	lblReportChannelTopicTemplate = "Channel topic template"
	lblReportChannelTopicBotPart  = "Channel topic (reporting)"
	lblReportChannelTopicBotIdle  = "Channel topic (idle)"
	lblReportChannelTopicUserPart = "Channel topic (no user topic)"
	lblMaxLevelChangeDelay        = "Max. Level Change Delay"

	lblEnableChatBot            = "Enable IRC Chat Bot"
	lblEnableTwoWayChat         = "Enable two-way chat"
	lblChatToGameAsTeamSay      = "Chat to game as TeamSay"
	lblChatThroughReporter      = "Chat through reporter bot"
	lblChatServerName           = "IRC server address"
	lblChatServerPort           = "IRC server port"
	lblChatServerPassword       = "IRC server password"
	lblChatUserNick             = "Nick"
	lblChatUserIdent            = "Ident"
	lblChatChannel              = "IRC channel"
	lblChatChannelKey           = "IRC channel key"
	lblChatStripCodes           = "Strip codes"
	lblChatTrigger              = "IRC trigger string"
	lblSpecOnlyChatTrigger      = "IRC spectator-only trigger string"
	lblChatReceiveOnlyText      = "Receive only text"
	lblColorCodeReplacements    = "Color code replacements"

	lblAuth           = "(Auth) Auth on Quakenet"
	lblChallengeAuth  = "(Auth) Use Challenge Auth"
	lblHideRealHost   = "(Auth) Hide real host"
	lblAuthNick       = "(Auth) Nick"
	lblAuthPassword   = "(Auth) Password"

	lblFloodProtectCommandPenalty = "(Connection) Flood protect command penalty"
	lblFloodProtectMessagePenalty = "(Connection) Flood protect message penalty"
	lblFloodProtectMaxPenalty     = "(Connection) Flood protect max. penalty"
	lblFloodProtectBytes          = "(Connection) Flood protect bytes"
	lblFloodProtectBytesDuration  = "(Connection) Flood protect bytes duration"
	lblMaxLenMessageQueue         = "(Connection) Max. message queue length"

	lblAutoReconnect  = "(Connection) Auto-reconnect"
	lblReconnectDelay = "(Connection) Reconnect Delay"
	lblConnectTimeout = "(Connection) Connect timeout"
	lblAutoRejoin     = "(Connection) Auto-rejoin"

	lblDebugLogFileName = "(Debug) Log file name"
	lblDebugStartMatch  = "(Debug) Auto-start match"

	lblItems = "(Reporter) Item names"

	// webadmin descriptions
	descEnableReporter              = "Enables the IRC event reporter bot."
	descReportServerName            = "IP address or DNS name of the reporter bot's IRC server."
	descReportServerPort            = "Port number of the reporter bot's IRC server."
	descReportServerPassword        = "Password required to connect to the reporter bot's IRC server."
	descReportUserNick              = "Nick name the reporter bot should use."
	descReportUserIdent             = "Ident the reporter bot should use."
	descReportChannel               = "Channel the reporter bot will send events to."
	descReportChannelKey            = "Key required to join the reporter bot's channel."
	descReportStripCodes            = "Whether the bot should strip colors or all codes from its messages to get around channel mode +c."
	descSetReportChannelTopic       = "The reporter bot should set the topic of the channel it reports to."
	descReportChannelTopicTemplate  = "The topic template. %%botpart%% is where the bot inserts match details, %%userpart%% is where channel ops can insert a topic."
	descReportChannelTopicBotPart   = "Template for the match details if there's a match in progress."
	descReportChannelTopicBotIdle   = "Message to insert insead of the match details if no match is in progress."
	descReportChannelTopicUserPart  = "Default text for the user part of the topic."
	descMaxLevelChangeDelay         = "Maximum number of seconds the reporter bot is allowed to delay a map change."

	descEnableChatBot           = "Enables the IRC chat relay bot."
	descEnableTwoWayChat        = "Allows players to see IRC chat."
	descChatToGameAsTeamSay     = "Display IRC chat only to spectators in team games."
	descChatThroughReporter     = "Reuse the reporter bot's IRC connection for chat, if available."
	descChatServerName          = "IP address or DNS name of the chat bot's IRC server."
	descChatServerPort          = "Port number of the chat bot's IRC server."
	descChatServerPassword      = "Password required to connect to the chat bot's IRC server."
	descChatUserNick            = "Nick name the chat bot should use."
	descChatUserIdent           = "Ident the chat bot should use."
	//descChatRegistrationHandler = "Class that will handle registering the chat bot on the IRC network."
	descChatChannel             = "Channel the chat bot will send events to."
	descChatChannelKey          = "Key required to join the chat bot's channel."
	descChatStripCodes          = "Whether the bot should strip colors or all codes from its messages to get around channel mode +c."
	descChatTrigger             = "Trigger string required if a text message should be seen in the game, e.g. '!say'."
	descSpecOnlyChatTrigger     = "Trigger string required if a text message should be seen by spectators in the game, e.g. '!say'."
	descChatReceiveOnlyText     = "The Chat Replay Bot should only send text to the game, no nick changes or users entering/leaving the channel."
	descColorCodeReplacements   = "List of replacement strings for UTComp color codes. Values are space-separated."

	descAuth          = "The bot(s) will try to auth when connecting to Quakenet."
	descChallengeAuth = "The bot(s) will use Challenge Auth so the password will never be sent in plain text."
	descHideRealHost  = "The bot(s) will set user mode +x and only join the report/chat channel(s) after they have authed."
	descAuthNick      = "The user name the bot(s) should auth with."
	descAuthPassword  = "The password associated with the auth nick."

	descFloodProtectCommandPenalty  = "How much each command increases the delay. (in milliseconds)"
	descFloodProtectMessagePenalty  = "How much each text message increases the delay. (in milliseconds)"
	descFloodProtectMaxPenalty      = "How much line delay is allowed."
	descFloodProtectBytes           = "How many bytes max should be sent in a short time interval."
	descFloodProtectBytesDuration   = "How long is the time interval for the byte count flood check."
	descMaxLenMessageQueue          = "How many messages may be in the message queue before the whole queue is dropped to catch up with gameplay."

	descAutoReconnect   = "Automatically reconnect after connection failure."
	descReconnectDelay  = "The bot will wait for this time before trying to reconnect to the IRC server."
	descConnectTimeout  = "Wait this long before considering a connection attempt to have timed out."
	descAutoRejoin      = "Automatically rejoin channel after getting kicked. Otherwise wait for invite."

	descDebugLogFileName  = "Name of the log file the raw IRC traffic is written to."
	descDebugStartMatch   = "Force-start the match once the reporter bot has joined the channel."

	descItems = "A list of pickup classes and their corresponding item names."

	dataStripCodes  = "0;None;1;Colors;2;All"
}