public static bool Prefix(TargetingSystem __instance, ref bool __result, Character ___m_character, ref LockingPoint ___m_currentLockingPoint,
ref int ___m_remainingHelpLockCount)
{
if (!___m_character || ___m_character.IsAI || !PvP.Instance.FriendlyFireEnabled || (PvP.Instance.FriendlyFireEnabled && PvP.Instance.FriendlyTargetingEnabled))
{
return(true);
}
if (__instance.CameraRef != null)
{
Collider[] array = Physics.OverlapSphere(___m_character.CenterPosition, __instance.TrueRange, Global.LockingPointsMask);
LockingPoint lockingPoint = null;
Vector3 vector = Vector2.zero;
Vector3 vector2;
Matrix4x4 worldToCameraMatrix = __instance.CameraRef.worldToCameraMatrix;
foreach (Collider collider in array)
{
vector2 = worldToCameraMatrix.MultiplyPoint(collider.transform.position);
if (vector2.z < 0f)
{
vector2.z *= 0.1f;
if (lockingPoint == null || vector2.magnitude < vector.magnitude)
{
LockingPoint component = collider.GetComponent <LockingPoint>();
if (component.OwnerChar == null
// This is the only thing I'm changing, using the unmodified IsTargetable instead of the patched one.
|| (OrigIsTargetable(__instance, component.OwnerChar) && // __instance.IsTargetable(component.OwnerChar)
component.OwnerChar.Alive &&
!Physics.Linecast(___m_character.CenterPosition, collider.transform.position, Global.SightHideMask)))
{
lockingPoint = component;
vector = vector2;
}
}
}
}
if (lockingPoint != null)
{
___m_currentLockingPoint = lockingPoint;
if (___m_remainingHelpLockCount > 0)
{
___m_remainingHelpLockCount--;
}
__result = true;
return(false);
}
}
__result = false;
return(false);
}
public static bool Prefix(ref bool __result, Character __instance, float _range)
{
__result = false;
Collider[] array = Physics.OverlapSphere(__instance.CenterPosition, _range, Global.LockingPointsMask);
for (int i = 0; i < array.Length; i++)
{
LockingPoint component = array[i].GetComponent <LockingPoint>();
if (component && component.OwnerChar && component.OwnerChar.Alive && OrigIsTargetable(__instance.TargetingSystem, component.OwnerChar))
{
__result = true;
}
}
return(false);
}
static void AICEnemyDetection_Detected_Post(AICEnemyDetection __instance, LockingPoint _point)
{
#region quit
if (!_changeTargetWhenTooFar || !_point.OwnerChar.TryAssign(out var target))
{
return;
}
#endregion
Character enemy = __instance.m_characterAI.Character;
enemy.AddLastDealer(target.UID);
if (_changeTargetDetectAllPlayers && target.IsPlayer())
{
foreach (var player in Players.Local)
{
enemy.AddLastDealer(player.Character.UID);
}
}
}
private void CustomToggleTarget(Character character)
{
var localControl = character.CharacterControl as LocalCharacterControl;
if (!character.CharacterCamera.InZoomMode && !character.TargetingSystem.LockedCharacter)
{
// If not locked, we will just get a target (same as vanilla method)
At.Invoke(localControl, "AcquireTarget");
if (character.TargetingSystem.Locked && localControl.ControlMode == LocalCharacterControl.CameraControlMode.Classic)
{
localControl.FaceLikeCamera = true;
}
}
else if (character.TargetingSystem.LockedCharacter)
{
// Otherwise we need to find a new target. This is similar to vanilla, but a bit different.
if (character.TargetingSystem.CameraRef != null)
{
Collider[] array = Physics.OverlapSphere(character.CenterPosition, character.TargetingSystem.TrueRange, Global.LockingPointsMask);
Matrix4x4 worldToCameraMatrix = character.TargetingSystem.CameraRef.worldToCameraMatrix;
var cam = character.TargetingSystem.CameraRef.transform.position;
LockingPoint lockingPoint = null;
float num = float.MaxValue;
// foreach collider that is not our current target
var currentCollider = character.TargetingSystem.LockingPoint.GetComponent <Collider>();
foreach (Collider collider in array.Where(x => x != currentCollider))
{
// this is my custom bit. Find the target with the smallest angle relative to our camera direction.
var angle = Vector2.Angle(cam, collider.transform.position);
if (angle < num || lockingPoint == null)
{
LockingPoint component = collider.GetComponent <LockingPoint>();
if (component.OwnerChar == null ||
(character.TargetingSystem.IsTargetable(component.OwnerChar) &&
!Physics.Linecast(character.CenterPosition, collider.transform.position, Global.SightHideMask)))
{
lockingPoint = component;
num = angle;
}
}
}
// if we got a new target, set it to them now.
if (lockingPoint != null)
{
if (character.TargetingSystem.Locked && localControl.ControlMode == LocalCharacterControl.CameraControlMode.Classic)
{
localControl.FaceLikeCamera = true;
}
character.TargetingSystem.SetLockingPoint(lockingPoint);
character.TargetingSystem.LockingPointOffset = Vector2.zero;
character.CharacterCamera.LookAtTransform = character.TargetingSystem.LockingPointTrans;
}
else // otherwise we did not find a new target. Release the current target.
{
At.Invoke(character.CharacterControl as LocalCharacterControl, "ReleaseTarget");
}
}
}
}
public static bool Prefix(LocalCharacterControl __instance)
{
var self = __instance;
var m_character = At.GetField(self as CharacterControl, "m_character") as Character;
var m_targetingSystem = m_character.TargetingSystem;
bool m_lockHoldUp = false;
if (!m_character.CharacterCamera.InZoomMode &&
(ControlsInput.LockToggle(m_character.OwnerPlayerSys.PlayerID) || ControlsInput.LockHoldDown(m_character.OwnerPlayerSys.PlayerID)))
{
At.SetField(self, "m_lockHoldUp", false);
if (m_targetingSystem.Locked)
{
At.Invoke(self, "ReleaseTarget");
if (self.ControlMode == LocalCharacterControl.CameraControlMode.Classic)
{
self.FaceLikeCamera = false;
}
}
else
{
At.Invoke(self, "AcquireTarget");
if (m_targetingSystem.Locked && self.ControlMode == LocalCharacterControl.CameraControlMode.Classic)
{
self.FaceLikeCamera = true;
}
}
}
if (ControlsInput.LockHoldUp(m_character.OwnerPlayerSys.PlayerID))
{
m_lockHoldUp = true;
At.SetField(self, "m_lockHoldUp", true);
}
if (!m_character.CharacterCamera.InZoomMode && m_lockHoldUp)
{
At.Invoke(self, "ReleaseTarget");
}
if (Input.GetMouseButtonDown(3) && self.TargetMode == LocalCharacterControl.TargetingMode.Aim)
{
Ray ray = m_character.CharacterCamera.CameraScript.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out RaycastHit raycastHit, m_targetingSystem.TrueRange * 1.5f, Global.AimTargetMask))
{
LockingPoint lockingPoint = raycastHit.collider.GetComponent <LockingPoint>();
if (lockingPoint == null)
{
Character characterOwner = raycastHit.collider.GetCharacterOwner();
if (characterOwner)
{
lockingPoint = characterOwner.LockingPoint;
}
}
if (lockingPoint)
{
At.Invoke(self, "SwitchTarget", new object[] { lockingPoint });
}
}
}
if (m_targetingSystem.Locked && !m_character.CharacterCamera.InZoomMode)
{
if (!self.FaceLikeCamera)
{
self.FaceLikeCamera = true;
}
if (self.TargetMode == LocalCharacterControl.TargetingMode.Classic)
{
Vector2 vector = new Vector2(
ControlsInput.SwitchTargetHorizontal(m_character.OwnerPlayerSys.PlayerID),
ControlsInput.SwitchTargetVertical(m_character.OwnerPlayerSys.PlayerID));
float magnitude = vector.magnitude;
float m_lastTargetSwitchTime = (float)At.GetField(self, "m_lastTargetSwitchTime");
if (Time.time - m_lastTargetSwitchTime > 0.3f)
{
//Vector2 m_previousInput = (Vector2)At.GetValue(typeof(LocalCharacterControl), self, "m_previousInput");
//float magnitude2 = (vector - m_previousInput).magnitude;
//if (magnitude2 >= 0.45f && magnitude > 0.6f)
//{
// At.Call(self, "SwitchTarget", new object[] { vector });
//}
// this is for bows
if (m_character.CurrentWeapon is ProjectileWeapon)
{
var m_timeOfLastAimOffset = (float)At.GetField(self, "m_timeOfLastAimOffset");
var m_timeToNextAimOffset = (float)At.GetField(self, "m_timeToNextAimOffset");
var m_aimOffsetRandom = (Vector2)At.GetField(self, "m_aimOffsetRandom");
if (ControlsInput.IsLastActionGamepad(m_character.OwnerPlayerSys.PlayerID))
{
Vector2 a = vector;
a.x *= -1f;
if (Time.time - m_timeOfLastAimOffset > m_timeToNextAimOffset)
{
m_aimOffsetRandom = UnityEngine.Random.insideUnitCircle;
At.SetField(self, "m_aimOffsetRandom", m_aimOffsetRandom);
At.SetField(self, "m_timeOfLastAimOffset", Time.time);
At.SetField(self, "m_timeToNextAimOffset", UnityEngine.Random.Range(0.1f, 0.3f));
}
a += m_aimOffsetRandom * ((Vector3)At.GetField(self, "m_modifMoveInput")).magnitude * Time.deltaTime * 0.5f;
m_character.TargetingSystem.LockingPointOffset = Vector2.Scale(a, new Vector2(-1f, 1f));
}
else
{
Vector2 vector2 = vector * self.LockAimMouseSense;
vector2.x *= -1f;
if (Time.time - m_timeOfLastAimOffset > m_timeToNextAimOffset)
{
m_aimOffsetRandom = UnityEngine.Random.insideUnitCircle;
At.SetField(self, "m_aimOffsetRandom", m_aimOffsetRandom);
At.SetField(self, "m_timeOfLastAimOffset", Time.time);
At.SetField(self, "m_timeToNextAimOffset", UnityEngine.Random.Range(0.1f, 0.3f));
}
vector2 += m_aimOffsetRandom * ((Vector3)At.GetField(self, "m_modifMoveInput")).magnitude * Time.deltaTime * 0.5f;
m_character.TargetingSystem.LockingPointOffset -= new Vector3(vector2.x, vector2.y, 0);
m_character.TargetingSystem.LockingPointOffset = Vector3.ClampMagnitude(m_character.TargetingSystem.LockingPointOffset, 1f);
}
}
At.SetField(self, "m_previousInput", vector);
}
else if (ControlsInput.IsLastActionGamepad(m_character.OwnerPlayerSys.PlayerID) && magnitude == 0f)
{
At.SetField(self, "m_lastTargetSwitchTime", 0f);
}
}
else if (self.TargetMode == LocalCharacterControl.TargetingMode.Aim)
{
Global.LockCursor(false);
}
Vector3 lockedPointPos = m_targetingSystem.LockedPointPos;
float m_lastInSightTime = (float)At.GetField(self, "m_lastInSightTime");
if (!Physics.Linecast(m_character.CenterPosition, lockedPointPos, Global.SightHideMask))
{
m_lastInSightTime = Time.time;
At.SetField(self, "m_lastInSightTime", m_lastInSightTime);
}
bool isLocked = m_targetingSystem.LockedCharacter != null && !m_targetingSystem.LockedCharacter.Alive;
if (Vector3.Distance(lockedPointPos, m_character.CenterPosition) > m_targetingSystem.TrueRange + 2f || Time.time - m_lastInSightTime > 1f || isLocked)
{
At.Invoke(self, "ReleaseTarget");
self.Invoke("AcquireTarget", 0.5f);
}
}
else
{
m_targetingSystem.LockingPointOffset = Vector3.zero;
if (m_character.CharacterCamera.InZoomMode)
{
float m_lastFreeAimUpdateTime = (float)At.GetField(self, "m_lastFreeAimUpdateTime");
if (Time.time - m_lastFreeAimUpdateTime > 0.05f)
{
m_lastFreeAimUpdateTime = Time.time;
At.SetField(self, "m_lastFreeAimUpdateTime", m_lastFreeAimUpdateTime);
bool m_debugFreeAim = (bool)At.GetField(self, "m_debugFreeAim");
At.SetField(self, "m_freeAimTargetPos", m_character.CharacterCamera.GetObstaclePos(new Vector3(0.5f, 0.5f, 0f), m_debugFreeAim));
}
var m_freeAimLockingPoint = At.GetField(self, "m_freeAimLockingPoint") as LockingPoint;
var m_freeAimTargetPos = (Vector3)At.GetField(self, "m_freeAimTargetPos");
if ((bool)At.GetField(self, "m_wasFreeAiming"))
{
float num = (m_freeAimLockingPoint.transform.position - m_freeAimTargetPos).sqrMagnitude;
num = Mathf.Max(num, 10f);
m_freeAimLockingPoint.transform.position = Vector3.Lerp(m_freeAimLockingPoint.transform.position, m_freeAimTargetPos, num * Time.deltaTime);
}
else
{
m_freeAimLockingPoint.transform.position = m_freeAimTargetPos;
}
}
}
At.SetField(self, "m_wasFreeAiming", m_character.CharacterCamera.InZoomMode);
return(false);
}
public static bool Prefix(ref bool __result, RaycastProjectile __instance, Vector3 _startRaycast, float dist, ref RaycastHit _hit,
ref Vector3 ___m_shootDir, float ___m_radiusAdd, float ___m_capsuleAdd, LockingPoint ___m_homingTarget,
List <Character> ___m_hitCharList)
{
var self = __instance;
if (!PvP.Instance.FriendlyFireEnabled || self.OwnerCharacter || self.OwnerCharacter.IsAI)
{
return(true);
}
_hit = default;
RaycastHit[] array;
int hitMask = RaycastHitLayerMask(self);
if (self.Radius == 0f)
{
array = Physics.RaycastAll(_startRaycast, ___m_shootDir, dist, hitMask);
}
else if (self.Capsule != 0f)
{
array = Physics.SphereCastAll(_startRaycast, self.Radius + ___m_radiusAdd, ___m_shootDir, dist, hitMask);
}
else
{
array = Physics.CapsuleCastAll(
_startRaycast - self.transform.right * (self.Capsule + ___m_capsuleAdd),
_startRaycast + self.transform.right * (self.Capsule + ___m_capsuleAdd),
self.Radius + ___m_radiusAdd,
___m_shootDir,
dist,
hitMask
);
}
if (array.Length != 0)
{
var ignoredChar = (Character)At.GetValue(typeof(Projectile), __instance, "m_ignoredCharacter");
int num = -1;
for (int i = 0; i < array.Length; i++)
{
Character hitChar = array[i].collider.GetCharacterOwner();
// Added: check that we are not hitting ourselves
if (self.OwnerCharacter.UID != hitChar.UID)
{
// This is the same check that the game does, just broken up so it's actually readable.
bool valid = hitChar == null && !self.HitTargetOnly;
if (!valid)
{
valid = !self.HitTargetOnly || (___m_homingTarget && hitChar == ___m_homingTarget.OwnerChar);
valid &= hitChar != ignoredChar;
valid &= !___m_hitCharList.Contains(hitChar) || (!self.MultiTarget && self.EndMode == Projectile.EndLifeMode.Normal);
// removed: targetable check
}
if (valid)
{
if (array[i].point == Vector3.zero)
{
array[i].point = self.transform.position;
}
if (num == -1 || (_startRaycast - array[i].point).sqrMagnitude < (_startRaycast - array[num].point).sqrMagnitude)
{
if (hitChar)
{
___m_hitCharList.Add(hitChar);
}
num = i;
}
}
}
}
if (num != -1)
{
_hit = array[num];
__result = true;
return(false);
}
}
__result = false;
return(false);
}
public static bool Prefix(LocalCharacterControl __instance)
{
var self = __instance;
var character = self.m_character;
var targetingSystem = character.TargetingSystem;
if (!character.CharacterCamera.InZoomMode &&
(ControlsInput.LockToggle(character.OwnerPlayerSys.PlayerID) ||
ControlsInput.LockHoldDown(character.OwnerPlayerSys.PlayerID)))
{
self.m_lockHoldUp = false;
if (targetingSystem.Locked)
{
self.ReleaseTarget();
if (self.ControlMode == LocalCharacterControl.CameraControlMode.Classic)
{
self.FaceLikeCamera = false;
}
}
else
{
self.AcquireTarget();
if (targetingSystem.Locked && self.ControlMode == LocalCharacterControl.CameraControlMode.Classic)
{
self.FaceLikeCamera = true;
}
}
}
if (ControlsInput.LockHoldUp(character.OwnerPlayerSys.PlayerID))
{
self.m_lockHoldUp = true;
}
if (!character.CharacterCamera.InZoomMode && self.m_lockHoldUp)
{
self.ReleaseTarget();
}
if (Input.GetMouseButtonDown(3) && self.TargetMode == LocalCharacterControl.TargetingMode.Aim)
{
Ray ray = character.CharacterCamera.CameraScript.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out RaycastHit raycastHit, targetingSystem.TrueRange * 1.5f, Global.AimTargetMask))
{
LockingPoint lockingPoint = raycastHit.collider.GetComponent <LockingPoint>();
if (lockingPoint == null)
{
Character characterOwner = raycastHit.collider.GetCharacterOwner();
if (characterOwner)
{
lockingPoint = characterOwner.LockingPoint;
}
}
if (lockingPoint)
{
self.SwitchTarget(lockingPoint);
}
}
}
if (targetingSystem.Locked && !character.CharacterCamera.InZoomMode)
{
if (!self.FaceLikeCamera)
{
self.FaceLikeCamera = true;
}
if (self.TargetMode == LocalCharacterControl.TargetingMode.Classic)
{
Vector2 inputVector = new Vector2(
ControlsInput.SwitchTargetHorizontal(character.OwnerPlayerSys.PlayerID),
ControlsInput.SwitchTargetVertical(character.OwnerPlayerSys.PlayerID));
if (character.CurrentWeapon is ProjectileWeapon)
{
// this is for bows
if (ControlsInput.IsLastActionGamepad(character.OwnerPlayerSys.PlayerID))
{
Vector2 bowVector = inputVector;
bowVector.x *= -1f;
if (Time.time - self.m_timeOfLastAimOffset > self.m_timeToNextAimOffset)
{
self.m_aimOffsetRandom = UnityEngine.Random.insideUnitCircle;
self.m_timeOfLastAimOffset = Time.time;
self.m_timeToNextAimOffset = UnityEngine.Random.Range(0.1f, 0.3f);
}
bowVector += self.m_aimOffsetRandom * self.m_modifMoveInput.magnitude * Time.deltaTime * 0.5f;
character.TargetingSystem.LockingPointOffset = Vector2.Scale(bowVector, new Vector2(-1f, 1f));
}
else
{
Vector2 aimVector = inputVector * self.LockAimMouseSense;
aimVector.x *= -1f;
if (Time.time - self.m_timeOfLastAimOffset > self.m_timeToNextAimOffset)
{
self.m_aimOffsetRandom = UnityEngine.Random.insideUnitCircle;
self.m_timeOfLastAimOffset = Time.time;
self.m_timeToNextAimOffset = UnityEngine.Random.Range(0.1f, 0.3f);
}
aimVector += self.m_aimOffsetRandom * self.m_modifMoveInput.magnitude * Time.deltaTime * 0.5f;
character.TargetingSystem.LockingPointOffset -= new Vector3(aimVector.x, aimVector.y, 0);
character.TargetingSystem.LockingPointOffset = Vector3.ClampMagnitude(
character.TargetingSystem.LockingPointOffset,
1f);
}
}
self.m_previousInput = inputVector;
}
else if (self.TargetMode == LocalCharacterControl.TargetingMode.Aim)
{
Global.LockCursor(false);
}
Vector3 lockedPointPos = targetingSystem.LockedPointPos;
if (!Physics.Linecast(character.CenterPosition, lockedPointPos, Global.SightHideMask))
{
self.m_lastInSightTime = Time.time;
}
bool isLocked = targetingSystem.LockedCharacter != null && targetingSystem.LockedCharacter.Alive;
if (Vector3.Distance(lockedPointPos, character.CenterPosition) > targetingSystem.TrueRange + 2f ||
Time.time - self.m_lastInSightTime > 1f ||
!isLocked)
{
self.ReleaseTarget();
self.Invoke("AcquireTarget", 0.5f);
}
}
else
{
targetingSystem.LockingPointOffset = Vector3.zero;
if (character.CharacterCamera.InZoomMode)
{
if (Time.time - self.m_lastFreeAimUpdateTime > 0.05f)
{
self.m_lastFreeAimUpdateTime = Time.time;
self.m_freeAimTargetPos = character.CharacterCamera.GetObstaclePos(new Vector3(0.5f, 0.5f, 0f), self.m_debugFreeAim);
}
if (self.m_wasFreeAiming)
{
float num = (self.m_freeAimLockingPoint.transform.position - self.m_freeAimTargetPos).sqrMagnitude;
num = Mathf.Max(num, 10f);
self.m_freeAimLockingPoint.transform.position = Vector3.Lerp(
self.m_freeAimLockingPoint.transform.position,
self.m_freeAimTargetPos, num * Time.deltaTime);
}
else
{
self.m_freeAimLockingPoint.transform.position = self.m_freeAimTargetPos;
}
}
}
self.m_wasFreeAiming = character.CharacterCamera.InZoomMode;
return(false);
}
