| Home Page | Recent Changes | Preferences

# ProfileConfigSet

UT2003 :: Object >> ProfileConfigSet (Ladder1.46)

    00001  //-----------------------------------------------------------
    00002  // Ladder.ProfileConfigSet
    00003  // Loosely (very loosely) based on GameConfigSet
    00004  //
    00005  // ProfileConfigSet is, in essence, a primitive database program which
    00006  // stores and retrieves not only numerous different "GameConfigSet"
    00007  // profiles, but map, mutator, serveractor and accesscontrol information as well.
    00008  //-----------------------------------------------------------
    00009  class ProfileConfigSet extends Object
    00010      Config(System)
    00011      PerObjectConfig;
    00012
    00013  const LOGNAME = 'ProfileConfigSet';
    00014
    00015  // Variables that are used globally
    00016  var LevelInfo                           Level;          // Need access to Level object
    00017  var protected string                    AllMapsPrefix;  // Which map prefix is currently loaded
    00018  var protected array< class<GameInfo> >  AllGameTypes;   // All valid gametypes
    00019  var protected config string             DefaultGameType;// The gametype for this profile
    00020  var protected class<AccessControl>      ACClass;        // The access control class
    00021  var protected GameConfigSet             RealConfigSet;  // Actual gameconfigset used by the game
    00022
    00023  var protected class<GameInfo>           GameClass;      // Which game class is used by this profile
    00024  var protected PlayInfo                  PInfo;          // PlayInfo for currently active GameType, AccessControl Class, and Active Mutators
    00025  var protected MapList                   Maps;           // Maps currently in rotation
    00026
    00027  // Regarding ServerActors
    00028  struct ProfileSA {
    00029                          var string      ActorClass;
    00030                          var bool        bRequired; };
    00031  var config array<ProfileSA>             AllServerActors;
    00032  var config array<string>                ProfileServerActors;
    00033  var protected array<string>             GameServerActors;
    00034  var protected StringArray               ActiveServerActors;
    00035
    00036  // Regarding Maps
    00037  struct ProfileMap {
    00038                          var string      MapName;
    00039                          var int         MapListOrder;
    00040                          var bool        bRequired; };
    00041  var config int                          MaxMaps;                // Maximum maps allowed in maplist
    00042  var protected array<string>             GameMaps;               // List of all maps for this gametype that exist on server
    00043  var protected config array<ProfileMap>  AllMaps;                // List of all maps that could be used by this profile
    00044  var protected config array<string>      ProfileMaps;            // List of all maps that are included in the maplist for this profile
    00045  var protected StringArray               ActiveMaps;             // StringArray of ProfileMaps
    00046
    00047  // Regarding Mutators
    00048  struct ProfileMutator {
    00049                          var string          MutatorName;
    00050                          var bool            bRequired; };
    00051  var string                                  NextMutators;           // What mutators were set during this session
    00052  var protected array<xUtil.MutatorRecord>    GameMutators;           // List of all mutators that exist on server
    00053  var protected config array<ProfileMutator>  AllMutators;            // List of all mutators that could be used this profile
    00054  var protected config array<string>          ProfileMutators;        // Mutators that will be loaded by this profile
    00055  var protected StringArray                   ActiveMutators;         // StringArray of ProfileMutators
    00056
    00057  // Regarding PlayInfo
    00058  var protected config string                 AccessClass;
    00059  struct ProfileSetting { var string          SettingName;
    00060                          var string          SettingValue; };
    00061  var protected config array<ProfileSetting>  ProfileSettings;    // Stored Profile Settings which include non-active mutators PlayInfo
    00062  var protected array<ProfileSetting>         ActiveSettings;     // Representation of stored profile settings including only active mutators
    00063
    00064  // Whether we are currently editing something
    00065  var protected bool                          bEdit;
    00066
    00067  // Localized strings
    00068  var localized string    ErrorNoGameType;
    00069  var localized string    SavingToFile;
    00070  var localized string    DidNotStartEdit;
    00071
    00072  function Init(LevelInfo Lv, optional string GameType, optional string AC)
    00073  {
    00074      if (Lv==None)
    00075          return;
    00076
    00077      Level = Lv;
    00078      if (GameType!="") DefaultGameType = GameType;
    00079      if (AC != "") AccessClass = AC;
    00080      else AccessClass = Level.Game.AccessControlClass;
    00081      AllMapsPrefix = FindGameType(DefaultGameType).default.MapPrefix;
    00082
    00083      // Make sure that none of the configured mutators have been removed from this server
    00084      ValidateProfile();
    00085  }
    00086
    00087  function Cleanup()
    00088  {
    00089      // Destroy any references to actors
    00090      if (Level != None)
    00091          Level=None;
    00092
    00093      if (ActiveMaps != None)
    00094          ActiveMaps = None;
    00095
    00096      if (Maps != None)
    00097          Maps = None;
    00098  }
    00099
    00100  function ValidateProfile()
    00101  {
    00102      ValidateAllMutators();
    00103      ValidateAllMaps();
    00104      ValidateAllServerActors();
    00105  }
    00106
    00107  function ValidateAllMutators()
    00108  {
    00109      local class<Mutator>    TempMutClass;
    00110      local int i;
    00111
    00112      for (i = 0;i < AllMutators.Length; i++)
    00113      {
    00114          TempMutClass = class<Mutator>(DynamicLoadObject(AllMutators[i].MutatorName, Class'class'));
    00115          if (TempMutClass == None)
    00116          {
    00117              log("Mutator class '"$AllMutators[i].MutatorName$"' has been removed from this server.  Removing mutator from current profile.",LOGNAME);
    00118              AllMutators.Remove(i--,1);
    00119              SaveConfig();
    00120          }
    00121      }
    00122  }
    00123
    00124  function ValidateAllMaps()
    00125  {
    00126      local int i, j;
    00127
    00128      LoadAllMaps();
    00129      for (i = 0;i < AllMaps.Length;i++)
    00130      {
    00131          for (j = 0;j < GameMaps.Length;j++)
    00132              if (GameMaps[j] ~= AllMaps[i].MapName)
    00133                  break;
    00134
    00135          if (j == GameMaps.Length)
    00136          {
    00137              log("Map '"$AllMaps[i].MapName$"' has been removed from this server. Removing map from profile.",LOGNAME);
    00138              AllMaps.Remove(i--,1);
    00139              SaveConfig();
    00140          }
    00141      }
    00142  }
    00143
    00144  function ValidateAllServerActors()
    00145  {
    00146      local int i;
    00147      local class<Info> TempSA;
    00148
    00149      for (i=0;i<AllServerActors.Length;i++)
    00150      {
    00151          TempSA = class<Info>(DynamicLoadObject(AllServerActors[i].ActorClass,Class'Class'));
    00152          if (TempSA == None)
    00153          {
    00154              log("ServerActor '"$AllServerActors[i].ActorClass$"' does not exist on this server.  Removing ServerActor from profile.",LOGNAME);
    00155              AllServerActors.Remove(i--,1);
    00156              SaveConfig();
    00157          }
    00158      }
    00159  }
    00160
    00161  function bool StartEdit()
    00162  {
    00163      if (Level == None || bEdit)
    00164          return false;
    00165
    00166      bEdit = true;
    00167
    00168      if (PInfo == None)
    00169          PInfo = New(None) class'PlayInfo';
    00170
    00171      if (AllGameTypes.Length == 0)
    00172          LoadGameTypes();
    00173      GameClass = FindGameType(DefaultGameType);
    00174      if (GameClass == None)
    00175      {
    00176          log(ErrorNoGameType$DefaultGameType);
    00177          return false;
    00178      }
    00179
    00180      if (AccessClass != "")
    00181          ACClass = class<AccessControl>(DynamicLoadObject(AccessClass, class'class'));
    00182
    00183      if (Level != None && Level.Game != None && Level.Game.AccessControl != None && AccessControlIni(Level.Game.AccessControl) != None && AccessControlIni(Level.Game.AccessControl).ConfigSet != None)
    00184          RealConfigSet = AccessControlIni(Level.Game.AccessControl).ConfigSet;
    00185
    00186      if (ActiveMutators == None)
    00187          ActiveMutators = new(None) class'SortedStringArray';
    00188      if (ActiveMaps == None)
    00189          ActiveMaps = new(None) class'StringArray';
    00190      if (ActiveServerActors == None)
    00191          ActiveServerActors = new(None) class'SortedStringArray';
    00192
    00193      NextMutators = "";
    00194      LoadAllMaps();
    00195
    00196      if (GameMutators.Length == 0)
    00197          LoadAllMutators();
    00198      LoadAllServerActors();
    00199
    00200      SetUsedMaps();
    00201      SetUsedMutators();
    00202      SetUsedServerActors();
    00203
    00204      // Load Game Setting
    00205      LoadSettings(GameClass);
    00206      AllMapsPrefix = GameClass.default.MapPrefix;
    00207      return true;
    00208  }
    00209
    00210  function bool EndEdit(bool bSave, optional bool bQuiet)
    00211  {
    00212      if (Level == None || !bEdit)
    00213          return false;
    00214
    00215      // Save all data where it belongs
    00216      if (bSave)
    00217      {
    00218          if (!bQuiet) Log(Name@SavingToFile);
    00219
    00220          SaveUsedMaps();
    00221          SaveUsedMutators();
    00222          SaveUsedServerActors();
    00223          SaveConfig();
    00224      }
    00225
    00226      bEdit = false;
    00227      return true;
    00228  }
    00229
    00230  function ReplaceWith(ProfileConfigSet SourcePCS)
    00231  {
    00232      local int i;
    00233
    00234      if (!bEdit)
    00235      {
    00236          log("ReplaceWith()"@DidNotStartEdit);
    00237          return;
    00238      }
    00239
    00240      if (SourcePCS.GetGameClass() != None)
    00241      {
    00242          Wipe();
    00243          DefaultGameType = string(SourcePCS.GetGameClass());
    00244          GameClass = FindGameType(DefaultGameType);
    00245          AccessClass = SourcePCS.GetAccessControl();
    00246          ACClass = SourcePCS.GetAccessClass();
    00247          AllMapsPrefix = GameClass.default.MapPrefix;
    00248          MaxMaps = SourcePCS.MaxMaps;
    00249
    00250          AllMaps = SourcePCS.GetProfileMaps();
    00251          AllMutators = SourcePCS.GetProfileMutators();
    00252          AllServerActors = SourcePCS.GetProfileServerActors();
    00253          ProfileMaps = SourcePCS.GetUsedMaps();
    00254          ProfileMutators = SourcePCS.GetUsedMutators();
    00255          ProfileServerActors = SourcePCS.GetUsedServerActors();
    00256          ProfileSettings.Length = SourcePCS.Count();
    00257          for (i = 0; i < SourcePCS.Count(); i++)
    00258              SetProfileParam(i, SourcePCS.GetProfileParamName(i), SourcePCS.GetProfileParam(i));
    00259
    00260          LoadSettings(GameClass);
    00261      }
    00262  }
    00263
    00264  function bool CanEdit()
    00265  {
    00266      return !bEdit;
    00267  }
    00268
    00269  // This profile was deleted, but PerObjectConfig config values cannot be completely removed from .ini (that I know of)
    00270  // We can, however, make the ini entry for this object as small as possible until it is reused.
    00271  final function Wipe()
    00272  {
    00273  //log("Wiping Profile"@Name);
    00274      ActiveMaps.Reset();
    00275      ActiveMutators.Reset();
    00276
    00277      MaxMaps = 0;
    00278
    00279      ProfileMaps.Length = 0;
    00280      AllMaps.Length = 0;
    00281      ProfileMutators.Length = 0;
    00282      AllMutators.Length = 0;
    00283      ProfileServerActors.Length = 0;
    00284      AllServerActors.Length = 0;
    00285      ProfileSettings.Length = 0;
    00286      ActiveSettings.Length = 0;
    00287
    00288      DefaultGameType = "";
    00289      AccessClass = "";
    00290      AllMapsPrefix = "";
    00291      NextMutators = "";
    00292
    00293      GameClass = None;
    00294      ACClass = None;
    00295      Maps = None;
    00296
    00297  }
    00298
    00299  ///////////////////////////////////////////////////////////////////
    00300  // Public GameType Information
    00301  ///////////////////////////////////////////////////////////////////
    00302
    00303  function bool SetGameType(optional string NewGameType)
    00304  {
    00305      local string OldGameType;
    00306
    00307      if (!bEdit)
    00308      {
    00309          log("SetGameType()"@DidNotStartEdit);
    00310          return false;
    00311      }
    00312
    00313      OldGameType = DefaultGameType;
    00314      if (NewGameType=="")
    00315          NewGameType=DefaultGameType;
    00316      else DefaultGameType = NewGameType;
    00317
    00318      if (AllGameTypes.Length==0)
    00319          LoadGameTypes();
    00320
    00321      GameClass = FindGameType(NewGameType);
    00322
    00323      if (GameClass != None && (NewGameType != OldGameType))
    00324      {
    00325          AllMapsPrefix = GameClass.default.MapPrefix;
    00326          ClearUsedMaps();
    00327          ClearAllMaps();
    00328          ClearProfile(ProfileSettings);
    00329          LoadSettings(GameClass);
    00330          return true;
    00331      }
    00332      return false;
    00333  }
    00334
    00335  function class<GameInfo> GetGameClass()
    00336  {
    00337      if (GameClass != None)
    00338          return GameClass;
    00339
    00340      return None;
    00341  }
    00342
    00343  function string GetGameAcronym()
    00344  {
    00345      if (GameClass != None)
    00346          return GameClass.default.Acronym;
    00347
    00348      return "";
    00349  }
    00350
    00351  function string GetAccessControl()
    00352  {
    00353      return AccessClass;
    00354  }
    00355
    00356  function class<AccessControl> GetAccessClass()
    00357  {
    00358      if (ACClass != None)
    00359          return ACClass;
    00360      return None;
    00361  }
    00362
    00363  /////////////////////////////////////////////////////////////
    00364  // Public MapList Functions
    00365  /////////////////////////////////////////////////////////////
    00366  function bool AddProfileMap(string MapMask, bool bRequired)
    00367  {
    00368      local int i;
    00369      local ProfileMap tmp;
    00370
    00371      if (!bEdit)
    00372      {
    00373          log("AddProfileMap()"@DidNotStartEdit);
    00374          return false;
    00375      }
    00376
    00377      for (i=0;i<AllMaps.Length;i++)
    00378      {
    00379          if (AllMaps[i].MapName ~= MapMask)
    00380          {
    00381              AllMaps[i].bRequired = bRequired;
    00382              return true;
    00383          }
    00384      }
    00385
    00386      for (i=0;i<GameMaps.Length;i++)
    00387      {
    00388          if (MapMask ~= GameMaps[i])
    00389          {
    00390              tmp.MapName = GameMaps[i];
    00391              tmp.bRequired = bRequired;
    00392              AllMaps[AllMaps.Length] = tmp;
    00393              return true;
    00394          }
    00395      }
    00396
    00397      return false;
    00398  }
    00399
    00400  function bool DelProfileMap(string MapName)
    00401  {
    00402      local int i;
    00403      local string Str;
    00404
    00405      if (!bEdit)
    00406      {
    00407          log("DelProfileMap()"@DidNotStartEdit);
    00408          return false;
    00409      }
    00410
    00411      for (i=0;i<AllMaps.Length;i++)
    00412      {
    00413          Str = AllMaps[i].MapName;
    00414          if (Str ~= MapName)
    00415          {
    00416              AllMaps.Remove(i, 1);
    00417              SetUsedMaps();
    00418              return true;
    00419          }
    00420      }
    00421
    00422      return false;
    00423  }
    00424
    00425  function string AddMap(string MapMask, int Order)
    00426  {
    00427      local int i, j, k;
    00428      local bool bFound;
    00429
    00430      if (!bEdit)
    00431      {
    00432          log("AddMaps()"@DidNotStartEdit);
    00433          return "";
    00434      }
    00435
    00436      k = ActiveMaps.Count();
    00437      for (i = 0; i<AllMaps.Length; i++)
    00438      {
    00439          if (AllMaps[i].MapName ~= MapMask)
    00440          {
    00441              // Found a matching map, see if its already in the Used Maps list
    00442              bFound = false;
    00443              for (j = 0; j < k; j++)
    00444              {
    00445                  if (ActiveMaps.GetTag(j) ~= AllMaps[i].MapName)
    00446                  {
    00447                      bFound = true;
    00448                      AllMaps[i].MapListOrder = Order;
    00449                      break;
    00450                  }
    00451              }
    00452
    00453              if (!bFound && ((MaxMaps == 0) || (k < MaxMaps)))
    00454              {
    00455                  AllMaps[i].MapListOrder = ActiveMaps.Count();
    00456                  ActiveMaps.Add(string(i), AllMaps[i].MapName);
    00457                  return AllMaps[i].MapName;
    00458              }
    00459          }
    00460      }
    00461      return "";
    00462  }
    00463
    00464  function string RemoveMap(string MapName)
    00465  {
    00466      local int i;
    00467      local string TempStr;
    00468      if (!bEdit)
    00469      {
    00470          log("RemoveMaps()"@DidNotStartEdit);
    00471          return "";
    00472      }
    00473
    00474      for (i=0; i<ActiveMaps.Count(); i++)
    00475      {
    00476          TempStr = ActiveMaps.GetTag(i);
    00477          if (TempStr ~= MapName)
    00478          {
    00479              ActiveMaps.Remove(i);
    00480              return TempStr;
    00481          }
    00482      }
    00483      return "";
    00484  }
    00485
    00486  function array<string> FindMaps(string MapMask)
    00487  {
    00488      local array<string> FoundMasks, FoundMaps;
    00489      local int i, j, k;
    00490      local bool bFound;
    00491
    00492      class'wUtils103.wString'.static.Split2(MapMask, " ", FoundMasks);
    00493      if (FoundMasks.Length > 0)
    00494      {
    00495          for (i = 0; i<AllMaps.Length; i++)
    00496          {
    00497              for (j = 0; j<FoundMasks.Length; j++)
    00498              {
    00499                  if (class'wUtils103.wString'.static.MaskedCompare(AllMaps[i].MapName, FoundMasks[j]))
    00500                  {
    00501                      // Found a matching map, see if its already in the Used Maps list
    00502                      bFound = false;
    00503                      for (k = 0; k<ActiveMaps.Count(); k++)
    00504                      {
    00505                          if (ActiveMaps.GetTag(k) ~= AllMaps[i].MapName)
    00506                          {
    00507                              bFound = true;
    00508                              break;
    00509                          }
    00510                      }
    00511
    00512                      if (bFound)
    00513                          FoundMaps[FoundMaps.Length] = "+"$AllMaps[i].MapName;
    00514                      else
    00515                          FoundMaps[FoundMaps.Length] = AllMaps[i].MapName;
    00516
    00517                      break;
    00518                  }
    00519              }
    00520          }
    00521      }
    00522      return FoundMaps;
    00523  }
    00524
    00525  function MapList GetMaps()
    00526  {
    00527      if (Maps==None)
    00528      {
    00529          if (GameClass==None)
    00530              GameClass=class<GameInfo>(DynamicLoadObject(DefaultGameType, class'Class'));
    00531
    00532          Maps = Level.Game.GetMapList(AllMapsPrefix);
    00533      }
    00534
    00535      return Maps;
    00536  }
    00537
    00538  function array<string> GetUsedMaps()
    00539  {
    00540      local array<string> Strings;
    00541      local int i;
    00542
    00543      if (ActiveMaps == None)
    00544          ActiveMaps = new(None) class'StringArray';
    00545
    00546      for (i = 0; i<ActiveMaps.Count(); i++)
    00547          Strings[Strings.Length] = ActiveMaps.GetTag(i);
    00548
    00549      return Strings;
    00550  }
    00551
    00552  function array<string> GetUnusedMaps()
    00553  {
    00554      local array<string> Strings;
    00555      local int i;
    00556
    00557      if (ActiveMaps == None)
    00558          ActiveMaps = new(None) class'StringArray';
    00559
    00560      Strings.Length = AllMaps.Length;
    00561      for (i = 0; i<AllMaps.Length; i++)
    00562          Strings[i] = AllMaps[i].MapName;
    00563
    00564      // Tag all used mutators
    00565      for (i = 0; i<ActiveMaps.Count(); i++)
    00566          Strings[int(ActiveMaps.GetItem(i))] = "";
    00567
    00568      for (i = 0; i<Strings.Length; i++)
    00569      {
    00570          if (Strings[i] == "")
    00571          {
    00572              Strings.Remove(i, 1);
    00573              i--;
    00574          }
    00575      }
    00576      return Strings;
    00577  }
    00578
    00579  function bool MapIsRequired(string MapName)
    00580  {
    00581      local int i;
    00582      for (i=0;i<AllMaps.Length;i++)
    00583          if (MapName ~= AllMaps[i].MapName && AllMaps[i].bRequired)
    00584              return true;
    00585      return false;
    00586  }
    00587
    00588  function array<ProfileMap> GetProfileMaps()
    00589  {
    00590      return AllMaps;
    00591  }
    00592
    00593  function int GetMaxMaps()
    00594  {
    00595      return MaxMaps;
    00596  }
    00597
    00598  /////////////////////////////////////////////////////////////////////
    00599  // Public Mutator list functions
    00600  /////////////////////////////////////////////////////////////////////
    00601
    00602  function array<ProfileMutator> GetProfileMutators()
    00603  {
    00604      return AllMutators;
    00605  }
    00606
    00607  function array<string> GetUsedMutators()
    00608  {
    00609      local array<string> Strings;
    00610      local int i;
    00611
    00612      if (ActiveMutators == None)
    00613          ActiveMutators = new(None) class'SortedStringArray';
    00614
    00615      for (i = 0; i<ActiveMutators.Count(); i++)
    00616          Strings[Strings.Length] = ActiveMutators.GetTag(i);
    00617
    00618      return Strings;
    00619  }
    00620
    00621  function array<string> GetUnusedMutators()
    00622  {
    00623      local array<string> Strings;
    00624      local int i;
    00625
    00626      if (ActiveMutators == None)
    00627          ActiveMutators = new(None) class'SortedStringArray';
    00628
    00629      Strings.Length = AllMutators.Length;
    00630      for (i = 0; i<AllMutators.Length; i++)
    00631          Strings[i] = AllMutators[i].MutatorName;
    00632
    00633      // Tag all used mutators
    00634      for (i = 0; i<ActiveMutators.Count(); i++)
    00635          Strings[int(ActiveMutators.GetItem(i))] = "";
    00636
    00637      for (i = 0; i<Strings.Length; i++)
    00638      {
    00639          if (Strings[i] == "")
    00640          {
    00641              Strings.Remove(i, 1);
    00642              i--;
    00643          }
    00644      }
    00645      return Strings;
    00646  }
    00647
    00648  function bool AddMutator(string MutatorName)
    00649  {
    00650      local int i;
    00651      local string Str;
    00652
    00653      if (!bEdit)
    00654      {
    00655          log("AddMutator()"@DidNotStartEdit);
    00656          return false;
    00657      }
    00658
    00659      if (ActiveMutators.Count() == 0)
    00660          SetUsedMutators();
    00661
    00662      // First make sure it isnt in the list
    00663      for (i = 0; i<ActiveMutators.Count(); i++)
    00664      {
    00665          Str = ActiveMutators.GetTag(i);
    00666          if (Str ~= MutatorName || Right(Str, Len(MutatorName) + 1) ~= ("."$MutatorName))
    00667              return false;
    00668      }
    00669
    00670      for (i=0;i<AllMutators.Length;i++)
    00671      {
    00672          Str = AllMutators[i].MutatorName;
    00673          if (Str ~= MutatorName || Right(Str, Len(MutatorName) + 1) ~= ("."$MutatorName))
    00674          {
    00675              ActiveMutators.Add(string(i), Str);
    00676              return true;
    00677          }
    00678      }
    00679      return false;
    00680  }
    00681
    00682  function bool DelMutator(string MutatorName)
    00683  {
    00684      local int i;
    00685      local string Str;
    00686
    00687      if (!bEdit)
    00688      {
    00689          log("DelMutator()"@DidNotStartEdit);
    00690          return false;
    00691      }
    00692
    00693      if (MutIsRequired(MutatorName))
    00694          return false;
    00695
    00696      // First make sure it is in the list
    00697      for (i = 0; i<ActiveMutators.Count(); i++)
    00698      {
    00699          Str = ActiveMutators.GetTag(i);
    00700          if (Str ~= MutatorName || Right(Str, Len(MutatorName) + 1) ~= ("."$MutatorName))
    00701          {
    00702              ActiveMutators.Remove(i);
    00703              return true;
    00704          }
    00705      }
    00706      return false;
    00707  }
    00708
    00709  // Add mutator to list of possible mutators
    00710  function bool AddProfileMutator(string MutatorName, bool bRequired)
    00711  {
    00712      local int i,j;
    00713      local string Str;
    00714      local ProfileMutator tmp;
    00715
    00716      if (!bEdit)
    00717      {
    00718          log("AddProfileMutator()"@DidNotStartEdit);
    00719          return false;
    00720      }
    00721
    00722      for (i=0;i<AllMutators.Length;i++)
    00723      {
    00724          Str = AllMutators[i].MutatorName;
    00725          if (Str ~= MutatorName || Right(Str, Len(MutatorName) + 1) ~= ("."$MutatorName))
    00726          {
    00727              AllMutators[i].bRequired = bRequired;
    00728              return false;
    00729          }
    00730      }
    00731
    00732      for (j=0;j<GameMutators.Length;j++)
    00733      {
    00734          Str = GameMutators[j].ClassName;
    00735          if (Str ~= MutatorName || Right(Str, Len(MutatorName) + 1) ~= ("."$MutatorName))
    00736          {
    00737              tmp.MutatorName = Str;
    00738              tmp.bRequired = bRequired;
    00739              AllMutators[AllMutators.Length] = tmp;
    00740              return true;
    00741          }
    00742      }
    00743
    00744      return false;
    00745  }
    00746
    00747  function bool DelProfileMutator(string MutatorName)
    00748  {
    00749      local int i;
    00750      local string Str;
    00751
    00752      if (!bEdit)
    00753      {
    00754          log("DelProfileMutator()"@DidNotStartEdit);
    00755          return false;
    00756      }
    00757
    00758      for (i=0;i<AllMutators.Length;i++)
    00759      {
    00760          Str = AllMutators[i].MutatorName;
    00761          if (Str ~= MutatorName || Right(Str, Len(MutatorName)+1) ~= ("."$MutatorName))
    00762          {
    00763              AllMutators.Remove(i, 1);
    00764              SetUsedMutators();
    00765              return true;
    00766          }
    00767      }
    00768
    00769      return false;
    00770  }
    00771
    00772  function bool MutIsRequired(string MutatorName)
    00773  {
    00774      local int i;
    00775      for (i=0;i<AllMutators.Length;i++)
    00776          if (MutatorName ~= AllMutators[i].MutatorName && AllMutators[i].bRequired)
    00777              return true;
    00778      return false;
    00779  }
    00780
    00781  //////////////////////////////////
    00782  // Public ServerActor Functions
    00783  //////////////////////////////////
    00784
    00785  function array<ProfileSA> GetProfileServerActors()
    00786  {
    00787      return AllServerActors;
    00788  }
    00789
    00790  function array<string> GetUsedServerActors()
    00791  {
    00792      local array<string> Strings;
    00793      local int i;
    00794
    00795      if (ActiveServerActors == None)
    00796          ActiveServerActors = new(None) class'SortedStringArray';
    00797
    00798      for (i = 0; i<ActiveServerActors.Count(); i++)
    00799          Strings[Strings.Length] = ActiveServerActors.GetTag(i);
    00800
    00801      return Strings;
    00802  }
    00803
    00804  function bool AddProfileServerActor(string ActorName, bool bRequired)
    00805  {
    00806      local int i;
    00807      local ProfileSA tmp;
    00808
    00809      if (!bEdit)
    00810      {
    00811          log("AddProfileServerActor()"@DidNotStartEdit);
    00812          return false;
    00813      }
    00814
    00815      for (i=0;i<AllServerActors.Length;i++)
    00816      {
    00817          if (AllServerActors[i].ActorClass ~= ActorName)
    00818          {
    00819              AllServerActors[i].bRequired = bRequired;
    00820              return false;
    00821          }
    00822      }
    00823
    00824      tmp.ActorClass = ActorName;
    00825      tmp.bRequired = bRequired;
    00826      AllServerActors[AllServerActors.Length] = tmp;
    00827      SetUsedServerActors();
    00828      return true;
    00829  }
    00830
    00831  function bool AddServerActor(string ActorName)
    00832  {
    00833      local int i;
    00834
    00835      if (!bEdit)
    00836      {
    00837          log("AddServerActor()"@DidNotStartEdit);
    00838          return false;
    00839      }
    00840
    00841      // Check for already exists
    00842      for (i=0;i<ProfileServerActors.Length;i++)
    00843      {
    00844          if (ProfileServerActors[i] ~= ActorName)
    00845              return false;
    00846      }
    00847
    00848      for (i=0;i<AllServerActors.Length;i++)
    00849      {
    00850          if (AllServerActors[i].ActorClass ~= ActorName)
    00851          {
    00852              ProfileServerActors[ProfileServerActors.Length] = ActorName;
    00853              SetUsedServerActors();
    00854              return true;
    00855          }
    00856      }
    00857      return false;
    00858  }
    00859
    00860  function bool DelProfileServerActor(string ActorName)
    00861  {
    00862      local int i;
    00863
    00864      if (!bEdit)
    00865      {
    00866          log("DelProfileServerActor()"@DidNotStartEdit);
    00867          return false;
    00868      }
    00869
    00870      for (i=0;i<AllServerActors.Length;i++)
    00871      {
    00872          if (AllServerActors[i].ActorClass ~= ActorName)
    00873          {
    00874              AllServerActors.Remove(i,1);
    00875              SetUsedServerActors();
    00876              return true;
    00877          }
    00878      }
    00879
    00880      return false;
    00881  }
    00882
    00883  function bool DelServerActor(string ActorName)
    00884  {
    00885      local int i;
    00886
    00887      if (!bEdit)
    00888      {
    00889          log("DelServerActor()"@DidNotStartEdit);
    00890          return false;
    00891      }
    00892
    00893      i = ActiveServerActors.FindTagId(ActorName);
    00894      if (i >= 0)
    00895      {
    00896          ActiveServerActors.Remove(i);
    00897          return true;
    00898      }
    00899
    00900      return false;
    00901  }
    00902
    00903  function bool ServerActorIsRequired(string ActorName)
    00904  {
    00905      local int i;
    00906      for (i=0;i<AllServerActors.Length;i++)
    00907          if (ActorName ~= AllServerActors[i].ActorClass)
    00908              return AllServerActors[i].bRequired;
    00909
    00910      return false;
    00911  }
    00912
    00913
    00914  ////////////////////////////////
    00915  // Protected Helping functions
    00916  ////////////////////////////////
    00917
    00918  // Always reload settings at StartEdit()
    00919  protected function string LoadSettings(class<GameInfo> GameClass)
    00920  {
    00921      local class<Mutator> MutClass;
    00922      local class<Info>   SAClass;
    00923      local int i,j;
    00924
    00925      if (!bEdit)
    00926      {
    00927          log("LoadSettings()"@DidNotStartEdit);
    00928          return "";
    00929      }
    00930
    00931      if (PInfo == None)
    00932          PInfo = new(None) class'PlayInfo';
    00933
    00934      PInfo.Clear();
    00935
    00936      // Unhook GameInfo.FillPlayInfo()'s hook to BaseMutator.FillPlayInfo()
    00937      // Otherwise, we end up with mutator playinfo that we may not want
    00938      GameClass.static.FillPlayInfo(PInfo);
    00939      PInfo.PopClass();
    00940
    00941      if (ACClass == None && AccessClass != "")
    00942          ACClass = class<AccessControl>(DynamicLoadObject(AccessClass,class'Class'));
    00943
    00944      if (ACClass!=None)
    00945      {
    00946          ACClass.static.FillPlayInfo(PInfo);
    00947          PInfo.PopClass();
    00948      }
    00949
    00950      if (GameClass.default.MutatorClass != "")
    00951      {
    00952          MutClass = class<Mutator>(DynamicLoadObject(GameClass.default.MutatorClass,class'Class'));
    00953          if (MutClass != None)
    00954          {
    00955              MutClass.static.FillPlayInfo(PInfo);
    00956              PInfo.PopClass();
    00957          }
    00958      }
    00959
    00960      if (ActiveMutators.Count() == 0)
    00961          SetUsedMutators();
    00962
    00963      if (ActiveServerActors.Count() == 0)
    00964          SetUsedServerActors();
    00965
    00966      for (i=0;i<ActiveMutators.Count();i++)
    00967      {
    00968          MutClass=class<Mutator>(DynamicLoadObject(AllMutators[int(ActiveMutators.GetItem(i))].MutatorName,class'class'));
    00969          if (MutClass!=None)
    00970          {
    00971              MutClass.static.FillPlayInfo(PInfo);
    00972              PInfo.PopClass();
    00973          }
    00974      }
    00975
    00976      for (i=0;i<ActiveServerActors.Count();i++)
    00977      {
    00978          j = int(ActiveServerActors.GetItem(i));
    00979          SAClass = class<Info>(DynamicLoadObject(AllServerActors[j].ActorClass,class'Class'));
    00980          if (SAClass != None)
    00981          {
    00982              SAClass.static.FillPlayInfo(PInfo);
    00983              PInfo.PopClass();
    00984          }
    00985      }
    00986
    00987      // Create active profile array
    00988      InitializeProfile(ActiveSettings);
    00989      if (ProfileSettings.Length > 0)
    00990      {
    00991          ActiveSettings.Length = ProfileSettings.Length;
    00992          // Then retrieve all stored values from saved profile
    00993          for (i=0;i<ProfileSettings.Length;i++)
    00994              ActiveSettings[i] = ProfileSettings[i];
    00995      }
    00996      else // Copy active profile to saved profile.
    00997      {
    00998          ProfileSettings.Length = ActiveSettings.Length;
    00999          for (i=0;i<ActiveSettings.Length;i++)
    01000              SetProfileParam(i,ActiveSettings[i].SettingName,ActiveSettings[i].SettingValue);
    01001      }
    01002
    01003      return string(GameClass);
    01004  }
    01005
    01006  protected function LoadGameTypes()
    01007  {
    01008      local class<GameInfo>   TempClass;
    01009      local String            NextGame;
    01010      local int               i;
    01011
    01012      // Compile a list of all gametypes.
    01013      i = 0;
    01014      NextGame = Level.GetNextInt("Engine.GameInfo", 0);
    01015      AllGameTypes.Length = 0;
    01016      while (NextGame != "")
    01017      {
    01018          TempClass = class<GameInfo>(DynamicLoadObject(NextGame, class'Class'));
    01019          if (TempClass != None)
    01020              AllGameTypes[AllGameTypes.Length] = TempClass;
    01021
    01022          NextGame = Level.GetNextInt("Engine.GameInfo", ++i);
    01023      }
    01024  }
    01025
    01026  protected function class<GameInfo> FindGameType(string GameType)
    01027  {
    01028      local class<GameInfo> TempClass;
    01029      local int i;
    01030
    01031      if (AllGameTypes.Length == 0)
    01032          LoadGameTypes();
    01033      TempClass = None;
    01034      for (i=0; i<AllGameTypes.Length; i++)
    01035      {
    01036          TempClass = AllGameTypes[i];
    01037          if (GameType ~= string(TempClass))              break;
    01038          if (GameType ~= TempClass.default.Acronym)      break;
    01039          if (GameType ~= TempClass.default.DecoTextName) break;
    01040          if (Right(string(TempClass), Len(GameType)+1) ~= ("."$GameType))            break;
    01041          if (Right(TempClass.default.DecoTextName, Len(GameType)+1) ~= ("."$GameType))   break;
    01042      }
    01043      return TempClass;
    01044  }
    01045
    01046  protected function LoadAllMaps()
    01047  {
    01048      if (GameClass==None)
    01049          GameClass = FindGameType(DefaultGameType);
    01050
    01051      if (GameClass == None)
    01052          return;
    01053
    01054      GameMaps.Length = 0;
    01055      GameClass.static.LoadMapList(GameClass.default.MapPrefix, GameMaps);
    01056  }
    01057
    01058  protected function LoadAllMutators()
    01059  {
    01060      class'xUtil'.static.GetMutatorList(GameMutators);
    01061  }
    01062
    01063  protected function LoadAllServerActors()
    01064  {
    01065      local int i;
    01066      local ConfigMaster ConfigM;
    01067
    01068      if (Level != None && Level.Game != None && Level.Game.BaseMutator != None && ConfigMaster(Level.Game.BaseMutator.NextMutator) != None)
    01069          ConfigM = ConfigMaster(Level.Game.BaseMutator.NextMutator);
    01070      else return;
    01071
    01072      for (i=0;i<ConfigM.ManagedActors.Length;i++)
    01073          GameServerActors[GameServerActors.Length] = string(ConfigM.ManagedActors[i].SAClass);
    01074  }
    01075
    01076  protected function bool MapIsValid(string MapName)
    01077  {
    01078      local string Prefix, ShortName;
    01079
    01080      Divide(MapName,"-",Prefix,ShortName);
    01081      if (Prefix ~= AllMapsPrefix)
    01082          return true;
    01083      return false;
    01084  }
    01085
    01086  protected function string GetMutatorGroup(string MutName)
    01087  {
    01088      local int i;
    01089
    01090      if (GameMutators.Length == 0)
    01091          LoadAllMutators();
    01092
    01093      for (i=0;i<GameMutators.Length;i++)
    01094          if (GameMutators[i].ClassName ~= MutName)
    01095              return GameMutators[i].GroupName;
    01096
    01097      return "";
    01098  }
    01099
    01100  protected function SetUsedMaps()
    01101  {
    01102      local int i,j;
    01103
    01104      if (!bEdit)
    01105      {
    01106          log("SetUsedMaps()"@DidNotStartEdit);
    01107          return;
    01108      }
    01109
    01110      if (AllMaps.Length == 0)
    01111          return;
    01112
    01113      ActiveMaps.Reset();
    01114
    01115      // Add required maps first, up to MaxMaps count
    01116      for (i=0;i<AllMaps.Length;i++)
    01117      {
    01118          if (MaxMaps > 0 && ActiveMaps.Count() >= MaxMaps)
    01119              break;
    01120          if (AllMaps[i].bRequired)
    01121              ActiveMaps.Add(string(i),AllMaps[i].MapName);
    01122      }
    01123
    01124      if ((((MaxMaps > 0) && (ActiveMaps.Count() < MaxMaps)) || (MaxMaps == 0))&&(ProfileMaps.Length>0))
    01125      {
    01126          for (i=0;i<ProfileMaps.Length;i++)
    01127          {
    01128              if (!MapIsValid(ProfileMaps[i]))
    01129              {
    01130                  ProfileMaps.Remove(i,1);
    01131                  i--;
    01132                  continue;
    01133              }
    01134
    01135              if (MaxMaps > 0 && ActiveMaps.Count() >= MaxMaps)
    01136                  break;
    01137              for (j=0;j<AllMaps.Length;j++)
    01138                  if ((ProfileMaps[i]~=AllMaps[j].MapName) && (ActiveMaps.FindTagId(AllMaps[j].MapName)<0))
    01139                      ActiveMaps.Add(string(j), AllMaps[j].MapName);
    01140          }
    01141      }
    01142  }
    01143
    01144  // Loads used mutators from ini into ActiveMutators StringArray
    01145  protected function SetUsedMutators()
    01146  {
    01147      local int i,j;
    01148      local string MutatorGroups, tmp;
    01149      if (!bEdit)
    01150      {
    01151          log("SetUsedMutators()"@DidNotStartEdit);
    01152          return;
    01153      }
    01154
    01155      if (AllMutators.Length == 0)
    01156          return;
    01157
    01158      ActiveMutators.Reset();
    01159      // Add required mutators first
    01160      for (i=0;i<AllMutators.Length;i++)
    01161      {
    01162          if (AllMutators[i].bRequired)
    01163          {
    01164              tmp = GetMutatorGroup(AllMutators[i].MutatorName);
    01165              if (InStr(MutatorGroups, tmp) == -1)
    01166              {
    01167                  if (MutatorGroups != "") MutatorGroups = MutatorGroups $ ",";
    01168                  MutatorGroups = MutatorGroups $ tmp;
    01169                  ActiveMutators.Add(string(i), AllMutators[i].MutatorName);
    01170              }
    01171          }
    01172      }
    01173
    01174      for (i=0;i<ProfileMutators.Length;i++)
    01175      {
    01176          for (j=0;j<AllMutators.Length;j++)
    01177          {
    01178              if ((AllMutators[j].MutatorName ~= ProfileMutators[i])&&(ActiveMutators.FindTagId(AllMutators[j].MutatorName)<0))
    01179              {
    01180                  tmp = GetMutatorGroup(AllMutators[j].MutatorName);
    01181                  if (InStr(MutatorGroups, tmp) == -1)
    01182                  {
    01183                      if (MutatorGroups != "") MutatorGroups = MutatorGroups $ ",";
    01184                      MutatorGroups = MutatorGroups $ tmp;
    01185                      ActiveMutators.Add(string(j), AllMutators[j].MutatorName);
    01186                  }
    01187              }
    01188          }
    01189      }
    01190  }
    01191
    01192  protected function SetUsedServerActors()
    01193  {
    01194      local int i,j;
    01195      if (!bEdit)
    01196      {
    01197          log("SetUsedServerActors()"@DidNotStartEdit);
    01198          return;
    01199      }
    01200
    01201      if (AllServerActors.Length == 0)
    01202          return;
    01203
    01204      ActiveServerActors.Reset();
    01205      // Add required server actors first
    01206      for (i=0;i<AllServerActors.Length;i++)
    01207          if (AllServerActors[i].bRequired)
    01208              ActiveServerActors.Add(string(i), AllServerActors[i].ActorClass,True);
    01209
    01210      for (i=0;i<ProfileServerActors.Length;i++)
    01211          for (j=0;j<AllServerActors.Length;j++)
    01212              if (AllServerActors[j].ActorClass ~= ProfileServerActors[i])
    01213                  ActiveServerActors.Add(string(j),AllServerActors[j].ActorClass,True);
    01214  }
    01215
    01216  protected function ClearUsedMaps()
    01217  {
    01218      ProfileMaps.Length = 0;
    01219      SaveConfig();
    01220  }
    01221
    01222  protected function ClearUsedMutators()
    01223  {
    01224      ProfileMutators.Length = 0;
    01225      SaveConfig();
    01226  }
    01227
    01228  protected function ClearUsedServerActors()
    01229  {
    01230      ProfileServerActors.Length = 0;
    01231      SaveConfig();
    01232  }
    01233
    01234  protected function ClearAllMaps()
    01235  {
    01236      AllMaps.Length=0;
    01237      SaveConfig();
    01238  }
    01239
    01240  protected function ClearAllMutators()
    01241  {
    01242      AllMutators.Length = 0;
    01243      SaveConfig();
    01244  }
    01245
    01246  protected function ClearAllServerActors()
    01247  {
    01248      AllServerActors.Length = 0;
    01249      SaveConfig();
    01250  }
    01251
    01252  // Saves active maps for this profile to ini
    01253  protected function SaveUsedMaps()
    01254  {
    01255      local int i;
    01256      if (!bEdit)
    01257      {
    01258          log("SaveUsedMaps()"@DidNotStartEdit);
    01259          return;
    01260      }
    01261
    01262      ClearUsedMaps();
    01263      for (i=0;i<ActiveMaps.Count();i++)
    01264          ProfileMaps[ProfileMaps.Length] = ActiveMaps.GetTag(i);
    01265  }
    01266
    01267  // Saves ActiveMutators to ini
    01268  protected function SaveUsedMutators()
    01269  {
    01270      local int i;
    01271
    01272      if (!bEdit)
    01273      {
    01274          log("SaveUsedMutators()"@DidNotStartEdit);
    01275          return;
    01276      }
    01277
    01278      ClearUsedMutators();
    01279      for (i=0;i<ActiveMutators.Count();i++)
    01280          ProfileMutators[ProfileMutators.Length] = ActiveMutators.GetTag(i);
    01281  }
    01282
    01283  protected function SaveUsedServerActors()
    01284  {
    01285      local int i;
    01286
    01287      if (!bEdit)
    01288      {
    01289          log("SaveUsedServerActors()"@DidNotStartEdit);
    01290          return;
    01291      }
    01292      ClearUsedServerActors();
    01293      for (i=0;i<ActiveServerActors.Count();i++)
    01294          ProfileServerActors[ProfileServerActors.Length] = ActiveServerActors.GetTag(i);
    01295  }
    01296
    01297  // Applies the active maps to the actual Game maplist
    01298  protected function ApplyMapList(array<string> NewMapList)
    01299  {
    01300      local int i;
    01301
    01302      if (GameClass == None)
    01303          GameClass = class<GameInfo>(DynamicLoadObject(DefaultGameType,class'Class'));
    01304
    01305      if (Maps == None)
    01306          GetMaps();
    01307
    01308      if (Maps == None)
    01309          return;
    01310
    01311      Maps.Maps.Length = 0;
    01312      for (i=0;i<NewMapList.Length;i++)
    01313          Maps.Maps[i] = NewMapList[i];
    01314
    01315      Maps.SaveConfig();
    01316  }
    01317
    01318  // Applies ActiveMutators to actual Game mutator list
    01319  protected function ApplyMutators()
    01320  {
    01321      local int i;
    01322      local array<string> TempMut;
    01323
    01324      if (!bEdit)
    01325      {
    01326          log("ApplyMutators()"@DidNotStartEdit);
    01327          return;
    01328      }
    01329
    01330      for (i=0;i<ActiveMutators.Count();i++)
    01331          TempMut[TempMut.Length] = ActiveMutators.GetTag(i);
    01332
    01333      if (TempMut.Length == 0)
    01334          NextMutators = "";
    01335
    01336      else NextMutators = class'wUtils103.wArray'.static.Join(TempMut,",");
    01337  }
    01338
    01339  protected function ClearProfile(out array<ProfileSetting> OldProfile)
    01340  {
    01341      if (!bEdit)
    01342      {
    01343          log("ClearProfile()"@DidNotStartEdit);
    01344          return;
    01345      }
    01346
    01347      OldProfile.Length = 0;
    01348  }
    01349
    01350  protected function bool InitializeProfile(out array<ProfileSetting> NewProfile)
    01351  {
    01352      local int i;
    01353      local ProfileSetting NewSetting;
    01354
    01355      if (!bEdit)
    01356      {
    01357          log("InitializeProfile()"@DidNotStartEdit);
    01358          return false;
    01359      }
    01360
    01361      if (PInfo==None)
    01362          return false;
    01363
    01364      if (NewProfile.Length>0)
    01365          ClearProfile(NewProfile);
    01366
    01367      for (i = 0; i < PInfo.Settings.Length; i++)
    01368      {
    01369          if (InStr(PInfo.Settings[i].SettingName,"AdminName") != -1 || InStr(PInfo.Settings[i].SettingName,"AdminEmail") != -1)
    01370              continue;
    01371
    01372          NewSetting.SettingName = PInfo.Settings[i].SettingName;
    01373          NewSetting.SettingValue = PInfo.Settings[i].Value;
    01374
    01375          NewProfile[NewProfile.Length] = NewSetting;
    01376      }
    01377
    01378      return true;
    01379  }
    01380
    01381  ////////////////////////////////////////////////////////////////////////////
    01382  // PlayInfo Query Functions
    01383  ////////////////////////////////////////////////////////////////////////////
    01384
    01385  function string GetParamName(int idx)
    01386  {
    01387      if (idx < 0 || idx >= PInfo.Settings.Length)
    01388          return "";
    01389
    01390      return PInfo.Settings[idx].SettingName;
    01391  }
    01392
    01393  function int GetParamIndex(string SettingName)
    01394  {
    01395      local int i;
    01396
    01397      for (i = 0; i < PInfo.Settings.Length; i++)
    01398          if (PInfo.Settings[i].SettingName ~= SettingName)
    01399              break;
    01400
    01401      if (i==PInfo.Settings.Length)
    01402          return -1;
    01403
    01404      return i;
    01405  }
    01406
    01407  function string GetParam(int idx)
    01408  {
    01409      if (idx < 0 || idx >= PInfo.Settings.Length)
    01410          return "";
    01411
    01412      return PInfo.Settings[idx].Value;
    01413  }
    01414
    01415  function string GetNamedParam(string Parameter)
    01416  {
    01417      local int i;
    01418      local string SettingName;
    01419
    01420      for (i = 0; i < PInfo.Settings.Length; i++)
    01421      {
    01422          SettingName = PInfo.Settings[i].SettingName;
    01423          if (SettingName ~= Parameter || Right(SettingName, Len(Parameter) + 1) ~= ("."$Parameter))
    01424              return PInfo.Settings[i].Value;
    01425      }
    01426      return "";
    01427  }
    01428
    01429  function array<string> GetMaskedParams(string ParamMask)
    01430  {
    01431      local array<string> FoundParams;
    01432      local array<string> FoundMasks;
    01433      local string SettingName, ShortName;
    01434      local int i, j, p;
    01435
    01436      class'wUtils103.wString'.static.Split2(ParamMask, " ", FoundMasks);
    01437      if (FoundMasks.Length > 0)
    01438      {
    01439          for (i = 0; i<PInfo.Settings.Length; i++)
    01440          {
    01441              SettingName = PInfo.Settings[i].SettingName;
    01442
    01443              ShortName = SettingName;
    01444              j = Instr(ShortName, ".");
    01445              while (j != -1)
    01446              {
    01447                  ShortName = Mid(ShortName, p+1);
    01448                  j = Instr(ShortName, ".");
    01449              }
    01450
    01451              for (j = 0; j<FoundMasks.Length; j++)
    01452              {
    01453                  if (class'wUtils103.wString'.static.MaskedCompare(ShortName, FoundMasks[j]) || class'wUtils103.wString'.static.MaskedCompare(SettingName, FoundMasks[j]))
    01454                  {
    01455                      FoundParams[FoundParams.Length] = SettingName;
    01456                      FoundParams[FoundParams.Length] = PInfo.Settings[i].Value;
    01457                      break;
    01458                  }
    01459              }
    01460          }
    01461      }
    01462      return FoundParams;
    01463  }
    01464
    01465  /////////////////////////////////////////////////////////////////////
    01466  // Profile Query Functions
    01467  ////////////////////////////////////////////////////////////////////
    01468
    01469  function int GetProfileParamIndex(string SettingName)
    01470  {
    01471      local int i;
    01472
    01473      for (i=0;i<ProfileSettings.Length;i++)
    01474          if (ProfileSettings[i].SettingName ~= SettingName)
    01475              break;
    01476
    01477      if (i==ProfileSettings.Length)
    01478          return -1;
    01479
    01480      return i;
    01481  }
    01482
    01483  function string GetProfileParamName(int idx)
    01484  {
    01485      if (idx < 0 || idx >= ProfileSettings.Length)
    01486          return "";
    01487
    01488      return ProfileSettings[idx].SettingName;
    01489  }
    01490
    01491  function string GetProfileParam(int idx)
    01492  {
    01493      if (idx < 0 || idx >= ProfileSettings.Length)
    01494          return "";
    01495
    01496      return ProfileSettings[idx].SettingValue;
    01497  }
    01498
    01499  function string GetProfileNamedParam(string Parameter)
    01500  {
    01501      local int i;
    01502      local string SettingName;
    01503
    01504      for (i = 0; i < ProfileSettings.Length; i++)
    01505      {
    01506          SettingName = ProfileSettings[i].SettingName;
    01507          if (SettingName ~= Parameter || Right(SettingName, Len(Parameter)+1) ~= ("."$Parameter))
    01508              return ProfileSettings[i].SettingValue;
    01509      }
    01510
    01511      return "";
    01512  }
    01513
    01514  /////////////////////////////////////////////////////////////////////
    01515  // PlayInfo Manipulation Functions
    01516  /////////////////////////////////////////////////////////////////////
    01517
    01518  function SavePI()
    01519  {
    01520      if (!bEdit)
    01521      {
    01522          log("SavePI()"@DidNotStartEdit);
    01523          return;
    01524      }
    01525
    01526      if (PInfo == None)
    01527          return;
    01528
    01529      PInfo.SaveSettings();
    01530  }
    01531
    01532  function bool SetParam(int idx, string Value)
    01533  {
    01534      if (PInfo == None || idx < 0 || idx >= PInfo.Settings.Length)
    01535          return false;
    01536
    01537      if (InStr(PInfo.Settings[idx].SettingName,"AdminName") != -1 || InStr(PInfo.Settings[idx].SettingName,"AdminEmail") != -1)
    01538          return false;
    01539
    01540      return PInfo.StoreSetting(idx, Value);
    01541  }
    01542
    01543  function bool SetNamedParam(string Parameter, string Value)
    01544  {
    01545      local int i;
    01546      local string SettingName;
    01547
    01548      if (PInfo == None) return false;
    01549
    01550      for (i = 0; i < PInfo.Settings.Length; i++)
    01551      {
    01552          SettingName = PInfo.Settings[i].SettingName;
    01553          if (SettingName ~= Parameter || Right(SettingName, Len(Parameter) + 1) ~= ("."$Parameter))
    01554          {
    01555              if (InStr(PInfo.Settings[i].SettingName,"AdminName") != -1 || InStr(PInfo.Settings[i].SettingName,"AdminEmail") != -1)
    01556                  return false;
    01557
    01558              return PInfo.StoreSetting(i, Value);
    01559          }
    01560      }
    01561      // Parameter not found
    01562      return false;
    01563  }
    01564
    01565  ///////////////////////////////////////////////////////////////////////////
    01566  // Profile Manipulation Functions
    01567  ///////////////////////////////////////////////////////////////////////////
    01568
    01569  function int Count()
    01570  {
    01571      return ProfileSettings.Length;
    01572  }
    01573
    01574  function bool SetProfileParam(int idx, string SettingName, coerce string SettingValue)
    01575  {
    01576      if (idx < 0 || idx > ProfileSettings.Length)
    01577          return false;
    01578
    01579      if (ProfileSettings.Length == idx)
    01580          ProfileSettings.Length = ProfileSettings.Length+1;
    01581
    01582      ProfileSettings[idx].SettingName = SettingName;
    01583      ProfileSettings[idx].SettingValue = SettingValue;
    01584
    01585      return true;
    01586  }
    01587
    01588  function bool SetProfileNamedParam(string Parameter, string Value)
    01589  {
    01590      local int i;
    01591      local string SettingName;
    01592
    01593      for (i = 0;i < ProfileSettings.Length; i++)
    01594      {
    01595          SettingName = ProfileSettings[i].SettingName;
    01596          if (SettingName ~= Parameter || Right(SettingName, Len(Parameter) + 1) ~= ("."$Parameter))
    01597          {
    01598              ProfileSettings[i].SettingValue = Value;
    01599              return true;
    01600          }
    01601      }
    01602
    01603      return false;
    01604  }

The Unreal Engine Documentation Site

Wiki Community

Topic Categories

Image Uploads

Random Page

Recent Changes

Offline Wiki

Unreal Engine

Console Commands

Terminology

Mapping Topics

Mapping Lessons

UnrealEd Interface

Questions&Answers

Scripting Topics

Scripting Lessons

Making Mods

Class Tree

Questions&Answers

Modeling Topics

Questions&Answers

Log In