private new void StartJealousyBroadcaster()
{
try
{
if (mReactToSocialBroadcaster == null)
{
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
CommonWoohoo.CheckForWitnessedCheating(Actor, Actor.SynchronizationTarget, true);
}
if (mIsMaster)
{
ElevatorWooHoo linked = LinkedInteractionInstance as ElevatorWooHoo;
if (linked != null)
{
linked.StartJealousyBroadcaster();
}
}
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
}
}
private new void StartJealousyBroadcaster()
{
try
{
if (mReactToSocialBroadcaster == null)
{
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, sBroadcastParams, SocialComponentEx.ReactToJealousEventHigh);
CommonWoohoo.CheckForWitnessedCheating(Actor, Target, !Rejected);
}
if (IsMaster)
{
BedSurrogate linked = LinkedInteractionInstance as BedSurrogate;
if (linked != null)
{
linked.StartJealousyBroadcaster();
}
}
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
}
}
public static void ReactToJealousEvent(Sim s, ReactionBroadcaster rb, JealousyLevel level, bool woohoo)
{
try
{
if (!WoohooScoring.ReactsToJealousy(s))
{
return;
}
Sim broadcastingObject = rb.BroadcastingObject as Sim;
if (broadcastingObject == null)
{
return;
}
if (broadcastingObject.CurrentInteraction == null)
{
return;
}
Sim target = null;
IWooHooDefinition definition = broadcastingObject.CurrentInteraction.InteractionDefinition as IWooHooDefinition;
if (definition != null)
{
target = definition.ITarget(broadcastingObject.CurrentInteraction);
}
if (target == null)
{
target = broadcastingObject.SynchronizationTarget;
}
if (target == null)
{
Woohooer.DebugNotify("Bad Target");
return;
}
if (CommonSocials.CaresAboutJealousy(broadcastingObject, target, s, level, woohoo))
{
if ((s != broadcastingObject) && (s != target))
{
if ((target != null) && (!SocialComponentEx.CheckCheating(s, broadcastingObject, target, level)) && (!broadcastingObject.CurrentInteraction.IsRejected))
{
SocialComponentEx.CheckCheating(s, target, broadcastingObject, level);
}
}
}
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(s, e);
}
}
public new void StartReaction(Sim sim, ReactionBroadcaster broadcaster)
{
if (sim.SimDescription.ChildOrAbove)
{
sim.InteractionQueue.Add(ReactToContractionEx.Singleton.CreateInstance(mMom, sim,
new InteractionPriority(InteractionPriorityLevel.Pregnancy, -1f), true, true));
}
}
public override void Cleanup()
{
if (mReactToSocialBroadcaster != null)
{
mReactToSocialBroadcaster.Dispose();
mReactToSocialBroadcaster = null;
}
base.Cleanup();
}
public static void ReactToJealousEventMedium(Sim s, ReactionBroadcaster rb)
{
JealousyLevel level = JealousyLevel.Medium;
if (level > Woohooer.Settings.mRomanceJealousyLevel)
{
level = Woohooer.Settings.mRomanceJealousyLevel;
}
ReactToJealousEvent(s, rb, level, false);
}
public static void ReactToJealousEventMedium(Sim s, ReactionBroadcaster rb)
{
JealousyLevel level = JealousyLevel.Medium;
if (level > Woohooer.Settings.mRomanceJealousyLevel)
{
level = Woohooer.Settings.mRomanceJealousyLevel;
}
ReactToJealousEvent(s, rb, level, false);
}
public static void ReactToJealousEvent(Sim s, ReactionBroadcaster rb, JealousyLevel level, bool woohoo)
{
try
{
if (!WoohooScoring.ReactsToJealousy(s)) return;
Sim broadcastingObject = rb.BroadcastingObject as Sim;
if (broadcastingObject == null) return;
if (broadcastingObject.CurrentInteraction == null)
{
return;
}
Sim target = null;
IWooHooDefinition definition = broadcastingObject.CurrentInteraction.InteractionDefinition as IWooHooDefinition;
if (definition != null)
{
target = definition.ITarget(broadcastingObject.CurrentInteraction);
}
if (target == null)
{
target = broadcastingObject.SynchronizationTarget;
}
if (target == null)
{
Woohooer.DebugNotify("Bad Target");
return;
}
if (CommonSocials.CaresAboutJealousy(broadcastingObject, target, s, level, woohoo))
{
if ((s != broadcastingObject) && (s != target))
{
if ((target != null) && (!SocialComponentEx.CheckCheating(s, broadcastingObject, target, level)) && (!broadcastingObject.CurrentInteraction.IsRejected))
{
SocialComponentEx.CheckCheating(s, target, broadcastingObject, level);
}
}
}
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(s, e);
}
}
private void OnJealousyEvent(StateMachineClient smc, IEvent evt)
{
if (mReactToSocialBroadcasterActor == null)
{
mReactToSocialBroadcasterActor = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
CommonWoohoo.CheckForWitnessedCheating(Actor, Target, !Rejected);
}
if (mReactToSocialBroadcasterTarget == null)
{
mReactToSocialBroadcasterTarget = new ReactionBroadcaster(Target, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
CommonWoohoo.CheckForWitnessedCheating(Target, Actor, !Rejected);
}
}
public override void Dispose(BuffManager bm)
{
if (Irb != null)
{
Irb.Dispose();
Irb = null;
}
if (mEffect != null)
{
mEffect.Stop();
mEffect.Dispose();
mEffect = null;
}
base.Dispose(bm);
}
public override bool Continue(Sim mom, bool momJustCreated)
{
if (mom == null)
{
return(false);
}
if (momJustCreated)
{
mHasRequestedWalkStyle = false;
}
mMom = mom;
mDad = null;
mTimeMoodSampled = SimClock.CurrentTime();
mMom.MoodManager.MoodChanged += new MoodManager.MoodChangedCallback(MoodManager_MoodChanged);
ActiveTopic.AddToSim(mom, "Pregnancy");
if (momJustCreated)
{
PreggersAlarm = mom.AddAlarmRepeating(1f, TimeUnit.Hours, new AlarmTimerCallback(HourlyCallback), 1f, TimeUnit.Hours,
"Hourly Human Surrogate Pregnancy Update Alarm", AlarmType.AlwaysPersisted);
}
mom.SimDescription.Pregnancy = this;
int arg_C0_0 = mHourOfPregnancy;
int arg_BF_0 = kHourToShowPregnantBuff;
if (mHourOfPregnancy >= kHourToShowPregnantBuff)
{
if (mHourOfPregnancy < kHourToStartContractions)
{
mMom.BuffManager.AddElement(BuffNames.Pregnant, Origin.FromPregnancy);
}
ActiveTopic.AddToSim(mMom, "Announce Pregnancy");
}
if (mHourOfPregnancy >= kHourToStartWalkingPregnant)
{
ActiveTopic.AddToSim(mMom, "Pregnant", mMom.SimDescription);
RequestPregnantWalkStyle();
}
if (mHourOfPregnancy >= kHourToStartContractions)
{
// Add BabyIsComing moodlet here!
if (mContractionBroadcast != null)
{
mContractionBroadcast.Dispose();
}
mContractionBroadcast = new ReactionBroadcaster(mMom, kContractionBroadcasterParams,
new ReactionBroadcaster.BroadcastCallback(StartReaction), new ReactionBroadcaster.BroadcastCallback(CancelReaction));
// Add TakeToHospital interaction here!
InteractionInstance entry = HaveContraction.Singleton.CreateInstance(mMom, mMom,
new InteractionPriority(InteractionPriorityLevel.High, 10f), false, false);
mMom.InteractionQueue.Add(entry);
mContractionsAlarm = mMom.AddAlarmRepeating(5f, TimeUnit.Minutes, new AlarmTimerCallback(TriggerContraction), 5f, TimeUnit.Minutes,
"Trigger Contractions Alarm", AlarmType.AlwaysPersisted);
}
if (mHourOfPregnancy == kHoursOfPregnancy)
{
mMom.AddAlarm(1f, TimeUnit.Minutes, new AlarmTimerCallback(HaveTheBaby), "Re-have the baby", AlarmType.AlwaysPersisted);
}
SetPregoBlendShape();
if (mMom.SimDescription.IsVisuallyPregnant)
{
TryToGiveLeave();
}
return(true);
}
public override bool Run()
{
try
{
IWooHooDefinition definition = InteractionDefinition as IWooHooDefinition;
if (WoohooObject == null)
{
return(false);
}
if (!SafeToSync())
{
return(false);
}
AllInOneBathroom.WoohooInAllInOneBathroomB entry = AllInOneBathroom.WoohooInAllInOneBathroomB.Singleton.CreateInstance(Actor, Target, GetPriority(), Autonomous, CancellableByPlayer) as AllInOneBathroom.WoohooInAllInOneBathroomB;
entry.TryForBaby = TryForBaby;
entry.LinkedInteractionInstance = this;
Target.InteractionQueue.Add(entry);
Actor.SynchronizationLevel = Sim.SyncLevel.Started;
Actor.SynchronizationTarget = Target;
Actor.SynchronizationRole = Sim.SyncRole.Initiator;
if (!WoohooObject.SimLine.WaitForTurn(this, SimQueue.WaitBehavior.Default, ~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached), 10f))
{
return(false);
}
if (!Actor.RouteToSlotAndCheckInUse(WoohooObject, Slot.RoutingSlot_1))
{
return(false);
}
StandardEntry();
WoohooObject.AddToUseList(Actor);
WoohooObject.AddToUseList(Target);
BeginCommodityUpdates();
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Routed, 30f))
{
WoohooObject.RemoveFromUseList(Actor);
WoohooObject.RemoveFromUseList(Target);
EndCommodityUpdates(false);
StandardExit();
return(false);
}
EnterStateMachine("AllInOneBathroom", "Enter", "x");
SetActor("bathroom", WoohooObject);
SetActor("y", Target);
AddOneShotScriptEventHandler(0x64, AnimationCallback);
AddOneShotScriptEventHandler(0x65, AnimationCallback);
RockGemMetalBase.HandleNearbyWoohoo(Actor, RockGemMetalBase.HowMuchWooHoo.MoreWoohoo);
if (mReactToSocialBroadcasterActor == null)
{
mReactToSocialBroadcasterActor = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
}
if (mReactToSocialBroadcasterTarget == null)
{
mReactToSocialBroadcasterTarget = new ReactionBroadcaster(Target, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
}
Animate("x", "WooHoo");
List <Sim> exceptions = new List <Sim>();
exceptions.Add(Target);
WoohooObject.PushSimsFromFootprint(0x31229a4d, Actor, exceptions, true);
WoohooObject.PushSimsFromFootprint(0x31229a4e, Actor, exceptions, true);
Animate("x", "Exit");
RockGemMetalBase.HandleNearbyWoohoo(Actor, RockGemMetalBase.HowMuchWooHoo.LessWoohoo);
CommonWoohoo.RunPostWoohoo(Actor, Target, WoohooObject, definition.GetStyle(this), definition.GetLocation(WoohooObject), true);
if (CommonPregnancy.IsSuccess(Actor, Target, Autonomous, definition.GetStyle(this)))
{
Pregnancy pregnancy = CommonPregnancy.Impregnate(Actor, Target, Autonomous, definition.GetStyle(this));
if (pregnancy != null)
{
if (RandomUtil.RandomChance(AllInOneBathroom.kChanceOfHydrophobicTrait))
{
pregnancy.SetForcedBabyTrait(TraitNames.Hydrophobic);
}
}
}
WoohooObject.RemoveFromUseList(Actor);
WoohooObject.RemoveFromUseList(Target);
WoohooObject.SimLine.RemoveFromQueue(Actor);
EndCommodityUpdates(true);
StandardExit();
EventTracker.SendEvent(EventTypeId.kWooHooInAllInOneBathroom, Actor, Target);
VisitSituation situation = VisitSituation.FindVisitSituationInvolvingGuest(Actor);
VisitSituation situation2 = VisitSituation.FindVisitSituationInvolvingGuest(Target);
if ((situation != null) && (situation2 != null))
{
situation.GuestStartingInappropriateAction(Actor, 3.5f);
situation2.GuestStartingInappropriateAction(Target, 3.5f);
}
Relationship.Get(Actor, Target, true).LTR.UpdateLiking(AllInOneBathroom.kLTRGainFromWoohooInAllInOneBathroom);
return(true);
}
catch (ResetException)
{
throw;
}
catch (Exception exception)
{
Common.Exception(Actor, Target, exception);
return(false);
}
}
public override bool Run()
{
try
{
int num;
if ((WoohooObject == null) || !WoohooObject.CanWooHooIn())
{
return(false);
}
if (!SafeToSync())
{
return(false);
}
LeafPile.WoohooInPileOrStackB entry = LeafPile.WoohooInPileOrStackB.Singleton.CreateInstance(Actor, Target, GetPriority(), Autonomous, CancellableByPlayer) as LeafPile.WoohooInPileOrStackB;
entry.LinkedInteractionInstance = this;
if (!Target.InteractionQueue.Add(entry))
{
Common.DebugNotify("LeafPileBaseWoohoo Add Fail");
return(false);
}
Actor.SynchronizationLevel = Sim.SyncLevel.Started;
Actor.SynchronizationTarget = Target;
Actor.SynchronizationRole = Sim.SyncRole.Initiator;
if (!WoohooObject.SimLine.WaitForTurn(this, SimQueue.WaitBehavior.Default, ~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached), 10f))
{
return(false);
}
Slot[] routingSlots = WoohooObject.GetRoutingSlots();
if (!Actor.RouteToSlotListAndCheckInUse(WoohooObject, routingSlots, out num))
{
return(false);
}
if (!WoohooObject.CanWooHooIn())
{
return(false);
}
CommonWoohoo.TestNakedOutfit(UsingNakedOutfit, Actor, Target);
mActorXRoutingSlot = routingSlots[num];
StandardEntry();
WoohooObject.AddToUseList(Actor);
WoohooObject.AddToUseList(Target);
BeginCommodityUpdates();
EnterStateMachine(WoohooObject.JazzFileName, "Enter", "x");
AddOneShotScriptEventHandler(0x65, PlayEffectsHandlerX);
AddOneShotScriptEventHandler(0x78, AnimCallbackSimX);
SetActor(WoohooObject.JazzObjectName, WoohooObject);
Animate("x", "GetInStackX");
WoohooObject.SimLine.RemoveFromQueue(Actor);
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Routed, 30f))
{
AddOneShotScriptEventHandler(0x65, PlayEffectsHandlerX);
AddOneShotScriptEventHandler(0x66, PlayEffectsHandlerX);
AddOneShotScriptEventHandler(0x6e, AnimCallbackSimX);
AddOneShotScriptEventHandler(0x79, AnimCallbackSimX);
Animate("x", "GetOut");
Animate("x", "Exit");
WoohooObject.RemoveFromUseList(Actor);
WoohooObject.RemoveFromUseList(Target);
EndCommodityUpdates(false);
StandardExit();
return(false);
}
mActorYRoutingSlot = (Slot)(LinkedInteractionInstance as LeafPile.WoohooInPileOrStackB).RoutedSlot;
RockGemMetalBase.HandleNearbyWoohoo(Actor, RockGemMetalBase.HowMuchWooHoo.MoreWoohoo);
SetActor("y", Target);
EnterState("y", "Enter");
AddOneShotScriptEventHandler(0x65, PlayEffectsHandlerY);
AddOneShotScriptEventHandler(0x78, AnimCallbackSimY);
Animate("y", "GetInStackY");
if (mReactToSocialBroadcasterActor == null)
{
mReactToSocialBroadcasterActor = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
CommonWoohoo.CheckForWitnessedCheating(Actor, Target, true);
}
if (mReactToSocialBroadcasterTarget == null)
{
mReactToSocialBroadcasterTarget = new ReactionBroadcaster(Target, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
CommonWoohoo.CheckForWitnessedCheating(Target, Actor, true);
}
AnimateJoinSims("Woohoo");
(WoohooObject as GameObject).PushSimsFromFootprint((uint)mActorXRoutingSlot, Actor, null, true);
AddOneShotScriptEventHandler(0x65, PlayEffectsHandlerX);
AddOneShotScriptEventHandler(0x66, PlayEffectsHandlerX);
AddOneShotScriptEventHandler(0x6e, AnimCallbackSimX);
AddOneShotScriptEventHandler(0x79, AnimCallbackSimX);
AnimateJoinSims("GetOutX");
List <Sim> exceptions = new List <Sim>();
exceptions.Add(Actor);
(WoohooObject as GameObject).PushSimsFromFootprint((uint)mActorYRoutingSlot, Target, exceptions, true);
if (mActorYRoutingSlot == mActorXRoutingSlot)
{
Actor.Wander(1f, 2f, false, RouteDistancePreference.PreferFurthestFromRouteOrigin, true);
}
AddOneShotScriptEventHandler(0x65, PlayEffectsHandlerY);
AddOneShotScriptEventHandler(0x66, PlayEffectsHandlerY);
AddOneShotScriptEventHandler(0x6e, AnimCallbackSimY);
AddOneShotScriptEventHandler(0x79, AnimCallbackSimY);
AnimateJoinSims("GetOutY");
AnimateJoinSims("Exit");
RockGemMetalBase.HandleNearbyWoohoo(Actor, RockGemMetalBase.HowMuchWooHoo.LessWoohoo);
IWooHooDefinition definition = InteractionDefinition as IWooHooDefinition;
CommonWoohoo.RunPostWoohoo(Actor, Target, WoohooObject, definition.GetStyle(this), definition.GetLocation(WoohooObject), true);
if (CommonPregnancy.IsSuccess(Actor, Target, Autonomous, definition.GetStyle(this)))
{
Pregnancy pregnancy = CommonPregnancy.Impregnate(Actor, Target, Autonomous, definition.GetStyle(this));
if (pregnancy != null)
{
if (RandomUtil.RandomChance(WoohooObject.ChanceBabyGetsLovesOutdoorsTrait))
{
pregnancy.SetForcedBabyTrait(TraitNames.LovesTheOutdoors);
}
}
}
WoohooObject.RemoveFromUseList(Actor);
WoohooObject.RemoveFromUseList(Target);
EndCommodityUpdates(true);
StandardExit();
VisitSituation situation = VisitSituation.FindVisitSituationInvolvingGuest(Actor);
VisitSituation situation2 = VisitSituation.FindVisitSituationInvolvingGuest(Target);
if ((situation != null) && (situation2 != null))
{
situation.GuestStartingInappropriateAction(Actor, 3.5f);
situation2.GuestStartingInappropriateAction(Target, 3.5f);
}
if (RandomUtil.RandomChance(WoohooObject.ChanceGetRollInHayBuff))
{
Actor.BuffManager.AddElement(BuffNames.RolledInTheHay, Origin.FromWooHooInHayStack);
Target.BuffManager.AddElement(BuffNames.RolledInTheHay, Origin.FromWooHooInHayStack);
}
Relationship.Get(Actor, Target, true).LTR.UpdateLiking(WoohooObject.LTRGain);
EventTracker.SendEvent(WoohooObject.WooHooEventID, Actor, Target);
EventTracker.SendEvent(WoohooObject.WooHooEventID, Target, Actor);
return(true);
}
catch (ResetException)
{
throw;
}
catch (Exception exception)
{
Common.Exception(Actor, Target, exception);
return(false);
}
}
public static void ReactToJealousEventHigh(Sim s, ReactionBroadcaster rb)
{
ReactToJealousEvent(s, rb, Woohooer.Settings.mWoohooJealousyLevel, true);
}
public override bool Run()
{
try
{
if (!Actor.Inventory.Contains(Target))
{
if (!Actor.RouteToObjectRadiusAndCheckInUse(Target, 0.7f))
{
return false;
}
StandardEntry();
BeginCommodityUpdates();
Actor.PlaySoloAnimation("a2o_object_genericSwipe_x", true);
if (!Actor.Inventory.TryToAdd(Target))
{
EndCommodityUpdates(false);
StandardExit();
return false;
}
}
else
{
StandardEntry();
BeginCommodityUpdates();
}
SocialJigTwoPerson person = GlobalFunctions.CreateObjectOutOfWorld(SocialJig.SocialJigMedatorNames.SocialJigTwoPerson.ToString()) as SocialJigTwoPerson;
person.RegisterParticipants(Actor, null);
Sim createdSim = null;
try
{
World.FindGoodLocationParams fglParams = new World.FindGoodLocationParams(Actor.Position);
fglParams.BooleanConstraints |= FindGoodLocationBooleans.Routable;
if (GlobalFunctions.PlaceAtGoodLocation(person, fglParams, true))
{
Route r = Actor.CreateRoute();
r.PlanToSlot(person, person.GetSlotForActor(Actor, true));
r.DoRouteFail = true;
if (Actor.DoRoute(r))
{
bool paramValue = false;
mSummonGenieBroadcast = new ReactionBroadcaster(Actor, kSummonGenieBroadcastParams, SummonGenieBroadcastCallback);
Sims3.Gameplay.Gameflow.SetGameSpeed(Sims3.Gameplay.Gameflow.GameSpeed.Normal, Sims3.Gameplay.Gameflow.SetGameSpeedContext.Gameplay);
if (Target.mGenieDescription == null)
{
Target.mGenieDescription = OccultGenie.CreateGenie(Actor, Target);
createdSim = Target.mGenieDescription.CreatedSim;
EventTracker.SendEvent(EventTypeId.kCleanLamp, Actor, Target);
paramValue = true;
}
else
{
createdSim = Target.mGenieDescription.Instantiate(Vector3.OutOfWorld, false);
OccultGenie occultType = null;
DateAndTime previousDateAndTime = SimClock.CurrentTime();
do
{
SpeedTrap.Sleep(0xa);
occultType = createdSim.OccultManager.GetOccultType(OccultTypes.None | OccultTypes.Genie) as OccultGenie;
}
while ((occultType == null) && (SimClock.ElapsedTime(TimeUnit.Minutes, previousDateAndTime) < 120f));
if (occultType != null)
{
occultType.SetGenieLampRelations(Actor, createdSim, Target);
}
else
{
createdSim.Destroy();
createdSim = null;
}
}
if (createdSim != null)
{
createdSim.FadeOut(false, false, 0f);
createdSim.GreetSimOnLot(Actor.LotCurrent);
createdSim.AddToWorld();
Slot slotForActor = person.GetSlotForActor(createdSim, false);
createdSim.SetPosition(person.GetSlotPosition(slotForActor));
createdSim.SetForward(person.GetForwardOfSlot(slotForActor));
IGameObject actor = GlobalFunctions.CreateObject("GenieLamp", ProductVersion.EP6, Vector3.OutOfWorld, 0x0, Vector3.UnitZ, null, null);
if (!actor.IsActorUsingMe(Actor))
{
actor.AddToUseList(Actor);
}
EnterStateMachine("GenieLampSummon", "Enter", "x");
SetActor("lamp", actor);
SetParameter("isFirstTime", paramValue);
AnimateSim("Exit");
actor.Destroy();
createdSim.FadeIn();
VisualEffect effect = VisualEffect.Create("ep6GenieAppearSmoke_main");
effect.SetPosAndOrient(createdSim.Position, Vector3.UnitX, Vector3.UnitZ);
effect.SubmitOneShotEffect(VisualEffect.TransitionType.SoftTransition);
OpportunityManager opportunityManager = Actor.OpportunityManager;
if ((opportunityManager != null) && opportunityManager.HasOpportunity(OpportunityNames.EP6_ReleaseGenie_SummonGenie))
{
OccultGenie genie2 = createdSim.OccultManager.GetOccultType(OccultTypes.Genie) as OccultGenie;
if (genie2 == null)
{
createdSim.Destroy();
createdSim = null;
}
else
{
OccultGenieEx.OnFreedFromLamp(genie2, Actor, createdSim, true);
if (opportunityManager.GetLastOpportunity(OpportunityCategory.Special) == OpportunityNames.EP6_ReleaseGenie_SummonGenie)
{
opportunityManager.ClearLastOpportunity(OpportunityCategory.Special);
}
EventTracker.SendEvent(EventTypeId.kGrantedWishToFreeGenie, Actor, Target);
if (Target.InInventory)
{
Actor.Inventory.RemoveByForce(Target);
if (Target.IsOnHandTool)
{
Target.RemoveFromWorld();
}
}
else
{
Target.RemoveFromWorld();
}
EnterStateMachine("FreeTheGenie", "Enter", "x");
SetActor("x", createdSim);
AnimateSim("Exit");
}
}
else
{
Target.mGenieSocializingEvent = EventTracker.AddListener(EventTypeId.kSocialInteraction, OnSocialization);
Target.CheckGenieReturnToLamp = createdSim.AddAlarmRepeating(1f, TimeUnit.Minutes, Target.CheckGenieReturnToLampCallback, "Genie Check to return to lamp", AlarmType.AlwaysPersisted);
Target.mTimeSinceLastSocialWithGenie = SimClock.CurrentTime();
}
}
}
}
}
finally
{
person.Destroy();
}
EndCommodityUpdates(true);
StandardExit(createdSim == null, createdSim == null);
return true;
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return false;
}
}
public override bool Run()
{
try
{
SetPriority(new InteractionPriority(InteractionPriorityLevel.Zero));
Cancelled = false;
if (!StartSync(IsMaster, true))
{
return(false);
}
// Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventMedium);
CommonWoohoo.CheckForWitnessedCheating(Actor, Target, !Rejected);
if (IsMaster)
{
//StartSocialContext();
Actor.SocialComponent.StartSocializingWith(Target);
InitiateSocialUI(Actor, Target);
if (mCurrentStateMachine == null)
{
BedMultiPart container = Actor.Posture.Container as BedMultiPart;
EnterStateMachine("BedSocials", "FromRelax", "x", "y");
SetActor("bed", container);
SetActorsAndParameters();
mCurrentStateMachine.EnterState("y", "FromRelax");
mCurrentStateMachine.RequestState(false, "x", "Cuddle");
mCurrentStateMachine.RequestState(true, "y", "Cuddle");
FinishSocial("Cuddle", true);
}
else
{
mCurrentStateMachine.RequestState(null, "Cuddle");
}
}
StandardEntry(false);
EnsureLinkedInteraction();
BeginCommodityUpdates();
Actor.BuffManager.RemoveElement(BuffNames.Lonely);
bool succeeded = DoLoop();
bool flag2 = true;
if (Actor.HasExitReason(ExitReason.HigherPriorityNext))
{
CopyExitReasonToLinkedInteraction();
flag2 = OnHigherPriorityNext();
}
if (flag2)
{
ForceExitNested = true;
}
if (IsMaster && flag2)
{
mCurrentStateMachine.RequestState(null, "ToRelax");
}
FinishLinkedInteraction(IsMaster);
EndCommodityUpdates(succeeded);
StandardExit(false, false);
WaitForSyncComplete();
return(succeeded);
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return(false);
}
}
public override bool Run()
{
try
{
if (!Actor.Inventory.Contains(Target))
{
if (!Actor.RouteToObjectRadiusAndCheckInUse(Target, 0.7f))
{
return(false);
}
StandardEntry();
BeginCommodityUpdates();
Actor.PlaySoloAnimation("a2o_object_genericSwipe_x", true);
if (!Actor.Inventory.TryToAdd(Target))
{
EndCommodityUpdates(false);
StandardExit();
return(false);
}
}
else
{
StandardEntry();
BeginCommodityUpdates();
}
SocialJigTwoPerson person = GlobalFunctions.CreateObjectOutOfWorld(SocialJig.SocialJigMedatorNames.SocialJigTwoPerson.ToString()) as SocialJigTwoPerson;
person.RegisterParticipants(Actor, null);
Sim createdSim = null;
try
{
World.FindGoodLocationParams fglParams = new World.FindGoodLocationParams(Actor.Position);
fglParams.BooleanConstraints |= FindGoodLocationBooleans.Routable;
if (GlobalFunctions.PlaceAtGoodLocation(person, fglParams, true))
{
Route r = Actor.CreateRoute();
r.PlanToSlot(person, person.GetSlotForActor(Actor, true));
r.DoRouteFail = true;
if (Actor.DoRoute(r))
{
bool paramValue = false;
mSummonGenieBroadcast = new ReactionBroadcaster(Actor, kSummonGenieBroadcastParams, SummonGenieBroadcastCallback);
Sims3.Gameplay.Gameflow.SetGameSpeed(Sims3.Gameplay.Gameflow.GameSpeed.Normal, Sims3.Gameplay.Gameflow.SetGameSpeedContext.Gameplay);
if (Target.mGenieDescription == null)
{
Target.mGenieDescription = OccultGenie.CreateGenie(Actor, Target);
createdSim = Target.mGenieDescription.CreatedSim;
EventTracker.SendEvent(EventTypeId.kCleanLamp, Actor, Target);
paramValue = true;
}
else
{
createdSim = Target.mGenieDescription.Instantiate(Vector3.OutOfWorld, false);
OccultGenie occultType = null;
DateAndTime previousDateAndTime = SimClock.CurrentTime();
do
{
SpeedTrap.Sleep(0xa);
occultType = createdSim.OccultManager.GetOccultType(OccultTypes.None | OccultTypes.Genie) as OccultGenie;
}while ((occultType == null) && (SimClock.ElapsedTime(TimeUnit.Minutes, previousDateAndTime) < 120f));
if (occultType != null)
{
occultType.SetGenieLampRelations(Actor, createdSim, Target);
}
else
{
createdSim.Destroy();
createdSim = null;
}
}
if (createdSim != null)
{
createdSim.FadeOut(false, false, 0f);
createdSim.GreetSimOnLot(Actor.LotCurrent);
createdSim.AddToWorld();
Slot slotForActor = person.GetSlotForActor(createdSim, false);
createdSim.SetPosition(person.GetSlotPosition(slotForActor));
createdSim.SetForward(person.GetForwardOfSlot(slotForActor));
IGameObject actor = GlobalFunctions.CreateObject("GenieLamp", ProductVersion.EP6, Vector3.OutOfWorld, 0x0, Vector3.UnitZ, null, null);
if (!actor.IsActorUsingMe(Actor))
{
actor.AddToUseList(Actor);
}
EnterStateMachine("GenieLampSummon", "Enter", "x");
SetActor("lamp", actor);
SetParameter("isFirstTime", paramValue);
AnimateSim("Exit");
actor.Destroy();
createdSim.FadeIn();
VisualEffect effect = VisualEffect.Create("ep6GenieAppearSmoke_main");
effect.SetPosAndOrient(createdSim.Position, Vector3.UnitX, Vector3.UnitZ);
effect.SubmitOneShotEffect(VisualEffect.TransitionType.SoftTransition);
OpportunityManager opportunityManager = Actor.OpportunityManager;
if ((opportunityManager != null) && opportunityManager.HasOpportunity(OpportunityNames.EP6_ReleaseGenie_SummonGenie))
{
OccultGenie genie2 = createdSim.OccultManager.GetOccultType(OccultTypes.Genie) as OccultGenie;
if (genie2 == null)
{
createdSim.Destroy();
createdSim = null;
}
else
{
OccultGenieEx.OnFreedFromLamp(genie2, Actor, createdSim, true);
if (opportunityManager.GetLastOpportunity(OpportunityCategory.Special) == OpportunityNames.EP6_ReleaseGenie_SummonGenie)
{
opportunityManager.ClearLastOpportunity(OpportunityCategory.Special);
}
EventTracker.SendEvent(EventTypeId.kGrantedWishToFreeGenie, Actor, Target);
if (Target.InInventory)
{
Actor.Inventory.RemoveByForce(Target);
if (Target.IsOnHandTool)
{
Target.RemoveFromWorld();
}
}
else
{
Target.RemoveFromWorld();
}
EnterStateMachine("FreeTheGenie", "Enter", "x");
SetActor("x", createdSim);
AnimateSim("Exit");
}
}
else
{
Target.mGenieSocializingEvent = EventTracker.AddListener(EventTypeId.kSocialInteraction, OnSocialization);
Target.CheckGenieReturnToLamp = createdSim.AddAlarmRepeating(1f, TimeUnit.Minutes, Target.CheckGenieReturnToLampCallback, "Genie Check to return to lamp", AlarmType.AlwaysPersisted);
Target.mTimeSinceLastSocialWithGenie = SimClock.CurrentTime();
}
}
}
}
}
finally
{
person.Destroy();
}
EndCommodityUpdates(true);
StandardExit(createdSim == null, createdSim == null);
return(true);
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return(false);
}
}
public override bool Run()
{
try
{
if (!StartSync())
{
return(false);
}
StandardEntry(false);
BeginCommodityUpdates();
if (IsMaster)
{
ReturnInstance.EnsureMaster();
StartSocial("Kiss");
InitiateSocialUI(Actor, Target);
(LinkedInteractionInstance as NestedCuddleInteraction).Rejected = Rejected;
// Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventMedium);
//SocialComponent.SendCheatingEvents(Actor, Target, !Rejected);
if (Rejected)
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "KissReject");
ReturnInstance.mCurrentStateMachine.RequestState(null, "ExitSitting");
FinishSocial("Kiss", true);
FinishSocialContext();
}
else
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "Kiss");
FinishSocial("Kiss", true);
}
}
else
{
DoLoop(~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
}
FinishLinkedInteraction(IsMaster);
EndCommodityUpdates(!Rejected);
StandardExit(false, false);
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Actor, Target, "Kiss", !IsMaster, !Rejected, false, CommodityTypes.Undefined));
if (Rejected)
{
InvokeDoResumeOnCleanup = false;
}
else
{
Actor.SimDescription.SetFirstKiss(Target.SimDescription);
if (SimClock.IsNightTime() && SimClock.IsFullMoon())
{
Actor.BuffManager.AddElement(BuffNames.KissedUnderFullMoon, Origin.None);
EventTracker.SendEvent(EventTypeId.kKissedUnderFullMoon, Actor);
}
}
WaitForSyncComplete();
return(!Rejected);
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return(false);
}
}
public override bool Run()
{
if (!SafeToSync())
{
return(false);
}
skillActor = Actor.SkillManager.GetSkill <EWPetFightingSkill>(EWPetFightingSkill.skillNameID);
if (skillActor == null)
{
skillActor = Actor.SkillManager.AddElement(EWPetFightingSkill.skillNameID)
as EWPetFightingSkill;
if (skillActor == null)
{
return(false);
}
}
skillTarget = Target.SkillManager.GetSkill <EWPetFightingSkill>(EWPetFightingSkill.skillNameID);
if (skillTarget == null)
{
skillTarget = Actor.SkillManager.AddElement(EWPetFightingSkill.skillNameID)
as EWPetFightingSkill;
if (skillTarget == null)
{
return(false);
}
}
skillActor.StartSkillGain(skillActor.getSkillGainRate(Actor));
skillTarget.StartSkillGain(skillTarget.getSkillGainRate(Target));
BeginCommodityUpdates();
Actor.RequestWalkStyle(WalkStyle.PetRun);
if (!BeginSocialInteraction(new SocialInteractionB.Definition(null, GetInteractionName(),
allowCarryChild: false), pairedSocial: true, doCallOver: false))
{
if (Actor.IsCat)
{
Actor.UnrequestWalkStyle(WalkStyle.CatStalk);
PouncePosture pouncePosture2 = Actor.Posture as PouncePosture;
if (pouncePosture2 != null)
{
pouncePosture2.ExitPounce();
Actor.PopPosture();
}
}
else
{
Actor.UnrequestWalkStyle(WalkStyle.PetRun);
}
EndCommodityUpdates(false);
return(false);
}
Actor.UnrequestWalkStyle(WalkStyle.PetRun);
if (Actor.IsCat)
{
PouncePosture pouncePosture = PouncePosture.Create(Actor);
pouncePosture.EnterPounce();
Actor.Posture = pouncePosture;
}
StandardEntry(addToUseList: false);
StartSocial("Fight Pet");
((SocialInteraction)LinkedInteractionInstance).Rejected = Rejected;
mPetFightNoiseBroadcast = new ReactionBroadcaster(Actor, kPetFightLoudBroadcastParams,
FightBroadcastCallback);
PetStartleBehavior.CheckForStartle(Actor, StartleType.Fight);
EnterStateMachine("PetFight", "Enter", "x");
SetActor("y", Target);
AnimateSim("Loop Fight");
// TODO: A fight should reduce fatigue
InteractionTuning tuning = InteractionObjectPair.Tuning;
if (tuning != null && tuning.mTradeoff != null)
{
using (List <CommodityChange> .Enumerator enumerator = tuning.mTradeoff.mOutputs.GetEnumerator())
{
if (enumerator.MoveNext())
{
CommodityChange current = enumerator.Current;
if (current.Commodity == CommodityKind.CatScratch)
{
LinkedInteractionInstance.BeginCommodityUpdate(current, 1f);
}
}
}
}
bool success = DoTimedLoop(RandomUtil.GetFloat(kPetFightTimeMinMax[0], kPetFightTimeMinMax[1]),
ExitReason.Default);
EndCommodityUpdates(success);
Actor.Motives.SetValue(CommodityKind.Energy, Actor.Motives.GetMotiveValue(CommodityKind.Energy - 200));
LinkedInteractionInstance.EndCommodityUpdates(success);
bool actorWon = DoesActorWinFight();
if (!actorWon)
{
AnimateSim("Swap");
SetActor("x", Target);
SetActor("y", Actor);
skillTarget.wonFight(Actor, Target.LotCurrent == Target.LotHome);
skillActor.lostFight(Target);
skillTarget.AddPoints(200f, true, true);
Actor.ShowTNSIfSelectable(Localization.LocalizeString("Echoweaver/PetFighting/EWFightPet:PetFightLose",
Actor.Name), StyledNotification.NotificationStyle.kGameMessageNegative);
}
else
{
skillActor.wonFight(Target, Actor.LotCurrent == Actor.LotHome);
skillTarget.lostFight(Actor);
Actor.ShowTNSIfSelectable(Localization.LocalizeString("Echoweaver/PetFighting/EWFightPet:PetFightWin",
Actor.Name), StyledNotification.NotificationStyle.kGameMessagePositive);
}
AnimateSim("Exit");
if (Actor.IsCat)
{
Actor.UnrequestWalkStyle(WalkStyle.CatStalk);
if (Actor.Posture is PouncePosture)
{
Actor.PopPosture();
}
}
else
{
Actor.UnrequestWalkStyle(WalkStyle.PetRun);
}
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Actor, Target, "Fight Pet", wasRecipient: false, wasAccepted: true, actorWon, CommodityTypes.Undefined));
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Target, Actor, "Fight Pet", wasRecipient: true, wasAccepted: true, !actorWon, CommodityTypes.Undefined));
if (mPetFightNoiseBroadcast != null)
{
mPetFightNoiseBroadcast.EndBroadcast();
mPetFightNoiseBroadcast = null;
}
FinishSocial("Fight Pet", bApplySocialEffect: true);
skillActor.StopSkillGain();
skillTarget.StopSkillGain();
FinishLinkedInteraction();
WaitForSyncComplete();
StandardExit(removeFromUseList: false);
LikingChange();
// Check for death conditions BEFORE new wounds assigned
CheckForDeath(actorWon);
AssignFightWounds();
// If this is called from ChaseOffLot, then the target will flee if it loses
if (!actorWon && actorRunOnLose && Actor.LotCurrent != Actor.LotHome)
{
Actor.PopPosture();
Actor.RequestWalkStyle(WalkStyle.PetRun);
MakeSimGoHome(Actor, false);
}
else if (actorWon && targetRunOnLose && Target.LotCurrent != Target.LotHome)
{
Target.PopPosture();
if (Target.IsHuman)
{
Target.RequestWalkStyle(WalkStyle.MeanChasedRun);
}
else
{
Target.RequestWalkStyle(WalkStyle.PetRun);
}
MakeSimGoHome(Target, false);
}
return(success);
}
public override bool Run()
{
try
{
SetPriority(new InteractionPriority(InteractionPriorityLevel.Zero));
Cancelled = false;
if (!StartSync(IsMaster, true))
{
return false;
}
// Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventMedium);
CommonWoohoo.CheckForWitnessedCheating(Actor, Target, !Rejected);
if (IsMaster)
{
//StartSocialContext();
Actor.SocialComponent.StartSocializingWith(Target);
InitiateSocialUI(Actor, Target);
if (mCurrentStateMachine == null)
{
BedMultiPart container = Actor.Posture.Container as BedMultiPart;
EnterStateMachine("BedSocials", "FromRelax", "x", "y");
SetActor("bed", container);
SetActorsAndParameters();
mCurrentStateMachine.EnterState("y", "FromRelax");
mCurrentStateMachine.RequestState(false, "x", "Cuddle");
mCurrentStateMachine.RequestState(true, "y", "Cuddle");
FinishSocial("Cuddle", true);
}
else
{
mCurrentStateMachine.RequestState(null, "Cuddle");
}
}
StandardEntry(false);
EnsureLinkedInteraction();
BeginCommodityUpdates();
Actor.BuffManager.RemoveElement(BuffNames.Lonely);
bool succeeded = DoLoop();
bool flag2 = true;
if (Actor.HasExitReason(ExitReason.HigherPriorityNext))
{
CopyExitReasonToLinkedInteraction();
flag2 = OnHigherPriorityNext();
}
if (flag2)
{
ForceExitNested = true;
}
if (IsMaster && flag2)
{
mCurrentStateMachine.RequestState(null, "ToRelax");
}
FinishLinkedInteraction(IsMaster);
EndCommodityUpdates(succeeded);
StandardExit(false, false);
WaitForSyncComplete();
return succeeded;
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return false;
}
}
public override bool Run()
{
try
{
if (!StartSync())
{
return false;
}
// Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
//SocialComponent.SendCheatingEvents(Actor, Target, !Rejected);
StandardEntry(false);
BeginCommodityUpdates();
HeartShapedBed container = Actor.Posture.Container as HeartShapedBed;
bool isVibrating = container.IsVibrating;
if (IsMaster)
{
ReturnInstance.EnsureMaster();
StartSocial("Vibrate Bed");
InitiateSocialUI(Actor, Target);
container.SetVibration(Actor, !isVibrating);
if (isVibrating)
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "Vibrate Stop");
}
else
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "Vibrate");
}
FinishSocial("Vibrate Bed", true);
}
else
{
DoLoop(~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
}
DoResume();
FinishLinkedInteraction(IsMaster);
EndCommodityUpdates(!isVibrating);
StandardExit(false, false);
WaitForSyncComplete();
if (isVibrating)
{
if (RandomUtil.RandomChance(kSimGetsNegativeBuff))
{
Actor.BuffManager.AddElement(BuffNames.Nauseous, Origin.FromVibratingBed);
}
else if (RandomUtil.RandomChance(kSimGetsPositiveBuff))
{
if (Actor.TraitManager.HasAnyElement(new TraitNames[] { TraitNames.Childish, TraitNames.Insane }))
{
Actor.BuffManager.AddElement(BuffNames.Amused, Origin.FromVibratingBed);
}
else if (Actor.TraitManager.HasAnyElement(new TraitNames[] { TraitNames.PartyAnimal, TraitNames.Flirty }) || Actor.BuffManager.HasElement(BuffNames.Blizzard))
{
Actor.BuffManager.AddElement(BuffNames.Excited, Origin.FromVibratingBed);
}
}
}
return true;
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return false;
}
}
public override bool Run()
{
try
{
if (!StartSync())
{
return false;
}
StandardEntry(false);
BeginCommodityUpdates();
if (IsMaster)
{
ReturnInstance.EnsureMaster();
StartSocial("Make Out");
InitiateSocialUI(Actor, Target);
(LinkedInteractionInstance as NestedCuddleInteraction).Rejected = Rejected;
//Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
//SocialComponent.SendCheatingEvents(Actor, Target, !Rejected);
IHasSeatingGroup container = Actor.Posture.Container as IHasSeatingGroup;
Seat seat = container.SeatingGroup[Actor];
ReturnInstance.mCurrentStateMachine.SetParameter("IsHottub", seat is IHotTubSeat);
if (Rejected)
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "MakeOutReject");
ReturnInstance.mCurrentStateMachine.RequestState(null, "ExitSitting");
FinishSocial("Make Out", true);
FinishSocialContext();
}
else
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "MakeOut");
StartStages();
DoLoop(~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
FinishSocial("Make Out", true);
}
}
else
{
DoLoop(~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
}
FinishLinkedInteraction(IsMaster);
EndCommodityUpdates(!Rejected);
StandardExit(false, false);
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Actor, Target, "Make Out", !IsMaster, !Rejected, false, CommodityTypes.Undefined));
EventTracker.SendEvent(EventTypeId.kMadeOut, Actor, Target);
if (Rejected)
{
InvokeDoResumeOnCleanup = false;
}
else
{
Actor.SimDescription.SetFirstKiss(Target.SimDescription);
}
WaitForSyncComplete();
return !Rejected;
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return false;
}
}
public static void ReactToJealousEventHigh(Sim s, ReactionBroadcaster rb)
{
ReactToJealousEvent(s, rb, Woohooer.Settings.mWoohooJealousyLevel, true);
}
public void Perform(Sim sim, ReactionBroadcaster broadcaster)
{
PoolEx.ReactIfSimIsTeenOrBelow(sim, mHotTub.GetSkinnyDippers());
}
public override bool Run()
{
try
{
Definition interactionDefinition = InteractionDefinition as Definition;
if (interactionDefinition == null)
{
return(false);
}
if (Autonomous && (interactionDefinition.mUsageType == BusinessPlanning.None))
{
interactionDefinition.mUsageType = (BusinessPlanning)RandomUtil.GetInt(0, 1);
}
IInteractionNameCanBeOverriden overriden = this;
if (overriden != null)
{
overriden.SetInteractionName(interactionDefinition.GetAutonomousInteractionName());
UpdateCaption = true;
}
if (this.mRunFromInventory && Actor.Inventory.Contains(Target))
{
Vector3 vector;
Vector3 vector2;
FindGoodLocationBooleans constraints = FindGoodLocationBooleans.Routable | FindGoodLocationBooleans.PreferEmptyTiles;
World.FindGoodLocationParams fglParams = new World.FindGoodLocationParams(Actor.Position, constraints);
if (!GlobalFunctions.FindGoodLocation(Target, fglParams, out vector, out vector2))
{
return(false);
}
Actor.Inventory.TryToRemove(Target);
Target.SetPosition(vector);
Target.SetForward(vector2);
Target.AddToWorld();
Target.SetOpacity(0f, 0f);
}
if (!Target.Line.WaitForTurn(this, SimQueue.WaitBehavior.Default, ~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached), AcademicBusinessPlanner.kTimeToWaitInLine))
{
Actor.Inventory.TryToAdd(Target);
return(false);
}
if (!Actor.RouteToSlotAndCheckInUse(Target, Slot.RoutingSlot_0))
{
Actor.Inventory.TryToAdd(Target);
return(false);
}
StandardEntry();
Target.EnableFootprintAndPushSims(AcademicBusinessPlanner.sFootprintHash, Actor);
if (this.mRunFromInventory)
{
Actor.PlaySoloAnimation("a2o_object_genericSwipe_x", true);
Target.SetOpacityTransition(0f, 1f, 1f);
}
AcquireStateMachine("BusinessPlanner");
SetActor("x", Actor);
SetActor("planner", Target);
List <AcademicDegreeNames> namesNeeded = new List <AcademicDegreeNames>();
namesNeeded.Add(AcademicDegreeNames.Business);
BeginCommodityUpdatesAccountingForAcademicPerformance(namesNeeded);
Target.mCurrentBusinessPlanningType = interactionDefinition.mUsageType;
mCurrentStateMachine.EnterState("x", "Enter");
if (!Target.PlannerIsOpen)
{
AnimateSim("Open");
Target.PlannerIsOpen = true;
}
float kXPIncreasePerWorking = 0f;
ReactionBroadcaster broadcaster = null;
if (interactionDefinition.mUsageType == BusinessPlanning.WorkOnBusinessPlan)
{
AnimateSim("Work");
this.mWaitTime = RandomUtil.GetFloat(kMinWorkLength, kMaxWorkLength);
kXPIncreasePerWorking = AcademicBusinessPlanner.UseBusinessPlanner.kXPIncreasePerWorking;
}
else
{
AnimateSim("Practice");
this.mWaitTime = RandomUtil.GetFloat(kMinPresentationLength, kMaxPresentationLength);
kXPIncreasePerWorking = kXPIncreasePerPresentation;
broadcaster = new ReactionBroadcaster(Target, kPresentationBroadcastParams, new ReactionBroadcaster.BroadcastCallback(this.BroadcastCallback));
}
DoTimedLoop(this.mWaitTime, ~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
bool flag2 = false;
foreach (InteractionInstance instance in Actor.InteractionQueue.InteractionList)
{
if ((instance != this) && (instance is AcademicBusinessPlanner.UseBusinessPlanner))
{
flag2 = true;
break;
}
}
if (!flag2 && Target.PlannerIsOpen)
{
AnimateSim("Close");
Target.PlannerIsOpen = false;
}
AnimateSim("Exit");
Target.DisableFootprint(AcademicBusinessPlanner.sFootprintHash);
EndCommodityUpdates(true);
StandardExit();
if (!Actor.HasExitReason(ExitReason.Canceled))
{
if (interactionDefinition.mUsageType == BusinessPlanning.PresentBusinessPlan)
{
EventTracker.SendEvent(EventTypeId.kPresentedBusinessPlan, Actor, Target.LotCurrent);
}
else if (interactionDefinition.mUsageType == BusinessPlanning.WorkOnBusinessPlan)
{
EventTracker.SendEvent(EventTypeId.kWorkedOnBusinessPlan, Actor, Target.LotCurrent);
}
}
if (broadcaster != null)
{
broadcaster.EndBroadcast();
broadcaster.Dispose();
broadcaster = null;
}
// Custom, removed IsUniversityWorld() check
Business occupationAsCareer = Actor.OccupationAsCareer as Business;
if (occupationAsCareer != null)
{
occupationAsCareer.UpdatePerformanceOrExperience(kXPIncreasePerWorking);
}
AcademicCareer occupationAsAcademicCareer = Actor.OccupationAsAcademicCareer;
if (((occupationAsAcademicCareer != null) && (occupationAsAcademicCareer.DegreeInformation != null)) && (occupationAsAcademicCareer.DegreeInformation.AcademicDegreeName == AcademicDegreeNames.Business))
{
occupationAsAcademicCareer.UpdatePerformanceOrExperience(kXPIncreasePerWorking);
}
if (!Target.PlannerIsOpen)
{
Actor.WaitForExitReason(2f, ~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
if (!Actor.Inventory.Contains(Target))
{
Actor.PlaySoloAnimation("a2o_object_genericSwipe_x", true);
Actor.Inventory.TryToAdd(Target);
}
}
return(true);
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return(false);
}
}
public void Perform(Sim sim, ReactionBroadcaster broadcaster)
{
PoolEx.ReactToSkinnyDippers(sim, mHotTub, HotTubBase.GetIn.SkinnyDipSingleton, mHotTub.GetSkinnyDippers());
}
public void Perform(Sim sim, ReactionBroadcaster broadcaster)
{
ReactIfSimIsTeenOrBelow(sim, mPool.mSkinnyDipperList);
}
public override bool Run()
{
try
{
if (!StartSync())
{
return false;
}
// Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
//SocialComponent.SendCheatingEvents(Actor, Target, !Rejected);
StandardEntry(false);
BeginCommodityUpdates();
if (IsMaster)
{
ReturnInstance.EnsureMaster();
StartSocial("Make Out");
InitiateSocialUI(Actor, Target);
(LinkedInteractionInstance as NestedRelaxingInteraction).Rejected = Rejected;
if (Rejected)
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "MakeOutReject");
ReturnInstance.mCurrentStateMachine.RequestState(null, "ToRelax");
FinishSocial("Make Out", true);
}
else
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "MakeOut");
StartStages();
if ((Actor.Posture.Container as Bed).IsTent)
{
ThoughtBalloonManager.BalloonData bd = new ThoughtBalloonManager.BalloonData("balloon_lips");
Actor.ThoughtBalloonManager.ShowBalloon(bd);
Target.ThoughtBalloonManager.ShowBalloon(bd);
}
DoLoop(~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
FinishSocial("Make Out", true);
}
}
else
{
DoLoop(~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
}
FinishLinkedInteraction(IsMaster);
EndCommodityUpdates(!Rejected);
StandardExit(false, false);
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Actor, Target, "Make Out", !IsMaster, !Rejected, false, CommodityTypes.Undefined));
if (!Rejected)
{
Actor.SimDescription.SetFirstKiss(Target.SimDescription);
DoResume();
}
WaitForSyncComplete();
return !Rejected;
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return false;
}
}
public override bool Run()
{
try
{
Actor.GreetSimOnMyLotIfPossible(Target);
Seat.EnsureLivingChairPosture(Actor);
IHasSeatingGroup container = Actor.Posture.Container as IHasSeatingGroup;
Seat otherSeat = container.SeatingGroup[Actor];
Seat seat2 = container.SeatingGroup[Target];
if (!SafeToSync())
{
return(false);
}
Actor.LookAtManager.SetInteractionLookAt(Target, kTargetLookAtPriority, LookAtJointFilter.TorsoBones);
if ((seat2 != null) && !seat2.IsAdjacentTo(otherSeat))
{
Seat emptyAdjacentSeat = seat2.GetEmptyAdjacentSeat(Actor);
if (emptyAdjacentSeat != null)
{
InteractionInstance instance = otherSeat.CreateChangeSeatInteraction(emptyAdjacentSeat, GetPriority(), Autonomous, CancellableByPlayer);
SaunaClassic.StartSaunaSeatedCuddleA ea = Singleton.CreateInstance(Target, Actor, GetPriority(), Autonomous, CancellableByPlayer) as SaunaClassic.StartSaunaSeatedCuddleA;
Actor.InteractionQueue.PushAsContinuation(instance, true);
Actor.InteractionQueue.PushAsContinuation(ea, true);
return(true);
}
return(false);
}
SaunaClassic.StartSaunaSeatedCuddleB entry = SaunaClassic.StartSaunaSeatedCuddleB.Singleton.CreateInstance(Actor, Target, GetPriority(), false, CancellableByPlayer) as SaunaClassic.StartSaunaSeatedCuddleB;
entry.SeatX = otherSeat;
entry.SeatY = seat2;
LinkedInteractionInstance = entry;
Target.InteractionQueue.Add(entry);
// Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventMedium);
//SocialComponent.SendCheatingEvents(Actor, Target, !Rejected);
Actor.SynchronizationRole = Sim.SyncRole.Initiator;
Actor.SynchronizationLevel = Sim.SyncLevel.Started;
Actor.SynchronizationTarget = Target;
Target.SynchronizationLevel = Sim.SyncLevel.NotStarted;
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Started, (float)kHowLongToWaitForOtherToArrive))
{
return(false);
}
StartSocial("Cuddle");
entry.Reject = Rejected;
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Routed, (float)kHowLongToWaitForOtherToArrive))
{
return(false);
}
if (Rejected)
{
if (Seat.SimsAreAdjacent(Actor, Target))
{
Seat.EnsureLivingChairPosture(Target);
bool paramValue = seat2 == otherSeat.Right;
EnterStateMachine("SeatingCuddle", "EnterSitting", "x", "y");
mCurrentStateMachine.EnterState("y", "EnterSitting");
mCurrentStateMachine.EnterState("SeatX", "EnterSitting");
mCurrentStateMachine.EnterState("SeatY", "EnterSitting");
SetActor("SeatX", otherSeat.Host);
SetParameter("SuffixX", otherSeat.IKSuffix);
SetActor("SeatY", seat2.Host);
SetParameter("SuffixY", seat2.IKSuffix);
SetActor("surface", otherSeat.Host);
SetParameter("IsMirrored", paramValue);
bool flag2 = otherSeat is IHotTubSeat;
SetParameter("IsHottub", flag2);
mCurrentStateMachine.RequestState(false, "x", "CuddleReject");
mCurrentStateMachine.RequestState(false, "SeatX", "CuddleReject");
mCurrentStateMachine.RequestState(false, "SeatY", "CuddleReject");
mCurrentStateMachine.RequestState(true, "y", "CuddleReject");
mCurrentStateMachine.RequestState(null, "ExitSitting");
Target.RouteAway(kMinDistanceToMoveAwayWhenRejected, kMaxDistanceToMoveAwayWhenRejected, true, new InteractionPriority(InteractionPriorityLevel.Zero), false, true, true, RouteDistancePreference.NoPreference);
}
else if (Actor.TraitManager.HasElement(TraitNames.HotHeaded))
{
Actor.PlayReaction(ReactionTypes.JealousIntense, ReactionSpeed.Immediate);
}
else if (Actor.TraitManager.HasElement(TraitNames.OverEmotional))
{
Actor.PlayReaction(ReactionTypes.JealousMild, ReactionSpeed.Immediate);
}
else if (Actor.TraitManager.HasAnyElement(new TraitNames[] { TraitNames.Flirty, TraitNames.GreatKisser }))
{
Actor.PlayReaction(ReactionTypes.Shrug, ReactionSpeed.Immediate);
}
else
{
Actor.PlayReaction(ReactionTypes.Awkward, ReactionSpeed.Immediate);
}
return(false);
}
Actor.SynchronizationLevel = Sim.SyncLevel.Completed;
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Completed, (float)kHowLongToWaitForOtherToArrive))
{
return(false);
}
if (!Seat.SimsAreAdjacent(Actor, Target))
{
Actor.Posture.CurrentStateMachine.RequestState("x", "routeFail");
return(false);
}
if (seat2 == null)
{
seat2 = container.SeatingGroup[Target];
}
InteractionPriority priority = new InteractionPriority(InteractionPriorityLevel.Zero);
CuddleSeated seated = CuddleSeated.Singleton.CreateInstance(Target, Actor, priority, false, CancellableByPlayer) as CuddleSeated;
seated.AdoptSocialEffect(this);
seated.SeatX = otherSeat;
seated.SeatY = seat2;
CuddleSeated seated2 = CuddleSeated.Singleton.CreateInstance(Actor, Target, priority, false, CancellableByPlayer) as CuddleSeated;
seated2.SeatX = otherSeat;
seated2.SeatY = seat2;
seated.LinkedInteractionInstance = seated2;
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Actor, Target, "Cuddle", false, !Rejected, false, CommodityTypes.Undefined));
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Target, Actor, "Cuddle", true, !Rejected, false, CommodityTypes.Undefined));
EventTracker.SendEvent(EventTypeId.kCuddled, Actor, Target);
EventTracker.SendEvent(EventTypeId.kCuddled, Target, Actor);
Actor.InteractionQueue.Add(seated);
Target.InteractionQueue.Add(seated2);
return(!Rejected);
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return(false);
}
}
public override bool Run()
{
try
{
mLinkedActor = LinkedInteractionInstance.InstanceActor;
IWooHooDefinition definition = InteractionDefinition as IWooHooDefinition;
bool succeeded = true;
if (mIsMaster)
{
Target.mRoutingSims.Add(Actor);
Target.mRoutingSims.Add(mLinkedActor);
}
if (!mIsMaster)
{
bool success = false;
Actor.RouteToObjectRadialRange(Target, 1.5f, 4f);
while (Target.mRoutingSims.Contains(mLinkedActor))
{
AncientPortalWooHoo interaction = LinkedInteractionInstance as AncientPortalWooHoo;
if (interaction == null)
{
break;
}
if (mLinkedActor.HasExitReason(ExitReason.Canceled))
{
break;
}
if (interaction.mNowWaiting)
{
success = true;
break;
}
SpeedTrap.Sleep(0xa);
}
if (!success)
{
Actor.AddExitReason(ExitReason.RouteFailed);
return(false);
}
}
bool routeSuccess = false;
Route r = Actor.CreateRoute();
r.AddObjectToIgnoreForRoute(mLinkedActor.ObjectId);
r.PlanToSlot(Target, Target.GetRoutingSlots());
routeSuccess = Actor.DoRoute(r);
if ((mIsMaster) && (routeSuccess))
{
routeSuccess = !Actor.InUse;
}
if (!routeSuccess)
{
Actor.AddExitReason(ExitReason.RouteFailed);
return(false);
}
CommonWoohoo.TestNakedOutfit(Woohooer.Settings.mNakedOutfitAncientPortal, Actor);
StandardEntry();
EnterStateMachine("AncientPortal", "Enter", "x", "portal");
AddOneShotScriptEventHandler(0x65, HideSim);
AddOneShotScriptEventHandler(0x66, ShowSim);
AnimateSim("InsidePortal");
if (mIsMaster)
{
Target.RemoveFromUseList(Actor);
mNowWaiting = true;
RockGemMetalBase.HandleNearbyWoohoo(Actor, RockGemMetalBase.HowMuchWooHoo.MoreWoohoo);
}
BeginCommodityUpdates();
if (mReactToSocialBroadcaster == null)
{
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
CommonWoohoo.CheckForWitnessedCheating(Actor, mLinkedActor, !Rejected);
}
if ((Target.BoobyTrapComponent != null) ? Target.BoobyTrapComponent.CanTriggerTrap(Actor.SimDescription) : false)
{
Target.TriggerTrap(Actor);
}
int count = 0;
while (Target.mRoutingSims.Contains(mLinkedActor))
{
AncientPortalWooHoo interaction = LinkedInteractionInstance as AncientPortalWooHoo;
if (interaction == null)
{
break;
}
if (mLinkedActor.HasExitReason(ExitReason.Canceled))
{
break;
}
if (!mIsMaster)
{
interaction.mWasSuccess = true;
if (count > 30)
{
break;
}
count++;
Target.SetOpacity(RandomUtil.GetFloat(0f, 1f), 0.25f);
}
SpeedTrap.Sleep(10);
}
if (!mIsMaster)
{
Target.SetOpacity(1f, 1f);
}
AnimateSim("Exit");
for (int i = 0; i < AncientPortal.CatchABeam.kPotentialTravelBuffs.Length; i++)
{
if (RandomUtil.RandomChance(AncientPortal.CatchABeam.kChanceForEachBuff))
{
Actor.BuffManager.AddElement(AncientPortal.CatchABeam.kPotentialTravelBuffs[i], Origin.FromAncientPortal);
}
}
if (mIsMaster)
{
RockGemMetalBase.HandleNearbyWoohoo(Actor, RockGemMetalBase.HowMuchWooHoo.LessWoohoo);
}
EndCommodityUpdates(succeeded);
StandardExit();
if ((mWasSuccess) && (mIsMaster))
{
CommonWoohoo.RunPostWoohoo(Actor, mLinkedActor, Target, definition.GetStyle(this), definition.GetLocation(Target), true);
if (CommonPregnancy.IsSuccess(Actor, mLinkedActor, Autonomous, definition.GetStyle(this)))
{
CommonPregnancy.Impregnate(Actor, mLinkedActor, Autonomous, definition.GetStyle(this));
}
}
Actor.Wander(1f, 2f, false, RouteDistancePreference.PreferNearestToRouteOrigin, false);
return(succeeded);
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return(false);
}
finally
{
Target.mRoutingSims.Remove(Actor);
}
}
public override bool Run()
{
try
{
Definition interactionDefinition = InteractionDefinition as Definition;
if (interactionDefinition == null)
{
return false;
}
if (Autonomous && (interactionDefinition.mUsageType == BusinessPlanning.None))
{
interactionDefinition.mUsageType = (BusinessPlanning)RandomUtil.GetInt(0, 1);
}
IInteractionNameCanBeOverriden overriden = this;
if (overriden != null)
{
overriden.SetInteractionName(interactionDefinition.GetAutonomousInteractionName());
UpdateCaption = true;
}
if (this.mRunFromInventory && Actor.Inventory.Contains(Target))
{
Vector3 vector;
Vector3 vector2;
FindGoodLocationBooleans constraints = FindGoodLocationBooleans.Routable | FindGoodLocationBooleans.PreferEmptyTiles;
World.FindGoodLocationParams fglParams = new World.FindGoodLocationParams(Actor.Position, constraints);
if (!GlobalFunctions.FindGoodLocation(Target, fglParams, out vector, out vector2))
{
return false;
}
Actor.Inventory.TryToRemove(Target);
Target.SetPosition(vector);
Target.SetForward(vector2);
Target.AddToWorld();
Target.SetOpacity(0f, 0f);
}
if (!Target.Line.WaitForTurn(this, SimQueue.WaitBehavior.Default, ~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached), AcademicBusinessPlanner.kTimeToWaitInLine))
{
Actor.Inventory.TryToAdd(Target);
return false;
}
if (!Actor.RouteToSlotAndCheckInUse(Target, Slot.RoutingSlot_0))
{
Actor.Inventory.TryToAdd(Target);
return false;
}
StandardEntry();
Target.EnableFootprintAndPushSims(AcademicBusinessPlanner.sFootprintHash, Actor);
if (this.mRunFromInventory)
{
Actor.PlaySoloAnimation("a2o_object_genericSwipe_x", true);
Target.SetOpacityTransition(0f, 1f, 1f);
}
AcquireStateMachine("BusinessPlanner");
SetActor("x", Actor);
SetActor("planner", Target);
List<AcademicDegreeNames> namesNeeded = new List<AcademicDegreeNames>();
namesNeeded.Add(AcademicDegreeNames.Business);
BeginCommodityUpdatesAccountingForAcademicPerformance(namesNeeded);
Target.mCurrentBusinessPlanningType = interactionDefinition.mUsageType;
mCurrentStateMachine.EnterState("x", "Enter");
if (!Target.PlannerIsOpen)
{
AnimateSim("Open");
Target.PlannerIsOpen = true;
}
float kXPIncreasePerWorking = 0f;
ReactionBroadcaster broadcaster = null;
if (interactionDefinition.mUsageType == BusinessPlanning.WorkOnBusinessPlan)
{
AnimateSim("Work");
this.mWaitTime = RandomUtil.GetFloat(kMinWorkLength, kMaxWorkLength);
kXPIncreasePerWorking = AcademicBusinessPlanner.UseBusinessPlanner.kXPIncreasePerWorking;
}
else
{
AnimateSim("Practice");
this.mWaitTime = RandomUtil.GetFloat(kMinPresentationLength, kMaxPresentationLength);
kXPIncreasePerWorking = kXPIncreasePerPresentation;
broadcaster = new ReactionBroadcaster(Target, kPresentationBroadcastParams, new ReactionBroadcaster.BroadcastCallback(this.BroadcastCallback));
}
DoTimedLoop(this.mWaitTime, ~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
bool flag2 = false;
foreach (InteractionInstance instance in Actor.InteractionQueue.InteractionList)
{
if ((instance != this) && (instance is AcademicBusinessPlanner.UseBusinessPlanner))
{
flag2 = true;
break;
}
}
if (!flag2 && Target.PlannerIsOpen)
{
AnimateSim("Close");
Target.PlannerIsOpen = false;
}
AnimateSim("Exit");
Target.DisableFootprint(AcademicBusinessPlanner.sFootprintHash);
EndCommodityUpdates(true);
StandardExit();
if (!Actor.HasExitReason(ExitReason.Canceled))
{
if (interactionDefinition.mUsageType == BusinessPlanning.PresentBusinessPlan)
{
EventTracker.SendEvent(EventTypeId.kPresentedBusinessPlan, Actor, Target.LotCurrent);
}
else if (interactionDefinition.mUsageType == BusinessPlanning.WorkOnBusinessPlan)
{
EventTracker.SendEvent(EventTypeId.kWorkedOnBusinessPlan, Actor, Target.LotCurrent);
}
}
if (broadcaster != null)
{
broadcaster.EndBroadcast();
broadcaster.Dispose();
broadcaster = null;
}
// Custom, removed IsUniversityWorld() check
Business occupationAsCareer = Actor.OccupationAsCareer as Business;
if (occupationAsCareer != null)
{
occupationAsCareer.UpdatePerformanceOrExperience(kXPIncreasePerWorking);
}
AcademicCareer occupationAsAcademicCareer = Actor.OccupationAsAcademicCareer;
if (((occupationAsAcademicCareer != null) && (occupationAsAcademicCareer.DegreeInformation != null)) && (occupationAsAcademicCareer.DegreeInformation.AcademicDegreeName == AcademicDegreeNames.Business))
{
occupationAsAcademicCareer.UpdatePerformanceOrExperience(kXPIncreasePerWorking);
}
if (!Target.PlannerIsOpen)
{
Actor.WaitForExitReason(2f, ~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
if (!Actor.Inventory.Contains(Target))
{
Actor.PlaySoloAnimation("a2o_object_genericSwipe_x", true);
Actor.Inventory.TryToAdd(Target);
}
}
return true;
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return false;
}
}
public override bool Run()
{
try
{
if (!StartSync())
{
return false;
}
StandardEntry(false);
BeginCommodityUpdates();
if (IsMaster)
{
ReturnInstance.EnsureMaster();
StartSocial("Kiss");
InitiateSocialUI(Actor, Target);
(LinkedInteractionInstance as NestedCuddleInteraction).Rejected = Rejected;
// Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventMedium);
//SocialComponent.SendCheatingEvents(Actor, Target, !Rejected);
if (Rejected)
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "KissReject");
ReturnInstance.mCurrentStateMachine.RequestState(null, "ExitSitting");
FinishSocial("Kiss", true);
FinishSocialContext();
}
else
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "Kiss");
FinishSocial("Kiss", true);
}
}
else
{
DoLoop(~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
}
FinishLinkedInteraction(IsMaster);
EndCommodityUpdates(!Rejected);
StandardExit(false, false);
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Actor, Target, "Kiss", !IsMaster, !Rejected, false, CommodityTypes.Undefined));
if (Rejected)
{
InvokeDoResumeOnCleanup = false;
}
else
{
Actor.SimDescription.SetFirstKiss(Target.SimDescription);
if (SimClock.IsNightTime() && SimClock.IsFullMoon())
{
Actor.BuffManager.AddElement(BuffNames.KissedUnderFullMoon, Origin.None);
EventTracker.SendEvent(EventTypeId.kKissedUnderFullMoon, Actor);
}
}
WaitForSyncComplete();
return !Rejected;
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return false;
}
}
public override bool Run()
{
try
{
int num;
if ((WoohooObject == null) || !WoohooObject.CanWooHooIn())
{
return false;
}
if (!SafeToSync())
{
return false;
}
LeafPile.WoohooInPileOrStackB entry = LeafPile.WoohooInPileOrStackB.Singleton.CreateInstance(Actor, Target, GetPriority(), Autonomous, CancellableByPlayer) as LeafPile.WoohooInPileOrStackB;
entry.LinkedInteractionInstance = this;
if (!Target.InteractionQueue.Add(entry))
{
Common.DebugNotify("LeafPileBaseWoohoo Add Fail");
return false;
}
Actor.SynchronizationLevel = Sim.SyncLevel.Started;
Actor.SynchronizationTarget = Target;
Actor.SynchronizationRole = Sim.SyncRole.Initiator;
if (!WoohooObject.SimLine.WaitForTurn(this, SimQueue.WaitBehavior.Default, ~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached), 10f))
{
return false;
}
Slot[] routingSlots = WoohooObject.GetRoutingSlots();
if (!Actor.RouteToSlotListAndCheckInUse(WoohooObject, routingSlots, out num))
{
return false;
}
if (!WoohooObject.CanWooHooIn())
{
return false;
}
CommonWoohoo.TestNakedOutfit(UsingNakedOutfit, Actor, Target);
mActorXRoutingSlot = routingSlots[num];
StandardEntry();
WoohooObject.AddToUseList(Actor);
WoohooObject.AddToUseList(Target);
MotiveDelta[] deltaArray = new MotiveDelta[2];
deltaArray[0] = AddMotiveDelta(CommodityKind.Fun, 1500f);
deltaArray[1] = AddMotiveDelta(CommodityKind.Social, 50f);
BeginCommodityUpdates();
EnterStateMachine(WoohooObject.JazzFileName, "Enter", "x");
AddOneShotScriptEventHandler(0x65, PlayEffectsHandlerX);
AddOneShotScriptEventHandler(0x78, AnimCallbackSimX);
SetActor(WoohooObject.JazzObjectName, WoohooObject);
Animate("x", "GetInStackX");
WoohooObject.SimLine.RemoveFromQueue(Actor);
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Routed, 30f))
{
AddOneShotScriptEventHandler(0x65, PlayEffectsHandlerX);
AddOneShotScriptEventHandler(0x66, PlayEffectsHandlerX);
AddOneShotScriptEventHandler(0x6e, AnimCallbackSimX);
AddOneShotScriptEventHandler(0x79, AnimCallbackSimX);
Animate("x", "GetOut");
Animate("x", "Exit");
WoohooObject.RemoveFromUseList(Actor);
WoohooObject.RemoveFromUseList(Target);
RemoveMotiveDelta(deltaArray[0x0]);
RemoveMotiveDelta(deltaArray[0x1]);
EndCommodityUpdates(false);
StandardExit();
return false;
}
mActorYRoutingSlot = (Slot)(LinkedInteractionInstance as LeafPile.WoohooInPileOrStackB).RoutedSlot;
RockGemMetalBase.HandleNearbyWoohoo(Actor, RockGemMetalBase.HowMuchWooHoo.MoreWoohoo);
SetActor("y", Target);
EnterState("y", "Enter");
AddOneShotScriptEventHandler(0x65, PlayEffectsHandlerY);
AddOneShotScriptEventHandler(0x78, AnimCallbackSimY);
Animate("y", "GetInStackY");
if (mReactToSocialBroadcasterActor == null)
{
mReactToSocialBroadcasterActor = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
CommonWoohoo.CheckForWitnessedCheating(Actor, Target, true);
}
if (mReactToSocialBroadcasterTarget == null)
{
mReactToSocialBroadcasterTarget = new ReactionBroadcaster(Target, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
CommonWoohoo.CheckForWitnessedCheating(Target, Actor, true);
}
AnimateJoinSims("Woohoo");
(WoohooObject as GameObject).PushSimsFromFootprint((uint)mActorXRoutingSlot, Actor, null, true);
AddOneShotScriptEventHandler(0x65, PlayEffectsHandlerX);
AddOneShotScriptEventHandler(0x66, PlayEffectsHandlerX);
AddOneShotScriptEventHandler(0x6e, AnimCallbackSimX);
AddOneShotScriptEventHandler(0x79, AnimCallbackSimX);
AnimateJoinSims("GetOutX");
List<Sim> exceptions = new List<Sim>();
exceptions.Add(Actor);
(WoohooObject as GameObject).PushSimsFromFootprint((uint)mActorYRoutingSlot, Target, exceptions, true);
if (mActorYRoutingSlot == mActorXRoutingSlot)
{
Actor.Wander(1f, 2f, false, RouteDistancePreference.PreferFurthestFromRouteOrigin, true);
}
AddOneShotScriptEventHandler(0x65, PlayEffectsHandlerY);
AddOneShotScriptEventHandler(0x66, PlayEffectsHandlerY);
AddOneShotScriptEventHandler(0x6e, AnimCallbackSimY);
AddOneShotScriptEventHandler(0x79, AnimCallbackSimY);
AnimateJoinSims("GetOutY");
AnimateJoinSims("Exit");
RockGemMetalBase.HandleNearbyWoohoo(Actor, RockGemMetalBase.HowMuchWooHoo.LessWoohoo);
IWooHooDefinition definition = InteractionDefinition as IWooHooDefinition;
CommonWoohoo.RunPostWoohoo(Actor, Target, WoohooObject, definition.GetStyle(this), definition.GetLocation(WoohooObject), true);
if (CommonPregnancy.IsSuccess(Actor, Target, Autonomous, definition.GetStyle(this)))
{
Pregnancy pregnancy = CommonPregnancy.Impregnate(Actor, Target, Autonomous, definition.GetStyle(this));
if (pregnancy != null)
{
if (RandomUtil.RandomChance(WoohooObject.ChanceBabyGetsLovesOutdoorsTrait))
{
pregnancy.SetForcedBabyTrait(TraitNames.LovesTheOutdoors);
}
}
}
WoohooObject.RemoveFromUseList(Actor);
WoohooObject.RemoveFromUseList(Target);
RemoveMotiveDelta(deltaArray[0x0]);
RemoveMotiveDelta(deltaArray[0x1]);
EndCommodityUpdates(true);
StandardExit();
VisitSituation situation = VisitSituation.FindVisitSituationInvolvingGuest(Actor);
VisitSituation situation2 = VisitSituation.FindVisitSituationInvolvingGuest(Target);
if ((situation != null) && (situation2 != null))
{
situation.GuestStartingInappropriateAction(Actor, 3.5f);
situation2.GuestStartingInappropriateAction(Target, 3.5f);
}
if (RandomUtil.RandomChance(WoohooObject.ChanceGetRollInHayBuff))
{
Actor.BuffManager.AddElement(BuffNames.RolledInTheHay, Origin.FromWooHooInHayStack);
Target.BuffManager.AddElement(BuffNames.RolledInTheHay, Origin.FromWooHooInHayStack);
}
Relationship.Get(Actor, Target, true).LTR.UpdateLiking(WoohooObject.LTRGain);
EventTracker.SendEvent(WoohooObject.WooHooEventID, Actor, Target);
EventTracker.SendEvent(WoohooObject.WooHooEventID, Target, Actor);
return true;
}
catch (ResetException)
{
throw;
}
catch (Exception exception)
{
Common.Exception(Actor, Target, exception);
return false;
}
}
public override bool Run()
{
try
{
Actor.GreetSimOnMyLotIfPossible(Target);
if (GetCuddleType(Actor, Target) == CuddleType.CuddleTargetOnDifferentBed)
{
ChildUtils.SetPosturePrecondition(this, CommodityKind.Relaxing, new CommodityKind[] { CommodityKind.NextToTarget });
Actor.InteractionQueue.PushAsContinuation(this, true);
return(true);
}
if (!SafeToSync())
{
return(false);
}
// Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventMedium);
//SocialComponent.SendCheatingEvents(Actor, Target, !Rejected);
StartBedCuddleB entry = StartBedCuddleB.Singleton.CreateInstance(Actor, Target, GetPriority(), false, CancellableByPlayer) as StartBedCuddleB;
LinkedInteractionInstance = entry;
Target.InteractionQueue.Add(entry);
if (Target.Posture.Container != Actor.Posture.Container)
{
Actor.LookAtManager.SetInteractionLookAt(Target, 0xc8, LookAtJointFilter.TorsoBones);
Actor.Posture.CurrentStateMachine.RequestState("x", "callOver");
}
Actor.SynchronizationLevel = Sim.SyncLevel.Started;
Actor.SynchronizationTarget = Target;
Actor.SynchronizationRole = Sim.SyncRole.Initiator;
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Started, Bed.kTimeToWaitForOtherToArriveForCuddling))
{
return(false);
}
Actor.Posture.CurrentStateMachine.RequestState("x", "ExitRelaxing");
StartSocial("Cuddle");
entry.Rejected = Rejected;
Actor.SynchronizationLevel = Sim.SyncLevel.Routed;
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Routed, Bed.kTimeToWaitForOtherToArriveForCuddling))
{
return(false);
}
if (Rejected)
{
if (Actor.Posture.Container == Target.Posture.Container)
{
BedMultiPart container = Actor.Posture.Container as BedMultiPart;
BedData partSimIsIn = container.PartComp.GetPartSimIsIn(Actor);
EnterStateMachine("BedSocials", "FromRelax", "x", "y");
mCurrentStateMachine.EnterState("y", "FromRelax");
mCurrentStateMachine.EnterState("bed", "FromRelax");
SetActor("bed", container);
partSimIsIn.SetPartParameters(mCurrentStateMachine);
mCurrentStateMachine.RequestState(false, "x", "CuddleReject");
mCurrentStateMachine.RequestState(false, "bed", "CuddleReject");
mCurrentStateMachine.RequestState(true, "y", "CuddleReject");
mCurrentStateMachine.RequestState(null, "ToRelax");
Target.RouteAway(kMinDistanceToMoveAwayWhenRejected, kMaxDistanceToMoveAwayWhenRejected, true, new InteractionPriority(InteractionPriorityLevel.Zero), false, true, true, RouteDistancePreference.NoPreference);
}
else
{
Actor.Posture.CurrentStateMachine.RequestState(true, "x", "CallOverReject");
}
return(false);
}
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Completed, Bed.kTimeToWaitForOtherToArriveForCuddling))
{
return(false);
}
InteractionPriority priority = new InteractionPriority(InteractionPriorityLevel.Zero);
CuddleRelaxing relaxing = CuddleRelaxing.Singleton.CreateInstance(Target, Actor, priority, false, CancellableByPlayer) as CuddleRelaxing;
relaxing.IsMaster = true;
relaxing.AdoptSocialEffect(this);
CuddleRelaxing relaxing2 = CuddleRelaxing.Singleton.CreateInstance(Actor, Target, priority, false, CancellableByPlayer) as CuddleRelaxing;
relaxing2.IsMaster = false;
relaxing.LinkedInteractionInstance = relaxing2;
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Actor, Target, "Cuddle", false, !Rejected, false, CommodityTypes.Undefined));
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Target, Actor, "Cuddle", true, !Rejected, false, CommodityTypes.Undefined));
Actor.InteractionQueue.Add(relaxing);
Target.InteractionQueue.Add(relaxing2);
return(!Rejected);
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return(false);
}
}
public override void OnDelayedWorldLoadFinished()
{
Overwatch.Log("CleanupReactionBroadcasters");
foreach (Lot lot in LotManager.Lots)
{
Lot.SavedData savedData = lot.mSavedData;
if (savedData == null)
{
continue;
}
foreach (List <ReactionBroadcaster> broadcasters in new List <ReactionBroadcaster>[] { savedData.mBroadcastersWithSims, savedData.mReactions })
{
if (broadcasters == null)
{
continue;
}
Dictionary <ObjectGuid, ReactionBroadcaster.BroadcastCallback> enterLookup = new Dictionary <ObjectGuid, ReactionBroadcaster.BroadcastCallback>();
Dictionary <ObjectGuid, ReactionBroadcaster.BroadcastCallback> exitLookup = new Dictionary <ObjectGuid, ReactionBroadcaster.BroadcastCallback>();
int index = 0;
while (index < broadcasters.Count)
{
ReactionBroadcaster broadcaster = broadcasters[index];
string reason = null;
if ((broadcaster == null) || (broadcaster.mBroadcastingObject == null))
{
reason = " Invalid";
}
else if ((broadcaster.mOnEnterInteraction != null) && (broadcaster.mOnEnterInteraction.InteractionDefinition == null))
{
reason = " Bad Interaction";
}
else if (broadcaster.mBroadcastingObject.HasBeenDestroyed)
{
reason = " Destroyed Object";
}
else if (broadcaster.mBroadcastingObject.LotCurrent != lot)
{
reason = " Wrong Lot";
}
else
{
if (broadcaster.mOnEnterCallback != null)
{
ReactionBroadcaster.BroadcastCallback callback;
if (enterLookup.TryGetValue(broadcaster.mBroadcastingObject.ObjectId, out callback))
{
if (callback == broadcaster.mOnEnterCallback)
{
reason = " Duplicate Enter Broadcaster: " + broadcaster.mBroadcastingObject;
}
}
else
{
enterLookup.Add(broadcaster.mBroadcastingObject.ObjectId, broadcaster.mOnEnterCallback);
}
}
if (broadcaster.mOnExitCallback != null)
{
ReactionBroadcaster.BroadcastCallback callback;
if (enterLookup.TryGetValue(broadcaster.mBroadcastingObject.ObjectId, out callback))
{
if (callback == broadcaster.mOnExitCallback)
{
reason = " Duplicate Exit Broadcaster: " + broadcaster.mBroadcastingObject;
}
}
else
{
enterLookup.Add(broadcaster.mBroadcastingObject.ObjectId, broadcaster.mOnExitCallback);
}
}
}
if (!string.IsNullOrEmpty(reason))
{
Overwatch.Log(reason);
broadcasters.RemoveAt(index);
}
else
{
index++;
}
}
}
}
}
public override void HourlyCallback()
{
if (GameUtils.IsOnVacation() || GameUtils.IsUniversityWorld())
{
Common.DebugNotify(mMom.FullName + Common.NewLine + "HumanSurrogatePregnancy.HourlyCallback" + Common.NewLine + " - Pregnancy Paused");
return;
}
mHourOfPregnancy++;
string msg = mMom.FullName + Common.NewLine + "HumanSurrogatePregnancy.HourlyCallback" + Common.NewLine +
" - Hour: " + mHourOfPregnancy + Common.NewLine;
if (mHourOfPregnancy == kHourToStartPregnantMotives)
{
mMom.BuffManager.AddElement(BuffNames.Nauseous, Origin.FromUnknown);
}
if (mHourOfPregnancy < kHourToShowPregnantBuff && mHourOfPregnancy > kHourToStartPregnantMotives)
{
mMom.BuffManager.AddElement(BuffNames.Nauseous, Origin.FromUnknown);
}
if (mMom.Household.IsTouristHousehold)
{
msg += " - Foreign Sim" + Common.NewLine;
ForeignVisitorsSituation foreignVisitorsSituation = ForeignVisitorsSituation.TryGetForeignVisitorsSituation(mMom);
if (mHourOfPregnancy == kForeignSimDisplaysTNS && foreignVisitorsSituation != null)
{
StyledNotification.Show(new StyledNotification.Format(Localization.LocalizeString("Gameplay/ActorSystems/Pregnancy:ForeignBabyIsComingTNS",
new object[] { mMom }), StyledNotification.NotificationStyle.kGameMessagePositive), "glb_tns_baby_coming_r2");
}
if (mHourOfPregnancy == kForeignSimLeavesWorld)
{
if (foreignVisitorsSituation != null)
{
foreignVisitorsSituation.MakeGuestGoHome(mMom);
}
else if (mMom.SimDescription.AssignedRole != null)
{
mMom.SimDescription.AssignedRole.RemoveSimFromRole();
}
}
if (mHourOfPregnancy > kForeignSimLeavesWorld)
{
Common.DebugNotify(msg);
mHourOfPregnancy--;
return;
}
}
if (mHourOfPregnancy == kHourToShowPregnantBuff)
{
msg += " - Adding Pregnant Buff" + Common.NewLine;
Common.DebugNotify(msg);
InteractionInstance interactionInstance = ShowPregnancyEx.Singleton.CreateInstance(mMom, mMom,
new InteractionPriority(InteractionPriorityLevel.ESRB), false, false);
interactionInstance.Hidden = true;
mMom.InteractionQueue.AddNext(interactionInstance);
return;
}
if (mHourOfPregnancy >= kHourToStartWalkingPregnant)
{
ActiveTopic.AddToSim(mMom, "Pregnant", mMom.SimDescription);
RequestPregnantWalkStyle();
}
if (mHourOfPregnancy == kHourToStartContractions)
{
msg += " - Starting Labor" + Common.NewLine;
for (int i = 0; i < kNumberOfPuddlesForWaterBreak; i++)
{
PuddleManager.AddPuddle(mMom.PositionOnFloor);
}
if (mMom.IsSelectable)
{
StyledNotification.Show(new StyledNotification.Format(Localization.LocalizeString("Gameplay/ActorSystems/Pregnancy:BabyIsComingTNS",
new object[] { mMom }), StyledNotification.NotificationStyle.kGameMessageNegative), "glb_tns_baby_coming_r2");
}
mMom.BuffManager.RemoveElement(BuffNames.Pregnant);
mMom.BuffManager.AddElement(BuffNames.BabyIsComing, Origin.FromPregnancy);
if (mContractionBroadcast != null)
{
mContractionBroadcast.Dispose();
}
mContractionBroadcast = new ReactionBroadcaster(mMom, kContractionBroadcasterParams,
new ReactionBroadcaster.BroadcastCallback(StartReaction), new ReactionBroadcaster.BroadcastCallback(CancelReaction));
mMom.AddInteraction(TakeToHospital.Singleton);
InteractionInstance entry = HaveContraction.Singleton.CreateInstance(mMom, mMom, new InteractionPriority(InteractionPriorityLevel.High, 10f), false, false);
mMom.InteractionQueue.Add(entry);
mContractionsAlarm = mMom.AddAlarmRepeating(5f, TimeUnit.Minutes, new AlarmTimerCallback(TriggerContraction),
5f, TimeUnit.Minutes, "Trigger Contractions Alarm", AlarmType.AlwaysPersisted);
EventTracker.SendEvent(EventTypeId.kPregnancyContractionsStarted, mMom);
}
if (mHourOfPregnancy == kHoursOfPregnancy)
{
msg += " - Having the Baby";
HaveTheBaby();
}
SetPregoBlendShape();
Common.DebugNotify(msg);
}
public static void OnStub(Sim sim, ReactionBroadcaster broadcaster)
{ }
public override bool Run()
{
try
{
if (!StartSync())
{
return(false);
}
// Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
//SocialComponent.SendCheatingEvents(Actor, Target, !Rejected);
StandardEntry(false);
BeginCommodityUpdates();
if (IsMaster)
{
ReturnInstance.EnsureMaster();
StartSocial("Make Out");
InitiateSocialUI(Actor, Target);
(LinkedInteractionInstance as NestedRelaxingInteraction).Rejected = Rejected;
if (Rejected)
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "MakeOutReject");
ReturnInstance.mCurrentStateMachine.RequestState(null, "ToRelax");
FinishSocial("Make Out", true);
}
else
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "MakeOut");
StartStages();
if ((Actor.Posture.Container as Bed).IsTent)
{
ThoughtBalloonManager.BalloonData bd = new ThoughtBalloonManager.BalloonData("balloon_lips");
Actor.ThoughtBalloonManager.ShowBalloon(bd);
Target.ThoughtBalloonManager.ShowBalloon(bd);
}
DoLoop(~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
FinishSocial("Make Out", true);
}
}
else
{
DoLoop(~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
}
FinishLinkedInteraction(IsMaster);
EndCommodityUpdates(!Rejected);
StandardExit(false, false);
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Actor, Target, "Make Out", !IsMaster, !Rejected, false, CommodityTypes.Undefined));
if (!Rejected)
{
Actor.SimDescription.SetFirstKiss(Target.SimDescription);
DoResume();
}
WaitForSyncComplete();
return(!Rejected);
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return(false);
}
}
public override bool Run()
{
try
{
Actor.GreetSimOnMyLotIfPossible(Target);
Seat.EnsureLivingChairPosture(Actor);
IHasSeatingGroup container = Actor.Posture.Container as IHasSeatingGroup;
Seat otherSeat = container.SeatingGroup[Actor];
Seat seat2 = container.SeatingGroup[Target];
if (!SafeToSync())
{
return false;
}
Actor.LookAtManager.SetInteractionLookAt(Target, kTargetLookAtPriority, LookAtJointFilter.TorsoBones);
if ((seat2 != null) && !seat2.IsAdjacentTo(otherSeat))
{
Seat emptyAdjacentSeat = seat2.GetEmptyAdjacentSeat(Actor);
if (emptyAdjacentSeat != null)
{
InteractionInstance instance = otherSeat.CreateChangeSeatInteraction(emptyAdjacentSeat, GetPriority(), Autonomous, CancellableByPlayer);
SaunaClassic.StartSaunaSeatedCuddleA ea = Singleton.CreateInstance(Target, Actor, GetPriority(), Autonomous, CancellableByPlayer) as SaunaClassic.StartSaunaSeatedCuddleA;
Actor.InteractionQueue.PushAsContinuation(instance, true);
Actor.InteractionQueue.PushAsContinuation(ea, true);
return true;
}
return false;
}
SaunaClassic.StartSaunaSeatedCuddleB entry = SaunaClassic.StartSaunaSeatedCuddleB.Singleton.CreateInstance(Actor, Target, GetPriority(), false, CancellableByPlayer) as SaunaClassic.StartSaunaSeatedCuddleB;
entry.SeatX = otherSeat;
entry.SeatY = seat2;
LinkedInteractionInstance = entry;
Target.InteractionQueue.Add(entry);
// Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventMedium);
//SocialComponent.SendCheatingEvents(Actor, Target, !Rejected);
Actor.SynchronizationRole = Sim.SyncRole.Initiator;
Actor.SynchronizationLevel = Sim.SyncLevel.Started;
Actor.SynchronizationTarget = Target;
Target.SynchronizationLevel = Sim.SyncLevel.NotStarted;
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Started, (float)kHowLongToWaitForOtherToArrive))
{
return false;
}
StartSocial("Cuddle");
entry.Reject = Rejected;
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Routed, (float)kHowLongToWaitForOtherToArrive))
{
return false;
}
if (Rejected)
{
if (Seat.SimsAreAdjacent(Actor, Target))
{
Seat.EnsureLivingChairPosture(Target);
bool paramValue = seat2 == otherSeat.Right;
EnterStateMachine("SeatingCuddle", "EnterSitting", "x", "y");
mCurrentStateMachine.EnterState("y", "EnterSitting");
mCurrentStateMachine.EnterState("SeatX", "EnterSitting");
mCurrentStateMachine.EnterState("SeatY", "EnterSitting");
SetActor("SeatX", otherSeat.Host);
SetParameter("SuffixX", otherSeat.IKSuffix);
SetActor("SeatY", seat2.Host);
SetParameter("SuffixY", seat2.IKSuffix);
SetActor("surface", otherSeat.Host);
SetParameter("IsMirrored", paramValue);
bool flag2 = otherSeat is IHotTubSeat;
SetParameter("IsHottub", flag2);
mCurrentStateMachine.RequestState(false, "x", "CuddleReject");
mCurrentStateMachine.RequestState(false, "SeatX", "CuddleReject");
mCurrentStateMachine.RequestState(false, "SeatY", "CuddleReject");
mCurrentStateMachine.RequestState(true, "y", "CuddleReject");
mCurrentStateMachine.RequestState(null, "ExitSitting");
Target.RouteAway(kMinDistanceToMoveAwayWhenRejected, kMaxDistanceToMoveAwayWhenRejected, true, new InteractionPriority(InteractionPriorityLevel.Zero), false, true, true, RouteDistancePreference.NoPreference);
}
else if (Actor.TraitManager.HasElement(TraitNames.HotHeaded))
{
Actor.PlayReaction(ReactionTypes.JealousIntense, ReactionSpeed.Immediate);
}
else if (Actor.TraitManager.HasElement(TraitNames.OverEmotional))
{
Actor.PlayReaction(ReactionTypes.JealousMild, ReactionSpeed.Immediate);
}
else if (Actor.TraitManager.HasAnyElement(new TraitNames[] { TraitNames.Flirty, TraitNames.GreatKisser }))
{
Actor.PlayReaction(ReactionTypes.Shrug, ReactionSpeed.Immediate);
}
else
{
Actor.PlayReaction(ReactionTypes.Awkward, ReactionSpeed.Immediate);
}
return false;
}
Actor.SynchronizationLevel = Sim.SyncLevel.Completed;
if (!Actor.WaitForSynchronizationLevelWithSim(Target, Sim.SyncLevel.Completed, (float)kHowLongToWaitForOtherToArrive))
{
return false;
}
if (!Seat.SimsAreAdjacent(Actor, Target))
{
Actor.Posture.CurrentStateMachine.RequestState("x", "routeFail");
return false;
}
if (seat2 == null)
{
seat2 = container.SeatingGroup[Target];
}
InteractionPriority priority = new InteractionPriority(InteractionPriorityLevel.Zero);
CuddleSeated seated = CuddleSeated.Singleton.CreateInstance(Target, Actor, priority, false, CancellableByPlayer) as CuddleSeated;
seated.AdoptSocialEffect(this);
seated.SeatX = otherSeat;
seated.SeatY = seat2;
CuddleSeated seated2 = CuddleSeated.Singleton.CreateInstance(Actor, Target, priority, false, CancellableByPlayer) as CuddleSeated;
seated2.SeatX = otherSeat;
seated2.SeatY = seat2;
seated.LinkedInteractionInstance = seated2;
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Actor, Target, "Cuddle", false, !Rejected, false, CommodityTypes.Undefined));
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Target, Actor, "Cuddle", true, !Rejected, false, CommodityTypes.Undefined));
EventTracker.SendEvent(EventTypeId.kCuddled, Actor, Target);
EventTracker.SendEvent(EventTypeId.kCuddled, Target, Actor);
Actor.InteractionQueue.Add(seated);
Target.InteractionQueue.Add(seated2);
return !Rejected;
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return false;
}
}
public void Perform(Sim sim, ReactionBroadcaster broadcaster)
{
ReactToSkinnyDippers(sim, mPool, GetInPool.SkinnyDipSingleton, mPool.mSkinnyDipperList);
}
public override bool Continue(Sim mom, bool momJustCreated)
{
if (mom == null)
{
return(false);
}
if (momJustCreated)
{
mHasRequestedWalkStyle = false;
}
mMom = mom;
mDad = null;
CheckForDad();
mTimeMoodSampled = SimClock.CurrentTime();
mMom.MoodManager.MoodChanged += new MoodManager.MoodChangedCallback(MoodManager_MoodChanged);
ActiveTopic.AddToSim(mom, "Pregnancy");
if (momJustCreated)
{
PreggersAlarm = mom.AddAlarmRepeating(1f, TimeUnit.Hours, new AlarmTimerCallback(HourlyCallback), 1f, TimeUnit.Hours,
"Hourly Alien Pregnancy Update Alarm", AlarmType.AlwaysPersisted);
}
mom.SimDescription.Pregnancy = this;
int arg_C0_0 = mHourOfPregnancy;
int arg_BF_0 = Aliens.Settings.mPregnancyShow;
if (mHourOfPregnancy >= Aliens.Settings.mPregnancyShow)
{
if (mHourOfPregnancy < Aliens.Settings.mStartLabor)
{
mMom.BuffManager.AddElement(BuffsAndTraits.sXenogenesis, Origin.FromPregnancy);
}
ActiveTopic.AddToSim(mMom, "Announce Pregnancy");
}
if (mHourOfPregnancy >= Aliens.Settings.mStartWalk)
{
ActiveTopic.AddToSim(mMom, "Pregnant", mMom.SimDescription);
RequestPregnantWalkStyle();
}
if (mHourOfPregnancy >= Aliens.Settings.mStartLabor)
{
mMom.BuffManager.AddElement(BuffsAndTraits.sAlienBabyIsComing, Origin.FromPregnancy);
if (mContractionBroadcast != null)
{
mContractionBroadcast.Dispose();
}
mContractionBroadcast = new ReactionBroadcaster(mMom, kContractionBroadcasterParams,
new ReactionBroadcaster.BroadcastCallback(StartReaction), new ReactionBroadcaster.BroadcastCallback(CancelReaction));
mMom.AddInteraction(TakeToHospitalEx.Singleton);
InteractionInstance entry = HaveContraction.Singleton.CreateInstance(mMom, mMom,
new InteractionPriority(InteractionPriorityLevel.High, 10f), false, false);
mMom.InteractionQueue.Add(entry);
mContractionsAlarm = mMom.AddAlarmRepeating(5f, TimeUnit.Minutes, new AlarmTimerCallback(TriggerContraction), 5f, TimeUnit.Minutes,
"Trigger Contractions Alarm", AlarmType.AlwaysPersisted);
}
if (mHourOfPregnancy == Aliens.Settings.mPregnancyDuration)
{
mMom.AddAlarm(1f, TimeUnit.Minutes, new AlarmTimerCallback(HaveTheBaby), "Re-have the baby.", AlarmType.AlwaysPersisted);
}
SetPregoBlendShape();
if (mMom.SimDescription.IsVisuallyPregnant)
{
TryToGiveLeave();
}
return(true);
}
public void PetstilenceContagionCallback(Sim s, ReactionBroadcaster rb)
{
EWDisease.Manager(s.SimDescription).PossibleProximityContagion(kProximitySicknessOddsSniffles);
}
public override void HourlyCallback()
{
if (GameUtils.IsOnVacation() || GameUtils.IsUniversityWorld())
{
Common.DebugNotify("AlienPregnancy.HourlyCallback - Pregnancy paused");
return;
}
mHourOfPregnancy++;
string msg = mMom.FullName + Common.NewLine
+ "AlienPregnancy.HourlyCallback" + Common.NewLine
+ " - Hour: " + mHourOfPregnancy + Common.NewLine;
if (mHourOfPregnancy == Aliens.Settings.mPregnancyShow)
{
msg += " - Showing Pregnancy";
InteractionInstance instance = ShowAlienPregnancy.Singleton.CreateInstance(mMom, mMom,
new InteractionPriority(InteractionPriorityLevel.ESRB), false, false);
instance.Hidden = true;
mMom.InteractionQueue.AddNext(instance);
Common.DebugNotify(msg);
return;
}
if (mMom.Household.IsTouristHousehold)
{
msg += " - Mother is Tourist" + Common.NewLine;
ForeignVisitorsSituation situation = ForeignVisitorsSituation.TryGetForeignVisitorsSituation(mMom);
if (mHourOfPregnancy == Aliens.Settings.mForeignShowTNS && situation != null)
{
StyledNotification.Show(new StyledNotification.Format(
Localization.LocalizeString("Gameplay/ActorSystems/Pregnancy:ForeignBabyIsComingTNS",
new object[] { mMom }), StyledNotification.NotificationStyle.kGameMessagePositive));
}
if (mHourOfPregnancy == Aliens.Settings.mForeignLeaves)
{
msg += " - Sending Pregnant Tourist Home";
if (situation != null)
{
situation.MakeGuestGoHome(mMom);
}
else if (mMom.SimDescription.AssignedRole != null)
{
mMom.SimDescription.AssignedRole.RemoveSimFromRole();
}
Common.DebugNotify(msg);
}
if (mHourOfPregnancy > Aliens.Settings.mForeignLeaves)
{
msg += " - Walking Back 1 Hour";
mHourOfPregnancy--;
Common.DebugNotify(msg);
return;
}
}
if (mHourOfPregnancy >= Aliens.Settings.mStartWalk)
{
ActiveTopic.AddToSim(mMom, "Pregnant", mMom.SimDescription);
RequestPregnantWalkStyle();
}
if (mHourOfPregnancy == Aliens.Settings.mStartLabor)
{
msg += " - Beginning Labor" + Common.NewLine;
for (int i = 0; i < Aliens.Settings.mNumPuddles; i++)
{
PuddleManager.AddPuddle(mMom.PositionOnFloor);
}
if (mMom.IsSelectable)
{
StyledNotification.Show(new StyledNotification.Format(Localization.LocalizeString("Gameplay/ActorSystems/Pregnancy:BabyIsComingTNS",
new object[] { mMom }), StyledNotification.NotificationStyle.kGameMessageNegative), "glb_tns_baby_coming_r2");
}
mMom.BuffManager.RemoveElement(BuffsAndTraits.sXenogenesis);
mMom.BuffManager.AddElement(BuffsAndTraits.sAlienBabyIsComing, Origin.FromPregnancy);
if (mContractionBroadcast != null)
{
mContractionBroadcast.Dispose();
}
mContractionBroadcast = new ReactionBroadcaster(mMom, kContractionBroadcasterParams,
new ReactionBroadcaster.BroadcastCallback(StartReaction), new ReactionBroadcaster.BroadcastCallback(CancelReaction));
mMom.AddInteraction(TakeToHospitalEx.Singleton);
InteractionInstance entry = HaveContraction.Singleton.CreateInstance(mMom, mMom,
new InteractionPriority(InteractionPriorityLevel.High, 10f), false, false);
mMom.InteractionQueue.Add(entry);
mContractionsAlarm = mMom.AddAlarmRepeating(5f, TimeUnit.Minutes, new AlarmTimerCallback(TriggerContraction), 5f, TimeUnit.Minutes,
"Trigger Contractions Alarm", AlarmType.AlwaysPersisted);
EventTracker.SendEvent(EventTypeId.kPregnancyContractionsStarted, mMom);
}
if (mHourOfPregnancy >= Aliens.Settings.mPregnancyDuration)
{
msg += " - Delivering Baby" + Common.NewLine;
HaveTheBaby();
}
SetPregoBlendShape();
Common.DebugNotify(msg);
}
public override bool Run()
{
try
{
if (!StartSync())
{
return(false);
}
StandardEntry(false);
BeginCommodityUpdates();
if (IsMaster)
{
ReturnInstance.EnsureMaster();
StartSocial("Make Out");
InitiateSocialUI(Actor, Target);
(LinkedInteractionInstance as NestedCuddleInteraction).Rejected = Rejected;
//Custom
mReactToSocialBroadcaster = new ReactionBroadcaster(Actor, Conversation.ReactToSocialParams, SocialComponentEx.ReactToJealousEventHigh);
//SocialComponent.SendCheatingEvents(Actor, Target, !Rejected);
IHasSeatingGroup container = Actor.Posture.Container as IHasSeatingGroup;
Seat seat = container.SeatingGroup[Actor];
ReturnInstance.mCurrentStateMachine.SetParameter("IsHottub", seat is IHotTubSeat);
if (Rejected)
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "MakeOutReject");
ReturnInstance.mCurrentStateMachine.RequestState(null, "ExitSitting");
FinishSocial("Make Out", true);
FinishSocialContext();
}
else
{
ReturnInstance.mCurrentStateMachine.RequestState(null, "MakeOut");
StartStages();
DoLoop(~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
FinishSocial("Make Out", true);
}
}
else
{
DoLoop(~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached));
}
FinishLinkedInteraction(IsMaster);
EndCommodityUpdates(!Rejected);
StandardExit(false, false);
EventTracker.SendEvent(new SocialEvent(EventTypeId.kSocialInteraction, Actor, Target, "Make Out", !IsMaster, !Rejected, false, CommodityTypes.Undefined));
EventTracker.SendEvent(EventTypeId.kMadeOut, Actor, Target);
if (Rejected)
{
InvokeDoResumeOnCleanup = false;
}
else
{
Actor.SimDescription.SetFirstKiss(Target.SimDescription);
}
WaitForSyncComplete();
return(!Rejected);
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return(false);
}
}
public new void CancelReaction(Sim sim, ReactionBroadcaster broadcaster)
{
sim.InteractionQueue.CancelInteractionByType(ReactToContractionEx.Singleton);
}
public override bool Run()
{
try
{
IWooHooDefinition definition = InteractionDefinition as IWooHooDefinition;
if (mIsMaster && !Actor.HasExitReason())
{
if (!Target.mEnterLine.WaitForTurn(this, Actor, SimQueue.WaitBehavior.Default, ~(ExitReason.Replan | ExitReason.MidRoutePushRequested | ExitReason.ObjectStateChanged | ExitReason.PlayIdle | ExitReason.MaxSkillPointsReached), 30f))
{
return(false);
}
List <Sim> exceptionsList = new List <Sim>();
exceptionsList.Add(WooHooer);
exceptionsList.Add(WooHooee);
Target.RemoveSimsExceptFor(exceptionsList);
ActorTrailerWooHoo entry = definition.ProxyClone(WooHooer).CreateInstance(Target, WooHooee, new InteractionPriority(InteractionPriorityLevel.UserDirected), false, true) as ActorTrailerWooHoo;
entry.LinkedInteractionInstance = this;
entry.WooHooer = WooHooer;
entry.WooHooee = WooHooee;
WooHooee.InteractionQueue.AddNext(entry);
}
if (!SafeToSync())
{
return(false);
}
if (!Target.RouteToAndEnterActorTrailer(Actor, this, false))
{
return(false);
}
StandardEntry(false);
Actor.LoopIdle();
if (!StartSync(mIsMaster))
{
StandardExit(false, false);
return(false);
}
BeginCommodityUpdates();
try
{
if (mIsMaster)
{
AcquireStateMachine("ActorTrailerSocials");
SetActorAndEnter("x", Actor, "FromRestOrSleep");
SetActorAndEnter("y", WooHooee, "FromRestOrSleep");
SetActor("Trailer", Target);
isWooHooing = true;
mWooHooReactionBroadcast = new ReactionBroadcaster(Target, ActorTrailer.kWooHooReactionBroadcastParams, PublicWooHooReactionCallback);
RockGemMetalBase.HandleNearbyWoohoo(Target, RockGemMetalBase.HowMuchWooHoo.MoreWoohoo);
AnimateJoinSims("WooHoo");
CommonWoohoo.TestNakedOutfit(Woohooer.Settings.mNakedOutfitActorTrailer, WooHooer, WooHooee);
CommonWoohoo.RunPostWoohoo(WooHooer, WooHooee, Target, definition.GetStyle(this), definition.GetLocation(Target), true);
if (CommonPregnancy.IsSuccess(WooHooer, WooHooee, Autonomous, definition.GetStyle(this)))
{
CommonPregnancy.Impregnate(WooHooer, WooHooee, Autonomous, definition.GetStyle(this));
}
RockGemMetalBase.HandleNearbyWoohoo(Actor, RockGemMetalBase.HowMuchWooHoo.LessWoohoo);
isWooHooing = false;
AnimateNoYield("y", "ToRestOrSleep");
AnimateSim("ToRestOrSleep");
}
FinishLinkedInteraction(mIsMaster);
WaitForSyncComplete();
}
finally
{
EndCommodityUpdates(true);
}
StandardExit(false, false);
if (mIsMaster)
{
//WooHooer.InteractionQueue.PushAsContinuation(ActorTrailer.Relax.Singleton.CreateInstance(Target, WooHooer, new InteractionPriority(InteractionPriorityLevel.Autonomous), true, true), true);
//WooHooee.InteractionQueue.PushAsContinuation(ActorTrailer.Relax.Singleton.CreateInstance(Target, WooHooee, new InteractionPriority(InteractionPriorityLevel.Autonomous), true, true), true);
if (mWooHooReactionBroadcast != null)
{
mWooHooReactionBroadcast.Dispose();
mWooHooReactionBroadcast = null;
}
foreach (Sim sim in Sims3.Gameplay.Queries.GetObjects <Sim>(Target.Position, ActorTrailer.kWooHooReactionBroadcastParams.PulseRadius))
{
if (sim.RoomId == Target.RoomId)
{
sim.PlayReaction(ReactionTypes.Cheer, Target, ReactionSpeed.NowOrLater);
}
}
}
return(true);
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return(false);
}
}
public void Perform(Sim sim, ReactionBroadcaster broadcaster)
{
PoolEx.ReactToSkinnyDippers(sim, mHotTub, HotTubBase.GetIn.SkinnyDipSingleton, mHotTub.GetSkinnyDippers());
}
