UTServerAdmin.UTServerAdmin

UTServerAdmin
Class UTServerAdmin

source: e:\games\UnrealTournament\UTServerAdmin\Classes\UTServerAdmin.uc

Core.Object
   |
   +--UWeb.WebApplication
      |
      +--UTServerAdmin.UTServerAdmin

Direct Known Subclasses:None

class UTServerAdmin
extends UWeb.WebApplication

Variables
`string`	`AdminPassword`
`string`	`AdminRealm`
`string`	`AdminUsername`
`string`	`CurrentConsoleLogPage`
`string`	`CurrentConsolePage`
`string`	`CurrentConsoleSendPage`
`string`	`CurrentGamePage`
`string`	`CurrentIndexPage`
`string`	`CurrentMenuPage`
`string`	`CurrentMutatorsPage`
`string`	`CurrentPage`
`string`	`CurrentPlayersPage`
`string`	`CurrentRestartPage`
`string`	`DefaultBG`
`string`	`DefaultSendText`
`string`	`DefaultsBotsPage`
`string`	`DefaultsIPPolicyPage`
`string`	`DefaultsMapsPage`
`string`	`DefaultsMenuPage`
`string`	`DefaultsPage`
`string`	`DefaultsRestartPage`
`string`	`DefaultsRulesPage`
`string`	`DefaultsServerPage`
`string`	`DefaultsSettingsPage`
`ListItem`	`ExcludeMaps`
`ListItem`	`ExcludeMutators`
`string`	`HighlightedBG`
`ListItem`	`IncludeMaps`
`ListItem`	`IncludeMutators`
`string`	`MenuPage`
`string`	`MessageUHTM`
`string`	`RootPage`
`UTServerAdminSpectator`	`Spectator`
`class`	`SpectatorType`

Function Summary
`void`	`ApplyMapList(out ListItem, out ListItem, String GameType, String MapListType)`
`String`	`GenerateGameTypeOptions(String CurrentGameType)`
`String`	`GenerateMapListOptions(String GameType, String MapListType)`
`String`	`GenerateMapListSelect(ListItem MapList, optional string)`
`String`	`GenerateMutatorListSelect(ListItem MutatorList)`
`void`	`LoadGameTypes()`
`void`	`LoadMutators()`
`String`	`PadLeft(String InStr, int Width, String PadStr)`
`void`	`QueryCurrent(WebRequest Request, WebResponse Response)` //*****************************************************************************
`void`	`QueryCurrentConsole(WebRequest Request, WebResponse Response)`
`void`	`QueryCurrentConsoleLog(WebRequest Request, WebResponse Response)`
`void`	`QueryCurrentConsoleSend(WebRequest Request, WebResponse Response)`
`void`	`QueryCurrentGame(WebRequest Request, WebResponse Response)`
`void`	`QueryCurrentMenu(WebRequest Request, WebResponse Response)`
`void`	`QueryCurrentMutators(WebRequest Request, WebResponse Response)`
`void`	`QueryCurrentPlayers(WebRequest Request, WebResponse Response)`
`void`	`QueryDefaults(WebRequest Request, WebResponse Response)` //*****************************************************************************
`void`	`QueryDefaultsBots(WebRequest Request, WebResponse Response)`
`void`	`QueryDefaultsIPPolicy(WebRequest Request, WebResponse Response)`
`void`	`QueryDefaultsMaps(WebRequest Request, WebResponse Response)`
`void`	`QueryDefaultsMenu(WebRequest Request, WebResponse Response)`
`void`	`QueryDefaultsRules(WebRequest Request, WebResponse Response)`
`void`	`QueryDefaultsServer(WebRequest Request, WebResponse Response)`
`void`	`QueryDefaultsSettings(WebRequest Request, WebResponse Response)`
`void`	`QueryMenu(WebRequest Request, WebResponse Response)`
`void`	`QueryRestartPage(WebRequest Request, WebResponse Response)`
`void`	`QueryRoot(WebRequest Request, WebResponse Response)` //*****************************************************************************
`void`	`ReloadExcludeMaps(out ListItem, String GameType)`
`void`	`ReloadIncludeMaps(out ListItem, out ListItem, String GameType)`
`void`	`UpdateDefaultMaps(String GameType, ListItem TempItem)`
`String`	`UsedMutators()`

Source Code


