public static void OnAccept(Sim actor, Sim target, string interaction, ActiveTopic topic, InteractionInstance i)
{
try
{
ScoringLookup.IncStat("OnAccept Woohoo");
if (Common.kDebugging)
{
Woohooer.DebugNotify("Woohoo" + Common.NewLine + actor.FullName + Common.NewLine + target.FullName, actor, target);
}
WooHooSocialInteraction woohooSocial = i as WooHooSocialInteraction;
if (woohooSocial != null)
{
woohooSocial.PushWooHoo(actor, target);
}
else
{
new CommonWoohoo.PushWoohoo(actor, target, i.Autonomous, CommonWoohoo.WoohooStyle.Safe);
}
}
catch (Exception e)
{
Common.Exception(actor, target, e);
}
}
public static bool ScoreInsulting(Sim actor, Sim target, bool isAutonomous, string scoring)
{
ScoringLookup.IncStat("OnScoreInsulting Try");
if (!isAutonomous)
{
if (!Woohooer.Settings.TraitScoringForUserDirected)
{
ScoringLookup.IncStat("OnScoreInsulting Not User TraitScored");
return(false);
}
}
if (!Woohooer.Settings.UsingTraitScoring)
{
ScoringLookup.IncStat("OnScoreInsulting Not TraitScored");
return(false);
}
// Target is not interested and is not attracted to sim
if (!TestScoringAbsolute(target, actor, scoring, true))
{
if (!TestScoringAbsolute(target, actor, "Attraction", false))
{
ScoringLookup.IncStat("OnScoreInsulting Attraction");
return(true);
}
}
ScoringLookup.IncStat("OnScoreInsulting Fail");
return(false);
}
public static bool SatisfiesUserLikingGate(Sim actor, Sim target, bool isAutonomous, bool woohoo, string logName)
{
if ((isAutonomous) || (Woohooer.Settings.mLikingGateForUserDirected))
{
if (!CommonSocials.SatisfiesLikingGate(actor, target, woohoo))
{
ScoringLookup.IncStat(logName + " LikingGate");
return(false);
}
else
{
Relationship relation = Relationship.Get(actor, target, false);
if (relation != null)
{
if ((relation.CurrentSTC != ShortTermContextTypes.Hot) && (relation.CurrentSTC != AmorousCommodity.sHot2))
{
ScoringLookup.IncStat(logName + " STC Fail " + relation.CurrentSTC);
return(false);
}
}
}
}
return(true);
}
protected override OptionResult Run(GameHitParameters <GameObject> parameters)
{
ScoringLookup.UnloadCaches(false);
WoohooScoring.Dump(true);
return(OptionResult.SuccessRetain);
}
public SocialSymptom(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "Social", Guid))
{
mSocial = row.GetString("Social");
if (mSocial != "Braaaiiins")
{
if (ActionData.Get(mSocial) == null)
{
BooterLogger.AddError(Guid + " Invalid Social: " + mSocial);
}
}
}
if (BooterLogger.Exists(row, "RoomOnly", Guid))
{
mRoomOnly = row.GetBool("RoomOnly");
}
mScoring = row.GetString("Scoring");
if (!string.IsNullOrEmpty(mScoring))
{
if (ScoringLookup.GetScoring(mScoring) == null)
{
BooterLogger.AddError(Guid + " Invalid Scoring: " + mScoring);
}
mMinimum = row.GetInt("Minimum", 0);
}
}
public override bool Parse(XmlDbRow row, ref string error)
{
if (!row.Exists("Method"))
{
error = "Method missing";
return(false);
}
else if (!row.Exists("Gate"))
{
error = "Gate missing";
return(false);
}
mMethod = row.GetString("Method");
if (ScoringLookup.GetScoring(mMethod) == null)
{
error = mMethod + " not found";
return(false);
}
mGate = new HitMissResult <T, SP>(row, "Gate", ref error);
if (!string.IsNullOrEmpty(error))
{
return(false);
}
return(base.Parse(row, ref error));
}
public ScoringStage(XmlDbRow row)
: base(row)
{
if (BooterLogger.Exists(row, "Scoring", Name))
{
mScoring = row.GetString("Scoring");
if (string.IsNullOrEmpty(mScoring))
{
BooterLogger.AddError(Name + " Empty Scoring");
}
else if (ScoringLookup.GetScoring(mScoring) == null)
{
BooterLogger.AddError(Name + " Invalid Scoring: " + mScoring);
}
}
if (row.GetString("Minimum") == "Strength")
{
mMinimum = int.MinValue;
}
else
{
mMinimum = row.GetInt("Minimum", int.MinValue);
}
mMinMutation = row.GetString("MinMutation");
}
public static bool TestScoringAbsolute(Sim actor, Sim target, string scoringName, bool checkAffair)
{
int score = GetScoring(actor, target, scoringName, checkAffair, true);
ScoringLookup.AddStat("Test Absolute " + scoringName, score);
return(score > 0);
}
public static bool TestScoringNormal(Sim actor, Sim target, string scoringName, bool checkAffair)
{
int score = GetScoring(actor, target, scoringName, checkAffair, false);
ScoringLookup.AddStat("Test Normal " + scoringName, score);
return(score > 0);
}
public override bool Test(Sim a, Computer target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
{
if (!SimClock.IsNightTime())
{
greyedOutTooltipCallback = Common.DebugTooltip("Not Night Time");
return(false);
}
if (isAutonomous)
{
if (!mRandom)
{
greyedOutTooltipCallback = Common.DebugTooltip("Not Random");
return(false);
}
if (!Woohooer.Settings.mAutonomousComputer)
{
greyedOutTooltipCallback = Common.DebugTooltip("No Autonomous");
return(false);
}
if (ScoringLookup.GetScore("LikeProfessional", a.SimDescription) < 0)
{
greyedOutTooltipCallback = Common.DebugTooltip("Score Fail");
return(false);
}
if (!CommonWoohoo.SatisfiesCooldown(a, RandomUtil.GetRandomObjectFromList <Sim>(LotManager.Actors), isAutonomous, ref greyedOutTooltipCallback))
{
greyedOutTooltipCallback = Common.DebugTooltip("Cooldown Fail");
return(false);
}
if (!CommonWoohoo.HasWoohooableObject(a.LotHome, a, RandomUtil.GetRandomObjectFromList <Sim>(LotManager.Actors)))
{
greyedOutTooltipCallback = Common.DebugTooltip("No Woohooable Objects Fail");
return(false);
}
if (GetPotentials(a).Count == 0)
{
greyedOutTooltipCallback = Common.DebugTooltip("No Choices");
return(false);
}
}
else
{
if (!KamaSimtra.Settings.mShowRegisterInteraction)
{
greyedOutTooltipCallback = Common.DebugTooltip("User Hidden");
return(false);
}
}
return(true);
}
protected override bool Allow(GameHitParameters <GameObject> parameters)
{
if (ScoringLookup.GetScoring("InterestInCommon", false) == null)
{
return(false);
}
return(true);
}
protected override bool IsFail(SimDescription sim, SimDescription target)
{
if (string.IsNullOrEmpty(mSneakinessScoring))
{
IncStat("No Sneakiness Scoring");
return(false);
}
return(AddScoring("Target Sneak", ScoringLookup.GetScore(mSneakinessScoring, target)) > AddScoring("Sim Sneak", ScoringLookup.GetScore(mSneakinessScoring, sim)));
}
protected bool ScoreChildMove(IScoringGenerator stats, string tag, SimDescription child, List <SimDescription> movingSims)
{
if (child.Genealogy.Parents.Count == 0)
{
stats.IncStat(tag + " ChildMove: No Parents");
return(false);
}
int firstScore = 0;
bool firstMoving = false;
SimDescription mom = null, dad = null;
Relationships.GetParents(child, out mom, out dad);
if (mom != null)
{
firstMoving = movingSims.Contains(mom);
if ((firstMoving) || (mom.Household == child.Household))
{
firstScore = stats.AddScoring(tag + " ChildMove", ScoringLookup.GetScore("ParentChild", child, mom));
}
else
{
return(true);
}
}
int secondScore = 0;
bool secondMoving = false;
if (dad != null)
{
secondMoving = movingSims.Contains(dad);
if ((secondMoving) || (dad.Household == child.Household))
{
secondScore = stats.AddScoring(tag + " ChildMove", ScoringLookup.GetScore("ParentChild", child, dad));
}
else
{
return(true);
}
}
if (firstScore > secondScore)
{
return(firstMoving);
}
else
{
return(secondMoving);
}
}
public static bool PublicTest(Sim actor, Sim target, ActiveTopic topic, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
{
if (!CommonTest(actor, target, ref greyedOutTooltipCallback))
{
return(false);
}
ScoringLookup.IncStat("OnTest Woohoo Try");
return(CommonWoohoo.SatisfiesWoohoo(actor, target, "OnTest Woohoo", isAutonomous, false, true, ref greyedOutTooltipCallback));
}
public int AddScoring(string scoring, SimDescription sim, Common.DebugLevel minLevel)
{
int score = ScoringLookup.GetScore(scoring, sim);
if (!Common.kDebugging)
{
return(score);
}
return(AddScoring(mName + " " + scoring, score, minLevel));
}
public int AddScoring(string scoring, SimDescription sim, SimDescription other)
{
int score = ScoringLookup.GetScore(scoring, sim, other);
if (!Common.kDebugging)
{
return(score);
}
return(AddScoring(mName + " " + scoring, score));
}
public int AddScoring(string scoring, int option, ScoringLookup.OptionType type, SimDescription sim)
{
int score = ScoringLookup.GetScore(scoring, option, type, sim);
if (!Common.kDebugging)
{
return(score);
}
return(AddScoring(mName + " " + scoring, score));
}
public static bool PublicTest(Sim actor, Sim target, ActiveTopic topic, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
{
if (!SimWoohoo.CommonTest(actor, target, ref greyedOutTooltipCallback))
{
return(false);
}
ScoringLookup.IncStat("OnTest TryForBaby Try");
return(CommonPregnancy.SatisfiesTryForBaby(actor, target, "OnTest TryForBaby", isAutonomous, false, ref greyedOutTooltipCallback));
}
public int AddScoring(string scoring, int option, ScoringLookup.OptionType type, SimDescription sim, SimDescription other, Common.DebugLevel minLevel)
{
int score = ScoringLookup.GetScore(scoring, option, type, sim, other);
if (!Common.kDebugging)
{
return(score);
}
return(AddScoring(mName + " " + scoring, score, minLevel));
}
public virtual void Symptomize(Sim sim, DiseaseVector vector)
{
if ((string.IsNullOrEmpty(mSymptomScoring)) ||
(ScoringLookup.GetScore(mSymptomScoring, sim.SimDescription) >= mSymptomScoringMinimum))
{
foreach (SymptomChance chance in mSymptoms)
{
chance.Perform(sim, vector);
}
}
}
public void AddClan(SimPersonality clan)
{
string name = clan.UnlocalizedName.ToLower();
if (mClans.Contains(name))
{
return;
}
ScoringLookup.UnloadCaches <IClanScoring>();
mClans.Add(name);
}
protected override bool IsSuccess(SimDescription sim, DiseaseVector vector)
{
int minimum = mMinimum;
if (minimum == int.MinValue)
{
minimum = vector.NetStrength;
}
minimum += vector.GetCounter(mMinMutation);
return(ScoringLookup.GetScore(mScoring, sim) > minimum);
}
protected override void PrivateUpdate(bool fullUpdate, bool initialPass)
{
if (initialPass)
{
ScoringLookup.Validate();
}
if (fullUpdate)
{
ScoringLookup.UnloadCaches(false);
}
base.PrivateUpdate(fullUpdate, initialPass);
}
public static int GetScoring(Sim actor, Sim target, string scoringName, bool checkAffair, bool absolute)
{
if (actor == target)
{
return(0);
}
int score = 0;
if (scoringName == "Attraction")
{
score = (int)RelationshipEx.GetAttractionScore(actor.SimDescription, target.SimDescription, false);
}
else
{
IListedScoringMethod scoring = null;
if (checkAffair)
{
if ((actor.Partner != null) && ((target == null) || (actor.Partner != target.SimDescription)))
{
scoring = ScoringLookup.GetScoring(scoringName + "Affair");
}
else
{
scoring = ScoringLookup.GetScoring(scoringName + "Single");
}
}
else
{
scoring = ScoringLookup.GetScoring(scoringName);
}
if (scoring == null)
{
return(1);
}
if (scoring is DualSimListedScoringMethod)
{
score = scoring.IScore(new DualSimScoringParameters(target.SimDescription, actor.SimDescription, absolute));
}
else
{
score = scoring.IScore(new SimScoringParameters(actor.SimDescription, absolute));
}
}
return(score);
}
protected static void OnTimer()
{
try
{
using (Common.TestSpan span = new Common.TestSpan(ScoringLookup.Stats, "Duration STCDesire:OnTimer"))
{
ScoringLookup.UnloadCaches(false);
Common.FunctionTask.Perform(OnRecalulateDesire);
}
}
catch (Exception e)
{
Common.Exception("STCDesire:OnTimer", e);
}
}
protected void Collect(SimDescription sim)
{
if (string.IsNullOrEmpty(mScoring))
{
return;
}
SimListedScoringMethod scoring = ScoringLookup.GetScoring(mScoring) as SimListedScoringMethod;
if (scoring == null)
{
return;
}
scoring.Collect(sim);
}
public FindSimSymptom(XmlDbRow row)
: base(row)
{
mScoring = row.GetString("Scoring");
if (!string.IsNullOrEmpty(mScoring))
{
if (ScoringLookup.GetScoring(mScoring) == null)
{
BooterLogger.AddError(Guid + " Invalid Scoring: " + mScoring);
}
mMinimum = row.GetInt("Minimum", 0);
}
mAllowActive = row.GetBool("AllowActive");
}
protected override bool PrivateUpdate(ScenarioFrame frame)
{
if (!base.PrivateUpdate(frame))
{
return(false);
}
Romances.AddWoohooerNotches(Sim, Target, false, true);
Add(frame, new ExpectedMarriageScenario(Sim, Target), ScenarioResult.Start);
Add(frame, new SuccessScenario(), ScenarioResult.Start);
mNumberOfKidsBetween = NumberOfKidsBetween(Sim, Target);
AddStat("Preferred Baby Count", (ScoringLookup.GetScore("PreferredBabyCount", Sim) + ScoringLookup.GetScore("PreferredBabyCount", Target)) / 2);
return(true);
}
public override bool Test(Sim a, Computer target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
{
if (isAutonomous)
{
if (!mRandom)
{
greyedOutTooltipCallback = Common.DebugTooltip("Not Random");
return(false);
}
if (!Woohooer.Settings.mAutonomousComputer)
{
greyedOutTooltipCallback = Common.DebugTooltip("No Autonomous");
return(false);
}
if (ScoringLookup.GetScore("LikeCyberWoohoo", a.SimDescription) < 0)
{
greyedOutTooltipCallback = Common.DebugTooltip("Score Fail");
return(false);
}
List <Sim> unknown = new List <Sim>();
List <Sim> known = new List <Sim>();
GetPotentials(a, target, isAutonomous, false, unknown, known);
if ((unknown.Count + known.Count) == 0)
{
greyedOutTooltipCallback = Common.DebugTooltip("No Choices");
return(false);
}
}
else
{
if (!KamaSimtra.Settings.mShowCyberWoohooInteraction)
{
greyedOutTooltipCallback = Common.DebugTooltip("User Hidden");
return(false);
}
}
return(base.Test(a, target, isAutonomous, ref greyedOutTooltipCallback));
}
public static bool ScoreFriendly(Sim actor, Sim target, bool isAutonomous, string scoring)
{
ScoringLookup.IncStat("OnScoreFriendly Try");
if (!isAutonomous)
{
if (!Woohooer.Settings.TraitScoringForUserDirected)
{
ScoringLookup.IncStat("OnScoreFriendly Not User TraitScored");
return(true);
}
}
if (!Woohooer.Settings.UsingTraitScoring)
{
ScoringLookup.IncStat("OnScoreFriendly Not TraitScored");
return(true);
}
// Both sims interested and attracted to each other
if (!TestScoringAbsolute(target, actor, scoring, true))
{
ScoringLookup.IncStat("OnScoreFriendly " + scoring);
return(false);
}
if (!TestScoringAbsolute(target, actor, "Attraction", false))
{
ScoringLookup.IncStat("OnScoreFriendly Attraction");
return(false);
}
if (!IsSafeFromJealousy(target, actor, true))
{
ScoringLookup.IncStat("OnScoreFriendly Jealousy");
return(false);
}
ScoringLookup.IncStat("OnScoreFriendly Success");
return(true);
}
public int AddScoring(string scoring, int option, ScoringLookup.OptionType type, SimDescription sim, SimDescription other, Common.DebugLevel minLevel)
{
return AddScoring(scoring, ScoringLookup.GetScore(scoring, option, type, sim, other), minLevel);
}
public int AddScoring(string scoring, int option, ScoringLookup.OptionType type, SimDescription sim, SimDescription other)
{
return AddScoring(scoring, option, type, sim, other, Common.DebugLevel.Stats);
}
public int AddScoring(string scoring, int option, ScoringLookup.OptionType type, SimDescription sim)
{
mResult = scoring;
return mManager.AddScoring(scoring, option, type, sim);
}
public int AddScoring(string scoring, int option, ScoringLookup.OptionType type, SimDescription sim, SimDescription other, Common.DebugLevel minLevel)
{
int score = ScoringLookup.GetScore(scoring, option, type, sim, other);
if (!Common.kDebugging) return score;
return AddScoring(mName + " " + scoring, score, minLevel);
}
public int AddScoring(string scoring, int option, ScoringLookup.OptionType type, SimDescription sim)
{
int score = ScoringLookup.GetScore(scoring, option, type, sim);
if (!Common.kDebugging) return score;
return AddScoring(mName + " " + scoring, score);
}
public int AddScoring(string scoring, int option, ScoringLookup.OptionType type, SimDescription sim, SimDescription other, DebugLevel minLevel)
{
mResult = scoring;
return mManager.AddScoring(scoring, option, type, sim, other, minLevel);
}
