public override void Run(Combat.Character character)
        {
            Int32 spritepriority = EvaluationHelper.AsInt32(character, Priority, 0);
            spritepriority = Misc.Clamp(spritepriority, -5, 5);

            character.DrawOrder = spritepriority;
        }

        public override void Run(Combat.Character character)
        {
            Int32 time = EvaluationHelper.AsInt32(character, Time, 1);
            Int32 target_id = EvaluationHelper.AsInt32(character, TargetId, Int32.MinValue);
            Vector2 offset = EvaluationHelper.AsVector2(character, Position, new Vector2(0, 0));

            foreach (Combat.Character target in character.GetTargets(target_id))
            {
                switch (BindPosition)
                {
                    case BindToTargetPostion.Mid:
                        offset += target.BasePlayer.Constants.Midposition;
                        break;

                    case BindToTargetPostion.Head:
                        offset += target.BasePlayer.Constants.Headposition;
                        break;

                    case BindToTargetPostion.None:
                    case BindToTargetPostion.Foot:
                    default:
                        break;
                }

                character.Bind.Set(target, offset, time, 0, false);
                break;
            }
        }

 public override void Run(Combat.Character character)
 {
     character.OffensiveInfo.MoveContact = 0;
     character.OffensiveInfo.MoveGuarded = 0;
     character.OffensiveInfo.MoveHit = 0;
     character.OffensiveInfo.MoveReversed = 0;
 }

        public override void Run(Combat.Character character)
        {
            Int32? start = EvaluationHelper.AsInt32(character, StartRange, null);
            Int32? end = EvaluationHelper.AsInt32(character, EndRange, null);

            if (IntNumber != null)
            {
                Int32? value = EvaluationHelper.AsInt32(character, IntNumber, null);
                if (value != null)
                {
                    for (Int32 i = 0; i != character.Variables.IntegerVariables.Count; ++i)
                    {
                        if (i < start || i > end) continue;
                        character.Variables.SetInteger(i, false, value.Value);
                    }
                }
            }

            if (FloatNumber != null)
            {
                Single? value = EvaluationHelper.AsSingle(character, FloatNumber, null);
                if (value != null)
                {
                    for (Int32 i = 0; i != character.Variables.FloatVariables.Count; ++i)
                    {
                        if (i < start || i > end) continue;
                        character.Variables.SetFloat(i, false, value.Value);
                    }
                }
            }
        }

        public override void Run(Combat.Character character)
        {
            Single x = EvaluationHelper.AsSingle(character, X, 0);
            Single y = EvaluationHelper.AsSingle(character, Y, 0);

            character.Move(new Vector2(x, y));
        }

		public override void Draw(Combat.PaletteFx palettefx)
		{
			Point tilestart;
			Point tileend;
			GetTileLength(Sprite.Size, out tilestart, out tileend);

			Video.DrawState drawstate = SpriteManager.DrawState;
			drawstate.Reset();
			drawstate.Blending = Transparency;
			drawstate.ScissorRectangle = DrawRect;
			drawstate.Set(Sprite);

			for (Int32 y = tilestart.Y; y != tileend.Y; ++y)
			{
				for (Int32 x = tilestart.X; x != tileend.X; ++x)
				{
					Vector2 adjustment = (Vector2)(Sprite.Size + TilingSpacing) * new Vector2(x, y);
					Vector2 location = CurrentLocation + adjustment;

					drawstate.AddData(location, null);
				}
			}

			if (palettefx != null) palettefx.SetShader(drawstate.ShaderParameters);

			drawstate.Use();
		}

        public Questor()
        {
            _lastPulse = DateTime.MinValue;

            _random = new Random();

            _salvage = new Salvage();
            _defense = new Defense();
            _combat = new Combat();
            _traveler = new Traveler();
            _unloadLoot = new UnloadLoot();
            _agentInteraction = new AgentInteraction();
            _arm = new Arm();
            _missionController = new MissionController();
            _drones = new Drones();
            _panic = new Panic();
            _storyline = new Storyline();

            Settings.Instance.SettingsLoaded += SettingsLoaded;

            // State fixed on ExecuteMission
            State = QuestorState.Idle;

            _directEve = new DirectEve();
            Cache.Instance.DirectEve = _directEve;

            _directEve.OnFrame += OnFrame;
        }

 // Use this for initialization
 public void Init()
 {
     player_combatData = GameObject.Find("player").GetComponent<Combat>();
     health = playerHealth.GetComponent<Slider>();
     mana = playerMana.GetComponent<Slider>();
     init = true;
 }

        public Boolean Trigger(Combat.Character character)
        {
            if (character == null) throw new ArgumentNullException("character");

            foreach (var trigger in m_triggers)
            {
                Boolean ok = true;
                foreach (Evaluation.Expression exp in trigger.Value)
                {
                    if(exp.EvaluateFirst(character).BooleanValue == false)
                    {
                        ok = false;
                        break;
                    }
                }

                if (ok == true)
                {
                    if (trigger.Key != 0) return true;
                }
                else
                {
                    if (trigger.Key == 0) return false;
                }
            }

            return false;
        }

        public override void Run(Combat.Character character)
        {
            Single x = EvaluationHelper.AsSingle(character, X, 0);
            Single y = EvaluationHelper.AsSingle(character, Y, 0);

            character.CurrentVelocity += new Vector2(x, y);
        }

        public override void Run(Combat.Character character)
        {
            Int32 explod_id = EvaluationHelper.AsInt32(character, Id, Int32.MinValue);
            Int32 time = EvaluationHelper.AsInt32(character, Time, 1);

            foreach (Combat.Explod explod in character.GetExplods(explod_id)) explod.Data.BindTime = time;
        }

        public Storyline()
        {
            _combat = new Combat();
            _traveler = new Traveler();
            _agentInteraction = new AgentInteraction();

            _agentBlacklist = new List<long>();

            _storylines = new Dictionary<string, IStoryline>();
            //_storylines.Add("__", new GenericCombatStoryline());
            //_storylines.Add("Materials For War Preparation", new MaterialsForWarPreparation());
            _storylines.Add("Shipyard Theft", new GenericCombatStoryline());
            _storylines.Add("Evolution", new GenericCombatStoryline());
            _storylines.Add("Record Cleaning", new GenericCombatStoryline());
            _storylines.Add("Covering Your Tracks", new GenericCombatStoryline());
            _storylines.Add("Crowd Control", new GenericCombatStoryline());
            _storylines.Add("A Force to Be Reckoned With", new GenericCombatStoryline());
            _storylines.Add("Kidnappers Strike - Ambush In The Dark (1 of 10)", new GenericCombatStoryline());
            _storylines.Add("Kidnappers Strike - The Kidnapping (3 of 10)", new GenericCombatStoryline());
            _storylines.Add("Kidnappers Strike - Incriminating Evidence (5 of 10)", new GenericCombatStoryline());
            _storylines.Add("Kidnappers Strike - The Secret Meeting (7 of 10)", new GenericCombatStoryline());
            _storylines.Add("Kidnappers Strike - Defend the Civilian Convoy (8 of 10)", new GenericCombatStoryline());
            _storylines.Add("Kidnappers Strike - Retrieve the Prisoners (9 of 10)", new GenericCombatStoryline());
            _storylines.Add("Kidnappers Strike - The Final Battle (10 of 10)", new GenericCombatStoryline());
            _storylines.Add("Whispers in the Dark - First Contact (1 of 4)", new GenericCombatStoryline());
            _storylines.Add("Whispers in the Dark - Lay and Pray (2 of 4)", new GenericCombatStoryline());
            _storylines.Add("Whispers in the Dark - The Outpost (4 of 4)", new GenericCombatStoryline());
            _storylines.Add("Transaction Data Delivery", new TransactionDataDelivery());
            _storylines.Add("Innocents in the Crossfire", new TransactionDataDelivery());
        }

    public override void init()
    {
        combatData = gameObject.GetComponent<Combat>();
        movement = gameObject.GetComponent<Navigation>();

        ai = GetComponent<HasObjectivePath>();
    }

    public void changeTarget()
    {
        if (player.target == null) return;

        player_target.SetActive(true);

        target = player.target.GetComponent<Combat>();

        if(TeamLogic.areAllies(target.gameObject, player.gameObject))
        {
            targetHealth.color = new Color(0, 255, 0);
        }
        else
        {
            targetHealth.color = new Color(255, 0, 0);
        }

        /*
        if(target.maxMana() > 0)
        {
            targetMana.color = new Color(0, 0, 255);
        }
        else
        {
            targetMana.color = new Color(255, 255, 255);
        }
        */
    }

        Boolean GetRange(Combat.Character character, out Int32 min, out Int32 max)
        {
            if (Range == null)
            {
                min = 0;
                max = 1000;
                return true;
            }

            Evaluation.Number[] result = Range.Evaluate(character);

            if (result.Length > 0 && result[0].NumberType != NumberType.None)
            {
                if (result.Length > 1 && result[1].NumberType != NumberType.None)
                {
                    min = result[0].IntValue;
                    max = result[1].IntValue;
                    return true;
                }
                else
                {
                    min = 0;
                    max = result[0].IntValue;
                    return true;
                }
            }

            min = 0;
            max = 1;
            return false;
        }

        public override void Run(Combat.Character character)
        {
            Int32 animationnumber = EvaluationHelper.AsInt32(character, AnimationNumber, 0);
            Boolean drawunder = EvaluationHelper.AsBoolean(character, DrawUnder, false);
            Point offset = EvaluationHelper.AsPoint(character, DrawPosition, new Point(0, 0));
            Int32 randomdisplacement = EvaluationHelper.AsInt32(character, RandomDisplacement, 0);

            Combat.ExplodData data = new xnaMugen.Combat.ExplodData();
            data.Scale = Vector2.One;
            data.AnimationNumber = animationnumber;
            data.CommonAnimation = true;
            data.Location = (Vector2)offset;
            data.PositionType = PositionType.P1;
            data.RemoveTime = -2;
            data.DrawOnTop = false;
            data.OwnPalFx = true;
            data.SpritePriority = (drawunder == true) ? -9 : 9;
            data.Random = new Point(randomdisplacement / 2, randomdisplacement / 2);
            data.Transparency = new Blending();
            data.Creator = character;
            data.Offseter = character;

            Combat.Explod explod = new Combat.Explod(character.Engine, data);
            if (explod.IsValid == true) explod.Engine.Entities.Add(explod);
        }

        public Recording(Combat.EngineInitialization init, List<RecordingData> data)
        {
            if (init == null) throw new ArgumentNullException("init");
            if (data == null) throw new ArgumentNullException("data");

            m_initsettings = init;
            m_data = data;
        }

        public override void Run(Combat.Character character)
        {
            Vector3 color = EvaluationHelper.AsVector3(character, ScreenColor, Vector3.One);
            Int32 time = EvaluationHelper.AsInt32(character, Time, 1);
            Boolean underflag = EvaluationHelper.AsBoolean(character, Under, false);

            character.Engine.EnvironmentColor.Setup(color, time, underflag);
        }

        public override void Run(Combat.Character character)
        {
            Int32? hits = EvaluationHelper.AsInt32(character, Hits, null);

            if (hits == null || hits <= 0) return;

            character.Team.Display.ComboCounter.AddHits(hits.Value);
        }

 public Attack(Combat.attackPhase phase, int skill, string damageExpression, bool isAP = false)
 {
     this.AttackPhase = phase;
     this.Skill = skill;
     this.DamageExpression = damageExpression;
     this.parseDamageExpression();
     this.IsAP = isAP;
 }