00001	class UTServerAdmin expands WebApplication config;
00002	
00003	var() class<UTServerAdminSpectator> SpectatorType;
00004	var UTServerAdminSpectator Spectator;
00005	
00006	var	ListItem GameTypeList;
00007	
00008	var ListItem IncludeMaps;
00009	var ListItem ExcludeMaps;
00010	
00011	var ListItem IncludeMutators;
00012	var ListItem ExcludeMutators;
00013	
00014	var config string MenuPage;
00015	var config string RootPage;
00016	
00017	var config string CurrentPage;
00018	var config string CurrentMenuPage;
00019	var config string CurrentIndexPage;
00020	var config string CurrentPlayersPage;
00021	var config string CurrentGamePage;
00022	var config string CurrentConsolePage;
00023	var config string CurrentConsoleLogPage;
00024	var config string CurrentConsoleSendPage;
00025	var config string DefaultSendText;
00026	var config string CurrentMutatorsPage;
00027	var config string CurrentRestartPage;
00028	
00029	var config string DefaultsPage;
00030	var config string DefaultsMenuPage;
00031	var config string DefaultsMapsPage;
00032	var config string DefaultsRulesPage;
00033	var config string DefaultsSettingsPage;
00034	var config string DefaultsBotsPage;
00035	var config string DefaultsServerPage;
00036	var config string DefaultsIPPolicyPage;
00037	var config string DefaultsRestartPage;
00038	
00039	var config string MessageUHTM;
00040	
00041	
00042	var config string DefaultBG;
00043	var config string HighlightedBG;
00044	
00045	var config string AdminRealm;
00046	var config string AdminUsername;
00047	var config string AdminPassword;
00048	
00049	event Init()
00050	{
00051		Super.Init();
00052		
00053		if (SpectatorType != None)
00054			Spectator = Level.Spawn(SpectatorType);
00055		else
00056			Spectator = Level.Spawn(class'UTServerAdminSpectator');
00057		
00058		// won't change as long as the server is up
00059		LoadGameTypes();	
00060		LoadMutators();
00061	}
00062	
00063	function LoadGameTypes()
00064	{
00065		local class<GameInfo>	TempClass;
00066		local String 			NextGame;
00067		local ListItem	TempItem;
00068		local int				i, Pos;
00069	
00070		// reinitialize list if needed
00071		GameTypeList = None;
00072		
00073		// Compile a list of all gametypes.
00074		TempClass = class'TournamentGameInfo';
00075		NextGame = Level.GetNextInt("TournamentGameInfo", 0); 
00076		while (NextGame != "")
00077		{
00078			Pos = InStr(NextGame, ".");
00079			TempClass = class<GameInfo>(DynamicLoadObject(NextGame, class'Class'));
00080	
00081			TempItem = new(None) class'ListItem';
00082			TempItem.Tag = TempClass.Default.GameName;
00083			TempItem.Data = NextGame;
00084	
00085			if (GameTypeList == None)
00086				GameTypeList = TempItem;
00087			else
00088				GameTypeList.AddElement(TempItem);
00089	
00090			NextGame = Level.GetNextInt("TournamentGameInfo", ++i);
00091		}
00092	}	
00093	
00094	function LoadMutators()
00095	{
00096		local int NumMutatorClasses;
00097		local string NextMutator, NextDesc;
00098		local listitem TempItem;
00099		local Mutator M;
00100		local int j;
00101		local int k;
00102	
00103		ExcludeMutators = None;
00104	
00105		Level.GetNextIntDesc("Engine.Mutator", 0, NextMutator, NextDesc);
00106		while( (NextMutator != "") && (NumMutatorClasses < 50) )
00107		{
00108			TempItem = new(None) class'ListItem';
00109			
00110			k = InStr(NextDesc, ",");
00111			if (k == -1)
00112				TempItem.Tag = NextDesc;
00113			else
00114				TempItem.Tag = Left(NextDesc, k);
00115	
00116			TempItem.Data = NextMutator;
00117	
00118			if (ExcludeMutators == None)
00119				ExcludeMutators = TempItem;
00120			else
00121				ExcludeMutators.AddSortedElement(ExcludeMutators, TempItem);
00122			NumMutatorClasses++;
00123			Level.GetNextIntDesc("Engine.Mutator", NumMutatorClasses, NextMutator, NextDesc);
00124		}
00125	
00126		IncludeMutators = None;
00127		
00128		for (M = Level.Game.BaseMutator.NextMutator; M != None; M = M.NextMutator) {
00129			TempItem = ExcludeMutators.DeleteElement(ExcludeMutators, String(M.Class));
00130			
00131			if (TempItem != None) {
00132				if (IncludeMutators == None)
00133					IncludeMutators = TempItem;
00134				else
00135					IncludeMutators.AddElement(TempItem);
00136			}
00137			else
00138				log("Unknown Mutator in use: "@String(M.Class));
00139		}
00140	}
00141	
00142	function String UsedMutators()
00143	{
00144		local ListItem TempItem;
00145		local String OutStr;
00146		
00147		if(IncludeMutators == None)
00148			return "";
00149	
00150		OutStr = IncludeMutators.Data;
00151		for (TempItem = IncludeMutators.Next; TempItem != None; TempItem = TempItem.Next)
00152		{
00153			OutStr = OutStr$","$TempItem.Data;
00154		}
00155		
00156		return OutStr;
00157	}
00158	
00159	function String GenerateMutatorListSelect(ListItem MutatorList)
00160	{
00161		local ListItem TempItem;
00162		local String ResponseStr, SelectedStr;
00163		
00164		if (MutatorList == None)
00165			return "<option value=\"\">*** None ***</option>";
00166			
00167		for (TempItem = MutatorList; TempItem != None; TempItem = TempItem.Next) {
00168			SelectedStr = "";
00169			if (TempItem.bJustMoved) {
00170				SelectedStr = " selected";
00171				TempItem.bJustMoved=false;
00172			}
00173			ResponseStr = ResponseStr$"<option value=\""$TempItem.Data$"\""$SelectedStr$">"$TempItem.Tag$"</option>";
00174		}
00175		return ResponseStr;
00176	}
00177	
00178	function String PadLeft(String InStr, int Width, String PadStr)
00179	{
00180		local String OutStr;
00181		
00182		if (Len(PadStr) == 0)
00183			PadStr = " ";
00184			
00185		for (OutStr=InStr; Len(OutStr) < Width; OutStr=PadStr$OutStr);
00186		
00187		return Right(OutStr, Width); // in case PadStr is more than one character
00188	}
00189	
00190	function ApplyMapList(out ListItem ExcludeMaps, out ListItem IncludeMaps, String GameType, String MapListType)
00191	{
00192		local class<MapList> MapListClass;
00193		local ListItem TempItem;
00194		local int IncludeCount, i;
00195		
00196		MapListClass = Class<MapList>(DynamicLoadObject(MapListType, class'Class'));
00197		
00198		IncludeMaps = None;
00199		ReloadExcludeMaps(ExcludeMaps, GameType);
00200		
00201		IncludeCount = ArrayCount(MapListClass.Default.Maps);
00202		for(i=0;i<IncludeCount;i++)
00203		{
00204			if(MapListClass.Default.Maps[i] == "")
00205				break;
00206			if (ExcludeMaps != None)
00207			{
00208				TempItem = ExcludeMaps.DeleteElement(ExcludeMaps, MapListClass.Default.Maps[i]);
00209				
00210				if(TempItem != None)
00211				{
00212					if (IncludeMaps == None)
00213						IncludeMaps = TempItem;
00214					else
00215						IncludeMaps.AddElement(TempItem);
00216				}
00217				else
00218					Log("*** Unknown map in Map List: "$MapListClass.Default.Maps[i]);
00219			}
00220			else
00221				Log("*** Empty exclude list, i="$i);
00222		}
00223	}
00224	
00225	function ReloadExcludeMaps(out ListItem ExcludeMaps, String GameType)
00226	{
00227		local class<GameInfo>	GameClass;
00228		local string FirstMap, NextMap, TestMap, MapName;
00229		local ListItem TempItem;
00230	
00231		GameClass = class<GameInfo>(DynamicLoadObject(GameType, class'Class'));
00232		
00233		ExcludeMaps = None;
00234		if(GameClass.Default.MapPrefix == "")
00235			return;
00236		FirstMap = Level.GetMapName(GameClass.Default.MapPrefix, "", 0);
00237		NextMap = FirstMap;
00238		while (!(FirstMap ~= TestMap) && FirstMap != "")
00239		{
00240			if(!(Left(NextMap, Len(NextMap) - 4) ~= (GameClass.Default.MapPrefix$"-tutorial")))
00241			{
00242				// Add the map.
00243				TempItem = new(None) class'ListItem';
00244				TempItem.Data = NextMap;
00245				
00246				if(Right(NextMap, 4) ~= ".unr")
00247					TempItem.Tag = Left(NextMap, Len(NextMap) - 4);
00248				else
00249					TempItem.Tag = NextMap;
00250					
00251				if (ExcludeMaps == None)
00252					ExcludeMaps = TempItem;
00253				else
00254					ExcludeMaps.AddSortedElement(ExcludeMaps, TempItem);
00255			}
00256				
00257			NextMap = Level.GetMapName(GameClass.Default.MapPrefix, NextMap, 1);
00258			TestMap = NextMap;
00259		}
00260	}
00261	
00262	function ReloadIncludeMaps(out ListItem ExcludeMaps, out ListItem IncludeMaps, String GameType)
00263	{
00264		local class<GameInfo> GameClass;
00265		local ListItem TempItem;
00266		local int i;
00267	
00268		GameClass = class<GameInfo>(DynamicLoadObject(GameType, class'Class'));
00269		if(GameClass.Default.MapListType == None)
00270			return;
00271		if (GameClass != None)
00272		{
00273			for (i=0; i<ArrayCount(GameClass.Default.MapListType.Default.Maps) && GameClass.Default.MapListType.Default.Maps[i] != ""; i++)
00274			{
00275				// Add the map.
00276				TempItem = ExcludeMaps.DeleteElement(ExcludeMaps, GameClass.Default.MapListType.Default.Maps[i]);
00277				if (TempItem == None)
00278				{
00279					TempItem = new(None) class'ListItem';
00280					TempItem.Data = GameClass.Default.MapListType.Default.Maps[i];
00281					
00282					if(Right(TempItem.Data, 4) ~= ".unr")
00283						TempItem.Tag = Left(TempItem.Data, Len(TempItem.Data) - 4);
00284					else
00285						TempItem.Tag = TempItem.Data;
00286				}			
00287				else
00288				{
00289					if (IncludeMaps == None)
00290						IncludeMaps = TempItem;
00291					else
00292						IncludeMaps.AddElement(TempItem);
00293				}
00294			}
00295		}
00296	}
00297	
00298	function UpdateDefaultMaps(String GameType, ListItem TempItem)
00299	{
00300		local class<GameInfo> GameClass;
00301		local int i;
00302		
00303		GameClass = class<GameInfo>(DynamicLoadObject(GameType, class'Class'));
00304	
00305		for (i=0; i<ArrayCount(GameClass.Default.MapListType.Default.Maps); i++)
00306		{
00307			if (TempItem != None)
00308			{
00309				GameClass.Default.MapListType.Default.Maps[i] = TempItem.Data;
00310				TempItem = TempItem.Next;
00311			}
00312			else
00313				GameClass.Default.MapListType.Default.Maps[i] = "";
00314		}
00315		
00316		GameClass.Static.StaticSaveConfig();
00317	}
00318	
00319	function String GenerateGameTypeOptions(String CurrentGameType)
00320	{
00321		local ListItem TempItem;
00322		local String SelectedStr, OptionStr;
00323	
00324		for (TempItem = GameTypeList; TempItem != None; TempItem = TempItem.Next)
00325		{
00326			if (CurrentGameType ~= TempItem.Data)
00327				SelectedStr = " selected";
00328			else
00329				SelectedStr = "";
00330					
00331			OptionStr = OptionStr$"<option value=\""$TempItem.Data$"\""$SelectedStr$">"$TempItem.Tag$"</option>";
00332		}
00333		return OptionStr;
00334	}
00335	
00336	function String GenerateMapListOptions(String GameType, String MapListType)
00337	{
00338		local class<GameInfo> GameClass;
00339		local String DefaultBaseClass, NextDefault, NextDesc, SelectedStr, OptionStr;
00340		local int NumDefaultClasses;
00341		
00342		GameClass = class<GameInfo>(DynamicLoadObject(GameType, class'Class'));
00343		if(GameClass == None)
00344			return "";
00345	
00346		DefaultBaseClass = String(GameClass.Default.MapListType);
00347	
00348		if(DefaultBaseClass == "")
00349			return "";
00350	
00351		NextDefault = "Custom";
00352		NextDesc = "Custom";
00353		
00354		if(DynamicLoadObject(DefaultBaseClass, class'Class') == None)
00355			return "";
00356		while( (NextDefault != "") && (NumDefaultClasses < 50) )
00357		{
00358			if (MapListType ~= NextDefault)
00359				SelectedStr = " selected";
00360			else
00361				SelectedStr = "";
00362				
00363			OptionStr = OptionStr$"<option value=\""$NextDefault$"\""$SelectedStr$">"$NextDesc$"</option>";
00364				
00365			Level.GetNextIntDesc(DefaultBaseClass, NumDefaultClasses++, NextDefault, NextDesc);
00366		}				
00367		return OptionStr;
00368	}
00369	
00370	function String GenerateMapListSelect(ListItem MapList, optional string SelectedItem)
00371	{
00372		local ListItem TempItem;
00373		local String ResponseStr, SelectedStr;
00374		
00375		if (MapList == None)
00376			return "<option value=\"\">*** None ***</option>";
00377			
00378		for (TempItem = MapList; TempItem != None; TempItem = TempItem.Next) {
00379			SelectedStr = "";
00380			if (TempItem.Data ~= SelectedItem || TempItem.bJustMoved)
00381				SelectedStr = " selected";
00382			ResponseStr = ResponseStr$"<option value=\""$TempItem.Data$"\""$SelectedStr$">"$TempItem.Tag$"</option>";
00383		}
00384		
00385		return ResponseStr;
00386	}
00387	
00388	
00389	//*****************************************************************************
00390	event Query(WebRequest Request, WebResponse Response)
00391	{
00392		// Check authentication:
00393		if ((AdminUsername != "" && Caps(Request.Username) != Caps(AdminUsername)) || (AdminPassword != "" && Caps(Request.Password) != Caps(AdminPassword))) {
00394			Response.FailAuthentication(AdminRealm);
00395			return;
00396		}
00397		
00398		Response.Subst("BugAddress", "utbugs"$Level.EngineVersion$"@epicgames.com");
00399	
00400		// Match query function.  checks URI and calls appropriate input/output function
00401		switch (Mid(Request.URI, 1)) {
00402		case "":
00403		case RootPage:
00404			QueryRoot(Request, Response); break;
00405		case MenuPage:
00406			QueryMenu(Request, Response); break;
00407		case CurrentPage:
00408			QueryCurrent(Request, Response); break;
00409		case CurrentMenuPage:
00410			QueryCurrentMenu(Request, Response); break;
00411		case CurrentPlayersPage:
00412			QueryCurrentPlayers(Request, Response); break;
00413		case CurrentGamePage:
00414			QueryCurrentGame(Request, Response); break;
00415		case CurrentConsolePage:
00416			QueryCurrentConsole(Request, Response); break;
00417		case CurrentConsoleLogPage:
00418			QueryCurrentConsoleLog(Request, Response); break;
00419		case CurrentConsoleSendPage:
00420			QueryCurrentConsoleSend(Request, Response); break;
00421		case CurrentMutatorsPage:
00422			QueryCurrentMutators(Request, Response); break;
00423		case CurrentRestartPage:
00424		case DefaultsRestartPage:
00425			QueryRestartPage(Request, Response); break;
00426		case DefaultsPage:
00427			QueryDefaults(Request, Response); break;
00428		case DefaultsMenuPage:
00429			QueryDefaultsMenu(Request, Response); break;
00430		case DefaultsMapsPage:
00431			QueryDefaultsMaps(Request, Response); break;
00432		case DefaultsRulesPage:
00433			QueryDefaultsRules(Request, Response); break;
00434		case DefaultsSettingsPage:
00435			QueryDefaultsSettings(Request, Response); break;
00436		case DefaultsBotsPage:
00437			QueryDefaultsBots(Request, Response); break;
00438		case DefaultsServerPage:
00439			QueryDefaultsServer(Request, Response); break;
00440		case DefaultsIPPolicyPage:
00441			QueryDefaultsIPPolicy(Request, Response); break;
00442		default:
00443			Response.SendText("ERROR: Page not found or enabled.");
00444	
00445		}		
00446	}
00447	
00448	//*****************************************************************************
00449	function QueryRoot(WebRequest Request, WebResponse Response)
00450	{
00451		local String GroupPage;
00452		
00453		GroupPage = Request.GetVariable("Group", CurrentPage);
00454		
00455		Response.Subst("MenuURI", MenuPage$"?Group="$GroupPage);
00456		Response.Subst("MainURI", GroupPage);
00457		
00458		Response.IncludeUHTM("root.uhtm");
00459	}
00460	
00461	
00462	function QueryMenu(WebRequest Request, WebResponse Response)
00463	{
00464		Response.Subst("CurrentBG", 	DefaultBG);
00465		Response.Subst("DefaultsBG",	DefaultBG);
00466		
00467		
00468		switch(Request.GetVariable("Group", DefaultsPage)) {
00469		case CurrentPage:
00470			Response.Subst("CurrentBG", 	HighlightedBG); break;
00471		case DefaultsPage:
00472			Response.Subst("DefaultsBG",	HighlightedBG); break;
00473		}
00474	
00475		// Set URIs
00476		Response.Subst("CurrentURI", 	RootPage$"?Group="$CurrentPage);
00477		Response.Subst("DefaultsURI", 	RootPage$"?Group="$DefaultsPage);
00478	
00479		Response.IncludeUHTM(MenuPage$".uhtm");
00480		Response.ClearSubst();	
00481		
00482	}
00483	
00484	//*****************************************************************************
00485	function QueryCurrent(WebRequest Request, WebResponse Response)
00486	{
00487		local String Page;
00488		
00489		// if no page specified, use the default
00490		Page = Request.GetVariable("Page", CurrentGamePage);
00491	
00492		Response.Subst("IndexURI", 	CurrentMenuPage$"?Page="$Page);
00493		Response.Subst("MainURI", 	Page);
00494		
00495		Response.IncludeUHTM(CurrentPage$".uhtm");
00496		Response.ClearSubst();
00497	}
00498	
00499	function QueryCurrentMenu(WebRequest Request, WebResponse Response)
00500	{
00501		local String Page;
00502		
00503		Page = Request.GetVariable("Page", CurrentGamePage);
00504			
00505		// set background colors
00506		Response.Subst("DefaultBG", DefaultBG);	// for unused tabs
00507	
00508		Response.Subst("PlayersBG", DefaultBG);
00509		Response.Subst("GameBG", 	DefaultBG);
00510		Response.Subst("ConsoleBG",	DefaultBG);
00511		Response.Subst("MutatorsBG",DefaultBG);
00512		Response.Subst("RestartBG", DefaultBG);
00513		
00514		switch(Page) {
00515		case CurrentPlayersPage:
00516			Response.Subst("PlayersBG",	HighlightedBG); break;
00517		case CurrentGamePage:
00518			Response.Subst("GameBG", 	HighlightedBG); break;
00519		case CurrentConsolePage:
00520			Response.Subst("ConsoleBG",	HighlightedBG); break;
00521		case CurrentMutatorsPage:
00522			Response.Subst("MutatorsBG",HighlightedBG); break;
00523		case CurrentRestartPage:
00524			Response.Subst("RestartBG", HighlightedBG); break;
00525		}
00526	
00527		// Set URIs
00528		Response.Subst("PlayersURI", 	CurrentPage$"?Page="$CurrentPlayersPage);
00529		Response.Subst("GameURI",		CurrentPage$"?Page="$CurrentGamePage);
00530		Response.Subst("ConsoleURI", 	CurrentPage$"?Page="$CurrentConsolePage);
00531		Response.Subst("MutatorsURI", 	CurrentPage$"?Page="$CurrentMutatorsPage);
00532		Response.Subst("RestartURI", 	CurrentPage$"?Page="$CurrentRestartPage);
00533		
00534		Response.IncludeUHTM(CurrentMenuPage$".uhtm");
00535		Response.ClearSubst();
00536	}
00537	
00538	function QueryCurrentPlayers(WebRequest Request, WebResponse Response)
00539	{
00540		local string Sort, PlayerListSubst, TempStr;
00541		local ListItem PlayerList, TempItem;
00542		local Pawn P;
00543		local int i, PawnCount, j;
00544		local string IP;
00545		
00546		Sort = Request.GetVariable("Sort", "Name");
00547		
00548		for (P=Level.PawnList; P!=None; P=P.NextPawn)
00549		{
00550			if(		PlayerPawn(P) != None 
00551				&&	P.PlayerReplicationInfo != None
00552				&&	NetConnection(PlayerPawn(P).Player) != None)
00553			{
00554				if(Request.GetVariable("BanPlayer"$string(P.PlayerReplicationInfo.PlayerID)) != "")
00555				{
00556					IP = PlayerPawn(P).GetPlayerNetworkAddress();
00557					if(Level.Game.CheckIPPolicy(IP))
00558					{
00559						IP = Left(IP, InStr(IP, ":"));
00560						Log("Adding IP Ban for: "$IP);
00561						for(j=0;j<50;j++)
00562							if(Level.Game.IPPolicies[j] == "")
00563								break;
00564						if(j < 50)
00565							Level.Game.IPPolicies[j] = "DENY,"$IP;
00566						Level.Game.SaveConfig();
00567					}
00568					P.Destroy();
00569				}
00570				else
00571				{
00572					if(Request.GetVariable("KickPlayer"$string(P.PlayerReplicationInfo.PlayerID)) != "")
00573						P.Destroy();
00574				}
00575			}
00576		}
00577	
00578		if (Request.GetVariable("SetMinPlayers", "") != "")
00579		{
00580			DeathMatchPlus(Level.Game).MinPlayers = Min(Max(int(Request.GetVariable("MinPlayers", String(0))), 0), 16);
00581			Level.Game.SaveConfig();
00582		}
00583		
00584		for (P=Level.PawnList; P!=None; P=P.NextPawn) {
00585			if (P.bIsPlayer && !P.bDeleteMe && UTServerAdminSpectator(P) == None) {
00586				PawnCount++;
00587				TempItem = new(None) class'ListItem';
00588	
00589				if (P.PlayerReplicationInfo.bIsABot) {
00590					TempItem.Data = "<tr><td width=\"1%\" colspan=2>&nbsp;</td>";
00591					TempStr = "&nbsp;(Bot)";
00592				}
00593				else {
00594					TempItem.Data = "<tr><td width=\"1%\"><div align=\"center\"><input type=\"checkbox\" name=\"KickPlayer"$P.PlayerReplicationInfo.PlayerID$"\" value=\"kick\"></div></td><td width=\"1%\"><div align=\"center\"><input type=\"checkbox\" name=\"BanPlayer"$P.PlayerReplicationInfo.PlayerID$"\" value=\"ban\"></div></td>";
00595					if (P.PlayerReplicationInfo.bIsSpectator)
00596						TempStr = "&nbsp;(Spectator)";
00597					else
00598						TempStr = "";
00599				}
00600				if(PlayerPawn(P) != None)
00601				{
00602					IP = PlayerPawn(P).GetPlayerNetworkAddress();
00603					IP = Left(IP, InStr(IP, ":"));
00604				}
00605				else
00606					IP = "";
00607				TempItem.Data = TempItem.Data$"<td><div align=\"left\">"$P.PlayerReplicationInfo.PlayerName$TempStr$"</div></td><td width=\"1%\"><div align=\"center\">"$P.PlayerReplicationInfo.TeamName$"&nbsp;</div></td><td width=\"1%\"><div align=\"center\">"$P.PlayerReplicationInfo.Ping$"</div></td><td width=\"1%\"><div align=\"center\">"$int(P.PlayerReplicationInfo.Score)$"</div></td><td width=\"1%\"><div align=\"center\">"$IP$"</div></td></tr>";
00608				
00609				switch (Sort) {
00610					case "Name":
00611						TempItem.Tag = P.PlayerReplicationInfo.PlayerName; break;
00612					case "Team":
00613						TempItem.Tag = PadLeft(P.PlayerReplicationInfo.TeamName, 2, "0"); break;
00614					case "Ping":
00615						TempItem.Tag = PadLeft(String(P.PlayerReplicationInfo.Ping), 4, "0"); break;
00616					default:
00617						TempItem.Tag = PadLeft(String(int(P.PlayerReplicationInfo.Score)), 3, "0"); break;
00618					}
00619				if (PlayerList == None)
00620					PlayerList = TempItem;
00621				else
00622					PlayerList.AddSortedElement(PlayerList, TempItem);
00623			}
00624		}
00625		if (PawnCount > 0) {
00626			if (Sort ~= "Score")
00627				for (TempItem=PlayerList; TempItem!=None; TempItem=TempItem.Next)
00628					PlayerListSubst = TempItem.Data$PlayerListSubst;
00629				
00630			else
00631				for (TempItem=PlayerList; TempItem!=None; TempItem=TempItem.Next)
00632					PlayerListSubst = PlayerListSubst$TempItem.Data;
00633		}
00634		else
00635			PlayerListSubst = "<tr align=\"center\"><td colspan=\"5\">** No Players Connected **</td></tr>";
00636	
00637		Response.Subst("PlayerList", PlayerListSubst);
00638		Response.Subst("CurrentGame", Level.Game.GameReplicationInfo.GameName$" in "$Level.Title);
00639		Response.Subst("PostAction", CurrentPlayersPage);
00640		Response.Subst("Sort", Sort);
00641		Response.Subst("MinPlayers", String(DeathMatchPlus(Level.Game).MinPlayers));
00642		Response.IncludeUHTM(CurrentPlayersPage$".uhtm");
00643	}
00644	
00645	function QueryCurrentGame(WebRequest Request, WebResponse Response)
00646	{
00647		local ListItem ExcludeMaps, IncludeMaps;
00648		local class<DeathMatchPlus> NewClass;
00649		local string NewGameType;
00650		
00651		if (Request.GetVariable("SwitchGameTypeAndMap", "") != "") {
00652			Level.ServerTravel(Request.GetVariable("MapSelect")$"?game="$Request.GetVariable("GameTypeSelect")$"?mutator="$UsedMutators(), false);
00653			Response.Subst("Title", "Please Wait");
00654			Response.Subst("Message", "The server is now switching to map '"$Request.GetVariable("MapSelect")$"' and game type '"$Request.GetVariable("GameTypeSelect")$"'.  Please allow 10-15 seconds while the server changes levels.");
00655			Response.IncludeUHTM(MessageUHTM);
00656		}
00657		else if (Request.GetVariable("SwitchGameType", "") != "") {
00658			NewGameType = Request.GetVariable("GameTypeSelect");
00659			NewClass = class<DeathMatchPlus>(DynamicLoadObject(NewGameType, class'Class'));
00660	
00661			ReloadExcludeMaps(ExcludeMaps, NewGameType);
00662			ReloadIncludeMaps(ExcludeMaps, IncludeMaps, NewGameType);
00663	
00664			Response.Subst("GameTypeButton", "");
00665			Response.Subst("MapButton", "<input type=\"submit\" name=\"SwitchGameTypeAndMap\" value=\"Switch\">");
00666			Response.Subst("GameTypeSelect", NewClass.default.GameName$"<input type=\"hidden\" name=\"GameTypeSelect\" value=\""$NewGameType$"\">");
00667			Response.Subst("MapSelect", GenerateMapListSelect(IncludeMaps));
00668			Response.Subst("PostAction", CurrentGamePage);
00669			Response.IncludeUHTM(CurrentGamePage$".uhtm");
00670		}
00671		else if (Request.GetVariable("SwitchMap", "") != "") {
00672			Level.ServerTravel(Request.GetVariable("MapSelect")$"?game="$Level.Game.Class$"?mutator="$UsedMutators(), false);
00673			Response.Subst("Title", "Please Wait");
00674			Response.Subst("Message", "The server is now switching to map '"$Request.GetVariable("MapSelect")$"'.    Please allow 10-15 seconds while the server changes levels.");
00675			Response.IncludeUHTM(MessageUHTM);
00676	
00677		}
00678		else {
00679			ReloadExcludeMaps(ExcludeMaps, String(Level.Game.Class));
00680			ReloadIncludeMaps(ExcludeMaps, IncludeMaps, String(Level.Game.Class));
00681	
00682			Response.Subst("GameTypeButton", "<input type=\"submit\" name=\"SwitchGameType\" value=\"Switch\">");
00683			Response.Subst("MapButton", "<input type=\"submit\" name=\"SwitchMap\" value=\"Switch\">");
00684			Response.Subst("GameTypeSelect", "<select name=\"GameTypeSelect\">"$GenerateGameTypeOptions(String(Level.Game.Class))$"</select>");
00685			Response.Subst("MapSelect", GenerateMapListSelect(IncludeMaps, Left(string(Level), InStr(string(Level), "."))$".unr") );
00686			Response.Subst("PostAction", CurrentGamePage);
00687			Response.IncludeUHTM(CurrentGamePage$".uhtm");
00688		}
00689	}
00690	
00691	function QueryCurrentConsole(WebRequest Request, WebResponse Response)
00692	{
00693		local String SendStr, OutStr;
00694	
00695		SendStr = Request.GetVariable("SendText", "");
00696		if (SendStr != "") {
00697			if (Left(SendStr, 4) ~= "say ")
00698				Spectator.BroadcastMessage("Admin: "$Mid(SendStr, 4));
00699			else {
00700				OutStr = Level.ConsoleCommand(SendStr);
00701				if (OutStr != "")
00702					Spectator.AddMessage(None, OutStr, 'Console');
00703			}
00704		}
00705		
00706		Response.Subst("LogURI", CurrentConsoleLogPage);
00707		Response.Subst("SayURI", CurrentConsoleSendPage);
00708		Response.IncludeUHTM(CurrentConsolePage$".uhtm");
00709	}
00710	
00711	function QueryCurrentConsoleLog(WebRequest Request, WebResponse Response)
00712	{
00713		local ListItem TempItem;
00714		local String LogSubst, LogStr;
00715		local int i;
00716	
00717		for (TempItem = Spectator.MessageList; TempItem != None; TempItem = TempItem.Next)
00718			LogSubst = LogSubst$"&gt; "$TempItem.Data$"<br>";
00719			
00720		Response.Subst("LogRefresh", WebServer.ServerURL$Path$"/"$CurrentConsoleLogPage$"#END");
00721		Response.Subst("LogText", LogSubst);
00722		Response.IncludeUHTM(CurrentConsoleLogPage$".uhtm");
00723	}
00724	
00725	function QueryCurrentConsoleSend(WebRequest Request, WebResponse Response)
00726	{
00727		Response.Subst("DefaultSendText", DefaultSendText);
00728		Response.Subst("PostAction", CurrentConsolePage);
00729		Response.IncludeUHTM(CurrentConsoleSendPage$".uhtm");
00730	}
00731	
00732	function QueryRestartPage(WebRequest Request, WebResponse Response)
00733	{
00734		Level.ServerTravel(Left(string(Level), InStr(string(Level), "."))$".unr"$"?game="$Level.Game.Class$"?mutator="$UsedMutators(), false);
00735		Response.Subst("Title", "Please Wait");
00736		Response.Subst("Message", "The server is now restarting the current map.  Please allow 10-15 seconds while the server changes levels.");
00737		Response.IncludeUHTM(MessageUHTM);
00738	}
00739	
00740	function QueryCurrentMutators(WebRequest Request, WebResponse Response)
00741	{
00742		local ListItem TempItem;
00743		local int Count, i;
00744		
00745		if (Request.GetVariable("AddMutator", "") != "") {
00746			Count = Request.GetVariableCount("ExcludeMutatorsSelect");
00747			for (i=0; i<Count; i++)
00748			{
00749				if (ExcludeMutators != None)
00750				{
00751					TempItem = ExcludeMutators.DeleteElement(ExcludeMutators, Request.GetVariableNumber("ExcludeMutatorsSelect", i));
00752					if (TempItem != None)
00753					{
00754						TempItem.bJustMoved = true;
00755						if (IncludeMutators == None)
00756							IncludeMutators = TempItem;
00757						else
00758							IncludeMutators.AddElement(TempItem);
00759					}
00760					else
00761						Log("Exclude mutator not found: "$Request.GetVariableNumber("ExcludeMutatorsSelect", i));
00762				}
00763			}
00764		}
00765		else if (Request.GetVariable("DelMutator", "") != "") {
00766			Count = Request.GetVariableCount("IncludeMutatorsSelect");
00767			for (i=0; i<Count; i++)
00768			{
00769				if (IncludeMutators != None)
00770				{
00771					TempItem = IncludeMutators.DeleteElement(IncludeMutators, Request.GetVariableNumber("IncludeMutatorsSelect", i));
00772					if (TempItem != None)
00773					{
00774						TempItem.bJustMoved = true;
00775						if (ExcludeMutators == None)
00776							ExcludeMutators = TempItem;
00777						else
00778							ExcludeMutators.AddSortedElement(ExcludeMutators, TempItem);
00779					}
00780					else
00781						Log("Include mutator not found: "$Request.GetVariableNumber("IncludeMutatorsSelect", i));
00782				}
00783			}
00784		}
00785		else if (Request.GetVariable("AddAllMutators", "") != "")
00786		{
00787			while (ExcludeMutators != None)
00788			{
00789				TempItem = ExcludeMutators.DeleteElement(ExcludeMutators);
00790				if (TempItem != None)
00791				{
00792					TempItem.bJustMoved = true;
00793					if (IncludeMutators == None)
00794						IncludeMutators = TempItem;
00795					else
00796						IncludeMutators.AddElement(TempItem);
00797				}
00798			}
00799		}
00800		else if (Request.GetVariable("DelAllMutators", "") != "")
00801		{
00802			while (IncludeMutators != None)
00803			{
00804				TempItem = IncludeMutators.DeleteElement(IncludeMutators);
00805				if (TempItem != None)
00806				{
00807					TempItem.bJustMoved = true;
00808					if (ExcludeMutators == None)
00809						ExcludeMutators = TempItem;
00810					else
00811						ExcludeMutators.AddSortedElement(ExcludeMutators, TempItem);
00812				}
00813			}
00814		}
00815	
00816		Response.Subst("ExcludeMutatorsOptions", GenerateMutatorListSelect(ExcludeMutators));
00817		Response.Subst("IncludeMutatorsOptions", GenerateMutatorListSelect(IncludeMutators));
00818		
00819		Response.Subst("PostAction", CurrentMutatorsPage);
00820		Response.IncludeUHTM(CurrentMutatorsPage$".uhtm");
00821	}
00822	
00823	//*****************************************************************************
00824	function QueryDefaults(WebRequest Request, WebResponse Response)
00825	{
00826		local String GameType, PageStr;
00827		
00828		// if no gametype specified use the first one in the list
00829		GameType = Request.GetVariable("GameType", String(Level.Game.Class));
00830		
00831		// if no page specified, use the first one
00832		PageStr = Request.GetVariable("Page", DefaultsMapsPage);
00833	
00834		Response.Subst("IndexURI", 	DefaultsMenuPage$"?GameType="$GameType$"&Page="$PageStr);
00835		Response.Subst("MainURI", 	PageStr$"?GameType="$GameType);
00836		
00837		Response.IncludeUHTM(DefaultsPage$".uhtm");
00838		Response.ClearSubst();
00839	}
00840	
00841	function QueryDefaultsMenu(WebRequest Request, WebResponse Response)
00842	{
00843		local	String	GameType, Page, TempStr;
00844		
00845		GameType = Request.GetVariable("GameType");
00846		Page = Request.GetVariable("Page");
00847			
00848		if (GameType == "")
00849			GameType = String(Level.Game.Class);
00850		
00851		if (Request.GetVariable("GameTypeSet", "") != "")
00852		{	
00853			TempStr = Request.GetVariable("GameTypeSelect", GameType);
00854			if (!(TempStr ~= GameType))
00855				GameType = TempStr;
00856		}
00857	
00858	
00859		// set post action
00860		Response.Subst("PostAction", DefaultsPage);
00861	
00862	
00863		// set currently used gametype
00864		Response.Subst("GameType", GameType);
00865	
00866		// set currently active page
00867		Response.Subst("Page", Page);
00868		
00869		// Generate gametype options
00870		Response.Subst("GameTypeOptions", GenerateGameTypeOptions(GameType));
00871	
00872		// set background colors
00873		Response.Subst("DefaultBG", DefaultBG);	// for unused tabs
00874	
00875		Response.Subst("MapsBG", 	DefaultBG);
00876		Response.Subst("RulesBG", 	DefaultBG);
00877		Response.Subst("SettingsBG",DefaultBG);
00878		Response.Subst("BotsBG",	DefaultBG);
00879		Response.Subst("ServerBG",	DefaultBG);
00880		Response.Subst("IPPolicyBG",DefaultBG);
00881		Response.Subst("RestartBG", DefaultBG);
00882		
00883		switch(Page) {
00884		case DefaultsMapsPage:
00885			Response.Subst("MapsBG", 	HighlightedBG); break;
00886		case DefaultsRulesPage:
00887			Response.Subst("RulesBG", 	HighlightedBG); break;
00888		case DefaultsSettingsPage:
00889			Response.Subst("SettingsBG",HighlightedBG); break;
00890		case DefaultsBotsPage:
00891			Response.Subst("BotsBG",	HighlightedBG); break;
00892		case DefaultsServerPage:
00893			Response.Subst("ServerBG",	HighlightedBG); break;
00894		case DefaultsIPPolicyPage:
00895			Response.Subst("IPPolicyBG",HighlightedBG); break;
00896		case DefaultsRestartPage:
00897			Response.Subst("RestartBG", HighlightedBG); break;
00898		}
00899	
00900		// Set URIs
00901		Response.Subst("MapsURI", 		DefaultsPage$"?GameType="$GameType$"&Page="$DefaultsMapsPage);
00902		Response.Subst("RulesURI", 		DefaultsPage$"?GameType="$GameType$"&Page="$DefaultsRulesPage);
00903		Response.Subst("SettingsURI", 	DefaultsPage$"?GameType="$GameType$"&Page="$DefaultsSettingsPage);
00904		Response.Subst("BotsURI", 		DefaultsPage$"?GameType="$GameType$"&Page="$DefaultsBotsPage);	
00905		Response.Subst("ServerURI", 	DefaultsPage$"?GameType="$GameType$"&Page="$DefaultsServerPage);	
00906		Response.Subst("IPPolicyURI", 	DefaultsPage$"?GameType="$GameType$"&Page="$DefaultsIPPolicyPage);	
00907		Response.Subst("RestartURI", 	DefaultsPage$"?GameType="$GameType$"&Page="$DefaultsRestartPage);	
00908	
00909		Response.IncludeUHTM(DefaultsMenuPage$".uhtm");
00910		Response.ClearSubst();
00911	}
00912	
00913	function QueryDefaultsMaps(WebRequest Request, WebResponse Response)
00914	{
00915		local String GameType, MapListType;
00916		local ListItem ExcludeMaps, IncludeMaps, TempItem;
00917		local int i, Count, MoveCount;
00918		
00919		// load saved entries from the page	
00920		GameType = Request.GetVariable("GameType");	// provided by index page
00921		MapListType = Request.GetVariable("MapListType", "Custom");
00922		
00923		ReloadExcludeMaps(ExcludeMaps, GameType);
00924		ReloadIncludeMaps(ExcludeMaps, IncludeMaps, GameType);
00925	
00926	
00927		if (Request.GetVariable("MapListSet", "") != "") {
00928			MapListType = Request.GetVariable("MapListSelect", "Custom");
00929			if (MapListType != "Custom")
00930			{
00931				ApplyMapList(ExcludeMaps, IncludeMaps, GameType, MapListType);
00932				
00933				UpdateDefaultMaps(GameType, IncludeMaps);
00934			}
00935		}
00936		else if (Request.GetVariable("AddMap", "") != "") {
00937			Count = Request.GetVariableCount("ExcludeMapsSelect");
00938			for (i=0; i<Count; i++)
00939			{
00940				if (ExcludeMaps != None)
00941				{
00942					TempItem = ExcludeMaps.DeleteElement(ExcludeMaps, Request.GetVariableNumber("ExcludeMapsSelect", i));
00943					if (TempItem != None)
00944					{
00945						TempItem.bJustMoved = true;
00946						if (IncludeMaps == None)
00947							IncludeMaps = TempItem;
00948						else
00949							IncludeMaps.AddElement(TempItem);
00950					}
00951					else
00952						Log("Exclude map not found: "$Request.GetVariableNumber("ExcludeMapsSelect", i));
00953				}
00954			}
00955			MapListType = "Custom";
00956			UpdateDefaultMaps(GameType, IncludeMaps);
00957		}
00958		else if (Request.GetVariable("DelMap", "") != "" && Request.GetVariableCount("IncludeMapsSelect") > 0) {
00959			Count = Request.GetVariableCount("IncludeMapsSelect");
00960			for (i=0; i<Count; i++)
00961			{
00962				if (IncludeMaps != None)
00963				{
00964					TempItem = IncludeMaps.DeleteElement(IncludeMaps, Request.GetVariableNumber("IncludeMapsSelect", i));
00965					if (TempItem != None)
00966					{
00967						TempItem.bJustMoved = true;
00968						if (ExcludeMaps == None)
00969							ExcludeMaps = TempItem;
00970						else
00971							ExcludeMaps.AddSortedElement(ExcludeMaps, TempItem);
00972					}
00973					else
00974						Log("Include map not found: "$Request.GetVariableNumber("IncludeMapsSelect", i));
00975				}
00976			}
00977			MapListType = "Custom";
00978			UpdateDefaultMaps(GameType, IncludeMaps);
00979		}
00980		else if (Request.GetVariable("AddAllMap", "") != "") {
00981			while (ExcludeMaps != None)
00982			{
00983				TempItem = ExcludeMaps.DeleteElement(ExcludeMaps);
00984				if (TempItem != None)
00985				{
00986					TempItem.bJustMoved = true;
00987					if (IncludeMaps == None)
00988						IncludeMaps = TempItem;
00989					else
00990						IncludeMaps.AddElement(TempItem);
00991				}
00992			}
00993			MapListType = "Custom";
00994			UpdateDefaultMaps(GameType, IncludeMaps);
00995		}
00996		else if (Request.GetVariable("DelAllMap", "") != "") {
00997			while (IncludeMaps != None)
00998			{
00999				TempItem = IncludeMaps.DeleteElement(IncludeMaps);
01000				if (TempItem != None)
01001				{
01002					TempItem.bJustMoved = true;
01003					if (ExcludeMaps == None)
01004						ExcludeMaps = TempItem;
01005					else
01006						ExcludeMaps.AddSortedElement(ExcludeMaps, TempItem);
01007				}
01008			}
01009			MapListType = "Custom";
01010			UpdateDefaultMaps(GameType, IncludeMaps);	// IncludeMaps should be None now.
01011		}
01012		else if (Request.GetVariable("MoveMap", "") != "") {
01013			MoveCount = int(Abs(float(Request.GetVariable("MoveMapCount"))));
01014			if (MoveCount != 0) {
01015				Count = Request.GetVariableCount("IncludeMapsSelect");
01016				if (Request.GetVariable("MoveMap") ~= "Down") {
01017					for (TempItem = IncludeMaps; TempItem.Next != None; TempItem = TempItem.Next);
01018					for (TempItem = TempItem; TempItem != None; TempItem = TempItem.Prev) {
01019						for (i=0; i<Count; i++) {
01020							if (TempItem.Data ~= Request.GetVariableNumber("IncludeMapsSelect", i)) {
01021								TempItem.bJustMoved = true;
01022								IncludeMaps.MoveElementDown(IncludeMaps, TempItem, MoveCount);
01023								break;
01024							}
01025						}
01026					}
01027				}
01028				else {
01029					for (TempItem = IncludeMaps; TempItem != None; TempItem = TempItem.Next) {
01030						for (i=0; i<Count; i++) {
01031							if (TempItem.Data ~= Request.GetVariableNumber("IncludeMapsSelect", i)) {
01032								TempItem.bJustMoved = true;
01033								IncludeMaps.MoveElementUp(IncludeMaps, TempItem, MoveCount);
01034								break;
01035							}
01036						}
01037					}
01038				}
01039				
01040				UpdateDefaultMaps(GameType, IncludeMaps);
01041			}
01042		}
01043		
01044		// Start output here
01045		
01046		Response.Subst("MapListType", MapListType);
01047		
01048		// Generate maplist options
01049		Response.Subst("MapListOptions", GenerateMapListOptions(GameType, MapListType));
01050	
01051		// Generate map selects
01052		Response.Subst("ExcludeMapsOptions", GenerateMapListSelect(ExcludeMaps));
01053		Response.Subst("IncludeMapsOptions", GenerateMapListSelect(IncludeMaps));
01054	
01055		Response.Subst("PostAction", DefaultsMapsPage);
01056		Response.Subst("GameType", GameType);
01057		Response.IncludeUHTM(DefaultsMapsPage$".uhtm");
01058		Response.ClearSubst();
01059	}
01060	
01061	function QueryDefaultsRules(WebRequest Request, WebResponse Response)
01062	{
01063		local String GameType, FragName, FragLimit, TimeLimit, MaxTeams, FriendlyFire, PlayersBalanceTeams, ForceRespawn;
01064		local String MaxPlayers, MaxSpectators, WeaponsStay, Tournament;
01065		local class<GameInfo> GameClass;
01066		
01067		GameType = Request.GetVariable("GameType", GameTypeList.Data);
01068		GameClass = class<GameInfo>(DynamicLoadObject(GameType, class'Class'));
01069	
01070		MaxPlayers = Request.GetVariable("MaxPlayers", String(class<DeathMatchPlus>(GameClass).Default.MaxPlayers));
01071		MaxPlayers = String(max(int(MaxPlayers), 0));
01072		class<DeathMatchPlus>(GameClass).Default.MaxPlayers = int(MaxPlayers);
01073		Response.Subst("MaxPlayers", MaxPlayers);
01074		
01075		MaxSpectators = Request.GetVariable("MaxSpectators", String(class<DeathMatchPlus>(GameClass).Default.MaxSpectators));
01076		MaxSpectators = String(max(int(MaxSpectators), 0));
01077		class<DeathMatchPlus>(GameClass).Default.MaxSpectators = int(MaxSpectators);
01078		Response.Subst("MaxSpectators", MaxSpectators);
01079		
01080		WeaponsStay = String(class<DeathMatchPlus>(GameClass).Default.bMultiWeaponStay);
01081		Tournament = String(class<DeathMatchPlus>(GameClass).Default.bTournament);
01082		if(	class<TeamGamePlus>(GameClass) != None )
01083			PlayersBalanceTeams = String(class<TeamGamePlus>(GameClass).Default.bPlayersBalanceTeams);
01084		
01085		if(	class<LastManStanding>(GameClass) == None )
01086			ForceRespawn = String(class<DeathMatchPlus>(GameClass).Default.bForceRespawn);
01087				
01088		if (Request.GetVariable("Apply", "") != "") {		
01089			if(	class<TeamGamePlus>(GameClass) != None )
01090			{
01091				PlayersBalanceTeams = Request.GetVariable("PlayersBalanceTeams", "false");
01092				class<TeamGamePlus>(GameClass).Default.bPlayersBalanceTeams = PlayersBalanceTeams ~= "true";
01093			}
01094	
01095			if(	class<LastManStanding>(GameClass) == None )
01096			{
01097				ForceRespawn = Request.GetVariable("ForceRespawn", "false");
01098				class<DeathMatchPlus>(GameClass).Default.bForceRespawn = bool(ForceRespawn);
01099			}
01100	
01101			WeaponsStay = Request.GetVariable("WeaponsStay", "false");
01102			class<DeathMatchPlus>(GameClass).Default.bMultiWeaponStay = bool(WeaponsStay);
01103	
01104			Tournament = Request.GetVariable("Tournament", "false");
01105			class<DeathMatchPlus>(GameClass).Default.bTournament = bool(Tournament);
01106		}
01107	
01108		if (WeaponsStay ~= "true") {
01109			Response.Subst("WeaponsStay", " checked");
01110		}
01111		if (Tournament ~= "true") {
01112			Response.Subst("Tournament", " checked");
01113		}
01114		if(	class<LastManStanding>(GameClass) == None )
01115		{
01116			if (ForceRespawn ~= "true")
01117				ForceRespawn = " checked";
01118			else
01119				ForceRespawn = "";
01120			Response.Subst("ForceRespawnSubst", "<tr><td>Force Respawn</td><td width=\"1%\"><input type=\"checkbox\" name=\"ForceRespawn\" value=\"true\""$ForceRespawn$"></td></tr>");
01121		}
01122	
01123		if(	class<TeamGamePlus>(GameClass) != None )
01124		{
01125			if (PlayersBalanceTeams ~= "true")
01126				PlayersBalanceTeams = " checked";
01127			else
01128				PlayersBalanceTeams = "";
01129			Response.Subst("BalanceSubst", "<tr><td>Force Balanced Teams</td><td width=\"1%\"><input type=\"checkbox\" name=\"PlayersBalanceTeams\" value=\"true\""$PlayersBalanceTeams$"></td></tr>");
01130		}
01131	
01132		if (class<DeathMatchPlus>(GameClass) != None && class<Assault>(GameClass) == None) {
01133	    	if (class<TeamGamePlus>(GameClass) != None) {
01134	    		FragLimit = Request.GetVariable("FragLimit", String(class<TeamGamePlus>(GameClass).Default.GoalTeamScore));
01135	    		FragLimit = String(max(int(FragLimit), 0));
01136	    		class<TeamGamePlus>(GameClass).Default.GoalTeamScore = float(FragLimit);
01137	    		FragName = "Max Team Score";
01138	    	}
01139	    	else {
01140	    		FragLimit = Request.GetVariable("FragLimit", String(class<DeathMatchPlus>(GameClass).Default.FragLimit));
01141	    		FragLimit = String(max(int(FragLimit), 0));
01142	    		class<DeathMatchPlus>(GameClass).Default.FragLimit = float(FragLimit);
01143	    		FragName = "Frag Limit";
01144	    	}
01145	    	
01146	    	Response.Subst("FragSubst", "<tr><td>"$FragName$"</td><td width=\"1%\"><input type=\"text\" name=\"FragLimit\" maxlength=\"3\" size=\"3\" value=\""$FragLimit$"\"></td></tr>");
01147	
01148			if(class<LastManStanding>(GameClass) == None)
01149			{
01150	    		TimeLimit = Request.GetVariable("TimeLimit", String(class<DeathMatchPlus>(GameClass).Default.TimeLimit));
01151	    		TimeLimit = String(max(int(TimeLimit), 0));
01152				Response.Subst("TimeLimitSubst", "<tr><td>Time Limit</td><td width=\"1%\"><input type=\"text\" name=\"TimeLimit\" maxlength=\"3\" size=\"3\" value=\""$TimeLimit$"\"></td></tr>");
01153				class<DeathMatchPlus>(GameClass).Default.TimeLimit = float(TimeLimit);
01154			}
01155		}
01156		
01157		if(	class<TeamGamePlus>(GameClass) != None &&
01158		    !ClassIsChildOf( GameClass, class'CTFGame' ) &&
01159			!ClassIsChildOf( GameClass, class'Assault' ) ) {
01160	   		MaxTeams = Request.GetVariable("MaxTeams", String(class<TeamGamePlus>(GameClass).Default.MaxTeams));
01161	   		MaxTeams = String(max(int(MaxTeams), 0));
01162	   		class<TeamGamePlus>(GameClass).Default.MaxTeams = Min(Max(int(MaxTeams), 2), 4);
01163			Response.Subst("TeamSubst", "<tr><td>Max Teams</td><td width=\"1%\"><input type=\"text\" name=\"MaxTeams\" maxlength=\"2\" size=\"2\" value="$MaxTeams$"></td><td></tr>");
01164		}
01165		
01166		if (class<TeamGamePlus>(GameClass) != None) {
01167	   		FriendlyFire = Request.GetVariable("FriendlyFire", String(class<TeamGamePlus>(GameClass).Default.FriendlyFireScale * 100));
01168			FriendlyFire = String(min(max(int(FriendlyFire), 0), 100));
01169	   		class<TeamGamePlus>(GameClass).Default.FriendlyFireScale = float(FriendlyFire)/100.0;
01170			Response.Subst("FriendlyFireSubst", "<tr><td>Friendly Fire: [0-100]%</td><td width=\"1%\"><input type=\"text\" name=\"FriendlyFire\" maxlength=\"3\" size=\"3\" value=\""$FriendlyFire$"\"></td></tr>");
01171	    }
01172	    
01173	    Response.Subst("PostAction", DefaultsRulesPage);
01174	   	Response.Subst("GameType", GameType);
01175	    Response.IncludeUHTM(DefaultsRulesPage$".uhtm");
01176		Response.ClearSubst();
01177		
01178		GameClass.Static.StaticSaveConfig();
01179	}
01180	
01181	function QueryDefaultsSettings(WebRequest Request, WebResponse Response)
01182	{
01183		local String GameType, UseTranslocator;
01184		local class<GameInfo> GameClass;
01185		local int GameStyle, GameSpeed, AirControl;
01186	
01187		GameType = Request.GetVariable("GameType", GameTypeList.Data);
01188		GameClass = class<GameInfo>(DynamicLoadObject(GameType, class'Class'));
01189	
01190		if (class<DeathMatchPlus>(GameClass).Default.bMegaSpeed == true)
01191			GameStyle=1;
01192		if (class<DeathMatchPlus>(GameClass).Default.bHardCoreMode == true)
01193			GameStyle+=1;
01194		
01195		switch (Request.GetVariable("GameStyle", String(GameStyle))) {
01196		case "0":
01197			class<DeathMatchPlus>(GameClass).Default.bMegaSpeed = false;
01198			class<DeathMatchPlus>(GameClass).Default.bHardCoreMode = false;
01199			Response.Subst("Normal", " selected"); break;
01200			break;
01201		case "1":
01202			class<DeathMatchPlus>(GameClass).Default.bMegaSpeed = false;
01203			class<DeathMatchPlus>(GameClass).Default.bHardCoreMode = true;
01204			Response.Subst("HardCore", " selected"); break;
01205		case "2":
01206			class<DeathMatchPlus>(GameClass).Default.bMegaSpeed = true;
01207			class<DeathMatchPlus>(GameClass).Default.bHardCoreMode = true;
01208			Response.Subst("Turbo", " selected"); break;
01209		}
01210	
01211		GameSpeed = class<DeathMatchPlus>(GameClass).Default.GameSpeed * 100.0;
01212		AirControl = class<DeathMatchPlus>(GameClass).Default.AirControl * 100.0;
01213		UseTranslocator = String(class<DeathMatchPlus>(GameClass).Default.bUseTranslocator);
01214		
01215		if (Request.GetVariable("Apply", "") != "") {
01216			GameSpeed = min(max(int(Request.GetVariable("GameSpeed", String(GameSpeed))), 10), 200);
01217			class<DeathMatchPlus>(GameClass).Default.GameSpeed = GameSpeed / 100.0;
01218	
01219			AirControl = min(max(int(Request.GetVariable("AirControl", String(AirControl))), 0), 100);
01220			class<DeathMatchPlus>(GameClass).Default.AirControl = AirControl / 100.0;
01221	
01222			UseTranslocator = Request.GetVariable("UseTranslocator", "false");
01223			class<DeathMatchPlus>(GameClass).Default.bUseTranslocator = bool(UseTranslocator);
01224		}
01225		
01226		Response.Subst("GameSpeed", String(GameSpeed));
01227		Response.Subst("AirControl", String(AirControl));
01228		if (UseTranslocator ~= "true")
01229			Response.Subst("UseTranslocator", " checked");
01230		
01231		Response.Subst("PostAction", DefaultsSettingsPage);
01232		Response.Subst("GameType", GameType);
01233		Response.IncludeUHTM(DefaultsSettingsPage$".uhtm");
01234		Response.ClearSubst();
01235		
01236		GameClass.Static.StaticSaveConfig();
01237	}
01238	
01239	
01240	function QueryDefaultsBots(WebRequest Request, WebResponse Response)
01241	{
01242		local String GameType, AutoAdjustSkill, RandomOrder, BalanceTeams, DumbDown;
01243		local class<GameInfo> GameClass;
01244		local class<ChallengeBotInfo> BotConfig;
01245		local int BotDifficulty, MinPlayers;
01246		
01247		GameType = Request.GetVariable("GameType", GameTypeList.Data);
01248		GameClass = class<GameInfo>(DynamicLoadObject(GameType, class'Class'));
01249		BotConfig = class<DeathMatchPlus>(GameClass).Default.BotConfigType;
01250			
01251		if (Request.GetVariable("Apply", "") != "") {
01252			BotDifficulty = int(Request.GetVariable("BotDifficulty", String(BotDifficulty)));
01253			BotConfig.Default.Difficulty = BotDifficulty;
01254			
01255			MinPlayers = min(max(int(Request.GetVariable("MinPlayers", String(MinPlayers))), 0), 16);
01256			class<DeathMatchPlus>(GameClass).Default.MinPlayers = MinPlayers;
01257			
01258			AutoAdjustSkill = Request.GetVariable("AutoAdjustSkill", "false");
01259			BotConfig.Default.bAdjustSkill = bool(AutoAdjustSkill);
01260	
01261			RandomOrder = Request.GetVariable("RandomOrder", "false");
01262			BotConfig.Default.bRandomOrder = bool(RandomOrder);
01263	
01264			if (class<TeamGamePlus>(GameClass) != None) {
01265				BalanceTeams = Request.GetVariable("BalanceTeams", "false");
01266				class<TeamGamePlus>(GameClass).Default.bBalanceTeams = bool(BalanceTeams);
01267	
01268				if (class<Domination>(GameClass) != None) {
01269					DumbDown = Request.GetVariable("DumbDown", "true");
01270					class<Domination>(GameClass).Default.bDumbDown = bool(Dumbdown);
01271				}
01272			}
01273			BotConfig.Static.StaticSaveConfig();
01274			GameClass.Static.StaticSaveConfig();
01275		}
01276	
01277		BotDifficulty = BotConfig.Default.Difficulty;
01278		MinPlayers = class<DeathMatchPlus>(GameClass).Default.MinPlayers;
01279		AutoAdjustSkill = String(BotConfig.Default.bAdjustSkill);
01280		RandomOrder = String(BotConfig.Default.bRandomOrder);
01281		
01282		if (class<TeamGamePlus>(GameClass) != None)
01283			BalanceTeams = String(class<TeamGamePlus>(GameClass).Default.bBalanceTeams);
01284	
01285		if (class<Domination>(GameClass) != None)
01286			DumbDown = String(class<Domination>(GameClass).Default.bDumbDown);
01287	
01288		
01289		Response.Subst("BotDifficulty"$BotDifficulty, " selected");
01290		Response.Subst("MinPlayers", String(MinPlayers));
01291		
01292		if (AutoAdjustSkill ~= "true")
01293			Response.Subst("AutoAdjustSkill", " checked");
01294		if (RandomOrder ~= "true")
01295			Response.Subst("RandomOrder", " checked");
01296	
01297		if (class<TeamGamePlus>(GameClass) != None) {
01298			if (BalanceTeams ~= "true")
01299				BalanceTeams = " checked";
01300			else
01301				BalanceTeams = "";
01302			Response.Subst("BalanceSubst", "<tr><td>Bots Balance Teams</td><td width=\"1%\"><input type=\"checkbox\" name=\"BalanceTeams\" value=\"true\""$BalanceTeams$"></td></tr>");
01303	
01304			if (class<Domination>(GameClass) != None) {
01305				if (DumbDown ~= "false")
01306					DumbDown = " checked";
01307				else
01308					DumbDown = "";
01309				Response.Subst("DumbDownSubst", "<tr><td>Enhanced AI</td><td width=\"1%\"><input type=\"checkbox\" name=\"DumbDown\" value=\"false\""$DumbDown$"></td></tr>");
01310			}
01311		}
01312		Response.Subst("PostAction", DefaultsBotsPage);
01313		Response.Subst("GameType", GameType);
01314		Response.IncludeUHTM(DefaultsBotsPage$".uhtm");
01315		Response.ClearSubst();
01316	}
01317	
01318	function QueryDefaultsServer(WebRequest Request, WebResponse Response)
01319	{
01320		local String ServerName, AdminName, AdminEmail, MOTDLine1, MOTDLine2, MOTDLine3, MOTDLine4, GamePassword, AdminPassword;
01321		local bool bDoUplink, bWorldLog;
01322		
01323		ServerName = class'Engine.GameReplicationInfo'.default.ServerName;
01324		AdminName = class'Engine.GameReplicationInfo'.default.AdminName;
01325		AdminEmail = class'Engine.GameReplicationInfo'.default.AdminEmail;
01326		MOTDLine1 = class'Engine.GameReplicationInfo'.default.MOTDLine1;
01327		MOTDLine2 = class'Engine.GameReplicationInfo'.default.MOTDLine2;
01328		MOTDLine3 = class'Engine.GameReplicationInfo'.default.MOTDLine3;
01329		MOTDLine4 = class'Engine.GameReplicationInfo'.default.MOTDLine4;
01330		GamePassword = Level.ConsoleCommand("get engine.gameinfo GamePassword");
01331		AdminPassword = Level.ConsoleCommand("get engine.gameinfo AdminPassword");
01332	
01333		bDoUplink = class'UdpServerUplink'.default.DoUplink;
01334		bWorldLog = Level.Game.Default.bWorldLog;
01335		
01336		if (Request.GetVariable("Apply", "") != "")
01337		{
01338			ServerName = Request.GetVariable("ServerName", "");
01339			AdminName = Request.GetVariable("AdminName", "");
01340			AdminEmail = Request.GetVariable("AdminEmail", "");
01341			MOTDLine1 = Request.GetVariable("MOTDLine1", "");
01342			MOTDLine2 = Request.GetVariable("MOTDLine2", "");
01343			MOTDLine3 = Request.GetVariable("MOTDLine3", "");
01344			MOTDLine4 = Request.GetVariable("MOTDLine4", "");
01345			bDoUplink = bool(Request.GetVariable("DoUplink", "false"));
01346			bWorldLog = bool(Request.GetVariable("WorldLog", "false"));
01347			GamePassword = Request.GetVariable("GamePassword", "");
01348			AdminPassword = Request.GetVariable("AdminPassword", "");
01349			
01350			class'Engine.GameReplicationInfo'.Default.ServerName = ServerName;
01351			class'Engine.GameReplicationInfo'.Default.AdminName = AdminName;
01352			class'Engine.GameReplicationInfo'.Default.AdminEmail = AdminEmail;
01353			class'Engine.GameReplicationInfo'.Default.MOTDline1 = MOTDLine1;
01354			class'Engine.GameReplicationInfo'.Default.MOTDline2 = MOTDLine2;
01355			class'Engine.GameReplicationInfo'.Default.MOTDline3 = MOTDLine3;
01356			class'Engine.GameReplicationInfo'.Default.MOTDline4 = MOTDLine4;
01357			class'Engine.GameReplicationInfo'.Static.StaticSaveConfig();
01358	
01359			class'UdpServerUplink'.default.DoUplink = bDoUplink;
01360			class'UdpServerUplink'.Static.StaticSaveConfig();
01361			
01362			Level.Game.Default.bWorldLog = bWorldLog;
01363			Level.Game.Static.StaticSaveConfig();
01364	
01365			Level.ConsoleCommand("set engine.gameinfo GamePassword "$GamePassword);
01366			Level.ConsoleCommand("set engine.gameinfo AdminPassword "$AdminPassword);
01367		}
01368		
01369		Response.Subst("ServerName", ServerName);
01370		Response.Subst("AdminName", AdminName);
01371		Response.Subst("AdminEmail", AdminEmail);
01372		Response.Subst("MOTDLine1", MOTDLine1);
01373		Response.Subst("MOTDLine2", MOTDLine2);
01374		Response.Subst("MOTDLine3", MOTDLine3);
01375		Response.Subst("MOTDLine4", MOTDLine4);
01376		Response.Subst("GamePassword", GamePassword);
01377		Response.Subst("AdminPassword", AdminPassword);
01378		
01379		if (bDoUplink)
01380			Response.Subst("DoUplink", " checked");
01381		if (bWorldLog)
01382			Response.Subst("WorldLog", " checked");
01383	
01384		Response.Subst("PostAction", DefaultsServerPage);		
01385		Response.IncludeUHTM(DefaultsServerPage$".uhtm");
01386	}
01387	
01388	function QueryDefaultsIPPolicy(WebRequest Request, WebResponse Response)
01389	{
01390		local int i, j;
01391	
01392		if(Request.GetVariable("Update") != "")
01393		{
01394			i = int(Request.GetVariable("PolicyNo", "-1"));
01395			if(i == -1)
01396				for(i = 0; i<50 && Level.Game.IPPolicies[i] != ""; i++);
01397			if(i < 50)
01398				Level.Game.IPPolicies[i] = Request.GetVariable("AcceptDeny")$","$Request.GetVariable("IPMask");
01399			Level.Game.SaveConfig();
01400		}
01401	
01402		if(Request.GetVariable("Delete") != "")
01403		{
01404			i = int(Request.GetVariable("PolicyNo", "-1"));
01405			
01406			if(i > 0)
01407			{
01408				for(i = i; i<49 && Level.Game.IPPolicies[i] != ""; i++)
01409					Level.Game.IPPolicies[i] = Level.Game.IPPolicies[i + 1];
01410	
01411				if(i == 49)
01412					Level.Game.IPPolicies[49] = "";
01413				Level.Game.SaveConfig();
01414			}
01415		}
01416	
01417		Response.IncludeUHTM(DefaultsIPPolicyPage$"-h.uhtm");
01418		for(i=0; i<50 && Level.Game.IPPolicies[i] != ""; i++)
01419		{
01420			j = InStr(Level.Game.IPPolicies[i], ",");
01421			if(Left(Level.Game.IPPolicies[i], j) ~= "DENY")
01422			{
01423				Response.Subst("AcceptCheck", "");
01424				Response.Subst("DenyCheck", "checked");
01425			}
01426			else
01427			{
01428				Response.Subst("AcceptCheck", "checked");
01429				Response.Subst("DenyCheck", "");
01430			}
01431			Response.Subst("IPMask", Mid(Level.Game.IPPolicies[i], j+1));
01432			Response.Subst("PostAction", DefaultsIPPolicyPage$"?PolicyNo="$string(i));
01433			Response.IncludeUHTM(DefaultsIPPolicyPage$"-d.uhtm");
01434		}
01435		Response.Subst("PostAction", DefaultsIPPolicyPage);
01436		Response.IncludeUHTM(DefaultsIPPolicyPage$"-f.uhtm");
01437	}
01438	
01439	defaultproperties
01440	{
01441	     SpectatorType=Class'UTServerAdmin.UTServerAdminSpectator'
01442	     MenuPage="menu"
01443	     RootPage="root"
01444	     CurrentPage="current"
01445	     CurrentMenuPage="current_menu"
01446	     CurrentIndexPage="current_index"
01447	     CurrentPlayersPage="current_players"
01448	     CurrentGamePage="current_game"
01449	     CurrentConsolePage="current_console"
01450	     CurrentConsoleLogPage="current_console_log"
01451	     CurrentConsoleSendPage="current_console_send"
01452	     DefaultSendText="say "
01453	     CurrentMutatorsPage="current_mutators"
01454	     CurrentRestartPage="current_restart"
01455	     DefaultsPage="defaults"
01456	     DefaultsMenuPage="defaults_menu"
01457	     DefaultsMapsPage="defaults_maps"
01458	     DefaultsRulesPage="defaults_rules"
01459	     DefaultsSettingsPage="defaults_settings"
01460	     DefaultsBotsPage="defaults_bots"
01461	     DefaultsServerPage="defaults_server"
01462	     DefaultsIPPolicyPage="defaults_ippolicy"
01463	     DefaultsRestartPage="defaults_restart"
01464	     MessageUHTM="message.uhtm"
01465	     DefaultBG="#aaaaaa"
01466	     HighlightedBG="#ffffff"
01467	     AdminRealm="UT Remote Admin Server"
01468	     AdminUsername="admin"
01469	     AdminPassword="admin"
01470	}

End Source Code

UTServerAdmin Class UTServerAdmin

UTServerAdmin
Class UTServerAdmin