);
}
const SEAT_COLORS = ["#b84d3f", "#4f7a3f", "#477981", "#8b7434", "#7a5a8a", "#8a664e"];
function seatColor(seat) { return SEAT_COLORS[seat % SEAT_COLORS.length]; }
// A status-ribbon chip: a compact, always-visible summary that expands into a
// floating panel on click. The panel is absolutely positioned so opening it
// never pushes the cards below down. `extra` renders an absolutely-positioned
// decoration inside the wrap (e.g. the build score-pop).
function RailChip({ id, open, onToggle, label, dot, tone, align, extra, children }) {
return (
);
}
const BUILD_GLYPH = { biome: "π²", layer_set: "πΎ", mushroom_set: "π", guidance_set: "β¦" };
// "Meadow forest", "Wetland forest" β¦ but just "Forest" / "Forest Edge" when
// the biome name already carries the word (no "Forest forest").
function biomeForestLabel(biome) {
return /forest/i.test(biome) ? biome : `${biome} forest`;
}
function buildKindLabel(f) {
if (f.kind === "biome") return biomeForestLabel(f.biome);
if (f.kind === "layer_set") return f.layer ? `${f.layer} layer set` : "Layer set";
if (f.kind === "mushroom_set") return "Mushroom set";
return "Forager's Codex";
}
// Compact, clickable list of a player's committed builds (in the harvest rail).
function BuiltStrip({ player, onOpen }) {
if (!player.forests.length) return null;
return (
{player.forests.map((f, i) => (
))}
);
}
// Full-screen look at every forest/set a player has committed, with the
// actual cards face-up. Built cards are public information once scored.
function BuildInspector({ player, season, onClose }) {
React.useEffect(() => {
const onKey = (e) => { if (e.key === "Escape") onClose(); };
window.addEventListener("keydown", onKey);
return () => window.removeEventListener("keydown", onKey);
}, [onClose]);
if (!player) return null;
const forests = player.forests || [];
const title = player.name === "You" ? "Your builds" : `${player.name}'s builds`;
return (
{ if (e.target.classList.contains("hh-overlay")) onClose(); }}>
);
}
// Recap shown when another player (usually a bot) commits a set on their turn:
// who played it, the cards face-up, and the points scored. Dismiss by clicking
// the backdrop, the Dismiss button, or Escape.
function BuildRecap({ recap, season, onDismiss }) {
React.useEffect(() => {
const onKey = (e) => { if (e.key === "Escape") onDismiss(); };
window.addEventListener("keydown", onKey);
return () => window.removeEventListener("keydown", onKey);
}, [onDismiss]);
if (!recap) return null;
const { name, seat, forest } = recap;
return (
{ if (e.target.classList.contains("hh-overlay")) onDismiss(); }}>
);
}
// The draw pile, sitting in the market row as a full card showing the BACK of
// the next card (its botanical plate, no stats) β the same card that, if you
// don't draw it as your free pick, refills the market next. Same size as every
// other card so the row stays uniform.
function DeckCard({ next, count, disabled, onClick, freeUsed }) {
return (
{communityForests
? "Finish rivals' forests for points β learn the base game first"
: "Off β build your own forests (recommended for new players)"}
{numHumans > 1 && (
Name the players
{names.map((nm, i) => (
setName(i, e.target.value)}
/>
))}
)}
{tooFew ? "Add at least one more forager (2 players minimum)."
: tooMany ? "That's a crowd β keep it to 6 foragers or fewer."
: numHumans > 1
? `${total} foragers Β· ${numHumans} share this device β hands stay hidden until each player reveals.`
: `${total} foragers Β· you vs ${numBots} bot${numBots === 1 ? "" : "s"}.`}
);
}
// Hot-seat privacy: between human turns, cover the screen until the next
// player confirms they hold the device, so nobody sees the prior hand.
function HandoffOverlay({ name, seat, giftTo, discardEvent, onReveal }) {
return (
Pass the device
{name}, you're up
{discardEvent
? <>{discardEvent} β you'll privately make your choice for this event.
: giftTo
? <>A card to pass β you'll privately choose one to give to {giftTo}.
: "Make sure the previous forager has looked away, then reveal your private hand."}
);
}
// What the named player must do (or what just happened to them) for the season
// event now on the table β drives the line on the season-change card.
function seasonAckAction(game, seat) {
const ev = game.event;
if (!ev || ev.neutralized || ev.name === "Still Day" || ev.name === "Mild Season") {
return { needsAction: false, text: "A calm turn of the season β no action needed. Forage on." };
}
const inQueue = (cur, q, key) => cur && (cur[key] === seat || (q || []).includes(seat));
const pd = game.pendingDiscard;
if (pd) {
const owes = inQueue(pd, game.pendingDiscardQueue, "seat");
const mode = pd.mode === "in_season" ? "in-season " : pd.mode === "out_of_season" ? "out-of-season " : "";
return owes
? { needsAction: true, text: `You'll choose which ${mode}card(s) to discard once every forager has read the card.` }
: { needsAction: false, text: "Nothing of yours is at risk β no discard for you." };
}
const pc = game.pendingChoice;
if (pc) {
const owes = inQueue(pc, game.pendingChoiceQueue, "seat");
return owes
? { needsAction: true, text: "You'll choose how to take the loss once every forager has read the card." }
: { needsAction: false, text: "Nothing of yours is affected this round." };
}
const pb = game.pendingBoon;
if (pb) {
const owes = inQueue(pb, game.pendingBoonQueue, "seat");
return owes
? { needsAction: true, text: "You'll choose whether to use this boon once every forager has read the card." }
: { needsAction: false, text: "You've no card that qualifies β nothing to gain here." };
}
const ps = game.pendingSwap;
if (ps) {
const owes = inQueue(ps, game.pendingSwapQueue, "seat");
return owes
? { needsAction: true, text: "You'll choose whether to swap a card at the fair once every forager has read the card." }
: { needsAction: false, text: "No swap available to you this round." };
}
const pg = game.pendingGift;
if (pg) {
const owes = inQueue(pg, game.pendingGiftQueue, "from");
const side = pg.dir === "right" ? "right" : "left";
return owes
? { needsAction: true, text: `You'll pass one card to the forager on your ${side} once every forager has read the card.` }
: { needsAction: false, text: "You've nothing to pass this round." };
}
switch (ev.name) {
case "Bounty": return { needsAction: false, text: "Two fresh cards have already been added to your hand." };
case "Open Market": return { needsAction: false, text: "A free market card has already been added to your hand." };
case "Knowledge Keeper": return { needsAction: false, text: "The best of the top three deck cards is already in your hand." };
case "Mentor's Visit": return { needsAction: false, text: "The best of the top two deck cards is already in your hand." };
case "Forager's Cache": return { needsAction: false, text: "A card from the discard pile is already in your hand." };
case "Overgrowth": return { needsAction: false, text: "Fresh cards have already been added to your hand." };
default: return { needsAction: false, text: "No action needed β forage on." };
}
}
// Season turn-over gate: every human reads and dismisses the new season's card
// (one at a time, hot-seat private) and performs the action it calls for.
function SeasonChangeModal({ season, event, playerName, seat, multi, needHandoff, action, gained, lost, onReveal, onAck }) {
// Gate the action until the flip has revealed the card front. Reset on the
// render where the event changes (a new season card needs a fresh reveal).
// Done during render β not in an effect β so it can't race the child flip's
// onRevealed callback (child effects fire before parent effects, which under
// reduced motion would otherwise re-gate an already-revealed card).
const [revealed, setRevealed] = React.useState(false);
const evName = event ? event.name : null;
const prevEvName = React.useRef(evName);
if (prevEvName.current !== evName) {
prevEvName.current = evName;
if (revealed) setRevealed(false);
}
if (needHandoff) {
return (
The season turns
{season} arrives
Pass the device to {playerName} so they can read this season's card.
{/* The action prompt + button stay gated until the card has flipped to
its front, so the player reads the rule before acting. */}
{revealed ? (
<>
{gained && gained.length > 0 && (
{gained.length === 1 ? "Added to your hand" : `Added to your hand Β· ${gained.length}`}
{lost.length === 1 ? "Lost from your hand" : `Lost from your hand Β· ${lost.length}`}
{lost.map((c) => (
{c.art_path && }
{c.name}
))}
)}
{/* Suppress the prose line when the gained/lost chips already say it
(pure gain or auto-loss events with no action to take). */}
{(action.needsAction || !((gained && gained.length > 0) || (lost && lost.length > 0))) && (
);
}
function prefersReducedMotion() {
return typeof window !== "undefined" && window.matchMedia
&& window.matchMedia("(prefers-reduced-motion: reduce)").matches;
}
function eventArtPath(event) {
const slug = event && EVENT_SLUG[event.name];
return slug ? `/assets/events/forage/${slug}.png` : null;
}
// The full event card β a real card at the game's 5:7 proportions, tone-tinted
// (good/bad/calm/social), with the herbarium engraved frame, the event art
// (mix-blend multiply, like the plant plates), the event NAME as title, a
// " Β· event" kicker, and the rule text as the body.
function EventCardFront({ event }) {
const [artOk, setArtOk] = React.useState(true);
if (!event) return null;
const art = eventArtPath(event);
return (
);
}
// The face-down card: herbarium frame + centered art only β no text at all.
function EventCardBack({ event }) {
const [artOk, setArtOk] = React.useState(true);
const art = eventArtPath(event);
return (
{art && artOk
? setArtOk(false)} />
: β¦}
);
}
// 3-D flip: starts showing the BACK, then flips to reveal the FRONT β after a
// short beat, or immediately when the player taps the card. Calls onRevealed
// once the front is showing so the modal can ungate the action. Honors
// prefers-reduced-motion (shows the front at once, no animation).
function EventCardFlip({ event, onRevealed }) {
const reduce = prefersReducedMotion();
const [revealed, setRevealed] = React.useState(reduce);
const firedRef = React.useRef(false);
const reveal = React.useCallback(() => {
setRevealed(true);
}, []);
// Tap-driven reveal, with an auto-flip safety net so the action is ALWAYS
// reachable even if the player never taps (a missed tap on mobile must not
// strand them before the "Got it" button). Tapping flips instantly. Reduced
// motion starts already revealed.
React.useEffect(() => {
if (reduce || revealed) return undefined;
const t = setTimeout(() => setRevealed(true), 1600);
return () => clearTimeout(t);
}, [reduce, revealed]);
// Notify the parent once, when the front first becomes visible.
React.useEffect(() => {
if (revealed && !firedRef.current) {
firedRef.current = true;
if (onRevealed) onRevealed();
}
}, [revealed, onRevealed]);
return (
Each turn you get one card pull: either
draw 1 card blind from the deck, or take
{slotMarket ? <> the oldest market card free : <> a free market card},
{" "}or buy one by trading in in-season hand cards{slotMarket
? <> β buying a card also sweeps every cheaper card to its left
: <> ({Forage.MARKET_COST.slice(1).join(", ")} in value)}
{" "}(a card is worth its current-season Cal+Bot+Seeds total).
That's your one pull β then take one main action:
build, clear a card, or pass.
Collect cards that share a biome, then build a
biome forest (3+ different layers) β every build scores and
counts toward the {game.preset.biomeTarget}-biome goal. Also possible:
a layer set (3+ cards that share one layer, any biome), a
mushroom set, or the 4-card Codex.
Mushrooms & guidance cards are weevil-proof and can't be cleared or traded.
Build {game.preset.biomeTarget} different biomes to win outright, or be ahead on
points when someone hits {game.preset.pointsTarget}. Tap a hand card for its field note.
{game.cfg.allowForestInfill && (
Community Forests (advanced) is on. Instead of building, you may
grow a rival's unfinished forest β completing missing layers from
your hand to score the points gain (but no biome credit for you).
Watch for ″ Grow⦠actions. The flip side: leaving your own forests thin
invites rivals to harvest the difference.
)}
)}
{/* Draw pile β its own titled group, weighted like the market. */}
Draw pile{game.deck.length} left
{/* Marketplace β the face-up row you buy from. */}
Marketplace
{freeUsed
? "card taken this turn β market closed until your next turn"
: slotMarket
? "one pull a turn: take the oldest free, buy a bundle, or draw the next card"
: "one pull a turn: take any card free, buy a card, or draw the next card"}
{slotMarket && (
β΅ oldest Β· cheapest
buying a card also takes every card to its leftnewest Β· priciest βΆ
)}
{game.market.map((c, i) => {
const cost = Forage.marketBuyCost(game, i);
const count = Forage.marketBuyCount(game, i);
// One pull per turn: once any card is taken or drawn, the
// whole market is closed for the rest of the turn.
const pullUsed = freeUsed;
// During a slot purchase, the picked card and every cheaper
// one to its left form the bundle you'd get β highlight them,
// dim the rest.
const inBundle = !!(purchase && purchase.slotIndex != null && i <= purchase.slotIndex);
const slotLabel = slotMarket
? (i === 0 ? `#1 Β· oldest` : i === game.market.length - 1 ? `#${i + 1} Β· newest` : `#${i + 1}`)
: null;
return (
{slotLabel &&
{slotLabel}
}
{swapActive ? (
) : (
)}
);
})}
{humansCount > 1 && viewer ? `${viewer.name}'s hand` : "Your hand"} Β· {viewer ? viewer.hand.length : 0} cards
{discard
? `${discard.event} β choose ${discard.required} ${discardModeLabel} card${discard.required === 1 ? "" : "s"} to discard`
: choice
? `${choice.event} β choose how to take the loss (buttons below)`
: boon
? `${boon.event} β ${boon.canUse ? `tap an in-season ${RESOURCE_LABEL[boon.kind]} card to use it, or decline` : "nothing to use β continue below"}`
: swapActive
? `Market Fair β ${swapHandUid ? "tap a market card to take it" : "tap a card to give up"}`
: purchase
? `Trading in for a market card β tap any in-season cards (you can pick several)`
: buildDraft
? (buildDraft.kind === "layer_set"
? "Composing a layer set β tap same-layer plants to add or remove them"
: `Composing a ${buildDraft.biome} forest β tap cards to add or remove them`)
: game.pendingGift
? `${game.pendingGift.dir === "right" ? "Generous Neighbor" : "Forager's Gift"} β tap a card, then confirm to pass it to ${game.pendingGift.to}`
: myTurn ? "your turn β buy from the market, then take one main action" : "the others are foragingβ¦"}
{discard && (
{discard.selected.length} of {discard.required} chosen
weevils take {discard.required} {discardModeLabel ? `${discardModeLabel} ` : ""}card{discard.required === 1 ? "" : "s"} β you pick which
{discard.selected.length === discard.required
? "β ready β confirm below"
: "π mushrooms & guidance are never owed, but you may choose them"}
)}
{purchase && (
= purchase.cost ? " ok" : ""}`}>
{purchase.selected.length} card{purchase.selected.length === 1 ? "" : "s"} selected
trade-in value {payTotal} / {purchase.cost} needed
{payTotal >= purchase.cost
? "β enough β confirm below (extra value is not refunded)"
: `tap ${purchase.cost - payTotal} more in value to afford this`}
You need to trade in cards with {purchase.cost} resource{purchase.cost === 1 ? "" : "s"} this season to buy these cards.
The highlighted cards above are the {purchaseCount} you'll get β the card you picked and every cheaper one below it. Tap in-season cards in your hand worth {purchase.cost} total, then confirm.
) : guidance ? (