Exemple #1
0
        public static bool OrderSequence_OnComplete_Prefix(OrderSequence __instance, AbstractActor ___owningActor)
        {
            if (__instance is SensorLockSequence && PilotHasFreeSensorLockAbility(___owningActor))
            {
                Mod.Log.Trace?.Write($"OS:OC entered, cm:{__instance.ConsumesMovement} cf:{__instance.ConsumesFiring}");
                Mod.Log.Trace?.Write($"    oa:{___owningActor.DisplayName}_{___owningActor.GetPilot().Name} hasFired:{___owningActor.HasFiredThisRound} hasMoved:{___owningActor.HasMovedThisRound} hasActivated:{___owningActor.HasActivatedThisRound}");
                Mod.Log.Trace?.Write($"    ca:{__instance.ConsumesActivation} fae:{__instance.ForceActivationEnd}");

                Mod.Log.Trace?.Write(" SensorLockSequence, skipping.");

                Mod.Log.Trace?.Write(" Clearing shown list");
                Traverse.Create(__instance).Method("ClearShownList").GetValue();
                Mod.Log.Trace?.Write(" Clearing camera");
                Traverse.Create(__instance).Method("ClearCamera").GetValue();
                Mod.Log.Trace?.Write(" Clearing focal point");
                Traverse.Create(__instance).Method("ClearFocalPoint").GetValue();
                if (__instance.CompletedCallback != null)
                {
                    Mod.Log.Trace?.Write(" Getting SequenceFinished");
                    var seqFinished = Traverse.Create(__instance).Property("CompletedCallback").GetValue <SequenceFinished>();
                }

                return(true);
            }
            else
            {
                //Mod.Log.Trace?.Write(" Not SensorLockSequence, continuing.");
                return(true);
            }
        }
Exemple #2
0
 static void Postfix(OrderSequence __instance)
 {
     if (CombatLog.combatChatModule != null)
     {
         CombatLog.combatChatModule.ForceRefreshImmediate();
     }
 }
Exemple #3
0
 public static void OrderSequence_ConsumesActivation_Postfix(OrderSequence __instance, ref bool __result, AbstractActor ___owningActor)
 {
     if (__instance is SensorLockSequence || (__instance is ActiveProbeSequence && Mod.Config.Combat.FlexibleSensorLock.AlsoAppliesToActiveProbe))
     {
         __result = true;
         if (ActorHasFreeSensorLock(___owningActor))
         {
             __result = false;
         }
         Mod.Log.Debug?.Write($" OrderSequence_ConsumesActivation_Postfix - returning [{__result}].");
     }
 }
Exemple #4
0
            // Token: 0x060000F1 RID: 241 RVA: 0x0001427C File Offset: 0x0001247C
            public static void Prefix(OrderSequence __instance, ref bool __state)
            {
                __state = false;
                Mech mech = __instance.owningActor as Mech;

                if (__instance == null || __instance.owningActor == null || mech == null)
                {
                    return;
                }
                Traverse traverse = Traverse.Create(__instance).Property("sequenceIsComplete", null);

                __state = traverse.GetValue <bool>();
            }
            public static void Prefix(OrderSequence __instance, ref bool __state)
            {
                __state = false;

                Mech mech = __instance.owningActor as Mech;

                if (__instance == null || __instance.owningActor == null || mech == null)
                {
                    return;                                                                       // Nothing to do
                }
                // sequenceIsComplete should be false here, but true in the postfix
                Traverse sequenceIsCompleteT = Traverse.Create(__instance).Property("sequenceIsComplete");

                __state = sequenceIsCompleteT.GetValue <bool>();
            }
 public static void OrderSequence_ConsumesActivation_Postfix(OrderSequence __instance, ref bool __result, AbstractActor ___owningActor)
 {
     if (__instance is SensorLockSequence)
     {
         //Mod.Log.Trace($"SLS:CA entered, cm:{__instance.ConsumesMovement} cf:{__instance.ConsumesFiring}");
         //Mod.Log.Trace($"    oa:{___owningActor.DisplayName}_{___owningActor.GetPilot().Name} hasFired:{___owningActor.HasFiredThisRound} hasMoved:{___owningActor.HasMovedThisRound} hasActivated:{___owningActor.HasActivatedThisRound}");
         if (___owningActor.HasFiredThisRound && ___owningActor.HasMovedThisRound)
         {
             Mod.Log.Debug(" Owner has moved and fired, returning true.");
             __result = false;
         }
         else
         {
             //Mod.Log.Trace(" Returning false");
             __result = false;
         }
     }
 }
