haunter/grepo-remote
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MJ: claude fix

Browse Source
This commit is contained in:
haunter
2026-04-26 12:53:14 +03:00
parent 7beece5aaa
commit 929af21d08
6 changed files with 757 additions and 862 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
bot_modules/00_config.js
View File

@@ -1,21 +1,31 @@
// ================================================================
// 00_config.js — Shared constants and utility helpers
// Runs first; everything here is available to all other modules.
// ================================================================
const uw = typeof unsafeWindow !== 'undefined' ? unsafeWindow : window;
const BASE_URL = 'https://grepo.haunter-pets.top';
const uw = typeof unsafeWindow !== 'undefined' ? unsafeWindow : window;
const BASE_URL = 'https://grepo.haunter-pets.top';
// ---- Jitter helpers -----------------------------------------------
// Returns a random integer between min and max (inclusive)
function randInt(min, max) {
// Returns a random integer between min and max (inclusive)
function randInt(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
// Schedules fn to run after a random ms delay, then reschedules itself
function jitterLoop(fn, minMs, maxMs) {
}
// Schedules fn to run after a random ms delay, then reschedules itself
function jitterLoop(fn, minMs, maxMs) {
function schedule() {
setTimeout(async () => {
await fn();
schedule(); // reschedule with a NEW random delay every time
schedule();
}, randInt(minMs, maxMs));
}
schedule();
}
}
// ----------------------------------------------------------------
function log(msg) {
console.log(`[GRC] ${msg}`);
}
function sleep(ms) {
return new Promise(r => setTimeout(r, ms));
}

34
bot_modules/01_ui.js
View File

@@ -1,15 +1,18 @@
// Toolbar indicator button
// ----------------------------------------------------------------
const btnHtml = `
// ================================================================
// 01_ui.js — Toolbar button + pause toggle
// Depends on: uw, log (00_config.js)
// ================================================================
const btnHtml = `
<div class="divider"></div>
<div class="activity" id="grc_btn"
style="filter: brightness(70%) sepia(100%) hue-rotate(200deg) saturate(1000%) contrast(0.8);">
<p id="grc_label" style="position:relative;top:-8px;font-weight:bold;z-index:6;">Remote</p>
</div>`;
let paused = false;
let paused = false;
function togglePause() {
function togglePause() {
paused = !paused;
const label = document.getElementById('grc_label');
const btn = document.getElementById('grc_btn');
@@ -21,25 +24,12 @@
btn.style.filter = 'brightness(294%) sepia(100%) hue-rotate(200deg) saturate(1000%) contrast(0.8)';
}
log(`Remote is now ${paused ? 'PAUSED' : 'ACTIVE'}`);
}
}
setTimeout(() => {
setTimeout(() => {
if (!document.getElementById('grc_btn')) {
uw.$('.tb_activities, .toolbar_activities').find('.middle').append(btnHtml);
}
}, 4000);
}, 4000);
uw.$(document).on('click', '#grc_btn', togglePause);
// ----------------------------------------------------------------
// Helpers
// ----------------------------------------------------------------
function log(msg) {
console.log(`[GRC] ${msg}`);
}
function sleep(ms) {
return new Promise(r => setTimeout(r, ms));
}
// ----------------------------------------------------------------
uw.$(document).on('click', '#grc_btn', togglePause);

109
bot_modules/02_state.js
View File

@@ -1,6 +1,9 @@
// Push town state to relay
// ----------------------------------------------------------------
function gatherState() {
// ================================================================
// 02_state.js — Gather & push town state to the relay server
// Depends on: uw, BASE_URL, log, paused (00_config.js / 01_ui.js)
// ================================================================
function gatherState() {
const towns = uw.ITowns?.towns || {};
const player = uw.Game?.player_name || '';
const player_id = uw.Game?.player_id ?? null;
@@ -9,10 +12,7 @@
try {
const pm = uw.MM.getModels().Player[player_id];
if (pm && pm.attributes) alliance_name = pm.attributes.alliance_name;
console.log("GrepoRemote: Extracted alliance_name =", alliance_name);
} catch (e) {
console.log("GrepoRemote: Failed to extract alliance_name", e);
}
} catch (e) {}
const total_points = uw.Game?.player_points ?? 0;
const world = uw.Game?.world_id || '';
@@ -31,13 +31,13 @@
: (units[k]?.getAmount?.() ?? 0);
});
}
} catch (e) { }
} catch (e) {}
let buildQueue = [];
try {
const bo = town.buildingOrders?.();
if (bo?.models) buildQueue = bo.models.map(m => m.attributes);
} catch (e) { }
} catch (e) {}
let buildDataMap = {};
try {
@@ -57,34 +57,21 @@
has_max_level: !!buildDataRaw[k].has_max_level
};
}
} catch (e) {
log(`Failed to gather build data: ${e}`);
}
} catch (e) { log(`Failed to gather build data: ${e}`); }
// ---- Storage capacity -----------------------------------------------
// res.storage / res.storage_capacity are always 0 in Grepolis.
// Real capacity lives in GameData keyed by the storage building level.
let storageCapacity = 0;
try {
// Strategy 1: dedicated getter (exists on some server versions)
storageCapacity = town.getStorageCapacity?.() || 0;
// Strategy 2: GameData.buildingData.storage.max_storage[level]
if (!storageCapacity) {
const storageLevel = buildings.storage ?? 0;
const gd = uw.GameData?.buildingData?.storage;
storageCapacity = gd?.max_storage?.[storageLevel]
|| gd?.storage?.[storageLevel]
|| 0;
storageCapacity = gd?.max_storage?.[storageLevel] || gd?.storage?.[storageLevel] || 0;
}
// Strategy 3: resource object fallback keys
if (!storageCapacity) {
storageCapacity = res.capacity || res.storage_capacity || res.storage || 0;
}
} catch (e) {
log(`storage capacity lookup failed: ${e}`);
}
} catch (e) { log(`storage capacity lookup failed: ${e}`); }
// ---- Market / Trade capacity -----------------------------------------
let marketCapacity = 0;
@@ -92,14 +79,10 @@
const marketLevel = buildings.market ?? 0;
const gd = uw.GameData?.buildingData?.market;
marketCapacity = gd?.capacity_per_level?.[marketLevel] || 0;
// Add Trade Office bonus if present
if (buildings.trade_office && buildings.trade_office > 0) {
marketCapacity += (uw.GameData?.buildingData?.trade_office?.capacity_extra_per_level || 500) * marketLevel;
}
} catch (e) {
log(`market capacity lookup failed: ${e}`);
}
} catch (e) { log(`market capacity lookup failed: ${e}`); }
// ---- Coordinates & sea zone -----------------------------------------
let x = null, y = null, sea = null;
@@ -109,7 +92,7 @@
if (typeof x === 'number' && typeof y === 'number') {
sea = Math.floor(x / 100) * 10 + Math.floor(y / 100);
}
} catch (e) { }
} catch (e) {}
// ---- Researches -----------------------------------------------------
let researches = {};
@@ -122,13 +105,10 @@
let unitDataMap = {};
try {
const gdUnits = uw.GameData?.units || {};
for (const u in gdUnits) {
if (u === 'militia') continue;
const reqBuildings = gdUnits[u].building_dependencies || {};
const reqResearch = gdUnits[u].research_dependencies || [];
let missing_deps = {};
for (const reqB in reqBuildings) {
if ((buildings[reqB] || 0) < reqBuildings[reqB]) {
@@ -140,19 +120,11 @@
missing_deps[reqR] = { name: reqR, needed_level: 'Έρευνα' };
}
}
const cost = gdUnits[u].resources || {};
const w = cost.wood || 0;
const s = cost.stone || 0;
const i = cost.iron || 0;
let enough = true;
if (res.wood < w || res.stone < s || res.iron < i) enough = false;
const w = cost.wood || 0, s = cost.stone || 0, i = cost.iron || 0;
let enough = !(res.wood < w || res.stone < s || res.iron < i);
unitDataMap[u] = {
wood: w,
stone: s,
iron: i,
wood: w, stone: s, iron: i,
pop: gdUnits[u].population || 0,
build_time: gdUnits[u].build_time || 0,
enough_resources: enough,
@@ -187,15 +159,13 @@
});
});
}
} catch (e) { }
} catch (e) {}
// ---- Extra town flags -----------------------------------------------
let has_premium = false;
let bonuses = {};
let wonder_points = 0;
try {
has_premium = uw.GameDataPremium?.isAdvisorActivated?.('curator') || false;
} catch (e) { }
} catch (e) {}
return {
town_id: town.id,
@@ -216,17 +186,17 @@
unitData: unitDataMap,
researches,
has_premium,
bonuses,
wonder_points,
bonuses: {},
wonder_points: 0,
alliance_name,
farms,
};
});
return { player, player_id, alliance_id, total_points, world_id: world, towns: townList };
}
}
function pushState() {
function pushState() {
if (paused) return;
try {
const payload = gatherState();
@@ -240,46 +210,35 @@
} catch (e) {
log(`gatherState error: ${e}`);
}
}
}
// ----------------------------------------------------------------
// AJAX Interceptor for Zero-Delay Push
// ----------------------------------------------------------------
let pushTimeout = null;
function debouncedPushState() {
// ---- AJAX Interceptor for Zero-Delay Push ----------------------------
let pushTimeout = null;
function debouncedPushState() {
if (paused) return;
if (pushTimeout) clearTimeout(pushTimeout);
pushTimeout = setTimeout(() => {
log('⚡ State change detected (AJAX). Syncing to Remote...');
pushState();
}, 1200); // Wait 1.2s for memory models to update after AJAX finishes
}
}, 1200);
}
if (uw.$) {
if (uw.$) {
uw.$(document).ajaxComplete(function (e, xhr, opt) {
if (!opt || !opt.url) return;
// Ignore requests to our own bot server or map data
if (opt.url.includes(BASE_URL)) return;
if (opt.url.includes('map_tiles')) return;
// Most game actions use "action=" parameter
// Switching towns uses "switch_town"
if (opt.url.includes('action=') || opt.url.includes('switch_town')) {
debouncedPushState();
}
});
}
}
// ----------------------------------------------------------------
// Report command result back to relay
// ----------------------------------------------------------------
function reportResult(cmdId, status, message) {
// ---- Report command result back to relay -----------------------------
function reportResult(cmdId, status, message) {
fetch(`${BASE_URL}/api/commands/${cmdId}/result`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ status, message })
}).catch(e => log(`reportResult failed: ${e}`));
}
// ----------------------------------------------------------------
}

23
bot_modules/03_captcha.js
View File

@@ -1,10 +1,11 @@
// Captcha detection via MutationObserver
// Watches document.body for #hcaptcha_window being added/removed.
// Confirmed selector from live DOM: DIV#hcaptcha_window > DIV.h-captcha
// ----------------------------------------------------------------
let captchaActive = false;
// ================================================================
// 03_captcha.js — hCaptcha detection & server alert
// Depends on: uw, BASE_URL, log, paused (00_config.js / 01_ui.js)
// ================================================================
function reportCaptcha(detected) {
let captchaActive = false;
function reportCaptcha(detected) {
const player_id = uw.Game?.player_id;
if (!player_id) return;
fetch(`${BASE_URL}/api/captcha/alert?player_id=${player_id}`, {
@@ -12,15 +13,14 @@
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ detected })
}).catch(e => log(`captcha report failed: ${e}`));
}
}
function detectCaptcha() {
function detectCaptcha() {
setInterval(() => {
const win = document.getElementById('hcaptcha_window');
let isVisible = false;
if (win) {
// Check if it's actually visible on screen (not display: none by the game)
const style = window.getComputedStyle(win);
if (style.display !== 'none' && style.visibility !== 'hidden') {
isVisible = true;
@@ -38,11 +38,8 @@
reportCaptcha(true);
} else if (!isVisible && captchaActive) {
captchaActive = false;
// Don't auto-resume — let the user click the button manually
log('✅ Captcha resolved — alert cleared (bot remains paused)');
reportCaptcha(false);
}
}, 1000);
}
// ----------------------------------------------------------------
}

158
bot_modules/04_execute.js
View File

@@ -1,11 +1,12 @@
// Execute: Farm Upgrade / Unlock
// Iterates all farm relations. Locked villages (status 0) get
// unlocked; unlocked villages below max level get upgraded.
// Uses random 800ms–2000ms delay between each action.
// payload.threshold = minimum kill points to keep (default 0)
// ----------------------------------------------------------------
async function executeFarmUpgrade(cmd) {
const threshold = parseInt(cmd.payload?.threshold ?? 0);
// ================================================================
// 04_execute.js — All command executors
// Depends on: uw, BASE_URL, log, sleep, randInt, paused, pushState
// ================================================================
// ----------------------------------------------------------------
// Execute: Farm Upgrade / Unlock
// ----------------------------------------------------------------
async function executeFarmUpgrade(cmd) {
const now = Math.floor(Date.now() / 1000);
let farmModels, relModels;
@@ -35,10 +36,7 @@
return { ok: false, msg: `Cannot build town list: ${e.message}` };
}
let upgraded = 0;
let unlocked = 0;
let skipped = 0;
let errors = 0;
let upgraded = 0, unlocked = 0, skipped = 0, errors = 0;
for (const town_id of polisList) {
const town = uw.ITowns?.towns?.[town_id];
@@ -57,24 +55,17 @@
const level = rel.attributes.expansion_stage || 0;
const expAt = rel.attributes.expansion_at || 0;
// Skip if upgrade already in progress
if (expAt > now) { skipped++; continue; }
// Skip if already max level
if (status === 1 && level >= 5) { skipped++; continue; }
// Skip if locked and we can't unlock (status -1 means enemy)
if (status < 0) { skipped++; continue; }
const isLocked = status === 0;
const action = isLocked ? 'unlock' : 'upgrade';
const requestedAction = cmd.payload?.action_type;
if (requestedAction && requestedAction !== action) {
skipped++; continue;
}
if (requestedAction && requestedAction !== action) { skipped++; continue; }
if (paused) {
return { ok: false, msg: 'Aborted due to pause/captcha' };
}
if (paused) return { ok: false, msg: 'Aborted due to pause/captcha' };
log(`Farm ${action}: farm_id=${farm.attributes.id} level=${level} town=${town_id}`);
try {
@@ -87,24 +78,19 @@
isLocked ? unlocked++ : upgraded++;
} catch (e) { errors++; }
// Random delay between actions: 1200ms – 2500ms
await sleep(randInt(1200, 2500));
}
}
}
pushState(); // refresh farm data after upgrades
pushState();
return { ok: true, msg: `Farm upgrade done: ${unlocked} unlocked, ${upgraded} upgraded, ${skipped} skipped, ${errors} errors` };
}
}
// ----------------------------------------------------------------
// Execute: Farm Loot
// Claims all ready farm towns across all towns that match
// the cmd payload (town_ids list + loot_option).
// Between-claim delay: random 500ms–1500ms (never below 500ms)
// Between-town-group delay: random 30s–90s
// ----------------------------------------------------------------
async function executeFarmLoot(cmd) {
// ----------------------------------------------------------------
// Execute: Farm Loot
// ----------------------------------------------------------------
async function executeFarmLoot(cmd) {
const { loot_option } = cmd.payload || {};
const option = parseInt(loot_option) || 1;
const now = Math.floor(Date.now() / 1000);
@@ -121,7 +107,7 @@
}
// Build island groups using MM (all towns, not just visible)
const islandTownsMap = {}; // island_id -> [town_id1, town_id2]
const islandTownsMap = {};
try {
const allTowns = uw.MM.getCollections().Town[0].models;
for (const town of allTowns) {
@@ -133,13 +119,11 @@
} catch (e) {
return { ok: false, msg: `Cannot build town list: ${e.message}` };
}
const islandList = Object.keys(islandTownsMap);
const islandList = Object.keys(islandTownsMap);
log(`Farm: processing ${islandList.length} islands with option=${option}`);
let claimed = 0;
let skipped = 0;
let errors = 0;
let claimed = 0, skipped = 0, errors = 0;
for (let i = 0; i < islandList.length; i++) {
const island_id = islandList[i];
@@ -161,16 +145,11 @@
}
const res = t.resources?.() || {};
const w = res.wood || 0;
const s = res.stone || 0;
const ir = res.iron || 0;
const w = res.wood || 0, s = res.stone || 0, ir = res.iron || 0;
// If completely full (all 3 resources >= max storage), skip this town
if (storageCapacity > 0 && w >= storageCapacity && s >= storageCapacity && ir >= storageCapacity) {
continue;
}
// Skip completely full towns
if (storageCapacity > 0 && w >= storageCapacity && s >= storageCapacity && ir >= storageCapacity) continue;
// Pick town with most space (lowest total resources)
const total_res = w + s + ir;
if (total_res < lowest_total_res) {
lowest_total_res = total_res;
@@ -188,13 +167,10 @@
const town = uw.ITowns?.towns?.[town_id];
if (!town) { skipped++; continue; }
// Use the same method as the original script
const ix = town.getIslandCoordinateX();
const iy = town.getIslandCoordinateY();
if (ix == null || iy == null) { skipped++; continue; }
// Find ready farms on this island (mirrors original getLootableFarms exactly)
const readyFarms = [];
for (const farm of farmModels) {
if (farm.attributes.island_x !== ix || farm.attributes.island_y !== iy) continue;
@@ -217,10 +193,7 @@
log(`Farm: ${readyFarms.length} ready on island of town ${town_id}`);
for (const farm of readyFarms) {
if (paused) {
return { ok: false, msg: 'Aborted due to pause/captcha' };
}
if (paused) return { ok: false, msg: 'Aborted due to pause/captcha' };
try {
uw.gpAjax.ajaxPost('frontend_bridge', 'execute', {
model_url: `FarmTownPlayerRelation/${farm.relation_id}`,
@@ -231,14 +204,11 @@
claimed++;
} catch (e) { errors++; }
// Random per-claim delay: 1000ms – 2200ms
await sleep(randInt(1000, 2200));
}
// Refresh map icons after claiming (same as original)
try { uw.WMap.removeFarmTownLootCooldownIconAndRefreshLootTimers(); } catch (e) { }
try { uw.WMap.removeFarmTownLootCooldownIconAndRefreshLootTimers(); } catch (e) {}
// Random between-island delay: 30s – 90s (only if more islands remain)
if (i < islandList.length - 1) {
if (paused) return { ok: false, msg: 'Aborted due to pause/captcha' };
const gap = randInt(30000, 90000);
@@ -248,22 +218,18 @@
}
return { ok: true, msg: `Farm done: ${claimed} claimed, ${skipped} islands skipped, ${errors} errors` };
}
}
// ----------------------------------------------------------------
// Execute: Build
// ----------------------------------------------------------------
async function executeBuild(cmd) {
// ----------------------------------------------------------------
// Execute: Build
// ----------------------------------------------------------------
async function executeBuild(cmd) {
const { town_id, payload } = cmd;
const { building_id } = payload;
const town = uw.ITowns?.getTown?.(town_id) || uw.ITowns?.towns?.[town_id];
if (!town) {
return { ok: false, msg: `Town ${town_id} not found in ITowns` };
}
if (!town) return { ok: false, msg: `Town ${town_id} not found in ITowns` };
// Check build queue
const queueLen = town.buildingOrders?.()?.length ?? 0;
const hasCurator = uw.GameDataPremium?.isAdvisorActivated?.('curator');
const maxQueue = hasCurator ? 7 : 2;
@@ -271,7 +237,6 @@
return { ok: false, requeue: true, msg: `Build queue full (${queueLen}/${maxQueue})` };
}
// Check resources
try {
const buildData = uw.MM.getModels?.()?.BuildingBuildData?.[town_id]
?.attributes?.building_data?.[building_id];
@@ -285,11 +250,8 @@
return { ok: false, requeue: true, msg: `Not enough resources for ${building_id}` };
}
}
} catch (e) {
log(`Resource check skipped: ${e}`);
}
} catch (e) { log(`Resource check skipped: ${e}`); }
// Fire the build request — with a human-like reaction delay
const reactionMs = randInt(800, 2500);
log(`Waiting ${reactionMs}ms before firing buildUp (reaction time)...`);
await sleep(reactionMs);
@@ -305,28 +267,24 @@
await sleep(500);
return { ok: true, msg: `buildUp ${building_id} queued` };
}
}
// ----------------------------------------------------------------
// Execute: Recruit
// ----------------------------------------------------------------
async function executeRecruit(cmd) {
// ----------------------------------------------------------------
// Execute: Recruit
// ----------------------------------------------------------------
async function executeRecruit(cmd) {
const { town_id, payload } = cmd;
const { unit_id, amount } = payload;
const town = uw.ITowns?.getTown?.(town_id) || uw.ITowns?.towns?.[town_id];
if (!town) {
return { ok: false, msg: `Town ${town_id} not found` };
}
if (!town) return { ok: false, msg: `Town ${town_id} not found` };
// Determine endpoint based on unit type
const navalUnits = [
'big_transporter', 'small_transporter', 'bireme',
'attack_ship', 'trireme', 'colonize_ship', 'sea_monster'
];
const endpoint = navalUnits.includes(unit_id) ? 'building_docks' : 'building_barracks';
// Fire the recruit request — with a human-like reaction delay
const reactionMs = randInt(800, 2500);
log(`Waiting ${reactionMs}ms before firing recruit (reaction time)...`);
await sleep(reactionMs);
@@ -341,19 +299,17 @@
await sleep(500);
return { ok: true, msg: `Recruit ${amount}x ${unit_id} submitted` };
}
}
// ----------------------------------------------------------------
// Execute: Market
// ----------------------------------------------------------------
async function executeMarketOffer(cmd) {
// ----------------------------------------------------------------
// Execute: Market Offer
// ----------------------------------------------------------------
async function executeMarketOffer(cmd) {
const { town_id, payload } = cmd;
const { offer, offer_type, demand, demand_type, max_delivery_time, visibility } = payload;
const town = uw.ITowns?.getTown?.(town_id) || uw.ITowns?.towns?.[town_id];
if (!town) {
return { ok: false, msg: `Town ${town_id} not found` };
}
if (!town) return { ok: false, msg: `Town ${town_id} not found` };
const reactionMs = randInt(800, 2500);
log(`Waiting ${reactionMs}ms before firing market offer (reaction time)...`);
@@ -365,26 +321,22 @@
model_url: 'CreateOffers/' + town_id,
action_name: 'createOffer',
captcha: null,
arguments: {
offer, offer_type, demand, demand_type, max_delivery_time, visibility
}
arguments: { offer, offer_type, demand, demand_type, max_delivery_time, visibility }
});
await sleep(500);
return { ok: true, msg: `Market offer posted: ${offer} ${offer_type} => ${demand} ${demand_type}` };
}
}
// ----------------------------------------------------------------
// Execute: Research (Academy)
// ----------------------------------------------------------------
async function executeResearch(cmd) {
// ----------------------------------------------------------------
// Execute: Research (Academy)
// ----------------------------------------------------------------
async function executeResearch(cmd) {
const { town_id, payload } = cmd;
const { research_id } = payload;
const town = uw.ITowns?.getTown?.(town_id) || uw.ITowns?.towns?.[town_id];
if (!town) {
return { ok: false, msg: `Town ${town_id} not found` };
}
if (!town) return { ok: false, msg: `Town ${town_id} not found` };
const reactionMs = randInt(800, 2500);
log(`Waiting ${reactionMs}ms before firing research (reaction time)...`);
@@ -396,11 +348,9 @@
model_url: 'ResearchOrder',
action_name: 'research',
arguments: { id: research_id },
town_id: town_id
town_id
});
await sleep(500);
return { ok: true, msg: `Research ${research_id} queued` };
}
// ----------------------------------------------------------------
}

47
bot_modules/05_main.js
View File

@@ -1,6 +1,9 @@
// Poll for and execute pending commands (build + recruit + market)
// ----------------------------------------------------------------
async function pollAndExecute() {
// ================================================================
// 05_main.js — Poll loop, command dispatch, boot
// Depends on: everything above
// ================================================================
async function pollAndExecute() {
if (paused) return;
const player_id = uw.Game?.player_id;
if (!player_id) return;
@@ -14,7 +17,6 @@
return;
}
// Build queue, Recruit queue and Market queue are independent
const buildCmd = cmdData.build;
const recruitCmd = cmdData.recruit;
const marketCmd = cmdData.market;
@@ -22,8 +24,6 @@
const farmCmd = cmdData.farm;
const farmUpgradeCmd = cmdData.farm_upgrade;
if (cmdData.sync_requested) {
log('Sync requested by server — pushing state immediately');
pushState();
@@ -49,6 +49,7 @@
} catch (e) {
result = { ok: false, msg: `Exception: ${e}` };
}
const finalStatus = result.requeue ? 'pending' : (result.ok ? 'done' : 'failed');
log(`Command #${cmd.id}: ${finalStatus === 'done' ? '✅' : finalStatus === 'pending' ? '⏳' : '❌'} ${result.msg}`);
reportResult(cmd.id, finalStatus, result.msg);
@@ -66,7 +67,6 @@
const farmSettings = cmdData.farm_settings || {};
if (farmSettings.enabled && !farmCmd) {
const nowTs = Math.floor(Date.now() / 1000);
// Check if ANY farm relation is ready
let readyFarms = [];
try {
const coll = uw.MM.getOnlyCollectionByName('FarmTownPlayerRelation');
@@ -77,11 +77,9 @@
} catch (e) { /* silent */ }
if (readyFarms.length > 0) {
// Check if the CURRENT town's warehouse is full (>95%)
let allFull = true;
let claimedAny = false;
// Iterate over all towns that have ready farms
const towns = Object.values(uw.ITowns?.towns || {});
for (const town of towns) {
const storage = town.resources?.()?.storage || town.get?.('storage') || 0;
@@ -94,55 +92,46 @@
const pct = maxRes / storage;
if (pct < 0.95) {
// This town has room — loot using its town_id context
allFull = false;
log(`⚡ Auto-farm: looting into town ${town.get?.('name')} (${Math.round(pct*100)}% full)`);
log(`⚡ Auto-farm: looting into town ${town.get?.('name')} (${Math.round(pct * 100)}% full)`);
await executeFarmLoot({ payload: { loot_option: farmSettings.loot_option } });
claimedAny = true;
pushState();
break; // one loot pass is enough per poll cycle
break;
}
}
if (allFull) {
log('⚠️ Auto-farm: ALL warehouses are full (>95%) — skipping loot this cycle');
// Report full status to backend so farm.html can show notice
try {
await fetch(`${BASE_URL}/api/farm_status?player_id=${uw.Game.player_id}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ warehouse_full: true })
});
} catch(e) {}
} catch (e) {}
} else if (claimedAny) {
// Clear the full flag
try {
await fetch(`${BASE_URL}/api/farm_status?player_id=${uw.Game.player_id}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ warehouse_full: false })
});
} catch(e) {}
}
} catch (e) {}
}
}
}
}
// ----------------------------------------------------------------
// Boot
// ----------------------------------------------------------------
window.addEventListener('load', () => {
log('Grepolis Remote Control v3.5.9 loaded');
// ----------------------------------------------------------------
// Boot
// ----------------------------------------------------------------
window.addEventListener('load', () => {
log('Grepolis Remote Control v4.0.0 (remote) loaded');
// Start captcha watcher immediately
detectCaptcha();
// Push state once after load, then heartbeat every 1-2 minutes
// The AJAX interceptor handles the real-time syncing!
setTimeout(pushState, 5000);
jitterLoop(pushState, 60000, 120000);
// Poll for commands every 8–18 seconds (randomized jitter)
jitterLoop(pollAndExecute, 8000, 18000);
});
});