Legacy:ConfigMaster

This is a custom class, which is part of the ConfigManager for UT2003.

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

// ConfigManager.ConfigMaster version 1.8

// Allows for ServerActors & Mutators to add to PlayInfo

```
//
```

// The latest version of ConfigManager is always available at

// http://www.organized-evolution.com/ConfigManager/

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

```
 
```

class ConfigMaster extends Mutator DependsOn(AutoLoader) config(ConfigMaster);

```
 
```
```
// If 2184 or earlier, crash the server
```
```
var int						GameVersion;
```
```
 
```

// Contains previous values of modified IniEntries, unless there is already

// a previous value for an IniEntry.  When a managed loader is de-activated,

// the original value of the IniEntry is restored.

var config array<AutoLoader.IniEntry>	OriginalValues;

```
 
```

// Holder for properties which aren't needed - used by loaders that get activated at the end of the match

var array<Property>			IrrelevantProperties;

```
 
```
```
struct SA
```
```
{
```
```
	var class<Info>			SA${1}< ${3} >
```
```
	var string				SAName;
```
```
	var string				SADescription;
```
```
};
```
```
 
```
```
struct AL
```
```
{
```

	var class<AutoLoader>	AutoLoader${1}< ${3} >

```
	var string				AutoLoaderDesc;
```
```
};
```
```
 
```

var array<SA>				ManagedActors;		// Info about Loaders' ActorClasses

var array<AL>				LoaderClasses;		// All Loader Classes found

var array<AutoLoader>		Loaders;			// Active Loaders

var array<string>			ActiveMutators;		// Currently active mutator classes

var bool					bInitialized;		// Initialization

var bool					bHangRestart;		// Don't let server travel yet

```
 
```
```
var GameEngine				GE;
```
```
 
```
```
const VERSION = 1.71;
```
```
const LOGNAME = 'Config Manager';
```
```
var const bool	DEBUG;
```
```
var const bool 	DEBUGPROPS;
```
```
 
```
```
// Localization
```
```
var localized string LoadSuccess;
```
```
var localized string RequiredVersion;
```
```
var localized string UpgradeOrDie;
```
```
var localized string RemovalCancelled;
```
```
 
```
```
// Errors
```

var localized string InvalidLoader${1}< ${3} >

```
var localized string InvalidPI;
```
```
 
```
```
event PreBeginPlay()
```
```
{
```

	GameVersion = int(Level.EngineVersion);

```
 
```

	log(" -"@LOGNAME@VERSION@LoadSuccess,LOGNAME);

```
	if (GameVersion < 2199)
```
```
	{
```

		log(RequiredVersion@LOGNAME$".",LOGNAME);

```
		log(UpgradeOrDie,LOGNAME);
```
```
		log("",'ConfigManager');
```
```
		Assert(False);
```
```
	}
```
```
 
```
```
	GetGameEngine();
```
```
}
```
```
 
```
```
event PostBeginPlay()
```
```
{
```
```
	local int i;
```
```
 
```
```
	if (DEBUG)
```
```
	{
```

		log(class@"Beginning initialization",'PostBeginPlay');

		log("START OF GAME SERVERACTORS",'PostBeginPlay');

		for (i = 0; i < GE.ServerActors.Length; i++)

			log("ServerActor["$i$"]:"$GE.ServerActors[i],'PostBeginPlay');

```
 
```

		log("START OF GAME SERVERPACKAGES",'PostBeginPlay');

		for (i = 0; i < GE.ServerPackages.Length; i++)

			log("ServerPackages["$i$"]:"$GE.ServerPackages[i],'PostBeginPlay');

```
 
```
```
		log("",'PostBeginPlay');
```
```
	}
```

//	Level.Game.AddMutator("ConfigManagerGUI.ConfigManagerGUIMaster");

```
 
```
```
	InitLoaders();
```
```
	if (DEBUG)
```

		log(class@"finished loading all actors and loaders",'PostBeginPlay');

```
 
```
```
	Super.PostBeginPlay();
```
```
}
```
```
 
```

// Sends a list of currently active mutators to all loader classes

// Loader classes may want to check if its mutator was loaded without using the loader

