//=============================================================================//
// Map Vote Mutator v0.5     Copyright(C) 2005  Adam Mummery-Smith     B.S.E.  //
//=============================================================================//

class MapVoteController extends U2PlayerController;

//=============================================================================//
// Class:        MapVoteController      | Date:    December 2005               //
//-----------------------------------------------------------------------------//
// Project:      Map Vote Mutator       | Author:  Adam Mummery-Smith          //
//-----------------------------------------------------------------------------//
// Description:  This class adds the user-interaction part to the map vote     //
//               system, since it contains the exec functions which makes it   //
//               all possible... but you knew that - didn't you?               //
//-----------------------------------------------------------------------------//
// Usage:        N/A                                                           //
//-----------------------------------------------------------------------------//
// Note:      1) This version includes my (alpha) version of the GUI designer  //
//               that I have experimented with before as a stand-alone system. //
//               Ask me for documentation if you're interested in using this   //
//               yourself.                                                     //
//            2) explode() and implode() need a lot of work                    //
//            3) I know that over-riding the playercontroller is a bad idea    //
//               mutatorwise, but there isn't an elegant way of doing this     //
//               in any other way.                                             //
//=============================================================================//

//-----------------------------------------------------------------------------
// Load external stuff

#exec OBJ LOAD File=..\Textures\UIResT.utx

//-----------------------------------------------------------------------------
// Declarations

// HUD Plugin manages all the drawing to canvas that we require
var MapVoteHUDPlugin h;

var MapVoteGameReplicationInfo MyGRI;

// Variables which keep track of player's votes in each map
var array< struct VotedForMap { var int votedTimes; var string votedMap; } > VotedForMaps;
var int totalVotes;
var float lastVoteTime;

// Local (client-side) copy of map rotations
var string VoteableMaps[10], next;
var array<string> MapsInRotation;
var array<string> AllMaps;

// Server-side variables used to control dumping of AllMaps to clients
var string ReplicatedMapList[20];
var int ReplicatedMapListSize, currentSegment;
var bool bSendingMaplist, bSentMapList;

// Make sure we only draw the ASCII logo once
var bool logodone;

// Error messages
var localized string QueuedMapMsg, AlreadyQueuedMsg;					// a map is already queued
var localized string TooManyRequestsMsg, TooManyIdenticalRequestsMsg;	// too many votes
var localized string TooSoonToVoteMsg;									// wait until delay has passed

// Voting UI Support
var config bool DisableGUI;			// Set true to use the old-style command-line interface
var config int VoteGUINumRows;		// Number of rows to display in the vote GUI

var bool bDisplayMapChooser;		// Set as a flag to let the HUD plugin know we want to
                                    // display the vote GUI
var config Sound MapVoteScrollSound;
var config Sound MapVoteClickSound;

var config string voteStyle;		// Type of mapvote interface to use
var string voteStyles[3];

// Voting UI localized text strings
var localized string MapVoteWindowTitle, MapVoteHelpLine1, MapVoteHelpLine2;

// MapVote Graphical Config Support
var array< struct ConfigLine { var() string Description; var() string Value; var() string HelpText1; var() string HelpText2; } > ConfigLines;
var bool bDisplayConfigGUI, bConfigGUIInitDone;
var int cfgPos;

var localized string MapVoteConfigWindowTitle;

// 'Internal' variables which control the voting GUI
var array< struct VoteLine { var() int Num; var() String Text; var() bool AdminOnly; var() Color Colour; } > VoteLines;
var int pos, start, total;
var int linespacing, numspacing, bracketspacing;

//=============================================================================//
// GUI Editing Support                                                         //
//-----------------------------------------------------------------------------//
// This is used to place GUI elements in-game to help with designing the GUI   //
// for a particular mutator. It's a bit cobbled at the moment and relies on a  //
// lot of EXEC functions, but is certainly easier than adding all the GUI      //
// components programatically and positioning them using trial and error.      //
//=============================================================================//

// // Flag which says we're in GUI editing mode
// var() config bool bGUIEdit;
//
// // Array of GUI elements that we will work with
// var() config array< struct GUIElement {	var() bool bDisplayed;
// 										var() Material mat;
// 										var() float top;
// 										var() float left;
// 										var() float xSize;
// 										var() float ySize;
// 										var() float u;
// 										var() float v;
// 										var() float uSize;
// 										var() float vSize;
// 										var() int alpha; } >	GUIElements;
//
// // Element currently being edited
// var() config int currentElement;
//
// // Parameter currently being edited
// var() enum EEditType {
//     ET_Position,
//     ET_Size,
// 	   ET_UV,
// 	   ET_UVSize
// } currentEditType;
// var() config int moveAmount;
//
// // The "window" is a pseudo-component designed to help determine dimensions and
// // nothing else
// var() config int windowX, windowY, windowWidth, windowHeight, windowAlpha;
// var() config bool bDisplayWindow;
// var() config Material windowMaterial;
//
// // The "cursor" is a flashing box which surrounds the current element if required
// var() config bool bDisplayCursor;        // Can be enabled/disabled
// var() config int cursorFlashRate;        // 1=slow, 100=flicker, default=70
// var() config color cursorColor;
// var float lastFlashTime;	                // Vars to keep track of when to flash
// var bool currentFlashState;
// 

//-----------------------------------------------------------------------------

replication
{
	unreliable if (Role < ROLE_Authority)
	    RequestMap, ServerDisplayMapList;

    reliable if (Role == ROLE_Authority)
    	ClientClearLocalMapList, ClientUpdateLocalMapList, ClientUpdateVotableMapList, ClientUpdateFullMapList,
		ClientDisplayGUI, ReBuildVoteLineArray, ClientNotifyVoteFailed, ClientNotifyVoteAccepted;

    reliable if (Role == ROLE_Authority)
    	next;

    reliable if (Role < ROLE_Authority)
    	DisableGUI;
}

//-----------------------------------------------------------------------------

