public override void Start(MonoBehaviour behaviour, Sequencer.StateInstance aState)
 {
     Entity ai = (Entity)behaviour;
     EntityMovement em = ai.entMove;
     em.Jump(speedMin < speedMax ? Random.Range(speedMin, speedMax) : speedMin);
     ai.state = state;
 }

	public static IEnumerator run_list(MonoBehaviour runner, IEnumerable<ActionWrapper> actions){
		foreach (ActionWrapper aw in actions) {
			Debug.Log("Running Coroutine");
			yield return runner.StartCoroutine(aw.run());
		}
		yield return null;
	}

    void ProcessMessage(MonoBehaviour behaviour)
    {
        bool AllOn  = true;
        bool AllOff = true;

        if (!Eneble){
            return;
        }
        for(int i = 0; i < TriggerButtonsOn.Length; i++){
            if(TriggerButtonsOn[i].State == c2StateButton.eButtonState.Off){
                AllOn = false;
            }
        }

        for(int i = 0; i < TriggerButtonsOff.Length; i++){
            if(TriggerButtonsOff[i].State == c2StateButton.eButtonState.On){
                AllOff = false;
            }
        }

        if(AllOn && AllOff){
            State = true;
            animation.CrossFade("Open");
        }
    }

 public void PerformInjections(MonoBehaviour component)
 {
     foreach (IInjector injector in _injectors)
     {
         injector.PerformAllInjections(component);
     }
 }

	private void displayInformationForUnit(IGameEntity entity) {

		//Remove previous values
		hideExtendedInformationPanel();
		    
		//Display window info
		windowInfo.GetComponent<Image>().enabled = true;

		currentPanel = Panel.UNIT;
		currentObject = (MonoBehaviour)entity;
		
		List<String> titles = new List<String>();
		titles.Add("Attack rate");
		titles.Add("Attack range");
		titles.Add("Movement rate");
		titles.Add("Resistance");
		titles.Add("Sight range");
		titles.Add("Strenght");
		titles.Add("Weapon Ability");
		List<String> values = new List<String>();
		values.Add(entity.info.unitAttributes.attackRate.ToString());
		values.Add(entity.info.unitAttributes.attackRange.ToString());
		values.Add(entity.info.unitAttributes.movementRate.ToString());
		values.Add(entity.info.unitAttributes.resistance.ToString());
		values.Add(entity.info.unitAttributes.sightRange.ToString());
		values.Add(entity.info.unitAttributes.strength.ToString());
		values.Add(entity.info.unitAttributes.weaponAbility.ToString());
		displayInformation(titles, values);
	}

    public override void Start(MonoBehaviour behaviour, Sequencer.StateInstance state)
    {
        Main.instance.cameraController.mode = mode;

        if(attachToPath.Length > 0) {
            GameObject go = ((SceneController)behaviour).SearchObject(attachToPath);
            if(go != null) {
                Main.instance.cameraController.attach = go.transform;
            }
            else {
                Debug.LogWarning("Path not found: "+attachToPath);
            }
        }
        else if(attachToWaypoint.Length > 0) {
            Transform t = WaypointManager.instance.GetWaypoint(attachToWaypoint);
            if(t != null) {
                Main.instance.cameraController.attach = t;
            }
            else {
                Debug.LogWarning("Can't find waypoint: "+attachToWaypoint);
            }
        }

        if(immediate) {
            Main.instance.cameraController.CancelMove();
        }
    }

    public override void Start(MonoBehaviour behaviour, Sequencer.StateInstance state)
    {
        Entity ai = (Entity)behaviour;
        PlanetAttach pa = ai.planetAttach;
        AIState aiState = (AIState)state;

        float speed = speedMin < speedMax ? Random.Range(speedMin, speedMax) : speedMin;
        if(speed > 0) {
            if(followPlayer) {
                Player player = SceneLevel.instance.player;

                aiState.curPlanetDir = pa.GetDirTo(player.planetAttach, followPlayerHorizontal);
            }
            else if(!useDir) {
                aiState.curPlanetDir = Util.Vector2DRot(new Vector2(1, 0), angle*Mathf.Deg2Rad);
            }

            pa.velocity = aiState.curPlanetDir*speed;

            ai.action = Entity.Action.move;
        }
        else {
            pa.velocity = Vector2.zero;

            ai.action = Entity.Action.idle;
        }

        if(resetAccel) {
            pa.accel = Vector2.zero;
        }
    }

    public void DispatchMessage(float delay, 	/*fa song zhe */int sender, 	/*jie shou zhe */int receiver, int msg,MonoBehaviour _be)
    {
        //jie shou zhe de zhi zhen
        BaseGameEntity pReceiver = EntityManager.Instance ().GetEntityFromID (receiver);

        //chuang jian yi ge xiao xi
        Telegram telegram = new Telegram (0, sender, receiver, msg,_be);

        if (delay <= 0.0f) {

            //li ji fa song xiao xi
            Discharge (pReceiver, telegram);
        } else {

            //yan chi fa song xiao xi
            float CurrentTime = Time.realtimeSinceStartup;

            telegram.DispatchTime = CurrentTime + delay;

            foreach(Telegram val in PriorityQ)
            {
                if(val.Sender == sender && val.Receiver == receiver && val.Msg ==msg)
                {
                    return ;
                }
            }

            PriorityQ.Add (telegram);

        }
    }

 public static YieldInstruction Start(CanvasGroup group, MonoBehaviour script, float from, float to, float time)
 {
     Stop(group, script);
     var coroutine = script.StartCoroutine(AnimateGroup(group, from, to, time));
     _fades.Add(group, coroutine);
     return coroutine;
 }

    public static void SubscribeToEvent(EGameEvent _e, MonoBehaviour _subscriber)
    {
        Initialize();

        // assert _gameEvent >= GameEvent.EVT_GOAL_SCORED && _gameEvent < GameEvent.COUNT
        evtSubscribers [(int)_e].Add (_subscriber);
    }

 public MonoBehaviour changeMotionModel(GlobalControl.motionModels newMotionModel)
 {
     //First, remove previous motion model
     DestroyImmediate (motionComponent);
     //Add the new motion model
     switch (newMotionModel){
         case GlobalControl.motionModels.DISCRETE:
             motionComponent = (MonoBehaviour)gameObject.AddComponent<MoveDiscrete>();
             break;
         case GlobalControl.motionModels.KINEMATIC:
             motionComponent = (MonoBehaviour)gameObject.AddComponent<MoveKinematic>();
             break;
         case GlobalControl.motionModels.DYNAMIC:
             motionComponent = (MonoBehaviour)gameObject.AddComponent<MoveDynamic>();
             break;
         case GlobalControl.motionModels.DIFFERENTIAL:
             motionComponent = (MonoBehaviour)gameObject.AddComponent<MoveDifferential>();
             break;
         case GlobalControl.motionModels.CAR:
             motionComponent = (MonoBehaviour)gameObject.AddComponent<MoveCar>();
             break;
     }
     motionModel = newMotionModel;
     return motionComponent;
 }

 public MapGenerator2(DungeonParameter param, MonoBehaviour obj,RndGenerator rnd)
 {
     DgParam = param;
     this.obj = obj;
     Rnd = rnd;
     reset();
 }

    void ProcessMessage(MonoBehaviour behaviour)
    {
        bool OpenCondition = true;
        bool NotYorButton = true;

        foreach (c2StateButton target in TriggerButtons){

            if (target == null) {continue;};

            if (target == behaviour){
                NotYorButton = false;
            }

            if (target.State != c2StateButton.eButtonState.On){
                OpenCondition = false;
                break;
            }

        }
        if (!NotYorButton){
            if (OpenCondition){
                animation.CrossFade("PullDown");

            }
            else{
                    animation.CrossFade("PullUp");
            }
        }
    }

 public SimpleChat(string identifier,MonoBehaviour currentMonoBehaviour,string senderName)
     : base(identifier,currentMonoBehaviour,senderName)
 {
     continueCheckMessages();
     rt = -messageTime;
     setReceiveFunction(receive);
 }

 public static Task Login(MonoBehaviour owner, IPEndPoint endPoint, string id, string password, Action<string> progressReport)
 {
     var task = new UnitySlimTaskCompletionSource<bool>();
     task.Owner = owner;
     owner.StartCoroutine(LoginCoroutine(endPoint, id, password, task, progressReport));
     return task;
 }

	void Start() {
		target = GetComponent(behaviour) as MonoBehaviour;
		if (!target) { 
			Debug.LogWarning("Did not find component " + behaviour + " on " + gameObject.name);
			Destroy(this);
		}
	}

    // Returns whether or not the crop planting worked, if it works, it takes the cost from the players money
    public bool PlantCrop(string _uniqueId, MonoBehaviour tileToPlant)
    {
        Crop CropInfo = null;

        //Checks to see if tile is empty
        if (PlantedCrops.ContainsKey(tileToPlant))
        {
            return false;
        }

        //Gives CropInfo a Crop value
        for (int value = 0; value < AvailableCrops.Count; ++value)
        {
            if (AvailableCrops[value].UniqueId == _uniqueId)
            {
                CropInfo = AvailableCrops[value];
            }
        }

        //If no crop is present and player has enough money, plant crop and decrease money
        if (CropInfo != null && Money >= CropInfo.Cost)
        {
            PlantedCrops.Add(tileToPlant, new Crop(CropInfo));
            Money = Money - CropInfo.Cost;
            return true;
        }
        else
        {
            return false;
        }
    }

    public static IEnumerator publishScore(int level, int score,MonoBehaviour toPause)
    {
        yield return new WaitForEndOfFrame();
        try{
            if (!loged){
                CallFBLogin();
            }

            if (FB.IsLoggedIn)
            {

                var query = new Dictionary<string, string>();
                query["score"] = score.ToString();
                FB.API("/me/scores", Facebook.HttpMethod.POST, delegate(FBResult r) { FbDebug.Log("Result: " + r.Text); }, query);
            }
        }catch{
            PopUpMessage.ShowPopUp(Globals.texts.withoutConnection,Globals.texts.error,toPause);
        }

        /*if (FB.IsLoggedIn)
        {
            var querySmash = new Dictionary<string, string>();

            querySmash["ScoreByLevel"] = "http://samples.ogp.me/284034268417686";
            print(FB.AppId);

            FB.API ("/me/" + "orl.ag.orly" + ":smash", Facebook.HttpMethod.POST,
                    delegate(FBResult r) { FbDebug.Log("Result: " + r.Text); }, querySmash);
        }*/
    }

    public override void Start(MonoBehaviour behaviour, Sequencer.StateInstance aState)
    {
        Entity ai = (Entity)behaviour;
        AIState aiState = (AIState)aState;

        ai.state = state;

        Vector2 src = ai.transform.position;
        Vector2 dest = Player.instance.transform.position;

        switch(type) {
        case Type.xOnly:
            dest.y = src.y;
            break;

        case Type.yOnly:
            dest.x = src.x;
            break;
        }

        Vector2 dir = dest - src;
        float dist = dir.magnitude;
        dir = dir/dist;

        float spd = minSpeed < maxSpeed ? Random.Range(minSpeed, maxSpeed) : minSpeed;
        ai.entMove.velocity = dir*spd;

        aiState.d = dist/spd;
    }

    public static void setSelected(GameObject obj)
    {
        if(objects[obj] == null)
            return;

        if(current_object == obj)
            return;

        current_file_loc = objects[obj].ToString();
        current_object = obj;

        string[] split_loc = current_file_loc.Split('/');
        string short_loc = split_loc[split_loc.Length - 1];

        string[] split_short_loc = short_loc.Split(':');

        string short_file_name = split_short_loc[0];
        string line_number = split_short_loc[1];

        current_line_number = Int32.Parse(line_number);

        string type_name = short_file_name.Split('.')[0];

        if(temp == null)
            temp = new GameObject("temp");

        temp.AddComponent(type_name);

        MonoBehaviour mb = temp.GetComponent(type_name) as MonoBehaviour;

        current_behaviour = mb;

        UnityEngine.Debug.Log(Fancy.current_behaviour);
    }