Example #1
0
 public void OnEvent(EVENT_TYPE eventType, Component sender, object param = null)
 {
     if (eventType == EVENT_TYPE.COLOR_GRADIENT && masterUrl.Equals(param as string))
     {
         Gradient();
     }
 }
Example #2
0
    public void OnEvent(EVENT_TYPE Event_Type, Component Sender, object Param = null)
    {
        switch (Event_Type)
        {
        case EVENT_TYPE.GAME_PLAYER_HEALTH_CHANGE:
            hpBar.value        -= (int)Param;
            attackedBlood.color = flashColour;
            attackedBlood.color = Color.Lerp(attackedBlood.color, Color.clear, 5 * Time.deltaTime);
            break;

        case EVENT_TYPE.GAME_ENEMY_DIE:     // 점수올라가야하고.. Kill! 뭐 이런 이펙트하나 있어야지?
            break;

        case EVENT_TYPE.GAME_OPTION_CLICK:
            /*
             * if (issetupWindow == false)
             * {
             *  setupWindow.SetActive(true);
             *  issetupWindow = true;
             * }
             * else
             * {
             *  setupWindow.SetActive(false);
             *  issetupWindow = false;
             * }
             */
            PopupManager.Instance.ShowPopup("option", "aa");
            break;

        case EVENT_TYPE.GAME_STATE_WIN:
            success.SetActive(true);
            break;
        }
    }
    public static void off(EVENT_TYPE eventType, OnEvent target = null)
    {
        if (target == null)
        {
            // 없으면 이벤트 제거
            Instance.Listeners.Remove(eventType);
        }
        else
        {
            // 타겟 있으면 타겟만 제거
            List <OnEvent> ListenList = null;
            if (!Instance.Listeners.TryGetValue(eventType, out ListenList))
            {
                return;
            }

            for (int i = 0; i < ListenList.Count; i++)
            {
                if (!ListenList[i].Equals(null))
                {
                    Instance.Listeners[eventType].Remove(target);
                }
            }
        }
    }
Example #4
0
 void IEventListener.OnEvent(EVENT_TYPE eventType, Component sender, object param)
 {
     if (eventType == EVENT_TYPE.WELCOME_UI)
     {
         selfText.text = param as string;
     }
 }
Example #5
0
    public void OnEvent(EVENT_TYPE eventType, Component sender, object param = null)
    {
        switch (eventType)
        {
        case EVENT_TYPE.COLOR_ACT:
            //Debug.Log(string.Format(
            //        $"{((IEnteract)sender).Url}[{(int)param}] -> " +
            //        $"{enteract.Url}[{enteract.Point}], {ReferenceEquals(sender, enteract)}"
            //        ));
            if (ReferenceEquals(sender, enteract))
            {
                if (answer.Equals(param))
                {
                    OpenDoor();
                }
                else
                {
                    CloseDoor();
                }
            }
            break;

        default:
            return;
        }
    }
    //-------------------------------------------------
    /// <summary>
    /// イベントが発生する時、実行
    /// </summary>
    /// <param name="Event_Type">イベントのタイプ</param>
    /// <param name="Sender">受けるcomponent</param>
    /// <param name="Param">first parameter</param>
    /// <param name="Param2">second parameter</param>
    public void OnEvent(EVENT_TYPE Event_Type, Component Sender, object Param = null, object Param2 = null)
    {
        switch (Event_Type)
        {
        case EVENT_TYPE.SERVER_CONNECTED:
            requestUserCollectionInfo();
            break;

        case EVENT_TYPE.ENTER_COLLECTION:
            OnEnterCollection();
            break;

        case EVENT_TYPE.SERVER_RESPONSE:
            if (((string)Param).Equals("GetCollectionInfo"))
            {
                GetUserCollectionInfo(((WWW)Param2).text);
            }
            break;

        case EVENT_TYPE.IMAGE_ARRIVED:
            if (((string)Param).Equals(GameData.CollectionInfo[imageNum, 1]))
            {
                image[imageNum] = ((WWW)Param2).texture;

                imageArrived = true;
            }
            break;
        }
    }
Example #7
0
 public void OnEvent(EVENT_TYPE Event_Type, Component Sender, object Param = null)
 {
     if (Event_Type == onEvent)
     {
         action.Invoke();
     }
 }
