public void Init(Hashtable changeStateData) { _gameMode = GameMode.COMBAT; _playerCombatSystem = _diContainer.Resolve<PlayerCombatSystem>(); _buildSystem = _diContainer.Resolve<BuildingSystem>(); _inventorySystem = _diContainer.Resolve<InventorySystem>(); _enemySystem = _diContainer.Resolve<EnemySystem>(); _lootSystem = _diContainer.Resolve<LootSystem>(); _particleGod = _diContainer.Resolve<ParticleGOD>(); _monsterGenerator = _diContainer.Resolve<MonsterGenerator>(); Singleton.instance.audioSystem.GenerateAudioLookupForLevel(); _particleGod.InitParticlePool(); //HUD _hudController = new HUDController(_gameConfig.playerConfig,_gameConfig.hudConfig); _hudController.Start(() => { _monsterGenerator.Init(_hudController, _playerCombatSystem); }); _playerCombatSystem.Init(_hudController); _buildSystem.Init(); _enemySystem.Init(); _lootSystem.Init(); _inventorySystem.Init(); // Get CombatPlayerView //_playerCombatSystem.isEnabled = true; _dispatcher.AddListener(GameplayEventType.DAMAGE_TAKEN, onDamageTaken); _dispatcher.AddListener(GameplayEventType.GAME_COMPLETE, onGameComplete); _dispatcher.AddListener(GameplayEventType.GAME_RETRY, onGameRetry); }
/// Remove a previously registered observer with exactly one argument from this Dispatcher public static void AddListenerStrangeEvent(object evt, EventCallback callback) { if (strangeDispatcher != null) { strangeDispatcher.AddListener(evt, callback); } else { Debug.LogWarning("strangeDispatcher Not Ready"); } }
public void RemoveListenerTest00() { void Listener() => _counter++; _dispatcher.AddListener(TestEvent.Event00, Listener); _dispatcher.Dispatch(TestEvent.Event00); Assert.AreEqual(1, _counter); _dispatcher.RemoveListener(TestEvent.Event00, Listener); _dispatcher.Dispatch(TestEvent.Event00); Assert.AreEqual(1, _counter); }
public static void ListenOnceForOne(this IEventDispatcher dispatcher, params BaseEventListener[] listeners) { bool returned = false; for (int i = 0; i < listeners.Length; i++) { BaseEventListener listener = listeners[i]; if (listener is DispatcherBaseEventListener) { (listener as DispatcherBaseEventListener).SetDispatcher(dispatcher); } listener.proxy = evt => { if (returned) { return; } returned = true; for (int j = 0; j < listeners.Length; j++) { dispatcher.RemoveListener(listeners[j].returnEvent, listener.proxy); } listener.Callback(evt); }; dispatcher.AddListener(listeners[i].returnEvent, listener.proxy); } }
/// <summary> /// Trigged before booting. /// </summary> protected virtual void BeforeBootstrap(IApplication application) { dispatcher.AddListener(ApplicationEvents.OnStartCompleted, (sender, args) => { OnStartCompleted((IApplication)sender, (StartCompletedEventArgs)args); }); }
public void AddAndDispatchTest() { var count = 0; void Handler() { count++; } _dispatcher.AddListener(TestEvent.Event00, Handler); _bus.Add(TestEvent.Event00); Assert.AreEqual(0, count); _bus.Dispatch(); Assert.AreEqual(1, count); }
/// Remove a previously registered observer with exactly one argument from this Dispatcher public static void AddListenerStrangeEvent(object evt, EventCallback callback) { if (strangeDispatcher == null && instance != null && instance.context != null) { if ((instance.context as MainContextInput).dispatcher != null) { strangeDispatcher = (instance.context as MainContextInput).dispatcher; } } if (strangeDispatcher != null) { strangeDispatcher.AddListener(evt, callback); } else { Debug.LogError("strangeDispatcher Not Redy"); } }
public MonsterGenerator(GameConfig gameConfig, EnemySystem enemySystem) { _dispatcher = Singleton.instance.notificationDispatcher; // TODO: Klean it up! _dispatcher.AddListener(GameplayEventType.ENEMY_KILLED, onEnemyKilled); _dispatcher.AddListener(GameplayEventType.GAME_COMPLETE, OnGameComplete); _levelConfig = gameConfig.levelConfig; _enemySystem = enemySystem; if (_levelConfig.levels.Count == 0) { Debug.LogError("NO LEVELS LOADED IN LEVEL CONFIG!"); } else { _levelDef = _levelConfig.levels[0]; } }
public static void ListenOnceForOne <E>(this IEventDispatcher dispatcher, object returnEvent, Action <E> callback) { EventCallback intermediary = null; intermediary = evt => { dispatcher.RemoveListener(returnEvent, intermediary); callback.Invoke((E)evt.data); }; dispatcher.AddListener(returnEvent, intermediary); }
public static void ListenOnceForOne(this IEventDispatcher dispatcher, object returnEvent, EventCallback callback) { EventCallback intermediary = null; intermediary = evt => { dispatcher.RemoveListener(returnEvent, intermediary); callback.Invoke(evt); }; dispatcher.AddListener(returnEvent, intermediary); }
public static void ListenOnceAndRedirect(this IEventDispatcher dispatcher, object returnEvent, object redirectToEvent) { EventCallback intermediary = null; intermediary = evt => { dispatcher.RemoveListener(returnEvent, intermediary); dispatcher.Dispatch(redirectToEvent, evt.data); }; dispatcher.AddListener(returnEvent, intermediary); }
public void OrderTest() { void Listener01() { _counter++; Assert.AreEqual(1, _counter); } void Listener02() { _counter++; Assert.AreEqual(2, _counter); } void Listener03() { _counter++; Assert.AreEqual(3, _counter); } _dispatcher.AddListener(TestEvent.Event00, Listener01); _dispatcher.AddListener(TestEvent.Event00, Listener02); _dispatcher.AddListener(TestEvent.Event00, Listener03); _dispatcher.Dispatch(TestEvent.Event00); Assert.AreEqual(3, _counter); }
public void TestBootstrapSkip() { var foo = new Mock <IBootstrap>(); var bar = new Mock <IBootstrap>(); dispatcher.AddListener(ApplicationEvents.OnBooting, eventArgs => { if (eventArgs is BootingEventArgs args && args.GetBootstrap() == foo.Object) { args.Skip(); } });
public void Retrieve_Bootstrap_Event_Retrieves_Setting() { bool isNull = true; _dispatcher.AddListener <RetrieveBootstrapSettingEvent>(RetrieveBootstrapSettingEvent.Type.Got, (evt) => { isNull = evt.SettingValue == null; }); _dispatcher.Dispatch(new RetrieveBootstrapSettingEvent(RetrieveBootstrapSettingEvent.Type.Get, "Environment", typeof(Environment))); Assert.IsFalse(isNull); }
public void TestBridgeChildToParent() { ChildOne.crossContextBridge.Bind(SomeEnum.ONE); IEventDispatcher childDispatcher = ChildOne.injectionBinder.GetInstance <IEventDispatcher> (ContextKeys.CONTEXT_DISPATCHER) as IEventDispatcher; IEventDispatcher parentDispatcher = Parent.injectionBinder.GetInstance <IEventDispatcher> (ContextKeys.CONTEXT_DISPATCHER) as IEventDispatcher; parentDispatcher.AddListener(SomeEnum.ONE, testCallback); TestDelegate testDelegate = delegate() { childDispatcher.Dispatch(SomeEnum.ONE); }; Assert.Throws <CCBTestPassedException> (testDelegate); ChildOne.crossContextBridge.Unbind(SomeEnum.ONE); Assert.DoesNotThrow(testDelegate); }
public void TestBridgeChildToChild() { ChildTwo.crossContextBridge.Bind(SomeEnum.ONE); //Note: binding in one Context... IEventDispatcher childOneDispatcher = ChildOne.injectionBinder.GetInstance <IEventDispatcher> (ContextKeys.CONTEXT_DISPATCHER) as IEventDispatcher; IEventDispatcher childTwoDispatcher = ChildTwo.injectionBinder.GetInstance <IEventDispatcher> (ContextKeys.CONTEXT_DISPATCHER) as IEventDispatcher; childTwoDispatcher.AddListener(SomeEnum.ONE, testCallback); TestDelegate testDelegate = delegate() { childOneDispatcher.Dispatch(SomeEnum.ONE); }; Assert.Throws <CCBTestPassedException> (testDelegate); ChildOne.crossContextBridge.Unbind(SomeEnum.ONE); //...unbinding in another Assert.DoesNotThrow(testDelegate); }
public WaitEvent(IEventDispatcher dispatcher, string EventType, object thisObj, string callName, object[] paramList = null, bool checkSame = true) { if (checkSame) { for (int i = 0; i < list.Count; i++) { if (list[i].dispatcher == dispatcher && list[i].EventType == EventType && list[i].thisObj == thisObj && list[i].callName == callName) { return; } } } this.dispatcher = dispatcher; this.EventType = EventType; this.thisObj = thisObj; this.callName = callName; this.paramList = paramList; dispatcher.AddListener(EventType, OnListenerBack); list.Add(this); }
public static UniRx.IObservable <object> ToObservable(this IEventDispatcher dispatcher, object[] returns) { if (returns == null || returns.Length == 0) { throw new ArgumentNullException("returns not valid"); } Subject <object> notYetReturned = new Subject <object>(); List <object> returnsLeft = new List <object>(returns); for (int i = 0; i < returns.Length; i++) { object ret = returns[i]; EmptyCallback handler = null; handler = () => { if (!returnsLeft.Contains(ret)) { throw new Exception("Something went wrong..."); } dispatcher.RemoveListener(ret, handler); returnsLeft.Remove(ret); notYetReturned.OnNext(ret); if (returnsLeft.Count == 0) { notYetReturned.OnCompleted(); } }; dispatcher.AddListener(ret, handler); } return(notYetReturned); }
public void TestBridgeChildToParent() { ChildOne.crossContextBridge.Bind(SomeEnum.ONE); IEventDispatcher childDispatcher = ChildOne.injectionBinder.GetInstance <IEventDispatcher> (ContextKeys.CONTEXT_DISPATCHER) as IEventDispatcher; IEventDispatcher parentDispatcher = Parent.injectionBinder.GetInstance <IEventDispatcher> (ContextKeys.CONTEXT_DISPATCHER) as IEventDispatcher; parentDispatcher.AddListener(SomeEnum.ONE, testCallback); int sentValue1 = 42; int sentValue2 = 43; childDispatcher.Dispatch(SomeEnum.ONE, sentValue1); Assert.AreEqual(sentValue1, testValue); ChildOne.crossContextBridge.Unbind(SomeEnum.ONE); childDispatcher.Dispatch(SomeEnum.ONE, sentValue2); Assert.AreEqual(sentValue1, testValue); //Unit-test wise, this is a bit of a cheat, but it assures me that //all Events are returned to the EventDispatcher pool Assert.AreEqual(0, EventDispatcher.eventPool.instanceCount - EventDispatcher.eventPool.available); }
/// <summary> /// Static implementation of <see cref="EventDispatcher.AddListener(Type, Action)"/> /// </summary> /// <param name="type">The type of the event.</param> /// <param name="handler">The handler.</param> public static void AddListener(Type type, Action handler) { eventDispacher.AddListener(type, handler); }
public void Init() { _dispatcher.AddListener(GameplayEventType.LOOT_PICKED_UP, onLootPickedUp); }
public void Map <T1, T2, T3>(IEventDispatcher dispatcher, Event <T1, T2, T3> @event, Action <T1, T2, T3> listener) { dispatcher.AddListener(@event, listener); AddMapInfo(dispatcher, @event, listener, dispatcher.RemoveListener); }
protected void OnEnable() { // Subscribe to the ExampleEvent, using OnExampleEvent as a callback eventDispatcher.AddListener <ExampleEvent>(OnExampleEvent); }
public void Map(IEventDispatcher dispatcher, Event @event, Action listener) { dispatcher.AddListener(@event, listener); AddMapInfo(dispatcher, @event, listener, dispatcher.RemoveListener); }
public void TestAddListeners() { var listener = new Mock <EventHandler>(); dispatcher.AddListener("foo", listener.Object); dispatcher.Dispatch("foo", this, eventArgs.Object); listener.Verify((o) => o.Invoke(this, eventArgs.Object), Times.Once); }
/* * Event Dispatcher. */ public void AddListener(Event @event, Action listener) { _dispatcher.AddListener(@event, listener); }
public void MapCommand <TEvent, TCommand>() where TEvent : AbstractEvent where TCommand : ICommand { //Debug.LogWarning("<color=\"green\">" + this + "MapCommand : " + typeof(TEvent) + "</color>"); _eventToCommandMap[typeof(TEvent)] = typeof(TCommand); _observer.AddListener <TEvent>(EventHandler <TEvent>); }
public void TestAddListenerNoArgs() { dispatcher.AddListener(SomeEnum.ONE, noArgumentsMethod); Assert.IsTrue(dispatcher.HasListener(SomeEnum.ONE, noArgumentsMethod)); }