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);
});
}
