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