private void ActiveFunction(GameEventID type)
{
if (type < 0 || type >= GameEventID.GEIdCount)
{
return;
}
List <VoidDelegate> mFuns = mAllEvents[(int)type];
if (mFuns == null)
{
return;
}
for (int index = mFuns.Count; index > 0; index--)
{
VoidDelegate function = mFuns[index - 1];
if (function != null)
{
try
{
function(null);
}
catch (System.Exception ex)
{
UnityEngine.Debug.LogWarning("ProcessEvent Exception: " + ex.ToString());
}
}
}
}
protected override void OnGameEvent(GameEventID aEventType)
{
if(m_Unit == null || m_Abilities == null)
{
return;
}
if(aEventType == m_EventType)
{
switch(m_EventType)
{
case GameEventID.TRIGGER_AREA:
{
AreaTrigger trigger = eventData.sender as AreaTrigger;
Unit unit = eventData.triggeringObject as Unit;
if (trigger != null && unit != null && unit == m_Unit && trigger.triggerName == m_EventName)
{
TeachAbilities(unit);
}
}
break;
case GameEventID.UNIT_KILLED:
{
Unit unit = eventData.sender as Unit;
if (unit != null && unit.unitName == m_EventName)
{
TeachAbilities(unit);
}
}
break;
}
}
}
public void ClearProcessEvent()
{
List <ClientEvent> eventList = GetProcessEvent();
if (null == eventList)
{
return;
}
for (int i = 0; i < eventList.Count; i++)
{
ClientEvent proEvent = eventList[i];
GameEventID type = proEvent.GetID();
if (type >= 0 && type < GameEventID.GEIdCount)
{
List <VoidDelegate> mFuns = mAllEvents[(int)type];
for (int index = 0; index < mFuns.Count; index++)
{
VoidDelegate function = mFuns[index];
if (function != null)
{
function(proEvent);
}
}
}
DestoryEvent(eventList[i]);
}
mProcessEventsList.Clear();
}
public GameEventData(float aTimeStamp, GameEventID aEventSubType, GameEventType aEventType, object aSender, object aTriggeringObject)
{
m_TimeStamp = aTimeStamp;
m_EventSubType = aEventSubType;
m_EventType = aEventType;
m_Sender = aSender;
m_TriggeringObject = aTriggeringObject;
}
private void RemoveListener(GameEventID eventId)
{
if (m_CombatRobotMono != null)
{
m_CombatRobotMono.m_lstEventID.Remove(eventId);
}
Engine.Utility.EventEngine.Instance().RemoveEventListener((int)eventId, OnEvent);
}
protected override void OnGameEvent(GameEventID aEventType)
{
if(aEventType == GameEventID.TRIGGER_AREA)
{
AreaTrigger trigger = eventData.sender as AreaTrigger;
if(trigger != null && trigger.triggerName == m_EventName)
{
Game.LoadLevel(m_LevelName);
}
}
}
protected override void OnGameEvent(GameEventID aEventType)
{
if (aEventType == GameEventID.TRIGGER_AREA)
{
AreaTrigger trigger = eventData.sender as AreaTrigger;
if(trigger != null && trigger.triggerName == m_WinTrigger)
{
Game.LoadLevel(Game.MENU_SCENE);
DebugUtils.Log("Winner");
}
}
}
// 删除事件的关注处理函数;
public void RemoveProcessFunction(GameEventID type, VoidDelegate function)
{
if (type >= 0 && type < GameEventID.GEIdCount)
{
List <VoidDelegate> mFuns = mAllEvents[(int)type];
if (mFuns.Contains(function) == true)
{
mFuns.Remove(function);
}
}
}
/// <summary>
/// Here I Override the OnGameEvent method as it will be invoked by the event system to let us know of the event occuring
/// </summary>
/// <param name="aEventType"></param>
protected override void OnGameEvent(GameEventID aEventType)
{
switch(aEventType)
{
case GameEventID.GAME_LEVEL_LOAD_FINISH:
{
GameScene loadedScene = (GameScene)eventData.triggeringObject;
Debug.Log("Loaded " + loadedScene.sceneName + "!");
}
break;
}
}
protected override void OnGameEvent(GameEventID aEventType)
{
if (aEventType == GameEventID.UNIT_KILLED)
{
Unit sender = eventData.sender as Unit;
if (sender != null && sender.unitName == playerName)
{
unit = sender;
StartCoroutine(Revive());
}
}
}
/// <summary>
/// 成员变量重置，为的是对象可以重用;
/// 继承自IPooledObjSupporter;
/// </summary>
public void Reset()
{
if (mParameters != null)
{
mParameters.Clear();
}
else
{
mParameters = new QuickList <object>(2);
}
mID = GameEventID.GEIdCount;
mTimeLock = 0;
mDeleteFlg = false;
}
//--------------------------------------
// 添加事件监听器：根据回调函数的类型分为带参数的回调函数（DataEventHandlerFunction）和不带参数的回调函数（EventHandlerFunction）
//--------------------------------------
/// <summary>
/// 添加 事件监听器（回调函数不带参数，无返回值）
/// </summary>
/// <param name="eventID">事件ID</param>
/// <param name="handler">监听器为无参数的函数</param>
/// <remarks>
/// 事件ID定义参见<see cref="DreamFaction.EventSystem.GameEventID"/><br/>
/// 事件定义参见<see cref="DreamFaction.EventSystem.GameEvent"/><br/>
/// </remarks>
/// <example>
/// 示例代码：
/// <code>
///class EventTestClass
///{
/// public void Init()
/// {
/// GameEventDispatcher.Inst.addEventListener(GameEventID.G_Clent_ResOK, OnClienResOK);//无参数
/// GameEventDispatcher.Inst.addEventListener(GameEventID.G_Clent_ResOK, OnClienResOK_Data);
/// GameEventDispatcher.Inst.dispatchEvent(GameEventID.G_Clent_ResOK);
/// object obj = new object();
/// obj = 10;
/// GameEventDispatcher.Inst.dispatchEvent(GameEventID.G_Clent_ResOK, obj);
/// obj = "Test string";
/// GameEventDispatcher.Inst.dispatchEvent(GameEventID.G_Clent_ResOK, obj);
/// }
///
/// public void OnClienResOK()
/// {
/// Debug.Log("OnClienResOK..."); //无参数
/// }
///
/// public void OnClienResOK_Data(GameEvent e)
/// {
/// Debug.Log("OnClienResOK : " + e.data); // 第一次 10 , 第二次 Test String
/// }
///}
///}
/// </code>
/// </example>
public void addEventListener(GameEventID eventID, EventHandlerFunction handler)
{
int e = (int)eventID;
if (listners.ContainsKey(e))
{
listners[e].Add(handler);
}
else
{
List <EventHandlerFunction> handlers = new List <EventHandlerFunction>();
handlers.Add(handler);
listners.Add(e, handlers);
}
}
// 创建事件ID和name的映射表.
void AddEventMapping(string name, GameEventID eventId)
{
if (mEventDefines.ContainsKey(name) == true)
{
CommonDebugLog.Log(" The event " + name + "already contains a definition for EventMapping");
}
else if (mEventDefines.ContainsValue(eventId) == true)
{
CommonDebugLog.Log(" The event " + name + "already contains a definition for EventMapping");
}
else
{
mEventDefines[name] = eventId;
}
}
/// <summary>
/// 删除有参数，无返回值的事件监听器
/// </summary>
/// <param name="eventID">事件ID</param>
/// <param name="handler">监听器为有参数的函数</param>
public void removeEventListener(GameEventID eventID, DataEventHandlerFunction handler)
{
int e = (int)eventID;
if (dataListners.ContainsKey(e))
{
List <DataEventHandlerFunction> handlers = dataListners[e];
handlers.Remove(handler);
if (handlers.Count == 0)
{
dataListners.Remove(e);
}
}
}
//--------------------------------------
// 删除事件监听器
//--------------------------------------
/// <summary>
/// 删除无参数，无返回值的事件监听器
/// </summary>
/// <param name="eventID">事件ID</param>
/// <param name="handler">监听器为无参数的函数</param>
public void removeEventListener(GameEventID eventID, EventHandlerFunction handler)
{
int e = (int)eventID;
if (listners.ContainsKey(e))
{
List <EventHandlerFunction> handlers = listners[e];
handlers.Remove(handler);
handler = null;
if (handlers.Count == 0)
{
listners.Remove(e);
}
}
}
// 添加事件的关注处理函数;
public void AddProcessFunction(GameEventID type, VoidDelegate function)
{
if (type >= 0 && type < GameEventID.GEIdCount)
{
List <VoidDelegate> mFuns = mAllEvents[(int)type];
#if UNITY_EDITOR
for (Int32 index = 0; index < mFuns.Count; index++)
{
if (mFuns[index] == function)
{
UnityEngine.Debug.LogError("AddProcessFunction error =================" + type);
}
}
#endif
mFuns.Add(function);
}
}
/// <summary>
/// 删除某个事件ID的所有监听器
/// </summary>
/// <param name="eventID">需要删除监听器的事件ID</param>
public void clearEvent(GameEventID eventID)
{
int e = (int)eventID;
if (listners.ContainsKey(e))
{
List <EventHandlerFunction> handlers = listners[e];
handlers.Clear();
listners.Remove(e);
}
if (dataListners.ContainsKey(e))
{
List <DataEventHandlerFunction> handlers = dataListners[e];
handlers.Clear();
dataListners.Remove(e);
}
}
protected override void OnGameEvent(GameEventID aEventType)
{
Debug.Log(aEventType);
switch(aEventType)
{
case GameEventID.UNIT_KILLED:
{
Unit dyingUnit = eventData.sender as Unit;
if(dyingUnit != null)
{
if(dyingUnit.unitType == UnitType.PLAYER)
{
Respawn(dyingUnit);
}
}
}
break;
}
}
protected override void OnGameEvent(GameEventID aEventType)
{
DebugUtils.Log(aEventType);
if(aEventType == GameEventID.TRIGGER_AREA)
{
AreaTrigger areaTrigger = eventData.sender as AreaTrigger;
Unit unit = eventData.triggeringObject as Unit;
if(unit == null)
{
return;
}
UnitInventory inventory = unit.inventory;
if(areaTrigger != null && areaTrigger.triggerName == m_KeyPickUpString && inventory != null )
{
areaTrigger.gameObject.SetActive(false);
m_Trigger = areaTrigger;
PlayerPickUpKey(inventory);
}
}
}
// 从对象池中得到一个Event;
public ClientEvent AddEvent(GameEventID type, bool immediately = false)
{
if (immediately)
{
ActiveFunction(type);
return(null);
}
ClientEvent eve = mEventPool.RentObject() as ClientEvent;
if (eve != null)
{
eve.SetID(type);
GetProcessEvent().Add(eve);
}
else
{
UnityEngine.Debug.LogError("CreatEvent Faild ");
}
return(eve);
}
void OnEvent(int nEventID, object param)
{
if (m_ClientGlobal == null)
{
return;
}
IEntitySystem es = m_ClientGlobal.GetEntitySystem();
if (es == null)
{
return;
}
GameEventID evt = (GameEventID)nEventID;
long uid = 0;
switch (evt)
{
case GameEventID.ENTITYSYSTEM_ENTITYMOVE:
{
stEntityMove move = (stEntityMove)param;
uid = move.uid;
break;
}
case GameEventID.ENTITYSYSTEM_ENTITYSTOPMOVE:
{
stEntityStopMove move = (stEntityStopMove)param;
uid = move.uid;
break;
}
case GameEventID.SYSTEM_GAME_READY:
{
PreLoadAllResource();
break;
}
default:
{
break;
}
}
IEntity en = es.FindEntity(uid);
if (en != null && en.GetEntityType() == EntityType.EntityType_Player)
{
Vector3 pos = en.GetPos();
MapAreaType type = GetAreaTypeByPos(pos);
if (m_eMapAreaType != type)
{
stEntityChangeArea changeArea = new stEntityChangeArea();
changeArea.uid = uid;
changeArea.eType = type;
m_eMapAreaType = type;
Engine.Utility.EventEngine.Instance().DispatchEvent((int)GameEventID.ENTITYSYSTEM_CHANGEAREA, changeArea);
}
}
}
private void OnEvent(int nEventID, object param)
{
GameEventID eventId = (GameEventID)nEventID;
switch (eventId)
{
case GameEventID.ENTITYSYSTEM_MAINPLAYERCREATE:
{
SetTimer(MEDICAL_TIMEID, MEDICAL_TIME_INTERVAL);
SetTimer(ATONCE_TIMERID, ATONCE_LEN);
}
break;
case GameEventID.ENTITYSYSTEM_RELIVE:
{
stEntityRelive er = (stEntityRelive)param;
if (ControllerSystem.m_ClientGlobal.IsMainPlayer(er.uid))
{
SetTimer(MEDICAL_TIMEID, MEDICAL_TIME_INTERVAL);
SetTimer(ATONCE_TIMERID, ATONCE_LEN);
}
}
break;
case GameEventID.ENTITYSYSTEM_ENTITYDEAD:
{
stEntityDead ed = (stEntityDead)param;
if (ControllerSystem.m_ClientGlobal.IsMainPlayer(ed.uid))
{
KillTimer(MEDICAL_TIMEID);
KillTimer(ATONCE_TIMERID);
}
}
break;
case GameEventID.SKILLSYSTEM_SKILLLISTCHANE:
case GameEventID.SKILLSYSTEM_ADDSKILL:
InitSkill();
break;
case GameEventID.SKILLNONESTATE_ENTER:
{
NextSkill = 0;
OnCombat();
}
break;
//case GameEventID.ROBOTCOMBAT_NEXTCMD:
// {
// if (param != null)
// {
// Client.stSkillDoubleHit skillDhHit = (Client.stSkillDoubleHit)param;
// OnUseDoubleHitSkill(skillDhHit);
// }
// }
// break;
case GameEventID.SKILLSYSTEM_STIFFTIMEOVER:
{ //挂机状态下 硬直结束(并且没有插入技能)只处理普攻前两招，第三招释放时如果有插入 就不播放收招
stNextSkill st = (stNextSkill)param;
NextSkill = st.nextSkillID;
if (m_status == CombatRobotStatus.RUNNING && NextSkill != 0)
{
DoAttack();
}
if (m_status == CombatRobotStatus.RUNNING && NextSkill == 0 && InsertSkillID != 0)
{
DoAttack();
}
}
break;
case GameEventID.SKILLGUIDE_PROGRESSBREAK:
{
if (param != null)
{
stGuildBreak skillFailed = (stGuildBreak)param;
if (skillFailed.action == GameCmd.UninterruptActionType.UninterruptActionType_SkillCJ)
{
if (ControllerSystem.m_ClientGlobal.IsMainPlayer(skillFailed.uid))
{
m_nIgnoreSkillid = skillFailed.skillid;
// AddTips(string.Format("使用技能失败id:{0} ret{1}", skillFailed.skillid, skillFailed.msg));
}
ChangeRoleAction(RoleAction.NONE);
}
}
//ChangeRoleAction(RoleAction.USESKILL);
//DoNextCMD();
}
break;
case GameEventID.JOYSTICK_UNPRESS:
m_fStopTime = UnityEngine.Time.realtimeSinceStartup;
break;
case GameEventID.JOYSTICK_PRESS:
m_fStopTime = 0;
OnPause(true);
break;
case GameEventID.ENTITYSYSTEM_CREATEENTITY:
{
Client.stCreateEntity createEntity = (Client.stCreateEntity)param;
Client.IEntitySystem es = ControllerSystem.m_ClientGlobal.GetEntitySystem();
Client.IEntity entity = es.FindEntity(createEntity.uid);
if (entity != null)
{
if (entity.GetEntityType() == EntityType.EntityType_Box)
{
ShowBoxTips(entity.GetID());
OnPickUpItem();
}
}
}
break;
case GameEventID.ENTITYSYSTEM_REMOVEENTITY:
{
Client.stRemoveEntity removeEntiy = (Client.stRemoveEntity)param;
Client.IEntitySystem es = ControllerSystem.m_ClientGlobal.GetEntitySystem();
Client.IEntity entity = es.FindEntity(removeEntiy.uid);
if (entity != null)
{
if (entity.GetEntityType() == EntityType.EntityType_Box)
{
OnPickUpItem();
}
}
}
break;
case GameEventID.ROBOTCOMBAT_COPYKILLWAVE:
{
if (param != null)
{
stCopySkillWave copyWave = (stCopySkillWave)param;
if (m_bInCopy)
{
m_nLaskKillWave = copyWave.waveId;
m_nLaskMovePosIndex = copyWave.posIndex;
// AddTips(string.Format("副本wave{0} posIndex{1}", m_nLaskKillWave, m_nLaskMovePosIndex));
if (m_nLaskMovePosIndex != 0)
{
// SetTimer(COPYCOMBAT_TIMEID, 1600);
//OnPause(false);
}
//DoNextCMD();
}
}
}
break;
case GameEventID.NETWORK_CONNECTE_CLOSE:
{
m_disconnectStatus = m_status;
if (m_disconnectStatus != CombatRobotStatus.STOP)
{
Stop();
Engine.Utility.Log.Error("掉线了 挂机停止！！！");
}
}
break;
case GameEventID.RECONNECT_SUCESS:
{
if (m_disconnectStatus != CombatRobotStatus.STOP)
{
Start();
if (m_disconnectStatus == CombatRobotStatus.PAUSE)
{
Pause();
}
m_disconnectStatus = CombatRobotStatus.STOP;
}
}
break;
default:
break;
}
}
protected override void OnGameEvent(GameEventID aEventType)
{
if(aEventType == GameEventID.TRIGGER_AREA)
{
AreaTrigger trigger = eventData.sender as AreaTrigger;
Unit unit = eventData.triggeringObject as Unit;
if(unit == null || trigger == null)
{
return;
}
m_TriggeringUnits.Add(unit);
UnitInventory inventory = unit.inventory;
if(trigger.triggerName == m_DoorName)
{
if(m_RequiredItem != ItemType.NONE)
{
if (inventory != null && inventory.GetItem(m_RequiredItem) != null)
{
Open();
}
}
else
{
Open();
}
}
}
else if(aEventType == GameEventID.TRIGGER_AREA_EXIT)
{
AreaTrigger trigger = eventData.sender as AreaTrigger;
Unit unit = eventData.triggeringObject as Unit;
if (unit == null || trigger == null)
{
return;
}
m_TriggeringUnits.Remove(unit);
}
}
/// <summary>
/// ゲーム内の通知
/// </summary>
/// <param name="id"> イベントID </param>
public void Notification(GameEventID id)
{
GetEventID = id;
}
/// <summary>
/// This method gets called to notify the EventHandler of the event type.
/// </summary>
/// <param name="aEventType"></param>
protected virtual void OnGameEvent(GameEventID aEventType)
{
}
public void Trigger(GameEventID id, object args = null)
{
Trigger((int)id, args);
}
public void Bind(GameEventID id, Action callback)
{
Bind((int)id, callback);
}
public void SetID(GameEventID id)
{
mID = id;
}
/// <summary>
/// 分发有附加数据参数，无返回值的事件
/// </summary>
/// <param name="eventID">事件ID</param>
/// <param name="data">事件附加的数据</param>
public void dispatchEvent(GameEventID eventID, object data)
{
dispatch((int)eventID, data);
}
//--------------------------------------
// 分发事件
//--------------------------------------
/// <summary>
/// 分发无附加数据参数，无返回值的事件
/// </summary>
/// <param name="eventID">事件ID</param>
public void dispatchEvent(GameEventID eventID)
{
dispatch((int)eventID, null);
}
/// <summary>
/// Register an event with the Game Event Manager
/// </summary>
/// <param name="aEventID"></param>
protected void RegisterEvent(GameEventID aEventID)
{
if(m_RegisteredEvents.Contains(aEventID))
{
return;
}
///Add the event
m_RegisteredEvents.Add(aEventID);
switch(aEventID)
{
case GameEventID.GAME_LEVEL_LOAD_BEGIN:
case GameEventID.GAME_LEVEL_LOAD_FINISH:
case GameEventID.GAME_LEVEL_UNLOAD_BEGIN:
case GameEventID.GAME_LEVEL_UNLOAD_FINISH:
case GameEventID.GAME_LOAD:
case GameEventID.GAME_PAUSED:
case GameEventID.GAME_SAVE:
case GameEventID.GAME_UNPAUSED:
//Register a game event type
if(m_GameEventsRegistered == 0)
{
GameEventManager.RegisterEventListener(GameEventType.GAME, this);
}
m_GameEventsRegistered++;
break;
case GameEventID.UNIT_KILLED:
case GameEventID.UNIT_REVIVED:
case GameEventID.UNIT_SPAWNED:
case GameEventID.UNIT_ATTACK_BEGIN:
case GameEventID.UNIT_ATTACK_CANCELLED:
case GameEventID.UNIT_ATTACK_EXECUTE:
case GameEventID.UNIT_ATTACK_FINISHED:
case GameEventID.UNIT_ATTACK_STOPPED:
if (m_UnitEventsRegistered == 0)
{
GameEventManager.RegisterEventListener(GameEventType.UNIT, this);
}
m_UnitEventsRegistered++;
break;
case GameEventID.TRIGGER_AREA:
case GameEventID.TRIGGER_AREA_EXIT:
if(m_TriggerEventsRegistered == 0)
{
GameEventManager.RegisterEventListener(GameEventType.TRIGGER, this);
}
m_TriggerEventsRegistered++;
break;
}
}
protected void BindEvent(GameEventID id, Action <object> cmdHandler)
{
GameEvents.Instance.Bind(id, cmdHandler);
}
public void SetID(string eventName)
{
mID = ClientEventManager.GetInstance().GetEventId(eventName);
}
