XAdmin.GameConfigSet

// ====================================================================
//  Class:  XAdmin.GameConfigSet
//  Parent: XAdmin.xAdminConfigBase
//
//  This class is responsible for handling changes to a Game default
//  Behavior like Map List,Mutators and Ini Settings.
// ====================================================================

class GameConfigSet extends Object;

var LevelInfo   Level;          // Need access to Level function

var protected class<GameInfo>   GameClass;      // Which game class is being edited
var protected int               GameIndex;      // Index of GameClass
var protected PlayInfo          Settings;       // Game Setting Defaults
var int                         CurrentMapList; // Index of maplist we're editing

var protected array<int>        UsedMutators;   // List of Mutators in use
var protected array<int>        UsedMaps;       // Index of maps within active maplist

// Maintaining Global Lists
var protected string            AllMapsPrefix;  // Which map prefix is currently loaded
var protected array<string>     AllMapLists;    // List of all maplists for the specified gametype
var protected array<string>     AllMaps;        // List of all Maps for the specified gametype.
var protected array<string>     AllMutators;    // List of all available mutators
var protected array< class<GameInfo> >  AllGameTypes;

var string NextMutators;                        // What mutators were set during this session
var protected bool bEdit;                       // We are currently editing something

function bool StartEdit(optional string GameType)
{
    if (Level == None || bEdit)
        return false;

    // Load all Game Types, unless already loaded
    if (AllGameTypes.Length == 0)
        LoadGameTypes();

    // Load All Mutators (Unless already loaded)
    if (AllMutators.Length == 0)
        LoadAllMutators();

    // If no GameType Specified, use currently loaded one.
    if (GameType == "")
        GameType = String(Level.Game.Class);

    // When editing allow for many ways to find the good game class
    // Try with Acronym, Class, Alternate class, etc
    GameClass = FindGameType(GameType);

    log("GameClass is"@GameClass);

    if (GameClass == None)
        return false;

    LoadAllMaps();
    GameIndex = Level.Game.MaplistHandler.GetGameIndex(string(GameClass));
    CurrentMapList = GetActiveList();
    AllMapLists = GetLists();

    // Load Game Setting
    LoadSettings(GameClass);

    // Fill in Used Mutators
    SetUsedMutators();
    NextMutators = "";

    bEdit = true;
    return true;
}

function bool EndEdit(bool bSave)
{
local int i;

    if (Level == None || !bEdit)
        return false;

    // Save all data where it belongs
    if (bSave)
    {
//		Log("GCS.EndEdit is now Saving All the Data");
        // Commit to PlayInfo
        Settings.SaveSettings();
        NextMutators = "";
        if (UsedMutators.Length > 0)
        {
            NextMutators = AllMutators[UsedMutators[0]];
            for (i=1; i<UsedMutators.Length; i++)
                NextMutators = NextMutators$","$AllMutators[UsedMutators[i]];
        }
//		Log("CGS.NextMutators="@NextMutators);
        Level.Game.MaplistHandler.SaveGame(GameIndex);
    }

    else Level.Game.MaplistHandler.ResetGame(GameIndex);

    bEdit = false;
    return true;
}

function bool CanEdit()
{
    return !bEdit;
}

// Settings Functions
function string GetParam(int idx)
{
    if (idx < 0 || idx >= Settings.Settings.Length)
        return "";

    return Settings.Settings[idx].Value;
}

function string GetNamedParam(string Parameter)
{
local int i;
local string SettingName;

    for (i = 0; i < Settings.Settings.Length; i++)
    {
        SettingName = Settings.Settings[i].SettingName;
        if (SettingName ~= Parameter || Right(SettingName, Len(Parameter) + 1) ~= ("."$Parameter))
            return Settings.Settings[i].Value;
    }
    return "";
}

function array<string> GetMaskedParams(string ParamMask)
{
local array<string> FoundParams;
local array<string> FoundMasks;
local string SettingName, ShortName;
local int i, j, p;

    Split(ParamMask, " ", FoundMasks);
    if (FoundMasks.Length > 0)
    {
        for (i = 0; i<Settings.Settings.Length; i++)
        {
            SettingName = Settings.Settings[i].SettingName;

            ShortName = SettingName;
            j = Instr(ShortName, ".");
            while (j != -1)
            {
                ShortName = Mid(ShortName, p+1);
                j = Instr(ShortName, ".");
            }

            for (j = 0; j<FoundMasks.Length; j++)
            {
                if (MaskedCompare(ShortName, FoundMasks[j]) || MaskedCompare(SettingName, FoundMasks[j]))
                {
                    FoundParams[FoundParams.Length] = SettingName;
                    FoundParams[FoundParams.Length] = Settings.Settings[i].Value;
                    break;
                }
            }
        }
    }
    return FoundParams;
}

function bool SetParam(int idx, string Value)
{
    if (idx < 0 || idx >= Settings.Settings.Length)
        return false;

    return Settings.StoreSetting(idx, Value);
}

