856 lines
36 KiB
C#
856 lines
36 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.Runtime.InteropServices.ComTypes;
|
|
using System.Runtime.Remoting;
|
|
using System.Security.Claims;
|
|
using System.Security.Cryptography;
|
|
using System.Security.Policy;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using System.Xml.Linq;
|
|
using static app.Enums;
|
|
using static app.EnumsStates;
|
|
using static app.MapAreaStruc;
|
|
using static System.Runtime.InteropServices.ComTypes.IStream;
|
|
using static System.Windows.Forms.AxHost;
|
|
|
|
namespace app
|
|
{
|
|
public class PlayerScan
|
|
{
|
|
Form1 Form1_0;
|
|
|
|
public long PlayerPointer = 0;
|
|
public long PlayerNamePointer = 0;
|
|
public long actAddress = 0;
|
|
public long mapSeedAddress = 0;
|
|
public Int64 pathAddress = 0;
|
|
public bool FoundPlayer = false;
|
|
public bool PlayerDead = false;
|
|
|
|
public long pAct = 0;
|
|
public uint mapSeedValue = 0;
|
|
public ushort xPos = 0;
|
|
public ushort yPos = 0;
|
|
public ushort xPosOffset = 0;
|
|
public ushort yPosOffset = 0;
|
|
public int xPosOffsetPercent = 0;
|
|
public int yPosOffsetPercent = 0;
|
|
public ushort xPosFinal = 0;
|
|
public ushort yPosFinal = 0;
|
|
public string pName = "";
|
|
public long pRoom1Address = 0;
|
|
public long pRoom2Address = 0;
|
|
public long pLevelAddress = 0;
|
|
public long levelNo = 0;
|
|
public long pStatsListEx = 0;
|
|
public long statPtr = 0;
|
|
public long statCount = 0;
|
|
|
|
public Enums.PlayerClass CurrentPlayerClass;
|
|
public Enums.Skill LeftSkill;
|
|
public Enums.Skill RightSkill;
|
|
|
|
public long PlayerGoldInventory = 0;
|
|
public long PlayerGoldInStash = 0;
|
|
public long PlayerHP = 0;
|
|
public long PlayerMaxHP = 0;
|
|
public long PlayerMana = 0;
|
|
public long PlayerMaxMana = 0;
|
|
public ushort difficulty = 0;
|
|
public uint lastdwInitSeedHash1 = 0;
|
|
public uint lastdwInitSeedHash2 = 0;
|
|
public string sFile = "";
|
|
public int PlayerSkillLeft = 0;
|
|
public int PlayerSkillRight = 0;
|
|
|
|
public int PlayerStrucCount = 0;
|
|
public uint unitId = 0;
|
|
public uint LeechPlayerUnitID = 0;
|
|
public long LeechPlayerPointer = 0;
|
|
public int LeechPosX = 0;
|
|
public int LeechPosY = 0;
|
|
public long LeechlevelNo = 0;
|
|
|
|
public ushort xPosFinalOtherP = 0;
|
|
public ushort yPosFinalOtherP = 0;
|
|
public bool IsCorpse = false;
|
|
public string pNameOther = "";
|
|
public uint unitIdOther = 0;
|
|
|
|
public int HPFromEquippedItems = 0;
|
|
public int ManaFromEquippedItems = 0;
|
|
public int VitalityFromEquippedItems = 0;
|
|
public int EnergyFromEquippedItems = 0;
|
|
public int HPPercentFromEquippedItems = 0;
|
|
public int ManaPercentFromEquippedItems = 0;
|
|
|
|
public long HPFromPlayer = 0;
|
|
public long ManaFromPlayer = 0;
|
|
public long VitalityFromPlayer = 0;
|
|
public long EnergyFromPlayer = 0;
|
|
public long HPPercentFromPlayer = 0;
|
|
public long ManaPercentFromPlayer = 0;
|
|
|
|
public bool PrintedLeechFoundInfo = false;
|
|
public bool HasBattleOrderState = false;
|
|
public long MaxHPValueWithBO = 0;
|
|
public long MaxManaValueWithBO = 0;
|
|
List<EnumsStates.State> PlayerStates = new List<EnumsStates.State>();
|
|
|
|
public int SameHPCount = 0;
|
|
public long LastPlayerHP = 0;
|
|
|
|
public int[] RoomExit = new int[2];
|
|
|
|
// REQUIRED METHODS
|
|
//[DllImport("checkmem.dll")]
|
|
//public static extern uint get_seed(uint InitSeedHash1, uint InitSeedHash2, uint EndSeedHash1);
|
|
|
|
public void SetForm1(Form1 form1_1)
|
|
{
|
|
Form1_0 = form1_1;
|
|
}
|
|
|
|
public void GetPositions()
|
|
{
|
|
Form1_0.SetProcessingTime();
|
|
|
|
pathAddress = Form1_0.Mem_0.ReadInt64Raw((IntPtr) (PlayerPointer + 0x38));
|
|
xPos = Form1_0.Mem_0.ReadUInt16Raw((IntPtr) (pathAddress + 0x02));
|
|
yPos = Form1_0.Mem_0.ReadUInt16Raw((IntPtr) (pathAddress + 0x06));
|
|
xPosOffset = Form1_0.Mem_0.ReadUInt16Raw((IntPtr) (pathAddress + 0x00));
|
|
yPosOffset = Form1_0.Mem_0.ReadUInt16Raw((IntPtr) (pathAddress + 0x04));
|
|
xPosOffsetPercent = (xPosOffset / 65536); //get percentage
|
|
yPosOffsetPercent = (yPosOffset / 65536); //get percentage
|
|
xPosFinal = (ushort)(xPos + xPosOffsetPercent);
|
|
yPosFinal = (ushort)(yPos + yPosOffsetPercent);
|
|
|
|
//long UnitID = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(PlayerPointer + 8));
|
|
//Console.WriteLine("PlayerID: 0x" + UnitID.ToString("X"));
|
|
|
|
//Console.WriteLine("X: " + xPos);
|
|
//Console.WriteLine("Off: " + Form1_0.Mem_0.ReadByteRaw((IntPtr)(pathAddress + 0x02)).ToString("X2"));
|
|
//Console.WriteLine("Off: " + Form1_0.Mem_0.ReadByteRaw((IntPtr)(pathAddress + 0x03)).ToString("X2"));
|
|
//Console.WriteLine("Off: " + Form1_0.Mem_0.ReadByteRaw((IntPtr)(pathAddress + 0x04)).ToString("X2"));
|
|
//Console.WriteLine("Off: " + Form1_0.Mem_0.ReadByteRaw((IntPtr)(pathAddress + 0x05)).ToString("X2"));
|
|
//byte[] bytee = new byte[2] { 0x76, 0x1e };
|
|
//Form1_0.Mem_0.WriteRawMemory((IntPtr)(pathAddress + 0x02), bytee, bytee.Length);
|
|
|
|
pStatsListEx = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(PlayerPointer + 0x88));
|
|
statPtr = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(pStatsListEx + 0x30));
|
|
statCount = Form1_0.Mem_0.ReadInt32Raw((IntPtr)(pStatsListEx + 0x38));
|
|
|
|
PlayerStates = GetStates(pStatsListEx);
|
|
HasBattleOrderState = HasState(EnumsStates.State.Battleorders, PlayerStates);
|
|
|
|
byte[] buffer = new byte[statCount * 8];
|
|
Form1_0.Mem_0.ReadRawMemory(statPtr + 0x2, ref buffer, (int) (statCount * 8));
|
|
|
|
if (Form1_0.Town_0.IsInTown)
|
|
{
|
|
PlayerHP = PlayerMaxHP;
|
|
if (PlayerHP == 0) PlayerHP = 100;
|
|
}
|
|
else
|
|
{
|
|
//reset player hp
|
|
PlayerHP = 0;
|
|
|
|
}
|
|
|
|
if (!Form1_0.GameStruc_0.IsInGame()) PlayerHP = PlayerMaxHP;
|
|
|
|
for (int i = 0; i < statCount; i++)
|
|
{
|
|
int offset = i * 8;
|
|
ushort statEnum = BitConverter.ToUInt16(buffer, offset);
|
|
uint statValue = BitConverter.ToUInt32(buffer, offset + 0x2);
|
|
|
|
//Console.WriteLine((Enums.Attribute) statEnum + " - " + statValue);
|
|
|
|
if (statEnum == (ushort) Enums.Attribute.Life)
|
|
{
|
|
PlayerHP = statValue >> 8;
|
|
}
|
|
if (statEnum == (ushort) Enums.Attribute.Mana)
|
|
{
|
|
PlayerMana = statValue >> 8;
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.GoldInPlayer)
|
|
{
|
|
PlayerGoldInventory = statValue;
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.GoldInStash)
|
|
{
|
|
PlayerGoldInStash = statValue;
|
|
}
|
|
//#####
|
|
/*if (statEnum == (ushort)Enums.Attribute.Vitality)
|
|
{
|
|
VitalityFromPlayer = statValue;
|
|
HPFromPlayer = statValue;
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.LifeMax)
|
|
{
|
|
HPFromPlayer = (statValue >> 8);
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.MaxHPPercent)
|
|
{
|
|
HPPercentFromPlayer = statValue;
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.Energy)
|
|
{
|
|
EnergyFromPlayer = statValue;
|
|
ManaFromPlayer = statValue;
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.ManaMax)
|
|
{
|
|
ManaFromPlayer = (statValue >> 8);
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.MaxManaPercent)
|
|
{
|
|
ManaPercentFromPlayer = statValue;
|
|
}*/
|
|
//#####
|
|
}
|
|
|
|
//Console.WriteLine("gold: " + PlayerGoldInventory);
|
|
|
|
if (PlayerHP == 0) PlayerDead = true;
|
|
else PlayerDead = false;
|
|
|
|
//; get the level number
|
|
pRoom1Address = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(pathAddress + 0x20));
|
|
pRoom2Address = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(pRoom1Address + 0x18));
|
|
pLevelAddress = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(pRoom2Address + 0x90));
|
|
levelNo = Form1_0.Mem_0.ReadUInt32Raw((IntPtr)(pLevelAddress + 0x1F8));
|
|
|
|
RoomExit[0] = Form1_0.Mem_0.ReadUInt16Raw((IntPtr)(pRoom1Address + 0x10));
|
|
RoomExit[1] = Form1_0.Mem_0.ReadUInt16Raw((IntPtr)(pRoom1Address + 0x14));
|
|
|
|
//; get/check for bad pointer
|
|
if (levelNo == 0 && xPosFinal == 0 && yPosFinal == 0)
|
|
{
|
|
Form1_0.HasPointers = false;
|
|
}
|
|
|
|
//#####################################################################################################
|
|
//#####################################################################################################
|
|
//#####################################################################################################
|
|
//; get the difficulty
|
|
actAddress = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(PlayerPointer + 0x20));
|
|
long aActUnk2 = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(actAddress + 0x78));
|
|
difficulty = Form1_0.Mem_0.ReadUInt16Raw((IntPtr)(aActUnk2 + 0x830));
|
|
|
|
//; get the map seed
|
|
long actMiscAddress = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(actAddress + 0x78)); //0x0000023a64ed4780; 2449824630656
|
|
uint dwInitSeedHash1 = Form1_0.Mem_0.ReadUInt32Raw((IntPtr)(actMiscAddress + 0x840));
|
|
uint dwInitSeedHash2 = Form1_0.Mem_0.ReadUInt32Raw((IntPtr)(actMiscAddress + 0x844));
|
|
uint dwEndSeedHash1 = Form1_0.Mem_0.ReadUInt32Raw((IntPtr)(actMiscAddress + 0x868));
|
|
|
|
/*byte[] buffData = new byte[0x100];
|
|
Form1_0.Mem_0.ReadRawMemory(actMiscAddress + 0x800, ref buffData, buffData.Length);
|
|
string SavePathh = Form1_0.ThisEndPath + "DumpHashStruc";
|
|
File.Create(SavePathh).Dispose();
|
|
File.WriteAllBytes(SavePathh, buffData);*/
|
|
|
|
var mapSeed = GetMapSeed((uint)dwInitSeedHash1, (uint)dwEndSeedHash1);
|
|
if (!mapSeed.Item2)
|
|
{
|
|
throw new Exception("Error calculating map seed");
|
|
}
|
|
|
|
|
|
mapSeedValue = mapSeed.Item1;
|
|
|
|
//Form1_0.method_1("SEED: " + mapSeed.Item1.ToString(), Color.Red);
|
|
//Form1_0.method_1("Difficulty: " + ((Difficulty) difficulty).ToString(), Color.Red);
|
|
//Form1_0.GetMapData(mapSeed.Item1.ToString(), (Difficulty) difficulty);
|
|
//#####################################################################################################
|
|
//#####################################################################################################
|
|
//#####################################################################################################
|
|
// Skills
|
|
long skillListPtr = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(PlayerPointer + 0x100));
|
|
//var skills = GetSkills(skillListPtr);
|
|
|
|
long leftSkillPtr = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(skillListPtr + 0x08));
|
|
long leftSkillTxtPtr = Form1_0.Mem_0.ReadInt64Raw((IntPtr)leftSkillPtr);
|
|
ushort leftSkillId = Form1_0.Mem_0.ReadUInt16Raw((IntPtr)leftSkillTxtPtr);
|
|
LeftSkill = (Enums.Skill)leftSkillId;
|
|
|
|
long rightSkillPtr = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(skillListPtr + 0x10));
|
|
long rightSkillTxtPtr = Form1_0.Mem_0.ReadInt64Raw((IntPtr)rightSkillPtr);
|
|
ushort rightSkillId = Form1_0.Mem_0.ReadUInt16Raw((IntPtr)rightSkillTxtPtr);
|
|
RightSkill = (Enums.Skill)rightSkillId;
|
|
|
|
// Class
|
|
uint classValue = Form1_0.Mem_0.ReadUInt32Raw((IntPtr)(PlayerPointer + 0x174));
|
|
CurrentPlayerClass = (Enums.PlayerClass)classValue;
|
|
//#####################################################################################################
|
|
//#####################################################################################################
|
|
//#####################################################################################################
|
|
|
|
//get player name
|
|
PlayerNamePointer = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(PlayerPointer + 0x10));
|
|
pName = Form1_0.Mem_0.ReadMemString(PlayerNamePointer);
|
|
//Form1_0.Potions_0.CheckHPAndManaMax(); //not used here
|
|
|
|
SetMaxHPAndMana();
|
|
|
|
Form1_0.Grid_SetInfos("Cords", xPosFinal + "," + yPosFinal);
|
|
Form1_0.Grid_SetInfos("Life", PlayerHP + "/" + PlayerMaxHP);
|
|
Form1_0.Grid_SetInfos("Mana", PlayerMana + "/" + PlayerMaxMana);
|
|
Form1_0.Grid_SetInfos("Map Level", levelNo.ToString() + " " + (Enums.Area) levelNo);
|
|
//Form1_0.Grid_SetInfos("Room Exit", RoomExit[0].ToString() + ", " + RoomExit[1].ToString());
|
|
//Form1_0.Grid_SetInfos("Seed", mapSeed.ToString());
|
|
//Form1_0.Grid_SetInfos("Difficulty", difficulty.ToString());
|
|
|
|
//Form1_0.method_1("URL: " + GetImageURL());
|
|
//DownloadImage(GetImageURL());
|
|
}
|
|
|
|
private const int MapHashDivisor = 1 << 16;
|
|
|
|
// Logic stolen from MapAssist, credits to them
|
|
public static (uint, bool) GetMapSeed(uint initHashSeed, uint endHashSeed)
|
|
{
|
|
uint gameSeedXor = 0;
|
|
var (seed, found) = ReverseMapSeedHash(endHashSeed);
|
|
if (found)
|
|
{
|
|
gameSeedXor = initHashSeed ^ seed;
|
|
}
|
|
|
|
if (gameSeedXor == 0)
|
|
{
|
|
return (0, false);
|
|
}
|
|
|
|
return (seed, true);
|
|
}
|
|
|
|
private static (uint, bool) ReverseMapSeedHash(uint hash)
|
|
{
|
|
uint incrementalValue = 1;
|
|
|
|
for (uint startValue = 0; startValue < uint.MaxValue; startValue += incrementalValue)
|
|
{
|
|
uint seedResult = (startValue * 0x6AC690C5 + 666) & 0xFFFFFFFF;
|
|
|
|
if (seedResult == hash)
|
|
{
|
|
return (startValue, true);
|
|
}
|
|
|
|
if (incrementalValue == 1 && (seedResult % MapHashDivisor) == (hash % MapHashDivisor))
|
|
{
|
|
incrementalValue = (uint)MapHashDivisor;
|
|
}
|
|
}
|
|
|
|
return (0, false);
|
|
}
|
|
|
|
public bool ShouldSeeShopForHP()
|
|
{
|
|
if (((Form1_0.PlayerScan_0.PlayerHP * 100) / Form1_0.PlayerScan_0.PlayerMaxHP) <= 80)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void SetMaxHPAndMana()
|
|
{
|
|
byte[] buffer = new byte[statCount * 8];
|
|
Form1_0.Mem_0.ReadRawMemory(statPtr + 0x2, ref buffer, (int)(statCount * 8));
|
|
|
|
for (int i = 0; i < statCount; i++)
|
|
{
|
|
int offset = i * 8;
|
|
ushort statEnum = BitConverter.ToUInt16(buffer, offset);
|
|
uint statValue = BitConverter.ToUInt32(buffer, offset + 0x2);
|
|
|
|
if (statEnum == (ushort)Enums.Attribute.LifeMax)
|
|
{
|
|
PlayerMaxHP = (statValue >> 8);
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.ManaMax)
|
|
{
|
|
PlayerMaxMana = (statValue >> 8);
|
|
}
|
|
}
|
|
|
|
//Console.WriteLine("added mana percent: " + ManaPercentFromEquippedItems);
|
|
double PercentHPAdd = Math.Ceiling(((double)HPPercentFromEquippedItems * (double)PlayerMaxHP) / 100);
|
|
double PercentManaAdd = Math.Ceiling(((double)ManaPercentFromEquippedItems * (double)PlayerMaxMana) / 100);
|
|
PlayerMaxHP = PlayerMaxHP + HPFromEquippedItems + (VitalityFromEquippedItems * 2) + (int)PercentHPAdd; //might be only for paladin
|
|
PlayerMaxMana = PlayerMaxMana + ManaFromEquippedItems + (EnergyFromEquippedItems / 2) + (int)PercentManaAdd; //might be only for paladin
|
|
|
|
|
|
/*double PercentHPAdd2 = Math.Ceiling(((double)HPPercentFromPlayer * (double)PlayerMaxHP) / 100);
|
|
PlayerMaxHP = PlayerMaxHP + (int)PercentHPAdd2;
|
|
|
|
double PercentManaAdd2 = Math.Ceiling(((double)ManaPercentFromPlayer * (double)PlayerMaxMana) / 100);
|
|
PlayerMaxMana = PlayerMaxMana + (int)PercentManaAdd2;*/
|
|
|
|
if (PlayerHP > PlayerMaxHP) PlayerMaxHP = PlayerHP;
|
|
if (PlayerMana > PlayerMaxMana) PlayerMaxMana = PlayerMana;
|
|
|
|
//Set Max HP With BattleOrder State
|
|
if (HasBattleOrderState)
|
|
{
|
|
//#####
|
|
//Check if Max HP/Mana remain the same, that BO 'power' level didn't changed
|
|
if (PlayerHP == LastPlayerHP)
|
|
{
|
|
SameHPCount++;
|
|
if (SameHPCount >= 30 && MaxHPValueWithBO != PlayerMaxHP)
|
|
{
|
|
MaxHPValueWithBO = PlayerMaxHP;
|
|
MaxManaValueWithBO = PlayerMaxMana;
|
|
|
|
PlayerMaxHP = MaxHPValueWithBO;
|
|
PlayerMaxMana = MaxManaValueWithBO;
|
|
|
|
SameHPCount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LastPlayerHP = PlayerHP;
|
|
SameHPCount = 0;
|
|
}
|
|
//#####
|
|
|
|
if (MaxHPValueWithBO < PlayerMaxHP)
|
|
{
|
|
MaxHPValueWithBO = PlayerMaxHP;
|
|
}
|
|
else
|
|
{
|
|
PlayerMaxHP = MaxHPValueWithBO;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MaxHPValueWithBO = 0;
|
|
}
|
|
|
|
//Set Max Mana With BattleOrder State
|
|
if (HasBattleOrderState)
|
|
{
|
|
if (MaxManaValueWithBO < PlayerMaxMana)
|
|
{
|
|
MaxManaValueWithBO = PlayerMaxMana;
|
|
}
|
|
else
|
|
{
|
|
PlayerMaxMana = MaxManaValueWithBO;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MaxManaValueWithBO = 0;
|
|
}
|
|
}
|
|
|
|
public bool HasAnyPlayerInArea(int ThisArea)
|
|
{
|
|
long UnitOffset = (long)Form1_0.BaseAddress + (long)Form1_0.offsets["rosterOffset"];
|
|
long partyStruct = Form1_0.Mem_0.ReadInt64Raw((IntPtr)UnitOffset);
|
|
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
ushort RosterlevelNo = Form1_0.Mem_0.ReadUInt16Raw((IntPtr)(partyStruct + 0x5C));
|
|
if (RosterlevelNo == ThisArea)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
partyStruct = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(partyStruct + 0x148));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void GetLeechPositions()
|
|
{
|
|
LeechPosX = (int) Form1_0.Mem_0.ReadUInt32Raw((IntPtr) (LeechPlayerPointer + 0x60));
|
|
LeechPosY = (int) Form1_0.Mem_0.ReadUInt32Raw((IntPtr) (LeechPlayerPointer + 0x64));
|
|
LeechlevelNo = Form1_0.Mem_0.ReadUInt16Raw((IntPtr)(LeechPlayerPointer + 0x5C));
|
|
|
|
Form1_0.Grid_SetInfos("LeechCords", LeechPosX + "," + LeechPosY);
|
|
|
|
//plevel = d2rprocess.read(partyStruct + 0x58, "UShort");
|
|
//partyId = d2rprocess.read(partyStruct + 0x5A, "UShort");
|
|
//hostilePtr = d2rprocess.read(partyStruct + 0x70, "Int64");
|
|
}
|
|
|
|
public void ScanForLeecher()
|
|
{
|
|
long UnitOffset = (long)Form1_0.BaseAddress + (long)Form1_0.offsets["rosterOffset"];
|
|
long partyStruct = Form1_0.Mem_0.ReadInt64Raw((IntPtr)UnitOffset);
|
|
LeechPlayerPointer = 0;
|
|
LeechPlayerUnitID = 0;
|
|
|
|
string LeeeechName = Form1_0.GameStruc_0.GameOwnerName;
|
|
if (CharConfig.IsRushing) LeeeechName = CharConfig.RushLeecherName;
|
|
|
|
if (LeeeechName == "")
|
|
{
|
|
Form1_0.method_1("Leecher name is empty!", Color.Red);
|
|
}
|
|
|
|
for (int i = 0; i < 9; i++)
|
|
{
|
|
string name = Form1_0.Mem_0.ReadMemString(partyStruct);
|
|
if (name.ToLower() == LeeeechName.ToLower())
|
|
{
|
|
if (!PrintedLeechFoundInfo)
|
|
{
|
|
Form1_0.method_1("Leecher pointer found!", Color.DarkViolet);
|
|
PrintedLeechFoundInfo = true;
|
|
}
|
|
LeechPlayerUnitID = Form1_0.Mem_0.ReadUInt32Raw((IntPtr)(partyStruct + 0x48));
|
|
LeechPlayerPointer = partyStruct;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
partyStruct = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(partyStruct + 0x148));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void scanForPlayer(bool QuickScan) //scanning for self
|
|
{
|
|
FoundPlayer = false;
|
|
|
|
int SizeArray = 0;
|
|
int SizeIncrement = 0;
|
|
byte[] unitTableBufferT = new byte[] { };
|
|
if (QuickScan)
|
|
{
|
|
SizeArray = (128 + 516) * 8;
|
|
SizeIncrement = 8;
|
|
unitTableBufferT = new byte[SizeArray];
|
|
long UnitOffset = (long)Form1_0.BaseAddress + (long)Form1_0.offsets["unitTable"] + Form1_0.UnitStrucOffset;
|
|
Form1_0.Mem_0.ReadRawMemory(UnitOffset, ref unitTableBufferT, SizeArray);
|
|
}
|
|
else
|
|
{
|
|
Form1_0.PatternsScan_0.scanForUnitsPointer("player");
|
|
SizeArray = Form1_0.PatternsScan_0.AllPlayersPointers.Count;
|
|
SizeIncrement = 1;
|
|
}
|
|
|
|
PlayerStrucCount = 0;
|
|
|
|
for (int i = 0; i < SizeArray; i += SizeIncrement)
|
|
{
|
|
long UnitPointerLocation = 0;
|
|
if (QuickScan)
|
|
{
|
|
UnitPointerLocation = BitConverter.ToInt64(unitTableBufferT, i);
|
|
}
|
|
else
|
|
{
|
|
UnitPointerLocation = Form1_0.PatternsScan_0.AllPlayersPointers[i];
|
|
}
|
|
|
|
if (UnitPointerLocation > 0)
|
|
{
|
|
byte[] itemdatastruc = new byte[144];
|
|
Form1_0.Mem_0.ReadRawMemory(UnitPointerLocation, ref itemdatastruc, 144);
|
|
|
|
// Do ONLY UnitType:0 && TxtFileNo:3
|
|
//if (BitConverter.ToUInt32(itemdatastruc, 0) == 0 && BitConverter.ToUInt32(itemdatastruc, 4) == 3)
|
|
if (BitConverter.ToUInt32(itemdatastruc, 0) == 0)
|
|
{
|
|
PlayerStrucCount++;
|
|
//Form1_0.method_1("PPointerLocation: 0x" + (UnitPointerLocation).ToString("X"));
|
|
|
|
long pUnitDataPtr = BitConverter.ToInt64(itemdatastruc, 0x10);
|
|
byte[] pUnitData = new byte[144];
|
|
Form1_0.Mem_0.ReadRawMemory(pUnitDataPtr, ref pUnitData, 144);
|
|
|
|
string name = "";
|
|
for (int i2 = 0; i2 < 16; i2++)
|
|
{
|
|
if (pUnitData[i2] != 0x00)
|
|
{
|
|
name += (char)pUnitData[i2];
|
|
}
|
|
}
|
|
//name = name.Replace("?", "");
|
|
//Form1_0.method_1("PNAME: " + name, Color.Red);
|
|
|
|
//Console.WriteLine(BitConverter.ToUInt32(itemdatastruc, 0));
|
|
//Console.WriteLine(BitConverter.ToUInt32(itemdatastruc, 4));
|
|
|
|
long ppath = BitConverter.ToInt64(itemdatastruc, 0x38);
|
|
byte[] ppathData = new byte[144];
|
|
Form1_0.Mem_0.ReadRawMemory(ppath, ref ppathData, 144);
|
|
|
|
//if posX equal not zero
|
|
if (BitConverter.ToInt16(ppathData, 2) != 0 && name == CharConfig.PlayerCharName)
|
|
{
|
|
Form1_0.method_1("------------------------------------------", Color.DarkBlue);
|
|
PlayerPointer = UnitPointerLocation;
|
|
Form1_0.Grid_SetInfos("Pointer", "0x" + PlayerPointer.ToString("X"));
|
|
FoundPlayer = true;
|
|
unitId = BitConverter.ToUInt32(itemdatastruc, 0x08);
|
|
Form1_0.method_1("Player ID: 0x" + unitId.ToString("X"), Color.DarkBlue);
|
|
|
|
/*string SavePathh = Form1_0.ThisEndPath + "DumpPlayerStruc";
|
|
File.Create(SavePathh).Dispose();
|
|
File.WriteAllBytes(SavePathh, itemdatastruc);
|
|
SavePathh = Form1_0.ThisEndPath + "DumpPlayerUnitData";
|
|
File.Create(SavePathh).Dispose();
|
|
File.WriteAllBytes(SavePathh, pUnitData);
|
|
SavePathh = Form1_0.ThisEndPath + "DumpPlayerPath";
|
|
File.Create(SavePathh).Dispose();
|
|
File.WriteAllBytes(SavePathh, ppathData);*/
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool ScanForOthersPlayers(long ThisUnitID, string ThisPlayerName, bool GetCorpseOnly)
|
|
{
|
|
//this can be used to get self corpse??
|
|
|
|
Form1_0.PatternsScan_0.scanForUnitsPointer("player");
|
|
for (int i = 0; i < Form1_0.PatternsScan_0.AllPlayersPointers.Count; i++)
|
|
{
|
|
long UnitPointerLocation = Form1_0.PatternsScan_0.AllPlayersPointers[i];
|
|
if (UnitPointerLocation > 0)
|
|
{
|
|
byte[] itemdatastruc = new byte[0x98];
|
|
Form1_0.Mem_0.ReadRawMemory(UnitPointerLocation, ref itemdatastruc, itemdatastruc.Length);
|
|
|
|
|
|
long pInventory = BitConverter.ToInt64(itemdatastruc, 0x90);
|
|
if (pInventory > 0)
|
|
{
|
|
unitIdOther = BitConverter.ToUInt32(itemdatastruc, 0x08);
|
|
|
|
long OtherpathAddress = Form1_0.Mem_0.ReadInt64Raw((IntPtr)(PlayerPointer + 0x38));
|
|
long OtherxPos = Form1_0.Mem_0.ReadUInt16Raw((IntPtr)(OtherpathAddress + 0x02));
|
|
long OtheryPos = Form1_0.Mem_0.ReadUInt16Raw((IntPtr)(OtherpathAddress + 0x06));
|
|
long OtherxPosOffset = Form1_0.Mem_0.ReadUInt16Raw((IntPtr)(OtherpathAddress + 0x00));
|
|
long OtheryPosOffset = Form1_0.Mem_0.ReadUInt16Raw((IntPtr)(OtherpathAddress + 0x04));
|
|
long OtherxPosOffsetPercent = (OtherxPosOffset / 65536); //get percentage
|
|
long OtheryPosOffsetPercent = (OtheryPosOffset / 65536); //get percentage
|
|
xPosFinalOtherP = (ushort)(OtherxPos + OtherxPosOffsetPercent);
|
|
yPosFinalOtherP = (ushort)(OtheryPos + OtheryPosOffsetPercent);
|
|
|
|
long pUnitDataPtr = BitConverter.ToInt64(itemdatastruc, 0x10);
|
|
byte[] pUnitData = new byte[144];
|
|
Form1_0.Mem_0.ReadRawMemory(pUnitDataPtr, ref pUnitData, 144);
|
|
|
|
string name = "";
|
|
for (int i2 = 0; i2 < 16; i2++)
|
|
{
|
|
if (pUnitData[i2] != 0x00)
|
|
{
|
|
name += (char)pUnitData[i2];
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
pNameOther = name;
|
|
|
|
IsCorpse = false;
|
|
if (Form1_0.Mem_0.ReadByteRaw((IntPtr)(PlayerPointer + 0x1A6)) == 1)
|
|
{
|
|
IsCorpse = true;
|
|
}
|
|
if (xPosFinalOtherP > 1 && yPosFinalOtherP > 1)
|
|
{
|
|
if (unitIdOther != 0)
|
|
{
|
|
if (unitIdOther == ThisUnitID)
|
|
{
|
|
if (!GetCorpseOnly || (GetCorpseOnly && IsCorpse))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (ThisPlayerName != "")
|
|
{
|
|
//Form1_0.method_1("TEST player corpse scan name: " + ThisPlayerName + "|" + IsCorpse, Color.OrangeRed);
|
|
|
|
if (pNameOther == ThisPlayerName)
|
|
{
|
|
if (!GetCorpseOnly || (GetCorpseOnly && IsCorpse))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void GetHPAndManaOnThisEquippedItem()
|
|
{
|
|
int AddedHP = 0;
|
|
int AddedMana = 0;
|
|
int AddedVit = 0;
|
|
int AddedEnergy = 0;
|
|
int AddedHPPercent = 0;
|
|
int AddedManaPercent = 0;
|
|
|
|
//item_maxmana_percent ln34 item_maxhp_percent ln34 skill_staminapercent
|
|
|
|
if (Form1_0.ItemsStruc_0.statCount > 0)
|
|
{
|
|
for (int i = 0; i < Form1_0.ItemsStruc_0.statCount; i++)
|
|
{
|
|
int offset = i * 8;
|
|
//short statLayer = BitConverter.ToInt16(Form1_0.ItemsStruc_0.statBuffer, offset);
|
|
ushort statEnum = BitConverter.ToUInt16(Form1_0.ItemsStruc_0.statBuffer, offset + 0x2);
|
|
int statValue = BitConverter.ToInt32(Form1_0.ItemsStruc_0.statBuffer, offset + 0x4);
|
|
|
|
if (statEnum == (ushort)Enums.Attribute.Vitality)
|
|
{
|
|
AddedVit += statValue;
|
|
AddedHP += statValue;
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.LifeMax)
|
|
{
|
|
AddedHP += (statValue >> 8);
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.MaxHPPercent)
|
|
{
|
|
AddedHPPercent += statValue;
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.Energy)
|
|
{
|
|
AddedEnergy += statValue;
|
|
AddedMana += statValue;
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.ManaMax)
|
|
{
|
|
AddedMana += (statValue >> 8);
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.MaxManaPercent)
|
|
{
|
|
AddedManaPercent += statValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Form1_0.ItemsStruc_0.statExCount > 0)
|
|
{
|
|
for (int i = 0; i < Form1_0.ItemsStruc_0.statExCount; i++)
|
|
{
|
|
int offset = i * 8;
|
|
//short statLayer = BitConverter.ToInt16(Form1_0.ItemsStruc_0.statBufferEx, offset);
|
|
ushort statEnum = BitConverter.ToUInt16(Form1_0.ItemsStruc_0.statBufferEx, offset + 0x2);
|
|
int statValue = BitConverter.ToInt32(Form1_0.ItemsStruc_0.statBufferEx, offset + 0x4);
|
|
|
|
if (statEnum == (ushort)Enums.Attribute.Vitality)
|
|
{
|
|
AddedVit += statValue;
|
|
AddedHP += statValue;
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.LifeMax)
|
|
{
|
|
AddedHP += (statValue >> 8);
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.MaxHPPercent)
|
|
{
|
|
AddedHPPercent += statValue;
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.Energy)
|
|
{
|
|
AddedEnergy += statValue;
|
|
AddedMana += statValue;
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.ManaMax)
|
|
{
|
|
AddedMana += (statValue >> 8);
|
|
}
|
|
if (statEnum == (ushort)Enums.Attribute.MaxManaPercent)
|
|
{
|
|
AddedManaPercent += statValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
HPFromEquippedItems += AddedHP;
|
|
ManaFromEquippedItems += AddedMana;
|
|
VitalityFromEquippedItems += AddedVit;
|
|
EnergyFromEquippedItems += AddedEnergy;
|
|
HPPercentFromEquippedItems += AddedHPPercent;
|
|
ManaPercentFromEquippedItems += AddedManaPercent;
|
|
}
|
|
|
|
public bool HasState(EnumsStates.State state, List<EnumsStates.State> ThisStatesList)
|
|
{
|
|
foreach (EnumsStates.State st in ThisStatesList)
|
|
{
|
|
if (st == state)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public List<EnumsStates.State> GetStates(long statsListExPtr)
|
|
{
|
|
List<EnumsStates.State> states = new List<EnumsStates.State>();
|
|
for (int i = 0; i < 6; i++)
|
|
{
|
|
int offset = i * 4;
|
|
byte stateByte = Form1_0.Mem_0.ReadByteRaw((IntPtr)(statsListExPtr + 0xAD0 + (uint)offset));
|
|
|
|
offset = (32 * i) - 1;
|
|
states.AddRange(CalculateStates(stateByte, (uint)offset));
|
|
}
|
|
|
|
return states;
|
|
}
|
|
|
|
// Assuming you have a Process class with a ReadUInt method
|
|
private Process Process = new Process();
|
|
|
|
private List<EnumsStates.State> CalculateStates(byte stateByte, uint offset)
|
|
{
|
|
List<EnumsStates.State> states = new List<EnumsStates.State>();
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
if ((stateByte & (1 << i)) != 0)
|
|
{
|
|
states.Add((EnumsStates.State)(offset + i + 1));
|
|
}
|
|
}
|
|
return states;
|
|
}
|
|
|
|
}
|
|
}
|