429 lines
15 KiB
C#
429 lines
15 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
using Random = UnityEngine.Random;
|
|
|
|
// ReSharper disable once CheckNamespace
|
|
namespace BlueWaterProject
|
|
{
|
|
public abstract class EnemyAi : CombatAi, IDamageable
|
|
{
|
|
#region Properties and variables
|
|
|
|
[field: SerializeField] public EnemyStat EnemyStat { get; set; }
|
|
|
|
protected bool isAttackCoroutine;
|
|
private bool beAttacked;
|
|
private EnemyUnit enemyUnit;
|
|
private int childNum;
|
|
|
|
#endregion
|
|
|
|
#region Unit Built-in methods
|
|
|
|
protected virtual void OnDrawGizmosSelected()
|
|
{
|
|
if (!isDrawGizmosInFieldOfView) return;
|
|
|
|
if (EnemyStat.AttackerType == EAttackerType.OFFENSE)
|
|
{
|
|
if (!targetTransform) return;
|
|
|
|
Gizmos.color = Color.red;
|
|
Gizmos.DrawLine(transform.position, targetTransform.position);
|
|
}
|
|
else if (EnemyStat.AttackerType == EAttackerType.DEFENSE)
|
|
{
|
|
if (EnemyStat.DefenseType == EDefenseType.DEFENDER)
|
|
{
|
|
Gizmos.color = Color.red;
|
|
var startPos = Application.isPlaying ? defensePos : transform.position;
|
|
Gizmos.DrawWireSphere(startPos, EnemyStat.DefenseRange);
|
|
}
|
|
|
|
Gizmos.color = Color.blue;
|
|
Gizmos.DrawWireSphere(transform.position, EnemyStat.ViewRange);
|
|
|
|
if (!targetTransform) return;
|
|
|
|
Gizmos.color = Color.red;
|
|
Gizmos.DrawLine(transform.position, targetTransform.position);
|
|
}
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
InitStart();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IDamageable interface
|
|
|
|
public void TakeDamage(float attackerPower, float attackerShieldPenetrationRate, Vector3? attackPos = null)
|
|
{
|
|
if (attackPos != null && EnemyStat.AttackerType == EAttackerType.DEFENSE && !targetTransform)
|
|
{
|
|
BeAttackedMovement((Vector3)attackPos);
|
|
}
|
|
|
|
// 회피 성공 체크
|
|
if (Random.Range(0, 100) < EnemyStat.AvoidanceRate)
|
|
{
|
|
// TODO : 회피 처리
|
|
return;
|
|
}
|
|
|
|
var finalDamage = 0f;
|
|
|
|
if (EnemyStat.UsingShield)
|
|
{
|
|
var penetrationChance = attackerShieldPenetrationRate -
|
|
(attackerShieldPenetrationRate * EnemyStat.PenetrationResistivity * 0.01f);
|
|
|
|
// 방패를 관통했다면,
|
|
if (Random.Range(0, 100) < penetrationChance)
|
|
{
|
|
finalDamage = attackerPower - EnemyStat.Def;
|
|
finalDamage = Mathf.Max(finalDamage, 0);
|
|
}
|
|
else
|
|
{
|
|
finalDamage = 0f;
|
|
}
|
|
}
|
|
|
|
finalDamage = attackerPower - EnemyStat.Def;
|
|
finalDamage = Mathf.Max(finalDamage, 0);
|
|
|
|
// 방패 막기 체크
|
|
if (finalDamage == 0f)
|
|
{
|
|
combatAnimator.SetTrigger(ShieldHash);
|
|
return;
|
|
}
|
|
var changeHp = Mathf.Max(EnemyStat.CurrentHp - finalDamage, 0);
|
|
SetCurrentHp(changeHp, true);
|
|
|
|
// 죽었는지 체크
|
|
if (changeHp == 0f) return;
|
|
|
|
combatAnimator.SetTrigger(DamageHash);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Custom methods
|
|
|
|
protected override void InitComponent()
|
|
{
|
|
base.InitComponent();
|
|
|
|
enemyUnit = Utils.GetComponentAndAssert<EnemyUnit>(transform.parent);
|
|
}
|
|
|
|
protected override void SetLayer()
|
|
{
|
|
gameObject.layer = LayerMask.NameToLayer("Enemy");
|
|
var hitBoxObj = hitBoxCollider.gameObject;
|
|
hitBoxObj.layer = LayerMask.NameToLayer("HitBox");
|
|
hitBoxObj.tag = "Enemy";
|
|
targetLayer = LayerMask.GetMask("Player") | LayerMask.GetMask("Pirate");
|
|
|
|
if (EnemyStat.AttackerType == EAttackerType.OFFENSE)
|
|
{
|
|
targetLayer |= LayerMask.GetMask("Props");
|
|
}
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
public virtual void InitStartInEditor()
|
|
{
|
|
var enemyViewData = DataManager.Inst.GetEnemyViewSoFromKey(EnemyStat.ViewIdx);
|
|
|
|
InitComponent();
|
|
SetLayer();
|
|
InitViewModel(enemyViewData);
|
|
}
|
|
#endif
|
|
|
|
protected virtual void InitStart()
|
|
{
|
|
var enemyViewData = DataManager.Inst.GetEnemyViewDictionaryFromKey(EnemyStat.ViewIdx);
|
|
|
|
InitViewModel(enemyViewData);
|
|
SetBehaviorTree(UnitManager.Inst.EnemyBehaviorTree);
|
|
|
|
SetCurrentHp(EnemyStat.MaxHp, true);
|
|
SetMoveSpeed(EnemyStat.MoveSpd);
|
|
|
|
|
|
if (EnemyStat.AttackerType == EAttackerType.DEFENSE)
|
|
{
|
|
SetDefensePos(transform.position, true);
|
|
childNum = transform.GetSiblingIndex();
|
|
enemyUnit.SetDefensePos(defensePos, childNum);
|
|
}
|
|
}
|
|
|
|
private void InitViewModel(EnemyView enemyView)
|
|
{
|
|
SetActiveViewModel(backpackContainer, enemyView.Backpack);
|
|
SetActiveViewModel(leftWeaponContainer, enemyView.LeftWeapon);
|
|
SetActiveViewModel(leftShieldContainer, enemyView.LeftShield);
|
|
SetActiveViewModel(headContainer, enemyView.Head);
|
|
SetActiveViewModel(rightWeaponContainer, enemyView.RightWeapon);
|
|
SetActiveViewModel(bodyContainer, enemyView.Body);
|
|
SetActiveViewModel(flagContainer, enemyView.Flag);
|
|
}
|
|
|
|
public override void FindTarget()
|
|
{
|
|
switch (EnemyStat.AttackerType)
|
|
{
|
|
case EAttackerType.NONE:
|
|
print("EnemyStat.AttackerType == NONE Error");
|
|
break;
|
|
case EAttackerType.OFFENSE:
|
|
FindTargetInOffense();
|
|
break;
|
|
case EAttackerType.DEFENSE:
|
|
FindTargetInDefense();
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
}
|
|
|
|
public override bool CanAttack()
|
|
{
|
|
if (!targetTransform) return false;
|
|
|
|
var attackInRange = Vector3.Distance(transform.position, targetTransform.position) <= EnemyStat.AtkRange;
|
|
return attackInRange;
|
|
}
|
|
|
|
public override void Attack()
|
|
{
|
|
isAttackCoroutine = true;
|
|
StartCoroutine(nameof(AttackAnimation));
|
|
}
|
|
|
|
protected abstract IEnumerator AttackAnimation();
|
|
|
|
private void FindTargetInOffense()
|
|
{
|
|
if (!attackingIslandInfo)
|
|
{
|
|
print("attackingIslandInfo == null error");
|
|
return;
|
|
}
|
|
|
|
switch (EnemyStat.OffenseType)
|
|
{
|
|
case EOffenseType.NONE:
|
|
print("AiStat.OffenseType == NONE Error");
|
|
break;
|
|
case EOffenseType.NORMAL:
|
|
if (attackingIslandInfo.ExceptHouseList.Count > 0)
|
|
{
|
|
FindNearestTargetInList(attackingIslandInfo.ExceptHouseList);
|
|
}
|
|
else if (attackingIslandInfo.HouseList.Count > 0)
|
|
{
|
|
FindNearestTargetInList(attackingIslandInfo.HouseList);
|
|
}
|
|
break;
|
|
case EOffenseType.ONLY_HOUSE:
|
|
if (attackingIslandInfo.HouseList.Count > 0)
|
|
{
|
|
FindNearestTargetInList(attackingIslandInfo.HouseList);
|
|
}
|
|
else if (attackingIslandInfo.ExceptHouseList.Count > 0)
|
|
{
|
|
FindNearestTargetInList(attackingIslandInfo.ExceptHouseList);
|
|
}
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
}
|
|
|
|
protected virtual void FindNearestTargetInList(List<Transform> targetList)
|
|
{
|
|
if (targetList.Count <= 0) return;
|
|
|
|
var nearestTarget = targetList.OrderBy(t => t ?
|
|
Vector3.Distance(transform.position, t.position) : float.MaxValue).FirstOrDefault();
|
|
|
|
if (nearestTarget == null) return;
|
|
|
|
SetTargetTransform(nearestTarget, true);
|
|
}
|
|
|
|
private void FindTargetInDefense()
|
|
{
|
|
switch (EnemyStat.DefenseType)
|
|
{
|
|
case EDefenseType.NONE:
|
|
print("EnemyStat.DefenseType == NONE Error");
|
|
break;
|
|
case EDefenseType.STRIKER:
|
|
FindNearestTargetInRange(transform.position, EnemyStat.ViewRange);
|
|
break;
|
|
case EDefenseType.MIDFIELDER:
|
|
FindNearestTargetInRange(transform.position, EnemyStat.ViewRange);
|
|
break;
|
|
case EDefenseType.DEFENDER:
|
|
FindNearestTargetInRange(defensePos, EnemyStat.DefenseRange);
|
|
break;
|
|
case EDefenseType.KEEPER:
|
|
FindNearestTargetInRange(transform.position, EnemyStat.ViewRange);
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
}
|
|
|
|
protected virtual void FindNearestTargetInRange(Vector3 centerPos, float range)
|
|
{
|
|
Array.Clear(colliderWithinRange, 0, TARGET_MAX_SIZE);
|
|
|
|
var maxColliderCount = Physics.OverlapSphereNonAlloc(centerPos, range, colliderWithinRange,
|
|
targetLayer, QueryTriggerInteraction.Collide);
|
|
|
|
if (maxColliderCount <= 0)
|
|
{
|
|
SetTargetTransform(null, true);
|
|
return;
|
|
}
|
|
|
|
var nearestDistance = Mathf.Infinity;
|
|
Transform nearestTargetTransform = null;
|
|
|
|
for (var i = 0; i < maxColliderCount; i++)
|
|
{
|
|
var distanceToTarget = Vector3.Distance(transform.position, colliderWithinRange[i].transform.position);
|
|
|
|
if (distanceToTarget >= nearestDistance) continue;
|
|
|
|
nearestDistance = distanceToTarget;
|
|
nearestTargetTransform = colliderWithinRange[i].transform;
|
|
}
|
|
|
|
SetTargetTransform(nearestTargetTransform, true);
|
|
}
|
|
|
|
public void MoveTargetInDefense(Vector3 targetPos)
|
|
{
|
|
switch (EnemyStat.DefenseType)
|
|
{
|
|
case EDefenseType.NONE:
|
|
print("EnemyStat.DefenseType == NONE error");
|
|
break;
|
|
case EDefenseType.STRIKER:
|
|
case EDefenseType.MIDFIELDER:
|
|
break;
|
|
case EDefenseType.DEFENDER:
|
|
if (Vector3.Distance(targetPos, defensePos) > EnemyStat.DefenseRange)
|
|
{
|
|
combatAgent.stoppingDistance = GlobalValue.MINIMUM_STOP_DISTANCE;
|
|
combatAgent.SetDestination(defensePos);
|
|
return;
|
|
}
|
|
break;
|
|
case EDefenseType.KEEPER:
|
|
return;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
|
|
if (Vector3.Distance(combatAgent.destination, targetPos) < 0.1f) return;
|
|
|
|
combatAgent.stoppingDistance = GlobalValue.MAXIMUM_STOP_DISTANCE;
|
|
combatAgent.SetDestination(targetPos);
|
|
}
|
|
|
|
public void ReturnDefensePos(Vector3 targetPos)
|
|
{
|
|
if (Vector3.Distance(combatAgent.destination, targetPos) < 0.1f) return;
|
|
|
|
combatAgent.stoppingDistance = GlobalValue.MINIMUM_STOP_DISTANCE;
|
|
combatAgent.SetDestination(targetPos);
|
|
}
|
|
|
|
protected override void SetCurrentHp(float value, bool useBehaviorTreeVariable = false)
|
|
{
|
|
EnemyStat.CurrentHp = value;
|
|
|
|
if (!useBehaviorTreeVariable) return;
|
|
|
|
Utils.SetBehaviorVariable(behaviorTree, "CurrentHp", value);
|
|
}
|
|
|
|
protected override void RemoveAiListElement()
|
|
{
|
|
if (enemyUnit.enemyUnitStat.EnemyAiList.Contains(this))
|
|
{
|
|
enemyUnit.enemyUnitStat.EnemyAiList.Remove(this);
|
|
}
|
|
|
|
enemyUnit.ResetDefensePos();
|
|
}
|
|
|
|
private void BeAttackedMovement(Vector3 attackPos)
|
|
{
|
|
switch (EnemyStat.DefenseType)
|
|
{
|
|
case EDefenseType.NONE:
|
|
print("EnemyStat.DefenseType == NONE Error");
|
|
break;
|
|
case EDefenseType.STRIKER:
|
|
case EDefenseType.MIDFIELDER:
|
|
break;
|
|
case EDefenseType.DEFENDER:
|
|
if (Vector3.Distance(defensePos, attackPos) > EnemyStat.DefenseRange) return;
|
|
break;
|
|
case EDefenseType.KEEPER:
|
|
return;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
|
|
foreach (var item in enemyUnit.enemyUnitStat.EnemyAiList)
|
|
{
|
|
if (item.GetTargetTransform()) continue;
|
|
|
|
item.SetBeAttacked(true, true);
|
|
item.MoveTarget(attackPos, GlobalValue.MAXIMUM_STOP_DISTANCE);
|
|
}
|
|
}
|
|
|
|
public void SetDefensePos(Vector3 value, bool useBehaviorTreeVariable = false)
|
|
{
|
|
defensePos = value;
|
|
|
|
if (!useBehaviorTreeVariable) return;
|
|
|
|
Utils.SetBehaviorVariable(behaviorTree, "DefensePos", value);
|
|
}
|
|
|
|
public void SetBeAttacked(bool value, bool useBehaviorTreeVariable = false)
|
|
{
|
|
beAttacked = value;
|
|
|
|
if (!useBehaviorTreeVariable) return;
|
|
|
|
Utils.SetBehaviorVariable(behaviorTree, "BeAttacked", value);
|
|
}
|
|
|
|
public bool GetIsAttackCoroutine() => isAttackCoroutine;
|
|
public void SetAttackerType(EAttackerType type) => EnemyStat.AttackerType = type;
|
|
public void SetOffenseType(EOffenseType type) => EnemyStat.OffenseType = type;
|
|
public void SetDefenseType(EDefenseType type) => EnemyStat.DefenseType = type;
|
|
|
|
#endregion
|
|
}
|
|
} |