```
// (added at command line, etc.)
```
```
function GetGameEngine()
```
```
{
```

	foreach AllObjects(class'Engine.GameEngine', GE)

```
		break;
```
```
}
```
```
 
```
```
function AddMutator(Mutator M)
```
```
{
```
```
	local int i;
```
```
 
```

	for (i = 0; i < ActiveMutators.Length; i++)

		if (ActiveMutators[i] ~= string(M.Class))

```
			break;
```
```
 
```
```
	if (i == ActiveMutators.Length)
```

		ActiveMutators[ActiveMutators.Length] = string(M.Class);

```
 
```
```
	if (DEBUG)
```

		for (i = 0; i < ActiveMutators.Length; i++)

			log("ActiveMutators["$i$"]:"@ActiveMutators[i],'AddMutator');

```
 
```
```
	Super.AddMutator(M);
```
```
}
```
```
 
```

// Do not show ConfigMaster in server browser as active mutator

function GetServerDetails( out GameInfo.ServerResponseLine ServerState )

```
{
```
```
}
```
```
 
```
```
function InitLoaders()
```
```
{
```
```
	FindAllLoaders();
```
```
	CreateLoaders();
```
```
}
```
```
 
```
```
function FindAllLoaders()
```
```
{
```
```
	local int i, j;
```
```
	local AL TempAL;
```
```
	local SA TempSA;
```
```
 
```

	local class<AutoLoader>	Loader${1}< ${3} >

	local class<Info>		ServerActor${1}< ${3} >

	local string			LoaderClassName, LoaderClassDescription,

				 			ActorClass, ServerActorName, ServerActorDesc;

```
 
```

	GetNextIntDesc("ConfigManager.AutoLoader",0,LoaderClassName,LoaderClassDescription);

```
	while (LoaderClassName != "")
```
```
	{
```

		// Hack to prevent Config Loader from being loaded

		if (LoaderClassName ~= "ConfigManagerLoader.SampleLoader")

```
		{
```

			GetNextIntDesc("ConfigManager.AutoLoader",++i,LoaderClassName,LoaderClassDescription);

```
			continue;
```
```
		}
```
```
		if (DEBUG)
```

			log("Found a new AutoLoader:"@LoaderClassName@LoaderClassDescription,'FindAllLoaders');

```
 
```

		LoaderClass = class<AutoLoader>(DynamicLoadObject(LoaderClassName,Class'Class'));

```
		if (LoaderClass != None)
```
```
		{
```

			if (ShouldAddLoaderClass(LoaderClass))

```
			{
```

				TempAL.AutoLoaderClass = Loader${1}< ${3} >

				TempAL.AutoLoaderDesc = LoaderClassDescription;

				LoaderClasses[LoaderClasses.Length] = TempAL;

```
				j = -1;
```

				while (LoaderClass.static.AddManagedActor(j++, ActorClass, ServerActorName, ServerActorDesc))

```
				{
```

					if (ActorClass != "" && ServerActorName != "" && ServerActorDesc != "")

```
					{
```

						ServerActorClass = class<Info>(DynamicLoadObject(ActorClass,class'Class'));

```
						if (ServerActorClass != None)
```
```
						{
```

							TempSA.SAClass = ServerActor${1}< ${3} >

```
							TempSA.SAName = ServerActorName;
```

							TempSA.SADescription = ServerActorDesc;

```
 
```

							ManagedActors[ManagedActors.Length] = TempSA;

```
						}
```
```
					}
```
```
				}
```
```
			}
```
```
		}
```

		else Warn(InvalidLoaderClass@LoaderClassName);

```
 
```

		GetNextIntDesc("ConfigManager.AutoLoader",++i, LoaderClassName, LoaderClassDescription);

```
	}
```
```
 
```
```
	return;
```
```
}
```
```
 
```

function bool ShouldAddLoaderClass(class<AutoLoader> NewClass)

```
{
```
```
	local int i;
```
```
 
```
```
	if (DEBUG)
```

		log("Loader Class"@NewClass,'ShouldAddLoaderClass');

