675 lines
42 KiB
JavaScript
675 lines
42 KiB
JavaScript
"use strict";
|
||
|
||
const fs = require("fs");
|
||
const vm = require("vm");
|
||
const path = require("path");
|
||
|
||
const source = fs.readFileSync(path.join(__dirname, "..", "js", "achievements.js"), "utf8");
|
||
|
||
class ClassList {
|
||
constructor() { this.values = new Set(["hidden"]); }
|
||
add(...names) { names.forEach(name => this.values.add(name)); }
|
||
remove(...names) { names.forEach(name => this.values.delete(name)); }
|
||
contains(name) { return this.values.has(name); }
|
||
toggle(name, force) {
|
||
const next = force === undefined ? !this.values.has(name) : Boolean(force);
|
||
if (next) this.values.add(name); else this.values.delete(name);
|
||
return next;
|
||
}
|
||
}
|
||
class Element {
|
||
constructor(id = "", tagName = "div") {
|
||
this.tagName = String(tagName || "div").toUpperCase();
|
||
this.open = false;
|
||
this.id = id;
|
||
this.className = "";
|
||
this.classList = new ClassList();
|
||
this.dataset = {};
|
||
this.styles = new Map();
|
||
this.style = {
|
||
setProperty: (name, value) => this.styles.set(name, value),
|
||
removeProperty: name => this.styles.delete(name),
|
||
};
|
||
this.children = [];
|
||
this.textContent = "";
|
||
this.tabIndex = -1;
|
||
this.isConnected = true;
|
||
}
|
||
append(...children) { this.children.push(...children); }
|
||
replaceChildren(...children) { this.children = children; }
|
||
setAttribute() {}
|
||
addEventListener() {}
|
||
focus() {}
|
||
getBoundingClientRect() { return { left: 0, top: 0, width: 100, height: 30 }; }
|
||
get offsetWidth() { return 100; }
|
||
}
|
||
|
||
function createHarness(existingStorage = null, search = "", options = {}) {
|
||
const storage = existingStorage || new Map();
|
||
const elements = new Map();
|
||
const ids = [
|
||
"achievementsBtn", "achievementButtonCount", "achievementsDialog", "achievementDialogCount",
|
||
"achievementsCloseBtn", "achievementsCloseIconBtn", "achievementRefreshBtn", "achievementResetBtn", "achievementUnlockAllBtn",
|
||
"achievementList", "achievementSharedStatus", "achievementToast", "achievementToastTitle", "pauseBtn",
|
||
];
|
||
ids.forEach(id => elements.set(id, new Element(id)));
|
||
elements.get("achievementsDialog").classList.add("hidden");
|
||
elements.get("achievementToast").classList.add("hidden");
|
||
let timerId = 0;
|
||
const context = {
|
||
console, Date, Intl, Math, JSON, Object, Array, Map, Set, WeakMap, Promise,
|
||
Number, String, Boolean, Error, AbortController, encodeURIComponent, URLSearchParams,
|
||
location: { protocol: options.protocol || "file:", search },
|
||
crypto: { randomUUID: () => "11111111-1111-4111-8111-111111111111" },
|
||
localStorage: {
|
||
getItem(key) { return storage.has(key) ? storage.get(key) : null; },
|
||
setItem(key, value) { storage.set(key, String(value)); },
|
||
removeItem(key) { storage.delete(key); },
|
||
},
|
||
document: {
|
||
hidden: false,
|
||
getElementById(id) { return elements.get(id) || null; },
|
||
createElement(tagName) { return new Element("", tagName); },
|
||
addEventListener() {},
|
||
},
|
||
TarinaiEvents: { emit() {} },
|
||
showToast() {},
|
||
audio: { uiClick() {} },
|
||
setTimeout() { timerId += 1; return timerId; },
|
||
clearTimeout() {},
|
||
setInterval() { timerId += 1; return timerId; },
|
||
clearInterval() {},
|
||
fetch: options.fetch || (async () => { throw new Error("offline"); }),
|
||
TARINAI_VERSION: "39.16.65",
|
||
TarinaiGameDialogs: { confirm: async () => true },
|
||
};
|
||
context.window = context;
|
||
context.globalThis = context;
|
||
vm.createContext(context);
|
||
vm.runInContext(source, context, { filename: "achievements.js" });
|
||
return { context, api: context.TarinaiAchievements, storage, elements };
|
||
}
|
||
|
||
function assert(condition, message) { if (!condition) throw new Error(message); }
|
||
function unlocked(h, id) { return h.api.isUnlocked(id); }
|
||
|
||
const expectedIds = [
|
||
"first_birth", "natural_zunchi_slave", "natural_tarinai_king", "self_zunchi_death",
|
||
"natural_zunchi_slave_5_generations", "natural_tarinai_king_3_generations",
|
||
"death_50_in_10_seconds", "birth_50_in_60_seconds", "great_mother_1000_births", "lifespan_completed",
|
||
"soccer_ball_death", "fight_pair_danger_kill", "all_non_sleep_diseased_25", "colony_happy", "direct_feed_33",
|
||
"ignite_during_birth_ritual", "laxative_starvation", "idle_observer_5_minutes",
|
||
"placed_objects_100", "mechanized_industry", "safe_colony_25_5_minutes",
|
||
"ants_alive_25", "ants_killed_100", "secret_collection_9_slots",
|
||
"pause_spam_4_in_1_second", "continuous_play_1_hour", "below_absolute_zero_item",
|
||
"undo_mass_revival", "robot_cleaner_100", "held_30_seconds", "minimalist_happy",
|
||
"overprotective", "self_sufficient", "unplanned_city_30", "sauna_cold_plunge",
|
||
"rain_shelter_all", "medicine_ledger_all", "mercury_lifespan", "enemy_enemy_friend",
|
||
"revolution", "fuel_to_fire", "undo_20", "redo_20",
|
||
"eternal_history_generation_10", "king_full_satisfaction", "slave_zero_satisfaction", "town_doctor_50", "poke_plushie_fling",
|
||
"chaos_seeker_666_fights", "clean_freak_robot_only", "true_tarinai_observer",
|
||
"sniper_333_shots", "megalopolis", "fertility_seeker_721_love_births",
|
||
"low_fps_single_digit", "continuous_play_24_hours", "sandbox_five_toilets",
|
||
"park_ground_changed", "ground_change_4_in_1_second",
|
||
"ant_nest_without_tarinai", "sticky_bomb_15_passes",
|
||
"daily_play_7_days", "wire_shock_7_tarinai", "information_industry",
|
||
];
|
||
|
||
(async function run() {
|
||
let h = createHarness();
|
||
let storage;
|
||
assert(h.api.definitions.length === 64, "definition count must be 64");
|
||
assert(JSON.stringify(h.api.definitions.map(d => d.id)) === JSON.stringify(expectedIds), "definition IDs mismatch");
|
||
const categorizedIds = h.api.categories.flatMap(category => category.ids);
|
||
assert(categorizedIds.length === expectedIds.length, "achievement category count mismatch");
|
||
assert(new Set(categorizedIds).size === expectedIds.length, "achievement category contains duplicates");
|
||
assert(expectedIds.every(id => categorizedIds.includes(id)), "achievement category misses an ID");
|
||
h.api.open();
|
||
const titles = Object.fromEntries(h.api.definitions.map(def => [def.id, def.title]));
|
||
assert(titles.natural_zunchi_slave === "ずんちどれい", "slave title mismatch");
|
||
assert(titles.natural_tarinai_king === "たりない王", "king title mismatch");
|
||
assert(titles.self_zunchi_death === "あぁ＾～ たまらねぇぜ", "self-zunchi title mismatch");
|
||
assert(titles.natural_zunchi_slave_5_generations === "末代までの恥", "five-generation title mismatch");
|
||
assert(titles.natural_tarinai_king_3_generations === "華麗なる王族", "three-generation title mismatch");
|
||
assert(titles.death_50_in_10_seconds === "6番目の大量絶滅", "mass-extinction title mismatch");
|
||
assert(titles.birth_50_in_60_seconds === "ベビーブーム", "baby-boom title mismatch");
|
||
assert(titles.idle_observer_5_minutes === "監視カメラ", "observer title mismatch");
|
||
assert(titles.laxative_starvation === "内臓全部出た", "laxative title mismatch");
|
||
assert(titles.colony_happy === "管理された楽園", "happy colony title mismatch");
|
||
assert(titles.soccer_ball_death === "豆野、殺ッカーやろうぜ！", "soccer title mismatch");
|
||
assert(titles.ants_alive_25 === "アリの惑星", "ant planet title mismatch");
|
||
assert(titles.all_non_sleep_diseased_25 === "緊急事態宣言", "emergency title mismatch");
|
||
assert(titles.secret_collection_9_slots === "秘密のコレクション", "save-slot title mismatch");
|
||
assert(titles.pause_spam_4_in_1_second === "何やってるの？", "pause-spam title mismatch");
|
||
assert(titles.continuous_play_1_hour === "めっちゃたりない観察", "continuous-play title mismatch");
|
||
assert(titles.below_absolute_zero_item === "物理法則を下側に超越", "absolute-zero title mismatch");
|
||
assert(titles.ignite_during_birth_ritual === "燃え上がる恋", "ritual ignition title mismatch");
|
||
assert(titles.safe_colony_25_5_minutes === "安全第一", "safe colony title mismatch");
|
||
assert(titles.great_mother_1000_births === "大いなる母", "great mother title mismatch");
|
||
assert(titles.fight_pair_danger_kill === "喧嘩両成敗", "fight-pair title mismatch");
|
||
assert(titles.direct_feed_33 === "餌やりじいさん", "feeding title mismatch");
|
||
assert(titles.eternal_history_generation_10 === "悠久の歴史", "generation title mismatch");
|
||
assert(titles.king_full_satisfaction === "五体満足", "king effect title mismatch");
|
||
assert(titles.slave_zero_satisfaction === "零体満足", "slave effect title mismatch");
|
||
assert(titles.chaos_seeker_666_fights === "混沌ヲ希求スル者", "chaos seeker title mismatch");
|
||
assert(titles.clean_freak_robot_only === "潔癖症", "clean freak title mismatch");
|
||
assert(titles.true_tarinai_observer === "真・たりない観察", "completionist title mismatch");
|
||
assert(titles.sniper_333_shots === "狙撃手", "sniper title mismatch");
|
||
assert(titles.megalopolis === "メガロポリス", "megalopolis title mismatch");
|
||
assert(titles.fertility_seeker_721_love_births === "豊穣ヲ希求スル者", "fertility title mismatch");
|
||
assert(titles.low_fps_single_digit === "スペックがたりない", "low-fps title mismatch");
|
||
assert(titles.continuous_play_24_hours === "寝ろ", "24-hour title mismatch");
|
||
assert(titles.sandbox_five_toilets === "砂場", "sandbox title mismatch");
|
||
assert(titles.park_ground_changed === "そこ公共空間だよ？", "park-ground title mismatch");
|
||
assert(titles.ground_change_4_in_1_second === "破格の工事費用", "ground-spam title mismatch");
|
||
assert(titles.ant_nest_without_tarinai === "アリ観察", "ant observation title mismatch");
|
||
assert(titles.sticky_bomb_15_passes === "命のバトン", "sticky-bomb relay title mismatch");
|
||
assert(titles.daily_play_7_days === "毎日たりない観察", "daily observation title mismatch");
|
||
assert(titles.wire_shock_7_tarinai === "抵抗器じゃない", "wire shock title mismatch");
|
||
const descriptions = Object.fromEntries(h.api.definitions.map(def => [def.id, def.description]));
|
||
assert(descriptions.natural_zunchi_slave === "ずんちどれいが出現する。", "slave description mismatch");
|
||
assert(descriptions.natural_tarinai_king === "たりない王が出現する。", "king description mismatch");
|
||
assert(descriptions.self_zunchi_death === "おしり鋲を抜いた時、自分のずんちで自爆する。", "self-zunchi description mismatch");
|
||
assert(descriptions.natural_zunchi_slave_5_generations === "5代連続でずんちどれい（鎖なし）", "five-generation description mismatch");
|
||
assert(descriptions.natural_tarinai_king_3_generations === "3代連続でたりない王（王冠なし）", "three-generation description mismatch");
|
||
assert(descriptions.great_mother_1000_births.includes("3333体"), "great mother description threshold mismatch");
|
||
assert(descriptions.robot_cleaner_100.includes("200個"), "cleaner description threshold mismatch");
|
||
assert(descriptions.minimalist_happy.includes("6日目以降"), "minimalist start-day description mismatch");
|
||
assert(descriptions.chaos_seeker_666_fights.includes("けんか餅") && descriptions.chaos_seeker_666_fights.includes("666回"), "chaos seeker description mismatch");
|
||
assert(descriptions.sniper_333_shots.includes("333発"), "sniper description mismatch");
|
||
assert(descriptions.megalopolis.includes("10個") && descriptions.megalopolis.includes("15個") && descriptions.megalopolis.includes("100体"), "megalopolis description mismatch");
|
||
assert(descriptions.fertility_seeker_721_love_births.includes("へこ餅") && descriptions.fertility_seeker_721_love_births.includes("721回"), "fertility description mismatch");
|
||
assert(descriptions.idle_observer_5_minutes === "5分間画面を見るだけ", "observer description mismatch");
|
||
assert(descriptions.safe_colony_25_5_minutes.includes("寿命以外で"), "safe-colony lifespan exclusion description mismatch");
|
||
assert(descriptions.pause_spam_4_in_1_second.includes("何もない部分"), "empty-click description mismatch");
|
||
assert(descriptions.low_fps_single_digit === "fpsを1桁にする。", "low-fps description mismatch");
|
||
assert(descriptions.park_ground_changed === "公園の地面を勝手に変更する。", "park-ground description mismatch");
|
||
assert(descriptions.ground_change_4_in_1_second === "地面を変えすぎて破産する。", "ground-spam description mismatch");
|
||
assert(descriptions.sauna_cold_plunge === "暑すぎる状態になったたりないを、15秒以内に寒すぎる状態にする。", "sauna description mismatch");
|
||
assert(descriptions.ant_nest_without_tarinai === "アリの巣があるが、たりないがいない。", "ant observation description mismatch");
|
||
assert(descriptions.sticky_bomb_15_passes === "粘着ボムを爆発までに15回以上パスする。", "sticky-bomb relay description mismatch");
|
||
assert(!source.includes("TarinaiTooltips"), "achievement tooltips were not removed");
|
||
assert(source.includes("PRE_UNLOCK_DESCRIPTION_IDS"), "pre-unlock disclosure allowlist is missing");
|
||
function walk(node, out = []) { for (const child of node?.children || []) { out.push(child); walk(child, out); } return out; }
|
||
const cards = walk(h.elements.get("achievementList")).filter(node => node.dataset?.achievementId);
|
||
const firstBirthCard = cards.find(node => node.dataset.achievementId === "first_birth");
|
||
const disclosedSlaveCard = cards.find(node => node.dataset.achievementId === "natural_zunchi_slave");
|
||
const disclosedKingCard = cards.find(node => node.dataset.achievementId === "natural_tarinai_king");
|
||
const disclosedRevolutionCard = cards.find(node => node.dataset.achievementId === "revolution");
|
||
const disclosedLaxativeCard = cards.find(node => node.dataset.achievementId === "laxative_starvation");
|
||
const eternalHistoryCard = cards.find(node => node.dataset.achievementId === "eternal_history_generation_10");
|
||
const lowFpsCard = cards.find(node => node.dataset.achievementId === "low_fps_single_digit");
|
||
const sleepCard = cards.find(node => node.dataset.achievementId === "continuous_play_24_hours");
|
||
const hiddenCard = cards.find(node => node.dataset.achievementId === "self_zunchi_death");
|
||
assert(firstBirthCard.children[1].children[0].children[1].textContent === descriptions.first_birth, "disclosed locked condition is not shown in the UI");
|
||
for (const card of [disclosedSlaveCard, disclosedKingCard, disclosedRevolutionCard, disclosedLaxativeCard, eternalHistoryCard, lowFpsCard, sleepCard]) {
|
||
assert(card.children[1].children[0].children[1].textContent !== "？？？", "requested pre-unlock condition is hidden");
|
||
}
|
||
assert(hiddenCard.children[1].children[0].children[1].textContent === "？？？", "undisclosed locked condition is not hidden as question marks");
|
||
const groups = h.elements.get("achievementList").children;
|
||
assert(groups.length === 4, "achievement UI must contain exactly four category groups");
|
||
assert(JSON.stringify(groups.map(group => group.dataset.achievementGroup)) === JSON.stringify(["ecology", "experiment", "construction", "operation"]), "achievement category order mismatch");
|
||
assert(groups.every(group => group.tagName === "DETAILS"), "achievement categories are not collapsible details");
|
||
const categoryTitles = h.api.categories.map(category => category.title);
|
||
assert(JSON.stringify(categoryTitles) === JSON.stringify(["生態", "実験", "建築", "その他"]), "achievement category titles mismatch");
|
||
const operationIds = h.api.categories.find(category => category.id === "operation").ids;
|
||
assert(JSON.stringify(operationIds.slice(-2)) === JSON.stringify(["continuous_play_1_hour", "true_tarinai_observer"]), "observation achievements are not at the bottom of その他");
|
||
h.api.unlock("natural_zunchi_slave");
|
||
const rerenderedGroups = h.elements.get("achievementList").children;
|
||
const ecologyCards = walk(rerenderedGroups[0]).filter(node => node.dataset?.achievementId);
|
||
const allRenderedCards = rerenderedGroups.flatMap(group => walk(group).filter(node => node.dataset?.achievementId));
|
||
assert(ecologyCards[0]?.dataset.achievementId === "natural_zunchi_slave", "unlocked achievement was not moved to the top of its category");
|
||
assert(allRenderedCards.filter(card => card.dataset.achievementId === "natural_zunchi_slave").length === 1, "unlocked achievement is duplicated across categories");
|
||
assert(await h.api.reset(), "in-game achievement reset confirmation was not accepted");
|
||
assert(!h.api.isUnlocked("natural_zunchi_slave"), "achievement reset did not clear unlocked state");
|
||
assert(source.includes('card.style.setProperty("--achievement-rate"'), "achievement percentage bar is not wired");
|
||
|
||
h = createHarness();
|
||
h.api.recordBirth({ world: { time: 0 } });
|
||
assert(unlocked(h, "first_birth"), "first birth did not unlock");
|
||
|
||
h = createHarness();
|
||
const birthWorld = { time: 0 };
|
||
for (let i = 0; i < 29; i += 1) { birthWorld.time = i; h.api.recordBirth({ world: birthWorld }); }
|
||
assert(!unlocked(h, "birth_50_in_60_seconds"), "rapid birth unlocked before 30");
|
||
birthWorld.time = 59;
|
||
h.api.recordBirth({ world: birthWorld });
|
||
assert(unlocked(h, "birth_50_in_60_seconds"), "rapid birth did not unlock at 30");
|
||
|
||
storage = new Map();
|
||
h = createHarness(storage);
|
||
for (let i = 0; i < 2000; i += 1) h.api.recordBirth({ world: { time: i % 61 } });
|
||
assert(!unlocked(h, "great_mother_1000_births"), "great mother unlocked before 3333");
|
||
h = createHarness(storage);
|
||
for (let i = 0; i < 1332; i += 1) h.api.recordBirth({ world: { time: i % 61 } });
|
||
assert(!unlocked(h, "great_mother_1000_births"), "great mother unlocked at 3332");
|
||
h.api.recordBirth({ world: { time: 1 } });
|
||
assert(unlocked(h, "great_mother_1000_births"), "great mother did not persist to 3333");
|
||
|
||
h = createHarness();
|
||
const deathWorld = { time: 0 };
|
||
for (let i = 0; i < 49; i += 1) { deathWorld.time = i * 0.19; h.api.recordDeath({ world: deathWorld, reason: "accident" }); }
|
||
assert(!unlocked(h, "death_50_in_10_seconds"), "rapid death unlocked before 50");
|
||
deathWorld.time = 9.5;
|
||
h.api.recordDeath({ world: deathWorld, reason: "accident" });
|
||
assert(unlocked(h, "death_50_in_10_seconds"), "rapid death did not unlock at 50");
|
||
|
||
h = createHarness();
|
||
h.api.recordDeath({ world: { time: 1 }, tarinai: {}, reason: "天寿を全うした" });
|
||
assert(unlocked(h, "lifespan_completed"), "lifespan did not unlock");
|
||
h = createHarness();
|
||
h.api.recordDeath({ world: { time: 1 }, tarinai: { _achievementLaxativeActiveThisFrame: true }, reason: "飢餓" });
|
||
assert(unlocked(h, "laxative_starvation"), "laxative starvation did not unlock");
|
||
|
||
h = createHarness();
|
||
const slaveWorld = {};
|
||
[1, 2, 4, 5, 6].forEach(generation => h.api.recordNaturalZunchiSlave({ world: slaveWorld, tarinai: { generation } }));
|
||
assert(!unlocked(h, "natural_zunchi_slave_5_generations"), "slave run ignored generation gap");
|
||
h.api.recordNaturalZunchiSlave({ world: slaveWorld, tarinai: { generation: 3 } });
|
||
assert(unlocked(h, "natural_zunchi_slave_5_generations"), "slave five-generation run did not unlock");
|
||
|
||
h = createHarness();
|
||
const kingWorld = {};
|
||
[4, 5, 6].forEach(generation => h.api.recordNaturalTarinaiKing({ world: kingWorld, tarinai: { generation } }));
|
||
assert(unlocked(h, "natural_tarinai_king_3_generations"), "king three-generation run did not unlock");
|
||
|
||
h = createHarness();
|
||
const feedWorldA = { time: 0, achievementDirectFeedCount: 0 };
|
||
for (let i = 0; i < 32; i += 1) h.api.recordDirectFeed({ world: feedWorldA });
|
||
assert(!unlocked(h, "direct_feed_33"), "direct feed unlocked before 33");
|
||
const feedWorldB = { time: 0, achievementDirectFeedCount: 0 };
|
||
h.api.recordDirectFeed({ world: feedWorldB });
|
||
assert(!unlocked(h, "direct_feed_33"), "direct-feed count survived a field reset");
|
||
h.api.recordDirectFeed({ world: feedWorldA });
|
||
assert(unlocked(h, "direct_feed_33"), "direct feed did not unlock at 33 in one field");
|
||
|
||
h = createHarness();
|
||
const diseased = Array.from({ length: 25 }, () => ({ fightDisease: true, dead: false }));
|
||
h.api.evaluateWorld({ tarinai: diseased, ants: [], time: 0 }, { id: "relaxed" });
|
||
assert(unlocked(h, "all_non_sleep_diseased_25"), "disease colony did not unlock");
|
||
h = createHarness();
|
||
const happyWorld = { tarinai: [{ dead: false }], ants: [], items: [], time: 600, day: 6 };
|
||
h.api.evaluateWorld(happyWorld, { id: "happy" });
|
||
happyWorld.time = 719.99;
|
||
h.api.evaluateWorld(happyWorld, { id: "happy" });
|
||
assert(!unlocked(h, "colony_happy"), "happy colony unlocked before one day");
|
||
happyWorld.time = 720;
|
||
h.api.evaluateWorld(happyWorld, { id: "happy" });
|
||
assert(unlocked(h, "colony_happy"), "happy colony did not unlock after one day from day 6");
|
||
|
||
h = createHarness();
|
||
const interruptedHappyWorld = { tarinai: [{ dead: false }], ants: [], items: [], time: 600, day: 6 };
|
||
h.api.evaluateWorld(interruptedHappyWorld, { id: "happy" });
|
||
interruptedHappyWorld.time = 650;
|
||
h.api.evaluateWorld(interruptedHappyWorld, { id: "normal" });
|
||
interruptedHappyWorld.time = 700;
|
||
h.api.evaluateWorld(interruptedHappyWorld, { id: "happy" });
|
||
interruptedHappyWorld.time = 819.99;
|
||
h.api.evaluateWorld(interruptedHappyWorld, { id: "happy" });
|
||
assert(!unlocked(h, "colony_happy"), "interrupted happiness did not restart the one-day timer");
|
||
interruptedHappyWorld.time = 820;
|
||
h.api.evaluateWorld(interruptedHappyWorld, { id: "happy" });
|
||
assert(unlocked(h, "colony_happy"), "happy colony did not unlock one full day after restart");
|
||
|
||
h = createHarness();
|
||
h.api.recordIgnition({});
|
||
h.api.recordSelfZunchiDeath({});
|
||
h.api.recordSoccerBallDeath({});
|
||
assert(unlocked(h, "ignite_during_birth_ritual"), "ritual ignition failed");
|
||
assert(unlocked(h, "self_zunchi_death"), "self zunchi failed");
|
||
assert(unlocked(h, "soccer_ball_death"), "soccer death failed");
|
||
|
||
|
||
h = createHarness();
|
||
const dangerItem = { id: "danger-1", type: "firecracker", roles: { danger: true } };
|
||
const fighterA = { id: "a", dead: true, fightTimer: 2, fightTargetId: "b", fightTargetIds: ["b"] };
|
||
const fighterB = { id: "b", dead: false, fightTimer: 2, fightTargetId: "a", fightTargetIds: ["a"] };
|
||
const fightWorld = {
|
||
time: 5,
|
||
tarinai: [fighterA, fighterB],
|
||
fightPairKey(a, b) { return [a.id, b.id].sort().join(":"); },
|
||
isAlreadyFightingPair() { return true; },
|
||
};
|
||
fighterA.world = fightWorld; fighterB.world = fightWorld;
|
||
h.api.recordDamageSource(fighterA, dangerItem, { world: fightWorld });
|
||
h.api.recordDeath({ world: fightWorld, tarinai: fighterA, reason: "爆竹", fromDamage: true });
|
||
assert(!unlocked(h, "fight_pair_danger_kill"), "fight pair unlocked after only one death");
|
||
fightWorld.time = 6;
|
||
fighterB.dead = true; fighterB.fightTimer = 0; fighterB.fightTargetId = null; fighterB.fightTargetIds = [];
|
||
h.api.recordDamageSource(fighterB, dangerItem, { world: fightWorld });
|
||
h.api.recordDeath({ world: fightWorld, tarinai: fighterB, reason: "爆竹", fromDamage: true });
|
||
assert(unlocked(h, "fight_pair_danger_kill"), "fight pair danger kill did not unlock");
|
||
|
||
h = createHarness();
|
||
const falsePositiveA = { id: "fa", dead: true, fightTimer: 2, fightTargetId: "fb", fightTargetIds: ["fb"] };
|
||
const falsePositiveB = { id: "fb", dead: false, fightTimer: 2, fightTargetId: "fa", fightTargetIds: ["fa"] };
|
||
const falsePositiveWorld = {
|
||
time: 3,
|
||
tarinai: [falsePositiveA, falsePositiveB],
|
||
fightPairKey(a, b) { return [a.id, b.id].sort().join(":"); },
|
||
isAlreadyFightingPair() { return true; },
|
||
};
|
||
falsePositiveA.world = falsePositiveWorld; falsePositiveB.world = falsePositiveWorld;
|
||
h.api.recordDamageSource(falsePositiveA, dangerItem, { world: falsePositiveWorld });
|
||
h.api.recordDeath({ world: falsePositiveWorld, tarinai: falsePositiveA, reason: "飢餓", fromDamage: false });
|
||
falsePositiveWorld.time = 4;
|
||
falsePositiveB.dead = true;
|
||
h.api.recordDamageSource(falsePositiveB, dangerItem, { world: falsePositiveWorld });
|
||
h.api.recordDeath({ world: falsePositiveWorld, tarinai: falsePositiveB, reason: "爆竹", fromDamage: true });
|
||
assert(!unlocked(h, "fight_pair_danger_kill"), "non-lethal danger damage was misclassified as a danger kill");
|
||
|
||
h = createHarness();
|
||
const generationWorld = { time: 0, maxGeneration: 9 };
|
||
h.api.recordBirth({ world: generationWorld, child: { generation: 9, world: generationWorld } });
|
||
assert(!unlocked(h, "eternal_history_generation_10"), "generation history unlocked before generation 10");
|
||
generationWorld.maxGeneration = 10;
|
||
h.api.recordBirth({ world: generationWorld, child: { generation: 10, world: generationWorld } });
|
||
assert(unlocked(h, "eternal_history_generation_10"), "generation history did not unlock at generation 10");
|
||
|
||
h = createHarness();
|
||
const king = { dead: false, isTarinaiChampion: true, isZunchiSlave: false, powerItemMode: "protein", sizeItemMode: "", world: {} };
|
||
h.api.recordConsumableUse({ tarinai: king, world: king.world, type: "protein" });
|
||
assert(!unlocked(h, "king_full_satisfaction"), "king satisfaction unlocked without giant drug");
|
||
king.sizeItemMode = "giant_drug";
|
||
h.api.recordConsumableUse({ tarinai: king, world: king.world, type: "giant_drug" });
|
||
assert(unlocked(h, "king_full_satisfaction"), "king satisfaction did not unlock with both effects");
|
||
|
||
h = createHarness();
|
||
const slave = { dead: false, isTarinaiChampion: false, isZunchiSlave: true, powerItemMode: "niteropu", sizeItemMode: "", world: {} };
|
||
h.api.recordConsumableUse({ tarinai: slave, world: slave.world, type: "niteropu" });
|
||
assert(!unlocked(h, "slave_zero_satisfaction"), "slave satisfaction unlocked without dwarf drug");
|
||
slave.sizeItemMode = "dwarf_drug";
|
||
h.api.recordConsumableUse({ tarinai: slave, world: slave.world, type: "dwarf_drug" });
|
||
assert(unlocked(h, "slave_zero_satisfaction"), "slave satisfaction did not unlock with both effects");
|
||
|
||
h = createHarness();
|
||
const allExceptCompletionist = expectedIds.filter(id => id !== "true_tarinai_observer");
|
||
for (let i = 0; i < allExceptCompletionist.length - 1; i += 1) h.api.unlock(allExceptCompletionist[i]);
|
||
assert(!unlocked(h, "true_tarinai_observer"), "completionist unlocked before every other achievement");
|
||
h.api.unlock(allExceptCompletionist[allExceptCompletionist.length - 1]);
|
||
assert(unlocked(h, "true_tarinai_observer"), "completionist did not unlock with every other achievement");
|
||
|
||
h = createHarness();
|
||
const idleWorld = { time: 300, tarinai: [], ants: [], achievementLastInterventionAt: 0, achievementNoDeathStartAt: -1 };
|
||
h.api.evaluateWorld(idleWorld, { id: "relaxed" });
|
||
assert(unlocked(h, "idle_observer_5_minutes"), "idle observer did not unlock");
|
||
|
||
storage = new Map();
|
||
h = createHarness(storage);
|
||
for (let i = 0; i < 60; i += 1) h.api.recordPlayerPlacement({ world: { time: 1 }, item: { type: "grass" } });
|
||
assert(!unlocked(h, "placed_objects_100"), "placement unlocked before 100");
|
||
h = createHarness(storage);
|
||
for (let i = 0; i < 39; i += 1) h.api.recordPlayerPlacement({ world: { time: 1 }, item: { type: "grass" } });
|
||
assert(!unlocked(h, "placed_objects_100"), "placement unlocked at 99");
|
||
h.api.recordPlayerPlacement({ world: { time: 1 }, item: { type: "grass" } });
|
||
assert(unlocked(h, "placed_objects_100"), "placement did not persist across field reset/reload to 100");
|
||
|
||
storage = new Map();
|
||
h = createHarness(storage);
|
||
h.api.recordLinkPlaced("wire", { world: { time: 1 }, item: { type: "wire" } });
|
||
h.api.recordLinkPlaced("insulated_wire", { world: { time: 2 }, item: { type: "insulated_wire" } });
|
||
const wireProgress = JSON.parse(storage.get("tarinai_achievements_v2")).progress;
|
||
assert(wireProgress.placementCount === 2, "wire placements were not counted toward placed objects");
|
||
assert(wireProgress.linkTypes.length === 0, "wire placements incorrectly advanced mechanized link types");
|
||
|
||
h = createHarness();
|
||
h.api.recordLinkPlaced("rope", { world: { time: 1 } });
|
||
h.api.recordLinkPlaced("rod", { world: { time: 1 } });
|
||
h.api.recordLinkPlaced("spring", { world: { time: 1 } });
|
||
assert(!unlocked(h, "mechanized_industry"), "mechanized industry unlocked without signal");
|
||
h.api.recordSignalActivation({ world: {}, target: { type: "gate_fence" } });
|
||
assert(unlocked(h, "mechanized_industry"), "mechanized industry did not unlock after logical AND");
|
||
assert(!unlocked(h, "signal_automation_first") && !unlocked(h, "link_craftsman"), "removed achievements remain accessible");
|
||
|
||
h = createHarness();
|
||
const safeAlive = Array.from({ length: 25 }, () => ({ dead: false }));
|
||
const safeWorld = { time: 0, tarinai: safeAlive, ants: [], achievementLastInterventionAt: 0, achievementNoDeathStartAt: -1 };
|
||
h.api.evaluateWorld(safeWorld, { id: "relaxed" });
|
||
safeWorld.time = 300;
|
||
h.api.evaluateWorld(safeWorld, { id: "relaxed" });
|
||
assert(unlocked(h, "safe_colony_25_5_minutes"), "safe colony did not unlock");
|
||
|
||
h = createHarness();
|
||
const lifespanSafeAlive = Array.from({ length: 25 }, () => ({ dead: false }));
|
||
const lifespanSafeWorld = { time: 100, tarinai: lifespanSafeAlive, achievementNoDeathStartAt: 0 };
|
||
h.api.recordDeath({ world: lifespanSafeWorld, reason: "天寿を全うした", tarinai: { deathReason: "天寿を全うした" } });
|
||
assert(lifespanSafeWorld.achievementNoDeathStartAt === 0, "lifespan death reset safe-colony timer");
|
||
h.api.recordDeath({ world: lifespanSafeWorld, reason: "事故", tarinai: { deathReason: "事故" } });
|
||
assert(lifespanSafeWorld.achievementNoDeathStartAt === 100, "non-lifespan death did not reset safe-colony timer");
|
||
|
||
h = createHarness();
|
||
const antWorld = { time: 1, tarinai: [], ants: Array.from({ length: 25 }, () => ({ dead: false })), achievementLastInterventionAt: 0, achievementNoDeathStartAt: -1 };
|
||
h.api.evaluateWorld(antWorld, { id: "relaxed" });
|
||
assert(unlocked(h, "ants_alive_25"), "ant herd did not unlock at 25");
|
||
|
||
storage = new Map();
|
||
h = createHarness(storage);
|
||
for (let i = 0; i < 65; i += 1) h.api.recordAntKilled({ world: {} });
|
||
assert(!unlocked(h, "ants_killed_100"), "ant extermination unlocked before 100");
|
||
h = createHarness(storage);
|
||
for (let i = 0; i < 34; i += 1) h.api.recordAntKilled({ world: {} });
|
||
assert(!unlocked(h, "ants_killed_100"), "ant extermination unlocked at 99");
|
||
h.api.recordAntKilled({ world: {} });
|
||
assert(unlocked(h, "ants_killed_100"), "ant extermination did not persist to 100");
|
||
|
||
|
||
h = createHarness();
|
||
const antObservationWorld = { tarinai: [], ants: [], items: [] };
|
||
h.api.evaluateWorld(antObservationWorld, {});
|
||
assert(!unlocked(h, "ant_nest_without_tarinai"), "ant observation unlocked without an ant nest");
|
||
antObservationWorld.items.push({ type: "ant_nest", dead: false });
|
||
antObservationWorld.tarinai.push({ dead: false });
|
||
h.api.evaluateWorld(antObservationWorld, {});
|
||
assert(!unlocked(h, "ant_nest_without_tarinai"), "ant observation unlocked while a tarinai was alive");
|
||
antObservationWorld.tarinai[0].dead = true;
|
||
h.api.evaluateWorld(antObservationWorld, {});
|
||
assert(unlocked(h, "ant_nest_without_tarinai"), "ant observation did not unlock with a nest and zero living tarinai");
|
||
|
||
h = createHarness();
|
||
const stickyBomb = { type: "sticky_bomb", dead: false };
|
||
for (let i = 0; i < 14; i += 1) h.api.recordStickyBombPass(stickyBomb, {});
|
||
assert(!unlocked(h, "sticky_bomb_15_passes"), "sticky-bomb relay unlocked before 15 passes");
|
||
h.api.recordStickyBombPass(stickyBomb, {});
|
||
assert(unlocked(h, "sticky_bomb_15_passes"), "sticky-bomb relay did not unlock at 15 passes");
|
||
|
||
h = createHarness();
|
||
h.api.recordSaveSlotsFilled({ filled: 8 });
|
||
assert(!unlocked(h, "secret_collection_9_slots"), "save-slot collection unlocked before 9");
|
||
h.api.recordSaveSlotsFilled({ filled: 9 });
|
||
assert(unlocked(h, "secret_collection_9_slots"), "save-slot collection did not unlock at 9");
|
||
|
||
h = createHarness();
|
||
[0, 250, 500].forEach(now => h.api.recordEmptyClick({ now }));
|
||
assert(!unlocked(h, "pause_spam_4_in_1_second"), "empty-click achievement unlocked before four clicks");
|
||
h.api.recordEmptyClick({ now: 999 });
|
||
assert(unlocked(h, "pause_spam_4_in_1_second"), "empty-click achievement did not unlock within one second");
|
||
h = createHarness();
|
||
[0, 400, 800, 1201].forEach(now => h.api.recordEmptyClick({ now }));
|
||
assert(!unlocked(h, "pause_spam_4_in_1_second"), "empty-click achievement unlocked outside one-second window");
|
||
|
||
h = createHarness();
|
||
h.api.recordContinuousPlay({ elapsedMs: 3599999 });
|
||
assert(!unlocked(h, "continuous_play_1_hour"), "continuous play unlocked before one hour");
|
||
h.api.recordContinuousPlay({ elapsedMs: 3600000 });
|
||
assert(unlocked(h, "continuous_play_1_hour"), "continuous play did not unlock at one hour");
|
||
assert(!unlocked(h, "continuous_play_24_hours"), "24-hour play unlocked at one hour");
|
||
h.api.recordContinuousPlay({ elapsedMs: 86399999 });
|
||
assert(!unlocked(h, "continuous_play_24_hours"), "24-hour play unlocked early");
|
||
h.api.recordContinuousPlay({ elapsedMs: 86400000 });
|
||
assert(unlocked(h, "continuous_play_24_hours"), "24-hour play did not unlock");
|
||
|
||
h = createHarness();
|
||
h.api.recordLowFps({ fps: 10 });
|
||
assert(!unlocked(h, "low_fps_single_digit"), "low-fps achievement unlocked at 10 fps");
|
||
h.api.recordLowFps({ fps: 9 });
|
||
assert(unlocked(h, "low_fps_single_digit"), "low-fps achievement did not unlock at 9 fps");
|
||
|
||
h = createHarness();
|
||
const sandboxWorld = { items: Array.from({ length: 4 }, () => ({ type: "toilet", dead: false })) };
|
||
h.api.evaluateSandbox(sandboxWorld);
|
||
assert(!unlocked(h, "sandbox_five_toilets"), "sandbox unlocked before five toilet sands");
|
||
sandboxWorld.items.push({ type: "toilet", dead: false });
|
||
h.api.evaluateSandbox(sandboxWorld);
|
||
assert(unlocked(h, "sandbox_five_toilets"), "sandbox did not unlock at five toilet sands");
|
||
|
||
h = createHarness();
|
||
h.api.recordGroundChange({ world: { fieldType: "garden" }, previous: "soil", next: "ice", now: 0 });
|
||
assert(!unlocked(h, "park_ground_changed"), "park-ground achievement unlocked outside park");
|
||
h.api.recordGroundChange({ world: { fieldType: "park" }, previous: "soil", next: "ice", now: 100 });
|
||
assert(unlocked(h, "park_ground_changed"), "park-ground achievement did not unlock in park");
|
||
h = createHarness();
|
||
const groundWorld = { fieldType: "garden" };
|
||
[0, 250, 500].forEach((now, index) => h.api.recordGroundChange({ world: groundWorld, previous: `g${index}`, next: `g${index + 1}`, now }));
|
||
assert(!unlocked(h, "ground_change_4_in_1_second"), "ground-spam achievement unlocked before four changes");
|
||
h.api.recordGroundChange({ world: groundWorld, previous: "g3", next: "g4", now: 999 });
|
||
assert(unlocked(h, "ground_change_4_in_1_second"), "ground-spam achievement did not unlock within one second");
|
||
|
||
h = createHarness();
|
||
const thermalWorld = {
|
||
time: 0, tarinai: [], ants: [], items: [{ id: "cold", x: 10, y: 20, dead: false }],
|
||
temperatureAt() { return -273.15; }, achievementLastInterventionAt: 0, achievementNoDeathStartAt: -1,
|
||
};
|
||
h.api.evaluateWorld(thermalWorld, { id: "relaxed" });
|
||
assert(!unlocked(h, "below_absolute_zero_item"), "absolute-zero achievement unlocked at exactly absolute zero");
|
||
thermalWorld.temperatureAt = () => -273.16;
|
||
h.api.evaluateWorld(thermalWorld, { id: "relaxed" });
|
||
assert(unlocked(h, "below_absolute_zero_item"), "absolute-zero achievement did not unlock below absolute zero");
|
||
|
||
storage = new Map();
|
||
storage.set("tarinai_achievements_v2", JSON.stringify({
|
||
unlocked: { signal_automation_first: 1000, link_craftsman: 2000 },
|
||
pending: ["signal_automation_first", "link_craftsman"],
|
||
progress: { linkTypes: ["rope", "rod", "spring"] },
|
||
}));
|
||
h = createHarness(storage);
|
||
assert(unlocked(h, "mechanized_industry"), "legacy AND achievements were not migrated");
|
||
|
||
storage = new Map();
|
||
storage.set("tarinai_achievements_v2", JSON.stringify({
|
||
unlocked: { link_craftsman: 2000 },
|
||
pending: [],
|
||
progress: {},
|
||
}));
|
||
h = createHarness(storage);
|
||
h.api.recordSignalActivation({ world: {}, target: { type: "gate_fence" } });
|
||
assert(unlocked(h, "mechanized_industry"), "legacy link-craftsman progress was not reconstructed before a later signal");
|
||
|
||
storage = new Map();
|
||
h = createHarness(storage, "?debug=1");
|
||
assert(h.elements.get("achievementUnlockAllBtn").hidden === false, "debug all-achievements button was not shown");
|
||
h.api.debugUnlockAll();
|
||
assert(h.api.definitions.every(def => unlocked(h, def.id)), "debug all-achievements button did not unlock all");
|
||
const debugState = JSON.parse(storage.get("tarinai_achievements_v2"));
|
||
assert(debugState.pending.length === 0, "debug unlocks were queued for shared statistics");
|
||
assert(debugState.debugUnlocked.length === h.api.definitions.length, "debug unlocks were not marked as local-only");
|
||
h = createHarness(storage, "");
|
||
assert(h.api.definitions.every(def => !unlocked(h, def.id)), "debug-only unlocks leaked into normal play");
|
||
|
||
storage = new Map();
|
||
storage.set("tarinai_achievements_v2", JSON.stringify({
|
||
unlocked: { first_birth: 1700000000123, lifespan_completed: 1700000000456 },
|
||
pending: [],
|
||
progress: {},
|
||
}));
|
||
const recoveryRequests = [];
|
||
h = createHarness(storage, "", {
|
||
protocol: "https:",
|
||
fetch: async (_url, options = {}) => {
|
||
recoveryRequests.push(JSON.parse(options.body || "{}"));
|
||
return { ok: true, async json() { return { ok: true, totalPlayers: 1, achievements: {} }; } };
|
||
},
|
||
});
|
||
await h.api.refresh();
|
||
assert(recoveryRequests.length === 1, "recovery sync did not issue exactly one request");
|
||
assert(recoveryRequests[0].action === "sync", "recovery request did not use bulk sync");
|
||
assert(recoveryRequests[0].completionistEligible === false, "full recovery sync did not report completionist eligibility");
|
||
assert(recoveryRequests[0].unlocked.first_birth === 1700000000123, "recovery sync omitted first birth timestamp");
|
||
assert(recoveryRequests[0].unlocked.lifespan_completed === 1700000000456, "recovery sync omitted lifespan timestamp");
|
||
|
||
h = createHarness();
|
||
for (let i = 0; i < 49; i += 1) h.api.recordFirstAidRecovery({ recovered: 10 });
|
||
assert(!unlocked(h, "town_doctor_50"), "doctor unlocked before 50 recoveries");
|
||
h.api.recordFirstAidRecovery({ recovered: 0 });
|
||
assert(!unlocked(h, "town_doctor_50"), "zero recovery counted for doctor");
|
||
h.api.recordFirstAidRecovery({ recovered: 1 });
|
||
assert(unlocked(h, "town_doctor_50"), "doctor did not unlock at 50 recoveries");
|
||
|
||
h = createHarness();
|
||
h.api.recordPlushiePokeFling({});
|
||
assert(unlocked(h, "poke_plushie_fling"), "plushie poke achievement did not unlock");
|
||
|
||
storage = new Map();
|
||
h = createHarness(storage);
|
||
const chaosWorld = { time: 0 };
|
||
for (let i = 0; i < 700; i += 1) h.api.recordFightStarted({ world: chaosWorld, a: {}, b: {} });
|
||
assert(!unlocked(h, "chaos_seeker_666_fights"), "ordinary fights counted toward chaos seeker");
|
||
const fightMochiTarinai = { fightMochiTimer: 10 };
|
||
for (let i = 0; i < 400; i += 1) h.api.recordFightStarted({ world: chaosWorld, a: fightMochiTarinai, b: {} });
|
||
h = createHarness(storage);
|
||
for (let i = 0; i < 265; i += 1) h.api.recordFightStarted({ world: chaosWorld, a: fightMochiTarinai, b: {} });
|
||
assert(!unlocked(h, "chaos_seeker_666_fights"), "chaos seeker unlocked at 665 influenced fights");
|
||
h.api.recordFightStarted({ world: chaosWorld, a: fightMochiTarinai, b: {} });
|
||
assert(unlocked(h, "chaos_seeker_666_fights"), "chaos seeker did not persist to 666 influenced fights");
|
||
|
||
storage = new Map();
|
||
h = createHarness(storage);
|
||
for (let i = 0; i < 332; i += 1) h.api.recordShotFired({});
|
||
assert(!unlocked(h, "sniper_333_shots"), "sniper unlocked before 333 shots");
|
||
h = createHarness(storage);
|
||
h.api.recordShotFired({});
|
||
assert(unlocked(h, "sniper_333_shots"), "sniper did not persist to 333 shots");
|
||
|
||
storage = new Map();
|
||
h = createHarness(storage);
|
||
for (let i = 0; i < 800; i += 1) h.api.recordLoveMochiBirth({ loveMochiInfluenced: false });
|
||
assert(!unlocked(h, "fertility_seeker_721_love_births"), "ordinary reproduction counted toward fertility seeker");
|
||
for (let i = 0; i < 720; i += 1) h.api.recordLoveMochiBirth({ loveMochiInfluenced: true });
|
||
assert(!unlocked(h, "fertility_seeker_721_love_births"), "fertility seeker unlocked before 721 influenced reproductions");
|
||
h = createHarness(storage);
|
||
h.api.recordLoveMochiBirth({ loveMochiInfluenced: true });
|
||
assert(unlocked(h, "fertility_seeker_721_love_births"), "fertility seeker did not persist to 721 influenced reproductions");
|
||
|
||
h = createHarness();
|
||
const metroWorld = {
|
||
tarinai: Array.from({ length: 99 }, () => ({ dead: false })),
|
||
items: [
|
||
...Array.from({ length: 10 }, () => ({ type: "duplicator", dead: false })),
|
||
...Array.from({ length: 15 }, (_v, i) => ({ type: i % 3 === 0 ? "grass_bed" : (i % 3 === 1 ? "nest_box" : "pipe"), dead: false })),
|
||
],
|
||
};
|
||
h.api.evaluateMegalopolis(metroWorld);
|
||
assert(!unlocked(h, "megalopolis"), "megalopolis ignored the 100-tarinai threshold");
|
||
metroWorld.tarinai.push({ dead: false });
|
||
metroWorld.items[0].dead = true;
|
||
h.api.evaluateMegalopolis(metroWorld);
|
||
assert(!unlocked(h, "megalopolis"), "megalopolis ignored the 10-duplicator threshold");
|
||
metroWorld.items[0].dead = false;
|
||
metroWorld.items[10].dead = true;
|
||
h.api.evaluateMegalopolis(metroWorld);
|
||
assert(!unlocked(h, "megalopolis"), "megalopolis ignored the 15-shelter threshold");
|
||
metroWorld.items[10].dead = false;
|
||
h.api.evaluateMegalopolis(metroWorld);
|
||
assert(unlocked(h, "megalopolis"), "megalopolis did not unlock at exact thresholds");
|
||
|
||
h = createHarness();
|
||
const cleaner = { type: "robot_cleaner", dead: false, robotCleanerMask: 0x3f, robotCleanerHighSpeed: true, _signalDriven: true, _signalOn: false };
|
||
const cleanWorld = { items: [cleaner], tarinai: [], ants: [], time: 0 };
|
||
h.api.evaluateCleanFreak(cleanWorld);
|
||
assert(!unlocked(h, "clean_freak_robot_only"), "clean freak unlocked while signal-powered cleaner was off");
|
||
cleaner._signalOn = true;
|
||
cleanWorld.tarinai.push({ dead: false });
|
||
h.api.evaluateCleanFreak(cleanWorld);
|
||
assert(!unlocked(h, "clean_freak_robot_only"), "clean freak ignored a living tarinai");
|
||
cleanWorld.tarinai.length = 0;
|
||
cleanWorld.items.push({ type: "grass", dead: false });
|
||
h.api.evaluateCleanFreak(cleanWorld);
|
||
assert(!unlocked(h, "clean_freak_robot_only"), "clean freak ignored another field item");
|
||
cleanWorld.items.pop();
|
||
h.api.evaluateCleanFreak(cleanWorld);
|
||
assert(unlocked(h, "clean_freak_robot_only"), "clean freak did not unlock with all settings and robot-only field");
|
||
|
||
console.log("[OK] all 64 achievement definitions, categorized UI, inline disclosures, and recovery synchronization passed");
|
||
})().catch(error => {
|
||
console.error(error);
|
||
process.exitCode = 1;
|
||
});
|