Example #8
0
 private void SetLevelList(EVENT_TYPE eventType,
                           Component sender,
                           object Param = null)
 {
     levelList = (List <Transform>)Param;
     InitialEnemy();
 }
    /// <summary>
    /// 事件传递函数 ===传递事件的关键函数===
    /// </summary>
    /// <param name="Event_Type">将要被处理的事件</param>
    /// <param name="Sender">发送事件的组件</param>
    /// <param name="Param">可选参数 指定响应本事件的对象</param>
    /// <param name="Value">可选参数 可以传递参数</param>
    public bool PostNotification(EVENT_TYPE Event_Type, Component Sender, Object param = null, Dictionary <string, object> value = null)
    {
        List <TListener> ListenList = null;

        //如果事件对应的监听器为空 直接返回
        if (!Listeners.TryGetValue(Event_Type, out ListenList))
        {
            return(false);
        }
        //遍历事件的所有监听器的事件处理函数
        for (int i = 0; i < ListenList.Count; i++)
        {
            //如果param不为空 则寻找特定的对象
            if (param)
            {
                if (!ListenList[i].Equals(null) && param == ListenList[i].getGameObject())
                {
                    //寻找到特定对象后执行操作并返回操作是否成功
                    return(ListenList[i].OnEvent(Event_Type, Sender, param, value));
                }
            }

            //如果没有特定对象(广播事件)则遍历事件所有的监听器
            else if (!ListenList[i].Equals(null))
            {
                ListenList[i].OnEvent(Event_Type, Sender, param, value);//调用函数 传参
            }
        }
        return(true);
    }
Example #10
0
    void HandleEvent(EVENT_TYPE type, System.Object data)
    {
        if (eventsList.Contains(type))
        {
            switch (type)
            {
            case EVENT_TYPE.BEGAN:
                OnOffTrajectory(true);
                break;

            case EVENT_TYPE.MOVED:
                PlayerBullet.transform.position = NozzlePoint.transform.position;
                PlayerTrajectoryPath(PlayerBullet.transform.position, (Vector3)data * power);
                break;

            case EVENT_TYPE.ENDED:

                PlayerBullet.GetComponent <Renderer>().enabled      = true;
                PlayerBullet.GetComponent <Rigidbody>().isKinematic = false;

                TouchController.disabletouch = true;

                Fire((Vector3)data);
                OnOffTrajectory(false);
                PlayerFired = true;
                TransitCamera.transform.DOPath(PlayerToEnemy, 10f, PathType.Linear, PathMode.Full3D);
                break;
            }
        }
    }
Example #11
0
    /// <summary>
    /// Handles the events
    /// </summary>
    public void OnEvent(EVENT_TYPE eventType, Component sender, System.Object param = null)
    {
        switch (eventType)
        {
        case EVENT_TYPE.BOMB_DEPLOYED:
            // verifies if player was hit by the bomb
            GameObject bomb              = (GameObject)param;
            float      timeToExplode     = bomb.GetComponent <BombAI> ().timeToExplode;
            bool       isWithinBombRange = BombAI.IsWithinExplosionRange(bomb.transform.position, transform.position, map);
            // verifying if player is in the tiles affected by the explosion
            if (isWithinBombRange && tileBombRange == null)
            {
                Vector3 tilePos = transform.position;
                tilePos.y += 0.1f;
                // highlight tile that will be affected by the explosion
                tileBombRange = Instantiate(tileBombRangePrefab, tilePos, transform.rotation) as GameObject;
                tileBombRange.transform.localScale = Vector3.one * map.tileSize;
            }
            break;

        case EVENT_TYPE.BOMB_EXPLODED:
            Vector3 bombPosition = (Vector3)param;
            if (BombAI.IsWithinExplosionRange(bombPosition, transform.position, map) && tileBombRange != null)
            {
                Destroy(tileBombRange);
            }
            break;
        }
    }
Example #12
0
    public bool OnEvent(EVENT_TYPE Event_Type, Component Sender, Object param = null, Dictionary <string, object> value = null)
    {
        switch (Event_Type)
        {
        case EVENT_TYPE.GAME_START:
            PlayerInterface.IControl p = Player.GetComponent <TuringOperate>().AIScript;
            TeamName = Player.GetComponent <TuringOperate>().AIScript.GetTeamName();
            SetupInfo();
            return(true);

        case EVENT_TYPE.GAME_OVER:
            transform.parent.gameObject.SetActive(false);    // 游戏结束时,隐藏Status的list
            return(true);

        case EVENT_TYPE.PLAYER_DEAD:
            if (Sender.gameObject == Player)
            {
                Die();    //对应玩家死亡
                return(true);
            }
            break;

        default:
            break;
        }
        return(false);
    }
Example #13
0
    public void AddListener(EVENT_TYPE eventType, OnEvent Listener)
    {
        //Список получателей
        List <OnEvent> ListenList = null;

        //Проверка типа события
        if (Listeners.TryGetValue(eventType, out ListenList))
        {
            if (!ListenList.Contains(Listener))
            {
                ListenList.Add(Listener);
            }
            return;
        }

        //Если списка нет
        ListenList = new List <OnEvent>();
        if (!ListenList.Contains(Listener))
        {
            ListenList.Add(Listener);
        }

        //Добавляем в главную коллекцию
        Listeners.Add(eventType, ListenList);
    }
