using Rewired;
using System;
using UnityEngine;
using wildlogicgames;

namespace DoomBreakers
{

    [RequireComponent(typeof(Animator))]
    [RequireComponent(typeof(SpriteRenderer))]
    [RequireComponent(typeof(Collider2D))]
    [RequireComponent(typeof(Rigidbody2D))]
    [RequireComponent(typeof(CharacterController2D))]//[RequireComponent(typeof(Controller2D))]
    public class Player : PlayerStateMachine, IPlayer
    {
        private PlayerStateMachine _stateMachine;

        [Header("Player ID")]
        [Tooltip("ID ranges from 0 to 3")]  //Max 4 players.
        public int _playerID;               //Set in editor per player.

        [Header("Player Attack Points")]
        [Tooltip("Vectors that represent point of attack radius")]
        public Transform[] _attackPoints; //1=quickATK, 2=powerATK, 3=upwardATK

        [Header("Player Indicator Icon")]
        [Tooltip("The animator that indicates player ID within game")]
        public Animator _playerIndicatorAnimator;

        private Rewired.Player _rewirdInputPlayer;
        private Vector2 _inputVector2;
        private CharacterController2D _controller2D;//private Controller2D _controller2D;
        private Animator _animator;
        private Transform _transform;

        private PlayerCollision _playerCollider;
        private IPlayerEquipment _playerEquipment;
        private PlayerAnimator _playerAnimator;
        private IPlayerSprite _playerSprite;
        private GameObject _playerStatsObj;
        private PlayerStats _playerStats;
        GameObject _timerObjA, _timerObjB;
        private ITimer _buttonHeldTimer, _buttonJumpIncrementTimer;
        private int _buttonJumpIncrement;

        private const string _inputMoveHorStr = "MoveHorizontal";
        private const string _inputMoveVerStr = "MoveVertical";
        private const string _inputSprintStr = "Sprint";
        private const string _inputPauseStr = "Pause";
        private const string _inputJumpStr = "Jump";
        private const string _inputDodgeLStr = "DodgeL";
        private const string _inputDodgeRStr = "DodgeR";
        private const string _inputKnockBackStr = "KnockBack"; 
        private const string _inputAttackStr = "Attack";
        private const string _inputDefendStr = "Defend";

        private Action[] _actionListener = new Action[9];

        private bool _setup;

