honeytree 1.0.6 → 1.0.7

package/src/core/animation.js

@@ -0,0 +1,135 @@
+const SPEEDS = {
+  butterfly: 0.21,
+  rabbit: 0.13,
+  fox: 0.09,
+  deer: 0.06,
+  owl: 0.04,
+};
+
+function wrap(value, min, max) {
+  const span = max - min;
+  if (span <= 0) return min;
+  let result = value;
+  while (result < min) result += span;
+  while (result > max) result -= span;
+  return result;
+}
+
+function hash(seed) {
+  let value = seed >>> 0;
+  value = Math.imul((value >>> 16) ^ value, 0x45d9f3b) >>> 0;
+  value = Math.imul((value >>> 16) ^ value, 0x45d9f3b) >>> 0;
+  return ((value >>> 16) ^ value) >>> 0;
+}
+
+export function getClouds(width, tick = 0, skyPhase = "day") {
+  const count = skyPhase === "night" ? 2 : 3;
+  return Array.from({ length: count }, (_, index) => {
+    const length = 7 + (index % 3) * 3;
+    const offset = ((tick * (0.35 + index * 0.08)) + index * 17) % (width + length * 2);
+    return {
+      x: Math.round(offset) - length,
+      y: index % 2 === 0 ? 1 : 2,
+      length,
+    };
+  });
+}
+
+export function getStars(width, tick = 0) {
+  const stars = [];
+  for (let column = 0; column < width; column += 1) {
+    const seeded = hash(column * 97);
+    if (seeded % 7 !== 0) continue;
+    stars.push({
+      x: column,
+      y: seeded % 3,
+      twinkle: ((tick + seeded) % 20) / 20,
+    });
+  }
+  return stars;
+}
+
+export function getAnimatedAnimals(state, width, tick = 0) {
+  return state.animals.map((animal, index) => {
+    const speed = SPEEDS[animal.type] ?? 0.08;
+    const direction = animal.direction === "left" ? -1 : 1;
+    const rawX = animal.x_position + direction * tick * speed;
+    const x = wrap(rawX, -6, width + 6);
+    return {
+      ...animal,
+      x,
+      y:
+        animal.type === "butterfly"
+          ? 6 + Math.round(Math.sin((tick + index * 5) / 4))
+          : animal.type === "owl"
+            ? 5 + Math.round(Math.sin((tick + index * 9) / 8))
+            : 11,
+      bob:
+        animal.type === "rabbit"
+          ? Math.abs(Math.sin((tick + index * 6) / 3))
+          : Math.abs(Math.sin((tick + index * 7) / 6)) * 0.35,
+    };
+  });
+}
+
+export function getWeatherParticles(width, height, tick = 0, weather = "clear", season = "summer") {
+  if (weather === "rain") {
+    return Array.from({ length: Math.max(10, Math.floor(width / 4)) }, (_, index) => ({
+      kind: "rain",
+      x: (index * 11 + tick * 2) % width,
+      y: (index * 7 + tick) % height,
+    }));
+  }
+
+  if (weather === "aurora") {
+    return Array.from({ length: width }, (_, index) => ({
+      kind: "aurora",
+      x: index,
+      y: 1 + Math.sin((tick + index) / 8) * 1.5,
+      alpha: 0.2 + ((index + tick) % 10) / 30,
+    }));
+  }
+
+  const particleKind =
+    season === "winter" ? "snow" : season === "spring" ? "petal" : season === "autumn" ? "leaf" : "firefly";
+  const count = season === "summer" ? Math.max(6, Math.floor(width / 10)) : Math.max(8, Math.floor(width / 8));
+
+  return Array.from({ length: count }, (_, index) => ({
+    kind: particleKind,
+    x: wrap(index * 9 + tick * (particleKind === "firefly" ? 0.25 : 0.45), 0, width - 1),
+    y:
+      particleKind === "firefly"
+        ? 6 + Math.sin((tick + index * 7) / 3) * 2
+        : (index * 5 + tick * 0.7) % height,
+    alpha: 0.3 + (Math.sin((tick + index) / 5) + 1) / 3,
+  }));
+}
+
+export function getLlamaAnimation(width, tick = 0, lastSaveTick = -Infinity) {
+  const speed = 0.06;
+  const cycle = width * 2;
+  const raw = (tick * speed) % cycle;
+  const x = raw < width ? raw : cycle - raw;
+  const direction = raw < width ? "right" : "left";
+
+  const ticksSinceSave = tick - lastSaveTick;
+  let pose = "walking";
+  if (ticksSinceSave < 8) {
+    pose = "happy";
+  } else if (ticksSinceSave > 300) {
+    pose = "sitting";
+  }
+
+  return { x: Math.round(x), y: 11, direction, pose };
+}
+
+export function getDynamicScene(state, width, tick, environment, lastSaveTick = -Infinity) {
+  return {
+    clouds: getClouds(width, tick, environment.sky.name),
+    stars: environment.sky.name === "night" ? getStars(width, tick) : [],
+    animals: getAnimatedAnimals(state, width, tick),
+    particles: getWeatherParticles(width, 12, tick, environment.weather.name, environment.season.name),
+    llama: getLlamaAnimation(width, tick, lastSaveTick),
+  };
+}
+