// Settings Commands Processing
function bool SetNamedParam(string Parameter, string Value)
{
local int i;
local string SettingName;

    for (i = 0; i < Settings.Settings.Length; i++)
    {
        SettingName = Settings.Settings[i].SettingName;
        if (SettingName ~= Parameter || Right(SettingName, Len(Parameter) + 1) ~= ("."$Parameter))
            return Settings.StoreSetting(i, Value);
    }
    // Parameter not found
    return false;
}

// MapList Functions
function array<string> GetLists()
{
    local array<string> Names;

    Names = Level.Game.MaplistHandler.GetMapListNames(GameIndex);
    return Names;
}

function int GetActiveList()
{
    return Level.Game.MaplistHandler.GetActiveList(GameIndex);
}

//function bool SetActiveList(int Index)
//{
//	if (Index < 0 || Index > AllMapLists.Length || !bEdit)
//		return false;
//
//	CurrentMapList = Index;
//	return true;
//}

function array<string> GetMaps()
{
    return Level.Game.MaplistHandler.GetMapList(GameIndex, CurrentMapList);
}

function array<string> AddMaps(string MapMask)
{
local array<string> FoundMasks, AddedMaps, CurrentMaps;
local int i, j, k;
local bool bFound;

    Split(MapMask, " ",FoundMasks);
    if (FoundMasks.Length > 0)
    {
        CurrentMaps = GetMaps();
        for (i = 0; i<AllMaps.Length; i++)
        {
            for (j = 0; j<FoundMasks.Length; j++)
            {
                if (MaskedCompare(AllMaps[i], FoundMasks[j]))
                {
                    // Found a matching map, see if its already in the Used Maps list
                    bFound = false;
                    for (k = 0; k<CurrentMaps.Length; k++)
                    {
                        if (CurrentMaps[k] == AllMaps[i])
                        {
                            bFound = true;
                            break;
                        }
                    }

                    if (!bFound)
                    {
                        Level.Game.MaplistHandler.AddMap(GameIndex, CurrentMapList, AllMaps[i]);
                        AddedMaps[AddedMaps.Length] = AllMaps[i];
                        break;
                    }
                }
            }
        }
    }
    return AddedMaps;
}

function array<string> RemoveMaps(string MapMask)
{
local array<string> FoundMasks, DelMaps, CurrentMaps;
local int i, j;

    Split(MapMask, " ", FoundMasks);
    if (FoundMasks.Length > 0)
    {
        CurrentMaps = GetMaps();
        for (i=0; i<CurrentMaps.Length; i++)
        {
            for (j=0; j<FoundMasks.Length; j++)
            {
                if (MaskedCompare(CurrentMaps[i], FoundMasks[j]))
                {
                    DelMaps[DelMaps.Length] = CurrentMaps[i];
                    Level.Game.MaplistHandler.RemoveMap(GameIndex, CurrentMapList, CurrentMaps[i]);
                    i--;
                    break;
                }
            }
        }
    }
    return DelMaps;
}

function array<string> FindMaps(string MapMask)
{
local array<string> FoundMasks, FoundMaps, CurrentMaps;
local int i, j, k;
local bool bFound;

    Split(MapMask, " ", FoundMasks);
    if (FoundMasks.Length > 0)
    {
        CurrentMaps = GetMaps();
        for (i = 0; i<AllMaps.Length; i++)
        {
            for (j = 0; j<FoundMasks.Length; j++)
            {
                if (MaskedCompare(AllMaps[i], FoundMasks[j]))
                {
                    // Found a matching map, see if its already in the Used Maps list
                    bFound = false;
                    for (k = 0; k<CurrentMaps.Length; k++)
                    {
                        if (CurrentMaps[k] ~= AllMaps[i])
                        {
//							Log("Found the map");
                            bFound = true;
                            break;
                        }
                    }

                    if (bFound)
                        FoundMaps[FoundMaps.Length] = "+"$AllMaps[i];
                    else
                        FoundMaps[FoundMaps.Length] = AllMaps[i];

                    break;
                }
            }
        }
    }
    return FoundMaps;
}

// Mutator list functions
function array<string> GetUsedMutators()
{
local array<string> Strings;
local int i;

    for (i = 0; i<UsedMutators.Length; i++)
        Strings[Strings.Length] = AllMutators[UsedMutators[i]];

    return Strings;
}

function array<string> GetUnusedMutators()
{
local array<string> Strings;
local int i;

    Strings.Length = AllMutators.Length;
    for (i = 0; i<AllMutators.Length; i++)
        Strings[i] = AllMutators[i];

    // Tag all used mutators
    for (i = 0; i<UsedMutators.Length; i++)
        Strings[UsedMutators[i]] = "";

    for (i = 0; i<Strings.Length; i++)
    {
        if (Strings[i] == "")
        {
            Strings.Remove(i, 1);
            i--;
        }
    }
    return Strings;
}

function bool AddMutator(string MutatorName)
{
local int i, j;
local string Str;

    // First make sure it isnt in the list
    for (i = 0; i<AllMutators.Length; i++)
    {
        Str = AllMutators[i];
        if (Str ~= MutatorName || Right(Str, Len(MutatorName) + 1) ~= ("."$MutatorName))
        {
            for (j=0; j<UsedMutators.Length; j++)
                if (UsedMutators[j] == i)
                    return false;

            UsedMutators[UsedMutators.Length] = i;
            return true;
        }
    }
    return false;
}

