static void Init(string processName)
{
while (!MemoryEditor.Init(processName))
{
}
Chat.RecordCommandSource();
DetectLastPuckToucherTeam();
NoRespawns();
MinHalves();
Longergameovertime();
Longerwarmuptime();
NoRespawnOnRoundStart();
WarmupTimeAfterGoals();
ResetPuckAfterGame();
Chat.FlushLastCommand();
Tools.ResumeGame();
MemoryEditor.WriteInt(28, 0x04130B8); //server version
MemoryEditor.WriteInt(60000, 0x79348AC); //warmup
MemoryEditor.WriteInt(0, 0x7933C9C);
byte[] warmup_time = new byte[10] {
0xC7, 0x05, 0x14, 0x3E, 0x89, 0x01, 0xB8, 0x0B, 0x00, 0x00
};
int warmup_add = 0x00411EDC;
MemoryEditor.WriteBytes(warmup_time, warmup_add);
byte[] twohalves = new byte[7] {
0x83, 0x3D, 0x10, 0x3E, 0x89, 0x01, 0x02
};
int twohalves_add = 0x00407924;
MemoryEditor.WriteBytes(twohalves, twohalves_add);
}
public static void DetectLastPuckToucherTeam()
{
MemoryEditor.WriteBytes(new byte[74] {
0x69, 0xC0, 0x98, 0x00, 0x00, 0x00, 0x8B, 0x88, 0x68, 0x0A, 0x53, 0x00, 0x89, 0x0D, 0x58, 0x49, 0xD3, 0x07, 0x8B, 0x88, 0x64, 0x0A, 0x53, 0x00, 0x89, 0x0D, 0x5C, 0x49, 0xD3, 0x07, 0xA1, 0x20, 0x3E, 0x89, 0x01, 0x8B, 0x0D, 0x20, 0x3E, 0x89, 0x01, 0x83, 0xE9, 0x01, 0x83, 0xE1, 0x03, 0x8B, 0x55, 0xDC, 0x69, 0xD2, 0xD8, 0x0B, 0x00, 0x00, 0x8B, 0x04, 0x8D, 0x24, 0x3E, 0x89, 0x01, 0x3B, 0x82, 0xE8, 0xB6, 0x87, 0x01, 0xE9, 0x18, 0xC7, 0xEC, 0xFF
}, 0x00540700);
MemoryEditor.WriteBytes(new byte[6] {
0xE9, 0x9F, 0x38, 0x13, 0x00, 0x90
}, 0x0040CE5C);
}
public static void MinHalves()
{
MemoryEditor.WriteBytes(new byte[25] {
0xC7, 0x05, 0x08, 0x3E, 0x89, 0x01, 0x60, 0xEA, 0x00, 0x00, 0xC7, 0x05, 0x9C, 0x48, 0xD3, 0x07, 0x01, 0x00, 0x00, 0x00, 0xE9, 0x44, 0x78, 0xEC, 0xFF
}, 0x00540100);
MemoryEditor.WriteBytes(new byte[10] {
0xE9, 0xA8, 0x87, 0x13, 0x00, 0x90, 0x90, 0x90, 0x90, 0x90
}, 0x00407953);
}
public static void Longergameovertime()
{
MemoryEditor.WriteBytes(new byte[25] {
0xC7, 0x05, 0x14, 0x3E, 0x89, 0x01, 0xB8, 0x0B, 0x00, 0x00, 0xC7, 0x05, 0x9C, 0x48, 0xD3, 0x07, 0x01, 0x00, 0x00, 0x00, 0xE9, 0x55, 0x77, 0xEC, 0xFF
}, 0x00540200);
MemoryEditor.WriteBytes(new byte[10] {
0xE9, 0x97, 0x88, 0x13, 0x00, 0x90, 0x90, 0x90, 0x90, 0x90
}, 0x00407964);
}
public static void Longerwarmuptime()
{
MemoryEditor.WriteBytes(new byte[35] {
0xC7, 0x05, 0x14, 0x3E, 0x89, 0x01, 0xB8, 0x0B, 0x00, 0x00, 0xC7, 0x05, 0x9C, 0x3C, 0xD3, 0x07, 0x01, 0x00, 0x00, 0x00, 0xC7, 0x05, 0xA0, 0x48, 0xD3, 0x07, 0x01, 0x00, 0x00, 0x00, 0xE9, 0x18, 0x34, 0xEC, 0xFF
}, 0x00540300);
MemoryEditor.WriteBytes(new byte[10] {
0xE9, 0xCA, 0xCB, 0x13, 0x00, 0x90, 0x90, 0x90, 0x90, 0x90
}, 0x00403731);
}
public static void NoRespawnOnRoundStart()
{
MemoryEditor.WriteBytes(new byte[26] {
0x90, 0xC7, 0x05, 0x9C, 0x3C, 0xD3, 0x07, 0x00, 0x00, 0x00, 0x00, 0xC7, 0x05, 0xA0, 0x48, 0xD3, 0x07, 0x01, 0x00, 0x00, 0x00, 0xE9, 0x48, 0x75, 0xEC, 0xFF
}, 0x00540400);
MemoryEditor.WriteBytes(new byte[5] {
0xE9, 0x9E, 0x8A, 0x13, 0x00
}, 0x0040795D);
}
public static void ResetPuckAfterGame()
{
MemoryEditor.WriteBytes(new byte[35] {
0xC7, 0x05, 0x14, 0x3E, 0x89, 0x01, 0xD0, 0x07, 0x00, 0x00, 0xC7, 0x05, 0x9C, 0x3C, 0xD3, 0x07, 0x00, 0x00, 0x00, 0x00, 0xC7, 0x05, 0xA0, 0x48, 0xD3, 0x07, 0x01, 0x00, 0x00, 0x00, 0xE9, 0xE0, 0x73, 0xEC, 0xFF
}, 0x00540600);
MemoryEditor.WriteBytes(new byte[10] {
0xE9, 0x02, 0x8C, 0x13, 0x00, 0x90, 0x90, 0x90, 0x90, 0x90
}, 0x004079F9);
}
public static void WarmupTimeAfterGoals()
{
MemoryEditor.WriteBytes(new byte[25] {
0xC7, 0x05, 0x00, 0x32, 0x89, 0x01, 0xD0, 0x07, 0x00, 0x00, 0xC7, 0x05, 0x9C, 0x3C, 0xD3, 0x07, 0x01, 0x00, 0x00, 0x00, 0xE9, 0xCD, 0x74, 0xEC, 0xFF
}, 0x00540500);
MemoryEditor.WriteBytes(new byte[10] {
0xE9, 0x1F, 0x8B, 0x13, 0x00, 0x90, 0x90, 0x90, 0x90, 0x90
}, 0x004079DC);
}
private void RestoreDefaults()
{
pitch = defaultPitch;
yaw = defaultYaw;
cameraHeight = defaultCameraHeight;
drawDistance = defaultDrawDistance;
m.WriteFloat(PitchAddress, defaultPitch);
m.WriteFloat(YawAddress, defaultYaw);
m.WriteFloat(CameraHeightAddress, defaultCameraHeight);
m.WriteFloat(DrawDistanceAddress, defaultDrawDistance);
m.WriteBytes(CameraModeAddress, BitConverter.GetBytes(defaultCameraMode));
}
public static void NoRespawns()
{
byte[] code_original = new byte[7] {
0xE9, 0x6B, 0x86, 0x13, 0x00, 0x90, 0x90
};
byte[] code_inject = new byte[22] {
0x83, 0x3D, 0x0C, 0x3E, 0x89, 0x01, 0x01, 0xC7, 0x05, 0x9C, 0x3C, 0xD3, 0x07, 0x00, 0x00, 0x00, 0x00, 0xE9, 0x81, 0x79, 0xEC, 0xFF
};
int addr_original = 0x00407990;
int addr_inject = 0x00540000;
MemoryEditor.WriteBytes(code_inject, addr_inject);
MemoryEditor.WriteBytes(code_original, addr_original);
}
public static void PuckCollision(bool value)
{
byte[] disable1_false = new byte[5] {
0xE8, 0x90, 0x52, 0x00, 0x00
};
byte[] disable1_true = new byte[5] {
0x90, 0x90, 0x90, 0x90, 0x90
};
byte[] disable2_false = new byte[5] {
0xE8, 0xFB, 0x52, 0x00, 0x00
};
byte[] disable2_true = new byte[5] {
0x90, 0x90, 0x90, 0x90, 0x90
};
byte[] disableph_false = new byte[5] {
0xE8, 0xA5, 0x54, 0x00, 0x00
};
byte[] disableph_true = new byte[5] {
0x90, 0x90, 0x90, 0x90, 0x90
};
int disable1 = 0x0040C5AB;
int disable2 = 0x0040C540;
int disableph = 0x0040C396;
if (value && puck_enabled)
{
Debug.Print("collision disabled");
MemoryEditor.WriteBytes(disable1_true, disable1);
MemoryEditor.WriteBytes(disable2_true, disable2);
MemoryEditor.WriteBytes(disableph_true, disableph);
Puck.Position = new HQMVector(Puck.Position.X, 0.2f, Puck.Position.Z);
Puck.Velocity = HQMVector.Zero;
Puck.RotationalVelocity = HQMVector.Zero;
puck_enabled = false;
}
if (!value && !puck_enabled)
{
Debug.Print("collision enabled");
MemoryEditor.WriteBytes(disable1_false, disable1);
MemoryEditor.WriteBytes(disable2_false, disable2);
MemoryEditor.WriteBytes(disableph_false, disableph);
puck_enabled = true;
}
}
public String fetchRoflDownloadUrl(UInt64 matchId)
{
IntPtr funcAddr = _leagueClientMemoryEditor.AllocateMemory(asm.Length);
//Structs not packed so 0x18 instead of 0x14 and 0xC is skipped
IntPtr paramsAddr = _leagueClientMemoryEditor.AllocateMemory(0x18);
//Write our custom function
_leagueClientMemoryEditor.WriteBytes(funcAddr, asm);
//Function Address is the address which our custom asm calls
_leagueClientMemoryEditor.WriteUInt32(paramsAddr, _functionAddress);
//Class Address is ECX, a class which is initialized which gets passed in to above function
_leagueClientMemoryEditor.WriteUInt32(paramsAddr + 0x4, _classAddress);
//Successful call will place a ptr to the download link here
_leagueClientMemoryEditor.WriteUInt32(paramsAddr + 0x8, 0);
//+16 (0x10) not +12 (0xC) because it wasnt packed, MatchID is a MatchID
_leagueClientMemoryEditor.WriteUInt64(paramsAddr + 0x10, matchId);
//Call Func and wait for completion
_leagueClientMemoryEditor.WaitForSingleObject(_leagueClientMemoryEditor.CreateRemoteThread(funcAddr, paramsAddr));
IntPtr downloadUrlIntPtr;
//Read the download Ptr
_leagueClientMemoryEditor.ReadIntPtr(paramsAddr + 0x8, out downloadUrlIntPtr);
String downloadUrl = "";
//If its null then call failed, Match Might not exist, User might not be logged in etc
if (downloadUrlIntPtr != IntPtr.Zero)
{
_leagueClientMemoryEditor.ReadNullTerminatedString(downloadUrlIntPtr, out downloadUrl);
}
//Free Memory of the ones we allocated and also the injected function
//TODO: Get LeagueClient to free the memory of the download URL though this is minor, though still a memory leak
//TODO: Potentially just allocated and reuse memory once?
_leagueClientMemoryEditor.FreeMemory(funcAddr);
_leagueClientMemoryEditor.FreeMemory(paramsAddr);
return(downloadUrl);
}
/*
* Byte[] asm = { 0xE8, 0x00, 0x00, 0x00, 0x00, 0xEB, 0x00, 0xA1, 0xC0, 0x00, 0x00, 0x00 };
* X86Disassembler d = new X86Disassembler(new MemoryStreamReader(asm));
* X86Instruction i = d.ReadNextInstruction();
* i = d.ReadNextInstruction();
* i = d.ReadNextInstruction();
*/
private static void LoadWadFiles(IntPtr function1Address, int funcOffset, IntPtr functionAddress, IntPtr ECDSA)
{
uint functionLength;
uint functionLength1;
uint ECDSALen;
MemoryEditor.FindPattern(@"\xC2\x04\x00\xCC", "xxxx", ECDSA, out ECDSALen);
MemoryEditor.FindPattern(@"\xC2\x08\x00\xCC", "xxxx", functionAddress, out functionLength);
MemoryEditor.FindPattern(@"\xC3\x57\xE8\x00\x00\x00\x00\xCC", "xxx????x", function1Address, out functionLength1);
functionLength = (functionLength - (uint)functionAddress) + 4;
ECDSALen = (ECDSALen - (uint)ECDSA) + 4;
functionLength1 = (functionLength1 - (uint)function1Address) + 8;
//Steal the function:
Byte[] asmECDSA;
MemoryEditor.ReadBytes(ECDSA, (int)ECDSALen, out asmECDSA);
Byte[] asm1;
MemoryEditor.ReadBytes(function1Address, (int)functionLength1, out asm1);
Byte[] asm;
MemoryEditor.ReadBytes(functionAddress, (int)functionLength, out asm);
//Allocate and copy the function to our new memory
IntPtr AllocatedMemory = MemoryEditor.AllocateMemory(0x1000);
//MemoryEditor.WriteBytes(AllocatedMemory, asm);
//Fix the bytecode for the new offsets:
X86Disassembler disassembler = new X86Disassembler(new MemoryStreamReader(asmECDSA));
while (disassembler.BaseStream.Position != disassembler.BaseStream.Length)
{
X86Instruction instruction = disassembler.ReadNextInstruction();
if (instruction.Mnemonic == X86Mnemonic.Je && instruction.Offset == 0x49)
{
Buffer.BlockCopy(new Byte[] { 0x90, 0x90 }, 0, asmECDSA, (int)instruction.Offset, 2);
continue;
}
if (instruction.Mnemonic != X86Mnemonic.Call || (instruction.Operand1 != null && instruction.Operand1.OperandUsage == X86OperandUsage.DwordPointer))
{
continue;
}
if (instruction.Operand1.Value.ToString() == "Eax")
{
continue;
}
//Fix the Call:
int offset;
MemoryEditor.ReadInt(ECDSA + (int)instruction.Offset + 1, out offset);
int callAddress = (5 + (int)instruction.Offset + (int)ECDSA) + offset;
offset = callAddress - ((int)AllocatedMemory + (int)instruction.Offset + 5);
Buffer.BlockCopy(BitConverter.GetBytes(offset), 0, asmECDSA, (int)instruction.Offset + 1, 4);
}
MemoryEditor.WriteBytes(AllocatedMemory, asmECDSA);
AllocatedMemory += asmECDSA.Length;
disassembler = new X86Disassembler(new MemoryStreamReader(asm));
while (disassembler.BaseStream.Position != disassembler.BaseStream.Length)
{
X86Instruction instruction = disassembler.ReadNextInstruction();
/*if (instruction.Mnemonic == X86Mnemonic.Jne)
* {
* Buffer.BlockCopy(new Byte[] { 0xEB }, 0, asm, (int)instruction.Offset, 1);
* continue;
* }*/
if (instruction.Mnemonic != X86Mnemonic.Call || (instruction.Operand1 != null && instruction.Operand1.OperandUsage == X86OperandUsage.DwordPointer))
{
continue;
}
if (instruction.Offset == 0x128)
{
Buffer.BlockCopy(BitConverter.GetBytes(((int)AllocatedMemory - asmECDSA.Length) - ((int)AllocatedMemory + (int)instruction.Offset + 5))
, 0, asm, (int)instruction.Offset + 1, 4);
continue;
}
//Fix the Call:
int offset;
MemoryEditor.ReadInt(functionAddress + (int)instruction.Offset + 1, out offset);
int callAddress = (5 + (int)instruction.Offset + (int)functionAddress) + offset;
offset = callAddress - ((int)AllocatedMemory + (int)instruction.Offset + 5);
Buffer.BlockCopy(BitConverter.GetBytes(offset), 0, asm, (int)instruction.Offset + 1, 4);
}
MemoryEditor.WriteBytes(AllocatedMemory, asm);
AllocatedMemory += asm.Length;
disassembler = new X86Disassembler(new MemoryStreamReader(asm1));
while (disassembler.BaseStream.Position != disassembler.BaseStream.Length)
{
X86Instruction instruction = disassembler.ReadNextInstruction();
if (instruction.Mnemonic != X86Mnemonic.Call || (instruction.Operand1 != null && instruction.Operand1.OperandUsage == X86OperandUsage.DwordPointer))
{
continue;
}
if (instruction.Offset == funcOffset)
{
Buffer.BlockCopy(BitConverter.GetBytes(((int)AllocatedMemory - asm.Length) - ((int)AllocatedMemory + (int)instruction.Offset + 5))
, 0, asm1, (int)instruction.Offset + 1, 4);
continue;
}
//Fix the Call:
int offset;
MemoryEditor.ReadInt(function1Address + (int)instruction.Offset + 1, out offset);
int callAddress = (5 + (int)instruction.Offset + (int)function1Address) + offset;
offset = callAddress - ((int)AllocatedMemory + (int)instruction.Offset + 5);
Buffer.BlockCopy(BitConverter.GetBytes(offset), 0, asm1, (int)instruction.Offset + 1, 4);
}
MemoryEditor.WriteBytes(AllocatedMemory, asm1);
IntPtr LoadWadFunction = AllocatedMemory;
AllocatedMemory += asm1.Length;
//Allocate Variables
IntPtr StringAddress = AllocatedMemory + 0x10;
//0x38 for failedFunctionCallback
AllocatedMemory = StringAddress + 0x110;
byte[] customAsm =
{
0x60, //pushad
0x6A, 0x00,
0x68, 0x00, 0x00, 0x00, 0x00,
0xE8, 0x00, 0x00, 0x00, 0x00,
0x5B, //pop x2,
0x5B,
0x61, //popad
0xEB, 0xFE //Endless Loop so we know to correct the EIP
};
Buffer.BlockCopy(BitConverter.GetBytes((uint)StringAddress), 0, customAsm, 0x4, 4);
Buffer.BlockCopy(BitConverter.GetBytes((uint)LoadWadFunction - ((uint)AllocatedMemory + 0xD)), 0, customAsm, 0x9, 4);
MemoryEditor.WriteBytes(AllocatedMemory, customAsm);
int lockedEip = (int)AllocatedMemory + customAsm.Length - 2;
MemoryEditor.Suspend();
MemoryEditor.Context context = MemoryEditor.GetThreadContext();
uint originalEip = context.Eip;
//Load Each WADFile:
foreach (String wadFile in WadFiles)
{
MemoryEditor.Suspend();
context.Eip = (uint)AllocatedMemory;
MemoryEditor.SetThreadContext(context);
MemoryEditor.WriteNullTerminatedString(StringAddress, wadFile);
MemoryEditor.Resume();
//NOTE: THE CODE HAS TO RUN ON MAIN THREAD TO PROPERLY LOAD WADS
//MemoryEditor.WaitForSingleObject(MemoryEditor.CreateRemoteThread(AllocatedMemory, IntPtr.Zero));
bool loop = true;
while (loop)
{
context = MemoryEditor.GetThreadContext();
loop = context.Eip != lockedEip;
MemoryEditor.Resume();
}
}
context.Eip = originalEip;
MemoryEditor.SetThreadContext(context);
MemoryEditor.FreeMemory(AllocatedMemory);
}
public static void Highlight(int value) //0=disable 1=red 2=blue
{
int shape_a = 0x0043585D;
int shape_h = 0x004358EA;
int shape_b = 0x004355B9;
int color = 0x004355BE;
int color_change = 0x04600081;
int y = 0x07D3490C;
if (value == 0 && highlighted)
{
Debug.Print("disable highlight");
MemoryEditor.WriteBytes(new byte[2] {
0x6A, 0x04
}, shape_a);
MemoryEditor.WriteBytes(new byte[7] {
0xC7, 0x45, 0xF0, 0x00, 0x00, 0x80, 0x3C
}, shape_h);
MemoryEditor.WriteBytes(new byte[5] {
0x68, 0x00, 0x00, 0x80, 0x3E
}, shape_b);
MemoryEditor.WriteBytes(new byte[6] {
0x6A, 0x00, 0x6A, 0x00, 0x6A, 0x00
}, color);
MemoryEditor.WriteFloat(352f, y);
System.Threading.Thread.Sleep(1000);
highlighted = false;
}
if (value == 1 && !highlighted)
{
highlighted = true;
Debug.Print("red highlight");
MemoryEditor.WriteBytes(new byte[2] {
0x6A, 0x06
}, shape_a);
MemoryEditor.WriteBytes(new byte[7] {
0xC7, 0x45, 0xF0, 0x00, 0x00, 0x80, 0x3F
}, shape_h);
MemoryEditor.WriteBytes(new byte[5] {
0x68, 0x00, 0x00, 0x80, 0x3F
}, shape_b);
MemoryEditor.WriteBytes(new byte[6] {
0xE9, 0xBE, 0xAA, 0x1C, 0x04, 0x90
}, color);
MemoryEditor.WriteBytes(new byte[14] {
0x6A, 0x00, 0x6A, 0x00, 0x68, 0x00, 0x00, 0x80, 0x3F, 0xE9, 0x35, 0x55, 0xE3, 0xFB
}, color_change);
MemoryEditor.WriteFloat(1352f, y);
}
if (value == 2 && !highlighted)
{
highlighted = true;
Debug.Print("blue highlight");
MemoryEditor.WriteBytes(new byte[2] {
0x6A, 0x06
}, shape_a);
MemoryEditor.WriteBytes(new byte[7] {
0xC7, 0x45, 0xF0, 0x00, 0x00, 0x80, 0x3F
}, shape_h);
MemoryEditor.WriteBytes(new byte[5] {
0x68, 0x00, 0x00, 0x80, 0x3F
}, shape_b);
MemoryEditor.WriteBytes(new byte[6] {
0xE9, 0xBE, 0xAA, 0x1C, 0x04, 0x90
}, color);
MemoryEditor.WriteBytes(new byte[14] {
0x68, 0x00, 0x00, 0x80, 0x3F, 0x6A, 0x00, 0x6A, 0x00, 0xE9, 0x35, 0x55, 0xE3, 0xFB
}, color_change);
MemoryEditor.WriteFloat(1352f, y);
}
}
static void Init(string processName)
{
while (!MemoryEditor.Init(processName))
{
}
MemoryEditor.WriteInt(28, 0x045B290); //server version
MemoryEditor.WriteInt(1, 0x4476164); //hide rink
MemoryEditor.WriteInt(1, 0x813AF88); //show names on minimap
byte[] stick_drawing = new byte[5] {
0x90, 0x90, 0x90, 0x90, 0x90
};
int stick_drawing_add = 0x0043410A;
MemoryEditor.WriteBytes(stick_drawing, stick_drawing_add);
byte[] code_original = new byte[9] {
0xE9, 0x0C, 0xBA, 0x1C, 0x04, 0x90, 0x90, 0x90, 0x90
};
byte[] code_inject = new byte[20] {
0x68, 0x33, 0x33, 0x73, 0x3F, 0x68, 0x33, 0x33, 0x73, 0x3F, 0x68, 0x33, 0x33, 0x73, 0x3F, 0xE9, 0xE4, 0x45, 0xE3, 0xFB
};
int addr_original = 0x004345EF;
int addr_inject = 0x04600000;
MemoryEditor.WriteBytes(code_inject, addr_inject);
MemoryEditor.WriteBytes(code_original, addr_original);
byte[] cbluegoal_original = new byte[9] {
0xE9, 0x3D, 0xBA, 0x1C, 0x04, 0x90, 0x90, 0x90, 0x90
};
byte[] cbluegoal_inj = new byte[20] {
0x68, 0x33, 0x33, 0x73, 0x3F, 0x68, 0x33, 0x33, 0x73, 0x3F, 0x68, 0x33, 0x33, 0x73, 0x3F, 0xE9, 0xB3, 0x45, 0xE3, 0xFB
};
int bluegoal_original = 0x004345DE;
int bluegoal_inject = 0x04600020;
MemoryEditor.WriteBytes(cbluegoal_inj, bluegoal_inject);
MemoryEditor.WriteBytes(cbluegoal_original, bluegoal_original);
byte[] spacecolor_o = new byte[6] {
0xE9, 0x36, 0x86, 0x1C, 0x04, 0x90
};
byte[] spacecolor_i = new byte[20] {
0x68, 0x14, 0xAE, 0x47, 0x3F, 0x68, 0xA8, 0xC6, 0x2B, 0x3F, 0x68, 0x12, 0x83, 0x20, 0x3F, 0xE9, 0xB7, 0x79, 0xE3, 0xFB
};
int spacolor_a = 0x00437A05;
int spacecolor_ainj = 0x04600040;
MemoryEditor.WriteBytes(spacecolor_i, spacecolor_ainj);
MemoryEditor.WriteBytes(spacecolor_o, spacolor_a);
byte[] warmupovrr_o = new byte[6] {
0xE9, 0x29, 0xD6, 0x1C, 0x04, 0x90
};
byte[] warmupovrr_i = new byte[27] {
0x0F, 0x8E, 0x72, 0x2B, 0xE3, 0xFB, 0x81, 0x3D, 0xA0, 0x3D, 0xD3, 0x07, 0xD0, 0x07, 0x00, 0x00, 0x0F, 0x8D, 0x62, 0x2B, 0xE3, 0xFB, 0xE9, 0xBD, 0x29, 0xE3, 0xFB
};
int warmupovrr_a = 0x00432A32;
int warmupovrr_ainj = 0x04600060;
MemoryEditor.WriteBytes(warmupovrr_i, warmupovrr_ainj);
MemoryEditor.WriteBytes(warmupovrr_o, warmupovrr_a);
//score bg
MemoryEditor.WriteBytes(new byte[5] {
0xE9, 0xF6, 0xD6, 0x1C, 0x04
}, 0x004329C6);
MemoryEditor.WriteBytes(new byte[50] {
0x68, 0xCD, 0xCC, 0x4C, 0x3E, 0x6A, 0x00, 0x6A, 0x00, 0x6A, 0x00, 0x6A, 0x00, 0x68, 0x00, 0x00, 0xF0, 0x41, 0x68, 0x00, 0x00, 0x16, 0x43, 0x68, 0x00, 0x00, 0xE0, 0x40, 0x68, 0x00, 0x00, 0x57, 0x44, 0x6A, 0xFF, 0xE8, 0xA8, 0x0B, 0xE5, 0xFB, 0xA1, 0x98, 0x3D, 0xD3, 0x07, 0xE9, 0xD8, 0x28, 0xE3, 0xFB
}, 0x046000C1);
//puck color in minimap
MemoryEditor.WriteBytes(new byte[6] {
0xE9, 0xD5, 0xDA, 0x1C, 0x04, 0x90
}, 0x00432621);
MemoryEditor.WriteBytes(new byte[20] {
0x68, 0x00, 0x00, 0x80, 0x3F, 0x68, 0x00, 0x00, 0x80, 0x3F, 0x68, 0x00, 0x00, 0x80, 0x3F, 0xE9, 0x18, 0x25, 0xE3, 0xFB
}, 0x046000FB);
//intermission message and short
MemoryEditor.WriteBytes(new byte[5] {
0x68, 0x68, 0x49, 0xD3, 0x07
}, 0x00432C4C);
MemoryEditor.WriteBytes(new byte[5] {
0x68, 0xE0, 0x48, 0xD3, 0x07
}, 0x00432E7D);
//show timers
MemoryEditor.WriteBytes(new byte[5] {
0xE9, 0x20, 0xD7, 0x1C, 0x04
}, 0x004329F0);
//07D3490C
MemoryEditor.WriteBytes(new byte[158] {
0xE8, 0x66, 0xFF, 0xE4, 0xFB, 0x83, 0xC4, 0x24, 0x83, 0x3D, 0xB4, 0x49, 0xD3, 0x07, 0x00, 0x74, 0x3D, 0xA1, 0xB4, 0x49, 0xD3, 0x07, 0x99, 0xB9, 0x64, 0x00, 0x00, 0x00, 0xF7, 0xF9, 0x50, 0x68, 0x00, 0x00, 0x80, 0x3F, 0x68, 0x00, 0x00, 0x80, 0x3F, 0x68, 0x00, 0x00, 0x80, 0x3F, 0x68, 0x00, 0x00, 0x80, 0x3F, 0x6A, 0x21, 0x68, 0x00, 0x00, 0x20, 0x42, 0x68, 0x00, 0x00, 0xB0, 0x43, 0x68, 0x00, 0x00, 0x00, 0x44, 0x68, 0x50, 0x75, 0x46, 0x00, 0xE8, 0x1D, 0xFF, 0xE4, 0xFB, 0x83, 0x3D, 0xA0, 0x3D, 0xD3, 0x07, 0x00, 0x0F, 0x84, 0x85, 0x28, 0xE3, 0xFB, 0xA1, 0xA0, 0x3D, 0xD3, 0x07, 0x99, 0xB9, 0x64, 0x00, 0x00, 0x00, 0xF7, 0xF9, 0x50, 0x68, 0x00, 0x00, 0x80, 0x3F, 0x68, 0x00, 0x00, 0x80, 0x3F, 0x68, 0x00, 0x00, 0x80, 0x3F, 0x68, 0x00, 0x00, 0x80, 0x3F, 0x6A, 0x21, 0x68, 0x00, 0x00, 0x20, 0x42, 0xFF, 0x35, 0x0C, 0x49, 0xD3, 0x07, 0x68, 0x00, 0x00, 0x00, 0x44, 0x68, 0x50, 0x75, 0x46, 0x00, 0xE8, 0xD2, 0xFE, 0xE4, 0xFB, 0xE9, 0x42, 0x28, 0xE3, 0xFB
}, 0x04600115);
}