simulated event PostNetReceive()
{
	// Make sure we have a HUD plugin on clients
	SpawnHUDPlugin();
}

//-----------------------------------------------------------------------------

// Tries to spawn the HUD plugin
simulated function SpawnHUDPlugin()
{
    if ( ViewPort(Player)? )
    {
		if (!logodone) DrawPrettyLogo();

    	if (!h?)
    	{
            Log ("MapVote: Spawning HUD Plugin");

    		h = new class 'MapVoteHUDPlugin';
    		h.Register(Level, self);

            if (h?)
            	Log ("MapVote: HUD Plugin successfully spawned");
            else
            	Log ("MapVote: HUD Plugin creation failed");
    	}
    }
}

//-----------------------------------------------------------------------------

// Does what it says on the tin
simulated exec function DrawPrettyLogo()
{
	logodone = true;

    if (Level.GetLocalPlayerController() == self)
    {
		ClientMessage("+-----------------------------------------------------------------+");
		ClientMessage("|      .-------------.    .-------------.    .-------------.      |");
		ClientMessage("|     |               |  |               |  |               |     |");
		ClientMessage("|      '---------.    |  |    .---------'   |    .---------'      |");
		ClientMessage("|      .---------'    |  |    '---------.   |    '---------.      |");
		ClientMessage("|     |              <   |               |  |               |     |");
		ClientMessage("|      '---------.    |   '---------.    |  |    .---------'      |");
		ClientMessage("|      .---------'    |   .---------'    |  |    '---------.      |");
		ClientMessage("|     |               |  |               |  |               |     |");
		ClientMessage("|      '-------------'    '-------------'    '-------------'      |");
		ClientMessage("|                                                                 |");
		ClientMessage("|        o             o                 o                        |");
		ClientMessage("|    ooooo ooooo  oooo o ooooo oooo    ooooo ooooo  oooo ooooo    |");
		ClientMessage("|    o   o o ooo ooooo o o   o o   o     o   o ooo ooo o o o o    |");
		ClientMessage("|    ooo o oooo  oooo  o ooooo o   o     ooo oooo  ooooo o o o    |");
		ClientMessage("|                         oooo                                    |");
		ClientMessage("+-----------------------------------------------------------------+");
		ClientMessage("|                  MAP VOTE MUTATOR  VERSION 0.5                  |");
		ClientMessage("+-----------------------------------------------------------------+");
		ClientMessage("| Useage:                                                         |");
		ClientMessage("|    MAPVOTE    - start a map vote using the graphical interface  |");
		ClientMessage("|    MAPVOTECFG - configure MapVote options                       |");
		ClientMessage("+-----------------------------------------------------------------+");
	}
}

//-----------------------------------------------------------------------------

// Functions called by the UI to determine if a poll should be displayed

interface function bool ShowPoll() {
    MyGRI = MapVoteGameReplicationInfo(GameReplicationInfo);
    return Super.ShowPoll() && MyGRI.PendingMap == ""; }

simulated function bool ShowMapVotePoll() {
    MyGRI = MapVoteGameReplicationInfo(GameReplicationInfo);
    return bPendingVote && MyGRI? && MyGRI.PendingMap? && MyGRI.PendingMap != ""; }

simulated function bool VotedMapDeferred() {
    MyGRI = MapVoteGameReplicationInfo(GameReplicationInfo);
    return MyGRI.PendingMapDeferred; }

simulated function string GetNominatedMapName() {
    MyGRI = MapVoteGameReplicationInfo(GameReplicationInfo);
    return MyGRI.PendingMap; }

simulated function bool DisplayMapSelectionGUI() {
	return (bDisplayConfigGUI || (!DisableGUI && bDisplayMapChooser));
}

//-----------------------------------------------------------------------------

// Called by the HUD Plugin to see if we want to enable GUI editing
//simulated function bool GUIEditMode() { return bGUIEdit; }

//-----------------------------------------------------------------------------

// Console function to change mapvote GUI parameters
exec function MapVoteCfg(string command)
{
	Local Array<String> params;

	StrArray(command, " ", params);

	if (params[0] ~= "disablegui")
	{
		if (DisableGUI) return;

		DisableGUI = true;
		bDisplayMapChooser = false;
		ClearProgressMessages();
		SetProgressTime(6);
		SetProgressMessage(0, "Map Vote GUI is now disabled", class'Canvas'.Static.MakeColor(255,0,0));
		ClientMessage("Map Vote GUI is now disabled");
		SendEvent("HideConsole");
	}
	else if (params[0] ~= "enablegui")
	{
		if (!DisableGUI) return;

		DisableGUI = false;
		bDisplayMapChooser = false;
		ClearProgressMessages();
		SetProgressTime(6);
		SetProgressMessage(0, "Map Vote GUI is now enabled", class'Canvas'.Static.MakeColor(0,255,0));
		ClientMessage("Map Vote GUI is now enabled");
		SendEvent("HideConsole");
	}
	else if (params[0] ~= "menusize")
	{
		VoteGUINumRows = int(params[1]);
		pos = 0;
		start = 0;

		if (VoteGUINumRows < 3) VoteGUINumRows = 3;
		if (VoteGUINumRows > 12) VoteGUINumRows = 12;

		if (VoteGUINumRows == 0)
		{
			VoteGUINumRows = 8;
			DisableGUI = true;
		}
		else
		{
			DisableGUI = false;
		}

		SendEvent("HideConsole");
	}
	else if (params[0] ~= "style")
	{
		if (!(params[1] ~= "small") && !(params[1] ~= "verysmall")) params[1] = "normal";
		voteStyle = params[1];
		SendEvent("HideConsole");
	}
	else
	{
        bDisplayConfigGUI = !bDisplayConfigGUI;			// Show/hide the configuration GUI

        cfgPos = 0;
        ClientMessage("");
        ClientMessage("Usage: MapVoteCfg enablegui            - enables the graphical mapvote (default)");
        ClientMessage("       MapVoteCfg disablegui           - disables the graphical mapvote");
        ClientMessage("       MapVoteCfg menusize <number>    - set the number of items to display on the map vote menu");
        ClientMessage("       MapVoteCfg style <style>        - set the display style for polls: normal, small or verysmall");
        ClientMessage("");
	}

	SaveConfig();
}

