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 2.0.2
// @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/*
// @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-03-18 13:37:39 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, options) {
if (!selectElement) return;
const previousValue = selectElement.value;
selectElement.replaceChildren();
options.forEach(({ value, label }) => {
const option = document.createElement("option");
option.value = String(value);
option.textContent = label;
selectElement.appendChild(option);
});
if (previousValue && options.some((option) => String(option.value) === previousValue)) {
selectElement.value = previousValue;
} else if (options.length > 0) {
selectElement.value = String(options[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);
}
function getToastSequence() {
return toastSequence;
}
var timedToast = (text, time, options) => setTimeout(() => showToast(text, options), 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, path) {
return path.split(".").reduce((cur, key) => cur != null ? cur[key] : void 0, obj);
}
function setByPath(obj, path, value) {
const keys = path.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(path) {
return getByPath(getStore().state, path);
}
function set(path, value) {
const store2 = getStore();
const oldValue = getByPath(store2.state, path);
if (oldValue === value) return;
setByPath(store2.state, path, value);
const callbacks = store2.subscribers.get(path);
if (callbacks) {
callbacks.forEach((cb) => {
try {
cb(value, oldValue, path);
} 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/ui/components/modal.js
function toggleModalByHotkey() {
if (get("modal.open")) closeModal();
else openModal();
}
function filterSectionRows(sectionEl, query2) {
if (!sectionEl) return;
const norm = String(query2 ?? "").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;
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;
function resetFrameState() {
frameExpected = 0;
frameProgress = 0;
frameFailures = 0;
}
function runEntriesSequentially(entries, { onProgress = null, onDone = null, daily = false } = {}) {
let index = 0;
function step() {
if (index >= entries.length) {
if (typeof onDone === "function") onDone();
logger_default(
"toggle:scheduler",
`${daily ? "Daily" : "Regular"} batch complete (${index} entries)`
);
return;
}
const [key, meta] = entries[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 onProgress === "function") onProgress(key);
requestAnimationFrame(step);
}
step();
}
var ToggleScheduler = {
register(id, fn, { daily = false, cooldownMs = DEFAULT_COOLDOWN_MS, maxFailures = DEFAULT_MAX_FAILURES } = {}) {
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 };
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 entries = Array.from(functionMap.entries());
logger_default("toggle:scheduler", `runAll: ${entries.length} regular toggles queued`);
runEntriesSequentially(entries, { onProgress, daily: false });
},
runDaily() {
const entries = Array.from(dailyMap.entries());
logger_default("toggle:scheduler", `runDaily: ${entries.length} daily toggles queued`);
runEntriesSequentially(entries, { 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;
logger_default(
"toggle:scheduler",
`Frame watchdog: progress ${frameProgress}/${frameExpected} (failures: ${frameFailures})`,
{
level: "warn"
}
);
if (typeof onFrameState === "function") {
onFrameState({ expected: frameExpected, progress: frameProgress, failures: frameFailures });
}
if (frameFailures > DEFAULT_MAX_FAILURES) {
logger_default(
"toggle:scheduler",
`Watchdog triggered: failures exceeded max (${frameFailures} > ${DEFAULT_MAX_FAILURES})`,
{
level: "warn"
}
);
this.restore({ onRestore: onWatchdogRestore });
}
return false;
}
const entries = Array.from(functionMap.entries());
if (!entries.length) {
resetFrameState();
if (typeof onFrameState === "function") {
onFrameState({ expected: 0, progress: 0, failures: 0 });
}
return false;
}
frameExpected = entries.length;
frameProgress = 0;
frameFailures = 0;
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;
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;
}
};
// 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(path) {
if (typeof path !== "string" || !path.trim()) return [];
const matches = path.match(/[^.[\]]+/g);
return matches ?? [];
}
function readAtPath(obj, path) {
const tokens = tokenizePath(path);
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 writeAtPath(obj, path, value) {
const tokens = tokenizePath(path);
if (!tokens.length || obj == null || typeof obj !== "object") return false;
let cursor = obj;
for (let i = 0; i < tokens.length - 1; i++) {
const token = tokens[i];
const nextToken = tokens[i + 1];
if (cursor[token] == null || typeof cursor[token] !== "object") {
cursor[token] = /^\d+$/.test(nextToken) ? [] : {};
}
cursor = cursor[token];
}
cursor[tokens[tokens.length - 1]] = value;
return true;
}
function getVariable(key) {
return getVars()?.[key];
}
function setVariable(key, value) {
const vars = getVars();
if (vars) vars[key] = value;
}
function getVariablePath(path) {
return readAtPath(getVars(), path);
}
function setVariablePath(path, value) {
return writeAtPath(getVars(), path, value);
}
function hasVariablePath(path) {
return getVariablePath(path) !== void 0;
}
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 isAtStart() {
return isAtPassage("Start");
}
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 isBrokenStringIndexedArray(value) {
return Array.isArray(value) && value.length === 0 && Object.keys(value).length > 0;
}
function walkValueTree(rootValue, rootPath, visitor) {
let stopped = false;
const stop = () => {
stopped = true;
};
function visit(value, path, parentIsArray = false, key = "") {
if (stopped) return;
visitor(value, path, { parentIsArray, key, stop });
if (stopped) return;
if (Array.isArray(value)) {
for (let index = 0; index < value.length; index++) {
visit(value[index], `${path}[${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], `${path}[${objectKey}]`, true, objectKey);
if (stopped) return;
}
return;
}
if (typeof value === "object" && value !== null) {
for (const childKey in value) {
visit(value[childKey], `${path}.${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, path, meta) => {
if (shouldMatchValue(value) && String(value).toLowerCase()[searchType](searchTerm) && value !== "") {
searchResult.value += `${path}=${value}
`;
}
if (!meta.parentIsArray && meta.key) {
checkObject(meta.key, value, path);
}
});
} 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(path) {
return get(`runtime.${path}`);
}
function setRuntime(path, value) {
set(`runtime.${path}`, 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
var convertStringIndexArrayToObject = (arr) => {
const obj = {};
for (const key in arr) {
if (typeof key === "string") {
obj[key] = arr[key];
}
}
return obj;
};
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 query = (selector) => document.querySelector(selector);
var debugActions = {
testAll: function(actionBag = debugActions) {
showToast("Testing all functions...");
executeFunctionsInObject(actionBag);
},
ArrayChecker: function() {
const textBoxId = byUiId("tmpText");
const vars = getVars();
textBoxId.value = "";
const textBox = query(".tmpText");
if (!textBox || !vars) return;
walkValueTree(vars, "SugarCube.State.variables", (value, path) => {
if (!isBrokenStringIndexedArray(value)) return;
textBox.value += `${path}=convertStringIndexArrayToObject(${path});`;
});
textBox.focus();
textBox.select();
try {
const successful = document.execCommand("copy");
showToast("Copying text command was " + (successful ? "successful" : "unsuccessful"));
} catch {
showToast("Oops, unable to copy");
}
},
stringJSSet: function() {
function textToJS(str, value2) {
const path = str.split(".");
let current = getRuntimeWindow();
for (let index = 0; index < path.length - 1; index++) {
current = current?.[path[index]];
if (!current) {
showToast("error");
return;
}
}
current[path[path.length - 1]] = value2;
showToast("Activated.");
}
const string = byUiId("stringJS").value;
const value = byUiId("stringValue").value;
textToJS(string, isNaN(parseFloat(value)) ? value : parseFloat(value));
},
convertStringIndexedArray: convertStringIndexArrayToObject
};
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, text, { hideWhenEmpty = false } = {}) {
const element = byUiId(id);
if (!element) return false;
const normalized = String(text ?? "");
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, options) {
const element = byUiId(id);
if (!element) return false;
replaceSelectOptions(element, options);
return true;
}
function setRangeOptions(id, length, { start = 0 } = {}) {
const count = Number.isFinite(length) ? Math.max(0, Number(length)) : 0;
const options = Array.from({ length: count }, (_, index) => {
const value = start + index;
return { value, label: String(value) };
});
return setOptions(id, options);
}
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, text) {
setText(id, text, { 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((entry) => entry.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_array_checker: () => update_array_checker,
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 update_array_checker() {
setText("auto_check_status", getCheatPlus()?.arrayCheck ? "found" : "not found");
}
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,
update_array_checker,
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 animals = ["pigs", "horses", "cattle", "dogs"];
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 options = Object.entries(creatures).filter(([, creature]) => creature != null).map(([key, creature]) => ({ value: key, label: creature.creature }));
setOptions("mc_tentacle_select", options);
});
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 }) => {
let totalFetus = 0;
for (const npc of getNPCName() ?? []) {
if (npc.description === selectedNpc.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 options = [];
let number = 1;
for (const key in storedNpcs) {
options.push({
value: key,
label: number + ". " + storedNpcs[key].pregnancy.fetus[0].mother
});
number++;
}
for (const key in getCheatPlus()?.storedNPCs ?? {}) {
options.push({
value: key,
label: number + ". " + getCheatPlus().storedNPCs[key].pregnancy.fetus[0].mother
});
number++;
}
setOptions("npc_abortion_chara_select", options);
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 options = Object.entries(pregnancy.fetus ?? {}).map(([key, fetus]) => ({
value: key,
label: fetus?.creature ?? key
}));
setOptions("mc_pregnancy_manager", options);
} 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,
crimecurrent,
vowcurrent,
update_cheat_state,
randomEncounterUpdate,
update_pregnancy,
update_toggle
];
var statsHydrators = [
statpick,
statpicke,
spraystate,
bodycurrent,
bodytypecurrent,
ballscurrent,
virginitycurrent,
characurrent,
lactatingcurrent,
milkcurrent,
cumcurrent,
famecurrent,
examcurrent,
update_school_rep,
talentcurrent
];
var miscHydrators = [
npccurrent,
update_pregnancy_day_named_npc,
update_pregnancy_day_npc,
update_pregnancy_list_mc,
update_pregnancy_day_mc,
update_mc_tentacle,
update_mc_baby_list,
update_mc_abortion_list,
update_named_npc_abortion_list,
update_npc_abortion_list,
update_npc_fetus_abortion_list,
update_farm_assault_day,
update_farm_buildtime,
update_farm_animals_like,
update_array_checker
];
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);
}
function hydrateStatsSection() {
runHydrators(statsHydrators);
}
function hydrateMiscSection() {
runHydrators(miscHydrators);
}
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 {
moneymanager() {
const input = parseInt(byUiId("moneyinput").value);
if (isNaN(input)) {
showToast("failed : input is not a number!");
return;
}
showToast("Activated!");
getVars().money = input;
},
bodymanager() {
const bodypick = byUiId("bodypick")?.value;
const bodySizes = { Tiny: 0, Small: 1, Normal: 2, Large: 3 };
if (bodypick in bodySizes) {
getVars().bodysize = bodySizes[bodypick];
showToast("Activated!");
hydrateCheatUi.bodycurrent();
} else {
showToast("Failed!");
}
},
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 options = virginitypick.getElementsByTagName("option");
for (let index = 0; index < options.length; index++) {
getVars().player.virginity[options[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 ? "2.0.2" : "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/sugarcube/cheat-config.js
function cfg() {
return getVars()?.cheatPlus ?? null;
}
function initCheatConfig() {
const vars = getVars();
if (!vars) return;
vars.cheatPlus ??= {};
const c = vars.cheatPlus;
c.angel ??= 0;
c.angelMode ??= true;
c.toggles ??= {};
c.storedNPCs ??= {};
c.storedNPCsDate ??= 0;
c.trueDivine ??= "";
c.orgasmCount ??= 0;
c.baseNpcPregnancyChance ??= vars.baseNpcPregnancyChance;
c.unlicumMode ??= false;
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 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;
}
function setArrayCheck(value) {
const c = cfg();
if (c) c.arrayCheck = value;
}
// src/constants/runtime.js
var SECONDS_PER_DAY = 86400;
// src/services/storage.js
function initStorage() {
initCheatConfig();
}
function reactivateToggles() {
setReactivatingToggles(true);
deactiveAllToggles();
const toggles = getToggles();
for (const key in toggles) {
if (isRegistered(key)) {
dispatch(key);
} else {
delete toggles[key];
}
}
setReactivatingToggles(false);
}
function deactiveAllToggles() {
const bundles = ToggleScheduler.getBundles();
const allFunctions = {
...bundles.functionbundle,
...bundles.dailyfunctionbundle
};
for (const key in allFunctions) {
if (typeof allFunctions[key] === "function" && isRegistered(key)) {
dispatch(key);
}
}
}
// src/core/toggle/state-repository.js
var toggleState = {
toggleActive: {},
toggleActiveDaily: {},
toggleDeactivated: false,
checkArrayThreshold: 0,
initNPCinstapreg: false,
tmpArousal: 0,
orgasmdown: 0
};
function clearActiveToggles() {
for (const key in toggleState.toggleActive) {
delete toggleState.toggleActive[key];
}
}
var state_repository_default = toggleState;
// 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 });
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 });
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(entries, keyGetter, bucketName) {
const seen = /* @__PURE__ */ new Set();
entries.forEach((entry, index) => {
const key = keyGetter(entry);
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(entries, bucketName) {
if (!Array.isArray(entries)) {
throw new Error(`[action-map-schema] ${bucketName} must be an array`);
}
entries.forEach((entry, index) => {
if (!entry || typeof entry !== "object") {
throw new Error(`[action-map-schema] ${bucketName}[${index}] must be an object`);
}
assertNonEmptyString(entry.id, "id", index, bucketName);
assertNonEmptyString(entry.label, "label", index, bucketName);
if (entry.trigger != null && entry.trigger !== "frame" && entry.trigger !== "daily") {
throw new Error(
`[action-map-schema] ${bucketName}[${index}].trigger must be "frame" or "daily"`
);
}
if (entry.cooldownMs != null && (!Number.isFinite(entry.cooldownMs) || entry.cooldownMs < 0)) {
throw new Error(
`[action-map-schema] ${bucketName}[${index}].cooldownMs must be a non-negative number`
);
}
if (entry.maxFailures != null && (!Number.isInteger(entry.maxFailures) || entry.maxFailures < 1)) {
throw new Error(
`[action-map-schema] ${bucketName}[${index}].maxFailures must be an integer >= 1`
);
}
if (entry.runOnActivate != null && typeof entry.runOnActivate !== "boolean") {
throw new Error(`[action-map-schema] ${bucketName}[${index}].runOnActivate must be boolean`);
}
});
assertUniqueKeys(entries, (entry) => entry.id, bucketName);
}
function validateMethodEntries(entries, bucketName) {
if (!Array.isArray(entries)) {
throw new Error(`[action-map-schema] ${bucketName} must be an array`);
}
entries.forEach((entry, index) => {
if (!entry || typeof entry !== "object") {
throw new Error(`[action-map-schema] ${bucketName}[${index}] must be an object`);
}
assertNonEmptyString(entry.actionKey, "actionKey", index, bucketName);
if (entry.methodName != null) {
assertNonEmptyString(entry.methodName, "methodName", index, bucketName);
}
});
assertUniqueKeys(entries, (entry) => entry.actionKey, bucketName);
}
function validateNavEntries(entries, bucketName) {
if (!Array.isArray(entries)) {
throw new Error(`[action-map-schema] ${bucketName} must be an array`);
}
entries.forEach((entry, index) => {
if (!entry || typeof entry !== "object") {
throw new Error(`[action-map-schema] ${bucketName}[${index}] must be an object`);
}
assertNonEmptyString(entry.actionKey, "actionKey", index, bucketName);
assertNonEmptyString(entry.navKey, "navKey", index, bucketName);
assertNonEmptyString(entry.contentKey, "contentKey", index, bucketName);
assertNonEmptyString(entry.hydrateKey, "hydrateKey", index, bucketName);
});
assertUniqueKeys(entries, (entry) => entry.actionKey, bucketName);
}
function validateSimpleUiEntries(entries, bucketName) {
if (!Array.isArray(entries)) {
throw new Error(`[action-map-schema] ${bucketName} must be an array`);
}
entries.forEach((entry, index) => {
if (!entry || typeof entry !== "object") {
throw new Error(`[action-map-schema] ${bucketName}[${index}] must be an object`);
}
assertNonEmptyString(entry.actionKey, "actionKey", index, bucketName);
assertNonEmptyString(entry.target, "target", index, bucketName);
if (entry.arg != null) {
assertNonEmptyString(entry.arg, "arg", index, bucketName);
}
});
assertUniqueKeys(entries, (entry) => entry.actionKey, bucketName);
}
function validateBoundEntries(entries, bucketName) {
if (!Array.isArray(entries)) {
throw new Error(`[action-map-schema] ${bucketName} must be an array`);
}
entries.forEach((entry, index) => {
if (!entry || typeof entry !== "object") {
throw new Error(`[action-map-schema] ${bucketName}[${index}] must be an object`);
}
assertNonEmptyString(entry.actionKey, "actionKey", index, bucketName);
assertNonEmptyString(entry.source, "source", index, bucketName);
assertNonEmptyString(entry.method, "method", index, bucketName);
});
assertUniqueKeys(entries, (entry) => entry.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: "checkArray", label: "Scan", trigger: "frame", cooldownMs: 400 },
{ 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((entry) => entry.trigger === "daily");
var TOGGLE_ACTIONS = TOGGLE_DEFINITIONS.filter((entry) => entry.trigger !== "daily");
validateToggleEntries(TOGGLE_DEFINITIONS, "TOGGLE_DEFINITIONS");
// src/features/cheat/toggle-domain-basic-actions.js
function createToggleDomainBasicActions(toggleState2) {
return {
everyone_horny() {
const vars = getVars();
if (vars.NPCName === void 0) return;
const npcnamelist2 = getNpcNameList();
for (let index = 0; index < npcnamelist2.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;
},
checkArray() {
const vars = getVars();
toggleState2.checkArrayThreshold += 1;
if (toggleState2.checkArrayThreshold <= 10) return;
toggleState2.checkArrayThreshold = 0;
setArrayCheck(false);
walkValueTree(vars, "SugarCube.State.variables", (value, _path, controls) => {
if (!isBrokenStringIndexedArray(value)) return;
setArrayCheck(true);
showToast("Broken array has been found!");
controls.stop();
});
},
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 (getStoredNPCsDate()) return;
let priorityQueue = 0;
let waitQueue = 0;
const limit = 8;
const activeNpcStore = {};
const waitingNpcStore = {};
let dateLeft = 0;
const gameTime = vars.timeStamp;
const date = (gameTime - gameTime % SECONDS_PER_DAY) / SECONDS_PER_DAY;
if (getStoredNPCsDate() !== 0) {
dateLeft = (date - getStoredNPCsDate()) * 3;
}
setStoredNPCsDate(date);
for (const key in vars.storedNPCs) {
const left = vars.storedNPCs[key].pregnancy.timerEnd - vars.storedNPCs[key].pregnancy.timer;
if (left <= 3 && priorityQueue <= limit) {
activeNpcStore["stored_" + priorityQueue] = vars.storedNPCs[key];
if (priorityQueue === 8) {
showToast("NPC about to give abirth, you cant bustin nuts in people for today!");
}
priorityQueue++;
} else {
waitingNpcStore["stored_" + waitQueue] = vars.storedNPCs[key];
waitQueue++;
}
}
const storedCheatNPCs = getStoredCheatNPCs();
for (const key in storedCheatNPCs) {
const timerEnd = storedCheatNPCs[key].pregnancy.timerEnd;
const timer = storedCheatNPCs[key].pregnancy.timer;
if (dateLeft > 0) {
storedCheatNPCs[key].pregnancy.timer += dateLeft;
if (storedCheatNPCs[key].pregnancy.timer > timerEnd) {
storedCheatNPCs[key].pregnancy.timer = timerEnd;
}
}
const left = timerEnd - timer;
if (left <= 3 && priorityQueue <= limit) {
activeNpcStore["stored_" + priorityQueue] = storedCheatNPCs[key];
if (priorityQueue === 8) {
showToast("NPC about to give abirth, you cant bustin nuts in people for today!");
}
priorityQueue++;
} else {
waitingNpcStore["stored_" + waitQueue] = storedCheatNPCs[key];
waitQueue++;
}
}
vars.storedNPCs = activeNpcStore;
setStoredCheatNPCs(waitingNpcStore);
},
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((entry) => [entry.id, entry]));
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,
toggleKey,
toggleHandler,
resolvePregnancy
}) {
if (!selectElement || isNaN(input)) return;
const index = locked.findIndex((name) => name == selectElement);
if (toggle && index === -1) {
locked.push(selectElement);
lockedDays.push(input);
updateToggleBundle(toggleKey, true, toggleHandler);
} else if (!toggle && index !== -1) {
locked.splice(index, 1);
lockedDays.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 max_Ferocity() {
setVariable("wolfpackferocity", 22);
showToast("Activated!");
}
function max_harmony() {
setVariable("wolfpackharmony", 22);
showToast("Activated!");
}
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,
max_Ferocity,
max_harmony,
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/ui/metadata/schema.js
var CONTROL_TYPES = Object.freeze({
BUTTON: "button",
TOGGLE: "toggle",
SELECT: "select",
RANGE: "range",
TEXT: "text",
INPUT: "input",
HEADER: "header",
BREAK: "break",
LINK: "link",
TOOLTIP: "tooltip",
GROUP: "group"
});
var VALID_TYPES = new Set(Object.values(CONTROL_TYPES));
var SCHEMA_REQUIRED = ["type"];
function validateControl(meta) {
const errors = [];
if (!meta || typeof meta !== "object") {
return { valid: false, errors: ["Control must be a plain object."] };
}
for (const key of SCHEMA_REQUIRED) {
if (meta[key] == null || meta[key] === "") {
errors.push(`Missing required field: "${key}".`);
}
}
if (meta.type != null && !VALID_TYPES.has(meta.type)) {
errors.push(`Unknown type "${meta.type}". Valid types: ${[...VALID_TYPES].join(", ")}.`);
}
if (meta.id != null && typeof meta.id !== "string") {
errors.push(`"id" must be a string.`);
}
if (meta.id === "") {
errors.push(`"id" cannot be an empty string.`);
}
if (meta.label != null && typeof meta.label !== "string") {
errors.push(`"label" must be a string.`);
}
if (meta.action != null && typeof meta.action !== "string") {
errors.push(`"action" must be a string command key.`);
}
if (meta.event != null && typeof meta.event !== "string") {
errors.push(`"event" must be a string DOM event name.`);
}
if (meta.feedback != null) {
const isObject = typeof meta.feedback === "object" && !Array.isArray(meta.feedback);
if (!isObject) {
errors.push(`"feedback" must be an object.`);
} else {
["success", "fail", "enabled", "disabled", "title", "variant"].forEach((key) => {
if (meta.feedback[key] != null && typeof meta.feedback[key] !== "string") {
errors.push(`"feedback.${key}" must be a string.`);
}
});
if (meta.feedback.variant != null && !["info", "success", "warning", "error"].includes(meta.feedback.variant)) {
errors.push(`"feedback.variant" must be one of: info, success, warning, error.`);
}
}
}
if (meta.bindings != null && !Array.isArray(meta.bindings)) {
errors.push(`"bindings" must be an array.`);
}
if (meta.optionsSource != null && typeof meta.optionsSource !== "function") {
errors.push(`"optionsSource" must be a function.`);
}
if (meta.binding != null) {
const isString = typeof meta.binding === "string";
const isObject = typeof meta.binding === "object" && !Array.isArray(meta.binding);
if (!isString && !isObject) {
errors.push(`"binding" must be a string path or object descriptor.`);
}
if (isObject) {
if (typeof meta.binding.path !== "string" || !meta.binding.path.trim()) {
errors.push(`"binding.path" must be a non-empty string.`);
}
if (meta.binding.onMissing != null && !["disable", "hide", "mark-section-broken"].includes(meta.binding.onMissing)) {
errors.push(`"binding.onMissing" must be one of: disable, hide, mark-section-broken.`);
}
if (meta.binding.coerce != null && !["string", "number", "boolean", "raw"].includes(meta.binding.coerce)) {
errors.push(`"binding.coerce" must be one of: string, number, boolean, raw.`);
}
}
}
if (meta.onMissing != null && !["disable", "hide", "mark-section-broken"].includes(meta.onMissing)) {
errors.push(`"onMissing" must be one of: disable, hide, mark-section-broken.`);
}
if (meta.requiredBinding != null && typeof meta.requiredBinding !== "boolean") {
errors.push(`"requiredBinding" must be a boolean.`);
}
if (meta.visibility != null && typeof meta.visibility !== "function" && typeof meta.visibility !== "boolean") {
errors.push(`"visibility" must be a boolean or function.`);
}
if (meta.type === CONTROL_TYPES.GROUP) {
if (!Array.isArray(meta.children) || meta.children.length === 0) {
errors.push(`GROUP type requires a non-empty "children" array.`);
}
}
return { valid: errors.length === 0, errors };
}
function validateRegistry(controls, registryName = "unknown") {
if (!Array.isArray(controls)) {
console.warn(`[CheatPlus][schema] Registry "${registryName}" is not an array.`);
return false;
}
let allValid = true;
controls.forEach((meta, idx) => {
const { valid, errors } = validateControl(meta);
if (!valid) {
allValid = false;
console.warn(
`[CheatPlus][schema] Invalid control at ${registryName}[${idx}] (id="${meta?.id}"):`,
errors
);
}
});
return allValid;
}
// src/services/ui-sync-scheduler.js
var intervalByContainer = /* @__PURE__ */ new WeakMap();
function startUiSync(container, tick, intervalMs = 400) {
if (!container || typeof tick !== "function") return null;
stopUiSync(container);
const timerId = setInterval(() => {
tick();
}, intervalMs);
intervalByContainer.set(container, timerId);
return timerId;
}
function stopUiSync(container) {
if (!container) return;
const timerId = intervalByContainer.get(container);
if (timerId == null) return;
clearInterval(timerId);
intervalByContainer.delete(container);
}
// src/ui/renderers/metadata-primitives.js
function normalizeSelectOption(option) {
if (typeof option === "string") {
return { value: option, label: option };
}
if (option && typeof option === "object") {
return {
value: String(option.value ?? ""),
label: option.label == null ? String(option.value ?? "") : String(option.label)
};
}
return { value: "", label: "" };
}
function getSelectOptions(meta) {
if (typeof meta?.optionsSource === "function") {
try {
const options = meta.optionsSource();
return Array.isArray(options) ? options.map(normalizeSelectOption) : [];
} catch (error) {
console.warn(`[CheatPlus][renderer] optionsSource failed for "${meta?.id}":`, error);
return [];
}
}
if (Array.isArray(meta?.bindings)) {
return meta.bindings.map(normalizeSelectOption);
}
return [];
}
function syncSelectOptions(selectEl, meta) {
if (!(selectEl instanceof HTMLSelectElement)) return { changed: false, selectionChanged: false };
const options = getSelectOptions(meta);
const signature = JSON.stringify(options);
const previousSignature = selectEl.dataset.cpOptionsSignature ?? "";
const previousValue = selectEl.value;
if (signature === previousSignature) {
return { changed: false, selectionChanged: false };
}
selectEl.replaceChildren();
options.forEach((opt) => {
const optionEl = document.createElement("option");
optionEl.value = opt.value;
optionEl.textContent = opt.label;
selectEl.appendChild(optionEl);
});
selectEl.dataset.cpOptionsSignature = signature;
let nextValue = "";
if (previousValue && options.some((opt) => opt.value === previousValue)) {
nextValue = previousValue;
} else if (options.length > 0) {
nextValue = options[0].value;
}
selectEl.value = nextValue;
return {
changed: true,
selectionChanged: previousValue !== nextValue
};
}
function renderButton(meta) {
const btn = document.createElement("button");
btn.type = "button";
if (meta.id) btn.id = meta.id;
btn.className = "modal-button";
btn.textContent = meta.label ?? "";
if (meta.hiddenWhenEmpty && !(meta.label || "").trim()) btn.style.display = "none";
return btn;
}
function renderToggle(meta) {
const label = document.createElement("label");
label.className = "modal-toggle";
const checkbox = document.createElement("input");
checkbox.type = "checkbox";
if (meta.id) checkbox.id = meta.id;
const labelSpan = document.createElement("span");
labelSpan.className = "toggle-label";
labelSpan.textContent = String(meta.label ?? "");
label.appendChild(checkbox);
label.appendChild(labelSpan);
return label;
}
function renderSelect(meta) {
const select = document.createElement("select");
if (meta.id) select.id = meta.id;
syncSelectOptions(select, meta);
return select;
}
function renderRange(meta) {
const input = document.createElement("input");
input.type = "range";
if (meta.id) input.id = meta.id;
input.min = String(meta.min ?? 0);
input.max = String(meta.max ?? 100);
input.value = String(meta.value ?? 0);
return input;
}
function renderInput(meta) {
const input = document.createElement("input");
input.type = "text";
input.className = "modal-content-width";
if (meta.id) input.id = meta.id;
input.autocomplete = "off";
if (meta.placeholder) input.placeholder = meta.placeholder;
return input;
}
function renderText(meta) {
const span = document.createElement("span");
span.className = "modal-text";
if (meta.id) span.id = meta.id;
span.textContent = meta.label ?? "";
if (meta.hiddenWhenEmpty && !(meta.label || "").trim()) span.style.display = "none";
return span;
}
function renderHeader(meta) {
const span = document.createElement("span");
span.className = "gold";
if (meta.id) span.id = meta.id;
span.textContent = meta.label ?? "";
return span;
}
function renderBreak() {
return document.createElement("br");
}
function renderLink(meta) {
const anchor = document.createElement("a");
if (meta.id) anchor.id = meta.id;
anchor.href = meta.href ?? "#";
anchor.target = "_blank";
anchor.className = "modal-link";
anchor.textContent = meta.label ?? "";
return anchor;
}
function renderTooltip(meta) {
const span = document.createElement("span");
span.className = "tooltip-small linkBlue";
if (meta.id) span.id = meta.id;
const trigger = meta.label ?? "(?)";
const tip = meta.tooltip ?? "";
span.innerHTML = `${trigger}<span>${tip}</span>`;
return span;
}
function renderControl(meta) {
switch (meta.type) {
case CONTROL_TYPES.BUTTON:
return renderButton(meta);
case CONTROL_TYPES.TOGGLE:
return renderToggle(meta);
case CONTROL_TYPES.SELECT:
return renderSelect(meta);
case CONTROL_TYPES.RANGE:
return renderRange(meta);
case CONTROL_TYPES.INPUT:
return renderInput(meta);
case CONTROL_TYPES.TEXT:
return renderText(meta);
case CONTROL_TYPES.HEADER:
return renderHeader(meta);
case CONTROL_TYPES.BREAK:
return renderBreak();
case CONTROL_TYPES.LINK:
return renderLink(meta);
case CONTROL_TYPES.TOOLTIP:
return renderTooltip(meta);
case CONTROL_TYPES.GROUP:
return document.createDocumentFragment();
default:
console.warn(`[CheatPlus][renderer] Unknown control type: "${meta.type}" (id="${meta.id}")`);
return document.createDocumentFragment();
}
}
function renderRow() {
const div = document.createElement("div");
div.className = "modal-content-padding";
return div;
}
// src/ui/renderers/metadata-renderer-missing-policy.js
var BROKEN_CLASS = "cp-section-broken";
var BROKEN_BANNER_CLASS = "cp-section-broken-banner";
function markSectionBroken(container, message) {
if (!container) return;
container.classList.add(BROKEN_CLASS);
let banner = container.querySelector(`.${BROKEN_BANNER_CLASS}`);
if (!banner) {
banner = document.createElement("div");
banner.className = BROKEN_BANNER_CLASS;
container.prepend(banner);
}
banner.textContent = message;
}
function clearSectionBroken(container) {
if (!container) return;
container.classList.remove(BROKEN_CLASS);
const banner = container.querySelector(`.${BROKEN_BANNER_CLASS}`);
if (banner) banner.remove();
}
function applyMissingPolicy(container, rowNode, controlEl, meta, path, getBindingPolicy2) {
const policy = getBindingPolicy2(meta);
if (policy === "hide") {
if (rowNode) rowNode.style.display = "none";
return;
}
if (policy === "disable") {
if (controlEl) controlEl.disabled = true;
return;
}
if (controlEl) controlEl.disabled = true;
markSectionBroken(container, `Cheat unavailable: missing variable "${path}".`);
}
// src/core/events/tracing.js
var traceSeq = 0;
function nextSeq() {
traceSeq += 1;
return traceSeq;
}
function traceEvent(type, key) {
logger_default("events", `[${type}] \u2192 "${key}" (#${nextSeq()})`);
}
// src/config/action-policy.js
var START_MENU_ACTION_ALLOWLIST = /* @__PURE__ */ new Set(["save_data", "load_data", "VrelCoinsUsage"]);
var DESTRUCTIVE_ACTIONS = /* @__PURE__ */ new Set([
"mc_abortion_set",
"named_npc_abortion_set",
"npc_abortion_set",
"npc_abortion_purge",
"purgeNPCPregnancy",
"purgeNPCBaby"
]);
var DESTRUCTIVE_ACTION_CONFIRMATION_MESSAGE = "This action is destructive and cannot be undone. Continue?";
// src/ui/helpers/action-dispatch.js
function dispatchUiAction(actionKey) {
if (!actionKey) return true;
if (!isRegistered(actionKey)) {
showToast(`Action "${actionKey}" is not registered.`, {
variant: "warning",
title: "Action Missing"
});
return false;
}
if (isAtStart() && !START_MENU_ACTION_ALLOWLIST.has(actionKey)) {
showToast("Still in the main menu!", { variant: "warning", title: "Blocked" });
return false;
}
if (DESTRUCTIVE_ACTIONS.has(actionKey)) {
const runtimeWindow2 = getRuntimeWindow();
const ok = runtimeWindow2?.confirm ? runtimeWindow2.confirm(DESTRUCTIVE_ACTION_CONFIRMATION_MESSAGE) : true;
if (!ok) return false;
}
traceEvent("render", actionKey);
dispatch(actionKey);
return true;
}
// src/ui/metadata/feedback-utils.js
function getMetaTooltipText(meta) {
if (!meta || typeof meta !== "object") return "";
if (typeof meta.tooltip === "string" && meta.tooltip.trim()) return meta.tooltip.trim();
const feedbackBits = [];
if (meta?.feedback?.enabled) feedbackBits.push(`On: ${meta.feedback.enabled}`);
if (meta?.feedback?.disabled) feedbackBits.push(`Off: ${meta.feedback.disabled}`);
if (meta?.feedback?.success) feedbackBits.push(meta.feedback.success);
if (feedbackBits.length) return feedbackBits.join(" | ");
if (meta.action) return `Action: ${meta.action}`;
return "";
}
function getControlFeedbackToast(meta, controlEl, actionOk, runtime = {}) {
const fb = meta?.feedback;
if (!fb) return null;
if (runtime.actionEmittedToast) return null;
if (runtime.eventType === "input") return null;
if (!actionOk && fb.fail) {
return {
message: fb.fail,
options: { variant: "error", title: fb.title || "Action Failed" }
};
}
if (meta.type === CONTROL_TYPES.TOGGLE) {
const enabled = Boolean(controlEl?.checked);
if (enabled && fb.enabled) {
return {
message: fb.enabled,
options: { variant: fb.variant || "success", title: fb.title }
};
}
if (!enabled && fb.disabled) {
return {
message: fb.disabled,
options: { variant: fb.variant || "info", title: fb.title }
};
}
}
if (fb.success) {
return {
message: fb.success,
options: { variant: fb.variant || "success", title: fb.title }
};
}
return null;
}
// src/ui/renderers/metadata-renderer-event-wiring.js
function dispatchAction(actionKey) {
return dispatchUiAction(actionKey);
}
function showControlFeedback(meta, controlEl, actionOk, runtime = {}) {
const toastPayload = getControlFeedbackToast(meta, controlEl, actionOk, runtime);
if (!toastPayload) return;
showToast(toastPayload.message, toastPayload.options);
}
function applyMetaTooltip(controlNode, controlEl, rowNode, meta) {
const tooltip = getMetaTooltipText(meta);
if (!tooltip) return;
if (controlEl) controlEl.title = tooltip;
if (controlNode instanceof HTMLElement) controlNode.title = tooltip;
if (rowNode instanceof HTMLElement && !rowNode.title) rowNode.title = tooltip;
}
function bindControlRuntimeEvent({
controlEl,
meta,
eventType,
path,
hintEl,
cleanupList,
syncNow,
readControlValue: readControlValue2,
coerceValue: coerceValue2,
getBindingCoerce: getBindingCoerce2,
setVariablePath: setVariablePath2,
updateBoundValueHint: updateBoundValueHint2,
updateToggleActiveClass: updateToggleActiveClass2
}) {
if (!eventType || !controlEl) return;
const handler = () => {
if (path) {
const raw = readControlValue2(controlEl, meta);
const coerced = coerceValue2(raw, getBindingCoerce2(meta));
setVariablePath2(path, coerced);
updateBoundValueHint2(hintEl, coerced);
}
updateToggleActiveClass2(controlEl, meta);
const toastSequenceBeforeAction = getToastSequence();
const actionOk = meta.action ? dispatchAction(meta.action) : true;
showControlFeedback(meta, controlEl, actionOk, {
actionEmittedToast: getToastSequence() > toastSequenceBeforeAction,
eventType
});
syncNow?.();
};
controlEl.addEventListener(eventType, handler);
cleanupList.push(() => controlEl.removeEventListener(eventType, handler));
}
// src/ui/renderers/metadata-renderer-runtime-binding.js
var DEFAULT_EVENT_BY_TYPE = {
[CONTROL_TYPES.BUTTON]: "click",
[CONTROL_TYPES.TOGGLE]: "change",
[CONTROL_TYPES.SELECT]: "change",
[CONTROL_TYPES.RANGE]: "input",
[CONTROL_TYPES.INPUT]: "input"
};
function normalizeBinding(meta) {
if (!meta?.binding) return null;
if (typeof meta.binding === "string") return { path: meta.binding };
if (typeof meta.binding === "object") return meta.binding;
return null;
}
function getBindingPath(meta) {
return normalizeBinding(meta)?.path ?? null;
}
function getBindingPolicy(meta) {
return normalizeBinding(meta)?.onMissing ?? meta?.onMissing ?? "mark-section-broken";
}
function getBindingCoerce(meta) {
return normalizeBinding(meta)?.coerce ?? meta?.coerce ?? "raw";
}
function getBindingDefault(meta) {
if (meta?.defaultValue !== void 0) return meta.defaultValue;
const binding = normalizeBinding(meta);
if (binding && Object.prototype.hasOwnProperty.call(binding, "defaultValue")) {
return binding.defaultValue;
}
return void 0;
}
function isBindingRequired(meta) {
if (meta?.requiredBinding != null) return Boolean(meta.requiredBinding);
const binding = normalizeBinding(meta);
if (binding?.required != null) return Boolean(binding.required);
return false;
}
function getControlElement(node, meta) {
if (!node) return null;
if (meta.type === CONTROL_TYPES.TOGGLE) {
return node.querySelector('input[type="checkbox"]');
}
if (node instanceof HTMLInputElement || node instanceof HTMLSelectElement || node instanceof HTMLButtonElement) {
return node;
}
return null;
}
function coerceValue(value, coerce) {
if (coerce === "string") return String(value ?? "");
if (coerce === "number") return Number(value ?? 0);
if (coerce === "boolean") return Boolean(value);
return value;
}
function readControlValue(el, meta) {
if (!el) return void 0;
if (meta.type === CONTROL_TYPES.TOGGLE) return Boolean(el.checked);
if (meta.type === CONTROL_TYPES.RANGE) return Number(el.value);
if (meta.type === CONTROL_TYPES.INPUT) return el.value;
if (meta.type === CONTROL_TYPES.SELECT) return el.value;
return void 0;
}
function applyControlValue(el, meta, value) {
if (!el) return;
if (meta.type === CONTROL_TYPES.TOGGLE) {
el.checked = Boolean(value);
return;
}
if (meta.type === CONTROL_TYPES.RANGE) {
const next = Number(value ?? 0);
if (!Number.isNaN(next)) el.value = String(next);
return;
}
if (meta.type === CONTROL_TYPES.INPUT || meta.type === CONTROL_TYPES.SELECT) {
el.value = value == null ? "" : String(value);
}
}
function updateToggleActiveClass(controlEl, meta) {
if (!controlEl || meta?.type !== CONTROL_TYPES.TOGGLE) return;
const wrapper = controlEl.closest(".modal-toggle");
if (!wrapper) return;
wrapper.classList.toggle("cp-toggle-active", Boolean(controlEl.checked));
}
function shouldShowBoundValue(meta) {
if (!meta) return false;
return meta.type === CONTROL_TYPES.INPUT || meta.type === CONTROL_TYPES.RANGE || meta.type === CONTROL_TYPES.SELECT || meta.type === CONTROL_TYPES.TOGGLE;
}
function formatBoundValue(value) {
if (value === null || value === void 0 || value === "") return "Current: -";
if (typeof value === "boolean") return `Current: ${value ? "On" : "Off"}`;
if (typeof value === "number") return `Current: ${Number.isFinite(value) ? value : "-"}`;
if (typeof value === "string") return `Current: ${value}`;
return "Current: [complex value]";
}
function ensureBoundValueHint(rowNode) {
if (!(rowNode instanceof HTMLElement)) return null;
let hint = rowNode.querySelector(".cp-bound-value");
if (hint) return hint;
hint = document.createElement("span");
hint.className = "cp-bound-value";
hint.setAttribute("aria-live", "polite");
rowNode.appendChild(hint);
return hint;
}
function updateBoundValueHint(hintEl, value) {
if (!hintEl) return;
hintEl.textContent = formatBoundValue(value);
}
function setupControlRuntime(container, rowNode, controlNode, meta, cleanupList, bindingRefs, syncNow) {
const controlEl = getControlElement(controlNode, meta);
if (controlEl) controlEl.dataset.cpControl = "1";
applyMetaTooltip(controlNode, controlEl, rowNode, meta);
const hintEl = shouldShowBoundValue(meta) ? ensureBoundValueHint(rowNode) : null;
const path = getBindingPath(meta);
if (path && controlEl) {
let exists = hasVariablePath(path);
if (!exists) {
const fallback = getBindingDefault(meta);
if (fallback !== void 0) {
setVariablePath(path, fallback);
exists = true;
}
}
if (!exists && isBindingRequired(meta)) {
applyMissingPolicy(container, rowNode, controlEl, meta, path, getBindingPolicy);
} else {
const value = getVariablePath(path);
applyControlValue(controlEl, meta, value);
updateToggleActiveClass(controlEl, meta);
updateBoundValueHint(hintEl, value);
bindingRefs.push({ controlEl, meta, path, hintEl });
}
} else if (controlEl) {
updateToggleActiveClass(controlEl, meta);
}
const eventType = meta.event || DEFAULT_EVENT_BY_TYPE[meta.type];
bindControlRuntimeEvent({
controlEl,
meta,
eventType,
path,
hintEl,
cleanupList,
syncNow,
readControlValue,
coerceValue,
getBindingCoerce,
setVariablePath,
updateBoundValueHint,
updateToggleActiveClass
});
}
function syncBindingsOnce(container, bindingRefs, optionRefs, syncSelectOptions2) {
if (!document.contains(container)) return;
if (!isReady()) return;
optionRefs.forEach(({ controlEl, meta }) => {
if (!document.contains(controlEl) || document.activeElement === controlEl) return;
const result = syncSelectOptions2(controlEl, meta);
if (result.selectionChanged && meta.action) {
dispatchAction(meta.action);
}
});
bindingRefs.forEach(({ controlEl, meta, path, hintEl }) => {
if (!path || !document.contains(controlEl)) return;
if (document.activeElement === controlEl && meta.type === CONTROL_TYPES.INPUT) return;
const next = getVariablePath(path);
applyControlValue(controlEl, meta, next);
updateToggleActiveClass(controlEl, meta);
updateBoundValueHint(hintEl, next);
});
}
function startBindingSync(container, bindingRefs, optionRefs, options, syncSelectOptions2) {
const hasSyncTargets = bindingRefs.length > 0 || optionRefs.length > 0;
if (!hasSyncTargets) return null;
const liveSyncEnabled = options.liveSync === true || bindingRefs.some((ref) => ref?.meta?.liveSync === true) || optionRefs.some((ref) => ref?.meta?.liveSync === true);
if (!liveSyncEnabled) return null;
return startUiSync(
container,
() => syncBindingsOnce(container, bindingRefs, optionRefs, syncSelectOptions2)
);
}
// src/ui/renderers/metadata-renderer.js
var REGISTRY_STATE = /* @__PURE__ */ new WeakMap();
function teardownRegistry(container) {
const state = REGISTRY_STATE.get(container);
if (!state) return;
state.cleanup.forEach((fn) => {
try {
fn();
} catch (_) {
}
});
stopUiSync(container);
REGISTRY_STATE.delete(container);
}
function renderControlsPhase(controls, container, cleanup, bindingRefs, optionRefs, syncNow) {
controls.forEach((meta) => {
const visible = meta.visibility == null ? true : typeof meta.visibility === "function" ? meta.visibility() : Boolean(meta.visibility);
if (!visible) return;
if (meta.type === CONTROL_TYPES.GROUP) {
container.appendChild(renderGroup(meta, container, cleanup, bindingRefs, syncNow));
return;
}
const row = renderRow(meta);
const node = renderControl(meta);
row.appendChild(node);
container.appendChild(row);
setupControlRuntime(container, row, node, meta, cleanup, bindingRefs, syncNow);
const controlEl = getControlElement(node, meta);
if (meta.type === CONTROL_TYPES.SELECT && controlEl && typeof meta.optionsSource === "function") {
optionRefs.push({ controlEl, meta });
}
});
}
function renderGroup(meta, container, cleanupList, bindingRefs, syncNow) {
const div = document.createElement("div");
div.className = "modal-content-padding";
if (meta.id) div.id = meta.id;
const children = meta.children ?? [];
let appendedAny = false;
children.forEach((child) => {
const visible = child.visibility == null ? true : typeof child.visibility === "function" ? child.visibility() : Boolean(child.visibility);
if (!visible) return;
const emptyLabel = !(child.label || "").toString().trim();
const emptyTooltip = !(child.tooltip || "").toString().trim();
if (child.hiddenWhenEmpty && emptyLabel && emptyTooltip) return;
if (appendedAny) div.appendChild(document.createTextNode(" | "));
const node = renderControl(child);
div.appendChild(node);
setupControlRuntime(container, div, node, child, cleanupList, bindingRefs, syncNow);
appendedAny = true;
});
return div;
}
function renderRegistry(controls, container, options = {}) {
if (!container) {
console.warn("[CheatPlus][renderer] renderRegistry: container is null/undefined");
return;
}
teardownRegistry(container);
clearSectionBroken(container);
const cleanup = [];
const bindingRefs = [];
const optionRefs = [];
const syncNow = () => syncBindingsOnce(container, bindingRefs, optionRefs, syncSelectOptions);
const requiredPaths = options.requiredPaths ?? [];
requiredPaths.forEach((path) => {
if (!hasVariablePath(path)) {
markSectionBroken(container, `Cheat unavailable: missing variable "${path}".`);
}
});
renderControlsPhase(controls, container, cleanup, bindingRefs, optionRefs, syncNow);
syncNow();
const timerId = startBindingSync(container, bindingRefs, optionRefs, options, syncSelectOptions);
REGISTRY_STATE.set(container, { cleanup, timerId });
}
// src/ui/metadata/factory.js
var TYPE_MAP = {
text: CONTROL_TYPES.TEXT,
header: CONTROL_TYPES.HEADER,
newline: CONTROL_TYPES.BREAK,
break: CONTROL_TYPES.BREAK,
button: CONTROL_TYPES.BUTTON,
range: CONTROL_TYPES.RANGE,
tooltip: CONTROL_TYPES.TOOLTIP,
link: CONTROL_TYPES.LINK,
input: CONTROL_TYPES.INPUT,
select: CONTROL_TYPES.SELECT,
checkbox: CONTROL_TYPES.TOGGLE,
toggle: CONTROL_TYPES.TOGGLE
};
function normalizeType(type) {
if (!type) return null;
const key = String(type).toLowerCase();
return TYPE_MAP[key] ?? type;
}
function normalizeBindingPath(path) {
if (typeof path !== "string") return path;
return path.replace(/^SugarCube\.(State|state)\.variables\./, "").replace(/^State\.variables\./, "").trim();
}
function isBindableType(type) {
return type === CONTROL_TYPES.INPUT || type === CONTROL_TYPES.RANGE || type === CONTROL_TYPES.SELECT || type === CONTROL_TYPES.TOGGLE;
}
function buildLegacyControl(kind, id, value, overrides = {}) {
const type = normalizeType(kind);
let control;
switch (type) {
case CONTROL_TYPES.TEXT:
control = { type, label: String(value ?? "") };
break;
case CONTROL_TYPES.HEADER:
control = { type, id, label: String(value ?? "") };
break;
case CONTROL_TYPES.BREAK:
control = { type };
break;
case CONTROL_TYPES.BUTTON:
control = { type, id, label: String(value ?? ""), action: id };
break;
case CONTROL_TYPES.RANGE:
control = {
type,
id,
max: Number(value ?? 100),
value: 0,
action: id
};
break;
case CONTROL_TYPES.TOOLTIP:
control = { type, id, label: "(?)", tooltip: String(value ?? "") };
break;
case CONTROL_TYPES.LINK:
control = { type, href: id, label: String(value ?? "") };
break;
case CONTROL_TYPES.INPUT:
control = {
type,
id,
placeholder: String(value ?? ""),
action: id
};
break;
case CONTROL_TYPES.SELECT:
control = {
type,
id,
bindings: value ?? [],
action: id
};
break;
case CONTROL_TYPES.TOGGLE:
control = {
type,
id,
label: String(value ?? ""),
action: id
};
break;
default:
control = { type: CONTROL_TYPES.TEXT, label: String(value ?? "") };
break;
}
if (id && !control.id) control.id = id;
if (value === "") {
control.hiddenWhenEmpty = true;
}
const override = id ? overrides[id] : null;
if (!override) return control;
const merged = { ...control, ...override };
if (merged.binding && typeof merged.binding === "object" && merged.binding.path) {
merged.binding = { ...merged.binding, path: normalizeBindingPath(merged.binding.path) };
}
return merged;
}
function createRowFromLegacyDef(rowDef, overrides = {}) {
const { ids = [], inputs = [], values = [] } = rowDef;
const children = inputs.map((kind, i) => buildLegacyControl(kind, ids[i], values[i], overrides));
return { type: CONTROL_TYPES.GROUP, children };
}
function createRowsFromLegacyDefs(rowDefs, overrides = {}) {
return rowDefs.map((row) => createRowFromLegacyDef(row, overrides));
}
function createControlFromInputDef(inputDef, rowDef, idx) {
const type = normalizeType(inputDef.type);
const control = {
type,
id: inputDef.id,
label: inputDef.text,
tooltip: inputDef.tooltip,
bindings: inputDef.options,
optionsSource: inputDef.optionsSource,
max: inputDef.max,
min: inputDef.min,
value: inputDef.value,
placeholder: inputDef.placeholder,
href: inputDef.href,
action: inputDef.action ?? inputDef.listener,
event: inputDef.event,
feedback: inputDef.feedback,
binding: inputDef.binding,
defaultValue: inputDef.defaultValue,
requiredBinding: inputDef.requiredBinding,
onMissing: inputDef.onMissing,
coerce: inputDef.coerce
};
if (isBindableType(type) && !control.binding && rowDef.bindingPath) {
control.binding = { path: normalizeBindingPath(rowDef.bindingPath) };
if (rowDef.requiredBinding != null) control.requiredBinding = rowDef.requiredBinding;
if (rowDef.onMissing) control.onMissing = rowDef.onMissing;
if (rowDef.coerce) control.coerce = rowDef.coerce;
if (rowDef.defaultValue !== void 0) control.defaultValue = rowDef.defaultValue;
}
if (!control.id && rowDef.key && type !== CONTROL_TYPES.TEXT && type !== CONTROL_TYPES.BREAK) {
control.id = `${rowDef.key}_${idx + 1}`;
}
if (control.binding && typeof control.binding === "object" && control.binding.path) {
control.binding = { ...control.binding, path: normalizeBindingPath(control.binding.path) };
}
Object.keys(control).forEach((k) => {
if (control[k] == null) delete control[k];
});
return control;
}
function createRowFromSettingDef(rowDef) {
const children = [];
if (rowDef.text) {
children.push({ type: CONTROL_TYPES.TEXT, label: rowDef.text });
}
(rowDef.inputs ?? []).forEach((inputDef, idx) => {
children.push(createControlFromInputDef(inputDef, rowDef, idx));
});
if (rowDef.tooltip) {
children.push({
type: CONTROL_TYPES.TOOLTIP,
id: rowDef.tooltipId,
label: "(?)",
tooltip: rowDef.tooltip
});
}
return {
type: CONTROL_TYPES.GROUP,
id: rowDef.key,
children
};
}
function createRowsFromSettingDefs(rowDefs) {
return rowDefs.map((rowDef) => createRowFromSettingDef(rowDef));
}
// src/ui/metadata/feedback-presets.js
function toggleFeedback(label = "Toggle") {
return {
title: label,
enabled: "Activated",
disabled: "Deactivated",
variant: "info"
};
}
function successFeedback(message, title) {
return {
success: message,
variant: "success",
title
};
}
// src/ui/metadata/quick/index.js
var CONTROL_OVERRIDES = {};
var QUICK_SETTING_DEFS = [
{
key: "quick_arousal",
text: "Arousal",
inputs: [
{
type: "range",
id: "arousal_val",
max: 100,
value: 0,
action: "arousal_val",
binding: { path: "arousal", required: true, onMissing: "mark-section-broken" },
defaultValue: 0,
coerce: "number",
feedback: { success: "Arousal updated", variant: "info" }
},
{
type: "text",
id: "arousal_preview",
text: "0"
},
{
type: "button",
id: "arousal_player",
text: "Player",
action: "arousal_player",
feedback: { success: "Player arousal applied", variant: "success" }
},
{
type: "button",
id: "arousal_enemy",
text: "Enemy",
action: "arousal_enemy",
feedback: { success: "Enemy arousal applied", variant: "success" }
}
]
}
];
function createQuickMetadata(context) {
const {
data: { downloadSite: downloadSite2, sourceCode: sourceCode2 },
runtime
} = context;
const testedOnStr = runtime.testedOn && runtime.testedOn !== "0.0.0" ? "Tested on :" + runtime.testedOn : "Tested on : Untested";
const curVerStr = runtime.curVer ? "Current ver :" + runtime.curVer : "";
const isCheatWorkSymbolStr = runtime.isCheatWorkSymbol ?? "";
const testedTooltip = runtime.testedOn && runtime.testedOn !== "0.0.0" ? runtime.isCheatWork ?? "" : "Not tested in current game version";
const localOverrides = { ...CONTROL_OVERRIDES };
localOverrides.is_cheat_symbol = { visibility: Boolean(isCheatWorkSymbolStr) };
const quickLegacyDefs = [
{
ids: ["", "", "is_cheat_symbol", "info_cheat"],
inputs: ["text", "text", "text", "tooltip"],
values: [testedOnStr, curVerStr, isCheatWorkSymbolStr, testedTooltip]
},
{ ids: [""], inputs: ["newline"], values: [""] },
{ ids: [""], inputs: ["header"], values: ["Quick cheat"] },
{
ids: ["", "hesoyam", "kill_player"],
inputs: ["text", "button", "button"],
values: ["Player state", "Recover", "Ruin"]
},
{
ids: ["", "enemycalm", "kill_enemy"],
inputs: ["text", "button", "button"],
values: ["Enemy state", "Recover", "Ruin"]
},
{
ids: ["", "crimecurrent", "sheesh", "jk-lol"],
inputs: ["text", "text", "button", "button"],
values: ["Crime : ", "0", "-100", "+100"]
},
{ ids: ["", "vow-virgin"], inputs: ["text", "button"], values: ["chruch vow", "Virgin"] },
{
ids: ["", "clean_cum", "dirty_cum", "clean_cum_uretus"],
inputs: ["text", "button", "button", "button"],
values: ["Hygiene", "Clean", "dirty", "clean uretus cum"]
},
{
ids: ["", "in_game_cheat", "alt_cheat"],
inputs: ["text", "button", "button"],
values: ["In game cheat", "Enable", "Open"]
},
{
ids: ["", "randomEncounterSet"],
inputs: ["text", "button"],
values: ["Random encounter", "Enabled"]
},
{ ids: [""], inputs: ["newline"], values: [""] },
{ ids: [""], inputs: ["header"], values: ["Unlimited Toggles"] },
{
ids: ["", "maxchruchtask", "maxanimaltask"],
inputs: ["text", "button", "button"],
values: ["Tasks", "Chruch", "Stray"]
},
{
ids: ["", "edenshrooms", "edengarden", "edenspring", "edentimer"],
inputs: ["text", "button", "button", "button", "button"],
values: ["Eden Tasks", "Shroom", "Garden", "Spring", "Timer"]
},
{
ids: ["", "everyone_horny"],
inputs: ["text", "button"],
values: ["Everyone is horny", "Horny"]
},
{ ids: ["", "farm_safe"], inputs: ["text", "button"], values: ["Farm safety", "Safe"] },
{
ids: ["", "unlicum", "unliarousal", "intenseCum"],
inputs: ["text", "button", "button", "button"],
values: ["Unlimited", "cum", "arousal", "intense cum"]
},
{
ids: ["", "virginity", "purity"],
inputs: ["text", "button", "button"],
values: ["Maintain pure", "virgin", "pure"]
},
{
ids: ["", "invincibleAngel", "invincibleAngelInfo"],
inputs: ["text", "button", "tooltip"],
values: [
"Invincible Angel",
"Activate",
"it will prevent angel build progress lower or become fallen.(combine it with pure cheat)"
]
},
{
ids: ["", "interact_child", "info_interact_child"],
inputs: ["text", "button", "tooltip"],
values: ["Auto Child Interact ", "Auto", "you must visit your baby first to trigger it."]
},
{
ids: ["", "pc_pregnancy", "npc_pregnancy", "pregnancy_detection"],
inputs: ["text", "text", "text", "button"],
values: ["pregnancy detection ", "pc=0", "NPC=0", "Activate"]
},
{
ids: ["", "invinityNPCPregnancy", "invinityNPCPregnancyInfo"],
inputs: ["text", "button", "tooltip"],
values: [
"Infinite NPC pregnancy ",
"Activate",
"It will store pregnancy on the cheat untill it reach 1 day before give birth."
]
},
{
ids: ["", "allNPCInstaPregnant", "allNPCInstaPregnantInfo"],
inputs: ["text", "button", "tooltip"],
values: [
"NPC max pregnancy rate",
"Activate",
"NPC has 100% pregnancy rate. some npc might cannot impregnated at all. Multiple pregnancy allows you to impregnated everyone multiple times."
]
},
{
ids: ["", "allNPCMultiplePregnancy", "allNPCMultiplePregnancyInfo"],
inputs: ["text", "button", "tooltip"],
values: [
"NPC multiple pregnancys",
"Activate",
"Allows you to impregnated NPCs multiple times."
]
},
{ ids: [""], inputs: ["newline"], values: [""] }
];
const rows = [...createRowsFromLegacyDefs(quickLegacyDefs, localOverrides)];
rows.splice(3, 0, ...createRowsFromSettingDefs(QUICK_SETTING_DEFS));
if (runtime.isServer === 1) {
rows.push(
...createRowsFromLegacyDefs(
[{ ids: [""], inputs: ["header"], values: ["Server"] }],
CONTROL_OVERRIDES
)
);
if (runtime.curVer != runtime.testedOn) {
rows.push(
...createRowsFromLegacyDefs(
[
{
ids: ["", "server_save_info"],
inputs: ["text", "tooltip"],
values: [
"caution! game version is different",
"Lower version or moded version could potentially cause problem."
]
}
],
CONTROL_OVERRIDES
)
);
}
rows.push(
...createRowsFromLegacyDefs(
[
{
ids: ["", "save_data", "load_data", "serversaveinfo"],
inputs: ["text", "button", "button", "tooltip"],
values: [
"Server Save",
"Export",
"Import",
"this will export all of your save data (1-10) to the local server, allows you to import it anywhere else in the same local network"
]
}
],
CONTROL_OVERRIDES
)
);
rows.push(
...createRowsFromLegacyDefs(
[{ ids: [""], inputs: ["newline"], values: [""] }],
CONTROL_OVERRIDES
)
);
}
rows.push(
...createRowsFromLegacyDefs(
[{ ids: [""], inputs: ["newline"], values: [""] }],
CONTROL_OVERRIDES
)
);
rows.push(
...createRowsFromLegacyDefs(
[
{
ids: ["", downloadSite2, sourceCode2],
inputs: ["text", "link", "link"],
values: [
"cheat ver : " + runtime.cheatVer + (runtime.cheatVerType ? " " + runtime.cheatVerType : ""),
"Check for update",
"Source Code"
]
}
],
CONTROL_OVERRIDES
)
);
return rows;
}
// src/ui/metadata/stat/characteristics-section.js
function createCharacteristicsSection(context) {
const {
data: { characteristics: characteristics2 }
} = context;
return {
afterHeader: "Characteristics",
rows: createRowsFromSettingDefs([
{
key: "stat_characteristics",
inputs: [
{ type: "select", id: "charapick", options: characteristics2, action: "charapick" },
{ type: "input", id: "charainput", coerce: "number" },
{
type: "button",
id: "charaset",
text: "set",
action: "charaset",
feedback: successFeedback("Characteristic updated")
}
]
},
{
key: "stat_lactating",
text: "lactating : ",
inputs: [
{
type: "button",
id: "lactatingset",
text: "Yes",
action: "lactatingset",
feedback: successFeedback("Lactation enabled")
}
]
},
{
key: "stat_milk",
text: "milk volume",
inputs: [
{ type: "input", id: "milkinput", coerce: "number" },
{
type: "button",
id: "milkset",
text: "set",
action: "milkset",
feedback: successFeedback("Milk volume updated")
},
{
type: "button",
id: "milkrefil",
text: "Refil",
action: "milkrefil",
feedback: successFeedback("Milk refilled")
}
]
},
{
key: "stat_cum",
text: "cum volume",
inputs: [
{ type: "input", id: "cuminput", coerce: "number" },
{
type: "button",
id: "cumset",
text: "set",
action: "cumset",
feedback: successFeedback("Cum volume updated")
},
{
type: "button",
id: "cumrefil",
text: "Refil",
action: "cumrefil",
feedback: successFeedback("Cum refilled")
}
]
}
])
};
}
// src/ui/metadata/stat/enemy-section.js
function createEnemySection() {
return {
afterHeader: "Enemy stats",
rows: createRowsFromSettingDefs([
{
key: "stat_enemy_state",
inputs: [
{
type: "button",
id: "enemycalm",
text: "Recover",
action: "enemycalm",
feedback: successFeedback("Enemy recovered")
},
{
type: "button",
id: "kill_enemy",
text: "Ruin",
action: "kill_enemy",
feedback: successFeedback("Enemy ruined")
}
]
},
{
key: "stat_enemy_values",
inputs: [
{
type: "select",
id: "statpicke",
options: ["enemyhealth", "enemytrust", "enemyanger"],
action: "statpicke"
},
{ type: "input", id: "statinpute", coerce: "number" },
{
type: "button",
id: "statsete",
text: "set",
action: "statsete",
feedback: successFeedback("Enemy stat updated")
}
]
}
])
};
}
// src/ui/metadata/stat/fame-section.js
function createFameSection(context) {
const {
data: { fame: fame2 }
} = context;
return {
afterHeader: "Fame",
rows: createRowsFromSettingDefs([
{
key: "stat_fame",
inputs: [
{ type: "select", id: "fame_name", options: fame2, action: "fame_name" },
{ type: "input", id: "input_fame12", coerce: "number" },
{
type: "button",
id: "set_fame12",
text: "Set",
action: "set_fame12",
feedback: successFeedback("Fame updated")
}
]
}
])
};
}
// src/ui/metadata/stat/player-section.js
function createPlayerSection(context) {
const {
data: { bodyparts: bodyparts2, parasitename: parasitename2 }
} = context;
return {
afterHeader: "Player",
rows: createRowsFromSettingDefs([
{
key: "stat_money",
text: "Money",
inputs: [
{
type: "input",
id: "moneyinput",
binding: { path: "money", required: true, onMissing: "mark-section-broken" },
defaultValue: 0,
coerce: "number"
},
{
type: "button",
id: "moneyset",
text: "set",
action: "moneyset",
feedback: successFeedback("Money updated")
}
]
},
{
key: "stat_spray",
text: "Unlimited spray",
inputs: [
{
type: "button",
id: "sprayset",
text: "set",
action: "sprayset",
feedback: successFeedback("Unlimited spray enabled")
}
]
},
{
key: "stat_body",
text: "Body Size : ",
inputs: [
{ type: "button", id: "bodycurrent", text: "" },
{
type: "select",
id: "bodypick",
options: ["Tiny", "Small", "Normal", "Large"]
},
{
type: "button",
id: "bodyset",
text: "set",
action: "bodyset",
feedback: successFeedback("Body size updated")
}
]
},
{
key: "stat_bodytype",
text: "Natural features : ",
inputs: [
{ type: "button", id: "bodytypecurrent", text: "" },
{
type: "select",
id: "bodytypepick",
options: ["Masculine", "Feminine", "Androgynous"]
},
{
type: "button",
id: "bodytypeset",
text: "set",
action: "bodytypeset",
feedback: successFeedback("Body type updated")
}
]
},
{
key: "stat_balls",
text: "Balls : ",
inputs: [
{
type: "button",
id: "ballsset",
text: "Remove",
action: "ballsset",
feedback: successFeedback("Balls removed")
}
]
},
{
key: "stat_virginity",
text: "Virginity : ",
inputs: [
{
type: "select",
id: "virginitypick",
options: ["anal", "oral", "penile", "vaginal", "temple", "handholding", "kiss"]
},
{ type: "button", id: "virginitycurrent", text: "" },
{
type: "button",
id: "virginityset",
text: "Restore",
action: "virginityset",
feedback: successFeedback("Virginity restored")
},
{
type: "button",
id: "virginpure",
text: "pure",
action: "virginpure",
feedback: successFeedback("Purity applied")
}
]
},
{
key: "stat_crime",
text: "Crime",
inputs: [
{
type: "button",
id: "sheesh",
text: "-100",
action: "sheesh",
feedback: successFeedback("Crime reduced")
},
{
type: "button",
id: "jk-lol",
text: "+100",
action: "jk-lol",
feedback: successFeedback("Crime increased")
}
]
},
{
key: "stat_parasite",
text: "Parasite",
inputs: [
{ type: "select", id: "parasitename", options: parasitename2 },
{ type: "select", id: "bodyparts", options: bodyparts2 },
{
type: "button",
id: "infect",
text: "infect",
action: "infect",
feedback: successFeedback("Parasite infected")
},
{
type: "button",
id: "desinfect",
text: "remove",
action: "desinfect",
feedback: successFeedback("Parasite removed")
}
]
}
])
};
}
// src/ui/metadata/stat/school-section.js
function createSchoolSection(context) {
const {
data: { exam: exam2, school_rep: school_rep2 }
} = context;
return {
afterHeader: "School",
rows: createRowsFromSettingDefs([
{
key: "stat_school_exam",
text: "Exam",
inputs: [
{ type: "select", id: "select_exam", options: exam2, action: "select_exam" },
{ type: "input", id: "input_exam", coerce: "number" },
{
type: "button",
id: "set_exam",
text: "Set",
action: "set_exam",
feedback: successFeedback("Exam updated")
}
]
},
{
key: "stat_school_rep",
text: "School reputation",
inputs: [
{
type: "select",
id: "select_school_rep",
options: school_rep2,
action: "select_school_rep"
},
{ type: "input", id: "input_school_rep", coerce: "number" },
{
type: "button",
id: "set_school_rep",
text: "Set",
action: "set_school_rep",
feedback: successFeedback("School reputation updated")
}
]
}
])
};
}
// src/ui/metadata/stat/stats-section.js
function createStatsSection() {
return {
afterHeader: "Stats",
rows: createRowsFromSettingDefs([
{
key: "stat_player_state",
inputs: [
{
type: "button",
id: "hesoyam",
text: "Recover",
action: "hesoyam",
feedback: successFeedback("Player recovered")
},
{
type: "button",
id: "kill_player",
text: "Ruin",
action: "kill_player",
feedback: successFeedback("Player ruined")
}
]
},
{
key: "stat_player_values",
inputs: [
{
type: "select",
id: "statpick",
options: [
"pain",
"arousal",
"tiredness",
"stress",
"trauma",
"control",
"drunk",
"drugged",
"hallucinogen"
],
action: "statpick"
},
{ type: "input", id: "statinput", coerce: "number" },
{
type: "button",
id: "statset",
text: "set",
action: "statset",
feedback: successFeedback("Player stat updated")
}
]
}
])
};
}
// src/ui/metadata/stat/talent-section.js
function createTalentSection(context) {
const {
data: { hentaiSkill: hentaiSkill2, talent_skill: talent_skill2 }
} = context;
return {
afterHeader: "Talent",
rows: createRowsFromSettingDefs([
{
key: "stat_talent",
text: "Talent",
inputs: [
{ type: "select", id: "select_talent", options: talent_skill2, action: "select_talent" },
{ type: "input", id: "input_talent", coerce: "number" },
{
type: "button",
id: "set_talent",
text: "Set",
action: "set_talent",
feedback: successFeedback("Talent updated")
}
]
},
{
key: "stat_hentai_talent",
text: "Ero Talent",
inputs: [
{
type: "select",
id: "select_hentai_skill",
options: hentaiSkill2
},
{ type: "input", id: "input_hentai_skill", coerce: "number" },
{
type: "button",
id: "set_hentai_skill",
text: "Set",
action: "set_hentai_skill",
feedback: successFeedback("Ero talent updated")
}
]
}
])
};
}
// src/ui/metadata/stat/index.js
function createStatMetadata(context) {
const separators = [
{ ids: [""], inputs: ["header"], values: ["Stats"] },
{ ids: [""], inputs: ["newline"], values: [""] },
{ ids: [""], inputs: ["header"], values: ["Enemy stats"] },
{ ids: [""], inputs: ["newline"], values: [""] },
{ ids: [""], inputs: ["header"], values: ["Player"] },
{ ids: [""], inputs: ["newline"], values: [""] },
{ ids: [""], inputs: ["header"], values: ["Characteristics"] },
{ ids: [""], inputs: ["newline"], values: [""] },
{ ids: [""], inputs: ["header"], values: ["Fame"] },
{ ids: [""], inputs: ["newline"], values: [""] },
{ ids: [""], inputs: ["header"], values: ["School"] },
{ ids: [""], inputs: ["newline"], values: [""] },
{ ids: [""], inputs: ["header"], values: ["Talent"] }
];
const sepRows = createRowsFromLegacyDefs(separators);
const sections = [
createStatsSection(),
createEnemySection(),
createPlayerSection(context),
createCharacteristicsSection(context),
createFameSection(context),
createSchoolSection(context),
createTalentSection(context)
];
const byHeader = new Map(sections.map((section) => [section.afterHeader, section.rows]));
const rows = [];
sepRows.forEach((row) => {
rows.push(row);
const header = row.children?.find((c) => c.type === "header");
if (!header?.label) return;
const sectionRows = byHeader.get(header.label);
if (sectionRows) rows.push(...sectionRows);
});
return rows;
}
// src/ui/metadata/misc/index.js
function getNamedNpcPregnancyOptions() {
const namedNpcs = getNPCName();
if (!Array.isArray(namedNpcs)) return [];
return namedNpcs.map((npc, index) => ({ npc, index })).filter(({ npc }) => npc?.pregnancy?.timer != null).map(({ npc, index }) => ({ value: String(index), label: npc.description }));
}
function getNpcPregnancyOptions() {
const storedNpcs = getStoredNPCs();
if (!storedNpcs || typeof storedNpcs !== "object") return [];
return Object.entries(storedNpcs).filter(([, npc]) => npc?.pregnancy?.fetus?.[0]?.mother).map(([key, npc]) => ({ value: key, label: npc.pregnancy.fetus[0].mother }));
}
var CONTROL_OVERRIDES2 = {
named_npc_pregnancy_toggle: {
binding: { path: "cheatPlus.namedNpcPregnancyLock", required: false },
defaultValue: false,
coerce: "boolean"
},
npc_pregnancy_toggle: {
binding: { path: "cheatPlus.npcPregnancyLock", required: false },
defaultValue: false,
coerce: "boolean"
}
};
function createMiscMetadata(context) {
const {
data: { npcnamelist: npcnamelist2, npctrait: npctrait2 }
} = context;
const rowDefs = [
{ ids: [""], inputs: ["header"], values: ["NPC"] },
{
ids: ["", "npcnames", "npctraits", "npcchangeinput", "changetraitbro"],
inputs: ["text", "select", "select", "input", "button"],
values: ["NPC manager", npcnamelist2, npctrait2, "", "Set"]
},
{
ids: ["", "max_harmony", "max_Ferocity"],
inputs: ["text", "button", "button"],
values: ["wolfpack", "max harmony", "max Ferocity"]
},
{ ids: [""], inputs: ["newline"], values: [""] },
{ ids: [""], inputs: ["header"], values: ["Pregnancy Manager"] },
{
ids: ["", "pregnancy_manager_time_tooltip"],
inputs: ["header", "tooltip"],
values: ["Pregnancy time", "day"]
}
];
const settingDefs = [
{
key: "misc_named_npc_pregnancy",
text: "Named NPC",
inputs: [
{
type: "select",
id: "named_npc_pregnancy_manager",
optionsSource: getNamedNpcPregnancyOptions,
action: "named_npc_pregnancy_manager"
},
{
type: "input",
id: "named_npc_pregnancy_input",
placeholder: "",
coerce: "number"
},
{
type: "checkbox",
id: "named_npc_pregnancy_toggle",
text: "lock preg",
binding: { path: "cheatPlus.namedNpcPregnancyLock", required: false },
defaultValue: false,
feedback: toggleFeedback("Named NPC Pregnancy Lock")
},
{
type: "button",
id: "named_npc_pregnancy_set",
text: "Set",
action: "named_npc_pregnancy_set",
feedback: successFeedback("Named NPC pregnancy updated")
}
]
},
{
key: "misc_npc_pregnancy",
text: "NPC",
inputs: [
{
type: "select",
id: "npc_pregnancy_manager",
optionsSource: getNpcPregnancyOptions,
action: "npc_pregnancy_manager"
},
{
type: "input",
id: "npc_pregnancy_input",
placeholder: "",
coerce: "number"
},
{
type: "checkbox",
id: "npc_pregnancy_toggle",
text: "lock preg",
binding: { path: "cheatPlus.npcPregnancyLock", required: false },
defaultValue: false,
feedback: toggleFeedback("NPC Pregnancy Lock")
},
{
type: "button",
id: "npc_pregnancy_set",
text: "Set",
action: "npc_pregnancy_set",
feedback: successFeedback("NPC pregnancy updated")
}
]
}
];
return [
...createRowsFromLegacyDefs(rowDefs, CONTROL_OVERRIDES2),
...createRowsFromSettingDefs(settingDefs)
];
}
// 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/features/cheat-init.js
function init_interface() {
safeCall("init_interface-start", () => {
logger_default("cheat-init", "init_interface-start");
});
const runtimeWindow2 = getRuntimeWindow();
const context = {
data: {
animals,
babyOptions,
bodyparts,
characteristics,
downloadSite,
exam,
fame,
hentaiSkill,
npcnamelist: npcnamelist || runtimeWindow2?.npcnamelist,
npctrait,
parasitename,
school_rep,
sourceCode,
talent_skill
},
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 quick = createQuickMetadata(context);
const stat = createStatMetadata(context);
const misc = createMiscMetadata(context);
validateRegistry(quick, "quickMetadata");
validateRegistry(stat, "statMetadata");
validateRegistry(misc, "miscMetadata");
renderRegistry(quick, byUiId("quick-content"), {
requiredPaths: ["passage", "arousal"]
});
renderRegistry(stat, byUiId("stats-content"), {
requiredPaths: ["passage", "money"]
});
renderRegistry(misc, byUiId("misc-content"), {
requiredPaths: ["passage"]
});
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, options) {
target.addEventListener(type, handler, options);
getStore3().push({ target, type, handler, options });
}
function reset() {
const store2 = getStore3();
for (const { target, type, handler, options } of store2) {
try {
target.removeEventListener(type, handler, options);
} 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: "max_harmony" },
{ actionKey: "max_Ferocity" },
{ 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: "ArrayChecker" },
{ actionKey: "statset", methodName: "statmanager" },
{ actionKey: "enemycalm" },
{ actionKey: "kill_enemy" },
{ actionKey: "statsete", methodName: "statmanagere" },
{ actionKey: "moneyset", methodName: "moneymanager" },
{ actionKey: "sprayset", methodName: "sprayunlimited" },
{ actionKey: "bodyset", methodName: "bodymanager" },
{ 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: "stringJSSet" },
{ 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(entry, 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?.[entry.arg];
if (typeof fn === "function") fn(cheatActions2);
},
executeSearch: () => executeSearch2(entry.arg),
Enable_cheat_history: Enable_cheat_history2,
Enable_sidebar_button: Enable_sidebar_button2,
simple_cheat_button: simple_cheat_button2,
init_interface: init_interface2
};
registerHandler(entry.actionKey, handlers[entry.target]);
}
function registerBoundAction(entry, context) {
const sourceMap = {
hydrateCheatUi: context.hydrateCheatUi,
hydratePregnancy: context.hydratePregnancy
};
const source = sourceMap[entry.source];
registerHandler(entry.actionKey, source?.[entry.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((entry) => registerSimpleUiAction(entry, context));
TOGGLE_DEFINITIONS.forEach(({ id, label }) => {
registerHandler(id, () => cheatActions2.toggleById(id, label));
});
METHOD_ACTIONS.forEach(({ actionKey, methodName }) => {
registerMethodAction(actionKey, cheatActions2, methodName);
});
BOUND_ACTIONS.forEach((entry) => registerBoundAction(entry, 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();
on(document, "click", function(event) {
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() {
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();
factory.initAllFeatures();
factory.startAllObservers();
bootstrapped = true;
return true;
}
function bootstrapCheat(options = {}) {
return bootstrap(options);
}
// 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 {\r\n font-family: var(--cp-font-ui, 'Trebuchet MS', 'Segoe UI', sans-serif);\r\n color: var(--cp-text-primary, #fff);\r\n}\r\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 {\r\n padding-bottom: 6px;\r\n display: flex;\r\n flex-wrap: wrap;\r\n align-items: center;\r\n gap: 8px;\r\n}\r\n\r\n.modal-content-width {\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-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 {\r\n border-color: rgba(240, 212, 109, 0.65);\r\n background: rgba(240, 212, 109, 0.12);\r\n}\r\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 {\r\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 {\r\n visibility: visible;\r\n}\r\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 {\r\n height: 72vh;\r\n max-height: 72vh;\r\n overflow-y: auto;\r\n overscroll-behavior: contain;\r\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 {\r\n padding: 1rem !important;\r\n display: none;\r\n}\r\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 {\r\n width: 100%;\r\n }\r\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}\r\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();
})();