325 lines
10 KiB
Go
325 lines
10 KiB
Go
package memory
|
|
|
|
import (
|
|
"encoding/binary"
|
|
|
|
"github.com/hectorgimenez/d2go/pkg/data/mode"
|
|
|
|
"github.com/hectorgimenez/d2go/pkg/data"
|
|
"github.com/hectorgimenez/d2go/pkg/data/area"
|
|
"github.com/hectorgimenez/d2go/pkg/data/skill"
|
|
"github.com/hectorgimenez/d2go/pkg/data/state"
|
|
)
|
|
|
|
func (gd *GameReader) GetRawPlayerUnits() RawPlayerUnits {
|
|
rawPlayerUnits := make(RawPlayerUnits, 0)
|
|
hover := gd.HoveredData()
|
|
for i := 0; i < 128; i++ {
|
|
unitOffset := gd.offset.UnitTable + uintptr(i*8)
|
|
playerUnitAddr := gd.Process.moduleBaseAddressPtr + unitOffset
|
|
playerUnit := uintptr(gd.Process.ReadUInt(playerUnitAddr, Uint64))
|
|
for playerUnit > 0 {
|
|
unitID := gd.Process.ReadUInt(playerUnit+0x08, Uint32)
|
|
pInventory := playerUnit + 0x90
|
|
inventoryAddr := uintptr(gd.Process.ReadUInt(pInventory, Uint64))
|
|
|
|
pPath := playerUnit + 0x38
|
|
pathAddress := uintptr(gd.Process.ReadUInt(pPath, Uint64))
|
|
room1Ptr := uintptr(gd.Process.ReadUInt(pathAddress+0x20, Uint64))
|
|
room2Ptr := uintptr(gd.Process.ReadUInt(room1Ptr+0x18, Uint64))
|
|
levelPtr := uintptr(gd.Process.ReadUInt(room2Ptr+0x90, Uint64))
|
|
levelNo := gd.Process.ReadUInt(levelPtr+0x1F8, Uint32)
|
|
|
|
xPos := gd.Process.ReadUInt(pathAddress+0x02, Uint16)
|
|
yPos := gd.Process.ReadUInt(pathAddress+0x06, Uint16)
|
|
pUnitData := playerUnit + 0x10
|
|
playerNameAddr := uintptr(gd.Process.ReadUInt(pUnitData, Uint64))
|
|
name := gd.Process.ReadStringFromMemory(playerNameAddr, 0)
|
|
|
|
expCharPtr := uintptr(gd.Process.ReadUInt(gd.moduleBaseAddressPtr+gd.offset.Expansion, Uint64))
|
|
expChar := gd.Process.ReadUInt(expCharPtr+0x5C, Uint16)
|
|
gd.ExpChar = uint16(expChar)
|
|
isMainPlayer := gd.Process.ReadUInt(inventoryAddr+0x30, Uint16)
|
|
if expChar >= 2 {
|
|
isMainPlayer = gd.Process.ReadUInt(inventoryAddr+0x70, Uint16)
|
|
}
|
|
isCorpse := gd.Process.ReadUInt(playerUnit+0x1AE, Uint8)
|
|
|
|
statsListExPtr := uintptr(gd.Process.ReadUInt(playerUnit+0x88, Uint64))
|
|
baseStats := gd.getStatsList(statsListExPtr + 0x30)
|
|
stats := gd.getStatsList(statsListExPtr + 0xA8)
|
|
states := gd.GetStates(statsListExPtr)
|
|
playerMode := mode.PlayerMode(gd.Process.ReadUInt(playerUnit+0x0c, Uint32))
|
|
|
|
rawPlayerUnits = append(rawPlayerUnits, RawPlayerUnit{
|
|
UnitID: data.UnitID(unitID),
|
|
Address: playerUnit,
|
|
Name: name,
|
|
IsMainPlayer: isMainPlayer > 0,
|
|
IsCorpse: isCorpse == 1 && inventoryAddr > 0 && xPos > 0 && yPos > 0,
|
|
Area: area.ID(levelNo),
|
|
Position: data.Position{
|
|
X: int(xPos),
|
|
Y: int(yPos),
|
|
},
|
|
IsHovered: hover.IsHovered && hover.UnitID == data.UnitID(unitID) && hover.UnitType == 0,
|
|
States: states,
|
|
Stats: stats,
|
|
BaseStats: baseStats,
|
|
Mode: playerMode,
|
|
})
|
|
playerUnit = uintptr(gd.Process.ReadUInt(playerUnit+0x158, Uint64))
|
|
}
|
|
}
|
|
|
|
return rawPlayerUnits
|
|
}
|
|
|
|
func (gd *GameReader) GetPlayerUnit(mainPlayerUnit RawPlayerUnit) data.PlayerUnit {
|
|
// Skills
|
|
skillListPtr := uintptr(gd.Process.ReadUInt(mainPlayerUnit.Address+0x100, Uint64))
|
|
skills := gd.getSkills(skillListPtr)
|
|
|
|
leftSkillPtr := gd.Process.ReadUInt(skillListPtr+0x08, Uint64)
|
|
leftSkillTxtPtr := uintptr(gd.Process.ReadUInt(uintptr(leftSkillPtr), Uint64))
|
|
leftSkillId := uintptr(gd.Process.ReadUInt(leftSkillTxtPtr, Uint16))
|
|
|
|
rightSkillPtr := gd.Process.ReadUInt(skillListPtr+0x10, Uint64)
|
|
rightSkillTxtPtr := uintptr(gd.Process.ReadUInt(uintptr(rightSkillPtr), Uint64))
|
|
rightSkillId := uintptr(gd.Process.ReadUInt(rightSkillTxtPtr, Uint16))
|
|
|
|
// Class
|
|
class := data.Class(gd.Process.ReadUInt(mainPlayerUnit.Address+0x17C, Uint32))
|
|
|
|
availableWPs := gd.decodeWaypointMasks()
|
|
|
|
d := data.PlayerUnit{
|
|
Address: mainPlayerUnit.Address,
|
|
Name: mainPlayerUnit.Name,
|
|
ID: mainPlayerUnit.UnitID,
|
|
Area: mainPlayerUnit.Area,
|
|
Position: mainPlayerUnit.Position,
|
|
Stats: mainPlayerUnit.Stats,
|
|
BaseStats: mainPlayerUnit.BaseStats,
|
|
Skills: skills,
|
|
States: mainPlayerUnit.States,
|
|
Class: class,
|
|
LeftSkill: skill.ID(leftSkillId),
|
|
RightSkill: skill.ID(rightSkillId),
|
|
AvailableWaypoints: availableWPs,
|
|
Mode: mainPlayerUnit.Mode,
|
|
}
|
|
|
|
return d
|
|
}
|
|
|
|
// WaypointTableData returns the waypoint table struct and the data buffer it points to
|
|
func (gd *GameReader) WaypointTableData() (structAddr uintptr, structBuf []byte, dataAddr uintptr, dataBuf []byte) {
|
|
var structSize = uint(0x100)
|
|
var dataSize = uint(0x200)
|
|
|
|
ptrAddr := gd.moduleBaseAddressPtr + gd.offset.WaypointTableOffset
|
|
structAddr = uintptr(gd.Process.ReadUInt(ptrAddr, Uint64))
|
|
structBuf = gd.Process.ReadBytesFromMemory(structAddr, structSize)
|
|
if len(structBuf) >= 0x18 {
|
|
dataAddr = uintptr(binary.LittleEndian.Uint64(structBuf[0x10:]))
|
|
if dataAddr != 0 {
|
|
dataBuf = gd.Process.ReadBytesFromMemory(dataAddr, dataSize)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// decodeWaypointMasks reads the global waypoint bitfield from the waypoint table.
|
|
// It returns nil if the table cannot be read.
|
|
func (gd *GameReader) decodeWaypointMasks() []area.ID {
|
|
waypointOrder := []area.ID{
|
|
// Act 1
|
|
area.RogueEncampment, area.ColdPlains, area.StonyField, area.DarkWood, area.BlackMarsh,
|
|
area.OuterCloister, area.JailLevel1, area.InnerCloister, area.CatacombsLevel2,
|
|
// Act 2
|
|
area.LutGholein, area.SewersLevel2Act2, area.DryHills, area.HallsOfTheDeadLevel2, area.FarOasis,
|
|
area.LostCity, area.PalaceCellarLevel1, area.ArcaneSanctuary, area.CanyonOfTheMagi,
|
|
// Act 3
|
|
area.KurastDocks, area.SpiderForest, area.GreatMarsh, area.FlayerJungle, area.LowerKurast,
|
|
area.KurastBazaar, area.UpperKurast, area.Travincal, area.DuranceOfHateLevel2,
|
|
// Act 4
|
|
area.ThePandemoniumFortress, area.CityOfTheDamned, area.RiverOfFlame,
|
|
// Act 5
|
|
area.Harrogath, area.FrigidHighlands, area.ArreatPlateau, area.CrystallinePassage, area.GlacialTrail,
|
|
area.HallsOfPain, area.FrozenTundra, area.TheAncientsWay, area.TheWorldStoneKeepLevel2,
|
|
}
|
|
_, structBuf, _, _ := gd.WaypointTableData()
|
|
if len(structBuf) < 4 {
|
|
return nil
|
|
}
|
|
// First two bytes are the 0x0201 header; the next five bytes hold the bitfield (per classic D2 layout).
|
|
if structBuf[0] != 0x02 || structBuf[1] != 0x01 {
|
|
return nil
|
|
}
|
|
|
|
var bits uint64
|
|
for i := 0; i < 5 && 2+i < len(structBuf); i++ {
|
|
bits |= uint64(structBuf[2+i]) << (8 * i)
|
|
}
|
|
|
|
if bits == 0 {
|
|
return nil
|
|
}
|
|
|
|
out := make([]area.ID, 0, len(waypointOrder))
|
|
for idx, wpArea := range waypointOrder {
|
|
if bits&(1<<uint(idx)) != 0 {
|
|
out = append(out, wpArea)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (gd *GameReader) getSkills(skillListPtr uintptr) map[skill.ID]skill.Points {
|
|
skills := make(map[skill.ID]skill.Points)
|
|
|
|
skillPtr := uintptr(gd.Process.ReadUInt(skillListPtr, Uint64))
|
|
|
|
for skillPtr != 0 {
|
|
skillTxtPtr := uintptr(gd.Process.ReadUInt(skillPtr, Uint64))
|
|
skillTxt := uintptr(gd.Process.ReadUInt(skillTxtPtr, Uint16))
|
|
lvl := gd.Process.ReadUInt(skillPtr+0x40, Uint16)
|
|
charges := gd.Process.ReadUInt(skillPtr+0x48, Uint16)
|
|
|
|
shouldSetSkill := true
|
|
existingSkill, exists := skills[skill.ID(skillTxt)]
|
|
if exists {
|
|
if existingSkill.Charges == 0 && charges > 0 {
|
|
shouldSetSkill = false
|
|
}
|
|
}
|
|
|
|
if shouldSetSkill {
|
|
skills[skill.ID(skillTxt)] = skill.Points{
|
|
Level: lvl,
|
|
Charges: charges,
|
|
}
|
|
}
|
|
|
|
skillPtr = uintptr(gd.Process.ReadUInt(skillPtr+0x08, Uint64))
|
|
}
|
|
|
|
return skills
|
|
}
|
|
|
|
func (gd *GameReader) GetStates(statsListExPtr uintptr) state.States {
|
|
var states state.States
|
|
for i := 0; i < 6; i++ {
|
|
offset := i * 4
|
|
stateByte := gd.Process.ReadUInt(statsListExPtr+0xAF0+uintptr(offset), Uint32)
|
|
|
|
offset = (32 * i) - 1
|
|
states = append(states, calculateStates(stateByte, uint(offset))...)
|
|
}
|
|
|
|
return states
|
|
}
|
|
|
|
func calculateStates(stateFlag uint, offset uint) []state.State {
|
|
var states []state.State
|
|
if 0x00000001&stateFlag != 0 {
|
|
states = append(states, state.State(1+offset))
|
|
}
|
|
if 0x00000002&stateFlag != 0 {
|
|
states = append(states, state.State(2+offset))
|
|
}
|
|
if 0x00000004&stateFlag != 0 {
|
|
states = append(states, state.State(3+offset))
|
|
}
|
|
if 0x00000008&stateFlag != 0 {
|
|
states = append(states, state.State(4+offset))
|
|
}
|
|
if 0x00000010&stateFlag != 0 {
|
|
states = append(states, state.State(5+offset))
|
|
}
|
|
if 0x00000020&stateFlag != 0 {
|
|
states = append(states, state.State(6+offset))
|
|
}
|
|
if 0x00000040&stateFlag != 0 {
|
|
states = append(states, state.State(7+offset))
|
|
}
|
|
if 0x00000080&stateFlag != 0 {
|
|
states = append(states, state.State(8+offset))
|
|
}
|
|
if 0x00000100&stateFlag != 0 {
|
|
states = append(states, state.State(9+offset))
|
|
}
|
|
if 0x00000200&stateFlag != 0 {
|
|
states = append(states, state.State(10+offset))
|
|
}
|
|
if 0x00000400&stateFlag != 0 {
|
|
states = append(states, state.State(11+offset))
|
|
}
|
|
if 0x00000800&stateFlag != 0 {
|
|
states = append(states, state.State(12+offset))
|
|
}
|
|
if 0x00001000&stateFlag != 0 {
|
|
states = append(states, state.State(13+offset))
|
|
}
|
|
if 0x00002000&stateFlag != 0 {
|
|
states = append(states, state.State(14+offset))
|
|
}
|
|
if 0x00004000&stateFlag != 0 {
|
|
states = append(states, state.State(15+offset))
|
|
}
|
|
if 0x00008000&stateFlag != 0 {
|
|
states = append(states, state.State(16+offset))
|
|
}
|
|
if 0x00010000&stateFlag != 0 {
|
|
states = append(states, state.State(17+offset))
|
|
}
|
|
if 0x00020000&stateFlag != 0 {
|
|
states = append(states, state.State(18+offset))
|
|
}
|
|
if 0x00040000&stateFlag != 0 {
|
|
states = append(states, state.State(19+offset))
|
|
}
|
|
if 0x00080000&stateFlag != 0 {
|
|
states = append(states, state.State(20+offset))
|
|
}
|
|
if 0x00100000&stateFlag != 0 {
|
|
states = append(states, state.State(21+offset))
|
|
}
|
|
if 0x00200000&stateFlag != 0 {
|
|
states = append(states, state.State(22+offset))
|
|
}
|
|
if 0x00400000&stateFlag != 0 {
|
|
states = append(states, state.State(23+offset))
|
|
}
|
|
if 0x00800000&stateFlag != 0 {
|
|
states = append(states, state.State(24+offset))
|
|
}
|
|
if 0x01000000&stateFlag != 0 {
|
|
states = append(states, state.State(25+offset))
|
|
}
|
|
if 0x02000000&stateFlag != 0 {
|
|
states = append(states, state.State(26+offset))
|
|
}
|
|
if 0x04000000&stateFlag != 0 {
|
|
states = append(states, state.State(27+offset))
|
|
}
|
|
if 0x08000000&stateFlag != 0 {
|
|
states = append(states, state.State(28+offset))
|
|
}
|
|
if 0x10000000&stateFlag != 0 {
|
|
states = append(states, state.State(29+offset))
|
|
}
|
|
if 0x20000000&stateFlag != 0 {
|
|
states = append(states, state.State(30+offset))
|
|
}
|
|
if 0x40000000&stateFlag != 0 {
|
|
states = append(states, state.State(31+offset))
|
|
}
|
|
if 0x80000000&stateFlag != 0 {
|
|
states = append(states, state.State(32+offset))
|
|
}
|
|
|
|
return states
|
|
}
|