```
 
```

	// Don't add if it's already in the list

	for (i = 0;i < LoaderClasses.Length; i++)

		if (LoaderClasses[i].AutoLoaderClass == NewClass)

```
			return false;
```
```
 
```
```
	return true;
```
```
}
```
```
 
```
```
function CreateLoaders()
```
```
{
```
```
	local int i;
```
```
	local AutoLoader Loader;
```
```
 
```
```
	if (DEBUG)
```

		log("LoaderClasses"@LoaderClasses.Length,'CreateLoaders');

```
 
```
```
	for (i = 0;i<LoaderClasses.Length;i++)
```
```
	{
```

		if (ShouldAddLoader(LoaderClasses[i].AutoLoaderClass))

```
		{
```

			Loader = AddLoader(LoaderClasses[i].AutoLoaderClass);

```
			if (Loader != None)
```
```
				Loaders[Loaders.Length] = Loader;
```
```
		}
```
```
	}
```
```
}
```
```
 
```

function bool LoaderNotActive(class<AutoLoader> NewClass)

```
{
```
```
	local int i;
```
```
 
```
```
	for (i = 0; i < Loaders.Length; i++)
```
```
		if (Loaders[i].Class == NewClass)
```
```
			return false;
```
```
 
```
```
	return true;
```
```
}
```
```
 
```

function bool ShouldAddLoader(class<AutoLoader> NewClass)

```
{
```
```
	local bool bShouldAdd;
```
```
 
```

	bShouldAdd = LoaderNotActive(NewClass) && GE != None;

```
 
```
```
	if (bShouldAdd)
```

		bShouldAdd = NewClass.static.CheckStrayActors(GE.GetPropertyText("ServerActors")) || NewClass.static.IsActive();

```
 
```

	bShouldAdd = bShouldAdd && NewClass.static.ValidateLoader();

```
 
```
```
	if (DEBUG)
```

		log(NewClass@"will be added:"$bShouldAdd,'ShouldAddLoader');

```
 
```
```
	return bShouldAdd;
```
```
}
```
```
 
```

function AutoLoader AddLoader(class<AutoLoader> NewClass)

```
{
```
```
	local AutoLoader Loader;
```
```
	if (NewClass == None) return None;
```
```
 
```
```
	Loader = Spawn(NewClass,Self);
```
```
	if (Loader != None && GE != None)
```
```
		Loader.GE = GE;
```
```
 
```
```
	if (DEBUG)
```
```
		log("Returning"@Loader,'AddLoader');
```
```
 
```
```
	return Loader;
```
```
}
```
```
 
```

// Make sure to remain as Game.BaseMutator.NextMutator so we will know about every mutator that is added.

```
event Tick(float DeltaTime)
```
```
{
```
```
	local int i;
```
```
 
```

	if (bInitialized && Level != None && Level.NextURL != "")

```
	{
```
```
		if (bHangRestart)
```
```
			Level.NextSwitchCountdown = 4.0;
```
```
 
```
```
		else if (Loaders.Length > 0)
```
```
		{
```
```
			bHangRestart = True;
```
```
			SetTimer(0.2,False);
```
```
		}
```
```
	}
```
```
 
```

	// Do not replace BaseMutator, or DMMutator will show up in server browser as an active mutator

	if (Level != None && Level.Game != None && Level.Game.BaseMutator != None)

```
	{
```

		if (Level.Game.BaseMutator.NextMutator != None)

```
		{
```

			if (Level.Game.BaseMutator.NextMutator != Self)

```
			{
```

			// Some other ConfigManager as BaseMutator.NextMutator, but it isn't me????

			// Maybe added ConfigManager as a serveractor?

```
			// Disable or server will crash
```

				if (!bInitialized && Level.Game.BaseMutator.NextMutator.Class == Class)

```
				{
```
```
					Destroy();
```
```
					return;
```
```
				}
```
```
 
```

				// We have been replaced by another mutator wanting

```
				// to be the first mutator.
```

				if (Level.Game.BaseMutator.NextMutator.NextMutator == Self)

```
				{
```
```
					if (NextMutator != None)
```

						Level.Game.BaseMutator.NextMutator.NextMutator = NextMutator;

					else Level.Game.BaseMutator.NextMutator.NextMutator = None;

