hammer-rpc.js

const RPC = require('discord-rpc');
const { exec, spawn } = require('child_process');
const path = require('path');
const fs = require('fs');

// ====== HARDCODED CLIENT ID (DO NOT CHANGE) ======
const CLIENT_ID = '1464543220317814878';

// ====== COLOR SYSTEM ======
const colors = {
    reset: '\x1b[0m',
    bright: '\x1b[1m',
    dim: '\x1b[2m',
    
    // Text colors
    black: '\x1b[30m',
    red: '\x1b[31m',
    green: '\x1b[32m',
    yellow: '\x1b[33m',
    blue: '\x1b[34m',
    magenta: '\x1b[35m',
    cyan: '\x1b[36m',
    white: '\x1b[37m',
    
    // Bright colors
    brightRed: '\x1b[91m',
    brightGreen: '\x1b[92m',
    brightYellow: '\x1b[93m',
    brightBlue: '\x1b[94m',
    brightMagenta: '\x1b[95m',
    brightCyan: '\x1b[96m',
    brightWhite: '\x1b[97m',
    
    // Background colors
    bgBlack: '\x1b[40m',
    bgRed: '\x1b[41m',
    bgGreen: '\x1b[42m',
};

let themeColor = colors.green; // Default

function setTheme(theme) {
    const themes = {
        'green': colors.brightGreen,
        'red': colors.brightRed,
        'blue': colors.brightBlue,
        'cyan': colors.brightCyan,
        'magenta': colors.brightMagenta,
        'yellow': colors.brightYellow,
        'hacker': colors.green,
        'matrix': colors.brightGreen,
        'fire': colors.brightRed,
        'ice': colors.brightCyan,
        'purple': colors.brightMagenta
    };
    themeColor = themes[theme.toLowerCase()] || colors.brightGreen;
}

function log(text, color = themeColor) {
    console.log(`${color}${text}${colors.reset}`);
}

function logError(text) {
    console.log(`${colors.brightRed}${text}${colors.reset}`);
}

function logWarning(text) {
    console.log(`${colors.brightYellow}${text}${colors.reset}`);
}

function logSuccess(text) {
    console.log(`${themeColor}${text}${colors.reset}`);
}

function logInfo(text) {
    console.log(`${colors.cyan}${text}${colors.reset}`);
}

// ====== FIX FOR PKG - Find config.json next to EXE ======
function getConfigPath() {
    if (process.pkg) {
        return path.join(path.dirname(process.execPath), 'config.json');
    }
    return path.join(__dirname, 'config.json');
}

// ====== CONFIGURATION LOADER ======
// ====== CONFIGURATION LOADER ======
function loadConfig() {
    try {
        const configPath = getConfigPath();
        logInfo(`📂 Looking for config at: ${configPath}`);
        
        if (!fs.existsSync(configPath)) {
            logError('❌ config.json not found!');
            logError(`   Expected location: ${configPath}`);
            logError('   Please make sure config.json is in the same folder as the EXE!');
            
            const defaultConfig = {
                "_comment": "Hammer Discord RPC Configuration - Edit the values below",
                "hammerPath": "D:\\SteamLibrary\\steamapps\\common\\SourceFilmmaker\\game\\bin\\hammer.exe",
                "autoLaunchHammer": true,
                "updateIntervalSeconds": 15,
                "showConsole": true,
                "theme": "green",
                "_themeOptions": "green, red, blue, cyan, magenta, yellow, matrix, fire, ice, purple, hacker"
            };
            
            try {
                fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
                logSuccess('✅ Created default config.json. Please edit it with your settings.');
            } catch (err) {
                logError('❌ Could not create config.json: ' + err.message);
            }
            
            console.log('\nPress any key to exit...');
            process.stdin.setRawMode(true);
            process.stdin.resume();
            process.stdin.on('data', process.exit.bind(process, 0));
            return null;
        }

        const configData = fs.readFileSync(configPath, 'utf8');
        const config = JSON.parse(configData);
        
        // Convert seconds to milliseconds for internal use
        config.updateInterval = (config.updateIntervalSeconds || 15) * 1000;
        
        // Set theme from config
        if (config.theme) {
            setTheme(config.theme);
        }
        
        logSuccess('✅ Config loaded successfully!');
        
        // Validate config
        if (!config.hammerPath || !fs.existsSync(config.hammerPath)) {
            logError('❌ Invalid Hammer path in config.json!');
            logError(`   Path: ${config.hammerPath}`);
            logError(`   Config location: ${configPath}`);
            logError('   Please update config.json with the correct path.');
            console.log('\nPress any key to exit...');
            process.stdin.setRawMode(true);
            process.stdin.resume();
            process.stdin.on('data', process.exit.bind(process, 0));
            return null;
        }

        return config;
    } catch (error) {
        logError('❌ Error loading config: ' + error.message);
        console.log('\nPress any key to exit...');
        process.stdin.setRawMode(true);
        process.stdin.resume();
        process.stdin.on('data', process.exit.bind(process, 0));
        return null;
    }
}
const config = loadConfig();
if (!config) {
    return;
}

const client = new RPC.Client({ transport: 'ipc' });
let startTime = null;
let lastMapName = null;
let hammerLaunched = false;