//-----------------------------------------------------------------------------

// Execute a map vote or retrieve a list of maps
exec function Mapvote(optional int MapNumber, optional string param2)
{
	local bool defer, updated;
    local string MapName;
    local int i;

	// If the player specifies the "next" option, try to defer the map selection
	if (param2 ~= "next") defer = true;

	if (MapNumber < 1)
	{
		bDisplayConfigGUI = false;
        cfgPos = 0;

		if (bDisplayMapChooser)
		{
			// If GUI is currently "on", hide it
			bDisplayMapChooser = false;
		}
		else
		{
			// Otherwise, get the maplist from the server
	        ServerDisplayMapList();
	        if (DisableGUI) SendEvent("ShowConsole");
	    }
    }
    else
    {
    	// Hide the GUI
        bDisplayMapChooser = false;

		// Locate the map the player wants to vote for by searching the locally cached list
        for (i = 0; i < VoteLines.Length; i++)
        	if (VoteLines[i].Num == MapNumber) MapName = VoteLines[i].Text;

		if ( PlayerReplicationInfo.bAdmin )
		{
			// Admins aren't restricted by the normal map vote restrictions, so just make the request
	        RequestMap(MapName, defer);
	        if (DisableGUI) SendEvent("HideConsole");
		}
		else
		{
		    MyGRI = MapVoteGameReplicationInfo(GameReplicationInfo);

			if ( totalVotes >= MyGRI.maxVotesPerMap )
			{
				// If the player has exceeded the maximum allowable number of votes for this round,
				// notify them and cancel the vote request
				ClearProgressMessages();
				SetProgressTime(6);
				SetProgressMessage(0, TooManyRequestsMsg, class'Canvas'.Static.MakeColor(255,255,255));
				return;
			}
			else if (Level.TimeSeconds < MyGRI.initialVotePeriod)
			{
				// If the player has tried to vote too soon after joining the game
				ClearProgressMessages();
				SetProgressTime(6);
				SetProgressMessage(0, VotedTooSoonMessage(float(MyGRI.initialVotePeriod) - Level.TimeSeconds), class'Canvas'.Static.MakeColor(255,255,255));
				return;
			}
			else if (lastVoteTime > 0 && Level.TimeSeconds - lastVoteTime < MyGRI.betweenVotesPeriod)
			{
				// If the player has tried to vote too soon after his last vote
				ClearProgressMessages();
				SetProgressTime(6);
				SetProgressMessage(0, VotedTooSoonMessage(float(MyGRI.betweenVotesPeriod) - (Level.TimeSeconds - lastVoteTime)), class'Canvas'.Static.MakeColor(255,255,255));
				return;
			}
			else
			{
				// Next, search through the list of already voted maps to check we haven't exceeded the limit
		        for (i = 0; i < VotedForMaps.Length; i++)
		        {
		        	if (VotedForMaps[i].votedMap == MapName)
					{
						if (VotedForMaps[i].votedTimes >= MyGRI.maxIdenticalVotesPerMap)
						{
							// If the player has voted for this map too many times, display an error message
							ClearProgressMessages();
							SetProgressTime(6);
							SetProgressMessage(0, TooManyIdenticalRequestsMsg, class'Canvas'.Static.MakeColor(255,255,255));
							return;
						}
						else
						{
							// Otherwise just increment the counter
							VotedForMaps[i].votedTimes++;
							totalVotes++;
							updated = true;
						}
					}
		        }
	
		        if (!updated)
		        {
		        	// If this map hasn't been voted for before, create an entry
		        	i = VotedForMaps.Length;
		        	VotedForMaps.Insert(i, 1);
					VotedForMaps[i].votedMap = MapName;
					VotedForMaps[i].votedTimes = 1;
					totalVotes++;
				}
	
				// If all goes well, forward the request to the server
		        RequestMap(MapName, defer);
		        if (DisableGUI) SendEvent("HideConsole");
		    }
		}
	}
}

//-----------------------------------------------------------------------------

// Replicated function, executed on the server. Tries to initiate a map vote and notifies
// the user if the vote is unsuccessful (a vote is already in progress)
function RequestMap(string MapName, optional bool defer)
{
    local int result;
	local ExtendedMapList MyMapList;

	// If we've managed to retrieve a valid map name, attempt to start the poll
    if (MapName != "")
    {
	    MyMapList = ExtendedMapList(Level.Game.GetMapList(Level.Game.MapListType));
	    if (MyMapList?)
		    next = MyMapList.PredictNextMap();		// Tries to get the name of the next map in rotation
		else
			next = "unknown";
			
		if (defer && Mapname ~= next)
		{
			ClearProgressMessages();
			SetProgressTime(6);
			SetProgressMessage(0, AlreadyQueuedMessage(), class'Canvas'.Static.MakeColor(255,255,255));
			ClientNotifyVoteFailed(MapName);
		}
		else
		{
	    	result = MapVoteGameReplicationInfo(GameReplicationInfo).MapRequest(MapName, PlayerReplicationInfo, defer);

			if (result == 0)		// Poll already in progress
			{
				ClearProgressMessages();
				SetProgressTime(6);
				SetProgressMessage(0, VoteFailedMsg, class'Canvas'.Static.MakeColor(255,255,255));
				ClientNotifyVoteFailed(MapName);
			}
			else if (result == 1)   // Map already queued
			{
				ClearProgressMessages();
				SetProgressTime(6);
				SetProgressMessage(0, QueuedMapMessage(), class'Canvas'.Static.MakeColor(255,255,255));
				ClientNotifyVoteFailed(MapName);
			}
			else if (result == 2)   // Vote accepted
			{
				ClientNotifyVoteAccepted();
			}
		}
	}
}