```
				}
```
```
 
```

				NextMutator = Level.Game.BaseMutator.NextMutator;

				Level.Game.BaseMutator.NextMutator = Self;

```
			}
```
```
		}
```
```
 
```

		else Level.Game.BaseMutator.NextMutator = Self;

```
	}
```
```
 
```
```
	if (!bInitialized)
```
```
	{
```

		for (i = 0; i < LoaderClasses.Length; i++)

```
		{
```

			if (LoaderNotActive(LoaderClasses[i].AutoLoaderClass) && LoaderClasses[i].AutoLoaderClass.static.CheckCurrentMutators(GetURLOption("Mutator")))

```
			{
```
```
				if (DEBUG)
```

					log("Adding previously non-active loader"@LoaderClasses[i].AutoLoaderClass,'Tick');

				Loaders[Loaders.Length] = AddLoader(LoaderClasses[i].AutoLoaderClass);

```
			}
```
```
		}
```
```
 
```
```
		bInitialized = True;
```
```
	}
```
```
}
```
```
 
```
```
event Timer()
```
```
{
```
```
	Super.Timer();
```
```
	ApplyLoaderSettings();
```
```
}
```
```
 
```

function array<Property> LoadProperties()

```
{
```
```
	local array<Property>	AllProperties;
```
```
	local array<class>		RelevantActors;
```

	local array<string>		RelevantPropNames;

```
	local class				Relevant${1}< ${3} >
```
```
	local Property P;
```
```
	local int i, j, k;
```
```
 
```

	// Build a array of properties which are relevant to the currently loaded loaders

	// so that the amount of time it will take each loader to update their settings will

```
	// be dramatically reduced -
```

	// Typical number of Property objects in the game: 200,000

	// Typical number of properties relevant to current loaders: 50

```
 
```
```
 
```

	// Start by first getting a list of actors/objects which will be relevant

```
 
```

	// All ManagedActors are relevant (Loader's ActorClass)

	for (i = 0; i < ManagedActors.Length; i++)

```
	{
```

		for (j = 0; j < RelevantActors.Length; j++)

			if (RelevantActors[j] == ManagedActors[i].SAClass)

```
				break;
```
```
 
```
```
		if (j < RelevantActors.Length)
```
```
			continue;
```
```
 
```

		RelevantActors[RelevantActors.Length] = ManagedActors[i].SA${1}< ${3} >

```
	}
```
```
 
```
```
	if (DEBUG)
```

		log("Loaders"@LoaderClasses.Length,'LoadProperties');

```
 
```

	for (i = 0; i < LoaderClasses.Length; i++)

```
	{
```

		// If ActorClass was already added to list, skip it

		for (j = 0; j < RelevantActors.Length; j++)

			if (string(RelevantActors[j]) ~= LoaderClasses[i].AutoLoaderClass.default.ActorClass)

```
				break;
```
```
 
```
```
		if (j == RelevantActors.Length)
```
```
		{
```

			if (LoaderClasses[i].AutoLoaderClass.default.ActorClass != "")

				RelevantClass = class(DynamicLoadObject(LoaderClasses[i].AutoLoaderClass.default.ActorClass,class'Class'));

```
 
```
```
			if (RelevantClass != None)
```

				RelevantActors[RelevantActors.Length] = Relevant${1}< ${3} >

```
		}
```
```
 
```

		// Begin building a list of property names to mark as relevant

		// We'll match these names to the Property.Name variable later when we iterate AllObjects for class'Property'

		for (j = 0; j < LoaderClasses[i].AutoLoaderClass.default.RequiredIniEntries.Length; j++)

```
		{
```
```
 
```

			for (k = 0; k < RelevantPropNames.Length; k++)

```
			{
```

				if (RelevantPropNames[k] == LoaderClasses[i].AutoLoaderClass.default.RequiredIniEntries[j].PropName)

```
					break;
```
```
			}
```
```
 
```
```
			if ( k == RelevantPropNames.Length )
```
```
			{
```

				RelevantPropNames[RelevantPropNames.Length] = LoaderClasses[i].AutoLoaderClass.default.RequiredIniEntries[j].PropName;

