public override State Tick(Enemy_Manager enemyManager, Enemy_Stats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
if (enemyManager.isPerformingAction)
{
enemyAnimatorManager.anim.SetFloat("Vertical", 0, 0.1f, Time.deltaTime);
return(this);
}
Vector3 targetDirection = enemyManager.currentTarget.transform.position - enemyManager.transform.position;
float distanceFromTarget = Vector3.Distance(enemyManager.currentTarget.transform.position, enemyManager.transform.position);
float viewableAngle = Vector3.Angle(targetDirection, enemyManager.transform.forward);
//if we are performing an action, stop our movement
if (distanceFromTarget > enemyManager.maximumAttackRange)
{
enemyAnimatorManager.anim.SetFloat("Vertical", 1, 0.1f, Time.deltaTime);
}
HandleRotationTowardsTarget(enemyManager);
if (distanceFromTarget <= enemyManager.maximumAttackRange)
{
return(combatStanceState);
}
else
{
return(this);
}
}
public override State Tick(Enemy_Manager enemyManager, Enemy_Stats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
float distanceFromTarget = Vector3.Distance(enemyManager.currentTarget.transform.position, enemyManager.transform.position);
HandleRotationTowardsTarget(enemyManager);
if (enemyManager.isPerformingAction)
{
enemyAnimatorManager.anim.SetFloat("Vertical", 0, 0.1f, Time.deltaTime);
}
if (enemyManager.currentRecoveryTime <= 0 && distanceFromTarget <= enemyManager.maximumAttackRange)
{
return(attackState);
}
else if (distanceFromTarget > enemyManager.maximumAttackRange)
{
return(pursueTargetState);
}
else
{
return(this);
}
//potentially circle the player or walk around them
}
public void Initialize()
{
enemy_manager = Enemy_Manager.Instance;
enemy_script = gameObject.GetComponent <Enemy>();
enemy_status = new Enemy_Status();
enemy_move = new Enemy_Move();
}
public static void DeleteEnemy(Enemy_Manager _Enemy)
{
if (_Enemys.Contains(_Enemy))
{
_Enemys.Remove(_Enemy);
}
}
public void ReciveTactical(Enemy_Manager _Enemy)
{
if (_Text == null)
{
_Text = UI_MANAGER.m_UI_MANAGER.Tactical;
}
switch (_Attack_Style)
{
case Attack_Style.NONE:
break;
case Attack_Style.Move_Forward:
Tactical = _Enemy.gameObject.AddComponent <Move_Forward>();
Tactical._this = _Enemy;
_Enemy._Tactical = Tactical;
_Text.text = "전진";
break;
case Attack_Style.Charge:
Tactical = _Enemy.gameObject.AddComponent <Charge>();
Tactical._this = _Enemy;
_Enemy._Tactical = Tactical;
_Text.text = "돌격";
break;
case Attack_Style.Siege:
Tactical = _Enemy.gameObject.AddComponent <Siege>();
Tactical._this = _Enemy;
_Enemy._Tactical = Tactical;
_Text.text = "포위";
break;
}
switch (_Defense_Style)
{
case Defense_Style.NONE:
break;
case Defense_Style.Build_Recon:
Tactical = _Enemy.gameObject.AddComponent <By_Pass>();
Tactical._this = _Enemy;
_Enemy._Tactical = Tactical;
_Text.text = "백핸드";
break;
case Defense_Style.Shot_Run:
Tactical = _Enemy.gameObject.AddComponent <Shot_Run>();
Tactical._this = _Enemy;
_Enemy._Tactical = Tactical;
_Text.text = "능동방어";
break;
case Defense_Style.Bypass:
Tactical = _Enemy.gameObject.AddComponent <By_Pass>();
Tactical._this = _Enemy;
_Enemy._Tactical = Tactical;
_Text.text = "백핸드";
break;
}
}
/// <summary>
/// 実際に攻撃を行い、ゲームを進める
/// </summary>
/// <param name="on_first">1マス先を取るのに使用</param>
void Attack_Process(int adjust_value1, int adjust_value2)
{
var enemy_manager = new Enemy_Manager();
// 隣接してるエネミーを調べる
GameObject side_enemy = enemy_manager.Find_Enemy(player_script.position.x + adjust_value1,
player_script.position.y + adjust_value2);
// 隣接してるエネミーのステータスを取ってくる
var enemy_status = side_enemy.GetComponent <Enemy_Controller>().enemy_status;
enemy_status.hit_point -= damage_calculation.Damage(player_status.attack,
enemy_status.defence);
// ダメージのログを流す
Log_Scroll.Player_Attack_Log(player_status, side_enemy, damage_calculation.Damage(player_status.attack,
enemy_status.defence));
// 攻撃した敵が死んでいたら経験値を取得
if (enemy_status.hit_point <= 0)
{
// レベルアップより先に経験値を取得
Log_Scroll.Get_Experience_Point(player_status, side_enemy, enemy_status.experience_point);
// 実際に経験値を取得し、次レベルに必要な経験値量に達しているかを見る
player_status.Add_Experience_Point(enemy_status.experience_point);
// ダンジョンに出現中の敵のリストを取得
List <GameObject> enemy_list = Enemy_Manager.Instance.enemies;
// プレイヤーに隣接しているものを抽出
enemy_manager.Dead_Enemy(enemy_list.IndexOf(side_enemy));
}
// 移動状態に戻す
player_action.Set_Action(ePlayer_State.Move);
}
/// <summary>
/// ダンジョンに出現する敵の種類ごとにステータスを設定し、リストに格納する
/// </summary>
public void Create_Enemy()
{
// csv読み込みクラス
csv_Reader reader;
reader = Game.Instance.reader;
enemy_manager = Enemy_Manager.Instance;
var enemy_status = reader.Load_csv("csv/Actor/Enemy/Enemy_csv", Define_Value.UNNECESSARY_COLUMN);
for (int enemy_type = 0; enemy_type < Define_Value.ENEMY_NUMBER; ++enemy_type)
{
var enemy = new Enemy_Status {
ID = int.Parse(enemy_status[enemy_type][0]), // 番号
name = enemy_status[enemy_type][1], // 名前
class_type = int.Parse(enemy_status[enemy_type][2]), // クラス
level = int.Parse(enemy_status[enemy_type][3]), // レベル
hit_point = int.Parse(enemy_status[enemy_type][4]), // 体力
max_hitpoint = int.Parse(enemy_status[enemy_type][5]), // 最大体力
attack = int.Parse(enemy_status[enemy_type][6]), // 攻撃力
defence = int.Parse(enemy_status[enemy_type][7]), // 防御力
activity = int.Parse(enemy_status[enemy_type][8]), // 行動力
critical = int.Parse(enemy_status[enemy_type][9]), // クリティカル
experience_point = int.Parse(enemy_status[enemy_type][10]), // 経験値
skill = int.Parse(enemy_status[enemy_type][11]), // スキル(種類)
AI_pattern = int.Parse(enemy_status[enemy_type][12]), // AI
first_floor = int.Parse(enemy_status[enemy_type][13]), // 出開始階層
last_floor = int.Parse(enemy_status[enemy_type][14]), // 出現終了階層
turn_count = int.Parse(enemy_status[enemy_type][15]) // 経過ターンをカウント
};
enemy_manager.enemy_type.Add(enemy);
}
}
private void HandleRotationTowardsTarget(Enemy_Manager enemyManager)
{
//rotate manually
if (enemyManager.isPerformingAction)
{
Vector3 direction = enemyManager.currentTarget.transform.position - transform.position;
direction.y = 0;
direction.Normalize();
if (direction == Vector3.zero)
{
direction = transform.forward;
}
Quaternion targetRotation = Quaternion.LookRotation(direction);
enemyManager.transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, enemyManager.rotationSpeed / Time.deltaTime);
}
//rotate w/ pathfinding
else
{
Vector3 relativeDirection = transform.InverseTransformDirection(enemyManager.navMeshAgent.desiredVelocity);
Vector3 targetVelocity = enemyManager.enemyRigidBody.velocity;
enemyManager.navMeshAgent.enabled = true;
enemyManager.navMeshAgent.SetDestination(enemyManager.currentTarget.transform.position);
enemyManager.enemyRigidBody.velocity = targetVelocity;
enemyManager.transform.rotation = Quaternion.Slerp(enemyManager.transform.rotation, enemyManager.navMeshAgent.transform.rotation, enemyManager.rotationSpeed / Time.deltaTime);
}
}
public static void AddEnemy(Enemy_Manager _Enemy)
{
if (_Enemys == null)
{
_Enemys = new List <Enemy_Manager>();
}
_Enemys.Add(_Enemy);
}
/// <summary>
/// 初期化
/// </summary>
public void Initialize(GameObject enemy_object, int enemy_number)
{
enemy_manager = Enemy_Manager.Instance;
Set_Enemy_Object(enemy_object);
Set_Enemy_Number(enemy_number);
now_room_number = enemy_object.GetComponent <Enemy_Controller>().enemy_status.Now_Room;
division_list = Dungeon_Manager.Instance.dungeon_generator.division_list;
}
public void Initialize()
{
game_manager = GameManager.Instance;
enemy_manager = Enemy_Manager.Instance;
player = Player_Manager.Instance.player_script;
player_status = Player_Manager.Instance.player_status;
enemy_status = new Enemy_Status();
map_layer = Dungeon_Manager.Instance.map_layer_2D;
damage_calculation = Game.Instance.damage_calculation;
}
void Start()
{
room_list = new List <List <Vector2Int> >();
enemy_manager = Enemy_Manager.Instance;
floor = new ReactiveProperty <int>(Define_Value.INITIAL_FLOOR);
max_floor = new ReactiveProperty <int>();
tile_state = new ReactiveProperty <eTile_State>(eTile_State.Grass);
wall_state = new ReactiveProperty <eWall_State>(eWall_State.Tree);
}
public override State Tick(Enemy_Manager enemyManager, Enemy_Stats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
Vector3 targetDirection = enemyManager.currentTarget.transform.position - transform.position;
float viewableAngle = Vector3.Angle(targetDirection, transform.forward);
float distanceFromTarget = Vector3.Distance(enemyManager.currentTarget.transform.position, enemyManager.transform.position);
HandleRotationTowardsTarget(enemyManager);
//select one of our many attacks
//if the selected attack is not able to be used because of bad angle or distance, select a new attack
//if the attack is viable, stop our movement and attack the target
//set our recovery timer to the attacks recovery time
//return to the combat stance state
#region Attacks
if (enemyManager.isPerformingAction)
{
return(combatStanceState);
}
if (currentAttack != null)
{
//if too close, get new attack
if (distanceFromTarget < currentAttack.minimumDistanceNeededToAttack)
{
return(this);
}
//if we are close enough to atack, then let us proceed
else if (distanceFromTarget < currentAttack.maximumDistanceNeededToAttack)
{
//if our enemy is within our attacks viewable angle, we attack
if (viewableAngle <= currentAttack.maximumAttackAngle &&
viewableAngle >= currentAttack.minimumAttackAngle)
{
if (enemyManager.currentRecoveryTime <= 0 && enemyManager.isPerformingAction == false)
{
enemyAnimatorManager.anim.SetFloat("Vertical", 0, 0.1f, Time.deltaTime);
enemyAnimatorManager.anim.SetFloat("Horizontal", 0, 0.1f, Time.deltaTime);
enemyAnimatorManager.PlayTargetAnimation(currentAttack.actionAnimation, true);
enemyManager.isPerformingAction = true;
enemyManager.currentRecoveryTime = currentAttack.recoveryTime;
currentAttack = null;
return(combatStanceState);
}
}
}
}
else
{
GetNewAttack(enemyManager);
}
return(combatStanceState);
}
private void GetNewAttack(Enemy_Manager enemyManager)
{
Vector3 targetsDirection = enemyManager.currentTarget.transform.position - transform.position;
float viewableAngle = Vector3.Angle(targetsDirection, transform.forward);
float distanceFromTarget = Vector3.Distance(enemyManager.currentTarget.transform.position, transform.position);
//Debug.Log("Distance from target currently is: " + distanceFromTarget);
int maxScore = 0;
for (int i = 0; i < enemyAttacks.Length; i++)
{
EnemyAttackAction enemyAttackAction = enemyAttacks[i];
if (distanceFromTarget <= enemyAttackAction.maximumDistanceNeededToAttack &&
distanceFromTarget >= enemyAttackAction.minimumDistanceNeededToAttack)
{
//Debug.Log("Enemy in Distance!");
if (viewableAngle <= enemyAttackAction.maximumAttackAngle &&
viewableAngle >= enemyAttackAction.minimumAttackAngle)
{
//Debug.Log("Grabbed Max Score!");
maxScore += enemyAttackAction.attackScore;
}
}
}
int randomValue = Random.Range(0, maxScore);
int temporaryScore = 0;
for (int i = 0; i < enemyAttacks.Length; i++)
{
EnemyAttackAction enemyAttackAction = enemyAttacks[i];
if (distanceFromTarget <= enemyAttackAction.maximumDistanceNeededToAttack &&
distanceFromTarget >= enemyAttackAction.minimumDistanceNeededToAttack)
{
if (viewableAngle <= enemyAttackAction.maximumAttackAngle &&
viewableAngle >= enemyAttackAction.minimumAttackAngle)
{
if (currentAttack != null)
{
return;
}
temporaryScore += enemyAttackAction.attackScore;
if (temporaryScore > randomValue)
{
currentAttack = enemyAttackAction;
}
}
}
}
}
public override State Tick(Enemy_Manager enemyManager, Enemy_Stats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
if (isSleeping && enemyManager.isInteracting == false)
{
//play sleep anim
Debug.Log("Is sleeping");
enemyAnimatorManager.PlayTargetAnimation(sleepAnimation, true);
}
#region Handle Target Detection
Collider[] colliders = Physics.OverlapSphere(enemyManager.transform.position, detectionRadius, detectionLayer);
for (int i = 0; i < colliders.Length; i++)
{
CharacterStats characterStats = colliders[i].transform.GetComponent <CharacterStats>();
if (characterStats != null)
{
Vector3 targetsDirection = characterStats.transform.position - enemyManager.transform.position;
float viewableAngle = Vector3.Angle(targetsDirection, enemyManager.transform.forward);
if (viewableAngle > enemyManager.minimumDetectionAngle &&
viewableAngle < enemyManager.maximumDetectionAngle)
{
enemyManager.currentTarget = characterStats;
isSleeping = false;
//play wake animation
Debug.Log("Is awake!");
enemyAnimatorManager.PlayTargetAnimation(wakeAnimation, true);
}
}
}
#endregion
#region Handle State Change
if (enemyManager.currentTarget != null)
{
return(pursueTargetState);
}
else
{
return(this);
}
#endregion
}
public void Start()
{
if (hasStarted)
{
return;
}
LevelManager = Managers[0].GetComponent <Level_Manager>();
PlayerManager = Managers[1].GetComponent <Player_Manager>();
EnemyManager = Managers[2].GetComponent <Enemy_Manager>();
FetchName();
LevelManager.Initialize();
EnemyManager.Initialize();
PlayerManager.Initialize();
PrepareNextLvl();
}
/// <summary>
/// スポーンされたエネミーに登録しておいた種類別のステータスをセットする
/// </summary>
/// <param name="enemy_object">生成されたエネミー</param>
/// <param name="type">敵の種類</param>
public void Set_Parameter(GameObject enemy_object, int type)
{
enemy_manager = Enemy_Manager.Instance;
Enemy_Status enemy_status = enemy_object.GetComponent <Enemy_Controller>().enemy_status;
enemy_status.ID = enemy_manager.enemy_type[type].ID; // ID
enemy_status.name = enemy_manager.enemy_type[type].name; // 名前
enemy_status.class_type = enemy_manager.enemy_type[type].class_type; // クラス
enemy_status.level = enemy_manager.enemy_type[type].level; // レベル
enemy_status.hit_point = enemy_manager.enemy_type[type].hit_point; // 体力
enemy_status.max_hitpoint = enemy_manager.enemy_type[type].max_hitpoint; // 最大体力
enemy_status.attack = enemy_manager.enemy_type[type].attack; // 攻撃力
enemy_status.defence = enemy_manager.enemy_type[type].defence; // 防御力
enemy_status.activity = enemy_manager.enemy_type[type].activity; // 行動力
enemy_status.critical = enemy_manager.enemy_type[type].critical; // クリティカル発生率
enemy_status.experience_point = enemy_manager.enemy_type[type].experience_point; // 経験値
enemy_status.skill = enemy_manager.enemy_type[type].skill; // スキル
enemy_status.AI_pattern = enemy_manager.enemy_type[type].AI_pattern; // 行動パターン
enemy_status.first_floor = enemy_manager.enemy_type[type].first_floor; // 出現開始階層
enemy_status.last_floor = enemy_manager.enemy_type[type].last_floor; // 出現終了階層
enemy_status.turn_count = enemy_manager.enemy_type[type].turn_count; // 経過ターン
}
public override State Tick(Enemy_Manager enemyManager, Enemy_Stats enemyStats, EnemyAnimatorManager enemyAnimatorManager)
{
#region Handle Enemy Target Detection
Collider[] colliders = Physics.OverlapSphere(transform.position, enemyManager.detectionRadius, detectionLayer);
for (int i = 0; i < colliders.Length; i++)
{
CharacterStats characterStats = colliders[i].transform.GetComponent <CharacterStats>();
if (characterStats != null)
{
//check for team id
Vector3 targetDirection = characterStats.transform.position - transform.position;
float viewableAngle = Vector3.Angle(targetDirection, transform.forward);
if (viewableAngle > enemyManager.minimumDetectionAngle && viewableAngle < enemyManager.maximumDetectionAngle)
{
enemyManager.currentTarget = characterStats;
}
}
}
#endregion
#region Handle Switching To Next State
if (enemyManager.currentTarget != null)
{
return(pursueTargetState);
}
else
{
return(this);
}
#endregion
}
public override bool Rand(Enemy_Manager _this)
{
base.Rand(_this);
if (Unit.Now_Action_Point < 3 || Action)
{
return(false);
}
Unit_Manager CloserPlayer = _this.GetMeetPlayer()[_this.CloserPlayer()];
if (Mathf.Abs(CloserPlayer.x - _this.x) + Mathf.Abs(CloserPlayer.y - _this.y) <= Weapon.Range)
{
Tile _Tile = CloserPlayer.T;
for (int x = _Tile.X - 1; x <= _Tile.X + 1; x++)
{
for (int y = _Tile.Y - 1; y <= _Tile.Y + 1; y++)
{
Weapon.HeadShot_Bonus = 0;
if (x < 0 || x >= _Tile._Tile.X || y < 0 || y >= _Tile._Tile.Y)
{
continue;
}
if (x != _Tile.X && y != _Tile.Y)
{
continue;
}
_Tile._Tile.MY_Tile[x][y].DownGrade();
if (_Tile._Tile.MY_Tile[x][y].transform.childCount > 0)
{
if (_Tile._Tile.MY_Tile[x][y].transform.Find("Enemy(Clone)") != null)
{
Unit_Manager _Unit = _Tile._Tile.MY_Tile[x][y].transform.Find("Enemy(Clone)").GetComponent <Unit_Manager>();
if (_Unit != null)
{
if (x == _Tile.X && y == _Tile.Y)
{
Weapon.HeadShot_Bonus = 100;
}
_Unit.Hit(Weapon);
}
}
else if (_Tile._Tile.MY_Tile[x][y].transform.Find("Player(Clone)") != null)
{
Unit_Manager _Unit = _Tile._Tile.MY_Tile[x][y].transform.Find("Player(Clone)").GetComponent <Unit_Manager>();
if (_Unit != null)
{
if (x == _Tile.X && y == _Tile.Y)
{
Weapon.HeadShot_Bonus = 100;
}
_Unit.Hit(Weapon);
}
}
}
}
}
_this.Now_Action_Point -= 3;
Btn1 = false;
Action = false;
count--;
Cursor_Manager.m_Cursor_Manager.SetCursor(UI_MANAGER.m_UI_MANAGER.Cursors[1]);
if (count <= 0)
{
_this.Items.Remove(this);
Destroy(gameObject);
}
}
return(true);
}
public virtual bool Rand(Enemy_Manager _this)
{
return(true);
}
/// <summary>
/// 変数に情報を入れる処理
/// </summary>
void Start()
{
EnemyShipManager_ = transform.root.GetComponent <EnemyShipManager>();
Enemy_Points_ = transform.root.GetComponent <Enemy_Points>();
Enemy_Manager_ = transform.root.GetComponent <Enemy_Manager>();
}
private void Awake()
{
enemyManager = GetComponent <Enemy_Manager>();
enemyAnimatorManager = GetComponentInChildren <EnemyAnimatorManager>();
}
public abstract State Tick(Enemy_Manager enemyManager, Enemy_Stats enemyStats, EnemyAnimatorManager enemyAnimatorManager);
void Start()
{
room_entrance = new List <Vector2Int>();
enemy_manager = Enemy_Manager.Instance;
player = Player_Manager.Instance.player_script;
}
private void Awake()
{
anim = GetComponent <Animator>();
enemyManager = GetComponentInParent <Enemy_Manager>();
}
void Start()
{
Enemyscript = RU3.GetComponent <Enemy_Manager>();
}
