Local player offset

import pymem
import pymem.exception
import pymem.process
import tkinter as tk
import time
import math
import traceback
import pymem.ptypes

# ================================================
# CONFIGURATION
# ================================================
DEBUG = False  # Set to False to disable debug messages

# ================================================
# GAME ADDRESSES AND OFFSETS
# ================================================
ENTITY_LIST = 0x1097504
LOCAL_PLAYER = 0x1097680
ENTITY_OBJECT_OFFSETS = [0x7C]
ENTITY_POS_OFFSETS = [0xC4, 0x4, 0x80]
POSITION_OFFSETS = [0x8, 0x28, 0xC4, 0x4, 0x80]
ACCELERATION_OFFSETS = [0x8, 0x28, 0xC4, 0x4, 0xB0]

# ================================================
# ENTITY FILTERING
# ================================================
EXCLUDED_NAMES = [
    "pet", "portal", "abilities", "placeable", "cornerstone",
    "services", "client", "karma", "mana", "outpost",
]

# ================================================
# UTILITY CLASSES
# ================================================
class Vec3:
    """3D vector representation with basic math operations"""
    def __init__(self, x=0.0, y=0.0, z=0.0):
        self.x = float(x)
        self.y = float(y)
        self.z = float(z)

    def __sub__(self, other):
        return Vec3(self.x - other.x, self.y - other.y, self.z - other.z)

    def __add__(self, other):
        return Vec3(self.x + other.x, self.y + other.y, self.z + other.z)

    def is_not_zero(self):
        """Check if vector has non-zero values"""
        return math.floor(self.x) != 0.0 and math.floor(self.y) != 0.0 and math.floor(self.z) != 0.0

    def length(self):
        """Calculate vector magnitude"""
        return math.sqrt(self.x * self.x + self.y * self.y + self.z * self.z)

    def normalized(self):
        """Return normalized version of the vector"""
        len_ = self.length()
        return Vec3() if len_ == 0.0 else Vec3(self.x/len_, self.y/len_, self.z/len_)

class Entity:
    """Game entity representation"""
    def __init__(self, name="", position=Vec3(), range=-1.0, scale=0.5):
        self.name = name
        self.position = position
        self.range = range
        self.scale = scale

# ================================================
# MEMORY OPERATIONS
# ================================================
def debug_print(*args, **kwargs):
    """Wrapper for debug messages"""
    if DEBUG:
        print("[DEBUG]", *args, **kwargs)

def read_pointer_chain(pm, base, offsets):
    """Follow pointer chain to get final memory address"""
    if not offsets:
        return base
    try:
        ptr = pymem.ptypes.RemotePointer(pm.process_handle, base)
        for offset in offsets[:-1]:
            ptr = pymem.ptypes.RemotePointer(pm.process_handle, ptr.value + offset)
        return ptr.value + offsets[-1]
    except Exception as e:
        debug_print(f"Pointer chain failed: {str(e)}")
        return None

def read_vec3(pm, base, offsets):
    """Read 3D vector from memory"""
    addr = read_pointer_chain(pm, base, offsets)
    try:
        return (
            pm.read_float(addr),
            pm.read_float(addr + 0x4),
            pm.read_float(addr + 0x8)
        )
    except Exception as e:
        debug_print(f"Failed to read Vec3: {str(e)}")
        return (0, 0, 0)

def write_vec3(pm, base, offsets, vec):
    """Write 3D vector to memory"""
    addr = read_pointer_chain(pm, base, offsets)
    try:
        pm.write_float(addr, vec[0])
        pm.write_float(addr + 0x4, vec[1])
        pm.write_float(addr + 0x8, vec[2])
    except Exception as e:
        debug_print(f"Failed to write Vec3: {str(e)}")

def get_address(pm, base, offsets):
    """Calculate address from base and offsets"""
    try:
        address = base
        for offset in offsets[:-1]:
            address = pm.read_uint(address + offset)
            if address == 0:
                return 0
        return address + offsets[-1] if offsets else base
    except Exception as e:
        debug_print(f"Address calculation failed: {str(e)}")
        return 0

def read_string(pm, address, max_len):
    """Read string from memory"""
    try:
        bytes_ = pm.read_bytes(address, max_len)
        return bytes_.split(b'\0', 1)[0].decode('latin-1', errors='replace')
    except Exception as e:
        debug_print(f"String read failed: {str(e)}")
        return ""

