| 1 | import { resolveState, statesForType } from "../definitions/tileSprites.js"; |
| 2 | |
| 3 | /** Calendar seasons for outdoor ground/block visuals (server local clock). */ |
| 4 | export const SeasonId = Object.freeze({ |
| 5 | summer: "summer", |
| 6 | fall: "fall", |
| 7 | winter: "winter" |
| 8 | }); |
| 9 | |
| 10 | export const SEASON_STATE_ORDER = Object.freeze([ |
| 11 | SeasonId.summer, |
| 12 | SeasonId.fall, |
| 13 | SeasonId.winter |
| 14 | ]); |
| 15 | |
| 16 | /** |
| 17 | * Season from a local Date / unix ms. |
| 18 | * Spring+summer share `summer` (Mar–Aug); fall Sep–Nov; winter Dec–Feb. |
| 19 | */ |
| 20 | export function seasonIdAt (now = Date.now()) |
| 21 | { |
| 22 | const month = new Date(now).getMonth(); |
| 23 | if (month >= 2 && month <= 7) |
| 24 | { return SeasonId.summer; } |
| 25 | if (month >= 8 && month <= 10) |
| 26 | { return SeasonId.fall; } |
| 27 | return SeasonId.winter; |
| 28 | } |
| 29 | |
| 30 | /** |
| 31 | * True when this type has full summer/fall/winter visual states. |
| 32 | * Only outdoor types should ship these; indoor types never need them. |
| 33 | */ |
| 34 | export function typeHasSeasonalStates (states) |
| 35 | { |
| 36 | const set = new Set(states ?? []); |
| 37 | const hasSummer = set.has(SeasonId.summer) || set.has("grass"); |
| 38 | return hasSummer && set.has(SeasonId.fall) && set.has(SeasonId.winter); |
| 39 | } |
| 40 | |
| 41 | /** |
| 42 | * Optional per-state seasonal overlay (`boulder-winter`, `copper-ore-winter`). |
| 43 | * Used when a type only overrides some seasons and otherwise keeps the base sprite. |
| 44 | */ |
| 45 | export function isSeasonalOverlayVariant (state) |
| 46 | { |
| 47 | if (typeof state !== "string" || isSeasonalStumpState(state)) |
| 48 | { return false; } |
| 49 | for (const season of SEASON_STATE_ORDER) |
| 50 | { |
| 51 | const suffix = `-${season}`; |
| 52 | if (state.endsWith(suffix) && state.length > suffix.length) |
| 53 | { return true; } |
| 54 | } |
| 55 | return false; |
| 56 | } |
| 57 | |
| 58 | export function seasonalOverlayBaseState (state) |
| 59 | { |
| 60 | if (!isSeasonalOverlayVariant(state)) |
| 61 | { return state; } |
| 62 | for (const season of SEASON_STATE_ORDER) |
| 63 | { |
| 64 | const suffix = `-${season}`; |
| 65 | if (state.endsWith(suffix)) |
| 66 | { return state.slice(0, -suffix.length); } |
| 67 | } |
| 68 | return state; |
| 69 | } |
| 70 | |
| 71 | export function seasonalOverlayState (baseState, seasonId) |
| 72 | { |
| 73 | if (!baseState || isSeasonalOverlayVariant(baseState) || isSeasonalStumpState(baseState)) |
| 74 | { return null; } |
| 75 | const season = seasonId ?? SeasonId.summer; |
| 76 | if (season === SeasonId.summer || season === SeasonId.fall || season === SeasonId.winter) |
| 77 | { return `${baseState}-${season}`; } |
| 78 | return null; |
| 79 | } |
| 80 | |
| 81 | /** |
| 82 | * Pick the visual state for the current season when the type supports seasons. |
| 83 | * Authored stump states stay exhausted visuals (seasonal stump sprite). |
| 84 | * Full seasonal outdoor types ignore authored live state (calendar drives the look). |
| 85 | * Types with only some overlays (e.g. `*-winter`) use the overlay when present, else the base. |
| 86 | */ |
| 87 | export function resolveSeasonalVisualState (states, authoredState, seasonId) |
| 88 | { |
| 89 | const season = seasonId ?? SeasonId.summer; |
| 90 | if (isSeasonalStumpState(authoredState) && typeHasSeasonalStates(states)) |
| 91 | { |
| 92 | const stump = treeStumpStateForSeason(season); |
| 93 | if (states.includes(stump)) |
| 94 | { return stump; } |
| 95 | if (states.includes(authoredState)) |
| 96 | { return authoredState; } |
| 97 | return resolveState(states, authoredState); |
| 98 | } |
| 99 | if (typeHasSeasonalStates(states)) |
| 100 | { |
| 101 | if (season === SeasonId.summer) |
| 102 | { |
| 103 | if (states.includes(SeasonId.summer)) |
| 104 | { return SeasonId.summer; } |
| 105 | if (states.includes("grass")) |
| 106 | { return "grass"; } |
| 107 | } |
| 108 | if (states.includes(season)) |
| 109 | { return season; } |
| 110 | return resolveState(states, authoredState); |
| 111 | } |
| 112 | const resolved = resolveState(states, authoredState); |
| 113 | const base = seasonalOverlayBaseState(resolved); |
| 114 | const overlay = seasonalOverlayState(base, season); |
| 115 | if (overlay && states.includes(overlay)) |
| 116 | { return overlay; } |
| 117 | if (base && states.includes(base)) |
| 118 | { return base; } |
| 119 | return resolved; |
| 120 | } |
| 121 | |
| 122 | /** True when authored state is a tree stump (`summer-stump`, …). */ |
| 123 | export function isSeasonalStumpState (state) |
| 124 | { |
| 125 | return typeof state === "string" && (state === "stump" || state.endsWith("-stump")); |
| 126 | } |
| 127 | |
| 128 | /** Exhausted tree visual for a calendar season. */ |
| 129 | export function treeStumpStateForSeason (seasonId) |
| 130 | { |
| 131 | const season = seasonId === SeasonId.fall || seasonId === SeasonId.winter |
| 132 | ? seasonId |
| 133 | : SeasonId.summer; |
| 134 | return `${season}-stump`; |
| 135 | } |
| 136 | |
| 137 | /** Preferred catalog default among seasonal states. */ |
| 138 | export function preferredSeasonalDefaultState (states) |
| 139 | { |
| 140 | if (!states?.length) |
| 141 | { return null; } |
| 142 | if (states.includes(SeasonId.summer)) |
| 143 | { return SeasonId.summer; } |
| 144 | if (states.includes("grass") && states.includes(SeasonId.fall)) |
| 145 | { return "grass"; } |
| 146 | return states[0]; |
| 147 | } |
| 148 | |
| 149 | /** |
| 150 | * Ordered seasonal visual states to cycle in the editor (summer/fall/winter). |
| 151 | * Legacy `grass` stands in for summer when `summer` is absent. |
| 152 | * Returns null when the type is not fully seasonal. |
| 153 | */ |
| 154 | export function seasonalCycleStates (states) |
| 155 | { |
| 156 | if (!typeHasSeasonalStates(states)) |
| 157 | { return null; } |
| 158 | const out = []; |
| 159 | if (states.includes(SeasonId.summer)) |
| 160 | { out.push(SeasonId.summer); } |
| 161 | else if (states.includes("grass")) |
| 162 | { out.push("grass"); } |
| 163 | if (states.includes(SeasonId.fall)) |
| 164 | { out.push(SeasonId.fall); } |
| 165 | if (states.includes(SeasonId.winter)) |
| 166 | { out.push(SeasonId.winter); } |
| 167 | return out.length >= 2 ? out : null; |
| 168 | } |
| 169 | |
| 170 | /** Map a seasonal visual state name to a SeasonId (legacy `grass` → summer). */ |
| 171 | export function seasonIdFromVisualState (state) |
| 172 | { |
| 173 | if (state === SeasonId.fall || state === SeasonId.winter || state === SeasonId.summer) |
| 174 | { return state; } |
| 175 | if (state === "grass") |
| 176 | { return SeasonId.summer; } |
| 177 | return null; |
| 178 | } |
| 179 | |
| 180 | /** States the editor may cycle/paint (excludes seasonal overlays, tree stumps, and autotile masks). */ |
| 181 | export function placeableStatesForType (catalog, layer, key) |
| 182 | { |
| 183 | return statesForType(catalog, layer, key) |
| 184 | .filter((state) => |
| 185 | !isSeasonalOverlayVariant(state) |
| 186 | && !isSeasonalStumpState(state) |
| 187 | && !/^\d+$/.test(String(state)) |
| 188 | ); |
| 189 | } |