public override void Attach() { base.Attach(); _patchContext = _patchMgr.AcquireContext(); GameLoopObserver.Patch(_patchContext); }
/// <inheritdoc cref="Manager.Attach"/> public override void Attach() { base.Attach(); if (!_patched) { _patched = true; _patchContext = _patchMgr.AcquireContext(); ProfilerPatch.Patch(_patchContext); _canceller?.Cancel(); _canceller?.Dispose(); _canceller = new CancellationTokenSource(); ThreadPool.QueueUserWorkItem(_ => { try { ProfilerResultQueue.Start(_canceller.Token); } catch (Exception e) { Log.Error(e); } }); } }
/// <inheritdoc cref="Manager.Attach"/> public override void Attach() { base.Attach(); if (_ctx == null) { _ctx = _patchManager.AcquireContext(); } Torch.GameStateChanged += Torch_GameStateChanged; _sessionManager = Torch.Managers.GetManager <TorchSessionManager>(); if (_sessionManager != null) { _sessionManager.SessionStateChanged += SessionChanged; } else { LogManager.GetCurrentClassLogger().Warn("No session manager. Player metrics won't work"); } loadTimer = new System.Timers.Timer(500); loadTimer.Elapsed += LoadTimerElapsed; loadTimer.AutoReset = true; loadTimer.Start(); var perfMetricManager = typeof(PerformanceMetricsManager); _ctx.GetPattern(_asyncSavingStart).Prefixes.Add(perfMetricManager.GetMethod(nameof(PrefixAsyncSavingStart), BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)); _ctx.GetPattern(_asyncSavingStart).Suffixes.Add(perfMetricManager.GetMethod(nameof(SuffixAsyncSavingStart), BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)); _ctx.GetPattern(_serverBanClient).Suffixes.Add(perfMetricManager.GetMethod(nameof(SuffixBanClient), BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)); _ctx.GetPattern(_spaceRespawnComponentCreateNewIdentity).Suffixes.Add(perfMetricManager.GetMethod(nameof(SuffixCreateNewIdentity), BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)); _patchManager.Commit(); LogManager.GetCurrentClassLogger().Info("Attached"); }
internal static void Patch(PatchContext context) { var target = typeof(MyMultiplayerBase).GetMethod("OnChatMessageRecieved_Server", BindingFlags.Static | BindingFlags.NonPublic); var patchMethod = typeof(ChatInterceptPatch).GetMethod(nameof(PrefixMessageProcessing), BindingFlags.Static | BindingFlags.NonPublic); context.GetPattern(target).Prefixes.Add(patchMethod); }
public override void Init(ITorchBase torch) { base.Init(torch); // Initialize the sessionManager so we can trigger on session ready var sessionManager = Torch.Managers.GetManager <TorchSessionManager>(); if (sessionManager != null) { sessionManager.SessionStateChanged += SessionChanged; } else { Log.Warn("No session manager loaded!"); } // Setup our patch manager so we can patch methods patchManager = Torch.Managers.GetManager <PatchManager>(); if (patchManager != null) { if (ctx == null) { ctx = patchManager.AcquireContext(); } } else { Log.Warn("No patch manager loaded!"); } Log.Info("FactionPaint Initialized"); }
public void TestModifyNode__MultiplyValue() { ConfigNode c1 = new TestConfigNode("NODE") { { "foo", "3" }, { "foo", "5" }, }; UrlDir.UrlConfig c2u = UrlBuilder.CreateConfig("abc/def", new TestConfigNode("@NODE") { { "@foo *", "2" }, }, root); PatchContext context = new PatchContext(c2u, root, logger, progress); ConfigNode c3 = MMPatchLoader.ModifyNode(new NodeStack(c1), c2u.config, context); EnsureNoErrors(); AssertConfigNodesEqual(new TestConfigNode("NODE") { { "foo", "6" }, { "foo", "5" }, }, c3); }
public static void Patch(PatchContext ctx) { Type type = Type.GetType("GameAnalyticsSDK.Net.Logging.GALogger, GameAnalytics.Mono"); if (type == null) { return; } FieldInfo loggerField = type.GetField("logger", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public); if (loggerField == null) { _log.Warn("GALogger logger field is unknown. Logging may not function."); return; } RuntimeHelpers.RunClassConstructor(type.TypeHandle); _setLogger = loggerField?.CreateSetter <ILogger, ILogger>(); FixLogging(); ConstructorInfo ctor = type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[0], new ParameterModifier[0]); if (ctor == null) { _log.Warn("GALogger constructor is unknown. Logging may not function."); return; } ctx.GetPattern(ctor).Prefixes.Add(typeof(GameAnalyticsPatch).GetMethod(nameof(PatchLogger), BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)); }
public static void Patch(PatchContext ctx) { var actionMethod = FindAction(Method); var transpiler = SelfType.GetStaticMethod(nameof(Transpile)); ctx.GetPattern(actionMethod).PostTranspilers.Add(transpiler); }
public static void Patch(PatchContext ptx) { var patchMethod = typeof(GameLoopObserver).GetMethod(nameof(OnSessionUpdate), BindingFlags.Static | BindingFlags.NonPublic); ptx.GetPattern(_sessionUpdateMethod).Suffixes.Add(patchMethod); _patched = true; }
#pragma warning restore 649 public static void Patch(PatchContext ctx) { ctx.GetPattern(_drawScene).Transpilers .Add(Method(nameof(TranspileDrawScene))); ctx.GetPattern(_draw).Transpilers .Add(Method(nameof(TranspileDraw))); }
public void TestCombo() { Invoke(_resetMethod); PatchContext context = _patchContext.AcquireContext(); if (_prefixMethod != null) { context.GetPattern(_targetMethod).Prefixes.Add(_prefixMethod); } if (_transpileMethod != null) { context.GetPattern(_targetMethod).Transpilers.Add(_transpileMethod); } if (_suffixMethod != null) { context.GetPattern(_targetMethod).Suffixes.Add(_suffixMethod); } _patchContext.Commit(); Invoke(); Invoke(_prefixAssert); Invoke(_transpileAssert); Invoke(_suffixAssert); _patchContext.FreeContext(context); _patchContext.Commit(); }
private BackupUnit(PatchContext context, string name) { Name = name; _context = context; _backupPath = new DirectoryInfo(Path.Combine(_context.BackupPath, Name)); _manifestFile = new FileInfo(Path.Combine(_backupPath.FullName, _ManifestFileName)); }
public static void Patch(PatchContext ctx) { var UpdateOnceBeforeFrameMethod = Type.GetStaticMethod(nameof(MyGameLogic.UpdateOnceBeforeFrame)); MyEntity_Transpile.Patch(ctx, UpdateOnceBeforeFrameMethod); if (MyDistributedUpdater_Iterate.ApiExists()) { var UpdateBeforeSimulationMethod = Type.GetStaticMethod(nameof(MyGameLogic.UpdateBeforeSimulation)); foreach (var updateMethod in MyDistributedUpdater_Iterate.FindUpdateMethods(UpdateBeforeSimulationMethod)) { MyEntity_Transpile.Patch(ctx, updateMethod); } var UpdateAfterSimulationMethod = Type.GetStaticMethod(nameof(MyGameLogic.UpdateAfterSimulation)); foreach (var updateMethod in MyDistributedUpdater_Iterate.FindUpdateMethods(UpdateAfterSimulationMethod)) { MyEntity_Transpile.Patch(ctx, updateMethod); } } else { Log.Error("Unable to find MyDistributedUpdater.Iterate(Delegate) method. Some profiling data will be missing."); } }
#pragma warning restore 649 public static void Patch(PatchContext ctx) { _log.Info("Patching mods downloading"); ctx.GetPattern(_downloadWorldModsBlockingMethod).Suffixes .Add(typeof(ModsDownloadingPatch).GetMethod(nameof(Postfix))); }
public void TestModifyNode__EditNode__SpecialCharacters() { ConfigNode c1 = new TestConfigNode("NODE") { new TestConfigNode("INNER_NODE") { { "weird_values", "some\r\n\tstuff" }, }, }; UrlDir.UrlConfig c2u = UrlBuilder.CreateConfig("abc/def", new TestConfigNode("@NODE") { new TestConfigNode("@INNER_NODE") { { "another_weird_value", "some\r\nmore\tstuff" }, }, }); PatchContext context = new PatchContext(c2u, Enumerable.Empty <IProtoUrlConfig>(), logger, progress); ConfigNode c3 = MMPatchLoader.ModifyNode(new NodeStack(c1), c2u.config, context); EnsureNoErrors(); AssertConfigNodesEqual(new TestConfigNode("NODE") { new TestConfigNode("INNER_NODE") { { "weird_values", "some\r\n\tstuff" }, { "another_weird_value", "some\r\nmore\tstuff" }, }, }, c3); }
private static void PatchDistributedUpdate(PatchContext ctx, MethodBase callerMethod) { var foundAnyIterate = false; var msil = PatchUtilities.ReadInstructions(callerMethod).ToList(); for (var i = 0; i < msil.Count; i++) { var insn = msil[i]; if ((insn.OpCode != OpCodes.Callvirt && insn.OpCode != OpCodes.Call) || !IsDistributedIterate((insn.Operand as MsilOperandInline <MethodBase>)?.Value as MethodInfo)) { continue; } foundAnyIterate = true; // Call to Iterate(). Backtrace up the instruction stack to find the statement creating the delegate. var foundNewDel = false; for (var j = i - 1; j >= 1; j--) { var insn2 = msil[j]; if (insn2.OpCode != OpCodes.Newobj) { continue; } var ctorType = (insn2.Operand as MsilOperandInline <MethodBase>)?.Value?.DeclaringType; if (ctorType == null || !ctorType.IsGenericType || ctorType.GetGenericTypeDefinition() != typeof(Action <>)) { continue; } foundNewDel = true; // Find the instruction loading the function pointer this delegate is created with var ldftn = msil[j - 1]; if (ldftn.OpCode != OpCodes.Ldftn || !(ldftn.Operand is MsilOperandInline <MethodBase> targetMethod)) { Log.Error( $"Unable to find ldftn instruction for call to Iterate in {callerMethod.DeclaringType}#{callerMethod}"); } else { Log.Debug( $"Patching {targetMethod.Value.DeclaringType}#{targetMethod.Value} for {callerMethod.DeclaringType}#{callerMethod}"); PatchDistUpdateDel(ctx, targetMethod.Value); } break; } if (!foundNewDel) { Log.Error( $"Unable to find new Action() call for Iterate in {callerMethod.DeclaringType}#{callerMethod}"); } } if (!foundAnyIterate) { Log.Error($"Unable to find any calls to {_distributedUpdaterIterate} in {callerMethod.DeclaringType}#{callerMethod}"); } }
public static BackupUnit FromDirectory(DirectoryInfo directory, PatchContext context) { var unit = new BackupUnit(context, directory.Name); // Read Manifest if (unit._manifestFile.Exists) { var manifest = File.ReadAllText(unit._manifestFile.FullName); foreach (var line in manifest.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)) { unit._files.Add(line); } } else { foreach (var file in directory.GetFiles("*", SearchOption.AllDirectories)) { if (file.Name == _ManifestFileName) { continue; } var relativePath = file.FullName.Substring(directory.FullName.Length + 1); unit._files.Add(relativePath); } } return(unit); }
public static void Patch(PatchContext ptx) { var patchee = typeof(MyCubeGrid).GetMethod("MoveBlocks", BindingFlags.Static | BindingFlags.NonPublic); var patcher = typeof(MyCubeGridPatch).GetMethod(nameof(MoveBlocksPostfix), BindingFlags.Static | BindingFlags.NonPublic); ptx.GetPattern(patchee).Suffixes.Add(patcher); }
public void TestModifyNode__IndexAllWithAssign() { ConfigNode c1 = new TestConfigNode("NODE") { { "foo", "bar1" }, { "foo", "bar2" }, }; UrlDir.UrlConfig c2u = UrlBuilder.CreateConfig("abc/def", new TestConfigNode("@NODE") { { "@foo,*", "bar3" }, }); PatchContext context = new PatchContext(c2u, Enumerable.Empty <IProtoUrlConfig>(), logger, progress); ConfigNode c3 = MMPatchLoader.ModifyNode(new NodeStack(c1), c2u.config, context); EnsureNoErrors(); AssertConfigNodesEqual(new TestConfigNode("NODE") { { "foo", "bar3" }, { "foo", "bar3" }, }, c3); }
public static void Patch(PatchContext patchContext) { Log.TryPatching(() => { patchContext.PatchInit <MyJumpDrive>(InitPatch); _jumpDistanceRatio = typeof(MyJumpDrive).GetPrivateFieldInfo("m_jumpDistanceRatio"); }); }
public static void Patch(PatchContext ctx) { ctx.GetPattern(typeof(MyShipMergeBlock).GetMethod("CheckUnobstructed", BindingFlags.NonPublic | BindingFlags.Instance)). Prefixes.Add(typeof(MergeBlockPatch).GetMethod(nameof(MergeCheck), BindingFlags.NonPublic | BindingFlags.Static)); ctx.GetPattern(typeof(MyShipMergeBlock).GetMethod("AddConstraint", BindingFlags.NonPublic | BindingFlags.Instance)). Suffixes.Add(typeof(MergeBlockPatch).GetMethod(nameof(AddBlocks), BindingFlags.NonPublic | BindingFlags.Static)); }
public static void Patch(PatchContext patchContext) { Log.TryPatching(() => { patchContext.PatchInit <MyBeacon>(InitPatch); _radius = typeof(MyBeacon).GetPrivateFieldInfo("m_radius"); }); }
public static void Patch(PatchContext ctx) { ctx.GetPattern(typeof(MyCubeBuilder).GetMethod("RequestGridSpawn", BindingFlags.NonPublic | BindingFlags.Static)) .Prefixes.Add(typeof(GridSpawnPatch).GetMethod(nameof(Prefix), BindingFlags.NonPublic | BindingFlags.Static)); ctx.GetPattern(typeof(MyCubeGrid).GetMethod("TryPasteGrid_Implementation", BindingFlags.Public | BindingFlags.Static)). Prefixes.Add(typeof(GridSpawnPatch).GetMethod(nameof(AttemptSpawn), BindingFlags.Static | BindingFlags.NonPublic)); }
public static void Patch(PatchContext patchContext) { Log.TryPatching(() => { patchContext.PatchInit <MyThrust>(InitPatch); _thrustOverride = typeof(MyThrust).GetPrivateFieldInfo("m_thrustOverride"); }); }
public static void Patch(PatchContext ctx) { Log.Info("Patch init"); ctx.GetPattern(typeof(MyProjectorBase).GetMethod("OnNewBlueprintSuccess", BindingFlags.Instance | BindingFlags.NonPublic)).Prefixes.Add( typeof(ProjectorFixPatch).GetMethod(nameof(PrefixNewBlueprint), BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic)); }
public static void Patch(PatchContext ctx) { ctx.GetPattern(OnChangeOwnersRequest).Prefixes.Add(patchOnChangeOwnersRequest); ctx.GetPattern(ChangeOwnerRequest).Prefixes.Add(patchChangeOwnerRequest); ctx.GetPattern(DestroyRequest).Prefixes.Add(patchOnDestroyRequest); LogManager.GetCurrentClassLogger().Debug("Patched MyCubeGrid!"); }
public static void Patch(PatchContext patchContext) { Log.TryPatching(() => { patchContext.PatchInit <MyLargeTurretBase>(InitPatch); _shootingRange = typeof(MyLargeTurretBase).GetPrivateFieldInfo("m_shootingRange"); }); }
public static BackupUnit FindLatestBackup(PatchContext context) { return(new DirectoryInfo(context.BackupPath) .GetDirectories() .OrderByDescending(p => p.Name) .Select(p => BackupUnit.FromDirectory(p, context)) .FirstOrDefault()); }
public static void Patch(PatchContext ctx) { ctx.GetPattern(typeof(MyProjectorBase).GetMethod("OnNewBlueprintSuccess", BindingFlags.Instance | BindingFlags.NonPublic)). Prefixes.Add(typeof(ProjectionPatch).GetMethod(nameof(PrefixNewBlueprint), BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic)); ctx.GetPattern(typeof(MyProjectorBase).GetMethod("RemoveProjection", BindingFlags.Instance | BindingFlags.NonPublic)). Prefixes.Add(typeof(ProjectionPatch).GetMethod(nameof(DecreaseProjectedCount), BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic)); }
public static void Patch(PatchContext ctx) { ctx.GetPattern(typeof(MyFunctionalBlock).GetMethod("UpdateBeforeSimulation10", BindingFlags.Instance | BindingFlags.Public)). Prefixes.Add(typeof(BlockSwitchPatch).GetMethod(nameof(KeepBlocksOff), BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic)); ctx.GetPattern(typeof(MyFunctionalBlock).GetMethod("UpdateBeforeSimulation100", BindingFlags.Instance | BindingFlags.Public)). Prefixes.Add(typeof(BlockSwitchPatch).GetMethod(nameof(KeepBlocksOff), BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic)); }