honeytree 1.1.2 → 1.1.4

package/src/core/state.js

@@ -46,6 +46,8 @@ export function createEmptyState(now = new Date()) {
     trees: [],
     animals: [],
     ground_elements: [],
+    biome: null,
+    activeSession: null,
   };
 }
 
@@ -127,6 +129,10 @@ export function normalizeState(input = {}) {
     trees: rescalePositions(trees),
     animals: rescalePositions(animals),
     ground_elements: rescalePositions(ground_elements),
+    biome: typeof input.biome === "string" ? input.biome : null,
+    activeSession: input.activeSession && typeof input.activeSession.type === "string"
+      ? { type: input.activeSession.type, strength: input.activeSession.strength ?? 0 }
+      : null,
   };
 }
 

package/src/renderers/terminal.js

@@ -1,16 +1,20 @@
 import chalk from "chalk";
 
 import { getDynamicScene, getCrystalPalette } from "../core/animation.js";
+import { getBiomeConfig } from "../core/biomes/index.js";
 import { getEnvironmentSnapshot, lerpColor } from "../core/environment.js";
 import { VIRTUAL_WIDTH } from "../core/progression.js";
 import {
   getAnimalSprite,
+  getBushSprite,
   getGroundElementSprite,
   getTreeSprite,
   materializeSprite,
 } from "../core/sprites.js";
 
 export const SCENE_HEIGHT = 14;
