public override void BeginTransition(Navigator navigator, Navigator.
ActiveTransition transition)
{
var inst = AllMinionsLocationHistory.Instance;
base.BeginTransition(navigator, transition);
int cell = Grid.PosToCell(navigator);
if (Grid.IsValidCell(cell) && cell != VisitedCells[0])
{
// Update global history
if (inst != null)
{
int droppedCell = VisitedCells[TRACK_CELLS - 1];
inst.IncrementRefCount(cell);
if (Grid.IsValidBuildingCell(droppedCell))
{
inst.DecrementRefCount(droppedCell);
}
}
for (int i = TRACK_CELLS - 1; i > 0; i--)
{
VisitedCells[i] = VisitedCells[i - 1];
}
VisitedCells[0] = cell;
}
}
public override void BeginTransition(Navigator navigator, Navigator.
ActiveTransition transition)
{
base.BeginTransition(navigator, transition);
int cell = Grid.PosToCell(navigator);
int targetCell = Grid.OffsetCell(cell, transition.x, transition.y);
AddDoor(targetCell);
// If duplicant is inside a tube they are only 1 cell tall
if (navigator.CurrentNavType != NavType.Tube)
{
AddDoor(Grid.CellAbove(targetCell));
}
// Include any other offsets
foreach (var offset in transition.navGridTransition.voidOffsets)
{
AddDoor(Grid.OffsetCell(cell, offset));
}
// If not open, start a transition with the dupe waiting for the door
if (doors.Count > 0 && !AreAllDoorsOpen())
{
transition.anim = navigator.NavGrid.GetIdleAnim(navigator.CurrentNavType);
transition.isLooping = false;
transition.end = transition.start;
transition.speed = 1.0f;
transition.animSpeed = 1.0f;
transition.x = 0;
transition.y = 0;
transition.isCompleteCB = AreAllDoorsOpen;
}
foreach (var door in doors)
{
door.Open();
}
}
public override bool InternalCanBegin(GameObject new_reactor, Navigator.ActiveTransition transition)
{
if ((UnityEngine.Object)reactor != (UnityEngine.Object)null)
{
return(false);
}
if ((UnityEngine.Object)new_reactor == (UnityEngine.Object)null)
{
return(false);
}
Navigator component = new_reactor.GetComponent <Navigator>();
if ((UnityEngine.Object)component == (UnityEngine.Object)null)
{
return(false);
}
if (!component.IsMoving())
{
return(false);
}
if (component.CurrentNavType == NavType.Tube || component.CurrentNavType == NavType.Ladder || component.CurrentNavType == NavType.Pole)
{
return(false);
}
return((UnityEngine.Object)gameObject != (UnityEngine.Object)new_reactor);
}
public override void BeginTransition(Navigator navigator, Navigator.ActiveTransition transition)
{
base.BeginTransition(navigator, transition);
int cell = Grid.PosToCell(navigator);
int cell2 = Grid.OffsetCell(cell, transition.x, transition.y);
AddDoor(cell2);
if (navigator.CurrentNavType != NavType.Tube)
{
AddDoor(Grid.CellAbove(cell2));
}
for (int i = 0; i < transition.navGridTransition.voidOffsets.Length; i++)
{
int cell3 = Grid.OffsetCell(cell, transition.navGridTransition.voidOffsets[i]);
AddDoor(cell3);
}
if (doors.Count > 0 && !AreAllDoorsOpen())
{
transition.anim = navigator.NavGrid.GetIdleAnim(navigator.CurrentNavType);
transition.isLooping = false;
transition.end = transition.start;
transition.speed = 1f;
transition.animSpeed = 1f;
transition.x = 0;
transition.y = 0;
transition.isCompleteCB = (() => AreAllDoorsOpen());
}
foreach (Door door in doors)
{
door.Open();
}
}
public bool CanBegin(GameObject reactor, Navigator.ActiveTransition transition)
{
if (GameClock.Instance.GetTime() - lastTriggerTime < minReactableTime)
{
return(false);
}
ChoreConsumer component = reactor.GetComponent <ChoreConsumer>();
if ((Object)component == (Object)null)
{
return(false);
}
Chore currentChore = component.choreDriver.GetCurrentChore();
if (currentChore == null)
{
return(false);
}
if (choreType.priority <= currentChore.choreType.priority)
{
return(false);
}
if (additionalPreconditions != null)
{
foreach (ReactablePrecondition additionalPrecondition in additionalPreconditions)
{
if (!additionalPrecondition(reactor, transition))
{
return(false);
}
}
}
return(InternalCanBegin(reactor, transition));
}
public static void Prefix(Navigator ___navigator, Vector3 ___targetPos, Navigator.ActiveTransition ___transition)
{
if ((___navigator != null) && ___navigator.gameObject.HasTag(GameTags.Minion))
{
Debug.Log(___transition);
NavigatorRecordManager.Add(Grid.PosToCell(___targetPos));
}
}
public override void EndTransition(Navigator navigator, Navigator.ActiveTransition transition)
{
base.EndTransition(navigator, transition);
bool flag = (transition.start == NavType.Pole || transition.end == NavType.Pole) && transition.y < 0 && transition.x == 0;
bool flag2 = transition.start == NavType.Tube || transition.end == NavType.Tube;
if (!isWalking && !flag && !flag2 && (Object)attributeLevels != (Object)null)
{
attributeLevels.AddExperience(Db.Get().Attributes.Athletics.Id, Time.time - startTime, DUPLICANTSTATS.ATTRIBUTE_LEVELING.ALL_DAY_EXPERIENCE);
}
}
public override bool InternalCanBegin(GameObject new_reactor, Navigator.ActiveTransition transition)
{
if (base.InternalCanBegin(new_reactor, transition))
{
PrimaryElement component = new_reactor.GetComponent <PrimaryElement>();
if ((UnityEngine.Object)component != (UnityEngine.Object)null)
{
return(component.DiseaseIdx != 255);
}
}
return(false);
}
public override bool InternalCanBegin(GameObject new_reactor, Navigator.ActiveTransition transition)
{
if (base.InternalCanBegin(new_reactor, transition))
{
Storage component = new_reactor.GetComponent <Storage>();
if ((UnityEngine.Object)component != (UnityEngine.Object)null && (UnityEngine.Object)GetFirstInfected(component) != (UnityEngine.Object)null)
{
return(true);
}
}
return(false);
}
public override void EndTransition(Navigator navigator, Navigator.ActiveTransition transition)
{
base.EndTransition(navigator, transition);
foreach (Door door in doors)
{
if ((Object)door != (Object)null)
{
door.Close();
}
}
doors.Clear();
}
public override void BeginTransition(Navigator navigator, Navigator.ActiveTransition transition)
{
base.BeginTransition(navigator, transition);
CreatureCalorieMonitor.Instance sMI = navigator.GetSMI <CreatureCalorieMonitor.Instance>();
if (sMI != null && sMI.stomach.IsReadyToPoop())
{
KBatchedAnimController component = navigator.GetComponent <KBatchedAnimController>();
string s = HashCache.Get().Get(transition.anim.HashValue) + "_full";
if (component.HasAnimation(s))
{
transition.anim = s;
}
}
}
public static void Postfix(Navigator navigator, ref Navigator.ActiveTransition transition, ref bool __state, ref TransitionDriver __instance)
{
if (!__state)
{
return;
}
if (transition.y > 0)
{
transition.speed *= 0.9f;
transition.animSpeed *= 0.9f;
}
else
{
transition.speed *= 1.5f;
transition.animSpeed *= 1.5f;
}
}
public override void BeginTransition(Navigator navigator, Navigator.ActiveTransition transition)
{
base.BeginTransition(navigator, transition);
ReactionMonitor.Instance reaction_monitor = navigator.GetSMI <ReactionMonitor.Instance>();
reaction_monitor.PollForReactables(transition);
if (reaction_monitor.IsReacting())
{
transition.anim = null;
transition.isLooping = false;
transition.end = transition.start;
transition.speed = 1f;
transition.animSpeed = 1f;
transition.x = 0;
transition.y = 0;
transition.isCompleteCB = (() => !reaction_monitor.IsReacting());
}
}
public override bool InternalCanBegin(GameObject newReactor, Navigator.
ActiveTransition transition)
{
bool disposed = checkpoint?.workable == null;
if (disposed)
{
Cleanup();
}
bool canBegin = !disposed && reactor == null;
if (canBegin)
{
canBegin = MustStop(newReactor, transition.x);
}
return(canBegin);
}
public override bool InternalCanBegin(GameObject reactor, Navigator.ActiveTransition transition)
{
if ((Object)reactor == (Object)null)
{
return(false);
}
Navigator component = reactor.GetComponent <Navigator>();
if ((Object)component == (Object)null)
{
return(false);
}
if (!component.IsMoving())
{
return(false);
}
return((Object)gameObject == (Object)reactor);
}
public void PollForReactables(Navigator.ActiveTransition transition)
{
if (!IsReacting())
{
if (justReacted)
{
justReacted = false;
}
else
{
lastReactable = null;
}
for (int num = oneshotReactables.Count - 1; num >= 0; num--)
{
Reactable reactable = oneshotReactables[num];
if (reactable.IsExpired())
{
reactable.Cleanup();
}
}
int cell = Grid.PosToCell(base.smi.gameObject);
ListPool <ScenePartitionerEntry, ReactionMonitor> .PooledList pooledList = ListPool <ScenePartitionerEntry, ReactionMonitor> .Allocate();
GameScenePartitioner instance = GameScenePartitioner.Instance;
Vector2I vector2I = Grid.CellToXY(cell);
int x = vector2I.x;
Vector2I vector2I2 = Grid.CellToXY(cell);
instance.GatherEntries(x, vector2I2.y, 1, 1, GameScenePartitioner.Instance.objectLayers[0], pooledList);
for (int i = 0; i < pooledList.Count; i++)
{
Reactable reactable2 = pooledList[i].obj as Reactable;
if (reactable2 != null && reactable2 != lastReactable && (!lastReactTimes.ContainsKey(reactable2.id) || !(GameClock.Instance.GetTime() - lastReactTimes[reactable2.id] < reactable2.minReactorTime)) && reactable2.CanBegin(base.gameObject, transition))
{
justReacted = true;
lastReactable = reactable2;
lastReactTimes[reactable2.id] = GameClock.Instance.GetTime();
base.sm.reactable.Set(reactable2, base.smi);
base.smi.GoTo(base.sm.reacting);
break;
}
}
pooledList.Recycle();
}
}
/// <summary>
/// Swap the dupes facing before starting the reactable
/// </summary>
static void Prefix(GameObject new_reactor, Navigator.ActiveTransition transition)
{
PrimaryElement dupe = new_reactor?.GetComponent <PrimaryElement>();
if (dupe != null)
{
Navigator navigator = dupe.GetComponent <Navigator>();
if (navigator != null)
{
NavGrid.Transition nextTransition = navigator.GetNextTransition();
if (nextTransition.x < 0)
{
// Mirror dupes facing direction to the initial direction
dupe.GetComponent <Facing>()?.SetFacing(true);
}
}
}
}
public override bool InternalCanBegin(GameObject new_reactor, Navigator.ActiveTransition transition)
{
if ((UnityEngine.Object)reactor != (UnityEngine.Object)null)
{
return(false);
}
if ((UnityEngine.Object)checkpoint == (UnityEngine.Object)null)
{
Cleanup();
return(false);
}
if (!checkpoint.RedLight)
{
return(false);
}
if (rotated)
{
return(transition.x < 0);
}
return(transition.x > 0);
}
public override void EndTransition(Navigator navigator, Navigator.ActiveTransition transition)
{
base.EndTransition(navigator, transition);
if (transition.end == NavType.Ladder)
{
int cell = Grid.PosToCell(navigator);
GameObject gameObject = Grid.Objects[cell, 1];
if ((Object)gameObject != (Object)null)
{
PrimaryElement component = gameObject.GetComponent <PrimaryElement>();
if ((Object)component != (Object)null)
{
PrimaryElement component2 = navigator.GetComponent <PrimaryElement>();
if ((Object)component2 != (Object)null)
{
SimUtil.DiseaseInfo invalid = SimUtil.DiseaseInfo.Invalid;
invalid.idx = component2.DiseaseIdx;
invalid.count = (int)((float)component2.DiseaseCount * 0.005f);
SimUtil.DiseaseInfo invalid2 = SimUtil.DiseaseInfo.Invalid;
invalid2.idx = component.DiseaseIdx;
invalid2.count = (int)((float)component.DiseaseCount * 0.005f);
component2.ModifyDiseaseCount(-invalid.count, "Navigator.EndTransition");
component.ModifyDiseaseCount(-invalid2.count, "Navigator.EndTransition");
if (invalid.count > 0)
{
component.AddDisease(invalid.idx, invalid.count, "TransitionDriver.EndTransition");
}
if (invalid2.count > 0)
{
component2.AddDisease(invalid2.idx, invalid2.count, "TransitionDriver.EndTransition");
}
}
}
}
}
}
private bool NotInATube(GameObject go, Navigator.ActiveTransition transition)
{
return(transition.navGridTransition.start != NavType.Tube && transition.navGridTransition.end != NavType.Tube);
}
private bool ReactorIsOnFloor(GameObject reactor, Navigator.ActiveTransition transition)
{
return(transition.end == NavType.Floor);
}
public override bool InternalCanBegin(GameObject reactor, Navigator.ActiveTransition transition)
{
return(cleaner.operational.IsActive && !reactor.GetSicknesses().Has(Db.Get().
Sicknesses.Sunburn));
}
public override void EndTransition(Navigator navigator, Navigator.
ActiveTransition transition)
{
base.EndTransition(navigator, transition);
ClearTransitions();
}
public override void BeginTransition(Navigator navigator, Navigator.ActiveTransition transition)
{
base.BeginTransition(navigator, transition);
}
public abstract bool InternalCanBegin(GameObject reactor, Navigator.ActiveTransition transition);
public override void BeginTransition(Navigator navigator, Navigator.ActiveTransition transition)
{
base.BeginTransition(navigator, transition);
float num = 1f;
bool flag = (transition.start == NavType.Pole || transition.end == NavType.Pole) && transition.y < 0 && transition.x == 0;
bool flag2 = transition.start == NavType.Tube || transition.end == NavType.Tube;
bool flag3 = transition.start == NavType.Hover || transition.end == NavType.Hover;
if (!flag && !flag2 && !flag3)
{
if (isWalking)
{
return;
}
num = GetMovementSpeedMultiplier(navigator);
}
int cell = Grid.PosToCell(navigator);
float num2 = 1f;
bool flag4 = (navigator.flags & PathFinder.PotentialPath.Flags.HasAtmoSuit) != PathFinder.PotentialPath.Flags.None;
if ((navigator.flags & PathFinder.PotentialPath.Flags.HasJetPack) == PathFinder.PotentialPath.Flags.None && !flag4 && Grid.IsSubstantialLiquid(cell, 0.35f))
{
num2 = 0.5f;
}
num *= num2;
if (transition.x == 0 && (transition.start == NavType.Ladder || transition.start == NavType.Pole) && transition.start == transition.end)
{
if (flag)
{
transition.speed = 15f * num2;
}
else
{
transition.speed = ladderSpeed * num;
GameObject gameObject = Grid.Objects[cell, 1];
if ((Object)gameObject != (Object)null)
{
Ladder component = gameObject.GetComponent <Ladder>();
if ((Object)component != (Object)null)
{
float num3 = component.upwardsMovementSpeedMultiplier;
if (transition.y < 0)
{
num3 = component.downwardsMovementSpeedMultiplier;
}
transition.speed *= num3;
transition.animSpeed *= num3;
}
}
}
}
else if (flag2)
{
transition.speed = 18f;
}
else if (flag3)
{
transition.speed = jetPackSpeed;
}
else
{
transition.speed = floorSpeed * num;
}
float num4 = num - 1f;
transition.animSpeed += transition.animSpeed * num4 / 2f;
if (transition.start == NavType.Floor && transition.end == NavType.Floor)
{
int num5 = Grid.CellBelow(cell);
if (Grid.Foundation[num5])
{
GameObject gameObject2 = Grid.Objects[num5, 1];
if ((Object)gameObject2 != (Object)null)
{
SimCellOccupier component2 = gameObject2.GetComponent <SimCellOccupier>();
if ((Object)component2 != (Object)null)
{
transition.speed *= component2.movementSpeedMultiplier;
transition.animSpeed *= component2.movementSpeedMultiplier;
}
}
}
}
startTime = Time.time;
}
public override void UpdateTransition(Navigator navigator, Navigator.ActiveTransition transition)
{
base.UpdateTransition(navigator, transition);
}
public static void Prefix(Navigator navigator, ref Navigator.ActiveTransition transition, ref bool __state)
{
__state = false;
if (transition.navGridTransition.isCritter)
{
return;
}
if (transition.y != 1 && transition.y != -1)
{
return;
}
if (transition.x != 1 && transition.x != -1)
{
return;
}
if (transition.start != NavType.Floor || transition.end != NavType.Floor)
{
return;
}
int num = Grid.PosToCell(navigator);
//if (MyGrid.IsStair(num)) return;
if (transition.y > 0)
{
num = Grid.OffsetCell(num, transition.x, 0);
if (transition.x > 0)
{
if (MyGrid.IsRightSet(num))
{
return;
}
}
else
{
if (!MyGrid.IsRightSet(num))
{
return;
}
}
}
else
{
num = Grid.OffsetCell(num, 0, transition.y);
if (transition.x > 0)
{
if (!MyGrid.IsRightSet(num))
{
return;
}
}
else
{
if (MyGrid.IsRightSet(num))
{
return;
}
}
}
if (!MyGrid.IsWalkable(num))
{
return;
}
transition.isLooping = true;
transition.anim = "floor_floor_1_0_loop";
__state = true;
}