        private void InitializePlayer()
		{
            _setup = false;
            _stateMachine = this;
            _controller2D = this.GetComponent<CharacterController2D>();//this.GetComponent<Controller2D>();
            _controller2D.IgnoreEdgeDetection(true);
            _rewirdInputPlayer = ReInput.players.GetPlayer(_playerID);
            _inputVector2 = new Vector2();
            _animator = this.GetComponent<Animator>();
            _transform = this.transform;
            //_playerStats = new PlayerStats(100.0, 100.0, 0.0);
            _playerStatsObj = new GameObject();
            _playerStatsObj.AddComponent<PlayerStats>();
            _playerStats = _playerStatsObj.GetComponent<PlayerStats>();
            _playerStats.Initialize(100.0, 100.0, 0.0);

            _playerCollider = this.gameObject.AddComponent<PlayerCollision>(); //Required for OnTriggerEnter2D()
            _playerCollider.Setup(this.GetComponent<Collider2D>(), ref _attackPoints, _playerID, ref _transform, ref _playerStats);
            
            _playerEquipment = new PlayerEquipment(_playerID);
            _playerAnimator = new PlayerAnimator(ref _animator, "HumanAnimControllers", "Unarmored", "Player_with_nothing_controller", ref _playerIndicatorAnimator, _playerID);

            _playerSprite = this.gameObject.AddComponent<PlayerSprite>();
            _playerSprite.Setup(this.GetComponent<SpriteRenderer>(), _playerID);

            _timerObjA = new GameObject();
            _timerObjA.AddComponent<Timer>();
            _buttonHeldTimer = _timerObjA.GetComponent<Timer>();
            //_buttonHeldTimer = new Timer();

            _timerObjB = new GameObject();
            _timerObjB.AddComponent<Timer>();
            _buttonJumpIncrementTimer = _timerObjB.GetComponent<Timer>();
            //_buttonJumpIncrementTimer = new Timer();
            _buttonJumpIncrement = 0;



            _actionListener[0] = new Action(AttackedByBandit);//AttackedByBandit()
            _actionListener[1] = new Action(AttackedByArrow);//AttackedByArrow()
            _actionListener[2] = new Action(CampsiteReachedEvent);//CampsiteReachedEvent()
            _actionListener[3] = new Action(AttackedByFireball);//AttackedByFireball()
            _actionListener[4] = new Action(AttackedBySkeleton);//AttackedBySkeleton()
            _actionListener[5] = new Action(AttackedByBatSkully);//AttackedByBatSkully()
            _actionListener[6] = new Action(AttackedByGoblin);//AttackedByGoblin()
            _actionListener[7] = new Action(StoryTellerDialogueInitiated);//StoryTellerDialogueInitiated()
            _actionListener[8] = new Action(AttackedByTroll);//AttackedByTroll()

        }
        private void OnEnable()
        {
            ////Bandit.cs->BanditCollision.cs->enemy.GetComponent<Player>()->BattleColliderManager.TriggerEvent("ReportCollisionWithPlayer"); 

            BattleColliderManager.Subscribe("ReportCollisionWithPlayerForBandit" + _playerID.ToString(), _actionListener[0]);
            BattleColliderManager.Subscribe("ReportCollisionWithArrowForPlayer" + _playerID.ToString(), _actionListener[1]);
            LevelEventManager.Subscribe("CampsiteReachedEvent", _actionListener[2]);
            BattleColliderManager.Subscribe("ReportCollisionWithFireballForPlayer" + _playerID.ToString(), _actionListener[3]);
            BattleColliderManager.Subscribe("ReportCollisionWithPlayerForSkeleton" + _playerID.ToString(), _actionListener[4]);
            BattleColliderManager.Subscribe("ReportCollisionWithPlayerForBatSkully" + _playerID.ToString(), _actionListener[5]);
            BattleColliderManager.Subscribe("ReportCollisionWithPlayerForGoblin" + _playerID.ToString(), _actionListener[6]);
            LevelEventManager.Subscribe("StoryTellerReachedEvent", _actionListener[7]);
            BattleColliderManager.Subscribe("ReportCollisionWithPlayerForTroll" + _playerID.ToString(), _actionListener[8]);//ReportCollisionWithPlayerForTroll
        }
        private void OnDisable()
        {
            BattleColliderManager.Unsubscribe("ReportCollisionWithPlayerForBandit" + _playerID.ToString(), _actionListener[0]);
            BattleColliderManager.Unsubscribe("ReportCollisionWithArrowForPlayer" + _playerID.ToString(), _actionListener[1]);
            LevelEventManager.Unsubscribe("CampsiteReachedEvent", _actionListener[2]);
            BattleColliderManager.Unsubscribe("ReportCollisionWithFireballForPlayer" + _playerID.ToString(), _actionListener[3]);
            BattleColliderManager.Unsubscribe("ReportCollisionWithPlayerForSkeleton" + _playerID.ToString(), _actionListener[4]);
            BattleColliderManager.Unsubscribe("ReportCollisionWithPlayerForBatSkully" + _playerID.ToString(), _actionListener[5]);
            BattleColliderManager.Unsubscribe("ReportCollisionWithPlayerForGoblin" + _playerID.ToString(), _actionListener[6]);
            LevelEventManager.Unsubscribe("StoryTellerReachedEvent", _actionListener[7]);
            BattleColliderManager.Unsubscribe("ReportCollisionWithPlayerForTroll" + _playerID.ToString(), _actionListener[8]);//ReportCollisionWithPlayerForTroll
        }

        private void Awake()
		{
            InitializePlayer();
            if (UIDialogueManager._instance != null) UIDialogueManager._instance.DisplayDialogue(DialogueFlag.Dialogue_Empty);
        }

