fix in autoweapon draw/ hide, bLock, bMeleeCombat and Input
This commit is contained in:
@@ -1,7 +1,7 @@
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using Beyond;
|
||||
using Invector;
|
||||
using System.Linq;
|
||||
using Invector; // Assuming vIHealthController is in this namespace or vCharacterController
|
||||
using Invector.vCharacterController;
|
||||
using UnityEngine;
|
||||
using UnityEngine.UI;
|
||||
@@ -9,20 +9,18 @@ using UnityEngine.UI;
|
||||
namespace Beyond
|
||||
{
|
||||
[vClassHeader("MELEE LOCK-ON")]
|
||||
public class bLockOn : vLockOnBehaviour
|
||||
public class bLockOn : vLockOnBehaviour // Inherits from your provided vLockOnBehaviour
|
||||
{
|
||||
#region variables
|
||||
|
||||
[System.Serializable]
|
||||
public class LockOnEvent : UnityEngine.Events.UnityEvent<Transform>
|
||||
{ }
|
||||
public class LockOnEvent : UnityEngine.Events.UnityEvent<Transform> { }
|
||||
|
||||
[Tooltip("Make sure to disable or change the StrafeInput to a different key at the Player Input component")]
|
||||
public bool strafeWhileLockOn = true;
|
||||
|
||||
[Tooltip("Create a Image inside the UI and assign here")]
|
||||
public RectTransform aimImagePrefab;
|
||||
|
||||
public Canvas aimImageContainer;
|
||||
public Vector2 aimImageSize = new Vector2(30, 30);
|
||||
|
||||
@@ -33,70 +31,95 @@ namespace Beyond
|
||||
[Range(-0.5f, 0.5f)]
|
||||
public float spriteHeight = 0.25f;
|
||||
|
||||
[Tooltip("Offset for the camera height")]
|
||||
[Tooltip("Offset for the camera height when locking on")]
|
||||
public float cameraHeightOffset;
|
||||
|
||||
[Tooltip("Transition Speed for the Camera")]
|
||||
[Tooltip("Transition Speed for the Camera to rotate towards the target when locking on.")]
|
||||
public float lockSpeed = 0.5f;
|
||||
|
||||
[Header("LockOn Inputs")]
|
||||
public GenericInput lockOnInput = new GenericInput("Tab", "RightStickClick", "RightStickClick");
|
||||
|
||||
// Inputs for Next/Previous target are now handled by calling base.ChangeTarget(1) or base.ChangeTarget(-1)
|
||||
public GenericInput nexTargetInput = new GenericInput("X", false, false, "RightAnalogHorizontal", true, false, "X", false, false);
|
||||
public GenericInput previousTargetInput = new GenericInput("Z", false, false, "RightAnalogHorizontal", true, true, "Z", false, false);
|
||||
|
||||
internal bool isLockingOn;
|
||||
|
||||
public bool isLockingOn { get; private set; } // Keep this for external systems like AutoTargetting
|
||||
public LockOnEvent onLockOnTarget;
|
||||
public LockOnEvent onUnLockOnTarget;
|
||||
private Canvas _aimCanvas;
|
||||
private RectTransform _aimImage;
|
||||
|
||||
protected bool inTarget;
|
||||
private RectTransform _aimImageInstance;
|
||||
// 'inTarget' might be redundant if we rely on base.currentTarget != null and isLockingOn
|
||||
// protected bool inTarget;
|
||||
protected bMeleeCombatInput tpInput;
|
||||
private AutoTargetting autoTargetingSystem;
|
||||
|
||||
#endregion variables
|
||||
|
||||
protected virtual void Start()
|
||||
protected void Start() // Override if base has Start, otherwise just 'void Start()'
|
||||
{
|
||||
Init();
|
||||
// If vLockOnBehaviour.Start is not virtual, you might not need base.Start()
|
||||
// but Init() is crucial from the base class.
|
||||
base.Init(); // Call the Init from vLockOnBehaviour
|
||||
|
||||
tpInput = GetComponent<bMeleeCombatInput>();
|
||||
if (tpInput)
|
||||
{
|
||||
tpInput.onUpdate -= UpdateLockOn;
|
||||
tpInput.onUpdate += UpdateLockOn;
|
||||
|
||||
// access the HealthController to Reset the LockOn when Dead
|
||||
GetComponent<vHealthController>().onDead.AddListener((GameObject g) =>
|
||||
// Player health for unlocking on death (assuming player has vIHealthController)
|
||||
var playerHealth = GetComponent<vIHealthController>();
|
||||
if (playerHealth != null)
|
||||
{
|
||||
// action to reset lockOn
|
||||
isLockingOn = false;
|
||||
LockOn(false);
|
||||
UpdateLockOn();
|
||||
});
|
||||
// This part might need adjustment based on how vIHealthController handles death events
|
||||
// For now, let's assume a simple check or that other systems handle player death state.
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Debug.LogError("bLockOn: bMeleeCombatInput not found. Lock-on system disabled.");
|
||||
enabled = false;
|
||||
return;
|
||||
}
|
||||
|
||||
if (!aimImageContainer)
|
||||
if (!aimImageContainer) aimImageContainer = GetComponentInChildren<Canvas>(true);
|
||||
if (aimImagePrefab && aimImageContainer && _aimImageInstance == null)
|
||||
{
|
||||
aimImageContainer = gameObject.GetComponentInChildren<Canvas>(true);
|
||||
_aimImageInstance = Instantiate(aimImagePrefab, aimImageContainer.transform, false);
|
||||
_aimImageInstance.gameObject.SetActive(false);
|
||||
}
|
||||
|
||||
// Get AutoTargetting system
|
||||
if (Player.Instance != null) autoTargetingSystem = Player.Instance.GetComponentInChildren<AutoTargetting>(true);
|
||||
if (autoTargetingSystem == null) autoTargetingSystem = FindObjectOfType<AutoTargetting>();
|
||||
|
||||
if (autoTargetingSystem != null)
|
||||
{
|
||||
// Set the 'range' field from the base class
|
||||
base.range = autoTargetingSystem.maxTargetingDistance;
|
||||
// Note: findTargetAngle from AutoTargetting is not directly used by this base class.
|
||||
// The base class uses screen-space sorting. We can't easily inject world-space angle here
|
||||
// without modifying vLockOnBehaviour.GetPossibleTargets() or SortTargets().
|
||||
// For now, switching will respect AutoTargetting's *distance* but use base class's screen-angle logic.
|
||||
}
|
||||
else
|
||||
{
|
||||
Debug.LogWarning("bLockOn: AutoTargetting system not found. Using default vLockOnBehaviour range.");
|
||||
}
|
||||
}
|
||||
|
||||
public RectTransform aimImage
|
||||
public RectTransform AimImageDisplay
|
||||
{
|
||||
get
|
||||
{
|
||||
if (_aimImage) return _aimImage;
|
||||
if (aimImageContainer)
|
||||
if (_aimImageInstance == null && aimImagePrefab && aimImageContainer)
|
||||
{
|
||||
_aimImage = Instantiate(aimImagePrefab, Vector2.zero, Quaternion.identity) as RectTransform;
|
||||
_aimImage.SetParent(aimImageContainer.transform);
|
||||
return _aimImage;
|
||||
_aimImageInstance = Instantiate(aimImagePrefab, aimImageContainer.transform, false);
|
||||
_aimImageInstance.anchoredPosition = Vector2.zero;
|
||||
// ... other setup for _aimImageInstance
|
||||
}
|
||||
else
|
||||
{
|
||||
Debug.LogWarning("Missing UI Canvas in the scene, please add one");
|
||||
}
|
||||
return null;
|
||||
return _aimImageInstance;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -105,139 +128,271 @@ namespace Beyond
|
||||
if (this.tpInput == null) return;
|
||||
LockOnInput();
|
||||
SwitchTargetsInput();
|
||||
CheckForCharacterAlive();
|
||||
CheckForCharacterAlive(); // Checks base.currentTarget
|
||||
UpdateAimImage();
|
||||
}
|
||||
|
||||
protected virtual void LockOnInput()
|
||||
{
|
||||
if (tpInput.tpCamera == null || tpInput.cc == null) return;
|
||||
|
||||
// lock the camera into a target, if there is any around
|
||||
if (lockOnInput.GetButtonDown() && !tpInput.cc.customAction)
|
||||
{
|
||||
isLockingOn = !isLockingOn;
|
||||
LockOn(isLockingOn);
|
||||
}
|
||||
// unlock the camera if the target is null
|
||||
else if (isLockingOn && (tpInput.tpCamera.lockTarget == null))
|
||||
{
|
||||
isLockingOn = false;
|
||||
LockOn(false);
|
||||
}
|
||||
// choose to use lock-on with strafe of free movement
|
||||
if (strafeWhileLockOn && !tpInput.cc.locomotionType.Equals(vThirdPersonMotor.LocomotionType.OnlyStrafe))
|
||||
{
|
||||
if (isLockingOn && tpInput.tpCamera.lockTarget != null)
|
||||
// Toggle lock-on state
|
||||
if (isLockingOn)
|
||||
{
|
||||
tpInput.cc.lockInStrafe = true;
|
||||
tpInput.cc.isStrafing = true;
|
||||
UnlockTarget();
|
||||
}
|
||||
else
|
||||
{
|
||||
tpInput.cc.lockInStrafe = false;
|
||||
tpInput.cc.isStrafing = false;
|
||||
AttemptLockOn(null); // Attempt to find a new target
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// This method is called by base.ChangeTargetRoutine when a target is selected
|
||||
protected override void SetTarget()
|
||||
{
|
||||
if (tpInput.tpCamera != null)
|
||||
// base.currentTarget (which is base.target) has been set by ChangeTargetRoutine
|
||||
// or by our AttemptLockOn/ManuallySetLockOnTarget.
|
||||
// We just need to react to it.
|
||||
if (tpInput.tpCamera != null && base.currentTarget != null)
|
||||
{
|
||||
tpInput.tpCamera.SetLockTarget(currentTarget.transform, cameraHeightOffset, lockSpeed);
|
||||
onLockOnTarget.Invoke(currentTarget);
|
||||
tpInput.tpCamera.SetLockTarget(base.currentTarget.transform, cameraHeightOffset, lockSpeed);
|
||||
if (isLockingOn) // Only invoke if we are truly in a locking state
|
||||
{
|
||||
onLockOnTarget.Invoke(base.currentTarget.transform);
|
||||
}
|
||||
}
|
||||
else if (base.currentTarget == null && isLockingOn) // Target became null while we thought we were locked
|
||||
{
|
||||
UnlockTarget(false); // Silently unlock if target disappeared
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
protected virtual void SwitchTargetsInput()
|
||||
{
|
||||
if (tpInput.tpCamera == null) return;
|
||||
|
||||
if (tpInput.tpCamera.lockTarget)
|
||||
if (tpInput.tpCamera == null || !isLockingOn) return;
|
||||
// base.currentTarget is the currently locked Transform
|
||||
if (base.currentTarget != null)
|
||||
{
|
||||
// switch between targets using Keyboard
|
||||
if (previousTargetInput.GetButtonDown()) PreviousTarget();
|
||||
else if (nexTargetInput.GetButtonDown()) NextTarget();
|
||||
if (previousTargetInput.GetButtonDown()) base.ChangeTarget(-1); // Calls base class method
|
||||
else if (nexTargetInput.GetButtonDown()) base.ChangeTarget(1); // Calls base class method
|
||||
}
|
||||
}
|
||||
|
||||
// 'ChangeTarget' is already defined in the base class and handles index changes.
|
||||
// We override SetTarget() which is called by the base ChangeTargetRoutine.
|
||||
|
||||
protected virtual void CheckForCharacterAlive()
|
||||
{
|
||||
if (currentTarget && !isCharacterAlive() && inTarget || (inTarget && !isCharacterAlive()))
|
||||
// base.isCharacterAlive() checks the base.currentTarget
|
||||
if (isLockingOn && base.currentTarget != null && !base.isCharacterAlive())
|
||||
{
|
||||
ResetLockOn();
|
||||
inTarget = false;
|
||||
LockOn(true);
|
||||
StopLockOn();
|
||||
// Debug.Log($"bLockOn: Locked target {base.currentTarget.name} died. Attempting to find new one or unlock.");
|
||||
Transform oldDeadTarget = base.currentTarget;
|
||||
AttemptLockOn(null, oldDeadTarget); // Try to find a new target, excluding the dead one for this attempt
|
||||
}
|
||||
}
|
||||
|
||||
protected virtual void LockOn(bool value)
|
||||
/// <summary>
|
||||
/// Attempts to lock onto a target. If preferredTarget is provided and valid, locks that.
|
||||
/// Otherwise, finds the best available target.
|
||||
/// </summary>
|
||||
protected void AttemptLockOn(Transform preferredTarget, Transform excludeTarget = null)
|
||||
{
|
||||
base.UpdateLockOn(value);
|
||||
if (!inTarget && currentTarget)
|
||||
if (tpInput == null || tpInput.cc == null || tpInput.tpCamera == null) return;
|
||||
|
||||
Transform targetToLock = null;
|
||||
|
||||
if (preferredTarget != null && base.isCharacterAlive(preferredTarget))
|
||||
{
|
||||
inTarget = true;
|
||||
// send current target if inTarget
|
||||
SetTarget();
|
||||
targetToLock = preferredTarget;
|
||||
}
|
||||
else if (inTarget && !currentTarget)
|
||||
else
|
||||
{
|
||||
inTarget = false;
|
||||
// send message to clear current target
|
||||
StopLockOn();
|
||||
// Update range from AutoTargetting before finding targets
|
||||
if (autoTargetingSystem != null) base.range = autoTargetingSystem.maxTargetingDistance;
|
||||
|
||||
List<Transform> possible = base.GetPossibleTargets(); // This uses base.range
|
||||
if (possible != null && possible.Count > 0)
|
||||
{
|
||||
// Filter out the excludeTarget if provided
|
||||
if (excludeTarget != null)
|
||||
{
|
||||
possible.Remove(excludeTarget);
|
||||
}
|
||||
// Optional: Re-filter 'possible' list here using AutoTargetting's angle
|
||||
// This would require iterating 'possible' and doing Vector3.Angle checks.
|
||||
// For now, we rely on base.SortTargets() which is screen-based.
|
||||
if (possible.Count > 0)
|
||||
{
|
||||
targetToLock = possible.FirstOrDefault(); // Base.GetPossibleTargets already sorts them
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (targetToLock != null)
|
||||
{
|
||||
// If we were previously locked on a different target
|
||||
if (isLockingOn && base.currentTarget != null && base.currentTarget != targetToLock)
|
||||
{
|
||||
onUnLockOnTarget.Invoke(base.currentTarget); // Invoke for old target
|
||||
}
|
||||
|
||||
// This directly sets the protected 'target' field in the base class
|
||||
// Since we can't call a base.SelectTarget(), we mimic what base.UpdateLockOn(true) would do.
|
||||
this.GetType().GetField("target", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.SetValue(this, targetToLock);
|
||||
// this.target = targetToLock; // This would create a new field in bLockOn, not set base.target
|
||||
|
||||
isLockingOn = true;
|
||||
base.UpdateLockOn(true); // This will set base.target if list not empty, and also set _inLockOn
|
||||
// and might call SetTarget if list was empty and now has one.
|
||||
// It's a bit of a dance because the base class design is restrictive.
|
||||
|
||||
// We need to ensure our 'isLockingOn' and the base class's internal lock state are synced.
|
||||
// And that SetTarget() (our override) is called to update camera & events.
|
||||
if (base.currentTarget == targetToLock) // If base.UpdateLockOn successfully set it
|
||||
{
|
||||
this.SetTarget(); // Manually call our override to ensure camera and events fire
|
||||
UpdateStrafeState(true);
|
||||
UpdateAimImage();
|
||||
}
|
||||
else // Fallback if base.UpdateLockOn didn't pick our target (e.g. list was empty for it)
|
||||
{
|
||||
// This case should ideally not happen if targetToLock was valid.
|
||||
// If it does, it means base.GetPossibleTargets within UpdateLockOn failed.
|
||||
UnlockTarget(false); // Silently unlock
|
||||
}
|
||||
}
|
||||
else // No target found or preferred target was invalid
|
||||
{
|
||||
UnlockTarget();
|
||||
}
|
||||
}
|
||||
|
||||
public void SetLockOnToFalse()
|
||||
protected void UnlockTarget(bool invokeEvent = true)
|
||||
{
|
||||
LockOn(false);
|
||||
if (tpInput == null || tpInput.tpCamera == null) return;
|
||||
|
||||
Transform previouslyLocked = base.currentTarget; // Get before clearing
|
||||
|
||||
base.UpdateLockOn(false); // This sets base.target to null and base._inLockOn to false
|
||||
isLockingOn = false;
|
||||
|
||||
if (previouslyLocked != null && invokeEvent)
|
||||
{
|
||||
onUnLockOnTarget.Invoke(previouslyLocked);
|
||||
}
|
||||
|
||||
tpInput.tpCamera.RemoveLockTarget();
|
||||
UpdateStrafeState(false);
|
||||
UpdateAimImage();
|
||||
}
|
||||
|
||||
|
||||
public void ManuallySetLockOnTarget(Transform newTargetTransform, bool shouldLock)
|
||||
{
|
||||
if (shouldLock)
|
||||
{
|
||||
AttemptLockOn(newTargetTransform);
|
||||
}
|
||||
else
|
||||
{
|
||||
UnlockTarget();
|
||||
}
|
||||
}
|
||||
|
||||
public Transform GetCurrentLockOnTarget()
|
||||
{
|
||||
// Relies on base.currentTarget which is the Transform 'target' from base class
|
||||
return isLockingOn ? base.currentTarget : null;
|
||||
}
|
||||
|
||||
private void UpdateStrafeState(bool shouldStrafe)
|
||||
{
|
||||
if (strafeWhileLockOn && tpInput?.cc != null && !tpInput.cc.locomotionType.Equals(vThirdPersonMotor.LocomotionType.OnlyStrafe))
|
||||
{
|
||||
bool canStrafe = shouldStrafe && isLockingOn && base.currentTarget != null;
|
||||
tpInput.cc.lockInStrafe = canStrafe;
|
||||
tpInput.cc.isStrafing = canStrafe;
|
||||
}
|
||||
}
|
||||
|
||||
public void SetLockOnToFalse() => UnlockTarget();
|
||||
|
||||
protected virtual void UpdateAimImage()
|
||||
{
|
||||
if (!aimImageContainer || !aimImage) return;
|
||||
if (hideSprite)
|
||||
var displayImage = AimImageDisplay;
|
||||
if (!aimImageContainer || displayImage == null) return;
|
||||
|
||||
displayImage.sizeDelta = aimImageSize;
|
||||
// base.currentTarget is the Transform, base.isCharacterAlive() checks it
|
||||
bool shouldShowAimImage = isLockingOn && base.currentTarget != null && base.isCharacterAlive(base.currentTarget);
|
||||
|
||||
|
||||
if (hideSprite) displayImage.gameObject.SetActive(shouldShowAimImage);
|
||||
else if (!displayImage.gameObject.activeSelf) displayImage.gameObject.SetActive(true);
|
||||
|
||||
if (shouldShowAimImage && tpCamera != null && base.currentTarget != null)
|
||||
{
|
||||
aimImage.sizeDelta = aimImageSize;
|
||||
if (currentTarget && !aimImage.transform.gameObject.activeSelf && isCharacterAlive())
|
||||
aimImage.transform.gameObject.SetActive(true);
|
||||
else if (!currentTarget && aimImage.transform.gameObject.activeSelf)
|
||||
aimImage.transform.gameObject.SetActive(false);
|
||||
else if (_aimImage.transform.gameObject.activeSelf && !isCharacterAlive())
|
||||
aimImage.transform.gameObject.SetActive(false);
|
||||
// Using the extension method from vLockOnHelper
|
||||
displayImage.anchoredPosition = base.currentTarget.GetScreenPointOffBoundsCenter(aimImageContainer, tpCamera.targetCamera, spriteHeight);
|
||||
}
|
||||
if (currentTarget && aimImage && aimImageContainer)
|
||||
aimImage.anchoredPosition = currentTarget.GetScreenPointOffBoundsCenter(aimImageContainer, tpCamera.targetCamera, spriteHeight);
|
||||
else if (aimImageContainer)
|
||||
aimImage.anchoredPosition = Vector2.zero;
|
||||
else if (!hideSprite) displayImage.anchoredPosition = Vector2.zero;
|
||||
}
|
||||
|
||||
public virtual void StopLockOn()
|
||||
// StopLockOn is effectively UnlockTarget now
|
||||
// public virtual void StopLockOn() { UnlockTarget(); }
|
||||
|
||||
|
||||
public List<Transform> GetNearbyTargets() // For AutoTargetting/MagicAttacks
|
||||
{
|
||||
if (currentTarget == null && tpInput.tpCamera != null)
|
||||
if (autoTargetingSystem != null)
|
||||
{
|
||||
onUnLockOnTarget.Invoke(tpInput.tpCamera.lockTarget);
|
||||
tpInput.tpCamera.RemoveLockTarget();
|
||||
isLockingOn = false;
|
||||
inTarget = false;
|
||||
base.range = autoTargetingSystem.maxTargetingDistance;
|
||||
// Angle filtering from AutoTargetting would need to be applied manually here
|
||||
// if we want to override the base class's screen-based sorting/filtering for this specific call.
|
||||
}
|
||||
}
|
||||
// base.GetPossibleTargets() returns List<Transform>
|
||||
List<Transform> allTargetsInBaseRange = base.GetPossibleTargets();
|
||||
|
||||
public virtual void NextTarget()
|
||||
{
|
||||
base.ChangeTarget(1);
|
||||
}
|
||||
if (allTargetsInBaseRange == null) return new List<Transform>();
|
||||
|
||||
public virtual void PreviousTarget()
|
||||
{
|
||||
base.ChangeTarget(-1);
|
||||
}
|
||||
// Optional: Further filter allTargetsInBaseRange by AutoTargetting's angle
|
||||
if (autoTargetingSystem != null && _playerTransform != null) // Assuming _playerTransform is accessible or passed
|
||||
{
|
||||
List<Transform> angleFilteredTargets = new List<Transform>();
|
||||
Vector3 playerPos = _playerTransform.position; // Need player transform
|
||||
Vector3 playerFwd = _playerTransform.forward;
|
||||
|
||||
public List<Transform> GetNearbyTargets()
|
||||
foreach (Transform t in allTargetsInBaseRange)
|
||||
{
|
||||
if (t == null) continue;
|
||||
Vector3 dirToTarget = (t.position - playerPos);
|
||||
dirToTarget.y = 0; // Assuming 2D angle check for simplicity
|
||||
if (dirToTarget.sqrMagnitude < 0.001f) // Target is at player's feet
|
||||
{
|
||||
angleFilteredTargets.Add(t);
|
||||
continue;
|
||||
}
|
||||
float angle = Vector3.Angle(playerFwd, dirToTarget.normalized);
|
||||
if (angle <= autoTargetingSystem.targetingAngleThreshold)
|
||||
{
|
||||
angleFilteredTargets.Add(t);
|
||||
}
|
||||
}
|
||||
return angleFilteredTargets;
|
||||
}
|
||||
|
||||
return allTargetsInBaseRange;
|
||||
}
|
||||
// Need player transform for angle filtering in GetNearbyTargets
|
||||
private Transform _playerTransform;
|
||||
void Awake() // Get player transform
|
||||
{
|
||||
return base.GetPossibleTargets();
|
||||
if (Player.Instance != null) _playerTransform = Player.Instance.transform;
|
||||
else _playerTransform = transform; // Fallback if bLockOn is on player
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user