Exemple #7
0
            public static void Postfix(OrderSequence __instance)
            {
                try
                {
                    //if (__instance.owningActor.team.IsLocalPlayer)
                    if (__instance.owningActor.team.LocalPlayerControlsTeam)
                    {
                        return;
                    }

                    Logger.Debug($"[OrderSequence_OnComplete_POSTFIX] Restoring camera position");

                    CameraControl.Instance.SetMovingToGroundPos(Fields.lastGroundPos, 0.95f);
                }
                catch (Exception e)
                {
                    Logger.Error(e);
                }
            }
Exemple #8
0
 public static void OrderSequence_ConsumesActivation_Postfix(OrderSequence __instance, ref bool __result, AbstractActor ___owningActor)
 {
     if (__instance is SensorLockSequence)
     {
         __result = true;
         if (!Mod.Config.Combat.FlexibleSensorLock.FreeActionWithAbility)
         {
             Mod.Log.Debug?.Write(" OrderSequence_ConsumesActivation_Postfix - Sensor Lock is always a free ability, setting __result to false...");
             // If we're in this method and haven't set sensor lock to be free with an ability, FlexibleSensorLock has been enabled and patched, so we always return false.
             __result = false;
         }
         else
         {
             // Check if the pilot has the associated ability ID, and return true if so...
             Mod.Log.Debug?.Write($" OrderSequence_ConsumesActivation_Postfix - Sensor Lock is paired with ability [{Mod.Config.Abilities.FlexibleSensorLockId}], checking pilot...");
             if (PilotHasFreeSensorLockAbility(___owningActor?.GetPilot()))
             {
                 Mod.Log.Debug?.Write($" OrderSequence_ConsumesActivation_Postfix - Sensor Lock paired ability [{Mod.Config.Abilities.FlexibleSensorLockId}] found, setting true...");
                 __result = false;
             }
         }
         Mod.Log.Debug?.Write($" OrderSequence_ConsumesActivation_Postfix - returning [{__result}].");
     }
 }
Exemple #9
0
            public static void Prefix(OrderSequence __instance)
            {
                try
                {
                    //if (__instance.owningActor.team.IsLocalPlayer)
                    if (__instance.owningActor.team.LocalPlayerControlsTeam)
                    {
                        return;
                    }

                    Logger.Debug($"[OrderSequence_OnAdded_PREFIX] Saving current camera position");

                    Fields.lastCameraPos = CameraControl.Instance.CameraPos;
                    Fields.lastCameraRot = CameraControl.Instance.CameraRot;
                    Fields.lastGroundPos = CameraControl.Instance.ScreenCenterToGroundPosition;
                    Logger.Debug($"[OrderSequence_OnAdded_PREFIX] Fields.lastCameraPos: {Fields.lastCameraPos}");
                    Logger.Debug($"[OrderSequence_OnAdded_PREFIX] Fields.lastCameraRot: {Fields.lastCameraRot}");
                    Logger.Debug($"[OrderSequence_OnAdded_PREFIX] Fields.lastGroundPos: {Fields.lastGroundPos}");
                }
                catch (Exception e)
                {
                    Logger.Error(e);
                }
            }
            public static void Postfix(OrderSequence __instance, bool __state)
            {
                Mech mech = __instance.owningActor as Mech;

                if (__instance == null || __instance.owningActor == null || mech == null)
                {
                    return;                                                                       // Nothing to do
                }
                Mod.ActivationLog.Debug?.Write($"OS:OU - entered for Mech: {CombatantUtils.Label(mech)} with autoBrace: {mech.AutoBrace}");

                // If state is true, orders were complete before we headed into the sequence, so skip
                if (__state)
                {
                    return;
                }

                // If the seqeuence doesn't consume activation, it's not one we target. Ignore it.
                if (!__instance.ConsumesActivation)
                {
                    Mod.ActivationLog.Debug?.Write($" -- !consumesActivation: {__instance.ConsumesActivation}, skipping");
                    return;
                }

                if (mech.IsShutDown)
                {
                    Mod.ActivationLog.Debug?.Write(" -- Mech is shutdown, assuming a MechStartupSequence will handle this - skipping.");
                    return;
                }

                bool isInterleaved = SharedState.Combat?.TurnDirector?.IsInterleaved == true;

                if (isInterleaved)
                {
                    Mod.ActivationLog.Debug?.Write(" -- Combat is interleaved, should be handled by OnUpdate() or MechStartupSequence - skipping.");
                    return;
                }

                DoneWithActorSequence dwaSeq = __instance as DoneWithActorSequence;

                if (dwaSeq != null)
                {
                    Mod.ActivationLog.Debug?.Write($" -- sequence is DoneWithActorSequence: {dwaSeq != null}, skipping.");
                    return; // Either a complete ending sequence, or the specific sequence doesn't consume activation so return
                }

                // Finally, check to see if the sequence isn't complete yet
                Traverse sequenceIsCompleteT = Traverse.Create(__instance).Property("sequenceIsComplete");
                bool     sequenceIsComplete  = sequenceIsCompleteT.GetValue <bool>();

                if (!sequenceIsComplete)
                {
                    Mod.ActivationLog.Debug?.Write($" -- !sequenceIsComplete: {sequenceIsComplete}, skipping");
                    return;
                }

                // At this point, ___state should be false and sequenceIsComplete is true. This represents OnUpdate flipping the value during it's processing.
                Mod.ActivationLog.Info?.Write($" -- AT ACTIVATION END, checking for heat sequence creation. ");
                Mod.ActivationLog.Info?.Write($"  -- isInterleavePending => {SharedState.Combat?.TurnDirector?.IsInterleavePending}  " +
                                              $"highestEnemyContactLevel => {SharedState.Combat?.LocalPlayerTeam?.VisibilityCache.HighestEnemyContactLevel}");

                // By default OrderSequence:OnUpdate doesn't apply a MechHeatSequence if you are in non-interleaved mode. Why? I don't know. Force it to add one here.
                MechHeatSequence heatSequence = mech.GenerateEndOfTurnHeat(__instance);

                if (heatSequence != null)
                {
                    Mod.ActivationLog.Info?.Write($" -- Creating heat sequence for non-interleaved mode");
                    __instance.AddChildSequence(heatSequence, __instance.MessageIndex);
                }
                else
                {
                    Mod.ActivationLog.Warn?.Write($"FAILED TO CREATE HEAT SEQUENCE FOR MECH: {mech.DistinctId()} - UNIT WILL CONTINUE TO GAIN HEAT!");
                }
            }