+const MIN_VISIBLE_TREES = 8;
+const MAX_VISIBLE_TREES = 18;
 
 export function computeLayout(termHeight) {
   if (!termHeight || termHeight < 16) {
@@ -46,24 +50,54 @@ function shuffleSeeded(items, rng) {
 }
 
 export function selectViewportTrees(trees, width, seed = 0) {
-  const maxVisible = 12;
+  const maxVisible = Math.max(MIN_VISIBLE_TREES, Math.min(MAX_VISIBLE_TREES, Math.floor(width / 10)));
   if (trees.length === 0) return [];
 
   const rng = mulberry32(seed);
-  const selected = shuffleSeeded(trees, rng).slice(0, Math.min(maxVisible, trees.length));
   const rowNames = ["back", "mid", "front"];
-  const perRow = Math.ceil(selected.length / rowNames.length);
-  const assigned = selected.map((tree, index) => ({
-    ...tree,
-    row: rowNames[Math.min(rowNames.length - 1, Math.floor(index / perRow))],
-  }));
+  const visibleCount = Math.min(maxVisible, trees.length);
+  const basePerRow = Math.floor(visibleCount / rowNames.length);
+  const extraRows = visibleCount % rowNames.length;
+  const assigned = [];
+  const used = new Set();
+
+  rowNames.forEach((rowName, rowIndex) => {
+    const targetCount = basePerRow + (rowIndex < extraRows ? 1 : 0);
+    const rowTrees = shuffleSeeded(
+      trees.filter((tree, treeIndex) => (tree.row || "front") === rowName && !used.has(treeIndex)),
+      rng,
+    );
+
+    for (const tree of rowTrees.slice(0, targetCount)) {
+      const originalIndex = trees.indexOf(tree);
+      used.add(originalIndex);
+      assigned.push({ ...tree, row: rowName });
+    }
+  });
+
+  if (assigned.length < visibleCount) {
+    const remaining = shuffleSeeded(
+      trees
+        .map((tree, index) => ({ tree, index }))
+        .filter(({ index }) => !used.has(index)),
+      rng,
+    );
+    for (const { tree } of remaining.slice(0, visibleCount - assigned.length)) {
+      const counts = Object.fromEntries(rowNames.map((rowName) => [
+        rowName,
+        assigned.filter((item) => item.row === rowName).length,
+      ]));
+      const row = rowNames.reduce((best, rowName) => (counts[rowName] < counts[best] ? rowName : best), "back");
+      assigned.push({ ...tree, row });
+    }
+  }
 
   for (const rowName of rowNames) {
     const rowTrees = assigned.filter((tree) => tree.row === rowName);
     const count = rowTrees.length;
     if (count === 0) continue;
 
-    const margin = rowName === "front" ? 10 : rowName === "mid" ? 8 : 6;
+    const margin = rowName === "front" ? 8 : rowName === "mid" ? 6 : 4;
     const clampedMargin = Math.min(margin, Math.max(4, Math.floor(width / 4)));
     const minX = Math.min(clampedMargin, Math.max(0, width - 1));
     const maxX = Math.max(minX, width - clampedMargin);
@@ -248,10 +282,71 @@ function desaturatePalette(palette, skyBottom, amount) {
   return result;
 }
 
+function silhouettePalette(palette) {
+  const result = {};
+  for (const key of Object.keys(palette)) {
+    result[key] = key.toLowerCase().includes("light") ? "#24243f" : "#111827";
+  }
+  return result;
+}
+
+function applySessionEffects(environment, biomeConfig, activeSession) {
+  if (!activeSession) return { environment, density: biomeConfig.undergrowthDensity };
+
+  let density = biomeConfig.undergrowthDensity;
+  let palette = { ...environment.palette };
+
+  switch (activeSession.type) {
+    case "refactoring":
+      // Reduce undergrowth, brighten palette slightly
+      density *= 0.5;
+      for (const key of Object.keys(palette)) {
+        if (typeof palette[key] === "string" && palette[key].startsWith("#")) {
+          palette[key] = lerpColor(palette[key], "#ffffff", 0.05);
+        }
+      }
+      break;
+    case "bugfix":
+      // Reduce wilt effect (handled elsewhere), no density change
+      break;
+    case "docs":
+      // No palette change, lanterns added in ground elements
+      break;
+    case "testing":
+      // Slightly more structured — no visual change in palette
+      break;
+  }
+
+  return {
+    environment: { ...environment, palette },
+    density,
+  };
+}
+
+function drawFarTrees(buffer, width, state, environment, layout) {
+  const { skyRows, forestRows } = layout;
+  const farY = skyRows + Math.floor(forestRows * 0.3);
+  const rng = mulberry32(7 + state.trees.length);
+  const count = Math.min(state.trees.length, Math.floor(width / 6));
+
+  const farPalette = desaturatePalette(environment.palette, environment.sky.bottom, 0.5);
+
+  for (let i = 0; i < count; i++) {
+    const x = Math.floor(rng() * width);
+    try {
+      const sprite = getTreeSprite("sapling");
+      compositeSprite(buffer, sprite, x, farY, farPalette, { minY: skyRows });
+    } catch {
+      // skip if sprite not found
+    }
+  }
+}
+
 function drawForest(buffer, width, viewportTrees, state, environment, tick, layout) {
   const { skyRows, forestRows, artRows, groundRows } = layout;
   const treeBaseY = skyRows + forestRows - 1;
   const crystalPalette = getCrystalPalette(tick);
+  const isSunsetSilhouette = environment.sky.name === "sunset";
 
   const rowOffset = { back: 4, mid: 2, front: 0 };
   const rowDesaturation = { back: 0.3, mid: 0.1, front: 0 };
@@ -261,7 +356,9 @@ function drawForest(buffer, width, viewportTrees, state, environment, tick, layo
 
     for (const tree of rowTrees) {
       let palette = environment.palette;
-      if (rowDesaturation[targetRow] > 0) {
+      if (isSunsetSilhouette) {
+        palette = silhouettePalette(palette);
+      } else if (rowDesaturation[targetRow] > 0) {
         palette = desaturatePalette(palette, environment.sky.bottom, rowDesaturation[targetRow]);
       }
       if (tree.species === "crystal_tree") {
@@ -293,6 +390,33 @@ function drawForest(buffer, width, viewportTrees, state, environment, tick, layo
   }
 }
 
+function drawUndergrowth(buffer, width, state, environment, layout, density) {
+  const biomeKey = state.biome || "general";
+  const biomeConfig = getBiomeConfig(biomeKey);
+  const bushTypes = biomeConfig.bushes;
+
+  if (!bushTypes || bushTypes.length === 0 || density <= 0) return;
+
+  const { skyRows, forestRows } = layout;
+  const groundY = skyRows + forestRows - 1;
+
+  // Use seeded RNG for deterministic placement
+  const rng = mulberry32(42 + width);
+  const count = Math.floor(width * density * 0.15);
+
+  for (let i = 0; i < count; i++) {
+    const bushType = bushTypes[Math.floor(rng() * bushTypes.length)];
+    const x = Math.floor(rng() * width);
+    let sprite;
+    try {
+      sprite = getBushSprite(bushType);
+    } catch {
+      continue;
+    }
+    compositeSprite(buffer, sprite, x, groundY, environment.palette, { minY: skyRows });
+  }
+}
+
 function drawGround(buffer, width, environment, layout) {
   const { skyRows, forestRows, groundRows } = layout;
   const groundStart = skyRows + forestRows;
@@ -360,7 +484,8 @@ function drawFog(buffer, width, layout, environment) {
 }
 
 function buildStatsLine(state, environment, width, color) {
-  const trees = `${state.trees.length} tree${state.trees.length === 1 ? "" : "s"} in your forest`;
+  const biomeLabel = state.biome ? getBiomeConfig(state.biome).name : "Forest";
+  const trees = `${state.trees.length} tree${state.trees.length === 1 ? "" : "s"} in your ${biomeLabel.toLowerCase()}`;
   const animals = `${state.animals.length} animal${state.animals.length === 1 ? "" : "s"}`;
   const streak = `${state.current_streak} day streak`;
   const weather = `${environment.season.icon} ${environment.season.label} ${environment.weather.label}`;
@@ -381,7 +506,26 @@ function buildStatsLine(state, environment, width, color) {
 export function buildTerminalScene(state, termWidth = 80, tick = 0, options = {}) {
   const width = Math.max(20, termWidth);
   const date = options.now instanceof Date ? options.now : new Date();
-  const environment = getEnvironmentSnapshot(date, state.current_streak ?? 0);
+  const biomeKey = state.biome || null;
+  let environment = getEnvironmentSnapshot(date, state.current_streak ?? 0, biomeKey);
+
+  // Blend biome sky with time-of-day sky (biome is subtle tint, not full override)
+  const biomeConfig = biomeKey ? getBiomeConfig(biomeKey) : null;
+  if (biomeConfig?.sky?.top) {
+    environment.sky = {
+      ...environment.sky,
+      top: lerpColor(environment.sky.top, biomeConfig.sky.top, 0.3),
+      mid: lerpColor(environment.sky.mid, biomeConfig.sky.mid, 0.3),
+      bottom: lerpColor(environment.sky.bottom, biomeConfig.sky.bottom, 0.3),
+    };
+  }
+
+  const sessionBiomeConfig = biomeKey ? getBiomeConfig(biomeKey) : getBiomeConfig("general");
+
+  // Apply session effects
+  const sessionMods = applySessionEffects(environment, sessionBiomeConfig, state.activeSession);
+  environment = sessionMods.environment;
+
   const layout = computeLayout(options.termHeight || null);
   const buffer = createBuffer(width, layout.artRows);
   const startOfYear = new Date(date.getFullYear(), 0, 0);
@@ -392,7 +536,9 @@ export function buildTerminalScene(state, termWidth = 80, tick = 0, options = {}
   drawSky(buffer, width, environment, tick, layout);
   drawWeather(buffer, width, environment, tick, layout);
   drawSeasonParticles(buffer, width, environment, tick, layout);
+  drawFarTrees(buffer, width, state, environment, layout);
   drawForest(buffer, width, viewportTrees, state, environment, tick, layout);
+  drawUndergrowth(buffer, width, state, environment, layout, sessionMods.density);
   drawGround(buffer, width, environment, layout);
   drawFog(buffer, width, layout, environment);
 
@@ -400,6 +546,7 @@ export function buildTerminalScene(state, termWidth = 80, tick = 0, options = {}
     width,
     environment,
     layout,
+    viewportTrees,
     buffer,
     statsLine: buildStatsLine(state, environment, width, options.color !== false),
   };
@@ -410,6 +557,7 @@ export function renderTerminalFrame(state, termWidth = 80, tick = 0, options = {
     const environment = getEnvironmentSnapshot(
       options.now instanceof Date ? options.now : new Date(),
       state.current_streak ?? 0,
+      state.biome || null,
     );
     return buildStatsLine(state, environment, Math.max(20, termWidth), options.color !== false);
   }