Initial tree implementation

Author: IrishBruse

src/trees/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+## 0.1.4
+
+- Changed: the needle tip sits 3 cells (12 pixels) above the top of the trunk.
+
+## 0.1.3
+
+- Changed: trunk growth is faster for testing. The canopy grows one needle row at a time.
+
+## 0.1.2
+
+- Changed: the pine trunk is 3 cells wide.
+
+## 0.1.1
+
+- Changed: the pine trunk is terrain. Mine it with a shovel or drill. The rest of the tree falls as raw wood.
+
+## 0.1.0
+
+- Added: pine seeds grow on wet sand into a 48-cell tree with a wide needle canopy.
+- Added: cut the base trunk to drop raw wood. Needles drop leaf dust that composts into dirt.
+- Added: sealed burning raw wood turns into charcoal. Open flame still burns to ash.

src/trees/README.md

@@ -0,0 +1,45 @@
+# Trees
+
+Pine trees, harvested wood, and charcoal for Sandustry.
+
+## Use
+
+1. Enable the mod and load a save.
+2. **Debug menu:** equip the Debug tool → **Element** brush → **Pine Seed**.
+3. Drop a seed onto **Wet Sand**. The wet sand becomes **Sand**. A pine grows up 48 cells. The trunk is **Pine Wood terrain**, 3 cells wide.
+4. Needles grow as a wide cone, one row at a time. The tip sits a few cells above the trunk.
+5. Mine any **trunk** cell with a shovel or drill. The rest of the trunk falls as **Raw Wood**. Needles fall as **Leaf Dust**.
+6. Burn a sealed pile of Raw Wood (no empty cells in the 8 neighbors) to make **Charcoal**. Open flame makes vanilla burnt residue and steam.
+7. Leaf Dust that rests in place becomes **Dirt**.
+
+Old trees from 0.1.0 are static elements. Plant a new seed after you reload.
+
+## Kiln (manual)
+
+1. Pile Raw Wood on a floor.
+2. Ignite it with a flamethrower or spark.
+3. Cover every neighbor, including diagonals, with sand, soil, or other solids.
+4. Dig the pile. Harvest Charcoal.
+
+## Factory (vanilla parts)
+
+No extra machines. Use conveyors, sensors, drills, pistons, and hoppers.
+
+- **Tree farm:** a sensor above a mature canopy fires a drill at the trunk. Catch falling Raw Wood in a hopper.
+- **Kiln chute:** drop Raw Wood down a shaft. Spark at the intake. Keep the shaft sealed (no empty diagonal cells). Gate Charcoal onto a belt below.
+
+## Options
+
+- **Mod enabled** — turn pine trees, wood, and charcoal off.
+
+## Dev
+
+```bash
+npm run dev -- --mod trees
+```
+
+Hard-reload Sandustry after the bundle writes.
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md).

src/trees/elements/definitions.ts