package/src/core/environment.js

@@ -0,0 +1,324 @@
+const MINUTES_PER_DAY = 24 * 60;
+const TRANSITION_MINUTES = 30;
+
+const SKY_PHASES = {
+  sunrise: {
+    top: "#f48c6c",
+    mid: "#f7b267",
+    bottom: "#ffd7a1",
+    haze: "#ffe6c7",
+    celestial: "#ffd166",
+    label: "Sunrise",
+  },
+  day: {
+    top: "#77b7e8",
+    mid: "#9fd0f5",
+    bottom: "#dff1ff",
+    haze: "#ffffff",
+    celestial: "#ffe066",
+    label: "Day",
+  },
+  sunset: {
+    top: "#5c2a72",
+    mid: "#d66f6f",
+    bottom: "#ffbf69",
+    haze: "#ffd6a5",
+    celestial: "#ffd166",
+    label: "Sunset",
+  },
+  night: {
+    top: "#08111f",
+    mid: "#10223d",
+    bottom: "#16314f",
+    haze: "#b9d6ff",
+    celestial: "#f5f3d7",
+    label: "Night",
+  },
+};
+
+const WEATHER_TIERS = [
+  { maxStreak: 2, name: "clear", label: "Clear", icon: "☀" },
+  { maxStreak: 6, name: "rain", label: "Gentle Rain", icon: "🌧" },
+  { maxStreak: 13, name: "rainbow", label: "Rainbow", icon: "🌈" },
+  { maxStreak: 29, name: "golden-hour", label: "Golden Hour", icon: "🌇" },
+];
+
+const SEASON_META = {
+  spring: { label: "Spring", icon: "🌱", particle: "petal" },
+  summer: { label: "Summer", icon: "☀", particle: "firefly" },
+  autumn: { label: "Autumn", icon: "🍂", particle: "leaf" },
+  winter: { label: "Winter", icon: "❄", particle: "snow" },
+};
+
+const BASE_PALETTE = {
+  trunkDark: "#5f3c24",
+  trunk: "#7c5231",
+  trunkLight: "#a06b45",
+  birchBark: "#f4f0e7",
+  birchShadow: "#d6d0c3",
+  leafDark: "#25543b",
+  leaf: "#3b7a57",
+  leafLight: "#67b07d",
+  pineDark: "#183f32",
+  pine: "#2d6a4f",
+  petal: "#ff8fab",
+  petalLight: "#ffcad4",
+  moss: "#799f55",
+  ground: "#447055",
+  groundDark: "#345344",
+  groundLight: "#5d8d69",
+  grass: "#69a65d",
+  grassLight: "#8bcb73",
+  flower: "#ff7aa2",
+  flowerLight: "#ffd3df",
+  flowerCenter: "#ffd166",
+  mushroomCap: "#cb6d51",
+  mushroomStem: "#f5e6d0",
+  stone: "#7c7f88",
+  wing: "#f6d365",
+  wingLight: "#fff1a8",
+  rabbit: "#d8d3cd",
+  rabbitLight: "#f4efea",
+  fox: "#d56b2d",
+  foxLight: "#f2c48f",
+  deer: "#8d5c3b",
+  deerLight: "#cba37b",
+  owl: "#5f5b6b",
+  owlLight: "#d8d7dd",
+  llama: "#e8ddd0",
+  llamaLight: "#f5f0ea",
+  llamaDark: "#c4b5a3",
+  llamaNose: "#f5a0b0",
+};
+
+const SEASON_OVERRIDES = {
+  spring: {
+    leafDark: "#2d6a4f",
+    leaf: "#40916c",
+    leafLight: "#74c69d",
+    ground: "#4a7c59",
+    groundDark: "#355742",
+    groundLight: "#6aa46d",
+    grass: "#74b86a",
+    grassLight: "#a4d98f",
+    flower: "#ff6f91",
+    flowerLight: "#ffd6e0",
+    petal: "#ff8fab",
+    petalLight: "#ffc2d1",
+  },
+  summer: {
+    leafDark: "#1f5a3f",
+    leaf: "#2d6a4f",
+    leafLight: "#52b788",
+    pineDark: "#133828",
+    pine: "#245642",
+    ground: "#3e6f4d",
+    groundDark: "#2c523a",
+    groundLight: "#5b9167",
+    grass: "#67a957",
+    grassLight: "#8ed36b",
+  },
+  autumn: {
+    leafDark: "#8b5a2b",
+    leaf: "#c97b39",
+    leafLight: "#f2b95d",
+    pineDark: "#35553a",
+    pine: "#4d724e",
+    ground: "#6b4f2d",
+    groundDark: "#4d381f",
+    groundLight: "#8f6938",
+    grass: "#8e6b2d",
+    grassLight: "#c49643",
+    flower: "#c2543f",
+    flowerLight: "#f0c29d",
+  },
+  winter: {
+    leafDark: "#8ea3b0",
+    leaf: "#b0c4cf",
+    leafLight: "#dce7ee",
+    pineDark: "#2f4b4e",
+    pine: "#4c7176",
+    ground: "#e4edf2",
+    groundDark: "#c8d5de",
+    groundLight: "#f5fbff",
+    grass: "#dbe6ee",
+    grassLight: "#f7fbff",
+    flower: "#b4c7d8",
+    flowerLight: "#eef6fb",
+    petal: "#d7e4ee",
+    petalLight: "#f5fbff",
+    mushroomCap: "#c3ccd4",
+    stone: "#a3adb8",
+  },
+};
+
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+function parseHex(hex) {
+  const normalized = hex.startsWith("#") ? hex.slice(1) : hex;
+  return {
+    r: Number.parseInt(normalized.slice(0, 2), 16),
+    g: Number.parseInt(normalized.slice(2, 4), 16),
+    b: Number.parseInt(normalized.slice(4, 6), 16),
+  };
+}
+
+function toHex({ r, g, b }) {
+  const encode = (value) => clamp(Math.round(value), 0, 255).toString(16).padStart(2, "0");
+  return `#${encode(r)}${encode(g)}${encode(b)}`;
+}
+
+export function lerpColor(from, to, amount) {
+  const start = parseHex(from);
+  const end = parseHex(to);
+  const mix = clamp(amount, 0, 1);
+  return toHex({
+    r: start.r + (end.r - start.r) * mix,
+    g: start.g + (end.g - start.g) * mix,
+    b: start.b + (end.b - start.b) * mix,
+  });
+}
+
+function lerpPalette(a, b, amount) {
+  const result = {};
+  for (const key of Object.keys(a)) {
+    result[key] = lerpColor(a[key], b[key], amount);
+  }
+  return result;
+}
+
+function getMinutesIntoDay(date) {
+  return date.getHours() * 60 + date.getMinutes();
+}
+
+function getBasePhase(minutes) {
+  if (minutes >= 360 && minutes < 540) {
+    return { name: "sunrise", start: 360, end: 540, previous: "night", next: "day" };
+  }
+  if (minutes >= 540 && minutes < 1020) {
+    return { name: "day", start: 540, end: 1020, previous: "sunrise", next: "sunset" };
+  }
+  if (minutes >= 1020 && minutes < 1200) {
+    return { name: "sunset", start: 1020, end: 1200, previous: "day", next: "night" };
+  }
+  return { name: "night", start: 1200, end: MINUTES_PER_DAY + 360, previous: "sunset", next: "sunrise" };
+}
+
+export function getSkyPhase(date = new Date()) {
+  const minutes = getMinutesIntoDay(date);
+  const phase = getBasePhase(minutes);
+  const minutesInPhase = phase.name === "night" && minutes < 360 ? minutes + MINUTES_PER_DAY - 1200 : minutes - phase.start;
+  const duration = phase.end - phase.start;
+  const progress = clamp(minutesInPhase / duration, 0, 1);
+
+  let colors = SKY_PHASES[phase.name];
+  if (minutesInPhase < TRANSITION_MINUTES) {
+    colors = lerpPalette(
+      SKY_PHASES[phase.previous],
+      SKY_PHASES[phase.name],
+      minutesInPhase / TRANSITION_MINUTES,
+    );
+  } else if (minutesInPhase > duration - TRANSITION_MINUTES) {
+    colors = lerpPalette(
+      SKY_PHASES[phase.name],
+      SKY_PHASES[phase.next],
+      (minutesInPhase - (duration - TRANSITION_MINUTES)) / TRANSITION_MINUTES,
+    );
+  }
+
+  return {
+    name: phase.name,
+    label: SKY_PHASES[phase.name].label,
+    progress,
+    ...colors,
+  };
+}
+
+export function getSeason(date = new Date()) {
+  const month = date.getMonth();
+  if (month >= 2 && month <= 4) return "spring";
+  if (month >= 5 && month <= 7) return "summer";
+  if (month >= 8 && month <= 10) return "autumn";
+  return "winter";
+}
+
+export function getWeather(streak = 0, date = new Date()) {
+  const sky = getSkyPhase(date);
+  const tier = WEATHER_TIERS.find((entry) => streak <= entry.maxStreak);
+  if (tier) {
+    return { ...tier };
+  }
+
+  if (sky.name === "night") {
+    return { name: "aurora", label: "Aurora", icon: "✨" };
+  }
+
+  return { name: "golden-hour", label: "Golden Hour", icon: "🌇" };
+}
+
+export function getSeasonPalette(season) {
+  return {
+    ...BASE_PALETTE,
+    ...(SEASON_OVERRIDES[season] ?? {}),
+  };
+}
+
+export function getEnvironmentSnapshot(date = new Date(), streak = 0) {
+  const season = getSeason(date);
+  const sky = getSkyPhase(date);
+  const weather = getWeather(streak, date);
+  return {
+    season: {
+      name: season,
+      ...SEASON_META[season],
+    },
+    sky,
+    weather,
+    palette: getSeasonPalette(season),
+  };
+}
+
+// Legacy API compatibility functions for simpler use cases
+
+export function getSkyColors(phase) {
+  const colors = SKY_PHASES[phase] ?? SKY_PHASES.day;
+  return {
+    top: colors.top,
+    mid: colors.mid,
+    bottom: colors.bottom,
+  };
+}
+
+export function getSeasonalPalette(season) {
+  return getSeasonPalette(season);
+}
+
+export function getCurrentEnvironment() {
+  const now = new Date();
+  const season = getSeason(now);
+  const sky = getSkyPhase(now);
+  const skyColors = getSkyColors(sky.name);
+  const palette = getSeasonalPalette(season);
+
+  return {
+    season,
+    skyPhase: sky.name,
+    skyColors,
+    palette,
+    hour: now.getHours(),
+    month: now.getMonth(),
+  };
+}
+
+export function getWindIntensity(tick) {
+  // Natural wind using overlapping sine waves for realistic gusts
+  const slow = Math.sin(tick * 0.002) * 0.5 + 0.5;
+  const fast = Math.sin(tick * 0.013) * 0.3 + 0.5;
+  const gust = Math.sin(tick * 0.037) * 0.2 + 0.5;
+
+  // Combine and normalize to 0-1 range
+  return clamp((slow * 0.5 + fast * 0.3 + gust * 0.2), 0, 1);
+}
+

