441 lines
16 KiB
JavaScript
441 lines
16 KiB
JavaScript
"use strict";
|
|
|
|
(function (global) {
|
|
const World = global.World;
|
|
if (!World) throw new Error("World is not available for mixin: world_view.js");
|
|
const BASE_ZOOM_MIN = 0.42;
|
|
const BASE_ZOOM_MAX = 4.5;
|
|
|
|
function terrainSignature(worldRef) {
|
|
// Terrain item additions/removals already invalidate only their affected chunks.
|
|
// Keep the global signature limited to changes that truly require every chunk.
|
|
return `${worldRef.fieldType || "garden"}:${worldRef.groundType || "soil"}`;
|
|
}
|
|
|
|
function maxCameraX(worldRef) {
|
|
return Math.max(0, worldRef.w - worldRef.visibleWorldW());
|
|
}
|
|
|
|
function maxCameraY(worldRef) {
|
|
return Math.max(0, worldRef.h - worldRef.visibleWorldH());
|
|
}
|
|
|
|
function fieldWorldScale(worldRef) {
|
|
const field = worldRef.fieldDefinition();
|
|
return Math.max(0.22, field.worldScale || 1);
|
|
}
|
|
|
|
Object.defineProperties(World.prototype, Object.getOwnPropertyDescriptors({
|
|
dayProgress() {
|
|
return (this.time % CONFIG.dayLength) / CONFIG.dayLength;
|
|
},
|
|
|
|
lightLevel() {
|
|
return (Math.sin(this.dayProgress() * Math.PI * 2 - Math.PI / 2) + 1) / 2;
|
|
},
|
|
|
|
triggerGroundShake(duration = 0.4, strength = 6) {
|
|
this.shakeTimer = Math.max(this.shakeTimer || 0, duration);
|
|
this.shakeDuration = Math.max(this.shakeDuration || 0, duration);
|
|
this.shakeStrength = Math.max(this.shakeStrength || 0, strength);
|
|
},
|
|
|
|
currentShakeOffset() {
|
|
const timeLeft = Math.max(0, this.shakeTimer || 0);
|
|
if (timeLeft <= 0) return { x: 0, y: 0 };
|
|
const duration = Math.max(0.001, this.shakeDuration || timeLeft);
|
|
const strength = Math.max(0, this.shakeStrength || 0);
|
|
const fade = clamp(timeLeft / duration, 0.18, 1);
|
|
const t = this.time || 0;
|
|
return {
|
|
x: Math.sin(t * 48) * strength * 0.34 * fade + Math.sin(t * 91) * strength * 0.12 * fade,
|
|
y: Math.cos(t * 60) * strength * 0.18 * fade,
|
|
};
|
|
},
|
|
|
|
emit(type, detail = {}) {
|
|
const events = this.events;
|
|
if (!events?.emit) return null;
|
|
if (typeof events.hasListeners === "function" && !events.hasListeners(type)) return null;
|
|
return events.emit(type, { ...detail, world: this }) || null;
|
|
},
|
|
|
|
markSpatialDirty(reason = "manual") {
|
|
this.spatialDirty = true;
|
|
this.spatialDirtyReason = reason;
|
|
if (this.spatialDirtyReasonCountsThisFrame) {
|
|
const key = String(reason || "manual");
|
|
this.spatialDirtyReasonCountsThisFrame[key] = (this.spatialDirtyReasonCountsThisFrame[key] || 0) + 1;
|
|
}
|
|
if (this.spatialDirtyReasonCountsThisFrame) {
|
|
this.spatialDirtyMarksThisFrame = (this.spatialDirtyMarksThisFrame || 0) + 1;
|
|
this.spatialDirtyMarksTotal = (this.spatialDirtyMarksTotal || 0) + 1;
|
|
}
|
|
this.lastSpatialDirtyReason = reason;
|
|
const r = String(reason || "manual");
|
|
if (/tarinai-moved|post-tarinai|creature/i.test(r)) {
|
|
this.spatialTarinaiDirty = true;
|
|
} else if (/ants?-moved|post-ant|ant/i.test(r) && !/ant_nest|ant-nest/i.test(r)) {
|
|
this.spatialAntDirty = true;
|
|
} else if (/items?-moved|ball-ball|mobile|kinematic|pushpin|oshibyo|firecracker|genkotsu|zunchi|mechanical|rotator|reciprocator|poison-block|constraint|rod-/i.test(r)) {
|
|
this.spatialDynamicItemsDirty = true;
|
|
// Ordinary moving items are not routing obstacles. Only explicit fence,
|
|
// gate, or nest geometry changes invalidate obstacle-route caches.
|
|
if (/fence|gate|nest-box|pipe/i.test(r)) this.routingObstacleVersion = (this.routingObstacleVersion || 0) + 1;
|
|
} else {
|
|
this.spatialStaticItemsDirty = true;
|
|
this.spatialDynamicItemsDirty = true;
|
|
this.spatialTarinaiDirty = true;
|
|
this.spatialAntDirty = true;
|
|
this.routingObstacleVersion = (this.routingObstacleVersion || 0) + 1;
|
|
}
|
|
},
|
|
|
|
markTerrainDirty(reason = "manual") {
|
|
const reasonKey = String(reason || "manual");
|
|
const terrainStats = this.terrainDirtyStatsThisFrame;
|
|
if (terrainStats) {
|
|
terrainStats.raw += 1;
|
|
terrainStats.global += 1;
|
|
terrainStats.reasons[reasonKey] = (terrainStats.reasons[reasonKey] || 0) + 1;
|
|
}
|
|
if (this.terrainDirtyGlobal && this.terrainDirtyReason === reasonKey) {
|
|
terrainStats && (terrainStats.coalesced += 1);
|
|
this.terrainDirty = true;
|
|
this.terrainLastDirtyAt = this.time || 0;
|
|
return;
|
|
}
|
|
this.terrainDirty = true;
|
|
this.terrainDirtyGlobal = true;
|
|
this.terrainDirtyReason = reasonKey;
|
|
this.terrainVersion = (this.terrainVersion || 0) + 1;
|
|
this.terrainLastDirtyAt = this.time || 0;
|
|
},
|
|
|
|
markTerrainDirtyAt(x, y, radius = 48, reason = "manual") {
|
|
const reasonKey = String(reason || "manual");
|
|
const cx = Math.floor((Number(x) || 0) / 256);
|
|
const cy = Math.floor((Number(y) || 0) / 256);
|
|
const cr = Math.max(0, Math.ceil((Number(radius) || 0) / 256));
|
|
const terrainStats = this.terrainDirtyStatsThisFrame;
|
|
if (terrainStats) {
|
|
terrainStats.raw += 1;
|
|
terrainStats.chunk += 1;
|
|
terrainStats.reasons[reasonKey] = (terrainStats.reasons[reasonKey] || 0) + 1;
|
|
}
|
|
if (!this.terrainDirtyChunks) this.terrainDirtyChunks = new Set();
|
|
let added = 0;
|
|
for (let yy = cy - cr; yy <= cy + cr; yy++) {
|
|
for (let xx = cx - cr; xx <= cx + cr; xx++) {
|
|
const key = `${xx}:${yy}`;
|
|
if (!this.terrainDirtyChunks.has(key)) added += 1;
|
|
this.terrainDirtyChunks.add(key);
|
|
}
|
|
}
|
|
this.terrainDirty = true;
|
|
this.terrainDirtyReason = reasonKey;
|
|
this.terrainLastDirtyAt = this.time || 0;
|
|
if (added <= 0) {
|
|
terrainStats && (terrainStats.coalesced += 1);
|
|
return true;
|
|
}
|
|
this.terrainVersion = (this.terrainVersion || 0) + 1;
|
|
return true;
|
|
},
|
|
|
|
|
|
updateTerrainDirtyState(dt = 0) {
|
|
const signature = terrainSignature(this);
|
|
if (signature !== this.lastTerrainSignature) {
|
|
this.lastTerrainSignature = signature;
|
|
this.markTerrainDirty("terrain-signature");
|
|
}
|
|
},
|
|
|
|
phaseName() {
|
|
const hour = this.dayProgress() * 24;
|
|
if (hour >= 5 && hour < 10) return "\u671d";
|
|
if (hour >= 10 && hour < 17) return "\u663c";
|
|
if (hour >= 17 && hour < 20) return "\u5915\u65b9";
|
|
return "\u591c";
|
|
},
|
|
|
|
clockString() {
|
|
const totalMinutes = Math.floor(this.dayProgress() * 24 * 60);
|
|
const hh = String(Math.floor(totalMinutes / 60)).padStart(2, "0");
|
|
const mm = String(totalMinutes % 60).padStart(2, "0");
|
|
return `${hh}:${mm}`;
|
|
},
|
|
|
|
fieldDefinition() {
|
|
return FIELD_TYPES?.[this.fieldType] || FIELD_TYPES.garden;
|
|
},
|
|
|
|
groundDefinition() {
|
|
return window.TarinaiGround.definition(this.groundType || "soil");
|
|
},
|
|
|
|
groundLabel() {
|
|
return window.TarinaiGround.label(this.groundType || "soil");
|
|
},
|
|
|
|
groundStressMultiplier() {
|
|
return window.TarinaiGround.stressMultiplier(this.groundType || "soil");
|
|
},
|
|
|
|
groundGrassMultiplier() {
|
|
return window.TarinaiGround.grassMultiplier(this.groundType || "soil");
|
|
},
|
|
|
|
|
|
setGroundType(id = "soil", opts = {}) {
|
|
const next = window.TarinaiGround.exists(id) ? id : "soil";
|
|
const previous = this.groundType || "soil";
|
|
this.groundType = next;
|
|
if (next !== previous || opts.force) {
|
|
if (next !== previous && !opts.silent) {
|
|
window.TarinaiAchievements?.recordGroundChange?.({ world: this, previous, next, silent: false });
|
|
}
|
|
window.TarinaiWeatherSystem.enforceFixedWeather(this, { silentLog: true });
|
|
this.markTerrainDirty?.("ground-type");
|
|
this.enforceGrassLimit?.("ground-type");
|
|
this.updateItemCounts?.("ground-type");
|
|
this.drawListDirty = true;
|
|
window.TarinaiRender.invalidateRenderCaches("ground-type");
|
|
window.TarinaiGroundUI.update(this);
|
|
if (window.uiCache) window.uiCache.selectedSnapshot = "";
|
|
renderSelected();
|
|
if (typeof document !== "undefined") {
|
|
const groundTextEl = document.getElementById("statGroundType");
|
|
if (groundTextEl) groundTextEl.textContent = this.groundLabel?.() || "\u5730\u9762";
|
|
}
|
|
if (!opts.silent) {
|
|
const label = this.groundLabel?.() || "\u5730\u9762";
|
|
showToast(`\u5730\u9762\u3092 ${label} \u306b\u3057\u307e\u3057\u305f\u3002`);
|
|
}
|
|
}
|
|
return this.groundDefinition?.();
|
|
},
|
|
|
|
cycleGroundType() {
|
|
return this.setGroundType(window.TarinaiGround.nextId(this.groundType || "soil"));
|
|
},
|
|
|
|
|
|
isFenceType(type = "") {
|
|
return isFenceItemType(type);
|
|
},
|
|
|
|
toolAngleFor(type = "") {
|
|
const key = String(type || "");
|
|
const fallback = defaultItemAngle(key);
|
|
const value = this.toolAngles?.[key];
|
|
return normalizedItemAngle(value, fallback);
|
|
},
|
|
|
|
setToolAngle(type = "", angle = 0, { silent = false } = {}) {
|
|
const key = String(type || "");
|
|
if (!key || !isRotatableItemType(key)) return false;
|
|
if (!this.toolAngles) this.toolAngles = {};
|
|
const fallback = defaultItemAngle(key);
|
|
const next = normalizedItemAngle(angle, fallback);
|
|
this.toolAngles[key] = next;
|
|
this.drawListDirty = true;
|
|
if (!silent) showToast(`\u5411\u304d: ${Math.round(next * 180 / Math.PI)}\u00b0`);
|
|
return true;
|
|
},
|
|
|
|
rotateToolAngle(type = "", delta = 0, options = {}) {
|
|
const key = String(type || "");
|
|
const current = this.toolAngleFor(key);
|
|
return this.setToolAngle?.(key, current + Number(delta || 0), options) || false;
|
|
},
|
|
|
|
fitFieldZoom() {
|
|
const vw = Math.max(1, this.viewportW || this.w || 1000);
|
|
const vh = Math.max(1, this.viewportH || this.h || 720);
|
|
const ww = Math.max(1, this.w || vw);
|
|
const wh = Math.max(1, this.h || vh);
|
|
// The minimum visible zoom is field-size dependent. Small fields must not
|
|
// be allowed to shrink below the viewport, otherwise empty margins appear.
|
|
return Math.max(vw / ww, vh / wh);
|
|
},
|
|
|
|
zoomLimits() {
|
|
const min = Math.max(BASE_ZOOM_MIN, this.fitFieldZoom());
|
|
// Keep the old upper bound for normal/large fields, but give small fields
|
|
// proportional zoom-in headroom because their no-margin minimum is higher.
|
|
const max = Math.max(BASE_ZOOM_MAX, min * BASE_ZOOM_MAX);
|
|
return { min, max };
|
|
},
|
|
|
|
normalizedFieldZoom(value = this.fieldZoom) {
|
|
const limits = this.zoomLimits();
|
|
return clamp(Number(value) || limits.min, limits.min, limits.max);
|
|
},
|
|
|
|
viewScale() {
|
|
return this.normalizedFieldZoom(this.fieldZoom);
|
|
},
|
|
|
|
visibleWorldW() {
|
|
return (this.viewportW || this.w) / this.viewScale();
|
|
},
|
|
|
|
visibleWorldH() {
|
|
return (this.viewportH || this.h) / this.viewScale();
|
|
},
|
|
|
|
screenSizeToWorld(size) {
|
|
// Hit tests use logical world units here, so this adapter intentionally
|
|
// returns the supplied size unchanged.
|
|
return size;
|
|
},
|
|
|
|
fieldScreenOffset() {
|
|
const scale = this.viewScale();
|
|
return {
|
|
x: Math.max(0, ((this.viewportW || this.w) - this.w * scale) / 2),
|
|
y: Math.max(0, ((this.viewportH || this.h) - this.h * scale) / 2),
|
|
};
|
|
},
|
|
|
|
|
|
clampCamera() {
|
|
this.cameraX = clamp(this.cameraX || 0, 0, maxCameraX(this));
|
|
this.cameraY = clamp(this.cameraY || 0, 0, maxCameraY(this));
|
|
},
|
|
|
|
panCamera(dx, dy) {
|
|
const scale = this.viewScale();
|
|
this.cameraX = (this.cameraX || 0) + dx / scale;
|
|
this.cameraY = (this.cameraY || 0) + dy / scale;
|
|
this.clampCamera();
|
|
},
|
|
|
|
screenToWorld(x, y) {
|
|
const scale = this.viewScale();
|
|
const off = this.fieldScreenOffset();
|
|
const rawX = (x - off.x) / scale + (this.cameraX || 0);
|
|
const rawY = (y - off.y) / scale + (this.cameraY || 0);
|
|
return {
|
|
x: clamp(rawX, 0, this.w),
|
|
y: clamp(rawY, 0, this.h),
|
|
inside: rawX >= 0 && rawY >= 0 && rawX <= this.w && rawY <= this.h,
|
|
};
|
|
},
|
|
|
|
worldToScreen(x, y) {
|
|
const scale = this.viewScale();
|
|
const off = this.fieldScreenOffset();
|
|
return {
|
|
x: (x - (this.cameraX || 0)) * scale + off.x,
|
|
y: (y - (this.cameraY || 0)) * scale + off.y,
|
|
};
|
|
},
|
|
|
|
setViewportSize(width, height, opts = {}) {
|
|
const oldW = this.w || width;
|
|
const oldH = this.h || height;
|
|
this.viewportW = Math.max(1, width || this.viewportW || 1000);
|
|
this.viewportH = Math.max(1, height || this.viewportH || 720);
|
|
|
|
// The playable world follows the CSS canvas size. Callers can opt out for
|
|
// presentation-only measurements, but normal viewport resizes keep the two
|
|
// dimensions linked and may scale existing contents to preserve layout.
|
|
const resizeWorld = opts.resizeWorld !== false || !this._worldSizeInitialized;
|
|
if (resizeWorld) {
|
|
const requestedScale = fieldWorldScale(this);
|
|
const scale = Math.max(requestedScale, 220 / this.viewportW, 180 / this.viewportH);
|
|
this.w = this.viewportW * scale;
|
|
this.h = this.viewportH * scale;
|
|
this._worldSizeInitialized = true;
|
|
}
|
|
|
|
this.fieldZoom = this.normalizedFieldZoom(this.fieldZoom);
|
|
this.clampCamera();
|
|
if (resizeWorld && opts.scaleContents && oldW > 0 && oldH > 0) {
|
|
const sx = this.w / oldW;
|
|
const sy = this.h / oldH;
|
|
const scalePoint = (p) => {
|
|
if (!p) return;
|
|
if (Number.isFinite(p.x)) p.x *= sx;
|
|
if (Number.isFinite(p.y)) p.y *= sy;
|
|
};
|
|
for (const t of this.tarinai || []) scalePoint(t);
|
|
for (const it of this.items || []) scalePoint(it);
|
|
for (const residue of this.residues || []) scalePoint(residue);
|
|
this.rebuildResidueIndex?.();
|
|
for (const ef of this.effects || []) scalePoint(ef);
|
|
scalePoint(this.pointer);
|
|
this.cameraX *= sx;
|
|
this.cameraY *= sy;
|
|
this.clampCamera();
|
|
this.markTerrainDirty?.("viewport-scale");
|
|
this.rebuildSpatial(true);
|
|
this.drawListDirty = true;
|
|
}
|
|
},
|
|
|
|
setFieldZoom(nextZoom) {
|
|
const current = this.normalizedFieldZoom(this.fieldZoom);
|
|
const next = this.normalizedFieldZoom(nextZoom);
|
|
if (Math.abs(next - current) < 0.001) {
|
|
this.fieldZoom = current;
|
|
this.clampCamera();
|
|
return false;
|
|
}
|
|
this.fieldZoom = next;
|
|
this.clampCamera();
|
|
this.markTerrainDirty?.("field-zoom");
|
|
this.drawListDirty = true;
|
|
return true;
|
|
},
|
|
|
|
edgeSpawnPoint(targetX = null, targetY = null, margin = 34, outside = false) {
|
|
const w = Math.max(this.w || 1000, margin * 2 + 1);
|
|
const h = Math.max(this.h || 720, margin * 2 + 1);
|
|
let side;
|
|
if (Number.isFinite(targetX) && Number.isFinite(targetY)) {
|
|
const distances = [targetY, w - targetX, h - targetY, targetX];
|
|
side = distances.indexOf(Math.min(...distances));
|
|
} else {
|
|
side = Math.floor(Math.random() * 4);
|
|
}
|
|
const p = outside ? -(margin + 24) : margin;
|
|
if (side === 0) return { x: clamp(targetX ?? rand(margin, w - margin), margin, w - margin), y: p, vx: rand(-10, 10), vy: rand(28, 48), angle: Math.PI / 2 };
|
|
if (side === 1) return { x: outside ? w - p : w - margin, y: clamp(targetY ?? rand(margin, h - margin), margin, h - margin), vx: rand(-48, -28), vy: rand(-10, 10), angle: Math.PI };
|
|
if (side === 2) return { x: clamp(targetX ?? rand(margin, w - margin), margin, w - margin), y: outside ? h - p : h - margin, vx: rand(-10, 10), vy: rand(-48, -28), angle: -Math.PI / 2 };
|
|
return { x: p, y: clamp(targetY ?? rand(margin, h - margin), margin, h - margin), vx: rand(28, 48), vy: rand(-10, 10), angle: 0 };
|
|
},
|
|
|
|
toolSizeFor(type = "") {
|
|
return normalizedToolSizeFor(this, type);
|
|
},
|
|
|
|
toolSizeScale(type = "") {
|
|
return toolSizeScaleFor(this, type);
|
|
},
|
|
|
|
applyToolSize(item) {
|
|
if (!item) return item;
|
|
const scale = this.toolSizeScale(item.type);
|
|
const size = this.toolSizeFor(item.type);
|
|
item.toolSize = size;
|
|
this.toolSize = size;
|
|
item.r *= scale;
|
|
if (isServingFoodType(item.type)) {
|
|
const servings = foodServingsForSize(size);
|
|
item.foodServingsMax = servings;
|
|
item.foodServingsRemaining = servings;
|
|
item.amount = servings;
|
|
(typeof updateServingFoodVisualSize === "function" ? updateServingFoodVisualSize(item) : false);
|
|
} else if (["grass", "zunchi"].includes(item.type)) {
|
|
item.amount *= scale * scale;
|
|
item.foodServingScale = scale;
|
|
}
|
|
if (item.type === "firecracker") item.blastScale = scale;
|
|
return item;
|
|
}
|
|
}));
|
|
})(typeof window !== "undefined" ? window : globalThis);
|