// ====== HAMMER LAUNCHER ======
function launchHammer() {
    if (!config.autoLaunchHammer || hammerLaunched) return;

    log('🚀 Launching Hammer Editor...');
    
    try {
        const hammerProcess = spawn(config.hammerPath, [], {
            detached: true,
            stdio: 'ignore'
        });
        
        hammerProcess.unref();
        hammerLaunched = true;
        logSuccess('✅ Hammer launched successfully!');
    } catch (error) {
        logError('❌ Failed to launch Hammer: ' + error.message);
    }
}

// ====== PROCESS DETECTION ======
function getHammerProcessDetails() {
    return new Promise((resolve) => {
        const command = `powershell "Get-Process hammer -ErrorAction SilentlyContinue | Select-Object MainWindowTitle, Path | ConvertTo-Json"`;

        exec(command, (error, stdout) => {
            if (error || !stdout.trim()) {
                resolve(null);
                return;
            }
            try {
                const result = JSON.parse(stdout);
                const processes = Array.isArray(result) ? result : [result];
                const targetPath = config.hammerPath.toLowerCase();
                const targetProcess = processes.find(p => p.Path && p.Path.toLowerCase() === targetPath);
                resolve(targetProcess);
            } catch (e) {
                resolve(null);
            }
        });
    });
}

// ====== MAP NAME EXTRACTOR ======
function extractMapName(windowTitle) {
    if (!windowTitle) return null;
    
    let match = windowTitle.match(/\[(.*?)\]/);
    if (match && match[1]) return match[1];
    
    match = windowTitle.match(/Hammer\s*-\s*(.+?\.(?:vmf|dvmf))\s*-/i);
    if (match && match[1]) {
        return path.basename(match[1], path.extname(match[1]));
    }
    
    match = windowTitle.match(/([^\\/]+\.(?:d?vmf))/i);
    if (match && match[1]) {
        return path.basename(match[1], path.extname(match[1]));
    }
    
    return null;
}

// ====== PRESENCE UPDATER ======
async function updatePresence() {
    try {
        const hammerProcess = await getHammerProcessDetails();

        if (hammerProcess) {
            const title = hammerProcess.MainWindowTitle || "";
            const mapName = extractMapName(title);
            const isModified = title.includes("*") || title.toLowerCase().includes("modified");
            
            if (mapName && mapName !== lastMapName) {
                if (config.showConsole) {
                    log(`📝 Map changed: ${mapName}`);
                }
                startTime = Date.now();
                lastMapName = mapName;
            } else if (!startTime) {
                startTime = Date.now();
            }

            let detailsText = "Idling in Editor";
            let stateText = "No Map Loaded";

            if (mapName) {
                const displayName = mapName.length > 30 ? mapName.substring(0, 27) + "..." : mapName;
                detailsText = `Editing: ${displayName}`;
                stateText = isModified ? "⚠️ Unsaved Changes" : "Source Filmmaker";
            }

            client.setActivity({
                details: detailsText,
                state: stateText,
                startTimestamp: startTime,
                largeImageKey: 'hammer_icon',
                largeImageText: 'Hammer Editor',
                smallImageKey: 'sfm_logo',
                smallImageText: 'SFM',
                instance: false,
                buttons: [
                    { label: 'Download SFM', url: 'https://store.steampowered.com/app/1840/Source_Filmmaker/' }
                ]
            });

            if (config.showConsole) {
                logSuccess(`✅ RPC: ${detailsText} | ${stateText}`);
            }
        } else {
            if (startTime) {
                if (config.showConsole) {
                    logWarning("⏸️ Hammer closed - RPC cleared");
                }
                startTime = null;
                lastMapName = null;
                client.clearActivity();
            }
        }
    } catch (err) {
        logError("❌ RPC Error: " + err.message);
    }
}

// ====== MAIN ======
// ====== MAIN ======
client.on('ready', () => {
    console.log('');
    log('╔════════════════════════════════════╗');
    log('║   Hammer Discord RPC - Ready! 🔨   ║');
    log('╚════════════════════════════════════╝');
    console.log('');
    logInfo(`📍 Target: ${config.hammerPath}`);
    logInfo(`🔄 Update interval: ${config.updateIntervalSeconds || 15}s`);
    logInfo(`🚀 Auto-launch: ${config.autoLaunchHammer ? 'Enabled' : 'Disabled'}`);
    logInfo(`🎨 Theme: ${config.theme || 'green'}`);
    console.log('');
    
    launchHammer();
    updatePresence();
    setInterval(updatePresence, config.updateInterval);
});

client.on('error', (err) => {
    logError('❌ Discord RPC Error: ' + err.message);
});

process.on('SIGINT', () => {
    console.log('');
    logWarning('👋 Shutting down gracefully...');
    client.clearActivity();
    process.exit(0);
});

client.login({ clientId: CLIENT_ID }).catch((err) => {
    logError('❌ Failed to connect to Discord: ' + err.message);
    logError('   Make sure Discord is running!');
    console.log('\nPress any key to exit...');
    process.stdin.setRawMode(true);
    process.stdin.resume();
    process.stdin.on('data', process.exit.bind(process, 0));
});