Floating QoL panel, stat controls & variable tools for Degrees of Lewdity
// ==UserScript==
// @name DoL Companion Panel
// @namespace https://github.com/Zenix-Al/DoL-Companion-Panel
// @version 3.0.0
// @description Floating QoL panel, stat controls & variable tools for Degrees of Lewdity
// @author Zenix-Al
// @match https://vanilla.dolmods.net/*
// @match https://dolp.dolmods.net/*
// @match https://*.dolmods.net/*
// @match file:///*.html
// @match file:///*.htm
// @icon https://f95zone.to/data/avatars/l/1963/1963870.jpg
// @run-at document-idle
// @grant unsafeWindow
// @license GPL-3.0-or-later
// ==/UserScript==
// ------------------------------------------------------------
// Built on 2026-09-05 18:00:38 UTC -- AUTO-GENERATED, edit from /src and rebuild
// Build mode: release
// Artifact: regular
// Logs: debugLog call sites stripped where possible
// ------------------------------------------------------------
(() => {
var __defProp = Object.defineProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
// src/constants/ui.js
var SHADOW_HOST_ID = "dol-cheatplus-host";
var GAME_VERSION_ELEMENT_ID = "gameVersionDisplay2";
var CHEAT_ROOT_ID = "cheat";
// src/core/feature-factory.js
function safeInvoke(featureId, phase, fn, ctx) {
if (typeof fn !== "function") return;
try {
fn(ctx);
} catch (err) {
console.error(`[CheatPlus:factory] ${featureId}.${phase} threw:`, err);
}
}
function createFeatureFactory() {
const features = /* @__PURE__ */ new Map();
function registerFeature(def) {
if (!def?.id) throw new Error("[CheatPlus:factory] Feature definition must have an id");
if (features.has(def.id)) {
console.warn(`[CheatPlus:factory] Feature "${def.id}" already registered; skipping`);
return;
}
features.set(def.id, def);
}
function runPhase(phase, ctx, opts = {}) {
const list = opts.reverse ? [...features.values()].reverse() : [...features.values()];
for (const feature of list) {
safeInvoke(feature.id, phase, feature[phase], ctx);
}
}
return {
registerFeature,
registerAllActions: (ctx) => runPhase("registerActions", ctx),
initAllFeatures: (ctx) => runPhase("init", ctx),
startAllObservers: (ctx) => runPhase("startObservers", ctx),
stopAllObservers: (ctx) => runPhase("stopObservers", ctx, { reverse: true }),
teardownAllFeatures: (ctx) => runPhase("dispose", ctx, { reverse: true })
};
}
var factory = createFeatureFactory();
// src/core/logger.js
var LS_DEBUG_KEY = "CheatPlus:debug";
var debugEnabled = null;
function isDebugEnabled() {
try {
if (true) return Boolean(true);
} catch (e) {
}
if (debugEnabled != null) return Boolean(debugEnabled);
try {
return localStorage.getItem(LS_DEBUG_KEY) === "1";
} catch (e) {
}
return false;
}
function debugLog(feature, msg, { data = null, level = "log" } = {}) {
if (!isDebugEnabled()) return;
const logMethod = console[level] || console.log;
const style = level === "warn" ? "color: orange;" : level === "error" ? "color: red;" : "";
try {
console.groupCollapsed(`%c[CheatPlus][${feature}] ${msg}`, style);
logMethod(msg);
if (data !== null && typeof data !== "undefined") logMethod(data);
} catch (e) {
try {
logMethod(`[CheatPlus][${feature}] ${msg}`);
if (data) logMethod(data);
} catch (err) {
}
} finally {
try {
console.groupEnd();
} catch (e) {
}
}
}
var logger_default = debugLog;
// src/ui/helpers/dom-query.js
var shadowHost = null;
var shadowRoot = null;
var quicklink = null;
var statlink = null;
var misclink = null;
var quickcontent = null;
var statscontent = null;
var misccontent = null;
var toastContainer = null;
var modal = null;
var modalContentContainer = null;
var cheat = null;
function getUiRoot() {
return shadowRoot || document;
}
function byUiId(id) {
if (shadowRoot) {
if (typeof shadowRoot.getElementById === "function") {
const el2 = shadowRoot.getElementById(id);
if (el2) return el2;
}
const el = shadowRoot.querySelector("#" + id);
if (el) return el;
}
return document.getElementById(id);
}
function ensureShadowRoot() {
if (shadowRoot) return shadowRoot;
if (!document.body) return null;
shadowHost = document.getElementById(SHADOW_HOST_ID);
if (!shadowHost) {
shadowHost = document.createElement("div");
shadowHost.id = SHADOW_HOST_ID;
document.body.appendChild(shadowHost);
try {
logger_default("ui", "ensureShadowRoot: created shadow host", { data: { id: SHADOW_HOST_ID } });
} catch (e) {
}
}
shadowRoot = shadowHost.shadowRoot || shadowHost.attachShadow({ mode: "open" });
try {
logger_default("ui", "ensureShadowRoot: shadowRoot attached", {
data: { hasShadowRoot: !!shadowRoot }
});
} catch (e) {
}
return shadowRoot;
}
function refreshUiRefs() {
quicklink = byUiId("quick-link");
statlink = byUiId("stats-link");
misclink = byUiId("misc-link");
quickcontent = byUiId("quick-content");
statscontent = byUiId("stats-content");
misccontent = byUiId("misc-content");
toastContainer = byUiId("toastContainer");
modal = byUiId("modal");
modalContentContainer = byUiId("modal-content-container");
cheat = byUiId("cheat");
try {
logger_default("ui", "refreshUiRefs", {
data: {
cheat: !!cheat,
modal: !!modal,
modalContentContainer: !!modalContentContainer
}
});
} catch (e) {
}
}
refreshUiRefs();
function getUiRefs() {
refreshUiRefs();
return {
quicklink,
quickcontent,
statlink,
statscontent,
misclink,
misccontent
};
}
function replaceSelectOptions(selectElement, options6) {
if (!selectElement) return;
const previousValue = selectElement.value;
selectElement.replaceChildren();
options6.forEach(({ value, label }) => {
const option = document.createElement("option");
option.value = String(value);
option.textContent = label;
selectElement.appendChild(option);
});
if (previousValue && options6.some((option) => String(option.value) === previousValue)) {
selectElement.value = previousValue;
} else if (options6.length > 0) {
selectElement.value = String(options6[0].value);
}
}
// src/ui/components/toast.js
var FALLBACK_CONTAINER_ID = "cp-fallback-toast-container";
var MAX_TOASTS = 4;
var DEFAULT_DURATION = 3e3;
var toastSequence = 0;
function ensureFallbackContainer() {
let container = document.getElementById(FALLBACK_CONTAINER_ID);
if (container) return container;
container = document.createElement("div");
container.id = FALLBACK_CONTAINER_ID;
container.className = "toast-container";
document.body.appendChild(container);
return container;
}
function getToastContainer() {
const shadowContainer = byUiId("toastContainer");
if (shadowContainer) return shadowContainer;
return ensureFallbackContainer();
}
function normalizeToastArgs(message, optionsOrDuration) {
if (typeof optionsOrDuration === "number") {
return {
message,
duration: optionsOrDuration,
variant: "info"
};
}
return {
message,
duration: optionsOrDuration?.duration ?? DEFAULT_DURATION,
variant: optionsOrDuration?.variant ?? "info",
title: optionsOrDuration?.title
};
}
function showToast(message, optionsOrDuration) {
const { duration, variant, title } = normalizeToastArgs(message, optionsOrDuration);
const toastContainer2 = getToastContainer();
if (!toastContainer2) return;
const toast = document.createElement("div");
toast.classList.add("toast", "toast-enter", `toast--${variant}`);
if (title) {
const titleEl = document.createElement("div");
titleEl.className = "toast-title";
titleEl.textContent = title;
toast.appendChild(titleEl);
}
const bodyEl = document.createElement("div");
bodyEl.className = "toast-body";
bodyEl.textContent = message;
toast.appendChild(bodyEl);
toast.dataset.cpToastSequence = String(++toastSequence);
toastContainer2.appendChild(toast);
while (toastContainer2.children.length > MAX_TOASTS) {
toastContainer2.firstElementChild?.remove();
}
requestAnimationFrame(() => {
toast.classList.remove("toast-enter");
toast.classList.add("toast-show");
});
setTimeout(() => {
toast.classList.remove("toast-show");
toast.classList.add("toast-leave");
setTimeout(() => {
toast.remove();
}, 200);
}, duration);
}
var timedToast = (text2, time, options6) => setTimeout(() => showToast(text2, options6), time);
// src/ui/renderers/layout.js
var modalTemplate = {
tag: "div",
id: "modal",
class: "modal",
children: [
{
tag: "div",
class: "modal-content",
children: [
{
tag: "div",
class: "navbar",
children: [
{ tag: "div", id: "quick-link", class: "nav-link gold", text: "Quick" },
{ tag: "div", id: "stats-link", class: "nav-link", text: "Stat" },
{ tag: "div", id: "misc-link", class: "nav-link", text: "Misc" },
{ tag: "div", id: "close-modal-top", class: "close nav-link", text: "\xD7" }
]
},
{
tag: "div",
id: "modal-content-container",
children: [
{ tag: "div", id: "quick-content", class: "cheat-content active" },
{ tag: "div", id: "stats-content", class: "cheat-content" },
{ tag: "div", id: "misc-content", class: "cheat-content" }
]
},
{
tag: "div",
class: "navbar",
children: [{ tag: "div", id: "close-modal-bottom", class: "close nav-link", text: "\xD7" }]
}
]
}
]
};
var layoutTemplate = {
tag: "div",
id: "cheat",
children: [
{
tag: "div",
id: "floating-button",
children: [
{ tag: "button", id: "cheat-history-backwards", text: "\u2190", hidden: true },
{ tag: "button", id: "cheat-history-forwards", text: "\u2192", hidden: true },
{ tag: "button", id: "cheat-sidebar", text: "\u2630", hidden: true },
{ tag: "button", id: "cheat-open", text: "Cheat" }
]
},
{ tag: "div", id: "toastContainer" },
{ tag: "div", id: "effect-layer", class: "hidden" }
// Modal is injected lazily on first open.
]
};
function renderTemplate(template) {
const el = document.createElement(template.tag);
if (template.id) el.id = template.id;
if (template.class) el.className = template.class;
if (template.text) el.textContent = template.text;
if (template.hidden) el.hidden = true;
if (template.children) {
template.children.forEach((child) => el.appendChild(renderTemplate(child)));
}
return el;
}
// src/core/state/index.js
var store = {
state: null,
subscribers: /* @__PURE__ */ new Map()
};
var initialState = () => ({
modal: {
open: false,
isDelete: false,
isCheatPressed: false
},
runtime: {
isLoad: false,
clickCounter: 0,
curDate: 0,
errorFunctions: 0,
progressFunctions: 0,
totalFunctions: 0,
extraNotif: false,
reactivatingToggles: false,
isTestingAllFunction: false,
pcPregnant: 0,
totalNpcPregnant: 0
}
});
function getStore() {
if (!store.state) {
store.state = initialState();
}
return store;
}
function getByPath(obj, path7) {
return path7.split(".").reduce((cur, key) => cur != null ? cur[key] : void 0, obj);
}
function setByPath(obj, path7, value) {
const keys = path7.split(".");
const last = keys.pop();
const parent = keys.reduce((cur, key) => {
if (cur[key] == null) cur[key] = {};
return cur[key];
}, obj);
parent[last] = value;
}
function get(path7) {
return getByPath(getStore().state, path7);
}
function set(path7, value) {
const store2 = getStore();
const oldValue = getByPath(store2.state, path7);
if (oldValue === value) return;
setByPath(store2.state, path7, value);
const callbacks = store2.subscribers.get(path7);
if (callbacks) {
callbacks.forEach((cb) => {
try {
cb(value, oldValue, path7);
} catch (e) {
}
});
}
}
// src/core/actions/dispatcher.js
var dispatcherStore = {
handlers: /* @__PURE__ */ new Map(),
onError: null
};
function getStore2() {
return dispatcherStore;
}
function register(key, handler) {
if (typeof key !== "string" || !key) {
logger_default("dispatcher", "register: key must be a non-empty string.", { level: "warn" });
return;
}
if (typeof handler !== "function") {
logger_default("dispatcher", `register: handler for "${key}" is not a function.`, {
level: "warn"
});
return;
}
logger_default("dispatcher", `Registered action: ${key}`);
getStore2().handlers.set(key, handler);
}
function dispatch(key, context) {
const store2 = getStore2();
const handler = store2.handlers.get(key);
if (!handler) {
logger_default("dispatcher", `No handler registered for action: "${key}"`, { level: "warn" });
return;
}
try {
logger_default("dispatcher", `Dispatching action: ${key}`);
return handler(context);
} catch (err) {
logger_default("dispatcher", `Handler error for action: ${key}`, { data: err, level: "error" });
if (typeof store2.onError === "function") {
try {
store2.onError(key, err);
} catch (_) {
}
}
}
}
function isRegistered(key) {
return getStore2().handlers.has(key);
}
function setErrorHook(fn) {
if (typeof fn !== "function") return;
getStore2().onError = fn;
}
// src/core/global-bridge.js
function getRuntimeWindow() {
try {
if (typeof unsafeWindow !== "undefined" && unsafeWindow) return unsafeWindow;
} catch (e) {
}
return typeof window !== "undefined" ? window : void 0;
}
// src/ui/helpers/modal-hotkey.js
var MODAL_HOTKEY_STORAGE_KEY = "dol-cheatplus-hotkey";
var MODAL_HOTKEY_GUARD_KEY = "__DOL_CP_MODAL_HOTKEY_BOUND__";
var DEFAULT_MODAL_HOTKEY = "ctrl+shift+c";
var toggleModal = null;
function parseHotkey(hotkey) {
const raw = String(hotkey || "").trim().toLowerCase();
if (!raw) return null;
if (raw === "off" || raw === "disabled") return { disabled: true };
const parts = raw.split("+").map((part) => part.trim()).filter(Boolean);
if (!parts.length) return null;
const key = parts[parts.length - 1];
const mods = new Set(parts.slice(0, -1));
return {
key,
ctrl: mods.has("ctrl") || mods.has("control"),
alt: mods.has("alt"),
shift: mods.has("shift")
};
}
function resolveModalHotkey() {
const runtimeWindow2 = getRuntimeWindow();
let configured = DEFAULT_MODAL_HOTKEY;
try {
const saved = runtimeWindow2?.localStorage?.getItem(MODAL_HOTKEY_STORAGE_KEY);
if (saved) configured = saved;
} catch (_) {
}
return parseHotkey(configured);
}
function isEditableTarget(target) {
if (!target) return false;
const tag = String(target.tagName || "").toLowerCase();
return tag === "input" || tag === "textarea" || tag === "select" || target.isContentEditable === true;
}
function matchesHotkey(event, hotkey) {
if (!hotkey || hotkey.disabled) return false;
const key = String(event.key || "").toLowerCase();
return key === hotkey.key && Boolean(event.ctrlKey) === Boolean(hotkey.ctrl) && Boolean(event.altKey) === Boolean(hotkey.alt) && Boolean(event.shiftKey) === Boolean(hotkey.shift);
}
function ensureModalHotkey(toggleFn) {
if (typeof toggleFn === "function") toggleModal = toggleFn;
const runtimeWindow2 = getRuntimeWindow();
if (runtimeWindow2?.[MODAL_HOTKEY_GUARD_KEY]) return;
const onKeydown = (event) => {
if (isEditableTarget(event.target)) return;
if (!matchesHotkey(event, resolveModalHotkey())) return;
event.preventDefault();
if (typeof toggleModal === "function") toggleModal();
};
document.addEventListener("keydown", onKeydown);
if (runtimeWindow2) runtimeWindow2[MODAL_HOTKEY_GUARD_KEY] = true;
}
// src/cheats/runtime/active-builder.js
var activeBuilder = null;
function setActiveCheatBuilder(builder) {
activeBuilder = builder ?? null;
return activeBuilder;
}
function getActiveCheatBuilder() {
return activeBuilder;
}
async function teardownActiveCheatBuilder() {
return activeBuilder?.teardown?.() ?? false;
}
// src/ui/components/modal.js
function toggleModalByHotkey() {
if (get("modal.open")) closeModal();
else openModal();
}
function filterSectionRows(sectionEl, query) {
if (!sectionEl) return;
const norm = String(query ?? "").trim().toLowerCase();
const rows = sectionEl.querySelectorAll(".modal-content-padding");
rows.forEach((row) => {
if (row.classList.contains("cp-search-row")) return;
if (!norm) {
row.style.display = "";
return;
}
const haystack = (row.textContent || "").toLowerCase();
row.style.display = haystack.includes(norm) ? "" : "none";
});
}
function attachSectionSearch(sectionEl, title) {
if (!sectionEl || sectionEl.querySelector(".cp-search-row")) return;
const row = document.createElement("div");
row.className = "modal-content-padding cp-search-row";
const input = document.createElement("input");
input.type = "search";
input.className = "cp-search-input";
input.placeholder = `Search ${title}...`;
input.autocomplete = "off";
input.setAttribute("aria-label", `${title} search`);
input.addEventListener("input", () => filterSectionRows(sectionEl, input.value));
row.appendChild(input);
sectionEl.prepend(row);
}
function ensureSectionSearchBars() {
attachSectionSearch(byUiId("quick-content"), "Quick");
attachSectionSearch(byUiId("stats-content"), "Stat");
attachSectionSearch(byUiId("misc-content"), "Misc");
}
function ensureModalInjected() {
if (byUiId("modal")) return;
const root = getUiRoot();
const cheatRoot = byUiId("cheat");
if (!root || !cheatRoot) return;
const modalEl = renderTemplate(modalTemplate);
modalEl.addEventListener("click", (event) => {
const id = event.target?.id;
if (id === "close-modal-top" || id === "close-modal-bottom") {
closeModal();
return;
}
if (id === "quick-link" || id === "stats-link" || id === "misc-link") {
dispatch(id);
}
});
cheatRoot.appendChild(modalEl);
refreshUiRefs();
}
function bloodEffect() {
const effect = byUiId("effect-layer");
const bodyElement = document.body;
if (!effect) return;
effect.classList.remove("hidden");
effect.style.transition = "opacity 0.1s ease-in-out";
effect.style.opacity = 0;
setTimeout(() => {
effect.style.transition = "opacity 2s ease-in-out";
effect.style.opacity = 1;
bodyElement.classList.add("shake");
}, 200);
setTimeout(() => {
bodyElement.classList.remove("shake");
effect.classList.add("hidden");
}, 2200);
}
function openModal() {
if (get("modal.open")) return;
ensureModalHotkey(toggleModalByHotkey);
ensureModalInjected();
const modal2 = byUiId("modal");
if (!modal2) return;
modal2.style.display = "block";
set("modal.open", true);
set("modal.isDelete", false);
set("modal.isCheatPressed", false);
dispatch("init_interface");
ensureSectionSearchBars();
dispatch("quick-link");
}
function closeModal() {
if (!get("modal.open")) return;
const modal2 = byUiId("modal");
if (!modal2) return;
void teardownActiveCheatBuilder();
set("modal.isDelete", true);
modal2.remove();
refreshUiRefs();
set("modal.open", false);
set("modal.isDelete", false);
set("modal.isCheatPressed", false);
}
ensureModalHotkey(toggleModalByHotkey);
// src/ui/components/controls.js
var rw = getRuntimeWindow();
var FLOATING_POSITION_KEY = "dol-cheatplus-floating-position-v1";
function clamp(value, min, max) {
return Math.min(Math.max(value, min), max);
}
function applyFloatingPosition(floatingButton, x, y) {
if (!floatingButton) return;
const maxX = Math.max(rw.innerWidth - floatingButton.offsetWidth, 0);
const maxY = Math.max(rw.innerHeight - floatingButton.offsetHeight, 0);
const left = clamp(x, 0, maxX);
const top = clamp(y, 0, maxY);
floatingButton.style.left = `${left}px`;
floatingButton.style.top = `${top}px`;
floatingButton.style.right = "auto";
floatingButton.dataset.cpCustomPosition = "1";
floatingButton.classList.add("cp-custom-position");
}
function persistFloatingPosition(x, y) {
try {
rw.localStorage.setItem(FLOATING_POSITION_KEY, JSON.stringify({ x, y }));
} catch (_) {
}
}
function restoreFloatingPosition(floatingButton) {
if (!floatingButton) return;
try {
const raw = rw.localStorage.getItem(FLOATING_POSITION_KEY);
if (!raw) return;
const parsed = JSON.parse(raw);
if (!Number.isFinite(parsed?.x) || !Number.isFinite(parsed?.y)) return;
applyFloatingPosition(floatingButton, parsed.x, parsed.y);
} catch (_) {
}
}
function initFloatingButtonDrag() {
const floatingButton = byUiId("floating-button");
const dragHandle = byUiId("cheat-open");
if (!floatingButton || !dragHandle || floatingButton.dataset.cpDragBound === "1") return;
restoreFloatingPosition(floatingButton);
let startX = 0;
let startY = 0;
let originLeft = 0;
let originTop = 0;
let dragged = false;
const onPointerMove = (event) => {
const dx = event.clientX - startX;
const dy = event.clientY - startY;
if (!dragged && (Math.abs(dx) > 3 || Math.abs(dy) > 3)) dragged = true;
if (!dragged) return;
applyFloatingPosition(floatingButton, originLeft + dx, originTop + dy);
};
const onPointerUp = () => {
rw.removeEventListener("pointermove", onPointerMove);
rw.removeEventListener("pointerup", onPointerUp);
floatingButton.classList.remove("cp-dragging");
if (!dragged) return;
const left = Number.parseFloat(floatingButton.style.left || "0");
const top = Number.parseFloat(floatingButton.style.top || "0");
persistFloatingPosition(left, top);
dragHandle.dataset.cpSuppressNextClick = "1";
};
dragHandle.addEventListener("pointerdown", (event) => {
event.preventDefault();
if (typeof dragHandle.setPointerCapture === "function") {
try {
dragHandle.setPointerCapture(event.pointerId);
} catch (_) {
}
}
startX = event.clientX;
startY = event.clientY;
dragged = false;
const rect = floatingButton.getBoundingClientRect();
originLeft = rect.left;
originTop = rect.top;
floatingButton.classList.add("cp-dragging");
rw.addEventListener("pointermove", onPointerMove);
rw.addEventListener("pointerup", onPointerUp);
});
dragHandle.addEventListener("click", (event) => {
if (dragHandle.dataset.cpSuppressNextClick !== "1") return;
dragHandle.dataset.cpSuppressNextClick = "0";
event.preventDefault();
if (typeof event.stopImmediatePropagation === "function") event.stopImmediatePropagation();
else event.stopPropagation();
});
rw.addEventListener("resize", () => {
if (floatingButton.dataset.cpCustomPosition !== "1") return;
const left = Number.parseFloat(floatingButton.style.left || "0");
const top = Number.parseFloat(floatingButton.style.top || "0");
applyFloatingPosition(floatingButton, left, top);
});
floatingButton.dataset.cpDragBound = "1";
}
function syncHistoryButtons() {
const backwards = byUiId("cheat-history-backwards");
const forwards = byUiId("cheat-history-forwards");
const gameBack = byUiId("history-backward") || document.getElementById("history-backward");
const gameForward = byUiId("history-forward") || document.getElementById("history-forward");
if (!backwards || !forwards || !gameBack || !gameForward) return;
backwards.disabled = gameBack.disabled;
forwards.disabled = gameForward.disabled;
}
function Enable_cheat_history() {
var button_back = byUiId("cheat-history-backwards");
var button_forward = byUiId("cheat-history-forwards");
var button_set = byUiId("Enable_cheat_history") || document.getElementById("Enable_cheat_history");
if (!button_back || !button_forward || !button_set) return;
if (button_back.hidden == true) {
button_back.hidden = false;
button_forward.hidden = false;
button_set.innerHTML = "Disable";
syncHistoryButtons();
} else {
button_back.hidden = true;
button_forward.hidden = true;
button_set.innerHTML = "Enable";
}
}
function Enable_sidebar_button() {
var button = byUiId("cheat-sidebar");
var sidebar_button = document.getElementById("Enable_sidebar_button");
if (!button || !sidebar_button) return;
if (button.hidden == true) {
button.hidden = false;
sidebar_button.innerHTML = "Disable";
} else {
button.hidden = true;
sidebar_button.innerHTML = "Enable";
}
}
function simple_cheat_button() {
const cheatButton = byUiId("cheat-open");
const simpleCheatButton = document.getElementById("simple_cheat_button");
if (!cheatButton || !simpleCheatButton) return;
const isDisabled = simpleCheatButton.innerHTML === "Disable";
simpleCheatButton.innerHTML = isDisabled ? "Enable" : "Disable";
cheatButton.innerHTML = isDisabled ? "Cheat" : "\u2699";
cheatButton.style.fontSize = isDisabled ? "" : "89%";
}
// src/ui/helpers/ui-display.js
function hideAllContent() {
const { quicklink: quicklink2, statlink: statlink2, misclink: misclink2, quickcontent: quickcontent2, statscontent: statscontent2, misccontent: misccontent2 } = getUiRefs();
if (!quicklink2 || !statlink2 || !misclink2 || !quickcontent2 || !statscontent2 || !misccontent2) {
return;
}
[quicklink2, statlink2, misclink2].forEach((link) => link.classList.remove("gold"));
[quickcontent2, statscontent2, misccontent2].forEach(
(content) => content.classList.remove("active")
);
}
function showContent(nav, contentElement) {
if (!nav || !contentElement) return;
hideAllContent();
nav.classList.add("gold");
contentElement.classList.add("active");
}
// src/services/toggle-scheduler.js
var functionMap = /* @__PURE__ */ new Map();
var dailyMap = /* @__PURE__ */ new Map();
var DEFAULT_COOLDOWN_MS = 100;
var DEFAULT_MAX_FAILURES = 5;
var scheduledRun = false;
var frameExpected = 0;
var frameProgress = 0;
var frameFailures = 0;
var framePending = /* @__PURE__ */ new Set();
var frameLastProgressKey = null;
function resetFrameState() {
frameExpected = 0;
frameProgress = 0;
frameFailures = 0;
framePending = /* @__PURE__ */ new Set();
frameLastProgressKey = null;
}
function getFramePendingSample(limit = 8) {
if (!framePending || framePending.size === 0) return [];
const out = [];
for (const key of framePending) {
out.push(key);
if (out.length >= limit) break;
}
return out;
}
function runEntriesSequentially(entries2, { onProgress = null, onDone = null, daily = false } = {}) {
let index = 0;
function step() {
if (index >= entries2.length) {
if (typeof onDone === "function") onDone();
logger_default(
"toggle:scheduler",
`${daily ? "Daily" : "Regular"} batch complete (${index} entries)`
);
return;
}
const [key, meta] = entries2[index++];
const now = Date.now();
if (!meta) {
if (typeof onProgress === "function") onProgress(key);
return requestAnimationFrame(step);
}
if (!daily && now - (meta.lastRun || 0) < (meta.cooldownMs || DEFAULT_COOLDOWN_MS)) {
logger_default(
"toggle:scheduler",
`Skipping ${key}: cooldown not ready (${now - (meta.lastRun || 0)}ms < ${meta.cooldownMs || DEFAULT_COOLDOWN_MS}ms)`
);
if (typeof onProgress === "function") onProgress(key);
return requestAnimationFrame(step);
}
try {
if (typeof meta.fn === "function") {
logger_default("toggle:scheduler", `Executing ${daily ? "daily" : "regular"} toggle: ${key}`);
meta.fn();
if (!daily) meta.lastRun = Date.now();
meta.failureCount = 0;
}
} catch (e) {
meta.failureCount = (meta.failureCount || 0) + 1;
logger_default(
"toggle:scheduler",
`Error executing ${daily ? "daily" : "regular"} toggle: ${key} (failure #${meta.failureCount})`,
{
data: e,
level: "error"
}
);
if (meta.failureCount >= (meta.maxFailures || DEFAULT_MAX_FAILURES)) {
if (daily) {
dailyMap.delete(key);
logger_default(
"toggle:scheduler",
`Unregistered daily toggle: ${key} after ${meta.failureCount} failures`,
{
level: "warn"
}
);
} else {
functionMap.delete(key);
logger_default(
"toggle:scheduler",
`Unregistered regular toggle: ${key} after ${meta.failureCount} failures`,
{
level: "warn"
}
);
}
if (typeof meta.onFailureThreshold === "function") {
meta.onFailureThreshold({ id: key, failures: meta.failureCount, error: e, daily });
}
}
}
if (typeof onProgress === "function") onProgress(key);
requestAnimationFrame(step);
}
step();
}
var ToggleScheduler = {
register(id, fn, {
daily = false,
cooldownMs = DEFAULT_COOLDOWN_MS,
maxFailures = DEFAULT_MAX_FAILURES,
onFailureThreshold = null
} = {}) {
if (!id) return;
logger_default("toggle:scheduler", `Registering ${daily ? "daily" : "regular"} toggle: ${id}`, {
data: { cooldownMs, maxFailures, fnExists: typeof fn === "function" }
});
const meta = {
fn,
lastRun: 0,
failureCount: 0,
cooldownMs,
maxFailures,
onFailureThreshold
};
if (daily) dailyMap.set(id, meta);
else functionMap.set(id, meta);
},
unregister(id, { daily = false } = {}) {
if (!id) return;
logger_default("toggle:scheduler", `Unregistering ${daily ? "daily" : "regular"} toggle: ${id}`);
if (daily) dailyMap.delete(id);
else functionMap.delete(id);
},
runAll({ onProgress = null } = {}) {
const entries2 = Array.from(functionMap.entries());
logger_default("toggle:scheduler", `runAll: ${entries2.length} regular toggles queued`);
runEntriesSequentially(entries2, { onProgress, daily: false });
},
runDaily() {
const entries2 = Array.from(dailyMap.entries());
logger_default("toggle:scheduler", `runDaily: ${entries2.length} daily toggles queued`);
runEntriesSequentially(entries2, { daily: true });
},
runAllDaily() {
this.runDaily();
},
runFrame({
isLoad = false,
onProgress = null,
onFrameState = null,
onWatchdogRestore = null
} = {}) {
if (isLoad) {
logger_default("toggle:scheduler", "Skipping frame: page is loading");
return false;
}
if (frameExpected > 0 && frameProgress < frameExpected) {
frameFailures += 1;
const pendingSample = getFramePendingSample();
logger_default(
"toggle:scheduler",
`Frame watchdog: progress ${frameProgress}/${frameExpected} (failures: ${frameFailures})` + (frameLastProgressKey ? `; last completed: ${frameLastProgressKey}` : "") + (framePending.size ? `; pending ${framePending.size}: ${pendingSample.join(", ")}${framePending.size > pendingSample.length ? ", ..." : ""}` : ""),
{
level: "warn"
}
);
if (typeof onFrameState === "function") {
onFrameState({ expected: frameExpected, progress: frameProgress, failures: frameFailures });
}
if (frameFailures > DEFAULT_MAX_FAILURES) {
const pendingSample2 = getFramePendingSample();
logger_default(
"toggle:scheduler",
`Watchdog triggered: failures exceeded max (${frameFailures} > ${DEFAULT_MAX_FAILURES})` + (framePending.size ? `; pending ${framePending.size}: ${pendingSample2.join(", ")}${framePending.size > pendingSample2.length ? ", ..." : ""}` : ""),
{
level: "warn"
}
);
this.restore({ onRestore: onWatchdogRestore });
}
return false;
}
const entries2 = Array.from(functionMap.entries());
if (!entries2.length) {
resetFrameState();
if (typeof onFrameState === "function") {
onFrameState({ expected: 0, progress: 0, failures: 0 });
}
return false;
}
frameExpected = entries2.length;
frameProgress = 0;
frameFailures = 0;
framePending = new Set(entries2.map(([key]) => key));
frameLastProgressKey = null;
logger_default("toggle:scheduler", `runFrame: Starting frame with ${frameExpected} toggles`);
if (typeof onFrameState === "function") {
onFrameState({ expected: frameExpected, progress: frameProgress, failures: frameFailures });
}
this.scheduleRunAll({
onProgress: (key) => {
frameProgress += 1;
frameLastProgressKey = key;
framePending.delete(key);
if (typeof onProgress === "function") onProgress(key);
}
});
return true;
},
// schedule a coalesced run; multiple calls within a frame result in a single execution
scheduleRunAll({ onProgress = null } = {}) {
if (scheduledRun) {
logger_default("toggle:scheduler", "scheduleRunAll: Already scheduled, skipping coalesce");
return;
}
scheduledRun = true;
requestAnimationFrame(() => {
try {
this.runAll({ onProgress });
} finally {
scheduledRun = false;
}
});
},
getBundles() {
return {
functionbundle: Object.fromEntries(
Array.from(functionMap.entries()).map(([k, meta]) => [k, meta.fn])
),
dailyfunctionbundle: Object.fromEntries(
Array.from(dailyMap.entries()).map(([k, meta]) => [k, meta.fn])
)
};
},
clearAll() {
logger_default(
"toggle:scheduler",
`Clearing all toggles: ${functionMap.size} regular + ${dailyMap.size} daily`
);
functionMap.clear();
dailyMap.clear();
},
reset() {
logger_default("toggle:scheduler", "Resetting scheduler state");
this.clearAll();
resetFrameState();
},
restore({ onRestore = null } = {}) {
logger_default("toggle:scheduler", "Restoring scheduler (full reset)", { level: "warn" });
this.reset();
if (typeof onRestore === "function") onRestore();
},
getFunction(id, { daily = false } = {}) {
const map = daily ? dailyMap : functionMap;
const meta = map.get(id);
return meta?.fn;
},
has(id, { daily = false } = {}) {
return (daily ? dailyMap : functionMap).has(id);
},
list({ daily = null } = {}) {
if (daily === true) return [...dailyMap.keys()];
if (daily === false) return [...functionMap.keys()];
return [...functionMap.keys(), ...dailyMap.keys()];
}
};
// src/core/sugarcube/state.js
function getSugarCube() {
const rw2 = getRuntimeWindow();
return rw2?.SugarCube ?? null;
}
function getVars() {
return getSugarCube()?.State?.variables ?? null;
}
function getSetup() {
return getSugarCube()?.setup ?? null;
}
function getPassage() {
return getVars()?.passage ?? null;
}
function isReady() {
return Boolean(getSugarCube()?.State?.variables);
}
// src/core/sugarcube/selectors.js
function tokenizePath(path7) {
if (typeof path7 !== "string" || !path7.trim()) return [];
const matches = path7.match(/[^.[\]]+/g);
return matches ?? [];
}
function readAtPath(obj, path7) {
const tokens = tokenizePath(path7);
if (!tokens.length) return void 0;
let cursor = obj;
for (const token of tokens) {
if (cursor == null || typeof cursor !== "object" || !(token in cursor)) return void 0;
cursor = cursor[token];
}
return cursor;
}
function getVariable(key) {
return getVars()?.[key];
}
function setVariable(key, value) {
const vars = getVars();
if (vars) vars[key] = value;
}
function getVariablePath(path7) {
return readAtPath(getVars(), path7);
}
function getSetupKey(key) {
return getSetup()?.[key];
}
function getNPCName() {
return getVars()?.NPCName ?? null;
}
function getStoredNPCs() {
return getVars()?.storedNPCs ?? null;
}
function getSexStats() {
return getVars()?.sexStats ?? null;
}
function getCheatPlus() {
return getVars()?.cheatPlus ?? null;
}
function getFarm() {
return getVars()?.farm ?? null;
}
function getChildren() {
return getVars()?.children ?? null;
}
function getContainer() {
return getVars()?.container ?? null;
}
// src/core/sugarcube/quirks.js
function isAtPassage(name) {
return getPassage() === name;
}
function isAtSettings() {
return isAtPassage("Settings");
}
// src/core/sugarcube/adapter.js
var scAdapter = {
// --- State access ---
getVariables: getVars,
getVariable,
setVariable,
// --- Setup ---
getSetup,
getSetupKey,
// --- Passage / navigation ---
getCurrentPassage: getPassage,
isAtPassage,
// --- Lifecycle ---
isReady
};
// src/features/utils/value-tree.js
function isCanonicalArrayIndex(key, length) {
if (!/^\d+$/.test(key)) return false;
const index = Number(key);
return Number.isInteger(index) && index >= 0 && index < length && String(index) === key;
}
function walkValueTree(rootValue, rootPath, visitor) {
let stopped = false;
const stop = () => {
stopped = true;
};
function visit(value, path7, parentIsArray = false, key = "") {
if (stopped) return;
visitor(value, path7, { parentIsArray, key, stop });
if (stopped) return;
if (Array.isArray(value)) {
for (let index = 0; index < value.length; index++) {
visit(value[index], `${path7}[${index}]`, true, String(index));
if (stopped) return;
}
const objectKeys = Object.keys(value);
for (const objectKey of objectKeys) {
if (isCanonicalArrayIndex(objectKey, value.length)) continue;
visit(value[objectKey], `${path7}[${objectKey}]`, true, objectKey);
if (stopped) return;
}
return;
}
if (typeof value === "object" && value !== null) {
for (const childKey in value) {
visit(value[childKey], `${path7}.${childKey}`, false, childKey);
if (stopped) return;
}
}
}
visit(rootValue, rootPath);
}
// src/features/search-actions.js
function executeSearch(action) {
const vars = getVars();
if (!vars) return;
const searchTypeMap = ["startsWith", "includes", "endsWith"];
const searchTypeEl = byUiId("search_type");
const searchType = searchTypeMap[searchTypeEl && searchTypeEl.value || 0] || "startsWith";
const searchValueEl = byUiId("search_value");
const searchTerm = searchValueEl && searchValueEl.value.trim().toLowerCase() || "";
const searchResult = byUiId("search_result");
if (!searchResult) return;
searchResult.value = "Result :\n";
if (!searchTerm) {
showToast("failed, Search key is blank!");
return;
}
function checkObject(key, value, newPath) {
if (key.toLowerCase()[searchType](searchTerm) && value !== "") {
searchResult.value += `${newPath}=${value}
`;
}
}
function shouldMatchValue(value) {
return !Array.isArray(value) && (typeof value !== "object" || value === null);
}
if (action === "search123") {
showToast("Searching... might take a while");
walkValueTree(vars, "SugarCube.State.variables", (value, path7, meta) => {
if (shouldMatchValue(value) && String(value).toLowerCase()[searchType](searchTerm) && value !== "") {
searchResult.value += `${path7}=${value}
`;
}
if (!meta.parentIsArray && meta.key) {
checkObject(meta.key, value, path7);
}
});
} else if (action === "search456") {
showToast("Searching...");
for (const prop in vars) {
if (prop.toLowerCase()[searchType](searchTerm)) {
searchResult.value += `SugarCube.State.variables.${prop}=${vars[prop]}
`;
}
}
}
}
function restoreVariables() {
let triggered = false;
const bundles = ToggleScheduler.getBundles();
if (getVariable("alluremod") === 0) {
setVariable("alluremod", 1);
showToast("Encounter rate enabled!");
}
if (typeof bundles.functionbundle["allNPCInstaPregnant"] === "function") {
dispatch("allNPCInstaPregnant");
showToast("NPC instant pregnant is disabled!");
triggered = true;
}
if (triggered) {
showToast("This ensure the game settings isnt break.");
showToast("You can re-enable it after youre done.");
}
}
// src/core/runtime-state.js
function getRuntime(path7) {
return get(`runtime.${path7}`);
}
function setRuntime(path7, value) {
set(`runtime.${path7}`, value);
}
function getIsLoad() {
return Boolean(getRuntime("isLoad"));
}
function setIsLoad(value) {
setRuntime("isLoad", Boolean(value));
}
function getClickCounter() {
return Number(getRuntime("clickCounter") ?? 0);
}
function incrementClickCounter() {
const next = getClickCounter() + 1;
setRuntime("clickCounter", next);
return next;
}
function decrementClickCounter() {
const next = getClickCounter() - 1;
setRuntime("clickCounter", next);
return next;
}
function getCurDate() {
return Number(getRuntime("curDate") ?? 0);
}
function setCurDate(value) {
setRuntime("curDate", Number(value) || 0);
}
function getExtraNotif() {
return Boolean(getRuntime("extraNotif"));
}
function setExtraNotif(value) {
setRuntime("extraNotif", Boolean(value));
}
function getReactivatingToggles() {
return Boolean(getRuntime("reactivatingToggles"));
}
function setReactivatingToggles(value) {
setRuntime("reactivatingToggles", Boolean(value));
}
function getIsTestingAllFunction() {
return Boolean(getRuntime("isTestingAllFunction"));
}
function setIsTestingAllFunction(value) {
setRuntime("isTestingAllFunction", Boolean(value));
}
function getPcPregnant() {
return Number(getRuntime("pcPregnant") ?? 0);
}
function setPcPregnant(value) {
setRuntime("pcPregnant", Number(value) || 0);
}
function getTotalNpcPregnant() {
return Number(getRuntime("totalNpcPregnant") ?? 0);
}
function setTotalNpcPregnant(value) {
setRuntime("totalNpcPregnant", Number(value) || 0);
}
// src/ui/renderers/cheat-form.js
function executeFunctionsInObject(obj) {
if (getIsTestingAllFunction()) return;
setIsTestingAllFunction(true);
let total = 0;
for (const key in obj) {
if (typeof obj[key] === "function") {
console.log(`Executing function at key: ${key}`);
obj[key]();
total++;
}
}
timedToast("testing complete", 5e3);
timedToast(`Total function tested ${total}`, 5e3);
setIsTestingAllFunction(false);
}
// src/features/cheat/debug-actions.js
var debugActions = {
testAll: function(actionBag = debugActions) {
showToast("Testing all functions...");
executeFunctionsInObject(actionBag);
}
};
var debug_actions_default = debugActions;
// src/features/fetchers/core-updates.js
var core_updates_exports = {};
__export(core_updates_exports, {
arousalpicked: () => arousalpicked,
ballscurrent: () => ballscurrent,
bodycurrent: () => bodycurrent,
bodytypecurrent: () => bodytypecurrent,
characurrent: () => characurrent,
crimecurrent: () => crimecurrent,
cumcurrent: () => cumcurrent,
default: () => core_updates_default,
examcurrent: () => examcurrent,
famecurrent: () => famecurrent,
lactatingcurrent: () => lactatingcurrent,
milkcurrent: () => milkcurrent,
npccurrent: () => npccurrent,
setButtonText: () => setButtonText,
spraystate: () => spraystate,
statpick: () => statpick,
statpicke: () => statpicke,
talentcurrent: () => talentcurrent,
update_pregnancy: () => update_pregnancy,
update_school_rep: () => update_school_rep,
virginitycurrent: () => virginitycurrent,
vowcurrent: () => vowcurrent
});
// src/ui/helpers/hydrate-utils.js
function getUi(id) {
return byUiId(id);
}
function withElements(ids, cb) {
const elements = {};
for (const [key, id] of Object.entries(ids)) {
const element = byUiId(id);
if (!element) return false;
elements[key] = element;
}
cb(elements);
return true;
}
function setText(id, text2, { hideWhenEmpty = false } = {}) {
const element = byUiId(id);
if (!element) return false;
const normalized = String(text2 ?? "");
element.textContent = normalized;
if (hideWhenEmpty) {
element.style.display = normalized.trim() ? "" : "none";
}
return true;
}
function setValue(id, value, { skipWhenNullish = false } = {}) {
const element = byUiId(id);
if (!element) return false;
if (skipWhenNullish && value == null) return false;
element.value = value == null ? "" : value;
return true;
}
function setChecked(id, checked) {
const element = byUiId(id);
if (!element) return false;
element.checked = Boolean(checked);
return true;
}
function setOptions(id, options6) {
const element = byUiId(id);
if (!element) return false;
replaceSelectOptions(element, options6);
return true;
}
function setRangeOptions(id, length, { start = 0 } = {}) {
const count = Number.isFinite(length) ? Math.max(0, Number(length)) : 0;
const options6 = Array.from({ length: count }, (_, index) => {
const value = start + index;
return { value, label: String(value) };
});
return setOptions(id, options6);
}
function syncInputFromSelect({ selectId, inputId, readValue }) {
return withElements({ select: selectId, input: inputId }, ({ select, input }) => {
if (select.value === "") return;
input.value = readValue(select.value) ?? "";
});
}
// src/features/fetchers/core-updates.js
function setButtonText(id, text2) {
setText(id, text2, { hideWhenEmpty: true });
}
function statpick() {
syncInputFromSelect({
selectId: "statpick",
inputId: "statinput",
readValue: (key) => getVariable(key)
});
}
function statpicke() {
syncInputFromSelect({
selectId: "statpicke",
inputId: "statinpute",
readValue: (key) => getVariable(key)
});
}
function spraystate() {
setButtonText("sprayset", getVariable("infinitespray") == 1 ? "unset" : "set");
}
function bodycurrent() {
const sizeNames = ["Tiny", "Small", "Normal", "Large"];
setButtonText("bodycurrent", sizeNames[getVariable("bodysize")] || "Unknown");
}
function bodytypecurrent() {
const genderMap = { m: "Masculine", f: "Feminine", a: "Androgynous" };
setButtonText("bodytypecurrent", genderMap[getVariablePath("player.gender_body")] || "Unknown");
}
function ballscurrent() {
getVariablePath("player.ballsExist") ? setButtonText("ballsset", "remove") : setButtonText("ballsset", "add");
}
function virginitycurrent() {
const pick = getUi("virginitypick");
if (!pick) return;
getVariablePath(`player.virginity.${pick.value}`) ? setButtonText("virginitycurrent", "pure") : setButtonText("virginitycurrent", "taken");
}
function crimecurrent() {
const crime = getVariable("crime");
if (!crime) return;
let total = 0;
for (const key in crime) {
if (key !== "events") total += crime[key].current;
}
setButtonText("crimecurrent", total);
}
function vowcurrent() {
setButtonText("vow-virgin", getVariablePath("player.virginity.temple") ? "Virgin" : "Not Virgin");
}
function characurrent() {
syncInputFromSelect({
selectId: "charapick",
inputId: "charainput",
readValue: (key) => getVariable(key)
});
}
function lactatingcurrent() {
getVariable("lactating") ? setButtonText("lactatingset", "No") : setButtonText("lactatingset", "Yes");
}
function milkcurrent() {
setValue("milkinput", getVariable("milk_volume"));
}
function cumcurrent() {
setValue("cuminput", getVariable("semen_volume"));
}
function famecurrent() {
syncInputFromSelect({
selectId: "fame_name",
inputId: "input_fame12",
readValue: (key) => getVariablePath(`fame.${key}`)
});
}
function npccurrent() {
withElements(
{
name: "npcnames",
trait: "npctraits",
input: "npcchangeinput"
},
({ name, trait, input }) => {
const npc = (getNPCName() ?? []).find((entry2) => entry2.description === name.value);
if (npc) input.value = npc[trait.value];
}
);
}
function examcurrent() {
syncInputFromSelect({
selectId: "select_exam",
inputId: "input_exam",
readValue: (key) => getVariable(key)
});
}
function talentcurrent() {
syncInputFromSelect({
selectId: "select_talent",
inputId: "input_talent",
readValue: (key) => getVariable(key)
});
}
function arousalpicked() {
const val = getUi("arousal_val");
if (val) setButtonText("arousal_preview", val.value + "%");
}
function update_pregnancy() {
setButtonText("pc_pregnancy", "MC = " + (getPcPregnant() ?? 0));
setButtonText("npc_pregnancy", "NPC = " + (getTotalNpcPregnant() ?? 0));
}
function update_school_rep() {
syncInputFromSelect({
selectId: "select_school_rep",
inputId: "input_school_rep",
readValue: (key) => getVariable(key)
});
}
var coreUpdates = {
setButtonText,
statpick,
statpicke,
spraystate,
bodycurrent,
bodytypecurrent,
ballscurrent,
virginitycurrent,
crimecurrent,
vowcurrent,
characurrent,
lactatingcurrent,
milkcurrent,
cumcurrent,
famecurrent,
npccurrent,
examcurrent,
talentcurrent,
arousalpicked,
update_pregnancy,
update_school_rep
};
var core_updates_default = coreUpdates;
// src/features/fetchers/misc-updates.js
var misc_updates_exports = {};
__export(misc_updates_exports, {
default: () => misc_updates_default,
randomEncounterUpdate: () => randomEncounterUpdate,
update_cheat_state: () => update_cheat_state,
update_farm_animals_like: () => update_farm_animals_like,
update_farm_assault_day: () => update_farm_assault_day,
update_farm_buildtime: () => update_farm_buildtime
});
function update_cheat_state() {
const button = getUi("in_game_cheat");
if (!button) return;
const debug = getVariable("debug");
const label = button.textContent?.trim() ?? "";
if (debug === 1 && label.startsWith("Enable") || debug === 0 && label.startsWith("Disable")) {
const isEnabled = button.innerHTML === "Enable";
setVariable("debug", isEnabled ? 1 : 0);
button.innerHTML = isEnabled ? "Disable" : "Enable";
}
}
function update_farm_assault_day() {
const timer = getVariable("farm_attack_timer");
if (timer != null) setValue("assault_time", timer);
}
function update_farm_buildtime() {
const timer = getVariablePath("farm.build_timer");
if (timer != null) setValue("build_time", timer);
}
function update_farm_animals_like() {
const farm = getFarm();
if (!farm) return;
withElements({ animal: "animal_choice", input: "animal_input" }, ({ animal, input }) => {
input.value = farm.beasts?.[animal.value] ?? "";
});
}
function randomEncounterUpdate() {
setText("randomEncounterSet", getVariable("alluremod") === 0 ? "Disabled" : "Enabled");
}
var miscUpdates = {
update_cheat_state,
update_farm_assault_day,
update_farm_buildtime,
update_farm_animals_like,
randomEncounterUpdate
};
var misc_updates_default = miscUpdates;
// src/features/fetchers/offspring-updates.js
var offspring_updates_exports = {};
__export(offspring_updates_exports, {
default: () => offspring_updates_default,
update_mc_abortion_list: () => update_mc_abortion_list,
update_mc_baby_info: () => update_mc_baby_info,
update_mc_baby_list: () => update_mc_baby_list,
update_mc_tentacle: () => update_mc_tentacle,
update_mc_tentacle_input: () => update_mc_tentacle_input,
update_named_npc_abortion_list: () => update_named_npc_abortion_list,
update_npc_abortion_list: () => update_npc_abortion_list,
update_npc_fetus_abortion_list: () => update_npc_fetus_abortion_list
});
// src/config/game-data.js
var downloadSite = "https://www.mediafire.com/folder/d6uiwpcm3y0gu/degrees_of_lewdity";
var sourceCode = "https://github.com/Zenix-Al/DoL-CheatPlus.git";
var npctrait = ["trust", "love", "dom", "lust", "rage", "trauma", "purity", "corruption"];
var characteristics = [
"beauty",
"purity",
"physique",
"willpower",
"awareness",
"promiscuity",
"exhibitionism",
"deviancy",
"grace",
"submissive",
"masochism",
"sadism"
];
var bodyparts = [
"nipples",
"bottom",
"penis",
"balls",
"clit",
"anus",
"vagina",
"labia",
"left_thigh",
"right_thigh",
"left_foot",
"right_foot",
"left_arm",
"right_arm",
"left_hand",
"right_hand",
"tummy",
"back",
"face",
"mouth",
"left_ear",
"right_ear",
"hair"
];
var parasitename = ["urchin", "slime", "maggot"];
var fame = [
"exhibitionism",
"prostitution",
"bestiality",
"sex",
"rape",
"good",
"business",
"scrap",
"pimp",
"social",
"model",
"pregnancy",
"impreg"
];
var school_rep = ["delinquency", "cool"];
var exam = ["science_exam", "maths_exam", "english_exam", "history_exam"];
var talent_skill = [
"danceskill",
"swimmingskill",
"skulduggery",
"athletics",
"tending",
"housekeeping"
];
var hentaiSkill = [
"seductionskill",
"oralskill",
"vaginalskill",
"analskill",
"handskill",
"feetskill",
"bottomskill",
"thighskill",
"chestskill",
"penileskill"
];
var babyOptions = ["motherKnown", "fatherKnown", "name", "abandon"];
var babyOptionsText = ["mother Known", "father Known", "name", "Abandon"];
// src/features/fetchers/offspring-updates.js
var mcBabyListOptionsLoaded = false;
function update_mc_tentacle() {
withElements({ location: "mc_tentacle_location" }, ({ location }) => {
const creatures = getContainer()?.[location.value]?.creatures ?? {};
const options6 = Object.entries(creatures).filter(([, creature]) => creature != null).map(([key, creature]) => ({ value: key, label: creature.creature }));
setOptions("mc_tentacle_select", options6);
});
update_mc_tentacle_input();
}
function update_mc_tentacle_input() {
withElements(
{
select: "mc_tentacle_select",
location: "mc_tentacle_location",
input: "mc_tentacle_input"
},
({ select, location, input }) => {
if (select.value === "") return;
input.value = getContainer()?.[location.value]?.creatures?.[select.value]?.stats?.speed ?? "";
}
);
}
function update_mc_baby_info() {
withElements(
{
babySelect: "mc_baby_select",
actionSelect: "mc_baby_action_select",
input: "mc_baby_input",
tooltip: "mc_baby_tooltip"
},
({ babySelect, actionSelect, input, tooltip }) => {
const child = getChildren()?.[babySelect.value];
if (!child) return;
const tooltipText = tooltip.querySelector("span");
if (tooltipText) {
tooltipText.textContent = `Name: ${child.name}, Father: ${child.father}, Mother: ${child.mother}, Location: ${child.birthLocation}`;
}
if (actionSelect.value === "name") {
input.type = "text";
input.value = child[actionSelect.value] || "";
} else {
input.type = "checkbox";
input.checked = Boolean(child[actionSelect.value]);
}
}
);
}
function update_mc_baby_list() {
const hasUi = withElements(
{ babyActionSelect: "mc_baby_action_select", babyInput: "mc_baby_input" },
({ babyActionSelect, babyInput }) => {
setOptions(
"mc_baby_select",
Object.keys(getChildren() ?? {}).map((key) => ({ value: key, label: key }))
);
update_mc_baby_info();
if (!mcBabyListOptionsLoaded) {
mcBabyListOptionsLoaded = true;
babyInput.style.display = "";
babyActionSelect.innerHTML = "";
Object.entries(babyOptions).forEach(([key, value]) => {
babyActionSelect.append(new Option(babyOptionsText[key], value));
});
}
}
);
if (!hasUi) return;
}
function update_mc_abortion_list() {
withElements({ location: "mc_abortion_location" }, ({ location }) => {
const totalFetus = getSexStats()?.[location.value]?.pregnancy?.fetus?.length ?? 0;
setRangeOptions("mc_abortion_select", totalFetus);
});
}
function update_named_npc_abortion_list() {
withElements({ selectedNpc: "named_npc_abortion_chara_select" }, ({ selectedNpc: selectedNpc2 }) => {
let totalFetus = 0;
for (const npc of getNPCName() ?? []) {
if (npc.description === selectedNpc2.value && typeof npc.pregnancy.fetus === "object") {
totalFetus = npc.pregnancy.fetus.length;
}
}
setRangeOptions("named_npc_abortion_select", totalFetus);
});
}
function update_npc_abortion_list() {
const storedNpcs = getStoredNPCs();
if (typeof storedNpcs?.pregnancy_0 !== "object") return false;
const hasUi = withElements({ abortionSelect: "npc_abortion_chara_select" }, () => {
});
if (!hasUi) return false;
const options6 = [];
let number = 1;
for (const key in storedNpcs) {
options6.push({
value: key,
label: number + ". " + storedNpcs[key].pregnancy.fetus[0].mother
});
number++;
}
for (const key in getCheatPlus()?.storedNPCs ?? {}) {
options6.push({
value: key,
label: number + ". " + getCheatPlus().storedNPCs[key].pregnancy.fetus[0].mother
});
number++;
}
setOptions("npc_abortion_chara_select", options6);
return true;
}
function update_npc_fetus_abortion_list() {
withElements({ abortionCharaSelect: "npc_abortion_chara_select" }, ({ abortionCharaSelect }) => {
const selected = abortionCharaSelect.value;
let totalFetus = 0;
if (selected.match(/pregnancy/)) {
totalFetus = getStoredNPCs()?.[selected]?.pregnancy?.fetus?.length ?? 0;
} else if (selected.match(/stored/)) {
totalFetus = getCheatPlus()?.storedNPCs?.[selected]?.pregnancy?.fetus?.length ?? 0;
}
setRangeOptions("npc_abortion_select", totalFetus);
});
}
var offspringUpdates = {
update_mc_tentacle,
update_mc_tentacle_input,
update_mc_baby_info,
update_mc_baby_list,
update_mc_abortion_list,
update_named_npc_abortion_list,
update_npc_abortion_list,
update_npc_fetus_abortion_list
};
var offspring_updates_default = offspringUpdates;
// src/features/fetchers/pregnancy-updates.js
var pregnancy_updates_exports = {};
__export(pregnancy_updates_exports, {
default: () => pregnancy_updates_default,
update_pregnancy_day_mc: () => update_pregnancy_day_mc,
update_pregnancy_day_named_npc: () => update_pregnancy_day_named_npc,
update_pregnancy_day_npc: () => update_pregnancy_day_npc,
update_pregnancy_list_mc: () => update_pregnancy_list_mc,
update_pregnancy_list_named_npc: () => update_pregnancy_list_named_npc,
update_pregnancy_list_npc: () => update_pregnancy_list_npc
});
// src/features/cheat/pregnancy-lock-state.js
var named_npc_pregnancy_locked = [];
var named_npc_pregnancy_locked_day = [];
var npc_pregnancy_locked = [];
var npc_pregnancy_locked_day = [];
var mc_pregnancy_locked = [];
var mc_pregnancy_locked_hole = [];
var mc_pregnancy_locked_type = [];
var mc_pregnancy_locked_day = [];
// src/features/fetchers/pregnancy-updates.js
function update_pregnancy_list_named_npc() {
update_pregnancy_day_named_npc();
}
function update_pregnancy_day_named_npc() {
withElements({ select: "named_npc_pregnancy_manager" }, ({ select }) => {
if (select.value === "") return;
const npc = getNPCName()?.[Number(select.value)];
if (!npc?.pregnancy || npc.pregnancy.timerEnd == null || npc.pregnancy.timer == null) return;
setValue("named_npc_pregnancy_input", (npc.pregnancy.timerEnd - npc.pregnancy.timer) / 3);
setChecked(
"named_npc_pregnancy_toggle",
Array.isArray(named_npc_pregnancy_locked) ? named_npc_pregnancy_locked.includes(select.value) : false
);
});
}
function update_pregnancy_list_npc() {
update_pregnancy_day_npc();
}
function update_pregnancy_day_npc() {
withElements({ select: "npc_pregnancy_manager" }, ({ select }) => {
if (select.value === "") return;
const npc = getStoredNPCs()?.[select.value];
if (!npc?.pregnancy || npc.pregnancy.timerEnd == null || npc.pregnancy.timer == null) return;
setValue("npc_pregnancy_input", (npc.pregnancy.timerEnd - npc.pregnancy.timer) / 3);
setChecked(
"npc_pregnancy_toggle",
Array.isArray(npc_pregnancy_locked) ? npc_pregnancy_locked.includes(select.value) : false
);
});
}
function update_pregnancy_list_mc() {
withElements({ hole: "mc_pregnancy_hole" }, ({ hole }) => {
const pregnancy = getSexStats()?.[hole.value]?.pregnancy;
if (!pregnancy) {
setOptions("mc_pregnancy_manager", []);
return;
}
if (pregnancy.type == "parasite") {
const options6 = Object.entries(pregnancy.fetus ?? {}).map(([key, fetus]) => ({
value: key,
label: fetus?.creature ?? key
}));
setOptions("mc_pregnancy_manager", options6);
} else if (pregnancy.timerEnd != null) {
setOptions("mc_pregnancy_manager", [{ value: "baby", label: "baby" }]);
} else {
setOptions("mc_pregnancy_manager", []);
}
});
}
function update_pregnancy_day_mc() {
withElements(
{
select: "mc_pregnancy_manager",
hole: "mc_pregnancy_hole"
},
({ select, hole }) => {
if (select.value === "") return;
const pregnancy = getSexStats()?.[hole.value]?.pregnancy;
if (!pregnancy) return;
const pregType = pregnancy.type;
if (pregType == "parasite") {
setValue("mc_pregnancy_input", pregnancy.fetus?.[select.value]?.daysLeft ?? "");
} else {
if (pregnancy.timerEnd == null || pregnancy.timer == null) return;
setValue("mc_pregnancy_input", (pregnancy.timerEnd - pregnancy.timer) / 3);
}
const lockIndex = Array.isArray(mc_pregnancy_locked) ? mc_pregnancy_locked.findIndex((name) => name == select.value) : -1;
const lockState = lockIndex === -1 ? 0 : mc_pregnancy_locked_hole[lockIndex] != hole.value ? 1 : mc_pregnancy_locked_type[lockIndex] != pregType ? 2 : 3;
setChecked("mc_pregnancy_toggle", lockState === 3);
}
);
}
var pregnancyUpdates = {
update_pregnancy_list_named_npc,
update_pregnancy_day_named_npc,
update_pregnancy_list_npc,
update_pregnancy_day_npc,
update_pregnancy_list_mc,
update_pregnancy_day_mc
};
var pregnancy_updates_default = pregnancyUpdates;
// src/features/fetchers/index.js
function runHydrators(handlers) {
handlers.forEach((handler) => {
if (typeof handler === "function") handler();
});
}
var quickHydrators = [
arousalpicked,
vowcurrent,
update_cheat_state,
randomEncounterUpdate,
update_pregnancy,
update_toggle
];
var miscHydrators = [];
function update_toggle() {
const bundles = ToggleScheduler.getBundles();
const allActive = {
...bundles.functionbundle,
...bundles.dailyfunctionbundle
};
for (const id in allActive) {
if (typeof allActive[id] === "function") {
const button = byUiId(id) || document.getElementById(id);
if (button) button.classList.add("cp-toggle-active");
}
}
}
function update_pregnancy_mc() {
update_pregnancy_list_mc();
update_pregnancy_day_mc();
}
function hydrateQuickSection() {
runHydrators(quickHydrators);
void getActiveCheatBuilder()?.sectionOpened("quick");
}
function hydrateStatsSection() {
void getActiveCheatBuilder()?.sectionOpened("stats");
}
function hydrateMiscSection() {
runHydrators(miscHydrators);
void getActiveCheatBuilder()?.sectionOpened("misc");
}
var fetcherActions = {
update_toggle,
...core_updates_exports,
...pregnancy_updates_exports,
...offspring_updates_exports,
...misc_updates_exports
};
var hydrateCheatUi = fetcherActions;
var hydratePregnancy = {
update_pregnancy_mc
};
// src/features/cheat/player-body-actions.js
function createPlayerBodyActions() {
return {
bodytypemanager() {
const bodytypepick = byUiId("bodytypepick")?.value;
const bodyTypes = { Masculine: "m", Feminine: "f", Androgynous: "a" };
if (bodytypepick in bodyTypes) {
getVars().player.gender_body = bodyTypes[bodytypepick];
showToast("Activated!");
hydrateCheatUi.bodytypecurrent();
} else {
showToast("Failed!");
}
},
sprayunlimited() {
getVars().infinitespray = getVars().infinitespray === 1 ? 0 : 1;
showToast("Activated!");
hydrateCheatUi.spraystate();
},
ballsmanager() {
if (getVars().player.ballsExist === void 0) return;
getVars().player.ballsExist = !getVars().player.ballsExist;
showToast("Activated!");
hydrateCheatUi.ballscurrent();
},
virginitymanager() {
const virginitypick = byUiId("virginitypick").value;
if (getVars().player.virginity === void 0) return;
getVars().player.virginity[virginitypick] = true;
hydrateCheatUi.virginitycurrent();
showToast("Activated!");
},
virginitypure() {
if (getVars().player.virginity === void 0) return;
const virginitypick = byUiId("virginitypick");
const options6 = virginitypick.getElementsByTagName("option");
for (let index = 0; index < options6.length; index++) {
getVars().player.virginity[options6[index].value] = true;
}
hydrateCheatUi.virginitycurrent();
showToast("Activated!");
},
charamanager() {
const statpick2 = byUiId("charapick").value;
const value = parseInt(byUiId("charainput").value);
if (!isNaN(value)) {
showToast("Activated!");
getVars()[statpick2] = value;
}
},
lactatingmanager() {
getVars().lactating = getVars().lactating == 1 ? 0 : 1;
hydrateCheatUi.lactatingcurrent();
showToast("Activated!");
},
cummanager() {
const value = parseInt(byUiId("cuminput").value);
if (!isNaN(value)) {
showToast("Activated!");
getVars().semen_volume = value;
hydrateCheatUi.cumcurrent();
}
},
milkmanager() {
const value = parseInt(byUiId("milkinput").value);
if (!isNaN(value)) {
showToast("Activated!");
getVars().milk_volume = value;
hydrateCheatUi.milkcurrent();
}
},
cumfill() {
getVars().semen_amount = getVars().semen_volume;
showToast("Activated!");
},
milkfill() {
getVars().milk_amount = getVars().milk_volume;
showToast("Activated!");
},
infect() {
if (getVars().parasite === void 0) return;
showToast("Activated!");
const parasite = byUiId("parasitename").value;
const body = byUiId("bodyparts").value;
getVars().parasite[parasite].push(body);
getVars().parasite[body].name = parasite;
},
desinfect() {
if (getVars().parasite === void 0) return;
showToast("Activated!");
const parasite = byUiId("parasitename").value;
const body = byUiId("bodyparts").value;
getVars().parasite[body] = [];
getVars().parasite[parasite] = getVars().parasite[parasite].filter((item) => item !== body);
}
};
}
// src/core/game-context.js
var runtimeWindow = getRuntimeWindow();
var runtimeSugarCube = runtimeWindow?.SugarCube;
var testedOn = runtimeWindow?.testedOn ?? "0.0.0";
var cheatVer = runtimeWindow?.cheatVer ?? (true ? "3.0.0" : "dev");
var isServer = runtimeWindow?.isServer ?? 0;
var cheatVerType = runtimeWindow?.cheatVerType ?? "";
var curVer = document.getElementById(GAME_VERSION_ELEMENT_ID)?.innerHTML ?? "";
var npcnamelist = runtimeSugarCube?.setup?.NPCNameList ?? [];
if (curVer?.startsWith(".")) curVer = "0" + curVer;
function getNpcNameList() {
return npcnamelist;
}
// src/features/cheat/player-progression-actions.js
function createPlayerProgressionActions() {
return {
changetraitbro() {
if (getVars().NPCName === void 0) return;
const npcName = byUiId("npcnames").value;
const trait = byUiId("npctraits").value;
const value = parseInt(byUiId("npcchangeinput").value);
if (!isNaN(value)) {
const npcnamelist2 = getNpcNameList();
for (let index = 0; index < npcnamelist2.length; index++) {
if (getVars().NPCName[index].description === npcName) {
getVars().NPCName[index][trait] = value;
showToast("Activated!");
break;
}
}
}
},
set_fame12() {
const selected = byUiId("fame_name").value;
const input = parseInt(byUiId("input_fame12").value);
if (isNaN(input)) {
showToast("failed : input is not a number!");
return;
}
if (getVars().fame[selected] === void 0) {
showToast("failed!");
return;
}
getVars().fame[selected] = input;
showToast("Activated!");
},
exammanager() {
const selected = byUiId("select_exam").value;
const input = parseInt(byUiId("input_exam").value);
if (isNaN(input)) {
showToast("failed : input is not a number!");
return;
}
getVars()[selected] = input;
showToast("Activated!");
},
talentmanager() {
const selected = byUiId("select_talent").value;
const input = parseInt(byUiId("input_talent").value);
if (isNaN(input)) {
showToast("failed : input is not a number!");
return;
}
getVars()[selected] = input;
showToast("Activated!");
},
set_hentai_skill() {
showToast("Activated!");
const selected = byUiId("select_hentai_skill").value;
const input = parseInt(byUiId("input_hentai_skill").value);
if (!selected || isNaN(input)) return;
getVars()[selected] = input;
}
};
}
// src/features/cheat/player-stats-actions.js
function createPlayerStatsActions() {
return {
arousal_player() {
const value = byUiId("arousal_val").value;
if (isNaN(value)) return;
showToast("Activated!");
getVars().arousal = parseInt(1e4 * value / 100);
},
arousal_enemy() {
const value = byUiId("arousal_val").value;
if (isNaN(value)) return;
const arousal = getVars().enemyarousalmax || 0;
getVars().enemyarousal = parseInt(arousal * value / 100);
showToast("Activated!");
},
aezakmi() {
if (!getVars().crime) return;
let total = 0;
let totalKeys = 0;
for (const key in getVars().crime) {
const crime = getVars().crime[key];
const currentVal = parseInt(crime.current);
if (!isNaN(currentVal)) {
total += currentVal;
totalKeys++;
}
}
if (totalKeys === 0) return;
total = parseInt((total - 100) / totalKeys);
for (const key in getVars().crime) {
const crime = getVars().crime[key];
if (!isNaN(parseInt(crime.current))) {
crime.current = total;
crime.count = total;
crime.countHistory = total;
crime.history = total;
}
}
hydrateCheatUi.crimecurrent();
showToast("Activated!");
},
imdonefor() {
if (!getVars().crime) return;
let total = 0;
let totalKeys = 0;
for (const key in getVars().crime) {
const crime = getVars().crime[key];
const currentVal = parseInt(crime.current);
if (!isNaN(currentVal)) {
total += currentVal;
totalKeys++;
}
}
if (totalKeys === 0) return;
total = parseInt((total + 100) / totalKeys);
for (const key in getVars().crime) {
const crime = getVars().crime[key];
if (!isNaN(parseInt(crime.current))) {
crime.current = total;
}
}
hydrateCheatUi.crimecurrent();
showToast("Activated!");
},
imvirgintemple() {
if (getVars()?.player?.virginity === void 0) {
showToast("Failed!");
return;
}
showToast("Activated!");
getVars().player.virginity.temple = !getVars().player.virginity.temple;
hydrateCheatUi.vowcurrent();
},
hesoyam() {
showToast("Activated!");
getVars().pain = 0;
getVars().arousal = 0;
getVars().tiredness = 0;
getVars().stress = 0;
getVars().trauma = 0;
getVars().control = 1e3;
getVars().drunk = 0;
getVars().drugged = 0;
getVars().hallucinogen = 0;
},
statmanager() {
const statpick2 = byUiId("statpick").value;
const value = parseFloat(byUiId("statinput").value);
if (!isNaN(value)) {
showToast("Activated!");
getVars()[statpick2] = value;
} else {
showToast("Value is not a number!");
}
},
kill_player() {
showToast("Activated!");
getVars().pain = 200;
getVars().arousal = 1e4;
getVars().tiredness = 2e3;
getVars().stress = 1e4;
getVars().trauma = 5e3;
getVars().control = 0;
getVars().drunk = 1e3;
getVars().drugged = 1e3;
getVars().hallucinogen = 1e3;
},
kill_enemy() {
showToast("Activated!");
getVars().enemyhealth = 0;
getVars().enemytrust = 100;
getVars().enemyanger = 0;
},
enemycalm() {
showToast("Activated!");
getVars().enemyhealth = getVars().enemyhealthmax > 0 ? 100 : 0;
getVars().enemytrust = 100;
getVars().enemyanger = 0;
},
statmanagere() {
const statpicke2 = byUiId("statpicke")?.value;
const value = Number(byUiId("statinpute")?.value);
if (!statpicke2 || isNaN(value)) {
showToast("Failed!");
return;
}
showToast("Activated!");
getVars()[statpicke2] = value;
}
};
}
// src/features/cheat/player-actions.js
var playerActions = {
...createPlayerStatsActions(),
...createPlayerBodyActions(),
...createPlayerProgressionActions()
};
var player_actions_default = playerActions;
// src/core/config/cheat-config-schema.js
var entry = (path7, type, defaultValue, description, migrationAliases = []) => Object.freeze({ path: path7, type, scope: "save", defaultValue, description, migrationAliases });
var CHEAT_CONFIG_SCHEMA = Object.freeze([
entry("angel", "number", 0, "Saved angel-stat baseline."),
entry("angelMode", "boolean", true, "Whether angel baseline restoration is active."),
entry("toggles", "object", {}, "Active stable toggle IDs."),
entry("storedNPCs", "object", {}, "CheatPlus-managed overflow NPC pregnancy data."),
entry("storedNPCsDate", "number", 0, "Last game day overflow NPC data was processed."),
entry("storedNPCsPriority", "number", 0, "Overflow NPC processing priority."),
entry("trueDivine", "string", "", "Remembered demon/angel transformation branch."),
entry("orgasmCount", "number", 0, "Intense-cum toggle counter."),
entry("baseNpcPregnancyChance", "number-or-null", null, "Baseline restored by NPC toggle."),
entry("unlicumMode", "boolean", false, "Intense-cum toggle phase.")
]);
var CHEAT_CONFIG_DEFAULTS = Object.freeze(
Object.fromEntries(CHEAT_CONFIG_SCHEMA.map(({ path: path7, defaultValue }) => [path7, defaultValue]))
);
var CHEAT_CONFIG_CLASSIFICATION = Object.freeze({
saveBackedConfig: Object.freeze(CHEAT_CONFIG_SCHEMA.map(({ path: path7 }) => path7)),
transientRuntimeState: Object.freeze([
"scheduler callbacks",
"failure counters",
"cooldown timestamps",
"mounted controls",
"AbortController instances"
]),
gameState: Object.freeze([
"money",
"arousal",
"date",
"player",
"NPCName",
"storedNPCs (base-game path)",
"pregnancy",
"setup"
])
});
function isPlainObject(value) {
return Boolean(value) && typeof value === "object" && !Array.isArray(value);
}
function isCheatConfigValueValid(definition, value) {
if (definition.type === "number") return Number.isFinite(value);
if (definition.type === "number-or-null") return value === null || Number.isFinite(value);
if (definition.type === "boolean") return typeof value === "boolean";
if (definition.type === "string") return typeof value === "string";
if (definition.type === "object") return isPlainObject(value);
return false;
}
function cloneDefault(value) {
return isPlainObject(value) ? { ...value } : value;
}
function normalizeCheatConfig(input, { baseNpcPregnancyChance = null } = {}) {
const source = isPlainObject(input) ? input : {};
const normalized = {};
for (const definition of CHEAT_CONFIG_SCHEMA) {
let value = source[definition.path];
if (value === void 0) {
for (const alias of definition.migrationAliases) {
if (source[alias] !== void 0) {
value = source[alias];
break;
}
}
}
if (!isCheatConfigValueValid(definition, value)) value = cloneDefault(definition.defaultValue);
normalized[definition.path] = value;
}
if (normalized.baseNpcPregnancyChance === null && Number.isFinite(baseNpcPregnancyChance)) {
normalized.baseNpcPregnancyChance = baseNpcPregnancyChance;
}
return normalized;
}
// src/core/sugarcube/cheat-config.js
function cfg() {
return getVars()?.cheatPlus ?? null;
}
function initCheatConfig() {
const vars = getVars();
if (!vars) return;
vars.cheatPlus = normalizeCheatConfig(vars.cheatPlus, {
baseNpcPregnancyChance: vars.baseNpcPregnancyChance
});
const c = vars.cheatPlus;
if (!c.trueDivine && vars.penisstate === 0 && vars.vaginastate === 0) {
c.trueDivine = vars.demon > 0 ? "demon" : vars.angel > 0 ? "angel" : "";
}
}
function getAngel() {
return cfg()?.angel ?? 0;
}
function setAngel(value) {
const c = cfg();
if (c) c.angel = value;
}
function getAngelMode() {
return cfg()?.angelMode ?? true;
}
function setAngelMode(value) {
const c = cfg();
if (c) c.angelMode = value;
}
function setTrueDivine(value) {
const c = cfg();
if (c) c.trueDivine = value;
}
function getToggles() {
return cfg()?.toggles ?? {};
}
function activateToggle(id) {
const c = cfg();
if (c) c.toggles[id] = id;
}
function deactivateToggle(id) {
const c = cfg();
if (c) delete c.toggles[id];
}
function getStoredCheatNPCs() {
return cfg()?.storedNPCs ?? {};
}
function setStoredCheatNPCs(value) {
const c = cfg();
if (c) c.storedNPCs = value;
}
function getStoredNPCsDate() {
return cfg()?.storedNPCsDate ?? 0;
}
function setStoredNPCsDate(value) {
const c = cfg();
if (c) c.storedNPCsDate = value;
}
function getNPCsPriority() {
return cfg()?.storedNPCsPriority ?? 0;
}
function setNPCsPriority(value) {
const c = cfg();
if (c) c.storedNPCsPriority = value;
}
function getBaseNpcPregnancyChance() {
return cfg()?.baseNpcPregnancyChance;
}
function setBaseNpcPregnancyChance(value) {
const c = cfg();
if (c) c.baseNpcPregnancyChance = value;
}
function getUnlicumMode() {
return cfg()?.unlicumMode ?? false;
}
function setUnlicumMode(value) {
const c = cfg();
if (c) c.unlicumMode = value;
}
function getOrgasmCount() {
return cfg()?.orgasmCount ?? 0;
}
function incrementOrgasmCount() {
const c = cfg();
if (!c) return 0;
c.orgasmCount = (c.orgasmCount ?? 0) + 1;
return c.orgasmCount;
}
function resetOrgasmCount() {
const c = cfg();
if (c) c.orgasmCount = 0;
}
// src/constants/runtime.js
var SECONDS_PER_DAY = 86400;
// src/core/toggle/state-repository.js
var toggleState = {
toggleActive: {},
toggleActiveDaily: {},
toggleDeactivated: false,
initNPCinstapreg: false,
tmpArousal: 0,
orgasmdown: 0
};
function getToggleState() {
return toggleState;
}
function clearActiveToggles() {
for (const key in toggleState.toggleActive) {
delete toggleState.toggleActive[key];
}
}
function clearAllActiveToggles() {
clearActiveToggles();
for (const key in toggleState.toggleActiveDaily) {
delete toggleState.toggleActiveDaily[key];
}
}
var state_repository_default = toggleState;
// src/services/storage.js
function initStorage() {
initCheatConfig();
}
function reactivateToggles() {
logger_default("toggle", "=== reactivateToggles START ===", { level: "info" });
const togglesRef = getToggles();
logger_default("toggle", `Loaded from storage: ${Object.keys(togglesRef || {}).length} toggles`, {
level: "info"
});
const storedToggles = JSON.parse(JSON.stringify(togglesRef || {}));
logger_default("toggle", `Deep cloned ${Object.keys(storedToggles).length} toggles`, { level: "info" });
setReactivatingToggles(true);
logger_default("toggle", "Set reactivating flag = true", { level: "info" });
resetRuntimeToggles();
logger_default("toggle", "Runtime toggles have been reset", { level: "info" });
let activatedCount = 0;
for (const key in storedToggles) {
if (isRegistered(key)) {
const value = storedToggles[key];
const enabled = value === true || value === 1 || value === key || Boolean(value);
if (!enabled) {
logger_default("toggle", `Skipping toggle with falsy value: ${key}`, {
level: "warn",
data: { value }
});
continue;
}
logger_default("toggle", `Dispatching toggle: ${key}`, { level: "info" });
dispatch(key);
activatedCount++;
} else {
logger_default("storage", `Skipping unregistered toggle: ${key}`, { level: "warn" });
}
}
logger_default("toggle", `Reactivation finished - Activated ${activatedCount} toggles`, {
level: "info"
});
logger_default("toggle", "=== reactivateToggles END ===", { level: "info" });
setReactivatingToggles(false);
}
function resetRuntimeToggles() {
logger_default("toggle", "resetRuntimeToggles called", { level: "info" });
ToggleScheduler.clearAll();
logger_default("toggle", "ToggleScheduler.clearAll() done", { level: "info" });
clearAllActiveToggles();
logger_default("toggle", "clearAllActiveToggles() done", { level: "info" });
const state = getToggleState();
if (state) {
state.toggleDeactivated = false;
logger_default("toggle", "Reset toggleDeactivated flag", { level: "info" });
}
}
// src/core/toggle/engine.js
function createToggleEngine(toggleState2, getActionById, getToggleConfigById = null) {
function restoreTogglesAfterObserverFailure() {
logger_default("toggle", "Watchdog: Error detected in toggle cheat, starting restoration...");
clearActiveToggles();
showToast("Error detected in toggle cheat, resetting.");
reactivateToggles();
logger_default("toggle", "Watchdog: Restoration complete");
showToast("Complete.");
}
function runitallRestore() {
logger_default("toggle", "Manual restore triggered");
ToggleScheduler.restore({ onRestore: restoreTogglesAfterObserverFailure });
}
function runitall() {
const started = ToggleScheduler.runFrame({
isLoad: getIsLoad(),
onWatchdogRestore: restoreTogglesAfterObserverFailure
});
if (!started) return;
decrementClickCounter();
if (getClickCounter() > 0) {
setTimeout(runitall, 10);
}
checkDateDaily();
}
function checkDateDaily() {
const vars = getVars();
const date = Math.floor(vars?.timeStamp / SECONDS_PER_DAY);
if (getCurDate() !== date) {
logger_default("toggle", `Daily trigger: game date changed from ${getCurDate()} to ${date}`);
setCurDate(date);
runitallDaily();
}
}
function applyToggleMutation({ id, name, daily = null }) {
if (!id) {
logger_default("toggle", "applyToggleMutation: Missing toggle id", { level: "warn" });
return;
}
const config = typeof getToggleConfigById === "function" ? getToggleConfigById(id) || {} : {};
const isDaily = daily == null ? config.trigger === "daily" : Boolean(daily);
const buttonLabel = name ?? config.label ?? "Activate";
const cooldownMs = Number.isFinite(config.cooldownMs) ? Number(config.cooldownMs) : 100;
const maxFailures = Number.isInteger(config.maxFailures) ? Math.max(1, Number(config.maxFailures)) : 5;
const runOnActivate = config.runOnActivate !== false;
const button = byUiId(id);
const mapActive = isDaily ? toggleState2.toggleActiveDaily : toggleState2.toggleActive;
const isActive = !!mapActive[id];
if (isActive) {
logger_default("toggle", `Deactivating toggle: ${id} (${isDaily ? "daily" : "regular"})`, {
data: { button: !!button, label: buttonLabel }
});
ToggleScheduler.unregister(id, { daily: isDaily });
if (!getReactivatingToggles()) deactivateToggle(id);
delete mapActive[id];
if (button) {
if (button instanceof HTMLInputElement && button.type === "checkbox") {
button.checked = false;
} else {
button.classList.remove("cp-toggle-active");
button.textContent = buttonLabel;
}
}
return;
}
if (!getReactivatingToggles()) setExtraNotif(true);
const actionFn = getActionById(id);
if (typeof actionFn !== "function") {
logger_default("toggle", `Action not found for toggle: ${id}`, {
data: { daily: isDaily },
level: "warn"
});
setExtraNotif(false);
return;
}
logger_default("toggle", `Activating toggle: ${id} (${isDaily ? "daily" : "regular"})`, {
data: { cooldownMs, maxFailures, runOnActivate, label: buttonLabel, button: !!button }
});
ToggleScheduler.register(id, actionFn, { daily: isDaily, cooldownMs, maxFailures });
if (!getReactivatingToggles()) activateToggle(id);
mapActive[id] = true;
if (button) {
if (button instanceof HTMLInputElement && button.type === "checkbox") {
button.checked = true;
} else {
button.classList.add("cp-toggle-active");
button.textContent = buttonLabel;
}
}
if (runOnActivate) {
try {
logger_default("toggle", `Running on activation: ${id}`);
const fn = ToggleScheduler.getFunction(id, { daily: isDaily }) || actionFn;
if (typeof fn === "function") fn();
} catch (err) {
logger_default("toggle", `Error running action on activation: ${id}`, {
data: err,
level: "error"
});
} finally {
setExtraNotif(false);
}
} else {
setExtraNotif(false);
}
}
function runitallDaily() {
logger_default("toggle", "Executing daily toggles");
ToggleScheduler.runDaily();
}
function toggle(id, name) {
applyToggleMutation({ id, name, daily: false });
}
function toggleDaily(id, name) {
applyToggleMutation({ id, name, daily: true });
}
function toggleById(id, name) {
applyToggleMutation({ id, name, daily: null });
}
return {
runitallRestore,
runitall,
checkDateDaily,
_applyToggleMutation: applyToggleMutation,
runitallDaily,
toggle,
toggleDaily,
toggleById
};
}
// src/features/listeners/action-map-schema.js
function assertNonEmptyString(value, fieldName, index, bucketName) {
if (typeof value !== "string" || !value.trim()) {
throw new Error(
`[action-map-schema] ${bucketName}[${index}].${fieldName} must be a non-empty string`
);
}
}
function assertUniqueKeys(entries2, keyGetter, bucketName) {
const seen = /* @__PURE__ */ new Set();
entries2.forEach((entry2, index) => {
const key = keyGetter(entry2);
assertNonEmptyString(key, "key", index, bucketName);
if (seen.has(key)) {
throw new Error(`[action-map-schema] Duplicate key "${key}" in ${bucketName}`);
}
seen.add(key);
});
}
function validateToggleEntries(entries2, bucketName) {
if (!Array.isArray(entries2)) {
throw new Error(`[action-map-schema] ${bucketName} must be an array`);
}
entries2.forEach((entry2, index) => {
if (!entry2 || typeof entry2 !== "object") {
throw new Error(`[action-map-schema] ${bucketName}[${index}] must be an object`);
}
assertNonEmptyString(entry2.id, "id", index, bucketName);
assertNonEmptyString(entry2.label, "label", index, bucketName);
if (entry2.trigger != null && entry2.trigger !== "frame" && entry2.trigger !== "daily") {
throw new Error(
`[action-map-schema] ${bucketName}[${index}].trigger must be "frame" or "daily"`
);
}
if (entry2.cooldownMs != null && (!Number.isFinite(entry2.cooldownMs) || entry2.cooldownMs < 0)) {
throw new Error(
`[action-map-schema] ${bucketName}[${index}].cooldownMs must be a non-negative number`
);
}
if (entry2.maxFailures != null && (!Number.isInteger(entry2.maxFailures) || entry2.maxFailures < 1)) {
throw new Error(
`[action-map-schema] ${bucketName}[${index}].maxFailures must be an integer >= 1`
);
}
if (entry2.runOnActivate != null && typeof entry2.runOnActivate !== "boolean") {
throw new Error(`[action-map-schema] ${bucketName}[${index}].runOnActivate must be boolean`);
}
});
assertUniqueKeys(entries2, (entry2) => entry2.id, bucketName);
}
function validateMethodEntries(entries2, bucketName) {
if (!Array.isArray(entries2)) {
throw new Error(`[action-map-schema] ${bucketName} must be an array`);
}
entries2.forEach((entry2, index) => {
if (!entry2 || typeof entry2 !== "object") {
throw new Error(`[action-map-schema] ${bucketName}[${index}] must be an object`);
}
assertNonEmptyString(entry2.actionKey, "actionKey", index, bucketName);
if (entry2.methodName != null) {
assertNonEmptyString(entry2.methodName, "methodName", index, bucketName);
}
});
assertUniqueKeys(entries2, (entry2) => entry2.actionKey, bucketName);
}
function validateNavEntries(entries2, bucketName) {
if (!Array.isArray(entries2)) {
throw new Error(`[action-map-schema] ${bucketName} must be an array`);
}
entries2.forEach((entry2, index) => {
if (!entry2 || typeof entry2 !== "object") {
throw new Error(`[action-map-schema] ${bucketName}[${index}] must be an object`);
}
assertNonEmptyString(entry2.actionKey, "actionKey", index, bucketName);
assertNonEmptyString(entry2.navKey, "navKey", index, bucketName);
assertNonEmptyString(entry2.contentKey, "contentKey", index, bucketName);
assertNonEmptyString(entry2.hydrateKey, "hydrateKey", index, bucketName);
});
assertUniqueKeys(entries2, (entry2) => entry2.actionKey, bucketName);
}
function validateSimpleUiEntries(entries2, bucketName) {
if (!Array.isArray(entries2)) {
throw new Error(`[action-map-schema] ${bucketName} must be an array`);
}
entries2.forEach((entry2, index) => {
if (!entry2 || typeof entry2 !== "object") {
throw new Error(`[action-map-schema] ${bucketName}[${index}] must be an object`);
}
assertNonEmptyString(entry2.actionKey, "actionKey", index, bucketName);
assertNonEmptyString(entry2.target, "target", index, bucketName);
if (entry2.arg != null) {
assertNonEmptyString(entry2.arg, "arg", index, bucketName);
}
});
assertUniqueKeys(entries2, (entry2) => entry2.actionKey, bucketName);
}
function validateBoundEntries(entries2, bucketName) {
if (!Array.isArray(entries2)) {
throw new Error(`[action-map-schema] ${bucketName} must be an array`);
}
entries2.forEach((entry2, index) => {
if (!entry2 || typeof entry2 !== "object") {
throw new Error(`[action-map-schema] ${bucketName}[${index}] must be an object`);
}
assertNonEmptyString(entry2.actionKey, "actionKey", index, bucketName);
assertNonEmptyString(entry2.source, "source", index, bucketName);
assertNonEmptyString(entry2.method, "method", index, bucketName);
});
assertUniqueKeys(entries2, (entry2) => entry2.actionKey, bucketName);
}
// src/features/listeners/action-map-toggle.js
var TOGGLE_DEFINITIONS = [
{ id: "maxchruchtask", label: "Church", trigger: "daily" },
{ id: "maxanimaltask", label: "Stray", trigger: "daily" },
{ id: "edenshrooms", label: "Shroom", trigger: "daily" },
{ id: "edengarden", label: "Garden", trigger: "daily" },
{ id: "edenspring", label: "Spring", trigger: "daily" },
{ id: "edentimer", label: "Timer", trigger: "daily" },
{ id: "invinityNPCPregnancy", label: "Activate", trigger: "daily" },
{ id: "virginity", label: "Virgin", trigger: "frame" },
{ id: "purity", label: "Pure", trigger: "frame" },
{ id: "unlicum", label: "Cum", trigger: "frame" },
{ id: "unliarousal", label: "arousal", trigger: "frame" },
{ id: "everyone_horny", label: "Horny", trigger: "frame" },
{ id: "farm_safe", label: "Safe", trigger: "frame" },
{ id: "interact_child", label: "Auto", trigger: "frame", cooldownMs: 200 },
{ id: "pregnancy_detection", label: "Activate", trigger: "frame", cooldownMs: 250 },
{ id: "invincibleAngel", label: "Activate", trigger: "frame" },
{ id: "intenseCum", label: "intense cum", trigger: "frame", cooldownMs: 80 },
{ id: "allNPCInstaPregnant", label: "Activate", trigger: "frame", cooldownMs: 250 },
{ id: "allNPCMultiplePregnancy", label: "Activate", trigger: "frame", cooldownMs: 250 }
];
var DAILY_TOGGLE_ACTIONS = TOGGLE_DEFINITIONS.filter((entry2) => entry2.trigger === "daily");
var TOGGLE_ACTIONS = TOGGLE_DEFINITIONS.filter((entry2) => entry2.trigger !== "daily");
validateToggleEntries(TOGGLE_DEFINITIONS, "TOGGLE_DEFINITIONS");
// src/features/cheat/toggle-domain-basic-actions.js
function createToggleDomainBasicActions() {
return {
everyone_horny() {
const vars = getVars();
if (vars.NPCName === void 0) return;
for (let index = 0; index < vars.NPCName.length; index++) {
if (vars.NPCName[index].description !== "Ivory Wraith") vars.NPCName[index].lust = 100;
}
},
edenspring() {
getVars().edenspring = 4;
},
edengarden() {
getVars().edengarden = 4;
},
edentimer() {
getVars().edendays = 0;
},
edenshrooms() {
getVars().edenshrooms = 4;
},
maxchruchtask() {
const vars = getVars();
vars.temple_garden = 100;
vars.temple_quarters = 100;
vars.grace = 100;
},
maxanimaltask() {
getVars().stray_happiness = 100;
},
purity() {
getVars().purity = 1e3;
},
virginity() {
const vars = getVars();
if (vars?.player?.virginity === void 0) return;
vars.player.virginity.penile = true;
vars.player.virginity.vaginal = true;
},
farm_safe() {
const vars = getVars();
if (vars.farm === void 0) return;
vars.farm.aggro = 0;
},
interact_child() {
const vars = getVars();
if (vars?.children && typeof vars.children === "object") {
for (const key in vars.children) {
const child = vars.children[key];
const local = child?.localVariables;
if (local?.event === true) {
local.interactions = (local.interactions ?? 0) + 1;
local.interactionsTotal = (local.interactionsTotal ?? 0) + 1;
local.event = false;
}
}
}
}
};
}
// src/features/cheat/toggle-domain-pregnancy-actions.js
function createToggleDomainPregnancyActions(toggleState2, actionBagRef) {
return {
pregnancy_detection() {
const vars = getVars();
if (Object.keys(vars.storedNPCs).length === 0 || vars.NPCName === void 0) return;
function countNpc() {
let total = Object.keys(vars.storedNPCs).length;
total += Object.keys(getStoredCheatNPCs()).length;
for (let index = 0; index < vars.NPCName.length; index++) {
if (vars?.NPCName[index]?.pregnancy?.fetus?.length > 0) total++;
}
return total;
}
function countPc() {
if (vars.sexStats?.vagina?.pregnancy?.fetus === void 0 || vars.sexStats?.anus?.pregnancy?.fetus === void 0) {
return 0;
}
return vars.sexStats.vagina.pregnancy.fetus.length + vars.sexStats.anus.pregnancy.fetus.length;
}
const nextNpc = countNpc();
const nextPc = countPc();
const actionBag = actionBagRef();
if (getTotalNpcPregnant() === 0) {
setTotalNpcPregnant(nextNpc);
setPcPregnant(nextPc);
return;
}
if (nextNpc > getTotalNpcPregnant()) {
showToast("NPC is impregnated!");
actionBag.invinityNPCPregnancy();
setTotalNpcPregnant(nextNpc);
} else if (nextNpc < getTotalNpcPregnant()) {
showToast("NPC's baby has been born!");
actionBag.invinityNPCPregnancy();
setTotalNpcPregnant(nextNpc);
}
if (nextPc > getPcPregnant()) {
showToast("MC is impregnated!");
setPcPregnant(nextPc);
} else if (nextPc < getPcPregnant()) {
showToast("your baby has been born!!");
setPcPregnant(nextPc);
}
},
named_npc_pregnancy_manager_toggle() {
const vars = getVars();
if (named_npc_pregnancy_locked.length === 0 || named_npc_pregnancy_locked_day.length === 0) {
return;
}
for (const key in named_npc_pregnancy_locked) {
let total = vars.NPCName[named_npc_pregnancy_locked[key]].pregnancy.timerEnd - named_npc_pregnancy_locked_day[key] * 3;
if (total < 0) total = 0;
vars.NPCName[named_npc_pregnancy_locked[key]].pregnancy.timer = total;
}
},
npc_pregnancy_manager_toggle() {
const vars = getVars();
if (npc_pregnancy_locked.length === 0 || npc_pregnancy_locked_day.length === 0) {
return;
}
for (const key in npc_pregnancy_locked) {
let total = vars.storedNPCs[npc_pregnancy_locked[key]].pregnancy.timerEnd - npc_pregnancy_locked_day[key] * 3;
if (total < 0) total = 0;
vars.storedNPCs[npc_pregnancy_locked[key]].pregnancy.timer = total;
}
},
mc_pregnancy_manager_toggle() {
const vars = getVars();
if (mc_pregnancy_locked.length === 0 || mc_pregnancy_locked_day.length === 0) return;
let offset = 0;
for (const key in mc_pregnancy_locked) {
if (mc_pregnancy_locked_type[offset] === "parasite") {
vars.sexStats[mc_pregnancy_locked_hole[offset]].pregnancy.fetus[key].daysLeft = mc_pregnancy_locked_day[offset];
} else {
const timeEnd = vars.sexStats[mc_pregnancy_locked_hole[offset]].pregnancy.timerEnd;
let time = timeEnd - mc_pregnancy_locked_day[offset] * 3;
if (time < 0) time = 0;
vars.sexStats[mc_pregnancy_locked_hole[offset]].pregnancy.timer = time;
}
offset++;
}
},
invinityNPCPregnancy() {
const vars = getVars();
if (!vars) return;
const limit = 8;
const hardLimit = 10;
const mainNPCs = vars.storedNPCs || {};
const mainLength = Object.keys(mainNPCs).length;
const priority = getNPCsPriority() || 0;
const gameTime = vars.timeStamp;
const currentDate = Math.floor(gameTime / SECONDS_PER_DAY);
const lastDate = getStoredNPCsDate();
const dateLeft = lastDate !== 0 ? (currentDate - lastDate) * 3 : 0;
if (dateLeft === 0) {
if (mainLength <= limit) return;
if (mainLength >= limit && priority >= 8) return;
}
setStoredNPCsDate(currentDate);
const cheatNPCs = { ...getStoredCheatNPCs() || {} };
let priorityQueue = 0;
const active = {};
const waiting = {};
for (const key in mainNPCs) {
const npc = mainNPCs[key];
const left = npc.pregnancy.timerEnd - npc.pregnancy.timer;
if (left <= 3 && priorityQueue <= limit) {
active[`stored_${priorityQueue}`] = npc;
if (priorityQueue === 8)
showToast("NPC about to give birth, you cant bustin nuts in people for today!");
priorityQueue++;
} else {
waiting[`stored_${Object.keys(waiting).length}`] = npc;
}
}
for (const key in cheatNPCs) {
const npc = cheatNPCs[key];
let timer = npc.pregnancy.timer;
const timerEnd = npc.pregnancy.timerEnd;
if (dateLeft > 0) {
timer += dateLeft;
if (timer > timerEnd) timer = timerEnd;
npc.pregnancy.timer = timer;
}
const left = timerEnd - timer;
if (left <= 3 && priorityQueue <= hardLimit) {
active[`stored_${priorityQueue}`] = npc;
if (priorityQueue === 8) showToast("NPC about to give birth...");
priorityQueue++;
} else {
waiting[`stored_${Object.keys(waiting).length}`] = npc;
}
}
setNPCsPriority(priorityQueue);
vars.storedNPCs = active;
setStoredCheatNPCs(waiting);
},
allNPCInstaPregnant() {
const vars = getVars();
if (toggleState2.toggleDeactivated) {
vars.baseNpcPregnancyChance = getBaseNpcPregnancyChance();
if (vars?.baseNpcPregnancyChance > 16) vars.baseNpcPregnancyChance = 16;
toggleState2.initNPCinstapreg = false;
return;
}
if (!toggleState2.initNPCinstapreg) {
toggleState2.initNPCinstapreg = true;
setBaseNpcPregnancyChance(vars.baseNpcPregnancyChance);
vars.baseNpcPregnancyChance = 19;
}
for (let index = 0; index < vars.NPCList.length; index++) {
if (vars?.NPCList[index].pregnancyAvoidance > 0) {
vars.NPCList[index].pregnancyAvoidance = 0;
}
}
},
allNPCMultiplePregnancy() {
const vars = getVars();
if (vars.NPCList === void 0) return;
for (let index = 0; index < vars.NPCList.length; index++) {
if (vars?.NPCList[index].pregnancy === 1) {
vars.NPCList[index].pregnancy = 0;
}
}
}
};
}
// src/features/cheat/toggle-domain-status-actions.js
function createToggleDomainStatusActions(toggleState2) {
return {
invincibleAngel() {
const vars = getVars();
if (getExtraNotif()) {
if (vars?.demon > 0) {
showToast("Youre a demon!");
timedToast("but, okay", 3e3);
} else if (vars?.fallenangel > 0) {
showToast("Im sorry, youre already a fallen angel.");
timedToast("im turning this off", 3e3);
dispatch("invincibleAngel");
return;
}
}
if (vars?.penisstate != 0 || vars?.vaginastate != 0) {
if (!getAngelMode()) return;
setAngel(vars.angel);
vars.angel = 0;
vars.angelbuild = 100;
setAngelMode(true);
} else if (!getAngelMode()) {
setAngelMode(false);
vars.angel = getAngel();
}
},
updateUserDivine() {
const vars = getVars();
if (vars?.penisstate != 0 || vars?.vaginastate != 0) return;
if (vars?.demon > 0) {
setTrueDivine("demon");
} else if (vars?.angel > 0) {
setTrueDivine("angel");
}
},
unlicum() {
const vars = getVars();
if (vars.semen_amount < vars.semen_volume) {
vars.semen_amount = vars.semen_volume;
vars.orgasmcount = 0;
}
},
intenseCum() {
const vars = getVars();
if (vars.orgasmcurrent != 0 && !getUnlicumMode()) {
resetOrgasmCount();
toggleState2.tmpArousal = vars.arousal;
vars.orgasmdown = 1e3;
toggleState2.orgasmdown = 1e3;
setUnlicumMode(true);
} else if (vars.orgasmdown < toggleState2.orgasmdown && getUnlicumMode()) {
toggleState2.orgasmdown = vars.orgasmdown;
vars.arousal = toggleState2.tmpArousal;
incrementOrgasmCount();
if (getOrgasmCount() > 2) {
setUnlicumMode(false);
vars.orgasmdown = -1;
toggleState2.orgasmdown = -1;
resetOrgasmCount();
vars.orgasmcurrent = 0;
}
}
},
unliarousal() {
getVars().arousal = 1e4;
}
};
}
// src/features/cheat/toggle-domain-actions.js
function createToggleDomainActions(toggleState2) {
let domainActions2 = {};
domainActions2 = {
...createToggleDomainBasicActions(toggleState2),
...createToggleDomainPregnancyActions(toggleState2, () => domainActions2),
...createToggleDomainStatusActions(toggleState2)
};
return domainActions2;
}
// src/features/cheat/toggle-runtime.js
var toggleDefinitionMap = new Map(TOGGLE_DEFINITIONS.map((entry2) => [entry2.id, entry2]));
var domainActions = createToggleDomainActions(state_repository_default);
var toggleRuntime = {
...domainActions
};
var engineActions = createToggleEngine(
state_repository_default,
(id) => toggleRuntime[id],
(id) => toggleDefinitionMap.get(id)
);
toggleRuntime = {
...engineActions,
...domainActions,
toggleActive: state_repository_default.toggleActive,
toggleActiveDaily: state_repository_default.toggleActiveDaily,
get toggleDeactivated() {
return state_repository_default.toggleDeactivated;
},
set toggleDeactivated(value) {
state_repository_default.toggleDeactivated = Boolean(value);
}
};
var toggle_runtime_default = toggleRuntime;
// src/features/cheat/pregnancy-shared.js
function updateToggleBundle(key, enabled, handler) {
if (enabled) {
ToggleScheduler.register(key, handler, { daily: false, cooldownMs: 100, maxFailures: 5 });
toggle_runtime_default.toggleActive[key] = true;
} else {
ToggleScheduler.unregister(key, { daily: false });
delete toggle_runtime_default.toggleActive[key];
}
}
function abortion_notice() {
showToast("Aborting...");
setTimeout(() => bloodEffect(), 1e3);
setTimeout(() => showToast("baby is aborted!"), 3200);
}
function setPregnancyTimer(pregnancy, days) {
let time = pregnancy.timerEnd - days * 3;
if (time < 0) time = 0;
pregnancy.timer = time;
}
function applyNpcPregnancySet({
selectElement,
input,
toggle,
locked,
lockedDays: lockedDays4,
toggleKey,
toggleHandler,
resolvePregnancy
}) {
if (!selectElement || isNaN(input)) return;
const index = locked.findIndex((name) => name == selectElement);
if (toggle && index === -1) {
locked.push(selectElement);
lockedDays4.push(input);
updateToggleBundle(toggleKey, true, toggleHandler);
} else if (!toggle && index !== -1) {
locked.splice(index, 1);
lockedDays4.splice(index, 1);
updateToggleBundle(toggleKey, false);
}
const npcPregnancy = resolvePregnancy(selectElement);
if (!npcPregnancy) return;
setPregnancyTimer(npcPregnancy, input);
showToast("Activated!");
}
// src/features/cheat/pregnancy-abortion-actions.js
function createPregnancyAbortionActions() {
return {
abortion_notice,
mc_abortion_set() {
const checked = byUiId("mc_abortion_checkbox").checked;
if (!checked) {
showToast("check the checkbox to confirm");
return false;
}
const location = byUiId("mc_abortion_location").value;
const selected = byUiId("mc_abortion_select").value;
const pregnancy = getVars().sexStats[location].pregnancy;
const length = pregnancy.fetus.length;
if (length === 0) {
showToast("No baby!");
return false;
}
if (length === 1) {
pregnancy.fetus = [];
pregnancy.awareOf = null;
pregnancy.awareOfDetails = null;
pregnancy.awareOfMultiple = null;
pregnancy.potentialFathers = [];
pregnancy.timer = 0;
pregnancy.timerEnd = null;
pregnancy.type = null;
pregnancy.waterBreaking = false;
pregnancy.waterBreakingTimer = null;
} else {
pregnancy.fetus.splice(selected, 1);
}
if (getVars().sexStats.anus.pregnancy.fetus[0]?.stats?.gender === "Hermaphrodite") {
getVars().sexStats.anus.pregnancy.motherStatus = 1;
}
abortion_notice();
hydrateCheatUi.update_mc_abortion_list();
},
named_npc_abortion_set() {
const checked = byUiId("named_npc_abortion_checkbox").checked;
if (!checked) {
showToast("check the checkbox to confirm");
return false;
}
const selectedName = byUiId("named_npc_abortion_chara_select").value;
const fetus = byUiId("named_npc_abortion_select").value;
let selectedIndex = -1;
let totalFetus = 0;
const npcnamelist2 = getNpcNameList();
const npcNames = getVars().NPCName;
for (let index = 0; index < npcnamelist2.length; index++) {
if (npcNames[index].description === selectedName) {
selectedIndex = index;
if (typeof npcNames[index].pregnancy.fetus === "object") {
totalFetus = npcNames[index].pregnancy.fetus.length;
}
}
}
if (totalFetus === 0) {
showToast("No baby!");
return false;
}
const pregnancy = npcNames[selectedIndex].pregnancy;
if (totalFetus === 1) {
pregnancy.fetus = [];
pregnancy.potentialFathers = [];
pregnancy.timer = 0;
pregnancy.timerEnd = null;
pregnancy.type = null;
pregnancy.waterBreaking = false;
pregnancy.waterBreakingTimer = null;
} else {
pregnancy.fetus.splice(fetus, 1);
}
abortion_notice();
hydrateCheatUi.update_named_npc_abortion_list();
},
npc_abortion_set() {
const checked = byUiId("npc_abortion_checkbox").checked;
if (!checked) {
showToast("check the checkbox to confirm");
return false;
}
const selected = byUiId("npc_abortion_chara_select").value;
if (!selected) return false;
const fetus = byUiId("npc_abortion_select").value;
const inGame = selected.match(/pregnancy/);
const vars = getVars();
const targetStore = inGame ? vars.storedNPCs : getStoredCheatNPCs();
const totalFetus = targetStore[selected].pregnancy.fetus.length;
if (totalFetus === 0) {
showToast("No baby!");
return false;
}
if (totalFetus === 1) {
targetStore[selected].pregnancy.fetus = [];
targetStore[selected].pregnancy.potentialFathers = [];
targetStore[selected].pregnancy.timer = 0;
targetStore[selected].pregnancy.timerEnd = null;
targetStore[selected].pregnancy.type = null;
targetStore[selected].pregnancy.waterBreaking = false;
targetStore[selected].pregnancy.waterBreakingTimer = null;
delete targetStore[selected];
abortion_notice();
hydrateCheatUi.update_npc_abortion_list();
} else {
targetStore[selected].pregnancy.fetus.splice(fetus, 1);
abortion_notice();
}
hydrateCheatUi.update_npc_fetus_abortion_list();
}
};
}
// src/features/cheat/pregnancy-manager-actions.js
function createPregnancyManagerActions({ actionBagRef, locks: locks2 }) {
return {
named_npc_pregnancy_set() {
const selectElement = byUiId("named_npc_pregnancy_manager").value;
const input = parseInt(byUiId("named_npc_pregnancy_input").value);
const toggle = byUiId("named_npc_pregnancy_toggle").checked;
const actionBag = actionBagRef();
applyNpcPregnancySet({
selectElement,
input,
toggle,
locked: locks2.named_npc_pregnancy_locked,
lockedDays: locks2.named_npc_pregnancy_locked_day,
toggleKey: "named_npc_pregnancy_manager_toggle",
toggleHandler: actionBag.named_npc_pregnancy_manager_toggle,
resolvePregnancy: (id) => getVars().NPCName?.[id]?.pregnancy
});
},
npc_pregnancy_set() {
const selectElement = byUiId("npc_pregnancy_manager").value;
const input = parseInt(byUiId("npc_pregnancy_input").value);
const toggle = byUiId("npc_pregnancy_toggle").checked;
const actionBag = actionBagRef();
applyNpcPregnancySet({
selectElement,
input,
toggle,
locked: locks2.npc_pregnancy_locked,
lockedDays: locks2.npc_pregnancy_locked_day,
toggleKey: "npc_pregnancy_manager_toggle",
toggleHandler: actionBag.npc_pregnancy_manager_toggle,
resolvePregnancy: (id) => getVars().storedNPCs?.[id]?.pregnancy
});
},
mc_pregnancy_set() {
const selectElement = byUiId("mc_pregnancy_manager").value;
const selectHole = byUiId("mc_pregnancy_hole").value;
const input = parseInt(byUiId("mc_pregnancy_input").value);
const toggle = byUiId("mc_pregnancy_toggle").checked;
const actionBag = actionBagRef();
if (!selectElement || isNaN(input)) return;
const pregType = getVars().sexStats[selectHole].pregnancy.type;
const index = locks2.mc_pregnancy_locked.findIndex((name) => name == selectElement);
const state = index === -1 ? 0 : locks2.mc_pregnancy_locked_hole[index] != selectHole ? 1 : locks2.mc_pregnancy_locked_type[index] != pregType ? 2 : 3;
if (toggle && state === 0) {
locks2.mc_pregnancy_locked.push(selectElement);
locks2.mc_pregnancy_locked_hole.push(selectHole);
locks2.mc_pregnancy_locked_type.push(pregType);
locks2.mc_pregnancy_locked_day.push(input);
updateToggleBundle(
"mc_pregnancy_manager_toggle",
true,
actionBag.mc_pregnancy_manager_toggle
);
} else if (!toggle && state !== 0) {
locks2.mc_pregnancy_locked.splice(index, 1);
locks2.mc_pregnancy_locked_hole.splice(index, 1);
locks2.mc_pregnancy_locked_type.splice(index, 1);
locks2.mc_pregnancy_locked_day.splice(index, 1);
updateToggleBundle("mc_pregnancy_manager_toggle", false);
}
if (pregType == "parasite") {
getVars().sexStats[selectHole].pregnancy.fetus[selectElement].daysLeft = input;
} else {
const sexPregnancy = getVars().sexStats[selectHole].pregnancy;
let time = sexPregnancy.timerEnd - input * 3;
if (time < 0) time = 0;
sexPregnancy.timer = time;
}
showToast("Activated!");
},
mc_tentacle_set() {
const selectElement = byUiId("mc_tentacle_select").value;
const selectlocation = byUiId("mc_tentacle_location").value;
const input = parseInt(byUiId("mc_tentacle_input").value);
if (!selectElement || isNaN(input)) return;
getVars().container[selectlocation].creatures[selectElement].stats.speed = input;
showToast("Activated!");
},
mc_baby_set() {
const selectElement = byUiId("mc_baby_select").value;
const selectAction = byUiId("mc_baby_action_select").value;
const input = byUiId("mc_baby_input").type == "checkbox" ? byUiId("mc_baby_input").checked : byUiId("mc_baby_input").value;
const vars = getVars();
if (!vars.children[selectElement]) return;
if (selectAction == "abandon") {
if (input == true) {
showToast(vars.children[selectElement].name + " has been abandoned!");
delete vars.children[selectElement];
hydrateCheatUi.update_mc_baby_list();
} else {
showToast("check the checkbox to confirm");
}
return true;
}
vars.children[selectElement][selectAction] = input;
showToast("Activated!");
}
};
}
// src/features/cheat/pregnancy-actions.js
var locks = {
named_npc_pregnancy_locked,
named_npc_pregnancy_locked_day,
npc_pregnancy_locked,
npc_pregnancy_locked_day,
mc_pregnancy_locked,
mc_pregnancy_locked_hole,
mc_pregnancy_locked_type,
mc_pregnancy_locked_day
};
var pregnancyActions = {
...locks
};
pregnancyActions = {
...pregnancyActions,
...createPregnancyManagerActions({ actionBagRef: () => pregnancyActions, locks }),
...createPregnancyAbortionActions()
};
var pregnancy_actions_default = pregnancyActions;
// src/features/cheat/world-actions.js
var FUNNY_FRUITS = [
"cabbage",
"wild_carrot",
"turnip",
"potato",
"onion",
"garlic_bulb",
"broccoli"
];
function VrelCoinsUsage() {
const vars = getVars();
if (vars?.featsBoosts?.pointsUsed === void 0) return;
vars.featsBoosts.pointsUsed = 0;
showToast("Activated!");
}
function set_animal_like() {
const animal = byUiId("animal_choice")?.value;
const value = parseInt(byUiId("animal_input")?.value);
if (isNaN(value)) {
showToast("failed : input is not a number!");
return;
}
const farm = getFarm();
if (farm?.beasts === void 0) {
showToast("failed!");
return;
}
showToast("Activated!");
farm.beasts[animal] = value;
}
function set_build_time() {
const value = parseInt(byUiId("build_time")?.value);
if (isNaN(value)) {
showToast("failed : input is not a number!");
return;
}
const farm = getFarm();
if (farm?.build_timer === void 0) {
showToast("failed!");
return;
}
showToast("Activated!");
farm.build_timer = value;
}
function set_assault_time() {
const value = parseInt(byUiId("assault_time")?.value);
if (!isNaN(value)) {
showToast("Activated!");
setVariable("farm_attack_timer", value);
}
}
function clean_cum() {
const vars = getVars();
if (vars?.player?.bodyliquid === void 0) return;
for (const key in vars.player.bodyliquid) {
for (const innerKey in vars.player.bodyliquid[key]) {
vars.player.bodyliquid[key][innerKey] = 0;
}
}
showToast("Activated!");
}
function dirty_cum() {
const vars = getVars();
if (vars?.player?.bodyliquid === void 0) return;
for (const key in vars.player.bodyliquid) {
for (const innerKey in vars.player.bodyliquid[key]) {
vars.player.bodyliquid[key][innerKey] = 100;
}
}
showToast("Activated!");
}
function clean_cum_uretus() {
const sexStats = getSexStats();
if (sexStats?.vagina?.sperm === void 0) return;
sexStats.vagina.sperm = [];
showToast("Activated!");
}
function check_fruit_selling() {
const vars = getVars();
if (vars?.farmersProduce?.selling === void 0) return;
const selling = vars.farmersProduce.selling;
const totals = FUNNY_FRUITS.reduce((acc, fruit) => {
acc[fruit] = selling[fruit] || 0;
return acc;
}, {});
const placeholder = Object.entries(totals).sort((left, right) => right[1] - left[1]).map(([fruit, amount], index) => `${index + 1}. ${fruit}: ${amount} | `).join("");
const placeholderEl = byUiId("placeholder_fruits");
if (placeholderEl) placeholderEl.innerHTML = placeholder;
}
function set_school_rep() {
showToast("Activated!");
const selected = byUiId("select_school_rep")?.value;
const input = parseInt(byUiId("input_school_rep")?.value);
if (isNaN(input)) {
showToast("failed : input is not a number!");
return;
}
setVariable(selected, input);
}
function sidebar_cheat() {
byUiId("ui-bar-toggle")?.click();
}
function cheat_backwards() {
const button = byUiId("history-backward");
if (!button) {
showToast("Failed, history probably disabled.");
return;
}
button.click();
update_history();
}
function cheat_forwards() {
const button = byUiId("history-forward");
if (!button) {
showToast("Failed, history probably disabled.");
return;
}
button.click();
update_history();
}
function update_history() {
const backwards = byUiId("cheat-history-backwards");
const forwards = byUiId("cheat-history-forwards");
const backwardHistory = byUiId("history-backward");
const forwardHistory = byUiId("history-forward");
if (backwards && backwardHistory) backwards.disabled = backwardHistory.disabled;
if (forwards && forwardHistory) forwards.disabled = forwardHistory.disabled;
}
function in_game_cheat() {
const button = byUiId("in_game_cheat");
if (!button) return;
const isEnabled = button.innerHTML === "Enable";
setVariable("debug", isEnabled ? 1 : 0);
button.innerHTML = isEnabled ? "Disable" : "Enable";
}
function alt_cheat() {
const overlay = byUiId("overlayButtons");
if (!overlay) return;
const cheatButton = [...overlay.getElementsByClassName("link-internal")].find(
(button) => button.innerHTML === "CHEATS"
);
if (cheatButton) {
closeModal();
cheatButton.click();
return;
}
showToast(
getVariable("debug") === 1 ? "move passage to see the change" : "cheat not enabled, please re-enable it again."
);
}
function randomEncounterSet() {
const button = byUiId("randomEncounterSet");
if (!button) return;
const isEnabled = getVariable("alluremod") === 0;
setVariable("alluremod", isEnabled ? 1 : 0);
button.innerHTML = isEnabled ? "Enabled" : "Disabled";
showToast(isEnabled ? "Enabled." : "Disabled.");
}
function purgeNPCBaby() {
const selectAction = byUiId("mc_baby_action_select")?.value;
if (selectAction !== "abandon") {
showToast("Pick abandon to purge.");
return;
}
const input = byUiId("mc_baby_input").type === "checkbox" ? byUiId("mc_baby_input").checked : byUiId("mc_baby_input").value;
if (input == true) {
const children = getChildren();
if (children) {
Object.keys(children).forEach((key) => delete children[key]);
}
hydrateCheatUi.update_mc_baby_list();
showToast("All of your baby has been abandoned!");
return;
}
showToast("check the checkbox to confirm");
}
var worldActions = {
VrelCoinsUsage,
set_animal_like,
set_build_time,
set_assault_time,
clean_cum,
dirty_cum,
clean_cum_uretus,
check_fruit_selling,
set_school_rep,
sidebar_cheat,
cheat_backwards,
cheat_forwards,
update_history,
in_game_cheat,
alt_cheat,
randomEncounterSet,
purgeNPCBaby
};
var world_actions_default = worldActions;
// src/features/actions.js
var cheatActions = {
...debug_actions_default,
...player_actions_default,
...pregnancy_actions_default,
...world_actions_default,
...toggle_runtime_default
};
// src/cheats/create-cheat.js
var FIELDS = /* @__PURE__ */ new Set([
"id",
"location",
"meta",
"actions",
"sync",
"refresh",
"toggle",
"effect",
"isApplicable",
"requiredPaths",
"onEnable",
"onDisable",
"dispose",
"config",
"diagnostics"
]);
var SECTIONS = /* @__PURE__ */ new Set(["quick", "stats", "misc"]);
var CONTROLS = /* @__PURE__ */ new Set(["button", "input", "range", "select", "text", "toggle"]);
var REFRESH = /* @__PURE__ */ new Set(["mount", "section-open", "after-action", "runtime-tick", "manual"]);
var CADENCES = /* @__PURE__ */ new Set(["frame", "daily"]);
var CONTROL_INTENTS = /* @__PURE__ */ new Set(["confirmation", "status"]);
var CONFIG_PATHS = new Set(CHEAT_CONFIG_SCHEMA.map(({ path: path7 }) => path7));
var CHEAT_CONTRACT_CONSTANTS = Object.freeze({
sections: Object.freeze([...SECTIONS]),
controlTypes: Object.freeze([...CONTROLS]),
refreshReasons: Object.freeze([...REFRESH]),
toggleCadences: Object.freeze([...CADENCES])
});
var plain = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value) && [Object.prototype, null].includes(Object.getPrototypeOf(value));
var text = (value) => typeof value === "string" && value.trim() !== "";
function stringArray(value, label) {
if (!Array.isArray(value) || value.some((item) => !text(item))) {
throw new TypeError(`${label} must be an array of non-empty strings.`);
}
const seen = /* @__PURE__ */ new Set();
for (const item of value) {
if (seen.has(item)) throw new Error(`${label} contains duplicate "${item}".`);
seen.add(item);
}
}
function validateCheatDefinition(definition) {
if (!plain(definition)) throw new TypeError("Cheat definition must be a plain object.");
for (const key of Object.keys(definition)) {
if (!FIELDS.has(key)) throw new Error(`Unknown cheat descriptor field "${key}".`);
}
if (!text(definition.id)) throw new TypeError("Cheat id must be a non-empty string.");
if (!/^[a-z0-9]+(?:[.-][a-z0-9]+)+$/.test(definition.id)) {
throw new Error(`Cheat id "${definition.id}" must be a lowercase namespaced id.`);
}
if (!plain(definition.location))
throw new TypeError(`Cheat "${definition.id}" location must be a plain object.`);
if (!SECTIONS.has(definition.location.section))
throw new Error(`Cheat "${definition.id}" has unsupported section.`);
if (!Number.isFinite(definition.location.order))
throw new TypeError(`Cheat "${definition.id}" location.order must be finite.`);
if (definition.location.group != null && !text(definition.location.group))
throw new TypeError(`Cheat "${definition.id}" location.group must be a non-empty string.`);
if (!plain(definition.meta) || !text(definition.meta.label))
throw new TypeError(`Cheat "${definition.id}" meta.label must be a non-empty string.`);
if (definition.meta.confirmation != null && !text(definition.meta.confirmation))
throw new TypeError(`Cheat "${definition.id}" meta.confirmation must be a non-empty string.`);
if (!Array.isArray(definition.meta.controls) || definition.meta.controls.length === 0)
throw new TypeError(`Cheat "${definition.id}" meta.controls must be a non-empty array.`);
if (definition.actions != null && !plain(definition.actions))
throw new TypeError(`Cheat "${definition.id}" actions must be a plain object.`);
for (const [name, action] of Object.entries(definition.actions ?? {})) {
if (!text(name) || typeof action !== "function")
throw new TypeError(`Cheat "${definition.id}" action "${name}" must be a function.`);
}
const keys = /* @__PURE__ */ new Set();
for (const control of definition.meta.controls) {
if (!plain(control) || !text(control.key))
throw new TypeError(`Cheat "${definition.id}" control key must be a non-empty string.`);
if (keys.has(control.key))
throw new Error(`Cheat "${definition.id}" has duplicate control key "${control.key}".`);
keys.add(control.key);
if (!CONTROLS.has(control.type))
throw new Error(`Cheat "${definition.id}" control "${control.key}" has invalid type.`);
if (control.intent != null && !CONTROL_INTENTS.has(control.intent))
throw new Error(`Cheat "${definition.id}" control "${control.key}" has invalid intent.`);
if (control.intent === "confirmation" && control.type !== "toggle")
throw new Error(`Cheat "${definition.id}" confirmation control must be a toggle.`);
if (control.intent === "status" && control.type !== "text")
throw new Error(`Cheat "${definition.id}" status control must be text.`);
if (control.action && !(control.action === "toggle" && definition.toggle) && typeof definition.actions?.[control.action] !== "function")
throw new Error(
`Cheat "${definition.id}" control "${control.key}" references missing local action "${control.action}".`
);
if (control.binding != null && (!plain(control.binding) || !text(control.binding.path)))
throw new TypeError(
`Cheat "${definition.id}" control binding path must be a non-empty string.`
);
if (control.binding?.writeOn != null && !["input", "change"].includes(control.binding.writeOn))
throw new Error(
`Cheat "${definition.id}" control "${control.key}" has invalid binding writeOn event.`
);
if (control.options != null && !Array.isArray(control.options) && typeof control.options !== "function")
throw new TypeError(
`Cheat "${definition.id}" control "${control.key}" options must be an array or function.`
);
if (control.fallbackOptions != null && !Array.isArray(control.fallbackOptions))
throw new TypeError(
`Cheat "${definition.id}" control "${control.key}" fallbackOptions must be an array.`
);
}
if (definition.refresh != null) {
stringArray(definition.refresh, `Cheat "${definition.id}" refresh`);
for (const reason of definition.refresh)
if (!REFRESH.has(reason))
throw new Error(`Cheat "${definition.id}" has invalid refresh reason "${reason}".`);
}
if (definition.toggle != null) {
if (!plain(definition.toggle) || !CADENCES.has(definition.toggle.cadence))
throw new Error(`Cheat "${definition.id}" has invalid toggle cadence.`);
if (typeof definition.effect !== "function")
throw new TypeError(`Cheat "${definition.id}" toggle requires effect().`);
if (!definition.meta.controls.some(({ type }) => type === "toggle"))
throw new Error(`Cheat "${definition.id}" toggle requires a toggle control.`);
if (definition.toggle.cooldownMs != null && (!Number.isFinite(definition.toggle.cooldownMs) || definition.toggle.cooldownMs < 0))
throw new TypeError(`Cheat "${definition.id}" toggle cooldownMs must be non-negative.`);
if (definition.toggle.maxFailures != null && (!Number.isInteger(definition.toggle.maxFailures) || definition.toggle.maxFailures < 1))
throw new TypeError(
`Cheat "${definition.id}" toggle maxFailures must be a positive integer.`
);
if (definition.toggle.runOnActivate != null && typeof definition.toggle.runOnActivate !== "boolean")
throw new TypeError(`Cheat "${definition.id}" toggle runOnActivate must be boolean.`);
} else if (definition.effect != null)
throw new Error(`Cheat "${definition.id}" effect requires toggle configuration.`);
for (const key of ["sync", "isApplicable", "onEnable", "onDisable", "dispose"])
if (definition[key] != null && typeof definition[key] !== "function")
throw new TypeError(`Cheat "${definition.id}" ${key} must be a function.`);
for (const key of ["requiredPaths", "config"])
if (definition[key] != null) stringArray(definition[key], `Cheat "${definition.id}" ${key}`);
if (definition.diagnostics != null && !plain(definition.diagnostics))
throw new TypeError(`Cheat "${definition.id}" diagnostics must be a plain object.`);
for (const path7 of definition.config ?? [])
if (!CONFIG_PATHS.has(path7))
throw new Error(`Cheat "${definition.id}" references unknown config path "${path7}".`);
if (!Object.keys(definition.actions ?? {}).length && typeof definition.effect !== "function" && typeof definition.sync !== "function")
throw new Error(`Cheat "${definition.id}" requires actions, effect, or sync.`);
return definition;
}
function freezeOwned(value) {
if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
for (const child of Object.values(value)) freezeOwned(child);
return Object.freeze(value);
}
function createCheat(definition) {
validateCheatDefinition(definition);
return freezeOwned(definition);
}
// src/cheats/definitions/developer/run-diagnostics.cheat.js
var revealed = /* @__PURE__ */ new WeakSet();
var lastReports = /* @__PURE__ */ new WeakMap();
function setRevealed(controls, visible) {
for (const key of ["run", "copy", "report"]) controls.element(key).hidden = !visible;
controls.element("reveal").hidden = visible;
if (visible) revealed.add(controls);
else revealed.delete(controls);
}
var runDiagnosticsCheat = createCheat({
id: "developer.run-diagnostics",
location: { section: "misc", group: "developer-tools", order: 1e3 },
meta: {
label: "Developer Tools",
controls: [
{ key: "reveal", type: "button", label: "Show Developer Tools", action: "reveal" },
{ key: "run", type: "button", label: "Run Diagnostics", action: "run" },
{ key: "copy", type: "button", label: "Copy Report", action: "copy" },
{ key: "report", type: "input" }
]
},
actions: {
reveal({ controls }) {
setRevealed(controls, true);
return { ok: true, message: "Developer Tools revealed for this modal." };
},
async run({ controls, services }) {
if (!revealed.has(controls))
return { ok: false, kind: "blocked", message: "Reveal Developer Tools first." };
if (!services.diagnostics?.runAll)
return { ok: false, kind: "blocked", message: "Diagnostics service is unavailable." };
const report = await services.diagnostics.runAll();
const text2 = services.diagnostics.formatReport(report);
lastReports.set(controls, text2);
controls.setValue("report", text2);
return {
ok: report.fail === 0,
kind: report.fail === 0 ? "success" : "validation",
variant: report.fail === 0 ? "success" : "warning",
message: `Diagnostics complete: ${report.pass} pass, ${report.warning} warning, ${report.fail} fail, ${report.blocked} blocked.`
};
},
async copy({ controls }) {
if (!revealed.has(controls))
return { ok: false, kind: "blocked", message: "Reveal Developer Tools first." };
const text2 = lastReports.get(controls) ?? controls.value("report");
if (!text2) return { ok: false, kind: "blocked", message: "Run diagnostics before copying." };
const input = controls.element("report");
const clipboard = input.ownerDocument.defaultView.navigator.clipboard;
if (clipboard?.writeText) {
await clipboard.writeText(text2);
return { ok: true, message: "Diagnostic report copied." };
}
input.hidden = false;
input.focus();
input.select();
return { ok: true, variant: "info", message: "Clipboard unavailable; report selected." };
}
},
onEnable({ controls }) {
setRevealed(controls, false);
},
dispose({ controls }) {
revealed.delete(controls);
lastReports.delete(controls);
},
diagnostics: { developerOnly: true, readOnly: true }
});
// src/cheats/definitions/player/balls.cheat.js
var ballsCheat = createCheat({
id: "player.balls",
location: { section: "stats", group: "player", order: 40 },
meta: {
label: "Balls",
controls: [{ key: "toggle", type: "button", label: "Remove", action: "toggle" }]
},
requiredPaths: ["player.ballsExist"],
refresh: ["mount", "section-open"],
actions: {
toggle({ game }) {
game.set("player.ballsExist", !game.get("player.ballsExist"));
return { ok: true, message: "Balls updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.text("toggle", game.get("player.ballsExist") ? "Remove" : "Add");
}
});
// src/cheats/definitions/player/body-size.cheat.js
var BODY_SIZES = Object.freeze({ Tiny: 0, Small: 1, Normal: 2, Large: 3 });
var BODY_LABELS = Object.freeze(["Tiny", "Small", "Normal", "Large"]);
var bodySizeCheat = createCheat({
id: "player.body-size",
location: { section: "stats", group: "player", order: 20 },
meta: {
label: "Body Size",
controls: [
{ key: "size", type: "select", options: Object.keys(BODY_SIZES) },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["bodysize"],
refresh: ["mount", "section-open", "after-action"],
actions: {
set({ game, controls }) {
const selected = controls.value("size");
if (!Object.hasOwn(BODY_SIZES, selected)) {
return { ok: false, kind: "validation", message: "Unknown body size." };
}
game.set("bodysize", BODY_SIZES[selected]);
return { ok: true, message: "Body size updated." };
}
},
sync({ game, controls }) {
controls.setValue("size", BODY_LABELS[game.get("bodysize")] ?? BODY_LABELS[2]);
}
});
// src/cheats/definitions/player/body-type.cheat.js
var TYPES = Object.freeze({ Masculine: "m", Feminine: "f", Androgynous: "a" });
var LABELS = Object.freeze({ m: "Masculine", f: "Feminine", a: "Androgynous" });
var bodyTypeCheat = createCheat({
id: "player.body-type",
location: { section: "stats", group: "player", order: 30 },
meta: {
label: "Natural Features",
controls: [
{ key: "type", type: "select", options: Object.keys(TYPES) },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["player.gender_body"],
refresh: ["mount", "section-open"],
actions: {
set({ game, controls }) {
const value = TYPES[controls.value("type")];
if (!value) return { ok: false, kind: "validation", message: "Unknown body type." };
game.set("player.gender_body", value);
return { ok: true, message: "Body type updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.setValue("type", LABELS[game.get("player.gender_body")] ?? "Androgynous");
}
});
// src/cheats/definitions/player/characteristics.cheat.js
function integer(controls, key) {
return Number.parseInt(controls.value(key), 10);
}
var characteristicsCheat = createCheat({
id: "player.characteristics",
location: { section: "stats", group: "player", order: 80 },
meta: {
label: "Characteristics",
controls: [
{ key: "characteristic", type: "select", options: characteristics, action: "select" },
{ key: "characteristicValue", type: "input" },
{ key: "setCharacteristic", type: "button", label: "Set", action: "setCharacteristic" }
]
},
requiredPaths: [...characteristics],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
setCharacteristic({ game, controls }) {
const value = integer(controls, "characteristicValue");
if (Number.isNaN(value))
return { ok: false, kind: "validation", message: "Input is not a number." };
game.set(controls.value("characteristic"), value);
return { ok: true, message: "Characteristic updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.setValue("characteristicValue", game.get(controls.value("characteristic")));
}
});
// src/cheats/definitions/player/crime.cheat.js
function numericCrimes(game) {
return Object.entries(game.get("crime") ?? {}).filter(
([, crime]) => Number.isFinite(Number.parseInt(crime?.current, 10))
);
}
var crimeCheat = createCheat({
id: "player.crime",
location: { section: "stats", group: "player", order: 60 },
meta: {
label: "Crime",
controls: [
{ key: "current", type: "text", intent: "status" },
{ key: "reduce", type: "button", label: "-100", action: "reduce" },
{ key: "increase", type: "button", label: "+100", action: "increase" }
]
},
requiredPaths: ["crime"],
refresh: ["mount", "section-open"],
actions: {
reduce({ game }) {
const entries2 = numericCrimes(game);
if (!entries2.length) return { ok: false, kind: "blocked", message: "No crime data." };
const value = Number.parseInt(
(entries2.reduce((sum, [, crime]) => sum + Number.parseInt(crime.current, 10), 0) - 100) / entries2.length,
10
);
for (const [key] of entries2) {
for (const field of ["current", "count", "countHistory", "history"])
game.set(`crime.${key}.${field}`, value);
}
return { ok: true, message: "Crime reduced.", refresh: true };
},
increase({ game }) {
const entries2 = numericCrimes(game);
if (!entries2.length) return { ok: false, kind: "blocked", message: "No crime data." };
const value = Number.parseInt(
(entries2.reduce((sum, [, crime]) => sum + Number.parseInt(crime.current, 10), 0) + 100) / entries2.length,
10
);
for (const [key] of entries2) game.set(`crime.${key}.current`, value);
return { ok: true, message: "Crime increased.", refresh: true };
}
},
sync({ game, controls }) {
controls.text(
"current",
numericCrimes(game).reduce((sum, [, crime]) => sum + Number.parseInt(crime.current, 10), 0)
);
}
});
// src/cheats/definitions/player/cum.cheat.js
var cumCheat = createCheat({
id: "player.cum",
location: { section: "stats", group: "player", order: 83 },
meta: {
label: "Cum",
controls: [
{ key: "volume", type: "input", binding: { path: "semen_volume" } },
{ key: "set", type: "button", label: "Set", action: "set" },
{ key: "refill", type: "button", label: "Refill", action: "refill" }
]
},
requiredPaths: ["semen_volume", "semen_amount"],
refresh: ["mount", "section-open"],
actions: {
set({ game, controls }) {
const value = Number.parseInt(controls.value("volume"), 10);
if (Number.isNaN(value))
return { ok: false, kind: "validation", message: "Input is not a number." };
game.set("semen_volume", value);
return { ok: true, message: "Cum volume updated." };
},
refill({ game }) {
game.set("semen_amount", game.get("semen_volume"));
return { ok: true, message: "Cum refilled." };
}
}
});
// src/cheats/definitions/player/editor-helpers.js
function hydrateSelectedValue({ game, controls, path: path7 }) {
const input = controls.element("value");
if (input.ownerDocument.activeElement === input) return;
controls.setValue("value", game.get(path7(controls.value("field"))) ?? "");
}
function setSelectedNumber({ game, controls, path: path7, label, requireExisting = true }) {
const field = controls.value("field");
const value = Number(controls.value("value"));
if (!field || !Number.isFinite(value))
return { ok: false, kind: "validation", message: `${label} must be a number.` };
const target = path7(field);
if (requireExisting && !game.has(target))
return { ok: false, kind: "validation", message: `${label} is unavailable.` };
game.set(target, value);
return { ok: true, message: `${label} updated.`, refresh: true };
}
function selectAndRefresh() {
return { ok: true, refresh: true };
}
// src/cheats/definitions/player/enemy-stats.cheat.js
var FIELDS2 = ["enemyhealth", "enemytrust", "enemyanger"];
var path = (field) => field;
var enemyStatsCheat = createCheat({
id: "player.enemy-stats",
location: { section: "stats", group: "enemy", order: 1 },
meta: {
label: "Enemy Stats",
controls: [
{ key: "field", type: "select", options: FIELDS2, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: FIELDS2,
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({ ...context, path, label: "Enemy stat" });
}
},
sync(context) {
hydrateSelectedValue({ ...context, path });
}
});
// src/cheats/definitions/player/exam.cheat.js
var path2 = (field) => field;
var examCheat = createCheat({
id: "player.exam",
location: { section: "stats", group: "school", order: 110 },
meta: {
label: "Exam",
controls: [
{ key: "field", type: "select", options: exam, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({
...context,
path: path2,
label: "Exam value",
requireExisting: false
});
}
},
sync(context) {
hydrateSelectedValue({ ...context, path: path2 });
}
});
// src/cheats/definitions/player/fame.cheat.js
var path3 = (field) => `fame.${field}`;
var fameCheat = createCheat({
id: "player.fame",
location: { section: "stats", group: "fame", order: 100 },
meta: {
label: "Fame",
controls: [
{ key: "field", type: "select", options: fame, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["fame"],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({ ...context, path: path3, label: "Fame" });
}
},
sync(context) {
hydrateSelectedValue({ ...context, path: path3 });
}
});
// src/cheats/definitions/player/hentai-skill.cheat.js
var path4 = (field) => field;
var hentaiSkillCheat = createCheat({
id: "player.hentai-skill",
location: { section: "stats", group: "talent", order: 140 },
meta: {
label: "Hentai Skill",
controls: [
{ key: "field", type: "select", options: hentaiSkill, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({
...context,
path: path4,
label: "Hentai skill",
requireExisting: false
});
}
},
sync(context) {
hydrateSelectedValue({ ...context, path: path4 });
}
});
// src/cheats/definitions/player/infinite-arousal.cheat.js
var infiniteArousalCheat = createCheat({
id: "player.infinite-arousal",
location: { section: "quick", group: "unlimited", order: 20 },
meta: {
label: "Unlimited Arousal",
controls: [{ key: "enabled", type: "toggle", label: "Arousal", action: "toggle" }]
},
requiredPaths: ["arousal"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("arousal", 1e4);
}
});
// src/cheats/definitions/player/lactation.cheat.js
var lactationCheat = createCheat({
id: "player.lactation",
location: { section: "stats", group: "player", order: 81 },
meta: {
label: "Lactation",
controls: [{ key: "toggle", type: "button", label: "Yes", action: "toggle" }]
},
requiredPaths: ["lactating"],
refresh: ["mount", "section-open"],
actions: {
toggle({ game }) {
game.set("lactating", game.get("lactating") == 1 ? 0 : 1);
return { ok: true, message: "Lactation updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.text("toggle", game.get("lactating") == 1 ? "No" : "Yes");
}
});
// src/cheats/definitions/player/milk.cheat.js
var milkCheat = createCheat({
id: "player.milk",
location: { section: "stats", group: "player", order: 82 },
meta: {
label: "Milk",
controls: [
{ key: "volume", type: "input", binding: { path: "milk_volume" } },
{ key: "set", type: "button", label: "Set", action: "set" },
{ key: "refill", type: "button", label: "Refill", action: "refill" }
]
},
requiredPaths: ["milk_volume", "milk_amount"],
refresh: ["mount", "section-open"],
actions: {
set({ game, controls }) {
const value = Number.parseInt(controls.value("volume"), 10);
if (Number.isNaN(value))
return { ok: false, kind: "validation", message: "Input is not a number." };
game.set("milk_volume", value);
return { ok: true, message: "Milk volume updated." };
},
refill({ game }) {
game.set("milk_amount", game.get("milk_volume"));
return { ok: true, message: "Milk refilled." };
}
}
});
// src/cheats/definitions/player/money.cheat.js
var moneyCheat = createCheat({
id: "player.money",
location: { section: "stats", group: "player", order: 10 },
meta: {
label: "Money",
controls: [
{ key: "value", type: "input", binding: { path: "money", coerce: "number" } },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["money"],
refresh: ["mount", "section-open", "after-action"],
actions: {
set({ game, controls }) {
const value = Number.parseInt(controls.value("value"), 10);
if (Number.isNaN(value)) {
return { ok: false, kind: "validation", message: "Input is not a number." };
}
game.set("money", value);
return { ok: true, message: "Money updated." };
}
}
});
// src/cheats/definitions/player/parasites.cheat.js
var parasitesCheat = createCheat({
id: "player.parasites",
location: { section: "stats", group: "player", order: 70 },
meta: {
label: "Parasite",
controls: [
{ key: "parasite", type: "select", options: parasitename },
{ key: "body", type: "select", options: bodyparts },
{ key: "infect", type: "button", label: "Infect", action: "infect" },
{ key: "remove", type: "button", label: "Remove", action: "remove" }
]
},
requiredPaths: ["parasite"],
actions: {
infect({ game, controls }) {
const parasite = controls.value("parasite");
const body = controls.value("body");
const locations = game.get(`parasite.${parasite}`);
if (!Array.isArray(locations) || game.get(`parasite.${body}`) == null)
return { ok: false, kind: "blocked", message: "Parasite data is unavailable." };
if (!locations.includes(body)) game.set(`parasite.${parasite}`, [...locations, body]);
game.set(`parasite.${body}.name`, parasite);
return { ok: true, message: "Parasite infected." };
},
remove({ game, controls }) {
const parasite = controls.value("parasite");
const body = controls.value("body");
const locations = game.get(`parasite.${parasite}`);
if (!Array.isArray(locations))
return { ok: false, kind: "blocked", message: "Parasite data is unavailable." };
game.set(`parasite.${body}`, []);
game.set(
`parasite.${parasite}`,
locations.filter((item) => item !== body)
);
return { ok: true, message: "Parasite removed." };
}
}
});
// src/cheats/definitions/player/school-reputation.cheat.js
var path5 = (field) => field;
var schoolReputationCheat = createCheat({
id: "player.school-reputation",
location: { section: "stats", group: "school", order: 120 },
meta: {
label: "School Reputation",
controls: [
{ key: "field", type: "select", options: school_rep, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({
...context,
path: path5,
label: "School reputation",
requireExisting: false
});
}
},
sync(context) {
hydrateSelectedValue({ ...context, path: path5 });
}
});
// src/cheats/definitions/player/stats.cheat.js
var STATS = Object.freeze([
"pain",
"arousal",
"tiredness",
"stress",
"trauma",
"control",
"drunk",
"drugged",
"hallucinogen"
]);
var playerStatsCheat = createCheat({
id: "player.stats",
location: { section: "stats", group: "player", order: 1 },
meta: {
label: "Player Stats",
controls: [
{ key: "stat", type: "select", options: STATS, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: STATS,
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set({ game, controls }) {
const value = Number.parseFloat(controls.value("value"));
if (Number.isNaN(value))
return { ok: false, kind: "validation", message: "Value is not a number." };
game.set(controls.value("stat"), value);
return { ok: true, message: "Player stat updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.setValue("value", game.get(controls.value("stat")));
}
});
// src/cheats/definitions/player/talent.cheat.js
var path6 = (field) => field;
var talentCheat = createCheat({
id: "player.talent",
location: { section: "stats", group: "talent", order: 130 },
meta: {
label: "Talent",
controls: [
{ key: "field", type: "select", options: talent_skill, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh,
set(context) {
return setSelectedNumber({
...context,
path: path6,
label: "Talent",
requireExisting: false
});
}
},
sync(context) {
hydrateSelectedValue({ ...context, path: path6 });
}
});
// src/cheats/definitions/player/unlimited-spray.cheat.js
var unlimitedSprayCheat = createCheat({
id: "player.unlimited-spray",
location: { section: "stats", group: "player", order: 15 },
meta: {
label: "Unlimited Spray",
controls: [{ key: "toggle", type: "button", label: "Set", action: "toggle" }]
},
requiredPaths: ["infinitespray"],
refresh: ["mount", "section-open"],
actions: {
toggle({ game }) {
game.set("infinitespray", game.get("infinitespray") === 1 ? 0 : 1);
return { ok: true, message: "Unlimited spray updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.text("toggle", game.get("infinitespray") === 1 ? "Unset" : "Set");
}
});
// src/cheats/definitions/player/virginity.cheat.js
var TYPES2 = Object.freeze(["anal", "oral", "penile", "vaginal", "temple", "handholding", "kiss"]);
var virginityCheat = createCheat({
id: "player.virginity",
location: { section: "stats", group: "player", order: 50 },
meta: {
label: "Virginity",
controls: [
{ key: "type", type: "select", options: TYPES2, action: "select" },
{ key: "current", type: "text", intent: "status" },
{ key: "restore", type: "button", label: "Restore", action: "restore" },
{ key: "pure", type: "button", label: "Pure", action: "pure" }
]
},
requiredPaths: ["player.virginity"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
restore({ game, controls }) {
game.set(`player.virginity.${controls.value("type")}`, true);
return { ok: true, message: "Virginity restored.", refresh: true };
},
pure({ game }) {
for (const type of TYPES2) game.set(`player.virginity.${type}`, true);
return { ok: true, message: "Purity applied.", refresh: true };
}
},
sync({ game, controls }) {
controls.text(
"current",
game.get(`player.virginity.${controls.value("type")}`) ? "Pure" : "Taken"
);
}
});
// src/cheats/definitions/quick/arousal.cheat.js
function percentage(controls) {
const value = Number(controls.value("percentage"));
return Number.isFinite(value) ? Math.max(0, Math.min(100, value)) : null;
}
var arousalCheat = createCheat({
id: "quick.arousal",
location: { section: "quick", group: "state", order: 10 },
meta: {
label: "Arousal",
controls: [
{ key: "percentage", type: "range", value: 0, action: "preview", event: "input" },
{ key: "current", type: "text", label: "0%", intent: "status" },
{ key: "player", type: "button", label: "Player", action: "player" },
{ key: "enemy", type: "button", label: "Enemy", action: "enemy" }
]
},
refresh: ["mount", "section-open"],
actions: {
preview() {
return { ok: true, refresh: true };
},
player({ game, controls }) {
const value = percentage(controls);
if (value == null)
return { ok: false, kind: "validation", message: "Arousal must be a number." };
game.set("arousal", Math.trunc(1e4 * value / 100));
return { ok: true, message: "Player arousal updated.", refresh: true };
},
enemy({ game, controls }) {
const value = percentage(controls);
if (value == null)
return { ok: false, kind: "validation", message: "Arousal must be a number." };
game.set("enemyarousal", Math.trunc((game.get("enemyarousalmax") || 0) * value / 100));
return { ok: true, message: "Enemy arousal updated.", refresh: true };
}
},
sync({ controls }) {
controls.text("current", `${controls.value("percentage")}%`);
}
});
// src/cheats/definitions/quick/auto-child-interaction.cheat.js
var autoChildInteractionCheat = createCheat({
id: "quick.auto-child-interaction",
location: { section: "quick", group: "unlimited", order: 90 },
meta: {
label: "Automatic Child Interaction",
controls: [
{
key: "enabled",
type: "toggle",
label: "Auto",
action: "toggle",
tooltip: "You must visit your baby first to trigger automatic interaction."
}
]
},
requiredPaths: ["children"],
toggle: { cadence: "frame", cooldownMs: 200, maxFailures: 5, runOnActivate: true },
effect({ game }) {
for (const child of Object.values(game.get("children") ?? {})) {
const local = child?.localVariables;
if (local?.event !== true) continue;
local.interactions = (local.interactions ?? 0) + 1;
local.interactionsTotal = (local.interactionsTotal ?? 0) + 1;
local.event = false;
}
}
});
// src/cheats/definitions/quick/eden-garden.cheat.js
var edenGardenCheat = createCheat({
id: "quick.eden-garden",
location: { section: "quick", group: "tasks", order: 40 },
meta: {
label: "Eden Garden",
controls: [{ key: "enabled", type: "toggle", label: "Garden", action: "toggle" }]
},
requiredPaths: ["edengarden"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("edengarden", 4);
}
});
// src/cheats/definitions/quick/eden-mushrooms.cheat.js
var edenMushroomsCheat = createCheat({
id: "quick.eden-mushrooms",
location: { section: "quick", group: "tasks", order: 30 },
meta: {
label: "Eden Mushrooms",
controls: [{ key: "enabled", type: "toggle", label: "Mushrooms", action: "toggle" }]
},
requiredPaths: ["edenshrooms"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("edenshrooms", 4);
}
});
// src/cheats/definitions/quick/eden-spring.cheat.js
var edenSpringCheat = createCheat({
id: "quick.eden-spring",
location: { section: "quick", group: "tasks", order: 50 },
meta: {
label: "Eden Spring",
controls: [{ key: "enabled", type: "toggle", label: "Spring", action: "toggle" }]
},
requiredPaths: ["edenspring"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("edenspring", 4);
}
});
// src/cheats/definitions/quick/eden-timer.cheat.js
var edenTimerCheat = createCheat({
id: "quick.eden-timer",
location: { section: "quick", group: "tasks", order: 60 },
meta: {
label: "Eden Timer",
controls: [{ key: "enabled", type: "toggle", label: "Timer", action: "toggle" }]
},
requiredPaths: ["edendays"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("edendays", 0);
}
});
// src/cheats/definitions/quick/enemy-state.cheat.js
var enemyStateCheat = createCheat({
id: "quick.enemy-state",
location: { section: "quick", group: "state", order: 30 },
meta: {
label: "Enemy State",
controls: [
{ key: "recover", type: "button", label: "Recover", action: "recover" },
{ key: "ruin", type: "button", label: "Ruin", action: "ruin" }
]
},
actions: {
recover({ game }) {
game.set("enemyhealth", Number(game.get("enemyhealthmax")) > 0 ? 100 : 0);
game.set("enemytrust", 100);
game.set("enemyanger", 0);
return { ok: true, message: "Enemy recovered." };
},
ruin({ game }) {
game.set("enemyhealth", 0);
game.set("enemytrust", 100);
game.set("enemyanger", 0);
return { ok: true, message: "Enemy ruined." };
}
}
});
// src/cheats/definitions/quick/everyone-horny.cheat.js
var everyoneHornyCheat = createCheat({
id: "quick.everyone-horny",
location: { section: "quick", group: "unlimited", order: 60 },
meta: {
label: "Everyone Is Horny",
controls: [{ key: "enabled", type: "toggle", label: "Horny", action: "toggle" }]
},
requiredPaths: ["NPCName"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
for (const [index, npc] of (game.get("NPCName") ?? []).entries()) {
if ((npc.nam ?? npc.description) === "Ivory Wraith") continue;
game.set(`NPCName.${index}.lust`, 100);
}
}
});
// src/cheats/definitions/quick/farm-safety.cheat.js
var farmSafetyCheat = createCheat({
id: "quick.farm-safety",
location: { section: "quick", group: "unlimited", order: 70 },
meta: {
label: "Farm Safety",
controls: [{ key: "enabled", type: "toggle", label: "Safe", action: "toggle" }]
},
requiredPaths: ["farm.aggro"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("farm.aggro", 0);
}
});
// src/cheats/definitions/quick/game-cheats.cheat.js
function documentOf(controls) {
return controls.element("open").ownerDocument;
}
var gameCheatsCheat = createCheat({
id: "quick.game-cheats",
location: { section: "quick", group: "state", order: 70 },
meta: {
label: "In-game Cheats",
controls: [
{ key: "toggle", type: "button", label: "Enable", action: "toggle" },
{ key: "open", type: "button", label: "Open", action: "open" }
]
},
refresh: ["mount", "section-open", "after-action", "runtime-tick"],
actions: {
toggle({ game }) {
const enabled = game.get("debug") !== 1;
game.set("debug", enabled ? 1 : 0);
return {
ok: true,
message: `In-game cheats ${enabled ? "enabled" : "disabled"}.`,
refresh: true
};
},
open({ game, controls }) {
const button = [
...documentOf(controls).getElementById("overlayButtons")?.querySelectorAll?.(".link-internal") ?? []
].find((candidate) => candidate.textContent?.trim() === "CHEATS");
if (!button) {
return {
ok: false,
kind: "blocked",
message: game.get("debug") === 1 ? "Change passage once, then try opening cheats again." : "Enable in-game cheats first."
};
}
controls.element("open").getRootNode()?.querySelector?.("#close-modal-top")?.click();
button.click();
return { ok: true };
}
},
sync({ game, controls }) {
controls.text("toggle", game.get("debug") === 1 ? "Disable" : "Enable");
}
});
// src/cheats/definitions/quick/hygiene.cheat.js
function fillBodyLiquid(game, amount) {
const bodyLiquid = game.get("player.bodyliquid");
if (!bodyLiquid || typeof bodyLiquid !== "object") return false;
for (const [outer, values] of Object.entries(bodyLiquid)) {
if (!values || typeof values !== "object") continue;
for (const inner of Object.keys(values))
game.set(`player.bodyliquid.${outer}.${inner}`, amount);
}
return true;
}
var hygieneCheat = createCheat({
id: "quick.hygiene",
location: { section: "quick", group: "state", order: 60 },
meta: {
label: "Hygiene",
controls: [
{ key: "clean", type: "button", label: "Clean", action: "clean" },
{ key: "dirty", type: "button", label: "Dirty", action: "dirty" },
{ key: "urethra", type: "button", label: "Clean urethral cum", action: "urethra" }
]
},
actions: {
clean({ game }) {
return fillBodyLiquid(game, 0) ? { ok: true, message: "Body liquids cleaned." } : { ok: false, kind: "validation", message: "Body-liquid data is unavailable." };
},
dirty({ game }) {
return fillBodyLiquid(game, 100) ? { ok: true, message: "Body liquids filled." } : { ok: false, kind: "validation", message: "Body-liquid data is unavailable." };
},
urethra({ game }) {
if (!Array.isArray(game.get("sexStats.vagina.sperm")))
return { ok: false, kind: "validation", message: "Vaginal sperm data is unavailable." };
game.set("sexStats.vagina.sperm", []);
return { ok: true, message: "Urethral cum cleaned." };
}
}
});
// src/cheats/definitions/quick/infinite-npc-pregnancy.cheat.js
var SECONDS_PER_DAY2 = 86400;
var ACTIVE_LIMIT = 8;
var HARD_LIMIT = 10;
function processNpcPregnancyOverflow({ game, config, feedback }) {
const mainNpcs = game.get("storedNPCs") ?? {};
const mainLength = Object.keys(mainNpcs).length;
const priority = config.get("storedNPCsPriority") || 0;
const currentDate = Math.floor(game.get("timeStamp") / SECONDS_PER_DAY2);
const lastDate = config.get("storedNPCsDate");
const elapsedTimerUnits = lastDate !== 0 ? (currentDate - lastDate) * 3 : 0;
if (elapsedTimerUnits === 0) {
if (mainLength <= ACTIVE_LIMIT) return;
if (priority >= ACTIVE_LIMIT) return;
}
const waitingNpcs = { ...config.get("storedNPCs") ?? {} };
const active = {};
const waiting = {};
let activeCount = 0;
config.set("storedNPCsDate", currentDate);
for (const npc of Object.values(mainNpcs)) {
const pregnancy = npc?.pregnancy;
const remaining = pregnancy.timerEnd - pregnancy.timer;
if (remaining <= 3 && activeCount <= ACTIVE_LIMIT) {
active[`stored_${activeCount}`] = npc;
if (activeCount === ACTIVE_LIMIT)
feedback.warning?.("An NPC is about to give birth; pregnancy capacity is full today.");
activeCount += 1;
} else waiting[`stored_${Object.keys(waiting).length}`] = npc;
}
for (const npc of Object.values(waitingNpcs)) {
const pregnancy = npc?.pregnancy;
let timer = pregnancy.timer;
if (elapsedTimerUnits > 0) {
timer = Math.min(pregnancy.timerEnd, timer + elapsedTimerUnits);
pregnancy.timer = timer;
}
const remaining = pregnancy.timerEnd - timer;
if (remaining <= 3 && activeCount <= HARD_LIMIT) {
active[`stored_${activeCount}`] = npc;
if (activeCount === ACTIVE_LIMIT)
feedback.warning?.("An NPC is about to give birth; pregnancy capacity is full today.");
activeCount += 1;
} else waiting[`stored_${Object.keys(waiting).length}`] = npc;
}
config.set("storedNPCsPriority", activeCount);
config.set("storedNPCs", waiting);
game.set("storedNPCs", active);
}
var infiniteNpcPregnancyCheat = createCheat({
id: "quick.infinite-npc-pregnancy",
location: { section: "quick", group: "pregnancy", order: 70 },
meta: {
label: "Infinite NPC Pregnancy",
controls: [
{
key: "enabled",
type: "toggle",
label: "Preserve",
action: "toggle",
tooltip: "Stores overflow pregnancies in CheatPlus until they are one day from birth."
}
]
},
requiredPaths: ["storedNPCs", "timeStamp"],
config: ["storedNPCs", "storedNPCsDate", "storedNPCsPriority"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect(context) {
processNpcPregnancyOverflow(context);
}
});
// src/cheats/definitions/quick/intense-cum.cheat.js
var temporaryArousal = 0;
var previousOrgasmDown = -1;
var intenseCumCheat = createCheat({
id: "quick.intense-cum",
location: { section: "quick", group: "unlimited", order: 80 },
meta: {
label: "Intense Cum",
controls: [{ key: "enabled", type: "toggle", label: "Intense", action: "toggle" }]
},
requiredPaths: ["orgasmcurrent", "orgasmdown", "arousal"],
config: ["orgasmCount", "unlicumMode"],
toggle: { cadence: "frame", cooldownMs: 80, maxFailures: 5, runOnActivate: true },
effect({ game, config }) {
if (game.get("orgasmcurrent") != 0 && !config.get("unlicumMode")) {
config.set("orgasmCount", 0);
temporaryArousal = game.get("arousal");
game.set("orgasmdown", 1e3);
previousOrgasmDown = 1e3;
config.set("unlicumMode", true);
return;
}
if (game.get("orgasmdown") >= previousOrgasmDown || !config.get("unlicumMode")) return;
previousOrgasmDown = game.get("orgasmdown");
game.set("arousal", temporaryArousal);
const count = config.get("orgasmCount") + 1;
config.set("orgasmCount", count);
if (count <= 2) return;
config.set("unlicumMode", false);
config.set("orgasmCount", 0);
game.set("orgasmdown", -1);
game.set("orgasmcurrent", 0);
previousOrgasmDown = -1;
}
});
// src/cheats/definitions/quick/invincible-angel.cheat.js
var invincibleAngelCheat = createCheat({
id: "quick.invincible-angel",
location: { section: "quick", group: "unlimited", order: 100 },
meta: {
label: "Invincible Angel",
controls: [
{
key: "enabled",
type: "toggle",
label: "Protect",
action: "toggle",
tooltip: "Prevents angel build from falling and helps prevent becoming a fallen angel. Combine it with Maintain Purity."
}
]
},
requiredPaths: ["penisstate", "vaginastate", "angel", "angelbuild"],
config: ["angel", "angelMode"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 1, runOnActivate: true },
effect({ game, config, feedback }) {
if (game.get("demon") > 0) feedback.warning?.("You are currently a demon.");
if (game.get("fallenangel") > 0) {
throw new Error("Invincible Angel is unavailable after becoming a fallen angel.");
}
const transformed = game.get("penisstate") != 0 || game.get("vaginastate") != 0;
if (transformed) {
if (!config.get("angelMode")) return;
config.set("angel", game.get("angel"));
game.set("angel", 0);
game.set("angelbuild", 100);
config.set("angelMode", true);
} else if (!config.get("angelMode")) {
game.set("angel", config.get("angel"));
}
}
});
// src/cheats/definitions/quick/maintain-purity.cheat.js
var maintainPurityCheat = createCheat({
id: "quick.maintain-purity",
location: { section: "quick", group: "unlimited", order: 50 },
meta: {
label: "Maintain Purity",
controls: [{ key: "enabled", type: "toggle", label: "Pure", action: "toggle" }]
},
requiredPaths: ["purity"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("purity", 1e3);
}
});
// src/cheats/definitions/quick/maintain-virginity.cheat.js
var maintainVirginityCheat = createCheat({
id: "quick.maintain-virginity",
location: { section: "quick", group: "unlimited", order: 40 },
meta: {
label: "Maintain Virginity",
controls: [{ key: "enabled", type: "toggle", label: "Virgin", action: "toggle" }]
},
requiredPaths: ["player.virginity.penile", "player.virginity.vaginal"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("player.virginity.penile", true);
game.set("player.virginity.vaginal", true);
}
});
// src/cheats/definitions/quick/maximum-npc-pregnancy-rate.cheat.js
var maximumNpcPregnancyRateCheat = createCheat({
id: "quick.maximum-npc-pregnancy-rate",
location: { section: "quick", group: "pregnancy", order: 110 },
meta: {
label: "Maximum NPC Pregnancy Rate",
controls: [
{
key: "enabled",
type: "toggle",
label: "Maximum",
action: "toggle",
tooltip: "Gives NPCs the maximum pregnancy rate. Some NPCs still cannot become pregnant; Multiple NPC Pregnancies permits repeated pregnancies."
}
]
},
requiredPaths: ["baseNpcPregnancyChance", "NPCList"],
config: ["baseNpcPregnancyChance"],
toggle: { cadence: "frame", cooldownMs: 250, maxFailures: 5, runOnActivate: true },
effect({ game, config }) {
if (config.get("baseNpcPregnancyChance") === null)
config.set("baseNpcPregnancyChance", game.get("baseNpcPregnancyChance"));
game.set("baseNpcPregnancyChance", 19);
for (const npc of game.get("NPCList")) {
if (npc?.pregnancyAvoidance > 0) npc.pregnancyAvoidance = 0;
}
}
});
// src/cheats/definitions/quick/maximum-stray-tasks.cheat.js
var maximumStrayTasksCheat = createCheat({
id: "quick.maximum-stray-tasks",
location: { section: "quick", group: "tasks", order: 20 },
meta: {
label: "Maximum Stray Tasks",
controls: [{ key: "enabled", type: "toggle", label: "Stray", action: "toggle" }]
},
requiredPaths: ["stray_happiness"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("stray_happiness", 100);
}
});
// src/cheats/definitions/quick/multiple-npc-pregnancies.cheat.js
var multipleNpcPregnanciesCheat = createCheat({
id: "quick.multiple-npc-pregnancies",
location: { section: "quick", group: "pregnancy", order: 120 },
meta: {
label: "Multiple NPC Pregnancies",
controls: [
{
key: "enabled",
type: "toggle",
label: "Multiple",
action: "toggle",
tooltip: "Allows NPCs to become pregnant multiple times."
}
]
},
requiredPaths: ["NPCList"],
toggle: { cadence: "frame", cooldownMs: 250, maxFailures: 5, runOnActivate: true },
effect({ game }) {
for (const npc of game.get("NPCList")) {
if (npc?.pregnancy === 1) npc.pregnancy = 0;
}
}
});
// src/cheats/definitions/quick/player-state.cheat.js
var RECOVERED = Object.freeze({
pain: 0,
arousal: 0,
tiredness: 0,
stress: 0,
trauma: 0,
control: 1e3,
drunk: 0,
drugged: 0,
hallucinogen: 0
});
var RUINED = Object.freeze({
pain: 200,
arousal: 1e4,
tiredness: 2e3,
stress: 1e4,
trauma: 5e3,
control: 0,
drunk: 1e3,
drugged: 1e3,
hallucinogen: 1e3
});
function applyValues(game, values) {
for (const [path7, value] of Object.entries(values)) game.set(path7, value);
}
var playerStateCheat = createCheat({
id: "quick.player-state",
location: { section: "quick", group: "state", order: 1 },
meta: {
label: "Player State",
controls: [
{ key: "recover", type: "button", label: "Recover", action: "recover" },
{ key: "ruin", type: "button", label: "Ruin", action: "ruin" }
]
},
requiredPaths: Object.keys(RECOVERED),
actions: {
recover({ game }) {
applyValues(game, RECOVERED);
return { ok: true, message: "Player recovered." };
},
ruin({ game }) {
applyValues(game, RUINED);
return { ok: true, message: "Player ruined." };
}
}
});
// src/cheats/definitions/quick/pregnancy-detection.cheat.js
var previousNpcCount = 0;
var previousPlayerCount = 0;
function npcCount(game, config) {
let total = Object.keys(game.get("storedNPCs") ?? {}).length;
total += Object.keys(config.get("storedNPCs") ?? {}).length;
for (const npc of game.get("NPCName") ?? []) {
if (npc?.pregnancy?.fetus?.length > 0) total += 1;
}
return total;
}
function playerCount(game) {
return (game.get("sexStats.vagina.pregnancy.fetus")?.length ?? 0) + (game.get("sexStats.anus.pregnancy.fetus")?.length ?? 0);
}
var pregnancyDetectionCheat = createCheat({
id: "quick.pregnancy-detection",
location: { section: "quick", group: "pregnancy", order: 100 },
meta: {
label: "Pregnancy Detection",
controls: [{ key: "enabled", type: "toggle", label: "Detect", action: "toggle" }]
},
requiredPaths: ["storedNPCs", "NPCName", "sexStats", "timeStamp"],
config: ["storedNPCs", "storedNPCsDate", "storedNPCsPriority"],
toggle: { cadence: "frame", cooldownMs: 250, maxFailures: 5, runOnActivate: true },
onEnable() {
previousNpcCount = 0;
previousPlayerCount = 0;
},
effect(context) {
const nextNpcCount = npcCount(context.game, context.config);
const nextPlayerCount = playerCount(context.game);
if (previousNpcCount === 0) {
previousNpcCount = nextNpcCount;
previousPlayerCount = nextPlayerCount;
return;
}
if (nextNpcCount !== previousNpcCount) {
context.feedback.info?.(
nextNpcCount > previousNpcCount ? "An NPC became pregnant." : "An NPC gave birth."
);
processNpcPregnancyOverflow(context);
previousNpcCount = nextNpcCount;
}
if (nextPlayerCount !== previousPlayerCount) {
context.feedback.info?.(
nextPlayerCount > previousPlayerCount ? "The player became pregnant." : "The player gave birth."
);
previousPlayerCount = nextPlayerCount;
}
}
});
// src/cheats/definitions/quick/random-encounters.cheat.js
var randomEncountersCheat = createCheat({
id: "quick.random-encounters",
location: { section: "quick", group: "state", order: 80 },
meta: {
label: "Random Encounters",
controls: [{ key: "toggle", type: "button", label: "Enable", action: "toggle" }]
},
refresh: ["mount", "section-open", "after-action", "runtime-tick"],
actions: {
toggle({ game }) {
const enabled = game.get("alluremod") === 0;
game.set("alluremod", enabled ? 1 : 0);
return {
ok: true,
message: `Random encounters ${enabled ? "enabled" : "disabled"}.`,
refresh: true
};
}
},
sync({ game, controls }) {
controls.text("toggle", game.get("alluremod") === 1 ? "Enabled" : "Disabled");
}
});
// src/cheats/definitions/quick/temple-vow.cheat.js
var templeVowCheat = createCheat({
id: "quick.temple-vow",
location: { section: "quick", group: "state", order: 50 },
meta: {
label: "Temple Vow",
controls: [
{ key: "toggle", type: "button", label: "Toggle", action: "toggle" },
{ key: "current", type: "text", label: "", intent: "status" }
]
},
requiredPaths: ["player.virginity.temple"],
refresh: ["mount", "section-open", "after-action", "runtime-tick"],
actions: {
toggle({ game }) {
game.set("player.virginity.temple", !game.get("player.virginity.temple"));
return { ok: true, message: "Temple vow updated.", refresh: true };
}
},
sync({ game, controls }) {
controls.text("current", game.get("player.virginity.temple") ? "Virgin" : "Not virgin");
}
});
// src/cheats/definitions/quick/unlimited-cum.cheat.js
var unlimitedCumCheat = createCheat({
id: "quick.unlimited-cum",
location: { section: "quick", group: "unlimited", order: 30 },
meta: {
label: "Unlimited Cum",
controls: [{ key: "enabled", type: "toggle", label: "Cum", action: "toggle" }]
},
requiredPaths: ["semen_amount", "semen_volume", "orgasmcount"],
toggle: { cadence: "frame", cooldownMs: 100, maxFailures: 5, runOnActivate: true },
effect({ game }) {
if (game.get("semen_amount") >= game.get("semen_volume")) return;
game.set("semen_amount", game.get("semen_volume"));
game.set("orgasmcount", 0);
}
});
// src/cheats/definitions/world/farm-editor-helpers.js
function hydrateInput({ game, controls, control = "value", path: path7 }) {
const input = controls.element(control);
if (input.ownerDocument.activeElement === input) return;
controls.setValue(control, game.get(path7) ?? "");
}
function setInteger({ game, controls, path: path7, label, control = "value" }) {
const raw = controls.value(control);
const value = Number(raw);
if (String(raw).trim() === "" || !Number.isInteger(value))
return { ok: false, kind: "validation", message: `${label} must be an integer.` };
if (!game.has(path7))
return { ok: false, kind: "validation", message: `${label} is unavailable.` };
game.set(path7, value);
return { ok: true, message: `${label} updated.`, refresh: true };
}
function selectAndRefresh2() {
return { ok: true, refresh: true };
}
// src/cheats/definitions/world/farm-animal-affinity.cheat.js
function animalOptions({ game }) {
return Object.keys(game.get("farm.beasts") ?? {}).sort(
(left, right) => left.localeCompare(right)
);
}
var selectedPath = (controls) => `farm.beasts.${controls.value("animal")}`;
var farmAnimalAffinityCheat = createCheat({
id: "world.farm-animal-affinity",
location: { section: "misc", group: "farm", order: 100 },
meta: {
label: "Farm Animal Affinity",
controls: [
{ key: "animal", type: "select", options: animalOptions, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["farm.beasts"],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select: selectAndRefresh2,
set({ game, controls }) {
return setInteger({
game,
controls,
path: selectedPath(controls),
label: "Animal affinity"
});
}
},
sync({ game, controls }) {
hydrateInput({ game, controls, path: selectedPath(controls) });
}
});
// src/cheats/definitions/world/farm-assault-time.cheat.js
var PATH = "farm_attack_timer";
var farmAssaultTimeCheat = createCheat({
id: "world.farm-assault-time",
location: { section: "misc", group: "farm", order: 120 },
meta: {
label: "Farm Assault Time",
controls: [
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [PATH],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
set({ game, controls }) {
return setInteger({ game, controls, path: PATH, label: "Farm assault time" });
}
},
sync({ game, controls }) {
hydrateInput({ game, controls, path: PATH });
}
});
// src/cheats/definitions/world/farm-build-time.cheat.js
var PATH2 = "farm.build_timer";
var farmBuildTimeCheat = createCheat({
id: "world.farm-build-time",
location: { section: "misc", group: "farm", order: 110 },
meta: {
label: "Farm Build Time",
controls: [
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: [PATH2],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
set({ game, controls }) {
return setInteger({ game, controls, path: PATH2, label: "Farm build time" });
}
},
sync({ game, controls }) {
hydrateInput({ game, controls, path: PATH2 });
}
});
// src/cheats/definitions/world/max-harmony.cheat.js
var maxHarmonyCheat = createCheat({
id: "world.max-harmony",
location: { section: "misc", group: "world", order: 10 },
meta: {
label: "Wolfpack",
controls: [
{ key: "harmony", type: "button", label: "Max Harmony", action: "harmony" },
{ key: "ferocity", type: "button", label: "Max Ferocity", action: "ferocity" }
]
},
actions: {
harmony({ game }) {
game.set("wolfpackharmony", 22);
return { ok: true, message: "Wolfpack harmony maximized." };
},
ferocity({ game }) {
game.set("wolfpackferocity", 22);
return { ok: true, message: "Wolfpack ferocity maximized." };
}
}
});
// src/cheats/definitions/world/maximum-church-tasks.cheat.js
var maximumChurchTasksCheat = createCheat({
id: "world.maximum-church-tasks",
location: { section: "quick", group: "tasks", order: 10 },
meta: {
label: "Maximum Church Tasks",
controls: [{ key: "enabled", type: "toggle", label: "Church", action: "toggle" }]
},
requiredPaths: ["temple_garden", "temple_quarters", "grace"],
toggle: { cadence: "daily", maxFailures: 5, runOnActivate: true },
effect({ game }) {
game.set("temple_garden", 100);
game.set("temple_quarters", 100);
game.set("grace", 100);
}
});
// src/cheats/definitions/world/pregnancy-editor-helpers.js
var confirmed = (controls) => controls.checked("confirm");
function fetusOptions(pregnancy) {
return (pregnancy?.fetus ?? []).map((fetus, index) => ({
value: index,
label: fetus?.name ?? fetus?.mother ?? fetus?.creature ?? fetus?.stats?.gender ?? `Fetus ${index + 1}`
}));
}
function resetPregnancy(pregnancy) {
pregnancy.fetus = [];
pregnancy.potentialFathers = [];
pregnancy.timer = 0;
pregnancy.timerEnd = null;
pregnancy.type = null;
pregnancy.waterBreaking = false;
pregnancy.waterBreakingTimer = null;
if ("awareOf" in pregnancy) pregnancy.awareOf = null;
if ("awareOfDetails" in pregnancy) pregnancy.awareOfDetails = null;
if ("awareOfMultiple" in pregnancy) pregnancy.awareOfMultiple = null;
}
function removeFetus(pregnancy, selected) {
if (!Array.isArray(pregnancy?.fetus) || pregnancy.fetus.length === 0) return false;
if (pregnancy.fetus.length === 1) resetPregnancy(pregnancy);
else pregnancy.fetus.splice(Number.parseInt(selected, 10), 1);
return true;
}
var destructiveConfirmation = "Confirm removal. Pregnancy and child deletion cannot be undone.";
// src/cheats/definitions/world/mc-abortion.cheat.js
function locationOptions({ game }) {
return Object.entries(game.get("sexStats") ?? {}).filter(([, value]) => Array.isArray(value?.pregnancy?.fetus)).map(([key]) => key);
}
function options({ game, controls }) {
return fetusOptions(game.get(`sexStats.${controls.value("location")}.pregnancy`));
}
var mcAbortionCheat = createCheat({
id: "world.mc-abortion",
location: { section: "misc", group: "pregnancy-removal", order: 70 },
meta: {
label: "MC Pregnancy Removal",
controls: [
{ key: "location", type: "select", options: locationOptions, action: "select" },
{ key: "fetus", type: "select", options, action: "select" },
{ key: "confirm", type: "toggle", label: "Confirm", intent: "confirmation" },
{ key: "remove", type: "button", label: "Remove", action: "remove" }
]
},
requiredPaths: ["sexStats"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
remove({ game, controls }) {
if (!confirmed(controls))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
const path7 = `sexStats.${controls.value("location")}.pregnancy`;
const pregnancy = game.get(path7);
if (!removeFetus(pregnancy, controls.value("fetus")))
return { ok: false, kind: "validation", message: "No fetus is available." };
game.set(path7, pregnancy);
controls.setValue("confirm", false);
return { ok: true, message: "MC pregnancy removed.", refresh: true };
}
}
});
// src/cheats/definitions/world/mc-child-manager.cheat.js
var PROPERTIES = [
{ value: "name", label: "Name" },
{ value: "motherKnown", label: "Mother Known" },
{ value: "fatherKnown", label: "Father Known" },
{ value: "abandon", label: "Abandon Selected" }
];
function childOptions({ game }) {
return Object.entries(game.get("children") ?? {}).map(([key, child]) => ({
value: key,
label: child?.name ?? key
}));
}
function selectedChild({ game, controls }) {
const key = controls.value("child");
return key ? game.get(`children.${key}`) : void 0;
}
function setChildControlsVisible(controls, visible) {
for (const key of ["property", "value", "summary", "confirm", "set", "purge"]) {
controls.element(key).closest(".cp-cheat-control-unit").hidden = !visible;
}
}
var mcChildManagerCheat = createCheat({
id: "world.mc-child-manager",
location: { section: "misc", group: "offspring", order: 60 },
meta: {
label: "MC Child Manager",
controls: [
{
key: "child",
type: "select",
options: childOptions,
fallbackOptions: [{ value: "", label: "No children" }],
action: "select"
},
{ key: "property", type: "select", options: PROPERTIES, action: "select" },
{ key: "value", type: "input" },
{ key: "summary", type: "text" },
{ key: "confirm", type: "toggle", label: "Confirm deletion", intent: "confirmation" },
{ key: "set", type: "button", label: "Apply", action: "set" },
{ key: "purge", type: "button", label: "Abandon All", action: "purge" }
]
},
requiredPaths: ["children"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set({ game, controls }) {
const key = controls.value("child");
const property = controls.value("property");
if (!key || !selectedChild({ game, controls }))
return { ok: false, kind: "validation", message: "Select an existing child." };
if (property === "abandon") {
if (!controls.checked("confirm"))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
const children = { ...game.get("children") ?? {} };
delete children[key];
game.set("children", children);
controls.setValue("confirm", false);
return { ok: true, message: "Child abandoned.", refresh: true };
}
const input = controls.element("value");
const value = property === "name" ? controls.value("value") : Boolean(input.checked);
game.set(`children.${key}.${property}`, value);
return { ok: true, message: "Child information updated.", refresh: true };
},
purge({ game, controls }) {
if (!controls.checked("confirm"))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
game.set("children", {});
controls.setValue("confirm", false);
return { ok: true, message: "All children abandoned.", refresh: true };
}
},
sync(context) {
const child = selectedChild(context);
setChildControlsVisible(context.controls, Boolean(child));
if (!child) return;
const property = context.controls.value("property");
const input = context.controls.element("value");
const booleanInput = property !== "name";
input.type = booleanInput ? "checkbox" : "text";
if (booleanInput) input.checked = property === "abandon" ? false : Boolean(child?.[property]);
else context.controls.setValue("value", child?.name ?? "");
context.controls.text(
"summary",
`${child.name ?? ""} \xB7 ${child.mother ?? "unknown mother"} \xB7 ${child.father ?? "unknown father"} \xB7 ${child.birthLocation ?? "unknown location"}`
);
}
});
// src/cheats/definitions/world/mc-pregnancy.cheat.js
var LOCK_JOB_ID = "world.mc-pregnancy.lock";
var lockedDays = /* @__PURE__ */ new Map();
function holeOptions({ game }) {
return Object.entries(game.get("sexStats") ?? {}).filter(([, value]) => value?.pregnancy).map(([key]) => key);
}
function pregnancyOptions({ game, controls }) {
const pregnancy = game.get(`sexStats.${controls.value("hole")}.pregnancy`);
if (pregnancy?.type === "parasite") {
return Object.entries(pregnancy.fetus ?? {}).map(([key, fetus]) => ({
value: key,
label: fetus?.creature ?? key
}));
}
return pregnancy?.timerEnd != null ? [{ value: "baby", label: "Baby" }] : [];
}
function lockKey(hole, type, pregnancy) {
return `${hole}:${type ?? "pregnancy"}:${pregnancy}`;
}
function applyDays(game, { hole, pregnancy: selected, days }) {
const pregnancy = game.get(`sexStats.${hole}.pregnancy`);
if (!pregnancy) return false;
if (pregnancy.type === "parasite") {
if (!pregnancy.fetus?.[selected]) return false;
game.set(`sexStats.${hole}.pregnancy.fetus.${selected}.daysLeft`, days);
} else {
if (!Number.isFinite(pregnancy.timerEnd)) return false;
game.set(`sexStats.${hole}.pregnancy.timer`, Math.max(0, pregnancy.timerEnd - days * 3));
}
return true;
}
function syncSchedule({ game, services }) {
services.scheduler?.unregister(LOCK_JOB_ID, { cadence: "frame" });
if (!lockedDays.size) return;
services.scheduler?.register(
LOCK_JOB_ID,
() => {
for (const lock of lockedDays.values()) applyDays(game, lock);
},
{ cadence: "frame", cooldownMs: 100, maxFailures: 5 }
);
}
var mcPregnancyCheat = createCheat({
id: "world.mc-pregnancy",
location: { section: "misc", group: "pregnancy", order: 40 },
meta: {
label: "MC Pregnancy",
controls: [
{ key: "hole", type: "select", options: holeOptions, action: "select" },
{ key: "pregnancy", type: "select", options: pregnancyOptions, action: "select" },
{ key: "days", type: "input" },
{ key: "locked", type: "toggle", label: "Lock pregnancy" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["sexStats"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set(context) {
const hole = context.controls.value("hole");
const selected = context.controls.value("pregnancy");
const days = Number.parseInt(context.controls.value("days"), 10);
const type = context.game.get(`sexStats.${hole}.pregnancy.type`);
if (!hole || !selected || Number.isNaN(days) || !applyDays(context.game, { hole, pregnancy: selected, days }))
return { ok: false, kind: "validation", message: "MC pregnancy data is unavailable." };
const key = lockKey(hole, type, selected);
if (context.controls.checked("locked"))
lockedDays.set(key, { hole, pregnancy: selected, days });
else lockedDays.delete(key);
syncSchedule(context);
return { ok: true, message: "MC pregnancy updated.", refresh: true };
}
},
sync({ game, controls }) {
const hole = controls.value("hole");
const selected = controls.value("pregnancy");
const pregnancy = game.get(`sexStats.${hole}.pregnancy`);
const input = controls.element("days");
if (input.ownerDocument.activeElement !== input) {
const days = pregnancy?.type === "parasite" ? pregnancy?.fetus?.[selected]?.daysLeft : Number.isFinite(pregnancy?.timerEnd - pregnancy?.timer) ? (pregnancy.timerEnd - pregnancy.timer) / 3 : "";
controls.setValue("days", days ?? "");
}
controls.setValue("locked", lockedDays.has(lockKey(hole, pregnancy?.type, selected)));
},
onEnable(context) {
syncSchedule(context);
return () => context.services.scheduler?.unregister(LOCK_JOB_ID, { cadence: "frame" });
}
});
// src/cheats/definitions/world/mc-tentacle.cheat.js
function locationOptions2({ game }) {
return Object.entries(game.get("container") ?? {}).filter(([, value]) => value?.creatures).map(([key]) => key);
}
function creatureOptions({ game, controls }) {
return Object.entries(game.get(`container.${controls.value("location")}.creatures`) ?? {}).filter(([, creature]) => creature).map(([key, creature]) => ({ value: key, label: creature.creature ?? key }));
}
var mcTentacleCheat = createCheat({
id: "world.mc-tentacle",
location: { section: "misc", group: "offspring", order: 50 },
meta: {
label: "MC Tentacle Pregnancy",
controls: [
{ key: "location", type: "select", options: locationOptions2, action: "select" },
{ key: "creature", type: "select", options: creatureOptions, action: "select" },
{ key: "speed", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["container"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set({ game, controls }) {
const path7 = `container.${controls.value("location")}.creatures.${controls.value(
"creature"
)}.stats.speed`;
const speed = Number.parseInt(controls.value("speed"), 10);
if (!game.has(path7) || Number.isNaN(speed))
return { ok: false, kind: "validation", message: "Tentacle data is unavailable." };
game.set(path7, speed);
return { ok: true, message: "Tentacle pregnancy speed updated.", refresh: true };
}
},
sync({ game, controls }) {
const input = controls.element("speed");
if (input.ownerDocument.activeElement === input) return;
controls.setValue(
"speed",
game.get(
`container.${controls.value("location")}.creatures.${controls.value(
"creature"
)}.stats.speed`
) ?? ""
);
}
});
// src/cheats/definitions/world/named-npc-abortion.cheat.js
function npcOptions({ game }) {
return (game.get("NPCName") ?? []).map((npc, index) => ({ npc, index })).filter(({ npc }) => Array.isArray(npc?.pregnancy?.fetus)).map(({ npc, index }) => ({ value: index, label: npc.nam ?? npc.description ?? index }));
}
function options2({ game, controls }) {
return fetusOptions(game.get(`NPCName.${controls.value("npc")}.pregnancy`));
}
var namedNpcAbortionCheat = createCheat({
id: "world.named-npc-abortion",
location: { section: "misc", group: "pregnancy-removal", order: 80 },
meta: {
label: "Named NPC Pregnancy Removal",
controls: [
{ key: "npc", type: "select", options: npcOptions, action: "select" },
{ key: "fetus", type: "select", options: options2, action: "select" },
{ key: "confirm", type: "toggle", label: "Confirm", intent: "confirmation" },
{ key: "remove", type: "button", label: "Remove", action: "remove" }
]
},
requiredPaths: ["NPCName"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
remove({ game, controls }) {
if (!confirmed(controls))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
const path7 = `NPCName.${controls.value("npc")}.pregnancy`;
const pregnancy = game.get(path7);
if (!removeFetus(pregnancy, controls.value("fetus")))
return { ok: false, kind: "validation", message: "No fetus is available." };
game.set(path7, pregnancy);
controls.setValue("confirm", false);
return { ok: true, message: "Named NPC pregnancy removed.", refresh: true };
}
}
});
// src/cheats/definitions/world/named-npc-pregnancy.cheat.js
var LOCK_JOB_ID2 = "world.named-npc-pregnancy.lock";
var lockedDays2 = /* @__PURE__ */ new Map();
function options3({ game }) {
return (game.get("NPCName") ?? []).map((npc, index) => ({ npc, index })).filter(({ npc }) => npc?.pregnancy?.timer != null).map(({ npc, index }) => ({ value: index, label: npc.nam ?? npc.description }));
}
function applyLocks(game) {
for (const [index, days] of lockedDays2) {
const timerEnd = game.get(`NPCName.${index}.pregnancy.timerEnd`);
if (!Number.isFinite(timerEnd)) continue;
game.set(`NPCName.${index}.pregnancy.timer`, Math.max(0, timerEnd - days * 3));
}
}
function syncSchedule2({ game, services }) {
services.scheduler?.unregister(LOCK_JOB_ID2, { cadence: "frame" });
if (!lockedDays2.size) return;
services.scheduler?.register(LOCK_JOB_ID2, () => applyLocks(game), {
cadence: "frame",
cooldownMs: 100,
maxFailures: 5
});
}
var namedNpcPregnancyCheat = createCheat({
id: "world.named-npc-pregnancy",
location: { section: "misc", group: "pregnancy", order: 20 },
meta: {
label: "Named NPC Pregnancy",
controls: [
{
key: "npc",
type: "select",
options: options3,
fallbackOptions: [{ value: "", label: "No pregnancies" }],
action: "select"
},
{ key: "days", type: "input" },
{ key: "locked", type: "toggle", label: "Lock pregnancy" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["NPCName"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set(context) {
const index = Number.parseInt(context.controls.value("npc"), 10);
const days = Number.parseInt(context.controls.value("days"), 10);
const timerEnd = context.game.get(`NPCName.${index}.pregnancy.timerEnd`);
if (!Number.isInteger(index) || Number.isNaN(days) || !Number.isFinite(timerEnd))
return { ok: false, kind: "validation", message: "Pregnancy data is unavailable." };
if (context.controls.checked("locked")) lockedDays2.set(index, days);
else lockedDays2.delete(index);
context.game.set(`NPCName.${index}.pregnancy.timer`, Math.max(0, timerEnd - days * 3));
syncSchedule2(context);
return { ok: true, message: "Named NPC pregnancy updated.", refresh: true };
}
},
sync({ game, controls }) {
const index = Number.parseInt(controls.value("npc"), 10);
const timer = game.get(`NPCName.${index}.pregnancy.timer`);
const timerEnd = game.get(`NPCName.${index}.pregnancy.timerEnd`);
controls.setValue("days", Number.isFinite(timerEnd - timer) ? (timerEnd - timer) / 3 : "");
controls.setValue("locked", lockedDays2.has(index));
},
onEnable(context) {
syncSchedule2(context);
return () => context.services.scheduler?.unregister(LOCK_JOB_ID2, { cadence: "frame" });
}
});
// src/cheats/definitions/world/npc-trait-editor.cheat.js
function npcOptions2({ game }) {
const configured = game.setup("NPCNameList");
const names = Array.isArray(configured) ? configured : (game.get("NPCName") ?? []).map(({ nam, description }) => nam ?? description);
return names.map((name) => ({ value: name, label: name }));
}
function selectedNpc({ game, controls }) {
const list = game.get("NPCName") ?? [];
const selectedName = controls.value("npc");
const index = list.findIndex(
({ nam, description }) => nam === selectedName || description === selectedName
);
return { index, npc: list[index] };
}
var npcTraitEditorCheat = createCheat({
id: "world.npc-trait-editor",
location: { section: "misc", group: "npc", order: 5 },
meta: {
label: "NPC Manager",
controls: [
{
key: "npc",
type: "select",
options: npcOptions2,
fallbackOptions: [{ value: "", label: "No NPC data" }],
action: "select"
},
{ key: "trait", type: "select", options: npctrait, action: "select" },
{ key: "value", type: "input" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["NPCName"],
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
select() {
return { ok: true, refresh: true };
},
set(context) {
const { index, npc } = selectedNpc(context);
const trait = context.controls.value("trait");
const value = Number.parseInt(context.controls.value("value"), 10);
if (!npc || !Object.hasOwn(npc, trait))
return { ok: false, kind: "validation", message: "NPC trait is unavailable." };
if (Number.isNaN(value))
return { ok: false, kind: "validation", message: "Input is not a number." };
context.game.set(`NPCName.${index}.${trait}`, value);
return { ok: true, message: "NPC trait updated.", refresh: true };
}
},
sync(context) {
const { npc } = selectedNpc(context);
const trait = context.controls.value("trait");
context.controls.setValue("value", npc?.[trait] ?? "");
}
});
// src/cheats/definitions/world/produce-sales-report.cheat.js
function sellingEntries(game) {
return Object.entries(game.get("farmersProduce.selling") ?? {}).map(([name, raw]) => ({ name, amount: Number(raw) })).filter(({ amount }) => Number.isFinite(amount)).sort((left, right) => right.amount - left.amount || left.name.localeCompare(right.name));
}
function renderReport({ game, controls }) {
const entries2 = sellingEntries(game);
controls.text(
"report",
entries2.length ? entries2.map(({ name, amount }, index) => `${index + 1}. ${name}: ${amount}`).join(" | ") : "No produce sales recorded."
);
}
var produceSalesReportCheat = createCheat({
id: "world.produce-sales-report",
location: { section: "misc", group: "produce-inspection", order: 130 },
meta: {
label: "Produce Sales",
controls: [
{ key: "report", type: "text" },
{ key: "refresh", type: "button", label: "Refresh", action: "refresh" }
]
},
requiredPaths: ["farmersProduce.selling"],
isApplicable({ game }) {
const selling = game.get("farmersProduce.selling");
return Boolean(selling) && typeof selling === "object" && !Array.isArray(selling);
},
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
refresh() {
return { ok: true, message: "Produce sales refreshed.", refresh: true };
}
},
sync: renderReport
});
// src/cheats/definitions/world/stored-npc-abortion.cheat.js
function entries(context) {
const gameEntries = Object.entries(context.game.get("storedNPCs") ?? {}).map(([key, npc]) => ({
source: "game",
key,
npc
}));
const configEntries = Object.entries(context.config.get("storedNPCs") ?? {}).map(
([key, npc]) => ({ source: "config", key, npc })
);
return [...gameEntries, ...configEntries].filter(
({ npc }) => Array.isArray(npc?.pregnancy?.fetus)
);
}
function npcOptions3(context) {
return entries(context).map(({ source, key, npc }, index) => ({
value: `${source}:${key}`,
label: `${index + 1}. ${npc.pregnancy.fetus[0]?.mother ?? key}`
}));
}
function selection(context) {
const [source, ...keyParts] = context.controls.value("npc").split(":");
const key = keyParts.join(":");
const store2 = source === "config" ? context.config.get("storedNPCs") : context.game.get("storedNPCs");
return { source, key, store: store2 ?? {}, npc: store2?.[key] };
}
function options4(context) {
return fetusOptions(selection(context).npc?.pregnancy);
}
var storedNpcAbortionCheat = createCheat({
id: "world.stored-npc-abortion",
location: { section: "misc", group: "pregnancy-removal", order: 90 },
meta: {
label: "Stored NPC Pregnancy Removal",
controls: [
{ key: "npc", type: "select", options: npcOptions3, action: "select" },
{ key: "fetus", type: "select", options: options4, action: "select" },
{ key: "confirm", type: "toggle", label: "Confirm", intent: "confirmation" },
{ key: "remove", type: "button", label: "Remove", action: "remove" },
{ key: "purge", type: "button", label: "Purge All", action: "purge" }
]
},
requiredPaths: ["storedNPCs"],
config: ["storedNPCs"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
remove(context) {
if (!confirmed(context.controls))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
const { source, key, store: store2, npc } = selection(context);
if (!key || !removeFetus(npc?.pregnancy, context.controls.value("fetus")))
return { ok: false, kind: "validation", message: "No fetus is available." };
if (npc.pregnancy.fetus.length === 0) delete store2[key];
if (source === "config") context.config.set("storedNPCs", { ...store2 });
else context.game.set("storedNPCs", { ...store2 });
context.controls.setValue("confirm", false);
return { ok: true, message: "Stored NPC pregnancy removed.", refresh: true };
},
purge(context) {
if (!confirmed(context.controls))
return { ok: false, kind: "blocked", message: destructiveConfirmation };
context.game.set("storedNPCs", {});
context.config.set("storedNPCs", {});
context.controls.setValue("confirm", false);
return { ok: true, message: "Stored NPC pregnancies purged.", refresh: true };
}
}
});
// src/cheats/definitions/world/stored-npc-pregnancy.cheat.js
var LOCK_JOB_ID3 = "world.stored-npc-pregnancy.lock";
var lockedDays3 = /* @__PURE__ */ new Map();
function options5({ game }) {
return Object.entries(game.get("storedNPCs") ?? {}).filter(([, npc]) => npc?.pregnancy?.fetus?.[0]?.mother).map(([key, npc]) => ({ value: key, label: npc.pregnancy.fetus[0].mother }));
}
function applyLocks2(game) {
for (const [key, days] of lockedDays3) {
const timerEnd = game.get(`storedNPCs.${key}.pregnancy.timerEnd`);
if (!Number.isFinite(timerEnd)) continue;
game.set(`storedNPCs.${key}.pregnancy.timer`, Math.max(0, timerEnd - days * 3));
}
}
function syncSchedule3({ game, services }) {
services.scheduler?.unregister(LOCK_JOB_ID3, { cadence: "frame" });
if (!lockedDays3.size) return;
services.scheduler?.register(LOCK_JOB_ID3, () => applyLocks2(game), {
cadence: "frame",
cooldownMs: 100,
maxFailures: 5
});
}
var storedNpcPregnancyCheat = createCheat({
id: "world.stored-npc-pregnancy",
location: { section: "misc", group: "pregnancy", order: 30 },
meta: {
label: "NPC Pregnancy",
controls: [
{
key: "npc",
type: "select",
options: options5,
fallbackOptions: [{ value: "", label: "No pregnancies" }],
action: "select"
},
{ key: "days", type: "input" },
{ key: "locked", type: "toggle", label: "Lock pregnancy" },
{ key: "set", type: "button", label: "Set", action: "set" }
]
},
requiredPaths: ["storedNPCs"],
refresh: ["mount", "section-open"],
actions: {
select() {
return { ok: true, refresh: true };
},
set(context) {
const key = context.controls.value("npc");
const days = Number.parseInt(context.controls.value("days"), 10);
const timerEnd = context.game.get(`storedNPCs.${key}.pregnancy.timerEnd`);
if (!key || Number.isNaN(days) || !Number.isFinite(timerEnd))
return { ok: false, kind: "validation", message: "Pregnancy data is unavailable." };
if (context.controls.checked("locked")) lockedDays3.set(key, days);
else lockedDays3.delete(key);
context.game.set(`storedNPCs.${key}.pregnancy.timer`, Math.max(0, timerEnd - days * 3));
syncSchedule3(context);
return { ok: true, message: "NPC pregnancy updated.", refresh: true };
}
},
sync({ game, controls }) {
const key = controls.value("npc");
const timer = game.get(`storedNPCs.${key}.pregnancy.timer`);
const timerEnd = game.get(`storedNPCs.${key}.pregnancy.timerEnd`);
controls.setValue("days", Number.isFinite(timerEnd - timer) ? (timerEnd - timer) / 3 : "");
controls.setValue("locked", lockedDays3.has(key));
},
onEnable(context) {
syncSchedule3(context);
return () => context.services.scheduler?.unregister(LOCK_JOB_ID3, { cadence: "frame" });
}
});
// src/cheats/definitions/world/vrel-coins-usage.cheat.js
var PATH3 = "featsBoosts.pointsUsed";
var vrelCoinsUsageCheat = createCheat({
id: "world.vrel-coins-usage",
location: { section: "misc", group: "mod-integration", order: 140 },
meta: {
label: "Reset Vrel Coins Usage",
controls: [
{ key: "current", type: "text" },
{ key: "reset", type: "button", label: "Reset", action: "reset" }
]
},
requiredPaths: [PATH3],
isApplicable({ game }) {
return Number.isFinite(game.get(PATH3));
},
refresh: ["mount", "section-open", "runtime-tick"],
actions: {
reset({ game }) {
game.set(PATH3, 0);
return { ok: true, message: "Vrel coins usage reset.", refresh: true };
}
},
sync({ game, controls }) {
controls.text("current", game.get(PATH3));
}
});
// src/generated/cheats.generated.js
var generatedCheats = Object.freeze([
runDiagnosticsCheat,
ballsCheat,
bodySizeCheat,
bodyTypeCheat,
characteristicsCheat,
crimeCheat,
cumCheat,
enemyStatsCheat,
examCheat,
fameCheat,
hentaiSkillCheat,
infiniteArousalCheat,
lactationCheat,
milkCheat,
moneyCheat,
parasitesCheat,
schoolReputationCheat,
playerStatsCheat,
talentCheat,
unlimitedSprayCheat,
virginityCheat,
arousalCheat,
autoChildInteractionCheat,
edenGardenCheat,
edenMushroomsCheat,
edenSpringCheat,
edenTimerCheat,
enemyStateCheat,
everyoneHornyCheat,
farmSafetyCheat,
gameCheatsCheat,
hygieneCheat,
infiniteNpcPregnancyCheat,
intenseCumCheat,
invincibleAngelCheat,
maintainPurityCheat,
maintainVirginityCheat,
maximumNpcPregnancyRateCheat,
maximumStrayTasksCheat,
multipleNpcPregnanciesCheat,
playerStateCheat,
pregnancyDetectionCheat,
randomEncountersCheat,
templeVowCheat,
unlimitedCumCheat,
farmAnimalAffinityCheat,
farmAssaultTimeCheat,
farmBuildTimeCheat,
maxHarmonyCheat,
maximumChurchTasksCheat,
mcAbortionCheat,
mcChildManagerCheat,
mcPregnancyCheat,
mcTentacleCheat,
namedNpcAbortionCheat,
namedNpcPregnancyCheat,
npcTraitEditorCheat,
produceSalesReportCheat,
storedNpcAbortionCheat,
storedNpcPregnancyCheat,
vrelCoinsUsageCheat
]);
// src/cheats/catalog.js
var SECTION_ORDER = ["quick", "stats", "misc"];
function createCheatCatalog(descriptors, { configPaths = CHEAT_CONFIG_SCHEMA.map(({ path: path7 }) => path7) } = {}) {
if (!Array.isArray(descriptors)) throw new TypeError("Cheat catalog input must be an array.");
const paths = new Set(configPaths), byId = /* @__PURE__ */ new Map(), placements = /* @__PURE__ */ new Map();
for (const descriptor of descriptors) {
validateCheatDefinition(descriptor);
if (byId.has(descriptor.id))
throw new Error(`Duplicate cheat descriptor id "${descriptor.id}".`);
const placement = `${descriptor.location.section}:${descriptor.location.group ?? ""}:${descriptor.location.order}`;
if (placements.has(placement))
throw new Error(
`Duplicate cheat placement "${placement}" for "${placements.get(placement)}" and "${descriptor.id}".`
);
for (const path7 of descriptor.config ?? [])
if (!paths.has(path7))
throw new Error(`Cheat "${descriptor.id}" references unknown config path "${path7}".`);
placements.set(placement, descriptor.id);
byId.set(descriptor.id, descriptor);
}
const ordered = [...byId.values()].sort(
(a, b) => SECTION_ORDER.indexOf(a.location.section) - SECTION_ORDER.indexOf(b.location.section) || a.location.order - b.location.order || (a.location.group ?? "").localeCompare(b.location.group ?? "") || a.id.localeCompare(b.id)
);
return Object.freeze({
listCheats: () => [...ordered],
getCheat: (id) => byId.get(id) ?? null,
listCheatsForSection: (section) => ordered.filter((cheat2) => cheat2.location.section === section)
});
}
// src/cheats/index.js
var cheatCatalog = createCheatCatalog(generatedCheats);
// src/ui/shell/renderer.js
var mountedShells = /* @__PURE__ */ new WeakMap();
function renderControl(control, document2, dispatchAction, cleanup) {
let element;
if (control.type === "heading") {
element = document2.createElement("span");
element.className = "gold";
} else if (control.type === "help") {
element = document2.createElement("span");
element.className = "cp-shell-help";
} else if (control.type === "link") {
element = document2.createElement("a");
element.className = "modal-link";
element.href = control.href;
element.target = "_blank";
element.rel = "noopener noreferrer";
} else if (control.type === "action") {
element = document2.createElement("button");
element.type = "button";
element.className = "modal-button";
const handler = () => dispatchAction?.(control.action);
element.addEventListener("click", handler);
cleanup.push(() => element.removeEventListener("click", handler));
} else {
element = document2.createElement("span");
element.className = "modal-text";
}
element.textContent = control.text ?? "";
if (control.key) element.dataset.shellControl = control.key;
if (control.action) element.dataset.shellAction = control.action;
return element;
}
function teardownSectionShell(container) {
const state = mountedShells.get(container);
if (!state) return false;
state.cleanup.forEach((fn) => fn());
state.root.remove();
mountedShells.delete(container);
return true;
}
function renderSectionShell({ section, rows, container, document: document2, dispatchAction }) {
if (!container) throw new TypeError("Shell renderer requires a section container.");
teardownSectionShell(container);
const cleanup = [];
const root = document2.createElement("div");
root.className = "cp-section-shell";
root.dataset.shellSection = section;
for (const definition of rows ?? []) {
const row = document2.createElement("div");
row.className = `modal-content-padding cp-layout-${definition.role}`;
row.dataset.shellKey = `${section}.${definition.key}`;
const groups = definition.groups ?? (definition.group ? [definition.group] : []);
if (groups.length) row.dataset.shellGroups = groups.join(" ");
for (const control of definition.controls ?? []) {
if (!control.text) continue;
row.appendChild(renderControl(control, document2, dispatchAction, cleanup));
}
root.appendChild(row);
}
container.appendChild(root);
mountedShells.set(container, { root, cleanup });
return Object.freeze({ root, dispose: () => teardownSectionShell(container) });
}
// src/ui/renderers/layout-primitives.js
var LAYOUT_CLASSES = Object.freeze({
row: "cp-layout-row",
cheat: "cp-layout-cheat-row",
group: "cp-layout-group",
heading: "cp-layout-heading",
help: "cp-layout-help",
spacer: "cp-layout-spacer",
footer: "cp-layout-footer"
});
// src/cheats/runtime/game-context.js
var CheatRuntimeUnavailableError = class extends Error {
constructor(message = "Active game runtime is not ready.") {
super(message);
this.name = "CheatRuntimeUnavailableError";
this.code = "CHEAT_RUNTIME_UNAVAILABLE";
}
};
var CheatGamePathError = class extends Error {
constructor(path7) {
super(`Game path "${path7}" cannot be written because its parent is missing.`);
this.name = "CheatGamePathError";
this.code = "CHEAT_GAME_PATH_MISSING";
this.path = path7;
}
};
var partsOf = (path7) => Array.isArray(path7) ? path7.map(String).filter(Boolean) : String(path7 ?? "").split(".").map((part) => part.trim()).filter(Boolean);
function readPath(root, path7) {
let value = root;
for (const part of partsOf(path7)) {
if (value == null || !Object.hasOwn(value, part)) return void 0;
value = value[part];
}
return value;
}
function createGameContext(adapter) {
if (!adapter || typeof adapter !== "object")
throw new TypeError("Game context requires an adapter.");
function variables() {
if (typeof adapter.isReady === "function" && !adapter.isReady()) {
throw new CheatRuntimeUnavailableError();
}
const value = adapter.variables?.() ?? adapter.getVariables?.();
if (!value || typeof value !== "object") throw new CheatRuntimeUnavailableError();
return value;
}
return Object.freeze({
variables,
get(path7) {
return readPath(variables(), path7);
},
set(path7, value) {
const parts = partsOf(path7);
if (!parts.length) throw new CheatGamePathError(path7);
let parent = variables();
for (const part of parts.slice(0, -1)) {
if (!parent?.[part] || typeof parent[part] !== "object") throw new CheatGamePathError(path7);
parent = parent[part];
}
parent[parts.at(-1)] = value;
return value;
},
has(path7) {
return readPath(variables(), path7) !== void 0;
},
setup(path7) {
const setup = adapter.setup?.() ?? adapter.getSetup?.();
if (!setup || typeof setup !== "object")
throw new CheatRuntimeUnavailableError("Game setup is not ready.");
return path7 == null || path7 === "" ? setup : readPath(setup, path7);
},
passage() {
return adapter.passage?.() ?? adapter.getCurrentPassage?.() ?? null;
}
});
}
// src/cheats/runtime/context.js
function createNarrowConfig(descriptor, provider) {
const declared = new Set(descriptor.config ?? []);
const requirePath = (path7) => {
if (!declared.has(path7))
throw new Error(`Cheat "${descriptor.id}" did not declare config path "${path7}".`);
};
return Object.freeze({
get(path7) {
requirePath(path7);
return provider.get(path7);
},
set(path7, value) {
requirePath(path7);
return provider.set(path7, value);
},
has(path7) {
requirePath(path7);
return provider.has(path7);
},
scope(path7) {
requirePath(path7);
return provider.scope(path7);
}
});
}
function createCheatCallbackContext({
descriptor,
adapter,
config,
controls,
signal,
reason,
event = null,
feedback,
services = {}
}) {
if (!descriptor?.id) throw new TypeError("Callback context requires a descriptor.");
if (!signal) throw new TypeError("Callback context requires an operation signal.");
const allowedServices = Object.freeze({
scheduler: services.scheduler,
logger: services.logger,
diagnostics: services.diagnostics
});
return Object.freeze({
cheat: descriptor,
game: createGameContext(adapter),
config: createNarrowConfig(descriptor, config),
controls,
event,
signal,
reason,
feedback,
services: allowedServices
});
}
// src/cheats/runtime/control-scope.js
function createControlScope({ descriptor, root }) {
if (!descriptor?.id) throw new TypeError("Control scope requires a descriptor.");
if (!root?.querySelectorAll) throw new TypeError("Control scope requires a mounted root.");
const definitions = new Map(
(descriptor.meta?.controls ?? []).map((control) => [control.key, control])
);
const elements = /* @__PURE__ */ new Map();
for (const element2 of root.querySelectorAll("[data-cheat-control]")) {
const key = element2.dataset.cheatControl;
if (definitions.has(key)) elements.set(key, element2);
}
function element(key) {
const found = elements.get(key);
if (!found) throw new Error(`Cheat "${descriptor.id}" has no mounted control "${key}".`);
return found;
}
function syncPresentation(target) {
if (target.dataset.toggleButton === "true") {
const active = target.getAttribute("aria-pressed") === "true";
target.classList.toggle("cp-toggle-active", active);
return;
}
if (target.type !== "checkbox") return;
const wrapper = target.closest(".modal-toggle");
wrapper?.classList.toggle("cp-toggle-active", Boolean(target.checked));
}
const value = (key) => {
const target = element(key);
return target.dataset.toggleButton === "true" ? target.getAttribute("aria-pressed") === "true" : target.type === "checkbox" ? Boolean(target.checked) : "value" in target ? target.value : target.textContent;
};
return Object.freeze({
element,
value,
number: (key) => Number(value(key)),
checked: (key) => {
const target = element(key);
return target.dataset.toggleButton === "true" ? target.getAttribute("aria-pressed") === "true" : Boolean(target.checked);
},
setValue(key, next) {
const target = element(key);
if (target.dataset.toggleButton === "true")
target.setAttribute("aria-pressed", String(Boolean(next)));
else if (target.type === "checkbox") target.checked = Boolean(next);
else if ("value" in target) target.value = next == null ? "" : String(next);
else target.textContent = next == null ? "" : String(next);
syncPresentation(target);
},
text(key, next) {
element(key).textContent = next == null ? "" : String(next);
},
options(key, options6 = []) {
const target = element(key);
if (target.tagName !== "SELECT") throw new Error(`Cheat control "${key}" is not a select.`);
const selected = target.value;
target.replaceChildren(
...options6.map((option) => {
const node = target.ownerDocument.createElement("option");
const normalized = option && typeof option === "object" ? option : { value: option, label: option };
node.value = String(normalized.value ?? "");
node.textContent = String(normalized.label ?? normalized.value ?? "");
return node;
})
);
if ([...target.options].some(({ value: value2 }) => value2 === selected)) target.value = selected;
return Object.freeze({
previousValue: selected,
value: target.value,
selectionChanged: Boolean(selected) && target.value !== selected
});
},
setEnabled(key, enabled, reason = "") {
const target = element(key);
target.disabled = !enabled;
const wrapper = target.closest(".modal-toggle");
if (wrapper) wrapper.setAttribute("aria-disabled", String(!enabled));
if (reason) target.dataset.disabledReason = reason;
else delete target.dataset.disabledReason;
}
});
}
// src/cheats/runtime/action-outcome.js
function normalizeCheatActionOutcome(value) {
if (value === false) return Object.freeze({ ok: false, kind: "validation" });
if (value === true || value == null) return Object.freeze({ ok: true, kind: "success" });
if (typeof value === "object") {
const ok = value.ok !== false;
return Object.freeze({ kind: ok ? "success" : "validation", ...value, ok });
}
return Object.freeze({ ok: true, kind: "success", value });
}
function normalizeCheatActionError(error) {
const blocked = error instanceof CheatRuntimeUnavailableError;
return Object.freeze({
ok: false,
kind: blocked ? "blocked" : "error",
variant: blocked ? "warning" : "error",
message: error?.message ?? String(error),
error
});
}
// src/cheats/runtime/renderer.js
var EVENT_BY_TYPE = Object.freeze({
button: "click",
toggle: "change",
select: "change",
range: "input",
input: "input"
});
function createControl(document2, definition) {
const confirmationToggle = definition.type === "toggle" && definition.intent === "confirmation";
const tag = definition.type === "button" || definition.type === "toggle" && !confirmationToggle ? "button" : definition.type === "select" ? "select" : definition.type === "text" ? "span" : "input";
const element = document2.createElement(tag);
element.dataset.cheatControl = definition.key;
element.classList.add("cp-cheat-control", `cp-cheat-control--${definition.type}`);
if (definition.type !== "text")
element.setAttribute("aria-label", definition.label ?? definition.key);
if (definition.tooltip) element.title = definition.tooltip;
if (definition.type === "button" || definition.type === "toggle" && !confirmationToggle) {
element.type = "button";
element.textContent = definition.label ?? "";
element.classList.add("modal-button");
}
if (definition.type === "toggle" && !confirmationToggle) {
element.dataset.toggleButton = "true";
element.setAttribute("aria-pressed", "false");
Object.defineProperty(element, "checked", {
configurable: true,
get: () => element.getAttribute("aria-pressed") === "true",
set: (next) => {
element.setAttribute("aria-pressed", String(Boolean(next)));
}
});
}
if (confirmationToggle) {
element.type = "checkbox";
const wrapper = document2.createElement("label");
wrapper.className = "modal-toggle cp-cheat-toggle";
const label = document2.createElement("span");
label.className = "toggle-label";
label.textContent = definition.label ?? definition.key;
wrapper.append(element, label);
return wrapper;
}
if (definition.type === "range") {
element.type = "range";
element.classList.add("cp-cheat-range");
}
if (definition.type === "input") {
element.type = "text";
element.classList.add("modal-content-width");
element.autocomplete = "off";
}
if (definition.type === "select") element.classList.add("cp-cheat-select");
if (definition.type === "text") {
element.textContent = definition.label ?? "";
element.classList.add("modal-text");
if (definition.intent === "status") element.classList.add("cp-status-chip");
}
return element;
}
function createTooltip(document2, message, className = "") {
const tooltip = document2.createElement("span");
tooltip.className = `tooltip-small linkBlue ${className}`.trim();
tooltip.tabIndex = 0;
tooltip.setAttribute("aria-label", message);
tooltip.textContent = "(?)";
const content = document2.createElement("span");
content.textContent = message;
tooltip.appendChild(content);
return tooltip;
}
function createControlUnit(document2, definition) {
const unit = document2.createElement("span");
unit.className = "cp-cheat-control-unit";
if (definition.intent === "confirmation") unit.classList.add("cp-confirmation-control");
if (definition.intent === "status") unit.classList.add("cp-status-control");
unit.appendChild(createControl(document2, definition));
if (definition.tooltip)
unit.appendChild(createTooltip(document2, definition.tooltip, "cp-cheat-tooltip"));
return unit;
}
function setControlNotice(control, message = "", kind = "info") {
const unit = control.closest(".cp-cheat-control-unit");
if (!unit) return;
let notice = unit.querySelector(".cp-control-notice");
if (!message) {
notice?.remove();
return;
}
if (!notice) {
notice = control.ownerDocument.createElement("small");
notice.className = "cp-control-notice";
notice.setAttribute("aria-live", "polite");
unit.appendChild(notice);
}
notice.dataset.noticeKind = kind;
notice.textContent = message;
}
function coerceBindingValue(value, type = "string") {
if (type === "number") return Number(value);
if (type === "integer") return Number.parseInt(value, 10);
if (type === "boolean") return Boolean(value);
return String(value ?? "");
}
async function mountCheatDescriptor({
descriptor,
document: document2,
parent = document2.body,
adapter,
config,
feedback = {},
services = {},
confirm = null
}) {
if (!descriptor?.id) throw new TypeError("Descriptor renderer requires a cheat descriptor.");
const root = document2.createElement("section");
root.dataset.cheatId = descriptor.id;
root.className = `modal-content-padding cp-cheat-descriptor ${LAYOUT_CLASSES.row} ${LAYOUT_CLASSES.cheat}`;
const label = document2.createElement("span");
label.className = "modal-text cp-cheat-label";
label.textContent = descriptor.meta.label;
const availabilityTooltip = createTooltip(document2, "", "cp-availability-tooltip");
availabilityTooltip.hidden = true;
availabilityTooltip.style.display = "none";
label.appendChild(availabilityTooltip);
const controlsRegion = document2.createElement("span");
controlsRegion.className = "cp-cheat-controls";
const availabilityStatus = document2.createElement("small");
availabilityStatus.className = "cp-cheat-status";
availabilityStatus.setAttribute("role", "status");
availabilityStatus.hidden = true;
root.append(label, controlsRegion, availabilityStatus);
for (const definition of descriptor.meta.controls)
controlsRegion.appendChild(createControlUnit(document2, definition));
parent.appendChild(root);
const controls = createControlScope({ descriptor, root });
const controller = new AbortController();
const listeners = [];
const cleanups = [];
const pending = /* @__PURE__ */ new Map();
const editedControls = /* @__PURE__ */ new Set();
let queuedRefresh = null;
let disposed = false;
let applicable = true;
let unavailableReason = "";
let lifecycleActive = false;
let enabledCleanup = null;
let toggleCleanup = null;
for (const definition of descriptor.meta.controls) {
if (definition.type === "select" && Array.isArray(definition.options))
controls.options(definition.key, definition.options);
if (definition.value !== void 0) controls.setValue(definition.key, definition.value);
}
const context = (reason, event = null) => createCheatCallbackContext({
descriptor,
adapter,
config,
controls,
signal: controller.signal,
reason,
event,
feedback,
services
});
const notify = (outcome) => {
if (!outcome.message) return;
const variant = outcome.variant ?? (outcome.ok ? "success" : outcome.kind === "blocked" ? "warning" : "error");
feedback[variant]?.(outcome.message);
};
const reportSyncFailure = (reason, error) => {
services.logger?.error?.("Cheat sync failed.", {
cheatId: descriptor.id,
trigger: reason,
errorType: error instanceof Error ? error.name : "UnknownError"
});
};
const isVisible = () => !root.hidden && root.getAttribute("aria-hidden") !== "true" && root.style.display !== "none";
const assessAvailability = (reason) => {
try {
const callbackContext = context(reason);
const missingPath = (descriptor.requiredPaths ?? []).find(
(path7) => !callbackContext.game.has(path7)
);
if (missingPath)
return {
applicable: false,
reason: `Required game path "${missingPath}" is unavailable.`
};
if (descriptor.isApplicable && !descriptor.isApplicable(callbackContext))
return {
applicable: false,
reason: "Cheat is not applicable in the current game state."
};
return { applicable: true, reason: "" };
} catch (error) {
return { applicable: false, reason: error?.message ?? "Cheat availability check failed." };
}
};
const renderAvailability = (next) => {
applicable = next.applicable;
unavailableReason = next.reason;
root.classList.toggle("cp-cheat-unavailable", !applicable);
availabilityStatus.hidden = true;
availabilityStatus.textContent = applicable ? "" : unavailableReason;
availabilityTooltip.hidden = applicable;
availabilityTooltip.style.display = applicable ? "none" : "";
availabilityTooltip.setAttribute("aria-label", applicable ? "" : unavailableReason);
availabilityTooltip.querySelector("span").textContent = applicable ? "" : unavailableReason;
for (const definition of descriptor.meta.controls)
controls.setEnabled(definition.key, applicable);
};
async function activateLifecycle(reason) {
if (lifecycleActive || !applicable) return;
lifecycleActive = true;
enabledCleanup = await descriptor.onEnable?.(context(reason));
toggleCleanup = await services.toggle?.attach?.(descriptor, context(reason));
}
async function deactivateLifecycle(reason) {
if (!lifecycleActive) return;
lifecycleActive = false;
await descriptor.onDisable?.(context(reason));
if (typeof toggleCleanup === "function") await toggleCleanup();
if (typeof enabledCleanup === "function") await enabledCleanup();
toggleCleanup = null;
enabledCleanup = null;
}
async function refreshAvailability(reason) {
const next = assessAvailability(reason);
const changed = next.applicable !== applicable || next.reason !== unavailableReason;
if (!changed) return applicable;
if (!next.applicable) await deactivateLifecycle(reason);
renderAvailability(next);
if (next.applicable) await activateLifecycle(reason);
return applicable;
}
const sync = async (reason = "manual", event = null) => {
if (disposed) return false;
if (reason !== "manual" && reason !== "mount" && !isVisible()) return false;
await refreshAvailability(reason);
if (!applicable) return false;
const callbackContext = context(reason, event);
try {
for (const definition of descriptor.meta.controls) {
if (definition.type === "select" && typeof definition.options === "function") {
let options6;
let optionError = false;
try {
options6 = await definition.options(callbackContext);
} catch (error) {
options6 = [];
optionError = true;
reportSyncFailure(reason, error);
}
const actualOptions = Array.isArray(options6) ? options6 : [];
const empty = actualOptions.length === 0;
const result = controls.options(
definition.key,
!empty || !definition.fallbackOptions ? actualOptions : definition.fallbackOptions ?? []
);
const select = controls.element(definition.key);
select.disabled = empty;
select.dataset.optionState = optionError ? "unavailable" : empty ? "empty" : "ready";
const optionMessage = optionError ? "Options are temporarily unavailable." : empty ? definition.fallbackOptions?.[0]?.label ?? "No options are currently available." : result.selectionChanged ? "The previous selection is no longer available." : "";
setControlNotice(select);
select.title = optionMessage || definition.tooltip || "";
if (optionMessage) select.setAttribute("aria-description", optionMessage);
else select.removeAttribute("aria-description");
}
if (!definition.binding) continue;
const activelyEdited = editedControls.has(definition.key) || document2.activeElement === controls.element(definition.key);
if (activelyEdited && !definition.binding.syncWhileEditing) continue;
controls.setValue(definition.key, callbackContext.game.get(definition.binding.path));
}
await descriptor.sync?.(callbackContext);
return true;
} catch (error) {
reportSyncFailure(reason, error);
return false;
}
};
const requestRefresh = (reason = "manual", event = null) => {
if (queuedRefresh) return queuedRefresh;
queuedRefresh = Promise.resolve().then(() => sync(reason, event)).finally(() => {
queuedRefresh = null;
});
return queuedRefresh;
};
async function runAction(name, { event = null, controlKey = null } = {}) {
if (disposed)
return normalizeCheatActionError(new Error(`Cheat "${descriptor.id}" is disposed.`));
if (!applicable) {
const outcome = Object.freeze({
ok: false,
kind: "blocked",
variant: "warning",
message: unavailableReason
});
notify(outcome);
return outcome;
}
const pendingKey = controlKey ?? name;
if (pending.has(pendingKey)) return pending.get(pendingKey);
const action = descriptor.actions?.[name];
if (typeof action !== "function")
throw new Error(`Cheat "${descriptor.id}" has no local action "${name}".`);
if (descriptor.meta.confirmation) {
const accepted = typeof confirm === "function" && await confirm(descriptor.meta.confirmation, descriptor);
if (!accepted) {
const outcome = Object.freeze({
ok: false,
kind: "blocked",
variant: "warning",
message: "Action cancelled."
});
notify(outcome);
return outcome;
}
}
const element = controlKey ? controls.element(controlKey) : null;
const lockDuringAction = element?.tagName === "BUTTON";
if (lockDuringAction) element.disabled = true;
const operation = (async () => {
let outcome;
try {
outcome = normalizeCheatActionOutcome(await action(context("action", event)));
} catch (error) {
outcome = normalizeCheatActionError(error);
}
notify(outcome);
if (outcome.ok && (outcome.refresh || descriptor.refresh?.includes("after-action")))
await requestRefresh("after-action", event);
return outcome;
})();
pending.set(pendingKey, operation);
try {
return await operation;
} finally {
pending.delete(pendingKey);
if (lockDuringAction && !disposed) element.disabled = false;
}
}
async function runToggle(controlKey, event) {
const enabled = controls.checked(controlKey);
controls.setValue(controlKey, enabled);
if (typeof services.toggle?.setEnabled !== "function") {
const outcome = Object.freeze({
ok: false,
kind: "blocked",
variant: "warning",
message: "Toggle runtime is unavailable."
});
notify(outcome);
return outcome;
}
try {
return normalizeCheatActionOutcome(
await services.toggle.setEnabled(descriptor, enabled, context("action", event))
);
} catch (error) {
const outcome = normalizeCheatActionError(error);
notify(outcome);
return outcome;
}
}
for (const definition of descriptor.meta.controls) {
if (definition.binding) {
const element2 = controls.element(definition.key);
const markEdited = () => editedControls.add(definition.key);
const clearEdited = () => editedControls.delete(definition.key);
element2.addEventListener("input", markEdited);
element2.addEventListener("blur", clearEdited);
listeners.push(() => element2.removeEventListener("input", markEdited));
listeners.push(() => element2.removeEventListener("blur", clearEdited));
if (definition.binding.writeOn) {
const write = () => {
const value = coerceBindingValue(
controls.value(definition.key),
definition.binding.coerce
);
context("action").game.set(definition.binding.path, value);
};
element2.addEventListener(definition.binding.writeOn, write);
listeners.push(() => element2.removeEventListener(definition.binding.writeOn, write));
}
}
if (definition.type === "toggle" && definition.action === "toggle") {
const element2 = controls.element(definition.key);
const listener2 = (event) => {
if (element2.dataset.toggleButton === "true")
controls.setValue(definition.key, !controls.checked(definition.key));
void runToggle(definition.key, event);
};
element2.addEventListener("click", listener2);
listeners.push(() => element2.removeEventListener("click", listener2));
const legacyChangeListener = (event) => void runToggle(definition.key, event);
element2.addEventListener("change", legacyChangeListener);
listeners.push(() => element2.removeEventListener("change", legacyChangeListener));
continue;
}
if (!definition.action) continue;
if (typeof descriptor.actions?.[definition.action] !== "function")
throw new Error(
`Cheat "${descriptor.id}" control "${definition.key}" references missing local action "${definition.action}".`
);
const element = controls.element(definition.key);
const eventName = definition.event ?? EVENT_BY_TYPE[definition.type] ?? "click";
const listener = (event) => void runAction(definition.action, { event, controlKey: definition.key });
element.addEventListener(eventName, listener);
listeners.push(() => element.removeEventListener(eventName, listener));
}
renderAvailability(assessAvailability("mount"));
await activateLifecycle("mount");
if (applicable && descriptor.refresh?.includes("mount")) await requestRefresh("mount");
return Object.freeze({
descriptor,
root,
controls,
signal: controller.signal,
get applicable() {
return applicable;
},
runAction,
sync,
requestRefresh,
sectionOpened(event = null) {
if (!descriptor.refresh?.includes("section-open")) return Promise.resolve(false);
return requestRefresh("section-open", event);
},
runtimeTick(event = null) {
if (!descriptor.refresh?.includes("runtime-tick")) return Promise.resolve(false);
return requestRefresh("runtime-tick", event);
},
async waitForIdle() {
await Promise.all([...pending.values()]);
},
async dispose() {
if (disposed) return false;
await deactivateLifecycle("dispose");
const disposeCleanup = await descriptor.dispose?.(context("dispose"));
if (typeof disposeCleanup === "function") cleanups.push(disposeCleanup);
controller.abort(new DOMException("descriptor disposed", "AbortError"));
listeners.splice(0).reverse().forEach((cleanup) => cleanup());
cleanups.splice(0).reverse().forEach((cleanup) => cleanup());
root.remove();
disposed = true;
return true;
}
});
}
// src/cheats/runtime/builder.js
function createCheatRuntimeBuilder({
catalog,
adapter,
config,
document: document2,
dispatchShellAction,
feedback = {},
services = {},
logger = console
}) {
if (!catalog?.listCheats) throw new TypeError("Cheat builder requires a catalog.");
if (!adapter) throw new TypeError("Cheat builder requires the active runtime adapter.");
const descriptors = Object.freeze(catalog.listCheats());
const bySection = new Map(
["quick", "stats", "misc"].map((section) => [
section,
descriptors.filter((descriptor) => descriptor.location.section === section)
])
);
const mounted = /* @__PURE__ */ new Map();
const failed = /* @__PURE__ */ new Map();
const sectionTimers = /* @__PURE__ */ new Map();
const sectionContainers = /* @__PURE__ */ new Map();
let compiled = false;
function compile() {
if (compiled) return false;
compiled = true;
return true;
}
async function disposeSection(section) {
const timer = sectionTimers.get(section);
if (timer != null) {
document2.defaultView.clearInterval(timer);
sectionTimers.delete(section);
}
const ids = new Set((bySection.get(section) ?? []).map(({ id }) => id));
for (const [id, instance] of [...mounted]) {
if (!ids.has(id)) continue;
await instance.dispose();
mounted.delete(id);
}
}
function placeDescriptor(root, descriptor, shellRoot, groupTails, fallbackTail) {
const group = descriptor.location.group;
const tail = groupTails.get(group);
if (tail) {
tail.node.after(root);
tail.node = root;
return fallbackTail;
}
const footer = shellRoot.querySelector(".cp-layout-footer");
if (fallbackTail) fallbackTail.after(root);
else if (footer) footer.before(root);
else shellRoot.appendChild(root);
return root;
}
async function mountSection(section, container, shellRows = []) {
if (!compiled) compile();
await disposeSection(section);
teardownSectionShell(container);
const sectionDescriptors = bySection.get(section) ?? [];
const shell = renderSectionShell({
section,
rows: shellRows,
container,
document: document2,
dispatchAction: dispatchShellAction
});
sectionContainers.set(section, container);
const groupTails = /* @__PURE__ */ new Map();
for (const row of shell.root.querySelectorAll("[data-shell-groups]")) {
const sharedTail = { node: row };
for (const group of row.dataset.shellGroups.split(/\s+/).filter(Boolean)) {
groupTails.set(group, sharedTail);
}
}
let fallbackTail = null;
for (const descriptor of sectionDescriptors) {
try {
const instance = await mountCheatDescriptor({
descriptor,
document: document2,
parent: shell.root,
adapter,
config,
feedback,
services
});
fallbackTail = placeDescriptor(
instance.root,
descriptor,
shell.root,
groupTails,
fallbackTail
);
mounted.set(descriptor.id, instance);
failed.delete(descriptor.id);
} catch (error) {
failed.set(descriptor.id, error?.name ?? "Error");
logger?.error?.("Cheat descriptor mount failed.", {
cheatId: descriptor.id,
errorType: error?.name ?? "Error"
});
}
}
if (sectionDescriptors.some(({ refresh }) => refresh?.includes("runtime-tick"))) {
sectionTimers.set(
section,
document2.defaultView.setInterval(() => {
for (const descriptor of sectionDescriptors) {
void mounted.get(descriptor.id)?.runtimeTick();
}
}, 400)
);
}
return health();
}
async function sectionOpened(section) {
await Promise.all(
(bySection.get(section) ?? []).map(({ id }) => mounted.get(id)).filter(Boolean).map((instance) => instance.sectionOpened())
);
}
async function teardown() {
for (const timer of sectionTimers.values()) document2.defaultView.clearInterval(timer);
sectionTimers.clear();
const instances = [...mounted.values()];
mounted.clear();
await Promise.all(instances.map((instance) => instance.dispose()));
for (const container of sectionContainers.values()) teardownSectionShell(container);
sectionContainers.clear();
return instances.length > 0;
}
function health() {
const instances = [...mounted.values()];
const applicable = instances.filter(({ applicable: applicable2 }) => applicable2).length;
return Object.freeze({
total: descriptors.length,
applicable,
mounted: instances.length,
disabled: instances.length - applicable,
failed: failed.size
});
}
return Object.freeze({
compile,
mountSection,
sectionOpened,
teardown,
health,
listCompiled: () => [...descriptors],
getMounted: (id) => mounted.get(id) ?? null
});
}
// src/cheats/runtime/config-provider.js
function createAdapterCheatConfigProvider(adapter) {
const schema = new Map(CHEAT_CONFIG_SCHEMA.map((entry2) => [entry2.path, entry2]));
const config = () => adapter.getVariables?.()?.cheatPlus ?? adapter.variables?.()?.cheatPlus;
const definition = (path7) => {
const found = schema.get(path7);
if (!found) throw new Error(`Unknown CheatPlus config path "${path7}".`);
return found;
};
return Object.freeze({
get(path7) {
definition(path7);
return config()?.[path7];
},
set(path7, value) {
const entry2 = definition(path7);
if (!isCheatConfigValueValid(entry2, value))
throw new TypeError(`Invalid value for CheatPlus config path "${path7}".`);
const target = config();
if (!target) throw new Error("CheatPlus config is unavailable.");
target[path7] = value;
return value;
},
has(path7) {
definition(path7);
return Object.hasOwn(config() ?? {}, path7);
},
scope(path7) {
return definition(path7).scope;
}
});
}
// src/cheats/runtime/toggle-store.js
function createSugarCubeToggleStore() {
return Object.freeze({
read(id) {
return Boolean(getToggles()?.[id]);
},
has(id) {
return Object.hasOwn(getToggles() ?? {}, id);
},
write(id, enabled) {
if (enabled) activateToggle(id);
else deactivateToggle(id);
return Boolean(enabled);
},
remove(id) {
const existed = Object.hasOwn(getToggles() ?? {}, id);
deactivateToggle(id);
return existed;
},
snapshot() {
return { ...getToggles() ?? {} };
}
});
}
// src/cheats/runtime/toggle-runtime.js
function toggleControlKey(descriptor) {
return descriptor.meta.controls.find(
({ type, action }) => type === "toggle" || action === "toggle"
)?.key;
}
function effectContext(base, reason) {
return Object.freeze({ ...base, event: null, reason });
}
function createProductionSchedulerAdapter(scheduler = ToggleScheduler) {
return Object.freeze({
register(id, effect, options6) {
scheduler.register(id, effect, {
daily: options6.cadence === "daily",
cooldownMs: options6.cooldownMs,
maxFailures: options6.maxFailures,
onFailureThreshold: options6.onFailureThreshold
});
},
unregister(id, options6 = {}) {
scheduler.unregister(id, { daily: options6.cadence === "daily" });
},
has(id, options6 = {}) {
return scheduler.has(id, { daily: options6.cadence === "daily" });
},
list() {
return scheduler.list();
}
});
}
function createCheatToggleRuntime({ scheduler, store: store2, logger = console } = {}) {
if (!scheduler?.register || !scheduler?.unregister || !scheduler?.has)
throw new TypeError("Cheat toggle runtime requires a scheduler adapter.");
if (!store2?.read || !store2?.write || !store2?.remove)
throw new TypeError("Cheat toggle runtime requires a toggle store.");
const attached = /* @__PURE__ */ new Map();
function render(entry2, enabled) {
const key = toggleControlKey(entry2.descriptor);
if (key) entry2.context.controls.setValue(key, enabled);
}
async function execute(entry2, reason) {
return entry2.descriptor.effect(effectContext(entry2.context, reason));
}
function quarantine(entry2, details) {
entry2.enabled = false;
render(entry2, false);
store2.remove(entry2.descriptor.id);
logger?.error?.("Cheat toggle quarantined.", {
cheatId: entry2.descriptor.id,
failures: details.failures
});
}
async function setEntryEnabled(entry2, enabled, { restore: restore2 = false } = {}) {
const desired = Boolean(enabled);
const registered = scheduler.has(entry2.descriptor.id, entry2.descriptor.toggle);
if (desired === entry2.enabled && (!desired || registered)) return desired;
entry2.enabled = desired;
render(entry2, desired);
if (!desired) {
scheduler.unregister(entry2.descriptor.id, entry2.descriptor.toggle);
if (!restore2) store2.remove(entry2.descriptor.id);
return false;
}
scheduler.register(
entry2.descriptor.id,
({ reason } = {}) => execute(entry2, reason ?? entry2.descriptor.toggle.cadence),
{
...entry2.descriptor.toggle,
onFailureThreshold: (details) => quarantine(entry2, details)
}
);
if (!restore2) store2.write(entry2.descriptor.id, true);
if (entry2.descriptor.toggle.runOnActivate !== false) {
await execute(entry2, restore2 ? "restore" : entry2.descriptor.toggle.cadence);
}
return true;
}
async function attach(descriptor, context) {
if (!descriptor.toggle) return null;
let entry2 = attached.get(descriptor.id);
if (entry2) {
entry2.context = context;
render(entry2, entry2.enabled);
return () => detach(descriptor);
}
entry2 = { descriptor, context, enabled: false };
attached.set(descriptor.id, entry2);
if (store2.read(descriptor.id)) await setEntryEnabled(entry2, true, { restore: true });
else render(entry2, false);
return () => detach(descriptor);
}
async function setEnabled(descriptor, enabled, context) {
let entry2 = attached.get(descriptor.id);
if (!entry2) {
entry2 = { descriptor, context, enabled: false };
attached.set(descriptor.id, entry2);
} else entry2.context = context;
return setEntryEnabled(entry2, enabled);
}
function detach(descriptor, { preserveIntent = true } = {}) {
const entry2 = attached.get(descriptor.id);
if (!entry2) return false;
scheduler.unregister(descriptor.id, descriptor.toggle);
if (!preserveIntent) store2.remove(descriptor.id);
attached.delete(descriptor.id);
return true;
}
async function restore() {
for (const entry2 of attached.values()) {
entry2.enabled = false;
if (store2.read(entry2.descriptor.id)) {
await setEntryEnabled(entry2, true, { restore: true });
} else render(entry2, false);
}
}
return Object.freeze({
attach,
detach,
setEnabled,
restore,
isEnabled(id) {
return attached.get(id)?.enabled ?? false;
},
listAttached() {
return [...attached.keys()];
}
});
}
function createProductionCheatToggleRuntime(options6 = {}) {
return createCheatToggleRuntime({
scheduler: options6.scheduler ?? createProductionSchedulerAdapter(),
store: options6.store ?? createSugarCubeToggleStore(),
logger: options6.logger
});
}
// src/ui/shell/definitions.js
function compatibilityText(runtime) {
return runtime.testedOn && runtime.testedOn !== "0.0.0" ? `Tested on: ${runtime.testedOn}` : "Tested on: Untested";
}
function quickShell({ data, runtime }) {
const rows = [
{
key: "compatibility",
role: "help",
controls: [
{ type: "text", text: compatibilityText(runtime) },
{ type: "text", text: runtime.curVer ? `Current version: ${runtime.curVer}` : "" },
...runtime.isCheatWorkSymbol ? [{ type: "text", text: runtime.isCheatWorkSymbol }] : [],
{ type: "help", text: runtime.testedOn && runtime.testedOn !== "0.0.0" ? runtime.isCheatWork || "Compatibility information" : "Not tested in the current game version" }
]
},
{ key: "quick-heading", role: "heading", groups: ["state"], controls: [{ type: "heading", text: "Quick cheats" }] },
{ key: "unlimited-heading", role: "heading", groups: ["tasks", "unlimited", "pregnancy"], controls: [{ type: "heading", text: "Unlimited Toggles" }] }
];
if (runtime.isServer === 1) {
rows.push({ key: "server-heading", role: "heading", group: "server", controls: [{ type: "heading", text: "Server" }] });
if (runtime.curVer !== runtime.testedOn) {
rows.push({ key: "server-version-warning", role: "help", group: "server", controls: [
{ type: "text", text: "Caution: game version is different." },
{ type: "help", text: "Older or modded versions can be incompatible." }
] });
}
rows.push({ key: "server-save-actions", role: "application", group: "server", controls: [
{ type: "text", text: "Server Save" },
{ type: "action", key: "export", text: "Export", action: "save_data" },
{ type: "action", key: "import", text: "Import", action: "load_data" },
{ type: "help", text: "Export or import save slots 1\u201310 through the local server." }
] });
}
rows.push({ key: "footer", role: "footer", controls: [
{ type: "text", text: `Cheat version: ${runtime.cheatVer}${runtime.cheatVerType ? ` ${runtime.cheatVerType}` : ""}` },
{ type: "link", key: "update", text: "Check for update", href: data.downloadSite },
{ type: "link", key: "source", text: "Source Code", href: data.sourceCode }
] });
return rows;
}
var statHeadings = [
["stats-heading", "stats", "Stats"],
["enemy-heading", "enemy", "Enemy stats"],
["player-heading", "player", "Player"],
["characteristics-heading", "characteristics", "Characteristics"],
["fame-heading", "fame", "Fame"],
["school-heading", "school", "School"],
["talent-heading", "talent", "Talent"]
];
function statShell() {
return statHeadings.map(([key, group, text2]) => ({ key, groups: [group], role: "heading", controls: [{ type: "heading", text: text2 }] }));
}
function miscShell() {
return [
{ key: "npc-heading", groups: ["npc", "world"], role: "heading", controls: [{ type: "heading", text: "NPC" }] },
{ key: "pregnancy-heading", role: "heading", controls: [{ type: "heading", text: "Pregnancy Manager" }] },
{ key: "pregnancy-time-help", groups: ["pregnancy", "offspring", "pregnancy-removal"], role: "help", controls: [
{ type: "heading", text: "Pregnancy time" },
{ type: "help", text: "Values are measured in days." }
] }
];
}
function createSectionShells(context) {
return Object.freeze({ quick: Object.freeze(quickShell(context)), stats: Object.freeze(statShell()), misc: Object.freeze(miscShell()) });
}
// src/core/safe-exec.js
function safeCall(label, fn, { onError = null } = {}) {
try {
return fn();
} catch (err) {
if (typeof onError === "function") {
onError(err);
} else {
console.warn(`[CheatPlus] ${label}`, err);
}
return void 0;
}
}
// src/diagnostics/probe.js
var SCOPES = /* @__PURE__ */ new Set(["catalog", "runtime", "aliases", "scheduler", "config"]);
function createDiagnosticProbe(definition) {
if (!definition || typeof definition !== "object" || Array.isArray(definition))
throw new TypeError("Diagnostic probe must be an object.");
const allowed = /* @__PURE__ */ new Set(["id", "label", "scope", "applicable", "run", "timeoutMs"]);
for (const key of Object.keys(definition))
if (!allowed.has(key)) throw new Error(`Unknown diagnostic probe field "${key}".`);
if (!/^[a-z0-9]+(?:[.-][a-z0-9]+)+$/.test(definition.id ?? ""))
throw new Error("Diagnostic probe requires a stable lowercase namespaced id.");
if (typeof definition.label !== "string" || !definition.label.trim())
throw new TypeError(`Diagnostic probe "${definition.id}" requires a label.`);
if (!SCOPES.has(definition.scope))
throw new Error(`Diagnostic probe "${definition.id}" has an invalid scope.`);
if (definition.applicable != null && typeof definition.applicable !== "function")
throw new TypeError(`Diagnostic probe "${definition.id}" applicable must be a function.`);
if (typeof definition.run !== "function")
throw new TypeError(`Diagnostic probe "${definition.id}" requires run().`);
if (!Number.isInteger(definition.timeoutMs) || definition.timeoutMs < 1)
throw new TypeError(`Diagnostic probe "${definition.id}" requires a positive timeoutMs.`);
return Object.freeze({ ...definition });
}
// src/diagnostics/runner.js
var STATUSES = /* @__PURE__ */ new Set(["pass", "warning", "fail", "blocked"]);
function safeMessage(value, fallback = "") {
return typeof value === "string" ? value.slice(0, 240) : fallback;
}
async function withTimeout(probe, context) {
let timer;
try {
return await Promise.race([
Promise.resolve().then(() => probe.run(context)),
new Promise((resolve) => {
timer = setTimeout(
() => resolve({ status: "fail", message: "Probe timed out." }),
probe.timeoutMs
);
})
]);
} finally {
clearTimeout(timer);
}
}
function formatDiagnosticReport(report) {
const lines = [
`CheatPlus diagnostics: ${report.pass} pass, ${report.warning} warning, ${report.fail} fail, ${report.blocked} blocked`
];
for (const result of report.results)
lines.push(`${result.status.toUpperCase()} ${result.id}${result.message ? ` \u2014 ${result.message}` : ""}`);
return lines.join("\n");
}
function createDiagnosticRunner({ probes, context = () => ({}) }) {
if (!Array.isArray(probes)) throw new TypeError("Diagnostic runner requires probes.");
const ids = /* @__PURE__ */ new Set();
for (const probe of probes) {
if (ids.has(probe.id)) throw new Error(`Duplicate diagnostic probe "${probe.id}".`);
ids.add(probe.id);
}
async function runAll() {
const results = [];
const shared = context();
for (const probe of probes) {
let result;
try {
if (probe.applicable && !await probe.applicable(shared)) {
result = { status: "blocked", message: "Not applicable." };
} else result = await withTimeout(probe, shared);
} catch (_) {
result = { status: "fail", message: "Probe failed." };
}
const status = STATUSES.has(result?.status) ? result.status : "fail";
results.push(
Object.freeze({
id: probe.id,
label: probe.label,
scope: probe.scope,
status,
message: safeMessage(result?.message, status === "fail" ? "Invalid probe result." : "")
})
);
}
const counts = Object.fromEntries([...STATUSES].map((status) => [status, results.filter((r) => r.status === status).length]));
return Object.freeze({ total: results.length, ...counts, results: Object.freeze(results) });
}
return Object.freeze({ runAll, formatReport: formatDiagnosticReport, list: () => [...probes] });
}
// src/diagnostics/production.js
function createProductionDiagnostics({ catalog, adapter, getHealth, getAliases, scheduler }) {
const descriptors = catalog.listCheats();
const game = createGameContext(adapter);
const probes = [
createDiagnosticProbe({
id: "catalog.identity",
label: "Catalog identity",
scope: "catalog",
timeoutMs: 250,
run: () => ({ status: new Set(descriptors.map(({ id }) => id)).size === descriptors.length ? "pass" : "fail", message: `${descriptors.length} descriptors.` })
}),
createDiagnosticProbe({
id: "runtime.paths",
label: "Runtime applicability",
scope: "runtime",
timeoutMs: 500,
applicable: () => adapter.isReady?.() !== false,
run: () => {
const missing = descriptors.filter(
({ requiredPaths = [] }) => requiredPaths.some((path7) => !game.has(path7))
).length;
return { status: missing ? "warning" : "pass", message: `${missing} descriptors have unavailable required paths.` };
}
}),
createDiagnosticProbe({
id: "builder.health",
label: "Builder health",
scope: "runtime",
timeoutMs: 250,
run: () => {
const health = getHealth();
return { status: health.failed ? "fail" : "pass", message: `${health.mounted}/${health.total} mounted; ${health.failed} failed.` };
}
}),
createDiagnosticProbe({
id: "aliases.registration",
label: "Alias registration",
scope: "aliases",
timeoutMs: 250,
run: () => {
const aliases = getAliases();
return { status: new Set(aliases).size === aliases.length ? "pass" : "fail", message: `${aliases.length} aliases registered.` };
}
}),
createDiagnosticProbe({
id: "scheduler.ownership",
label: "Scheduler ownership",
scope: "scheduler",
timeoutMs: 250,
run: () => ({ status: "pass", message: `${scheduler.list().length} scheduler entries.` })
}),
createDiagnosticProbe({
id: "config.references",
label: "Config references",
scope: "config",
timeoutMs: 250,
run: () => {
const paths = new Set(CHEAT_CONFIG_SCHEMA.map(({ path: path7 }) => path7));
const invalid = descriptors.flatMap(({ config = [] }) => config).filter((path7) => !paths.has(path7));
return { status: invalid.length ? "fail" : "pass", message: `${invalid.length} invalid config references.` };
}
})
];
return createDiagnosticRunner({ probes });
}
// src/features/cheat-init.js
function configureCheatRuntime(runtimeEngine) {
const adapter = runtimeEngine?.adapter;
if (!adapter) throw new TypeError("Cheat runtime configuration requires an active adapter.");
const runtimeLogger = {
error: (message, data) => logger_default("cheat-runtime", message, { data, level: "error" })
};
const scheduler = createProductionSchedulerAdapter();
const toggle = createProductionCheatToggleRuntime({ logger: runtimeLogger, scheduler });
let builder;
const diagnostics = createProductionDiagnostics({
catalog: cheatCatalog,
adapter,
getHealth: () => builder?.health() ?? { total: 0, mounted: 0, failed: 0 },
getAliases: () => [],
scheduler
});
builder = createCheatRuntimeBuilder({
catalog: cheatCatalog,
adapter,
config: createAdapterCheatConfigProvider(adapter),
document,
dispatchShellAction: dispatch,
feedback: {
success: (message) => showToast(message, { variant: "success" }),
error: (message) => showToast(message, { variant: "error" }),
warning: (message) => showToast(message, { variant: "warning" }),
info: (message) => showToast(message, { variant: "info" })
},
services: { toggle, scheduler, logger: runtimeLogger, diagnostics },
logger: {
error: (message, data) => logger_default("cheat-builder", message, { data, level: "error" })
}
});
builder.compile();
return setActiveCheatBuilder(builder);
}
async function init_interface() {
safeCall("init_interface-start", () => {
logger_default("cheat-init", "init_interface-start");
});
const runtimeWindow2 = getRuntimeWindow();
const context = {
data: {
downloadSite,
sourceCode
},
runtime: {
testedOn: testedOn || runtimeWindow2?.testedOn,
curVer: curVer || runtimeWindow2?.curVer,
isCheatWorkSymbol: runtimeWindow2?.isCheatWorkSymbol,
isCheatWork: runtimeWindow2?.isCheatWork,
isServer: isServer || runtimeWindow2?.isServer,
cheatVer: cheatVer || runtimeWindow2?.cheatVer,
cheatVerType: cheatVerType || runtimeWindow2?.cheatVerType
}
};
safeCall(
"failed to clear existing sections",
() => {
["quick-content", "stats-content", "misc-content"].forEach((id) => {
const el = byUiId(id) || document.getElementById(id);
if (el) {
while (el.firstChild) el.removeChild(el.firstChild);
}
});
},
{
onError: (err) => {
logger_default("cheat-init", "failed to clear existing sections", { data: err, level: "warn" });
}
}
);
const shells = createSectionShells(context);
const builder = getActiveCheatBuilder();
if (builder) {
await builder.mountSection("quick", byUiId("quick-content"), shells.quick);
await builder.mountSection("stats", byUiId("stats-content"), shells.stats);
await builder.mountSection("misc", byUiId("misc-content"), shells.misc);
} else {
for (const section of ["quick", "stats", "misc"]) {
renderSectionShell({
section,
rows: shells[section],
container: byUiId(`${section === "stats" ? "stats" : section}-content`),
document,
dispatchAction: dispatch
});
}
}
var element = byUiId("tmpText") || document.getElementById("tmpText");
if (element) element.classList.add("tmpText");
safeCall("init_interface-done", () => {
logger_default("cheat-init", "init_interface-done");
});
}
// src/core/events/registry.js
var registryStore = [];
function getStore3() {
return registryStore;
}
function on(target, type, handler, options6) {
target.addEventListener(type, handler, options6);
getStore3().push({ target, type, handler, options: options6 });
}
function reset() {
const store2 = getStore3();
for (const { target, type, handler, options: options6 } of store2) {
try {
target.removeEventListener(type, handler, options6);
} catch (_) {
}
}
store2.length = 0;
}
// src/core/runtime-observer-policy.js
function defaultDetectLoadTrigger(target) {
return Boolean(target?.classList?.contains("macro-button") && target?.innerHTML == "SAVES");
}
function defaultDetectHistoryNavigation(target) {
return Boolean(target?.id == "history-backward" || target?.id === "history-forward");
}
var defaultRuntimeObserverPolicy = Object.freeze({
detectLoadTrigger: defaultDetectLoadTrigger,
detectHistoryNavigation: defaultDetectHistoryNavigation
});
function createRuntimeObserverPolicy(overrides = {}) {
return {
...defaultRuntimeObserverPolicy,
...overrides
};
}
// src/features/listeners/action-map-methods.js
var METHOD_ACTIONS = [
{ actionKey: "vow-virgin", methodName: "imvirgintemple" },
{ actionKey: "arousal_player" },
{ actionKey: "arousal_enemy" },
{ actionKey: "sheesh", methodName: "aezakmi" },
{ actionKey: "jk-lol", methodName: "imdonefor" },
{ actionKey: "hesoyam" },
{ actionKey: "kill_player" },
{ actionKey: "statset", methodName: "statmanager" },
{ actionKey: "enemycalm" },
{ actionKey: "kill_enemy" },
{ actionKey: "statsete", methodName: "statmanagere" },
{ actionKey: "sprayset", methodName: "sprayunlimited" },
{ actionKey: "bodytypeset", methodName: "bodytypemanager" },
{ actionKey: "ballsset", methodName: "ballsmanager" },
{ actionKey: "virginityset", methodName: "virginitymanager" },
{ actionKey: "virginpure", methodName: "virginitypure" },
{ actionKey: "charaset", methodName: "charamanager" },
{ actionKey: "lactatingset", methodName: "lactatingmanager" },
{ actionKey: "cumset", methodName: "cummanager" },
{ actionKey: "milkset", methodName: "milkmanager" },
{ actionKey: "cumrefil", methodName: "cumfill" },
{ actionKey: "milkrefil", methodName: "milkfill" },
{ actionKey: "changetraitbro" },
{ actionKey: "VrelCoinsUsage" },
{ actionKey: "set_fame12" },
{ actionKey: "infect" },
{ actionKey: "desinfect" },
{ actionKey: "set_animal_like" },
{ actionKey: "set_build_time" },
{ actionKey: "set_assault_time" },
{ actionKey: "set_exam", methodName: "exammanager" },
{ actionKey: "set_talent", methodName: "talentmanager" },
{ actionKey: "clean_cum" },
{ actionKey: "check_fruit_selling" },
{ actionKey: "set_school_rep" },
{ actionKey: "named_npc_pregnancy_set" },
{ actionKey: "npc_pregnancy_set" },
{ actionKey: "mc_pregnancy_set" },
{ actionKey: "mc_tentacle_set" },
{ actionKey: "mc_baby_set" },
{ actionKey: "set_hentai_skill" },
{ actionKey: "mc_abortion_set" },
{ actionKey: "named_npc_abortion_set" },
{ actionKey: "npc_abortion_set" },
{ actionKey: "dirty_cum" },
{ actionKey: "clean_cum_uretus" },
{ actionKey: "in_game_cheat" },
{ actionKey: "alt_cheat" },
{ actionKey: "randomEncounterSet" },
{ actionKey: "npc_abortion_purge", methodName: "purgeNPCPregnancy" },
{ actionKey: "purgeNPCBaby" },
{ actionKey: "testAll" }
];
validateMethodEntries(METHOD_ACTIONS, "METHOD_ACTIONS");
// src/features/listeners/action-map-ui.js
var NAV_ACTIONS = [
{
actionKey: "quick-link",
navKey: "quicklink",
contentKey: "quickcontent",
hydrateKey: "hydrateQuickSection"
},
{
actionKey: "stats-link",
navKey: "statlink",
contentKey: "statscontent",
hydrateKey: "hydrateStatsSection"
},
{
actionKey: "misc-link",
navKey: "misclink",
contentKey: "misccontent",
hydrateKey: "hydrateMiscSection"
}
];
var SIMPLE_UI_ACTIONS = [
{ actionKey: "cheat-open", target: "openModal" },
{ actionKey: "cheat-history-backwards", target: "cheatActions", arg: "cheat_backwards" },
{ actionKey: "cheat-history-forwards", target: "cheatActions", arg: "cheat_forwards" },
{ actionKey: "cheat-sidebar", target: "cheatActions", arg: "sidebar_cheat" },
{ actionKey: "init_interface", target: "init_interface" },
{ actionKey: "search123", target: "executeSearch", arg: "search123" },
{ actionKey: "search456", target: "executeSearch", arg: "search456" },
{ actionKey: "Enable_cheat_history", target: "Enable_cheat_history" },
{ actionKey: "Enable_sidebar_button", target: "Enable_sidebar_button" },
{ actionKey: "simple_cheat_button", target: "simple_cheat_button" }
];
var BOUND_ACTIONS = [
{ actionKey: "statpick", source: "hydrateCheatUi", method: "statpick" },
{ actionKey: "statpicke", source: "hydrateCheatUi", method: "statpicke" },
{ actionKey: "charapick", source: "hydrateCheatUi", method: "characurrent" },
{ actionKey: "fame_name", source: "hydrateCheatUi", method: "famecurrent" },
{ actionKey: "select_exam", source: "hydrateCheatUi", method: "examcurrent" },
{ actionKey: "npcnames", source: "hydrateCheatUi", method: "npccurrent" },
{ actionKey: "npctraits", source: "hydrateCheatUi", method: "npccurrent" },
{ actionKey: "select_talent", source: "hydrateCheatUi", method: "talentcurrent" },
{ actionKey: "select_school_rep", source: "hydrateCheatUi", method: "update_school_rep" },
{
actionKey: "named_npc_pregnancy_manager",
source: "hydrateCheatUi",
method: "update_pregnancy_day_named_npc"
},
{
actionKey: "npc_pregnancy_manager",
source: "hydrateCheatUi",
method: "update_pregnancy_day_npc"
},
{ actionKey: "mc_pregnancy_hole", source: "hydratePregnancy", method: "update_pregnancy_mc" },
{
actionKey: "mc_pregnancy_manager",
source: "hydrateCheatUi",
method: "update_pregnancy_day_mc"
},
{ actionKey: "mc_tentacle_location", source: "hydrateCheatUi", method: "update_mc_tentacle" },
{
actionKey: "mc_tentacle_select",
source: "hydrateCheatUi",
method: "update_mc_tentacle_input"
},
{
actionKey: "mc_baby_action_select",
source: "hydrateCheatUi",
method: "update_mc_baby_info"
},
{ actionKey: "mc_baby_select", source: "hydrateCheatUi", method: "update_mc_baby_info" },
{
actionKey: "mc_abortion_location",
source: "hydrateCheatUi",
method: "update_mc_abortion_list"
},
{
actionKey: "named_npc_abortion_chara_select",
source: "hydrateCheatUi",
method: "update_named_npc_abortion_list"
},
{
actionKey: "npc_abortion_chara_select",
source: "hydrateCheatUi",
method: "update_npc_fetus_abortion_list"
},
{ actionKey: "animal_choice", source: "hydrateCheatUi", method: "update_farm_animals_like" },
{ actionKey: "arousal_val", source: "hydrateCheatUi", method: "arousalpicked" }
];
validateNavEntries(NAV_ACTIONS, "NAV_ACTIONS");
validateSimpleUiEntries(SIMPLE_UI_ACTIONS, "SIMPLE_UI_ACTIONS");
validateBoundEntries(BOUND_ACTIONS, "BOUND_ACTIONS");
// src/features/listeners/action-maps.js
function registerHandler(actionKey, handler) {
if (typeof handler === "function") register(actionKey, handler);
}
function registerMethodAction(actionKey, cheatActions2, methodName = actionKey) {
registerHandler(actionKey, () => {
const fn = cheatActions2?.[methodName];
if (typeof fn === "function") fn(cheatActions2);
});
}
function registerSimpleUiAction(entry2, context) {
const {
closeModal: closeModal2,
openModal: openModal2,
cheatActions: cheatActions2,
executeSearch: executeSearch2,
Enable_cheat_history: Enable_cheat_history2,
Enable_sidebar_button: Enable_sidebar_button2,
simple_cheat_button: simple_cheat_button2,
init_interface: init_interface2
} = context;
const handlers = {
closeModal: closeModal2,
openModal: openModal2,
cheatActions: () => {
const fn = cheatActions2?.[entry2.arg];
if (typeof fn === "function") fn(cheatActions2);
},
executeSearch: () => executeSearch2(entry2.arg),
Enable_cheat_history: Enable_cheat_history2,
Enable_sidebar_button: Enable_sidebar_button2,
simple_cheat_button: simple_cheat_button2,
init_interface: init_interface2
};
registerHandler(entry2.actionKey, handlers[entry2.target]);
}
function registerBoundAction(entry2, context) {
const sourceMap = {
hydrateCheatUi: context.hydrateCheatUi,
hydratePregnancy: context.hydratePregnancy
};
const source = sourceMap[entry2.source];
registerHandler(entry2.actionKey, source?.[entry2.method]);
}
function registerAllActions({
closeModal: closeModal2,
openModal: openModal2,
showContent: showContent2,
getUiRefs: getUiRefs2,
cheatActions: cheatActions2,
hydratePregnancy: hydratePregnancy2,
hydrateCheatUi: hydrateCheatUi2,
hydrateQuickSection: hydrateQuickSection2,
hydrateStatsSection: hydrateStatsSection2,
hydrateMiscSection: hydrateMiscSection2,
Enable_cheat_history: Enable_cheat_history2,
Enable_sidebar_button: Enable_sidebar_button2,
simple_cheat_button: simple_cheat_button2,
executeSearch: executeSearch2,
init_interface: init_interface2
}) {
const context = {
closeModal: closeModal2,
openModal: openModal2,
cheatActions: cheatActions2,
executeSearch: executeSearch2,
Enable_cheat_history: Enable_cheat_history2,
Enable_sidebar_button: Enable_sidebar_button2,
simple_cheat_button: simple_cheat_button2,
init_interface: init_interface2,
hydrateCheatUi: hydrateCheatUi2,
hydratePregnancy: hydratePregnancy2
};
const showSection = (navKey, contentKey, hydrate) => {
const uiRefs = getUiRefs2();
showContent2(uiRefs?.[navKey], uiRefs?.[contentKey]);
hydrate?.();
};
const hydrateMap = {
hydrateQuickSection: hydrateQuickSection2,
hydrateStatsSection: hydrateStatsSection2,
hydrateMiscSection: hydrateMiscSection2
};
NAV_ACTIONS.forEach(({ actionKey, navKey, contentKey, hydrateKey }) => {
registerHandler(actionKey, () => showSection(navKey, contentKey, hydrateMap[hydrateKey]));
});
SIMPLE_UI_ACTIONS.forEach((entry2) => registerSimpleUiAction(entry2, context));
TOGGLE_DEFINITIONS.forEach(({ id, label }) => {
registerHandler(id, () => cheatActions2.toggleById(id, label));
});
METHOD_ACTIONS.forEach(({ actionKey, methodName }) => {
registerMethodAction(actionKey, cheatActions2, methodName);
});
BOUND_ACTIONS.forEach((entry2) => registerBoundAction(entry2, context));
}
// src/features/listeners/index.js
var actionsRegistered = false;
var runtimeObserverPolicy = createRuntimeObserverPolicy();
function configureRuntimeObserverPolicy(overrides = {}) {
runtimeObserverPolicy = createRuntimeObserverPolicy(overrides);
}
function registerListenerActions() {
if (actionsRegistered) return;
registerAllActions({
closeModal,
openModal,
showContent,
getUiRefs,
cheatActions,
hydratePregnancy,
hydrateCheatUi,
hydrateQuickSection,
hydrateStatsSection,
hydrateMiscSection,
Enable_cheat_history,
Enable_sidebar_button,
simple_cheat_button,
executeSearch,
init_interface
});
setErrorHook((key) => showToast(`Action "${key}" failed.`, { variant: "error" }));
actionsRegistered = true;
}
function initGameObservers() {
const cheat2 = byUiId("cheat");
if (!cheat2) return;
reset();
function ensureTogglesActive() {
if (!actionsRegistered) return;
if (getIsLoad() || getReactivatingToggles()) return;
const stored = getToggles();
const storedCount = stored && typeof stored === "object" ? Object.keys(stored).length : 0;
if (!storedCount) return;
const bundles = ToggleScheduler.getBundles();
const runtimeCount = Object.keys(bundles.functionbundle || {}).length + Object.keys(bundles.dailyfunctionbundle || {}).length;
if (runtimeCount === 0) {
initStorage();
reactivateToggles();
}
}
on(document, "click", function(event) {
ensureTogglesActive();
if (isAtSettings()) {
restoreVariables();
} else {
incrementClickCounter();
cheatActions.runitall();
}
let target = event.target;
if (runtimeObserverPolicy.detectLoadTrigger(target)) {
setIsLoad(true);
} else if (getIsLoad()) {
initStorage();
reactivateToggles();
showToast("Cheat state loaded", { variant: "success" });
setIsLoad(false);
} else if (runtimeObserverPolicy.detectHistoryNavigation(target)) {
initStorage();
}
});
on(document, "keyup", function() {
ensureTogglesActive();
if (!isAtSettings()) {
incrementClickCounter();
cheatActions.runitall();
}
});
on(cheat2, "keyup", function(event) {
event.stopPropagation();
});
}
function stopGameObservers() {
reset();
ToggleScheduler.reset();
}
// src/features/registry.js
factory.registerFeature({
id: "storage",
init() {
initStorage();
reactivateToggles();
}
});
factory.registerFeature({
id: "listeners",
registerActions() {
registerListenerActions();
},
startObservers() {
initGameObservers();
},
stopObservers() {
stopGameObservers();
}
});
// src/features/bootstrap.js
var bootstrapped = false;
function canBootstrap(runtimeEngine) {
return Boolean(runtimeEngine?.adapter?.isReady?.() && byUiId(CHEAT_ROOT_ID));
}
function bootstrap({ runtimeEngine } = {}) {
if (bootstrapped) return false;
if (!canBootstrap(runtimeEngine)) return false;
configureRuntimeObserverPolicy(runtimeEngine?.observerPolicy ?? {});
factory.registerAllActions();
configureCheatRuntime(runtimeEngine);
factory.initAllFeatures();
factory.startAllObservers();
bootstrapped = true;
return true;
}
function bootstrapCheat(options6 = {}) {
return bootstrap(options6);
}
// src/core/styleRegistry.js
var registry = { shadow: [], document: [] };
function getRegistry() {
return registry;
}
function registerSheet(cssText, { target = "shadow" } = {}) {
const reg = getRegistry();
if (target === "shadow" || target === "both") {
if (!reg.shadow.includes(cssText)) reg.shadow.push(cssText);
}
if (target === "document" || target === "both") {
if (!reg.document.includes(cssText)) reg.document.push(cssText);
}
}
var appliedShadowRoots = /* @__PURE__ */ new WeakSet();
function applyToShadow(shadowRoot2) {
if (!shadowRoot2) return;
if (appliedShadowRoots.has(shadowRoot2)) return;
appliedShadowRoots.add(shadowRoot2);
const reg = getRegistry();
reg.shadow.forEach((cssText) => {
const style = document.createElement("style");
style.textContent = cssText;
shadowRoot2.appendChild(style);
});
}
// src/ui/assets/base.css
var base_default = "#cheat {\n font-family: var(--cp-font-ui, Arial, sans-serif);\n color: var(--cp-text-primary, #fff);\n}\n\r\n#effect-layer {\r\n z-index: 999;\r\n background-color: red;\r\n opacity: 0;\r\n position: fixed;\r\n top: 0;\r\n left: 0;\r\n width: 100%;\r\n height: 100%;\r\n}\r\n\r\n.hidden {\r\n display: none;\r\n}\r\n\r\n@media (prefers-reduced-motion: reduce) {\r\n .fade {\r\n transition: none;\r\n }\r\n}\r\n\r\n.fade:not(.show) {\r\n opacity: 0;\r\n}\r\n\r\n.collapse:not(.show) {\r\n display: none;\r\n}\r\n\r\n.collapsing {\r\n height: 0;\r\n overflow: hidden;\r\n transition: height 0.35s ease;\r\n}\r\n\r\n@media (prefers-reduced-motion: reduce) {\r\n .collapsing {\r\n transition: none;\r\n }\r\n}\r\n\r\n.collapsing.collapse-horizontal {\r\n width: 0;\r\n height: auto;\r\n transition: width 0.35s ease;\r\n}\r\n\r\n@media (prefers-reduced-motion: reduce) {\r\n .collapsing.collapse-horizontal {\r\n transition: none;\r\n }\r\n}\r\n\r\n.gold {\r\n color: var(--cp-color-gold, #f0d46d);\r\n}\r\n\r\n.linkBlue {\r\n color: var(--cp-color-link, #66a7ff);\r\n}\r\n\r\n@keyframes shake {\r\n 0% {\r\n transform: translate(0px, 0px);\r\n }\r\n 25% {\r\n transform: translate(2px, -2px);\r\n }\r\n 50% {\r\n transform: translate(-2px, 2px);\r\n }\r\n 75% {\r\n transform: translate(2px, -2px);\r\n }\r\n 100% {\r\n transform: translate(0px, 0px);\r\n }\r\n}\r\n\r\n.shake {\r\n animation: shake 0.3s linear infinite;\r\n}\r\n";
// src/ui/assets/floating.css
var floating_default = "#floating-button {\r\n position: fixed;\r\n top: 2%;\r\n right: 20px;\r\n z-index: 899;\r\n display: flex;\r\n flex-direction: row;\r\n gap: 5px;\r\n transition: top 0.5s ease-in-out;\r\n}\r\n\r\n#floating-button button {\r\n min-height: 34px;\r\n padding: 0 12px;\r\n border-radius: 8px;\r\n border: 1px solid rgba(255, 255, 255, 0.35);\r\n background: linear-gradient(180deg, #575757 0%, #3f3f3f 100%);\r\n color: #f2f2f2;\r\n font-weight: 600;\r\n}\r\n\r\n#floating-button button:hover {\r\n background: linear-gradient(180deg, #646464 0%, #474747 100%);\r\n}\r\n\r\n#floating-button #cheat-open {\r\n cursor: grab;\r\n touch-action: none;\r\n padding: 0 16px;\r\n border-color: rgba(240, 212, 109, 0.55);\r\n box-shadow: 0 0 0 1px rgba(240, 212, 109, 0.18);\r\n}\r\n\r\n#floating-button.cp-dragging,\r\n#floating-button.cp-dragging #cheat-open {\r\n cursor: grabbing;\r\n user-select: none;\r\n}\r\n\r\n#floating-button.cp-dragging,\r\n#floating-button.cp-custom-position {\r\n transition: none;\r\n}\r\n\r\n#floating-button.moved {\r\n top: 90%;\r\n}\r\n";
// src/ui/assets/modal.css
var modal_default = ".modal {\r\n display: none;\r\n position: fixed;\r\n z-index: 900;\r\n left: 0;\r\n top: 0;\r\n width: 100%;\r\n height: 100%;\r\n overflow: auto;\r\n background-color: var(--cp-color-overlay, rgba(0, 0, 0, 0.5));\r\n}\r\n\r\n.modal-content {\r\n background-color: var(--cp-bg-modal, #222);\r\n margin: 10px auto;\r\n border: 1px solid var(--cp-border-modal, #888);\r\n border-radius: 10px;\r\n width: min(960px, 94vw);\r\n overflow: hidden;\r\n box-shadow: 0 18px 44px rgba(0, 0, 0, 0.45);\r\n}\r\n\r\n.modal-content-padding {\n box-sizing: border-box;\n padding: 5px 0 9px;\n display: flex;\n flex-wrap: wrap;\n align-items: center;\n column-gap: 10px;\n row-gap: 8px;\n scroll-margin-top: 58px;\n}\n\n.cp-layout-heading {\n padding-top: 14px;\n padding-bottom: 7px;\n font-weight: 600;\n}\n\n.cp-layout-help {\n padding-bottom: 10px;\n}\n\n.cp-layout-spacer {\n min-height: 10px;\n padding: 0;\n}\n\n.cp-layout-footer {\n margin-top: 14px;\n padding-top: 12px;\n border-top: 1px solid rgba(255, 255, 255, 0.12);\n}\n\n.cp-section-shell {\n display: contents;\n}\n\n.cp-shell-help {\n color: #9cbcff;\n font-size: 0.9em;\n}\n\n.cp-cheat-descriptor {\n display: grid;\n grid-template-columns: minmax(150px, max-content) minmax(0, 1fr);\n align-items: start;\n column-gap: 12px;\n min-width: 0;\n}\n\n.cp-cheat-label {\n min-height: 32px;\n display: inline-flex;\n align-items: center;\n font-weight: 400;\n gap: 7px;\n}\n\n.cp-cheat-controls {\n min-width: 0;\n display: flex;\n flex-wrap: wrap;\n align-items: center;\n column-gap: 10px;\n row-gap: 8px;\n}\n\n.cp-cheat-control-unit {\n min-width: 0;\n max-width: 100%;\n display: inline-flex;\n align-items: center;\n gap: 10px;\n break-inside: avoid;\n}\n\n.cp-cheat-status {\n grid-column: 1 / -1;\n margin-left: 162px;\n color: #f2c879;\n line-height: 1.35;\n}\n\n.cp-cheat-unavailable {\n border-left: 3px solid #b47a36;\n padding-left: 9px;\n}\n\n.cp-control-notice {\n flex-basis: 100%;\n color: var(--cp-text-muted, #c8c3bc);\n line-height: 1.3;\n}\n\n.cp-control-notice[data-notice-kind='warning'] {\n color: #f2c879;\n}\n\n.cp-confirmation-control {\n padding: 2px 7px;\n border: 1px solid rgba(240, 212, 109, 0.35);\n border-radius: 6px;\n}\n\n.cp-status-control {\n flex: 0 0 auto;\n}\n\n.cp-cheat-control-unit[hidden] {\n display: none;\n}\n\n.cp-status-chip {\n display: inline-flex;\n align-items: center;\n min-height: 24px;\n box-sizing: border-box;\n padding: 2px 9px;\n border: 1px solid rgba(102, 167, 255, 0.45);\n border-radius: 999px;\n background: rgba(102, 167, 255, 0.12);\n color: #c9dcff;\n line-height: 1.2;\n white-space: nowrap;\n}\n\n.cp-cheat-control-unit > .modal-content-width,\n.cp-cheat-control-unit > select {\n max-width: min(100%, 320px);\n}\n\r\n.modal-content-width {\n box-sizing: border-box;\r\n min-height: 32px;\r\n padding: 0 10px;\r\n border-radius: 6px;\r\n border: 1px solid var(--cp-border-button, #8a8a8a);\r\n background: #151515;\r\n color: var(--cp-text-primary, #fff);\n}\n\n.cp-cheat-control:focus-visible {\n outline: 2px solid var(--cp-color-link, #66a7ff);\n outline-offset: 2px;\n}\n\n.cp-cheat-control:disabled {\n cursor: not-allowed;\n opacity: 0.55;\n}\n\n.cp-cheat-range {\n accent-color: var(--cp-color-gold, #f0d46d);\n}\n\n.cp-search-row {\r\n position: sticky;\r\n top: 0;\r\n z-index: 2;\r\n background: var(--cp-bg-modal, #222);\r\n padding-top: 4px;\r\n display: flex;\r\n align-items: center;\r\n gap: 8px;\r\n}\r\n\r\n.cp-search-input {\r\n width: min(460px, 96%);\r\n box-sizing: border-box;\r\n min-height: 32px;\r\n padding: 0 10px;\r\n border-radius: 6px;\r\n border: 1px solid var(--cp-border-button, #8a8a8a);\r\n background: #151515;\r\n color: var(--cp-text-primary, #fff);\r\n}\r\n\r\n.cp-search-input::placeholder {\r\n color: #9f9f9f;\r\n}\r\n\r\n.modal-button {\r\n background: var(--cp-bg-button, #4b4b4b);\r\n color: var(--cp-text-primary, #fff);\r\n border: 1px solid var(--cp-border-button, #8a8a8a);\r\n border-radius: var(--cp-radius-button, 2px);\r\n min-height: 32px;\r\n padding: 0 10px;\r\n line-height: 1;\r\n display: inline-flex;\r\n align-items: center;\r\n justify-content: center;\r\n white-space: nowrap;\r\n cursor: pointer;\r\n}\r\n\r\n.modal-content select {\r\n min-height: 32px;\r\n padding: 0 28px 0 10px;\r\n border-radius: 6px;\r\n border: 1px solid var(--cp-border-button, #8a8a8a);\r\n background: #151515;\r\n color: var(--cp-text-primary, #fff);\r\n}\r\n\r\n.modal-button:hover {\r\n background: var(--cp-bg-button-hover, #5a5a5a);\r\n}\r\n\r\n.modal-button.cp-toggle-active {\r\n background: var(--cp-color-gold, #f0d46d);\r\n color: #1a1a1a;\r\n border-color: var(--cp-color-gold, #f0d46d);\r\n}\r\n\r\n.modal-button.cp-toggle-active:hover {\r\n background: #d4b84a;\r\n border-color: #d4b84a;\r\n}\r\n\r\n.modal-button[hidden],\r\n.modal-toggle[hidden],\r\n.modal-link[hidden],\r\n.modal-toggle[hidden] * {\r\n display: none !important;\r\n}\r\n\r\n.modal-toggle {\r\n display: inline-flex;\r\n align-items: center;\r\n gap: 6px;\r\n cursor: pointer;\r\n user-select: none;\r\n border: 1px solid transparent;\r\n border-radius: 999px;\r\n padding: 2px 8px;\r\n transition: border-color 0.2s ease, background-color 0.2s ease;\r\n}\r\n\r\n.modal-toggle input[type='checkbox'] {\r\n width: 14px;\r\n height: 14px;\r\n margin: 0;\r\n cursor: pointer;\r\n}\r\n\r\n.modal-toggle .toggle-label {\r\n color: var(--cp-text-muted, #c8c3bc);\r\n}\r\n\r\n.modal-toggle input[type='checkbox']:checked + .toggle-label {\r\n color: var(--cp-color-gold, #f0d46d);\r\n font-weight: 700;\r\n}\r\n\r\n.modal-toggle.cp-toggle-active {\n border-color: rgba(240, 212, 109, 0.65);\r\n background: rgba(240, 212, 109, 0.12);\n}\n\n.modal-toggle[aria-disabled='true'] {\n cursor: not-allowed;\n opacity: 0.7;\n}\n\n.modal-toggle:has(input[hidden]) {\n display: none !important;\n}\n\r\n.cp-bound-value {\r\n margin-left: 8px;\r\n color: var(--cp-text-muted, #c8c3bc);\r\n font-size: 11px;\r\n opacity: 0.9;\r\n}\r\n\r\n.modal-link {\r\n color: var(--cp-color-link, #66a7ff);\r\n text-decoration: underline;\r\n}\r\n\r\n.modal-content-color {\r\n color: var(--cp-text-muted, #c8c3bc);\r\n}\r\n\r\n.modal-content-right {\r\n margin-right: 10px;\r\n}\r\n\r\n.tooltip-small {\n position: relative;\r\n display: inline-block;\r\n cursor: help;\r\n}\r\n\r\n.tooltip-small span {\r\n visibility: hidden;\r\n width: 300px;\r\n max-width: min(70vw, 300px);\r\n background: var(--cp-bg-tooltip, #111);\r\n color: var(--cp-text-tooltip, #f2f2f2);\r\n border: 1px solid var(--cp-border-tooltip, #444);\r\n border-radius: var(--cp-radius-tooltip, 4px);\r\n padding: 6px 8px;\r\n position: absolute;\r\n z-index: 1000;\r\n left: 0;\r\n top: 1.4em;\r\n white-space: normal;\r\n}\r\n\r\n.tooltip-small:hover span,\n.tooltip-small:focus span,\n.tooltip-small:focus-within span {\n visibility: visible;\n}\n\n.tooltip-small[hidden] {\n display: none;\n}\n\r\n.close {\r\n cursor: pointer;\r\n}\r\n\r\n.navbar .close {\r\n flex: 0 0 52px;\r\n width: 52px;\r\n min-width: 52px;\r\n border-right: 0;\r\n padding: 8px 0;\r\n font-size: 24px;\r\n font-weight: 700;\r\n line-height: 1;\r\n color: #ffe5e5;\r\n background: linear-gradient(180deg, #6b2d2d 0%, #542222 100%);\r\n transition: background-color 0.2s ease, color 0.2s ease;\r\n}\r\n\r\n.navbar .close:hover,\r\n.navbar .close:focus {\r\n color: #ffffff;\r\n background: linear-gradient(180deg, #7d3636 0%, #632c2c 100%);\r\n}\r\n\r\n#modal-content-container {\r\n display: flex;\r\n flex-direction: column;\r\n}\r\n\r\n.modal-row {\r\n display: flex;\r\n justify-content: space-between;\r\n align-items: center;\r\n margin-bottom: 10px;\r\n}\r\n\r\n.modal-label {\r\n flex: 1;\r\n}\r\n\r\n.modal-inputs {\r\n flex: 2;\r\n}\r\n\r\n#modal-content-container {\n height: 72vh;\n max-height: 72vh;\n overflow-y: auto;\n overscroll-behavior: contain;\n scroll-padding: 58px 0 64px;\n}\r\n\r\n.navbar {\r\n display: flex;\r\n justify-content: space-between;\r\n align-items: center;\r\n background-color: var(--cp-bg-navbar, #333);\r\n color: var(--cp-text-primary, #fff);\r\n}\r\n\r\n.nav-link {\r\n width: 100%;\r\n cursor: pointer;\r\n text-align: center;\r\n position: relative;\r\n border-right: 1px solid rgba(255, 255, 255, 0.3);\r\n padding: 10px;\r\n}\r\n\r\n.nav-link.active {\r\n text-decoration: underline;\r\n}\r\n\r\n.cheat-content {\n box-sizing: border-box;\n width: 100%;\n padding: 1rem 1rem 3rem !important;\n display: none;\n}\n\r\n.cheat-content.active {\r\n display: block;\r\n}\r\n\r\n.content {\r\n display: none;\r\n padding: 10px;\r\n}\r\n\r\n.content.active {\r\n display: block;\r\n}\r\n\r\n.cp-section-broken {\r\n border: 1px solid #9f2d2d;\r\n background: rgba(159, 45, 45, 0.12);\r\n}\r\n\r\n.cp-section-broken-banner {\r\n background: #9f2d2d;\r\n color: #fff;\r\n padding: 6px 8px;\r\n margin-bottom: 8px;\r\n font-size: 12px;\r\n}\r\n";
// src/ui/assets/responsive.css
var responsive_default = "@media (max-width: 768px) {\r\n .modal-content {\r\n width: 96vw;\r\n margin: 8px auto;\r\n }\r\n\r\n #modal-content-container {\r\n height: 72vh;\r\n max-height: 72vh;\r\n overflow-y: auto;\r\n }\r\n\r\n .cp-search-row {\r\n flex-wrap: wrap;\r\n }\r\n\r\n .cp-search-input {\n width: 100%;\n }\n\n .cp-cheat-descriptor {\n grid-template-columns: minmax(0, 1fr);\n row-gap: 5px;\n padding-top: 9px;\n padding-bottom: 12px;\n }\n\n .cp-cheat-label {\n min-height: auto;\n }\n\n .cp-cheat-status {\n margin-left: 0;\n }\n\n .cp-cheat-controls {\n width: 100%;\n }\n\n .cp-cheat-control-unit {\n max-width: 100%;\n }\n\n .cp-cheat-control-unit > .modal-content-width,\n .cp-cheat-control-unit > select {\n min-width: 0;\n max-width: min(100%, 280px);\n }\n\r\n .toast-container,\r\n #toastContainer,\r\n #cp-fallback-toast-container {\r\n left: 50%;\r\n right: auto;\r\n transform: translateX(-50%);\r\n width: min(92vw, 420px);\r\n }\r\n}\n\n@media (max-width: 480px) {\n .cheat-content {\n padding: 0.75rem 0.75rem 3.5rem !important;\n }\n\n .cp-cheat-controls {\n column-gap: 8px;\n }\n\n}\n";
// src/ui/assets/toast.css
var toast_default = ".toast-container,\r\n#toastContainer,\r\n#cp-fallback-toast-container {\r\n position: fixed;\r\n top: max(12px, env(safe-area-inset-top));\r\n right: max(12px, env(safe-area-inset-right));\r\n z-index: 999;\r\n display: flex;\r\n flex-direction: column;\r\n gap: 8px;\r\n pointer-events: none;\r\n width: min(90vw, 380px);\r\n}\r\n\r\n.toast {\r\n background-color: var(--cp-bg-toast, #333);\r\n color: var(--cp-text-toast, #fff);\r\n padding: 10px 14px;\r\n border-radius: var(--cp-radius-toast, 5px);\r\n border: 1px solid rgba(255, 255, 255, 0.15);\r\n opacity: 1;\r\n transform: translateY(0);\r\n transition: opacity 0.2s ease, transform 0.2s ease;\r\n box-shadow: 0 10px 28px rgba(0, 0, 0, 0.35);\r\n backdrop-filter: blur(2px);\r\n}\r\n\r\n.toast-title {\r\n font-weight: 700;\r\n font-size: 12px;\r\n margin-bottom: 2px;\r\n}\r\n\r\n.toast-body {\r\n font-size: 13px;\r\n line-height: 1.35;\r\n}\r\n\r\n.toast--success {\r\n border-color: #3a9d5d;\r\n background-color: #193524;\r\n}\r\n\r\n.toast--warning {\r\n border-color: #be8e2d;\r\n background-color: #3e2f12;\r\n}\r\n\r\n.toast--error {\r\n border-color: #b24646;\r\n background-color: #441d1d;\r\n}\r\n\r\n.toast--info {\r\n border-color: #4d84d3;\r\n background-color: #1a2b44;\r\n}\r\n\r\n.toast-enter {\r\n opacity: 0;\r\n transform: translateY(-10px);\r\n}\r\n\r\n.toast-show {\r\n opacity: 1;\r\n transform: translateY(0);\r\n}\r\n\r\n.toast-leave {\r\n opacity: 0;\r\n transform: translateY(-10px);\r\n}\r\n";
// src/ui/theme/tokens.css
var tokens_default = "/**\r\n * CheatPlus Shadow-safe Theme Tokens\r\n *\r\n * All custom properties are scoped to :host so they are self-contained inside\r\n * the Shadow DOM and never leak to or inherit from the host page.\r\n *\r\n * Naming convention: --cp-{category}-{variant}\r\n *\r\n * Categories:\r\n * color-* \u2013 palette tokens\r\n * bg-* \u2013 background colors\r\n * text-* \u2013 foreground / text colors\r\n * border-* \u2013 border colors\r\n * spacing-* \u2013 padding / gap constants\r\n * radius-* \u2013 border-radius\r\n * font-* \u2013 font stacks and sizes\r\n * transition-* \u2013 animation durations\r\n */\r\n\r\n:host {\r\n /* --- Palette --- */\r\n --cp-color-gold: #f0d46d;\r\n --cp-color-link: #66a7ff;\r\n --cp-color-danger: #e05a5a;\r\n --cp-color-overlay: rgba(0, 0, 0, 0.5);\r\n\r\n /* --- Backgrounds --- */\r\n --cp-bg-modal: #222;\r\n --cp-bg-navbar: #333;\r\n --cp-bg-button: #4b4b4b;\r\n --cp-bg-button-hover: #5a5a5a;\r\n --cp-bg-tooltip: #111;\r\n --cp-bg-toast: #333;\r\n\r\n /* --- Text --- */\r\n --cp-text-primary: #fff;\r\n --cp-text-muted: #c8c3bc; /* replaces host var(--500) \u2014 DoL body text approximation */\r\n --cp-text-tooltip: #f2f2f2;\r\n --cp-text-toast: #fff;\r\n\r\n /* --- Borders --- */\r\n --cp-border-modal: #888;\r\n --cp-border-button: #8a8a8a;\r\n --cp-border-tooltip: #444;\r\n\r\n /* --- Spacing --- */\r\n --cp-spacing-xs: 2px;\r\n --cp-spacing-sm: 5px;\r\n --cp-spacing-md: 10px;\r\n --cp-spacing-lg: 20px;\r\n --cp-spacing-content: 1rem;\r\n\r\n /* --- Border radius --- */\r\n --cp-radius-button: 2px;\r\n --cp-radius-tooltip: 4px;\r\n --cp-radius-toast: 5px;\r\n\r\n /* --- Typography --- */\r\n --cp-font-ui: system-ui, -apple-system, sans-serif;\r\n --cp-font-size-base: 13px;\r\n\r\n /* --- Transitions --- */\r\n --cp-transition-fade: opacity 0.3s ease-in-out;\r\n --cp-transition-collapse: height 0.35s ease;\r\n --cp-transition-float: top 0.5s ease-in-out;\r\n}\r\n";
// src/ui/index.js
registerSheet(tokens_default, { target: "shadow" });
registerSheet(base_default, { target: "shadow" });
registerSheet(floating_default, { target: "shadow" });
registerSheet(toast_default, { target: "shadow" });
registerSheet(modal_default, { target: "shadow" });
registerSheet(responsive_default, { target: "shadow" });
function bindOnce(element, flag, eventName, handler) {
if (!element || element[flag]) return;
element.addEventListener(eventName, handler);
element[flag] = true;
}
function shouldCloseModalFromTarget(target) {
if (!target?.id) return false;
if (target.id !== "modal") return false;
const modal2 = byUiId("modal");
if (!modal2) return true;
const content = modal2.querySelector(".modal-content");
return !(content && content.contains(target));
}
function mountInterface() {
if (!document.body) {
requestAnimationFrame(mountInterface);
return;
}
const root = ensureShadowRoot();
if (!root) {
logger_default("ui", "mountInterface: ensureShadowRoot returned null");
return;
}
if (byUiId("cheat")) return;
const styleApplied = safeCall("CSS injection failed:", () => {
applyToShadow(root);
return true;
});
if (!styleApplied) {
}
root.appendChild(renderTemplate(layoutTemplate));
refreshUiRefs();
initFloatingButtonDrag();
logger_default("ui", "mountInterface: mounted template", {
data: { modalContainer: !!byUiId("modal-content-container") }
});
safeCall("failed to bind fallback open handler", () => {
const btn = byUiId("cheat-open");
bindOnce(btn, "__cheatPlusBound", "click", () => {
safeCall("openModal failed:", () => openModal());
});
const btnSidebar = byUiId("cheat-sidebar");
bindOnce(btnSidebar, "__cheatPlusBoundSidebar", "click", () => {
safeCall("cheat-sidebar failed:", () => dispatch("cheat-sidebar"));
});
const histBack = byUiId("cheat-history-backwards");
bindOnce(histBack, "__cheatPlusBoundHistBack", "click", () => {
safeCall("history-back failed:", () => dispatch("cheat-history-backwards"));
});
const histFor = byUiId("cheat-history-forwards");
bindOnce(histFor, "__cheatPlusBoundHistFor", "click", () => {
safeCall("history-for failed:", () => dispatch("cheat-history-forwards"));
});
const rootEl = byUiId("cheat");
bindOnce(rootEl, "__cheatPlusCloseBound", "click", (event) => {
const target = event.target;
if (!shouldCloseModalFromTarget(target)) return;
safeCall("closeModal fallback failed:", () => closeModal());
});
});
}
// src/core/runtime-engine-sugarcube.js
function hasSugarCubeCorePrerequisites() {
const runtimeWindow2 = getRuntimeWindow();
return Boolean(runtimeWindow2?.SugarCube && scAdapter.isReady());
}
function hasSugarCubeRuntimePrerequisites() {
const setup = scAdapter.getSetup();
return Boolean(
hasSugarCubeCorePrerequisites() && Array.isArray(setup?.NPCNameList) && document.getElementById(GAME_VERSION_ELEMENT_ID)
);
}
function describeSugarCubePrerequisiteState() {
const runtimeWindow2 = getRuntimeWindow();
const sugarCube = runtimeWindow2?.SugarCube;
return {
sugarCubeDefined: Boolean(sugarCube),
sugarCubeState: Boolean(sugarCube?.State),
sugarCubeVariables: Boolean(sugarCube?.State?.variables),
sugarCubeSetup: Boolean(sugarCube?.setup),
npcList: Array.isArray(sugarCube?.setup?.NPCNameList),
versionElement: Boolean(document.getElementById(GAME_VERSION_ELEMENT_ID))
};
}
var sugarcubeRuntimeEngine = Object.freeze({
id: "sugarcube",
label: "SugarCube",
detect() {
return Boolean(getRuntimeWindow()?.SugarCube);
},
adapter: scAdapter,
observerPolicy: defaultRuntimeObserverPolicy,
hasCorePrerequisites: hasSugarCubeCorePrerequisites,
hasRuntimePrerequisites: hasSugarCubeRuntimePrerequisites,
describePrerequisiteState: describeSugarCubePrerequisiteState
});
// src/core/renpy-web/adapter.js
function getRenPyRoot() {
const runtimeWindow2 = getRuntimeWindow();
return runtimeWindow2?.RenPyWeb ?? null;
}
function getStore4() {
const root = getRenPyRoot();
return root?.store ?? null;
}
var renpyWebAdapter = {
getVariables: getStore4,
getVariable(key) {
const store2 = getStore4();
return store2 ? store2[key] : void 0;
},
setVariable(key, value) {
const store2 = getStore4();
if (store2) store2[key] = value;
},
getSetup() {
return getRenPyRoot()?.setup ?? null;
},
getSetupKey(key) {
const setup = getRenPyRoot()?.setup;
return setup ? setup[key] : void 0;
},
getCurrentPassage() {
return getRenPyRoot()?.passage ?? null;
},
isAtPassage(name) {
return this.getCurrentPassage() === name;
},
isReady() {
return Boolean(getStore4());
}
};
// src/core/runtime-engine-renpy-web.js
function hasRenPyWebCorePrerequisites() {
return renpyWebAdapter.isReady();
}
function hasRenPyWebRuntimePrerequisites() {
return hasRenPyWebCorePrerequisites();
}
function describeRenPyWebPrerequisiteState() {
const runtimeWindow2 = getRuntimeWindow();
const renpyWeb = runtimeWindow2?.RenPyWeb;
return {
renpyWebDefined: Boolean(renpyWeb),
storeDefined: Boolean(renpyWeb?.store),
setupDefined: Boolean(renpyWeb?.setup),
passageDefined: Boolean(renpyWeb?.passage)
};
}
var renpyWebRuntimeEngine = Object.freeze({
id: "renpy-web",
label: "RenPy-web",
detect() {
return Boolean(getRuntimeWindow()?.RenPyWeb);
},
adapter: renpyWebAdapter,
observerPolicy: defaultRuntimeObserverPolicy,
hasCorePrerequisites: hasRenPyWebCorePrerequisites,
hasRuntimePrerequisites: hasRenPyWebRuntimePrerequisites,
describePrerequisiteState: describeRenPyWebPrerequisiteState
});
// src/core/runtime-engine-registry.js
var runtimeEngines = [sugarcubeRuntimeEngine, renpyWebRuntimeEngine];
var activeRuntimeEngine = null;
function resolveRuntimeEngine() {
return runtimeEngines.find((engine) => {
try {
return engine.detect();
} catch (_) {
return false;
}
}) ?? null;
}
function ensureActiveRuntimeEngine() {
if (activeRuntimeEngine) return activeRuntimeEngine;
const resolved = resolveRuntimeEngine();
if (resolved) activeRuntimeEngine = resolved;
return activeRuntimeEngine;
}
// src/core/injection.js
var injectionState = {
started: false,
ready: false
};
function getInjectionState() {
return injectionState;
}
function getDetectedRuntimeEngine() {
return ensureActiveRuntimeEngine();
}
function waitForCondition(check, { intervalMs = 50, timeoutMs = 3e4 } = {}) {
return new Promise((resolve, reject) => {
if (check()) {
resolve();
return;
}
const startedAt = Date.now();
const timer = setInterval(() => {
if (check()) {
clearInterval(timer);
resolve();
return;
}
if (Date.now() - startedAt > timeoutMs) {
clearInterval(timer);
reject(new Error("Injection prerequisites timed out."));
}
}, intervalMs);
});
}
async function waitForRuntimeEngine() {
await waitForCondition(() => Boolean(getDetectedRuntimeEngine()), { timeoutMs: 3e4 });
const runtimeEngine = getDetectedRuntimeEngine();
if (!runtimeEngine) {
throw new Error("No supported runtime engine detected.");
}
return runtimeEngine;
}
async function waitForPrerequisites(runtimeEngine) {
await waitForCondition(() => runtimeEngine.hasRuntimePrerequisites(), { timeoutMs: 3e4 }).catch(
async () => {
console.warn(
`[CheatPlus] ${runtimeEngine.label} runtime prerequisites not met within 30s \u2014 dumping status and retrying.`
);
console.warn("[CheatPlus] status:", runtimeEngine.describePrerequisiteState());
await waitForCondition(() => runtimeEngine.hasRuntimePrerequisites(), {
timeoutMs: 6e4
}).catch(async () => {
await waitForCondition(() => runtimeEngine.hasCorePrerequisites(), { timeoutMs: 6e4 });
console.warn(`[CheatPlus] Continuing with core ${runtimeEngine.label} readiness only.`);
});
}
);
}
async function startCheatInjection() {
const state = getInjectionState();
if (state.started) return;
state.started = true;
try {
logger_default("injection", "startCheatInjection:before-mount", {
data: { bodyPresent: !!document.body }
});
await waitForCondition(() => Boolean(document.body), { timeoutMs: 2e4 });
mountInterface();
logger_default("injection", "mountInterface() called", {
data: { hostPresent: !!document.getElementById(SHADOW_HOST_ID) }
});
const runtimeEngine = await waitForRuntimeEngine();
logger_default("injection", "runtime-engine-detected", {
data: { runtimeEngine: runtimeEngine.id }
});
await waitForPrerequisites(runtimeEngine);
bootstrapCheat({ runtimeEngine });
logger_default("injection", "after-bootstrap", { data: { ready: true } });
state.ready = true;
} catch (error) {
state.started = false;
console.error("[CheatPlus] Injection failed:", error);
}
}
// src/main.js
startCheatInjection();
})();