Example #14
0
 /*
  * UnRegister a previously registered listening fucntion for the passed type event enum
  */
 public void UnRegisterListener(EVENT_TYPE eventType)
 {
     if (eventListeners.ContainsKey(eventType))
     {
         eventListeners.Remove(eventType);
     }
 }
Example #15
0
    //-----------------------------------------------------------
    /// <summary>
    /// Посылает события получателям
    /// </summary>
    /// <param name="Event_Type">Событие для вызова</param>
    /// <param name="Sender">Вызываемый объект</param>
    /// <param name="Param">Optional argument</param>
    public void PostNotification(EVENT_TYPE Event_Type, Component Sender, object Param = null)
    {
        if (dbgShowMessages)
        {
            Debug.Log("Send message|" + Event_Type + "|\nSender|" + Sender);
        }
        //Notify all listeners of an event

        //List of listeners for this event only
        List <IListener> ListenList = null;

        //If no event entry exists, then exit because there are no listeners to notify
        if (!Listeners.TryGetValue(Event_Type, out ListenList))
        {
            return;
        }

        //Entry exists. Now notify appropriate listeners
        for (int i = 0; i < ListenList.Count; i++)
        {
            if (!ListenList[i].Equals(null)) //If object is not null, then send message via interfaces
            {
                ListenList[i].OnEvent(Event_Type, Sender, Param);
            }
        }
    }
    public bool OnEvent(EVENT_TYPE Event_Type, Component Sender, Object param = null, Dictionary <string, object> value = null)
    {
        switch (Event_Type)
        {
        case EVENT_TYPE.TURING_SET_BOMB:     //选手操作:放置炸弹
            if (GameObject.FindGameObjectWithTag("Global").GetComponent <MapManager>().GetBoxType((int)(transform.position.x + 0.5), (int)(transform.position.z + 0.5)) != 0)
            {
                return(false);
            }
            if (bombAvaliable && !GetComponent <PlayerMovement>().IsMoving())   //如果当前可放置炸弹
            {
                SetBomb();
                GetComponent <Animator>().SetTrigger("SetBomb");
                return(true);
            }
            else
            {
                return(false);
            }

        case EVENT_TYPE.BOMB_BUFF:     //选手操作:加强炸弹
            IncreaseBombArea();
            return(true);

        default: return(false);
        }
    }
    //-------------------------------------------------
    /// <summary>
    /// イベントが発生する時、実行
    /// </summary>
    /// <param name="Event_Type">イベントのタイプ</param>
    /// <param name="Sender">受けるcomponent</param>
    /// <param name="Param">first parameter</param>
    /// <param name="Param2">second parameter</param>
    public void OnEvent(EVENT_TYPE Event_Type, Component Sender, object Param = null, object Param2 = null)
    {
        switch (Event_Type)
        {

        }
    }
 public void EnterDialogue(EVENT_TYPE Event_Type, Component Sender, object Param = null)
 {
     #region Set GameObjects Active
     pnlDisplay.SetActive(true);
     pnlCharacterName.SetActive(true);
     txtDisplay.gameObject.SetActive(true);
     txtCharacterName.gameObject.SetActive(true);
     btnNext.gameObject.SetActive(true);
     btnPrevious.gameObject.SetActive(true);
     txtNext.gameObject.SetActive(true);
     txtPrevious.gameObject.SetActive(true);
     btnCloseChat.gameObject.SetActive(true);
     #endregion
     //Dialogue Handled Beneath
     if (interactingID == "s")
     {   //Sage2000 Interaction
         Fin_Sage = DialogueManager.Instance.Fin_SageList1.Head;
         //Debug.Log(DialogueManager.Instance.Fin_SageList1.Head.Data.characterLine);
         txtCharacterName.text = Fin_Sage.Data.characterNickname;
         txtDisplay.text       = Fin_Sage.Data.characterLine;
     }
     else if (DialogueManager.Instance.currentInteraction == "b")
     {   //SocialBot Interaction
         Fin_SocialB = DialogueManager.Instance.Fin_BotList1.Head;
         //Futher Check To Determine starting character
         txtCharacterName.text = Fin_SocialB.Data.characterNickname;
         txtDisplay.text       = Fin_SocialB.Data.characterLine;
     }
 }
Example #19
0
 internal MouseWheelEventArgs(EVENT_TYPE event_type, ulong time, ushort mask, ushort reserved, ushort clicks, short x, short y, byte type, ushort amount, short rotation)
     : base(event_type, time, mask, reserved, 0, clicks, x, y)
 {
     this.type     = type;
     this.amount   = amount;
     this.rotation = rotation;
 }
 public Event(EVENT_TYPE type, double x, Point p, Arc a)
     : this(type)
 {
     this.x = x;
     this.p = p;
     this.a = a;
 }
