kill-switch-mcp 1.0.0

package/defaults/actions/fight-loop.ts

@@ -0,0 +1,117 @@
+/**
+ * Fight the nearest player (or a specific target) with tick-optimized auto-eat.
+ *
+ * Uses RS PvP combat fundamentals:
+ *   - Attack FIRST, eat AFTER — eating delays your attack by 3 ticks,
+ *     but if you eat right after your hit lands, the delay expires before
+ *     your next attack is ready. Zero DPS loss.
+ *   - Emergency eat at HP <= max hit (13) regardless of threshold
+ *   - Won't eat above HP 28 (40 max - 12 lobster heal = wasted healing)
+ *   - Targets lowest-HP visible player for fastest kills (unless overridden)
+ *
+ * @param opts.eatAt - HP threshold to eat at (default: 25)
+ * @param opts.duration - How long to fight in ms (default: 15000)
+ * @param opts.target - Specific player name or /pattern/ (default: weakest nearby)
+ * @param opts.fleeAt - Food count to flee at if outnumbered (default: 3)
+ * @returns { hp, maxHp, foodLeft, target, nearbyPlayers } — status at end of loop
+ *
+ * Usage:
+ *   await actions.fightLoop()
+ *   await actions.fightLoop({ eatAt: 20, duration: 20000 })
+ *   await actions.fightLoop({ target: /vex/i })
+ */
+export default async function fightLoop(bot: any, sdk: any, opts: any = {}) {
+    const eatAt = opts.eatAt ?? 25;
+    const emergencyHp = 13; // one-hit kill range — eat no matter what
+    const maxEatHp = 28; // don't eat above this (wastes food: 40 max - 12 heal)
+    const duration = opts.duration ?? 15000;
+    const targetPattern = opts.target ?? null;
+    const fleeAt = opts.fleeAt ?? 3;
+    const endTime = Date.now() + duration;
+
+    let lastTarget: string | null = null;
+
+    while (Date.now() < endTime) {
+        const state = sdk.getState();
+        if (!state) { await sdk.waitForTicks(1); continue; }
+
+        const hp = state.player.hitpoints;
+        const players = sdk.getNearbyPlayers();
+
+        // Bail signal: low food + outnumbered
+        const foodCount = countFood(sdk);
+        if (foodCount <= fleeAt && players.length > 1) {
+            return {
+                hp,
+                maxHp: state.player.hitpointsBase ?? 0,
+                foodLeft: foodCount,
+                target: lastTarget,
+                nearbyPlayers: players,
+                fled: true,
+            };
+        }
+
+        // Priority 1: Attack (deal damage BEFORE eating — tick-optimal)
+        let target;
+        if (targetPattern) {
+            target = players.find((p: any) =>
+                typeof targetPattern === 'string'
+                    ? p.name.toLowerCase() === targetPattern.toLowerCase()
+                    : targetPattern.test(p.name)
+            );
+        }
+
+        // Default: attack nearest player (simplest, most reliable)
+        if (!target && players.length > 0) {
+            target = players.sort((a: any, b: any) => a.distance - b.distance)[0];
+        }
+
+        if (target) {
+            lastTarget = target.name;
+            try {
+                await bot.attackPlayer(target);
+            } catch (e) {
+                // Target may have died or moved — continue loop
+            }
+        }
+
+        // Priority 2: Eat AFTER attacking (3-tick eat delay fits inside attack cooldown)
+        const shouldEat = hp <= emergencyHp || (hp < eatAt && hp <= maxEatHp);
+        if (shouldEat) {
+            const food = findBestFood(sdk);
+            if (food) {
+                await bot.eatFood(food);
+                await sdk.waitForTicks(1);
+                continue; // re-engage immediately
+            }
+        }
+
+        await sdk.waitForTicks(2);
+    }
+
+    // Return status
+    const finalState = sdk.getState();
+    return {
+        hp: finalState?.player?.hitpoints ?? 0,
+        maxHp: finalState?.player?.hitpointsBase ?? 0,
+        foodLeft: countFood(sdk),
+        target: lastTarget,
+        nearbyPlayers: sdk.getNearbyPlayers(),
+    };
+}
+
+function findBestFood(sdk: any): any {
+    return sdk.findInventoryItem(/swordfish/i)
+        || sdk.findInventoryItem(/lobster/i)
+        || sdk.findInventoryItem(/salmon/i)
+        || sdk.findInventoryItem(/trout/i)
+        || sdk.findInventoryItem(/bread/i)
+        || sdk.findInventoryItem(/meat/i);
+}
+
+function countFood(sdk: any): number {
+    const inv = sdk.getInventory();
+    return inv.filter((i: any) =>
+        /swordfish|lobster|salmon|trout|bread|meat/i.test(i.name)
+    ).length;
+}

