void CopyTo(CustomAttribute target, ModuleDefinition context) { foreach (var arg in ConstructorArguments) target.ConstructorArguments.Add(new CustomAttributeArgument(context.ImportReference(arg.Type), arg.Value)); foreach (var field in Fields) target.Fields.Add(new CustomAttributeNamedArgument(field.Name, new CustomAttributeArgument(context.ImportReference(field.Argument.Type), field.Argument.Value))); foreach (var prop in Properties) target.Properties.Add(new CustomAttributeNamedArgument(prop.Name, new CustomAttributeArgument(context.ImportReference(prop.Argument.Type), prop.Argument.Value))); }
public override void InjectInto(ModuleDefinition gamedef, ModuleDefinition moddef) { // This injects a call to the mod's static Init() method into the top of the game's central Provider Awake method. // Our mod init will run before anything else in the assembly due to this. TypeDefinition modtype = moddef.GetType("UnturnedFrenetic.UnturnedFreneticMod"); MethodReference initmethod = gamedef.ImportReference(GetMethod(modtype, "Init", 0)); MethodReference initmethod2 = gamedef.ImportReference(GetMethod(modtype, "InitSecondary", 0)); TypeDefinition providertype = gamedef.GetType("SDG.Unturned.Provider"); MethodDefinition awakemethod = GetMethod(providertype, "Awake"); MethodBody awakebody = awakemethod.Body; // Call: the mod initialization. awakebody.Instructions.Insert(0, Instruction.Create(OpCodes.Call, initmethod)); // Call: the mod secondary initialization. awakebody.Instructions.Insert(117, Instruction.Create(OpCodes.Call, initmethod2)); }
public override void InjectInto(ModuleDefinition gamedef, ModuleDefinition moddef) { // This injects a call to the mod's static AnimalDamaged method for the AnimalDamagedScriptEvent TypeDefinition modtype = moddef.GetType("UnturnedFrenetic.UnturnedFreneticMod"); MethodReference eventmethod = gamedef.ImportReference(GetMethod(modtype, "AnimalDamaged", 4)); TypeDefinition animaltype = gamedef.GetType("SDG.Unturned.Animal"); MethodDefinition damagemethod = GetMethod(animaltype, "askDamage", 4); MethodBody damagebody = damagemethod.Body; InjectInstructions(damagebody, 0, new Instruction[] { // Load "this" onto the stack. Instruction.Create(OpCodes.Ldarg_0), // Load "amount" onto the stack. Instruction.Create(OpCodes.Ldarga_S, damagemethod.Parameters[0]), // Load "newRagdoll" onto the stack. Instruction.Create(OpCodes.Ldarga_S, damagemethod.Parameters[1]), // Load "xp" onto the stack Instruction.Create(OpCodes.Ldarga_S, damagemethod.Parameters[3]), // Call the AnimalDamaged method with the above parameters and return a bool. Instruction.Create(OpCodes.Call, eventmethod), // If the return is false, jump ahead to the original 0th instruction. Instruction.Create(OpCodes.Brfalse, damagebody.Instructions[0]), // Otherwise, return now. Instruction.Create(OpCodes.Ret) }); }
public void Rewrite(ModuleDefinition module, IEnumerable<ImplementedEventSource> loggers) { var fullNameOfGet = module .ImportReference(typeof(Enyim.EventSourceFactory)).Resolve() .FindMethod("Get").FullName; var methods = module.Types.SelectMany(t => t.Methods).Where(m => m.HasBody).ToArray(); var implMap = loggers.ToDictionary(l => l.Old.FullName); var localRemap = new Dictionary<string, TypeDefinition>(); foreach (var method in methods) { var factoryCalls = (from i in method.GetOpsOf(OpCodes.Call) let mr = i.Operand as MethodReference where mr.IsGenericInstance && mr.Resolve() ?.GetElementMethod() ?.FullName == fullNameOfGet select new { Instruction = i, Wanted = ((GenericInstanceMethod)mr).GenericArguments.First().Resolve() }).ToArray(); if (factoryCalls.Length > 0) { var ilp = method.Body.GetILProcessor(); foreach (var tmp in factoryCalls) { ImplementedEventSource ies; var rewriteTo = tmp.Wanted.IsClass ? tmp.Wanted.Resolve() : implMap.TryGetValue(tmp.Wanted.FullName, out ies) ? ies.New : null; if (rewriteTo == null) { Log.Warn($"Factory: cannot rewrite {tmp.Wanted.FullName}"); continue; } var ctor = rewriteTo.FindConstructor(); if (ctor == null) throw new InvalidOperationException($"{rewriteTo.FullName} has no constructor"); var newobj = Instruction.Create(OpCodes.Newobj, ctor); newobj.SequencePoint = tmp.Instruction.SequencePoint; ilp.Replace(tmp.Instruction, newobj); Log.Info($"Factory: {tmp.Wanted.FullName} -> {rewriteTo.FullName}"); localRemap[tmp.Wanted.FullName] = rewriteTo; } } RewriteLocalVariables(method, localRemap); } }
public static Mono.Cecil.TypeReference ToMonoTypeReference(this System.Type type) { String kernel_assembly_file_name = type.Assembly.Location; Mono.Cecil.ModuleDefinition md = Mono.Cecil.ModuleDefinition.ReadModule(kernel_assembly_file_name); var reference = md.ImportReference(type); return(reference); }
public void Add(MethodInfo reference) { String kernel_assembly_file_name = reference.DeclaringType.Assembly.Location; Mono.Cecil.ModuleDefinition md = Campy.Meta.StickyReadMod.StickyReadModule(kernel_assembly_file_name); MethodReference refer = md.ImportReference(reference); Add(refer); }
public override void InjectInto(ModuleDefinition gamedef, ModuleDefinition moddef) { // This injects a call to the mod's static ZombieDamaged method for the ZombieDamagedScriptEvent. Also exposes some zombie variables. Also, disable its AI optionally. TypeDefinition zombietype = gamedef.GetType("SDG.Unturned.Zombie"); FieldDefinition field = GetField(zombietype, "target"); field.IsPrivate = false; field.IsPublic = true; FieldDefinition fieldistick = GetField(zombietype, "isTicking"); fieldistick.IsPrivate = false; fieldistick.IsPublic = true; FieldDefinition fieldseeker = GetField(zombietype, "seeker"); fieldseeker.IsPrivate = false; fieldseeker.IsPublic = true; FieldDefinition fieldpath = GetField(zombietype, "path"); fieldpath.IsPrivate = false; fieldpath.IsPublic = true; FieldDefinition aidisabledfield = new FieldDefinition("UFM_AIDisabled", FieldAttributes.Public, gamedef.TypeSystem.Boolean); zombietype.Fields.Add(aidisabledfield); foreach (MethodDefinition tmethod in zombietype.Methods) { switch (tmethod.Name) { case "alert": DisableAI(tmethod.Body, aidisabledfield); break; default: break; } } // TODO: Disable things in the update methods too. TypeDefinition modtype = moddef.GetType("UnturnedFrenetic.UnturnedFreneticMod"); MethodReference eventmethod = gamedef.ImportReference(GetMethod(modtype, "ZombieDamaged", 4)); MethodDefinition damagemethod = GetMethod(zombietype, "askDamage", 4); MethodBody damagebody = damagemethod.Body; InjectInstructions(damagebody, 0, new Instruction[] { // Load "this" onto the stack. Instruction.Create(OpCodes.Ldarg_0), // Load "amount" onto the stack. Instruction.Create(OpCodes.Ldarga_S, damagemethod.Parameters[0]), // Load "newRagdoll" onto the stack. Instruction.Create(OpCodes.Ldarga_S, damagemethod.Parameters[1]), // Load "xp" onto the stack Instruction.Create(OpCodes.Ldarga_S, damagemethod.Parameters[3]), // Call the ZombieDamaged method with the above parameters and return a bool. Instruction.Create(OpCodes.Call, eventmethod), // If the return is false, jump ahead to the original 0th instruction. Instruction.Create(OpCodes.Brfalse, damagebody.Instructions[0]), // Otherwise, return now. Instruction.Create(OpCodes.Ret) }); }
public override void InjectInto(ModuleDefinition gamedef, ModuleDefinition moddef) { // This injects a debug output message to the "debug" command, as well as allowing execution // of Frenetic command via the debug command. // To use, simple input: debug echo "Hello world!" // Replace the command after debug with any valid Frenetic-enabled command. TypeDefinition debugtype = gamedef.GetType("SDG.Unturned.CommandDebug"); MethodDefinition method = GetMethod(debugtype, "execute"); TypeDefinition modmaintype = moddef.GetType("UnturnedFrenetic.UnturnedFreneticMod"); MethodDefinition modruncommands = GetMethod(modmaintype, "RunCommands", 1); MethodReference game_modruncommands = gamedef.ImportReference(modruncommands); TypeDefinition windowtype = gamedef.GetType("SDG.Unturned.CommandWindow"); MethodDefinition logmethod = GetMethod(windowtype, "Log", 1); MethodDefinition isnullorempty = GetMethod(gamedef.TypeSystem.String.Resolve(), "IsNullOrEmpty", 1); MethodReference game_isnullorempty = gamedef.ImportReference(isnullorempty); MethodBody body = method.Body; Instruction ldstr = Instruction.Create(OpCodes.Ldstr, "Frenetic loaded properly!"); InjectInstructions(body, 3, new Instruction[] { // Load the parameter onto the stack. Instruction.Create(OpCodes.Ldarg_S, method.Parameters[1]), // Add whether the string 'is null or empty' to the stack. Instruction.Create(OpCodes.Call, game_isnullorempty), // Jump to the end if the top of the stack is false. Instruction.Create(OpCodes.Brtrue_S, ldstr), // NOTE: Instruction reference will move at the end. // Load the parameter onto the stack. Instruction.Create(OpCodes.Ldarg_S, method.Parameters[1]), // Run commands based on the string on top of the stack. Instruction.Create(OpCodes.Call, game_modruncommands), // Return so we don't get random debug spam. Instruction.Create(OpCodes.Ret), // Load the output string onto the stack. ldstr, // Log the string. Instruction.Create(OpCodes.Call, logmethod) }); // Redirect the result of the IF to our new method. body.Instructions[1].Operand = body.Instructions[3]; }
private void Add(MethodInfo method_info) { String kernel_assembly_file_name = method_info.DeclaringType.Assembly.Location; string p = Path.GetDirectoryName(kernel_assembly_file_name); var resolver = new DefaultAssemblyResolver(); resolver.AddSearchDirectory(p); Mono.Cecil.ModuleDefinition md = Mono.Cecil.ModuleDefinition.ReadModule( kernel_assembly_file_name, new ReaderParameters { AssemblyResolver = resolver, ReadSymbols = true }); MethodReference method_reference = md.ImportReference(method_info); Add(method_reference); }
private static void JustImport(SimpleKernel simpleKernel) { System.Reflection.MethodInfo method_info = simpleKernel.Method; String kernel_assembly_file_name = method_info.DeclaringType.Assembly.Location; Mono.Cecil.ModuleDefinition md = Campy.Meta.StickyReadMod.StickyReadModule( kernel_assembly_file_name, new ReaderParameters { ReadSymbols = true }); MethodReference method_reference = md.ImportReference(method_info); Campy.Utils.TimePhase.Time("compile ", () => { Singleton._compiler.ImportOnlyCompile(method_reference, simpleKernel.Target); }); }
public override void InjectInto(ModuleDefinition gamedef, ModuleDefinition moddef) { // This injects a call to the mod's static Init() method into the top of the game's central Provider Awake method. // Our mod init will run before anything else in the assembly due to this. TypeDefinition modtype = moddef.GetType("UnturnedFrenetic.UnturnedFreneticMod"); MethodReference connectingmethod = gamedef.ImportReference(GetMethod(modtype, "PlayerConnecting", 1)); TypeDefinition providertype = gamedef.GetType("SDG.Unturned.Provider"); MethodDefinition validatemethod = GetMethod(providertype, "handleValidateAuthTicketResponse", 1); MethodBody validatebody = validatemethod.Body; // Call: the mod's wrapper method. InjectInstructions(validatebody, 45, new Instruction[] { // Load "steamPending" onto the stack. Instruction.Create(OpCodes.Ldloc_0), // "Call the connect method with parameter 'steamPending' and returning a bool. Instruction.Create(OpCodes.Call, connectingmethod), // If the return is false, jump ahead to the original 45th instruction. Instruction.Create(OpCodes.Brfalse, validatebody.Instructions[45]), // Otherwise,return now. Instruction.Create(OpCodes.Ret) }); }
public override void InjectInto(ModuleDefinition gamedef, ModuleDefinition moddef) { // This injects a call to the mod's static PlayerChat method for the PlayerChatScriptEvent TypeDefinition managertype = gamedef.GetType("SDG.Unturned.ChatManager"); FieldDefinition managerfield = GetField(managertype, "manager"); managerfield.IsPrivate = false; managerfield.IsPublic = true; TypeDefinition modtype = moddef.GetType("UnturnedFrenetic.UnturnedFreneticMod"); MethodReference eventmethod = gamedef.ImportReference(GetMethod(modtype, "PlayerChat", 5)); MethodDefinition chatmethod = GetMethod(managertype, "askChat", 3); MethodBody chatbody = chatmethod.Body; // Remove old color handling chatbody.Instructions[53].Operand = chatbody.Instructions[124]; chatbody.Instructions[81].Operand = chatbody.Instructions[124]; chatbody.Instructions[109].Operand = chatbody.Instructions[124]; for (int i = 111; i <= 123; i++) { chatbody.Instructions.RemoveAt(111); } InjectInstructions(chatbody, 27, new Instruction[] { // Load "steamPlayer" onto the stack. Instruction.Create(OpCodes.Ldloc_0), // Load "mode" onto the stack. Instruction.Create(OpCodes.Ldarga_S, chatmethod.Parameters[1]), // Load "eChatMode" onto the stack. Instruction.Create(OpCodes.Ldloca_S, chatbody.Variables[1]), // Load "color" onto the stack. Instruction.Create(OpCodes.Ldloca_S, chatbody.Variables[2]), // Load "text" onto the stack. Instruction.Create(OpCodes.Ldarga_S, chatmethod.Parameters[2]), // Call the PlayerChat method with the above parameters and return a bool. Instruction.Create(OpCodes.Call, eventmethod), // If the return is false, jump ahead to the original 27th instruction. Instruction.Create(OpCodes.Brfalse, chatbody.Instructions[27]), // Otherwise, return now. Instruction.Create(OpCodes.Ret) }); }
public InterfaceBasedTypeDefs(ModuleDefinition module) { const string MS = "Microsoft.Diagnostics.Tracing"; const string SYS = "System.Diagnostics.Tracing"; BaseTypeRef = GuessBaseType(module).ImportInto(module); BaseTypeImpl = BaseTypeRef.Resolve(); WriteEventFallback = BaseTypeImpl.FindMethod("WriteEvent", module.TypeSystem.Int32, module.ImportReference(typeof(object[]))).ImportInto(module); var baseModule = BaseTypeImpl.Module; EventLevel = FindOne(baseModule, "EventLevel", MS, SYS).ImportInto(module); EventKeywords = FindOne(baseModule, "EventKeywords", MS, SYS).ImportInto(module); EventOpcode = FindOne(baseModule, "EventOpcode", MS, SYS).ImportInto(module); EventTask = FindOne(baseModule, "EventTask", MS, SYS).ImportInto(module); EventSourceAttribute = FindOne(baseModule, "EventSourceAttribute", MS, SYS).ImportInto(module); EventAttribute = FindOne(baseModule, "EventAttribute", MS, SYS).ImportInto(module); NonEventAttribute = FindOne(baseModule, "NonEventAttribute", MS, SYS).ImportInto(module); IsEnabledSpecific = BaseTypeImpl.FindMethod("IsEnabled", EventLevel, EventKeywords).ImportInto(module); IsEnabledFallback = BaseTypeImpl.FindMethod("IsEnabled").ImportInto(module); }
public override void InjectInto(ModuleDefinition gamedef, ModuleDefinition moddef) { // This injects a call to the mod's static PlayerShoot method for the PlayerShootScriptEvent TypeDefinition modtype = moddef.GetType("UnturnedFrenetic.UnturnedFreneticMod"); MethodReference eventmethod = gamedef.ImportReference(GetMethod(modtype, "PlayerShoot", 2)); TypeDefinition guntype = gamedef.GetType("SDG.Unturned.UseableGun"); MethodDefinition firemethod = GetMethod(guntype, "fire", 0); MethodBody firebody = firemethod.Body; InjectInstructions(firebody, 0, new Instruction[] { // Load "base.player" onto the stack. Instruction.Create(OpCodes.Ldarg_0), Instruction.Create(OpCodes.Call, GetMethod(gamedef.GetType("SDG.Unturned.PlayerCaller"), "get_player", 0)), // Load "this" onto the stack. Instruction.Create(OpCodes.Ldarg_0), // Call the PlayerShoot method with the above parameters and return a bool. Instruction.Create(OpCodes.Call, eventmethod), // If the return is false, jump ahead to the original 0th instruction. Instruction.Create(OpCodes.Brfalse, firebody.Instructions[0]), // Otherwise, return now. Instruction.Create(OpCodes.Ret) }); }
public static MethodReference ImportEx(this ModuleDefinition module, MethodReference method) { return(module.ImportReference(method)); }
public static Mono.Cecil.TypeReference SubstituteMonoTypeReference(this System.Type type, Mono.Cecil.ModuleDefinition md) { var reference = md.ImportReference(type); return(reference); }
public static FieldReference ImportEx(this ModuleDefinition module, FieldReference field) { return(module.ImportReference(field)); }
private static TypeReference GetTypeRef(string nameSpace, string name, string assemblyName, ModuleDefinition targetModule) { TypeReference typeRef = targetModule.ImportReference(new TypeReference(nameSpace, name, targetModule, targetModule.AssemblyReferences.First(x => x.Name == assemblyName))); return typeRef; }
public override void InjectInto(ModuleDefinition gamedef, ModuleDefinition moddef) { // This injects a call to the mod's static PlayerDamaged method for the PlayerDamagedScriptEvent, and exposes relevant fields. It also adds a new parameter to 'PlayerLife.askDamage'. TypeDefinition lifetype = gamedef.GetType("SDG.Unturned.PlayerLife"); MakePublic(GetField(lifetype, "_health")); MakePublic(GetField(lifetype, "_isBleeding")); MakePublic(GetField(lifetype, "lastBleeding")); MakePublic(GetField(lifetype, "lastBleed")); MakePublic(GetField(lifetype, "_isBroken")); MakePublic(GetField(lifetype, "ragdoll")); TypeDefinition skillstype = gamedef.GetType("SDG.Unturned.PlayerSkills"); MakePublic(GetField(skillstype, "_experience")); MethodDefinition damagemethod = GetMethod(lifetype, "askDamage", 6); ParameterDefinition objectParam = new ParameterDefinition("obj", ParameterAttributes.None, gamedef.ImportReference(typeof(object))); damagemethod.Parameters.Add(objectParam); TypeDefinition modtype = moddef.GetType("UnturnedFrenetic.UnturnedFreneticMod"); MethodReference eventhealmethod = gamedef.ImportReference(GetMethod(modtype, "PlayerHealed", 4)); MethodDefinition healmethod = GetMethod(lifetype, "askHeal", 3); MethodBody healbody = healmethod.Body; InjectInstructions(healbody, 0, new Instruction[] { // Load "base.player" onto the stack. Instruction.Create(OpCodes.Ldarg_0), Instruction.Create(OpCodes.Call, GetMethod(gamedef.GetType("SDG.Unturned.PlayerCaller"), "get_player", 0)), // Load "amount" onto the stack. Instruction.Create(OpCodes.Ldarga_S, healmethod.Parameters[0]), // Load "healBleeding" onto the stack. Instruction.Create(OpCodes.Ldarga_S, healmethod.Parameters[1]), // Load "healBroken" onto the stack. Instruction.Create(OpCodes.Ldarga_S, healmethod.Parameters[2]), // Call the PlayerHealed method with the above parameters and return a bool. Instruction.Create(OpCodes.Call, eventhealmethod), // If the return is false, jump ahead to the original 0th instruction. Instruction.Create(OpCodes.Brfalse, healbody.Instructions[0]), // Otherwise,return now. Instruction.Create(OpCodes.Ret) }); MethodReference eventmethod = gamedef.ImportReference(GetMethod(modtype, "PlayerDamaged", 7)); MethodBody damagebody = damagemethod.Body; InjectInstructions(damagebody, 0, new Instruction[] { // Load "base.player" onto the stack. Instruction.Create(OpCodes.Ldarg_0), Instruction.Create(OpCodes.Call, GetMethod(gamedef.GetType("SDG.Unturned.PlayerCaller"), "get_player", 0)), // Load "amount" onto the stack. Instruction.Create(OpCodes.Ldarga_S, damagemethod.Parameters[0]), // Load "newRagdoll" onto the stack. Instruction.Create(OpCodes.Ldarga_S, damagemethod.Parameters[1]), // Load "newCause" onto the stack. Instruction.Create(OpCodes.Ldarga_S, damagemethod.Parameters[2]), // Load "newLimb" onto the stack. Instruction.Create(OpCodes.Ldarga_S, damagemethod.Parameters[3]), // Load "newKiller" onto the stack. Instruction.Create(OpCodes.Ldarg, damagemethod.Parameters[4]), // Load our custom "obj" onto the stack Instruction.Create(OpCodes.Ldarg, objectParam), // Call the PlayerDamaged method with the above parameters and return a bool. Instruction.Create(OpCodes.Call, eventmethod), // If the return is false, jump ahead to the original 0th instruction. Instruction.Create(OpCodes.Brfalse, damagebody.Instructions[0]), // Otherwise,return now. Instruction.Create(OpCodes.Ret) }); MethodDefinition suicidemethod = GetMethod(lifetype, "askSuicide", 1); MethodBody suicidebody = suicidemethod.Body; // Load "null" onto the stack. InjectInstructions(suicidebody, 19, Instruction.Create(OpCodes.Ldnull)); MethodDefinition landedmethod = GetMethod(lifetype, "onLanded", 1); MethodBody landedbody = landedmethod.Body; // Load "null" onto the stack. InjectInstructions(landedbody, 34, Instruction.Create(OpCodes.Ldnull)); MethodDefinition simulatemethod = GetMethod(lifetype, "simulate", 1); MethodBody simulatebody = simulatemethod.Body; // Load "null" onto the stack. InjectInstructions(simulatebody, 986, Instruction.Create(OpCodes.Ldnull)); // Load "null" onto the stack. InjectInstructions(simulatebody, 814, Instruction.Create(OpCodes.Ldnull)); // Load "null" onto the stack. InjectInstructions(simulatebody, 714, Instruction.Create(OpCodes.Ldnull)); // Load "null" onto the stack. InjectInstructions(simulatebody, 626, Instruction.Create(OpCodes.Ldnull)); // Load "null" onto the stack. InjectInstructions(simulatebody, 340, Instruction.Create(OpCodes.Ldnull)); // Load "null" onto the stack. InjectInstructions(simulatebody, 201, Instruction.Create(OpCodes.Ldnull)); // Load "null" onto the stack. InjectInstructions(simulatebody, 158, Instruction.Create(OpCodes.Ldnull)); // Load "null" onto the stack. InjectInstructions(simulatebody, 136, Instruction.Create(OpCodes.Ldnull)); // Load "null" onto the stack. InjectInstructions(simulatebody, 83, Instruction.Create(OpCodes.Ldnull)); TypeDefinition barriertype = gamedef.GetType("SDG.Unturned.Barrier"); MethodDefinition barriercollide = GetMethod(barriertype, "OnTriggerEnter", 1); MethodBody barriercollidebody = barriercollide.Body; // Load "this" onto the stack. InjectInstructions(barriercollidebody, 25, Instruction.Create(OpCodes.Ldarg_0)); TypeDefinition slaytype = gamedef.GetType("SDG.Unturned.CommandSlay"); MethodDefinition slayexecute = GetMethod(slaytype, "execute", 2); MethodBody slayexecutebody = slayexecute.Body; // Load "this" onto the stack. InjectInstructions(slayexecutebody, 67, Instruction.Create(OpCodes.Ldarg_0)); TypeDefinition damagetooltype = gamedef.GetType("SDG.Unturned.DamageTool"); MethodDefinition damagetooldamage = GetMethod(damagetooltype, "damage", 8); MethodBody damagetooldamagebody = damagetooldamage.Body; // Load "null" onto the stack. InjectInstructions(damagetooldamagebody, 24, Instruction.Create(OpCodes.Ldnull)); TypeDefinition levelmanagertype = gamedef.GetType("SDG.Unturned.LevelManager"); MethodDefinition levelmanagerplay = GetMethod(levelmanagertype, "arenaPlay", 0); MethodBody levelmanagerplaybody = levelmanagerplay.Body; // Load "null" onto the stack. InjectInstructions(levelmanagerplaybody, 217, Instruction.Create(OpCodes.Ldnull)); MethodDefinition levelmanagerrestart = GetMethod(levelmanagertype, "arenaRestart", 0); MethodBody levelmanagerrestartbody = levelmanagerrestart.Body; // Load "null" onto the stack. InjectInstructions(levelmanagerrestartbody, 82, Instruction.Create(OpCodes.Ldnull)); TypeDefinition animaltype = gamedef.GetType("SDG.Unturned.Animal"); MethodDefinition animalupdate = GetMethod(animaltype, "tick", 0); MethodBody animalupdatebody = animalupdate.Body; // Load "this" onto the stack. InjectInstructions(animalupdatebody, 154, Instruction.Create(OpCodes.Ldarg_0)); TypeDefinition zombietype = gamedef.GetType("SDG.Unturned.Zombie"); MethodDefinition zombieupdate = GetMethod(zombietype, "tick", 0); MethodBody zombieupdatebody = zombieupdate.Body; // Load "this" onto the stack. InjectInstructions(zombieupdatebody, 1450, Instruction.Create(OpCodes.Ldarg_0)); }
private static TypeReference GuessBaseType(ModuleDefinition module) { const string MS_EVENT_SOURCE = "Microsoft.Diagnostics.Tracing.EventSource"; const string MS_ASSEMBLY = "Microsoft.Diagnostics.Tracing.EventSource"; var msAssemblyRef = module.AssemblyReferences.FirstOrDefault(r => r.Name == MS_ASSEMBLY); if (msAssemblyRef != null) { var msAssembly = module.AssemblyResolver.Resolve(msAssemblyRef); var baseType = msAssembly.Modules .SelectMany(m => m.Types) .FirstOrDefault(t => t.FullName == MS_EVENT_SOURCE); if (baseType != null) return module.ImportReference(baseType); } return module.ImportReference(typeof(System.Diagnostics.Tracing.EventSource)); }
private static Mono.Cecil.CustomAttribute GetModelDefaultCustomAttribute(string name, string value, ModuleDefinition mod) { var ctor = mod.ImportReference( typeof (ModelDefaultAttribute).GetConstructor(new[] {typeof (string), typeof (string)})); var cb = new Mono.Cecil.CustomAttribute(ctor); var tr = mod.ImportReference(typeof (string)); cb.ConstructorArguments.Add(new CustomAttributeArgument(tr, name)); cb.ConstructorArguments.Add(new CustomAttributeArgument(tr, value)); return cb; }
public static TypeReference ImportEx(this ModuleDefinition module, TypeReference type, IGenericParameterProvider context) { return(module.ImportReference(type, context)); }
internal static CustomAttribute Clone(CustomAttribute custattr, ModuleDefinition context) { var ca = new CustomAttribute(context.ImportReference(custattr.Constructor)); custattr.CopyTo(ca, context); return ca; }
public static TypeReference ImportEx(this ModuleDefinition module, TypeReference type) { return(module.ImportReference(type)); }
public static FieldReference ImportEx(this ModuleDefinition module, FieldReference field, IGenericParameterProvider context) { return(module.ImportReference(field, context)); }
public static MethodReference ImportEx(this ModuleDefinition module, MethodReference method, IGenericParameterProvider context) { return(module.ImportReference(method, context)); }
public static void For(int number_of_threads, SimpleKernel simpleKernel) { if (Campy.Utils.Options.IsOn("import-only")) { JustImport(simpleKernel); return; } GCHandle handle1 = default(GCHandle); GCHandle handle2 = default(GCHandle); try { unsafe { System.Reflection.MethodInfo method_info = simpleKernel.Method; String kernel_assembly_file_name = method_info.DeclaringType.Assembly.Location; Mono.Cecil.ModuleDefinition md = Campy.Meta.StickyReadMod.StickyReadModule( kernel_assembly_file_name, new ReaderParameters { ReadSymbols = true }); MethodReference method_reference = md.ImportReference(method_info); CUfunction ptr_to_kernel = default(CUfunction); CUmodule module = default(CUmodule); Campy.Utils.TimePhase.Time("compile ", () => { IntPtr image = Singleton._compiler.Compile(method_reference, simpleKernel.Target); module = Singleton._compiler.SetModule(method_reference, image); Singleton._compiler.StoreJits(module); ptr_to_kernel = Singleton._compiler.GetCudaFunction(method_reference, module); }); RUNTIME.BclCheckHeap(); BUFFERS buffer = Singleton.Buffer; IntPtr kernel_target_object = IntPtr.Zero; Campy.Utils.TimePhase.Time("deep copy ", () => { int count = simpleKernel.Method.GetParameters().Length; var bb = Singleton._compiler.GetBasicBlock(method_reference); if (bb.HasThis) { count++; } if (!(count == 1 || count == 2)) { throw new Exception("Expecting at least one parameter for kernel."); } if (bb.HasThis) { kernel_target_object = buffer.AddDataStructure(simpleKernel.Target); } }); Campy.Utils.TimePhase.Time("kernel cctor set up", () => { // For each cctor, run on GPU. // Construct dependency graph of methods. List <MethodReference> order_list = COMPILER.Singleton.ConstructCctorOrder(); // Finally, call cctors. foreach (var bb in order_list) { if (Campy.Utils.Options.IsOn("trace-cctors")) { System.Console.WriteLine("Executing cctor " + bb.FullName); } var cctor = Singleton._compiler.GetCudaFunction(bb, module); var res = CUresult.CUDA_SUCCESS; Campy.Utils.CudaHelpers.MakeLinearTiling(1, out Campy.Utils.CudaHelpers.dim3 tile_size, out Campy.Utils.CudaHelpers.dim3 tiles); res = Cuda.cuLaunchKernel( cctor, tiles.x, tiles.y, tiles.z, // grid has one block. tile_size.x, tile_size.y, tile_size.z, // n threads. 0, // no shared memory default(CUstream), (IntPtr)IntPtr.Zero, (IntPtr)IntPtr.Zero ); CudaHelpers.CheckCudaError(res); res = Cuda.cuCtxSynchronize(); // Make sure it's copied back to host. CudaHelpers.CheckCudaError(res); } }); if (Campy.Utils.Options.IsOn("trace-cctors")) { System.Console.WriteLine("Done with cctors"); } Campy.Utils.TimePhase.Time("kernel call ", () => { IntPtr[] parm1 = new IntPtr[1]; IntPtr[] parm2 = new IntPtr[1]; parm1[0] = kernel_target_object; parm2[0] = buffer.New(BUFFERS.SizeOf(typeof(int))); IntPtr[] x1 = parm1; handle1 = GCHandle.Alloc(x1, GCHandleType.Pinned); IntPtr pointer1 = handle1.AddrOfPinnedObject(); IntPtr[] x2 = parm2; handle2 = GCHandle.Alloc(x2, GCHandleType.Pinned); IntPtr pointer2 = handle2.AddrOfPinnedObject(); IntPtr[] kp = new IntPtr[] { pointer1, pointer2 }; var res = CUresult.CUDA_SUCCESS; fixed(IntPtr * kernelParams = kp) { Campy.Utils.CudaHelpers.MakeLinearTiling(number_of_threads, out Campy.Utils.CudaHelpers.dim3 tile_size, out Campy.Utils.CudaHelpers.dim3 tiles); //MakeLinearTiling(1, out dim3 tile_size, out dim3 tiles); res = Cuda.cuLaunchKernel( ptr_to_kernel, tiles.x, tiles.y, tiles.z, // grid has one block. tile_size.x, tile_size.y, tile_size.z, // n threads. 0, // no shared memory default(CUstream), (IntPtr)kernelParams, (IntPtr)IntPtr.Zero ); }
public override void InjectInto(ModuleDefinition gamedef, ModuleDefinition moddef) { // Expose the "spawnItem" method in ItemManager for easier use. // Then, add all items spawned internally to the item manager's model list as physical entities. // This allows us to have better control over items and make them more interactive. TypeDefinition type = gamedef.GetType("SDG.Unturned.ItemManager"); MethodDefinition spawnItemMethod = GetMethod(type, "spawnItem", 8); spawnItemMethod.IsPrivate = false; spawnItemMethod.IsPublic = true; FieldDefinition managerField = GetField(type, "manager"); managerField.IsPrivate = false; managerField.IsPublic = true; FieldDefinition fieldregions = GetField(type, "regions"); fieldregions.IsPrivate = false; fieldregions.IsPublic = true; FieldDefinition fieldinstcount = GetField(type, "instanceCount"); fieldinstcount.IsPrivate = false; fieldinstcount.IsPublic = true; TypeDefinition plInvType = gamedef.GetType("SDG.Unturned.PlayerInventory"); FieldDefinition plInvItems = GetField(plInvType, "items"); plInvItems.IsPrivate = false; plInvItems.IsPublic = true; // Keep track of items by using models TypeDefinition itemTracker = moddef.GetType("UnturnedFrenetic.ItemModelTracker"); // (Item, Vector3) MethodReference trackItemMethod = gamedef.ImportReference(GetMethod(itemTracker, "Track", 2)); // (byte, byte, int) MethodReference untrackItemMethod = gamedef.ImportReference(GetMethod(itemTracker, "Untrack", 3)); // (byte, byte, List<ItemData>) MethodReference resetItemsMethod = gamedef.ImportReference(GetMethod(itemTracker, "Reset", 3)); // For getting 'point' property from ItemSpawnpoint objects MethodDefinition getPointProperty = GetMethod(gamedef.GetType("SDG.Unturned.ItemSpawnpoint"), "get_point", 0); // Track dropItem MethodDefinition dropItemMethod = GetMethod(type, "dropItem", 5); InjectInstructions(dropItemMethod.Body, 74, new Instruction[] { // Load: ItemData itemData Instruction.Create(OpCodes.Ldloc_3), // Load: Vector3 point Instruction.Create(OpCodes.Ldarg_1), // ItemModelTracker.Track(itemData, point); Instruction.Create(OpCodes.Call, trackItemMethod) }); // Track generateItems MethodDefinition generateItemsMethod = GetMethod(type, "generateItems", 2); InjectInstructions(generateItemsMethod.Body, 137, new Instruction[] { // Load: byte x Instruction.Create(OpCodes.Ldarg_1), // Load: byte y Instruction.Create(OpCodes.Ldarg_2), // Load: List<ItemData> list Instruction.Create(OpCodes.Ldloc_0), // Call: ItemModelTracker.Reset(x, y, list); Instruction.Create(OpCodes.Call, resetItemsMethod) }); // Track respawnItems MethodDefinition respawnItemsMethod = GetMethod(type, "respawnItems", 0); InjectInstructions(respawnItemsMethod.Body, 130, new Instruction[] { // Load: ItemData itemData Instruction.Create(OpCodes.Ldloc, respawnItemsMethod.Body.Variables[4]), // Load: ItemSpawnpoint itemSpawnpoint Instruction.Create(OpCodes.Ldloc_0), // Call: 'get_point' on itemSpawnpoint2 -> add the Vector3 result to the stack. Instruction.Create(OpCodes.Callvirt, getPointProperty), // Call: ItemModelTracker.Track(itemData, itemSpawnpoint2.point); Instruction.Create(OpCodes.Call, trackItemMethod) }); // Untrack askTakeItem MethodDefinition askTakeItemMethod = GetMethod(type, "askTakeItem", 8); InjectInstructions(askTakeItemMethod.Body, 95, new Instruction[] { // Load: byte x Instruction.Create(OpCodes.Ldarg_2), // Load: byte y Instruction.Create(OpCodes.Ldarg_3), // Load: ushort num Instruction.Create(OpCodes.Ldloc_2), // Call: ItemModelTracker.Untrack(x, y, num); Instruction.Create(OpCodes.Call, untrackItemMethod) }); // Untrack despawnItems MethodDefinition despawnItemsMethod = GetMethod(type, "despawnItems", 0); InjectInstructions(despawnItemsMethod.Body, 50, new Instruction[] { // Load: ItemManager.despawnItems_X Instruction.Create(OpCodes.Ldsfld, GetField(type, "despawnItems_X")), // Load: ItemManager.despawnItems_Y Instruction.Create(OpCodes.Ldsfld, GetField(type, "despawnItems_Y")), // Load: int i Instruction.Create(OpCodes.Ldloc_0), // Call: ItemModelTracker.Untrack(ItemManager.despawnItems_X, ItemManager.despawnItems_Y, i); Instruction.Create(OpCodes.Call, untrackItemMethod) }); }