@@ -0,0 +1,118 @@
+import { ELEMENT, NAME_KEY, VANILLA_ELEMENT } from "./ids.ts";
+
+const MatterType = sandkit.enums.MatterType;
+
+type LiveRegister = Parameters<typeof sandkit.api.elements.register>[0] & {
+  interactions?: readonly { kind: string; structures?: readonly string[] }[];
+  isGrabbable?: boolean;
+  isTransportable?: boolean;
+  metaColor?: number;
+  flammable?: {
+    outputElementId?: string;
+    outputChance?: number;
+  };
+};
+
+function definition(partial: LiveRegister): LiveRegister {
+  return partial;
+}
+
+export const ELEMENT_DEFINITIONS: LiveRegister[] = [
+  definition({
+    id: ELEMENT.pineSeed,
+    nameKey: NAME_KEY.pineSeed,
+    density: 220,
+    matterType: MatterType.Solid,
+    metaColor: 0x6b4226,
+    isGrabbable: true,
+    isTransportable: true,
+    colors: {
+      variants: [
+        [107, 66, 38],
+        [92, 54, 30],
+        [130, 82, 48],
+      ],
+    },
+  }),
+  definition({
+    id: ELEMENT.pineShoot,
+    nameKey: NAME_KEY.pineShoot,
+    density: 160,
+    matterType: MatterType.Static,
+    metaColor: 0x5c3a21,
+    colors: {
+      variants: [
+        [92, 58, 33],
+        [74, 46, 26],
+        [110, 70, 40],
+      ],
+    },
+    defaultDataFields: { field1: 0, field2: 0, field3: 1, field4: 0 },
+  }),
+  definition({
+    id: ELEMENT.pineNeedle,
+    nameKey: NAME_KEY.pineNeedle,
+    density: 40,
+    matterType: MatterType.Static,
+    metaColor: 0x2f5a32,
+    colors: {
+      variants: [
+        [47, 90, 50],
+        [36, 72, 40],
+        [62, 110, 58],
+      ],
+    },
+    defaultDataFields: { field1: 0, field2: 0 },
+  }),
+  definition({
+    id: ELEMENT.rawWood,
+    nameKey: NAME_KEY.rawWood,
+    density: 120,
+    matterType: MatterType.Solid,
+    metaColor: 0xb07a48,
+    isGrabbable: true,
+    isTransportable: true,
+    interactions: [{ kind: "flammable" }],
+    flammable: { outputElementId: VANILLA_ELEMENT.burntResidue, outputChance: 1 },
+    colors: {
+      variants: [
+        [176, 122, 72],
+        [150, 98, 56],
+        [196, 140, 88],
+      ],
+    },
+  }),
+  definition({
+    id: ELEMENT.charcoal,
+    nameKey: NAME_KEY.charcoal,
+    density: 200,
+    matterType: MatterType.Solid,
+    metaColor: 0x2a2a2a,
+    isGrabbable: true,
+    isTransportable: true,
+    colors: {
+      variants: [
+        [42, 42, 42],
+        [28, 28, 28],
+        [58, 54, 50],
+      ],
+    },
+  }),
+  definition({
+    id: ELEMENT.leafDust,
+    nameKey: NAME_KEY.leafDust,
+    density: 55,
+    matterType: MatterType.Powder,
+    metaColor: 0x6b7a3a,
+    isGrabbable: true,
+    isTransportable: true,
+    colors: {
+      variants: [
+        [107, 122, 58],
+        [90, 104, 46],
+        [128, 138, 72],
+      ],
+    },
+    defaultDataFields: { field1: 0 },
+  }),
+];

src/trees/elements/ids.ts

@@ -0,0 +1,32 @@
+import { modinfo } from "../modinfo.ts";
+
+const root = modinfo.id;
+
+export const ELEMENT = {
+  pineSeed: `${root}:pineSeed`,
+  pineShoot: `${root}:pineShoot`,
+  pineNeedle: `${root}:pineNeedle`,
+  rawWood: `${root}:rawWood`,
+  charcoal: `${root}:charcoal`,
+  leafDust: `${root}:leafDust`,
+} as const;
+
+export const TERRAIN = {
+  pineWood: `${root}:pineWood`,
+} as const;
+
+export const NAME_KEY = {
+  pineSeed: `${root}.pineSeed.name`,
+  pineShoot: `${root}.pineShoot.name`,
+  pineWood: `${root}.pineWood.name`,
+  pineNeedle: `${root}.pineNeedle.name`,
+  rawWood: `${root}.rawWood.name`,
+  charcoal: `${root}.charcoal.name`,
+  leafDust: `${root}.leafDust.name`,
+} as const;
+
+export const VANILLA_ELEMENT = {
+  wetSand: "wetSand",
+  sand: "sand",
+  burntResidue: "burntResidue",
+} as const;

src/trees/elements/register.ts

@@ -0,0 +1,31 @@
+import { ELEMENT_DEFINITIONS } from "./definitions.ts";
+import { ELEMENT, NAME_KEY } from "./ids.ts";
+
+const api = sandkit.api;
+
+export function registerElements(): void {
+  api.i18n.register("en", {
+    [NAME_KEY.pineSeed]: "Pine Seed",
+    [NAME_KEY.pineShoot]: "Pine Shoot",
+    [NAME_KEY.pineWood]: "Pine Wood",
+    [NAME_KEY.pineNeedle]: "Pine Needle",
+    [NAME_KEY.rawWood]: "Raw Wood",
+    [NAME_KEY.charcoal]: "Charcoal",
+    [NAME_KEY.leafDust]: "Leaf Dust",
+  });
+
+  for (const definition of ELEMENT_DEFINITIONS) {
+    const { elementType } = api.elements.register(
+      definition as Parameters<typeof api.elements.register>[0],
+    );
+    if (definition.flammable) {
+      api.elements.addInteractionInfo(elementType, { kind: "flammable" });
+      api.elements.updateDefinition(elementType, {
+        flammable: definition.flammable,
+      } as Parameters<typeof api.elements.updateDefinition>[1]);
+    }
+    if (definition.id !== ELEMENT.pineShoot) {
+      api.discoveries.addElementByType(elementType);
+    }
+  }
+}

