RuneServerAdmin.RuneServerAdmin

RuneServerAdmin
Class RuneServerAdmin

source: c:\runehov\RuneServerAdmin\Classes\RuneServerAdmin.uc

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

Direct Known Subclasses:None

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

End Source Code

RuneServerAdmin Class RuneServerAdmin

RuneServerAdmin
Class RuneServerAdmin