package/src/core/progression.js

@@ -0,0 +1,129 @@
+import { addMinutes } from "date-fns";
+
+import {
+  getAnimalTypeForMinutes,
+  getAnimalSprite,
+  getGroundElementSprite,
+  getGroundElementType,
+  getTreeSpeciesForCommit,
+  getTreeSprite,
+} from "./sprites.js";
+
+function hashString(value) {
+  let hash = 0;
+  for (const char of value) {
+    hash = (hash * 31 + char.charCodeAt(0)) >>> 0;
+  }
+  return hash;
+}
+
+function seededNumber(seed) {
+  let value = hashString(String(seed));
+  value = Math.imul(value ^ (value >>> 15), 0x2c1b3c6d) >>> 0;
+  value = Math.imul(value ^ (value >>> 12), 0x297a2d39) >>> 0;
+  return (value >>> 0) / 0xffffffff;
+}
+
+function dayString(date) {
+  return date.toISOString().slice(0, 10);
+}
+
+function dayNumber(value) {
+  const [year, month, day] = String(value).split("-").map(Number);
+  return Date.UTC(year, month - 1, day) / 86_400_000;
+}
+
+function placeSprite(existing, spriteWidth, width, key) {
+  const safeWidth = Math.max(width, 40);
+  const half = Math.floor(spriteWidth / 2);
+  const minX = half + 1;
+  const maxX = Math.max(minX, safeWidth - half - 2);
+
+  for (let attempt = 0; attempt < 24; attempt += 1) {
+    const rand = seededNumber(`${key}:${attempt}`);
+    const x = Math.round(minX + rand * (maxX - minX));
+    const collides = existing.some((entry) => Math.abs(entry.x_position - x) < half + 2);
+    if (!collides || existing.length > Math.floor(safeWidth / 4)) {
+      return x;
+    }
+  }
+
+  return minX + (existing.length * 7) % Math.max(1, maxX - minX + 1);
+}
+
+export function getNextMinuteCheckpoint(totalMinutes) {
+  return Math.ceil((totalMinutes + 1) / 30) * 30;
+}
+
+export function updateCommitStreak(currentStreak, lastActiveDate, now = new Date()) {
+  if (currentStreak <= 0 || !lastActiveDate) {
+    return 1;
+  }
+  const gap = dayNumber(dayString(now)) - dayNumber(lastActiveDate);
+  if (gap <= 0) {
+    return Math.max(1, currentStreak);
+  }
+  if (gap === 1) {
+    return Math.max(1, currentStreak) + 1;
+  }
+  return 1;
+}
+
+export function applyCommit(state, { commitHash = "", now = new Date(), width = 80 } = {}) {
+  const nextTotal = state.total_commits + 1;
+  const species = getTreeSpeciesForCommit(nextTotal);
+  const sprite = getTreeSprite(species);
+  state.total_commits = nextTotal;
+  state.current_streak = updateCommitStreak(state.current_streak, state.last_active_date, now);
+  state.last_active_date = dayString(now);
+  state.last_commit_hash = commitHash || state.last_commit_hash;
+  state.trees.push({
+    species,
+    planted_at: now.toISOString(),
+    x_position: placeSprite(state.trees, sprite.width, width, `${species}:${nextTotal}`),
+  });
+  return state;
+}
+
+export function applyFileSave(state, { now = new Date(), width = 80 } = {}) {
+  state.total_file_saves += 1;
+  if (state.total_file_saves % 50 === 0) {
+    const type = getGroundElementType(state.total_file_saves);
+    const sprite = getGroundElementSprite(type);
+    state.ground_elements.push({
+      type,
+      x_position: placeSprite(
+        state.ground_elements,
+        sprite.width,
+        width,
+        `${type}:${state.total_file_saves}`,
+      ),
+    });
+  }
+  return state;
+}
+
+export function applyActiveMinutes(state, { minutes = 1, now = new Date(), width = 80 } = {}) {
+  const before = state.total_minutes_coded;
+  const after = before + minutes;
+  state.total_minutes_coded = after;
+
+  let checkpoint = Math.floor(before / 30) * 30 + 30;
+  while (checkpoint <= after) {
+    const type = getAnimalTypeForMinutes(checkpoint);
+    const sprite = getAnimalSprite(type);
+    state.animals.push({
+      type,
+      x_position: placeSprite(state.animals, sprite.width, width, `${type}:${checkpoint}`),
+      direction: state.animals.length % 2 === 0 ? "right" : "left",
+    });
+    checkpoint += 30;
+  }
+
+  return state;
+}
+
+export function applyActivityPulse(state, { now = new Date() } = {}) {
+  const updated = addMinutes(now, 0);
+  return state;
+}