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