Example #21
0
    public bool OnEvent(EVENT_TYPE Event_Type, Component Sender, Object param, Dictionary <string, object> value)
    {
        switch (Event_Type)
        {
        //游戏开始时 开启脚本 开启游戏
        case EVENT_TYPE.GAME_START:
            SetAIEnabled();
            isGameRunning = true;
            return(true);

        //游戏结束时 关闭脚本 结束游戏
        case EVENT_TYPE.GAME_OVER:
            SetAIDisabled();
            isGameRunning = false;
            return(true);

        case EVENT_TYPE.PLAYER_DEAD:
            //关闭尸体碰撞箱
            Sender.gameObject.GetComponent <BoxCollider>().enabled = false;
            //添加排名信息
            var   score = Sender.gameObject.GetComponent <PlayerScoreManager>();
            float time  = GetRemainTime();
            RankInfo.info.deadlist.Add(new RankInfo.DeadInfo {
                index = score.playerID, time = time, score = score.GetScore()
            });
            //
            DeadPlayer++;
            return(true);

        default: return(false);
        }
    }
Example #22
0
 public void unsubscribe(EVENT_TYPE ev, IEventListener listener)
 {
     if (listeners.ContainsKey(ev))
     {
         listeners[ev] = null;
     }
 }
Example #23
0
 public void notify(EVENT_TYPE ev, string info)
 {
     if (listeners.ContainsKey(ev))
     {
         listeners[ev].update(ev, info);
     }
 }
Example #24
0
    public void RegisteEvent(EVENT_TYPE eventType, EventDelegate handler, int delegatePrior = 0)
    {
        HandlerInfo handleInfo = new HandlerInfo();

        handleInfo._EventDelegate = handler;
        handleInfo._Priority      = delegatePrior;

        if (_HandleList.ContainsKey(eventType))
        {
            _HandleList[eventType].Add(handleInfo);
            _HandleList[eventType].Sort((handler1, handler2) =>
            {
                if (handler1._Priority > handler2._Priority)
                {
                    return(-1);
                }
                else if (handler1._Priority < handler2._Priority)
                {
                    return(1);
                }
                return(0);
            });
        }
        else
        {
            List <HandlerInfo> newHandle = new List <HandlerInfo>();
            newHandle.Add(handleInfo);
            _HandleList.Add(eventType, newHandle);
        }
    }
Example #25
0
    public void OnEvent(EVENT_TYPE Event_type, Component Sender, object Param = null)
    {
        switch (Event_type)
        {
        case EVENT_TYPE.GAMEOVER:
            Time.timeScale = 0.0f;
            break;

        case EVENT_TYPE.GAME:
            Time.timeScale = 1.0f;
            break;

        case EVENT_TYPE.PAUSED:
            Time.timeScale = 0.0f;
            break;

        case EVENT_TYPE.STARTING_READY:
            Time.timeScale = 1.0f;
            break;

        case EVENT_TYPE.READY:
            Time.timeScale = 0.0f;
            break;
        }
    }
Example #26
0
    //-----------------------------------------------------------
    /// <summary>
    /// Function to post event to listeners
    /// </summary>
    /// <param name="Event_Type">Event to invoke</param>
    /// <param name="Sender">Object invoking event</param>
    /// <param name="Param">Optional argument</param>
    public void PostNotification(EVENT_TYPE Event_Type, Component Sender, object Param = null)
    {
        //Notify all listeners of an event

        //List of listeners for this event only
        OnEvent delegateListener = null;

        //If no event entry exists, then exit because there are no listeners to notify
        if (!Listeners.TryGetValue(Event_Type, out delegateListener))
        {
            return;
        }

        //Entry exists. Now notify appropriate listeners
        if (delegateListener != null)
        {
            delegateListener.Invoke(Sender, Param);
        }


        //Entry exists. Now notify appropriate listeners
        //for (int i = 0; i < ListenList.Count; i++)
        //{
        //    if (!ListenList[i].Equals(null)) //If object is not null, then send message via interfaces
        //        ListenList[i](Event_Type, Sender, Param);
        //}
    }
