static bool Prefix(AbstractActor __instance, MessageCenterMessage message) { if (ModState.CurrentSpawningLance != null && __instance != null) { ActorDestroyedMessage actorDestroyedMessage = message as ActorDestroyedMessage; if (actorDestroyedMessage != null && actorDestroyedMessage.HasAffectedObject && (actorDestroyedMessage.affectedObjectGuid == __instance.standingOnBuildingGuid || actorDestroyedMessage.affectedObjectGuid == __instance.standingOnBuildingGuid + ".Building") && __instance.LanceId == ModState.CurrentSpawningLance.GUID ) { Mod.Log.Debug?.Write("Intercepted displacement message for ambush spawns."); // Replay displacement w/o effects Vector3 vector = __instance.CurrentPosition; vector.y = __instance.Combat.MapMetaData.GetLerpedHeightAt(__instance.CurrentPosition, false); if (__instance.GameRep != null) { __instance.GameRep.transform.position = vector; } __instance.OnPositionUpdate(vector, __instance.CurrentRotation, -1, true, null, false); return(false); } } return(true); }
public static void Postfix(AttackDirector __instance, MessageCenterMessage message) { Mod.Log.Debug?.Write("AD:OASB - entered."); AttackSequenceBeginMessage asbMessage = message as AttackSequenceBeginMessage; if (__instance == null || asbMessage == null) { return; } int sequenceId = asbMessage.sequenceId; AttackDirector.AttackSequence attackSequence = __instance.GetAttackSequence(sequenceId); if (attackSequence == null) { Mod.Log.Debug?.Write($"AttackSequence not found - created by a mod or CAC watchdog killed it. Skipping!"); ModState.BreachAttackId = ModState.NO_ATTACK_SEQUENCE_ID; } // No chosen target, nothing to damage if (attackSequence.chosenTarget == null) { return; } Mod.Log.Debug?.Write($"Recording attackSequence: {attackSequence.id} for possible hull breaches."); ModState.BreachAttackId = attackSequence.id; }
public override bool Evaluate(MessageCenterMessage message, string responseName) { base.Evaluate(message, responseName); EncounterObjectStateChangeMessage encounterMessage = message as EncounterObjectStateChangeMessage; // Main.LogDebug("[EncounterObjectMatchesStateConditional] Evaluating..."); if (State == EncounterObjectStatus.Nothing) { Main.Logger.LogError($"[EncounterObjectMatchesStateConditional] Trying to use this conditional without setting State to check against. You must set state."); return(false); } if (encounterMessage != null && encounterMessage.EncounterGuid == this.EncounterGuid) { base.LogEvaluationPassed("[EncounterObjectMatchesStateConditional] Encounter guid matches guid of message.", responseName); if (encounterMessage.State == this.State) { Main.LogDebug($"[EncounterObjectMatchesStateConditional] Encounter guid and State matched for '{responseName}'"); return(true); } } // Main.LogDebug($"[EncounterObjectMatchesStateConditional] Encounter guid and/or State did NOT match for '{responseName}'"); base.LogEvaluationFailed("[EncounterObjectMatchesStateConditional] Encounter guid did NOT match guid of message.", responseName); return(false); }
public static void Postfix(AttackDirector __instance, MessageCenterMessage message) { CustomAmmoCategoriesLog.Log.LogWrite($"Try jamm weapon\n"); while (JammingEnabler.jammQueue.Count > 0) { AbstractActor actor = JammingEnabler.jammQueue.Dequeue(); CustomAmmoCategoriesLog.Log.LogWrite($"Try jamm weapon of " + actor.DisplayName + "\n"); foreach (Weapon weapon in actor.Weapons) { CustomAmmoCategoriesLog.Log.LogWrite($" weapon " + weapon.UIName + " rounds since last fire " + weapon.roundsSinceLastFire + "\n"); if (weapon.roundsSinceLastFire > 0) { continue; } float flatJammingChance = CustomAmmoCategories.getWeaponFlatJammingChance(weapon); CustomAmmoCategoriesLog.Log.LogWrite($" flatJammingChance " + flatJammingChance + "\n"); if (flatJammingChance > CustomAmmoCategories.Epsilon) { CustomAmmoCategoriesLog.Log.LogWrite($" Try jamm weapon " + weapon.UIName + "\n"); float Roll = Random.Range(0.0f, 1.0f); CustomAmmoCategoriesLog.Log.LogWrite($" Jamming chance " + flatJammingChance + " roll " + Roll + "\n"); if (Roll < flatJammingChance) { CustomAmmoCategoriesLog.Log.LogWrite($" Jammed!\n"); CustomAmmoCategories.AddJam(actor, weapon); } } if (CustomAmmoCategories.getWeaponCooldown(weapon) > 0) { CustomAmmoCategories.AddCooldown(actor, weapon); } } } }
static void Postfix(TurnDirector __instance, MessageCenterMessage message) { Mod.Log.Trace?.Write("TD:OICC - entered."); // Iterate contract objectives List <ITaggedItem> objectsOfType = SharedState.Combat.ItemRegistry.GetObjectsOfType(TaggedObjectType.Objective); List <ObjectiveGameLogic> objectives = objectsOfType.ConvertAll((ITaggedItem x) => x as ObjectiveGameLogic); foreach (ObjectiveGameLogic ogl in objectives) { Mod.Log.Debug?.Write($" -- objective: {ogl.DisplayName} has: {ogl.GetTargetUnits().Count} targets"); foreach (ICombatant combatant in ogl.GetTargetUnits()) { if (combatant is BattleTech.Building building) { BattleTech.Building scaledBuilding = building; if (!ModState.ScaledObjectiveBuildings.Contains(building.DistinctId())) { building.ScaleHealth(); ModState.ScaledObjectiveBuildings.Add(building.DistinctId()); } else { Mod.Log.Debug?.Write($" -- building: {building.DistinctId()} was already scaled, skipping"); } } } } }
public static void Prefix(MechDFASequence __instance, ref MessageCenterMessage message) { // Only remove entrenched if the attach actually did hit? /* * AttackCompleteMessage attackCompleteMessage = (AttackCompleteMessage)message; * if (attackCompleteMessage.attackSequence.attackCompletelyMissed) * { * return; * } */ // Get melee target ICombatant DFATarget = (ICombatant)AccessTools.Property(typeof(MechDFASequence), "DFATarget").GetValue(__instance, null); if (DFATarget is Mech TargetMech) { // Remove Entrenched if (TargetMech.IsEntrenched) { Logger.Debug("[MechDFASequence_OnMeleeComplete_PREFIX] Removing Entrenched from target"); TargetMech.IsEntrenched = false; TargetMech.Combat.MessageCenter.PublishMessage(new FloatieMessage(TargetMech.GUID, TargetMech.GUID, "LOST: ENTRENCHED", FloatieMessage.MessageNature.Debuff)); } else { Logger.Debug("[MechDFASequence_OnMeleeComplete_PREFIX] Target wasn't entrenched"); } } }
public override void Trigger(MessageCenterMessage inMessage, string triggeringName) { Main.LogDebug($"[SetTeamShareVisionWithAlliesResult] Setting Team '{Team}' to share vision with allies '{ShareVision}'"); Team team = UnityGameInstance.BattleTechGame.Combat.ItemRegistry.GetItemByGUID <Team>(TeamUtils.GetTeamGuid(Team)); // Visibility stuff might be a bit too early here /* * team.VisibilityCache = null; * AccessTools.Property(typeof(Team), "ShareVisionWithAlliance").SetValue(team, ShareVision); * AccessTools.Method(typeof(Team), "InitVisibilityCaches").Invoke(team, null); * * foreach (Lance lance in team.lances) { * AccessTools.Method(typeof(Lance), "InitVisibilityCache").Invoke(lance, null); * } */ /* * Main.LogDebug($"[SetTeamShareVisionWithAlliesResult] Units in team are: '{team.units.Count}'"); * team.units.ForEach(unit => { * Main.LogDebug($"[SetTeamShareVisionWithAlliesResult] Hiding unit '{unit.DisplayName}'"); * unit.OnPlayerVisibilityChanged(VisibilityLevel.None); * }); */ }
public static bool Prefix(ref MessageCenterMessage message, AttackDirector.AttackSequence __instance) { Logger.Debug("hit prefix"); var attackSequenceResolveDamageMessage = (AttackSequenceResolveDamageMessage)message; var hitInfo = attackSequenceResolveDamageMessage.hitInfo; if (hitInfo.attackSequenceId != __instance.id) { return(true); } var messageCoordinator = Traverse.Create(__instance).Field("messageCoordinator").GetValue <MessageCoordinator>(); if (!messageCoordinator.CanProcessMessage(attackSequenceResolveDamageMessage)) { return(true); } var attackGroupIndex = attackSequenceResolveDamageMessage.hitInfo.attackGroupIndex; var attackWeaponIndex = attackSequenceResolveDamageMessage.hitInfo.attackWeaponIndex; var weapon = __instance.GetWeapon(attackGroupIndex, attackWeaponIndex); if (__instance.meleeAttackType != MeleeAttackType.DFA) { return(true); } var attacker = __instance.attacker; var rawDFASelfDamageValue = attacker.StatCollection.GetValue <float>("DFASelfDamage"); var dfaSelfDamageValue = rawDFASelfDamageValue; if (Core.ModSettings.PilotingSkillDFASelfDamageMitigation) { // TODO: hook up water physics // var superAlphaWaterFactor = 1f; // if ((attacker as Mech).occupiedDesignMask.Description.Id == "DesignMaskWater") // superAlphaWaterFactor = 2f; var mitigation = Calculator.PilotingMitigation(attacker); var mitigationPercent = Mathf.RoundToInt(mitigation * 100); dfaSelfDamageValue = rawDFASelfDamageValue - (rawDFASelfDamageValue * mitigation); Logger.Debug($"dfa miss numbers\n" + $"pilotSkill: {attacker.SkillPiloting}\n" + $"mitigation: {mitigation}\n" + $"rawDFASelfDamageValue: {rawDFASelfDamageValue}\n" + $"mitigationPercent: {mitigationPercent}\n" + $"dfaSelfDamageValue: {dfaSelfDamageValue}"); attacker.Combat.MessageCenter.PublishMessage(new AddSequenceToStackMessage(new ShowActorInfoSequence(attacker, $"Pilot Check: Avoided {mitigationPercent}% DFA Self-Damage!", FloatieMessage.MessageNature.Neutral, true))); } attacker.TakeWeaponDamage(attackSequenceResolveDamageMessage.hitInfo, (int)ArmorLocation.LeftLeg, weapon, dfaSelfDamageValue, 0, DamageType.DFASelf); attacker.TakeWeaponDamage(attackSequenceResolveDamageMessage.hitInfo, (int)ArmorLocation.RightLeg, weapon, dfaSelfDamageValue, 0, DamageType.DFASelf); if (AttackDirector.damageLogger.IsLogEnabled) { AttackDirector.damageLogger.Log($"@@@@@@@@ {attacker.DisplayName} takes {dfaSelfDamageValue} damage to its legs from the DFA attack!"); } return(true); }
public override void Trigger(MessageCenterMessage inMessage, string triggeringName) { Main.LogDebug("[EndCombatResult] Ending combat..."); MissionRetreatMessage message = new MissionRetreatMessage(this.IsGoodFaithEffort()); UnityGameInstance.BattleTechGame.MessageCenter.PublishMessage(message); }
public static bool Prefix(CombatHUD __instance, MessageCenterMessage message) { try { TriggerDialog triggerDialog = message as TriggerDialog; if (triggerDialog == null) { return(false); } if ( triggerDialog.DialogID == __instance.Combat.Constants.RavenTutorialDialogID || triggerDialog.DialogID == __instance.Combat.Constants.Story2TutorialSlides1ID || triggerDialog.DialogID == __instance.Combat.Constants.Story2TutorialSlides2ID || triggerDialog.DialogID == __instance.Combat.Constants.Story2TutorialSlides3ID || triggerDialog.DialogID == __instance.Combat.Constants.Story2TutorialSlides4ID ) { Logger.Debug("[CombatHUD_OnTriggerDialog_PREFIX] Supress tutorial: " + triggerDialog.DialogID); return(false); } return(true); } catch (Exception e) { Logger.Error(e); return(true); } }
public static void Postfix(AttackStackSequence __instance, MessageCenterMessage message) { try { Logger.Debug($"[AttackStackSequence_OnAttackBegin_POSTFIX] Focus on attacked target..."); CombatGameState ___combatGameState = (CombatGameState)AccessTools.Property(typeof(AttackStackSequence), "Combat").GetValue(__instance, null); AttackSequenceBeginMessage attackSequenceBeginMessage = message as AttackSequenceBeginMessage; AttackDirector.AttackSequence attackSequence = ___combatGameState.AttackDirector.GetAttackSequence(attackSequenceBeginMessage.sequenceId); bool isChosenTargetFriendly = attackSequence.chosenTarget.team.GUID == ___combatGameState.LocalPlayerTeamGuid || ___combatGameState.HostilityMatrix.IsLocalPlayerFriendly(attackSequence.chosenTarget.team.GUID); bool shouldFocus = (CameraUnchained.Settings.FocusOnTargetedFriendly && isChosenTargetFriendly) || (CameraUnchained.Settings.FocusOnTargetedEnemy && !isChosenTargetFriendly); Logger.Info($"[AttackStackSequence_OnAttackBegin_POSTFIX] isChosenTargetFriendly: {isChosenTargetFriendly}, shouldFocus: {shouldFocus}"); if (attackSequence == null || !shouldFocus) { return; } if (attackSequence.stackItemUID == __instance.SequenceGUID && !__instance.hasOwningSequence) { CameraControl.Instance.SetMovingToGroundPos(attackSequence.chosenTarget.CurrentPosition, 0.95f); } } catch (Exception e) { Logger.Error(e); } }
public override void Trigger(MessageCenterMessage inMessage, string triggeringName) { Main.LogDebug("[PositionRegion] Positioning Region..."); GameObject regionGo = GameObject.Find(RegionName); CombatGameState combatState = UnityGameInstance.BattleTechGame.Combat; Team playerTeam = combatState.LocalPlayerTeam; Vector3 centerOfTeamMass = GetCenterOfTeamMass(playerTeam, true); Vector3 possiblePosition = Vector3.zero; AbstractActor actor = combatState.AllActors.First((AbstractActor x) => x.TeamId == playerTeam.GUID); while (possiblePosition == Vector3.zero || !PathFinderManager.Instance.IsSpawnValid(regionGo, possiblePosition, actor.GameRep.transform.position, UnitType.Mech, $"PositionRegionResult.{RegionName}")) { Main.LogDebug($"[PositionRegion] {(possiblePosition == Vector3.zero ? "Finding possible position..." : "Trying again to find a possible position...")}"); possiblePosition = SceneUtils.GetRandomPositionFromTarget(centerOfTeamMass, Main.Settings.DynamicWithdraw.MinDistanceForZone, Main.Settings.DynamicWithdraw.MaxDistanceForZone); } regionGo.transform.position = possiblePosition; // Debug // GameObjextExtensions.CreateDebugPoint("DEBUGCenterofTeamMassGizmo", centerOfTeamMass, Color.red); // GameObjextExtensions.CreateDebugPoint("DEBUGDynamicWithdrawCenter", regionGo.transform.position, Color.blue); RegionGameLogic regionGameLogic = regionGo.GetComponent <RegionGameLogic>(); regionGameLogic.Regenerate(); }
public override void Trigger(MessageCenterMessage inMessage, string triggeringName) { Main.Logger.Log("[IssueCustomAIOrderResult] Triggered"); if ((this.issueAIOrderTo & IssueAIOrderTo.ToUnit) != IssueAIOrderTo.INVALID_UNSET) { List <ITaggedItem> objectsOfTypeWithTagSet = this.combat.ItemRegistry.GetObjectsOfTypeWithTagSet(TaggedObjectType.Unit, this.requiredReceiverTags); for (int i = 0; i < objectsOfTypeWithTagSet.Count; i++) { AbstractActor abstractActor = objectsOfTypeWithTagSet[i] as AbstractActor; AiManager.Instance.IssueAiOrder("UNIT", abstractActor.GUID, this.aiOrder); } } if ((this.issueAIOrderTo & IssueAIOrderTo.ToLance) != IssueAIOrderTo.INVALID_UNSET) { List <ITaggedItem> objectsOfTypeWithTagSet2 = this.combat.ItemRegistry.GetObjectsOfTypeWithTagSet(TaggedObjectType.Lance, this.requiredReceiverTags); for (int j = 0; j < objectsOfTypeWithTagSet2.Count; j++) { Lance lance = objectsOfTypeWithTagSet2[j] as Lance; AiManager.Instance.IssueAiOrder("LANCE", lance.GUID, this.aiOrder); } } if ((this.issueAIOrderTo & IssueAIOrderTo.ToTeam) != IssueAIOrderTo.INVALID_UNSET) { List <ITaggedItem> objectsOfTypeWithTagSet3 = this.combat.ItemRegistry.GetObjectsOfTypeWithTagSet(TaggedObjectType.Team, this.requiredReceiverTags); for (int k = 0; k < objectsOfTypeWithTagSet3.Count; k++) { Team team = objectsOfTypeWithTagSet3[k] as Team; AiManager.Instance.IssueAiOrder("TEAM", team.GUID, this.aiOrder); } } }
public static void Prefix(AttackStackSequence __instance, MessageCenterMessage message) { AttackCompleteMessage attackCompleteMessage = message as AttackCompleteMessage; bool ShouldPanic = false; bool IsEarlyPanic = false; Mech mech = null; if (attackCompleteMessage == null || attackCompleteMessage.stackItemUID != __instance.SequenceGUID) { return; } if (__instance.directorSequences[0].target is Mech) { mech = __instance.directorSequences[0].target as Mech; ShouldPanic = RollHelpers.ShouldPanic(mech, attackCompleteMessage.attackSequence); } if (mech == null || mech.GUID == null || attackCompleteMessage == null) { return; } Holder.SerializeActiveJson(); if (PanicHelpers.IsPanicking(mech, ref IsEarlyPanic) && BasicPanic.RollForEjectionResult(mech, attackCompleteMessage.attackSequence, IsEarlyPanic)) { mech.EjectPilot(mech.GUID, attackCompleteMessage.stackItemUID, DeathMethod.PilotEjection, false); } }
static void Postfix(ref MessageCenterMessage message, MechMeleeSequence __instance) { Logger.Debug($"checking for miss: {(message as AttackCompleteMessage).attackSequence.attackCompletelyMissed}"); if (Core.ModSettings.AttackMissInstability) { // Deal with attacker missing var attackCompleteMessage = (AttackCompleteMessage)message; var attacker = __instance.OwningMech; if (attackCompleteMessage.attackSequence.attackCompletelyMissed) { Logger.Debug($"melee pre-miss stability: {attacker.CurrentStability}"); var rawInstabilityToAdd = attacker.IsLegged ? Core.ModSettings.AttackMissInstabilityLeggedPercent : Core.ModSettings.AttackMissInstabilityPercent; var instabilityToAdd = rawInstabilityToAdd; if (Core.ModSettings.pilotingSkillInstabilityMitigation) { var mitigation = Calculator.PilotingMitigation(attacker); var mitigationPercent = Mathf.RoundToInt(mitigation * 100); instabilityToAdd = rawInstabilityToAdd - rawInstabilityToAdd * mitigation; Logger.Debug($"melee miss numbers\n" + $"pilotSkill: {attacker.SkillPiloting}\n" + $"mitigation: {mitigation}\n" + $"rawInstabilityToAdd: {rawInstabilityToAdd}\n" + $"mitigationPercent: {mitigationPercent}\n" + $"instabilityToAdd: {instabilityToAdd}"); attacker.Combat.MessageCenter.PublishMessage(new AddSequenceToStackMessage(new ShowActorInfoSequence(attacker, $"Pilot Check: Avoided {mitigationPercent}% Instability!", FloatieMessage.MessageNature.Neutral, true))); } attacker.AddRelativeInstability(instabilityToAdd, StabilityChangeSource.Attack, attacker.GUID); Logger.Debug($"melee post-miss stability: {attacker.CurrentStability}"); attacker.NeedsInstabilityCheck = true; if (Core.ModSettings.AllowSteadyToKnockdownForMelee) { attacker.CheckForInstability(); attacker.NeedsInstabilityCheck = true; } } } // Deal with target needing additional checks if we want to be able to knock over // mechs in a single round from one attack. if (Core.ModSettings.AllowSteadyToKnockdownForMelee) { if (!__instance.MeleeTarget.IsDead) { var target = __instance.MeleeTarget as AbstractActor; if (target != null) { target.NeedsInstabilityCheck = true; target.CheckForInstability(); var attacker = __instance.OwningMech; HandleFall.Say(attacker); target.HandleKnockdown(__instance.RootSequenceGUID, attacker.GUID, Vector2.one, null); } } } }
public override void Trigger(MessageCenterMessage inMessage, string triggeringName) { Main.LogDebug($"[SetTeamByTagResult] Setting Team '{Team}' with tags '{String.Concat(Tags)}'"); List <ICombatant> combatants = ObjectiveGameLogic.GetTaggedCombatants(UnityGameInstance.BattleTechGame.Combat, new TagSet(Tags)); Main.LogDebug($"[SetTeamByTagResult] Found '{combatants.Count}' combatants"); Team newTeam = UnityGameInstance.BattleTechGame.Combat.ItemRegistry.GetItemByGUID <Team>(TeamUtils.GetTeamGuid(Team)); Lance newLance = new Lance(newTeam); newLance.team = newTeam; foreach (ICombatant combatant in combatants) { if (combatant is AbstractActor) { /* * AbstractActor actor = combatant as AbstractActor; * * actor.lance.RemoveUnitGUID(actor.GUID); * actor.RemoveFromLance(); * actor.team.RemoveUnit(actor); * * actor.AddToTeam(newTeam); * newLance.AddUnitGUID(actor.GUID); * actor.AddToLance(newLance); * newLance.team.AddUnit(actor); * * actor.team.lances.Add(newLance); */ Main.Logger.LogError($"[SetTeamByTagResult] Using this result with AbstractActors isn't supported yet"); } else { combatant.RemoveFromTeam(); combatant.AddToTeam(newTeam); } if (ApplyTags != null) { combatant.EncounterTags.AddRange(ApplyTags); } CombatantSwitchedTeams message = new CombatantSwitchedTeams(combatant.GUID, newTeam.GUID); this.combat.MessageCenter.PublishMessage(message); LazySingletonBehavior <FogOfWarView> .Instance.FowSystem.Rebuild(); } if (newLance.unitGuids.Count > 0) { newTeam.lances.Add(newLance); UnityGameInstance.BattleTechGame.Combat.ItemRegistry.AddItem(newLance); if (this.AlertLance) { newLance.BroadcastAlert(); } } }
private static void PostDamageComponent() { if (CritCompMessage == null) { return; // If non-ME, we can defer and suppress the message } Combat.MessageCenter.PublishMessage(CritCompMessage); CritCompMessage = null; }
public static void Postfix(CombatHUDPhaseTrack __instance, MessageCenterMessage message, TextMeshProUGUI ___roundCounterText) { //SkillBasedInit.Logger.Log($"CombatHUDPhaseTrack:OnPhaseBegin:post - Init"); PhaseBeginMessage phaseBeginMessage = message as PhaseBeginMessage; string phaseText = string.Format("{0} - Phase {1}", phaseBeginMessage.Round, 31 - phaseBeginMessage.Phase); ___roundCounterText.SetText(phaseText); //SkillBasedInit.Logger.Log($"CombatHUDPhaseTrack:OnPhaseBegin:post - for {phaseText}"); }
static void Prefix(EncounterLayerParent __instance, MessageCenterMessage message) { Main.Logger.Log($"[EncounterLayerParentInitializeContractPatch Prefix] Patching InitializeContract"); InitializeContractMessage initializeContractMessage = message as InitializeContractMessage; CombatGameState combat = initializeContractMessage.combat; Contract activeContract = combat.ActiveContract; GizmoManager.GetInstance().SetContract(activeContract); }
public static void OnAuraRemovedMessage(MessageCenterMessage message) { Mod.Log.Info?.Write("SAH == ON AURA REMOVED"); AuraRemovedMessage auraRemoveMessage = message as AuraRemovedMessage; AbstractActor target = Combat.FindActorByGUID(auraRemoveMessage.targetID); AbstractActor creator = Combat.FindActorByGUID(auraRemoveMessage.creatorID); Mod.Log.Debug?.Write($"ON AURA ADDED: {CombatantUtils.Label(target)} from {CombatantUtils.Label(creator)}"); }
private static void OnFloatie(MessageCenterMessage message) { FloatieMessage floatieMessage = (FloatieMessage)message; AbstractActor target = combat.FindActorByGUID(floatieMessage.affectedObjectGuid); if (target == null) { return; } if (floatieMessage.text == null) { return; } try { string senderColor; if (combat.HostilityMatrix.IsLocalPlayerEnemy(target.TeamId)) { senderColor = "#" + ColorUtility.ToHtmlStringRGBA(LazySingletonBehavior <UIManager> .Instance.UIColorRefs.redHalf); } else if (combat.HostilityMatrix.IsLocalPlayerNeutral(target.TeamId)) { senderColor = "#" + ColorUtility.ToHtmlStringRGBA(LazySingletonBehavior <UIManager> .Instance.UIColorRefs.blueHalf); } else { senderColor = "#" + ColorUtility.ToHtmlStringRGBA(LazySingletonBehavior <UIManager> .Instance.UIColorRefs.greenHalf); } string sender = (target.IsPilotable && target.GetPilot() != null) ? $"{target.DisplayName}-{target.GetPilot().Name}" : $"{target.DisplayName}"; string senderWithColor = $"<{senderColor}>{sender}</color>"; Mod.Log.Debug($"ChatMessage senderWithColor: '{senderWithColor}'"); string logMessage = floatieMessage.text.ToString(); switch (floatieMessage.nature) { case FloatieMessage.MessageNature.ArmorDamage: logMessage = $"{logMessage} armor damage"; break; case FloatieMessage.MessageNature.StructureDamage: logMessage = $"{logMessage} structure damage"; break; default: break; } messageCenter.PublishMessage(new ChatMessage(senderWithColor, logMessage, false)); } catch (Exception e) { Mod.Log.Error($"Failed to send floatieMessage: {floatieMessage}"); Mod.Log.Error(e); } }
public override void Trigger(MessageCenterMessage inMessage, string triggeringName) { Main.LogDebug($"[DelayResult] Delaying '{Name}' results for '{Time}' seconds, '{Rounds}' rounds and/or '{Phases}' phases"); SubscribeToMessages(true); if (IsTimeControlled()) { MissionControl.Instance.EncounterLayerParent.StartCoroutine(DelayResultsWithTime()); } }
private void BeforeSceneManipulation(MessageCenterMessage message) { if (this.gameObject.GetComponentInParent <EncounterChunkGameLogic>().startingStatus == EncounterObjectStatus.ControlledByContract) { Main.LogDebug($"[SwapPlacementGameLogic.BeforeSceneManipulation] Skipping as Chunk is set to not be enabled in the contract json"); return; } SwapPlacement(); }
public static void Postfix(AttackDirector __instance, MessageCenterMessage message) { Mod.Log.Debug("AD:OASB - entered."); int sequenceId = ((AttackSequenceBeginMessage)message).sequenceId; AttackDirector.AttackSequence attackSequence = __instance.GetAttackSequence(sequenceId); ModState.BreachAttackId = attackSequence.id; }
public static void SetImpact(MessageCenterMessage message) { if (message is not AttackSequenceImpactMessage impactMessage) { return; } WeaponHitInfo info = impactMessage.hitInfo; currentImpact = info.attackSequenceId; currentRoll = (impactMessage.hitIndex < info.toHitRolls.Length)?info.toHitRolls[impactMessage.hitIndex]:0f; }
// new ReceiveMessageCenterMessage(OnTurnActorActivateMessage) // PhaseBeginCompleteMessage(int round, int phase, string TurnActorGUID, int available) public static void OnTurnActorActivateMessage(MessageCenterMessage message) { TurnActorActivateMessage turnActorActivateMessage = message as TurnActorActivateMessage; if (turnActorActivateMessage.TurnActorGUID == combatGameState.LocalPlayerTeamGuid) { combatGameState.MessageCenter.AddFiniteSubscriber(MessageCenterMessageType.SequenceCompleteMessage, new TeamActivationSequence) combatGameState.BattleTechGame.Save(SaveReason.COMBAT_GAME_DESIGNER_TRIGGER, false); // UnityGameInstance.BattleTechGame.Save(SaveReason.COMBAT_GAME_DESIGNER_TRIGGER, false); } }
public static void Postfix(CombatHUDActorInfo __instance, MessageCenterMessage message, AbstractActor ___displayedActor) { Mod.Log.Trace?.Write("CHUDAI:OSC entered"); StealthChangedMessage stealthChangedMessage = message as StealthChangedMessage; if (___displayedActor != null && stealthChangedMessage.affectedObjectGuid == ___displayedActor.GUID && __instance.StealthDisplay != null) { VfxHelper.CalculateMimeticPips(__instance.StealthDisplay, ___displayedActor); } }
private static void PreDamageComponent(MessageCenterMessage critMessage) { if (MechEngineerCheckCritPublishMessage != null) // ME expects pre-damage call { MechEngineerCheckCritPublishMessage.Invoke(null, new object[] { Combat.MessageCenter, critMessage }); } else { CritCompMessage = critMessage; } }
public static void SetImpact(MessageCenterMessage message) { if (!(message is AttackSequenceImpactMessage impactMessage)) { return; } WeaponHitInfo info = impactMessage.hitInfo; currentImpact = info.attackSequenceId; currentRoll = info.toHitRolls[impactMessage.hitIndex]; }
// Use this for initialization void Start() { swrveComponent = (SwrveComponent)FindObjectOfType(typeof(SwrveComponent)); swrveComponent.SDK.GetMessageCenterCampaigns(SwrveOrientation.Portrait).ForEach(campaign => { GameObject newButton = Instantiate(MessageCenterMessagePrefab) as GameObject; MessageCenterMessage message = newButton.GetComponent <MessageCenterMessage> (); message.setCampaign(campaign); message.transform.SetParent(ContentPanel, false); }); }