1768 lines
64 KiB
C#
1768 lines
64 KiB
C#
using BulletHellTemplate.Core.Events;
|
||
using Cysharp.Threading.Tasks;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Threading;
|
||
using TMPro;
|
||
using UnityEngine;
|
||
using UnityEngine.UI;
|
||
using BulletHellTemplate.VFX;
|
||
using BulletHellTemplate.PVP;
|
||
|
||
|
||
|
||
#if FUSION2
|
||
using Fusion;
|
||
#endif
|
||
|
||
namespace BulletHellTemplate
|
||
{
|
||
public class CharacterEntity : BaseCharacterEntity
|
||
{
|
||
[Header("Settings")]
|
||
public float reviveInvincibleTime = 2.5f;
|
||
public float decreaseHpBarDelay = 0.12f;
|
||
public float decreaseHPBarSpeed = 1.5f;
|
||
public float mpLerpSpeed = 4.0f;
|
||
|
||
[Header("Transforms")]
|
||
public Transform characterModelTransform;
|
||
public Transform launchTransform;
|
||
public Transform effectsTransform;
|
||
public GameObject directionalAim;
|
||
|
||
[Header("Managers")]
|
||
[Tooltip("Reference to the indicator manager.")]
|
||
public IndicatorManager indicatorManager;
|
||
|
||
[Header("UI Elements")]
|
||
public Image hpBar;
|
||
public Image hpDecreaseBar;
|
||
public Image mpBar;
|
||
public Image shieldBar;
|
||
public Image shieldIcon;
|
||
public Image invincibleIcon;
|
||
public Image buffIcon;
|
||
public Image debuffIcon;
|
||
public TextMeshProUGUI level;
|
||
public TextMeshProUGUI HpText;
|
||
public TextMeshProUGUI insufficientMPText;
|
||
public TextMeshProUGUI playerNicknameText;
|
||
|
||
[Header("PVP")]
|
||
public GameObject[] teamObjects;
|
||
public Image hpBarAlly;
|
||
public Image hpBarEnemy;
|
||
|
||
|
||
private bool isStunned = false;
|
||
public bool IsStunned => isStunned;
|
||
private bool wasMoving;
|
||
private Vector2 lastDir2D;
|
||
|
||
public bool IsNetworked { get; private set; } = false;
|
||
|
||
private CancellationTokenSource stunCts;
|
||
|
||
#if FUSION2
|
||
private bool _visualsApplied = false;
|
||
[HideInInspector][Networked, OnChangedRender(nameof(OnTeamChanged))] public byte TeamId { get; set; }
|
||
#else
|
||
public int Team; // offline
|
||
#endif
|
||
|
||
#if FUSION2
|
||
/* ---------- Network fields ---------- */
|
||
[HideInInspector][Networked, OnChangedRender(nameof(OnNetworkDataChanged))]public byte CharacterId { get; set; }
|
||
[HideInInspector][Networked, OnChangedRender(nameof(OnNetworkDataChanged))] public byte SkinId { get; set; }
|
||
/// <summary>
|
||
/// Networked player nickname (fixed-capacity string). Use .ToString() to read.
|
||
/// </summary>
|
||
[HideInInspector][Networked, OnChangedRender(nameof(OnNetworkDataChanged))]
|
||
public NetworkString<_32> PlayerNick { get; set; }
|
||
|
||
/* ---------- Network stats ---------- */
|
||
[HideInInspector][Networked, OnChangedRender(nameof(OnMiniHudChanged))] public ushort NetHP { get; set; }
|
||
[HideInInspector][Networked, OnChangedRender(nameof(OnMiniHudChanged))] public ushort NetHPMax { get; set; }
|
||
[HideInInspector][Networked, OnChangedRender(nameof(OnMiniHudChanged))] public ushort NetMP { get; set; }
|
||
[HideInInspector][Networked, OnChangedRender(nameof(OnMiniHudChanged))] public ushort NetMPMax { get; set; }
|
||
[HideInInspector][Networked, OnChangedRender(nameof(OnMiniHudChanged))] public ushort NetShield { get; set; }
|
||
[HideInInspector][Networked, OnChangedRender(nameof(OnMiniHudChanged))] public byte NetIcons { get; set; }
|
||
|
||
private bool _wasNetworkedMoving = false;
|
||
private Vector2 _lastSentDirection = Vector2.zero;
|
||
|
||
private NetworkId _lastHitBy;
|
||
|
||
private struct HitKey : System.IEquatable<HitKey>
|
||
{
|
||
public NetworkId Attacker;
|
||
public ulong HitId;
|
||
public bool Equals(HitKey other) => Attacker == other.Attacker && HitId == other.HitId;
|
||
public override bool Equals(object obj) => obj is HitKey hk && Equals(hk);
|
||
public override int GetHashCode() => (Attacker.GetHashCode() * 486187739) ^ HitId.GetHashCode();
|
||
}
|
||
private readonly Dictionary<HitKey, float> _seenPlayerHits = new();
|
||
private const float PLAYER_HIT_TTL = 3f;
|
||
private List<HitKey> _seenHitsTmp;
|
||
|
||
private void PruneSeenPlayerHits()
|
||
{
|
||
if (_seenPlayerHits.Count == 0) return;
|
||
float now = Time.time;
|
||
_seenHitsTmp ??= new List<HitKey>(8);
|
||
_seenHitsTmp.Clear();
|
||
foreach (var kv in _seenPlayerHits)
|
||
if (now - kv.Value > PLAYER_HIT_TTL)
|
||
_seenHitsTmp.Add(kv.Key);
|
||
for (int i = 0; i < _seenHitsTmp.Count; i++)
|
||
_seenPlayerHits.Remove(_seenHitsTmp[i]);
|
||
}
|
||
|
||
byte _cachedCid = byte.MaxValue;
|
||
byte _cachedSkin = byte.MaxValue;
|
||
private byte _cid = byte.MaxValue;
|
||
private byte _skin = byte.MaxValue;
|
||
private string _name = string.Empty;
|
||
private byte _cachedTeam = 0;
|
||
#endif
|
||
|
||
|
||
|
||
#region ------------------------------- Init & Setup -------------------------------
|
||
protected override void Awake()
|
||
{
|
||
base.Awake();
|
||
}
|
||
|
||
protected override void Start()
|
||
{
|
||
base.Start();
|
||
if (characterModelTransform == null) characterModelTransform = transform;
|
||
if (launchTransform == null) launchTransform = transform;
|
||
if (effectsTransform == null) effectsTransform = transform;
|
||
|
||
shieldIcon.gameObject.SetActive(false);
|
||
buffIcon.gameObject.SetActive(false);
|
||
debuffIcon.gameObject.SetActive(false);
|
||
invincibleIcon.gameObject.SetActive(false);
|
||
#if FUSION2
|
||
IsNetworked = Runner != null && Runner.IsRunning;
|
||
#endif
|
||
}
|
||
|
||
protected override void OnEnable()
|
||
{
|
||
base.OnEnable();
|
||
if (!GameplayManager.Singleton) return;
|
||
|
||
if (!GameplayManager.Singleton.IsRunnerActive || GameplayManager.Singleton.IsLeader)
|
||
GameplayManager.Singleton.ActiveCharactersList.Add(transform);
|
||
|
||
GameplayManager.Singleton.RegisterAlive(this);
|
||
}
|
||
protected override void OnDisable()
|
||
{
|
||
base.OnDisable();
|
||
if (!GameplayManager.Singleton) return;
|
||
|
||
if (!GameplayManager.Singleton.IsRunnerActive || GameplayManager.Singleton.IsLeader)
|
||
GameplayManager.Singleton.ActiveCharactersList.Remove(transform);
|
||
|
||
GameplayManager.Singleton.UnregisterAlive(this);
|
||
#if FUSION2
|
||
UIGameplay.Singleton?.NotifyCharacterDespawned(this);
|
||
#endif
|
||
}
|
||
|
||
protected override void OnDestroy()
|
||
{
|
||
base.OnDestroy();
|
||
}
|
||
private void OnPlayerDiedEvent(PlayerDiedEvent evt)
|
||
{
|
||
if (evt.Target != this) return;
|
||
OnDeath();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Sets the character data and updates the character model.
|
||
/// </summary>
|
||
/// <param name="_characterData">The character data to set.</param>
|
||
public async void SetCharacterData(CharacterData _characterData, int _skinIndex)
|
||
{
|
||
characterData = _characterData;
|
||
skinIndex = _skinIndex;
|
||
UpdateCharacterModel();
|
||
|
||
if (directionalAim != null)
|
||
directionalAim.SetActive(false);
|
||
|
||
#if FUSION2
|
||
if (Runner != null && Runner.IsRunning && !Object.HasInputAuthority)
|
||
return;
|
||
#endif
|
||
playerNicknameText.text = PlayerSave.GetPlayerName();
|
||
InitializeCharacter();
|
||
|
||
if (UIGameplay.Singleton == null)
|
||
{
|
||
var hud = Instantiate(GameInstance.Singleton.GetUIGameplayForPlatform());
|
||
if (hud.minimapImage) hud.minimapImage.sprite = hud.unlockedSprite;
|
||
}
|
||
UIGameplay.Singleton?.SetCharacterEntity(this);
|
||
await GameplayManager.Singleton.SetupCharacterEntity(this);
|
||
TopDownCameraController.Singleton.SetTarget(gameObject.transform);
|
||
characterStatsComponent.SetUIGameplayStats();
|
||
|
||
#if FUSION2
|
||
if (Runner && Runner.IsRunning && Object && Object.HasStateAuthority)
|
||
PushMiniHudFromStats();
|
||
#endif
|
||
}
|
||
|
||
#if FUSION2
|
||
public void SetInitialNetworkData(byte cid, byte skin, string name, byte team = 0)
|
||
{
|
||
_cachedCid = cid;
|
||
_cachedSkin = skin;
|
||
_name = SanitizeNickname(name);
|
||
_cachedTeam = team;
|
||
}
|
||
|
||
private void OnNetworkDataChanged()
|
||
{
|
||
ApplyNetworkVisuals();
|
||
}
|
||
|
||
public override void Spawned()
|
||
{
|
||
if (HasStateAuthority && _cachedCid != byte.MaxValue)
|
||
{
|
||
CharacterId = _cachedCid;
|
||
SkinId = _cachedSkin;
|
||
PlayerNick = _name;
|
||
TeamId = _cachedTeam;
|
||
}
|
||
|
||
ApplyNetworkVisuals();
|
||
|
||
if (Object.HasInputAuthority && UIGameplay.Singleton == null)
|
||
{
|
||
var hud = Instantiate(GameInstance.Singleton.GetUIGameplayForPlatform());
|
||
if (hud.minimapImage) hud.minimapImage.sprite = hud.unlockedSprite;
|
||
}
|
||
UIGameplay.Singleton?.NotifyCharacterSpawned(this);
|
||
OnMiniHudChanged();
|
||
RefreshTeamObjects();
|
||
GameplayManager.Singleton?.RegisterCharacter(this);
|
||
}
|
||
|
||
private void ApplyNetworkVisuals()
|
||
{
|
||
if (CharacterId == byte.MaxValue)
|
||
return;
|
||
|
||
bool changed = !_visualsApplied || _cid != CharacterId || _skin != SkinId;
|
||
|
||
if (!changed)
|
||
return;
|
||
|
||
if (playerNicknameText != null)
|
||
playerNicknameText.text = PlayerNick.ToString();
|
||
|
||
_visualsApplied = true;
|
||
_cid = CharacterId;
|
||
_skin = SkinId;
|
||
|
||
var data = GameInstance.Singleton.GetCharacterDataById(_cid);
|
||
if (data == null)
|
||
{
|
||
Debug.LogError($"CharacterData id {_cid} not found.");
|
||
return;
|
||
}
|
||
|
||
characterData = data;
|
||
skinIndex = _skin;
|
||
UpdateCharacterModel();
|
||
|
||
if (directionalAim != null)
|
||
directionalAim.SetActive(false);
|
||
|
||
SelectHpBarVariant();
|
||
InitializeCharacter();
|
||
RefreshTeamObjects();
|
||
}
|
||
[Rpc(RpcSources.All, RpcTargets.StateAuthority)]
|
||
public void RPC_RequestPlaceAtTeamSpawn(byte team, RpcInfo info = default)
|
||
{
|
||
var gm = GameplayManager.Singleton;
|
||
Vector3 pos = gm ? gm.GetTeamSpawnPosition(team) : Vector3.zero;
|
||
Quaternion rot = gm ? gm.GetTeamSpawnRotation(team) : Quaternion.identity;
|
||
|
||
if (characterControllerComponent)
|
||
characterControllerComponent.Teleport(pos, rot, snapToGround: true);
|
||
else
|
||
transform.SetPositionAndRotation(pos, rot);
|
||
|
||
RPC_OnPlacedForOwner();
|
||
}
|
||
|
||
[Rpc(RpcSources.StateAuthority, RpcTargets.InputAuthority)]
|
||
private void RPC_OnPlacedForOwner()
|
||
{
|
||
characterControllerComponent?.ResumeMovement();
|
||
characterAttackComponent?.ResumeAutoAttack();
|
||
if (LoadingManager.Singleton && LoadingManager.Singleton.isLoading)
|
||
LoadingManager.Singleton.Close();
|
||
}
|
||
|
||
[Rpc(RpcSources.InputAuthority, RpcTargets.StateAuthority)]
|
||
private void RPC_RequestSetNickname(string nick)
|
||
{
|
||
if (!Object || !Object.HasStateAuthority)
|
||
return;
|
||
PlayerNick = SanitizeNickname(nick);
|
||
}
|
||
|
||
[Rpc(RpcSources.All, RpcTargets.StateAuthority)]
|
||
public void RPC_AssignTeam(byte team)
|
||
{
|
||
TeamId = team;
|
||
Debug.Log($"[PVP] TeamId set -> {team} ({PlayerNick})");
|
||
}
|
||
|
||
private void OnTeamChanged()
|
||
{
|
||
RefreshTeamObjects();
|
||
SelectHpBarVariant();
|
||
}
|
||
|
||
public void RefreshTeamObjects()
|
||
{
|
||
bool isPvp = GameplayManager.Singleton && GameplayManager.Singleton.IsPvp;
|
||
|
||
if (teamObjects == null || teamObjects.Length == 0) return;
|
||
|
||
int myTeam = 0;
|
||
#if FUSION2
|
||
myTeam = TeamId;
|
||
#else
|
||
myTeam = Team;
|
||
#endif
|
||
|
||
for (int i = 0; i < teamObjects.Length; i++)
|
||
{
|
||
if (!teamObjects[i]) continue;
|
||
teamObjects[i].SetActive(isPvp && i == myTeam);
|
||
}
|
||
SelectHpBarVariant();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Sets the nickname locally; in online sessions it propagates to StateAuthority.
|
||
/// </summary>
|
||
/// <param name="newNick">Desired nickname</param>
|
||
/// <param name="propagateIfOnline">If true and online, requests host to update the networked property.</param>
|
||
public void SetNickname(string newNick, bool propagateIfOnline = true)
|
||
{
|
||
string sanitized = SanitizeNickname(newNick);
|
||
|
||
if (Runner && Object)
|
||
{
|
||
if (Object.HasStateAuthority)
|
||
{
|
||
PlayerNick = sanitized;
|
||
}
|
||
else if (Object.HasInputAuthority && propagateIfOnline)
|
||
{
|
||
RPC_RequestSetNickname(sanitized);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (playerNicknameText != null)
|
||
playerNicknameText.text = sanitized;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Trims and clamps nickname length.
|
||
/// </summary>
|
||
private static string SanitizeNickname(string raw)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(raw))
|
||
return "Player";
|
||
|
||
string trimmed = raw.Trim();
|
||
return trimmed.Length > 31 ? trimmed.Substring(0, 31) : trimmed;
|
||
}
|
||
|
||
private void OnMiniHudChanged()
|
||
{
|
||
if (Object.HasStateAuthority) return;
|
||
|
||
if (characterUIHandlerComponent != null)
|
||
{
|
||
characterUIHandlerComponent.SetHpImmediate(NetHP, NetHPMax);
|
||
characterUIHandlerComponent.SetMpImmediate(NetMP, NetMPMax);
|
||
characterUIHandlerComponent.SetShieldImmediate(NetShield, NetHPMax);
|
||
}
|
||
|
||
if (UIGameplay.Singleton)
|
||
{
|
||
float hpNorm = NetHPMax > 0 ? (float)NetHP / NetHPMax : 0f;
|
||
UIGameplay.Singleton.UpdateAllyMiniHud(this, hpNorm);
|
||
}
|
||
|
||
invincibleIcon?.gameObject.SetActive((NetIcons & 1) != 0);
|
||
buffIcon?.gameObject.SetActive((NetIcons & 2) != 0);
|
||
debuffIcon?.gameObject.SetActive((NetIcons & 4) != 0);
|
||
}
|
||
|
||
private void SelectHpBarVariant()
|
||
{
|
||
bool isLocalOwner =
|
||
#if FUSION2
|
||
Object && Object.HasInputAuthority;
|
||
#else
|
||
true;
|
||
#endif
|
||
if (hpBar) hpBar.gameObject.SetActive(false);
|
||
if (hpBarAlly) hpBarAlly.gameObject.SetActive(false);
|
||
if (hpBarEnemy) hpBarEnemy.gameObject.SetActive(false);
|
||
|
||
Image chosen = hpBar;
|
||
|
||
if (isLocalOwner || !IsNetworked)
|
||
{
|
||
if (hpBar) hpBar.gameObject.SetActive(true);
|
||
chosen = hpBar ?? chosen;
|
||
}
|
||
else
|
||
{
|
||
bool isPvp = GameplayManager.Singleton && GameplayManager.Singleton.IsPvp;
|
||
bool isAlly = true;
|
||
|
||
#if FUSION2
|
||
if (isPvp)
|
||
{
|
||
byte localTeam = 255;
|
||
CharacterEntity local = null;
|
||
#if UNITY_6000_0_OR_NEWER
|
||
var all = FindObjectsByType<CharacterEntity>(FindObjectsSortMode.None);
|
||
#else
|
||
var all = FindObjectsOfType<CharacterEntity>();
|
||
#endif
|
||
foreach (var c in all)
|
||
if (c && c.Object && c.Object.HasInputAuthority) { local = c; break; }
|
||
if (local) localTeam = local.TeamId;
|
||
isAlly = local && TeamId == localTeam;
|
||
}
|
||
else
|
||
{
|
||
isAlly = true;
|
||
}
|
||
#endif
|
||
if (isAlly && hpBarAlly)
|
||
{
|
||
hpBarAlly.gameObject.SetActive(true);
|
||
chosen = hpBarAlly;
|
||
}
|
||
else if (!isAlly && hpBarEnemy)
|
||
{
|
||
hpBarEnemy.gameObject.SetActive(true);
|
||
chosen = hpBarEnemy;
|
||
}
|
||
else
|
||
{
|
||
if (hpBar) hpBar.gameObject.SetActive(true);
|
||
chosen = hpBar ?? chosen;
|
||
}
|
||
}
|
||
if (chosen != null) hpBar = chosen;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Pushes current HP/MP/Shield and status icons to networked mini-HUD (authority only).
|
||
/// </summary>
|
||
private void PushMiniHudFromStats()
|
||
{
|
||
if (!Object || !Object.HasStateAuthority) return;
|
||
|
||
ushort hp = ToUShort(characterStatsComponent.CurrentHP);
|
||
ushort hpMax = ToUShort(characterStatsComponent.MaxHp);
|
||
ushort mp = ToUShort(characterStatsComponent.CurrentMP);
|
||
ushort mpMax = ToUShort(characterStatsComponent.MaxMp);
|
||
ushort shield = ToUShort(characterStatsComponent.CurrentShield);
|
||
|
||
bool inv = isInvincible;
|
||
bool buff = activeBuffCount > 0;
|
||
bool debuf = false;
|
||
|
||
PushMiniHud(hp, hpMax, mp, mpMax, shield, inv, buff, debuf);
|
||
}
|
||
public void PushMiniHud(ushort hp, ushort hpMax, ushort mp, ushort mpMax, ushort shield, bool inv, bool buff, bool debuff)
|
||
{
|
||
if (!Object || !Object.HasStateAuthority) return;
|
||
|
||
NetHP = hp;
|
||
NetHPMax = hpMax;
|
||
NetMP = mp;
|
||
NetMPMax = mpMax;
|
||
NetShield = shield;
|
||
|
||
byte flags = 0;
|
||
if (inv) flags |= 1 << 0;
|
||
if (buff) flags |= 1 << 1;
|
||
if (debuff) flags |= 1 << 2;
|
||
NetIcons = flags;
|
||
}
|
||
private static ushort ToUShort(float v)
|
||
{
|
||
int iv = Mathf.RoundToInt(v);
|
||
if (iv < 0) iv = 0;
|
||
if (iv > 65535) iv = 65535;
|
||
return (ushort)iv;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Server-side RPC that validates the caller and deduplicates each hit before applying.
|
||
/// </summary>
|
||
[Rpc(RpcSources.All, RpcTargets.StateAuthority)]
|
||
private void RPC_RequestPlayerDamage(float amount, bool critical, NetworkId attackerId, ulong hitId, RpcInfo info = default)
|
||
{
|
||
if (!Object || !Object.HasStateAuthority) return;
|
||
if (amount <= 0f) return;
|
||
|
||
var src = info.Source;
|
||
if (attackerId.IsValid && Runner.TryFindObject(attackerId, out var attackerObj))
|
||
{
|
||
if (src != attackerObj.InputAuthority && src != Object.InputAuthority)
|
||
return;
|
||
}
|
||
var key = new HitKey { Attacker = attackerId, HitId = hitId };
|
||
PruneSeenPlayerHits();
|
||
if (_seenPlayerHits.ContainsKey(key)) return;
|
||
|
||
_seenPlayerHits[key] = Time.time;
|
||
if (attackerId.IsValid) _lastHitBy = attackerId;
|
||
ApplyDamageAuthority(ScalePvpDamageIfNeeded(attackerId, amount), critical);
|
||
|
||
}
|
||
#endif
|
||
|
||
#if FUSION2
|
||
private float ScalePvpDamageIfNeeded(NetworkId attackerId, float raw)
|
||
{
|
||
if (!PvpSync.Instance) return raw;
|
||
if (!attackerId.IsValid) return raw;
|
||
|
||
if (Runner.TryFindObject(attackerId, out var attObj))
|
||
{
|
||
if (attObj && attObj.GetComponent<CharacterEntity>())
|
||
{
|
||
var mult = Mathf.Clamp01(PvpSync.Instance.PlayerDamageTakenMultiplier);
|
||
return raw * mult;
|
||
}
|
||
}
|
||
return raw;
|
||
}
|
||
#endif
|
||
|
||
#if FUSION2
|
||
[Rpc(RpcSources.StateAuthority, RpcTargets.All)]
|
||
private void RPC_SpawnDamagePopup(int amount, bool critical)
|
||
{
|
||
DamagePopup.Show(amount,transform.position + Vector3.up * 1.6f, critical);
|
||
}
|
||
#endif
|
||
|
||
/// <summary>
|
||
/// Instantiates the character model from CharacterData and sets up the _anim reference.
|
||
/// </summary>
|
||
public void UpdateCharacterModel()
|
||
{
|
||
if (characterData == null)
|
||
{
|
||
Debug.LogError("CharacterData is null.");
|
||
return;
|
||
}
|
||
|
||
// Destroy any existing child models to avoid duplicates
|
||
foreach (Transform child in characterModelTransform)
|
||
{
|
||
Destroy(child.gameObject);
|
||
}
|
||
|
||
// Choose model from skins or default
|
||
CharacterModel selectedModel = null;
|
||
|
||
if (characterData.characterSkins != null &&
|
||
characterData.characterSkins.Length > 0 &&
|
||
skinIndex >= 0 &&
|
||
skinIndex < characterData.characterSkins.Length)
|
||
{
|
||
selectedModel = characterData.characterSkins[skinIndex].skinCharacterModel;
|
||
}
|
||
else
|
||
{
|
||
selectedModel = characterData.characterModel;
|
||
}
|
||
|
||
// Instantiate model if valid
|
||
if (selectedModel != null)
|
||
{
|
||
characterModel = Instantiate(selectedModel, characterModelTransform.position, characterModelTransform.rotation, characterModelTransform);
|
||
|
||
// Try to find the Animator on the instantiated model
|
||
if (!characterModel.TryGetComponent(out animator))
|
||
{
|
||
animator = characterModel.GetComponentInChildren<Animator>();
|
||
}
|
||
|
||
if (animator == null)
|
||
{
|
||
Debug.LogError("Animator component not found on the character model or its children.");
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Debug.LogError("No valid character model found in CharacterData.");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Initializes all core character components using the assigned CharacterData.
|
||
/// </summary>
|
||
public void InitializeCharacter()
|
||
{
|
||
// Cache component references if not assigned
|
||
if (characterStatsComponent == null)
|
||
characterStatsComponent = GetComponent<CharacterStatsComponent>();
|
||
|
||
if (characterControllerComponent == null)
|
||
characterControllerComponent = GetComponent<CharacterControllerComponent>();
|
||
|
||
if (characterAttackComponent == null)
|
||
characterAttackComponent = GetComponent<CharacterAttackComponent>();
|
||
|
||
if (characterBuffsComponent == null)
|
||
characterBuffsComponent = GetComponent<CharacterBuffsComponent>();
|
||
|
||
if(characterUIHandlerComponent == null)
|
||
characterUIHandlerComponent = GetComponent<CharacterUIHandlerComponent>();
|
||
|
||
// Validate essential components before initializing
|
||
if (characterData == null)
|
||
{
|
||
Debug.LogWarning("CharacterData is null. Initialization aborted.");
|
||
return;
|
||
}
|
||
|
||
if (characterUIHandlerComponent != null)
|
||
characterUIHandlerComponent.Initialize(this);
|
||
else
|
||
Debug.LogWarning("CharacterUIHandlerComponent not found.");
|
||
|
||
if (characterStatsComponent != null)
|
||
characterStatsComponent.Initialize(characterData);
|
||
else
|
||
Debug.LogWarning("CharacterStatsComponent not found.");
|
||
|
||
if (characterAttackComponent != null)
|
||
characterAttackComponent.Initialize(characterData, launchTransform, effectsTransform);
|
||
else
|
||
Debug.LogWarning("CharacterAttackComponent not found.");
|
||
|
||
if (characterBuffsComponent != null)
|
||
characterBuffsComponent.Initialize();
|
||
else
|
||
Debug.LogWarning("CharacterBuffsComponent not found.");
|
||
|
||
}
|
||
#endregion
|
||
#region ------------------------------- Update Loop -------------------------------
|
||
|
||
private void UpdateStatPerkUI()
|
||
{
|
||
UIGameplay.Singleton.UpdateSkillPerkUI();
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region ------------------------------- Skill & Attack -------------------------------
|
||
|
||
/// <summary>
|
||
/// Executes the auto-attack action using the AutoAttack skill from characterData.
|
||
/// </summary>
|
||
public override void Attack()
|
||
{
|
||
if (isStunned) return;
|
||
base.Attack();
|
||
|
||
if (characterData == null || characterData.autoAttack == null)
|
||
{
|
||
Debug.LogWarning("Cannot perform auto-attack: characterData or autoAttack skill is null.");
|
||
return;
|
||
}
|
||
|
||
if (GameplayManager.Singleton.IsPaused() || !canAutoAttack)
|
||
return;
|
||
|
||
characterAttackComponent.Attack();
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Uses the skill at the specified index and launches it in the specified direction.
|
||
/// The skill is launched from the launchTransform in the direction specified.
|
||
/// </summary>
|
||
/// <param name="index">The index of the skill to use.</param>
|
||
/// <param name="inputDirection">The input direction from a joystick or other source.</param>
|
||
public override void UseSkill(int index, Vector2 inputDirection)
|
||
{
|
||
if (isStunned) return;
|
||
base.UseSkill(index, inputDirection);
|
||
|
||
if (characterData == null || characterData.skills == null)
|
||
{
|
||
Debug.LogWarning("Cannot use skill: characterData or skills array is null.");
|
||
return;
|
||
}
|
||
|
||
if (index < 0 || index >= characterData.skills.Length)
|
||
{
|
||
Debug.LogWarning($"Skill index {index} is out of range.");
|
||
return;
|
||
}
|
||
|
||
SkillData skill = characterData.skills[index];
|
||
|
||
if (skill == null)
|
||
{
|
||
Debug.LogWarning($"Skill at index {index} is null.");
|
||
return;
|
||
}
|
||
|
||
if (GameplayManager.Singleton.IsPaused())
|
||
return;
|
||
|
||
if (!ConsumeMP(skill.manaCost))
|
||
{
|
||
DisplayMPInsufficientMessage("Not enough MP to use skill.");
|
||
return;
|
||
}
|
||
|
||
characterAttackComponent.UseSkill(index, skill, inputDirection);
|
||
}
|
||
|
||
public void PlayAttack()
|
||
{
|
||
if (characterModel == null) return;
|
||
#if FUSION2
|
||
if (Runner)
|
||
{
|
||
if (!Object.HasInputAuthority || isStunned) return;
|
||
RPC_PlayAttack();
|
||
}
|
||
#endif
|
||
EventBus.Publish(new AnimationOnActionEvent(characterModel, true));
|
||
}
|
||
|
||
public void PlaySkill(int skillIndex)
|
||
{
|
||
if (characterModel == null) return;
|
||
#if FUSION2
|
||
if (Runner)
|
||
{
|
||
if (!Object.HasInputAuthority || isStunned) return;
|
||
RPC_PlaySkill(skillIndex);
|
||
}
|
||
#endif
|
||
EventBus.Publish(new AnimationOnActionEvent(characterModel, false, skillIndex));
|
||
}
|
||
|
||
public void PlayReceiveDamage()
|
||
{
|
||
if (characterModel == null) return;
|
||
EventBus.Publish(new AnimationOnReceiveDamageEvent(characterModel));
|
||
}
|
||
|
||
public void PlayDeath()
|
||
{
|
||
if (characterModel == null) return;
|
||
EventBus.Publish(new AnimationOnDiedEvent(characterModel));
|
||
}
|
||
|
||
#if FUSION2
|
||
//─────────────────────── RPCs ───────────────────────//
|
||
[Rpc(RpcSources.InputAuthority, RpcTargets.All)]
|
||
/// <summary>Play auto‐attack animation on all clients.</summary>
|
||
public void RPC_PlayAttack()
|
||
{
|
||
if (Object.HasInputAuthority) return;
|
||
EventBus.Publish(new AnimationOnActionEvent(characterModel, true));
|
||
}
|
||
|
||
[Rpc(RpcSources.InputAuthority, RpcTargets.All)]
|
||
/// <summary>Play skill animation on all clients.</summary>
|
||
public void RPC_PlaySkill(int skillIndex)
|
||
{
|
||
if (Object.HasInputAuthority) return;
|
||
EventBus.Publish(new AnimationOnActionEvent(characterModel, false, skillIndex));
|
||
}
|
||
|
||
[Rpc(RpcSources.StateAuthority, RpcTargets.All)]
|
||
/// <summary>Play receive‐damage animation on all clients.</summary>
|
||
public void RPC_PlayReceiveDamage()
|
||
{
|
||
if (Object.HasInputAuthority) return;
|
||
EventBus.Publish(new AnimationOnReceiveDamageEvent(characterModel));
|
||
}
|
||
|
||
[Rpc(RpcSources.StateAuthority, RpcTargets.All)]
|
||
private void RPC_PlayMoveAnim(bool moving, Vector2 dir)
|
||
{
|
||
if (Object.HasInputAuthority)
|
||
return;
|
||
|
||
if (moving)
|
||
EventBus.Publish(new AnimationOnRunEvent(characterModel, dir));
|
||
else
|
||
EventBus.Publish(new AnimationOnIdleEvent(characterModel));
|
||
}
|
||
|
||
[Rpc(RpcSources.InputAuthority, RpcTargets.All)]
|
||
private void RPC_ApplyRotateCharacterModel(Vector3 dir, float duration)
|
||
{
|
||
if (Object.HasInputAuthority)
|
||
return;
|
||
|
||
RotateCharacterModelAsync(dir, duration, this.GetCancellationTokenOnDestroy()).Forget();
|
||
}
|
||
#endif
|
||
|
||
/// <summary>
|
||
/// Resets the ability to auto-attack after a delay.
|
||
/// </summary>
|
||
/// <param name="delay">The time to wait before resetting auto-attack.</param>
|
||
public void ApplyResetAutoAttack(float delay)
|
||
{
|
||
ResetAutoAttackAsync(0.8f, this.GetCancellationTokenOnDestroy()).Forget();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Applies a skill perk and manages its execution based on level and cooldown.
|
||
/// </summary>
|
||
/// <param name="skillPerk">The skill perk to apply.</param>
|
||
public void ApplySkillPerk(SkillPerkData skillPerk)
|
||
{
|
||
characterAttackComponent.ApplySkillPerk(skillPerk, false);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region ------------------------------- Stats / Buffs / Debuffs -------------------------------
|
||
|
||
public void ApplyStatPerk(StatPerkData statPerk, int level) => characterStatsComponent.ApplyStatPerk(statPerk, level);
|
||
|
||
/// <summary>
|
||
/// Tries to consume the specified amount of MP. Returns true if successful.
|
||
/// </summary>
|
||
/// <param name="amount">Amount of mana to consume.</param>
|
||
/// <returns>True if mana was consumed, false if insufficient mana.</returns>
|
||
public bool ConsumeMP(float amount) => characterStatsComponent.ConsumeMP(amount);
|
||
|
||
private void IncrementBuffCount()
|
||
{
|
||
activeBuffCount++;
|
||
}
|
||
|
||
private void DecrementBuffCount()
|
||
{
|
||
activeBuffCount--;
|
||
activeBuffCount = Mathf.Max(activeBuffCount, 0);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Applies a positive move speed buff and reverts after duration.
|
||
/// Ensures the amount is always positive.
|
||
/// </summary>
|
||
public void ApplyMoveSpeedBuff(float amount, float duration)
|
||
{
|
||
amount = Mathf.Abs(amount);
|
||
characterBuffsComponent.ApplyMoveSpeedBuff(amount, duration);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Applies a negative move speed debuff and reverts after duration.
|
||
/// Ensures the amount is always negative.
|
||
/// </summary>
|
||
public void ReceiveMoveSpeedDebuff(float amount, float duration)
|
||
{
|
||
amount = -Mathf.Abs(amount);
|
||
characterBuffsComponent.ApplyMoveSpeedBuff(amount, duration);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Temporarily increases the character's attack speed and reverts after duration.
|
||
/// </summary>
|
||
public void ApplyAttackSpeedBuff(float amount, float duration)
|
||
{
|
||
characterBuffsComponent.ApplyAttackSpeedBuff(amount, duration);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Temporarily increases the character's defense and reverts after duration.
|
||
/// </summary>
|
||
public void ApplyDefenseBuff(float amount, float duration)
|
||
{
|
||
characterBuffsComponent.ApplyDefenseBuff(amount, duration);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Temporarily increases the character's damage and reverts after duration.
|
||
/// </summary>
|
||
public void ApplyDamageBuff(float extraDamage, float duration)
|
||
{
|
||
characterBuffsComponent.ApplyDamageBuff(extraDamage, duration);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Increases the shield of the character.
|
||
/// </summary>
|
||
/// <param name="amount">The amount of shield to increase.</param>
|
||
public void ApplyShield(int amount)
|
||
{
|
||
characterBuffsComponent.ApplyShield(amount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Increases the shield of the character for a specified duration.
|
||
/// </summary>
|
||
/// <param name="amount">The amount of shield to increase.</param>
|
||
/// <param name="duration">Duration in seconds for which the shield remains.</param>
|
||
/// <param name="isTemporary">Set to true if the buff is temporary. Default is false. </param>
|
||
public void ApplyShield(int amount, float duration = 0f, bool isTemporary = false)
|
||
{
|
||
characterBuffsComponent.ApplyShield(amount, duration, isTemporary);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Increases the maximum HP of the character.
|
||
/// </summary>
|
||
/// <param name="amount">Amount to increase max HP by.</param>
|
||
public void AddMaxHP(int amount)
|
||
{
|
||
amount = Mathf.Abs(amount);
|
||
characterStatsComponent.AlterMaxHp(amount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Decreases the maximum HP of the character.
|
||
/// </summary>
|
||
/// <param name="amount">Amount to increase max HP by.</param>
|
||
public void RemoveMaxHP(int amount)
|
||
{
|
||
amount = -Mathf.Abs(amount);
|
||
characterStatsComponent.AlterMaxHp(amount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Sets the character invincible for a duration.
|
||
/// </summary>
|
||
/// <param name="duration">Duration in seconds.</param>
|
||
public override void ApplyInvincible(float duration)
|
||
{
|
||
isInvincible = true;
|
||
RemoveInvincibilityAfterAsync(duration, this.GetCancellationTokenOnDestroy()).Forget();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Heals the character by a specified amount up to their maximum health.
|
||
/// </summary>
|
||
/// <param name="amount">The amount to heal.</param>
|
||
public void ApplyHealHP(int amount)
|
||
{
|
||
amount = Mathf.Abs(amount);
|
||
characterStatsComponent.HealHP(amount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Heals the character's MP.
|
||
/// </summary>
|
||
/// <param name="amount">The amount to heal.</param>
|
||
public void ApplyHealMP(int amount)
|
||
{
|
||
amount = Mathf.Abs(amount);
|
||
characterStatsComponent.HealMP(amount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Applies health leech based on the damage dealt.
|
||
/// </summary>
|
||
/// <param name="damage">The total damage dealt.</param>
|
||
public void ApplyHpLeech(float damage)
|
||
{
|
||
characterStatsComponent.ApplyHpLeech(damage);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Increases the cooldown reduction percentage.
|
||
/// </summary>
|
||
/// <param name="amount">The amount to increase cooldown reduction by.</param>
|
||
public void AddCooldownReduction(float amount)
|
||
{
|
||
amount = Mathf.Abs(amount);
|
||
characterStatsComponent.AlterCooldownReduction(amount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Decreases the cooldown reduction percentage.
|
||
/// </summary>
|
||
/// <param name="amount">The amount to increase cooldown reduction by.</param>
|
||
public void RemoveCooldownReduction(float amount)
|
||
{
|
||
amount = -Mathf.Abs(amount);
|
||
characterStatsComponent.AlterCooldownReduction(amount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Adds XP to the character and handles leveling up.
|
||
/// </summary>
|
||
/// <param name="xpAmount">The amount of XP to add.</param>
|
||
public void AddXP(int xpAmount)
|
||
{
|
||
xpAmount = Mathf.Abs(xpAmount);
|
||
characterStatsComponent.AddXP(xpAmount);
|
||
}
|
||
|
||
public void ReceiveKnockback(Vector3 senderDirection,float distance, float duration)
|
||
{
|
||
characterControllerComponent.ApplyKnockback(senderDirection,distance,duration);
|
||
}
|
||
|
||
public void ReceiveStun(float duration)
|
||
{
|
||
stunCts?.Cancel();
|
||
stunCts = new CancellationTokenSource();
|
||
StunRoutine(duration, stunCts.Token).Forget();
|
||
}
|
||
|
||
public void ReceiveDot(MonsterSkill sourceSkill, int totalDmg, float duration)
|
||
{
|
||
characterStatsComponent.ApplyDot(sourceSkill, totalDmg, duration);
|
||
}
|
||
|
||
|
||
#endregion
|
||
|
||
#region ------------------------------- Animation & Movement -------------------------------
|
||
|
||
/// <summary>
|
||
/// Moves the character and handles animation locally. Triggers animation RPC only when state changes.
|
||
/// </summary>
|
||
/// <param name="worldDir">Direction to move in world space.</param>
|
||
public override void Move(Vector3 worldDir)
|
||
{
|
||
base.Move(worldDir);
|
||
|
||
bool isMoving = worldDir.sqrMagnitude > 0.01f;
|
||
Vector2 currentDir2D = Vector2.zero;
|
||
|
||
if (isMoving)
|
||
{
|
||
Vector3 local3D = characterModelTransform.InverseTransformDirection(new Vector3(worldDir.x, 0f, worldDir.z));
|
||
currentDir2D = new Vector2(local3D.x, local3D.z).normalized;
|
||
}
|
||
|
||
// ─── Always trigger animation locally ──────────────────────
|
||
if (isMoving)
|
||
EventBus.Publish(new AnimationOnRunEvent(characterModel, currentDir2D));
|
||
else
|
||
EventBus.Publish(new AnimationOnIdleEvent(characterModel));
|
||
|
||
#if FUSION2
|
||
if (Runner && Object.HasStateAuthority)
|
||
{
|
||
bool sendMoveRpc = false;
|
||
|
||
// Start/stop movement change
|
||
if (isMoving != _wasNetworkedMoving)
|
||
{
|
||
sendMoveRpc = true;
|
||
}
|
||
|
||
// Direction change while moving
|
||
if (isMoving && Vector2.Distance(currentDir2D, _lastSentDirection) > 0.1f)
|
||
{
|
||
sendMoveRpc = true;
|
||
}
|
||
|
||
if (sendMoveRpc)
|
||
{
|
||
_wasNetworkedMoving = isMoving;
|
||
_lastSentDirection = currentDir2D;
|
||
|
||
RPC_PlayMoveAnim(isMoving, currentDir2D);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
characterControllerComponent.Move(worldDir);
|
||
wasMoving = isMoving;
|
||
}
|
||
|
||
public void ApplyStopMovement(float duration, bool allowRotation = false)
|
||
{
|
||
StopMovementAsync(duration, allowRotation, this.GetCancellationTokenOnDestroy()).Forget();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Smoothly rotates the visible model to a direction.
|
||
/// Cancels any previous rotation to avoid jitter.
|
||
/// </summary>
|
||
public void ApplyRotateCharacterModel(Vector3 dir, float duration, CancellationToken token)
|
||
{
|
||
RotateCharacterModelAsync(dir, duration, token).Forget();
|
||
|
||
#if FUSION2
|
||
//if (Runner && Object.HasInputAuthority)
|
||
// RPC_ApplyRotateCharacterModel(dir, duration);
|
||
#endif
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region ------------------------------- UI -------------------------------
|
||
|
||
/// <summary>
|
||
/// Displays a status message related to insufficient MP or other notifications.
|
||
/// </summary>
|
||
/// <param name="message">The message to display.</param>
|
||
public void DisplayMPInsufficientMessage(string message)
|
||
{
|
||
insufficientMPText.text = message;
|
||
HideStatusMessageAfterDelayAsync(insufficientMPText, 1.5f, this.GetCancellationTokenOnDestroy()).Forget();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Updates the directional aim's rotation based on the joystick input and updates the corresponding indicator.
|
||
/// </summary>
|
||
/// <param name="joystickDirection">The direction from the skill joystick.</param>
|
||
/// <param name="skillIndex">Index of the skill being aimed.</param>
|
||
public void UpdateDirectionalAim(Vector2 joystickDirection, int skillIndex)
|
||
{
|
||
if (directionalAim == null)
|
||
{
|
||
Debug.LogWarning("Directional aim object is not set.");
|
||
return;
|
||
}
|
||
|
||
// Rotate visual
|
||
if (joystickDirection.magnitude > 0)
|
||
{
|
||
Vector3 direction3D = new Vector3(joystickDirection.x, 0, joystickDirection.y).normalized;
|
||
directionalAim.transform.rotation = Quaternion.LookRotation(direction3D, Vector3.up);
|
||
}
|
||
|
||
if (!directionalAim.activeSelf || indicatorManager == null)
|
||
return;
|
||
|
||
SkillData skillData = GetSkillData(skillIndex);
|
||
if (skillData == null || skillData.rangeIndicatorType == RangeIndicatorType.None)
|
||
return;
|
||
|
||
float maxRange = skillData.rangeIndicatorType switch
|
||
{
|
||
RangeIndicatorType.RadialAoE => skillData.radialAoEIndicatorSettings.radiusMaxRange,
|
||
RangeIndicatorType.Radial => skillData.radialIndicatorSettings.radiusArea,
|
||
_ => 1f
|
||
};
|
||
|
||
Vector3 aimWorldPos = GetAimWorldPosition(joystickDirection, maxRange);
|
||
|
||
switch (skillData.rangeIndicatorType)
|
||
{
|
||
case RangeIndicatorType.Radial:
|
||
indicatorManager.ShowCircleRangeIndicator(maxRange);
|
||
break;
|
||
|
||
case RangeIndicatorType.RadialAoE:
|
||
indicatorManager.ShowCircleRangeIndicator(skillData.radialAoEIndicatorSettings.radiusMaxRange);
|
||
indicatorManager.ShowPositionAoECircle(skillData.radialAoEIndicatorSettings.radiusArea, aimWorldPos);
|
||
break;
|
||
|
||
case RangeIndicatorType.Arrow:
|
||
indicatorManager.ShowArrowIndicator();
|
||
indicatorManager.UpdateArrowIndicator(transform.position, aimWorldPos.magnitude, maxRange, directionalAim.transform.rotation);
|
||
break;
|
||
|
||
case RangeIndicatorType.Cone:
|
||
indicatorManager.ShowConeIndicator();
|
||
indicatorManager.UpdateConeIndicator(transform.position, aimWorldPos.magnitude, maxRange, directionalAim.transform.rotation);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Activates or deactivates the directional aim and manages indicator animations.
|
||
/// </summary>
|
||
/// <param name="isActive">True to activate the directional aim; false to deactivate.</param>
|
||
/// <param name="skillIndex">Index of the skill being used.</param>
|
||
/// <param name="skillUsed">True if the skill was used (triggering cast indicator animation); false if canceled.</param>
|
||
public void SetDirectionalAimActive(bool isActive, int skillIndex, bool skillUsed)
|
||
{
|
||
if (directionalAim != null)
|
||
directionalAim.SetActive(isActive);
|
||
|
||
if (!isActive && indicatorManager != null)
|
||
{
|
||
SkillData skillData = GetSkillData(skillIndex);
|
||
if (skillData == null || skillData.rangeIndicatorType == RangeIndicatorType.None)
|
||
return;
|
||
|
||
indicatorManager.HidePositionAoECircle();
|
||
|
||
if (!skillUsed)
|
||
{
|
||
indicatorManager.CloseIndicators();
|
||
return;
|
||
}
|
||
|
||
float castDuration = skillData.delayToLaunch;
|
||
Vector3 startPos = transform.position;
|
||
Vector3 endPos = startPos + transform.forward * (
|
||
skillData.rangeIndicatorType == RangeIndicatorType.RadialAoE ?
|
||
skillData.radialAoEIndicatorSettings.radiusMaxRange : 1f
|
||
);
|
||
|
||
switch (skillData.rangeIndicatorType)
|
||
{
|
||
case RangeIndicatorType.Radial:
|
||
if (skillData.radialIndicatorSettings.useCastIndicator)
|
||
indicatorManager.StartCastCircleIndicator(skillData.radialIndicatorSettings.radiusArea, castDuration);
|
||
else
|
||
indicatorManager.CloseIndicators();
|
||
break;
|
||
|
||
case RangeIndicatorType.RadialAoE:
|
||
if (skillData.radialAoEIndicatorSettings.useCastIndicator)
|
||
{
|
||
indicatorManager.StartCastDamageIndicator(skillData.radialAoEIndicatorSettings.radiusArea, castDuration);
|
||
indicatorManager.ShowAoECurveLine(startPos, endPos);
|
||
StartCoroutine(indicatorManager.HideAoECurveLineAfterDelay(castDuration + 0.1f));
|
||
}
|
||
else
|
||
{
|
||
indicatorManager.CloseIndicators();
|
||
}
|
||
break;
|
||
|
||
case RangeIndicatorType.Arrow:
|
||
if (skillData.arrowIndicatorSettings.useCastIndicator)
|
||
indicatorManager.StartCastArrowIndicator(skillData.arrowIndicatorSettings.arrowSize, castDuration);
|
||
else
|
||
indicatorManager.CloseIndicators();
|
||
break;
|
||
|
||
case RangeIndicatorType.Cone:
|
||
if (skillData.coneIndicatorSettings.useCastIndicator)
|
||
indicatorManager.StartCastConeIndicator(skillData.coneIndicatorSettings.ConeSize, castDuration);
|
||
else
|
||
indicatorManager.CloseIndicators();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
#endregion
|
||
|
||
#region ------------------------------- Damage & Life Cycle -------------------------------
|
||
|
||
/// <summary>
|
||
/// Public entry point: only owner/authority should cause damage; dedup by (attacker, hitId).
|
||
/// Offline falls back to local application.
|
||
/// </summary>
|
||
public void ApplyDamageToSelfFromHit(
|
||
#if FUSION2
|
||
NetworkObject attacker,
|
||
#else
|
||
object attacker,
|
||
#endif
|
||
ulong hitId, float amount, bool critical)
|
||
{
|
||
#if FUSION2
|
||
if (Runner == null || !Runner.IsRunning || Object == null)
|
||
{
|
||
ApplyDamageAuthority(ScalePvpDamageIfNeeded(attacker ? attacker.Id : default, amount), critical);
|
||
return;
|
||
}
|
||
|
||
if (Object.HasStateAuthority)
|
||
{
|
||
var key = new HitKey { Attacker = attacker ? attacker.Id : default, HitId = hitId };
|
||
PruneSeenPlayerHits();
|
||
if (_seenPlayerHits.ContainsKey(key)) return;
|
||
_seenPlayerHits[key] = Time.time;
|
||
|
||
if (attacker)
|
||
_lastHitBy = attacker.Id;
|
||
|
||
ApplyDamageAuthority(ScalePvpDamageIfNeeded(attacker ? attacker.Id : default, amount), critical);
|
||
}
|
||
else
|
||
{
|
||
RPC_RequestPlayerDamage(amount, critical, attacker ? attacker.Id : default, hitId);
|
||
}
|
||
#else
|
||
ApplyDamageAuthority(amount, critical);
|
||
#endif
|
||
}
|
||
|
||
/// <summary>
|
||
/// Applies damage on the authoritative instance and updates network/local UI.
|
||
/// </summary>
|
||
private void ApplyDamageAuthority(float amount, bool critical)
|
||
{
|
||
if (amount <= 0f) return;
|
||
if (GameplayManager.Singleton.IsPaused()) return;
|
||
if (isInvincible) return;
|
||
|
||
characterStatsComponent.ReceiveDamage(amount);
|
||
|
||
#if FUSION2
|
||
if (Runner && Object && Object.HasStateAuthority)
|
||
{
|
||
RPC_SpawnDamagePopup(Mathf.Max(Mathf.RoundToInt(amount)), critical);
|
||
RPC_PlayReceiveDamage();
|
||
}
|
||
#endif
|
||
PlayReceiveDamage();
|
||
|
||
if (characterUIHandlerComponent != null)
|
||
{
|
||
characterUIHandlerComponent.SetHpImmediate(characterStatsComponent.CurrentHP, characterStatsComponent.MaxHp);
|
||
characterUIHandlerComponent.SetMpImmediate(characterStatsComponent.CurrentMP, characterStatsComponent.MaxMp);
|
||
characterUIHandlerComponent.SetShieldImmediate(characterStatsComponent.CurrentShield, characterStatsComponent.MaxHp);
|
||
}
|
||
|
||
#if FUSION2
|
||
if (Runner && Object && Object.HasStateAuthority)
|
||
PushMiniHudFromStats();
|
||
#endif
|
||
|
||
if (characterStatsComponent.CurrentHP <= 0f)
|
||
OnDeath();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Receives damage, reducing shield first if available and then HP.
|
||
/// Damage is reduced by current defense but not lower than a global minimum.
|
||
/// </summary>
|
||
/// <param name="damage">The damage to receive.</param>
|
||
public override void ReceiveDamage(float damage)
|
||
{
|
||
#if FUSION2
|
||
if (Runner && Runner.IsRunning && Object && !Object.HasStateAuthority)
|
||
return;
|
||
#endif
|
||
base.ReceiveDamage(damage);
|
||
if (GameplayManager.Singleton.IsPaused()) return;
|
||
if (isInvincible) return;
|
||
|
||
characterStatsComponent.ReceiveDamage(damage);
|
||
}
|
||
|
||
public void CharacterRevive()
|
||
{
|
||
if (!IsDead) return;
|
||
IsDead = false;
|
||
characterStatsComponent.Revive();
|
||
canAutoAttack = true;
|
||
isMovementStopped = false;
|
||
characterControllerComponent.ResumeMovement();
|
||
|
||
characterAttackComponent.ResumeAutoAttack();
|
||
GameplayManager.Singleton?.MarkCharacterRevived(this);
|
||
#if FUSION2
|
||
GameplaySync.Instance?.SyncPlayerRevived(this);
|
||
#endif
|
||
OnCharacterRevive();
|
||
}
|
||
|
||
/// <summary>
|
||
/// called when the character revives.
|
||
/// </summary>
|
||
public override void OnCharacterRevive()
|
||
{
|
||
ApplyInvincible(reviveInvincibleTime);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Final death routine – runs once. Stops movement/inputs, plays animation,
|
||
/// notifies GameplayManager and (optionally) replicates via Fusion.
|
||
/// </summary>
|
||
public override void OnDeath()
|
||
{
|
||
if (IsDead) return;
|
||
IsDead = true;
|
||
|
||
#if FUSION2
|
||
if (Runner && Object && Object.HasStateAuthority && PvpSync.IsSpawnedReady && PvpSync.Instance)
|
||
{
|
||
NetworkObject killerObj = null;
|
||
if (_lastHitBy.IsValid) Runner.TryFindObject(_lastHitBy, out killerObj);
|
||
var killerCE = killerObj ? killerObj.GetComponent<CharacterEntity>() : null;
|
||
|
||
if (killerCE)
|
||
{
|
||
PvpSync.Instance.RPC_NotifyKill(killerCE.CharacterId, killerCE.PlayerNick,
|
||
this.CharacterId, this.PlayerNick, killerCE.TeamId);
|
||
|
||
if (PvpSync.Instance.Mode == PvpModeType.BattleRoyale)
|
||
PvpSync.Instance.AnnounceEliminationNow(this);
|
||
}
|
||
|
||
PvpSync.Instance.ScheduleRevive(this).Forget();
|
||
}
|
||
#endif
|
||
|
||
canAutoAttack = false;
|
||
isMovementStopped = true;
|
||
|
||
characterControllerComponent.CancelDash();
|
||
characterControllerComponent.StopMovement();
|
||
|
||
characterAttackComponent.StopAutoAttack();
|
||
|
||
PlayDeath();
|
||
directionalAim?.SetActive(false);
|
||
|
||
GameplayManager.Singleton?.MarkCharacterDead(this);
|
||
#if FUSION2
|
||
GameplaySync.Instance?.SyncPlayerDied(this);
|
||
#endif
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region ------------------------------- Utility / Getters -------------------------------
|
||
|
||
/// <summary>
|
||
/// Returns the current CharacterData assigned to this entity.
|
||
/// </summary>
|
||
/// <returns>The character data, or null if not set.</returns>
|
||
public CharacterData GetCharacterData()
|
||
{
|
||
return characterData;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Returns the CharacterTypeData from the current character, if available.
|
||
/// </summary>
|
||
/// <returns>The CharacterTypeData, or null if CharacterData is not assigned.</returns>
|
||
public CharacterTypeData GetCharacterType()
|
||
{
|
||
if (characterData == null)
|
||
{
|
||
Debug.LogWarning("CharacterData is null. Cannot retrieve CharacterType.");
|
||
return null;
|
||
}
|
||
|
||
return characterData.characterType;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Retrieves the SkillData for a given skill index.
|
||
/// </summary>
|
||
/// <param name="index">The skill index.</param>
|
||
/// <returns>The SkillData object, or null if invalid.</returns>
|
||
public SkillData GetSkillData(int index)
|
||
{
|
||
if (characterData == null || characterData.skills == null)
|
||
{
|
||
Debug.LogWarning("CharacterData or skills array is null.");
|
||
return null;
|
||
}
|
||
|
||
if (index < 0 || index >= characterData.skills.Length)
|
||
{
|
||
Debug.LogWarning($"Invalid skill index: {index}. Array length: {characterData.skills.Length}");
|
||
return null;
|
||
}
|
||
|
||
return characterData.skills[index];
|
||
}
|
||
|
||
/// <summary>
|
||
/// Returns the index of a specific skill in the character's skill array.
|
||
/// </summary>
|
||
/// <param name="skill">The skill to find.</param>
|
||
/// <returns>The index of the skill, or -1 if not found.</returns>
|
||
public int GetSkillIndex(SkillData skill)
|
||
{
|
||
if (skill == null)
|
||
{
|
||
Debug.LogWarning("Skill is null. Cannot find index.");
|
||
return -1;
|
||
}
|
||
|
||
if (characterData == null || characterData.skills == null)
|
||
{
|
||
Debug.LogWarning("CharacterData or skills array is null. Cannot search for skill.");
|
||
return -1;
|
||
}
|
||
|
||
for (int index = 0; index < characterData.skills.Length; index++)
|
||
{
|
||
if (characterData.skills[index] == skill)
|
||
return index;
|
||
}
|
||
|
||
Debug.LogWarning($"Skill '{skill.skillName}' not found in the character's skills.");
|
||
return -1;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Retrieves the icon sprite for a specific skill.
|
||
/// </summary>
|
||
/// <param name="skillIndex">The index of the skill in the character's skill array.</param>
|
||
/// <returns>The icon sprite of the skill, or null if invalid.</returns>
|
||
public Sprite GetSkillIcon(int skillIndex)
|
||
{
|
||
SkillData skill = GetSkillData(skillIndex);
|
||
return skill != null ? skill.icon : null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Retrieves the cooldown duration for a specific skill.
|
||
/// </summary>
|
||
/// <param name="skillIndex">The index of the skill in the character's skill array.</param>
|
||
/// <returns>The cooldown duration in seconds, or 0 if invalid.</returns>
|
||
public float GetSkillCooldown(int skillIndex)
|
||
{
|
||
SkillData skill = GetSkillData(skillIndex);
|
||
return skill != null ? skill.cooldown : 0f;
|
||
}
|
||
private Vector3 GetAimWorldPosition(Vector2 joystickDirection, float maxRange)
|
||
{
|
||
float joystickMag = Mathf.Clamp01(joystickDirection.magnitude);
|
||
float actualDistance = joystickMag * maxRange;
|
||
return transform.position + transform.forward * actualDistance;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Retrieves a list of perks available to the player at level-up.
|
||
/// </summary>
|
||
/// <returns>List of perk options</returns>
|
||
private List<object> GetAvailablePerks() => GameplayManager.Singleton.GetRandomPerks();
|
||
|
||
public bool HasStatPerk(StatPerkData perk) => characterStatsComponent.HasStatPerk(perk);
|
||
|
||
/// <summary>
|
||
/// Retrieves the list of skill perks associated with the character.
|
||
/// </summary>
|
||
public List<SkillPerkData> GetSkillsPerkData() => characterAttackComponent.GetSkillsPerkData();
|
||
|
||
/// <summary>
|
||
/// Retrieves the list of stat perks associated with the character.
|
||
/// </summary>
|
||
public List<StatPerkData> GetStatsPerkData() => characterStatsComponent.GetStatsPerkData();
|
||
|
||
/// <summary>
|
||
/// Gets the current level of the character.
|
||
/// </summary>
|
||
public int GetCurrentLevel() => characterStatsComponent.CurrentLevel;
|
||
|
||
/// <summary>
|
||
/// Gets the current XP of the character.
|
||
/// </summary>
|
||
public int GetCurrentXP() => characterStatsComponent.CurrentXP;
|
||
|
||
/// <summary>
|
||
/// Gets the XP required for the next level.
|
||
/// </summary>
|
||
public int GetXPToNextLevel() => characterStatsComponent.GetXPToNextLevel();
|
||
|
||
public float GetCurrentHP() => characterStatsComponent.CurrentHP;
|
||
public float GetMaxHP() => characterStatsComponent.MaxHp;
|
||
public float GetCurrentHPRegen() => characterStatsComponent.CurrentHPRegen;
|
||
public float GetCurrentHPLeech() => characterStatsComponent.CurrentHPLeech;
|
||
public float GetCurrentMP() => characterStatsComponent.CurrentMP;
|
||
public float GetMaxMP() => characterStatsComponent.MaxMp;
|
||
public float GetCurrentMPRegen() => characterStatsComponent.CurrentMPRegen;
|
||
public float GetCurrentDamage() => characterStatsComponent.CurrentDamage;
|
||
public float GetCurrentAttackSpeed() => characterStatsComponent.CurrentAttackSpeed;
|
||
public float GetCurrentCooldownReduction() => characterStatsComponent.CurrentCooldownReduction;
|
||
public float GetCurrentCriticalRate() => characterStatsComponent.CurrentCriticalRate;
|
||
public float GetCurrentCriticalDamageMultiplier() => characterStatsComponent.CurrentCriticalDamageMultiplier;
|
||
public float GetCurrentDefense() => characterStatsComponent.CurrentDefense;
|
||
public float GetCurrentShield() => characterStatsComponent.CurrentShield;
|
||
public float GetCurrentMoveSpeed() => characterStatsComponent.CurrentMoveSpeed;
|
||
public float GetCurrentCollectRange() => characterStatsComponent.CurrentCollectRange;
|
||
public float GetCurrentMaxStats() => characterStatsComponent.CurrentMaxStats;
|
||
public float GetCurrentMaxSkills() => characterStatsComponent.CurrentMaxSkills;
|
||
|
||
#endregion
|
||
|
||
#region ------------------------------- Coroutines -------------------------------
|
||
|
||
/// <summary>
|
||
/// Rotates the character model visually toward the given direction for a duration.
|
||
/// Y component is ignored to prevent vertical tilt.
|
||
/// </summary>
|
||
/// <param name="direction">Direction to face.</param>
|
||
/// <param name="duration">Duration of the rotation effect.</param>
|
||
/// <param name="token">Optional cancellation token.</param>
|
||
private async UniTask RotateCharacterModelAsync(Vector3 direction, float duration, CancellationToken token = default)
|
||
{
|
||
if (!this || transform == null) return;
|
||
if (characterModelTransform == null)
|
||
{
|
||
Debug.LogWarning("Character model transform is not set.");
|
||
return;
|
||
}
|
||
|
||
Vector3 flatDirection = new Vector3(direction.x, 0f, direction.z).normalized;
|
||
if (flatDirection == Vector3.zero)
|
||
{
|
||
return;
|
||
}
|
||
|
||
Quaternion targetRotation = Quaternion.LookRotation(flatDirection);
|
||
|
||
float timer = 0f;
|
||
try
|
||
{
|
||
while (timer < duration)
|
||
{
|
||
token.ThrowIfCancellationRequested();
|
||
|
||
Quaternion desiredLocalRotation = Quaternion.Inverse(transform.rotation) * targetRotation;
|
||
characterModelTransform.localRotation = desiredLocalRotation;
|
||
|
||
timer += Time.deltaTime;
|
||
await UniTask.Yield(PlayerLoopTiming.Update, token);
|
||
}
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
|
||
}
|
||
finally
|
||
{
|
||
characterModelTransform.localRotation = Quaternion.identity;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Disables auto-attack for a duration, then re-enables it.
|
||
/// Uses UniTask for better performance and cancelation.
|
||
/// </summary>
|
||
/// <param name="delay">Delay before allowing auto-attack again.</param>
|
||
/// <param name="token">Optional cancellation token.</param>
|
||
private async UniTask ResetAutoAttackAsync(float delay, CancellationToken token = default)
|
||
{
|
||
canAutoAttack = false;
|
||
|
||
if (delay > 0f)
|
||
await UniTask.Delay(TimeSpan.FromSeconds(delay), cancellationToken: token);
|
||
|
||
canAutoAttack = true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Removes invincibility after a set duration.
|
||
/// Uses UniTask for better performance and optional cancellation.
|
||
/// </summary>
|
||
/// <param name="duration">The time to remain invincible.</param>
|
||
/// <param name="token">Optional cancellation token.</param>
|
||
private async UniTask RemoveInvincibilityAfterAsync(float duration, CancellationToken token = default)
|
||
{
|
||
if (duration > 0f)
|
||
await UniTask.Delay(TimeSpan.FromSeconds(duration), cancellationToken: token);
|
||
|
||
isInvincible = false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Stops the player's movement for a specified duration using UniTask.
|
||
/// </summary>
|
||
/// <param name="duration">Duration in seconds to stop movement.</param>
|
||
/// <param name="allowRotation">If true, allows rotation while movement is stopped.</param>
|
||
/// <param name="token">Optional cancellation token.</param>
|
||
private async UniTask StopMovementAsync(float duration, bool allowRotation, CancellationToken token = default)
|
||
{
|
||
if (characterControllerComponent == null)
|
||
{
|
||
Debug.LogWarning("CharacterController is not assigned.");
|
||
return;
|
||
}
|
||
|
||
characterControllerComponent.StopMovement(allowRotation);
|
||
isMovementStopped = true;
|
||
|
||
if (duration > 0f)
|
||
await UniTask.Delay(TimeSpan.FromSeconds(duration), cancellationToken: token);
|
||
|
||
characterControllerComponent.ResumeMovement();
|
||
isMovementStopped = false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Internal coroutine that enforces the stun and restores the previous state.
|
||
/// </summary>
|
||
private async UniTaskVoid StunRoutine(float duration, CancellationToken token)
|
||
{
|
||
if (isStunned) return;
|
||
|
||
bool prevAutoAttack = canAutoAttack;
|
||
bool prevMovementStop = isMovementStopped;
|
||
characterControllerComponent.CancelDash();
|
||
characterControllerComponent.StopMovement();
|
||
isMovementStopped = true;
|
||
canAutoAttack = false;
|
||
isStunned = true;
|
||
|
||
try
|
||
{
|
||
await UniTask.Delay(TimeSpan.FromSeconds(duration), cancellationToken: token);
|
||
}
|
||
catch (OperationCanceledException) { }
|
||
finally
|
||
{
|
||
isStunned = false;
|
||
canAutoAttack = prevAutoAttack;
|
||
|
||
if (!prevMovementStop)
|
||
{
|
||
characterControllerComponent.ResumeMovement();
|
||
isMovementStopped = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Hides the status message after a delay using UniTask.
|
||
/// </summary>
|
||
/// <param name="statusText">The TextMeshProUGUI component displaying the status message.</param>
|
||
/// <param name="delay">The delay in seconds before hiding the message.</param>
|
||
/// <param name="token">Optional cancellation token.</param>
|
||
private async UniTask HideStatusMessageAfterDelayAsync(TextMeshProUGUI statusText, float delay, CancellationToken token = default)
|
||
{
|
||
if (delay > 0f)
|
||
await UniTask.Delay(TimeSpan.FromSeconds(delay), cancellationToken: token);
|
||
|
||
if (statusText != null)
|
||
statusText.text = string.Empty;
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
}
|