Example #27
0
    public void ResponseEventInfo(SEventInfo[] infoArray)
    {
        m_sEventList = Util.ToList <SEventInfo>(infoArray);

        EVENT_TYPE type = EVENT_TYPE.EVENT_CHARGE_REWARD;

        if (WorldManager.instance.CheckMemoryInfoExists(WORLD_MEMORY_INFO.EVENT_PAGE_TYPE))
        {
            type = (EVENT_TYPE)WorldManager.instance.GetMemoryInfo(WORLD_MEMORY_INFO.EVENT_PAGE_TYPE);
            type = CheckEventExists((int)type) ? type : GetExistsFirstEventType();

            WorldManager.instance.DelMemoryInfo(WORLD_MEMORY_INFO.EVENT_PAGE_TYPE);
        }

        switch (type)
        {
        case EVENT_TYPE.EVENT_NONE: StartCoroutine(WaitForLoadSdkModuleData()); break;

        case EVENT_TYPE.EVENT_SPECIAL_REWARD: EventManager.instance.SendEventAttendInfo(); return;

        case EVENT_TYPE.EVENT_TIME_REWARD: EventManager.instance.SendEventTimeInfo(); return;

        case EVENT_TYPE.EVENT_COLLECT: EventManager.instance.SendEventCollectInfo(); return;

        case EVENT_TYPE.EVENT_COMEBACK: EventManager.instance.SendEventReturnInfo(); return;

        case EVENT_TYPE.EVENT_PROMOTION_COUPON01:
        case EVENT_TYPE.EVENT_PROMOTION_COUPON02:
        case EVENT_TYPE.EVENT_PROMOTION_COUPON03: EventManager.instance.SendEventPromoteCoupon(type); return;

        default: OpenEventWindow(type); return;
        }
    }
        private void IsPlayerHit(EVENT_TYPE eventType, Component sender, object param = null)
        {
            if ((Tile)param)
            {
                Tile   tile   = (Tile)param;
                Bullet bullet = (Bullet)sender;
                if (tile.tileData.isPlayerGround != isPlayer)
                {
                    return;
                }
                switch (bullet.TowerKind)
                {
                case TowerKind.STRAIGHT:
                    PlayerHit(bullet.Damage);
                    break;

                default:
                    if (unitData.unitIndex == tile.tileData.index)
                    {
                        PlayerHit(bullet.Damage);
                    }
                    break;
                }
            }
        }
        private void BunkerButtonTap(EVENT_TYPE eventType, Component sender, object param = null)
        {
            if (onBunker)
            {
                return;
            }
            var nearTileIndexs = NearTileList(unitData.unitIndex);

            foreach (var i in nearTileIndexs)
            {
                Tile tile = ground.GetTile(i);
                if (tile.tileData.tileState == TileState.NORMAL || tile.tileData.tileState == TileState.WILL_BUILD)
                {
                    Debug.Log("UnitLevel" + unitData.unitLevel);
                    if (unitData.unitLevel == 4)
                    {
                        tile.WillBuildBunker((BunkerPoolList)3);
                    }
                    else
                    {
                        tile.WillBuildBunker((BunkerPoolList)unitData.unitLevel - 1);
                    }
                }
            }
        }
Example #30
0
 public static void RaiseEvent(EVENT_TYPE type, System.Object data = null)
 {
     if (OnEvent != null)
     {
         OnEvent(type, data);
     }
 }
Example #31
0
 public virtual void OnEvent(EVENT_TYPE Event_Type, Component Sender, object Param = null)
 {
     if (Event_Type.Equals(eventType))
     {
         PlaySound();
     }
 }
Example #32
0
 public void OnEvent(EVENT_TYPE Event_Type, Component Sender, object Param = null)
 {
     switch(Event_Type)
     {
         case EVENT_TYPE.MANA_EMPTY:
             OnManaEmpty(Sender, (int)Param);
             break;
     }
 }
Example #33
0
File: Event.cs Project: t1b1c/lwas
 public Event(string key, EVENT_TYPE type)
 {
     if (string.IsNullOrEmpty(key))
     {
         throw new ArgumentNullException("key");
     }
     this._key = key;
     this._eventType = type;
 }
Example #34
0
 //-------------------------------------------------------
 //Called when events happen
 public void OnEvent(EVENT_TYPE Event_Type, Component Sender, object Param = null)
 {
     //Detect event type
     switch(Event_Type)
     {
         case EVENT_TYPE.HEALTH_CHANGE:
             OnHealthChange(Sender, (int)Param);
         break;
     }
 }
Example #35
0
 public void OnEvent(EVENT_TYPE Event_Type, Component Sender, object Param = null)
 {
     switch (Event_Type)
     {
         case EVENT_TYPE.HEALTH_CHANGE:
             OnHeathChange(Sender, (int)Param);
             break;
         case EVENT_TYPE.MANA_CHANGE:
             OnManaChange(Sender, (int)Param);
             break;
     }
 }
