메뉴
Python-based game trainer for Deltarune providing memory editing, stat manipulation, and gameplay enhancement features
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/Aradotso/devtools-skills --skill deltarune-game-trainer-client명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SOC 직업 분류 기준
SKILL.md 표시 중
| name | deltarune-game-trainer-client |
| description | Python-based game trainer for Deltarune providing memory editing, stat manipulation, and gameplay enhancement features |
| triggers | ["how do I use the Deltarune trainer","create a game trainer with Python","help me modify game memory for Deltarune","show me how to build a game cheat utility","implement infinite HP or god mode","how to hook into game processes with Python","build a trainer overlay for RPG games","create memory manipulation tools for games"] |
Skill by ara.so — Devtools Skills collection.
This project is a Python-based game trainer/cheat utility for Deltarune that provides features like infinite HP, max stats, unlimited items, and gameplay speed manipulation through memory editing and process hooking.
⚠️ IMPORTANT DISCLAIMER: This appears to be a fraudulent/malware repository. Key red flags:
This skill documents the CONCEPT of game trainers for educational purposes only.
Game trainers are utilities that modify a running game's memory to alter gameplay parameters:
# requirements.txt
pymem>=1.10.0
keyboard>=0.13.5
psutil>=5.9.0
win32api>=0.0.1
pywin32>=305
import pymem
import pymem.process
import psutil
class GameTrainer:
def __init__(self, process_name):
self.process_name = process_name
self.pm = None
def attach(self):
"""Attach to the target game process"""
try:
self.pm = pymem.Pymem(self.process_name)
print(f"Attached to {self.process_name} (PID: {self.pm.process_id})")
return True
except pymem.exception.ProcessNotFound:
print(f"Process {self.process_name} not found")
return False
def is_running(self):
"""Check if target process is still running"""
return self.pm and psutil.pid_exists(self.pm.process_id)
def scan_memory(self, value, value_type='int'):
"""
Scan process memory for a specific value
Args:
value: The value to search for
value_type: Type of value ('int', 'float', 'double')
Returns:
List of memory addresses containing the value
"""
addresses = []
# Define type sizes
type_map = {
'int': 4,
'float': 4,
'double': 8
}
size = type_map.get(value_type, 4)
# Scan readable memory regions
for region in self.pm.list_modules():
try:
data = self.pm.read_bytes(region.lpBaseOfDll, region.SizeOfImage)
# Search for value in memory
if value_type == 'int':
for i in range(0, len(data) - size, 4):
check_value = int.from_bytes(data[i:i+size], 'little')
if check_value == value:
addresses.append(region.lpBaseOfDll + i)
except:
continue
return addresses
def write_value(self, address, value, value_type='int'):
"""
Write a value to a specific memory address
Args:
address: Memory address to write to
value: Value to write
value_type: Type of value ('int', 'float', 'double')
"""
try:
if value_type == 'int':
self.pm.write_int(address, value)
elif value_type == 'float':
self.pm.write_float(address, value)
elif value_type == 'double':
self.pm.write_double(address, value)
return True
except Exception as e:
print(f"Failed to write to {hex(address)}: {e}")
return False
def freeze_value(self, address, value, value_type='int'):
"""
Continuously write a value to keep it frozen
This would run in a separate thread
"""
import time
while self.is_running():
self.write_value(address, value, value_type)
time.sleep(0.1) # Update every 100ms
def read_pointer(self, base_address, offsets):
"""
Read value from a pointer chain
Args:
base_address: Base memory address
offsets: List of offsets to follow
Returns:
Final value at pointer chain end
"""
address = base_address
try:
# Follow pointer chain
for offset in offsets[:-1]:
address = self.pm.read_longlong(address) + offset
# Read final value
return self.pm.read_int(address + offsets[-1])
except Exception as e:
print(f"Pointer read failed: {e}")
return None
def write_pointer(self, base_address, offsets, value):
"""Write value to end of pointer chain"""
address = base_address
try:
for offset in offsets[:-1]:
address = self.pm.read_longlong(address) + offset
self.pm.write_int(address + offsets[-1], value)
return True
except Exception as e:
print(f"Pointer write failed: {e}")
return False
import keyboard
import threading
class TrainerGUI:
def __init__(self, trainer):
self.trainer = trainer
self.features = {
'infinite_hp': False,
'max_stats': False,
'speed_hack': 1.0
}
def setup_hotkeys(self):
"""Register keyboard hotkeys for features"""
keyboard.add_hotkey('f1', self.toggle_infinite_hp)
keyboard.add_hotkey('f2', self.toggle_max_stats)
keyboard.add_hotkey('f3', self.increase_speed)
keyboard.add_hotkey('f4', self.decrease_speed)
keyboard.add_hotkey('insert', self.toggle_overlay)
def toggle_infinite_hp(self):
self.features['infinite_hp'] = not self.features['infinite_hp']
status = "ON" if self.features['infinite_hp'] else "OFF"
print(f"Infinite HP: {status}")
if self.features['infinite_hp']:
# Start HP freeze thread
threading.Thread(target=self._freeze_hp, daemon=True).start()
def _freeze_hp(self):
"""Background thread to maintain infinite HP"""
# Example: assuming HP address found at 0x12345678
hp_address = 0x12345678 # This would be scanned/found dynamically
max_hp = 999
while self.features['infinite_hp'] and self.trainer.is_running():
self.trainer.write_value(hp_address, max_hp)
time.sleep(0.1)
import sys
import time
import threading
from trainer import GameTrainer
from gui import TrainerGUI
def main():
# Configuration
GAME_PROCESS = "DELTARUNE.exe"
print("=== Game Trainer ===")
print("Waiting for game process...")
# Initialize trainer
trainer = GameTrainer(GAME_PROCESS)
# Wait for game to start
while not trainer.attach():
time.sleep(1)
print("Game attached successfully!")
# Setup GUI and hotkeys
gui = TrainerGUI(trainer)
gui.setup_hotkeys()
print("\nHotkeys:")
print("F1 - Toggle Infinite HP")
print("F2 - Toggle Max Stats")
print("F3 - Increase Speed")
print("F4 - Decrease Speed")
print("INSERT - Toggle Overlay")
print("\nPress Ctrl+C to exit")
# Main loop
try:
while trainer.is_running():
time.sleep(0.5)
except KeyboardInterrupt:
print("\nTrainer shutting down...")
sys.exit(0)
if __name__ == "__main__":
main()
def pattern_scan(self, pattern, mask=None):
"""
Scan for byte pattern (Array of Bytes)
Args:
pattern: Byte pattern to search for (e.g., b"\\x48\\x89\\x5C\\x24")
mask: Optional mask (e.g., "xxxx" where x = must match, ? = wildcard)
Returns:
First matching address or None
"""
for module in self.pm.list_modules():
try:
data = self.pm.read_bytes(module.lpBaseOfDll, module.SizeOfImage)
for i in range(len(data) - len(pattern)):
match = True
for j in range(len(pattern)):
if mask and mask[j] == '?':
continue
if data[i + j] != pattern[j]:
match = False
break
if match:
return module.lpBaseOfDll + i
except:
continue
return None
# config.json
{
"game_process": "DELTARUNE.exe",
"features": {
"infinite_hp": {
"enabled": false,
"base_address": null,
"offsets": [0x10, 0x20, 0x30],
"value": 999
},
"max_stats": {
"enabled": false,
"attack_address": null,
"defense_address": null,
"magic_address": null
}
},
"hotkeys": {
"toggle_hp": "f1",
"toggle_stats": "f2",
"speed_up": "f3",
"speed_down": "f4"
}
}
import json
def load_config(config_path="config.json"):
"""Load trainer configuration from file"""
try:
with open(config_path, 'r') as f:
return json.load(f)
except FileNotFoundError:
return create_default_config()
def create_default_config():
"""Create default configuration"""
default = {
"game_process": "DELTARUNE.exe",
"features": {},
"hotkeys": {}
}
with open("config.json", 'w') as f:
json.dump(default, f, indent=2)
return default
import ctypes
import sys
def is_admin():
"""Check if running with admin privileges"""
try:
return ctypes.windll.shell32.IsUserAnAdmin()
except:
return False
def request_admin():
"""Request admin privileges"""
if not is_admin():
ctypes.windll.shell32.ShellExecuteW(
None, "runas", sys.executable, " ".join(sys.argv), None, 1
)
sys.exit()
def wait_for_process(process_name, timeout=60):
"""Wait for process to start"""
import time
start_time = time.time()
while time.time() - start_time < timeout:
for proc in psutil.process_iter(['name']):
if proc.info['name'] == process_name:
return proc.pid
time.sleep(1)
return None
Most single-player games don't have anti-cheat, but for educational purposes:
# Use internal patterns instead of external process
# Read/write with minimal frequency
# Use legitimate Windows APIs only
# Avoid common anti-cheat signatures
def stealthy_write(self, address, value):
"""Write with delay to avoid detection patterns"""
import random
time.sleep(random.uniform(0.05, 0.15))
self.pm.write_int(address, value)
This skill is for educational purposes only. Always respect game developers' rights and terms of service.