```
				if (DEBUGPROPS)
```

					log("Added new Relevant Property Name:"$RelevantPropNames[k],'LoadProperties');

```
			}
```
```
 
```

			RelevantClass = class(DynamicLoadObject(LoaderClasses[i].AutoLoaderClass.default.RequiredIniEntries[j].ClassFrom,Class'class',True));

```
			if (RelevantClass == None) continue;
```
```
 
```

			// Find out if this entry's associated class is already in the relevant actors list

```
			// If not, add it
```

			for (k = 0; k < RelevantActors.Length; k++)

```
			{
```
```
				if (DEBUGPROPS)
```

					log("Compare"@LoaderClasses[i].AutoLoaderClass.default.RequiredIniEntries[j].ClassFrom@"to Relevant Actor"@k$":"@RelevantActors[k],'LoadProperties');

```
 
```

				if (RelevantActors[k] == RelevantClass)

```
					break;
```
```
			}
```
```
			if (DEBUGPROPS)
```

				log("Breaking on"@k$", Total Relevant Actors:"@RelevantActors.Length,'LoadProperties');

```
 
```
```
			if (k < RelevantActors.Length)
```
```
				continue;
```
```
 
```

			RelevantActors[RelevantActors.Length] = Relevant${1}< ${3} >

```
			if (DEBUGPROPS)
```

				log("Added new relevant actor:"$LoaderClasses[i].AutoLoaderClass.default.RequiredIniEntries[j].ClassFrom,'LoadProperties');

```
		}
```
```
	}
```
```
 
```

	// Finished building relevant actors and relevant names

	// Iterate AllObjects, looking for Property objects

```
	foreach AllObjects(class'Property', P)
```
```
	{
```
```
		RelevantClass = None;
```

		// Some property types should be skipped

```
		if ( ValidProp(P) )
```
```
		{
```

			if (Class(P.Outer) != None) RelevantClass = Class(P.Outer);

```
			if (RelevantClass != None)
```
```
			{
```

				for (i = 0; i < RelevantActors.Length; i++)

```
			 	{
```

			 		// The Outer variable for properties is the class that the property is contained in

			 		// If this property's Outer is an object that is relevant, add it to the list

			 		if (RelevantClass == RelevantActors[i])

```
			 		{
```

			 			for (j = 0; j < RelevantPropNames.Length; j++)

			 				if (RelevantPropNames[j] == string(P.Name))

```
			 				{
```
```
			 					if (DEBUGPROPS)
```

			 						log("Adding Initial Relevant Property:"$P.Outer$"."$P.Name,'LoadProperties');

			 					AllProperties[AllProperties.Length] = P;

```
			 					break;
```
```
			 				}
```
```
 
```

			 			if (j < RelevantPropNames.Length)

```
			 				break;
```
```
			 		}
```
```
			 	}
```
```
			}
```
```
 
```

			// OK, this property's Outer wasn't relevant

			// Check the property against the relevant name list

```
		 	if (i == RelevantActors.Length)
```
```
		 	{
```

		 		for (i = 0; i < RelevantPropNames.Length; i++)

```
		 		{
```

				// If we find a match, then we should check the relevant objects list again,

				// in case the relevant object is a superclass of the property's Outer

		 			if (RelevantPropNames[i] == string(P.Name))

```
		 			{
```
```
						if (DEBUGPROPS)
```

							log("Compare Property:"@i@RelevantPropNames[i]@"to"@string(P.Name),'LoadProperties');

```
 
```

		 				for (j = 0; j < RelevantActors.Length; j ++)

```
		 				{
```

		 					if (RelevantClass == None) continue;

```
 
```
```
							if (DEBUGPROPS)
```

								log("Relevant Actor Check:"@j@RelevantActors[j]@"is child of"@class(P.Outer)@":"$ClassIsChildOf(RelevantActors[j],Class(P.Outer)),'LoadProperties');

```
 
```

		 					if (ClassIsChildOf(RelevantActors[j], RelevantClass))