Example #36
0
 public virtual void onTrigger(EVENT_TYPE event_type, object data)
 {
     if (event_type == EVENT_TYPE.TRIGGER_LOGIN_STATE) {
         this.next_state = machine.getState (STATE_ID.LOGIN_STATE);
     } else if (event_type == EVENT_TYPE.TRIGGER_SELECT_ROOM_STATE) {
         this.next_state = machine.getState (STATE_ID.SELECT_ROOM_STATE);
     } else if (event_type == EVENT_TYPE.TRIGGER_HALL_STATE) {
         this.next_state = machine.getState(STATE_ID.HALL_STATE);
     } else if (event_type == EVENT_TYPE.TRIGGER_CREATE_ROOM_STATE) {
         this.next_state = machine.getState(STATE_ID.CREATE_ROOM_STATE);
     }
 }
Example #37
0
 public void AddListener(EVENT_TYPE event_type,OnEvent listener)
 {
     List<OnEvent> ListenList = null;
     // if the event_type is exist
     if (Listeners.TryGetValue(event_type, out ListenList)) {
         ListenList.Add(listener);
         return;
     }
     //if the event_type is new
     ListenList = new List<OnEvent>();
     ListenList.Add(listener);
     Listeners.Add (event_type,ListenList);
 }
Example #38
0
    public void PostNotification(EVENT_TYPE event_type,Component sender, object Param = null)
    {
        List<OnEvent> ListenList = null;

        if (!Listeners.TryGetValue(event_type,out ListenList)) {
            return;
        }

        for(int i =0; i < ListenList.Count; i++){
            if(!ListenList[i].Equals(null)){
                ListenList[i](event_type,sender,Param);
            }
        }
    }
Example #39
0
    //-----------------------------------------------------------
    /// <summary>
    /// Function to add specified listener-object to array of listeners
    /// </summary>
    /// <param name="Event_Type">Event to Listen for</param>
    /// <param name="Listener">Object to listen for event</param>
    public void AddListener(EVENT_TYPE Event_Type, OnEvent Listener)
    {
        //List of listeners for this event
        OnEvent delegateListener;

        //New item to be added. Check for existing event type key. If one exists, add to list
        if (Listeners.TryGetValue(Event_Type, out delegateListener))
        {
            //List exists, so add new item
            delegateListener += Listener;
            return;
        }

        //Otherwise create new list as dictionary key
        delegateListener += Listener;
        Listeners.Add(Event_Type, delegateListener); //Add to internal listeners list
    }
Example #40
0
    public void RemoveListener(EVENT_TYPE event_type,OnEvent listener)
    {
        List<OnEvent> ListenList = null;
        if (Listeners.TryGetValue(event_type, out ListenList)) {
            // this event is exists
            // then find if the listener is listening this event
            if(ListenList.Contains(listener)){
                ListenList.Remove(listener);
            }

            return;

        }else{
            // the event is not exist check the name again
            return;
        }
    }
Example #41
0
    //-----------------------------------------------------------
    /// <summary>
    /// Function to add specified listener-object to array of listeners
    /// </summary>
    /// <param name="Event_Type">Event to Listen for</param>
    /// <param name="Listener">Object to listen for event</param>
    public void AddListener(EVENT_TYPE Event_Type, IListener Listener)
    {
        //List of listeners for this event
        List<IListener> ListenList = null;

        //New item to be added. Check for existing event type key. If one exists, add to list
        if(Listeners.TryGetValue(Event_Type, out ListenList))
        {
            //List exists, so add new item
            ListenList.Add(Listener);
            return;
        }

        //Otherwise create new list as dictionary key
        ListenList = new List<IListener>();
        ListenList.Add(Listener);
        Listeners.Add(Event_Type, ListenList); //Add to internal listeners list
    }
