import { resolveState, statesForType } from "../definitions/tileSprites.js"; /** Calendar seasons for outdoor ground/block visuals (server local clock). */ export const SeasonId = Object.freeze({ spring: "spring", summer: "summer", fall: "fall", winter: "winter" }); /** @deprecated Prefer {@link SeasonId}; same four-way calendar for regrow rates. */ export const GrowthSeasonId = SeasonId; export const SEASON_STATE_ORDER = Object.freeze([ SeasonId.spring, SeasonId.summer, SeasonId.fall, SeasonId.winter ]); /** * Season from a local Date / unix ms. * Spring Mar–May; summer Jun–Aug; fall Sep–Nov; winter Dec–Feb. */ export function seasonIdAt (now = Date.now()) { const month = new Date(now).getMonth(); if (month >= 2 && month <= 4) { return SeasonId.spring; } if (month >= 5 && month <= 7) { return SeasonId.summer; } if (month >= 8 && month <= 10) { return SeasonId.fall; } return SeasonId.winter; } /** Alias of {@link seasonIdAt} (regrow rates use the same four seasons). */ export const growthSeasonIdAt = seasonIdAt; /** * Tree / flower / herb exhaust→respawn duration multiplier by growth season. * Summer & fall: 1×; winter: 2×; spring: 0.75× (25% faster). */ export function regrowDurationMultiplier (growthSeasonId) { if (growthSeasonId === SeasonId.winter) { return 2; } if (growthSeasonId === SeasonId.spring) { return 0.75; } return 1; } /** Scale a base exhaust duration (ms) for the current growth season. */ export function scaleRegrowDurationMs (baseMs, nowOrGrowthSeason = Date.now()) { const growth = typeof nowOrGrowthSeason === "string" ? nowOrGrowthSeason : growthSeasonIdAt(nowOrGrowthSeason); return Math.max(1, Math.round((baseMs | 0 || 0) * regrowDurationMultiplier(growth))); } /** * True when this type has full summer/fall/winter visual states. * Optional `spring` is allowed; types without it fall back to summer in spring. * Only outdoor types should ship these; indoor types never need them. */ export function typeHasSeasonalStates (states) { const set = new Set(states ?? []); const hasSummer = set.has(SeasonId.summer) || set.has("grass"); return hasSummer && set.has(SeasonId.fall) && set.has(SeasonId.winter); } /** * Optional per-state seasonal overlay (`boulder-winter`, `copper-ore-winter`). * Used when a type only overrides some seasons and otherwise keeps the base sprite. */ export function isSeasonalOverlayVariant (state) { if (typeof state !== "string" || isSeasonalStumpState(state)) { return false; } for (const season of SEASON_STATE_ORDER) { const suffix = `-${season}`; if (state.endsWith(suffix) && state.length > suffix.length) { return true; } } return false; } export function seasonalOverlayBaseState (state) { if (!isSeasonalOverlayVariant(state)) { return state; } for (const season of SEASON_STATE_ORDER) { const suffix = `-${season}`; if (state.endsWith(suffix)) { return state.slice(0, -suffix.length); } } return state; } export function seasonalOverlayState (baseState, seasonId) { if (!baseState || isSeasonalOverlayVariant(baseState) || isSeasonalStumpState(baseState)) { return null; } const season = seasonId ?? SeasonId.summer; if ( season === SeasonId.spring || season === SeasonId.summer || season === SeasonId.fall || season === SeasonId.winter ) { return `${baseState}-${season}`; } return null; } /** Summer (or legacy grass) look when spring art is absent. */ function resolveSummerVisualState (states) { if (states.includes(SeasonId.summer)) { return SeasonId.summer; } if (states.includes("grass")) { return "grass"; } return null; } /** * Pick the visual state for the current season when the type supports seasons. * Authored stump states stay exhausted visuals (seasonal stump sprite). * Full seasonal outdoor types ignore authored live state (calendar drives the look). * Spring uses `spring` when present, otherwise the summer look. * Types with only some overlays (e.g. `*-winter`) use the overlay when present, else the base. */ export function resolveSeasonalVisualState (states, authoredState, seasonId) { const season = seasonId ?? SeasonId.summer; if (isSeasonalStumpState(authoredState) && typeHasSeasonalStates(states)) { const stump = treeStumpStateForSeason(season); if (states.includes(stump)) { return stump; } if (states.includes(authoredState)) { return authoredState; } return resolveState(states, authoredState); } if (typeHasSeasonalStates(states)) { if (season === SeasonId.spring) { if (states.includes(SeasonId.spring)) { return SeasonId.spring; } const summer = resolveSummerVisualState(states); if (summer) { return summer; } } if (season === SeasonId.summer) { const summer = resolveSummerVisualState(states); if (summer) { return summer; } } if (states.includes(season)) { return season; } return resolveState(states, authoredState); } const resolved = resolveState(states, authoredState); const base = seasonalOverlayBaseState(resolved); const overlay = seasonalOverlayState(base, season); if (overlay && states.includes(overlay)) { return overlay; } // Spring overlays are optional; fall back to the unseasoned base. if (season === SeasonId.spring && base && states.includes(base)) { return base; } if (base && states.includes(base)) { return base; } return resolved; } /** True when authored state is a tree stump (`summer-stump`, …). */ export function isSeasonalStumpState (state) { return typeof state === "string" && (state === "stump" || state.endsWith("-stump")); } /** Exhausted tree visual for a calendar season (spring shares summer stump art). */ export function treeStumpStateForSeason (seasonId) { const season = seasonId === SeasonId.fall || seasonId === SeasonId.winter ? seasonId : SeasonId.summer; return `${season}-stump`; } /** Preferred catalog default among seasonal states. */ export function preferredSeasonalDefaultState (states) { if (!states?.length) { return null; } if (states.includes(SeasonId.summer)) { return SeasonId.summer; } if (states.includes("grass") && states.includes(SeasonId.fall)) { return "grass"; } return states[0]; } /** * Ordered seasonal visual states to cycle in the editor (spring/summer/fall/winter). * Legacy `grass` stands in for summer when `summer` is absent. * Returns null when the type is not fully seasonal. */ export function seasonalCycleStates (states) { if (!typeHasSeasonalStates(states)) { return null; } const out = []; if (states.includes(SeasonId.spring)) { out.push(SeasonId.spring); } if (states.includes(SeasonId.summer)) { out.push(SeasonId.summer); } else if (states.includes("grass")) { out.push("grass"); } if (states.includes(SeasonId.fall)) { out.push(SeasonId.fall); } if (states.includes(SeasonId.winter)) { out.push(SeasonId.winter); } return out.length >= 2 ? out : null; } /** Map a seasonal visual state name to a SeasonId (legacy `grass` → summer). */ export function seasonIdFromVisualState (state) { if ( state === SeasonId.spring || state === SeasonId.fall || state === SeasonId.winter || state === SeasonId.summer ) { return state; } if (state === "grass") { return SeasonId.summer; } return null; } /** States the editor may cycle/paint (excludes seasonal overlays, tree stumps, and autotile masks). */ export function placeableStatesForType (catalog, layer, key) { return statesForType(catalog, layer, key) .filter((state) => !isSeasonalOverlayVariant(state) && !isSeasonalStumpState(state) && !/^\d+$/.test(String(state)) ); }