```
		 					{
```
```
		 						if (DEBUGPROPS)
```

		 							log("Adding Additional Relevant Property:"$P.Outer$"."$P.Name,'LoadProperties');

```
 
```

		 						AllProperties[AllProperties.Length] = P;

```
		 						break;
```
```
		 					}
```
```
		 				}
```
```
 
```
```
		 				if (j < RelevantActors.Length)
```
```
		 					break;
```
```
		 			}
```
```
		 		}
```
```
		 	}
```
```
		}
```
```
	}
```
```
 
```
```
	return AllProperties;
```
```
}
```
```
 
```

// Update Properties array with newly loaded loaders

```
// No longer used
```

function CheckRelevantProperties(AutoLoader L, out array<Property> Props)

```
{
```
```
	local int i, j;
```
```
	local array<class> Classes, Outers;
```
```
 
```
```
	local class Temp${1}< ${3} >
```
```
	local Property P;
```
```
 
```

	if (DEBUGPROPS) log("Checking relevant properties for new loader"@L,'CheckRelevantProperties');

```
 
```
```
	for (i = 0; i < Props.Length; i++)
```
```
	{
```
```
		TempClass = Class(Props[i].Outer);
```
```
		if (TempClass == None) continue;
```
```
 
```
```
		for (j = 0; j < Outers.Length; j++)
```
```
			if (TempClass == Outers[j])
```
```
				break;
```
```
 
```
```
		if (j < Outers.Length) continue;
```
```
 
```

		Outers[Outers.Length] = Temp${1}< ${3} >

```
	}
```
```
 
```

	if (L.bIncludeServerActor && L.ActorClass != "")

```
	{
```

		if (DEBUGPROPS) log("Checking for existence of"@L.ActorClass@"properties",'CheckRelevantProperties');

```
 
```

		TempClass = class(DynamicLoadObject(L.ActorClass,class'Class',True));

```
		if (TempClass != None)
```
```
		{
```
```
			for (i = 0; i < Outers.Length; i++)
```
```
				if (TempClass == Outers[i])
```
```
					break;
```
```
 
```
```
			if (i == Outers.Length)
```

				Classes[Classes.Length] = Temp${1}< ${3} >

```
 
```
```
			else if (DEBUGPROPS)
```

				log(TempClass@"has already been added to the properties array.",'CheckRelevantProperties');

```
		}
```
```
	}
```
```
 
```

	for (i = 0; i < L.RequiredIniEntries.Length; i++)

```
	{
```

		if (DEBUGPROPS) log("Checking for existence of relevant class"@L.RequiredIniEntries[i].ClassFrom,'CheckRelevantProperties');

```
 
```

		TempClass = class(DynamicLoadObject(L.RequiredIniEntries[i].ClassFrom,class'Class',True));

```
		if (TempClass != None)
```
```
		{
```
```
			for (j = 0; j < Classes.Length; j++)
```
```
				if (Classes[j] == TempClass) break;
```
```
 
```
```
			if (j < Classes.Length) continue;
```
```
 
```
```
			for (j = 0; j < Outers.Length; j++)
```
```
				if (Outers[j] == TempClass) break;
```
```
 
```
```
			if (j < Outers.Length) continue;
```
```
 
```

			Classes[Classes.Length] = Temp${1}< ${3} >

```
		}
```
```
		else if (DEBUGPROPS)
```

			log("Could not load RequiredIniEntry["$i$"].ClassFrom:"@L.RequiredIniEntries[i].ClassFrom,'CheckRelevantProperties');

```
	}
```
```
 
```
```
	if (DEBUGPROPS && Classes.Length == 0)
```

		log("All relevant classes from this loader already existed in properties array",'CheckRelevantProperties');

```
 
```
```
	for (i = 0; i < Classes.Length; i++)
```
```
	{
```
```
		if (DEBUGPROPS)
```
```
		{
```
```
			log("");
```

			log("Adding properties from class"@Classes[i]@"to properties array.",'CheckRelevantProperties');

```
		}
```
```
 
```

		for (j = 0; j < IrrelevantProperties.Length; j++)

```
		{
```
```
			P = IrrelevantProperties[j];
```
```
			TempClass = Class(P.Outer);
```
```
 
```

			if (TempClass == None || TempClass != Classes[i]) continue;