//-----------------------------------------------------------------------------

// If a map vote fails server-side, notify the client so that we can keep track of
// the total number of votes and the votes per map
simulated function ClientNotifyVoteFailed(string MapName)
{
	local int i;

	for (i = 0; i < VotedForMaps.Length; i++)
		if (VotedForMaps[i].votedMap == MapName)
			VotedForMaps[i].votedTimes--;

	totalVotes--;
	lastVoteTime = 0;
}

//-----------------------------------------------------------------------------

// If a map vote is accepted, make a note of when
simulated function ClientNotifyVoteAccepted()
{
	lastVoteTime = Level.TimeSeconds;
}

//-----------------------------------------------------------------------------

// Called by the server to clear the locally cached map rotation list
simulated function ClientClearLocalMapList()
{
    MapsInRotation.Remove(0,MapsInRotation.Length);
}

// Called by the server to add maps to the locally cached map rotation list
simulated function ClientUpdateLocalMapList(int position, string value)
{
	MapsInRotation[position] = value;
}

// Called by the server to add maps to the locally cached votable map list
simulated function ClientUpdateVotableMapList(int position, string value)
{
	VoteableMaps[position] = value;
}

// Called by the server once maplist propogation is complete to notify the
// client to display the GUI
simulated function ClientDisplayGUI()
{
	if (!DisableGUI) bDisplayMapChooser = true;
}

// Called by the server to dump a chunk of the full map list to a client
simulated function ClientUpdateFullMapList(string MapListSegment, int segmentNumber, bool bFinalSegment)
{
	ReplicatedMapList[segmentNumber] = MapListSegment;
	explode("?", ReplicatedMapList, AllMaps);
	ReBuildVoteLineArray();
}

//-----------------------------------------------------------------------------

// Replicated function, executed on the server. Dumps the current map rotation and
// pre-defined map list to the client's console, and updates the locally cached versions.
function ServerDisplayMapList()
{
	local class<GameInfo> GameClass;
	local class<MapList> MapListClass;
	local ExtendedMapList MyMapList;
	local string spc;
	local int i, j;

	// Fetch the pre-defined map list from the ini
    class'ExtendedMapList'.static.GetPredefinedMapList(VoteableMaps);

	// Send the votable maplist to the client
	for (i = 0; i < 10; i++)
	    ClientUpdateVotableMapList(i, VoteableMaps[i]);

	GameClass = class<GameInfo>(DynamicLoadObject("U2.XMPGame", class'Class'));
	MapListClass = class<MapList>(DynamicLoadObject(GameClass.default.MapListType, class'Class'));

	if (DisableGUI)
	{
	    ClientMessage("=============================================================================");
	    ClientMessage("                           LISTING AVAILABLE MAPS                            ");
	    ClientMessage("=============================================================================");
	    ClientMessage("  Pre-defined map choices");
	    ClientMessage("-----------------------------------------------------------------------------");

		for (i = 0; i < 10; i++)
		{
			if (i == 9) spc = "   "; else spc = "    ";
	
			if (VoteableMaps[i] != "")
			{
				ClientMessage(spc $ (i + 1) $ ": " $ VoteableMaps[i]);
				j++;
			}
			else
				break;
		}
		if (j == 0) ClientMessage("                --- sorry, no pre-defined maps available ---                 ");

	    ClientMessage("=============================================================================");
	    ClientMessage("  Maps in server rotation");
	    ClientMessage("-----------------------------------------------------------------------------");
	}

	if (MapListClass != None)
	{
	    //size = MapListClass.Default.Maps.length;
	    MapsInRotation.Remove(0,MapsInRotation.Length);
	    ClientClearLocalMapList();

		for (i = 0; i < MapListClass.Default.Maps.length && MapListClass.Default.Maps[i] != ""; i++)
		{
            if (i < 989) spc = "  ";
			if (i < 89) spc = "   ";

			// Display each maplist entry
			if (DisableGUI) ClientMessage(spc $ (i + 11) $ ": " $ MapListClass.Default.Maps[i]);
			MapsInRotation[MapsInRotation.Length] = MapListClass.Default.Maps[i];

			// Send each maplist entry to the client
			ClientUpdateLocalMapList(MapsInRotation.Length - 1, MapListClass.Default.Maps[i]);
			j++;
		}
    }

    MyMapList = ExtendedMapList(Level.Game.GetMapList(Level.Game.MapListType));

    if (MyMapList?)
	    next = MyMapList.PredictNextMap();		// Tries to get the name of the next map in rotation
	else
		next = "unknown";

    if (DisableGUI)
    {
	    ClientMessage("-----------------------------------------------------------------------------");
	    ClientMessage("  " $ j $ " map(s) available. Next map is " $ next);
	    ClientMessage("  To initiate a map vote, use MAPVOTE <mapnumber>");
	    ClientMessage("=============================================================================");
	}

	// Tell the client to rebuild the GUI list
	ReBuildVoteLineArray();

	// Tell the client to display the GUI
	ClientDisplayGUI();

	// Admins get a list of ALL the server's maps appended to the rotation list
	if ( PlayerReplicationInfo.bAdmin && !bSendingMapList && !bSentMapList )
	{
		bSendingMapList = true;

    	AllMaps.Remove(0, AllMaps.Length);

		MyMapList.GetAllMaps(AllMaps, "U2.XMPGame");

		ReplicatedMapListSize = implode("?", 128, AllMaps, ReplicatedMapList);
		currentSegment = 0;
		AddTimer( 'PropogateMapList' , 0.5, true );
	}
}

//-----------------------------------------------------------------------------