package/defaults/actions/kite.ts

@@ -0,0 +1,103 @@
+/**
+ * Retreat from the nearest enemy while eating food to recover HP.
+ *
+ * Walks away from the closest player while prioritizing eating.
+ * Uses tick-optimal eating: won't eat above HP 28 (40 max - 12 heal = waste).
+ * Stops when HP is above the safe threshold or food/time runs out.
+ *
+ * @param opts.safeHp - HP to heal to before stopping (default: 40)
+ * @param opts.duration - Max time to kite in ms (default: 10000)
+ * @param opts.direction - "north"|"south"|"east"|"west"|"away" (default: "away" from nearest enemy)
+ * @returns { hp, foodLeft, escaped } — status after kiting
+ *
+ * Usage:
+ *   await actions.kite()
+ *   await actions.kite({ safeHp: 35, direction: "north" })
+ */
+export default async function kite(bot: any, sdk: any, opts: any = {}) {
+    const safeHp = opts.safeHp ?? 40;
+    const duration = opts.duration ?? 10000;
+    const direction = opts.direction ?? 'away';
+    const maxEatHp = 28; // don't eat above this (wastes food)
+    const endTime = Date.now() + duration;
+
+    const STEP_SIZE = 5; // tiles per retreat step
+
+    while (Date.now() < endTime) {
+        const state = sdk.getState();
+        if (!state) { await sdk.waitForTicks(1); continue; }
+
+        const hp = state.player.hitpoints;
+
+        // Check if we've healed enough
+        if (hp >= safeHp) {
+            return { hp, foodLeft: countFood(sdk), escaped: true };
+        }
+
+        // Eat if below the waste ceiling (don't eat at 29+ HP — wastes healing)
+        if (hp <= maxEatHp) {
+            const food = findBestFood(sdk);
+            if (food) {
+                await bot.eatFood(food);
+            } else {
+                // No food left, no point kiting
+                return { hp, foodLeft: 0, escaped: false };
+            }
+        }
+
+        // Calculate retreat direction
+        const myX = state.player.worldX;
+        const myZ = state.player.worldZ;
+        let dx = 0, dz = 0;
+
+        if (direction === 'away') {
+            const players = sdk.getNearbyPlayers();
+            if (players.length > 0) {
+                const nearest = players.sort((a: any, b: any) => a.distance - b.distance)[0];
+                // Move opposite direction from nearest player
+                dx = myX - nearest.x;
+                dz = myZ - nearest.z;
+                // Normalize to step size
+                const dist = Math.sqrt(dx * dx + dz * dz) || 1;
+                dx = Math.round((dx / dist) * STEP_SIZE);
+                dz = Math.round((dz / dist) * STEP_SIZE);
+            }
+        } else {
+            switch (direction) {
+                case 'north': dz = STEP_SIZE; break;
+                case 'south': dz = -STEP_SIZE; break;
+                case 'east': dx = STEP_SIZE; break;
+                case 'west': dx = -STEP_SIZE; break;
+            }
+        }
+
+        if (dx !== 0 || dz !== 0) {
+            try {
+                await bot.walkTo(myX + dx, myZ + dz, 2);
+            } catch (e) {
+                // Hit a wall or boundary — try different direction
+            }
+        }
+
+        await sdk.waitForTicks(2);
+    }
+
+    const finalHp = sdk.getState()?.player?.hitpoints ?? 0;
+    return { hp: finalHp, foodLeft: countFood(sdk), escaped: finalHp >= safeHp };
+}
+
+function findBestFood(sdk: any): any {
+    return sdk.findInventoryItem(/swordfish/i)
+        || sdk.findInventoryItem(/lobster/i)
+        || sdk.findInventoryItem(/salmon/i)
+        || sdk.findInventoryItem(/trout/i)
+        || sdk.findInventoryItem(/bread/i)
+        || sdk.findInventoryItem(/meat/i);
+}
+
+function countFood(sdk: any): number {
+    const inv = sdk.getInventory();
+    return inv.filter((i: any) =>
+        /swordfish|lobster|salmon|trout|bread|meat/i.test(i.name)
+    ).length;
+}

