public EventHandler(GameEventType t, EventAction e)
{
//todo(seba) don't think these are interned the way you'd hope
filter = @v => v.type == t;
action = e;
timing = EventTiming.Main;
}
/// <summary>
/// Filters the event and calls OnGameEvent if the event was registered.
/// </summary>
/// <param name="aType"></param>
protected void FilterEvent(GameEventType aType)
{
if(m_RegisteredEvents.Contains(eventData.eventSubType))
{
OnGameEvent(eventData.eventSubType);
}
}
public void StartRandomEvent(GameEventType gameEventType = GameEventType.Any)
{
string gameEvent = "";
switch (gameEventType)
{
case GameEventType.Any:
var combinedArrays = new List<String>();
combinedArrays.AddRange(BuildingEvents);
combinedArrays.AddRange(CombatEvents);
combinedArrays.AddRange(ResourceEvents);
combinedArrays.AddRange(CharacterEvents);
gameEvent = combinedArrays.ElementAt(random.Next(combinedArrays.Count));
break;
case GameEventType.BuildingEvent:
gameEvent = BuildingEvents[random.Next(BuildingEvents.Length)];
break;
case GameEventType.CharacterEvent:
gameEvent = CharacterEvents[random.Next(CharacterEvents.Length)];
break;
case GameEventType.CombatEvent:
gameEvent = CombatEvents[random.Next(CombatEvents.Length)];
break;
case GameEventType.ResourceEvent:
gameEvent = ResourceEvents[random.Next(ResourceEvents.Length)];
break;
}
gameObject.AddComponent(gameEvent);
}
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;
}
public void AddEvent(GameEventType type,EventCallBack callBack)
{
if (EventGroup.ContainsKey (type)) {
EventGroup [type] += callBack;
} else {
EventGroup[type] = callBack;
}
}
public EffectInfo()
{
Duration = -1;
DurationKind = EffectDurationType.Time;
Group = "";
DisplayName = "";
Description = "";
EventsToListenTo = new GameEventType[0];
TickLength = -1;
}
public void RegisterObserver(GameEventType eventType, IObserver observer)
{
ISubject sub = GetGameEventSub(eventType);
if (sub == null)
{
return;
}
sub.RegisterObserver(observer);
observer.SetSubject(sub);
}
public void Bind(GameEventType type, GameEventHandler handler)
{
if (m_handlerDict.ContainsKey(type) && m_handlerDict[type] != null)
{
m_handlerDict[type] += handler;
}
else
{
m_handlerDict[type] = handler;
}
}
public static void FireEvent(GameEventType eventKind, IGameObject targetObject, IGameObject instigator, Dictionary<string, object> args = null)
{
if (targetObject != null)
{
List<GameObjectScript> listeners = targetObject.Scripts.GetScripts(eventKind);
foreach (GameObjectScript script in listeners)
{
script.EventOccured(eventKind, targetObject, instigator, args);
}
}
}
public void RemoveObserver(GameEventType eventType, IGameEventObserver observer)
{
IGameEventSubject sub = GetGameEventSub(eventType);
if (sub == null)
{
return;
}
sub.RemoveObserver(observer);
observer.SetSubject(null);
}
private void GameEventHandler(GameEventType gameEventType)
{
if (gameEventType == GameEventType.PlayerTurn || gameEventType == GameEventType.EnemyFinishedTurn)
{
isPlayerTurn = true;
}
else
{
isPlayerTurn = false;
}
}
public void NotifySubject(GameEventType gameEventType)
{
IGameEventSubject sub = GetGameEventSubject(gameEventType);
if (sub == null)
{
return;
}
sub.Notify();
}
public void SubscribeToEvent(GameEventType eventId)
{
lock (EventsToListenTo)
{
if (EventsToListenTo.Contains(eventId))
{
return;
}
EventsToListenTo.Add(eventId);
}
}
public void addHandler(GameEventType gameEventType, int listeningToEntityId, IEventHandler handler)
{
if (!_handlers.ContainsKey(gameEventType))
_handlers.Add(gameEventType, new Dictionary<int,List<IEventHandler>>());
if (!_handlers[gameEventType].ContainsKey(listeningToEntityId))
_handlers[gameEventType].Add(listeningToEntityId, new List<IEventHandler>());
if (!_handlers[gameEventType][listeningToEntityId].Contains(handler))
{
_handlers[gameEventType][listeningToEntityId].Add(handler);
}
}
public static GameEvent GetSingleGameEvent(GameEventType type)
{
using (DatabaseContext context = new DatabaseContext())
{
return(context.Events
.Include(x => x.UGCMapContractSale)
.Include(x => x.UGCMapExtensionSale)
.Include(x => x.FieldPopupEvent)
.FirstOrDefault(x => x.Type == type && x.Active == true));
}
}
public static void Notify(GameEventType eventType, params object[] args)
{
//foreach (var handler in handlers)
//{
// handler.OnGameEvent(eventType, args);
//}
foreach (IGameEventListener handler in new List <IGameEventListener>(handlers))
{
handler.OnGameEvent(eventType, args);
}
}
public void ProcessEvent(GameEventType eventType, GameEvent <object> gameEvent)
{
switch (eventType)
{
case GameEventType.GameStateEvent:
SwitchState(StateTransformer.TransformStringToState(gameEvent.Parameter1));
break;
default:
break;
}
}
public void OnGameEvent(GameEventType gameEventType, params object[] args)
{
switch (gameEventType)
{
case GameEventType.UpdateMoveDistance:
CalculateDistance((float)args[0]);
break;
default:
break;
}
}
/// <summary>
/// Procceses the events of the SwitchState, and in which string it needs to be transformed to.
/// </summary>
/// <param name="eventType">Which kind of event, like a GameStateEvent</param>
/// <param name="gameEvent">In which state of the game the message is at</param>
public void ProcessEvent(GameEventType eventType, GameEvent <object> gameEvent)
{
// if the event window is called, process it here
if (eventType == GameEventType.GameStateEvent)
{
SwitchState(StateTransformer.TransformStringToState(gameEvent.Message));
}
else if (eventType == GameEventType.InputEvent)
{
ActiveState.HandleKeyEvent(gameEvent.Message, gameEvent.Parameter1);
}
}
public GameEvent CreateSessionEvent <T>(GameEventType type, GameSession session, T data)
{
session.Updated = DateTime.UtcNow;
return(new GameEvent
{
Id = Guid.NewGuid(),
GameSessionId = session.Id,
Type = (int)type,
Revision = GetNextGameEventRevision(session.Id),
Data = JSON.Stringify(data)
});
}
public void AddGameEvent(string user, GameEventType t, string comment, bool isAnonym = false)
{
if (!isAnonym)
{
comment += $" пользователем {CurrentUser?.Login??"N/A"}";
}
var e = new GameEvent(t, user);
e.Description = comment;
Data.GameEvents.Add(e);
Data.SaveChanges();
}
private void GameEventHandler(GameEventType gameEventType)
{
switch (gameEventType)
{
case GameEventType.StartGame:
gameData.SetGameEvent(GameEventType.SelectHero);
break;
case GameEventType.SelectHero:
//Do nothing.
break;
case GameEventType.StartBattle:
StartBattle();
break;
case GameEventType.PlayerTurn:
CheckHeroesState();
break;
case GameEventType.PlayerFinishedTurn:
gameData.SetGameEvent(GameEventType.EnemyTurn);
break;
case GameEventType.EnemyTurn:
if (CheckEnemyState())
{
break;
}
enemyController.Attack();
break;
case GameEventType.EnemyFinishedTurn:
gameData.SetGameEvent(GameEventType.PlayerTurn);
break;
case GameEventType.PlayerWon:
gameData.battleResult = "Win!";
break;
case GameEventType.PlayerDefeated:
gameData.battleResult = "defeat!";
gameData.SetGameEvent(GameEventType.EndBattle);
break;
case GameEventType.EndBattle:
EndBattle();
break;
default:
throw new ArgumentOutOfRangeException(nameof(gameEventType), gameEventType, null);
}
}
// This is terrible TBD
public void Subscribe(GameObject subscriber, GameEventType gameEvent, Action <GameObject, System.Object> eventResponse)
{
ReferenceEventPair newPair = new ReferenceEventPair(new WeakReference(subscriber), eventResponse);
if (!eventTable.ContainsKey(gameEvent))
{
eventTable.Add(gameEvent, new List <ReferenceEventPair>());
}
// TODO: Check for existing subscription
eventTable[gameEvent].Add(newPair);
}
protected GameEventMessage(GameEventType eventType, GameMessageGroup group, Session session) : base(GameMessageOpcode.GameEvent, group)
{
EventType = eventType;
Session = session;
Writer.WriteGuid(session.Player.Guid);
var debugMessage = $"GameEventSequence Update - {eventType} - GameEventSequence was {session.GameEventSequence}";
Writer.Write(session.GameEventSequence++);
//Console.WriteLine(debugMessage + $" and is now {session.GameEventSequence}");
Writer.Write((uint)EventType);
}
public void ProcessEvent(GameEventType eventType, GameEvent <object> gameEvent)
{
// Count events using integer fields
if (eventType == GameEventType.ControlEvent)
{
EventCounterControl++;
}
if (eventType == GameEventType.SoundEvent)
{
EventCounterSound++;
}
}
public void ProcessEvent(GameEventType eventType, GameEvent <object> gameEvent)
{
if (eventType == GameEventType.WindowEvent)
{
switch (gameEvent.Message)
{
case "CLOSE_WINDOW":
win.CloseWindow();
break;
}
}
}
private void GameEventHandler(GameEventType gameEventType)
{
if (gameEventType != GameEventType.UpdateMoveCount)
{
return;
}
countdown--;
text.text = countdown.ToString();
if (countdown == 0)
{
PublisherSubscriber.Publish(GameEventType.GameOver);
}
}
private static void OnListenerAdding(GameEventType eventType, Delegate callBack)
{
if (!eventDic.ContainsKey(eventType))
{
eventDic.Add(eventType, null);
}
Delegate d = eventDic[eventType];
if (d != null && d.GetType() != callBack.GetType())
{
throw new Exception(String.Format("尝试为事件添加不同类型的委托,当前事件所对应的委托为{1}，要添加的委托类型为{2}", eventType.GetType(), callBack.GetType()));
}
}
public void Suscribe(GameEventType type, OnEventDel callback)
{
if (event_delegates.ContainsKey(type))
{
event_delegates[type] += callback;
}
else
{
OnEventDel del = null;
del += callback;
event_delegates.Add(type, del);
}
}
public void ProcessEvent(GameEventType eventType, GameEvent <object> gameEvent)
{
switch (gameEvent.Parameter1)
{
case "KEY_PRESS":
KeyPress(gameEvent.Message);
break;
case "KEY_RELEASE":
KeyRelease(gameEvent.Message);
break;
}
}
protected GameEventMessage(GameEventType eventType, GameMessageGroup group, Session session) : base(GameMessageOpcode.GameEvent, group)
{
EventType = eventType;
Session = session;
// Force session to not be null -- due to races with player initialization
session.WaitForPlayer();
Writer.WriteGuid(session.Player.Guid);
Console.WriteLine($"GameEventSequence Update - {eventType} - GameEventSequence was {session.GameEventSequence}");
Writer.Write(session.GameEventSequence++);
Console.WriteLine($"GameEventSequence Update - {eventType} - GameEventSequence is now {session.GameEventSequence}");
Writer.Write((uint)EventType);
}
public void RegisterEvent(GameEventType type, int id, GameEventDelegate handler)
{
int key = GetEventKey(type, id);
if (!mMapEventDlg.ContainsKey(key))
{
mMapEventDlg[key] = handler;
}
else
{
Debug.Log("repeat register event");
}
}
public static void RemoveListener(GameEventType eventType, Callback handler)
{
if (!IsCanRemoveListener(eventType, handler))
{
return;
}
AllEventDic[eventType] = (Callback)AllEventDic[eventType] - handler;
if (AllEventDic[eventType] == null)
{
AllEventDic.Remove(eventType);
}
}
public void ProcessEvent(GameEventType eventType, GameEvent <object> gameEvent)
{
if (eventType == GameEventType.GameStateEvent)
{
if (gameEvent.Message == "CHANGE_STATE")
{
SwitchState(StateTransformer.TransformStringToState(gameEvent.Parameter1));
}
}
else if (eventType == GameEventType.InputEvent)
{
ActiveState.HandleKeyEvent(gameEvent.Message, gameEvent.Parameter1);
}
}
private static bool BeforeRemoveListener(GameEventType type, Delegate action)
{
if (!m_EventDic.ContainsKey(type))
{
return(false);
}
var d = m_EventDic[type];
if (d.GetType() != action.GetType())
{
return(false);
}
return(true);
}
private void GameEventHandler(GameEventType type)
{
switch (type)
{
case GameEventType.BeginPlay:
entities.Add(enemy.Instantiate().GetComponent <Entity>());
for (int i = 1; i < entities.Count; i++)
{
entities[i].Init(this, i);
}
break;
}
}
private void GameEventHandler(GameEventType gameEventType)
{
if (gameEventType == GameEventType.PlayerWon)
{
HeroModel.AddExperience();
//Show some UI
Flags.Add(new ShowUpgradeFlag
{
HeroController = this,
IsStillShowing = true
});
StartCoroutine(ShowUpgrades());
}
}
public void addHandler(GameEventType gameEventType, int listeningToEntityId, IEventHandler handler)
{
if (!_handlers.ContainsKey(gameEventType))
{
_handlers.Add(gameEventType, new Dictionary <int, List <IEventHandler> >());
}
if (!_handlers[gameEventType].ContainsKey(listeningToEntityId))
{
_handlers[gameEventType].Add(listeningToEntityId, new List <IEventHandler>());
}
if (!_handlers[gameEventType][listeningToEntityId].Contains(handler))
{
_handlers[gameEventType][listeningToEntityId].Add(handler);
}
}
void OnGUI()
{
IsSearchByEventType = EditorGUILayout.Toggle ("search by event type:", IsSearchByEventType);
if (IsSearchByEventType) {
searchEventType = (GameEventType)EditorGUILayout.EnumPopup ("search by event type:", searchEventType);
}
IsSearchByObjectInReceiverField = EditorGUILayout.Toggle ("search by GameObject in Gameevent.Receiver:", IsSearchByObjectInReceiverField);
if (IsSearchByObjectInReceiverField) {
SearchObjectReference = (GameObject)EditorGUILayout.ObjectField ("search by GameObject:", SearchObjectReference, typeof(GameObject));
}
if (GUILayout.Button ("Search")) {
Search ();
}
DisplayResult();
}
public ShowChoiceStep(GameEventType t)
: base(t)
{
for(int i=0; i<this.message.Length; i++)
{
this.message[i] = "";
}
for(int i=0; i<this.choiceNext.Length; i++)
{
this.choice.Add(new string[this.message.Length]);
for(int j=0; j<((string[])this.choice[i]).Length; j++)
{
((string[])this.choice[i])[j] = "";
}
this.variableCondition[i] = new VariableCondition();
}
}
public static void RegisterEventListener(GameEventType aType, IGameEventReceiver aListener)
{
if(aListener == null)
{
return;
}
switch(aType)
{
case GameEventType.GAME:
instance.m_GameEventListener.Add(aListener);
break;
case GameEventType.UNIT:
instance.m_UnitEventListener.Add(aListener);
break;
case GameEventType.TRIGGER:
instance.m_TriggerEventListener.Add(aListener);
break;
}
}
public PlayerEvent(Player plr, GameEventType type)
: base(type)
{
player = plr;
}
public SetToPositionStep(GameEventType t)
: base(t)
{
}
public MultiCardEvent(List<Card> cards, GameEventType t)
: base(t)
{
cs = cards;
}
public MultiCardEvent(Card c, GameEventType t)
: base(t)
{
cs = new List<Card>(1);
cs.Add(c);
}
public MoveToDirectionStep(GameEventType t)
: base(t)
{
}
public CardEvent(Card card, GameEventType type)
: base(type)
{
this.card = card;
}
public HasLeftPartyStep(GameEventType t)
: base(t)
{
}
public CircuitOutputConnection(EditorCircuitActor circuitActor, EditorActor actor, Gate gate, GameEventType onEnabledEvent, GameEventType onDisabledEvent)
: base(circuitActor, actor, gate, "output")
{
_onEnabledEvent = onEnabledEvent;
_onDisabledEvent = onDisabledEvent;
}
public GameEvent(GameEventType type)
{
this.type = type;
}
public RotationStep(GameEventType t)
: base(t)
{
}
public ClearStatisticStep(GameEventType t)
: base(t)
{
}
public CustomStatisticStep(GameEventType t)
: base(t)
{
}
public RotateToWaypointStep(GameEventType t)
: base(t)
{
}
public JoinPartyStep(GameEventType t)
: base(t)
{
}
public MoveToPrefabStep(GameEventType t)
: base(t)
{
}
public GameEvent(GameEventType eventType, GameTime gameTime, bool isInstant)
: this(gameTime, isInstant)
{
this.EventType = eventType;
this.Id = eventTypeNameDict[eventType];
}
public MoveToWaypointStep(GameEventType t)
: base(t)
{
}
public CheckPlayerStep(GameEventType t)
: base(t)
{
}
public IsInPartyStep(GameEventType t)
: base(t)
{
}