```
 
```

			if (DEBUGPROPS) log("    Adding property"@P.Name,'CheckRelevantProperties');

```
 
```
```
			Props[Props.Length] = P;
```
```
			IrrelevantProperties.Remove(j--, 1);
```
```
		}
```
```
	}
```
```
}
```
```
 
```
```
// TODO: Add support for structs
```

final function bool ValidProp(Property P)

```
{
```

	return P.Class != class'ObjectProperty' &&

		   P.Class != class'DelegateProperty' &&

		   P.Class != class'PointerProperty' &&

```
		   P.Class != class'MapProperty' &&
```
```
		   P.Class != class'StructProperty';
```
```
}
```
```
 
```
```
// Fills PlayInfo for ServerActors
```

final function CallManagedActorPlayInfo(PlayInfo PI)

```
{
```
```
	local int i, j;
```
```
 
```

	for (i = 0; i < LoaderClasses.Length; i++)

```
	{
```
```
		if (DEBUG)
```

			log("Checking for LoaderClass"@i@"in playinfo:"$loaderclasses[i].autoloaderclass,'ManagedActorFillPlayInfo');

```
 
```

		if (NotInPlayInfo(PI,LoaderClasses[i].AutoLoaderClass))

```
		{
```
```
			if (DEBUG)
```

				log("Calling FillPlayInfo() for LoaderClass"@i$":"$loaderclasses[i].autoloaderclass,'ManagedActorFillPlayInfo');

```
 
```

			LoaderClasses[i].AutoLoaderClass.static.FillPlayInfo(PI);

```
			PI.PopClass();
```
```
		}
```
```
 
```

		for (j = 0; j < ManagedActors.Length; j++)

```
		{
```

			if (LoaderClasses[i].AutoLoaderClass.default.ActorClass != string(ManagedActors[j].SAClass))

```
				continue;
```
```
 
```
```
			if (DEBUG)
```

				log("Checking for ManagedActor"@j@"in playinfo:"$ManagedActors[j].SAClass,'ManagedActorFillPlayInfo');

```
 
```

			if (LoaderClasses[i].AutoLoaderClass.static.IsActive())

```
			{
```

				ManagedActors[j].SAClass.static.FillPlayInfo(PI);

```
				PI.PopClass();
```
```
			}
```
```
		}
```
```
	}
```
```
}
```
```
 
```

// Only webadmin calls Mutator.MutatorFillPlayInfo()?

function MutatorFillPlayInfo(PlayInfo PI)

```
{
```
```
	if (DEBUG)
```
```
		log("");
```
```
 
```
```
	if (DEBUG)
```

		log("Checking URL Option:"$GetURLOption("Mutator"),'MutatorFillPlayInfo');

```
 
```
```
	if (NextMutator != None)
```
```
		NextMutator.MutatorFillPlayInfo(PI);
```
```
 
```
```
	CallManagedActorPlayInfo(PI);
```
```
}
```
```
 
```

// Allows Loaders to adjust game configuration parameters

// Loaders provide info about which ini changes need to be made for the mod to work

// This allows other programs (such as Ladder) to only include the ini modifications

// which are applicable for the loaded packages

```
//
```

// (Ex: ServerActors, ServerPackages, QueryHandlerClasses, Applications)

```
final function ApplyLoaderSettings()
```
```
{
```
```
	local int 				i, Index;
```

	local array<Property>	CurrentProperties;

```
	local class Temp;
```
```
 
```

	// Checking for any loaders that have been enabled since last check

	// Otherwise, must wait 2 server restarts to apply new loader settings

	// (One to load loader and apply changes, another for changes to take effect)

```
	FindAllLoaders();
```
```
	CurrentProperties = LoadProperties();
```

	for ( i = 0; i < LoaderClasses.Length; i++)

```
	{
```
```
		if (DEBUG)
```

			log("LoaderClass"@i$":"@LoaderClasses[i].AutoLoaderClass,'ApplyLoaderSettings');

