honeytree 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honeytree",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "A living pixel art forest that grows while you code",
   "type": "module",
   "bin": {

package/src/renderers/terminal.js

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 
 import { getDynamicScene, getCrystalPalette } from "../core/animation.js";
-import { getEnvironmentSnapshot } from "../core/environment.js";
+import { getEnvironmentSnapshot, lerpColor } from "../core/environment.js";
 import { VIRTUAL_WIDTH } from "../core/progression.js";
 import {
   getAnimalSprite,
@@ -20,14 +20,20 @@ export const SCENE_HEIGHT = ART_ROWS + STATS_ROWS;
 
 function createBuffer(width) {
   return Array.from({ length: ART_ROWS }, () =>
-    Array.from({ length: width }, () => ({ char: " ", color: null })),
+    Array.from({ length: width }, () => ({ char: " ", color: null, bg: null })),
   );
 }
 
 function paint(buffer, x, y, char, color) {
   if (y < 0 || y >= buffer.length) return;
   if (x < 0 || x >= buffer[0].length) return;
-  buffer[y][x] = { char, color };
+  buffer[y][x] = { char, color, bg: buffer[y][x].bg };
+}
+
+function paintBg(buffer, x, y, bg) {
+  if (y < 0 || y >= buffer.length) return;
+  if (x < 0 || x >= buffer[0].length) return;
+  buffer[y][x].bg = bg;
 }
 
 function compositeSprite(buffer, sprite, centerX, baseY, palette) {
@@ -44,11 +50,42 @@ function compositeSprite(buffer, sprite, centerX, baseY, palette) {
   }
 }
 
-function colorize(text, color, enabled) {
-  if (!enabled || !color) {
-    return text;
+function colorize(text, color, bg, enabled) {
+  if (!enabled) return text;
+  if (!color && !bg) return text;
+  let fn = chalk;
+  if (bg) fn = fn.bgHex(bg);
+  if (color) fn = fn.hex(color);
+  return fn(text);
+}
+
+function drawSkyBackground(buffer, width, environment) {
+  const sky = environment.sky;
+  // Sky rows: vertical gradient from top → mid → bottom
+  for (let y = 0; y < SKY_ROWS; y++) {
+    const t = y / Math.max(1, SKY_ROWS - 1);
+    let color;
+    if (t < 0.5) {
+      color = lerpColor(sky.top, sky.mid, t * 2);
+    } else {
+      color = lerpColor(sky.mid, sky.bottom, (t - 0.5) * 2);
+    }
+    for (let x = 0; x < width; x++) {
+      paintBg(buffer, x, y, color);
+    }
+  }
+  // Forest rows: blend from sky.bottom toward ground
+  for (let y = SKY_ROWS; y < SKY_ROWS + FOREST_ROWS; y++) {
+    const t = (y - SKY_ROWS) / Math.max(1, FOREST_ROWS - 1);
+    const color = lerpColor(sky.bottom, environment.palette.groundDark, t * 0.7);
+    for (let x = 0; x < width; x++) {
+      paintBg(buffer, x, y, color);
+    }
+  }
+  // Ground row: solid ground color
+  for (let x = 0; x < width; x++) {
+    paintBg(buffer, x, ART_ROWS - 1, environment.palette.groundDark);
   }
-  return chalk.hex(color)(text);
 }
 
 function drawSky(buffer, width, environment, tick) {
@@ -126,6 +163,20 @@ function scaleX(virtualX, width) {
   return Math.round((virtualX / VIRTUAL_WIDTH) * width);
 }
 
+function spaceTrees(trees, width, minGap) {
+  const sorted = [...trees].sort((a, b) => a.x_position - b.x_position);
+  const result = [];
+  let lastScreenX = -Infinity;
+  for (const tree of sorted) {
+    const screenX = Math.round((tree.x_position / VIRTUAL_WIDTH) * width);
+    if (screenX - lastScreenX >= minGap) {
+      result.push(tree);
+      lastScreenX = screenX;
+    }
+  }
+  return result;
+}
+
 function drawForest(buffer, width, state, environment, tick) {
   const treeBaseY = SKY_ROWS + FOREST_ROWS - 1;
   const isSunsetSilhouette = environment.sky.name === "sunset";
@@ -138,23 +189,24 @@ function drawForest(buffer, width, state, environment, tick) {
 
   const crystalPalette = getCrystalPalette(tick);
 
-  // Sort trees by row: back first, then mid, then front
-  const rowOrder = { back: 0, mid: 1, front: 2 };
-  const sortedTrees = [...state.trees].sort(
-    (a, b) => (rowOrder[a.row] ?? 2) - (rowOrder[b.row] ?? 2),
-  );
+  // Separate trees by row, then filter for spacing
+  const minGap = { back: 6, mid: 10, front: 14 };
+  const rows = ["back", "mid", "front"];
+  for (const targetRow of rows) {
+    const rowTrees = state.trees.filter((t) => (t.row || "front") === targetRow);
+    const spaced = spaceTrees(rowTrees, width, minGap[targetRow]);
+    const rowY = targetRow === "back" ? treeBaseY - 2 : targetRow === "mid" ? treeBaseY - 1 : treeBaseY;
 
-  for (const tree of sortedTrees) {
-    const row = tree.row || "front";
-    const rowY = row === "back" ? treeBaseY - 2 : row === "mid" ? treeBaseY - 1 : treeBaseY;
-    let palette = environment.palette;
-    if (tree.species === "crystal_tree") {
-      palette = { ...environment.palette, ...crystalPalette };
-    }
-    if (isSunsetSilhouette) {
-      palette = silhouettePalette;
+    for (const tree of spaced) {
+      let palette = environment.palette;
+      if (tree.species === "crystal_tree") {
+        palette = { ...environment.palette, ...crystalPalette };
+      }
+      if (isSunsetSilhouette) {
+        palette = silhouettePalette;
+      }
+      compositeSprite(buffer, getTreeSprite(tree.species), scaleX(tree.x_position, width), rowY, palette);
     }
-    compositeSprite(buffer, getTreeSprite(tree.species), scaleX(tree.x_position, width), rowY, palette);
   }
 
   for (const element of state.ground_elements) {
@@ -162,7 +214,9 @@ function drawForest(buffer, width, state, environment, tick) {
   }
 
   const scene = getDynamicScene(state, width, tick, environment);
-  for (const animal of scene.animals) {
+  const maxAnimals = Math.max(2, Math.min(4, Math.floor(width / 25)));
+  const visibleAnimals = scene.animals.slice(0, maxAnimals);
+  for (const animal of visibleAnimals) {
     if (animal.type === "owl" && environment.sky.name !== "night") {
       continue;
     }
@@ -187,12 +241,12 @@ function buildStatsLine(state, environment, width, color) {
   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}`;
-  const separator = colorize(" • ", "#6b7280", color);
+  const separator = colorize(" • ", "#6b7280", null, color);
   const line = [
-    colorize("🌲 " + trees, "#7bd389", color),
-    colorize("🐇 " + animals, "#f4d35e", color),
-    colorize("🔥 " + streak, "#ee964b", color),
-    colorize(weather, "#d4d4d8", color),
+    colorize("🌲 " + trees, "#7bd389", null, color),
+    colorize("🐇 " + animals, "#f4d35e", null, color),
+    colorize("🔥 " + streak, "#ee964b", null, color),
+    colorize(weather, "#d4d4d8", null, color),
   ].join(separator);
 
   if (line.length >= width) {
@@ -207,6 +261,7 @@ export function buildTerminalScene(state, termWidth = 80, tick = 0, options = {}
   const environment = getEnvironmentSnapshot(date, state.current_streak ?? 0);
   const buffer = createBuffer(width);
 
+  drawSkyBackground(buffer, width, environment);
   drawSky(buffer, width, environment, tick);
   drawWeather(buffer, width, environment, tick);
   drawSeasonParticles(buffer, width, environment, tick);
@@ -233,7 +288,7 @@ export function renderTerminalFrame(state, termWidth = 80, tick = 0, options = {
   const scene = buildTerminalScene(state, termWidth, tick, options);
   const lines = scene.buffer.map((row) =>
     row
-      .map((cell) => colorize(cell.char, cell.color, options.color !== false))
+      .map((cell) => colorize(cell.char, cell.color, cell.bg, options.color !== false))
       .join(""),
   );
   lines.push(scene.statsLine);