// Player attacking trainer.
        public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = false)
        {
            if (attacker == null) return 0;

            if (_currentAttacker != null && _currentAttacker != attacker)
            {
                OutputAverage();
                ResetStats();
            }
            damage += attacker.AttackBonus;
            _currentAttacker = attacker;
            _hitCount++;
            _totalDamage += damage;
            _lastAttackTime = Envir.Time;

            switch (type)
            {
                case DefenceType.ACAgility:
                    attacker.ReceiveChat(damage + " Physical Agility Damage inflicted on the trainer.", ChatType.Trainer);
                    break;
                case DefenceType.AC:
                    attacker.ReceiveChat(damage + " Physical Damage inflicted on the trainer.", ChatType.Trainer);
                    break;
                case DefenceType.MACAgility:
                    attacker.ReceiveChat(damage + " Magic Agility Damage inflicted on the trainer.", ChatType.Trainer);
                    break;
                case DefenceType.MAC:
                    attacker.ReceiveChat(damage + " Magic Damage inflicted on the trainer.", ChatType.Trainer);
                    break;
                case DefenceType.Agility:
                    attacker.ReceiveChat(damage + " Agility Damage inflicted on the trainer.", ChatType.Trainer);
                    break;
            }
            return 1;
        }

    public PlayerObject GetTarget(bool isRight)
    {
        var sortedList = new SortedList<float, PlayerObject>();

        foreach (PlayerObject po in _targetList)
        {
            sortedList.Add(po._playerPrefab.transform.position.x, po);
        }

        float currentTargetX = _currentTarget._playerPrefab.transform.position.x;

        foreach (var kpo in sortedList)
        {
            PlayerObject po = kpo.Value;
            if (isRight)
            {
                if (currentTargetX < kpo.Key)
                {
                    _currentTarget = po;
                    break;
                }
            }
            else
            {
                if (currentTargetX >= kpo.Key)
                {
                    _currentTarget = po;
                    break;
                }
            }
        }

        return _currentTarget;
    }

 /// <summary>
 ///     Initializes a new instance of the <see cref="SelectPlayerObjectEventArgs" /> class.
 /// </summary>
 /// <param name="player">The player.</param>
 /// <param name="object">The player object.</param>
 /// <param name="modelid">The modelid.</param>
 /// <param name="position">The position.</param>
 public SelectPlayerObjectEventArgs(BasePlayer player, PlayerObject @object, int modelid, Vector3 position)
     : base(position)
 {
     Player = player;
     Object = @object;
     ModelId = modelid;
 }

        public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
        {
            int currentMoveDistance = 0;

            Point target = Functions.PointMove(CurrentLocation, attacker.Direction, _ballMoveDistance);

            MirDirection dir = Functions.DirectionFromPoint(CurrentLocation, target);

            while (currentMoveDistance < _ballMoveDistance)
            {
                Point location = Functions.PointMove(CurrentLocation, dir, 1);

                if (location.X < 0 || location.Y < 0 || location.X >= CurrentMap.Width || location.Y >= CurrentMap.Height) break;

                currentMoveDistance++;

                if (!CurrentMap.GetCell(location).Valid)
                {
                    dir = Functions.ReverseDirection(dir);
                    continue;
                }

                Walk(dir);
                MoveTime = 0;
                ActionTime = 0;
            }

            return 0;
        }

 public void procBonusStart(PlayerObject player)
 {
     if(activeBonus != null)
     {
         activeBonus.start(player);
     }
 }

    public bool CheckSkillConditions(PlayerObject origin, PlayerObject target)
    {
        // Check target

        var targetType = TargetType.None;
        Team teamOrigin = origin._playerPrefab.GetComponent<PlayerState>()._team;
        Team teamTarget = target._playerPrefab.GetComponent<PlayerState>()._team;

        if (origin == target)
        {
            targetType = TargetType.Myself;
            return false;
        } /*
        else if ((teamOrigin == Team.Blue && teamTarget == Team.Blue) ||
                 (teamOrigin == Team.Red && teamTarget == Team.Red))
        {
            targetType = TargetType.Ally;
        }
        else
        {
            targetType = TargetType.Enemy;
        }

        if (_targetTypes.Find(t => t != null && t == targetType) == TargetType.None)
        {
            return false;
        }
        */
        // Check range
        if (_range <= 0)
        {
            return true;
        }

        float distance = Vector3.Distance(origin._playerPrefab.position, target._playerPrefab.position);
        Debug.Log("Distance: " + distance + "max range: " + _range);
        if (distance > _range)
        {
            return false;
        }

        // Checks if the source  is facing the target (Expensive)
        if (_needToBeInFront)
        {
            Vector3 heading = origin._playerPrefab.transform.position - target._playerPrefab.transform.position;
            float dot = Vector3.Dot(heading, origin._playerPrefab.transform.forward);

            if (dot < 0.0f)
            {
                Debug.Log("in front");
            }
            else
            {
                Debug.Log("Not in front");
                return false;
            }
        }

        return true;
    }

 public void AddEffectsForPlayer(PlayerObject source, PlayerObject target, List<Effect> effect)
 {
     foreach (Effect e in effect)
     {
         DynamicEffect de = new DynamicEffect(e, source, target);
         _effectDictionary[target].Add(de);
     }
 }

        public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
        {
            CheckDirection();

            if (!Conquest.WarIsOn || attacker.MyGuild != null && Conquest.Owner == attacker.MyGuild.Guildindex) damage = 0;

            return base.Attacked(attacker, damage, type, damageWeapon);
        }

 /// <summary>
 ///     Initializes a new instance of the <see cref="EditPlayerObjectEventArgs" /> class.
 /// </summary>
 /// <param name="player">The player.</param>
 /// <param name="object">The global object.</param>
 /// <param name="response">The response.</param>
 /// <param name="position">The position.</param>
 /// <param name="rotation">The rotation.</param>
 public EditPlayerObjectEventArgs(GtaPlayer player, PlayerObject @object, EditObjectResponse response,
     Vector3 position, Vector3 rotation)
     : base(position)
 {
     Player = player;
     Object = @object;
     EditObjectResponse = response;
     Rotation = rotation;
 }

 public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
 {
     if (ChildRock) ParentRock.FirstAttack = false;
     if (!ChildRock && FirstAttack == true)
     {
         Die();
         return 0;
     }
     return base.Attacked(attacker, damage, type, damageWeapon);
 }

    public void procBonusEnd(PlayerObject player)
    {
        if(activeBonus != null)
        {
            activeBonus.end(player);

            if(activeBonus.isEnd())
                activeBonus = null;
        }
    }

 void Start()
 {
     _parent = this.transform.parent.gameObject;
     _parentPlayerObj = _parent.GetComponent<PlayerObject>();
     _hp = this.transform.Find("Panel").Find("slider_hp").GetComponent<Slider>();
     _time = this.transform.Find("Panel").Find("slider_time").GetComponent<Slider>();
     _name = this.transform.Find("Panel").Find("txt_enemyname").GetComponent<Text>();
     _icon = this.transform.Find("Panel").Find("img_icon").GetComponent<RawImage>();
     if (_name != null) _name.text = _parent.name;
     if (_time != null) _time.maxValue = _parentPlayerObj.waitTime;
 }

 /// <summary>
 /// Registers a player entity with this player mover.
 /// </summary>
 /// <param name="player">The player to register with this mover.</param>
 public void RegisterPlayer(PlayerObject player)
 {
     if(OnRegisterPlayer(player))
     {
         m_registeredPlayers.Add(player);
         if (player.Player.isLocal)
             OnRegistered();
         else
             photonView.RPC(nameof(_rpcOnRegistered), player.Player);
     }
 }

        public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = true)
        {
            MirDirection newDirection = (MirDirection)(3 - GetDamageLevel());

            if (newDirection != Direction)
            {
                Direction = newDirection;
                Broadcast(new S.ObjectTurn { ObjectID = ObjectID, Direction = Direction, Location = CurrentLocation });
            }

            return base.Attacked(attacker, damage, type, damageWeapon);
        }

    void Awake()
    {
        // Setting up the references.
        settings = GameObject.Find("System");
        player = settings.GetComponent<SystemDB>().player;
        playerObject = GameObject.FindGameObjectWithTag("Player").GetComponent<PlayerObject>();

        playerMovement = GetComponent<PlayerMovement>();
        lastPlayerSighting = GameObject.FindGameObjectWithTag("GameController").GetComponent<LastPlayerSighting>();
        health=player.maxHP;
        player.HP = health;
    }

        public override bool Harvest(PlayerObject player)
        {
            if (RemainingSkinCount == 0)
            {
                for (int i = _drops.Count - 1; i >= 0; i--)
                    if (player.CanGainItem(_drops[i]))
                    {
                        player.GainItem(_drops[i]);
                        _drops.RemoveAt(i);
                    }

                if (_drops.Count == 0)
                {
                    Harvested = true;
                    _drops = null;
                    Broadcast(new S.ObjectHarvested { ObjectID = ObjectID, Direction = Direction, Location = CurrentLocation });
                }
                else player.ReceiveChat("You cannot carry anymore.", ChatType.System);

                return true;
            }

            if (--RemainingSkinCount > 0) return true;

            _drops = new List<UserItem>();

            for (int i = 0; i < Info.Drops.Count; i++)
            {
                DropInfo drop = Info.Drops[i];

                int rate = (int)(drop.Chance / Settings.DropRate); if (rate < 1) rate = 1;
                if (drop.Gold > 0 || Envir.Random.Next(rate) != 0) continue;

                UserItem item = Envir.CreateDropItem(drop.Item);
                if (item == null) continue;
                if (item.Info.Type == ItemType.Meat)
                    item.CurrentDura = (ushort)Math.Max(0, item.CurrentDura + Quality);

                _drops.Add(item);
            }

            if (_drops.Count == 0)
            {
                player.ReceiveChat("Nothing was found.", ChatType.System);
                Harvested = true;
                _drops = null;
                Broadcast(new S.ObjectHarvested { ObjectID = ObjectID, Direction = Direction, Location = CurrentLocation });
            }

            return true;
        }

 void UpdateHumanoid(PlayerObject _p)
 {
     if (_p.state == PlayerObject.PlayerState.Dead) return;
     if (_p._target != null) _p._lookAt = _p._target.transform.position;
     this.transform.LookAt(_p._lookAt);
     switch (_p.type)
     {
        case PlayerObject.PlayerType.EnemyRootedAI:
             _p.RootedMovement();
         break;
         case PlayerObject.PlayerType.EnemyAI:
         _p.AiMovement();
         break;
     }
 }

    public override void Start()
    {
        base.Start();

        questions = new QuestionDictionary();
        questions.loadList("plant");
        print(questions.QuestionList.Count);
        _questionList = questions.QuestionList;
        _pObject = FnGlobal.GetPlayer<PlayerObject>();
        if (_pObject.type == PlayerObject.PlayerType.Player)
        {
            AnswerResult = Instantiate(AnswerResult) as GameObject;
            AnswerResult.GetComponent<CanvasGroup>().alpha = 0;
            AnswerResult.SetActive(false);
        }
        _victoryCanvas = Instantiate(_victoryCanvas) as GameObject;
        _victoryCanvas.SetActive(false);
    }

        // Player attacking trainer.
        public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = false)
        {
            if (attacker == null) return 0;

            if (_currentAttacker != null && _currentAttacker != attacker)
            {
                OutputAverage();
                ResetStats();
            }

            damage += attacker.AttackBonus;
            int armour = 0;
            //deal with trainers defense
            switch (type)
            {
                case DefenceType.AC:
                case DefenceType.ACAgility:
                    armour = GetAttackPower(MinAC, MaxAC);
                    break;
                case DefenceType.MAC:
                case DefenceType.MACAgility:
                    armour = GetAttackPower(MinMAC, MaxMAC);
                    break;
            }
            if (armour >= damage)
            {
                BroadcastDamageIndicator(DamageType.Miss);
                return 0;
            }
            damage -= armour;

            if (_currentAttacker == null)
                _StartTime = Envir.Time;
            _currentAttacker = attacker;
            _hitCount++;
            _totalDamage += damage;
            _lastAttackTime = Envir.Time;
            
            ReportDamage(damage, type, false);
            return 1;
        }

 // Player attacking trainer.
 public override int Attacked(PlayerObject attacker, int damage, DefenceType type = DefenceType.ACAgility, bool damageWeapon = false)
 {
     switch (type)
     {
         case DefenceType.ACAgility:
             attacker.ReceiveChat(damage + " AC Agility Damage inflicted on the trainer.", ChatType.Trainer);
             break;
         case DefenceType.AC:
             attacker.ReceiveChat(damage + " AC Damage inflicted on the trainer.", ChatType.Trainer);
             break;
         case DefenceType.MACAgility:
             attacker.ReceiveChat(damage + " MAC Agility Damage inflicted on the trainer.", ChatType.Trainer);
             break;
         case DefenceType.MAC:
             attacker.ReceiveChat(damage + " MAC Damage inflicted on the trainer.", ChatType.Trainer);
             break;
         case DefenceType.Agility:
             attacker.ReceiveChat(damage + " Agility Damage inflicted on the trainer.", ChatType.Trainer);
             break;
     }
     return 1;
 }