// Timer-invoked function called to gradually dump the full map list to the client
function PropogateMapList()
{
	if (currentSegment < ReplicatedMapListSize - 1)
	{
		ClientUpdateFullMapList(ReplicatedMapList[currentSegment], currentSegment, false);
		currentSegment++;
	}
	else if (currentSegment < ReplicatedMapListSize)
	{
		ClientUpdateFullMapList(ReplicatedMapList[currentSegment], currentSegment, true);
		RemoveTimer( 'PropogateMapList' );
		bSendingMapList = false;
		bSentMapList = true;
	}
	else
	{
		RemoveTimer( 'PropogateMapList' );
		bSendingMapList = false;
		bSentMapList = true;
	}
}

//-----------------------------------------------------------------------------

// Called by the HUD Plugin when the client wants to display the vote GUI
simulated function DrawVoteUI(Canvas C, MapVoteHUDPlugin MyHUDPlugin)
{
	local float xl, yl;
	local int i, current;
	local int maxWidth, offset, top;

	// Display the Config GUI instead of MapVote one
	if (bDisplayConfigGUI)
	{
		DrawConfigUI(C, MyHUDPlugin);
		return;
	}

	if (DisableGUI)
	{
		// If the GUI is disabled, don't display it
		bDisplayMapChooser=false;
		return;
	}

	// Calculate the top co-ordinate for the GUI (should be just below the reticle)
	top = (C.ClipY / 2) + 55;

	// Draw the GUI title
    C.bCenter = True;
	C.Font = Font'SubTFonts.EE16';
	C.DrawColor = MyHUDPlugin.White;
	C.SetPos(0, C.ClipY/2 + 32);
    C.DrawText( MapVoteWindowTitle, True );

	// and some help messages
	C.Font = Font'Engine.SmallFont';
	C.SetPos(0, 40 + top + (linespacing * VoteGUINumRows));
    C.DrawText( MapVoteHelpLine1, True );
	C.SetPos(0, 56 + top + (linespacing * VoteGUINumRows));
    C.DrawText( MapVoteHelpLine2, True );

	// Draw the graphical frame around the GUI
    DrawInterfaceGraphics(C, MyHUDPlugin, top, VoteGUINumRows);

	// Do some checking to make sure we're not out of bounds
    if (start >= VoteLines.Length) start = VoteLines.Length - VoteGUINumRows;
    if (start < 0) start = 0;
    if (pos >= VoteLines.Length) pos = VoteLines.Length - 1;
    if (pos < 0) pos = 0;

    C.bCenter = False;
	C.Font = Font'HUD_Fonts.EuroExt14';

	// Since we're going to centre the text manually, find the widest element
	for (i = 0; i < VoteLines.Length; i++)
	{
		C.TextSize(VoteLines[i].Text, xl, yl);
		maxWidth = Max(xl, maxWidth);
	}

	// Offset will be half the width of the sceen minus half the width of the widest element
	offset = (C.ClipX / 2) - (maxWidth / 2);

	DrawInterfaceScrollBar(C, MyHUDPlugin, top, VoteGUINumRows, offset, maxWidth);

	// Draw the current segment of the map list
	for (i = 0; i < VoteGUINumRows; i++)
	{
		current = start + i;

		// Don't read past the end of the array!!!
		if (current >= VoteLines.Length) break;

		if (VoteLines[current].Num != 0)
		{
			// Draw the number
			C.DrawColor = MyHUDPlugin.White;
			C.SetPos(offset - numspacing, top + (i * linespacing));
			C.DrawText(VoteLines[current].Num, True);
		}

		// Unlisted maps drawn in cyan, current map drawn in red
		if (VoteLines[current].Text ~= next) C.DrawColor = MyHUDPlugin.Red;
		if (VoteLines[current].AdminOnly) C.DrawColor = MyHUDPlugin.Cyan;

		// If this is the currently highlighted element, draw the graphical selection bar
		if (current == pos)
		{
			C.DrawColor = MyHUDPlugin.white;

			C.SetPos(offset - 30, top + (i * linespacing) - 2);
			C.DrawTile(	Texture'UIResT.UI.UIPieces', maxWidth + 60, 20, 229, 416, 178, 16);

			if (C.DrawColor != MyHUDPlugin.Red) C.DrawColor = MyHUDPlugin.black;
		}

		// Draw the map name
		C.SetPos(offset, top + (i * linespacing));
		C.DrawText(VoteLines[current].Text, True);
	}
}

//-----------------------------------------------------------------------------

// Draws the graphical border & background for MapVote and MapVote Config
simulated function DrawInterfaceGraphics(Canvas C, MapVoteHUDPlugin MyHUDPlugin, int top, int numberOfLines)
{
	// Top frame graphic
	C.SetPos(C.ClipX/2 - 256, top - 39);
	C.DrawTile(	Texture'UIResT.UI.UIPieces', 512, 25, 0, 0, 512, 25);

	// Bottom frame graphic
	C.SetPos(C.ClipX/2 - 256, top + (linespacing * numberOfLines) + 5);
	C.DrawTile(	Texture'UIResT.UI.UIPieces', 512, 32, 0, 26, 512, 32);

	// Background
	C.DrawColor.A = 80;
	C.SetPos(C.ClipX/2 - 155, top - 32);
	C.DrawTile(	Texture'UIResT.UI.UIPieces', 304, 58 + (linespacing * numberOfLines), 402, 109, 100, 14);
}

//-----------------------------------------------------------------------------

// Function which draws the pretty graphical scrollbar for the MapVote GUI
simulated function DrawInterfaceScrollBar(Canvas C, MapVoteHUDPlugin MyHUDPlugin, int top, int numberOfLines, int offset, int maxWidth)
{
	local float scrollbarpct;
	local int scrollbarabs;

	// Calculate the scrollbar position
	scrollbarpct = float(start) / (total - VoteGUINumRows);
    scrollbarabs = scrollbarpct * float((VoteGUINumRows * linespacing) - 16);

	// Draw the scroll bar
	C.DrawColor.A = 255;
	C.SetPos(offset + maxWidth + 42, top + 1);
	C.DrawTile(	Texture'UIResT.UI.UIPieces', 6, (linespacing * numberOfLines) - 2, 93, 436, 214, 6);

	// Draw the scroll bar marker
	C.SetPos(offset + maxWidth + 41, top + scrollbarabs - 1);
	C.DrawTile(	Texture'UIResT.UI.UIPieces', 9, 18, 358, 75, 41, 14);
}