Example #42
0
    //-----------------------------------------------------------
    /// <summary>
    /// Function to post event to listeners
    /// </summary>
    /// <param name="Event_Type">Event to invoke</param>
    /// <param name="Sender">Object invoking event</param>
    /// <param name="Param">Optional argument</param>
    public void PostNotification(EVENT_TYPE Event_Type, Component Sender, object Param = null)
    {
        //Notify all listeners of an event

        //List of listeners for this event only
        List<IListener> ListenList = null;

        //If no event entry exists, then exit because there are no listeners to notify
        if(!Listeners.TryGetValue(Event_Type, out ListenList))
            return;

        //Entry exists. Now notify appropriate listeners
        for(int i=0; i<ListenList.Count; i++)
        {
            if(!ListenList[i].Equals(null)) //If object is not null, then send message via interfaces
                ListenList[i].OnEvent(Event_Type, Sender, Param);
        }
    }
    //-----------------------------------------------------------
    /// <summary>
    /// Function to post event to listeners
    /// </summary>
    /// <param name="Event_Type">Event to invoke</param>
    /// <param name="Sender">Object invoking event</param>
    /// <param name="Param">Optional argument</param>
    public void PostNotification(EVENT_TYPE Event_Type,
        Component Sender, Object Param = null)
    {
        //Notify all listeners of an event

         //List of listeners for this event only
         List<OnEvent> ListenList = null;

         //If no event exists, then exit
         if(!Listeners.TryGetValue(Event_Type, out ListenList))
         return;

         //Entry exists. Now notify appropriate listeners
         for(int i = 0; i<ListenList.Count; i++)
        {
            if (!ListenList[i].Equals(null))
                ListenList[i](Event_Type, Sender, Param);
        }
    }
    //-----------------------------------------------------------
    /// <summary>
    /// Function to add listener to array of listeners
    /// </summary>
    /// <param name="Event_Type">Event to Listen for</param>
    /// <param name="Listener">Object to listen for event</param>
    public void AddListener(EVENT_TYPE Event_Type, OnEvent
    Listener)
    {
        //List of listeners for this event
        List<OnEvent> ListenList = null;

        // Check existing event type key. If exists, add to

        if(Listeners.TryGetValue(Event_Type, out ListenList))
        {
            //List exists, so add new item
            ListenList.Add(Listener);
            return;
        }

        //Otherwise create new list as dictionary key
        ListenList = new List<OnEvent>();
        ListenList.Add(Listener);
        Listeners.Add(Event_Type, ListenList);
    }
Example #45
0
 public void RemoveEvent(EVENT_TYPE event_type)
 {
     Listeners.Remove(event_type);
 }
Example #46
0
    //-----------------------------------------------------------
    /// <summary>
    /// Function to post event to listeners
    /// </summary>
    /// <param name="Event_Type">Event to invoke</param>
    /// <param name="Sender">Object invoking event</param>
    /// <param name="Param">Optional argument</param>
    public void PostNotification(EVENT_TYPE Event_Type, Component Sender, object Param = null)
    {
        //Notify all listeners of an event

        //List of listeners for this event only
        OnEvent delegateListener = null;

        //If no event entry exists, then exit because there are no listeners to notify
        if (!Listeners.TryGetValue(Event_Type, out delegateListener))
            return;

        //Entry exists. Now notify appropriate listeners
        if (delegateListener != null)
            delegateListener.Invoke(Sender, Param);

        //Entry exists. Now notify appropriate listeners
        //for (int i = 0; i < ListenList.Count; i++)
        //{
        //    if (!ListenList[i].Equals(null)) //If object is not null, then send message via interfaces
        //        ListenList[i](Event_Type, Sender, Param);
        //}
    }