src/trees/main.ts

@@ -0,0 +1,17 @@
+import { isEnabled } from "@modkit/utils";
+import { registerElements } from "./elements/register.ts";
+import { registerHarvest } from "./terrains/harvest.ts";
+import { registerTerrains } from "./terrains/register.ts";
+
+const api = sandkit.api;
+
+if (isEnabled(api)) {
+  registerElements();
+  const pineWoodType = registerTerrains();
+  registerHarvest(pineWoodType);
+  api.events.on("game:ready", () => {
+    api.ui.toast("Trees — Debug → Element → Pine Seed", {});
+  });
+}
+
+console.log("loaded — pine trees, raw wood, charcoal");

src/trees/modinfo.ts

@@ -0,0 +1,25 @@
+import { defineModInfo } from "@modkit/modinfo";
+
+export const modinfo = defineModInfo({
+  manifestVersion: 1,
+  id: "irishbruse.trees",
+  name: "Trees",
+  version: "0.1.4",
+  apiVersion: 1,
+  gameVersion: { minimum: "0.5.5" },
+  entry: "main.js",
+  workerEntry: "worker.js",
+  author: "IrishBruse",
+  description:
+    "Pine trees grow on wet sand. Mine the trunk to harvest wood. Seal burning wood to make charcoal.",
+  dependencies: [],
+  loadOrder: 0,
+  configSchema: {
+    enabled: {
+      type: "boolean",
+      default: true,
+      labelKey: "Mod enabled",
+      descriptionKey: "Turn pine trees, wood, and charcoal off.",
+    },
+  },
+});

src/trees/sim/air.test.ts

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { countAdjacentAir } from "./air.ts";
+
+test("countAdjacentAir is 8 when every neighbor is empty", () => {
+  assert.equal(
+    countAdjacentAir(() => true, 10, 10),
+    8,
+  );
+});
+
+test("countAdjacentAir is 0 when no neighbor is empty", () => {
+  assert.equal(
+    countAdjacentAir(() => false, 10, 10),
+    0,
+  );
+});
+
+test("countAdjacentAir counts only empty ortho-8 neighbors", () => {
+  const empty = new Set(["11,9", "9,11"]);
+  const count = countAdjacentAir((x, y) => empty.has(`${x},${y}`), 10, 10);
+  assert.equal(count, 2);
+});

src/trees/sim/air.ts

@@ -0,0 +1,13 @@
+import { ORTHO8_DIRS } from "./constants.ts";
+
+export function countAdjacentAir(
+  isEmpty: (cellX: number, cellY: number) => boolean,
+  cellX: number,
+  cellY: number,
+): number {
+  let count = 0;
+  for (const [dx, dy] of ORTHO8_DIRS) {
+    if (isEmpty(cellX + dx, cellY + dy)) count += 1;
+  }
+  return count;
+}

src/trees/sim/burn.ts

@@ -0,0 +1,16 @@
+import { countAdjacentAir } from "./air.ts";
+import type { TreeTypes } from "./types.ts";
+
+export function burnRawWood(
+  api: WorkerSandkitApi,
+  types: TreeTypes,
+  cellX: number,
+  cellY: number,
+  context: { cancel(): void },
+): void {
+  const air = countAdjacentAir((x, y) => api.grid.isCellEmptyAtCell(x, y), cellX, cellY);
+  if (air > 0) return;
+  context.cancel();
+  api.elements.replaceAtCell(cellX, cellY, types.charcoal);
+  api.grid.reportActivityAtCell(cellX, cellY);
+}