# ================================================
# ENTITY MANAGEMENT
# ================================================
def get_all_entities(pm, world, our_pos, max_range):
    """Retrieve all entities within specified range"""
    entities = []
    nodes = []
    
    try:
        if world == 0:
            return entities
            
        node_info = get_address(pm, world, [0x7C])
        base_addr = pm.read_uint(node_info)
        size_addr = get_address(pm, node_info, [0x8])
        size = pm.read_uint(size_addr)
        step = pm.read_uint(get_address(pm, node_info, [0x4]))

        # Node collection logic
        if size == 0:
            address = base_addr
            for _ in range(100):  # Fail-safe
                address_next = pm.read_uint(address) & 0xFFFFFFFE
                if address_next == 0:
                    break
                nodes.append(address)
                address = address_next
        else:
            for i in range(size):
                address = base_addr + i * step
                while True:
                    address_next = pm.read_uint(address)
                    if address_next == 1:
                        break
                    nodes.append(address)
                    address = address_next & 0xFFFFFFFE
                    if address == 0:
                        break

        # Entity processing
        for node in nodes:
            try:
                entity = get_address(pm, node, [0x10, 0xC4, 0x4, 0x0])
                name_addr = get_address(pm, entity, [0x58, 0x64, 0x0])
                
                if not name_addr:
                    continue
                    
                name = read_string(pm, name_addr, 96)
                if not name or any(ex in name.lower() for ex in EXCLUDED_NAMES):
                    continue
                    
                pos_addr = get_address(pm, entity, [0x58, 0xC4, 0x4, 0x80])
                if not pos_addr:
                    continue
                    
                position = Vec3(
                    pm.read_float(pos_addr),
                    pm.read_float(pos_addr + 0x4),
                    pm.read_float(pos_addr + 0x8)
                )
                delta = position - our_pos
                dist = delta.length()
                
                if dist < max_range:
                    entities.append((dist, Entity(name, position, dist)))
                    
            except Exception as e:
                debug_print(f"Entity processing error: {str(e)}")

    except Exception as e:
        debug_print(f"get_all_entities error: {str(e)}")
        traceback.print_exc()

    return entities

def nearest_entity(entities):
    """Find closest entity from list"""
    return min(entities, key=lambda x: x[0])[1] if entities else Entity()

# ================================================
# BOT CORE
# ================================================
class TroveBot:
    """Main application class"""
    def __init__(self):
        self.pm = None
        self.base = None
        self.root = tk****()
        self.canvas = tk.Canvas(self.root, width=500, height=500, bg='black')
        self.canvas.pack()
        
        try:
            self.initialize_memory()
            self.root.after(50, self.update)
            self.root.mainloop()
        except Exception as e:
            print(f"Initialization failed: {str(e)}")
            input("Press ENTER to exit...")

    def initialize_memory(self):
        """Connect to game process"""
        debug_print("Initializing memory...")
        self.pm = pymem.Pymem("Trove.exe")
        self.base = pymem.process.module_from_name(
            self.pm.process_handle, 
            "Trove.exe"
        ).lpBaseOfDll
        print("[+] Successfully connected to Trove.exe")

    def get_local_position(self):
        """Get player's current position"""
        try:
            pos = read_vec3(self.pm, self.base + LOCAL_PLAYER, POSITION_OFFSETS)
            return Vec3(*pos) if pos != (0, 0, 0) else None
        except Exception as e:
            debug_print(f"Position read error: {str(e)}")
            return None

    def update_ui(self, local_pos, entities):
        """Update radar display"""
        self.canvas.delete("all")
        
        # Draw player
        self.canvas.create_oval(245, 245, 255, 255, fill='green')
        
        # Draw entities
        for dist, entity in entities:
            dx = entity.position.x - local_pos.x
            dz = entity.position.z - local_pos.z
            x = 250 + dx * 4
            y = 250 + dz * 4
            self.canvas.create_oval(x-3, y-3, x+3, y+3, fill='red')

    def handle_movement(self, local_pos, entity):
        """Move player towards target entity"""
        if entity.range == -1 or not entity.position.is_not_zero():
            return

        try:
            delta = entity.position - local_pos
            if delta.length() > 0.1:
                direction = delta.normalized()
                accel = (direction.x * 2.0, 0.0, direction.z * 2.0)
                write_vec3(self.pm, self.base + LOCAL_PLAYER, ACCELERATION_OFFSETS, accel)
                debug_print(f"Moving towards {entity.name} ({accel[0]:.2f}, {accel[2]:.2f})")

        except Exception as e:
            debug_print(f"Movement error: {str(e)}")

    def update(self):
        """Main update loop"""
        try:
            local_pos = self.get_local_position()
            if not local_pos:
                return

            world = get_address(self.pm, self.base, [ENTITY_LIST, 0x0])
            if not world:
                return

            entities = get_all_entities(self.pm, world, local_pos, 100.0)
            closest = nearest_entity(entities)

            self.update_ui(local_pos, entities)
            self.handle_movement(local_pos, closest)

        except Exception as e:
            debug_print(f"Update error: {str(e)}")
            traceback.print_exc()
        finally:
            self.root.after(30, self.update)

