private static void Init(Action orig)
{
orig();
HookAttribute.DisableHooks(typeof(SceneCatalogHooks));
var lookups = SceneCatalog.allSceneDefs.ToDictionary(sd => sd.baseSceneName);
Logger.LogInfo("Lodded dictionary for sceneNameOverride doping");
var sceneDefinitions = RainOfStages.Instance.SceneDefinitions.OfType <SceneDefinition>();
var overrideMapping = MakeLinks(sceneDefinitions, def => def.reverseSceneNameOverrides);
var destinationsMapping = MakeLinks(sceneDefinitions, def => def.destionationInjections);
Weave(lookups, overrideMapping,
sd => sd.Destination.baseSceneName,
sd => sd.sceneNameOverrides,
(sd, data) => sd.sceneNameOverrides = data.ToList());
Weave(lookups, destinationsMapping,
sd => sd.Destination,
sd => sd.destinations,
(sd, data) => sd.destinations = data.ToArray());
}
public override void SetHook(HookInfo info)
{
if (HookInfos.Count > 0)
{
throw new InvalidOperationException("JumpHook can not mix with other hook");
}
base.SetHook(info);
HookAttribute hook = info.GetHookAttribute();
switch (hook.Type)
{
case HookType.SimpleJumpToRet:
int address = (int)info.GetReturnValue();
Logger.Log("jump to address: 0x{0:X}", address);
ASMWriter.WriteJump(new JumpStruct(hook.Address, address));
break;
case HookType.DirectJumpToHook:
int callable = (int)info.GetCallable();
Logger.Log("jump to callable: 0x{0:X}", callable);
ASMWriter.WriteJump(new JumpStruct(hook.Address, callable));
break;
default:
Logger.LogError("found unkwnow jump hook: " + info.Member.Name);
break;
}
}
static SceneDefReference()
{
if (Application.isEditor)
{
return;
}
HookAttribute.ApplyHooks <SceneDefReference>();
}
private HookMetaData BuildMethodHookType(HookAttribute hookAttrib, MethodInfo method)
{
if (method.GetParameters().Any())
{
var message = string.Format("Method {0} on class {1} may not have any parameters.", method.Name, method.DeclaringType.Name);
throw new ArgumentException(message, "method");
}
return(new MethodHookMetaData(method, hookAttrib));
}
private HookMetaData BuildDelegateHookType(HookAttribute hookAttrib, FieldInfo @delegate)
{
if (@delegate.FieldType != typeof(Action))
{
var message = string.Format("Field {0} with attribute {1} must be of type SystemAction.", @delegate.Name, hookAttrib.GetType().Name);
throw new ArgumentException(message, "delegate");
}
var obj = GetInstance(@delegate);
var action = (Action)@delegate.GetValue(obj);
return(new DelegateHookMetaData(action, hookAttrib));
}
public override void SetHook(HookInfo info)
{
if (HookInfos.Count > 0)
{
throw new InvalidOperationException("WriteBytesHook can not mix with other hook");
}
base.SetHook(info);
HookAttribute hook = info.GetHookAttribute();
var bytes = info.GetReturnValue() as byte[];
Logger.Log("write bytes: [{0}]", string.Join(", ", bytes));
MemoryHelper.Write(hook.Address, bytes, bytes.Length);
}
private void BuildEventBindingFromMethod(MethodInfo method, HookAttribute hookAttr)
{
CheckEventBindingMethod(hookAttr.Event, method);
ApplyForScope(method,
scope =>
{
var eventBinding = bindingFactory.CreateEventBinding(method, scope);
GetEvents(hookAttr.Event).Add(eventBinding);
},
hookAttr.Tags == null
? null
: hookAttr.Tags.Select(tag => new ScopeAttribute {
Tag = tag
})
);
}
public override void SetHook(HookInfo info)
{
base.SetHook(info);
HookAttribute hook = MaxHookInfo.GetHookAttribute();
var callable = (int)MaxHookInfo.GetCallable();
Logger.Log("ares hook callable: 0x{0:X}", callable);
int pMemory = (int)GetMemory(code_call.Length + hook.Size + ASM.Jmp.Length);
Logger.Log("AresHookTransferStation alloc: 0x{0:X}", pMemory);
if (pMemory != (int)IntPtr.Zero)
{
MemoryHelper.Write(pMemory, code_call, code_call.Length);
MemoryHelper.Write(pMemory + 3, hook.Address);
ASMWriter.WriteCall(new JumpStruct(pMemory + 0xF, callable));
var origin_code_offset = pMemory + code_call.Length;
if (hook.Size > 0)
{ // write origin code
MemoryHelper.Write(origin_code_offset, code_over, hook.Size);
// protect relative jmp or call
if (code_over[0] == ASM.Jmp[0] || code_over[0] == ASM.Call[0])
{
int destination = 0;
MemoryHelper.Read(hook.Address + 1, ref destination);
destination = hook.Address + 5 + destination;
MemoryHelper.Write(origin_code_offset + 1, new JumpStruct(origin_code_offset, destination).Offset);
}
}
var jmp_back_offset = origin_code_offset + hook.Size;
ASMWriter.WriteJump(new JumpStruct(jmp_back_offset, hook.Address + hook.Size));
ASMWriter.WriteJump(new JumpStruct(hook.Address, pMemory));
ASMWriter.FlushInstructionCache(pMemory, memoryHandle.Size);
}
}
private static void Init(Action orig)
{
orig();
HookAttribute.DisableHooks(typeof(SceneCatalogHooks));
var lookups = SceneCatalog.allSceneDefs.ToDictionary(sd => sd.baseSceneName);
Logger.LogInfo("Lodded dictionary for sceneNameOverride doping");
var sceneDefinitions = RainOfStages.Instance.SceneDefinitions.OfType <SceneDefinition>();
{
var maps = sceneDefinitions.SelectMany(destination => destination.destionationInjections.Select(origin => (destination, origin)));
var mapGroups = maps.GroupBy(map => map.origin.baseSceneName);
foreach (var mapGroup in mapGroups)
{
var destinations = lookups[mapGroup.Key].destinations = lookups[mapGroup.Key].destinations.Union(mapGroup.Select(map => map.destination as SceneDef)).Distinct().ToArray();
foreach (var destination in destinations)
{
Logger.LogMessage($"Added destination {destination.baseSceneName} to SceneDef {mapGroup.Key}");
}
}
}
{
var maps = sceneDefinitions.SelectMany(loadedSceneDef => loadedSceneDef.reverseSceneNameOverrides.Select(overridedScene => (loadedSceneDef, overridedScene)));
var mapGroups = maps.GroupBy(map => map.overridedScene.baseSceneName);
foreach (var mapGroup in mapGroups)
{
var overridingScenes = lookups[mapGroup.Key].sceneNameOverrides = lookups[mapGroup.Key].sceneNameOverrides.Union(mapGroup.Select(map => map.loadedSceneDef.baseSceneName)).Distinct().ToList();
foreach (var overridingScene in overridingScenes)
{
Logger.LogMessage($"Added override {overridingScene} to SceneDef {mapGroup.Key}");
}
}
}
}
public static void Init()
{
if (IsInitialized)
{
return;
}
IsInitialized = true;
const BindingFlags bf_All = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
MethodInfo[] methods = ModContent.Types.ModContentHooks.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Static);
Type t_Hooks = typeof(ModContentHooks);
Type t_HookAttribute = typeof(HookAttribute);
for (int i = 0; i < methods.Length; i++)
{
MethodInfo mHook = methods[i];
object[] mHookInfos = mHook.GetCustomAttributes(t_HookAttribute, true);
if (mHookInfos.Length == 0)
{
continue;
}
HookAttribute mHookInfo = (HookAttribute)mHookInfos[0];
ParameterInfo[] args = mHook.GetParameters();
Type[] argTypes = new Type[args.Length];
for (int ai = 0; ai < args.Length; ai++)
{
argTypes[ai] = args[ai].ParameterType;
}
MethodInfo mTarget = mHookInfo.Type.GetMethod(mHook.Name, bf_All, null, argTypes, null);
MethodInfo mTrampoline = t_Hooks.GetMethod("t_" + mHook.Name, bf_All, null, argTypes, null);
mTarget.Detour(mHook);
mTrampoline.Detour(mTarget.CreateOrigTrampoline());
}
}
private MethodInfo GetTestHook(Type attributeType)
{
HookAttribute hook = (HookAttribute)Attribute.GetCustomAttribute(_type, attributeType);
return(_type.GetMethod(hook.Method));
}
protected HookMetaData(HookAttribute hookAttrib)
{
HookAttrib = hookAttrib;
}
public MethodHookMetaData(MethodInfo method, HookAttribute hookAttrib)
: base(hookAttrib)
{
this.method = method;
instance = Activator.CreateInstance(method.DeclaringType);
}
public DelegateHookMetaData(Action action, HookAttribute hookAttrib)
: base(hookAttrib)
{
this.action = action;
}
private void BuildEventBindingFromMethod(MethodInfo method, HookAttribute hookAttr)
{
CheckEventBindingMethod(hookAttr.Event, method);
ApplyForScope(method,
scope =>
{
var eventBinding = bindingFactory.CreateEventBinding(new RuntimeBindingMethod(method), scope);
GetHookList(hookAttr.Event).Add(eventBinding);
},
hookAttr.Tags == null
? null
: hookAttr.Tags.Select(tag => new ScopeAttribute { Tag = tag })
);
}
