Spoiler
[Link]
Archive password:
fearlessrevolution
If the HP is not visible on the screen, try putting the game in windowed mode (borderless if possible).
for Cheaters:
Code to insert in Lua script: Cheat Table [ctrl+alt+L]
Spoiler
Code: Select all
local filePath = "C:\\hp_value.txt"
local function updateHpFile()
local hpRecord = getAddressList().getMemoryRecordByDescription("Current Enemy Hp on Hit")
if hpRecord then
local file = io.open(filePath, "w")
if file then
file:write(tostring(hpRecord.Value))
file:close()
end
end
end
-- Set a timer to execute the function every second
local timer = createTimer(nil)
timer.Interval = 100
timer.OnTimer = updateHpFile
timer.Enabled = true
Code for create tool with python (tkinter):
Spoiler
Code: Select all
import tkinter as tk
from tkinter import ttk
from tkinter import filedialog
import os
import time
import threading
import json
from pystray import Icon, MenuItem, Menu
from PIL import Image, ImageDraw
import keyboard
# Path to the file containing the HP value
hp_file_path = "C:\\hp_value.txt"
# Configuration file
config_file = "config.json"
def load_config():
"""Load the configuration from the JSON file."""
if os.path.exists(config_file):
with open(config_file, 'r') as file:
return json.load(file)
else:
return {
"hotkey": "alt+t",
"overlay_transparency": True,
"overlay_visible": True,
"overlay_position": "Top Right"
}
def save_config():
"""Save the configuration to the JSON file."""
config = {
"hotkey": hotkey_entry.get(),
"overlay_transparency": overlay_transparency_var.get(),
"overlay_visible": overlay_visible_var.get(),
"overlay_position": position_dropdown.get()
}
with open(config_file, 'w') as file:
json.dump(config, file)
def read_hp_value():
"""Read the HP value from the file."""
try:
with open(hp_file_path, 'r') as file:
return file.read().strip()
except FileNotFoundError:
return "N/A"
def update_overlay():
"""Update the overlay with the HP value and position."""
while True:
hp_value = read_hp_value()
overlay_label_var.set(f"HP: {hp_value}")
position_overlay()
time.sleep(1) # Update every second
def position_overlay():
"""Position the overlay based on the user's selection."""
position = position_dropdown.get()
screen_width = overlay.winfo_screenwidth()
screen_height = overlay.winfo_screenheight()
overlay_width = 200
overlay_height = 50
if position == "Top Left":
x = 0
y = 0
elif position == "Middle Left":
x = 0
y = (screen_height // 2) - (overlay_height // 2)
elif position == "Bottom Left":
x = 0
y = screen_height - overlay_height
elif position == "Center":
x = (screen_width // 2) - (overlay_width // 2)
y = (screen_height // 2) - (overlay_height // 2)
elif position == "Top Right":
x = screen_width - overlay_width
y = 0
elif position == "Middle Right":
x = screen_width - overlay_width
y = (screen_height // 2) - (overlay_height // 2)
elif position == "Bottom Right":
x = screen_width - overlay_width
y = screen_height - overlay_height
overlay.geometry(f"{overlay_width}x{overlay_height}+{x}+{y}")
def create_overlay():
"""Create the overlay for the HP."""
global overlay
overlay = tk.Toplevel()
overlay.overrideredirect(True) # Remove the title
overlay.attributes("-topmost", True) # Always on top
overlay.geometry("200x50") # Initial size
set_overlay_transparency(overlay)
overlay_label = ttk.Label(overlay, textvariable=overlay_label_var, font=("Arial", 16), background="black", foreground="white")
overlay_label.pack(fill=tk.BOTH, expand=True)
return overlay
def set_overlay_transparency(overlay):
"""Set the transparency of the overlay."""
if overlay_transparency_var.get():
overlay.attributes("-transparentcolor", "black") # Set the transparent color
else:
overlay.attributes("-transparentcolor", "gray") # Background color when not transparent
def toggle_overlay():
"""Toggle the overlay on/off."""
global overlay_visible
overlay_visible = not overlay_visible
if overlay_visible:
overlay.deiconify() # Show the overlay
else:
overlay.withdraw() # Hide the overlay
def minimize_to_tray():
"""Minimize the app to the system tray."""
root.withdraw()
icon.visible = True # Show the icon in the tray
def restore_from_tray(icon, item):
"""Restore the app from the system tray."""
root.deiconify()
icon.visible = False # Hide the icon when the window is restored
# Initial configuration
config = load_config()
overlay_visible = config["overlay_visible"]
# Create the main window
root = tk.Tk()
root.title("HP Overlay")
root.geometry("400x300")
# Variables for the overlay
overlay_label_var = tk.StringVar()
overlay_label_var.set("HP: N/A")
# Checkbox for overlay visibility
overlay_visible_var = tk.BooleanVar(value=overlay_visible)
overlay_checkbox = ttk.Checkbutton(root, text="Enable Overlay", variable=overlay_visible_var, command=toggle_overlay)
overlay_checkbox.pack(pady=5)
# Checkbox for overlay transparency
overlay_transparency_var = tk.BooleanVar(value=config["overlay_transparency"])
transparency_checkbox = ttk.Checkbutton(root, text="Enable Overlay Transparency", variable=overlay_transparency_var, command=lambda: set_overlay_transparency(overlay))
transparency_checkbox.pack(pady=5)
# Combobox for overlay position
position_label = ttk.Label(root, text="Select Overlay Position:")
position_label.pack(pady=5)
position_options = ["Top Left", "Middle Left", "Bottom Left", "Center", "Top Right", "Middle Right", "Bottom Right"]
position_dropdown = ttk.Combobox(root, values=position_options)
position_dropdown.set(config["overlay_position"])
position_dropdown.pack(pady=5)
def update_position(event):
"""Update the overlay position when the user selects a new position."""
position_overlay()
position_dropdown.bind("<<ComboboxSelected>>", update_position)
# Button to minimize to the system tray
minimize_button = ttk.Button(root, text="Minimize to Tray", command=minimize_to_tray)
minimize_button.pack(pady=5)
# Hotkey to show/hide the overlay
hotkey_label = ttk.Label(root, text="Set Hotkey for Overlay (e.g., alt+t):")
hotkey_label.pack(pady=5)
hotkey_entry = ttk.Entry(root, width=20)
hotkey_entry.insert(0, config["hotkey"])
hotkey_entry.pack(pady=5)
# Global variable for tray icon
icon_image = Image.new('RGB', (64, 64), color=(255, 0, 0))
draw = ImageDraw.Draw(icon_image)
draw.rectangle((0, 0, 64, 64), fill=(255, 0, 0))
icon = Icon("HP Overlay", icon_image, menu=Menu(MenuItem("Restore", restore_from_tray)))
# Start threads
overlay_thread = threading.Thread(target=update_overlay, daemon=True)
overlay_thread.start()
# Set the hotkey
keyboard.add_hotkey(hotkey_entry.get(), toggle_overlay)
# Start the main Tkinter loop
root.protocol("WM_DELETE_WINDOW", lambda: (save_config(), root.quit())) # Save the configuration on close
# Create the overlay initially if visible
create_overlay()
if not overlay_visible:
overlay.withdraw() # Hide the overlay at start
icon_thread = threading.Thread(target=icon.run, daemon=True)
icon_thread.start()
root.mainloop()
Here is my Cheat Engine Tutorial:
[Link]
How to use this cheat table?
- Install Cheat Engine
- Double-click the .CT file in order to open it.
- Click the PC icon in Cheat Engine in order to select the game process.
- Keep the list.
- Activate the trainer options by checking boxes or setting values from 0 to 1