public override bool IsEqual(SettingsKey o)
{
SeasonKey key = o as SeasonKey;
if (key == null) return false;
if (mSeason != key.mSeason) return false;
return base.IsEqual(o);
}
public override bool IsEqual(SettingsKey o)
{
if (o is GeneralKey)
{
return base.IsEqual(o);
}
else
{
return false;
}
}
protected void SetAdvertised(SettingsKey key, InteractionTuning tuning, Dictionary <CommodityKind, float> advertised)
{
if (Retuner.StoreDefault(key, tuning))
{
foreach (KeyValuePair <CommodityKind, float> pair in advertised)
{
foreach (CommodityChange change in tuning.mTradeoff.mOutputs)
{
if (change.Commodity == pair.Key)
{
change.mConstantChange = pair.Value;
}
}
}
}
}
public override bool IsEqual(SettingsKey o)
{
SeasonKey key = o as SeasonKey;
if (key == null)
{
return(false);
}
if (mSeason != key.mSeason)
{
return(false);
}
return(base.IsEqual(o));
}
public void Remove(SettingsKey key)
{
List <SeasonSettings> list;
if (!SeasonSettings.TryGetValue(key.Season, out list))
{
return;
}
for (int i = list.Count - 1; i >= 0; i--)
{
if (list[i].Key.IsEqual(key))
{
list.RemoveAt(i);
}
}
}
public void SetAgeSpecies(SettingsKey key, InteractionTuning tuning, List <CASAGSAvailabilityFlags> ageSpeciesList)
{
mAgeSpeciesList = null;
mFlags |= Flags.AgeSpecies;
mAgeSpecies = CASAGSAvailabilityFlags.None;
foreach (CASAGSAvailabilityFlags ageSpecies in ageSpeciesList)
{
mAgeSpecies |= ageSpecies;
}
if (Retuner.StoreDefault(key, tuning))
{
tuning.Availability.AgeSpeciesAvailabilityFlags = mAgeSpecies;
}
}
public void SetTargetAgeSpecies(SettingsKey key, ActionData data, List <CASAGSAvailabilityFlags> ageSpeciesList)
{
mTargetAgeSpeciesList = null;
mFlags |= Flags.TargetAgeSpecies;
mTargetAgeSpecies = CASAGSAvailabilityFlags.None;
foreach (CASAGSAvailabilityFlags ageSpecies in ageSpeciesList)
{
mTargetAgeSpecies |= ageSpecies;
}
if (Retuner.StoreDefault(key, data))
{
data.mTargetAgeAllowed = mTargetAgeSpecies;
}
}
public string ToXMLString(SettingsKey key)
{
string result = null;
string[] names = mName.Split('|');
result += " <ITUN>";
if (key != null)
{
result += key.ToXMLString();
}
result += Common.NewLine + " <ObjectName>" + names[0] + "</ObjectName>";
result += Common.NewLine + " <InteractionName>" + names[1] + "</InteractionName>";
if ((mFlags & Flags.Autonomous) != Flags.None)
{
result += Common.NewLine + " <Autonomous>" + mAutonomous + "</Autonomous>";
}
if ((mFlags & Flags.UserDirected) != Flags.None)
{
result += Common.NewLine + " <UserDirected>" + mUserDirected + "</UserDirected>";
}
if ((mFlags & Flags.AgeSpecies) != Flags.None)
{
result += Common.NewLine + " <AgeSpecies>" + mAgeSpecies + "</AgeSpecies>";
}
if ((mFlags & Flags.Availability) != Flags.None)
{
result += Common.NewLine + " <Availability>" + mAvailability + "</Availability>";
}
if (mAdvertisedOutputs.Count > 0)
{
result += Common.NewLine + " <Advertised>" + AdvertisedToString() + "</Advertised>";
}
result += Common.NewLine + " </ITUN>";
return(result);
}
public void SetUserDirected(SettingsKey key, InteractionTuning tuning, bool value)
{
mUserDirected = value;
mFlags |= Flags.UserDirected;
if (Retuner.StoreDefault(key, tuning))
{
if (value)
{
tuning.RemoveFlags(InteractionTuning.FlagField.DisallowUserDirected);
}
else
{
tuning.AddFlags(InteractionTuning.FlagField.DisallowUserDirected);
}
}
}
public void SetAutonomous(SettingsKey key, InteractionTuning tuning, bool value)
{
mAutonomous = value;
mFlags |= Flags.Autonomous;
if (Retuner.StoreDefault(key, tuning))
{
if (value)
{
tuning.RemoveFlags(InteractionTuning.FlagField.DisallowAutonomous);
}
else
{
tuning.AddFlags(InteractionTuning.FlagField.DisallowAutonomous);
}
}
}
public void SetAllowPregnant(SettingsKey key, ActionData data, bool value)
{
mAllowPregnant = value;
mFlags |= Flags.AllowPregnant;
if (Retuner.StoreDefault(key, data))
{
// Inverted
if (!value)
{
data.mDataBits |= ActionDataBase.ActionDataBits.DisallowedIfPregnant;
}
else
{
data.mDataBits &= ~ActionDataBase.ActionDataBits.DisallowedIfPregnant;
}
}
}
public bool Exists(SettingsKey key)
{
List <SeasonSettings> list;
if (!SeasonSettings.TryGetValue(key.Season, out list))
{
return(false);
}
foreach (SeasonSettings settings in list)
{
if (settings.Key.IsEqual(key))
{
return(true);
}
}
return(false);
}
public string ToXMLString(SettingsKey key)
{
string result = null;
result += " <Social>";
if (key != null)
{
result += key.ToXMLString();
}
result += Common.NewLine + " <Name>" + mName + "</Name>";
if ((mFlags & Flags.Autonomous) != Flags.None)
{
result += Common.NewLine + " <Autonomous>" + mAutonomous + "</Autonomous>";
}
if ((mFlags & Flags.UserDirected) != Flags.None)
{
result += Common.NewLine + " <UserDirected>" + mUserDirected + "</UserDirected>";
}
if ((mFlags & Flags.AllowPregnant) != Flags.None)
{
result += Common.NewLine + " <AllowPregnant>" + mAllowPregnant + "</AllowPregnant>";
}
if ((mFlags & Flags.ActorAgeSpecies) != Flags.None)
{
result += Common.NewLine + " <ActorAgeSpecies>" + mActorAgeSpecies + "</ActorAgeSpecies>";
}
if ((mFlags & Flags.TargetAgeSpecies) != Flags.None)
{
result += Common.NewLine + " <TargetAgeSpecies>" + mTargetAgeSpecies + "</TargetAgeSpecies>";
}
result += Common.NewLine + " </Social>";
return(result);
}
public SeasonSettings GetSettings(SettingsKey key)
{
SeasonSettings result;
if (key is CurrentKey)
{
if (sEmptySettings == null)
{
sEmptySettings = new SeasonSettings(key);
}
result = sEmptySettings;
}
else
{
List <SeasonSettings> list;
if (!SeasonSettings.TryGetValue(key.Season, out list))
{
return(null);
}
result = null;
foreach (SeasonSettings setting in list)
{
if (setting.IsEqual(key))
{
result = setting;
break;
}
}
if (result == null)
{
return(null);
}
}
result.SetKey(key);
return(result);
}
public void Import(Persistence.Lookup settings)
{
mKey = settings.GetChild <SettingsKey>("Key");
mSettings.Clear();
foreach (ITUNSettings setting in settings.GetList <ITUNSettings>("Settings"))
{
mSettings[setting.mName] = setting;
}
mTunables = settings.GetList <TunableStore>("Tunables");
mTunableLookup = null;
mActionData.Clear();
foreach (ActionDataSetting setting in settings.GetList <ActionDataSetting>("ActionData"))
{
mActionData[setting.mName] = setting;
}
Apply();
}
public override bool IsEqual(SettingsKey o)
{
return(o is CurrentKey);
}
public void SetUserDirected(SettingsKey key, InteractionTuning tuning, bool value)
{
mUserDirected = value;
mFlags |= Flags.UserDirected;
if (Retuner.StoreDefault(key, tuning))
{
if (value)
{
tuning.RemoveFlags(InteractionTuning.FlagField.DisallowUserDirected);
}
else
{
tuning.AddFlags(InteractionTuning.FlagField.DisallowUserDirected);
}
}
}
public void SetAgeSpecies(SettingsKey key, InteractionTuning tuning, List<CASAGSAvailabilityFlags> ageSpeciesList)
{
mAgeSpeciesList = null;
mFlags |= Flags.AgeSpecies;
mAgeSpecies = CASAGSAvailabilityFlags.None;
foreach (CASAGSAvailabilityFlags ageSpecies in ageSpeciesList)
{
mAgeSpecies |= ageSpecies;
}
if (Retuner.StoreDefault(key, tuning))
{
tuning.Availability.AgeSpeciesAvailabilityFlags = mAgeSpecies;
}
}
public SeasonSettings(SettingsKey key)
{
mKey = key;
}
protected void SetAvailability(SettingsKey key, InteractionTuning tuning, Availability.FlagField availability)
{
mAvailability = availability;
mFlags |= Flags.Availability;
if (Retuner.StoreDefault(key, tuning))
{
tuning.Availability.mFlags = mAvailability;
}
}
public void SetKey(SettingsKey key)
{
mKey = key;
}
public void Apply(SettingsKey key, InteractionTuning tuning)
{
if ((mFlags & Flags.Autonomous) != Flags.None)
{
SetAutonomous(key, tuning, mAutonomous);
}
if ((mFlags & Flags.UserDirected) != Flags.None)
{
SetUserDirected(key, tuning, mUserDirected);
}
// Not Persisted, so rebuild now
mAgeSpeciesList = null;
if ((mFlags & Flags.AgeSpecies) != Flags.None)
{
SetAgeSpecies(key, tuning, AgeSpecies);
}
if ((mFlags & Flags.Availability) != Flags.None)
{
SetAvailability(key, tuning, mAvailability);
}
SetAdvertised(key, tuning, mAdvertisedOutputs);
}
public static bool StoreDefault(SettingsKey key, ActionData data)
{
if (!key.IsActive) return false;
sDefaultSettings.StoreDefaultSettings(data);
return true;
}
public static bool StoreDefault(SettingsKey key, InteractionTuning tuning)
{
if (!key.IsActive) return false;
sDefaultSettings.StoreDefaultSettings(tuning);
return true;
}
public void SetUserDirected(SettingsKey key, ActionData data, bool value)
{
mUserDirected = value;
mFlags |= Flags.UserDirected;
if (Retuner.StoreDefault(key, data))
{
data.mUserDirectedOnly = value;
}
}
public string ToXMLString(SettingsKey key)
{
string result = null;
result += " <Social>";
if (key != null)
{
result += key.ToXMLString();
}
result += Common.NewLine + " <Name>" + mName + "</Name>";
if ((mFlags & Flags.Autonomous) != Flags.None)
{
result += Common.NewLine + " <Autonomous>" + mAutonomous + "</Autonomous>";
}
if ((mFlags & Flags.UserDirected) != Flags.None)
{
result += Common.NewLine + " <UserDirected>" + mUserDirected + "</UserDirected>";
}
if ((mFlags & Flags.AllowPregnant) != Flags.None)
{
result += Common.NewLine + " <AllowPregnant>" + mAllowPregnant + "</AllowPregnant>";
}
if ((mFlags & Flags.ActorAgeSpecies) != Flags.None)
{
result += Common.NewLine + " <ActorAgeSpecies>" + mActorAgeSpecies + "</ActorAgeSpecies>";
}
if ((mFlags & Flags.TargetAgeSpecies) != Flags.None)
{
result += Common.NewLine + " <TargetAgeSpecies>" + mTargetAgeSpecies + "</TargetAgeSpecies>";
}
result += Common.NewLine + " </Social>";
return result;
}
public void Apply(SettingsKey key, ActionData data)
{
if ((mFlags & Flags.Autonomous) != Flags.None)
{
SetAutonomous(key, data, mAutonomous);
}
if ((mFlags & Flags.UserDirected) != Flags.None)
{
SetUserDirected(key, data, mUserDirected);
}
if ((mFlags & Flags.AllowPregnant) != Flags.None)
{
SetAllowPregnant(key, data, mAllowPregnant);
}
if ((mFlags & Flags.ActorAgeSpecies) != Flags.None)
{
SetActorAgeSpecies(key, data, ActorAgeSpecies);
}
if ((mFlags & Flags.TargetAgeSpecies) != Flags.None)
{
SetTargetAgeSpecies(key, data, TargetAgeSpecies);
}
}
public void SetTargetAgeSpecies(SettingsKey key, ActionData data, List<CASAGSAvailabilityFlags> ageSpeciesList)
{
mTargetAgeSpeciesList = null;
mFlags |= Flags.TargetAgeSpecies;
mTargetAgeSpecies = CASAGSAvailabilityFlags.None;
foreach (CASAGSAvailabilityFlags ageSpecies in ageSpeciesList)
{
mTargetAgeSpecies |= ageSpecies;
}
if (Retuner.StoreDefault(key, data))
{
data.mTargetAgeAllowed = mTargetAgeSpecies;
}
}
public void SetAllowPregnant(SettingsKey key, ActionData data, bool value)
{
mAllowPregnant = value;
mFlags |= Flags.AllowPregnant;
if (Retuner.StoreDefault(key, data))
{
// Inverted
if (!value)
{
data.mDataBits |= ActionDataBase.ActionDataBits.DisallowedIfPregnant;
}
else
{
data.mDataBits &= ~ActionDataBase.ActionDataBits.DisallowedIfPregnant;
}
}
}
public bool IsEqual(SettingsKey key)
{
return(mKey.IsEqual(key));
}
public SeasonSettings(SettingsKey key)
{
mKey = key;
}
protected void SetAdvertised(SettingsKey key, InteractionTuning tuning, Dictionary<CommodityKind, float> advertised)
{
if (Retuner.StoreDefault(key, tuning))
{
foreach (KeyValuePair<CommodityKind, float> pair in advertised)
{
foreach (CommodityChange change in tuning.mTradeoff.mOutputs)
{
if (change.Commodity == pair.Key)
{
change.mConstantChange = pair.Value;
}
}
}
}
}
public bool IsEqual(SettingsKey key)
{
return mKey.IsEqual(key);
}
public void Import(Persistence.Lookup settings)
{
mKey = settings.GetChild<SettingsKey>("Key");
mSettings.Clear();
foreach (ITUNSettings setting in settings.GetList<ITUNSettings>("Settings"))
{
mSettings[setting.mName] = setting;
}
mTunables = settings.GetList<TunableStore>("Tunables");
mTunableLookup = null;
mActionData.Clear();
foreach (ActionDataSetting setting in settings.GetList<ActionDataSetting>("ActionData"))
{
mActionData[setting.mName] = setting;
}
Apply();
}
public bool Exists(SettingsKey key)
{
List<SeasonSettings> list;
if (!SeasonSettings.TryGetValue(key.Season, out list)) return false;
foreach (SeasonSettings settings in list)
{
if (settings.Key.IsEqual(key)) return true;
}
return false;
}
public SeasonSettings Add(SettingsKey key, bool checkExist)
{
if (checkExist)
{
if (Exists(key)) return null;
}
List<SeasonSettings> list;
if (!SeasonSettings.TryGetValue(key.Season, out list))
{
list = new List<SeasonSettings>();
SeasonSettings.Add(key.Season, list);
}
SeasonSettings settings = new SeasonSettings(key);
list.Add(settings);
return settings;
}
public void Remove(SettingsKey key)
{
List<SeasonSettings> list;
if (!SeasonSettings.TryGetValue(key.Season, out list)) return;
for (int i = list.Count - 1; i >= 0; i--)
{
if (list[i].Key.IsEqual(key))
{
list.RemoveAt(i);
}
}
}
public void SetAvailability(SettingsKey key, InteractionTuning tuning, Availability.FlagField availability, bool set)
{
if ((mFlags & Flags.Availability) == Flags.None)
{
mAvailability = tuning.Availability.mFlags;
}
mFlags |= Flags.Availability;
if (set)
{
mAvailability |= availability;
}
else
{
mAvailability &= ~availability;
}
if (Retuner.StoreDefault(key, tuning))
{
if (set)
{
tuning.Availability.AddFlags(availability);
}
else
{
tuning.Availability.RemoveFlags(availability);
}
}
}
public SeasonSettings GetSettings(SettingsKey key)
{
SeasonSettings result;
if (key is CurrentKey)
{
if (sEmptySettings == null)
{
sEmptySettings = new SeasonSettings(key);
}
result = sEmptySettings;
}
else
{
List<SeasonSettings> list;
if (!SeasonSettings.TryGetValue(key.Season, out list)) return null;
result = null;
foreach (SeasonSettings setting in list)
{
if (setting.IsEqual(key))
{
result = setting;
break;
}
}
if (result == null) return null;
}
result.SetKey(key);
return result;
}
public void SetAutonomous(SettingsKey key, InteractionTuning tuning, bool value)
{
mAutonomous = value;
mFlags |= Flags.Autonomous;
if (Retuner.StoreDefault(key, tuning))
{
if (value)
{
tuning.RemoveFlags(InteractionTuning.FlagField.DisallowAutonomous);
}
else
{
tuning.AddFlags(InteractionTuning.FlagField.DisallowAutonomous);
}
}
}
public virtual bool IsEqual(SettingsKey key)
{
if (mHours != key.mHours) return false;
return true;
}
public void SetKey(SettingsKey key)
{
mKey = key;
}
public string ToXMLString(SettingsKey key)
{
string result = null;
string[] names = mName.Split('|');
result += " <ITUN>";
if (key != null)
{
result += key.ToXMLString();
}
result += Common.NewLine + " <ObjectName>" + names[0] + "</ObjectName>";
result += Common.NewLine + " <InteractionName>" + names[1] + "</InteractionName>";
if ((mFlags & Flags.Autonomous) != Flags.None)
{
result += Common.NewLine + " <Autonomous>" + mAutonomous + "</Autonomous>";
}
if ((mFlags & Flags.UserDirected) != Flags.None)
{
result += Common.NewLine + " <UserDirected>" + mUserDirected + "</UserDirected>";
}
if ((mFlags & Flags.AgeSpecies) != Flags.None)
{
result += Common.NewLine + " <AgeSpecies>" + mAgeSpecies + "</AgeSpecies>";
}
if ((mFlags & Flags.Availability) != Flags.None)
{
result += Common.NewLine + " <Availability>" + mAvailability + "</Availability>";
}
if (mAdvertisedOutputs.Count > 0)
{
result += Common.NewLine + " <Advertised>" + AdvertisedToString() + "</Advertised>";
}
result += Common.NewLine + " </ITUN>";
return result;
}
public static bool StoreDefault(SettingsKey key, TunableStore store)
{
if (!key.IsActive) return false;
if (store == null) return false;
sDefaultSettings.AddTunable(store, false);
return true;
}
public void SetAutonomous(SettingsKey key, ActionData data, bool value)
{
mAutonomous = value;
mFlags |= Flags.Autonomous;
if (Retuner.StoreDefault(key, data))
{
data.mAutonomous = value;
}
}
public ActiveSettingsToggle(SettingsKey season)
{
sActiveSettings = Retuner.Settings.GetSettings(season);
}
public override bool IsEqual(SettingsKey o)
{
return (o is CurrentKey);
}
