public static bool Prefix(BehaviorNode __instance, ref BehaviorTreeResults __result, ref BehaviorTree ___tree, ref AbstractActor ___unit)
{
try {
List <AbstractActor> allAlliesOf = ___unit.Combat.GetAllAlliesOf(___unit);
AuraBubble sensors = ___unit.sensorAura();
for (int index1 = 0; index1 < ___tree.enemyUnits.Count; ++index1)
{
ICombatant enemyUnit = ___tree.enemyUnits[index1];
AbstractActor abstractActor = enemyUnit as AbstractActor;
float magnitude = (enemyUnit.CurrentPosition - ___unit.CurrentPosition).magnitude;
if (AIUtil.UnitHasVisibilityToTargetFromPosition(___unit, enemyUnit, ___unit.CurrentPosition, allAlliesOf))
{
if (___unit.CanEngageTarget(enemyUnit) || ___unit.CanDFATargetFromPosition(enemyUnit, ___unit.CurrentPosition))
{
__result = new BehaviorTreeResults(BehaviorNodeState.Success);
return(false);
}
if ((double)magnitude <= (double)___unit.MaxWalkDistance)
{
__result = new BehaviorTreeResults(BehaviorNodeState.Success);
return(false);
}
if (abstractActor != null && abstractActor.IsGhosted)
{
float num = Mathf.Lerp(___unit.MaxWalkDistance, ___unit.MaxSprintDistance, ___unit.BehaviorTree.GetBehaviorVariableValue(BehaviorVariableName.Float_SignalInWeapRngWhenEnemyGhostedWithinMoveDistance).FloatVal);
float range = sensors.collider.radius;
if ((double)Vector3.Distance(___unit.CurrentPosition, abstractActor.CurrentPosition) - (double)range >= (double)num)
{
continue;
}
}
for (int index2 = 0; index2 < ___unit.Weapons.Count; ++index2)
{
Weapon weapon = ___unit.Weapons[index2];
if (weapon.CanFire && (double)weapon.MaxRange >= (double)magnitude)
{
__result = new BehaviorTreeResults(BehaviorNodeState.Success);
return(false);
}
}
}
}
__result = new BehaviorTreeResults(BehaviorNodeState.Failure);
return(false);
} catch (Exception e) {
Log.Debug?.Write(e.ToString() + "\n");
__result = new BehaviorTreeResults(BehaviorNodeState.Failure);
return(false);
}
}
public static bool Prefix(CombatAuraReticle __instance, ref ButtonState __result, ref AbstractActor ___owner, ref CombatHUD ___HUD)
{
try {
AuraBubble aura = __instance.AuraBubble();
if (aura == null)
{
__result = ButtonState.Disabled; return(false);
}
__result = __instance.isAuraVisible(aura, ___owner, ___HUD, false)? ButtonState.Enabled : ButtonState.Disabled;
return(false);
}catch (Exception e) {
Log.LogWrite(e.ToString() + "\n");
}
return(true);
//__instance.GameRep.PlayVFXAt(__instance.GameRep.thisTransform, Vector3.zero, "vfxPrfPrtl_ECM_loop", true, Vector3.zero, false, -1f);
}
public static bool Prefix(CombatAuraReticle __instance, ref AbstractActor ___owner, ref float ___currentAuraRange, ref CombatHUD ___HUD, ref Transform ___thisTransform, ref bool __result)
{
try {
//if (CombatHUD_Update_HideReticlesHotKey.hideReticles == AuraShowState.HideAll) { __result = false; return false; };
AuraBubble aura = __instance.AuraBubble();
if (aura == null)
{
return(true);
}
;
__result = __instance.isAuraVisible(aura, ___owner, ___HUD, true);
return(false);
}catch (Exception e) {
Log.LogWrite(e.ToString() + "\n");
}
return(true);
}
public static bool Prefix(AITeam __instance, List <AbstractActor> unusedUnits, ref AbstractActor __result)
{
try {
if (!__instance.CanEntireEnemyTeamBeGhosted())
{
__result = null;
return(false);
}
AbstractActor result = (AbstractActor)null;
float minDistance = float.MaxValue;
for (int index1 = 0; index1 < unusedUnits.Count; ++index1)
{
AbstractActor unusedUnit = unusedUnits[index1];
List <AbstractActor> enemies = AIUtil.HostilesToUnit(unusedUnit);
AuraBubble sensors = unusedUnit.sensorAura();
if (sensors == null)
{
continue;
}
;
for (int index2 = 0; index2 < enemies.Count; ++index2)
{
AbstractActor enemy = enemies[index2];
if (enemy.HasECMAbilityInstalled)
{
float floatVal = unusedUnit.BehaviorTree.GetBehaviorVariableValue(BehaviorVariableName.Float_SignalInWeapRngWhenEnemyGhostedWithinMoveDistance).FloatVal;
float maxMoveDist = Mathf.Lerp(unusedUnit.MaxWalkDistance, unusedUnit.MaxSprintDistance, floatVal);
float range = sensors.collider.radius;
float needMoveDist = Vector3.Distance(unusedUnit.CurrentPosition, enemy.CurrentPosition) - range;
if ((double)needMoveDist <= (double)maxMoveDist && (double)needMoveDist < (double)minDistance)
{
result = unusedUnit;
minDistance = needMoveDist;
}
}
}
}
__result = result;
return(false);
}catch (Exception e) {
Log.WriteCritical(e.ToString() + "\n");
__result = null;
return(false);
}
}
public static bool Prefix(CombatAuraReticle __instance, bool isBright, ref AbstractActor ___owner, ref CombatHUD ___HUD, ref bool ___currentAPIsBright)
{
try {
AuraBubble aura = __instance.AuraBubble();
if (aura == null)
{
return(true);
}
if (isBright == false)
{
return(false);
}
isBright = ___HUD.SelectedActor != null && ___HUD.SelectionHandler.ActiveState is SelectionStateMoveBase;
if (isBright)
{
__instance.activeProbeDecal.DecalMaterial = __instance.activeProbeMatBright;
//this.apSpinAnim.DORestartById("spin");
}
else
{
__instance.activeProbeDecal.DecalMaterial = __instance.activeProbeMatDim;
//this.apSpinAnim.DOPause();
}
if (___currentAPIsBright != aura.Def.isSpining)
{
___currentAPIsBright = aura.Def.isSpining;
if (___currentAPIsBright)
{
__instance.apSpinAnim.DORestartById("spin");
}
else
{
__instance.apSpinAnim.DOPause();
}
}
return(false);
} catch (Exception e) {
Log.LogWrite(e.ToString() + "\n");
}
return(true);
}
public static bool Prefix(CombatAuraReticle __instance, bool showActiveProbe, ref AbstractActor ___owner, ref float ___currentAPRange)
{
try {
GameObject activeProbeRangeScaledObject = __instance.activeProbeRangeScaledObject();
if (showActiveProbe == false)
{
activeProbeRangeScaledObject.SetActive(false);
return(false);
}
//AuraBubble mainSensorsBubble = __instance.MainSensors();
//Log.LogWrite("CombatAuraReticle.RefreshAuraRange " + (mainSensorsBubble == null ? "null" : mainSensorsBubble.collider.radius.ToString()) + "\n");
//if (mainSensorsBubble != null) {
//auraRangeScaledObject.SetActive(true);
//float b = mainSensorsBubble.collider.radius;
//if (!Mathf.Approximately(___currentAuraRange, b)) {
//auraRangeScaledObject.transform.localScale = new Vector3(b * 2f, 1f, b * 2f);
//}
//___currentAuraRange = b;
//return false;
//}
AuraBubble auraBubble = __instance.AuraBubble();
if (auraBubble != null)
{
activeProbeRangeScaledObject.SetActive(true);
float b = auraBubble.collider.radius;
if (!Mathf.Approximately(___currentAPRange, b))
{
activeProbeRangeScaledObject.transform.localScale = new Vector3(b * 2f, 1f, b * 2f);
}
___currentAPRange = b;
return(false);
}
} catch (Exception e) {
Log.LogWrite(e.ToString() + "\n", true);
}
return(true);
}
public static bool isAuraVisible(this CombatAuraReticle __instance, AuraBubble aura, AbstractActor ___owner, CombatHUD ___HUD, bool spinning)
{
if (CombatHUD_Update_HideReticlesHotKey.hideReticles == AuraShowState.HideAll)
{
return(false);
}
;
if ((___owner.IsVisibleToPlayer() == false) || (___owner.IsOperational == false))
{
return(false);
}
if (aura != null)
{
if (aura.Def.isSpining != spinning)
{
return(false);
}
if (aura.isMainSensors)
{
if (CombatHUD_Update_HideReticlesHotKey.hideReticles == AuraShowState.ShowAll)
{
return(true);
}
if (aura.Def.NotShowOnSelected)
{
return(false);
}
;
if (aura.Def.HideOnNotSelected)
{
if (___HUD.SelectedActor != null)
{
if (___HUD.SelectedActor.GUID == ___owner.GUID)
{
return(true);
}
}
return(false);
}
else
{
return(true);
}
}
if (aura.source != null)
{
if (aura.Def.isSpining != spinning)
{
return(false);
}
Weapon weapon = aura.source as Weapon;
if ((weapon == null) || (aura.Def.Id != "AMS"))
{
if (CombatHUD_Update_HideReticlesHotKey.hideReticles == AuraShowState.ShowAll)
{
return(true);
}
if (aura.Def.NotShowOnSelected)
{
return(false);
}
;
if (aura.Def.HideOnNotSelected)
{
if (___HUD.SelectedActor != null)
{
if (___HUD.SelectedActor.GUID == ___owner.GUID)
{
return(true);
}
}
return(false);
}
else
{
return(true);
}
}
else
{
if (weapon.isAMS() == false)
{
return(false);
}
if (weapon.IsEnabled == false)
{
return(false);
}
if (CombatHUD_Update_HideReticlesHotKey.hideReticles == AuraShowState.ShowAll)
{
return(true);
}
if (aura.Def.NotShowOnSelected)
{
return(false);
}
;
if (aura.Def.HideOnNotSelected)
{
if (___HUD.SelectedActor != null)
{
if (___HUD.SelectedActor.GUID == ___owner.GUID)
{
return(true);
}
}
return(false);
}
else
{
return(true);
}
}
}
else
{
return(false);
}
}
return(false);
}
public static AuraPreviewRecord fillPreviewCache(this AbstractActor movingActor, Vector3 position)
{
AuraActorBody body = movingActor.bodyAura();
if (body == null)
{
Log.WriteCritical("WARNING!" + movingActor.DisplayName + ":" + movingActor.GUID + " has no body to apply auras\n");
return(new AuraPreviewRecord(movingActor));
}
HashSet <AuraBubble> newAuras = new HashSet <AuraBubble>();
HashSet <AuraBubble> remAuras = new HashSet <AuraBubble>();
foreach (var aura in body.affectedAurasEffects)
{
if (aura.Key.owner.GUID != movingActor.GUID)
{
remAuras.Add(aura.Key);
}
}
Collider[] hitColliders = Physics.OverlapSphere(position, 1f);
foreach (Collider collider in hitColliders)
{
AuraBubble aura = collider.gameObject.GetComponent <AuraBubble>();
if (aura == null)
{
continue;
}
if (aura.Def.RemoveOnSensorLock && movingActor.IsSensorLocked)
{
continue;
}
if (aura.owner.GUID == movingActor.GUID)
{
continue;
}
if (body.affectedAurasEffects.ContainsKey(aura) == false)
{
newAuras.Add(aura);
}
else
{
remAuras.Remove(aura);
}
}
AuraPreviewRecord result = new AuraPreviewRecord(movingActor);
result.aurasAdded.Add(movingActor, new List <AuraPreview>());
result.aurasRemoved.Add(movingActor, new List <AuraPreview>());
List <AuraPreview> tmpList = result.aurasAdded[movingActor];
foreach (AuraBubble aura in newAuras)
{
if ((aura.owner.GUID == movingActor.GUID) && (aura.Def.ApplySelf == false))
{
continue;
}
tmpList.Add(new AuraPreview(aura.owner, movingActor, aura.Def));
}
tmpList = result.aurasRemoved[movingActor];
foreach (AuraBubble aura in remAuras)
{
tmpList.Add(new AuraPreview(aura.owner, movingActor, aura.Def));
}
List <AuraBubble> actorAuras = movingActor.actorAuras();
foreach (AuraBubble aura in actorAuras)
{
if (aura.collider.enabled == false)
{
continue;
}
if (aura.collider.radius < 1f)
{
continue;
}
hitColliders = Physics.OverlapSphere(position, aura.collider.radius);
HashSet <AbstractActor> newUnits = new HashSet <AbstractActor>();
HashSet <AbstractActor> remUnits = new HashSet <AbstractActor>();
foreach (var unit in aura.affectedTo)
{
if (unit.owner.GUID != movingActor.GUID)
{
remUnits.Add(unit.owner);
}
}
foreach (Collider collider in hitColliders)
{
AuraActorBody otherBody = collider.gameObject.GetComponent <AuraActorBody>();
if (otherBody == null)
{
continue;
}
if (movingActor.GUID == otherBody.owner.GUID)
{
continue;
}
if (aura.Def.RemoveOnSensorLock && otherBody.owner.IsSensorLocked)
{
continue;
}
if (aura.affectedTo.Contains(otherBody) == false)
{
newUnits.Add(otherBody.owner);
}
else
{
remUnits.Remove(otherBody.owner);
}
}
foreach (AbstractActor unit in newUnits)
{
if (result.aurasAdded.ContainsKey(unit) == false)
{
result.aurasAdded.Add(unit, new List <AuraPreview>());
}
;
result.aurasAdded[unit].Add(new AuraPreview(aura.owner, unit, aura.Def));
}
foreach (AbstractActor unit in remUnits)
{
if (result.aurasRemoved.ContainsKey(unit) == false)
{
result.aurasRemoved.Add(unit, new List <AuraPreview>());
}
;
result.aurasRemoved[unit].Add(new AuraPreview(aura.owner, unit, aura.Def));
}
}
result.RecalculateStealthPips();
//Log.LogWrite("fillPreviewCache:"+movingActor.DisplayName+" "+position.ToString()+"\n");
//result.DBGLogPrint();
return(result);
}