//-----------------------------------------------------------------------------

// Draws the MapVote Configuration GUI (when required)
simulated function DrawConfigUI(Canvas C, MapVoteHUDPlugin MyHUDPlugin)
{
	local float xl, yl;
	local int i, maxWidth, offset, top;

	// Hide the MapVote UI - it doesn't need to be done but means that if MAPVOTE is typed
	// again, the GUIs will just change places
	bDisplayMapChooser = false;

	// Calculate the top co-ordinate for the GUI (should be just below the reticle)
	top = (C.ClipY / 2) + 55;

	// Draw the Config GUI title
    C.bCenter = True;
	C.Font = Font'SubTFonts.EE16';
	C.DrawColor = MyHUDPlugin.White;
	C.SetPos(0, C.ClipY/2 + 32);
    C.DrawText( MapVoteConfigWindowTitle, True );

	// Do some checking to make sure we're not out of bounds
    if (cfgPos > 3) cfgPos = 3;
    if (cfgPos < 0) cfgPos = 0;

	// Only set this array data once
	if ( !bConfigGUIInitDone )
	{
	    ConfigLines.Length = 4;

	    ConfigLines[0].Description = "Disable MapVote GUI:";
	    ConfigLines[0].HelpText1 = "Set to TRUE to disable the MapVote GUI and use the text interface.";
	    ConfigLines[0].HelpText2 = "";

	    ConfigLines[1].Description = "GUI Menu Size:";
	    ConfigLines[1].HelpText1 = "Sets the size of the MapVote menu.";
	    ConfigLines[1].HelpText2 = "Use smaller sizes for low resolutions.";

	    ConfigLines[2].Description = "Poll Display Style:";
	    ConfigLines[2].HelpText1 = "Sets the display style for polls.";
	    ConfigLines[2].HelpText2 = "";

	    ConfigLines[3].Description = "< Close MapVote Configuration >";
	    ConfigLines[3].HelpText1 = "Close this menu.";
	    ConfigLines[3].HelpText2 = "";
	    ConfigLines[3].Value = "";

	    bConfigGUIInitDone = true;
	}

	// Set the values to be displayed based on the config var values
    ConfigLines[0].Value = string(DisableGUI);
    ConfigLines[1].Value = string(VoteGUINumRows) $ " lines";
    ConfigLines[2].Value = voteStyle;

	// Draw the help messages
	C.Font = Font'Engine.SmallFont';
	C.SetPos(0, 40 + top + (linespacing * 4));
    C.DrawText( ConfigLines[cfgPos].HelpText1, True );
	C.Font = Font'Engine.SmallFont';
	C.SetPos(0, 56 + top + (linespacing * 4));
    C.DrawText( ConfigLines[cfgPos].HelpText2, True );

	// Draw the graphical frame around the GUI
    DrawInterfaceGraphics(C, MyHUDPlugin, top, 4);

    C.bCenter = False;
	C.Font = Font'HUD_Fonts.EuroExt14';

	// Since we're going to centre the text manually, find the widest element
	for (i = 0; i < ConfigLines.Length; i++)
	{
		C.TextSize(ConfigLines[i].Description, xl, yl);
		maxWidth = Max(xl, maxWidth);
	}

	// Offset will be half the width of the sceen minus half the width of the widest element
	offset = (C.ClipX / 2) - (maxWidth / 2) - 30;

	// Draw the configuration options
	for (i = 0; i < ConfigLines.Length; i++)
	{
		C.DrawColor = MyHUDPlugin.White;

		if (left(ConfigLines[i].Description, 1) == "<") C.DrawColor = MyHUDPlugin.Cyan;

		// Current option, so draw the selection bar
		if (i == cfgPos)
		{
			C.DrawColor = MyHUDPlugin.white;

			C.SetPos(offset - 50, top + (i * linespacing) - 2);
			C.DrawTile(	Texture'UIResT.UI.UIPieces', maxWidth + 160, 20, 229, 416, 178, 16);

			C.DrawColor = MyHUDPlugin.black;
		}

		C.SetPos(offset - 10, top + (i * linespacing));
		C.DrawText(ConfigLines[i].Description, True);

		C.SetPos(offset + MaxWidth + 10, top + (i * linespacing));
		C.DrawText(ConfigLines[i].Value, True);
	}
}

//-----------------------------------------------------------------------------

// Handles the player clicking on a config option to click it
simulated function ChangeConfigVar(optional string param2)
{
	local int i;

	switch (cfgPos)
	{
		case 0:							// Map Vote GUI Enabled/Disabled
			DisableGUI = !DisableGUI;
			SaveConfig();
			break;

		case 1:							// Vote GUI Menu Size
			if (param2 ~= "next")
            	VoteGUINumRows--;
            else
            	VoteGUINumRows++;

            if (VoteGUINumRows > 12) VoteGUINumRows = 3;
            if (VoteGUINumRows < 3) VoteGUINumRows = 12;

            SaveConfig();
            break;

        case 2:							// Poll interface style
        	for (i = 0; i < 3; i++) if (voteStyle ~= voteStyles[i]) break;

			if (param2 ~= "next")
			{
				switch (i)
				{
					case 0: voteStyle = voteStyles[2]; break;
					case 1: voteStyle = voteStyles[0]; break;
					case 2: voteStyle = voteStyles[1]; break;
				}
			}
            else
			{
				switch (i)
				{
					case 0: voteStyle = voteStyles[1]; break;
					case 1: voteStyle = voteStyles[2]; break;
					case 2: voteStyle = voteStyles[0]; break;
				}
			}

            SaveConfig();
        	break;

        case 3:							// Leave the configuration menu
            bDisplayConfigGUI = false;
            bDisplayMapChooser = false;
        	break;
	}
}

