forked from wmantly/mc-bot-town
516 lines
16 KiB
JavaScript
516 lines
16 KiB
JavaScript
'use strict';
|
|
|
|
const Vec3 = require('vec3');
|
|
const { sleep } = require('../../utils');
|
|
|
|
class Scanner {
|
|
constructor() {
|
|
this.chestBlockType = null;
|
|
}
|
|
|
|
async discoverChests(bot, radius, database) {
|
|
if (!this.chestBlockType) {
|
|
this.chestBlockType = bot.mcData.blocksByName.chest?.id;
|
|
if (!this.chestBlockType) {
|
|
throw new Error('Chest block not found in minecraft-data');
|
|
}
|
|
}
|
|
|
|
this._scanRadius = radius;
|
|
console.log(`Scanner: Discovering chests within ${radius} blocks...`);
|
|
const chestPositions = bot.bot.findBlocks({
|
|
matching: this.chestBlockType,
|
|
maxDistance: radius,
|
|
count: Infinity,
|
|
});
|
|
|
|
console.log(`Scanner: Found ${chestPositions.length} chest block(s)`);
|
|
|
|
const discoveredChests = [];
|
|
const processed = new Set();
|
|
|
|
for (const pos of chestPositions) {
|
|
const key = `${pos.x},${pos.y},${pos.z}`;
|
|
if (processed.has(key)) continue;
|
|
processed.add(key);
|
|
|
|
const chestInfo = this.detectChestType(bot, pos);
|
|
|
|
// Skip the second half of double chests
|
|
if (chestInfo.type === 'skip') {
|
|
continue;
|
|
}
|
|
|
|
const rowColumn = this.assignRowColumn(pos);
|
|
const category = this.columnToCategory(rowColumn.column);
|
|
|
|
await database.upsertChest(
|
|
pos.x, pos.y, pos.z,
|
|
chestInfo.type,
|
|
rowColumn.row,
|
|
rowColumn.column,
|
|
category
|
|
);
|
|
|
|
discoveredChests.push({
|
|
x: pos.x, y: pos.y, z: pos.z,
|
|
type: chestInfo.type,
|
|
...rowColumn,
|
|
category
|
|
});
|
|
}
|
|
|
|
// Remove DB records for chest positions no longer discovered
|
|
// (e.g., the old canonical half of a double chest that switched sides)
|
|
if (discoveredChests.length > 0) {
|
|
await database.deleteOrphanChests(discoveredChests);
|
|
}
|
|
console.log(`Scanner: Discovered/updated ${discoveredChests.length} chest(s)`);
|
|
return discoveredChests;
|
|
}
|
|
|
|
detectChestType(bot, position) {
|
|
const block = bot.bot.blockAt(position);
|
|
if (!block) return { type: 'single' };
|
|
|
|
// Use block state properties (Minecraft 1.13+ has type: single/left/right)
|
|
const props = typeof block.getProperties === 'function' ? block.getProperties() : null;
|
|
if (props && props.type) {
|
|
if (props.type === 'single') return { type: 'single' };
|
|
// Register the 'left' half as canonical, skip 'right'
|
|
if (props.type === 'left') return { type: 'double' };
|
|
return { type: 'skip' }; // 'right' half
|
|
}
|
|
|
|
// Fallback: adjacency check for older versions
|
|
const directions = [
|
|
new Vec3(1, 0, 0),
|
|
new Vec3(-1, 0, 0),
|
|
new Vec3(0, 0, 1),
|
|
new Vec3(0, 0, -1)
|
|
];
|
|
|
|
for (const dir of directions) {
|
|
const adjacentPos = position.offset(dir.x, dir.y, dir.z);
|
|
const adjacentBlock = bot.bot.blockAt(adjacentPos);
|
|
|
|
if (adjacentBlock && adjacentBlock.name === 'chest') {
|
|
if (dir.x === -1 || dir.z === -1) {
|
|
return { type: 'double' };
|
|
}
|
|
return { type: 'skip' };
|
|
}
|
|
}
|
|
|
|
return { type: 'single' };
|
|
}
|
|
|
|
assignRowColumn(position) {
|
|
const row = Math.floor(position.y / 4) + 1;
|
|
const column = position.x;
|
|
return { row, column };
|
|
}
|
|
|
|
columnToCategory(column) {
|
|
if (column <= 1) return 'minerals';
|
|
if (column === 2) return 'food';
|
|
if (column === 3) return 'tools';
|
|
if (column === 4) return 'armor';
|
|
if (column === 5) return 'blocks';
|
|
if (column === 6) return 'redstone';
|
|
return 'misc';
|
|
}
|
|
|
|
async scanChest(bot, database, chestPosition) {
|
|
console.log(`Scanner: Scanning chest at ${chestPosition.x},${chestPosition.y},${chestPosition.z}`);
|
|
|
|
try {
|
|
// Ensure bot is close enough to interact
|
|
const distance = bot.bot.entity.position.distanceTo(chestPosition);
|
|
if (distance > 4) {
|
|
await bot.goTo({ where: chestPosition, range: 3 });
|
|
}
|
|
|
|
const chestBlock = bot.bot.blockAt(chestPosition);
|
|
if (!chestBlock || !chestBlock.name.includes('chest')) {
|
|
console.log(`Scanner: Not a chest at ${chestPosition.x},${chestPosition.y},${chestPosition.z}`);
|
|
return 0;
|
|
}
|
|
|
|
// Get chest from database
|
|
const chest = await database.getChestByPosition(chestPosition.x, chestPosition.y, chestPosition.z);
|
|
if (!chest) {
|
|
console.log(`Scanner: Chest not in database`);
|
|
return 0;
|
|
}
|
|
|
|
const window = await bot.openContainer(chestBlock);
|
|
const slots = window.slots;
|
|
let shulkerCount = 0;
|
|
|
|
// Only scan chest inventory slots (not player inventory)
|
|
const chestSlotCount = window.inventoryStart || 27;
|
|
console.log(`Scanner: Chest has ${chestSlotCount} slots`);
|
|
|
|
// Correct DB chest_type if it doesn't match the actual window size
|
|
const actualType = chestSlotCount > 27 ? 'double' : 'single';
|
|
if (chest.chest_type !== actualType) {
|
|
console.log(`Scanner: Correcting chest type: DB says '${chest.chest_type}', actual is '${actualType}'`);
|
|
await database.upsertChest(
|
|
chestPosition.x, chestPosition.y, chestPosition.z,
|
|
actualType, chest.row, chest.column, chest.category
|
|
);
|
|
}
|
|
|
|
// Clear previous loose item records before re-scanning
|
|
await database.clearLooseItems(chest.id);
|
|
|
|
const looseItems = [];
|
|
for (let i = 0; i < chestSlotCount; i++) {
|
|
const slot = slots[i];
|
|
if (!slot) continue;
|
|
|
|
if (slot.name.includes('shulker_box')) {
|
|
console.log(`Scanner: Found shulker at slot ${i}: ${slot.name}`);
|
|
await this.scanShulkerFromNBT(bot, database, chest.id, i, slot);
|
|
shulkerCount++;
|
|
} else {
|
|
looseItems.push({ slot: i, name: slot.name, id: slot.type, count: slot.count });
|
|
}
|
|
}
|
|
|
|
if (looseItems.length > 0) {
|
|
await database.batchUpsertLooseItems(chest.id, looseItems);
|
|
}
|
|
|
|
await bot.bot.closeWindow(window);
|
|
console.log(`Scanner: Found ${shulkerCount} shulkers in chest`);
|
|
return shulkerCount;
|
|
|
|
} catch (error) {
|
|
console.error(`Scanner: Error scanning chest at ${chestPosition.x},${chestPosition.y},${chestPosition.z}:`, error);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
async scanAllChests(bot, database) {
|
|
const chests = await database.getChests();
|
|
console.log(`Scanner: Scanning all ${chests.length} tracked chests`);
|
|
|
|
let totalShulkers = 0;
|
|
let scannedCount = 0;
|
|
let skippedCount = 0;
|
|
|
|
// Track scanned positions so we don't re-scan or re-queue
|
|
const scannedPositions = new Set();
|
|
|
|
// Visit chests in nearest-neighbor order to minimize travel
|
|
const remaining = chests.map(c => ({ ...c, pos: new Vec3(c.pos_x, c.pos_y, c.pos_z) }));
|
|
for (const c of remaining) {
|
|
scannedPositions.add(`${c.pos.x},${c.pos.y},${c.pos.z}`);
|
|
}
|
|
|
|
while (remaining.length > 0) {
|
|
const botPos = bot.bot.entity.position;
|
|
|
|
// Find the closest unscanned chest
|
|
let closestIdx = 0;
|
|
let closestDist = botPos.distanceTo(remaining[0].pos);
|
|
for (let i = 1; i < remaining.length; i++) {
|
|
const dist = botPos.distanceTo(remaining[i].pos);
|
|
if (dist < closestDist) {
|
|
closestDist = dist;
|
|
closestIdx = i;
|
|
}
|
|
}
|
|
|
|
const chest = remaining.splice(closestIdx, 1)[0];
|
|
|
|
if (closestDist > 4.5) {
|
|
console.log(`Scanner: Walking to chest at ${chest.pos} (distance: ${closestDist.toFixed(1)})`);
|
|
try {
|
|
const reached = await bot.goTo({
|
|
where: chest.pos,
|
|
range: 3,
|
|
});
|
|
if (reached === false) {
|
|
console.log(`Scanner: Could not reach chest at ${chest.pos}: no path`);
|
|
skippedCount++;
|
|
continue;
|
|
}
|
|
} catch (error) {
|
|
console.log(`Scanner: Could not reach chest at ${chest.pos}: ${error.message}`);
|
|
skippedCount++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Wait for anti-ESP to reveal nearby blocks after arriving
|
|
await sleep(250);
|
|
|
|
// Discover any new chests now visible from this position (every 5th stop or first)
|
|
if (scannedCount % 5 === 0) {
|
|
const newChests = await this.discoverChests(bot, this._scanRadius || 30, database);
|
|
for (const nc of newChests) {
|
|
const key = `${nc.x},${nc.y},${nc.z}`;
|
|
if (!scannedPositions.has(key)) {
|
|
scannedPositions.add(key);
|
|
remaining.push({ ...nc, pos: new Vec3(nc.x, nc.y, nc.z) });
|
|
console.log(`Scanner: Discovered new chest at ${nc.x},${nc.y},${nc.z} while walking`);
|
|
}
|
|
}
|
|
}
|
|
|
|
const shulkerCount = await this.scanChest(bot, database, chest.pos);
|
|
totalShulkers += shulkerCount;
|
|
scannedCount++;
|
|
|
|
if (scannedCount % 10 === 0) {
|
|
console.log(`Scanner: Progress - ${scannedCount}/${scannedCount + remaining.length} chests scanned, ${totalShulkers} shulkers found`);
|
|
}
|
|
|
|
}
|
|
|
|
await database.rebuildItemIndex();
|
|
console.log(`Scanner: Scanned ${scannedCount} chests, skipped ${skippedCount}, found ${totalShulkers} shulkers`);
|
|
return totalShulkers;
|
|
}
|
|
|
|
// Read shulker contents from NBT data (no physical interaction needed)
|
|
async scanShulkerFromNBT(bot, database, chestId, chestSlot, shulkerItem) {
|
|
console.log(`Scanner: Reading shulker NBT at slot ${chestSlot}`);
|
|
|
|
try {
|
|
// Create/update shulker record and get its ID in one call
|
|
const shulkerRecord = await database.upsertAndGetShulker(
|
|
chestId,
|
|
chestSlot,
|
|
shulkerItem.name,
|
|
null // category will be set based on contents
|
|
);
|
|
if (!shulkerRecord) {
|
|
console.error(`Scanner: No shulker record found for chest ${chestId} slot ${chestSlot}`);
|
|
return [];
|
|
}
|
|
const shulkerId = shulkerRecord.id;
|
|
|
|
await database.clearShulkerItems(shulkerId);
|
|
|
|
// Extract items from shulker NBT
|
|
const items = this.extractShulkerContents(bot, shulkerItem);
|
|
|
|
let totalItems = 0;
|
|
const itemTypes = new Set();
|
|
|
|
await database.batchUpsertShulkerItems(shulkerId, items);
|
|
|
|
for (const item of items) {
|
|
totalItems += item.count;
|
|
itemTypes.add(item.name);
|
|
}
|
|
|
|
// Update shulker stats
|
|
let itemFocus = itemTypes.size === 1 ? Array.from(itemTypes)[0] : null;
|
|
const usedSlots = items.length;
|
|
|
|
// If any item in the shulker is special, append #special to the focus
|
|
if (itemFocus) {
|
|
const hasSpecial = items.some(item => Scanner.isSpecialItem(item.nbt));
|
|
if (hasSpecial) {
|
|
itemFocus = itemFocus + '#special';
|
|
}
|
|
}
|
|
|
|
await database.updateShulkerCounts(shulkerId, usedSlots, totalItems);
|
|
|
|
await database.updateShulkerItemFocus(shulkerId, itemFocus);
|
|
|
|
console.log(`Scanner: Shulker has ${items.length} slot(s) used, ${totalItems} total items`);
|
|
return items;
|
|
|
|
} catch (error) {
|
|
console.error(`Scanner: Error reading shulker NBT:`, error);
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// Extract items from shulker box NBT data
|
|
extractShulkerContents(bot, shulkerItem) {
|
|
const items = [];
|
|
|
|
if (!shulkerItem.nbt) {
|
|
console.log('Scanner: Shulker has no NBT data (empty)');
|
|
return items;
|
|
}
|
|
|
|
try {
|
|
// Navigate the NBT structure to find Items array
|
|
// Structure varies between:
|
|
// - Placed+opened shulker: nbt.value.BlockEntityTag.value.Items.value.value
|
|
// - Trade window / freshly-crafted: nbt.value.tag.value.BlockEntityTag.value.Items.value.value
|
|
// - Simple forms: nbt.Items, nbt.BlockEntityTag.Items, etc.
|
|
let nbtItems = null;
|
|
const nbt = shulkerItem.nbt;
|
|
|
|
// Try multiple paths to find the items array
|
|
const paths = [
|
|
() => nbt.value?.BlockEntityTag?.value?.Items?.value?.value, // Full nested path (standard placed shulker)
|
|
() => nbt.value?.BlockEntityTag?.value?.Items?.value, // One less nesting level
|
|
() => nbt.BlockEntityTag?.Items?.value?.value, // Without top-level value wrapper
|
|
() => nbt.BlockEntityTag?.Items?.value, // Simpler BlockEntityTag path
|
|
() => nbt.BlockEntityTag?.Items, // Direct BlockEntityTag
|
|
() => nbt.value?.tag?.value?.BlockEntityTag?.value?.Items?.value?.value, // Trade window shulker (has extra tag wrapper)
|
|
() => nbt.value?.tag?.value?.Items?.value?.value, // Trade window with Items directly under tag
|
|
() => nbt.value?.tag?.value?.Items?.value, // Trade window simpler
|
|
() => nbt.value?.Items?.value?.value, // No BlockEntityTag
|
|
() => nbt.Items?.value?.value, // Even simpler
|
|
() => nbt.Items, // Direct Items
|
|
() => nbt.tag?.value?.BlockEntityTag?.value?.Items?.value?.value, // Tag wrapper path
|
|
() => nbt.tag?.BlockEntityTag?.Items?.value?.value, // Tag without value
|
|
() => nbt.tag?.Items?.value?.value, // Tag with Items direct
|
|
];
|
|
|
|
for (const pathFn of paths) {
|
|
const result = pathFn();
|
|
if (Array.isArray(result)) {
|
|
nbtItems = result;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!nbtItems || !Array.isArray(nbtItems)) {
|
|
console.log('Scanner: No items array found in shulker (may be empty)');
|
|
return items;
|
|
}
|
|
|
|
console.log(`Scanner: Found ${nbtItems.length} items in shulker NBT`);
|
|
|
|
for (const nbtItem of nbtItems) {
|
|
// Extract slot, id, count from NBT item
|
|
const slot = nbtItem.Slot?.value ?? nbtItem.Slot ?? 0;
|
|
const id = nbtItem.id?.value ?? nbtItem.id ?? 'unknown';
|
|
const count = nbtItem.Count?.value ?? nbtItem.Count ?? 1;
|
|
|
|
// Clean up the id (remove minecraft: prefix)
|
|
const cleanId = String(id).replace('minecraft:', '');
|
|
|
|
if (count <= 0 || cleanId === 'air') continue;
|
|
|
|
// tag may be a prismarine-nbt compound or a plain object
|
|
const tag = nbtItem.tag?.value ?? nbtItem.tag ?? null;
|
|
items.push({
|
|
slot: slot,
|
|
name: cleanId,
|
|
id: bot.mcData.itemsByName[cleanId]?.id || 0,
|
|
count: count,
|
|
nbt: tag ? this.parseNBT(tag) : null
|
|
});
|
|
}
|
|
} catch (error) {
|
|
console.error('Scanner: Error parsing shulker NBT:', error);
|
|
console.log('Scanner: Raw NBT:', JSON.stringify(shulkerItem.nbt).substring(0, 500));
|
|
}
|
|
|
|
return items;
|
|
}
|
|
|
|
// Recursively unwrap prismarine-nbt {type, value} structures into plain objects
|
|
simplifyNBT(nbt) {
|
|
if (nbt === null || nbt === undefined) return nbt;
|
|
if (typeof nbt !== 'object') return nbt;
|
|
|
|
// prismarine-nbt compound/value wrapper
|
|
if (nbt.type !== undefined && nbt.value !== undefined) {
|
|
return this.simplifyNBT(nbt.value);
|
|
}
|
|
|
|
if (Array.isArray(nbt)) {
|
|
return nbt.map(v => this.simplifyNBT(v));
|
|
}
|
|
|
|
const out = {};
|
|
for (const key of Object.keys(nbt)) {
|
|
out[key] = this.simplifyNBT(nbt[key]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
parseNBT(nbt) {
|
|
if (!nbt) return null;
|
|
if (typeof nbt === 'string') {
|
|
try {
|
|
nbt = JSON.parse(nbt);
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Unwrap prismarine-nbt wrappers so we can access keys directly
|
|
nbt = this.simplifyNBT(nbt);
|
|
|
|
const result = {};
|
|
|
|
if (nbt.Enchantments) {
|
|
let enchList = nbt.Enchantments;
|
|
if (Array.isArray(enchList)) {
|
|
result.enchantments = enchList.map(e => ({
|
|
id: e.id,
|
|
level: e.lvl
|
|
}));
|
|
}
|
|
}
|
|
|
|
if (nbt.Damage) {
|
|
result.damage = nbt.Damage;
|
|
}
|
|
|
|
if (nbt.display?.Name) {
|
|
const name = nbt.display.Name;
|
|
if (typeof name === 'string') {
|
|
try { result.displayName = JSON.parse(name).text || name; } catch (e) { result.displayName = name; }
|
|
} else {
|
|
result.displayName = name?.text || String(name);
|
|
}
|
|
}
|
|
|
|
if (nbt.display?.Lore) {
|
|
let lore = nbt.display.Lore;
|
|
if (!Array.isArray(lore)) lore = [lore];
|
|
result.lore = lore.map(l => {
|
|
if (typeof l === 'string') {
|
|
try { return JSON.parse(l).text || l; } catch (e) { return l; }
|
|
}
|
|
return l?.text || String(l);
|
|
});
|
|
}
|
|
|
|
if (nbt.CustomModelData) {
|
|
result.customModelData = nbt.CustomModelData;
|
|
}
|
|
|
|
if (nbt.RepairCost) {
|
|
result.repairCost = nbt.RepairCost;
|
|
}
|
|
|
|
// Map ID for filled_map items
|
|
if (nbt.map !== undefined) {
|
|
result.map = nbt.map;
|
|
}
|
|
|
|
return Object.keys(result).length > 0 ? result : null;
|
|
}
|
|
|
|
/**
|
|
* Check if parsed NBT data indicates a "special" item — one with a custom
|
|
* display name, lore, or custom model data that should be stored separately.
|
|
*/
|
|
static isSpecialItem(nbtData) {
|
|
if (!nbtData) return false;
|
|
if (typeof nbtData === 'string') {
|
|
try { nbtData = JSON.parse(nbtData); } catch (e) { return false; }
|
|
}
|
|
return !!(nbtData.displayName || nbtData.lore || nbtData.customModelData);
|
|
}
|
|
}
|
|
|
|
module.exports = Scanner; |