package/defaults/actions/loot-and-equip.ts

@@ -0,0 +1,95 @@
+/**
+ * Scan for nearby ground items, pick up the best available, and equip gear.
+ *
+ * Prioritizes weapons > armor > food. Picks up items closest to you first
+ * within each priority tier. Equips weapons and armor automatically.
+ *
+ * @param opts.maxItems - Max items to pick up before stopping (default: 5)
+ * @param opts.radius - Only grab items within this distance (default: 10)
+ * @param opts.foodOnly - Only pick up food, skip weapons/armor (default: false)
+ * @returns { picked, equipped, inventory } — what was grabbed and equipped
+ *
+ * Usage:
+ *   await actions.lootAndEquip()
+ *   await actions.lootAndEquip({ maxItems: 3, foodOnly: true })
+ */
+export default async function lootAndEquip(bot: any, sdk: any, opts: any = {}) {
+    const maxItems = opts.maxItems ?? 5;
+    const maxRadius = opts.radius ?? 10;
+    const foodOnly = opts.foodOnly ?? false;
+
+    const picked: string[] = [];
+    const equipped: string[] = [];
+
+    // Item tier lists (best first)
+    const weapons = [
+        /rune scimitar/i, /rune long/i,
+        /adamant sword/i, /mithril scimitar/i,
+        /iron sword/i, /bronze dagger/i,
+    ];
+
+    const armor = [
+        /rune chain/i, /adamant plate/i,
+        /steel chain/i, /mithril.*helm/i,
+        /hardleather/i, /leather chaps/i, /leather body/i,
+    ];
+
+    const food = [
+        /swordfish/i, /lobster/i,
+        /salmon/i, /trout/i,
+        /bread/i, /meat/i,
+    ];
+
+    // Build a prioritized pickup list
+    const priorities = foodOnly
+        ? [...food]
+        : [...weapons, ...armor, ...food];
+
+    for (const pattern of priorities) {
+        if (picked.length >= maxItems) break;
+
+        const item = sdk.findGroundItem(pattern);
+        if (item && item.distance <= maxRadius) {
+            try {
+                const result = await bot.pickupItem(item);
+                if (result.success) {
+                    picked.push(item.name);
+                }
+            } catch (e) {
+                // Item may have been grabbed by someone else
+            }
+        }
+    }
+
+    // Equip best weapon found (try best first)
+    if (!foodOnly) {
+        for (const pattern of weapons) {
+            const item = sdk.findInventoryItem(pattern);
+            if (item) {
+                try {
+                    await bot.equipItem(item);
+                    equipped.push(item.name);
+                } catch (e) { /* already equipped or can't */ }
+                break; // Only equip one weapon
+            }
+        }
+
+        // Equip best armor found
+        for (const pattern of armor) {
+            const item = sdk.findInventoryItem(pattern);
+            if (item) {
+                try {
+                    await bot.equipItem(item);
+                    equipped.push(item.name);
+                } catch (e) { /* already equipped or can't */ }
+                // Don't break — can equip body + legs + helm
+            }
+        }
+    }
+
+    return {
+        picked,
+        equipped,
+        inventory: sdk.getInventory(),
+    };
+}