public ItemReader(ProcessMemoryReader reader, D2MemoryTable memory) : base(reader, memory)
{
cachedItemData = new Dictionary <IntPtr, D2ItemData>();
cachedDescriptions = new Dictionary <int, D2ItemDescription>();
globals = reader.Read <D2GlobalData>(reader.ReadAddress32(memory.Address.GlobalData, AddressingMode.Relative));
lowQualityTable = reader.Read <D2SafeArray>(memory.Address.LowQualityItems, AddressingMode.Relative);
descriptionTable = reader.Read <D2SafeArray>(memory.Address.ItemDescriptions, AddressingMode.Relative);
magicModifiers = reader.Read <ModifierTable>(memory.Address.MagicModifierTable, AddressingMode.Relative);
rareModifiers = reader.Read <ModifierTable>(memory.Address.RareModifierTable, AddressingMode.Relative);
if (globals != null)
{
opNestings = reader.ReadArray <ushort>(globals.OpStatNesting, (int)globals.OpStatNestingCount);
if (ItemStatCost == null && !globals.ItemStatCost.IsNull)
{
ItemStatCost = reader.ReadArray <D2ItemStatCost>(globals.ItemStatCost, (int)globals.ItemStatCostCount);
}
}
}
public static void Start(Process process)
{
if (_running)
{
return;
}
_running = true;
AdministrativeRights.Ensure();
if (process == null)
{
throw new ArgumentNullException(nameof(process));
}
_reader = new ProcessMemoryReader(process);
_process = process;
_cancellationSource = new CancellationTokenSource();
_pulseTask = new Task(async() =>
{
while (!_cancellationSource.IsCancellationRequested)
{
try
{
Pulse();
await Task.Delay(new TimeSpan(0, 0, 0, 0, 10));
}
catch (Exception)
{
_cancellationSource.Cancel();
throw;
}
}
}, _cancellationSource.Token);
Pulse();
_pulseTask.Start();
}
public bool LinkToDosBOX(int floor, int room, int detectedGame)
{
if (!TryGetMemoryReader(out ProcessReader))
{
return(false);
}
if (!FindActorsAddress(detectedGame))
{
ProcessReader.Close();
ProcessReader = null;
return(false);
}
//force reload
linkfloor = floor;
linkroom = room;
dosBoxPattern = detectedGame - 1;
return(true);
}
public void ReadRootNode()
{
try
{
var MengeCandidateProcess = System.Diagnostics.Process.GetProcessesByName("exefile");
var EveProcess = MengeCandidateProcess.FirstOrDefault();
if (null == EveProcess)
{
return;
}
MemoryReader = new ProcessMemoryReader(EveProcess);
PyMemoryReader = new PythonMemoryReader(MemoryReader);
RootNode = EveOnline.UIRoot(PyMemoryReader);
}
catch (Exception e)
{
RootNode = null;
}
}
static void Main(string[] args)
{
ProcessMemoryReader p = new ProcessMemoryReader();
if (p.FindProcess("ffxiv_dx11"))
{
p.OpenProcess();
//not found is 0
Console.WriteLine(p.handle);
IntPtr ptr = FindWindow(null, "最终幻想XIV");
//not found is 0
Console.WriteLine(ptr);
}
else
{
Console.WriteLine("Not Found");
}
Console.ReadLine();
}
void WriteActorPosition(Box actor, Vector3 lowerBound, Vector3 upperBound, Vector3 localPosition, Vector3 worldPosition)
{
ProcessMemoryReader processReader = GetComponent <DosBox>().ProcessReader;
//get object offset
int address = GetComponent <DosBox>().GetActorMemoryAddress(actor.Slot);
//update to memory
//bounds
byte[] buffer = new byte[12];
buffer.Write(lowerBound, upperBound, 0);
processReader.Write(buffer, address + 8, 12);
//local+world
buffer.Write(localPosition, 0);
buffer.Write(worldPosition, 6);
processReader.Write(buffer, address + 28, 12);
actor.LocalPosition = localPosition;
actor.WorldPosition = worldPosition;
actor.BoundingLower = lowerBound;
actor.BoundingUpper = upperBound;
}
private void WriteActorPosition(Box actor, Vector3 lowerBound, Vector3 upperBound, Vector3 localPosition, Vector3 worldPosition)
{
ProcessMemoryReader ProcessReader = GetComponent <DosBox>().ProcessReader;
//get object offset
int index = Actors.GetComponentsInChildren <Box>(true).ToList().IndexOf(actor);
if (index != -1)
{
long offset = GetComponent <DosBox>().GetActorMemoryAddress(index);
//update to memory
//bounds
byte[] buffer = new byte[12];
Utils.WriteShort((int)lowerBound.x, buffer, 0);
Utils.WriteShort((int)upperBound.x, buffer, 2);
Utils.WriteShort((int)lowerBound.y, buffer, 4);
Utils.WriteShort((int)upperBound.y, buffer, 6);
Utils.WriteShort((int)lowerBound.z, buffer, 8);
Utils.WriteShort((int)upperBound.z, buffer, 10);
ProcessReader.Write(buffer, offset + 8, 12);
//local+world
Utils.WriteShort((int)localPosition.x, buffer, 0);
Utils.WriteShort((int)localPosition.y, buffer, 2);
Utils.WriteShort((int)localPosition.z, buffer, 4);
Utils.WriteShort((int)worldPosition.x, buffer, 6);
Utils.WriteShort((int)worldPosition.y, buffer, 8);
Utils.WriteShort((int)worldPosition.z, buffer, 10);
ProcessReader.Write(buffer, offset + 28, 12);
warpActor.LocalPosition = localPosition;
warpActor.WorldPosition = worldPosition;
warpActor.BoundingLower = lowerBound;
warpActor.BoundingUpper = upperBound;
}
}
public static void StartMemoryManager(uint BasePointer, string BaseProcessName)
{
try
{
Pointer = BasePointer;
ProcessName = BaseProcessName;
mReader = new ProcessMemoryReader();
Process process = Process.GetProcessesByName(ProcessName).ToList().FirstOrDefault();
if (process != null)
{
mReader.ReadProcess = process;
mReader.OpenProcess();
}
else
{
throw new Exception("Couldn't find process");
}
}
catch (Exception ex)
{
MessageBox.Show("MemoryManager: Constructor: error " + ex.Message);
}
}
// StatCostClassId => looks like statcost is in high bits and class is in low bits
// example:
// 00AC0000
// 00AC => statcost idx
// 0000 => class id
public static int GetArrayIndexByStatCostClassId(ProcessMemoryReader r, IntPtr addr, int StatCostClassId)
{
D2StatArray statArray = r.Read <D2StatArray>(addr);
ushort statArrayLen = statArray.Length;
if (statArrayLen < 1)
{
return(-1);
}
for (int i = statArrayLen - 1; i >= 0; i--)
{
// read the itemstatcost
//
int value = r.ReadInt32(statArray.Address.Address + i * 8);
if (value == StatCostClassId)
{
return(i);
}
}
return(-1);
}
public static IList <Player> GetPlayers(ProcessMemoryReader memoryReader)
{
IList <Player> players = new List <Player>();
for (var i = 0; i < Offsets.MaxEntities; i++)
{
var heapAddress = GetHeapAddress(GetEntities(memoryReader), i);
if (heapAddress != 0)
{
players.Add(new Player()
{
PlayerId = i,
TeamId = ReadInt(memoryReader, heapAddress, Offsets.EntityTeamId),
Health = ReadInt(memoryReader, heapAddress, Offsets.EntityHealth),
X = ReadSingle(memoryReader, heapAddress, Offsets.EntityCoordinateOffset + 0),
Y = ReadSingle(memoryReader, heapAddress, Offsets.EntityCoordinateOffset + 4),
Z = ReadSingle(memoryReader, heapAddress, Offsets.EntityCoordinateOffset + 8)
});
}
}
return(players);
}
/// <summary>
/// The thread funktion to poll the telemetry data and send TelemetryUpdated events.
/// </summary>
private void Run()
{
isStopped = false;
WFSTAPI lastTelemetryData = new WFSTAPI();
lastTelemetryData.Reset();
Matrix4x4 lastTransform = Matrix4x4.Identity;
bool lastFrameValid = false;
Vector3 lastVelocity = Vector3.Zero;
float lastYaw = 0.0f;
Stopwatch sw = new Stopwatch();
sw.Start();
NestedSmooth accXSmooth = new NestedSmooth(3, 6, 0.5f);
NestedSmooth accYSmooth = new NestedSmooth(3, 6, 0.5f);
NestedSmooth accZSmooth = new NestedSmooth(3, 6, 0.5f);
KalmanFilter velXFilter = new KalmanFilter(1, 1, 0.02f, 1, 0.02f, 0.0f);
KalmanFilter velZFilter = new KalmanFilter(1, 1, 0.02f, 1, 0.02f, 0.0f);
NoiseFilter velXSmooth = new NoiseFilter(6, 0.5f);
NoiseFilter velZSmooth = new NoiseFilter(6, 0.5f);
KalmanFilter yawRateFilter = new KalmanFilter(1, 1, 0.02f, 1, 0.02f, 0.0f);
NoiseFilter yawRateSmooth = new NoiseFilter(6, 0.5f);
NoiseFilter pitchFilter = new NoiseFilter(3);
NoiseFilter rollFilter = new NoiseFilter(3);
NoiseFilter yawFilter = new NoiseFilter(3);
KalmanFilter posXFilter = new KalmanFilter(1, 1, 0.02f, 1, 0.1f, 0.0f);
KalmanFilter posYFilter = new KalmanFilter(1, 1, 0.02f, 1, 0.1f, 0.0f);
KalmanFilter posZFilter = new KalmanFilter(1, 1, 0.02f, 1, 0.1f, 0.0f);
NestedSmooth posXSmooth = new NestedSmooth(12, 6, 0.5f);
NestedSmooth posYSmooth = new NestedSmooth(12, 6, 0.5f);
NestedSmooth posZSmooth = new NestedSmooth(12, 6, 0.5f);
NoiseFilter slipAngleSmooth = new NoiseFilter(6, 0.25f);
ProcessMemoryReader reader = new ProcessMemoryReader();
reader.ReadProcess = wfstProcess;
uint readSize = 4 * 4 * 4;
byte[] readBuffer = new byte[readSize];
reader.OpenProcess();
while (!isStopped)
{
try
{
float dt = (float)sw.ElapsedMilliseconds / 1000.0f;
int byteReadSize;
reader.ReadProcessMemory((IntPtr)memoryAddress, readSize, out byteReadSize, readBuffer);
if (byteReadSize == 0)
{
continue;
}
float[] floats = new float[4 * 4];
Buffer.BlockCopy(readBuffer, 0, floats, 0, readBuffer.Length);
Matrix4x4 transform = new Matrix4x4(floats[0], floats[1], floats[2], floats[3]
, floats[4], floats[5], floats[6], floats[7]
, floats[8], floats[9], floats[10], floats[11]
, floats[12], floats[13], floats[14], floats[15]);
Vector3 rht = new Vector3(transform.M11, transform.M12, transform.M13);
Vector3 up = new Vector3(transform.M21, transform.M22, transform.M23);
Vector3 fwd = new Vector3(transform.M31, transform.M32, transform.M33);
float rhtMag = rht.Length();
float upMag = up.Length();
float fwdMag = fwd.Length();
//reading garbage
if (rhtMag < 0.9f || upMag < 0.9f || fwdMag < 0.9f)
{
IsConnected = false;
IsRunning = false;
TelemetryLost();
break;
}
if (!lastFrameValid)
{
lastTransform = transform;
lastFrameValid = true;
lastVelocity = Vector3.Zero;
lastYaw = 0.0f;
continue;
}
WFSTAPI telemetryData = new WFSTAPI();
if (dt <= 0)
{
dt = 1.0f;
}
Vector3 worldVelocity = (transform.Translation - lastTransform.Translation) / dt;
lastTransform = transform;
Matrix4x4 rotation = new Matrix4x4();
rotation = transform;
rotation.M41 = 0.0f;
rotation.M42 = 0.0f;
rotation.M43 = 0.0f;
Matrix4x4 rotInv = new Matrix4x4();
Matrix4x4.Invert(rotation, out rotInv);
Vector3 localVelocity = Vector3.Transform(worldVelocity, rotInv);
telemetryData.velX = worldVelocity.X;
telemetryData.velZ = worldVelocity.Z;
Vector3 localAcceleration = localVelocity - lastVelocity;
lastVelocity = localVelocity;
telemetryData.accX = localAcceleration.X * 10.0f;
telemetryData.accY = localAcceleration.Y * 100.0f;
telemetryData.accZ = localAcceleration.Z * 10.0f;
float pitch = (float)Math.Asin(-fwd.Y);
float yaw = (float)Math.Atan2(fwd.X, fwd.Z);
float roll = 0.0f;
Vector3 rhtPlane = rht;
rhtPlane.Y = 0;
rhtPlane = Vector3.Normalize(rhtPlane);
if (rhtPlane.Length() <= float.Epsilon)
{
roll = -(float)(Math.Sign(rht.Y) * Math.PI * 0.5f);
}
else
{
roll = -(float)Math.Asin(Vector3.Dot(up, rhtPlane));
}
telemetryData.pitchPos = pitch;
telemetryData.yawPos = yaw;
telemetryData.rollPos = roll;
telemetryData.yawRate = CalculateAngularChange(lastYaw, yaw) * (180.0f / (float)Math.PI);
lastYaw = yaw;
// otherwise we are connected
IsConnected = true;
if (IsConnected)
{
IsRunning = true;
WFSTAPI telemetryToSend = new WFSTAPI();
telemetryToSend.Reset();
telemetryToSend.CopyFields(telemetryData);
telemetryToSend.accX = accXSmooth.Filter(telemetryData.accX);
telemetryToSend.accY = accYSmooth.Filter(telemetryData.accY);
telemetryToSend.accZ = accZSmooth.Filter(telemetryData.accZ);
telemetryToSend.pitchPos = pitchFilter.Filter(telemetryData.pitchPos);
telemetryToSend.rollPos = rollFilter.Filter(telemetryData.rollPos);
telemetryToSend.yawPos = yawFilter.Filter(telemetryData.yawPos);
telemetryToSend.velX = velXSmooth.Filter(velXFilter.Filter(telemetryData.velX));
telemetryToSend.velZ = velZSmooth.Filter(velZFilter.Filter(telemetryData.velZ));
telemetryToSend.yawRate = yawRateSmooth.Filter(yawRateFilter.Filter(telemetryData.yawRate));
telemetryToSend.yawAcc = slipAngleSmooth.Filter(telemetryToSend.CalculateSlipAngle());
sw.Restart();
TelemetryEventArgs args = new TelemetryEventArgs(
new WFSTTelemetryInfo(telemetryToSend, lastTelemetryData));
RaiseEvent(OnTelemetryUpdate, args);
lastTelemetryData = telemetryToSend;
Thread.Sleep(1000 / 100);
}
else if (sw.ElapsedMilliseconds > 500)
{
IsRunning = false;
}
}
catch (Exception e)
{
LogError("WFSTTelemetryProvider Exception while processing data", e);
IsConnected = false;
IsRunning = false;
Thread.Sleep(1000);
}
}
IsConnected = false;
IsRunning = false;
reader.CloseHandle();
}
private static float ReadSingle(ProcessMemoryReader memoryReader, int baseaddress, int offset)
{
return(BitConverter.ToSingle(memoryReader.ReadProcessMemory((IntPtr)(baseaddress + offset), 4, out int _), 0));
}
private static int ReadInt(ProcessMemoryReader memoryReader, int baseaddress, int offset)
{
return(BitConverter.ToInt32(memoryReader.ReadProcessMemory((IntPtr)(baseaddress + offset), 4, out int _), 0));
}
private static byte[] GetEntities(ProcessMemoryReader memoryReader)
{
return(memoryReader.ReadProcessMemory((IntPtr)(Offsets.ClientBaseAddress + Offsets.EntityListBaseAddress), (uint)(Offsets.MaxEntities * Offsets.EntityLength), out int _));
}
public void SearchForPatterns(ProcessMemoryReader reader)
{
varsMemoryAddress = reader.SearchForBytePattern(varsMemoryPattern);
cvarsMemoryAddress = reader.SearchForBytePattern(cvarsMemoryPattern);
}
public static void SetProcessMemoryReader()
{
preader = new ProcessMemoryReader(CampahStatus.Instance.process.Id);
IntPtr pointer = sigscan(Constants.AH_SIG);//+Constants.AH_OFFSETS[0];
for (int i = 0; i < Constants.AH_OFFSETS.Length; i++)
pointer = readPointer(pointer, Constants.AH_OFFSETS[i]);
AhStructPointer = pointer;
// IntPtr pointer2 = sigscan(Constants.MENU_SIG, false);
// BidValue = 1000;
// String pstr = ((int)pointer2).ToString("X4");
// IntPtr pointer3 = sigscan(pstr.Substring(6) + pstr.Substring(4, 2) + pstr.Substring(2, 2) + pstr.Substring(0, 2));
// MenuStructPointer = (IntPtr)((int)pointer2 + Constants.MENU_OFFSET);
BidValPointer = readPointer(readPointer(sigscan(Constants.BIDVAL_SIG),0),0);
}
internal void hackHealth(ProcessMemoryReader mem)
{
mem.WriteInt(base_addr + health_offset, 1000); // 체력 1000으로...
}
public FFVIIIMemoryAddresses(IntPtr ProcessAddress, ref ProcessMemoryReader MemReader)
{
ProcessBaseAddress = ProcessAddress;
reader = MemReader;
}
public static void SetProcessMemoryReader()
{
_preader = new ProcessMemoryReader(CampahStatus.Instance.process.Id);
var pointer = SigScan(Constants.AH_SIG);//+Constants.AH_OFFSETS[0];
pointer = Constants.AH_OFFSETS.Aggregate(pointer, ReadPointer);
AhStructPointer = pointer;
BidValPointer = ReadPointer(ReadPointer(SigScan(Constants.BIDVAL_SIG), 0), 0);
MenuStructurePointer = new IntPtr(SigScan(Constants.MENU_SIG).ToInt32() + 10);
}
public WowObject(ProcessMemoryReader reader, uint objectBaseAddress)
{
_reader = reader;
BaseAddress = objectBaseAddress;
UnitFieldsAddress = _reader.ReadUInt(BaseAddress + (uint)Offsets.WowObjectManager.DESCRIPTOR);
}
public void UpdateItemStats(ProcessMemoryReader r, D2MemoryTable memory, D2Unit pl)
{
InventoryReader inventoryReader = new InventoryReader(r, memory);
UnitReader unitReader = new UnitReader(r, memory);
// Build filter to get only equipped items.
Func <D2ItemData, bool> filter = data => data.BodyLoc != BodyLocation.None;
foreach (D2Unit item in inventoryReader.EnumerateInventory(filter))
{
List <D2Stat> itemStats = unitReader.GetStats(item);
if (itemStats == null)
{
continue;
}
StringBuilder statBuilder = new StringBuilder();
statBuilder.Append(inventoryReader.ItemReader.GetFullItemName(item));
statBuilder.Append("\n");
List <string> magicalStrings = inventoryReader.ItemReader.GetMagicalStrings(item);
foreach (string str in magicalStrings)
{
statBuilder.Append(" ");
statBuilder.Append(str);
statBuilder.Append("\n");
}
Control c = null;
D2ItemData itemData = r.Read <D2ItemData>(item.UnitData);
switch (itemData.BodyLoc)
{
case BodyLocation.Head: c = tabPageHead; break;
case BodyLocation.Amulet: c = tabPageAmulet; break;
case BodyLocation.BodyArmor: c = tabPageBody; break;
case BodyLocation.PrimaryRight: c = tabPageWeaponRight; break;
case BodyLocation.PrimaryLeft: c = tabPageWeaponLeft; break;
case BodyLocation.RingRight: c = tabPageRingRight; break;
case BodyLocation.RingLeft: c = tabPageRingLeft; break;
//case BodyLocation.SecondaryLeft: c = tabPageRingRight; break;
//case BodyLocation.SecondaryRight: c = tabPageRingLeft; break;
case BodyLocation.Belt: c = tabPageBelt; break;
case BodyLocation.Boots: c = tabPageFeet; break;
case BodyLocation.Gloves: c = tabPageHand; break;
}
if (c != null)
{
if (c.Controls.Count == 0)
{
c.Invoke(new Action(delegate() {
c.Controls.Add(new RichTextBox());
c.Controls[0].Dock = DockStyle.Fill;
}));
}
c.Controls[0].Invoke(new Action(() => c.Controls[0].Text = statBuilder.ToString()));
}
}
}
public CommandManager(Process process, ProcessMemoryReader reader)
{
_process = process;
_reader = reader;
}
public void Update()
{
if (m_GameProcess == null || m_GameProcess.HasExited)
{
if (m_SkipUpdates > 0)
{
--m_SkipUpdates;
return;
}
m_SkipUpdates = 4;
m_GameProcess = null;
Active = false;
if (Reader != null)
{
Reader.CloseHandle();
Reader = null;
}
if (m_Injector != null)
{
m_Injector.Dispose();
m_Injector = null;
}
var s_Processes = Process.GetProcessesByName("HitmanBloodMoney");
if (s_Processes.Length == 0)
{
return;
}
// We always select the first process.
m_GameProcess = s_Processes[0];
// Setup our Memory Reader.
Reader = new ProcessMemoryReader(m_GameProcess);
try
{
if (Reader.OpenProcess())
{
m_SkipUpdates = 0;
Active = true;
// Create our injector and inject our stat module.
m_Injector = new Injector(m_GameProcess, false);
m_Injector.InjectLibrary("HM3.dll");
// Setup our main control.
MainApp.MainWindow.Dispatcher.Invoke(() =>
{
Control = new MainControl();
});
// Setup our engine-specific classes.
StatTracker = new StatTracker(this);
TimeTracker = new TimeTracker(this);
// Update level labels.
CurrentLevel = "No Level";
CurrentLevelScene = "No Level";
InGame = false;
Control.SetCurrentLevel(CurrentLevel);
Control.SetCurrentLevelScene(CurrentLevelScene);
// Set our control in the main window.
InitMenuItems();
MainApp.MainWindow.SetEngineControl(Control, m_MenuItems);
}
}
catch (Exception)
{
m_GameProcess = null;
Active = false;
}
}
if (!Active)
{
return;
}
// Update our trackers.
TimeTracker.Update();
StatTracker.Update();
// Set game time.
if (StatTracker.CurrentStats.m_Time > 0 || !InGame)
{
Control.SetCurrentTime(StatTracker.CurrentStats.m_Time);
}
else
{
Control.SetCurrentTime(TimeTracker.CurrentTime);
}
}
public UnitReader(ProcessMemoryReader reader, GameMemoryTable memory)
{
this.reader = reader;
this.memory = memory;
stringReader = new StringLookupTable(reader, memory.Address);
}
public StringLookupTable(ProcessMemoryReader reader, GameMemoryAddressTable memory)
{
this.reader = reader;
this.memory = memory;
}
internal float getAimErr(ProcessMemoryReader mem, double _x_angle, double _y_angle)
{
return(Double2Float(Math.Pow(x_angle - _x_angle, 2) + Math.Pow(y_angle - _y_angle, 2)));
}
public WowUnit(ProcessMemoryReader reader, uint objectBaseAddress)
: base(reader, objectBaseAddress)
{
_reader = reader;
_objectBaseAddress = objectBaseAddress;
}
public InventoryReader(ProcessMemoryReader reader, ItemReader itemReader)
{
processReader = reader;
ItemReader = itemReader;
}
internal void hackAmmo(ProcessMemoryReader mem)
{
mem.WriteInt(base_addr + ammo_offset, 1000); // 탄약 1000으로...
}
public void UnlinkDosBox()
{
ProcessReader.Close();
ProcessReader = null;
RightText.text = string.Empty;
}
public InventoryReader(ProcessMemoryReader reader, D2MemoryTable memory)
{
processReader = reader;
this.memory = memory;
itemReader = new ItemReader(processReader, memory);
}
public static UIRect TranslateToClientRect(this UIRect rect, ProcessMemoryReader processMemory)
{
return(rect.TranslateToClientRect(processMemory.Process.MainWindowHandle));
}