		void Start()
        {
            _playerAnimator.SetAnimatorController(ref _playerEquipment);
            //SetState(new PlayerIdle(this, _inputVector2));
            SetState(PlayerStatePool._instance.GetPlayerIdleObjState(this, _inputVector2, false));
        }
        private void Setup()
		{
            if (_playerID == 0)
			{
                LevelEventManager.ActivateStartLevel(_transform); //Only call once from Player 1.

                LevelEventManager.PluginPlayerTransform(_playerID, ref _transform);

                string sceneName = wildlogicgames.Utilities.GetCurrentSceneName();
                //print("SCENE=" + sceneName);
                //if (sceneName == "TrainingScene") AudioEventManager.PlayLevelMusic(LevelMUSICID.TrainingHall);
                //AudioEventManager.PlayLevelMusic(LevelMUSICID.StoryForestAct1);
                if (sceneName == "TrainingTutorialSceneAct1") AudioEventManager.PlayLevelMusic(LevelMUSICID.TrainingHall);
                //if (sceneName == "TutorialScene") AudioEventManager.PlayLevelMusic(LevelMUSICID.ForestAct1A);
                //if (sceneName == "ForestSceneAct1_Prologue") AudioEventManager.PlayLevelMusic(LevelMUSICID.ForestAct1A);
                if (sceneName == "ForestSceneAct1") AudioEventManager.PlayLevelMusic(LevelMUSICID.ForestAct1A);
                if (sceneName == "ForestSceneAct2") AudioEventManager.PlayLevelMusic(LevelMUSICID.ForestAct2A);
                if (sceneName == "ForestSceneAct1_Campsite") AudioEventManager.PlayLevelMusic(LevelMUSICID.ForestActCampsite);
                //if (sceneName == "ForestSceneAct2_Prologue") AudioEventManager.PlayLevelMusic(LevelMUSICID.ForestAct1A);
                //if (sceneName == "ForestSceneAct2") AudioEventManager.PlayLevelMusic(LevelMUSICID.ForestAct1A);
                if (sceneName == "ForestSceneAct1_StoryTell") AudioEventManager.PlayLevelMusic(LevelMUSICID.StoryForestAct1);

                //UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
                _playerStats.Reset(ref _playerStats, ref _playerEquipment, _playerID);
                //_playerStats.Defence = 0;
                UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);

            }
            _setup = true;
        }

        void Update()
        {
            if (!_setup) Setup();
            if (UILevelMenuManager._instance.IsPaused()) return;

            UpdateInput();
            UpdateStateBehaviours();
            UpdateCollisions();
            UpdateStats();
        }