Exemple #11
0
            // Token: 0x060000F2 RID: 242 RVA: 0x000142C4 File Offset: 0x000124C4
            public static void Postfix(OrderSequence __instance, bool __state)
            {
                Mech mech = __instance.owningActor as Mech;

                if (__instance == null || __instance.owningActor == null || mech == null)
                {
                    return;
                }

                if (__state)
                {
                    return;
                }

                if (!__instance.ConsumesActivation)
                {
                    Mod.Log.Debug($" -- !consumesActivation: {__instance.ConsumesActivation}, skipping");
                    return;
                }

                if (mech.IsShutDown)
                {
                    Mod.Log.Debug(" -- Mech is shutdown, assuming a MechStartupSequence will handle this - skipping.");
                    return;
                }

                bool isInterleaved = true;

                if (isInterleaved)
                {
                    Mod.Log.Debug(" -- Combat is interleaved, should be handled by OnUpdate() or MechStartupSequence - skipping.");
                    return;
                }

                DoneWithActorSequence dwaSeq = __instance as DoneWithActorSequence;

                if (dwaSeq != null)
                {
                    Mod.Log.Debug($" -- sequence is DoneWithActorSequence: {dwaSeq != null}, skipping.");
                    return;
                }

                Traverse sequenceIsCompleteT = Traverse.Create(__instance).Property("sequenceIsComplete");
                bool     sequenceIsComplete  = sequenceIsCompleteT.GetValue <bool>();

                if (!sequenceIsComplete)
                {
                    Mod.Log.Debug($" -- !sequenceIsComplete: {sequenceIsComplete}, skipping");
                    return;
                }

                MechHeatSequence heatSequence = mech.GenerateEndOfTurnHeat(__instance);

                if (heatSequence != null)
                {
                    Mod.Log.Debug($" -- Creating heat sequence for non-interleaved mode");
                    __instance.AddChildSequence(heatSequence, __instance.MessageIndex);
                }
                else
                {
                    Mod.Log.Trace($"FAILED TO CREATE HEAT SEQUENCE FOR MECH: {mech} - UNIT WILL CONTINUE TO GAIN HEAT!");
                }
            }