//-----------------------------------------------------------------------------

// Called by the server once the maplists have been sent to the client, instructs
// the client to rebuild its GUI map list
simulated function ReBuildVoteLineArray()
{
	local int i, j;
	local VoteLine v;

	// Clear the version we have already
    if (VoteLines.Length > 0) VoteLines.Remove(0,VoteLines.Length);
    
    VoteLines.Length = 1;
    
    VoteLines[0].Num = 0;
    VoteLines[0].Text = "< Close this menu >";
    VoteLines[0].AdminOnly = true;

	// Add the predefined maps to the list
	for (i = 0; i < 10; i++)
	{
		if (VoteableMaps[i] != "")
		{
			v.Num = i + 1;
			v.Text = VoteableMaps[i];
			VoteLines[VoteLines.Length] = v;
			j++;
		}
		else
			break;
	}

	// Add the rotation maps to the list
	for (i = 0; i < MapsInRotation.Length; i++)
	{
		if (MapsInRotation[i] != "")
		{
			v.Num = i + 11;
			v.Text = MapsInRotation[i];
			VoteLines[VoteLines.Length] = v;
			j++;
		}
		else
			break;
	}

	// Add the full map list to the list for admins
	if ( PlayerReplicationInfo.bAdmin )
	{
		for (i = i; i < AllMaps.Length; i++)
		{
			if (AllMaps[i] != "")
			{
				v.Num = i + 11;
				v.Text = AllMaps[i];
				v.AdminOnly = true;
				VoteLines[VoteLines.Length] = v;
				j++;
			}
			else
				break;
		}
	}

	// If there are no maps pre-configured, and none in rotation ( wtf!? )
	if (j == 0)
	{
		v.Num = 0;
		v.Text = "< Sorry, no maps available >";
		v.AdminOnly = true;
		VoteLines[VoteLines.Length] = v;
	}

	total = j;
}

//-----------------------------------------------------------------------------

// The 3 GUI action functions below return a boolean value which indicates whether
// the calling function should make a call to Super(). For example, the Fire() function
// calls GUISelectMap(). GUISelectMap() reports FALSE to indicate that it intercepted
// and used the call for it's own purposes. If the GUI is not in use, GUISelectMap()
// returns TRUE and the Fire() function makes the call to Super.Fire()

// Try to start a vote with the currently selected map
simulated function bool GUISelectMap(optional string param2)
{
	if ( bDisplayConfigGUI )
	{
		ViewTarget.PlayOwnedSound(MapVoteClickSound, SLOT_Interface, 2.5);
		ChangeConfigVar(param2);
		return false;
	}
	else if ( bDisplayMapChooser )
	{
		ViewTarget.PlayOwnedSound(MapVoteClickSound, SLOT_Interface, 2.5);
		MapVote(VoteLines[pos].Num, param2);
		return false;
	}

	return true;
}

// Scroll up one position
simulated exec function bool ScrollUp()
{
	local int oldval;

	if ( bDisplayConfigGUI && cfgPos > 0 )
	{
		ViewTarget.PlayOwnedSound(MapVoteScrollSound, SLOT_Interface, 2.5);
		cfgPos--;
		return false;
	}
	else if ( bDisplayMapChooser )
	{
		oldval = pos;
		if ( pos > 0) pos--;
		if ( pos < start ) start = pos;
		if ( pos != oldval) ViewTarget.PlayOwnedSound(MapVoteScrollSound, SLOT_Interface, 2.5);
		return false;
	}
	else if ( bDisplayConfigGUI )
	{
		return false;
	}

	return true;
}

