alex/my-botty-tools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
my-botty-tools/tools/asset_manager.py

1107 lines
35 KiB
Python
Raw Permalink Blame History

"""
Botty Asset Manager - Unified asset management tool.
All-in-one tool for managing D2R template assets: capture, crop, audit,
analyze, and maintain your template library.
Commands:
inventory List all assets with size, dimensions, category
audit Find issues: duplicates, orphans, naming problems
quality Analyze image quality: resolution, transparency, size
capture Capture D2R window to screenshots/captures/
crop X Y W H NAME Crop region from latest capture, save as template
auto_crop Interactive: click D2R to select a crop region
search TERM Find assets matching a name/pattern
key NAME Look up the template key to use in code
validate Check all templates load correctly
similarity Find near-duplicate images
cleanup [--yes] Find/remove duplicate assets
batch OP VALUE Batch operation: "resize WxH" or "convert png"
help Show this help
Examples:
python asset_manager.py inventory
python asset_manager.py audit
python asset_manager.py search akara
python asset_manager.py key akara_front
python asset_manager.py crop 100 200 50 80 my_npc
python asset_manager.py auto_crop
python asset_manager.py similarity
python asset_manager.py cleanup
python asset_manager.py validate
Template naming convention:
- Use lowercase_with_underscores (e.g. akara_front.png)
- Template key is the filename uppercased (e.g. AKARA_FRONT)
- NPC assets go in assets/npc/<name>/
- UI templates go in assets/templates/ui/
- Item templates go in assets/item_properties/
"""
import os, sys, argparse, json, hashlib, time, math, re
from pathlib import Path
from datetime import datetime
from collections import defaultdict
# DPI awareness
try:
import ctypes
ctypes.windll.shcore.SetProcessDpiAwareness(2)
except:
pass
# Fix DLL loading
if sys.platform == "win32":
_dll = os.path.join(os.path.dirname(os.path.dirname(sys.executable)), "Library", "bin")
if os.path.isdir(_dll):
os.add_dll_directory(_dll)
import cv2
import numpy as np
BASE = Path(os.path.dirname(os.path.abspath(__file__)))
ASSETS = BASE / "assets"
# Template directories that template_finder.py loads
TEMPLATE_DIRS = [
"templates",
"npc",
"shop",
"item_properties",
"chests",
"gamble",
"items",
]
# Known NPC names for routing
NPC_NAMES = {
'akara', 'charsi', 'kashya', 'cain', 'drognan', 'lysander',
'fara', 'ormus', 'tyrael', 'jamella', 'halbu', 'qual_kehk',
'malah', 'larzuk', 'anya', 'carrow', 'ashera', 'alkaar',
'elzix', 'meshiff', 'hrrky', 'izhu', 'essjay', 'seraphina',
'aluria', 'jermak', 'griswold', 'hugel', 'rodek', 'meathead',
'gheed', 'act1', 'act2', 'act3', 'act4', 'act5',
}
# ===================== IMAGE UTILITIES =====================
def img_hash(path):
"""MD5 hash of image file content."""
try:
with open(path, 'rb') as f:
return hashlib.md5(f.read()).hexdigest()
except:
return None
def img_hash_fast(path):
"""Faster hash: read first/last 4KB of file."""
try:
sz = os.path.getsize(path)
with open(path, 'rb') as f:
h = hashlib.md5(f.read(4096)).hexdigest()
if sz > 4096:
f.seek(-4096, 2)
h += hashlib.md5(f.read(4096)).hexdigest()
return h
except:
return None
def img_dims(path):
"""Return (w, h) or None."""
try:
img = cv2.imread(str(path), cv2.IMREAD_UNCHANGED)
if img is None:
return None
return img.shape[1], img.shape[0]
except:
return None
def img_quick_info(path):
"""Return (w, h, has_alpha) in a single image load."""
try:
img = cv2.imread(str(path), cv2.IMREAD_UNCHANGED)
if img is None:
return None, None, False
w, h = img.shape[1], img.shape[0]
has_alpha = (img.shape[2] == 4 and np.min(img[:, :, 3]) < 255) if len(img.shape) > 1 and img.shape[2] >= 4 else False
return w, h, has_alpha
except:
return None, None, False
def img_similarity(path1, path2):
"""Compute visual similarity between two images (0-1, higher = more similar).
Uses resized comparison + MSE for speed."""
try:
img1 = cv2.imread(str(path1))
img2 = cv2.imread(str(path2))
if img1 is None or img2 is None:
return 0.0
# Resize to same size for comparison
img1 = cv2.resize(img1, (64, 64))
img2 = cv2.resize(img2, (64, 64))
mse = np.mean((img1.astype('float') - img2.astype('float')) ** 2)
return float(math.exp(-mse / 10000))
except:
return 0.0
# ===================== ASSET GATHERING =====================
def gather_assets(asset_dirs=None):
"""Gather all asset file paths with metadata. Uses lazy evaluation for image info."""
if asset_dirs is None:
asset_dirs = TEMPLATE_DIRS
assets = {}
for d in asset_dirs:
dir_path = ASSETS / d
if not dir_path.exists():
continue
for f in dir_path.rglob('*.png'):
rel = str(f.relative_to(ASSETS))
assets[rel] = {
'path': f,
'category': d,
'size': f.stat().st_size,
'dims': None, # Lazy-loaded
'hash': img_hash(f),
'fast_hash': img_hash_fast(f),
'has_alpha': False, # Lazy-loaded
}
return assets
def _ensure_image_info(info):
"""Lazy-load image dimensions and alpha info if not already loaded."""
if info['dims'] is not None:
return
w, h, alpha = img_quick_info(info['path'])
info['dims'] = (w, h) if w is not None else None
info['has_alpha'] = alpha
# ===================== COMMANDS =====================
def cmd_inventory(args):
"""List all assets with details."""
assets = gather_assets()
if not assets:
print("No assets found.")
return
# Group by category
cats = defaultdict(list)
for name, info in sorted(assets.items()):
cats[info['category']].append((name, info))
print(f"\n{'='*70}")
print(f" Botty Asset Inventory ({len(assets)} assets)")
print(f"{'='*70}\n")
total_size = 0
for cat in sorted(cats.keys()):
items = cats[cat]
cat_size = sum(i['size'] for _, i in items)
total_size += cat_size
print(f" [{cat.upper()}] ({len(items)} files, {cat_size/1024:.1f} KB)")
for name, info in items:
_ensure_image_info(info)
dims_str = f"{info['dims'][0]}x{info['dims'][1]}" if info['dims'] else "???"
alpha = " [A]" if info['has_alpha'] else ""
size_str = f"{info['size']/1024:.1f} KB" if info['size'] >= 1024 else f"{info['size']} B"
print(f" {name} {dims_str} {size_str}{alpha}")
print()
print(f" Total: {len(assets)} files, {total_size/1024:.1f} KB")
print()
def cmd_search(args):
"""Search assets by name/pattern."""
assets = gather_assets()
if not assets:
print("No assets found.")
return
term = ' '.join(args.args).lower()
# Exact and fuzzy matches
results = []
for name, info in assets.items():
name_lower = name.lower()
stem = Path(name).stem.lower()
score = 0
if term in stem:
score = 100
elif stem in term:
score = 80
elif term in name_lower:
score = 60
elif any(w in stem for w in term.split()):
score = 40
else:
# Check with separators removed
clean = stem.replace('_', '').replace('-', '')
clean_term = term.replace('_', '').replace('-', '')
if clean_term in clean:
score = 30
elif clean in clean_term:
score = 20
if score > 0:
results.append((score, name, info))
# Sort by score descending
results.sort(key=lambda x: -x[0])
print(f"\n{'='*70}")
print(f" Search: '{term}' ({len(results)} results)")
print(f"{'='*70}\n")
if not results:
print(" No matches found.")
# Suggest closest
best = None
best_dist = 999
for name, info in assets.items():
stem = Path(name).stem.lower()
dist = len(set(term) - set(stem))
if dist < best_dist and dist < len(term):
best_dist = dist
best = stem
if best:
print(f" Closest: {best}")
else:
for score, name, info in results[:50]:
_ensure_image_info(info)
dims_str = f"{info['dims'][0]}x{info['dims'][1]}" if info['dims'] else "???"
template_key = Path(name).stem.upper()
alpha = " [A]" if info['has_alpha'] else ""
print(f" {name} {dims_str} key={template_key}{alpha}")
if len(results) > 50:
print(f" ... and {len(results) - 50} more")
print()
def cmd_key(args):
"""Look up the template key to use in code."""
assets = gather_assets()
if not assets:
print("No assets found.")
return
term = ' '.join(args.args)
if not term:
print(" Usage: python asset_manager.py key <name>")
print(" Example: python asset_manager.py key akara_front")
return
term_lower = term.lower().replace('-', '_')
# Find matching assets
matches = []
for name, info in assets.items():
stem = Path(name).stem.lower()
if term_lower in stem or stem in term_lower:
template_key = Path(name).stem.upper()
matches.append((name, template_key, info))
print(f"\n{'='*70}")
print(f" Template Key Lookup: '{term}'")
print(f"{'='*70}\n")
if not matches:
print(f" No assets matching '{term}'.")
print(f" Try: python asset_manager.py search {term}")
else:
for name, key, info in matches[:10]:
_ensure_image_info(info)
dims_str = f"{info['dims'][0]}x{info['dims'][1]}" if info['dims'] else "???"
print(f" {name}")
print(f" Key: '{key}'")
print(f" Use: template_finder.search('{key}', img, threshold=0.XX)")
print(f" Size: {dims_str}")
print()
print()
def cmd_audit(args):
"""Find asset issues: duplicates, orphans, naming problems."""
assets = gather_assets()
issues = []
# 1. Find exact duplicates (same hash)
hash_map = defaultdict(list)
for name, info in assets.items():
if info['hash']:
hash_map[info['hash']].append(name)
print(f"\n{'='*70}")
print(f" Botty Asset Audit")
print(f"{'='*70}\n")
print(" DUPLICATES (identical content):")
dup_count = 0
for h, names in hash_map.items():
if len(names) > 1:
dup_count += len(names) - 1
print(f" {len(names)}x: {', '.join(names)}")
if not dup_count:
print(" None found.")
# 2. Naming convention issues
print(f"\n NAMING ISSUES:")
naming_issues = 0
for name, info in assets.items():
base = Path(name).stem
if ' ' in base:
print(f" {name} - contains spaces")
naming_issues += 1
if base != base.lower() and base != base.upper():
print(f" {name} - mixed case")
naming_issues += 1
if '_' in base and '-' in base:
print(f" {name} - mixed separators")
naming_issues += 1
# Dots in filename (not extension)
if '.' in base and not base.endswith('.png'):
print(f" {name} - contains dots in name (use underscores)")
naming_issues += 1
if not naming_issues:
print(" None found.")
# 3. Oversized assets
print(f"\n OVERSIZED (>500x500, likely full screenshots misused as templates):")
oversized = 0
for name, info in assets.items():
_ensure_image_info(info)
if info['dims'] and (info['dims'][0] > 500 or info['dims'][1] > 500):
print(f" {name} {info['dims'][0]}x{info['dims'][1]}")
oversized += 1
if not oversized:
print(" None found.")
# 4. Tiny assets
print(f"\n TINY (<10x10, likely corrupted or miscropped):")
tiny = 0
for name, info in assets.items():
_ensure_image_info(info)
if info['dims'] and (info['dims'][0] < 10 or info['dims'][1] < 10):
print(f" {name} {info['dims'][0]}x{info['dims'][1]}")
tiny += 1
if not tiny:
print(" None found.")
# 5. Asymmetric assets (potential miscrop)
print(f"\n VERY ASYMMETRIC (ratio >10:1, potential miscrop):")
asym = 0
for name, info in assets.items():
_ensure_image_info(info)
if info['dims']:
w, h = info['dims']
ratio = max(w, h) / max(min(w, h), 1)
if ratio > 10 and max(w, h) > 30:
print(f" {name} {w}x{h} ratio {ratio:.0f}:1")
asym += 1
if not asym:
print(" None found.")
print(f"\n Summary: {dup_count} duplicates, {naming_issues} naming issues, "
f"{oversized} oversized, {tiny} tiny, {asym} asymmetric")
print()
def cmd_quality(args):
"""Analyze image quality metrics."""
assets = gather_assets()
if not assets:
print("No assets found.")
return
print(f"\n{'='*70}")
print(f" Botty Asset Quality Report")
print(f"{'='*70}\n")
# Resolution distribution
dims = defaultdict(int)
for name, info in assets.items():
_ensure_image_info(info)
if info['dims']:
dims[str(info['dims'][0]) + 'x' + str(info['dims'][1])] += 1
print(" Resolution distribution (top 20):")
for d, c in sorted(dims.items(), key=lambda x: -x[1])[:20]:
print(f" {d}: {c} files")
print()
# File size distribution
sizes = defaultdict(int)
for name, info in assets.items():
bucket = info['size'] // 1024
if bucket < 1:
sizes['<1 KB'] += 1
elif bucket < 10:
sizes['1-10 KB'] += 1
elif bucket < 50:
sizes['10-50 KB'] += 1
elif bucket < 100:
sizes['50-100 KB'] += 1
else:
sizes['>100 KB'] += 1
print(" File size distribution:")
for s, c in sorted(sizes.items()):
print(f" {s}: {c} files")
print()
# Transparency usage
alpha_count = sum(1 for info in assets.values() if info['has_alpha'])
print(f" With transparency (alpha): {alpha_count}/{len(assets)}")
print()
# Per-category stats
print(" Per-category stats:")
cats = defaultdict(lambda: {'count': 0, 'total_size': 0, 'avg_dims': [0, 0]})
for name, info in assets.items():
_ensure_image_info(info)
c = cats[info['category']]
c['count'] += 1
c['total_size'] += info['size']
if info['dims']:
c['avg_dims'][0] += info['dims'][0]
c['avg_dims'][1] += info['dims'][1]
for cat in sorted(cats.keys()):
c = cats[cat]
avg_w = c['avg_dims'][0] // c['count'] if c['count'] else 0
avg_h = c['avg_dims'][1] // c['count'] if c['count'] else 0
print(f" {cat}: {c['count']} files, {c['total_size']/1024:.1f} KB, avg {avg_w}x{avg_h}")
print()
def find_d2r():
"""Find D2R window handle."""
import win32gui
import psutil
# Find D2R process first
d2r_pids = set()
for proc in psutil.process_iter(['name']):
try:
if proc.info['name'] and 'D2R' in proc.info['name']:
d2r_pids.add(proc.pid)
except:
pass
if not d2r_pids:
return None
hwnds = []
def cb(h, r):
title = win32gui.GetWindowText(h)
if 'diablo' in title.lower() and win32gui.IsWindowVisible(h):
# Check if this window belongs to D2R process
import win32process
_, pid = win32process.GetWindowThreadProcessId(h)
if pid in d2r_pids:
r.append((h, title))
win32gui.EnumWindows(cb, hwnds)
if not hwnds:
return None
# Return the window with most title characters (most likely the game window)
hwnds.sort(key=lambda x: -len(x[1]))
return hwnds[0][0]
def grab_d2r():
"""Grab D2R client area at 1280x720."""
from mss import mss
import win32gui
hwnd = find_d2r()
if not hwnd:
print(" [ERROR] D2R not found. Is it running and visible?")
return None
client = win32gui.GetClientRect(hwnd)
w, h = client[2] - client[0], client[3] - client[1]
screen_pos = win32gui.ClientToScreen(hwnd, (0, 0))
with mss() as sct:
region = {
'top': screen_pos[1],
'left': screen_pos[0],
'width': w,
'height': h
}
sct_img = sct.grab(region)
img = np.array(sct_img)[:, :, :3]
if w != 1280 or h != 720:
img = cv2.resize(img, (1280, 720), interpolation=cv2.INTER_LINEAR)
print(f" [RESIZED] {w}x{h} -> 1280x720")
else:
print(f" [CAPTURED] {w}x{h}")
return img
def cmd_capture(args):
"""Capture D2R window and save."""
save_dir = BASE / "screenshots" / "captures"
save_dir.mkdir(parents=True, exist_ok=True)
img = grab_d2r()
if img is None:
return
ts = datetime.now().strftime("%Y%m%d_%H%M%S")
name = f"capture_{ts}.png"
path = save_dir / name
cv2.imwrite(str(path), img)
print(f"\n [SAVED] {path}")
print(f" Crop with: python asset_manager.py crop X Y W H template_name")
print(f" Or use: python asset_manager.py auto_crop")
print()
def cmd_crop(args):
"""Crop a region from the latest capture and save as template."""
x, y, w, h = args.x, args.y, args.w, args.h
name = args.name
# Find latest capture or grab fresh
save_dir = BASE / "screenshots" / "captures"
captures = sorted(save_dir.glob("capture_*.png"), key=os.path.getmtime)
if captures:
img = cv2.imread(str(captures[-1]), cv2.IMREAD_UNCHANGED)
if img is not None:
print(f" [LOADED] {captures[-1].name}")
else:
img = None
if img is None:
print(" No recent capture. Grabbing fresh...")
img = grab_d2r()
if img is None:
return
# Crop
h_img, w_img = img.shape[:2]
x1, y1 = max(0, x), max(0, y)
x2, y2 = min(w_img, x + w), min(h_img, y + h)
crop = img[y1:y2, x1:x2]
if crop.size == 0:
print(f" [ERROR] Crop region ({x},{y},{w},{h}) is out of bounds (image is {w_img}x{h_img})")
return
# Auto-trim black/transparent borders
crop = _trim_borders(crop)
# Determine save location
save_dir, name_lower = _resolve_save_path(name)
# Auto-number if exists
fname = f"{name_lower}.png"
save_path = save_dir / fname
variant = 1
while save_path.exists():
variant += 1
fname = f"{name_lower}_{variant}.png"
save_path = save_dir / fname
cv2.imwrite(str(save_path), crop)
rel = str(save_path.relative_to(ASSETS))
print(f"\n [SAVED] {rel} ({crop.shape[1]}x{crop.shape[0]})")
# Show template key for use in code
template_key = fname[:-4].upper()
print(f" Template key: '{template_key}'")
print(f" Use in code: template_finder.search('{template_key}', img, threshold=0.XX)")
print()
def _trim_borders(img):
"""Trim black and transparent borders from an image."""
# Handle grayscale images (1 channel)
if len(img.shape) == 2:
mask = (img > 1).astype(np.uint8) * 255
elif img.shape[2] == 4:
# RGBA: non-transparent AND non-black pixels
alpha = img[:, :, 3]
gray = cv2.cvtColor(img[:, :, :3], cv2.COLOR_BGR2GRAY)
mask = ((gray > 1) & (alpha > 0)).astype(np.uint8) * 255
else:
# BGR or other: non-black pixels
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
mask = (gray > 1).astype(np.uint8) * 255
coords = cv2.findNonZero(mask)
if coords is None:
return img
x, y, w, h = cv2.boundingRect(coords)
# Add 2px padding
pad = 2
h_img, w_img = img.shape[:2]
x = max(0, x - pad)
y = max(0, y - pad)
w = min(w_img - x, w + 2 * pad)
h = min(h_img - y, h + 2 * pad)
return img[y:y+h, x:x+w]
def _resolve_save_path(name):
"""Determine where to save a new asset based on its name."""
name_lower = name.lower().replace('-', '_').replace(' ', '_')
if name_lower in NPC_NAMES:
save_dir = ASSETS / "npc" / name_lower
elif 'template' in name_lower or 'ui' in name_lower:
save_dir = ASSETS / "templates" / "ui"
elif 'chest' in name_lower:
save_dir = ASSETS / "chests"
elif 'item' in name_lower:
save_dir = ASSETS / "item_properties"
elif 'npc' in name_lower or 'action' in name_lower:
save_dir = ASSETS / "npc" / "action_btn"
elif 'gamble' in name_lower:
save_dir = ASSETS / "gamble"
elif 'shop' in name_lower:
save_dir = ASSETS / "shop"
else:
save_dir = ASSETS / "templates"
save_dir.mkdir(parents=True, exist_ok=True)
return save_dir, name_lower
def cmd_auto_crop(args):
"""Interactive crop mode: click D2R to select region."""
try:
from input_layer import keyboard
except ImportError:
sys.path.insert(0, str(BASE / "src"))
from input_layer import keyboard
print(f"\n{'='*70}")
print(f" Botty Auto-Crop (Interactive)")
print(f"{'='*70}")
print(f" 1. Press F1 to capture D2R")
print(f" 2. Position mouse over TOP-LEFT corner, press F2")
print(f" 3. Position mouse over BOTTOM-RIGHT corner, press F2")
print(f" 4. Preview shows in window - press:")
print(f" F3 Accept and save (you'll be prompted for name)")
print(f" F4 Retry selection (goes back to step 2)")
print(f" F12 Exit")
print(f" {'='*70}")
print(" Ready. Press F1 to capture D2R.\n")
img = None
pt1 = None
pt2 = None
def on_f1():
nonlocal img
img = grab_d2r()
if img is not None:
print(" [CAPTURED] Press F2 for top-left corner.")
def on_f2():
nonlocal pt1, pt2
from input_layer import mouse
mx, my = mouse.get_position()
# Convert to D2R client coordinates
hwnd = find_d2r()
if hwnd:
import win32gui
screen_pos = win32gui.ClientToScreen(hwnd, (0, 0))
cx = mx - screen_pos[0]
cy = my - screen_pos[1]
# Scale if needed
if img is not None:
h_img, w_img = img.shape[:2]
cx = int(cx * w_img / 1280)
cy = int(cy * h_img / 720)
if pt1 is None:
pt1 = (cx, cy)
print(f" Top-left: {pt1}. Now move mouse to bottom-right and press F2 again.")
else:
pt2 = (cx, cy)
print(f" Bottom-right: {pt2}. Preview: F3=save, F4=retry")
_show_preview()
def _show_preview():
if img is None or pt1 is None or pt2 is None:
return
h_img, w_img = img.shape[:2]
x1 = max(0, min(pt1[0], pt2[0]))
y1 = max(0, min(pt1[1], pt2[1]))
x2 = min(w_img, max(pt1[0], pt2[0]))
y2 = min(h_img, max(pt1[1], pt2[1]))
preview = img[y1:y2, x1:x2]
preview = _trim_borders(preview)
# Resize for display if too large
disp = preview.copy()
if max(disp.shape[:2]) > 500:
scale = 500.0 / max(disp.shape[:2])
disp = cv2.resize(disp, (int(disp.shape[1] * scale), int(disp.shape[0] * scale)))
cv2.imshow("Auto-Crop Preview", disp)
cv2.waitKey(1)
print(f" Preview: {preview.shape[1]}x{preview.shape[0]} (after trim)")
def on_f3():
nonlocal img, pt1, pt2
if img is None or pt1 is None or pt2 is None:
print(" [ERROR] No selection. Press F1 first, then F2 twice.")
return
h_img, w_img = img.shape[:2]
x1 = max(0, min(pt1[0], pt2[0]))
y1 = max(0, min(pt1[1], pt2[1]))
x2 = min(w_img, max(pt1[0], pt2[0]))
y2 = min(h_img, max(pt1[1], pt2[1]))
crop = img[y1:y2, x1:x2]
crop = _trim_borders(crop)
# Ask for name
name = input("\n Enter template name: ").strip()
if not name:
name = "new_asset"
name = re.sub(r'[^a-zA-Z0-9_\-]', '_', name)
save_dir, name_lower = _resolve_save_path(name)
fname = f"{name_lower}.png"
save_path = save_dir / fname
variant = 1
while save_path.exists():
variant += 1
fname = f"{name_lower}_{variant}.png"
save_path = save_dir / fname
cv2.imwrite(str(save_path), crop)
cv2.destroyWindow("Auto-Crop Preview")
rel = str(save_path.relative_to(ASSETS))
template_key = fname[:-4].upper()
print(f"\n [SAVED] {rel} ({crop.shape[1]}x{crop.shape[0]})")
print(f" Template key: '{template_key}'")
print(f" Use in code: template_finder.search('{template_key}', img, threshold=0.XX)")
# Reset for next crop
pt1 = pt2 = None
def on_f4():
nonlocal pt1, pt2
pt1 = pt2 = None
cv2.destroyWindow("Auto-Crop Preview")
print(" Retry. Press F2 for top-left corner.")
keyboard.add_hotkey('f1', on_f1)
keyboard.add_hotkey('f2', on_f2)
keyboard.add_hotkey('f3', on_f3)
keyboard.add_hotkey('f4', on_f4)
keyboard.add_hotkey('f12', lambda: (print("\n Bye."), sys.exit(0)))
try:
keyboard.wait()
except KeyboardInterrupt:
print("\n Bye.")
def cmd_validate(args):
"""Validate all templates load correctly."""
assets = gather_assets()
print(f"\n{'='*70}")
print(f" Botty Template Validation")
print(f"{'='*70}\n")
errors = 0
warnings = 0
for name, info in sorted(assets.items()):
_ensure_image_info(info)
if info['dims'] is None:
print(f" [ERROR] {name} - cannot read image")
errors += 1
elif info['dims'][0] == 0 or info['dims'][1] == 0:
print(f" [ERROR] {name} - zero dimensions")
errors += 1
elif info['size'] == 0:
print(f" [ERROR] {name} - empty file")
errors += 1
else:
# Check template key is usable
template_key = Path(name).stem.upper()
cleaned = ''.join(c for c in template_key if c not in '0123456789_')
if not cleaned.isalpha():
print(f" [WARN] {name} - key '{template_key}' contains unusual chars")
warnings += 1
if not errors and not warnings:
print(" All templates are valid.")
else:
print(f"\n {errors} error(s), {warnings} warning(s)")
print()
def cmd_similarity(args):
"""Find near-duplicate images using visual similarity."""
assets = gather_assets()
if len(assets) < 2:
print("Need at least 2 assets to compare.")
return
print(f"\n{'='*70}")
print(f" Botty Similarity Analysis (fast mode)")
print(f"{'='*70}\n")
print(" Comparing assets within each category...")
print()
# Group by category for faster comparison
cats = defaultdict(list)
for name, info in assets.items():
cats[info['category']].append((name, info))
pairs_found = 0
for cat, items in cats.items():
if len(items) < 2:
continue
# Quick pre-filter: only compare same-size images
size_groups = defaultdict(list)
for name, info in items:
_ensure_image_info(info)
if info['dims']:
size_groups[(info['dims'][0], info['dims'][1])].append((name, info))
for size, group in size_groups.items():
if len(group) < 2:
continue
for i in range(len(group)):
for j in range(i + 1, len(group)):
n1, i1 = group[i]
n2, i2 = group[j]
# Skip exact duplicates (those are caught by audit)
if i1['hash'] == i2['hash']:
continue
sim = img_similarity(i1['path'], i2['path'])
if sim > 0.85:
pairs_found += 1
print(f" [{sim:.2f}] {n1} ~= {n2} ({size[0]}x{size[1]})")
elif sim > 0.70 and cat == 'npc':
pairs_found += 1
print(f" [{sim:.2f}] {n1} ~= {n2} ({size[0]}x{size[1]})")
if not pairs_found:
print(" No near-duplicates found.")
else:
print(f"\n {pairs_found} near-duplicate pair(s) found.")
print()
def cmd_cleanup(args):
"""Remove duplicate assets (keep first occurrence)."""
assets = gather_assets()
hash_map = defaultdict(list)
for name, info in assets.items():
if info['hash']:
hash_map[info['hash']].append((name, info))
print(f"\n{'='*70}")
print(f" Botty Asset Cleanup")
print(f"{'='*70}\n")
removed = 0
for h, items in hash_map.items():
if len(items) > 1:
print(f" Duplicate group ({len(items)} files):")
for i, (name, info) in enumerate(items):
if i == 0:
print(f" [KEEP] {name}")
else:
if args.yes:
os.remove(str(info['path']))
print(f" [REMOVED] {name}")
removed += 1
else:
print(f" [WILL REMOVE] {name}")
print()
if args.yes:
print(f" Removed {removed} duplicates.")
else:
print(f" Would remove {removed} duplicates. Use --yes to actually remove.")
print()
def cmd_batch(args):
"""Batch operations on assets."""
operation = args.operation.lower()
if operation == "resize":
try:
target_w, target_h = map(int, args.value.split('x'))
except:
print(" Usage: python asset_manager.py batch resize WxH")
return
assets = gather_assets()
count = 0
for name, info in assets.items():
_ensure_image_info(info)
if info['dims'] and (info['dims'][0] != target_w or info['dims'][1] != target_h):
img = cv2.imread(str(info['path']), cv2.IMREAD_UNCHANGED)
if img is not None:
# Use INTER_AREA for downscaling (better quality), INTER_CUBIC for upscaling
if target_w < info['dims'][0]:
interp = cv2.INTER_AREA
else:
interp = cv2.INTER_CUBIC
resized = cv2.resize(img, (target_w, target_h), interpolation=interp)
cv2.imwrite(str(info['path']), resized)
count += 1
print(f" Resized {count} assets to {target_w}x{target_h}.")
elif operation == "convert":
fmt = args.value.lower()
if fmt not in ('png', 'jpg', 'jpeg'):
print(" Supported formats: png, jpg")
return
assets = gather_assets()
count = 0
for name, info in assets.items():
if info['path'].suffix.lower() != f'.{fmt}':
new_path = info['path'].with_suffix(f'.{fmt}')
img = cv2.imread(str(info['path']), cv2.IMREAD_UNCHANGED)
if img is not None:
cv2.imwrite(str(new_path), img)
count += 1
print(f" Converted {count} assets to .{fmt}")
else:
print(f" Unknown batch operation: {operation}")
print(f" Supported: resize, convert")
def print_help():
print(f"""
{'='*70}
Botty Asset Manager
{'='*70}
Usage: python asset_manager.py [command] [options]
Commands:
inventory List all assets with size, dimensions, category
search TERM Find assets matching a name/pattern
key NAME Look up the template key to use in code
audit Find issues: duplicates, naming, oversized, tiny
quality Analyze image quality: resolution, transparency, size
similarity Find near-duplicate images
capture Capture D2R window to screenshots/captures/
crop X Y W H NAME Crop region from latest capture, save as template
auto_crop Interactive: click D2R to select a crop region
validate Check all templates load correctly
cleanup [--yes] Find/remove duplicate assets
batch OP VALUE Batch operation: "resize WxH" or "convert png"
help Show this help
Examples:
python asset_manager.py inventory
python asset_manager.py audit
python asset_manager.py quality
python asset_manager.py search akara
python asset_manager.py key akara_front
python asset_manager.py capture
python asset_manager.py crop 100 200 50 80 akara_front
python asset_manager.py crop 300 400 100 120 npc_dialogue
python asset_manager.py auto_crop
python asset_manager.py similarity
python asset_manager.py validate
python asset_manager.py cleanup
python asset_manager.py cleanup --yes
python asset_manager.py batch resize 64x64
Template naming convention:
- Use lowercase_with_underscores (e.g. akara_front.png)
- Template key is the filename uppercased (e.g. AKARA_FRONT)
- NPC assets go in assets/npc/<name>/
- UI templates go in assets/templates/ui/
- Item templates go in assets/item_properties/
Template Finder search paths:
""")
for d in TEMPLATE_DIRS:
print(f" assets/{d}/")
print()
def main():
parser = argparse.ArgumentParser(description='Botty Asset Manager', add_help=False)
parser.add_argument('command', nargs='?', default='help',
help='Command to run')
parser.add_argument('args', nargs='*', help='Command arguments')
parser.add_argument('--yes', action='store_true', help='Confirm destructive actions')
parsed = parser.parse_args()
cmd = parsed.command.lower()
if cmd == 'inventory':
cmd_inventory(parsed)
elif cmd == 'search':
cmd_search(parsed)
elif cmd == 'key':
cmd_key(parsed)
elif cmd == 'audit':
cmd_audit(parsed)
elif cmd == 'quality':
cmd_quality(parsed)
elif cmd == 'capture':
cmd_capture(parsed)
elif cmd == 'crop':
if len(parsed.args) < 5:
print(" Usage: python asset_manager.py crop X Y W H NAME")
print(" Example: python asset_manager.py crop 100 200 50 80 akara_front")
return
parsed.x = int(parsed.args[0])
parsed.y = int(parsed.args[1])
parsed.w = int(parsed.args[2])
parsed.h = int(parsed.args[3])
parsed.name = parsed.args[4]
cmd_crop(parsed)
elif cmd == 'auto_crop':
cmd_auto_crop(parsed)
elif cmd == 'validate':
cmd_validate(parsed)
elif cmd == 'similarity':
cmd_similarity(parsed)
elif cmd == 'cleanup':
cmd_cleanup(parsed)
elif cmd == 'batch':
if len(parsed.args) < 2:
print(" Usage: python asset_manager.py batch OP VALUE")
print(" Example: python asset_manager.py batch resize 64x64")
return
parsed.operation = parsed.args[0]
parsed.value = parsed.args[1]
cmd_batch(parsed)
else:
print_help()
if __name__ == "__main__":
main()
Reference in New Issue View Git Blame Copy Permalink