```
 
```

		if (ShouldAddLoader(LoaderClasses[i].AutoLoaderClass) || (LoaderClasses[i].AutoLoaderClass.static.CheckCurrentMutators(Level.NextURL) && LoaderClasses[i].AutoLoaderClass.static.ValidateLoader()))

			Loaders[Loaders.Length] = AddLoader(LoaderClasses[i].AutoLoaderClass);

```
 
```

		else if (LoaderNotActive(LoaderClasses[i].AutoLoaderClass))

			AddLoader(LoaderClasses[i].AutoLoaderClass).AcceptRemoval(CurrentProperties);

```
	}
```
```
 
```
```
	if (DEBUGPROPS)
```
```
	{
```

		log("*** Relevant Property Listing ***",'ApplyLoaderSettings');

		for (i = 0; i < CurrentProperties.Length;i++)

```
		{
```

			if (Class(CurrentProperties[i].Outer) != None && Temp != Class(CurrentProperties[i].Outer))

```
			{
```

				Temp = Class(CurrentProperties[i].Outer);

```
				log("",'ApplyLoaderSettings');
```

				log("Relevant properties from class"@Temp@"-",'ApplyLoaderSettings');

```
			}
```

			log("    "$currentproperties[i].name,'ApplyLoaderSettings');

```
		}
```
```
	}
```
```
 
```
```
	while (Index < Loaders.Length)
```
```
	{
```
```
		if (DEBUG)
```

			log("Loader"@Index$":"@Loaders[Index],'ApplyLoaderSettings');

```
 
```
```
		if (Loaders[Index].ApplyUpdate())
```

			Loaders[Index].UpdateConfiguration(CurrentProperties);

```
 
```

		else if (!Loaders[Index].AcceptRemoval(CurrentProperties))

			log(RemovalCancelled@Loaders[Index],'ConfigManager');

```
 
```
```
		Index++;
```
```
	}
```
```
 
```
```
	Disable('Tick');
```
```
	if (DEBUG)
```
```
	{
```
```
		log("",'ApplyLoaderSettings');
```

		log("END OF GAME SERVERACTORS",'ApplyLoaderSettings');

		for (i = 0; i < GE.ServerActors.Length; i++)

			log("ServerActor["$i$"]:"$GE.ServerActors[i],'ApplyLoaderSettings');

```
 
```

		log("END OF GAME SERVERPACKAGES",'ApplyLoaderSettings');

		for (i = 0; i < GE.ServerPackages.Length; i++)

			log("ServerPackages["$i$"]:"$GE.ServerPackages[i],'ApplyLoaderSettings');

```
 
```
```
		log("",'ApplyLoaderSettings');
```
```
	}
```
```
}
```
```
 
```

function bool NotInPlayInfo(PlayInfo PI, class<Info> NewInfo)

```
{
```
```
	local int i;
```
```
	if (PI == None)
```
```
	{
```
```
		Warn(InvalidPI);
```
```
		return false;
```
```
	}
```
```
 
```
```
	for (i=0;i<PI.InfoClasses.Length;i++)
```
```
	{
```
```
		if (PI.InfoClasses[i] == NewInfo)
```
```
			return false;
```
```
	}
```
```
 
```
```
	return true;
```
```
}
```
```
 
```

function array<string> GetAllManagedActors()

```
{
```
```
	local int i;
```
```
	local array<string> Arr;
```
```
 
```

	for (i = 0; i < LoaderClasses.Length; i++)

		Arr = AddS(Arr,LoaderClasses[i].AutoLoaderClass.static.GetManagedActors());

```
 
```
```
	return Arr;
```
```
}
```
```
 
```

static final function float GetConfigMasterVersion()

```
{
```
```
	return VERSION;
```
```
}
```
```
 
```

// following function copied from wUtils (El_Muerte[TDS])

static final function array<string> AddS(array<string> A, array<string> B)

```
{
```
```
  local int i;
```
```
  for (i = 0; i < B.length; i++)
```
```
  {
```
```
    A.length = A.length+1;
```
```
    A[A.length-1] = B[i];
```
```
  }
```
```
  return A;
```
```
}
```

Legacy:ConfigMaster

Navigation menu

Views

Personal tools

Navigation

Search

Tools