function bool DelMutator(string MutatorName)
{
local int i;
local string Str;

    // First make sure it isnt in the list
    for (i = 0; i<UsedMutators.Length; i++)
    {
        Str = AllMutators[UsedMutators[i]];
        if (Str ~= MutatorName || Right(Str, Len(MutatorName) + 1) ~= ("."$MutatorName))
        {
            UsedMutators.Remove(i, 1);
            return true;
        }
    }
    return false;
}

////////////////////////////////
// Public Information
////////////////////////////////

function string GetEditedClass()
{
    if (GameClass != None)
        return String(GameClass);

    return "";
}

function string GetGameAcronym()
{
    if (GameClass != None)
        return GameClass.default.Acronym;

    return "";
}

////////////////////////////////
// Protected Helping functions
////////////////////////////////

protected function LoadGameTypes()
{
local class<GameInfo>   TempClass;
local String            NextGame;
local int               i;

    // Compile a list of all gametypes.
    i = 0;
    NextGame = Level.GetNextInt("Engine.GameInfo", 0);
    while (NextGame != "")
    {
        TempClass = class<GameInfo>(DynamicLoadObject(NextGame, class'Class'));
        if (TempClass != None)
            AllGameTypes[AllGameTypes.Length] = TempClass;

        NextGame = Level.GetNextInt("Engine.GameInfo", ++i);
    }
}

protected function class<GameInfo> FindGameType(string GameType)
{
local class<GameInfo> TempClass;
local int i;

    TempClass = None;
    for (i=0; i<AllGameTypes.Length; i++)
    {
        TempClass = AllGameTypes[i];
        if (GameType ~= string(TempClass))              break;
        if (GameType ~= TempClass.default.Acronym)      break;
        if (GameType ~= TempClass.default.DecoTextName) break;
        if (Right(string(TempClass), Len(GameType)+1) ~= ("."$GameType))            break;
        if (Right(TempClass.default.DecoTextName, Len(GameType)+1) ~= ("."$GameType))   break;
    }
    return TempClass;
}

protected function LoadAllMutators()
{
local string NextMutator, NextDesc;
local int    Cnt;

    Level.GetNextIntDesc("Engine.Mutator", 0, NextMutator, NextDesc);

    Cnt = 0;
    AllMutators.Length = 0;
    while(NextMutator != "")
    {
        AllMutators[AllMutators.Length] = NextMutator;
        Cnt++;
        Level.GetNextIntDesc("Engine.Mutator", Cnt, NextMutator, NextDesc);
    }
}

protected function SetUsedMutators()
{
local Mutator M;
local int i;

    for (M = Level.Game.BaseMutator.NextMutator; M != None; M = M.NextMutator)
    {
        if (M.bUserAdded)
        {
            for (i=0; i<AllMutators.Length; i++)
                if (string(M.Class) ~= AllMutators[i])
                    break;

            if (i == AllMutators.Length)
            {
                // Since this mutator had no .int entry, but it was added on the command line
                // lets just add it to the list.
                AllMutators[AllMutators.Length] = string(M.Class);
                log("Unknown Mutator in use: "@String(M.Class));
            }

            UsedMutators[UsedMutators.Length] = i;
        }
    }
}

// Always reload settings at StartEdit()
protected function string LoadSettings(class<GameInfo> GameClass)
{
    if (Settings == None)
        Settings = new(None) class'PlayInfo';

    Settings.Clear();
    GameClass.static.FillPlayInfo(Settings);
    return string(GameClass);
}

// TODO: Have a "native array<string> LoadAllMapNames(string MapPrefix)" somewhere ?
protected function LoadAllMaps(optional bool bForceLoad)
{
local string MapPrefix;

    if (GameClass == None)
        return;

    MapPrefix = GameClass.Default.MapPrefix;

    if(MapPrefix != "" && (MapPrefix != AllMapsPrefix || bForceLoad))
    {
        GameClass.static.LoadMapList(MapPrefix, AllMaps);
        AllMapsPrefix = MapPrefix;
    }
}

////////////////////////////////////////////////////////////
// TODO: Find Centralized place for the following functions
////////////////////////////////////////////////////////////

// Mask can be *|*Name|Name*|*Name*|Name
protected function bool MaskedCompare(string SettingName, string Mask)
{
local bool bMaskLeft, bMaskRight;
local int MaskLen;

    if (Mask == "*" || Mask == "**")
        return true;

    MaskLen = Len(Mask);
    bMaskLeft = Left(Mask, 1) == "*";
    bMaskRight = Right(Mask, 1) == "*";

    if (bMaskLeft && bMaskRight)
        return Instr(Caps(SettingName), Mid(Caps(Mask), 1, MaskLen-2)) >= 0;

    if (bMaskLeft)
        return Left(SettingName, MaskLen -1) ~= Left(Mask, MaskLen - 1);

    if (bMaskRight)
        return Right(SettingName, MaskLen -1) ~= Right(Mask, MaskLen - 1);

    return SettingName ~= Mask;
}

defaultproperties
{
}