public static void Update()
{
CameraDeepPtr.DerefOffsets(process, out cameraPtr);
process.ReadValue <Camera>(cameraPtr, out camera);
transformMod = transformModifier;
rotationMod = rotationModifier;
fovMod = fovModifier;
if (VirtualKey.VK_LMENU.IsDown())
{
transformMod *= keyModifier;
rotationMod *= keyModifier;
fovMod *= keyModifier;
}
if (VirtualKey.VK_LCONTROL.IsDown())
{
transformMod /= keyModifier;
rotationMod /= keyModifier;
fovMod /= keyModifier;
}
updateTransform();
updateRotation();
updateFov();
updateTilt();
process.WriteValue <Camera>(cameraPtr, camera);
}
private void SetValue(dynamic value)
{
pointer.DerefOffsets(FzzyComponent.process, out var ptr);
if (value is bool b)
{
FzzyComponent.process.WriteValue(ptr, b);
}
if (value is float f)
{
FzzyComponent.process.WriteValue(ptr, f);
}
if (value is int i)
{
FzzyComponent.process.WriteValue(ptr, i);
}
if (value is byte[] by)
{
FzzyComponent.process.WriteBytes(ptr, by);
}
if (value is string s)
{
FzzyComponent.process.WriteBytes(ptr, Encoding.ASCII.GetBytes(s));
}
}
private LocalizationManager.Language GetSettingsLang()
{
byte langID;
SettingsLangDP = new DeepPointer(PtrDB.DP_Settings_Lang);
SettingsLangDP.DerefOffsets(game, out SettingsLangPtr);
game.ReadValue(SettingsLangPtr, out langID);
switch (langID)
{
case 0:
return(LocalizationManager.Language.EN);
case 1:
return(LocalizationManager.Language.PL);
case 2:
return(LocalizationManager.Language.FR);
case 3:
return(LocalizationManager.Language.DE);
case 6:
return(LocalizationManager.Language.ES);
case 7:
return(LocalizationManager.Language.RU);
}
return(LocalizationManager.Language.OTHER);
}
protected override void DerefPointer(Process game)
{
base.DerefPointer(game); // deref WorldObject (spawnPoint)
endPointDP.DerefOffsets(game, out endPointPtr);
startMoveDelayDP.DerefOffsets(game, out startMoveDelayPtr);
timeLerpA_DP.DerefOffsets(game, out timeLerpA_Ptr);
timeLerpB_DP.DerefOffsets(game, out timeLerpB_Ptr);
}
/// <summary>
/// Deref ObjectDP, overwrite if needed for more pointers
/// </summary>
/// <param name="game">hooked game process</param>
protected virtual void DerefPointer(Process game)
{
if (ObjectDP == null)
{
return;
}
ObjectDP.DerefOffsets(game, out ObjectPtr);
}
public static void ModifyCP(DeepPointer dp, Vector3f pos, Process game)
{
IntPtr cpPtr;
dp.DerefOffsets(game, out cpPtr);
game.WriteBytes(cpPtr, BitConverter.GetBytes(pos.X));
game.WriteBytes(cpPtr + 4, BitConverter.GetBytes(pos.Y));
game.WriteBytes(cpPtr + 8, BitConverter.GetBytes(pos.Z));
}
public void ChangePatrolPoint(Process game, DeepPointer patrolDP, Vector3f pos)
{
IntPtr patrolPtr;
patrolDP.DerefOffsets(game, out patrolPtr);
game.WriteBytes(patrolPtr, BitConverter.GetBytes((float)pos.X));
game.WriteBytes(patrolPtr + 4, BitConverter.GetBytes((float)pos.Y));
game.WriteBytes(patrolPtr + 8, BitConverter.GetBytes((float)pos.Z));
}
protected override void DerefPointer(Process game)
{
base.DerefPointer(game);
// deref shield glow/cone if any
if (shieldGlowDP != null)
{
shieldGlowDP.DerefOffsets(game, out shieldGlowPtr);
}
}
public static void DisableCP(DeepPointer dp)
{
IntPtr cpPtr;
var offsets = dp.GetOffsets();
offsets.RemoveRange(offsets.Count - 2, 2);
offsets.Add(0x02A0);
dp = new DeepPointer(dp.GetBase(), offsets);
dp.DerefOffsets(GameHook.game, out cpPtr);
GameHook.game.WriteBytes(cpPtr, new byte[] { 0 });
}
private void CheckNewGame()
{
DeepPointer bestTimeDP = new DeepPointer(PtrDB.DP_Awakening_BestTime);
IntPtr bestTimePtr;
bestTimeDP.DerefOffsets(GameHook.game, out bestTimePtr);
float time;
GameHook.game.ReadValue <float>(bestTimePtr, out time);
IsNewGame = time < 1;
}
protected override void DerefPointer(Process game)
{
base.DerefPointer(game);
if (boxDP != null)
{
boxDP.DerefOffsets(game, out boxPtr);
}
if (boxOriginDP != null)
{
boxOriginDP.DerefOffsets(game, out boxOriginPtr);
}
}
public static void Update()
{
DebugCamera.CameraDeepPtr.DerefOffsets(process, out cameraPtr);
camera = process.ReadValue <Camera>(cameraPtr);
frankPositionDeepPtr.DerefOffsets(process, out frankPositionPtr);
frankPosition = process.ReadValue <Point3>(frankPositionPtr);
updatePosition();
process.WriteValue <Point3>(frankPositionPtr, frankPosition);
}
private void AddAltTabPause()
{
var deepClient = new DeepPointer("engine.dll", 0x1A1B04);
deepClient.DerefOffsets(FzzyComponent.process, out var pointerClient);
FzzyComponent.process.WriteBytes(pointerClient, new byte[] { 0x88, 0x81 });
var deepServer = new DeepPointer("engine.dll", 0x1C8C02);
deepServer.DerefOffsets(FzzyComponent.process, out var pointerServer);
FzzyComponent.process.WriteBytes(pointerServer, new byte[] { 0x75 });
}
private static void WriteUI(DeepPointer TextDP, DeepPointer TextLengthDP, string text)
{
// pointers
IntPtr titlePtr, titleLengthPtr;
TextDP.DerefOffsets(game, out titlePtr);
TextLengthDP.DerefOffsets(game, out titleLengthPtr);
// set title and length + 1
game.WriteBytes(titleLengthPtr, BitConverter.GetBytes((int)(text.Length + 1)));
game.WriteBytes(titlePtr, StringToMemoryBytes(text));
}
public static void ModifyCP(DeepPointer dp, Vector3f pos, Angle angle, Process game)
{
IntPtr cpPtr;
dp.DerefOffsets(game, out cpPtr);
// pos
game.WriteBytes(cpPtr, BitConverter.GetBytes(pos.X));
game.WriteBytes(cpPtr + 4, BitConverter.GetBytes(pos.Y));
game.WriteBytes(cpPtr + 8, BitConverter.GetBytes(pos.Z));
// angle
game.WriteBytes(cpPtr - 8, BitConverter.GetBytes(angle.angleSin));
game.WriteBytes(cpPtr - 4, BitConverter.GetBytes(angle.angleCos));
}
private bool SetCommandText(string text)
{
var cmd = text + '\0';
var data = Encoding.Unicode.GetBytes(cmd);
if (this.consoleKeyCodeIntPtr == IntPtr.Zero)
{
return(false);
}
var len = text.Length;
FillWithWhitespace(len);
if (!consoleTextPointer.DerefOffsets(this.process, out var pointer))
{
return(false);
}
this.process.WriteInt(this.consoleCursorSizeIntPtr, len + 1);
this.process.WriteInt(this.consoleCursorIndexIntPtr, len);
return(this.process.WriteBytes(pointer, data));
}
public static void DEV_FindAllCP(List <Room> rooms = default, ExtBool overlap = ExtBool.Both, Mode mode = Mode.Both)
{
int c = 0;
ReadPtrValue(PtrDB.ObjectsTypes["checkpoint"], out IntPtr CheckpointVFT);
ReadDPValue(PtrDB.DP_SublevelsCount, out int Sublevels);
for (var j = 1; j < Sublevels; j++)
{
ReadDPValue(new DeepPointer(PtrDB.DP_ObjectsCount).Format(0x8 * (j - 1)), out int Objects);
for (var i = 1; i < Objects; i++)
{
DeepPointer VFTableDP = new DeepPointer(PtrDB.DP_VFTablePattern).Format(0x8 * (j - 1), 0x8 * (i - 1), 0x0);
VFTableDP.DerefOffsets(GameHook.game, out IntPtr VFTablePtr);
GameHook.game.ReadValue(VFTablePtr, out IntPtr VFTable);
if (VFTable == CheckpointVFT)
{
GameHook.game.ReadValue(IntPtr.Add(VFTablePtr, 0x2A0), out bool triggerbyoverlap);
GameHook.game.ReadValue(IntPtr.Add(VFTablePtr, 0x2A1), out bool workinHC);
GameHook.game.ReadValue(IntPtr.Add(VFTablePtr, 0x2A2), out bool workinCL);
List <int> offsets = new List <int>(VFTableDP.GetOffsets());
offsets[offsets.Count - 1] = 0x248;
offsets.Add(0x1d0);
DeepPointer PosDP = new DeepPointer(VFTableDP.GetBase(), offsets);
PosDP.DerefOffsets(GameHook.game, out IntPtr PosPtr);
float x, y, z;
GameHook.game.ReadValue(PosPtr, out x);
GameHook.game.ReadValue(PosPtr + 4, out y);
GameHook.game.ReadValue(PosPtr + 8, out z);
if (rooms == default(List <Room>) || rooms.Where(r => GameUtils.PlayerWithinRectangle(new Vector3f(x, y, z), r.pointA, r.pointB)).Count() > 0)
{
if ((overlap == ExtBool.Both || Convert.ToBoolean(overlap) == triggerbyoverlap) && (mode == Mode.Both || (mode == Mode.Classic ? (Convert.ToBoolean(mode) == !workinCL) : (Convert.ToBoolean(mode) == workinHC))))
{
c++;
Console.WriteLine($"CP:\nPos: {x} {y} {z}");
Console.WriteLine($"TriggerbyOverlap: {triggerbyoverlap}, WorkinHC: {workinHC}, WorkinCl: {workinCL}");
Console.WriteLine($"(0x04609420, 0x98, 0x{0x8 * (j - 1):X}, 0x128, 0xA8, 0x{0x8 * (i - 1):X}, 0x248, 0x1D0)\n");
}
}
}
}
}
Console.WriteLine("found: " + c);
}
public static void DEV_GetEnemyTypes(List <Enemy> enemies)
{
for (int i = 0; i < enemies.Count; i++)
{
List <int> offsets = new List <int>(enemies[i].GetObjectDP().GetOffsets());
offsets[offsets.Count - 1] = 0x0;
DeepPointer parentDP = new DeepPointer(enemies[i].GetObjectDP().GetBase(), offsets);
IntPtr parentPtr;
parentDP.DerefOffsets(GameHook.game, out parentPtr);
// pos
int value;
GameHook.game.ReadValue(parentPtr, out value);
Console.WriteLine($"Enemy: {i}: {value}");
}
}
private void SetLastCP()
{
IntPtr cpPtr;
DeepPointer cpDP = PtrDB.MapCPPointers[mapType];
cpDP.DerefOffsets(GameHook.game, out cpPtr);
// pos
GameHook.game.WriteBytes(cpPtr, BitConverter.GetBytes(spawnPos.X));
GameHook.game.WriteBytes(cpPtr + 4, BitConverter.GetBytes(spawnPos.Y));
GameHook.game.WriteBytes(cpPtr + 8, BitConverter.GetBytes(spawnPos.Z));
// angle
double horizontalAngle = (((spawnAngle.angleSin > 0) ? Math.Acos(spawnAngle.angleCos) : -Math.Acos(spawnAngle.angleCos)) * 180 / Math.PI) * 2;
GameHook.game.WriteBytes(cpPtr + 20, BitConverter.GetBytes((float)horizontalAngle)); // horizontal angle
GameHook.game.WriteBytes(cpPtr + 16, BitConverter.GetBytes(verticalAngle)); // vertical angle
}
protected override void DerefPointer(Process game)
{
boxPtr.Clear();
// normal deref
originDP.DerefOffsets(game, out originPtr);
// signature scan for trigger corners
IntPtr startPtr;
startSearch.DerefOffsets(game, out startPtr);
SignatureScanner scanner = new SignatureScanner(game, startPtr, searchLength);
SigScanTarget target = new SigScanTarget(signature);
var targets = scanner.ScanAll(target).ToList();
boxPtr.AddRange(targets);
}
/// <summary>
/// Deref Pointers
/// </summary>
private void DerefPointers()
{
mapNameDP.DerefOffsets(game, out mapNamePtr);
hcDP.DerefOffsets(game, out hcPtr);
LoadingDP.DerefOffsets(game, out LoadingPtr);
preciseTimeDP.DerefOffsets(game, out preciseTimePtr);
reloadCounterDP.DerefOffsets(game, out reloadCounterPtr);
IntPtr capsulePtr;
capsuleDP.DerefOffsets(game, out capsulePtr);
xPosPtr = capsulePtr + 0x1D0;
yPosPtr = capsulePtr + 0x1D4;
zPosPtr = capsulePtr + 0x1D8;
angleSinPtr = capsulePtr + 0x1A8;
angleCosPtr = capsulePtr + 0x1AC;
}
private static void ReadLocation(DeepPointer DP, int offset, out Vector3f location, int rootoffset = 0x130)
{
List <int> offsets = new List <int>(DP.GetOffsets());
offsets[offsets.Count - 1] = rootoffset;
offsets.Add(offset);
DeepPointer PosDP = new DeepPointer(DP.GetBase(), offsets);
PosDP.DerefOffsets(GameHook.game, out IntPtr PosPtr);
float x, y, z;
GameHook.game.ReadValue(PosPtr, out x);
GameHook.game.ReadValue(PosPtr + 4, out y);
GameHook.game.ReadValue(PosPtr + 8, out z);
location = new Vector3f(x, y, z);
}
protected void ModifyCP(Process game, SpawnData sp, DeepPointer dp, int[] posAppendOffsets, int[] angleAppendOffsets)
{
DeepPointer posDP = AppendBaseOffset(dp, posAppendOffsets);
DeepPointer angleDP = AppendBaseOffset(dp, angleAppendOffsets);
// Deref
IntPtr posPtr, anglePtr;
posDP.DerefOffsets(game, out posPtr);
angleDP.DerefOffsets(game, out anglePtr);
// Update Pos
game.WriteBytes(posPtr, BitConverter.GetBytes(sp.pos.X));
game.WriteBytes(posPtr + 4, BitConverter.GetBytes(sp.pos.Y));
game.WriteBytes(posPtr + 8, BitConverter.GetBytes(sp.pos.Z));
// Update Angle
game.WriteBytes(anglePtr, BitConverter.GetBytes(sp.angle.angleSin));
game.WriteBytes(anglePtr + 4, BitConverter.GetBytes(sp.angle.angleCos));
}
public void Update(IInvalidator invalidator, LiveSplitState state, float width, float height, LayoutMode mode)
{
if (Game == null)
{
isHooked = false;
}
else if (Game.HasExited)
{
Game = null;
isHooked = false;
}
else
{
isHooked = xVelocityDP.Deref <float>(Game, out var ignore);
}
if (!isHooked)
{
List <Process> GameProcesses = Process.GetProcesses().ToList().FindAll(x => x.ProcessName.StartsWith("bms"));
if (GameProcesses.Count > 0)
{
Game = GameProcesses.First();
velocityTextDP.DerefOffsets(Game, out velocityTextPTR);
Game.VirtualProtect(velocityTextPTR, 32, MemPageProtect.PAGE_EXECUTE_READWRITE);
isHooked = xVelocityDP.Deref <float>(Game, out var ignore);
}
}
else
{
float xVel = xVelocityDP.Deref <float>(Game);
float yVel = yVelocityDP.Deref <float>(Game);
float zVel = zVelocityDP.Deref <float>(Game);
double horizontalVelocity = Math.Sqrt(Math.Pow(xVel, 2) + Math.Pow(yVel, 2));
byte[] velocityArray = Encoding.ASCII.GetBytes("hvel: " + horizontalVelocity.ToString("0.00") + " zvel: " + zVel.ToString("0.00"));
byte[] outputArray = new byte[32];
for (int i = 0; i < velocityArray.Length; i++)
{
outputArray[i] = velocityArray[i];
}
Game.WriteBytes(velocityTextPTR, outputArray);
}
}
public virtual Tuple <Vector3f, QuaternionAngle> GetMemoryCurrCoords(Process game)
{
var offsets = ObjectDP.GetOffsets();
offsets[offsets.Count - 1] = 0x130;
offsets.Add(0x1D0);
DeepPointer DP_CurrentPos = new DeepPointer(ObjectDP.GetBase(), offsets);
IntPtr PTR_CurrentPos;
DP_CurrentPos.DerefOffsets(GameHook.game, out PTR_CurrentPos);
float q1, q2, q3, q4, x, y, z;
game.ReadValue <float>(PTR_CurrentPos, out x);
game.ReadValue <float>(PTR_CurrentPos + 4, out y);
game.ReadValue <float>(PTR_CurrentPos + 8, out z);
game.ReadValue <float>(PTR_CurrentPos - 16, out q1);
game.ReadValue <float>(PTR_CurrentPos - 12, out q2);
game.ReadValue <float>(PTR_CurrentPos - 8, out q3);
game.ReadValue <float>(PTR_CurrentPos - 4, out q4);
LastUpdatedCoords = new Tuple <Vector3f, QuaternionAngle>(new Vector3f(x, y, z), new QuaternionAngle(q1, q2, q3, q4));
return(LastUpdatedCoords);
}
public static string DEV_PrintEnemyTypes(Process game, List <Enemy> enemies, bool print = true)
{
// pointers
if (EnemyTypeEP.Pointers.Count == 0)
{
PtrDB.EnemyTypes.ToList().ForEach(x => EnemyTypeEP.Add(x.Key, x.Value));
}
EnemyTypeEP.DerefPointers(game);
string output = "";
// compare data
for (int i = 0; i < enemies.Count; i++)
{
// create 0x0 DP of enemy
var dp = enemies[i].GetObjectDP();
var offsets = dp.GetOffsets();
offsets[offsets.Count - 1] = 0x0;
// deref DP
DeepPointer baseDP = new DeepPointer(dp.GetBase(), offsets);
IntPtr enemyBasePtr;
baseDP.DerefOffsets(game, out enemyBasePtr);
// read value
byte[] enemyValue = new byte[8];
game.ReadBytes(enemyBasePtr, 8, out enemyValue);
// get IndentityAddressHEX and compare it with enemy value as HEX
string enemyHex = BitConverter.ToString(enemyValue.Reverse().ToArray()).Replace("-", string.Empty).Remove(0, 4);
string enemyType = EnemyTypeEP.Pointers.FirstOrDefault(x => x.Value.Item2.ToString("x8").ToUpper() == enemyHex).Key;
// print type
if (print)
{
Console.WriteLine($"{i}:{enemyType}");
}
output += $"{i}:{enemyType}\n";
}
return(output);
}
private Room room_HC_7 = new Room(new Vector3f(281790, 202947, 1397), new Vector3f(298765, 222590, 4989)); //
#endregion
public Faster() : base(GameUtils.MapType.Faster)
{
if (GameHook.IsHC || Config.GetInstance().Setting_Difficulty >= Config.Difficulty.Normal)
{
#region Signs1
ChainedSignSpawners chained = new ChainedSignSpawners(0x3c0, 0x3c8, 0x3b8);
//mixed
chained.AddChainedInfo(new List <SignSpawnerSpawnInfo>()
{
new SignSpawnerSpawnInfo {
DelayOnStart = 1, SpawnDelay = 3
},
new SignSpawnerSpawnInfo {
DelayOnStart = 2, SpawnDelay = 3
},
new SignSpawnerSpawnInfo {
DelayOnStart = 0, SpawnDelay = 3
},
});
chained.AddChainedInfo(new List <SignSpawnerSpawnInfo>()
{
new SignSpawnerSpawnInfo {
DelayOnStart = 2, SpawnDelay = 3
},
new SignSpawnerSpawnInfo {
DelayOnStart = 0, SpawnDelay = 3
},
new SignSpawnerSpawnInfo {
DelayOnStart = 1, SpawnDelay = 3
},
});
//some double sign))
chained.AddChainedInfo(new List <SignSpawnerSpawnInfo>()
{
new SignSpawnerSpawnInfo {
DelayOnStart = 0, SpawnDelay = 3
},
new SignSpawnerSpawnInfo {
DelayOnStart = 2, SpawnDelay = 2
},
new SignSpawnerSpawnInfo {
DelayOnStart = 1, SpawnDelay = 3
},
});
chained.AddChainedInfo(new List <SignSpawnerSpawnInfo>()
{
new SignSpawnerSpawnInfo {
DelayOnStart = 0, SpawnDelay = 3
},
new SignSpawnerSpawnInfo {
DelayOnStart = 0, SpawnDelay = 2
},
new SignSpawnerSpawnInfo {
DelayOnStart = 2, SpawnDelay = 3
},
});
//should be rare
chained.AddChainedInfo(new List <SignSpawnerSpawnInfo>()
{
new SignSpawnerSpawnInfo {
DelayOnStart = 0, SpawnDelay = 2
},
new SignSpawnerSpawnInfo {
DelayOnStart = 0, SpawnDelay = 1
},
new SignSpawnerSpawnInfo {
DelayOnStart = 3, SpawnDelay = 4
},
});
//default
chained.AddChainedInfo(new List <SignSpawnerSpawnInfo>()
{
new SignSpawnerSpawnInfo {
DelayOnStart = 0, SpawnDelay = 3
},
new SignSpawnerSpawnInfo {
DelayOnStart = 1, SpawnDelay = 3
},
new SignSpawnerSpawnInfo {
DelayOnStart = 2, SpawnDelay = 3
},
});
worldObjects.Add(chained);
#endregion
#region Signs2
chained = new ChainedSignSpawners(0x3b0, 0x3a8, 0x3a0, 0x398, 0x390, 0x388, 0x3D0);
//default
var delays = new List <float>()
{
0.0f, 1.1f, 2.2f, 3.3f, 4.0f, 4.8f, 5.8f
};
var result = delays.Select(x => new { value = x, order = Config.GetInstance().r.Next() }).OrderBy(x => x.order).Select(x => x.value).ToList();
chained.AddChainedInfo(new List <SignSpawnerSpawnInfo>()
{
new SignSpawnerSpawnInfo {
DelayOnStart = result[0], SpawnDelay = 6.8f
},
new SignSpawnerSpawnInfo {
DelayOnStart = result[1], SpawnDelay = 6.8f
},
new SignSpawnerSpawnInfo {
DelayOnStart = result[2], SpawnDelay = 6.8f
},
new SignSpawnerSpawnInfo {
DelayOnStart = result[3], SpawnDelay = 6.8f
},
new SignSpawnerSpawnInfo {
DelayOnStart = result[4], SpawnDelay = 6.8f
},
new SignSpawnerSpawnInfo {
DelayOnStart = result[5], SpawnDelay = 6.8f
},
new SignSpawnerSpawnInfo {
DelayOnStart = result[6], SpawnDelay = 6.8f
},
});
worldObjects.Add(chained);
#endregion
#region ForceSlideTrigger
if (Config.GetInstance().Settings_RemoveForceSlideTrigger)
{
IntPtr triggerPtr;
DeepPointer triggerDP = new DeepPointer(PtrDB.DP_Faster_ForcedSliderTrigger);
triggerDP.DerefOffsets(GameHook.game, out triggerPtr);
GameHook.game.WriteBytes(triggerPtr, BitConverter.GetBytes((float)0));
}
#endregion
#region Signs Triggers
// force signs, section 1
// Default: -11830, 160550, 2040 | 650, 1025, 540
worldObjects.Add(new Trigger(0x18, 0x380, new Vector3f(-11815, 139661, 350), new Vector3f(650, 1025, 540), // first wagon doorframe
new DeepPointer(PtrDB.DP_SignTrigger_Scan), PtrDB.SignTrigger_ScanLength, PtrDB.SignTrigger1_Signature));
// trigger to disable first signs moved upwards, to avoid double signs(because speedrunners...)
worldObjects.Add(new Trigger(0x18, 0x17c8, new Vector3f(-11801, 181093, 1609), new Vector3f(595, 40, 528.75f),
new DeepPointer(PtrDB.DP_SignTrigger_Scan), PtrDB.SignTrigger_ScanLength, PtrDB.SignTrigger2_Signature));
#endregion
}
}
public EchoesCV() : base(Game.GameUtils.MapType.EchoesCV, manualGen: true)
{
Gen_PerRoom();
RotationDP.DerefOffsets(GameHook.game, out RotationPtr);
CPRequired = false;
}
protected void AttachToGroup(Enemy EnemyToAdd, Enemy EnemyInGroup)
{
IntPtr parentPtr, parentPtr0, killcountPtr, killlistPtr, basePtr0;
ulong parent, parent0;
int killcount;
//check if there is a parent object
List <int> offsets = new List <int>(EnemyInGroup.GetObjectDP().GetOffsets());
offsets[offsets.Count - 1] = 0x5D0;
DeepPointer parentDP = new DeepPointer(EnemyInGroup.GetObjectDP().GetBase(), offsets);
parentDP.DerefOffsets(GameHook.game, out parentPtr);
GameHook.game.ReadValue <ulong>(parentPtr, out parent);
//return if there is no parent object
if (parent == 0)
{
return;
}
List <int> offsets0 = new List <int>(EnemyToAdd.GetObjectDP().GetOffsets());
offsets0[offsets0.Count - 1] = 0x5D0;
DeepPointer parentDP0 = new DeepPointer(EnemyToAdd.GetObjectDP().GetBase(), offsets0);
parentDP0.DerefOffsets(GameHook.game, out parentPtr0);
GameHook.game.ReadValue <ulong>(parentPtr0, out parent0);
//read kill count
offsets.Add(0x230);
DeepPointer killcountDP = new DeepPointer(EnemyInGroup.GetObjectDP().GetBase(), offsets);
killcountDP.DerefOffsets(GameHook.game, out killcountPtr);
GameHook.game.ReadValue <int>(killcountPtr, out killcount);
if (killcount == 0)
{
return;
}
//return if same parent object
if (parent0 == parent)
{
return;
}
//remove previous parentobject
if (parent0 != 0)
{
EnemyToAdd.DisableAttachedCP(GameHook.game);
}
//enemy0 start address
basePtr0 = parentPtr0 - 0x5d0;
//find killlist address and write this enemy pointer
offsets[offsets.Count - 1] = 0x228;
offsets.Add(0x8 * killcount);
DeepPointer killlistDP = new DeepPointer(EnemyInGroup.GetObjectDP().GetBase(), offsets);
killlistDP.DerefOffsets(GameHook.game, out killlistPtr);
GameHook.game.WriteBytes(killlistPtr, BitConverter.GetBytes((ulong)basePtr0));
killcount += 1;
// update kill count
GameHook.game.WriteBytes(killcountPtr, BitConverter.GetBytes(killcount));
//add parent object
GameHook.game.WriteBytes(parentPtr0, BitConverter.GetBytes((ulong)parent));
}
private void Write(DeepPointer pointer, byte[] b)
{
pointer.DerefOffsets(FzzyComponent.process, out var ptr);
FzzyComponent.process.WriteBytes(ptr, b);
}
