protected void ResolveHook(EventHooks eventHooks, string start)
{
TraceUtils.WithScope(traceScope =>
{
if (eventHooks.OnProvisioning)
{
if (!ShowOnlyFalseResults)
{
traceScope.WriteLine(string.Format("[INF]{0} [VALIDATED] - [OnProvisioning]", start));
}
}
else
{
traceScope.WriteLine(string.Format("[ERR]{0} [MISSED] - [OnProvisioning]", start));
}
if (eventHooks.OnProvisioned)
{
if (!ShowOnlyFalseResults)
{
traceScope.WriteLine(string.Format("[INF]{0} [VALIDATED] - [OnProvisioned]", start));
}
}
else
{
traceScope.WriteLine(string.Format("[IERR]{0} [MISSED] - [OnProvisioned]", start));
}
AssertService.AreEqual(true, eventHooks.OnProvisioning);
AssertService.AreEqual(true, eventHooks.OnProvisioned);
});
}
public void AddHook(string id, EventHooks hooks)
{
if (!_hookMap.ContainsKey(id))
{
_hookMap.Add(id, hooks);
}
}
internal void CopyTo(EventHooks eventHooks)
{
eventHooks.BeforeMessageSent.AddRange(_beforeMessageSent);
eventHooks.AfterMessageSent.AddRange(_afterMessageSent);
eventHooks.BeforeMessageHandled.AddRange(_beforeMessageHandled);
eventHooks.AfterMessageHandled.AddRange(_afterMessageHandled);
}
public new void InitializeMainMenu()
{
orig_InitializeMainMenu();
if (!_Notified)
{
EventHooks.InvokeMainMenuLoadedFirstTime(this);
}
_Notified = true;
}
protected virtual void WithEventHooks(Action <EventHooks> hooks)
{
TraceUtils.WithScope(traceScope =>
{
traceScope.WriteLine(string.Format("Validating OnProvisioning/OnProvisioned events."));
var eventHooks = new EventHooks();
hooks(eventHooks);
traceScope.WriteLine(string.Format("Validating OnProvisioning event hit."));
Assert.AreEqual(true, eventHooks.OnProvisioning);
traceScope.WriteLine(string.Format(" - done"));
traceScope.WriteLine(string.Format("Validating OnProvisioned event hit."));
Assert.AreEqual(true, eventHooks.OnProvisioned);
traceScope.WriteLine(string.Format(" - done"));
});
}
protected virtual void AssertEventHooks <TObj>(ModelNode modelNode, EventHooks hooks)
{
modelNode.OnProvisioning <TObj>(context =>
{
hooks.OnProvisioning = true;
Assert.IsNotNull(context.ObjectDefinition);
});
modelNode.OnProvisioned <TObj>(context =>
{
hooks.OnProvisioned = true;
Assert.IsNotNull(context.Object);
Assert.IsNotNull(context.ObjectDefinition);
Assert.IsInstanceOfType(context.Object, typeof(TObj));
});
}
protected virtual void AssertEventHooksByStringType(string spType, ModelNode modelNode, EventHooks hooks)
{
var spObjectType = Type.GetType(spType);
var modelContextType = typeof(OnCreatingContext <,>);
AddHook(spObjectType.AssemblyQualifiedName + ":" + modelNode.Value.GetHashCode().ToString(), hooks);
var nonDefinition = new Type[] { spObjectType, typeof(DefinitionBase) };
var withDefinition = new Type[] { spObjectType, modelNode.Value.GetType() };
var modelNonDefInstanceType = modelContextType.MakeGenericType(nonDefinition);
var modelWithDefInstanceType = modelContextType.MakeGenericType(withDefinition);
var genericAction = typeof(Action <>);
HandlerOnProvisioningHook(modelNode, spObjectType, nonDefinition);
HandlerOnProvisionedHook(modelNode, spObjectType, nonDefinition);
}
public HookHandler(object container, string eventName, EventHooks hooks)
: base(container, eventName, hooks)
{
}
protected BaseHookHandler(object container, string eventName, EventHooks hooks)
{
this.hooks = hooks;
this.container = container;
this.eventName = eventName;
}
private void Awake()
{
Loader.Logger.Info("Mod the Gungeon entry point");
EventHooks.InvokeGameStarted();
Backend.GameObject = new GameObject("Mod the Gungeon");
var asm = Assembly.GetExecutingAssembly();
var types = asm.GetTypes();
for (int i = 0; i < types.Length; i++)
{
var type = types[i];
if (type.IsSubclassOf(typeof(Backend)))
{
var backend = (Backend)Backend.GameObject.AddComponent(type);
DontDestroyOnLoad(backend);
Backend.AllBackends.Add(new Backend.Info {
Name = type.Name,
StringVersion = backend.StringVersion,
Version = backend.Version,
Type = type,
Instance = backend
});
try {
backend.NoBackendsLoadedYet();
} catch (Exception e) {
Loader.Logger.Error($"Exception while pre-loading backend {type.Name}: [{e.GetType().Name}] {e.Message}");
foreach (var l in e.StackTrace.Split('\n'))
{
Loader.Logger.ErrorIndent(l);
}
}
}
}
for (int i = 0; i < Backend.AllBackends.Count; i++)
{
var backend = Backend.AllBackends[i];
Loader.Logger.Info($"Initializing backend {backend.Name} {backend.StringVersion}");
try {
backend.Instance.Loaded();
} catch (Exception e) {
Loader.Logger.Error($"Exception while loading backend {backend.Name}: [{e.GetType().Name}] {e.Message}");
foreach (var l in e.StackTrace.Split('\n'))
{
Loader.Logger.ErrorIndent(l);
}
}
}
for (int i = 0; i < Backend.AllBackends.Count; i++)
{
try {
Backend.AllBackends[i].Instance.AllBackendsLoaded();
} catch (Exception e) {
Loader.Logger.Error($"Exception while post-loading backend {Backend.AllBackends[i].Name}: [{e.GetType().Name}] {e.Message}");
foreach (var l in e.StackTrace.Split('\n'))
{
Loader.Logger.ErrorIndent(l);
}
}
}
if (Environment.GetEnvironmentVariable("ModTheGungeon_DUMP_ASSETS") == "1")
{
DumpAssets();
}
orig_Awake();
}
