288 lines
7.7 KiB
JavaScript
288 lines
7.7 KiB
JavaScript
import Database from 'better-sqlite3';
|
|
import path from 'path';
|
|
import { fileURLToPath } from 'url';
|
|
|
|
const __filename = fileURLToPath(import.meta.url);
|
|
const __dirname = path.dirname(__filename);
|
|
|
|
const db = new Database(path.join(__dirname, 'turtle_control.db'));
|
|
|
|
// Initialize database schema
|
|
export function initializeDatabase() {
|
|
// Turtle homes table
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS turtle_homes (
|
|
turtle_id INTEGER PRIMARY KEY,
|
|
x INTEGER NOT NULL,
|
|
y INTEGER NOT NULL,
|
|
z INTEGER NOT NULL,
|
|
updated_at INTEGER NOT NULL
|
|
)
|
|
`);
|
|
|
|
// Turtle configuration table
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS turtle_config (
|
|
turtle_id INTEGER PRIMARY KEY,
|
|
max_distance INTEGER DEFAULT 200,
|
|
facing INTEGER DEFAULT 0,
|
|
config_json TEXT,
|
|
updated_at INTEGER NOT NULL
|
|
)
|
|
`);
|
|
|
|
// World blocks table
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS world_blocks (
|
|
x INTEGER NOT NULL,
|
|
y INTEGER NOT NULL,
|
|
z INTEGER NOT NULL,
|
|
block_name TEXT NOT NULL,
|
|
metadata INTEGER DEFAULT 0,
|
|
discovered_by INTEGER NOT NULL,
|
|
discovered_at INTEGER NOT NULL,
|
|
PRIMARY KEY (x, y, z)
|
|
)
|
|
`);
|
|
|
|
// Turtle paths table (for path recording)
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS turtle_paths (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
turtle_id INTEGER NOT NULL,
|
|
path_name TEXT NOT NULL,
|
|
path_data TEXT NOT NULL,
|
|
created_at INTEGER NOT NULL,
|
|
updated_at INTEGER NOT NULL
|
|
)
|
|
`);
|
|
|
|
// Task queue table (for multi-turtle coordination)
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS task_queue (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
task_type TEXT NOT NULL,
|
|
task_data TEXT NOT NULL,
|
|
assigned_turtle_id INTEGER,
|
|
priority INTEGER DEFAULT 0,
|
|
status TEXT DEFAULT 'pending',
|
|
created_at INTEGER NOT NULL,
|
|
updated_at INTEGER NOT NULL
|
|
)
|
|
`);
|
|
|
|
// Mining areas table (for area visualization)
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS mining_areas (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
turtle_id INTEGER NOT NULL,
|
|
min_x INTEGER NOT NULL,
|
|
min_y INTEGER NOT NULL,
|
|
min_z INTEGER NOT NULL,
|
|
max_x INTEGER NOT NULL,
|
|
max_y INTEGER NOT NULL,
|
|
max_z INTEGER NOT NULL,
|
|
status TEXT DEFAULT 'active',
|
|
created_at INTEGER NOT NULL,
|
|
updated_at INTEGER NOT NULL
|
|
)
|
|
`);
|
|
|
|
// Create indexes for better performance
|
|
db.exec(`
|
|
CREATE INDEX IF NOT EXISTS idx_world_blocks_discovered
|
|
ON world_blocks(discovered_by);
|
|
`);
|
|
|
|
db.exec(`
|
|
CREATE INDEX IF NOT EXISTS idx_task_queue_status
|
|
ON task_queue(status, priority DESC);
|
|
`);
|
|
|
|
console.log('✅ Database initialized');
|
|
}
|
|
|
|
// Turtle Homes
|
|
export function saveTurtleHome(turtleId, position) {
|
|
const stmt = db.prepare(`
|
|
INSERT OR REPLACE INTO turtle_homes (turtle_id, x, y, z, updated_at)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
`);
|
|
stmt.run(turtleId, position.x, position.y, position.z, Date.now());
|
|
}
|
|
|
|
export function getTurtleHome(turtleId) {
|
|
const stmt = db.prepare('SELECT x, y, z FROM turtle_homes WHERE turtle_id = ?');
|
|
return stmt.get(turtleId);
|
|
}
|
|
|
|
export function getAllTurtleHomes() {
|
|
const stmt = db.prepare('SELECT turtle_id, x, y, z FROM turtle_homes');
|
|
return stmt.all();
|
|
}
|
|
|
|
// Turtle Configuration
|
|
export function saveTurtleConfig(turtleId, config) {
|
|
const stmt = db.prepare(`
|
|
INSERT OR REPLACE INTO turtle_config (turtle_id, max_distance, facing, config_json, updated_at)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
`);
|
|
stmt.run(
|
|
turtleId,
|
|
config.maxDistance || 200,
|
|
config.facing || 0,
|
|
JSON.stringify(config),
|
|
Date.now()
|
|
);
|
|
}
|
|
|
|
export function getTurtleConfig(turtleId) {
|
|
const stmt = db.prepare('SELECT * FROM turtle_config WHERE turtle_id = ?');
|
|
const row = stmt.get(turtleId);
|
|
if (row && row.config_json) {
|
|
return JSON.parse(row.config_json);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// World Blocks
|
|
export function saveWorldBlock(x, y, z, blockName, metadata, discoveredBy) {
|
|
const stmt = db.prepare(`
|
|
INSERT OR REPLACE INTO world_blocks (x, y, z, block_name, metadata, discovered_by, discovered_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
`);
|
|
stmt.run(x, y, z, blockName, metadata || 0, discoveredBy, Date.now());
|
|
}
|
|
|
|
export function getWorldBlocks(limit = 10000) {
|
|
const stmt = db.prepare('SELECT * FROM world_blocks LIMIT ?');
|
|
return stmt.all(limit);
|
|
}
|
|
|
|
export function getWorldBlocksInArea(minX, minY, minZ, maxX, maxY, maxZ) {
|
|
const stmt = db.prepare(`
|
|
SELECT * FROM world_blocks
|
|
WHERE x BETWEEN ? AND ?
|
|
AND y BETWEEN ? AND ?
|
|
AND z BETWEEN ? AND ?
|
|
`);
|
|
return stmt.all(minX, maxX, minY, maxY, minZ, maxZ);
|
|
}
|
|
|
|
export function clearOldBlocks(daysOld = 7) {
|
|
const cutoffTime = Date.now() - (daysOld * 24 * 60 * 60 * 1000);
|
|
const stmt = db.prepare('DELETE FROM world_blocks WHERE discovered_at < ?');
|
|
const result = stmt.run(cutoffTime);
|
|
return result.changes;
|
|
}
|
|
|
|
// Turtle Paths
|
|
export function savePath(turtleId, pathName, pathData) {
|
|
const stmt = db.prepare(`
|
|
INSERT INTO turtle_paths (turtle_id, path_name, path_data, created_at, updated_at)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
`);
|
|
const now = Date.now();
|
|
stmt.run(turtleId, pathName, JSON.stringify(pathData), now, now);
|
|
}
|
|
|
|
export function getPaths(turtleId) {
|
|
const stmt = db.prepare('SELECT * FROM turtle_paths WHERE turtle_id = ? ORDER BY created_at DESC');
|
|
return stmt.all(turtleId).map(row => ({
|
|
...row,
|
|
path_data: JSON.parse(row.path_data)
|
|
}));
|
|
}
|
|
|
|
export function deletePath(pathId) {
|
|
const stmt = db.prepare('DELETE FROM turtle_paths WHERE id = ?');
|
|
return stmt.run(pathId);
|
|
}
|
|
|
|
// Task Queue
|
|
export function createTask(taskType, taskData, priority = 0) {
|
|
const stmt = db.prepare(`
|
|
INSERT INTO task_queue (task_type, task_data, priority, status, created_at, updated_at)
|
|
VALUES (?, ?, ?, 'pending', ?, ?)
|
|
`);
|
|
const now = Date.now();
|
|
const result = stmt.run(taskType, JSON.stringify(taskData), priority, now, now);
|
|
return result.lastInsertRowid;
|
|
}
|
|
|
|
export function getNextTask() {
|
|
const stmt = db.prepare(`
|
|
SELECT * FROM task_queue
|
|
WHERE status = 'pending'
|
|
ORDER BY priority DESC, created_at ASC
|
|
LIMIT 1
|
|
`);
|
|
const row = stmt.get();
|
|
if (row) {
|
|
return {
|
|
...row,
|
|
task_data: JSON.parse(row.task_data)
|
|
};
|
|
}
|
|
return null;
|
|
}
|
|
|
|
export function assignTask(taskId, turtleId) {
|
|
const stmt = db.prepare(`
|
|
UPDATE task_queue
|
|
SET assigned_turtle_id = ?, status = 'assigned', updated_at = ?
|
|
WHERE id = ?
|
|
`);
|
|
stmt.run(turtleId, Date.now(), taskId);
|
|
}
|
|
|
|
export function completeTask(taskId) {
|
|
const stmt = db.prepare(`
|
|
UPDATE task_queue
|
|
SET status = 'completed', updated_at = ?
|
|
WHERE id = ?
|
|
`);
|
|
stmt.run(Date.now(), taskId);
|
|
}
|
|
|
|
export function getAllTasks() {
|
|
const stmt = db.prepare('SELECT * FROM task_queue ORDER BY priority DESC, created_at DESC');
|
|
return stmt.all().map(row => ({
|
|
...row,
|
|
task_data: JSON.parse(row.task_data)
|
|
}));
|
|
}
|
|
|
|
// Mining Areas
|
|
export function saveMiningArea(turtleId, bounds) {
|
|
const stmt = db.prepare(`
|
|
INSERT INTO mining_areas (turtle_id, min_x, min_y, min_z, max_x, max_y, max_z, status, created_at, updated_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, 'active', ?, ?)
|
|
`);
|
|
const now = Date.now();
|
|
stmt.run(
|
|
turtleId,
|
|
bounds.minX, bounds.minY, bounds.minZ,
|
|
bounds.maxX, bounds.maxY, bounds.maxZ,
|
|
now, now
|
|
);
|
|
}
|
|
|
|
export function getMiningAreas() {
|
|
const stmt = db.prepare('SELECT * FROM mining_areas WHERE status = \'active\'');
|
|
return stmt.all();
|
|
}
|
|
|
|
export function closeMiningArea(areaId) {
|
|
const stmt = db.prepare('UPDATE mining_areas SET status = \'closed\', updated_at = ? WHERE id = ?');
|
|
stmt.run(Date.now(), areaId);
|
|
}
|
|
|
|
// Cleanup function
|
|
export function closeDatabase() {
|
|
db.close();
|
|
}
|
|
|
|
// Export database instance for custom queries if needed
|
|
export { db };
|