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) { }