public void StartThreadToFindTilesInRange(Combatant combatant, MapManager map)
 {
     this.combatant = combatant;
     this.map = map;
     thread = new System.Threading.Thread(FindTilesInRange);
     thread.Start();
 }

    public void AddCombatant(Combatant combatant)
    {
        List<SkillButton> buttons;
        _buttons.TryGetValue(combatant, out buttons);

        if (buttons == null) {
            buttons = new List<SkillButton>();

            foreach (ISkill skill in combatant.Skills) {
                SkillButton newButton = CreateButton(skill);
                buttons.Add(newButton);
            }

            _buttons[combatant] = buttons;
        } else {
            foreach (ISkill skill in combatant.Skills.Except(buttons.Select(b => b.Skill))) {
                SkillButton newButton = CreateButton(skill);
                buttons.Add(newButton);
            }
        }

        if (_combatant == null) {
            _combatant = combatant;
            _page = SetPage(0);
        }
    }

    double CalcDamage(Combatant attacker, Combatant defender, Attack attack)
    {
        System.Random gen = new System.Random();
        double crit = 1.0;
        double attackPower = 0.0;
        double defensePower = 0.0;

        //does hit
        if(gen.NextDouble() * 100 > (attack.accuracy + attacker.perception))
        {
            return 0.0;
        }
        //is crit

        if(gen.NextDouble()*100 < (0.05+0.02 * attacker.luck))
        {
            crit = 1.5;
        }
        //do damage
        attackPower = attack.power * attacker.strength;
        defensePower = defender.defense + defender.getArmorValue();

        //return

        return (attackPower / defensePower) * crit;
    }

 public ThreadedCalculateAIOrder(Combatant combatant, MapManager map)
 {
     this.combatant = combatant;
     this.map = map;
     thread = new System.Threading.Thread(Calculate);
     thread.Start();
 }

    private void OnSkillActivated(Combatant combatant, ISkill skill)
    {
        // Unbind delegates from old skill
        if (_ranged != null) {
            _ranged.TargetChanged -= OnTargetChanged;
        } else if (_directional != null) {
            _directional.DirectionChanged -= OnDirectionChanged;
        }

        // Figure out origin from ActionQueue
        PawnAction lastAction = _combatant.LastAction;
        _origin = (lastAction == null) ? _combatant.Position : lastAction.PostRunPosition;

        // Figure out what kind of skill it is
        _ranged = skill as RangedSkill;
        _directional = skill as DirectionalSkill;

        // Bind delegates to new skill
        if (_ranged != null) {
            _ranged.TargetChanged += OnTargetChanged;
            OnTargetChanged(_ranged.Target);
        } else if (_directional != null) {
            _directional.DirectionChanged += OnDirectionChanged;
            OnDirectionChanged(_directional.Direction);
        }
    }

    /*
    ============================================================================
    Condition functions
    ============================================================================
    */
    public void ApplyCondition(Combatant c)
    {
        if(DataHolder.BattleSystem().IsActiveTime())
        {
            c.timeBar = this.timebar;
            if(c.timeBar > DataHolder.BattleSystem().maxTimebar)
            {
                c.timeBar = DataHolder.BattleSystem().maxTimebar;
            }
        }

        for(int i=0; i<this.setStatus.Length; i++)
        {
            if(this.setStatus[i])
            {
                c.status[i].SetValue(this.status[i], true, false, false);
            }
        }

        for(int i=0; i<this.effect.Length; i++)
        {
            if(SkillEffect.ADD.Equals(this.effect[i]))
            {
                c.AddEffect(i, c);
            }
            else if(SkillEffect.REMOVE.Equals(this.effect[i]))
            {
                c.RemoveEffect(i);
            }
        }
    }

        public void StationaryMelee()
        {
            Board board = new Board(BoardCommon.GRID_12X8);
            Combatant attacker = new Combatant("Attacker", board, new Point(5, 4));
            Combatant defender = new Combatant("Defender", board, new Point(7, 4));
            board.AddPawn(attacker);
            board.AddPawn(defender);

            attacker.Health = 10;
            defender.Health = 10;

            attacker.BaseStats = new Stats() {
                Attack = 10,
                Stamina = 10
            };

            MeleeAttackSkill attack = new MeleeAttackSkill(attacker, new Point[] { Point.Right, 2 * Point.Right }) {
                ActionPoints = 3
            };
            attack.SetDirection(CardinalDirection.East);

            attacker.AddSkill(attack);
            attack.Fire();

            board.BeginTurn();
            Assert.AreEqual(10, attacker.ActionPoints);

            board.Turn();
            Assert.AreEqual(0, defender.Health);
            Assert.AreEqual(7, attacker.ActionPoints);
        }

 private void OnSkillDeactivated(Combatant combatant, ISkill skill)
 {
     _gridField.ClearPoints();
     _gridField.RebuildMesh();
     _ranged = null;
     _directional = null;
 }

        /// <summary>
        /// Contruct a new MeleeAttackSkill.
        /// </summary>
        /// <param name="attacker">Reference to Attacking Combatant</param>
        /// <param name="areaOfEffect">
        /// Collection of Point offsets indicating which tiles around the attacker are affected by the attack.
        /// These offsets are rotated based on this skill's Direction attribute, and are defined based on the
        /// attacker facing east.
        /// </param>
        public MeleeAttackSkill(Combatant attacker, IEnumerable<Point> areaOfEffect = null)
            : base(attacker, "Melee Attack", "Attack an adjacent space")
        {
            if (areaOfEffect == null) {
                _areaOfEffect = new List<Point>();
            } else {
                _areaOfEffect = new List<Point>(areaOfEffect);
            }

            for (CardinalDirection d = CardinalDirection.East; d < CardinalDirection.Count; d++) {
                _transforms[d] = new Point[_areaOfEffect.Count];
            }

            for (int i = 0; i < _areaOfEffect.Count; i++) {
                Point east = _areaOfEffect[i];
                Point south = new Point(-east.Y, east.X);
                Point west = new Point(-east.X, -east.Y);
                Point north = new Point(east.Y, -east.X);

                _transforms[CardinalDirection.East][i] = east;
                _transforms[CardinalDirection.South][i] = south;
                _transforms[CardinalDirection.West][i] = west;
                _transforms[CardinalDirection.North][i] = north;

                _fullAreaOfEffect.Add(east);
                _fullAreaOfEffect.Add(south);
                _fullAreaOfEffect.Add(west);
                _fullAreaOfEffect.Add(north);
            }
        }

 public MoveAction(Combatant owner, Point start, Point end, bool isContinuous)
     : base(owner)
 {
     _start = start;
     _end = end;
     _isContinuous = isContinuous;
 }

 public SquadUnit(Combatant unit)
 {
     Unit = unit;
     Goal = new StateOffset();
     IsManual = true;
     Planner = new Planner(StateOffset.Heuristic);
 }

    public void SetCombatant(Combatant combatant)
    {
        this.combatant = combatant;

        leftPane = CharacterPane.FindLeftPane();
        EnablePane();
        CreateBattleOrder();
    }

 public BattleAction(AttackSelection t, Combatant u, int tID, int id, int ul)
 {
     this.type = t;
     this.user = u;
     this.targetID = tID;
     this.useID = id;
     this.useLevel = ul;
 }

 public CharacterController(Combatant owner)
 {
     _owner = owner;
     _approachDecision = new Decision.ApproachMeleeRange(_owner);
     _planner.AddDecision(_approachDecision);
     _attackDecision = new Decision.AttackWithMelee(_owner);
     _planner.AddDecision(_attackDecision);
 }

    public void Initialize(Combatant combatant, BoardGridField gridField)
    {
        _combatant = combatant;
        _combatant.SkillActivated += OnSkillActivated;
        _combatant.SkillDeactivated += OnSkillDeactivated;

        _gridField = gridField;
    }

    public void SetCombatant(Combatant combatant)
    {
        Debug.Log("setting combant -" + combatant + "-");
        this.combatant = combatant;

        leftPane = CharacterPane.FindLeftPane();
        EnablePane();
    }

 public override Queue<Action> GetActions(Combatant me, List<Combatant> allies, List<Combatant> enemies)
 {
     Queue<Action> actions = new Queue<Action>();
     actions.Enqueue(new ActionInfo(me.combatantName + " uses Taunt!"));
     actions.Enqueue(new ActionBuff(me,"Taunt", 1));
     actions.Enqueue(new ActionPauseForFrames(60));
     actions.Enqueue(new ActionHideInfo());
     return actions;
 }

 public void pickUp(Combatant currentCombatant)
 {
     this.currentCombatant = currentCombatant;
     transform.rotation = currentCombatant.transform.rotation;
     rb.isKinematic = true;
     collider.enabled = false;
     pickedUp = true;
     onPickUp();
 }

    public void PopulateOptions(Combatant combatant)
    {
        //options = combatant.Options;
        string message = string.Join("\n", options.ToArray());
        headerText.text = combatant.gameObject.name;
        optionsText.text = message;

        currentSelection = options [0];
    }

    //Combatant player;
    //Combatant enemy;

    public void StartCombat(Combatant player, Combatant enemy)
    {
        /*
        this.player = player;
        this.enemy = enemy;
        player.Initialize();
        enemy.Initialize();
        */
    }