Example #47
0
        public void SendEventToAllActorsWhoCanSeeActor(EVENT_TYPE etype, MapEventArgs args, Actor sActor, bool sendToSourceActor)
        {
            try
            {
                for (short deltaY = -1; deltaY <= 1; deltaY++)
                {
                    for (short deltaX = -1; deltaX <= 1; deltaX++)
                    {
                        uint region = (uint)(sActor.region + (deltaX * 1000000) + deltaY);
                        if (!this.actorsByRegion.ContainsKey(region)) continue;

                        foreach (Actor actor in this.actorsByRegion[region])
                        {
                            try
                            {
                                if (!sendToSourceActor && (actor.ActorID == sActor.ActorID)) continue;

                                if (this.ACanSeeB(actor, sActor))
                                {
                                    switch (etype)
                                    {
                                        case EVENT_TYPE.APPEAR:
                                            actor.e.OnActorAppears(sActor);
                                            break;

                                        case EVENT_TYPE.DISAPPEAR:
                                            actor.e.OnActorDisappears(sActor);
                                            break;

                                        case EVENT_TYPE.EMOTION:
                                            actor.e.OnActorChangeEmotion(sActor, args);
                                            break;

                                        case EVENT_TYPE.MOTION:
                                            actor.e.OnActorChangeMotion(sActor, args);
                                            break;

                                        case EVENT_TYPE.CHAT:
                                            actor.e.OnActorChat(sActor, args);
                                            break;

                                        case EVENT_TYPE.SKILL:
                                            actor.e.OnActorSkillUse(sActor, args);
                                            break;

                                        case EVENT_TYPE.CHANGE_EQUIP:
                                            actor.e.OnActorChangeEquip(sActor, args);
                                            break;
                                        default:
                                            break;
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                Logger.ShowError(ex);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.ShowError(ex);
            }
        }
Example #48
0
 void OnEvent(EVENT_TYPE event_type, Component sender, object Param = null)
 {
 }
Example #49
0
 public void AddEvent(EVENT_TYPE event_type)
 {
     List<OnEvent> ListenList = null;
     ListenList = new List<OnEvent>();
     Listeners.Add (event_type,ListenList);
 }
Example #50
0
        public void SendEventToAllActorsWhoCanSeeActor(EVENT_TYPE etype, MapEventArgs args, Actor sActor, bool sendToSourceActor)
        {
            try
            {
                for (short deltaY = -1; deltaY <= 1; deltaY++)
                {
                    for (short deltaX = -1; deltaX <= 1; deltaX++)
                    {
                        uint region = (uint)(sActor.region + (deltaX * 1000000) + deltaY);
                        if (!this.actorsByRegion.ContainsKey(region)) continue;

                        foreach (Actor actor in this.actorsByRegion[region])
                        {
                            try
                            {
                                if (!sendToSourceActor && (actor.id == sActor.id)) continue;

                                if (this.ACanSeeB(actor, sActor))
                                {
                                    switch (etype)
                                    {
                                        case EVENT_TYPE.APPEAR:
                                            actor.e.OnActorAppears(sActor);
                                            actor.e.OnActorChangesState(sActor, null);
                                            break;

                                        case EVENT_TYPE.DISAPPEAR:
                                            actor.e.OnActorDisappears(sActor);
                                            break;

                                        case EVENT_TYPE.CHANGE_STATE:
                                            actor.e.OnActorChangesState(sActor, args);
                                            break;

                                        case EVENT_TYPE.CHAT:
                                            actor.e.OnActorChat(sActor, args);
                                            break;

                                        case EVENT_TYPE.SKILL:
                                            actor.e.OnActorSkillUse(sActor, args);
                                            break;

                                        case EVENT_TYPE.CHANGE_EQUIP:
                                            actor.e.OnActorChangeEquip(sActor, args);
                                            break;

                                        case EVENT_TYPE.CHANGE_STATUS:
                                            actor.e.OnChangeStatus(sActor, args);
                                            break;
                                        case EVENT_TYPE.ACTOR_SELECTION:
                                            Map.ActorSelArgs arg = (Map.ActorSelArgs)args;
                                            Actor target = this.GetActor(arg.target);
                                            if (target != null)
                                            {
                                                if (actor == sActor)//broadcast disabled temporaryly, which crashes the client
                                                    if (this.ACanSeeB(actor, target))
                                                        actor.e.OnActorSelection((ActorPC)sActor, args);
                                            }
                                            break;
                                        case EVENT_TYPE.YAW_UPDATE :
                                            if (actor.type == ActorType.PC)
                                            {
                                                ActorPC pc = (ActorPC)actor;
                                                ActorEventHandlers.PC_EventHandler eh = (SagaMap.ActorEventHandlers.PC_EventHandler)pc.e;
                                                Packets.Server.UpdateActorYaw p1 = new SagaMap.Packets.Server.UpdateActorYaw();
                                                p1.SetActor(sActor.id);
                                                p1.SetYaw(sActor.yaw);
                                                eh.C.netIO.SendPacket(p1, eh.C.SessionID);
                                            }
                                            break;
                                        default:
                                            break;
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                Logger.ShowError(ex);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.ShowError(ex);
            }
        }
Example #51
0
        public IEvent NewEventInstance(string key, IEvent parent, object data, EVENT_TYPE eventType)
        {
            if (string.IsNullOrEmpty(key)) throw new ArgumentNullException("key");

            return new Event(key, parent, data, eventType);
        }
Example #52
0
    public void RemoveListener(EVENT_TYPE Event_Type, OnEvent Listener)
    {
        if (Listeners.ContainsKey(Event_Type))
        {
            Listeners[Event_Type] -= Listener;
        }

        Debug.Log("Just doesn't have this " + Listener + "yet");
        return;
    }
 //-----------------------------------------------------------
 //Remove event from dictionary, including all listeners
 public void RemoveEvent(EVENT_TYPE Event_Type)
 {
     //Remove entry from dictionary
      Listeners.Remove(Event_Type);
 }
Example #54
0
File: Event.cs Project: t1b1c/lwas
 public Event(string key, IEvent parent, EVENT_TYPE type)
     : this(key, type)
 {
     this._parent = parent;
 }
Example #55
0
File: Event.cs Project: t1b1c/lwas
 public Event(string key, IEvent parent, object data, EVENT_TYPE type)
     : this(key, parent, type)
 {
     this._data = data;
 }
 public Event(EVENT_TYPE type)
 {
     this.valid = true;
     this.type = type;
 }
Example #57
0
 public void onTrigger(EVENT_TYPE event_type,object data)
 {
     current_state.onTrigger (event_type, data);
     State next_state = current_state.check ();
     if ((next_state==null) || (next_state.id == current_state.id)) {
         return;
     }
     current_state.onLeave (next_state);
     next_state.onEnter (current_state);
     current_state = next_state;
 }