private static void Clear(GameEventTypes eventType, object[] args)
{
LinkedListNode <EffectObject> curNode = activeEffects.First;
int count = activeEffects.Count;
for (int i = 0; i < count; i++)
{
curNode.Value.Destroy();
curNode = curNode.Next;
}
curNode = pool.First;
count = pool.Count;
for (int i = 0; i < count; i++)
{
curNode.Value.Destroy();
curNode = curNode.Next;
}
count = pending.Count;
for (int i = 0; i < count; i++)
{
curNode.Value.Destroy();
curNode = curNode.Next;
}
activeEffects.Clear();
pool.Clear();
pending.Clear();
unimportantEffectsCount = 0;
}
/// <summary>
/// Отписываемся от прослушки событий
/// </summary>
/// <param name="eventName">Тип события в игре</param>
/// <param name="listener">Метод, который вызывался на событии</param>
public static void StopListening(GameEventTypes eventName, UnityAction <EventArgs> listener)
{
if (Instance._eventDictionary.TryGetValue(eventName, out var thisEvent))
{
thisEvent.RemoveListener(listener);
}
}
public void TriggerEvent(GameEventTypes eventName, EventArgs eventArgs)
{
if (_eventDictionary.TryGetValue(eventName, out var thisEvent))
{
thisEvent.Invoke(eventArgs);
}
}
private void OnRefreshEquip(GameEventTypes eventType, object[] args)
{
if (GameConvert.IntConvert(args[0]) == 0)
{
SetInfo();
}
}
public GameEvent(GameDate dateTime, GameEventTypes eventType, Politician[] involvedPoliticians, string[] involvedDistricts)
{
this.involvedDistricts = involvedDistricts;
this.dateTime = dateTime;
this.eventType = eventType;
this.involvedPoliticians = involvedPoliticians;
}
private void RoomImage_MouseClick(object sender, MouseEventArgs e)
{
switch (_mode)
{
case GameEventTypes.ChooseSpawnPosition:
if (Room != null && Room.Game != null)
{
var pt = WindowPositionToMapLocation(e.Location);
var pos = Room.GetPositionAt(pt);
string name = RequestStringDialog("Spawn Name", "My Spawn 1");
if (!string.IsNullOrWhiteSpace(name))
{
var result = Room.Game.ChooseSpawn(pos, Player, name);
if (result.TypeID == ResultTypes.Success)
{
Text = Room.Name;
_mode = GameEventTypes.None;
}
}
}
break;
}
}
public static void RegisterEvent(GameEventTypes eventType, GameEventCallback callback)
{
lock (eventLock)
{
List <GameEventCallback> callbackList = eventMap[eventType];
callbackList.Add(callback);
}
}
/// <summary>
/// Вызываем событие
/// </summary>
/// <param name="eventName">Тип события</param>
/// <param name="eventArgs">Параметры события</param>
public static void TriggerEvent(GameEventTypes eventName, EventArgs eventArgs)
{
#if UNITY_EDITOR
Debug.Log($"Event triggered: {eventName}");
#endif
if (Instance._eventDictionary.TryGetValue(eventName, out var thisEvent))
{
thisEvent.Invoke(eventArgs);
}
}
public void LoadEventTypes(Assembly assembly)
{
var types = assembly.GetCustomAttributes(typeof(GameEventRegisterAttribute), false)
.Select(a => ((GameEventRegisterAttribute)a).Type);
foreach (var t in types)
{
GameEventTypes.Add(t);
}
}
private static void Clear(GameEventTypes eventType, object[] args)
{
while (activeEffects.Count > 0)
{
var node = activeEffects.First.Value;
node.StopImmediate();
ProcessExpiredEffect(node);
activeEffects.RemoveFirst();
}
}
private static void Clear(GameEventTypes eventType, object[] args)
{
if (activeTrajectories.Count > 0)
{
var node = activeTrajectories.First.Value;
node.Stop();
ProcessExpiredEffect(node);
activeTrajectories.RemoveFirst();
}
}
public static void RaiseEvent(GameEventTypes eventType, params object[] args)
{
if (System.Threading.Thread.CurrentThread.ManagedThreadId == mainThreadID && EnableEventFiring)
{
RaiseEventNow(eventType, args);
}
else
{
QueueEvent(eventType, args);
}
}
private static List <GameEventCallback> GetEventCallbackList(GameEventTypes eventType)
{
List <GameEventCallback> callbackList = null;
if (!eventMap.TryGetValue(eventType, out callbackList))
{
callbackList = new List <GameEventCallback>();
eventMap.Add(eventType, callbackList);
}
return(callbackList);
}
public static void Regist(GameEventTypes type, Action handler)
{
if (gameEventHandlers.ContainsKey(type))
{
gameEventHandlers[type] += handler;
}
else
{
gameEventHandlers.Add(type, handler);
}
}
public GameEventCounter(int _activateCount, GameEventTypes _trigger, Action _action, bool _isTriggeredReset)
{
activateCount = _activateCount;
trigger = _trigger;
isActioned = false;
action = _action;
isTriggeredReset = _isTriggeredReset;
EventListener.Regist(trigger, onTrigger);
}
private static void QueueEvent(GameEventTypes eventType, params object[] args)
{
lock (eventLock)
{
GameEvent ev = eventPool.Fetch();
ev.eventType = eventType;
ev.args = args;
eventQueue.Enqueue(ev);
}
}
public static void RaiseEventSync(GameEventTypes eventType, params object[] args)
{
if (System.Threading.Thread.CurrentThread.ManagedThreadId == mainThreadID)
{
RaiseEventNow(eventType, args);
}
else
{
QueueEvent(eventType, args);
WaitQueue();
}
}
public static void Dispatch(GameEventTypes type)
{
Action result;
if (gameEventHandlers.TryGetValue(type, out result))
{
if (null == result)
{
return;
}
result();
}
}
/// <summary>
/// Регистриция слушателя события
/// </summary>
/// <param name="eventName">Тип события в игре</param>
/// <param name="listener">Метод, вызывающийся на событии</param>
public static void StartListening(GameEventTypes eventName, UnityAction <EventArgs> listener)
{
if (Instance._eventDictionary.TryGetValue(eventName, out var thisEvent))
{
thisEvent.AddListener(listener);
}
else
{
thisEvent = new GameEvent();
thisEvent.AddListener(listener);
Instance._eventDictionary.Add(eventName, thisEvent);
}
}
public static void UnregisterEvent(GameEventTypes eventType, GameEventCallback callback)
{
lock (eventLock)
{
List <GameEventCallback> callbackList = eventMap[eventType];
for (int i = callbackList.Count - 1; i >= 0; i--)
{
if (callbackList[i] == callback)
{
callbackList.RemoveAt(i);
break;
}
}
}
}
private static void RaiseEventNow(GameEventTypes eventType, params object[] args)
{
List <GameEventCallback> callbackList = eventMap[eventType];
try
{
for (int i = 0; i < callbackList.Count; i++)
{
callbackList[i].Invoke(eventType, args);
}
}
catch (Exception ex)
{
Debug.LogError(ex);
}
}
private void OnExitScene(GameEventTypes eventType, object[] args)
{
LinkedListNode <AudioObject> curNode = activeAudio.First;
int count = activeAudio.Count;
for (int i = 0; i < count; i++)
{
curNode.Value.Destroy();
curNode = curNode.Next;
}
curNode = pool.First;
count = pool.Count;
for (int i = 0; i < count; i++)
{
curNode.Value.Destroy();
curNode = curNode.Next;
}
activeAudio.Clear();
audioPlayedCurrFrame.Clear();
pool.Clear();
}
private void OnKillChessEvent(GameEventTypes eventType, object[] args)
{
ChessEntity attack = args[0] as ChessEntity;
ChessEntity beAttack = args[1] as ChessEntity;
if (attack == null || beAttack == null)
{
return;
}
if (beAttack.GetChessType() == ChessType.ChessTypeJiang)
{
fightMainUIPanel.SetStateInfoString("");
Account account = KBEngine.KBEngineApp.app.player() as Account;
if ((int)beAttack.chessObj.chess_owner_player == account.CampType)
{
GUIManager.Open <FightLostUIPanel>("Fight", "FightLostUIPanel");
}
else
{
GUIManager.Open <FightWinUIPanel>("Fight", "FightWinUIPanel");
}
}
else
{
Account account = KBEngine.KBEngineApp.app.player() as Account;
account.baseCall("KillChess", beAttack.chessObj.id);
if (currentAttackChess != null && currentAttackChess == attack)
{
currentAttackChess.MoveTo((int)beAttack.chessObj.chess_index_x, (int)beAttack.chessObj.chess_index_z);
}
}
currentAttackChess = null;
}
internal void GameEvent(GameObject source, GameEventArgs args)
{
switch (args.Type)
{
case GameEventTypes.ChooseSpawnPosition:
Text = "Choose your spawn position";
_mode = args.Type;
break;
case GameEventTypes.GameStep:
case GameEventTypes.RoomChanged:
if (Room != null)
{
var viewer = UI.RoomViewer.Create(Room);
if (viewer != null)
{
//RoomImage.BackgroundImage = viewer.RenderBackground( RoomImage.ClientSize );
RoomImage.Image = viewer.RenderImage(RoomImage.ClientSize, _lastPoint);
}
}
break;
}
}
public static void Clear(GameEventTypes type)
{
gameEventHandlers[type] = delegate { };
}
private void Clear(GameEventTypes eventType, object[] args)
{
points.Clear();
}
public void Reset()
{
eventType = GameEventTypes.Inavlid;
args = null;
}
private static void OnEnterScene(GameEventTypes eventType, object[] args)
{
DestroyExistingListener();
RestoreSettings();
}
public GameEvent(string name, GameEventTypes type = GameEventTypes.Multiple, double probability = 100.0)
{
Name = name;
Type = type;
Probability = probability;
}
public static int ToInt(this GameEventTypes command)
{
return((int)command);
}
