public SkillReader(IProcessMemoryReader reader, GameMemoryTable memory)
{
this.reader = reader;
globals = reader.Read <D2GlobalData>(reader.ReadAddress32(memory.GlobalData, AddressingMode.Relative));
stringReader = new StringLookupTable(reader, memory);
}
public UnitReader(
IProcessMemoryReader reader,
GameMemoryTable memory,
IStringReader stringReader,
ISkillReader skillReader
)
{
this.reader = reader;
this.stringReader = stringReader;
this.skillReader = skillReader;
cachedItemData = new Dictionary <IntPtr, D2ItemData>();
cachedDescriptions = new Dictionary <int, D2ItemDescription>();
globals = reader.Read <D2GlobalData>(reader.ReadAddress32(memory.GlobalData));
lowQualityTable = reader.Read <D2SafeArray>(memory.LowQualityItems);
descriptionTable = reader.Read <D2SafeArray>(memory.ItemDescriptions);
magicModifiers = reader.Read <ModifierTable>(memory.MagicModifierTable);
rareModifiers = reader.Read <ModifierTable>(memory.RareModifierTable);
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);
}
}
}
private GameMemoryTable CreateForReaderD2SEFallback1(IProcessMemoryReader reader)
{
// we try to detect version for D2SE
IntPtr baseAddress;
try
{
baseAddress = GetModuleAddress(
"fog.dll",
reader.ProcessInfo.ModuleBaseAddresses
);
} catch (ModuleNotLoadedException)
{
throw new GameVersionUnsupportedException("Unknown");
}
var pointer = new Pointer()
{
Base = baseAddress + 0x04AFE0,
Offsets = new int[] { 0x0, 0xe00 }
};
var versionAddress = reader.ResolvePointer(pointer);
var version = reader.ReadNullTerminatedString(versionAddress, 20, Encoding.ASCII);
Logger.Info($"Check D2SE version: {version}");
return(CreateForVersion(
version,
reader.ProcessInfo.BaseAddress,
reader.ProcessInfo.ModuleBaseAddresses
));
}
GameMemoryTable CreateGameMemoryTableForReader(IProcessMemoryReader reader)
{
var memoryTable = memoryTableFactory.CreateForReader(reader);
Logger.Debug($"Memory table created.");
return(memoryTable);
}
public static CommandManager GetDefault(IWowProcess process = null, IProcessMemoryReader reader = null,
KeyboardCommandDispatcher keyboard = null, ILogger logger = null)
{
if (_commandManager != null)
{
return(_commandManager);
}
if (process == null)
{
throw new ArgumentNullException(nameof(process));
}
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (keyboard == null)
{
throw new ArgumentNullException(nameof(keyboard));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_commandManager = new CommandManager(process, reader, keyboard, logger);
return(_commandManager);
}
public SkillReader(IProcessMemoryReader reader, GameMemoryTable memory)
{
this.reader = reader;
globals = reader.Read <D2GlobalData>(reader.ReadAddress32(memory.GlobalData));
stringReader = new StringReader(reader, memory);
}
bool InitializeGameDataReaders()
{
foreach (var desc in this.processDescriptions)
{
try
{
reader = ProcessMemoryReader.Create(desc.ProcessName, desc.ModuleName);
memory = CreateGameMemoryTableForReader(reader);
}
catch (ProcessNotFoundException)
{
CleanUpDataReaders();
}
catch (ModuleNotLoadedException)
{
CleanUpDataReaders();
}
if (reader != null)
{
break;
}
}
if (reader == null)
{
return(false);
}
Logger.Info($"Diablo II process found:");
Logger.Info(reader.ProcessInfo);
OnProcessFound(new ProcessFoundEventArgs(reader.ProcessInfo));
try
{
CreateReaders();
return(true);
}
catch (ModuleNotLoadedException e)
{
Logger.Error($"Try launching a game. Module not loaded: {e.ModuleName}", e);
CleanUpDataReaders();
return(false);
}
catch (GameVersionUnsupportedException e)
{
Logger.Error($"Version not supported: {e.GameVersion}", e);
CleanUpDataReaders();
return(false);
}
catch (ProcessMemoryReadException e)
{
Logger.Error($"Failed to read memory: {e.Message}", e);
CleanUpDataReaders();
return(false);
}
}
private CommandManager(IWowProcess process, IProcessMemoryReader reader, KeyboardCommandDispatcher keyboard,
ILogger logger)
{
_process = process;
_reader = reader;
_keyboard = keyboard;
_logger = logger;
}
void CleanUpDataReaders()
{
reader?.Dispose();
reader = null;
memory = null;
inventoryReader = null;
unitReader = null;
skillReader = null;
}
public StringLookupTable(IProcessMemoryReader reader, GameMemoryTable memory)
{
this.reader = reader;
this.memory = memory;
Language = DetectLanguage();
if (!Cache.ContainsKey(Language))
{
Cache[Language] = new Dictionary <ushort, string>();
}
}
void DisposeProcessReaderIfProcessTerminated()
{
if (!IsProcessReaderTerminated)
{
return;
}
Logger.Warn("Disposing process reader for terminated Diablo II process.");
reader.Dispose();
reader = null;
}
internal void Parse(
D2Unit unit,
UnitReader unitReader,
ISkillReader skillReader,
IProcessMemoryReader reader,
GameInfo gameInfo
)
{
var monsterData = unitReader.GetMonsterData(unit);
Name = reader.ReadNullTerminatedString(monsterData.szMonName, 300, System.Text.Encoding.Unicode);
Class = unit.eClass;
var skillIds = new List <uint>();
foreach (var skill in skillReader.EnumerateSkills(unit))
{
var d = skillReader.ReadSkillData(skill);
skillIds.Add(d.SkillId);
}
SkillIds = skillIds;
var data = unitReader.GetStatsMap(unit);
int penalty = ResistancePenalty.GetPenaltyByGame(gameInfo.Game);
int ValueByStatID(Dictionary <StatIdentifier, D2Stat> d, StatIdentifier statID)
{
// Get the value if if the key exists, else assume zero.
return(d.TryGetValue(statID, out D2Stat stat) ? stat.Value : 0);
}
int getStat(StatIdentifier statID) => ValueByStatID(data, statID);
Level = getStat(StatIdentifier.Level);
Experience = getStat(StatIdentifier.Experience);
Strength = getStat(StatIdentifier.Strength);
Dexterity = getStat(StatIdentifier.Dexterity);
int maxFire = BASE_MAX_RESIST + getStat(StatIdentifier.ResistFireMax);
int maxCold = BASE_MAX_RESIST + getStat(StatIdentifier.ResistColdMax);
int maxLightning = BASE_MAX_RESIST + getStat(StatIdentifier.ResistLightningMax);
int maxPoison = BASE_MAX_RESIST + getStat(StatIdentifier.ResistPoisonMax);
FireResist = Utility.Clamp(getStat(StatIdentifier.ResistFire) + penalty, MIN_RESIST, maxFire);
ColdResist = Utility.Clamp(getStat(StatIdentifier.ResistCold) + penalty, MIN_RESIST, maxCold);
LightningResist = Utility.Clamp(getStat(StatIdentifier.ResistLightning) + penalty, MIN_RESIST, maxLightning);
PoisonResist = Utility.Clamp(getStat(StatIdentifier.ResistPoison) + penalty, MIN_RESIST, maxPoison);
}
private GameMemoryTable CreateForReaderD2SEFallback2(IProcessMemoryReader reader)
{
// pre DiabloInterface v0.4.11 check for 1.13c in D2SE
//
// the check just reads the string displayed in D2SE,
// so this is not a safe check, but apparently neither is the one above.
// Until we can safely determine the D2 version with a single
// method, we keep the legacy check...
//
// this should be 1.13c, but most likely isn't, in many cases
string version = reader.ReadNullTerminatedString(reader.BaseAddress + 0x1A049, 5, Encoding.ASCII);
Logger.Info($"Check D2SE version (Fallback check): {version}");
return(CreateForVersion(version, reader.BaseAddress, reader.ModuleBaseAddresses));
}
protected virtual void Dispose(bool disposing)
{
if (isDisposed)
{
return;
}
Logger.Info("Data reader disposed.");
if (disposing && reader != null)
{
reader.Dispose();
reader = null;
}
isDisposed = true;
}
public GameMemoryTable CreateForReader(IProcessMemoryReader reader)
{
try
{
Logger.Info($"Check version: {reader.FileVersion}");
return(CreateForVersion(reader.FileVersion, reader.BaseAddress, reader.ModuleBaseAddresses));
}
catch (GameVersionUnsupportedException)
{
try
{
return(CreateForReaderD2SEFallback1(reader));
}
catch (GameVersionUnsupportedException)
{
return(CreateForReaderD2SEFallback2(reader));
}
}
}
public static void Start(IWowProcess process, IProcessMemoryReader processMemoryReader)
{
if (_running)
{
return;
}
_running = true;
AdministrativeRights.Ensure();
_reader = processMemoryReader;
_process = process;
if (_process == null)
{
throw new ArgumentNullException(nameof(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 GameMemoryTable CreateForReader(IProcessMemoryReader reader)
{
try
{
Logger.Info($"Check version: {reader.FileVersion}");
return(CreateForVersion(reader.FileVersion, reader.ModuleBaseAddresses));
}
catch (GameVersionUnsupportedException)
{
// we try to detect version for D2SE
var baseAddress = GetModuleAddress("Fog.dll", reader.ModuleBaseAddresses);
var pointer = new Pointer()
{
Base = new IntPtr(baseAddress + 0x0004AFE0), Offsets = new int[] { 0x0, 0xe00 }
};
IntPtr versionAddress = reader.ResolvePointer(pointer, AddressingMode.Relative);
string version = reader.ReadNullTerminatedString(versionAddress, 20, Encoding.ASCII, AddressingMode.Absolute);
try
{
Logger.Info($"Check D2SE version: {version}");
return(CreateForVersion(version, reader.ModuleBaseAddresses));
}
catch (GameVersionUnsupportedException)
{
// pre DiabloInterface v0.4.11 check for 1.13c in D2SE
//
// the check just reads the string displayed in D2SE,
// so this is not a safe check, but apparently neither is the one above.
// Until we can safely determine the D2 version with a single
// method, we keep the legacy check...
//
// this should be 1.13c, but most likely isn't, in many cases
version = reader.ReadNullTerminatedString(new IntPtr(0x1A049), 5, Encoding.ASCII, AddressingMode.Relative);
Logger.Info($"Check D2SE version (Fallback check): {version}");
return(CreateForVersion(version, reader.ModuleBaseAddresses));
}
}
}
// 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(IProcessMemoryReader 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 WowPlayer(IWowProcess wowProcess, IProcessMemoryReader reader, uint objectBaseAddress)
: base(reader, objectBaseAddress)
{
_wowProcess = wowProcess;
_reader = reader;
}
public InventoryReader(IProcessMemoryReader reader, UnitReader unitReader)
{
processReader = reader;
this.unitReader = unitReader;
}
public WowUnit(IProcessMemoryReader reader, uint objectBaseAddress)
: base(reader, objectBaseAddress)
{
_reader = reader;
_objectBaseAddress = objectBaseAddress;
}
protected WowObject(IProcessMemoryReader reader, uint objectBaseAddress)
{
_reader = reader;
BaseAddress = objectBaseAddress;
UnitFieldsAddress = _reader.ReadUInt(BaseAddress + (uint)Offsets.WowObjectManager.DESCRIPTOR);
}
