private static bool PrivateIsFailure(IMagicalInteraction interaction, OccultTypes testType, out bool fail, out bool epicFailure)
{
fail = false;
epicFailure = false;
if (!OccultTypeHelper.HasType(interaction.Actor, testType)) return false;
switch (testType)
{
case OccultTypes.Witch:
SpellcastingSkill spellcasting = interaction.Actor.SkillManager.GetElement(SkillNames.Spellcasting) as SpellcastingSkill;
MagicWand wand = MagicWand.GetWandToUse(interaction.Actor, spellcasting);
if (wand != null)
{
fail = RandomUtil.RandomChance(wand.SuccessChance(interaction.Actor, interaction.SpellLevel, spellcasting.SkillLevel));
if (!fail)
{
epicFailure = RandomUtil.RandomChance(wand.EpicFailChance(interaction.Actor));
}
}
break;
case OccultTypes.Fairy:
if (interaction.SpellLevel <= interaction.Actor.SkillManager.GetSkillLevel(SkillNames.FairyMagic))
{
fail = true;
}
break;
case OccultTypes.Genie:
case OccultTypes.Unicorn:
return false;
}
return fail;
}
public static void UsePoints(Sim sim, int points, OccultTypes intended)
{
SpellcastingSkill spellCasting = sim.SkillManager.GetElement(SkillNames.Spellcasting) as SpellcastingSkill;
MagicWand wand = MagicWand.GetWandToUse(sim, spellCasting);
if (intended != OccultTypes.None)
{
if (PrivateUsePoints(sim, wand, points, intended))
{
return;
}
}
foreach (OccultTypes type in sMagicOccult)
{
if (type == intended)
{
continue;
}
if (PrivateUsePoints(sim, wand, points, type))
{
return;
}
}
}
private static List <OccultTypes> GetSharedOccults(ref List <OccultTypes> abductee, ref List <OccultTypes> alien)
{
List <OccultTypes> types = new List <OccultTypes>();
List <OccultTypes> valid = OccultTypeHelper.CreateListOfMissingOccults(new List <OccultTypes>()
{
OccultTypes.Frankenstein,
OccultTypes.Mummy,
OccultTypes.Robot,
OccultTypes.Unicorn
}, false);
foreach (OccultTypes current in valid)
{
OccultTypes type = current;
if (abductee.Contains(type) && alien.Contains(type))
{
types.Add(type);
abductee.Remove(type);
alien.Remove(type);
}
}
return(types);
}
public override void Initialize()
{
try
{
if (mNewSimDescKey != ResourceKey.kInvalidResourceKey)
{
AddStep(new SetSimDescStepEx(mNewSimDescKey));
}
else if (mNewSimDesc != null)
{
AddStep(new SetSimDescStepEx(mNewSimDesc));
OccultTypes occult = OccultTypes.None;
if (mNewSimDesc.SupernaturalData != null)
{
occult = mNewSimDesc.SupernaturalData.OccultType;
}
AddStep(new CASLogic.SetOccultTypeStep(occult, mInHousehold));
}
}
catch (Exception e)
{
Common.Exception("Initialize", e);
}
}
public static List <OccultTypes> CreateList(OccultTypes types, bool onlyTransferable)
{
List <OccultTypes> results = new List <OccultTypes>();
foreach (OccultTypes type in Enum.GetValues(typeof(OccultTypes)))
{
if (type == OccultTypes.None)
{
continue;
}
if ((types & type) != type)
{
continue;
}
if (onlyTransferable)
{
if (!OccultManager.DoesOccultTransferToOffspring(type))
{
continue;
}
}
results.Add(type);
}
return(results);
}
public SpellSettings(OccultTypes validTypes, int minSkillLevel, float minMana, int offIntendedLevel)
{
mValidTypes = validTypes;
mMinSkillLevel = minSkillLevel;
mMinMana = minMana;
mOffIntendedLevel = offIntendedLevel;
}
public static bool IsFailure(IMagicalInteraction interaction, OccultTypes intended, out bool epicFailure)
{
bool fail = false;
epicFailure = false;
if (intended != OccultTypes.None)
{
if (PrivateIsFailure(interaction, intended, out fail, out epicFailure))
{
return(fail);
}
}
foreach (OccultTypes type in sMagicOccult)
{
if (type == intended)
{
continue;
}
if (PrivateIsFailure(interaction, type, out fail, out epicFailure))
{
return(fail);
}
}
return(fail);
}
public static bool HasPoints(Sim sim, OccultTypes intended, bool allowFailure)
{
if (intended != OccultTypes.None)
{
if (PrivateHasPoints(sim, intended, allowFailure))
{
return(true);
}
}
foreach (OccultTypes type in sMagicOccult)
{
if (type == intended)
{
continue;
}
if (PrivateHasPoints(sim, type, allowFailure))
{
return(true);
}
}
return(false);
}
public static bool IsFailure(IMagicalInteraction interaction, OccultTypes intended, out bool epicFailure)
{
bool fail = false;
epicFailure = false;
if (intended != OccultTypes.None)
{
if (PrivateIsFailure(interaction, intended, out fail, out epicFailure))
{
return fail;
}
}
foreach (OccultTypes type in sMagicOccult)
{
if (type == intended) continue;
if (PrivateIsFailure(interaction, type, out fail, out epicFailure))
{
return fail;
}
}
return fail;
}
protected override ManagerStory.Story PrintStory(StoryProgressionObject manager, string name, object[] parameters, string[] extended, ManagerStory.StoryLogging logging)
{
List <OccultTypes> occults = OccultTypeHelper.CreateList(Sim);
if (occults.Count == 0)
{
return(null);
}
OccultTypes occult = occults[occults.Count - 1];
switch (occult)
{
case OccultTypes.Vampire:
case OccultTypes.Werewolf:
case OccultTypes.Fairy:
case OccultTypes.Witch:
case OccultTypes.Genie:
//case OccultTypes.Mummy:
name = "Became" + occult;
break;
default:
if (!Manager.DebuggingEnabled)
{
return(null);
}
break;
}
return(base.PrintStory(manager, name, parameters, extended, logging));
}
public Item(OccultTypes occult, SimDescription.DeathType deathType, int count, string displayKey)
{
Values value = new Values(occult, deathType);
SetValue(value, value);
mCount = count;
mDisplayKey = displayKey;
}
public static bool HasType(Sim sim, OccultTypes type)
{
if (sim == null)
{
return(false);
}
return(HasType(sim.SimDescription, type));
}
private static bool PrivateUsePoints(Sim sim, MagicWand wand, int points, OccultTypes type)
{
if (!OccultTypeHelper.HasType(sim, type))
{
return(false);
}
switch (type)
{
case OccultTypes.Genie:
OccultGenie genie = sim.OccultManager.GetOccultType(OccultTypes.Genie) as OccultGenie;
if (genie != null)
{
genie.MagicPoints.UsePoints(points);
(Sims3.UI.Responder.Instance.HudModel as HudModel).FlashMagicMotiveBar();
return(true);
}
break;
case OccultTypes.Fairy:
sim.Motives.ChangeValue(CommodityKind.AuraPower, -points);
(Sims3.UI.Responder.Instance.HudModel as HudModel).FlashMagicMotiveBar();
return(true);
case OccultTypes.Witch:
if (wand != null)
{
wand.DrainMotive(sim, CommodityKind.MagicFatigue, -points);
return(true);
}
else
{
float num = (points * DefaultWand.kMotiveDrainMultiplier) * MagicWand.kMoonPhaseMotiveDrainMultiplier[World.GetLunarPhase()];
if (sim.BuffManager.HasElement(BuffNames.AnimalFamiliar))
{
num *= MagicWand.kFamiliarMotiveMultiplier;
}
sim.Motives.ChangeValue(CommodityKind.MagicFatigue, -num);
(Sims3.UI.Responder.Instance.HudModel as HudModel).FlashMagicMotiveBar();
}
break;
case OccultTypes.Unicorn:
OccultUnicorn unicorn = sim.OccultManager.GetOccultType(OccultTypes.Unicorn) as OccultUnicorn;
if (unicorn != null)
{
unicorn.MagicPoints.UsePoints(points);
(Sims3.UI.Responder.Instance.HudModel as HudModel).FlashMagicMotiveBar();
return(true);
}
break;
}
return(false);
}
public static bool Run(IMagicalInteraction ths, OccultTypes intendedType)
{
bool succeeded = true;
if (!ths.OnPreFailureCheck())
{
return(false);
}
bool epicFailure;
ths.SpellCastingSucceeded = MagicPointControl.IsFailure(ths, intendedType, out epicFailure);
if (!ths.SpellCastingSucceeded)
{
ths.SpellCastingEpiclyFailed = epicFailure;
}
ths.StandardEntry();
ths.BeginCommodityUpdates();
try
{
if (!ths.OnPostFailureCheck())
{
return(false);
}
MagicPointControl.UsePoints(ths.Actor, ths.SpellPoints, intendedType);
if (ths.SpellCastingSucceeded)
{
ths.OnSpellSuccess();
}
else if ((ths.EpicFailureAllowed()) && (ths.SpellCastingEpiclyFailed))
{
succeeded = false;
ths.OnSpellEpicFailure();
}
else
{
succeeded = false;
ths.OnSpellFailure();
}
EventTracker.SendEvent(EventTypeId.kCastSpell, ths.Actor);
}
finally
{
ths.EndCommodityUpdates(succeeded);
ths.StandardExit();
}
return(succeeded);
}
public static bool IsOccult(IMiniSimDescription sim, OccultTypes type)
{
if (sim is MiniSimDescription)
{
return(IsOccult(sim as MiniSimDescription, type));
}
else
{
return(IsOccult(sim as SimDescription, type));
}
}
public TBaseType GetValue(OccultTypes type)
{
TOption option = GetSubOption(type);
if (option == null)
{
return(default(TBaseType));
}
return(option.Value);
}
protected override bool Allow(OccultTypes value)
{
switch (value)
{
case OccultTypes.Witch:
case OccultTypes.Genie:
case OccultTypes.Fairy:
return(true);
}
return(false);
}
public TType GetValue <T, TType>(OccultTypes occult)
where T : OptionItem, IByOccultOptionItem <TType>, IGeneralOption
{
T item = GetInternalOption <T>(null);
if (item == null)
{
return(default(TType));
}
return(item.GetValue(occult));
}
public override bool Parse(XmlDbRow row, ref string error)
{
mOccult = row.GetEnum <OccultTypes>("Occult", OccultTypes.None);
if (mOccult == OccultTypes.None)
{
error = "Occult Fail: " + row.GetString("Occult");
return(false);
}
mAllowHybrid = row.GetBool("AllowHybrid");
return(base.Parse(row, ref error));
}
public static void ApplyTrait(SimDescription sim, OccultTypes type)
{
TraitNames trait = TraitFromOccult(type);
if (trait == TraitNames.Unknown)
{
return;
}
// Apply the trait using both functions, just in case the user has a tuning mod that mod the trait visible
sim.TraitManager.AddHiddenElement(trait);
sim.TraitManager.AddElement(trait);
}
public override bool Parse(XmlDbRow row, ref string error)
{
mOccult = row.GetEnum<OccultTypes>("Occult", OccultTypes.None);
if (mOccult == OccultTypes.None)
{
error = "Occult Fail: " + row.GetString("Occult");
return false;
}
mAllowHybrid = row.GetBool("AllowHybrid");
return base.Parse(row, ref error);
}
protected override bool Allow(OccultTypes value)
{
switch (value)
{
case OccultTypes.None:
case OccultTypes.Ghost:
case OccultTypes.Unicorn:
case OccultTypes.TimeTraveler:
return(false);
}
return(base.Allow(value));
}
public static bool HasType(SimDescription sim, OccultTypes type)
{
if (sim == null)
{
return(false);
}
if (sim.OccultManager == null)
{
return(false);
}
return(sim.OccultManager.HasOccultType(type));
}
protected override bool Allow(OccultTypes value)
{
/*
* switch (value)
* {
* case OccultTypes.Witch:
* case OccultTypes.Genie:
* case OccultTypes.Fairy:
* return true;
* }
*/
return(false);
}
public static string GetLocalizedName(OccultTypes type)
{
switch (type)
{
case OccultTypes.Vampire:
return(OccultManager.GetSingularOccultName(OccultTypesAll.Vampire));
case OccultTypes.Mummy:
return(OccultManager.GetSingularOccultName(OccultTypesAll.Mummy));
case OccultTypes.Frankenstein:
return(OccultManager.GetSingularOccultName(OccultTypesAll.Frankenstein));
case OccultTypes.ImaginaryFriend:
return(OccultManager.GetSingularOccultName(OccultTypesAll.ImaginaryFriend));
case OccultTypes.Unicorn:
return(OccultManager.GetSingularOccultName(OccultTypesAll.Unicorn));
case OccultTypes.Genie:
return(OccultManager.GetSingularOccultName(OccultTypesAll.Genie));
case OccultTypes.Werewolf:
return(OccultManager.GetSingularOccultName(OccultTypesAll.Werewolf));
case OccultTypes.Fairy:
return(OccultManager.GetSingularOccultName(OccultTypesAll.Fairy));
case OccultTypes.Witch:
return(OccultManager.GetSingularOccultName(OccultTypesAll.Witch));
case OccultTypes.Ghost:
return(OccultManager.GetSingularOccultName(OccultTypesAll.Ghost));
case OccultTypes.Mermaid:
return(OccultManager.GetSingularOccultName(OccultTypesAll.Mermaid));
case OccultTypes.PlantSim:
return(OccultManager.GetSingularOccultName(OccultTypesAll.PlantSim));
case OccultTypes.TimeTraveler:
return(OccultManager.GetSingularOccultName(OccultTypesAll.TimeTraveler));
case OccultTypes.Robot:
return(OccultManager.GetSingularOccultName(OccultTypesAll.Robot));
default:
return(Common.Localize("OccultTypes:None"));
}
}
public static bool Run(IMagicalInteraction ths, OccultTypes intendedType)
{
bool succeeded = true;
if (!ths.OnPreFailureCheck()) return false;
bool epicFailure;
ths.SpellCastingSucceeded = MagicPointControl.IsFailure(ths, intendedType, out epicFailure);
if (!ths.SpellCastingSucceeded)
{
ths.SpellCastingEpiclyFailed = epicFailure;
}
ths.StandardEntry();
ths.BeginCommodityUpdates();
try
{
if (!ths.OnPostFailureCheck()) return false;
MagicPointControl.UsePoints(ths.Actor, ths.SpellPoints, intendedType);
if (ths.SpellCastingSucceeded)
{
ths.OnSpellSuccess();
}
else if ((ths.EpicFailureAllowed()) && (ths.SpellCastingEpiclyFailed))
{
succeeded = false;
ths.OnSpellEpicFailure();
}
else
{
succeeded = false;
ths.OnSpellFailure();
}
EventTracker.SendEvent(EventTypeId.kCastSpell, ths.Actor);
}
finally
{
ths.EndCommodityUpdates(succeeded);
ths.StandardExit();
}
return succeeded;
}
public static TraitNames TraitFromOccult(OccultTypes occult)
{
switch (occult)
{
case OccultTypes.Vampire:
return(TraitNames.VampireHiddenTrait);
case OccultTypes.Mummy:
return(TraitNames.MummyHiddenTrait);
case OccultTypes.Frankenstein:
return(TraitNames.FrankensteinHiddenTrait);
case OccultTypes.ImaginaryFriend:
return(TraitNames.ImaginaryFriendHiddenTrait);
case OccultTypes.Unicorn:
return(TraitNames.UnicornHiddenTrait);
case OccultTypes.Genie:
return(TraitNames.GenieHiddenTrait);
case OccultTypes.Witch:
return(TraitNames.WitchHiddenTrait);
case OccultTypes.Werewolf:
return(TraitNames.LycanthropyHuman);
case OccultTypes.Fairy:
return(TraitNames.FairyHiddenTrait);
case OccultTypes.PlantSim:
return(TraitNames.PlantSim);
case OccultTypes.Mermaid:
return(TraitNames.MermaidHiddenTrait);
case OccultTypes.Robot:
return(TraitNames.RobotHiddenTrait);
case OccultTypes.TimeTraveler:
return(TraitNames.TimeTravelerHiddenTrait);
default:
return(TraitNames.Unknown);
}
}
private static float GetMagicLevel(Sim actor, OccultTypes exclude, out OccultTypes selection)
{
if (exclude != OccultTypes.Fairy)
{
Motive motive = actor.Motives.GetMotive(CommodityKind.AuraPower);
if (motive != null)
{
selection = OccultTypes.Fairy;
return(motive.UIValue);
}
}
if (exclude != OccultTypes.Witch)
{
Motive motive = actor.Motives.GetMotive(CommodityKind.MagicFatigue);
if (motive != null)
{
selection = OccultTypes.Witch;
return(-motive.UIValue);
}
}
if (exclude != OccultTypes.Genie)
{
OccultGenie genie = actor.OccultManager.GetOccultType(OccultTypes.Genie) as OccultGenie;
if (genie != null)
{
selection = OccultTypes.Genie;
return((genie.MagicPoints.mCurrentMagicPointValue * 100) / genie.MagicPoints.mMaxMagicPoints);
}
}
if (exclude != OccultTypes.Unicorn)
{
OccultUnicorn unicorn = actor.OccultManager.GetOccultType(OccultTypes.Unicorn) as OccultUnicorn;
if (unicorn != null)
{
selection = OccultTypes.Unicorn;
return((unicorn.MagicPoints.mCurrentMagicPointValue * 100) / unicorn.MagicPoints.mMaxMagicPoints);
}
}
selection = OccultTypes.None;
return(0);
}
private static float GetMagicLevel(Sim actor, OccultTypes exclude, out OccultTypes selection)
{
if (exclude != OccultTypes.Fairy)
{
Motive motive = actor.Motives.GetMotive(CommodityKind.AuraPower);
if (motive != null)
{
selection = OccultTypes.Fairy;
return motive.UIValue;
}
}
if (exclude != OccultTypes.Witch)
{
Motive motive = actor.Motives.GetMotive(CommodityKind.MagicFatigue);
if (motive != null)
{
selection = OccultTypes.Witch;
return -motive.UIValue;
}
}
if (exclude != OccultTypes.Genie)
{
OccultGenie genie = actor.OccultManager.GetOccultType(OccultTypes.Genie) as OccultGenie;
if (genie != null)
{
selection = OccultTypes.Genie;
return (genie.MagicPoints.mCurrentMagicPointValue * 100) / genie.MagicPoints.mMaxMagicPoints;
}
}
if (exclude != OccultTypes.Unicorn)
{
OccultUnicorn unicorn = actor.OccultManager.GetOccultType(OccultTypes.Unicorn) as OccultUnicorn;
if (unicorn != null)
{
selection = OccultTypes.Unicorn;
return (unicorn.MagicPoints.mCurrentMagicPointValue * 100) / unicorn.MagicPoints.mMaxMagicPoints;
}
}
selection = OccultTypes.None;
return 0;
}
public static bool IsInstalled(OccultTypes type)
{
switch (type)
{
case OccultTypes.Vampire:
return(GameUtils.IsInstalled(ProductVersion.EP3 | ProductVersion.EP7));
case OccultTypes.Mummy:
return(GameUtils.IsInstalled(ProductVersion.EP1));
case OccultTypes.Frankenstein:
return(GameUtils.IsInstalled(ProductVersion.EP2));
case OccultTypes.ImaginaryFriend:
return(GameUtils.IsInstalled(ProductVersion.EP4));
case OccultTypes.Unicorn:
return(GameUtils.IsInstalled(ProductVersion.EP5));
case OccultTypes.Genie:
return(GameUtils.IsInstalled(ProductVersion.EP6));
case OccultTypes.Werewolf:
case OccultTypes.Fairy:
case OccultTypes.Witch:
return(GameUtils.IsInstalled(ProductVersion.EP7));
case OccultTypes.PlantSim:
return(GameUtils.IsInstalled(ProductVersion.EP9));
case OccultTypes.Mermaid:
return(GameUtils.IsInstalled(ProductVersion.EP10));
case OccultTypes.TimeTraveler:
case OccultTypes.Robot:
return(GameUtils.IsInstalled(ProductVersion.EP11));
case OccultTypes.Ghost:
case OccultTypes.None:
return(true);
}
return(false);
}
public static bool Add(SimDescription sim, OccultTypes type, bool isReward, bool applyOutfit)
{
try
{
if (sim.IsPregnant)
{
return(false);
}
if (!OccultTypeHelper.IsInstalled(type))
{
return(false);
}
if (sim.OccultManager.HasOccultType(type))
{
bool found = false;
if (sim.OccultManager.mOccultList != null)
{
foreach (OccultBaseClass occult in sim.OccultManager.mOccultList)
{
if (occult.ClassOccultType == type)
{
found = true;
break;
}
}
}
if (found)
{
return(false);
}
}
return(AddOccultType(sim.OccultManager, type, applyOutfit, isReward, false, null));
}
catch (Exception e)
{
Common.Exception(sim, e);
return(false);
}
}
public static List<OccultTypes> CreateList(OccultTypes types, bool onlyTransferable)
{
List<OccultTypes> results = new List<OccultTypes>();
foreach (OccultTypes type in Enum.GetValues(typeof(OccultTypes)))
{
if (type == OccultTypes.None) continue;
if ((types & type) != type) continue;
if (onlyTransferable)
{
if (!OccultManager.DoesOccultTransferToOffspring(type)) continue;
}
results.Add(type);
}
return results;
}
public static bool IsOccult(SimDescription sim, OccultTypes type)
{
if (sim == null)
{
return(false);
}
if (sim.OccultManager == null)
{
return(false);
}
if (type == OccultTypes.None)
{
return(sim.OccultManager.HasAnyOccultType());
}
else
{
return(sim.OccultManager.HasOccultType(type));
}
}
public static void WoohooDisgraceChecks(Sim actor, Sim target)
{
if (!WasWitnessed(actor, target, JealousyLevel.High, true))
{
return;
}
if (actor.LotCurrent.IsCommunityLot)
{
DisgracefulActionEvent e = new DisgracefulActionEvent(EventTypeId.kSimCommittedDisgracefulAction, actor, DisgracefulActionType.WooHooInPublic);
e.TargetId = target.SimDescription.SimDescriptionId;
EventTracker.SendEvent(e);
e = new DisgracefulActionEvent(EventTypeId.kSimCommittedDisgracefulAction, target, DisgracefulActionType.WooHooInPublic);
e.TargetId = actor.SimDescription.SimDescriptionId;
EventTracker.SendEvent(e);
}
OccultTypes currentOccultTypes = target.SimDescription.OccultManager.CurrentOccultTypes;
OccultTypes types2 = actor.SimDescription.OccultManager.CurrentOccultTypes;
List <KamaSimtra.OccultTypesEx> actorTypes = KamaSimtra.GetOccultType(actor.SimDescription, false);
List <KamaSimtra.OccultTypesEx> targetTypes = KamaSimtra.GetOccultType(target.SimDescription, false);
if (actorTypes.Count == 0)
{
if (targetTypes.Count > 0)
{
DisgracefulActionEvent event3 = new DisgracefulActionEvent(EventTypeId.kSimCommittedDisgracefulAction, actor, DisgracefulActionType.WooHooWithOccult);
event3.TargetId = target.SimDescription.SimDescriptionId;
EventTracker.SendEvent(event3);
}
}
else if (targetTypes.Count == 0)
{
DisgracefulActionEvent event4 = new DisgracefulActionEvent(EventTypeId.kSimCommittedDisgracefulAction, target, DisgracefulActionType.WooHooWithOccult);
event4.TargetId = actor.SimDescription.SimDescriptionId;
EventTracker.SendEvent(event4);
}
}
public static bool IsOccult(MiniSimDescription sim, OccultTypes type)
{
switch (type)
{
case OccultTypes.Vampire:
return(sim.IsVampire);
case OccultTypes.Frankenstein:
return(sim.IsFrankenstein);
case OccultTypes.Mummy:
return(sim.IsMummy);
case OccultTypes.Unicorn:
return(sim.IsUnicorn);
case OccultTypes.Genie:
return(sim.IsGenie);
case OccultTypes.Fairy:
return(sim.IsFairy);
case OccultTypes.Ghost:
return(sim.IsDead || sim.IsPlayableGhost);
case OccultTypes.Werewolf:
return(sim.IsWerewolf);
case OccultTypes.Witch:
return(sim.IsWitch);
case OccultTypes.Mermaid:
return(sim.IsMermaid);
case OccultTypes.Robot:
return(sim.IsEP11Bot);
}
return(false);
}
private static bool PrivateIsFailure(IMagicalInteraction interaction, OccultTypes testType, out bool fail, out bool epicFailure)
{
fail = false;
epicFailure = false;
if (!OccultTypeHelper.HasType(interaction.Actor, testType))
{
return(false);
}
switch (testType)
{
case OccultTypes.Witch:
SpellcastingSkill spellcasting = interaction.Actor.SkillManager.GetElement(SkillNames.Spellcasting) as SpellcastingSkill;
MagicWand wand = MagicWand.GetWandToUse(interaction.Actor, spellcasting);
if (wand != null)
{
fail = RandomUtil.RandomChance(wand.SuccessChance(interaction.Actor, interaction.SpellLevel, spellcasting.SkillLevel));
if (!fail)
{
epicFailure = RandomUtil.RandomChance(wand.EpicFailChance(interaction.Actor));
}
}
break;
case OccultTypes.Fairy:
if (interaction.SpellLevel <= interaction.Actor.SkillManager.GetSkillLevel(SkillNames.FairyMagic))
{
fail = true;
}
break;
case OccultTypes.Genie:
case OccultTypes.Unicorn:
return(false);
}
return(fail);
}
public static bool HasPoints(Sim sim, OccultTypes intended, bool allowFailure)
{
if (intended != OccultTypes.None)
{
if (PrivateHasPoints(sim, intended, allowFailure)) return true;
}
foreach(OccultTypes type in sMagicOccult)
{
if (type == intended) continue;
if (PrivateHasPoints(sim, type, allowFailure)) return true;
}
return false;
}
public static void UsePoints(Sim sim, int points, OccultTypes intended)
{
SpellcastingSkill spellCasting = sim.SkillManager.GetElement(SkillNames.Spellcasting) as SpellcastingSkill;
MagicWand wand = MagicWand.GetWandToUse(sim, spellCasting);
if (intended != OccultTypes.None)
{
if (PrivateUsePoints(sim, wand, points, intended)) return;
}
foreach(OccultTypes type in sMagicOccult)
{
if (type == intended) continue;
if (PrivateUsePoints(sim, wand, points, type)) return;
}
}
private static bool PrivateHasPoints(Sim sim, OccultTypes type, bool allowFailure)
{
if (!OccultTypeHelper.HasType(sim, type)) return false;
switch (type)
{
case OccultTypes.Genie:
OccultGenie genie = sim.OccultManager.GetOccultType(OccultTypes.Genie) as OccultGenie;
if (genie != null)
{
return genie.MagicPoints.HasPoints();
}
break;
case OccultTypes.Fairy:
return (!sim.BuffManager.HasElement(BuffNames.FairyAuraFailure));
case OccultTypes.Witch:
if (allowFailure) return true;
return (!sim.BuffManager.HasElement(BuffNames.DepletedMagic));
case OccultTypes.Unicorn:
OccultUnicorn unicorn = sim.OccultManager.GetOccultType(OccultTypes.Unicorn) as OccultUnicorn;
if (unicorn != null)
{
return unicorn.MagicPoints.HasPoints();
}
break;
}
return false;
}
public static bool Add(SimDescription sim, OccultTypes type, bool isReward, bool applyOutfit)
{
try
{
if (sim.IsPregnant) return false;
if (!OccultTypeHelper.IsInstalled(type)) return false;
if (sim.OccultManager.HasOccultType(type))
{
bool found = false;
if (sim.OccultManager.mOccultList != null)
{
foreach (OccultBaseClass occult in sim.OccultManager.mOccultList)
{
if (occult.ClassOccultType == type)
{
found = true;
break;
}
}
}
if (found) return false;
}
return AddOccultType(sim.OccultManager, type, applyOutfit, isReward, false, null);
}
catch (Exception e)
{
Common.Exception(sim, e);
return false;
}
}
public static bool HasType(Sim sim, OccultTypes type)
{
if (sim == null) return false;
return HasType(sim.SimDescription, type);
}
public static void ApplyTrait(SimDescription sim, OccultTypes type)
{
TraitNames trait = TraitFromOccult(type);
if (trait == TraitNames.Unknown) return;
// Apply the trait using both functions, just in case the user has a tuning mod that mod the trait visible
sim.TraitManager.AddHiddenElement(trait);
sim.TraitManager.AddElement(trait);
}
public void SetVisualOverride(OccultTypes type)
{
mCASModel.SetVisualOverride(type);
}
// From OccultManager
protected static bool AddOccultType(OccultManager ths, OccultTypes type, bool addOutfit, bool isReward, bool fromRestore, OccultBaseClass overrideOccultToAdd)
{
OccultBaseClass newOccult = null;
OccultBaseClass oldOccult = ths.VerifyOccultList(type);
if (overrideOccultToAdd != null)
{
newOccult = overrideOccultToAdd;
}
else
{
switch (type)
{
case OccultTypes.Mummy:
newOccult = new OccultMummy();
break;
case OccultTypes.Frankenstein:
newOccult = new OccultFrankenstein();
break;
case OccultTypes.Vampire:
newOccult = new OccultVampire();
break;
case OccultTypes.ImaginaryFriend:
OccultImaginaryFriend oldImFr = oldOccult as OccultImaginaryFriend;
if (oldImFr == null)
{
newOccult = new OccultImaginaryFriend();
}
else
{
newOccult = new OccultImaginaryFriend(oldImFr);
}
break;
case OccultTypes.Unicorn:
newOccult = new OccultUnicorn();
break;
case OccultTypes.Fairy:
newOccult = new OccultFairy();
break;
case OccultTypes.Witch:
newOccult = new OccultWitch();
break;
case OccultTypes.Genie:
newOccult = new OccultGenie();
break;
case OccultTypes.Werewolf:
newOccult = new OccultWerewolf();
break;
case OccultTypes.PlantSim:
newOccult = new OccultPlantSim();
break;
case OccultTypes.Mermaid:
newOccult = new OccultMermaid();
break;
case OccultTypes.TimeTraveler:
newOccult = new OccultTimeTraveler();
break;
case OccultTypes.Robot:
newOccult = new OccultRobot();
break;
}
}
if (newOccult == null)
{
return false;
}
OccultTypes originalTypes = ths.mCurrentOccultTypes;
Role assignedRole = ths.mOwnerDescription.AssignedRole;
float alienDNAPercentage = ths.mOwnerDescription.AlienDNAPercentage;
try
{
ths.mCurrentOccultTypes = OccultTypes.None;
ths.mOwnerDescription.AssignedRole = null;
ths.mOwnerDescription.mAlienDNAPercentage = 0f;
if (!newOccult.CanAdd(ths.mOwnerDescription, fromRestore))
{
return false;
}
}
finally
{
ths.mCurrentOccultTypes = originalTypes;
ths.mOwnerDescription.AssignedRole = assignedRole;
ths.mOwnerDescription.mAlienDNAPercentage = alienDNAPercentage;
}
if ((ths.mOwnerDescription.SupernaturalData == null) ||
((type == OccultTypes.Fairy) && (ths.mOwnerDescription.SupernaturalData.OccultType != OccultTypes.Fairy)) ||
((type == OccultTypes.Robot) && (ths.mOwnerDescription.SupernaturalData.OccultType != OccultTypes.Robot)) ||
((type == OccultTypes.PlantSim) && (ths.mOwnerDescription.SupernaturalData.OccultType != OccultTypes.PlantSim)))
{
ths.mOwnerDescription.AddSupernaturalData(type);
}
ths.mIsLifetimeReward = isReward;
if (type == OccultTypes.Genie)
{
// Corrections for improper handling of the special outfits by OccultGenie
if (ths.mOwnerDescription.mSpecialOutfitIndices == null)
{
ths.mOwnerDescription.mSpecialOutfitIndices = new Dictionary<uint, int>();
}
addOutfit = false;
}
if (type == OccultTypes.Unicorn)
{
OccultUnicornEx.OnAddition(newOccult as OccultUnicorn, ths.mOwnerDescription, addOutfit);
}
ApplyTrait(ths.mOwnerDescription, type);
MidlifeCrisisManager midlifeCrisisManager = ths.mOwnerDescription.MidlifeCrisisManager;
try
{
// Inactive mummies don't agree with mid-life crisis managers
ths.mOwnerDescription.MidlifeCrisisManager = null;
newOccult.OnAddition(ths.mOwnerDescription, addOutfit, ths.mIsLifetimeReward, fromRestore);
}
finally
{
ths.mOwnerDescription.MidlifeCrisisManager = midlifeCrisisManager;
}
ths.mOccultList.Add(newOccult);
ths.mCurrentOccultTypes |= type;
EventTracker.SendEvent(new BeAnOccultEvent(EventTypeId.kBeAnOccult, ths.mOwnerDescription.CreatedSim, (uint)type));
if (ths.mOwnerDescription.CreatedSim != null)
{
if (!Cane.IsAllowedToUseCane(ths.mOwnerDescription.CreatedSim))
{
Cane.StopUsingAnyActiveCanes(ths.mOwnerDescription.CreatedSim);
}
if (!Backpack.IsAllowedToUseBackpack(ths.mOwnerDescription.CreatedSim))
{
Backpack.StopUsingAnyActiveBackpacks(ths.mOwnerDescription.CreatedSim);
}
if (!Jetpack.IsAllowedToUseJetpack(ths.mOwnerDescription.CreatedSim))
{
Jetpack.StopUsingAnyActiveJetpacks(ths.mOwnerDescription.CreatedSim);
}
}
(Responder.Instance.HudModel as Sims3.Gameplay.UI.HudModel).OnSimDaysPerAgingYearChanged();
ths.ClearOneShot();
ths.UpdateOccultUI();
if (!fromRestore)
{
EventTracker.SendEvent(EventTypeId.kBecameOccult, ths.mOwnerDescription.CreatedSim);
}
if (oldOccult != null)
{
newOccult.MergeOccultData(oldOccult);
}
if (ths.mOwnerDescription.CreatedSim != null)
{
Sim.StandingPosture standing = ths.mOwnerDescription.CreatedSim.Standing as Sim.StandingPosture;
if (standing != null)
{
standing.SetDefaultIdleAnim();
}
}
return true;
}
public static bool IsFailure(IMagicalInteraction interaction, OccultTypes preferredType)
{
bool epicFailure = false;
return IsFailure(interaction, preferredType, out epicFailure);
}
public SpellSettings(OccultTypes validTypes, int minSkillLevel, float minMana, int offIntendedLevel)
{
mValidTypes = validTypes;
mMinSkillLevel = minSkillLevel;
mMinMana = minMana;
mOffIntendedLevel = offIntendedLevel;
}
public static IGameObject FetchRandomOccultTreat(OccultTypes type, bool isAlien)
{
if (isAlien)
{
InteractionDefinition instance = RabbitHole.StealSpaceRocks.Singleton;
RabbitHole.StealSpaceRocks instance2 = instance as RabbitHole.StealSpaceRocks;
if (instance2 != null)
{
RabbitHole.StealSpaceRocks.SpaceRockSize weightedIndex = (RabbitHole.StealSpaceRocks.SpaceRockSize)RandomUtil.GetWeightedIndex(instance2.SSRTuning.SpaceRockWeights);
RockGemMetal spaceRockSize = RockGemMetal.SpaceRockSmall;
switch (weightedIndex)
{
case RabbitHole.StealSpaceRocks.SpaceRockSize.Small:
spaceRockSize = RockGemMetal.SpaceRockSmall;
break;
case RabbitHole.StealSpaceRocks.SpaceRockSize.Medium:
spaceRockSize = RockGemMetal.SpaceRockMedium;
break;
case RabbitHole.StealSpaceRocks.SpaceRockSize.Large:
spaceRockSize = RockGemMetal.SpaceRockLarge;
break;
}
return RockGemMetalBase.Make(spaceRockSize, false);
}
}
switch(type)
{
case OccultTypes.Fairy:
PlantRarity rarity = (PlantRarity) RandomUtil.GetInt(0, 3);
Quality quality = (Quality) RandomUtil.GetInt(4, 9);
PlayerDisclosure playerKnowledgeOfPlantableType = (rarity == PlantRarity.Common) ? PlayerDisclosure.Exposed : PlayerDisclosure.Concealed;
IGameObject seed = PlantHelper.CreateRandomPlantable(rarity, quality, true, playerKnowledgeOfPlantableType);
return seed;
case OccultTypes.Frankenstein:
ScrapInitParameters initData = new ScrapInitParameters(1);
IGameObject scrap = GlobalFunctions.CreateObjectOutOfWorld("scrapPile", ProductVersion.EP2, null, initData);
return scrap;
case OccultTypes.Genie:
IGameObject lamp = GlobalFunctions.CreateObjectOutOfWorld("GenieLamp", ProductVersion.EP6);
return lamp;
case OccultTypes.Mermaid:
IGameObject kelp = MermadicKelp.MakeMermadicKelp(RandomUtil.CoinFlip());
return kelp;
case OccultTypes.PlantSim:
string randomHerb = RandomUtil.GetRandomObjectFromList<string>(new List<string>(Herb.sIngredientToHerbDataMap.Keys));
Ingredient herb = Ingredient.Create(IngredientData.NameToDataMap[randomHerb]);
return herb as IGameObject;
case OccultTypes.Robot:
TraitChipStaticData data = RandomUtil.GetRandomObjectFromDictionary<ulong, TraitChipStaticData>(GenericManager<TraitChipName, TraitChipStaticData, TraitChip>.sDictionary);
if (data != null)
{
TraitChip chip = TraitChipManager.CreateTraitChip(data.Guid);
return chip;
}
return null;
case OccultTypes.Vampire:
IGameObject vampireTreat = null;
if (!GameUtils.IsInstalled(ProductVersion.EP3))
{
vampireTreat = Recipe.NameToRecipeHash["VampireJuiceEP7"].CreateFinishedFood(Recipe.MealQuantity.Single, Quality.Perfect);
}
else
{
bool coinToss = RandomUtil.CoinFlip();
if (coinToss)
{
vampireTreat = Recipe.NameToRecipeHash["VampireJuice"].CreateFinishedFood(Recipe.MealQuantity.Single, Quality.Perfect);
}
else
{
vampireTreat = Ingredient.Create(IngredientData.NameToDataMap["VampireFruit"]);
}
}
return vampireTreat;
case OccultTypes.Werewolf:
List<FishType> fish = new List<FishType>();
List<float> weights = new List<float>(fish.Count);
foreach (FishType fishType in Fish.sFishData.Keys)
{
FishData data2 = Fish.sFishData[fishType];
if (((data2.IngredientData != null) && data2.IngredientData.CanBuyFromStore) && (data2.Level >= 0))
{
fish.Add(fishType);
weights.Add(1f);
}
}
int weightedIndexFish = RandomUtil.GetWeightedIndex(weights.ToArray());
Fish obj2 = Fish.CreateFishOfRandomWeight(fish[weightedIndexFish]);
return obj2 as IGameObject;
case OccultTypes.Witch:
if (RandomUtil.CoinFlip())
{
ISoloInteractionDefinition cdef = TraitFunctions.ConjureApple.Singleton;
TraitFunctions.ConjureApple appleDef = cdef as TraitFunctions.ConjureApple;
if (appleDef != null)
{
return appleDef.CreateAppleForInventory(RandomUtil.CoinFlip(), Quality.Perfect);
}
}
else
{
AlchemyPotion potion = AlchemyPotion.CreateARandomPotion(RandomUtil.CoinFlip(), 0);
return potion as IGameObject;
}
return null;
case OccultTypes.None:
default:
return null;
}
}
public static TraitNames TraitFromOccult(OccultTypes occult)
{
switch (occult)
{
case OccultTypes.Vampire:
return TraitNames.VampireHiddenTrait;
case OccultTypes.Mummy:
return TraitNames.MummyHiddenTrait;
case OccultTypes.Frankenstein:
return TraitNames.FrankensteinHiddenTrait;
case OccultTypes.ImaginaryFriend:
return TraitNames.ImaginaryFriendHiddenTrait;
case OccultTypes.Unicorn:
return TraitNames.UnicornHiddenTrait;
case OccultTypes.Genie:
return TraitNames.GenieHiddenTrait;
case OccultTypes.Witch:
return TraitNames.WitchHiddenTrait;
case OccultTypes.Werewolf:
return TraitNames.LycanthropyHuman;
case OccultTypes.Fairy:
return TraitNames.FairyHiddenTrait;
case OccultTypes.PlantSim:
return TraitNames.PlantSim;
case OccultTypes.Mermaid:
return TraitNames.MermaidHiddenTrait;
case OccultTypes.Robot:
return TraitNames.RobotHiddenTrait;
case OccultTypes.TimeTraveler:
return TraitNames.TimeTravelerHiddenTrait;
default:
return TraitNames.Unknown;
}
}
public static List<OccultTypes> CreateList(OccultTypes types)
{
return CreateList(types, false);
}
public static bool IsInstalled(OccultTypes type)
{
switch (type)
{
case OccultTypes.Vampire:
return GameUtils.IsInstalled(ProductVersion.EP3 | ProductVersion.EP7);
case OccultTypes.Mummy:
return GameUtils.IsInstalled(ProductVersion.EP1);
case OccultTypes.Frankenstein:
return GameUtils.IsInstalled(ProductVersion.EP2);
case OccultTypes.ImaginaryFriend:
return GameUtils.IsInstalled(ProductVersion.EP4);
case OccultTypes.Unicorn:
return GameUtils.IsInstalled(ProductVersion.EP5);
case OccultTypes.Genie:
return GameUtils.IsInstalled(ProductVersion.EP6);
case OccultTypes.Werewolf:
case OccultTypes.Fairy:
case OccultTypes.Witch:
return GameUtils.IsInstalled(ProductVersion.EP7);
case OccultTypes.PlantSim:
return GameUtils.IsInstalled(ProductVersion.EP9);
case OccultTypes.Mermaid:
return GameUtils.IsInstalled(ProductVersion.EP10);
case OccultTypes.TimeTraveler:
case OccultTypes.Robot:
return GameUtils.IsInstalled(ProductVersion.EP11);
case OccultTypes.Ghost:
case OccultTypes.None:
return true;
}
return false;
}
private static bool PrivateUsePoints(Sim sim, MagicWand wand, int points, OccultTypes type)
{
if (!OccultTypeHelper.HasType(sim, type)) return false;
switch (type)
{
case OccultTypes.Genie:
OccultGenie genie = sim.OccultManager.GetOccultType(OccultTypes.Genie) as OccultGenie;
if (genie != null)
{
genie.MagicPoints.UsePoints(points);
(Sims3.UI.Responder.Instance.HudModel as HudModel).FlashMagicMotiveBar();
return true;
}
break;
case OccultTypes.Fairy:
sim.Motives.ChangeValue(CommodityKind.AuraPower, -points);
(Sims3.UI.Responder.Instance.HudModel as HudModel).FlashMagicMotiveBar();
return true;
case OccultTypes.Witch:
if (wand != null)
{
wand.DrainMotive(sim, CommodityKind.MagicFatigue, -points);
return true;
}
else
{
float num = (points * DefaultWand.kMotiveDrainMultiplier) * MagicWand.kMoonPhaseMotiveDrainMultiplier[World.GetLunarPhase()];
if (sim.BuffManager.HasElement(BuffNames.AnimalFamiliar))
{
num *= MagicWand.kFamiliarMotiveMultiplier;
}
sim.Motives.ChangeValue(CommodityKind.MagicFatigue, -num);
(Sims3.UI.Responder.Instance.HudModel as HudModel).FlashMagicMotiveBar();
}
break;
case OccultTypes.Unicorn:
OccultUnicorn unicorn = sim.OccultManager.GetOccultType(OccultTypes.Unicorn) as OccultUnicorn;
if (unicorn != null)
{
unicorn.MagicPoints.UsePoints(points);
(Sims3.UI.Responder.Instance.HudModel as HudModel).FlashMagicMotiveBar();
return true;
}
break;
}
return false;
}
public static bool IsOccult(IMiniSimDescription sim, OccultTypes type)
{
if (sim is MiniSimDescription)
{
return IsOccult(sim as MiniSimDescription, type);
}
else
{
return IsOccult(sim as SimDescription, type);
}
}
public void RequestSetOccultType(OccultTypes newType)
{
mCASModel.RequestSetOccultType(newType);
}
public static bool IsOccult(MiniSimDescription sim, OccultTypes type)
{
switch (type)
{
case OccultTypes.Vampire:
return sim.IsVampire;
case OccultTypes.Frankenstein:
return sim.IsFrankenstein;
case OccultTypes.Mummy:
return sim.IsMummy;
case OccultTypes.Unicorn:
return sim.IsUnicorn;
case OccultTypes.Genie:
return sim.IsGenie;
case OccultTypes.Fairy:
return sim.IsFairy;
case OccultTypes.Ghost:
return sim.IsDead || sim.IsPlayableGhost;
case OccultTypes.Werewolf:
return sim.IsWerewolf;
case OccultTypes.Witch:
return sim.IsWitch;
case OccultTypes.Mermaid:
return sim.IsMermaid;
case OccultTypes.Robot:
return sim.IsEP11Bot;
}
return false;
}
public void OnOccultTypeSelectedProxy(OccultTypes currentType)
{
try
{
if (OccultTypeSelected != null)
{
OccultTypeSelected(currentType);
}
}
catch (Exception e)
{
Common.Exception("OnOccultTypeSelectedProxy", e);
}
}
public static bool IsOccult(SimDescription sim, OccultTypes type)
{
if (sim == null) return false;
if (sim.OccultManager == null) return false;
if (type == OccultTypes.None)
{
return sim.OccultManager.HasAnyOccultType();
}
else
{
return sim.OccultManager.HasOccultType(type);
}
}
public MotiveKey(CASAgeGenderFlags ageSpecies, OccultTypes occult, CommodityKind kind)
{
mAgeSpecies = ageSpecies;
mOccult = occult;
mKind = kind;
}
public static bool HasType(SimDescription sim, OccultTypes type)
{
if (sim == null) return false;
if (sim.OccultManager == null) return false;
return sim.OccultManager.HasOccultType(type);
}
public static bool Remove(SimDescription sim, OccultTypes type, bool alterOutfit)
{
if (sim.OccultManager == null) return false;
if (sim.CreatedSim != null)
{
try
{
if (sim.CreatedSim.CurrentOutfitCategory == OutfitCategories.Special)
{
sim.CreatedSim.SwitchToOutfitWithoutSpin(OutfitCategories.Everyday);
}
}
catch
{ }
}
OccultVampire vampire = sim.OccultManager.GetOccultType(type) as OccultVampire;
if (vampire != null)
{
if ((vampire.mOwningSim == null) || (vampire.mOwningSim.MapTagManager == null))
{
vampire.mPreyMapTag = null;
}
}
if (sim.GetOutfitCount(OutfitCategories.Everyday) == 1)
{
SimOutfit outfit = sim.GetOutfit(OutfitCategories.Everyday, 0);
using (CASParts.OutfitBuilder builder = new CASParts.OutfitBuilder(sim, new CASParts.Key(OutfitCategories.Everyday, 1), outfit))
{ }
}
if (type == OccultTypes.Unicorn)
{
OccultUnicornEx.OnRemoval(sim);
}
bool success = false;
OccultManager occultManager = sim.OccultManager;
try
{
if (occultManager.HasOccultType(type))
{
occultManager.mCurrentOccultTypes ^= type;
foreach (OccultBaseClass occultClass in occultManager.mOccultList)
{
if (type == occultClass.ClassOccultType)
{
if ((occultManager.mOwnerDescription.SupernaturalData != null) && (occultManager.mOwnerDescription.SupernaturalData.OccultType == type))
{
occultManager.mOwnerDescription.RemoveSupernaturalData();
}
OccultGenie genie = occultClass as OccultGenie;
if (genie != null)
{
OccultGenieEx.OnRemoval(genie, occultManager.mOwnerDescription, alterOutfit);
}
else
{
OccultPlantSim plantSim = occultClass as OccultPlantSim;
if (plantSim != null)
{
OccultPlantSimEx.OnRemoval(plantSim, occultManager.mOwnerDescription, alterOutfit);
}
else
{
occultClass.OnRemoval(occultManager.mOwnerDescription);
}
}
occultManager.mOccultList.Remove(occultClass);
occultManager.mIsLifetimeReward = false;
if (occultManager.mOccultList.Count == 0x0)
{
occultManager.mOccultList = null;
}
break;
}
}
(Responder.Instance.HudModel as Sims3.Gameplay.UI.HudModel).OnSimDaysPerAgingYearChanged();
occultManager.UpdateOccultUI();
EventTracker.SendEvent(EventTypeId.kLostOccult, occultManager.mOwnerDescription.CreatedSim);
}
//occultManager.RemoveOccultType(type);
success = true;
}
catch (Exception e)
{
bool showError = true;
switch (type)
{
case OccultTypes.Genie:
case OccultTypes.ImaginaryFriend:
if (sim.CreatedSim == null)
{
showError = false;
}
break;
}
if (showError)
{
Common.Exception(sim, e);
}
}
if (!success)
{
for (int i = occultManager.mOccultList.Count - 1; i >= 0; i--)
{
if (type == occultManager.mOccultList[i].ClassOccultType)
{
occultManager.mOccultList.RemoveAt(i);
}
(Sims3.UI.Responder.Instance.HudModel as Sims3.Gameplay.UI.HudModel).OnSimDaysPerAgingYearChanged();
sim.OccultManager.UpdateOccultUI();
}
}
TraitNames trait = TraitFromOccult(type);
if (trait != TraitNames.Unknown)
{
sim.TraitManager.RemoveElement(trait);
}
return success;
}
public static string GetLocalizedName(OccultTypes type)
{
switch (type)
{
case OccultTypes.Vampire:
return OccultManager.GetSingularOccultName(OccultTypesAll.Vampire);
case OccultTypes.Mummy:
return OccultManager.GetSingularOccultName(OccultTypesAll.Mummy);
case OccultTypes.Frankenstein:
return OccultManager.GetSingularOccultName(OccultTypesAll.Frankenstein);
case OccultTypes.ImaginaryFriend:
return OccultManager.GetSingularOccultName(OccultTypesAll.ImaginaryFriend);
case OccultTypes.Unicorn:
return OccultManager.GetSingularOccultName(OccultTypesAll.Unicorn);
case OccultTypes.Genie:
return OccultManager.GetSingularOccultName(OccultTypesAll.Genie);
case OccultTypes.Werewolf:
return OccultManager.GetSingularOccultName(OccultTypesAll.Werewolf);
case OccultTypes.Fairy:
return OccultManager.GetSingularOccultName(OccultTypesAll.Fairy);
case OccultTypes.Witch:
return OccultManager.GetSingularOccultName(OccultTypesAll.Witch);
case OccultTypes.Ghost:
return OccultManager.GetSingularOccultName(OccultTypesAll.Ghost);
case OccultTypes.Mermaid:
return OccultManager.GetSingularOccultName(OccultTypesAll.Mermaid);
case OccultTypes.PlantSim:
return OccultManager.GetSingularOccultName(OccultTypesAll.PlantSim);
case OccultTypes.TimeTraveler:
return OccultManager.GetSingularOccultName(OccultTypesAll.TimeTraveler);
case OccultTypes.Robot:
return OccultManager.GetSingularOccultName(OccultTypesAll.Robot);
default:
return Common.Localize("OccultTypes:None");
}
}
