public void SendEvent(GameEvent gameEvent, IEventReceiver receiver)
 {
     SingletonFactory.LOG.Log("SendEvent: " + gameEvent.ToString() + (receiver == null ? "" : ", Receiver: " + receiver.ToString()), Logging.LoggerLevel.LOW);
     SingletonFactory.LOG.Log("EventArgs: " + gameEvent.ArgString);
     FilterEvent(gameEvent);
     receiver.OnEvent(gameEvent);
 }

    //bool decisionMade;
    public void AssignEvent(GameEvent newEvent, MapRegion eventRegion, List<PartyMember> movedMembers)
    {
        GameEventManager.mainEventManager.drawingEvent=true;
        currentTeamRegion=eventRegion;
        teamList=movedMembers;
        assignedEvent=newEvent;
        descriptionText.text=newEvent.GetDescription(currentTeamRegion,teamList);
        //decisionMade=false;

        List<EventChoice> choices=newEvent.GetChoices(currentTeamRegion,teamList);
        if (choices!=null)
        {
            foreach (EventChoice choice in choices)
            {
                Button newButton=Instantiate(decisionButtonPrefab);
                newButton.transform.SetParent(transform.FindChild("Event Panel").FindChild("Decision Group"),false);
                //this is required, otherwise lambda listener only captures the last choice iteration
                newButton.GetComponentInChildren<Text>().text=choice.choiceTxt;
                newButton.interactable=!choice.grayedOut;
                newButton.onClick.AddListener(()=>ResolveChoice(newButton.GetComponentInChildren<Text>().text));
            }
        }
        else
        {
            //Create exit button
            Button newButton=Instantiate(decisionButtonPrefab);
            newButton.transform.SetParent(transform.FindChild("Event Panel").FindChild("Decision Group"),false);
            newButton.GetComponentInChildren<Text>().text="Close";
            newButton.onClick.AddListener(CloseChoiceScreen);
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    // EVENT LISTENING
    ///////////////////////////////////////////////////////////////////////////
    public void eventReceived(GameEvent e)
    {
        if (e is PlayerMoveEvent)
        {

            KeyCode k = (e as PlayerMoveEvent).pressedKey;
            string strKeyPressed = k.ToString();

            switch (strKeyPressed){
            case "A":
                Flip ("left");
                anim.SetBool("Idle",false);
                anim.SetBool("WalkRight",false);
                anim.SetBool("WalkLeft",true);
                break;
            case "D":
                Flip ("right");
                anim.SetBool("Idle",false);
                anim.SetBool("WalkRight",true);
                anim.SetBool("WalkLeft",false);
                break;
            default:
                anim.SetBool("Idle",true);
                anim.SetBool("WalkRight",false);
                anim.SetBool("WalkLeft",false);
                break;
            }
        }

        if (e is PlayerActionEvent) {
            KeyCode k = (e as PlayerActionEvent).pressedKey;

        }
    }

 public AddItemEditor()
 {
     this.ge = ScriptableObject.CreateInstance<GameEvent> ();
     ge.Name = this.EventName;
     ge.setParameter ("item", null);
     ge.setParameter ("inventory", null);
 }

	private void ClimbOverEdgeMove(GameEvent gEvent)
	{
		if(charState.IsClimbing() && gEvent == GameEvent.ClimbOverEdge && !noClimbOver)
		{
//			LeanTweenPath path = new LeanTweenPath();
//			LeanTweenVisual tween = new LeanTweenVisual();
////
			if (charState.IsVineClimbing())
			{
//				tween = vineTween;
//				path = vinePath;
//				print("ClimbOverVine: should start climbing over vine");
			}
			else if(charState.IsEdgeClimbing())
			{
//				tween = edgeTween;
//				path = edgePath;
			}

			//EnableClimbOverTween(path, tween, true);

			//path.transform.parent = null;
			animator.SetTrigger("ClimbOverEdge");

			RSUtil.Instance.DelayedAction(() => {
				//path.transform.parent = transform;
				//path.transform.localPosition = Vector3.zero;
				//EnableClimbOverTween(path, tween, false);
				EventManager.OnCharEvent(GameEvent.FinishClimbOver);
				noClimbOver = false;
			}, tweenDuration);

		}
	}

 // Initial cost for employees is one weeks pay
 public void NewEvent(int EventIndex)
 {
     GameEvent NewEvent = new GameEvent ();
     NewEvent.EventIndex = EventIndex;
     switch (EventIndex) {
         case (0):	// patients give money
             NewEvent.EventText = "Application: Patient" + "\n" +
                                 "Name: Steve" + "\n" +
                                 "Income: $300" + "\n" +
                                 "Condition: Alchoholism";
             NewEvent.CashBonus = 300;
             break;
         case (1):	// guards cost money
             NewEvent.EventText = "Application: Guard" + "\n" +
                                 "Name: Dezlo" + "\n" +
                                 "Cost: $1050" + "\n" +
                                 "Salary: $150 Per Day";
             NewEvent.CashBonus = -1050;
             break;
         case (2):	// doctors cost money
             NewEvent.EventText = "Application: Doctor" + "\n" +
                                 "Name: Leviathan" + "\n" +
                                 "Cost: $2100" + "\n" +
                                 "Salary: $300 Per Day";
             NewEvent.CashBonus = -2100;
             break;
     }
     MyEvents.Add (NewEvent);
 }

    ///////////////////////////////////////////////////////////////////////////
    // EVENT LISTENING
    //////////////////////////////////////////////////////////////////////////
    public void eventReceived(GameEvent e)
    {
        if (e is NPCHealthEvent) {
            NPCHealthEvent evento = (e as NPCHealthEvent);

            ///////////////////////////////////////
            /// Confere se foi o monstro alvo
            var selfID = gameObject.GetInstanceID();
            if (selfID == evento.NPCInstanceID){

                NPCHealthChange = evento.NPCHealth;

                if ((NPCHealthLvl >= NPCMaxHealth / 2) && (NPCHealthLvl+NPCHealthChange < NPCMaxHealth / 2))
                    GameEventManager.post(new NPCStateEvent(selfID, 2)); //dispara o evento de transformação do inimigo em Vegetal. Esse evento será disparado com o efeito do antidoto

                if ((NPCHealthLvl < NPCMaxHealth / 2) && (NPCHealthLvl + NPCHealthChange >= NPCMaxHealth / 2))
                    GameEventManager.post(new NPCStateEvent(selfID, 1)); //dispara o evento de transformação do vegetal em Inimigo. Esse evento será disparado pelo efeito do veneno no ataque dos inimigos no vegetal, que poderá transformar-lo novamente em vegetalInimigo

                NPCHealthLvl += NPCHealthChange;
                if (NPCHealthLvl <= 0){
                    Die ();
                    NPCHealthLvl = 0;
                }

                ///////////////////////////////////////////////////////////////////
                /// Exibe Dano
                var selfTransform = GetComponent<Transform> ();
                DamagePopUp.ShowMessage (NPCHealthChange.ToString(), selfTransform.position);
            }
        }
    }

 public override void eventHappened(GameEvent ge)
 {
     if(ge.getParameter("Inventory") == this || ge.getParameter("Inventory") == this.Entity.gameObject)
     {
         Item item = (Item)ge.getParameter("Item");
         switch (ge.Name.ToLower())
         {
         case "open inventory":
             openInventory = true;
             events.Add(ge);
             break;
         case "add item":
             itemsToAdd.Add (item);
             events.Add(ge);
             break;
         case "remove item":
             itemsToRemove.Add(item);
             events.Add(ge);
             break;
         case "use item":
             itemsToUse.Add(item);
             events.Add(ge);
             break;
         }
     }
 }

    ///////////////////////////////////////////////////////////////////////////
    // EVENT LISTENING
    ///////////////////////////////////////////////////////////////////////////
    public void eventReceived(GameEvent e)
    {
        if (e is PlayerActionEvent)
        {
            KeyCode pressedKey = (e as PlayerActionEvent).pressedKey;

            switch (pressedKey){
                case KeyCode.Space:
                    Debug.Log ("ESPAÇOOOOOOOOOOOOOOOOOOO");
                    break;
                case KeyCode.UpArrow:
                    FireBullet("Up");
                    break;
                case KeyCode.LeftArrow:
                    FireBullet("Left");
                    break;
                case KeyCode.RightArrow:
                    FireBullet("Right");
                    break;
                case KeyCode.DownArrow:
                    FireBullet("Down");
                    break;
                default :
                    Debug.Log(pressedKey.GetTypeCode());
                    break;
            }
        }
    }

 //Out's a game event if it exists otherwise it will out null
 public void GetEventFromPool(string key, out GameEvent gameEvent)
 {
     if (_eventDictionary.ContainsKey (key))
         gameEvent = _eventDictionary [key];
     else
         gameEvent = null;
 }

 void Awake()
 {
     for (int i = 0; i < eventNames.Length; i++) {
         GameEvent gameEvent = new GameEvent();
         AddEventToPool (eventNames[i], ref gameEvent);
     }
 }

 //Adds a game event to the collection of events if it does not exist
 //or replaces the event with the Key if it does exist
 public void AddEventToPool(string key, ref GameEvent gameEvent)
 {
     if (!_eventDictionary.ContainsKey (key))
         _eventDictionary.Add (key, gameEvent);
     else
         _eventDictionary [key] = gameEvent;
 }

 private void FilterEvent(GameEvent gameEvent)
 {
     foreach (EventFilter filter in _filters)
     {
         filter.FilterEvent(gameEvent);
     }
 }

 public override void Execute(GameEvent gameEvent)
 {
     bool finished = false;
     GameObject actor = null;
     if(this.show3)
     {
         actor = (GameObject)gameEvent.spawnedPrefabs[this.actorID];
     }
     else
     {
         actor = gameEvent.actor[this.actorID].GetActor();
     }
     if(actor != null)
     {
         ActorEventMover comp = actor.gameObject.GetComponent<ActorEventMover>();
         if(comp == null)
         {
             comp = actor.gameObject.AddComponent<ActorEventMover>();
         }
         Vector3 target = this.v3;
         if(this.show2) target = actor.transform.TransformDirection(target);
         comp.StartCoroutine(comp.MoveToDirection(actor.transform, this.controller, target, this.show, this.speed, this.time));
         if(this.wait)
         {
             finished = true;
             gameEvent.StartTime(this.time, this.next);
         }
     }
     if(!finished)
     {
         gameEvent.StepFinished(this.next);
     }
 }

    public override void ApplyEvent(GameWorldController gameWorldController, GameEvent.OnEventCompleteDelegate onComplete)
    {
        base.ApplyEvent(gameWorldController, onComplete);

        EnergyTankEntity energyTankEntity = gameWorldController.Model.GetEnergyTankEntity(EnergyTankId);

        energyTankEntity.Energy = (uint)Math.Max((int)energyTankEntity.Energy - EnergyDrained, 0);

        if (DrainerFaction == GameConstants.eFaction.ai)
        {
            MobEntity mobEntity = gameWorldController.Model.GetMobEntity(DrainerId);

            mobEntity.Energy = mobEntity.Energy + EnergyDrained;
        }
        else if (DrainerFaction == GameConstants.eFaction.player)
        {
            CharacterEntity characterEntity = gameWorldController.Model.GetCharacterEntity(DrainerId);

            characterEntity.Energy = characterEntity.Energy + EnergyDrained;
        }

        // Completes immediately
        if (onComplete != null)
        {
            onComplete();
        }
    }

 public override void Execute(GameEvent gameEvent)
 {
     bool finished = false;
     GameObject actor = null;
     if(this.show3)
     {
         actor = (GameObject)gameEvent.spawnedPrefabs[this.actorID];
     }
     else
     {
         actor = gameEvent.actor[this.actorID].GetActor();
     }
     if(actor != null && gameEvent.waypoint[this.waypointID] != null)
     {
         ActorEventMover comp = (ActorEventMover)actor.gameObject.GetComponent("ActorEventMover");
         if(comp == null)
         {
             comp = (ActorEventMover)actor.gameObject.AddComponent("ActorEventMover");
         }
         comp.StartCoroutine(comp.RotateToObject(actor.transform, gameEvent.waypoint[this.waypointID], this.interpolate, this.time));
         if(this.wait)
         {
             finished = true;
             gameEvent.StartTime(this.time, this.next);
         }
     }
     if(!finished)
     {
         gameEvent.StepFinished(this.next);
     }
 }

    public void SetAlertLevel(GameEvent.eEventLevel alertLevel)
    {
        Color orange = new Color(1f,.55f,0f);
        switch (alertLevel)
        {
            case GameEvent.eEventLevel.Informational:
                ButtonText.color = Color.white;
                break;

            case GameEvent.eEventLevel.Positive:
                ButtonText.color = Color.green;
                break;

            case GameEvent.eEventLevel.Moderate:
                ButtonText.color = Color.yellow;
                break;

            case GameEvent.eEventLevel.Serious:
                ButtonText.color = orange;
                break;

            case GameEvent.eEventLevel.Critical:
                ButtonText.color = Color.red;
                break;

            default:
                ButtonText.color = Color.white;
                break;
        }
    }

    public void HandleEvent(GameEvent ge)
    {
        if(Pause.paused)
            return;
        Vector3 mousepos = InputWatcher.GetCanvasInputPosition((RectTransform)canvas.transform);
        if(ge.type.Equals("mouse_click")){
            if(spinning)
                return;

            spinning = true;
            startingDialRot = transform.eulerAngles.z * Mathf.Deg2Rad;
            startingMouseRot = Mathf.Atan2(mousepos.y-anchorY,mousepos.x-anchorX);
        }else if(ge.type.Equals("mouse_release")){
            if(!spinning)
                return;
            spinning = false;
            float mouseAngle = Mathf.Atan2 ((mousepos.y - anchorY) - transform.position.y, (mousepos.x-anchorX) - transform.position.x);
            float angleChange = mouseAngle-startingMouseRot;
            transform.eulerAngles = new Vector3(transform.eulerAngles.x,transform.eulerAngles.y,(startingDialRot + angleChange)*Mathf.Rad2Deg);
            float rotation = transform.eulerAngles.z;
            float lockRot = Mathf.Round (rotation / 60) * 60;
            UpdateSelection(lockRot);
            transform.rotation = Quaternion.Euler (0, 0, lockRot);
        }
    }

    public void HandleEvent(GameEvent ge)
    {
        if (ge.type.Equals ("mouse_release")) {
            RaycastHit targetFind;

            Ray targetSeek = Camera.main.ScreenPointToRay (InputWatcher.GetTouchPosition ());
            if (Physics.Raycast (targetSeek, out targetFind)) {
                Debug.Log (targetFind.collider.name);
                //sees if ray collided with the start button
                if (targetFind.collider.gameObject == startButton) {
                    //Debug.Log ("try and load level select");
                    if(levelHolder[menuPosition] == "Return"){
                        Camera.main.transform.position = cameraLock2.transform.position;
                    }else{
                        WorldData.lastScene = Application.loadedLevelName;
                        levelName = levelHolder[menuPosition];
                        GamePause.paused = false;
                        Application.LoadLevel(levelName);
                    }

                    /*if(menuPosition == 3 || menuPosition == 1){
                        worldHolder.GetComponent<WorldData>().lastScene = Application.loadedLevelName;
                        Application.LoadLevel(levelName);
                    }else if(menuPosition == 2){
                        Camera.main.transform.position = cameraLock2.transform.position;
                    }*/
                }
            }
        }
    }

 ///////////////////////////////////////////////////////////////////////////
 // EVENT LISTENING
 ///////////////////////////////////////////////////////////////////////////
 public void eventReceived(GameEvent e)
 {
     if (e is PlayerFireEvent) {
         Debug.Log ("send fireProjectile");
         GetComponent<MonkController>().fireProjectile();
     }
 }