// Scroll down one position
simulated exec function bool ScrollDown()
{
	local int oldval;

	if ( bDisplayConfigGUI && cfgPos < 3 )
	{
		ViewTarget.PlayOwnedSound(MapVoteScrollSound, SLOT_Interface, 2.5);
		cfgPos++;
		return false;
	}
	else if ( bDisplayMapChooser )
	{
		oldval = pos;
		if ( pos < total - 1) pos++;
		if ( pos >= start + VoteGUINumRows) start++;
		if ( pos != oldval) ViewTarget.PlayOwnedSound(MapVoteScrollSound, SLOT_Interface, 2.5);
		return false;
	}
	else if ( bDisplayConfigGUI )
	{
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------

// Intercept calls to Fire() so that the we can use them to control the GUI
exec function Fire( optional float F )
{
	if (GUISelectMap()) Super.Fire(F);
}

// Intercept calls to AltFire() so that the we can use them to control the GUI
exec function AltFire( optional float F )
{
	if (GUISelectMap("next")) Super.AltFire(F);
}

// Intercept calls to PrevWeapon() so that the we can use them to control the GUI
exec function PrevWeapon()
{
	if (ScrollUp()) Super.PrevWeapon();
}

// Intercept calls to NextWeapon() so that the we can use them to control the GUI
exec function NextWeapon()
{
	if (ScrollDown()) Super.NextWeapon();
}

//-----------------------------------------------------------------------------

// Some states set the functions we need to control the GUI (Fire, AltFire,
// PrevWeapon and NextWeapon) to ignore and/or over-ride them with functions which
// perform special operations (such as locking into a deploy). We want to intercept
// calls to these functions in all states in which they are implemented so that
// the MapVote GUI works regardless of what state the player is actually in.


state WaitingToDeploy
{
	ignores SeeEnemy, HearNoise, KilledBy, SwitchWeapon;

	event BeginState()
	{
		// Spawns HUD plugin on listen servers , and sometimes on clients more reliably
		// than the PostNetRecieve() event
		SpawnHUDPlugin();
		Super.BeginState();
	}

	exec function Fire( optional float F ) { if (GUISelectMap()) Super.Fire(F); }
	exec function AltFire( optional float F ) { if (GUISelectMap("next")) Super.AltFire(F); }
	exec function PrevWeapon() { ScrollUp(); }
	exec function NextWeapon() { ScrollDown(); }
}

state GameEnded
{
	exec function Fire( optional float F ) { if (GUISelectMap()) Super.Fire(F); }
	exec function AltFire( optional float F ) { if (GUISelectMap("next")) Super.AltFire(F); }
}

state PlayerDriving
{
	exec function Fire( optional float F ) { if (GUISelectMap()) Super.Fire(F); }
	exec function AltFire( optional float F ) { if (GUISelectMap("next")) Super.AltFire(F); }
}

state PlayerTurreting
{
	exec function Fire( optional float F ) { if (GUISelectMap()) Super.Fire(F); }
	exec function AltFire( optional float F ) { if (GUISelectMap("next")) Super.AltFire(F); }
}

state Dead
{
	ignores SeeEnemy, HearNoise, KilledBy, SwitchWeapon;

	exec function PrevWeapon() { ScrollUp(); }
	exec function NextWeapon() { ScrollDown();	}
}

auto state PlayerWaiting
{
	ignores SeeEnemy, HearNoise, NotifyBump, TakeDamage, PhysicsVolumeChange, SwitchToBestWeapon;

	exec function Fire( optional float F ) { if (GUISelectMap()) Super.Fire(F);	}
	exec function AltFire( optional float F ) { if (GUISelectMap("next")) Super.AltFire(F); }
	exec function PrevWeapon() { ScrollUp(); }
	exec function NextWeapon() { ScrollDown(); }
}

state Wounded
{
	ignores SeeEnemy, HearNoise, KilledBy, SwitchWeapon;

	exec function Fire( optional float F ) { if (GUISelectMap()) Super.Fire(F); }
	exec function AltFire( optional float F ) { if (GUISelectMap("next")) Super.AltFire(F); }
	exec function PrevWeapon() { ScrollUp(); }
	exec function NextWeapon() { ScrollDown(); }
}

//-----------------------------------------------------------------------------

// This function takes in a dynamic-sized array of strings and implodes to a set of strings
// with the individual entries delimited by the 'glue' string. It returns a value indicating
// how much of the fixed array it has filled.
function int implode(string glue, int maxLength, array<string> pieces, out string result[20])
{
	local int i, j, size;

	i = 0;

	for (j = 0; j < 20; j++)
	{
	    if (pieces.length - i < 1) break;	// <- what does this line do!?!?!

	    size++;

		while (i < pieces.length - 1 && len(result[j]) < maxLength)
		{
			result[j] = result[j] $ pieces[i] $ glue;
			i++;
		}

		result[j] = result[j] $ pieces[i];
		i++;

		if (i >= pieces.length - 1) break;
	}

	return size;
}

//-----------------------------------------------------------------------------

// This is the opposite of the 'implode' function, and will yeild the original dynamic
// array of strings.
function explode(string glue, string implodedString[20], out array<string> result)
{
	local int pos, j;

	result.Remove(0, result.Length);

	for (j = 0; j < 20; j++)
	{
		while (instr(implodedString[j], glue) > -1)
		{
			pos = instr(implodedString[j], glue);

			result[result.length] = Left(implodedString[j], pos);
			implodedString[j] = Right(implodedString[j], len(implodedString[j]) - len(glue) - pos);
		}
		
		if(len(implodedString[j]) < 1) break;

		result[result.length] = implodedString[j];
	}
}

//-----------------------------------------------------------------------------

// Returns the localized "vote failed because a map is queued" message with the map name inserted
function string QueuedMapMessage()
{
	local string msg;

    MyGRI = MapVoteGameReplicationInfo(GameReplicationInfo);
	msg = QueuedMapMsg;
	ReplaceText(msg, "$1", MyGRI.QueuedMap);

	return msg;
}

//-----------------------------------------------------------------------------

// Returns the localized "vote failed because map is already queued" message with the map name inserted
function string AlreadyQueuedMessage()
{
	local string msg;

	msg = AlreadyQueuedMsg;
	ReplaceText(msg, "$1", next);

	return msg;
}

//-----------------------------------------------------------------------------

// Returns the localized "vote failed because you need to wait n seconds" message with the time inserted
function string VotedTooSoonMessage(float time)
{
	local string msg;

	msg = TooSoonToVoteMsg;
	ReplaceText(msg, "$1", string(time));

	return msg;
}

//-----------------------------------------------------------------------------

// GUI Designer code removed. If you want a copy of the source send e-mail to eq2@eq2.co.uk

defaultproperties
{
	QueuedMapMsg="Vote Failed: Cannot start a map vote because $1 is already queued"
	AlreadyQueuedMsg="Vote Failed: $1 is already queued as the next map"
	TooManyRequestsMsg="Vote Failed: You have exceeded your map vote limit for this round"
	TooManyIdenticalRequestsMsg="Vote Failed: Sorry, you have voted for the same map too many times"
	TooSoonToVoteMsg="Vote Failed: Sorry, you must wait another $1 seconds before voting"
	VoteGUINumRows=6
	MapVoteScrollSound=Sound'UISounds.MouseOver'
	MapVoteClickSound=Sound'UISounds.MouseDown'
	linespacing=17
	numspacing=65
	bracketspacing=12
	PlayerReplicationInfoClass=Class'BSEMapVote_0_5.CheaterPRI'
	voteStyle="Small"
	voteStyles(0)="Normal"
	voteStyles(1)="Small"
	voteStyles(2)="VerySmall"
	MapVoteWindowTitle="Available Maps"
	MapVoteHelpLine1="Use mouse wheel to select a map. Use primary fire to vote"
	MapVoteHelpLine2="Use secondary fire to vote for next map."
	MapVoteConfigWindowTitle="MapVote Options"
}