static void Prefix(PilotableActorRepresentation __instance, ref VisibilityLevel newLevel)
{
if (!FogOfWarManager.GetInstance().IsFogOfWarOn)
{
newLevel = VisibilityLevel.LOSFull;
}
}
public static VisibilityLevel Calculate(Vector3 position, List <LightSource> lightSources)
{
VisibilityLevel visibility = VisibilityLevel.Hidden;
for (int i = 0; i < lightSources.Count; i++)
{
LightSource light = lightSources[i];
float distanceSq = Vector3.SqrMagnitude(light.gameObject.transform.position - position);
float partialRadius = light.lightRadius + 0.8f;
if (distanceSq < partialRadius * partialRadius)
{
Vector3 raycastDir = position - light.transform.position;
if (Physics.Raycast(light.transform.position, raycastDir, raycastDir.magnitude, LayerMask.NameToLayer("Player"), QueryTriggerInteraction.Ignore))
{
// Something is blocking the light ray
return(VisibilityLevel.Hidden);
}
visibility = VisibilityLevel.Partial;
if (distanceSq < light.lightRadius * light.lightRadius)
{
visibility = VisibilityLevel.Visible;
}
}
}
return(visibility);
}
/* public static void ToggleCallout () { try {
* if ( IsCallout != IsCalloutPressed ) {
* IsCallout = IsCalloutPressed;
* foreach ( Action<bool> listener in CalloutListener )
* listener( IsCallout );
* }
* } catch ( Exception ex ) { Error( ex ); } }*/
// ============ Floating Nameplate ============
public static void ShowPilotWounds(CombatHUDActorNameDisplay __instance, VisibilityLevel visLevel)
{
try {
AbstractActor actor = __instance.DisplayedCombatant as AbstractActor;
Pilot pilot = actor?.GetPilot();
Team team = actor?.team;
TMPro.TextMeshProUGUI textbox = __instance.PilotNameText;
if (AnyNull <object>(pilot, team, textbox, Combat) || pilot.Injuries <= 0)
{
return;
}
string format = null;
object[] args = new object[] { null, pilot.Injuries, pilot.Health - pilot.Injuries, pilot.Health };
if (team == Combat.LocalPlayerTeam)
{
format = Settings.ShowPlayerHealth;
}
else if (team.IsFriendly(Combat.LocalPlayerTeam))
{
format = Settings.ShowAllyHealth;
}
else if (visLevel == VisibilityLevel.LOSFull)
{
format = Settings.ShowEnemyWounds;
args[2] = args[3] = "?";
}
if (format != null)
{
textbox.text = textbox.text + "</uppercase><size=80%>" + Translate(format, args);
}
} catch (Exception ex) { Error(ex); }
}
public static void Postfix(PilotableActorRepresentation __instance, VisibilityLevel newLevel)
{
try {
Log.LogWrite("PilotableActorRepresentation.OnPlayerVisibilityChanged " + __instance.parentCombatant.DisplayName + " " + newLevel + "\n");
if (__instance.parentActor == null)
{
Log.LogWrite(" are you f*****g seriously?? parentActor is null\n", true);
return;
}
foreach (MechComponent component in __instance.parentActor.allComponents)
{
try {
ActivatableComponent activatable = component.componentDef.GetComponent <ActivatableComponent>();
if (activatable == null)
{
continue;
}
;
if ((activatable.activateVFXOutOfLOSHide == false) && (activatable.presistantVFXOutOfLOSHide == false))
{
continue;
}
if (activatable.activateVFXOutOfLOSHide == true)
{
ObjectSpawnDataSelf activeVFX = component.ActivateVFX();
if (activeVFX != null)
{
if (newLevel != VisibilityLevel.LOSFull)
{
activeVFX.Hide();
}
else
{
activeVFX.Show();
}
}
}
if (activatable.presistantVFXOutOfLOSHide == true)
{
ObjectSpawnDataSelf presistantVFX = component.PresitantVFX();
if (presistantVFX != null)
{
if (newLevel != VisibilityLevel.LOSFull)
{
presistantVFX.Hide();
}
else
{
presistantVFX.Show();
}
}
}
} catch (Exception e) {
Log.LogWrite(e.ToString() + "\n", true);
}
}
}catch (Exception e) {
Log.LogWrite(e.ToString() + "\n", true);
}
}
public static void Postfix(Turret __instance, ref Text __result, VisibilityLevel visLevel)
{
if (__instance == null)
{
return;
}
/*
* Turret.UnitName = return (this.TurretDef == null) ? "UNDEFINED" : this.TurretDef.Chassis.Description.Name ->
* Turret.NickName = (this.TurretDef == null) ? "UNDEFINED" : this.TurretDef.Description.Name ->
*/
if (__instance.Combat.HostilityMatrix.IsLocalPlayerEnemy(__instance.team.GUID))
{
string chassisName = __instance.UnitName;
string fullName = __instance.Nickname;
SensorScanType scanType = SensorLockHelper.CalculateSharedLock(__instance, null);
if (scanType < SensorScanType.ArmorAndWeaponType)
{
bool hasVisualScan = VisualLockHelper.CanSpotTargetUsingCurrentPositions(ModState.LastPlayerActorActivated, __instance);
if (hasVisualScan)
{
scanType = SensorScanType.ArmorAndWeaponType;
}
}
Text response = CombatNameHelper.GetTurretOrVehicleDetectionLabel(visLevel, scanType, fullName, chassisName, false);
__result = response;
}
}
public static void Postfix(Vehicle __instance, ref Text __result, VisibilityLevel visLevel)
{
if (__instance == null)
{
return;
}
;
/*
* Vehicle.UnitName = VehicleDef.Chassis.Description.Name ->
* Alacorn Mk.VI-P / vehicledef_ARES_CLAN / Demolisher II / Galleon GAL-102
* Vehicle.NickName = VehicleDef.Description.Name ->
* Pirate Alacorn Gauss Carrier / Ares / Demolisher II`
* VehicleDef.Description.Id ->
* / / vehicledef_DEMOLISHER-II / vehicledef_GALLEON_GAL102
*/
if (__instance.Combat.HostilityMatrix.IsLocalPlayerEnemy(__instance.team.GUID))
{
string chassisName = __instance.UnitName;
string fullName = __instance.Nickname;
SensorScanType scanType = SensorLockHelper.CalculateSharedLock(__instance, null);
if (scanType < SensorScanType.ArmorAndWeaponType)
{
bool hasVisualScan = VisualLockHelper.CanSpotTargetUsingCurrentPositions(ModState.LastPlayerActorActivated, __instance);
if (hasVisualScan)
{
scanType = SensorScanType.ArmorAndWeaponType;
}
}
Text response = CombatNameHelper.GetTurretOrVehicleDetectionLabel(visLevel, scanType, fullName, chassisName, true);
__result = response;
}
}
/*
* Helper method used to find the label text for any enemy vehicles and turrets based on the visiblity and senors levels.
*
* chassisName -> ICombatant.UnitName = (Vehicle/Turret)Def.Chassis.Description.Name -> Carrier / Vargr APC / ArrowIV Chassis
* fullname -> ICombatant.NickName = (Vehicle/Turret)Def.Description.Name -> AC/2 Carrier / Vargr APC / Arrow IV Turret
*/
public static Text GetTurretOrVehicleDetectionLabel(VisibilityLevel visLevel, SensorScanType sensorScanType,
string fullName, string chassisName, bool isVehicle = true)
{
Text label = new Text("?");
if (visLevel >= VisibilityLevel.Blip0Minimum)
{
string labelKey = isVehicle ? ModConfig.LT_UNIT_TYPE_VEHICLE : ModConfig.LT_UNIT_TYPE_TURRET;
string typeS = new Text(Mod.Config.LocalizedText[labelKey]).ToString();
if (sensorScanType == SensorScanType.NoInfo)
{
label = new Text("?");
}
else if (sensorScanType == SensorScanType.LocationAndType)
{
label = new Text(typeS);
}
else if (sensorScanType == SensorScanType.ArmorAndWeaponType)
{
label = new Text($"{chassisName}");
}
else if (sensorScanType == SensorScanType.StructAndWeaponID)
{
label = new Text($"{fullName}");
}
else if (sensorScanType == SensorScanType.AllInformation)
{
label = new Text($"{fullName}");
}
}
return(label);
}
public static void Postfix(ref CalledShotAttackOrderInfo __result, AbstractActor attackingUnit, int enemyUnitIndex)
{
Mod.Log.Trace?.Write("AE:CCSLTC entered");
ICombatant combatant = attackingUnit.BehaviorTree.enemyUnits[enemyUnitIndex];
if (combatant is AbstractActor targetActor)
{
// Prevents blips from being the targets of called shots
VisibilityLevel targetVisibility = attackingUnit.VisibilityToTargetUnit(targetActor);
if (targetVisibility < VisibilityLevel.LOSFull)
{
Mod.Log.Info?.Write($"Target {CombatantUtils.Label(combatant)} is a blip, cannot be targeted by AI called shot");
__result = null;
return;
}
float distance = Vector3.Distance(attackingUnit.CurrentPosition, targetActor.CurrentPosition);
bool hasVisualScan = VisualLockHelper.GetVisualScanRange(attackingUnit) >= distance;
SensorScanType sensorScan = SensorLockHelper.CalculateSharedLock(targetActor, attackingUnit);
if (sensorScan < SensorScanType.ArmorAndWeaponType && !hasVisualScan)
{
Mod.Log.Info?.Write($"Target {CombatantUtils.Label(targetActor)} sensor info {sensorScan} is less than SurfaceScan and outside visualID, cannot be targeted by AI called shot");
__result = null;
return;
}
}
}
public static bool Prefix(LineOfSight __instance, ref VisibilityLevel __result,
AbstractActor source, Vector3 sourcePosition, ICombatant target, Vector3 targetPosition, Quaternion targetRotation)
{
Mod.Log.Trace?.Write($"LOS:GVTTWPAR: source:{CombatantUtils.Label(source)} ==> target:{CombatantUtils.Label(target)}");
// Skip if we aren't ready to process
// TODO: Is this necessary anymore?
//if (State.TurnDirectorStarted == false || (target as AbstractActor) == null) { return true; }
AbstractActor sourceActor = source as AbstractActor;
// TODO: Handle buildings here
bool sourceHasLineOfSight = VisualLockHelper.CanSpotTarget(sourceActor, sourcePosition, target, targetPosition, targetRotation, __instance);
if (sourceHasLineOfSight)
{
__result = VisibilityLevel.LOSFull;
}
else
{
VisibilityLevel sensorsVisibility = VisibilityLevel.None;
if (ModState.TurnDirectorStarted)
{
SensorScanType sensorLock = SensorLockHelper.CalculateSensorLock(sourceActor, sourcePosition, target, targetPosition);
sensorsVisibility = sensorLock.Visibility();
}
__result = sensorsVisibility;
}
//Mod.Log.Trace?.Write($"LOS:GVTTWPAR - [{__result}] visibility for source:{CombatantUtils.Label(source)} ==> target:{CombatantUtils.Label(target)}");
return(false);
}
public static void Postfix(AIUtil __instance, ref bool __result, AbstractActor attacker, ICombatant target, Vector3 position, List <AbstractActor> allies)
{
//LowVisibility.Logger.Debug("AIUtil:UnitHasVisibilityToTargetFromPosition:post - entered.");
bool alliesHaveVis = false;
for (int i = 0; i < allies.Count; i++)
{
//if (allies[i].VisibilityCache.VisibilityToTarget(target).VisibilityLevel == VisibilityLevel.LOSFull) {
if (allies[i].VisibilityCache.VisibilityToTarget(target).VisibilityLevel == VisibilityLevel.Blip0Minimum)
{
alliesHaveVis = true;
}
}
if (alliesHaveVis)
{
VisibilityLevel visibilityToTargetWithPositionsAndRotations =
attacker.Combat.LOS.GetVisibilityToTargetWithPositionsAndRotations(attacker, position, target);
//__result = visibilityToTargetWithPositionsAndRotations >= VisibilityLevel.LOSFull;
__result = visibilityToTargetWithPositionsAndRotations >= VisibilityLevel.Blip0Minimum;
}
else
{
__result = true;
}
//LowVisibility.Logger.Debug($"AIUtil:UnitHasVisibilityToTargetFromPosition:post - result is:{__result}");
}
/*
* Helper method used to find the label text for any enemy mechs based on the visiblity and senors levels.
*
* Parameters:
* chassisName -> Mech.UnitName = MechDef.Chassis.Description.Name -> Shadow Hawk / Atlas / Marauder
* (The name of the base chassis, even if customized chassis (such as RogueOmnis))
*
* partialName -> Mech.NickName = MechDef.Description.Name -> Shadow Hawk SHD-2D / Atlas AS7-D / Marauder ANU-O
* (Partial name, most cases chassis and variant name combined, but for some elite mechs can be "less precise" to trick the player which mech it is)
*
* fullname -> Mech.NickName = MechDef.Description.UIName -> Shadow Hawk SHD-2D / Atlas AS7-D Danielle / Anand ANU-O
* (Full name, will almost always display the full actual name, and if a hero/elite mech the chassis name is replaced by its custom name. ONly exception is LA's hidden nasty surprises, such as Nuke mechs)
*/
public static Text GetEnemyMechDetectionLabel(VisibilityLevel visLevel, SensorScanType sensorScanType,
string fullName, string partialName, string chassisName)
{
Text label = new Text("?");
if (visLevel >= VisibilityLevel.Blip0Minimum)
{
string typeS = new Text(Mod.Config.LocalizedText[ModConfig.LT_UNIT_TYPE_MECH]).ToString();
if (sensorScanType == SensorScanType.NoInfo)
{
label = new Text("?");
}
else if (sensorScanType == SensorScanType.LocationAndType)
{
label = new Text(typeS);
}
else if (sensorScanType == SensorScanType.ArmorAndWeaponType)
{
label = new Text($"{chassisName}");
}
else if (sensorScanType == SensorScanType.StructAndWeaponID)
{
label = new Text($"{partialName}");
}
else if (sensorScanType == SensorScanType.AllInformation)
{
label = new Text($"{fullName}");
}
}
return(label);
}
/// <summary> Creates a new project snippet associated with the provided project ID. </summary>
/// <param name="projectId"> The ID of the project to create this snippet for. </param>
/// <param name="title"> The snippet's title. </param>
/// <param name="fileName"> The snippet's file name. </param>
/// <param name="code"> The code for this snippet. </param>
/// <param name="visibilityLevel"> The visibility level for this snippet. </param>
/// <returns> A <see cref="RequestResult{ProjectSnippet}" /> representing the results of the request. </returns>
public async Task <RequestResult <ProjectSnippet> > Create(uint projectId, string title, string fileName,
string code, VisibilityLevel visibilityLevel)
{
if (title == null)
{
throw new ArgumentNullException(nameof(title));
}
if (fileName == null)
{
throw new ArgumentNullException(nameof(fileName));
}
if (code == null)
{
throw new ArgumentNullException(nameof(code));
}
var request = RequestFactory.Create("projects/{projectId}/snippets", Method.Post);
request.AddUrlSegment("projectId", projectId);
request.AddParameter("title", title);
request.AddParameter("file_name", fileName);
request.AddParameter("code", code);
request.AddParameter("visibility_level", visibilityLevel);
return(await request.Execute <ProjectSnippet>());
}
private static bool ComputePropertyVisibility(PropertyInfo propertyInfo, bool bypassParam, VisibilityLevel visibilityLevel)
{
bool isVisible = false;
var hiddenAttribute = propertyInfo.GetCustomAttribute(typeof(HiddenWhenAttribute));
var visibilityByPassAttribute = propertyInfo.GetCustomAttribute(typeof(VisibilityByPassAttribute));
if (visibilityByPassAttribute == null && hiddenAttribute == null) // no attribute = keep in any case
{
isVisible = true;
}
else if (visibilityByPassAttribute != null && bypassParam) // bypass attribute + bypassParam = keep
{
isVisible = true;
}
else if (hiddenAttribute != null)
{
HiddenWhenAttribute hiddenLevels = hiddenAttribute as HiddenWhenAttribute;
if (hiddenLevels != null)
{
if (!hiddenLevels.Levels.Contains(visibilityLevel))
isVisible = true;
}
}
else
{
isVisible = false;
}
return isVisible;
}
static void Prefix(PilotableActorRepresentation __instance, ref VisibilityLevel newLevel)
{
if (!FogOfWarManager.GetInstance().IsFogOfWarOn)
{
Main.Logger.LogDebug($"[BTDebug] Running PilotableActorRepresentation Prefix for Fog of War");
newLevel = VisibilityLevel.LOSFull;
}
}
public static Color GetGemColor(VisibilityLevel level)
{
if (visibilityColors.ContainsKey(level))
{
return(visibilityColors[level]);
}
Debug.LogError("Missing visibility color!");
return(Color.magenta);
}
public async Task Create_ValidParameters_AddsVisibilityLevelParameter()
{
const VisibilityLevel expected = VisibilityLevel.Public;
var sut = new ProjectSnippetRepository(_requestFactory);
await sut.Create(0, "title", "fileName", "code", expected);
_request.Received().AddParameter("visibility_level", expected);
}
public async Task Update_VisibilityLevelIsSet_AddsVisibilityLevelParameter()
{
const VisibilityLevel expected = VisibilityLevel.Public;
var sut = new ProjectSnippetRepository(_requestFactory);
await sut.Update(0, 0, visibilityLevel : expected);
_request.Received().AddParameterIfNotNull("visibility_level", expected);
}
public static void Postfix(CombatHUDActorNameDisplay __instance, VisibilityLevel visLevel, AbstractActor ___displayedActor)
{
if (___displayedActor != null && ModState.LastPlayerActorActivated != null && ModState.TurnDirectorStarted &&
!___displayedActor.Combat.HostilityMatrix.IsLocalPlayerFriendly(___displayedActor.TeamId))
{
SensorScanType scanType = SensorLockHelper.CalculateSharedLock(___displayedActor, ModState.LastPlayerActorActivated);
// TODO: Needs to be hidden or localized
string nameText = scanType >= SensorScanType.AllInformation ? ___displayedActor.GetPilot().Name : "";
__instance.PilotNameText.SetText(nameText);
}
}
public static bool Prefix(SelectionStateFire __instance, ref bool __result, ICombatant combatant)
{
Mod.Log.Trace?.Write("SSF:PCC:PRE entered");
if (__instance != null && combatant != null && combatant is AbstractActor targetActor && __instance.SelectedActor != null)
{
CombatGameState Combat = __instance.SelectedActor.Combat;
bool targetIsFriendly = Combat.HostilityMatrix.IsFriendly(combatant.team.GUID, Combat.LocalPlayerTeamGuid);
if (targetIsFriendly)
{
Mod.Log.Trace?.Write("Friendly target, skipping check");
return(true);
}
EWState targetState = new EWState(targetActor);
EWState attackerState = new EWState(__instance.SelectedActor);
if (__instance.SelectionType == SelectionType.FireMorale)
{
// Prevents blips from being the targets of called shots
VisibilityLevel targetVisibility = __instance.SelectedActor.VisibilityToTargetUnit(targetActor);
if (targetVisibility < VisibilityLevel.LOSFull)
{
Mod.Log.Info?.Write($"Target {CombatantUtils.Label(combatant)} is a blip, cannot be targeted by called shot");
__result = false;
return(false);
}
float distance = Vector3.Distance(__instance.SelectedActor.CurrentPosition, targetActor.CurrentPosition);
bool hasVisualScan = VisualLockHelper.GetVisualScanRange(__instance.SelectedActor) >= distance;
SensorScanType sensorScan = SensorLockHelper.CalculateSharedLock(targetActor, __instance.SelectedActor);
if (sensorScan < SensorScanType.ArmorAndWeaponType && !hasVisualScan)
{
Mod.Log.Info?.Write($"Target {CombatantUtils.Label(targetActor)} sensor info {sensorScan} is less than SurfaceScan and range:{distance} outside visualScan range, cannot be targeted by called shot");
__result = false;
return(false);
}
}
else if (__instance.SelectionType == SelectionType.FireMulti)
{
if (targetState.HasStealth() || targetState.HasMimetic())
{
Mod.Log.Info?.Write($"Target {CombatantUtils.Label(targetActor)} has stealth, cannot be multi-targeted!");
__result = false;
return(false);
}
}
}
__result = false;
return(true);
}
public static bool Prefix(TurnDirector __instance, VisibilityLevel contactLevel)
{
Mod.Log.Trace?.Write($"TD:NC - entered.");
if (__instance.IsInterleaved && contactLevel == VisibilityLevel.None && !__instance.DoAnyUnitsHaveContactWithEnemy)
{
Mod.Log.Info?.Write("Intercepting lostContact state, allowing remainder of actors to move.");
return(false);
}
else
{
return(true);
}
}
private void SetVisibility(VisibilityLevel visibility)
{
CurrentVisibility = visibility;
Renderer[] renderers = this.GetComponentsInChildren <Renderer>();
for (int index = 0; index < renderers.Length; index++)
{
Color color = renderers[index].material.color;
color.a = (float)visibility / 100;
renderers[index].material.color = color;
}
}
// Token: 0x06000D92 RID: 3474 RVA: 0x0003CE40 File Offset: 0x0003B040
public void SetVisibilityLevel(VisibilityLevel newVisibilityLevel)
{
if (this.visibilityLevel != newVisibilityLevel)
{
this.visibilityLevel = newVisibilityLevel;
switch (this.visibilityLevel)
{
case VisibilityLevel.Invisible:
for (int i = 0; i < this.rendererInfos.Length; i++)
{
CharacterModel.RendererInfo rendererInfo = this.rendererInfos[i];
rendererInfo.renderer.enabled = false;
rendererInfo.renderer.shadowCastingMode = ShadowCastingMode.Off;
}
return;
case VisibilityLevel.Cloaked:
for (int j = 0; j < this.rendererInfos.Length; j++)
{
CharacterModel.RendererInfo rendererInfo2 = this.rendererInfos[j];
rendererInfo2.renderer.enabled = true;
rendererInfo2.renderer.shadowCastingMode = ShadowCastingMode.Off;
rendererInfo2.renderer.material = CharacterModel.cloakedMaterial;
}
return;
case VisibilityLevel.Revealed:
for (int k = 0; k < this.rendererInfos.Length; k++)
{
CharacterModel.RendererInfo rendererInfo3 = this.rendererInfos[k];
rendererInfo3.renderer.enabled = true;
rendererInfo3.renderer.shadowCastingMode = ShadowCastingMode.Off;
rendererInfo3.renderer.material = CharacterModel.revealedMaterial;
}
return;
case VisibilityLevel.Visible:
for (int l = 0; l < this.rendererInfos.Length; l++)
{
CharacterModel.RendererInfo rendererInfo4 = this.rendererInfos[l];
rendererInfo4.renderer.enabled = true;
rendererInfo4.renderer.shadowCastingMode = ShadowCastingMode.On;
rendererInfo4.renderer.material = rendererInfo4.defaultMaterial;
}
break;
default:
return;
}
}
}
private IEnumerator DoSetDeviceIndex(int index)
{
yield return(new WaitForSeconds(1f));
yield return(null); //wait for children to be initialized
Rigidbody = this.GetComponent <Rigidbody>();
if (Rigidbody == null)
{
Rigidbody = this.gameObject.AddComponent <Rigidbody>();
}
Rigidbody.isKinematic = true;
Transform trackhat = this.transform.FindChild("trackhat");
Collider trackhatCollider = trackhat.GetComponent <Collider>();
if (trackhatCollider == null)
{
trackhatCollider = trackhat.gameObject.AddComponent <SphereCollider>();
}
trackhatCollider.isTrigger = true;
NVRPlayer.Instance.RegisterHand(this);
if (NVRPlayer.Instance.PhysicalHands == true)
{
if (PhysicalController != null)
{
PhysicalController.Kill();
}
PhysicalController = this.gameObject.AddComponent <NVRPhysicalController>();
PhysicalController.Initialize(this, false);
Color transparentcolor = Color.white;
transparentcolor.a = (float)VisibilityLevel.Ghost / 100f;
GhostRenderers = this.GetComponentsInChildren <Renderer>();
for (int rendererIndex = 0; rendererIndex < GhostRenderers.Length; rendererIndex++)
{
NVRHelpers.SetTransparent(GhostRenderers[rendererIndex].material, transparentcolor);
}
GhostColliders = new Collider[] { trackhatCollider };
CurrentVisibility = VisibilityLevel.Ghost;
}
CurrentHandState = HandState.Idle;
}
public void UpdatePlayerVisibility()
{
List <LightSource> lights = CurrentFloorObject.GetComponent <DungeonLevel>().LightSources.Items;
Vector3 playerWorldPos = Utils.ConvertToWorldCoord(playerCreature.Position) + new Vector3(0f, 0.5f, 0f);
VisibilityLevel level = Visibility.Calculate(playerWorldPos, lights);
// Equipped lightsources always cause player to be visible
if (CreatureHasLightsource(playerCreature, EquipSlot.LeftHand) || CreatureHasLightsource(playerCreature, EquipSlot.RightHand))
{
level = VisibilityLevel.Visible;
}
playerObject.GetComponent <Player>().CurrentVisibility = level;
visibilityDiamondObject.GetComponent <MeshRenderer>().material.SetColor("_Color", Visibility.GetGemColor(level));
}
static void Postfix(PilotableActorRepresentation __instance, VisibilityLevel newLevel)
{
Mod.Log.Trace?.Write("PAR:OPVC entered.");
Traverse parentT = Traverse.Create(__instance).Property("parentActor");
AbstractActor parentActor = parentT.GetValue <AbstractActor>();
if (ModState.AmbushTurretGUIDtoBuilding.Keys.Contains(parentActor.GUID))
{
Turret turret = parentActor as Turret;
if (newLevel == VisibilityLevel.LOSFull)
{
__instance.VisibleObject.SetActive(false);
}
}
}
private bool?ShouldTraceBasedOnClassLevelInfo(MethodDefinition definition)
{
TraceAttributeInfo attributeInfo = GetTraceAttributeInfoForType(definition.DeclaringType);
if (attributeInfo != null)
{
if (attributeInfo.IsNoTrace)
{
return(false);
}
TraceTargetVisibility targetVisibility = attributeInfo.TargetVisibility;
VisibilityLevel methodVisibility = VisibilityHelper.GetMethodVisibilityLevel(definition);
return((int)targetVisibility >= (int)methodVisibility);
}
return(null);
}
internal override bool IsMatching(MethodDefinition methodDefinition)
{
if (base.IsMatching(methodDefinition))
{
TypeDefinition declaringType = methodDefinition.DeclaringType;
VisibilityLevel typeVisibility = VisibilityHelper.GetTypeVisibilityLevel(declaringType);
VisibilityLevel methodVisibilityLevel = VisibilityHelper.GetMethodVisibilityLevel(methodDefinition);
//check type visibility
if ((int)typeVisibility > (int)_targetClass)
{
return(false);
}
//then method visibility will decide
return((int)methodVisibilityLevel <= (int)_targetMethod);
}
return(false);
}
public static void Postfix(ref VisibilityLevel __result, AbstractActor source, Vector3 sourcePosition, Vector3 targetPosition)
{
try
{
if (__result == VisibilityLevel.None)
{
float maxDistance = source.team.TeamController == TeamController.Computer
? AlwaysDetect.HarmonyManager.Settings.MaxAIDetectionDistance
: AlwaysDetect.HarmonyManager.Settings.MaxHumanDetectionDistance;
if (Vector3.Distance(sourcePosition, targetPosition) < maxDistance)
{
__result = VisibilityLevel.Blip0Minimum;
}
}
}
catch (Exception e)
{
AlwaysDetect.HarmonyManager.Log(e.ToString());
throw;
}
}
public static void Postfix(Mech __instance, ref Text __result, VisibilityLevel visLevel)
{
if (__instance == null)
{
return;
}
/*
* Mech.UnitName = MechDef.Chassis.Description.Name -> Shadow Hawk / Atlas / Marauder
* Mech.Nickname = Mech.Description.Name -> Shadow Hawk SHD-2D / Atlas AS7-D / Marauder ANU-O
* Mech.Description.UIName -> Shadow Hawk SHD-2D / Atlas AS7-D Danielle / Anand ANU-O
*/
string fullName = __instance.Description.UIName;
if (__instance.Combat.HostilityMatrix.IsLocalPlayerEnemy(__instance.team.GUID))
{
string chassisName = __instance.UnitName;
string partialName = __instance.Nickname;
SensorScanType scanType = SensorLockHelper.CalculateSharedLock(__instance, null);
if (scanType < SensorScanType.ArmorAndWeaponType)
{
bool hasVisualScan = VisualLockHelper.CanSpotTargetUsingCurrentPositions(ModState.LastPlayerActorActivated, __instance);
if (hasVisualScan)
{
scanType = SensorScanType.ArmorAndWeaponType;
}
}
__result = CombatNameHelper.GetEnemyMechDetectionLabel(visLevel, scanType, fullName, partialName, chassisName);
}
else
{
string displayName = __instance.DisplayName;
__result = CombatNameHelper.GetNonHostileMechDetectionLabel(__instance, fullName, displayName);
}
}
private void SetVisibility(VisibilityLevel visibility)
{
if (CurrentVisibility != visibility)
{
if (visibility == VisibilityLevel.Ghost)
{
PhysicalController.Off();
for (int index = 0; index < GhostRenderers.Length; index++)
{
GhostRenderers[index].enabled = true;
}
for (int index = 0; index < GhostColliders.Length; index++)
{
GhostColliders[index].enabled = true;
}
}
if (visibility == VisibilityLevel.Visible)
{
PhysicalController.On();
for (int index = 0; index < GhostRenderers.Length; index++)
{
GhostRenderers[index].enabled = false;
}
for (int index = 0; index < GhostColliders.Length; index++)
{
GhostColliders[index].enabled = false;
}
}
}
CurrentVisibility = visibility;
}
public static void Postfix(FiringPreviewManager __instance, ref bool __result, CombatGameState ___combat,
AbstractActor attacker, ICombatant target, Vector3 position, List <AbstractActor> allies)
{
//LowVisibility.Logger.Debug("FiringPreviewManager:HasLOS:post - entered.");
for (int i = 0; i < allies.Count; i++)
{
//if (allies[i].VisibilityCache.VisibilityToTarget(target).VisibilityLevel == VisibilityLevel.LOSFull) {
if (allies[i].VisibilityCache.VisibilityToTarget(target).VisibilityLevel >= VisibilityLevel.Blip0Minimum)
{
__result = true;
Mod.Log.Trace?.Write($"Allied actor{CombatantUtils.Label(allies[i])} has LOS " +
$"to target:{CombatantUtils.Label(target as AbstractActor)}, returning true.");
return;
}
}
VisibilityLevel visibilityToTargetWithPositionsAndRotations =
___combat.LOS.GetVisibilityToTargetWithPositionsAndRotations(attacker, position, target);
//__result = visibilityToTargetWithPositionsAndRotations == VisibilityLevel.LOSFull;
__result = visibilityToTargetWithPositionsAndRotations >= VisibilityLevel.Blip0Minimum;
Mod.Log.Trace?.Write($"Actor{CombatantUtils.Label(attacker)} has LOS? {__result} " +
$"to target:{CombatantUtils.Label(target as AbstractActor)}");
}
private void SetVisibility(VisibilityLevel visibility)
{
CurrentVisibility = visibility;
Renderer[] renderers = this.GetComponentsInChildren<Renderer>();
for (int index = 0; index < renderers.Length; index++)
{
Color color = renderers[index].material.color;
color.a = (float)visibility / 100;
renderers[index].material.color = color;
}
}
private IEnumerator DoInitialize()
{
do
{
yield return null; //wait for render model to be initialized
} while (RenderModelInitialized == false && CustomModel == null);
Rigidbody = this.GetComponent<Rigidbody>();
if (Rigidbody == null)
Rigidbody = this.gameObject.AddComponent<Rigidbody>();
Rigidbody.isKinematic = true;
Rigidbody.maxAngularVelocity = float.MaxValue;
Rigidbody.useGravity = false;
Collider[] Colliders = null;
if (CustomModel == null)
{
string controllerModel = GetDeviceName();
SteamVR_RenderModel renderModel = this.GetComponentInChildren<SteamVR_RenderModel>();
switch (controllerModel)
{
case "vr_controller_05_wireless_b":
Transform dk1Trackhat = renderModel.transform.Find("trackhat");
if (dk1Trackhat == null)
{
// Dk1 controller model has trackhat
}
else
{
dk1Trackhat.gameObject.SetActive(true);
}
SphereCollider dk1TrackhatCollider = dk1Trackhat.gameObject.GetComponent<SphereCollider>();
if (dk1TrackhatCollider == null)
{
dk1TrackhatCollider = dk1Trackhat.gameObject.AddComponent<SphereCollider>();
dk1TrackhatCollider.isTrigger = true;
}
Colliders = new Collider[] { dk1TrackhatCollider };
break;
case "vr_controller_vive_1_5":
Transform dk2Trackhat = renderModel.transform.FindChild("trackhat");
if (dk2Trackhat == null)
{
dk2Trackhat = new GameObject("trackhat").transform;
dk2Trackhat.gameObject.layer = this.gameObject.layer;
dk2Trackhat.parent = renderModel.transform;
dk2Trackhat.localPosition = new Vector3(0, -0.033f, 0.014f);
dk2Trackhat.localScale = Vector3.one * 0.1f;
dk2Trackhat.localEulerAngles = new Vector3(325, 0, 0);
dk2Trackhat.gameObject.SetActive(true);
}
else
{
dk2Trackhat.gameObject.SetActive(true);
}
Collider dk2TrackhatCollider = dk2Trackhat.gameObject.GetComponent<SphereCollider>();
if (dk2TrackhatCollider == null)
{
dk2TrackhatCollider = dk2Trackhat.gameObject.AddComponent<SphereCollider>();
dk2TrackhatCollider.isTrigger = true;
}
Colliders = new Collider[] { dk2TrackhatCollider };
break;
default:
Debug.LogError("Error. Unsupported device type: " + controllerModel);
break;
}
}
else if (RenderModelInitialized == false)
{
RenderModelInitialized = true;
GameObject CustomModelObject = GameObject.Instantiate(CustomModel);
Colliders = CustomModelObject.GetComponentsInChildren<Collider>(); //note: these should be trigger colliders
CustomModelObject.transform.parent = this.transform;
CustomModelObject.transform.localScale = Vector3.one;
CustomModelObject.transform.localPosition = Vector3.zero;
CustomModelObject.transform.localRotation = Quaternion.identity;
}
NVRPlayer.Instance.RegisterHand(this);
if (NVRPlayer.Instance.PhysicalHands == true)
{
if (PhysicalController != null)
{
PhysicalController.Kill();
}
PhysicalController = this.gameObject.AddComponent<NVRPhysicalController>();
PhysicalController.Initialize(this, false);
Color transparentcolor = Color.white;
transparentcolor.a = (float)VisibilityLevel.Ghost / 100f;
GhostRenderers = this.GetComponentsInChildren<Renderer>();
for (int rendererIndex = 0; rendererIndex < GhostRenderers.Length; rendererIndex++)
{
NVRHelpers.SetTransparent(GhostRenderers[rendererIndex].material, transparentcolor);
}
if (Colliders != null)
{
GhostColliders = Colliders;
}
CurrentVisibility = VisibilityLevel.Ghost;
}
else
{
Color transparentcolor = Color.white;
transparentcolor.a = (float)VisibilityLevel.Ghost / 100f;
GhostRenderers = this.GetComponentsInChildren<Renderer>();
for (int rendererIndex = 0; rendererIndex < GhostRenderers.Length; rendererIndex++)
{
NVRHelpers.SetTransparent(GhostRenderers[rendererIndex].material, transparentcolor);
}
if (Colliders != null)
{
GhostColliders = Colliders;
}
CurrentVisibility = VisibilityLevel.Ghost;
}
CurrentHandState = HandState.Idle;
}
private IEnumerator DoInitialize()
{
yield return null; //wait for children to be initialized
Rigidbody = this.GetComponent<Rigidbody>();
if (Rigidbody == null)
Rigidbody = this.gameObject.AddComponent<Rigidbody>();
Rigidbody.isKinematic = true;
Transform trackhat = this.transform.FindChild("trackhat");
Collider trackhatCollider = trackhat.GetComponent<Collider>();
if (trackhatCollider == null)
trackhatCollider = trackhat.gameObject.AddComponent<SphereCollider>();
trackhatCollider.isTrigger = true;
NVRPlayer.Instance.RegisterHand(this);
if (NVRPlayer.Instance.PhysicalHands == true)
{
if (PhysicalController != null)
{
PhysicalController.Kill();
}
PhysicalController = this.gameObject.AddComponent<NVRPhysicalController>();
PhysicalController.Initialize(this, false);
Color transparentcolor = Color.white;
transparentcolor.a = (float)VisibilityLevel.Ghost / 100f;
GhostRenderers = this.GetComponentsInChildren<Renderer>();
for (int rendererIndex = 0; rendererIndex < GhostRenderers.Length; rendererIndex++)
{
NVRHelpers.SetTransparent(GhostRenderers[rendererIndex].material, transparentcolor);
}
GhostColliders = new Collider[] { trackhatCollider };
CurrentVisibility = VisibilityLevel.Ghost;
}
CurrentHandState = HandState.Idle;
}
private void SetVisibility(VisibilityLevel visibility)
{
if (CurrentVisibility != visibility)
{
if (visibility == VisibilityLevel.Ghost)
{
PhysicalController.Off();
for (int index = 0; index < GhostRenderers.Length; index++)
{
GhostRenderers[index].enabled = true;
}
for (int index = 0; index < GhostColliders.Length; index++)
{
GhostColliders[index].enabled = true;
}
}
if (visibility == VisibilityLevel.Visible)
{
PhysicalController.On();
for (int index = 0; index < GhostRenderers.Length; index++)
{
GhostRenderers[index].enabled = false;
}
for (int index = 0; index < GhostColliders.Length; index++)
{
GhostColliders[index].enabled = false;
}
}
}
CurrentVisibility = visibility;
}