        public float GetAttackButtonHeldTime() => _buttonHeldTimer.GetTimeRecord();
        public void UpdateInput()
		{
            if (_rewirdInputPlayer == null)
                return;
            if (IsDying())
                return;
            if (_state.GetType() == typeof(PlayerGainedEquipment))
                return;
            if (LevelEventManager.IsStartOfLevel()) return;
            if (LevelEventManager.IsEndOfLevel()) return;
            if (LevelEventManager.IsDialogue() && LevelEventManager.GetLevelSelection() != LevelSelection.Level_Training) return;

            _inputVector2.x = _rewirdInputPlayer.GetAxis(_inputMoveHorStr);
            _inputVector2.y = _rewirdInputPlayer.GetAxis(_inputMoveVerStr);


            if (_inputVector2.x > 0f || _inputVector2.x < 0f)
            {
                if (SafeToSetMove())
                {
                    ////if (_playerCollider.IsLadderCollisionEnabled()) _playerCollider.EnableLadderCollision(false);
                    //if (!_playerCollider.IsLadderCollisionEnabled())// && !IsClimbing())
                    //    SetState(new PlayerMove(this, _inputVector2, _transform, ref _playerSprite));
                    if (!_playerCollider.IsLadderCollisionEnabled() && !_playerCollider.SignalLadderGrabCollision())//!IsClimbing())
                        SetState(PlayerStatePool._instance.GetPlayerMoveObjState(_stateMachine, _velocity, null, ref _playerSprite, _playerCollider.IsWaterCollisionEnabled()));// new PlayerMove(this, _inputVector2, _transform, ref _playerSprite));
				}
                if (_inputVector2.x > 0.8f || _inputVector2.x < -0.8f)
				{
                    if (_playerCollider.IsLadderCollisionEnabled()) _playerCollider.EnableLadderCollision(false);
                    if (_controller2D._collisionDetail._collidedDirection[0])
                    {
                        if (SafeToSetMove()) SetState(PlayerStatePool._instance.GetPlayerMoveObjState(_stateMachine, _velocity, null, ref _playerSprite,_playerCollider.IsWaterCollisionEnabled()));// new PlayerMove(this, _inputVector2, _transform, ref _playerSprite));//On Ground
                    }
                }
            }
            if (_inputVector2.y > 0f || _inputVector2.y < 0f)
            {
                if (!_playerCollider.IsWaterCollisionEnabled())
				{
                    if (_playerCollider.IsLadderCollisionEnabled() && SafeToSetClimb())
                        SetState(PlayerStatePool._instance.GetPlayerClimbObjState(this, _inputVector2, _transform, ref _playerSprite, ref _animator));//new PlayerClimb(this, _inputVector2, _transform, ref _playerSprite, ref _animator));

                    if (_inputVector2.y > 0.66f || _inputVector2.y < -0.66f)
                    {
                        if (_playerCollider.SignalLadderGrabCollision()) //_playerCollider.EnableLadderCollision(true);
                        {
                            if (!_playerCollider.IsLadderCollisionEnabled()) _playerCollider.EnableLadderCollision(true);
                        }
                    }
                }
                if (_playerCollider.IsWaterCollisionEnabled())
				{
                    if (SafeToSetMove()) SetState(PlayerStatePool._instance.GetPlayerMoveObjState(_stateMachine, _velocity, null, ref _playerSprite, _playerCollider.IsWaterCollisionEnabled()));
                }
            }
            if (Mathf.Abs(_inputVector2.x) == 0f && Mathf.Abs(_inputVector2.y) == 0f)//else
            {
                //if (SafeToSetIdle()) SetState(new PlayerIdle(this, _inputVector2));
                if (SafeToSetIdle()) SetState(PlayerStatePool._instance.GetPlayerIdleObjState(this, _inputVector2, _playerCollider.IsWaterCollisionEnabled()));
            }
            if (_rewirdInputPlayer.GetButtonDown(_inputSprintStr))
			{
                _playerStats.Stamina -= 0.1; //magic numbers are bad.
                if (SafeToSetSprint())
                    SetState(PlayerStatePool._instance.GetPlayerSprintObjState(this, _inputVector2, _transform, ref _playerSprite, _playerCollider.IsWaterCollisionEnabled()));//new PlayerSprint(this, _inputVector2, _transform, ref _playerSprite));
            }
            if (_rewirdInputPlayer.GetButtonDown(_inputPauseStr))
			{
                UILevelMenuManager._instance.UIDisplayMenu(UILevelMenuDisplayOption.PauseDisplay);
                if (UIDialogueManager._instance != null) UIDialogueManager._instance.DisplayDialogue(DialogueFlag.Dialogue_Empty);
            }
            if (_rewirdInputPlayer.GetButtonUp(_inputSprintStr))
                return;
            if (_rewirdInputPlayer.GetButtonDown(_inputJumpStr))
            {
                if (SafeToSetJump())
				{
                    if (_buttonJumpIncrement < 2)
                    {
                        _buttonJumpIncrement++;
                        SetState(PlayerStatePool._instance.GetPlayerJumpObjState(_stateMachine, _velocity, null, ref _playerSprite, _playerCollider.IsWaterCollisionEnabled()));// new PlayerJump(this, _inputVector2, _transform, ref _playerSprite));
                        AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerJumpSFX);
                    }
                    else
                    {
                        _buttonJumpIncrementTimer.StartTimer(3.33f);//(2.44f);
                        if (_buttonJumpIncrementTimer.HasTimerFinished())
						{
                            _buttonJumpIncrementTimer.Reset();
                            _buttonJumpIncrement = 0;
                            SetState(PlayerStatePool._instance.GetPlayerJumpObjState(_stateMachine, _velocity, null, ref _playerSprite, _playerCollider.IsWaterCollisionEnabled()));// new PlayerJump(this, _inputVector2, _transform, ref _playerSprite));
                            AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerJumpSFX);
                        }
                    }
                }
            }
            if (_rewirdInputPlayer.GetButtonDown(_inputDodgeLStr))
            {
                _inputDodgedLeft = true;
                if (_state.GetType() != typeof(PlayerDodge))
                {
                    SetState(PlayerStatePool._instance.GetPlayerDodgeObjState(_stateMachine, _velocity));//new PlayerDodge(this, _inputVector2));
                    _playerStats.Stamina -= 0.125;
                    UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerDodgeSFX);
                }
            }
            if (_rewirdInputPlayer.GetButtonDown(_inputDodgeRStr))
            {
                _inputDodgedLeft = false;
                if (_state.GetType() != typeof(PlayerDodge))
                {
                    SetState(PlayerStatePool._instance.GetPlayerDodgeObjState(_stateMachine, _velocity));//new PlayerDodge(this, _inputVector2));
                    _playerStats.Stamina -= 0.125;
                    UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerDodgeSFX);
                }
            }
            if (_rewirdInputPlayer.GetButtonTimedPressUp(_inputAttackStr, 0.01f))
            {

                if (!_playerCollider.IsNPCTalkCollisionEnabled() && !_playerCollider.SignalNPCTalkCollision())//!IsTalking())
				{
                    if (_inputVector2.y > 0.44f)
                        SetState(PlayerStatePool._instance.GetPlayerUpwardAttackObjState(this, _inputVector2, _transform));//new PlayerUpwardAttack(this, _inputVector2, _transform));//GetPlayerUpwardAttackObjState
                    else
                    {
                        if (_state.GetType() != typeof(PlayerHoldAttack))
                        {
                            if (_inputVector2.y < -0.44f)
                                SetState(PlayerStatePool._instance.GetPlayerDownwardAttackObjState(this, _inputVector2, _transform));//new PlayerDownwardAttack(this, _inputVector2, _transform));
                            else
                                SetState(PlayerStatePool._instance.GetPlayerQuickAttackObjState(this, _inputVector2));//new PlayerQuickAttack(this, _inputVector2));//, _quickAttackIncrement));
                        }
                    }

                    _playerCollider.EnableAttackCollisions();
                    if (_playerCollider.SignalItemPickupCollision()) _playerCollider.EnableItemPickupCollision();
                    //if (_playerCollider.SignalLadderGrabCollision()) _playerCollider.EnableLadderCollision(true);
                }
                else
				{
                    //Initiate NPC Dialogue.
                    if (_playerCollider.SignalNPCTalkCollision()) 
                    {
                        if (!_playerCollider.IsNPCTalkCollisionEnabled()) _playerCollider.EnableNPCTalkCollision(true);
                    }
                }

            }
            if (_rewirdInputPlayer.GetButtonTimedPressUp(_inputKnockBackStr, 0.01f))
			{
                SetState(PlayerStatePool._instance.GetPlayerKnockAttackObjState(this, _inputVector2, _transform));//new PlayerKnockAttack(this, _inputVector2, _transform));
                _playerCollider.EnableAttackCollisions();
                _playerStats.Stamina -= 0.1;
                UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
                
            }
            if (_rewirdInputPlayer.GetButtonDown(_inputDefendStr))
			{
                SetState(PlayerStatePool._instance.GetPlayerDefendObjState(this, _inputVector2));//new PlayerDefend(this, _inputVector2));
			}

            if (_rewirdInputPlayer.GetButtonUp(_inputDefendStr))
			{
                //if (_state.GetType() == typeof(PlayerDefend))
                //SetState(new PlayerIdle(this, _inputVector2));
                SetState(PlayerStatePool._instance.GetPlayerIdleObjState(this, _inputVector2, _playerCollider.IsWaterCollisionEnabled()));
            }
            if (_rewirdInputPlayer.GetButtonTimedPressDown(_inputAttackStr, 0.25f))
			{
                if(SafeToSetHoldAttack())
				{
                    _buttonHeldTimer.BeginTimeRecord();
                    SetState(PlayerStatePool._instance.GetPlayerHoldAttackObjState(this, _inputVector2, _transform));//new PlayerHoldAttack(this, _inputVector2, _transform));
                    _playerStats.Stamina -= 0.15;
                    UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerChargeAttackSFX);
                }



            }
            if (_rewirdInputPlayer.GetButtonTimedPressUp(_inputAttackStr, 0.25f))
			{
                if (_state.GetType() == typeof(PlayerHoldAttack))
                {
                    _buttonHeldTimer.FinishTimeRecord();
                    BattleColliderManager.SetPlayerHeldAttackButtonTime(_buttonHeldTimer.GetTimeRecord());
                    SetState(PlayerStatePool._instance.GetPlayerReleaseAttackObjState(this, _inputVector2, _transform));//new PlayerReleaseAttack(this, _inputVector2, _transform));
                    _playerCollider.EnableAttackCollisions();
                    AudioEventManager.StopPlayerSFX(PlayerSFXID.PlayerChargeAttackSFX);
                    //AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerPowerAttackSFX);
                }
            }
        }
        public void UpdateStateBehaviours()
		{
            _state.IsIdle(ref _animator, ref _playerSprite);

            _state.IsClimb(ref _animator, ref _inputVector2, ref _playerSprite);
            _state.IsGainedEquipment(ref _animator, ref _playerSprite, ref _playerEquipment);
            _state.IsBrokenEquipment(ref _animator, ref _playerSprite, ref _playerEquipment);
            _state.IsExhausted(ref _animator, ref _playerSprite);

            //if (!IsClimbing()) _state.IsMoving(ref _animator, ref _inputVector2, ref _playerSprite, ref _playerCollider);
            _state.IsMoving(ref _animator, ref _inputVector2, ref _playerSprite, ref _playerCollider);
            _state.IsSprinting(ref _animator, ref _inputVector2, ref _playerSprite, ref _playerCollider);
            
            _state.IsJumping(ref _animator, ref _controller2D, ref _inputVector2, ref _playerSprite, _playerCollider.IsWaterCollisionEnabled());
            _state.IsFalling(ref _animator, ref _controller2D, ref _inputVector2, _playerCollider.IsWaterCollisionEnabled());
           
            _state.IsDodging(ref _animator, ref _controller2D, ref _inputVector2, _inputDodgedLeft, ref _playerSprite, ref _playerCollider);
            _state.IsDodged(ref _animator, ref _controller2D, ref _inputVector2);
            
            _state.IsQuickAttack(ref _animator, ref _playerSprite, ref _inputVector2, ref _quickAttackIncrement);
            _state.IsUpwardAttack(ref _animator, ref _playerSprite, ref _inputVector2);
            _state.IsDownwardAttack(ref _animator, ref _playerSprite, ref _inputVector2, ref _controller2D);
            _state.IsKnockAttack(ref _animator, ref _playerSprite, ref _inputVector2);
            _state.IsHoldAttack(ref _animator, ref _playerSprite, ref _inputVector2);
            _state.IsReleaseAttack(ref _animator, ref _playerSprite, ref _inputVector2);
            
            _state.IsDefending(ref _animator, ref _inputVector2);
            
            _state.IsHitByQuickAttack(ref _animator, ref _playerSprite, ref _inputVector2);
            _state.IsHitByReleaseAttack(ref _animator, ref _playerSprite, ref _inputVector2);
            _state.IsHitByKnockAttack(ref _animator, ref _playerSprite, ref _inputVector2);
            _state.IsHitWhileDefending(ref _animator, ref _inputVector2);

            _state.IsDying(ref _animator, ref _playerSprite);
            _state.IsDead(ref _animator, ref _playerSprite);
            _state.IsRevive(ref _animator, ref _playerSprite, ref _transform, ref _playerStats, _playerID);
            _state.UpdateBehaviour(ref _controller2D, ref _animator, ref _state, ref _buttonJumpIncrement, _playerCollider.IsWaterCollisionEnabled());
        }
        public void UpdateCollisions()
		{
            if (!SafeToProcessCollisions()) return;

            _playerCollider.UpdateCollision(ref _state, ref _stateMachine, ref _velocity, _playerID, ref _playerAnimator,
                ref _playerEquipment, ref _playerSprite, ref _playerStats, false);
        }
        private void StoryTellerDialogueInitiated()
		{
            //print("\nStoryTellerDialogueInitiated() reached.");
            _velocity.x = 0f;
            UpdateCollisions();
            //SetState(new PlayerIdle(this, _inputVector2));
            SetState(PlayerStatePool._instance.GetPlayerIdleObjState(this, _inputVector2, _playerCollider.IsWaterCollisionEnabled()));
        }
        private void AttackedByBandit()
		{
            //print("\nPlayer.cs= AttackedByBandit() called!");

            int enemyId = BattleColliderManager.GetRecentCollidedBasicEnemyId();
            int banditFaceDir = BattleColliderManager.GetAssigneBasicEnemyFaceDir(enemyId);
            BasicEnemyBaseState attackingBanditState = BattleColliderManager.GetAssignedBasicEnemyState(enemyId);

            if (IsIgnoreDamage())
                return;


            //BanditStats tempStat = new BanditStats(0,0,0);
            var tempStat = BattleColliderManager.GetAssignedBanditStatus(enemyId);

            //if (tempStat == null) return;

            double banditQuickAttackDamage = tempStat.QuickAttackDamage;
            double banditPowerAttackDamage = tempStat.PowerAttackDamage;
            bool process = false;

            if(process = ProcessQuickAttackFromEnemy(ref attackingBanditState, banditFaceDir, _playerSprite.GetSpriteDirection(), ref _transform))
			{
                if (!_playerStats.IsArmored())
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_BloodHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Health -= banditQuickAttackDamage;
                    AudioEventManager.PlayEnemySFX(EnemySFXID.EnemyHitSFX);//AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerHitSFX);
                }
                else
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_ArmorHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Defence -= banditQuickAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerArmorHitSFX);
                }
                if (process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
            }
            if(process = ProcessPowerAttackFromEnemy(ref attackingBanditState, banditFaceDir, _playerSprite.GetSpriteDirection(), ref _transform))
			{
                if (!_playerStats.IsArmored())
                {
                    _playerStats.Health -= banditPowerAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerPowerAttackSFX);
                }
                else
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_ArmorHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerArmorHitSFX);
                    _playerStats.Defence -= banditPowerAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerPowerAttackSFX);
                }
                if (process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
            }
            //if(process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
        }
        private void AttackedBySkeleton()
        {
            //print("\nPlayer.cs= AttackedByBandit() called!");

            int enemyId = BattleColliderManager.GetRecentCollidedBasicEnemyId();
            int skellyFaceDir = BattleColliderManager.GetAssigneBasicEnemyFaceDir(enemyId);
            BasicEnemyBaseState attackingSkellyState = BattleColliderManager.GetAssignedBasicEnemyState(enemyId);

            if (IsIgnoreDamage())
                return;


            //SkeletonStats tempStat = new SkeletonStats(0, 0, 0);
            var tempStat = BattleColliderManager.GetAssignedSkeletonStatus(enemyId);

            //if (tempStat == null) return;

            double skellyQuickAttackDamage = tempStat.QuickAttackDamage;
            double skellyPowerAttackDamage = tempStat.PowerAttackDamage;
            bool process = false;

            if (process = ProcessQuickAttackFromEnemy(ref attackingSkellyState, skellyFaceDir, _playerSprite.GetSpriteDirection(), ref _transform))
            {
                if (!_playerStats.IsArmored())
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_BloodHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Health -= skellyQuickAttackDamage;
                    AudioEventManager.PlayEnemySFX(EnemySFXID.EnemyHitSFX);//AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerHitSFX);
                }
                else
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_ArmorHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Defence -= skellyQuickAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerArmorHitSFX);
                }
                if (process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
            }
            if (process = ProcessPowerAttackFromEnemy(ref attackingSkellyState, skellyFaceDir, _playerSprite.GetSpriteDirection(), ref _transform))
            {
                if (!_playerStats.IsArmored())
                {
                    _playerStats.Health -= skellyPowerAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerPowerAttackSFX);
                }
                else
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_ArmorHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerArmorHitSFX);
                    _playerStats.Defence -= skellyPowerAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerPowerAttackSFX);
                }
                if (process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
            }
            //if(process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
        }
        private void AttackedByGoblin()
        {
            //print("\nPlayer.cs= AttackedByBandit() called!");

            int enemyId = BattleColliderManager.GetRecentCollidedBasicEnemyId();
            int goblinFaceDir = BattleColliderManager.GetAssigneBasicEnemyFaceDir(enemyId);
            BasicEnemyBaseState attackingGoblinState = BattleColliderManager.GetAssignedBasicEnemyState(enemyId);

            if (IsIgnoreDamage())
                return;


            //GoblinStats tempStat = new GoblinStats(0, 0, 0);
            var tempStat = BattleColliderManager.GetAssignedGoblinStatus(enemyId);

            //if (tempStat == null) return;

            double goblinQuickAttackDamage = tempStat.QuickAttackDamage;
            double goblinPowerAttackDamage = tempStat.PowerAttackDamage;
            bool process = false;

            if (process = ProcessQuickAttackFromEnemy(ref attackingGoblinState, goblinFaceDir, _playerSprite.GetSpriteDirection(), ref _transform))
            {
                if (!_playerStats.IsArmored())
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_BloodHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Health -= goblinQuickAttackDamage;
                    AudioEventManager.PlayEnemySFX(EnemySFXID.EnemyHitSFX);//AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerHitSFX);
                }
                else
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_ArmorHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Defence -= goblinQuickAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerArmorHitSFX);
                }
                if (process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
            }
            if (process = ProcessPowerAttackFromEnemy(ref attackingGoblinState, goblinFaceDir, _playerSprite.GetSpriteDirection(), ref _transform))
            {
                if (!_playerStats.IsArmored())
                {
                    _playerStats.Health -= goblinPowerAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerPowerAttackSFX);
                }
                else
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_ArmorHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerArmorHitSFX);
                    _playerStats.Defence -= goblinPowerAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerPowerAttackSFX);
                }
                if (process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
            }
            //if(process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
        }
        private void AttackedByTroll()
		{

            int enemyId = BattleColliderManager.GetRecentCollidedBasicEnemyId();
            int trollFaceDir = BattleColliderManager.GetAssigneBasicEnemyFaceDir(enemyId);
            BasicEnemyBaseState attackingTrollState = BattleColliderManager.GetAssignedBasicEnemyState(enemyId);


            if (IsIgnoreDamage())
                return;

            

            var tempStat = BattleColliderManager.GetAssignedTrollStatus(enemyId);

            double trollGroundSlamAttackDamage = tempStat.GroundSlamDamage;
            bool process = false;

            if (process = ProcessGroundSlamFromEnemy(ref attackingTrollState, trollFaceDir, _playerSprite.GetSpriteDirection(), ref _transform))
			{
                if (!_playerStats.IsArmored())
				{
                    _playerStats.Health -= trollGroundSlamAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerPowerAttackSFX);
                }
                else
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_ArmorHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerArmorHitSFX);
                    _playerStats.Defence -= trollGroundSlamAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerPowerAttackSFX);
                }
                if (process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
            }

                
           
        }
        private void AttackedByFireball()
		{
            if (IsIgnoreDamage())
                return;

            double fireballAttackDamage = 0.066;// 0.1;//0.0025;
            bool process = false;

            ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_FireHitFX, _transform, 0, _playerSprite.GetSpriteDirection());
            ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_FireHitFX, _transform, 0, _playerSprite.GetSpriteDirection());

            if (process = ProcessFireballAttack(_playerSprite.GetSpriteDirection(), ref _transform))
            {
                if (!_playerStats.IsArmored())
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_BloodHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Health -= fireballAttackDamage;
                    AudioEventManager.PlayEnemySFX(EnemySFXID.EnemyHitSFX);//AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerHitSFX);
                }
                else
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_ArmorHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Defence -= fireballAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerArmorHitSFX);
                }
            }
            if (process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
            
        }
        private void AttackedByArrow()
		{
            if (IsIgnoreDamage())
                return;

            double arrowAttackDamage = 0.044;// 0.1;//0.0025;
            bool process = false;

            if(process = ProcessArrowAttack(_playerSprite.GetSpriteDirection(),ref _transform))
			{
                if (!_playerStats.IsArmored())
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_BloodHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Health -= arrowAttackDamage;
                    AudioEventManager.PlayEnemySFX(EnemySFXID.EnemyHitSFX);//AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerHitSFX);
                }
                else
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_ArmorHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Defence -= arrowAttackDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerArmorHitSFX);
                }
            }
            if (process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
        }
        private void AttackedByBatSkully()
		{
            if (IsIgnoreDamage())
                return;

            double batSkullyDamage = 0.0025;// 0.1;//0.0025;
            bool process = false;

            ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_FireHitFX, _transform, 0, _playerSprite.GetSpriteDirection());
            ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_FireHitFX, _transform, 0, _playerSprite.GetSpriteDirection());

            if (process = ProcessFireballAttack(_playerSprite.GetSpriteDirection(), ref _transform))
            {
                if (!_playerStats.IsArmored())
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_BloodHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Health -= batSkullyDamage;
                    AudioEventManager.PlayEnemySFX(EnemySFXID.EnemyHitSFX);//AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerHitSFX);
                }
                else
                {
                    ObjectPooler._instance.InstantiateForPlayer(PrefabID.Prefab_ArmorHitFX, _transform, _playerID, _playerSprite.GetSpriteDirection());
                    _playerStats.Defence -= batSkullyDamage;
                    AudioEventManager.PlayPlayerSFX(PlayerSFXID.PlayerArmorHitSFX);
                }
            }
            if (process) UIPlayerManager.TriggerEvent("ReportUIPlayerStatEvent", ref _playerStats, _playerID);
        }
        private void UpdateStats() //=> _playerStats.UpdateStatus();
		{
            bool SetDeath = SafeToSetDying(); //if(!SafeToSetDying()) return;
            _playerStats.UpdateStatus(ref _stateMachine, ref _state, ref _transform, ref _playerAnimator, ref _playerEquipment, ref _playerStats,
                ref _playerIndicatorAnimator, ref _velocity, _playerID, SetDeath);
        }
        private void CampsiteReachedEvent()
		{
            //print("\nCampsiteReachedEvent() Trigger from Player.cs - do work here.");
		}

        private void OnDrawGizmosSelected()
        {
            for (int i = 0; i < _attackPoints.Length; i++)
            {
                if (_attackPoints[i].position == null)
                    return;
            }


            Gizmos.color = Color.red;
            Gizmos.DrawWireSphere(_attackPoints[0].position, 1.2f);
            Gizmos.DrawWireSphere(_attackPoints[1].position, 1.6f);
            Gizmos.color = Color.yellow;
            Gizmos.DrawWireSphere(_attackPoints[2].position, 1.3f);
            Gizmos.DrawWireSphere(_attackPoints[3].position, 1.0f);

            Gizmos.color = Color.white;
            Gizmos.DrawWireSphere(this.gameObject.transform.position, 12.0f);
        }
    }
}