# ================================================
# ENTRY POINT
# ================================================
if __name__ == "__main__":
    TroveBot()

import time
import pymem
import pymem.process
import pymem.ptypes

# === Configuration ===
TROVE_EXE = "Trove.exe"
LOCAL_PLAYER_OFFSET = 0x1097680  # Offset to local player pointer
Pos_off = [0x8, 0x28, 0xC4, 0x4, 0x80]  # Pointer chain to position struct

# Signature and patch bytes for enabling/disabling bypass
bypass_sig_off = bytes([0xDC, 0x67, 0x68, 0xC6, 0x45, 0xFF, 0x01, 0xD9])
bypass_sig_on = bytes([0xDC, 0x47, 0x68, 0xC6, 0x45, 0xFF, 0x01, 0xD9])

# Bypass settings
bypass_enabled = False
TICK_DELAY = 0.02       # Delay between position updates
BYPASS_PUSH = 0.4       # Amount to push position forward

# === Helper: Follow a pointer chain ===
def read_pointer_chain(pm, base, offsets):
    """Follow a pointer chain and return the final address."""
    if not offsets:
        return base
    try:
        ptr = pymem.ptypes.RemotePointer(pm.process_handle, base)
        for offset in offsets[:-1]:
            ptr = pymem.ptypes.RemotePointer(pm.process_handle, ptr.value + offset)
        return ptr.value + offsets[-1]
    except Exception:
        return None

# === Bypass Logic ===
def full_distance_bypass():
    try:
        pm = pymem.Pymem(TROVE_EXE)

        # Get base address of Trove.exe module
        base_address = pymem.process.module_from_name(pm.process_handle, TROVE_EXE).lpBaseOfDll
        print("[✓] Bypass running...")

        # Calculate local player base pointer
        local_player = base_address + LOCAL_PLAYER_OFFSET

        # Scan for bypass signature
        if bypass_enabled:
            sig = pymem.pattern.pattern_scan_module(pm.process_handle, pm.process_base, bypass_sig_off)
            pm.write_bytes(sig, bypass_sig_on, len(bypass_sig_on))
            print(f"[✓] Signature found at: {hex(sig)}")
        else:
            sig = pymem.pattern.pattern_scan_module(pm.process_handle, pm.process_base, bypass_sig_on)
            pm.write_bytes(sig, bypass_sig_off, len(bypass_sig_off))
            print(f"[✓] Signature found at: {hex(sig)}")

        # Main loop: constantly push the player forward
        while True:
            pos_addr = read_pointer_chain(pm, local_player, Pos_off)
            if pos_addr:
                x = pm.read_float(pos_addr)
                y = pm.read_float(pos_addr + 0x8)  # Not used, but read
                z = pm.read_float(pos_addr + 0x4)

                # Write updated position to memory
                pm.write_float(pos_addr, x + BYPASS_PUSH)
                pm.write_float(pos_addr + 0x4, z + BYPASS_PUSH)
            else:
                print("[!] Failed to resolve position address")

            time.sleep(TICK_DELAY)

    except KeyboardInterrupt:
        print("\n[!] Bypass manually stopped.")
    except Exception as e:
        print(f"[!] Error: {e}")

# === Start the bypass ===
full_distance_bypass()