spawnpoint-studio 0.3.4__tar.gz → 0.3.5__tar.gz

{spawnpoint_studio-0.3.4/compiler/spawnpoint_studio.egg-info → spawnpoint_studio-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spawnpoint-studio
-Version: 0.3.4
+Version: 0.3.5
 Summary: Turn a sentence into a juicy, playable Godot 4 game — locally, on a consumer GPU.
 Author: smoky1496
 License: MIT
@@ -22,6 +22,8 @@ Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Dynamic: license-file
 
+<p align="center"><img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/logo.png" width="520" alt="Spawn Point: a sprout growing out of a glowing spawn pad, and the name in gold pixel letters"></p>
+
 # Spawn Point
 
 **Describe a 2D game in one sentence — get a playable, juicy Godot 4 game in seconds.**
@@ -187,8 +189,10 @@ shipping bin, while crows, foxes, rabbits or mice go for your crops. Step throug
 inside (bed, fireplace, table, rug). Maps vary: the house on either side, the field and the pen swapping places, the
 pond moving around. The workbench by the house sells tool upgrades (a watering can and a hoe that work a
 3x3 patch, a bigger basket, a sharper axe, a better rod), and the farm saves itself: close the game and it carries on
-where you left it (a won or lost season, or R, starts a fresh one). On a phone, ACT does all of it and a tap on a seed in
-the bar picks it. The
+where you left it (a won or lost season, or R, starts a fresh one). Some days it rains and the crops water themselves
+(snow on a winter farm); a shop stall sells hens, cows, golden melon seeds and sprinklers that water their patch every
+morning. A farm opens on a title screen (carry on, or N for a new farm), P pauses, and each season has its own little
+chiptune, composed at build time. On a phone, ACT does all of it, a tap on a seed in the bar picks it, and II pauses. The
 hotbar shows your seeds and basket. You walk behind trees and the house (the scene is depth-sorted), and only an
 object's footprint blocks you. `spawnpoint overview <project>` saves a picture of the whole map after a short autopilot
 run, like the one above.
@@ -407,7 +411,7 @@ headless smoke test (spawn, scripted input, crash detection) and report `E_RUNTI
 | Game modes | `BubbleBoard` (a complete bubble shooter: bank shots, colour pops, falling clusters, a descending ceiling) |
 | Shooters | `FlightPath` (straight, wave, dive and hover patterns across the screen), `ShmupShip` (auto-fire, power-ups that add shots and spread), `HealthBar` (boss bars), and `WaveSpawner` gates (`autostart`, `endless`, random spread) |
 | Tower defense | `PathFollower` (walks the road to the base), `Base` (loses a life per invader that gets in), `WaveSpawner` ("8 x Goblin every 1.2; ..."), `TowerSlot`, `TowerBuilder` (click a pad, pay in gold), `TowerBrain` (targets the invader furthest along), `GroundPatch` (roads and paths) |
-| Farming | `FarmPlot` (soil that grows a crop only while watered, drawn from its growth stages), `Farmer` (till / plant / water / harvest, buy seeds, feed, collect, fish, chop, sleep, a basket and a tappable hotbar), `FarmAnimal` (wanders, needs feeding, gives eggs or milk, chicks grow up), `FarmDays` (a season of days with day and night), `SleepSpot` (a bed), `ToolBench` (tool upgrades), `FarmSave` (keeps the farm between plays), `Gatherable` (trees and rocks that break into wood and stone), `FishingSpot` (cast, bite, reel in), `Warp` (doorways, e.g. into the farmhouse), `Market` (a stall or a shipping bin that buys the basket), `CropPest` (crows that eat crops) |
+| Farming | `FarmPlot` (soil that grows a crop only while watered, drawn from its growth stages), `Farmer` (till / plant / water / harvest, buy seeds, feed, collect, fish, chop, sleep, a basket and a tappable hotbar), `FarmAnimal` (wanders, needs feeding, gives eggs or milk, chicks grow up), `FarmDays` (a season of days with day and night), `SleepSpot` (a bed), `ToolBench` (tool upgrades), `FarmSave` (keeps the farm between plays), `Shop` and `Sprinkler` (buy animals, seeds and sprinklers), `GameMenu` (title screen, pause menu, music), `Gatherable` (trees and rocks that break into wood and stone), `FishingSpot` (cast, bite, reel in), `Warp` (doorways, e.g. into the farmhouse), `Market` (a stall or a shipping bin that buys the basket), `CropPest` (crows that eat crops) |
 | Feel | `Juice` — attached to every entity unless `"juice": "none"` |
 
 Runtime autoloads: `GameState` (score, lives, variables, win/lose), `World` (spawning, rule

{spawnpoint_studio-0.3.4 → spawnpoint_studio-0.3.5}/README.md

@@ -1,3 +1,5 @@
+<p align="center"><img src="https://raw.githubusercontent.com/leluong141996-dev/Spawn-Point/main/docs/media/logo.png" width="520" alt="Spawn Point: a sprout growing out of a glowing spawn pad, and the name in gold pixel letters"></p>
+
 # Spawn Point
 
 **Describe a 2D game in one sentence — get a playable, juicy Godot 4 game in seconds.**
@@ -163,8 +165,10 @@ shipping bin, while crows, foxes, rabbits or mice go for your crops. Step throug
 inside (bed, fireplace, table, rug). Maps vary: the house on either side, the field and the pen swapping places, the
 pond moving around. The workbench by the house sells tool upgrades (a watering can and a hoe that work a
 3x3 patch, a bigger basket, a sharper axe, a better rod), and the farm saves itself: close the game and it carries on
-where you left it (a won or lost season, or R, starts a fresh one). On a phone, ACT does all of it and a tap on a seed in
-the bar picks it. The
+where you left it (a won or lost season, or R, starts a fresh one). Some days it rains and the crops water themselves
+(snow on a winter farm); a shop stall sells hens, cows, golden melon seeds and sprinklers that water their patch every
+morning. A farm opens on a title screen (carry on, or N for a new farm), P pauses, and each season has its own little
+chiptune, composed at build time. On a phone, ACT does all of it, a tap on a seed in the bar picks it, and II pauses. The
 hotbar shows your seeds and basket. You walk behind trees and the house (the scene is depth-sorted), and only an
 object's footprint blocks you. `spawnpoint overview <project>` saves a picture of the whole map after a short autopilot
 run, like the one above.
@@ -383,7 +387,7 @@ headless smoke test (spawn, scripted input, crash detection) and report `E_RUNTI
 | Game modes | `BubbleBoard` (a complete bubble shooter: bank shots, colour pops, falling clusters, a descending ceiling) |
 | Shooters | `FlightPath` (straight, wave, dive and hover patterns across the screen), `ShmupShip` (auto-fire, power-ups that add shots and spread), `HealthBar` (boss bars), and `WaveSpawner` gates (`autostart`, `endless`, random spread) |
 | Tower defense | `PathFollower` (walks the road to the base), `Base` (loses a life per invader that gets in), `WaveSpawner` ("8 x Goblin every 1.2; ..."), `TowerSlot`, `TowerBuilder` (click a pad, pay in gold), `TowerBrain` (targets the invader furthest along), `GroundPatch` (roads and paths) |
-| Farming | `FarmPlot` (soil that grows a crop only while watered, drawn from its growth stages), `Farmer` (till / plant / water / harvest, buy seeds, feed, collect, fish, chop, sleep, a basket and a tappable hotbar), `FarmAnimal` (wanders, needs feeding, gives eggs or milk, chicks grow up), `FarmDays` (a season of days with day and night), `SleepSpot` (a bed), `ToolBench` (tool upgrades), `FarmSave` (keeps the farm between plays), `Gatherable` (trees and rocks that break into wood and stone), `FishingSpot` (cast, bite, reel in), `Warp` (doorways, e.g. into the farmhouse), `Market` (a stall or a shipping bin that buys the basket), `CropPest` (crows that eat crops) |
+| Farming | `FarmPlot` (soil that grows a crop only while watered, drawn from its growth stages), `Farmer` (till / plant / water / harvest, buy seeds, feed, collect, fish, chop, sleep, a basket and a tappable hotbar), `FarmAnimal` (wanders, needs feeding, gives eggs or milk, chicks grow up), `FarmDays` (a season of days with day and night), `SleepSpot` (a bed), `ToolBench` (tool upgrades), `FarmSave` (keeps the farm between plays), `Shop` and `Sprinkler` (buy animals, seeds and sprinklers), `GameMenu` (title screen, pause menu, music), `Gatherable` (trees and rocks that break into wood and stone), `FishingSpot` (cast, bite, reel in), `Warp` (doorways, e.g. into the farmhouse), `Market` (a stall or a shipping bin that buys the basket), `CropPest` (crows that eat crops) |
 | Feel | `Juice` — attached to every entity unless `"juice": "none"` |
 
 Runtime autoloads: `GameState` (score, lives, variables, win/lose), `World` (spawning, rule

{spawnpoint_studio-0.3.4 → spawnpoint_studio-0.3.5}/compiler/spawnpoint/build.py

@@ -9,7 +9,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
-from . import godot, manifest as manifest_mod, project, sfx
+from . import godot, manifest as manifest_mod, music, project, sfx
 from .analyze import Analysis, analyze
 from .diagnostics import Diagnostics
 from .manifest import Manifest
@@ -68,6 +68,8 @@ def build(data: Any, out_dir: Path, *, manifest: Manifest | None = None, smoke:
     project.write(out_dir, data, plan, analysis.rules_source, feature, analysis.sprites, analysis.tiles_image,
                   analysis.scenery_images)
     sfx.write_all(out_dir / "sfx", seed=analysis.graph.settings.seed)
+    if analysis.graph.settings.music != "none":
+        music.write(out_dir / "sfx", analysis.graph.settings.music, analysis.graph.settings.seed)
     timings["write"] = time.perf_counter() - t
 
     log: list[str] = []

{spawnpoint_studio-0.3.4 → spawnpoint_studio-0.3.5}/compiler/spawnpoint/cli.py

@@ -97,6 +97,9 @@ def main(argv: list[str] | None = None) -> int:
     gf.add_argument("--focus", default="", choices=["", "field", "animals", "fish", "house"],
                     help="farms: show one activity")
 
+    lg = sub.add_parser("logo", help="write the Spawn Point pixel-art logo (icons, wordmark, favicon)")
+    lg.add_argument("-o", "--out", type=Path, default=Path("logo"))
+
     ov = sub.add_parser("overview", help="save one picture of a built project's whole map (needs a display)")
     ov.add_argument("project", type=Path)
     ov.add_argument("-o", "--out", type=Path, help="output file (default: <project>/overview.png)")
@@ -150,7 +153,7 @@ def main(argv: list[str] | None = None) -> int:
         return {"validate": _validate, "build": _build, "run": _run, "components": _components,
                 "manifest": _manifest, "create": studio_cli.create, "tweak": studio_cli.tweak,
                 "serve": studio_cli.serve, "dataset": studio_cli.dataset, "playtest": studio_cli.playtest, "studio": studio_cli.studio,
-                "sprites": _sprites, "gif": _gif, "overview": _overview, "llm": _llm, "examples": _examples,
+                "sprites": _sprites, "gif": _gif, "overview": _overview, "logo": _logo, "llm": _llm, "examples": _examples,
                 "demo": _demo}[args.cmd](args)
     except godot.GodotError as e:
         print(f"error: {e}", file=sys.stderr)
@@ -264,6 +267,14 @@ def _gif(args) -> int:
     return 0
 
 
+def _logo(args) -> int:
+    from .logo import write
+
+    for path in write(args.out):
+        print(f"Wrote {path}")
+    return 0
+
+
 def _overview(args) -> int:
     from .gif import overview
 

{spawnpoint_studio-0.3.4 → spawnpoint_studio-0.3.5}/compiler/spawnpoint/demo.py

@@ -55,9 +55,9 @@ SHOWCASE = [
      "Move: arrows / WASD | Dash: Shift | Pick an upgrade: 1 / 2 / 3 or click | Restart: R",
      {"pad": "dpad", "buttons": [["DASH", "ShiftLeft"]], "tap": "Move with the stick - you shoot on your own"}),
     ("sunny_farm.json", "farming",
-     "A cozy island farm over three days: buy seeds, till and grow strawberries, carrots and pumpkins, feed the hens and the cow, fish in the pond, chop wood, sleep in the farmhouse, upgrade your tools, and sell it all at the shipping bin. Your farm is saved as you play.",
-     "Move: arrows / WASD | Till, plant, water, harvest, feed, fish, chop, go in, sleep: Space / E | Seed: 1 / 2 / 3 or click it | Shoo crows: X | Restart: R",
-     {"pad": "dpad", "buttons": [["ACT", "Space"], ["SHOO", "KeyX"]],
+     "A cozy island farm over three days: buy seeds, till and grow strawberries, carrots and pumpkins, feed the hens and the cow, fish in the pond, chop wood, sleep in the farmhouse, upgrade your tools, buy hens and sprinklers, and sell it all at the shipping bin. Rainy days water the crops; your farm is saved as you play.",
+     "Move: arrows / WASD | Till, plant, water, harvest, feed, fish, chop, shop, go in, sleep: Space / E | Seed: 1 / 2 / 3 or click it | Shoo crows: X | Pause: P | Restart: R",
+     {"pad": "dpad", "buttons": [["ACT", "Space"], ["SHOO", "KeyX"], ["II", "KeyP"]],
       "tap": "ACT works the field, feeds, fishes and opens doors; tap a seed in the bar to choose it"}),
     ("pixel_arena.json", "arena shooter",
      "A top-down arena: blast through robots and turrets, then reach the portal.",
@@ -127,6 +127,8 @@ def build_site(out: Path, games: list[Game] | None = None, screenshots: bool = T
             share_engine(out, target)
             log(f"  {g.slug}: built (web export {seconds:.1f}s)")
     shutil.copy2(TOUCH_JS, out / "touch.js")  # every game page loads it (before the browser check)
+    from . import logo
+    logo.write(out)  # favicon.ico, logo.png and the icon sizes
     built = [g for g in games if (out / g.slug / "index.html").exists()]
     if screenshots:
         if webcheck.find_chrome() is None:
@@ -205,6 +207,8 @@ def index_html(games: list[Game]) -> str:
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>Spawn Point demos</title>
+<link rel="icon" href="favicon.ico">
+<meta property="og:image" content="logo.png">
 <meta name="description" content="Nine Godot 4 games built with Spawn Point: platformers, a sword fighter, tower defense, a space shooter, a bubble shooter, a survivor, a farm. Play in your browser.">
 <meta property="og:title" content="Spawn Point demos: play Godot games in your browser">
 <meta property="og:description" content="A Mario-style platformer, a ninja rescue, a dinosaur-egg shooter, a survivor and an arena, all built from Spawn Point components.">
@@ -243,7 +247,7 @@ footer {{ color:var(--muted); font-size:13px; padding-bottom:40px }}
 </head>
 <body>
 <header>
-  <h1>Spawn<span>Point</span> demos</h1>
+  <h1 class="brand"><img src="logo-icon-64.png" width="48" height="48" alt="" style="image-rendering:pixelated;vertical-align:middle;margin-right:10px">Spawn<span>Point</span> demos</h1>
   <p class="lede">Nine games, nine ways to play, all built by Spawn Point from small JSON game graphs and a
   library of tested Godot 4 components: game feel, cartoon or pixel art and collisions come for free. Click a card to play in
   your browser, no install needed.</p>

{spawnpoint_studio-0.3.4 → spawnpoint_studio-0.3.5}/compiler/spawnpoint/demo_touch.js

@@ -8,7 +8,7 @@
   var forced = location.search.indexOf("touch") >= 0;  // ?touch shows the controls on a desktop (testing)
   if (!(coarse || forced || "ontouchstart" in window) || location.search.indexOf("shot") >= 0) return;
 
-  var KEYS = {Space: " ", ShiftLeft: "Shift", KeyX: "x", KeyR: "r", KeyE: "e", Digit1: "1", Digit2: "2", Digit3: "3",
+  var KEYS = {Space: " ", ShiftLeft: "Shift", KeyX: "x", KeyR: "r", KeyE: "e", Digit1: "1", Digit2: "2", Digit3: "3", KeyP: "p", KeyN: "n", KeyM: "m",
               ArrowLeft: "ArrowLeft",
               ArrowRight: "ArrowRight", ArrowUp: "ArrowUp", ArrowDown: "ArrowDown"};
   var held = {};

{spawnpoint_studio-0.3.4 → spawnpoint_studio-0.3.5}/compiler/spawnpoint/graph.py

@@ -133,6 +133,8 @@ class Settings(_Model):
     # "~" water, "," tidy grass (fields), "_" sand. Used by farms; replaces the floor and scenery.
     terrain: list[str] | None = None
     season: Literal["spring", "autumn", "winter", "desert"] = "spring"  # the terrain's colours
+    # Background music, composed at build time (see music.py): a season's tune, or none.
+    music: Literal["none", "spring", "autumn", "winter", "desert"] = "none"
     # Draw entities lower on screen in front of the ones above them (top-down games with tall trees and houses).
     y_sort: bool = False
     # Extra pictures for components (crop growth stages, item icons, soil): name -> what to draw.

spawnpoint_studio-0.3.5/compiler/spawnpoint/logo.py

@@ -0,0 +1,167 @@
+"""The Spawn Point logo, drawn as pixel art from code: a glowing spawn pad with a sprout growing out of it, and a
+chunky pixel wordmark. `spawnpoint logo -o <dir>` writes the icon (several sizes), the wordmark and a favicon."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+RGBA = tuple[int, int, int, int]
+
+
+def _c(h: str, a: int = 255) -> RGBA:
+    h = h.lstrip("#")
+    return int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16), a
+
+
+BG, BG_LIGHT, BG_EDGE = _c("#1d1a33"), _c("#2b2650"), _c("#0e0c1c")
+PAD, PAD_LIGHT, PAD_DARK, GLOW = _c("#29adff"), _c("#9ee8ff"), _c("#1a6ab0"), _c("#29adff", 70)
+LEAF, LEAF_LIGHT, LEAF_DARK, STEM = _c("#5cd84a"), _c("#a8f070"), _c("#2c8a3c"), _c("#3fa83a")
+GOLD, GOLD_DARK, GOLD_LIGHT, INK = _c("#ffec27"), _c("#e8902a"), _c("#fff7a8"), _c("#2a1e2e")
+SPARK = _c("#fffaf0")
+
+
+def _blend(dst: np.ndarray, y: int, x: int, c: RGBA) -> None:
+    if 0 <= y < dst.shape[0] and 0 <= x < dst.shape[1]:
+        a = c[3] / 255.0
+        dst[y, x, :3] = (dst[y, x, :3] * (1 - a) + np.array(c[:3]) * a).astype(np.uint8)
+        dst[y, x, 3] = max(dst[y, x, 3], c[3])
+
+
+def icon(size: int = 32) -> np.ndarray:
+    """The square app icon at its art size (32x32 art pixels; scale it up by whole numbers)."""
+    n = 32
+    img = np.zeros((n, n, 4), dtype=np.uint8)
+    # a rounded dark tile with a soft top light
+    for y in range(n):
+        for x in range(n):
+            corner = min(x, n - 1 - x) + min(y, n - 1 - y)
+            if corner < 3 and (min(x, n - 1 - x) < 2 and min(y, n - 1 - y) < 2):
+                if (min(x, n - 1 - x), min(y, n - 1 - y)) in ((0, 0), (0, 1), (1, 0)):
+                    continue
+            img[y, x] = _c("#3a3366") if y < 6 else BG_LIGHT if y < 11 else _c("#24204a") if y < 16 else BG
+    edge = img[..., 3] > 0
+    p = np.pad(edge, 1)
+    ring = edge & ~(p[:-2, 1:-1] & p[2:, 1:-1] & p[1:-1, :-2] & p[1:-1, 2:])
+    img[ring] = BG_EDGE
+    # the beam of light rising from the pad
+    for y in range(6, 25):
+        for x in range(12, 20):
+            a = int(60 * (1 - abs(x - 15.5) / 4.5) * (y - 5) / 19)
+            if a > 0:
+                _blend(img, y, x, (158, 232, 255, a))
+    # the spawn pad: a glowing ellipse
+    for y in range(22, 29):
+        for x in range(5, 27):
+            d = ((x - 15.5) / 10.5) ** 2 + ((y - 25) / 3.2) ** 2
+            if d <= 1.0:
+                img[y, x] = PAD_DARK if d > 0.62 else PAD
+            elif d <= 1.35:
+                _blend(img, y, x, GLOW)
+    for x in range(9, 23):  # the lit inner rim
+        _blend(img, 23, x, PAD_LIGHT)
+    for x in range(11, 21):
+        img[25, x] = PAD_LIGHT if (x % 3) else PAD
+    # the sprout: a stem and two round leaves, a bud on top
+    for y in range(12, 25):
+        img[y, 15] = STEM
+        img[y, 16] = LEAF_DARK
+    for cx, cy, rx, ry in ((11.5, 15.5, 4.2, 2.4), (20.5, 12.5, 4.2, 2.4)):
+        for y in range(int(cy - ry) - 1, int(cy + ry) + 2):
+            for x in range(int(cx - rx) - 1, int(cx + rx) + 2):
+                d = ((x + 0.5 - cx) / rx) ** 2 + ((y + 0.5 - cy) / ry) ** 2
+                if d <= 1.0:
+                    img[y, x] = LEAF_DARK if y + 0.5 > cy + ry * 0.35 else LEAF
+                    if d < 0.35 and y + 0.5 < cy:
+                        img[y, x] = LEAF_LIGHT
+    for (y, x, col) in ((9, 15, LEAF), (9, 16, LEAF), (8, 15, LEAF_LIGHT), (10, 15, LEAF), (10, 16, LEAF_DARK),
+                        (11, 15, STEM), (11, 16, LEAF_DARK)):
+        img[y, x] = col
+    sprout = (img[..., 1] > 150) & (img[..., 0] < 200) & (img[..., 2] < 140)  # an outline round the green
+    q = np.pad(sprout, 1)
+    rim = (q[:-2, 1:-1] | q[2:, 1:-1] | q[1:-1, :-2] | q[1:-1, 2:]) & ~sprout & (np.arange(n)[:, None] < 22)
+    img[rim] = _c("#143a24")
+    # sparkles
+    for (y, x) in ((5, 7), (8, 25), (4, 21), (19, 6)):
+        img[y, x] = SPARK
+        for dy, dx in ((-1, 0), (1, 0), (0, -1), (0, 1)):
+            _blend(img, y + dy, x + dx, (255, 250, 240, 140))
+    return img
+
+
+# A 5x7 pixel font for the wordmark (only the letters it needs, and a few spares).
+GLYPHS = {
+    "S": ["01111", "10000", "10000", "01110", "00001", "00001", "11110"],
+    "P": ["11110", "10001", "10001", "11110", "10000", "10000", "10000"],
+    "A": ["01110", "10001", "10001", "11111", "10001", "10001", "10001"],
+    "W": ["10001", "10001", "10001", "10101", "10101", "10101", "01010"],
+    "N": ["10001", "11001", "10101", "10011", "10001", "10001", "10001"],
+    "O": ["01110", "10001", "10001", "10001", "10001", "10001", "01110"],
+    "I": ["11111", "00100", "00100", "00100", "00100", "00100", "11111"],
+    "T": ["11111", "00100", "00100", "00100", "00100", "00100", "00100"],
+    " ": ["00"] * 7,
+}
+
+
+def wordmark(text: str = "SPAWN POINT", scale: int = 3) -> np.ndarray:
+    """The name in chunky gold pixel letters with a dark outline and a drop shadow (art pixels)."""
+    glyphs = [GLYPHS.get(ch, GLYPHS[" "]) for ch in text.upper()]
+    w = sum((len(g[0]) + 1) * scale + 1 for g in glyphs) + 8
+    h = 7 * scale + 8
+    mask = np.zeros((h, w), dtype=bool)
+    shade = np.zeros((h, w), dtype=np.uint8)  # 0 body, 1 top light, 2 bottom shadow
+    x_at = 3
+    for rows in glyphs:
+        for gy, row in enumerate(rows):
+            for gx, bit in enumerate(row):
+                if bit == "1":  # one pixel wider than the grid: bold strokes
+                    y0, x0 = 3 + gy * scale, x_at + gx * scale
+                    mask[y0:y0 + scale, x0:x0 + scale + 1] = True
+                    shade[y0:y0 + scale, x0:x0 + scale + 1] = 1 if gy < 2 else (2 if gy > 4 else 0)
+        x_at += (len(rows[0]) + 1) * scale + 1
+    img = np.zeros((h, w, 4), dtype=np.uint8)
+    shadow = np.zeros_like(mask)
+    shadow[2:, 2:] = mask[:-2, :-2]
+    p = np.pad(mask, 1)
+    outline = (p[:-2, 1:-1] | p[2:, 1:-1] | p[1:-1, :-2] | p[1:-1, 2:]) & ~mask
+    img[shadow & ~mask] = BG_EDGE
+    img[outline] = INK
+    img[mask] = GOLD
+    img[mask & (shade == 1)] = GOLD_LIGHT
+    img[mask & (shade == 2)] = GOLD_DARK
+    return img
+
+
+def banner(scale: int = 3) -> np.ndarray:
+    """The icon and the wordmark side by side (art pixels, transparent background)."""
+    ic, wm = icon(), wordmark(scale=scale)
+    h = max(ic.shape[0], wm.shape[0])
+    out = np.zeros((h, ic.shape[1] + 6 + wm.shape[1], 4), dtype=np.uint8)
+    out[(h - ic.shape[0]) // 2:(h - ic.shape[0]) // 2 + ic.shape[0], :ic.shape[1]] = ic
+    y = (h - wm.shape[0]) // 2
+    out[y:y + wm.shape[0], ic.shape[1] + 6:] = wm
+    return out
+
+
+def _up(a: np.ndarray, k: int) -> Image.Image:
+    return Image.fromarray(a).resize((a.shape[1] * k, a.shape[0] * k), Image.NEAREST)
+
+
+def write(out_dir: Path) -> list[Path]:
+    """logo-icon-<size>.png (32..512), logo.png (icon + name), favicon.ico."""
+    out_dir.mkdir(parents=True, exist_ok=True)
+    written = []
+    ic = icon()
+    for k in (1, 2, 4, 8, 16):
+        path = out_dir / f"logo-icon-{32 * k}.png"
+        _up(ic, k).save(path)
+        written.append(path)
+    path = out_dir / "logo.png"
+    _up(banner(), 4).save(path)
+    written.append(path)
+    fav = out_dir / "favicon.ico"
+    _up(ic, 2).save(fav, sizes=[(16, 16), (32, 32), (64, 64)])
+    written.append(fav)
+    return written

spawnpoint_studio-0.3.5/compiler/spawnpoint/music.py

@@ -0,0 +1,117 @@
+"""Background music: a short chiptune loop per farming season, composed from a seed (no audio files are read).
+
+Eight bars over a four-chord progression: a square-wave melody that walks the chord tones, a triangle bass on the
+roots, and a quiet arpeggio (bells in winter). The loop is written as res://sfx/music.wav and played on repeat.
+"""
+
+from __future__ import annotations
+
+import io
+import random
+import wave
+from pathlib import Path
+
+import numpy as np
+
+RATE = 22050  # music is fine at half rate, and half the size on the web
+
+# season -> (tempo, root note (MIDI), scale steps, progression of chord roots as scale degrees, lead wave)
+STYLES = {
+    "spring": (112, 60, (0, 2, 4, 5, 7, 9, 11), (0, 4, 5, 3), "square"),     # C major, I-V-vi-IV
+    "autumn": (96, 57, (0, 2, 3, 5, 7, 8, 10), (0, 5, 2, 6), "square"),      # A minor, i-VI-III-VII
+    "winter": (84, 62, (0, 2, 4, 5, 7, 9, 11), (0, 2, 3, 0), "sine"),        # D major, slow bells, I-iii-IV-I
+    "desert": (100, 64, (0, 1, 4, 5, 7, 8, 10), (0, 1, 0, 4), "square"),     # E phrygian dominant, i-bII-i-V
+}
+SEASONS = tuple(STYLES)
+
+
+def _freq(midi: float) -> float:
+    return 440.0 * 2 ** ((midi - 69) / 12)
+
+
+def _osc(kind: str, phase: np.ndarray) -> np.ndarray:
+    p = phase % 1.0
+    if kind == "square":
+        return np.where(p < 0.25, 1.0, -1.0)  # a 25% pulse: the classic chiptune lead
+    if kind == "triangle":
+        return 4 * np.abs(p - 0.5) - 1
+    return np.sin(2 * np.pi * p)
+
+
+def _note(buf: np.ndarray, start: float, length: float, midi: float, kind: str, volume: float,
+          decay: float = 0.0) -> None:
+    """Adds one note to `buf` (seconds), with a short attack and release (and an optional exponential decay)."""
+    s0, n = int(start * RATE), int(length * RATE)
+    n = min(n, len(buf) - s0)
+    if n <= 0:
+        return
+    i = np.arange(n)
+    attack, release = max(int(0.006 * RATE), 1), max(int(0.04 * RATE), 1)
+    env = np.minimum(np.minimum(1.0, i / attack), (n - i) / release)
+    if decay:
+        env = env * np.exp(-decay * i / RATE)
+    buf[s0:s0 + n] += volume * env * _osc(kind, _freq(midi) * i / RATE)
+
+
+def compose(season: str = "spring", seed: int = 0) -> list[float]:
+    """Eight bars of music as samples in -1..1."""
+    tempo, root, scale, progression, lead = STYLES.get(season, STYLES["spring"])
+    rng = random.Random(f"music:{season}:{seed}")
+    beat = 60.0 / tempo
+    bars = 8
+    buf = np.zeros(int(bars * 4 * beat * RATE) + RATE // 4)
+
+    def degree(d: int, octave: int = 0) -> int:
+        return root + scale[d % len(scale)] + 12 * (d // len(scale) + octave)
+
+    melody_degree = 2
+    for bar in range(bars):
+        chord = progression[bar % len(progression)]
+        tones = [chord, chord + 2, chord + 4]
+        t0 = bar * 4 * beat
+        for b in range(4):  # bass on the beat (root, and the fifth on beat three)
+            d = chord if b != 2 else chord + 4
+            _note(buf, t0 + b * beat, beat * 0.9, degree(d, -2), "triangle", 0.30)
+        for step in range(8):  # an arpeggio on the eighths (bells in winter)
+            d = tones[step % 3]
+            if season == "winter":
+                if step % 2 == 0:
+                    _note(buf, t0 + step * beat / 2, beat * 1.5, degree(d, 1), "sine", 0.10, decay=3.0)
+            else:
+                _note(buf, t0 + step * beat / 2, beat * 0.35, degree(d), "square", 0.05)
+        step = 0
+        while step < 8:  # the melody: a walk that leans toward the chord's notes
+            length = rng.choice((1, 1, 2, 2, 3)) if season != "winter" else rng.choice((2, 2, 3, 4))
+            length = min(length, 8 - step)
+            if rng.random() < 0.22 and step > 0:
+                step += length
+                continue
+            target = rng.choice(tones) + 7
+            melody_degree += max(-2, min(2, target - melody_degree)) if rng.random() < 0.7 else rng.choice((-1, 1))
+            melody_degree = max(5, min(14, melody_degree))
+            _note(buf, t0 + step * beat / 2, length * beat / 2 * 0.92, degree(melody_degree), lead,
+                  0.16 if lead == "square" else 0.22, decay=1.5 if season == "winter" else 0.0)
+            step += length
+    peak = max(1e-6, float(np.abs(buf).max()))
+    return list(buf / peak * 0.6)
+
+
+def to_wav_bytes(samples: list[float]) -> bytes:
+    out = io.BytesIO()
+    with wave.open(out, "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(RATE)
+        w.writeframes((np.clip(np.asarray(samples), -1.0, 1.0) * 32767).astype("<i2").tobytes())
+    return out.getvalue()
+
+
+def write(out_dir: Path, season: str, seed: int = 0) -> Path:
+    """Writes music.wav for `season` (skipped when it is already there for the same season and seed)."""
+    out_dir.mkdir(parents=True, exist_ok=True)
+    target, stamp = out_dir / "music.wav", out_dir / ".music.params"
+    key = f"{season}:{seed}"
+    if not (target.exists() and stamp.exists() and stamp.read_text() == key):
+        target.write_bytes(to_wav_bytes(compose(season, seed)))
+        stamp.write_text(key)
+    return target

{spawnpoint_studio-0.3.4 → spawnpoint_studio-0.3.5}/compiler/spawnpoint/sprites/farm.py

@@ -726,6 +726,42 @@ def paint_workbench(g: Fig, color: str, anim: str, i: int) -> None:
     _out(g)
 
 
+def paint_shop(g: Fig, color: str, anim: str, i: int) -> None:
+    d, b, l = _ramp(color)
+    g.ellipse(16, 31, 15, 1.8, _c("#2c5a30", 110))
+    g.rect(3, 10, 4, 30, WOOD_DARK)  # posts
+    g.rect(27, 10, 28, 30, WOOD_DARK)
+    g.rect(1, 19, 30, 29, WOOD)  # the counter
+    g.rect(1, 19, 30, 20, WOOD_LIGHT)
+    g.rect(1, 29, 30, 29, WOOD_DARK)
+    for k, x in enumerate(range(0, 32, 4)):  # a striped awning with a scalloped edge
+        g.rect(x, 4, x + 3, 10, b if k % 2 == 0 else WHITE)
+        g.ellipse(x + 2, 11, 2, 1.6, b if k % 2 == 0 else WHITE)
+    g.rect(0, 3, 31, 4, d)
+    g.rect(5, 15, 9, 18, _c("#e8c25a"))  # wares: a sack of seeds, eggs, a chick in a basket
+    g.rect(6, 14, 8, 14, _c("#c8a040"))
+    g.ellipse(14, 17, 2, 1.6, _c("#f8f0e0"))
+    g.ellipse(17.5, 17, 2, 1.6, _c("#f8f0e0"))
+    g.rect(21, 15, 26, 18, WOOD_LIGHT)
+    g.ellipse(23.5, 14, 1.8, 1.6, _c("#ffd84a"))
+    g.rect(10, 22, 21, 25, PLANK)  # a sign on the counter
+    g.rect(12, 23, 19, 23, WOOD_DARK)
+    _out(g)
+
+
+def paint_sprinkler(g: Fig, color: str, anim: str, i: int) -> None:
+    g.ellipse(8, 14, 4, 1.2, _c("#2c5a30", 110))
+    g.rect(7, 7, 8, 13, STONE_DARK)
+    g.rect(5, 12, 10, 13, STONE)
+    g.ellipse(7.5, 6, 3, 2, STONE)
+    g.ellipse(7, 5.5, 1.4, 0.8, STONE_LIGHT)
+    k = i % 4
+    for n, (dx, dy) in enumerate(((-5, -2), (5, -2), (-3, -4), (3, -4))):  # little jets of water
+        if (n + k) % 2 == 0:
+            g.set(7.5 + dx, 5 + dy, _c("#7fd0ff"))
+    _out(g)
+
+
 def paint_sign(g: Fig, color: str, anim: str, i: int) -> None:
     g.rect(7, 8, 8, 15, WOOD_DARK)
     g.rect(1, 2, 14, 9, WOOD)
@@ -1397,6 +1433,8 @@ SPRITES: dict[str, tuple[tuple[int, int], dict[str, tuple[int, float, bool]], ob
     "barrel": ((16, 16), {"idle": (1, 1, False)}, paint_barrel, "#9a5e36"),
     "signpost": ((16, 16), {"idle": (1, 1, False)}, paint_sign, "#9a5e36"),
     "workbench": ((24, 18), {"idle": (1, 1, False)}, paint_workbench, "#9a5e36"),
+    "shop": ((32, 32), {"idle": (1, 1, False)}, paint_shop, "#3a8ad0"),
+    "sprinkler": ((16, 16), {"idle": (4, 6, True)}, paint_sprinkler, "#a8a8b8"),
     "flower_bush": ((16, 16), {"idle": (1, 1, False)}, paint_flower_bush, "#ff8fb4"),
     "fence_h": ((16, 16), {"idle": (1, 1, False)}, paint_fence_h, "#9a5e36"),
     "fence_v": ((16, 16), {"idle": (1, 1, False)}, paint_fence_v, "#9a5e36"),

{spawnpoint_studio-0.3.4 → spawnpoint_studio-0.3.5}/compiler/spawnpoint/sprites/gallery.py

@@ -43,7 +43,7 @@ CAST: list[tuple[str, str, str]] = [
     ("Farmer", "farmer", "#e8503a"), ("Maple", "tree_maple", "#d8402a"), ("SnowyPine", "tree_snowy_pine", "#2f7a5a"),
     ("BareTree", "tree_bare", "#9a5e36"), ("Palm", "tree_palm", "#4caf50"), ("Cactus", "cactus", "#5aa048"),
     ("Bed", "bed", "#4a7ad0"), ("Fireplace", "fireplace", "#c8643a"), ("Table", "table", "#9a5e36"),
-    ("Workbench", "workbench", "#9a5e36"), ("Crow", "crow", "#3a3448"), ("Fox", "fox", "#e07a2a"), ("Rabbit", "rabbit", "#d8c8b8"), ("Mouse", "mouse", "#9a9aa8"),
+    ("Workbench", "workbench", "#9a5e36"), ("ShopStall", "shop", "#3a8ad0"), ("Sprinkler", "sprinkler", "#a8a8b8"), ("Crow", "crow", "#3a3448"), ("Fox", "fox", "#e07a2a"), ("Rabbit", "rabbit", "#d8c8b8"), ("Mouse", "mouse", "#9a9aa8"),
     ("Chair", "chair", "#9a5e36"), ("Dresser", "dresser", "#9a5e36"), ("PottedPlant", "potted_plant", "#5cb84a"),
 ]
 

{spawnpoint_studio-0.3.4 → spawnpoint_studio-0.3.5}/compiler/spawnpoint/studio/assemble.py

@@ -112,7 +112,13 @@ FARM_CROP_COLORS = {"strawberry": "#e83a4a", "potato": "#c8986a", "carrot": "#ff
                     "pumpkin": "#ff9a2a", "corn": "#ffd84a", "cabbage": "#8ad860", "wheat": "#e8c25a",
                     "onion": "#f4ece0", "eggplant": "#8a4ac8", "blueberry": "#4a6ae8", "turnip": "#c84a9a"}
 FARM_DAYS = {"short": 2, "medium": 3, "long": 4}  # days in a farming season
+FARM_RAIN = {"spring": 0.35, "autumn": 0.4, "winter": 0.35, "desert": 0.05}  # chance of a rainy (or snowy) day
 FARM_START_MONEY = 15  # enough for the first seeds
+# For sale at the shop stall (key, name, price; see ShopComponent), and the rare crop it sells
+# (name, colour, grow seconds, price).
+FARM_SHOP = (("chicken", "Chicken", 40), ("cow", "Cow", 90), ("seeds", "Golden melon seeds", 60),
+             ("sprinkler", "Sprinkler", 55))
+FARM_RARE_CROP = ("GoldenMelon", "#ffd84a", 30, 45)
 # Tool upgrades at the workbench: (key, name, price); see ToolBenchComponent.
 FARM_UPGRADES = (("basket", "Big basket", 30), ("can", "Watering can", 45), ("hoe", "Hoe", 35), ("axe", "Axe", 40),
                  ("rod", "Fishing rod", 30))
@@ -141,6 +147,7 @@ FARM_OBJECTS: dict[str, tuple[str, dict]] = {
     "hay": ("Hay", {"base": (28, 14)}), "barrel": ("Barrel", {"base": (24, 14)}), "well": ("Well", {"base": (44, 28)}),
     "scarecrow": ("Scarecrow", {"base": (12, 10)}), "signpost": ("Signpost", {"base": (12, 8)}),
     "workbench": ("Workbench", {"base": (40, 14)}),
+    "shop": ("ShopStall", {"base": (56, 18)}), "sprinkler": ("WaterSprinkler", {"base": (12, 8)}),
     "bed": ("Bed", {"base": (28, 56)}), "fireplace": ("Fireplace", {"base": (60, 20)}), "table": ("Table", {"base": (56, 20)}),
     "chair": ("Chair", {"base": (20, 12)}), "dresser": ("Dresser", {"base": (44, 16)}),
     "potted_plant": ("PottedPlant", {"base": (16, 12)}),
@@ -381,6 +388,11 @@ class _Assembler:
             art[f"icon_{c}"] = {"kind": "crop_icon", "of": c, "color": color}
             crop_entries.append(f"{c}|{color}|{grow}|{price}|res://sprites/art_crop_{c}.png|res://sprites/art_icon_{c}.png")
         art["icon_hay"] = {"kind": "item_icon", "of": "hay"}
+        rare = FARM_RARE_CROP  # sold at the shop stall
+        art[f"crop_{rare[0]}"] = {"kind": "crop", "of": rare[0], "color": rare[1]}
+        art[f"icon_{rare[0]}"] = {"kind": "crop_icon", "of": rare[0], "color": rare[1]}
+        rare_entry = (f"{rare[0]}|{rare[1]}|{rare[2]}|{rare[3]}|res://sprites/art_crop_{rare[0]}.png"
+                      f"|res://sprites/art_icon_{rare[0]}.png")
         goods = []
         for item, price in FARM_GOODS:
             art[f"icon_{item.lower()}"] = {"kind": "item_icon", "of": item.lower()}
@@ -389,8 +401,11 @@ class _Assembler:
                                                        "acceleration": 2200}, "PlayerInput": {},
                                   "Farmer": {"crops": ";".join(crop_entries), "goods": ";".join(goods), "reach": 46,
                                              "basket_size": 16, "buy_seeds": True},
-                                  "FarmDays": {"days": days, "day_seconds": day_seconds},
-                                  "FarmSave": {"slot": f"{farm_slug(b.title or 'farm')}-{self.seed}"}}
+                                  "FarmDays": {"days": days, "day_seconds": day_seconds, "weather_seed": self.seed,
+                                               "rain_chance": FARM_RAIN[season], "snow": season == "winter"},
+                                  "FarmSave": {"slot": f"{farm_slug(b.title or 'farm')}-{self.seed}"},
+                                  "GameMenu": {"title": b.title or "My Farm",
+                                               "subtitle": f"Earn ${target} in {days} days. Space works the farm, P pauses."}}
         if "dash" in b.player.abilities:
             comps["TopDownMovement"]["dash_speed"] = 600.0
         self.entities["Player"] = {"shape": {"type": "circle", "size": [18, 18], "color": pal["player"]},
@@ -433,6 +448,12 @@ class _Assembler:
                        "components": {}}
                 if kind == "bed":
                     ent["components"]["SleepSpot"] = {}
+                if kind == "sprinkler":  # waits hidden in the field until bought
+                    ent["body"] = "area"
+                    ent["components"]["Sprinkler"] = {"radius": 52}
+                if kind == "shop":
+                    ent["components"]["Shop"] = {"offers": ";".join(f"{k}|{n}|{p}" for k, n, p in FARM_SHOP),
+                                                 "rare_crop": rare_entry}
                 if kind == "workbench":
                     ent["components"]["ToolBench"] = {"offers": ";".join(f"{k}|{n}|{p}" for k, n, p in FARM_UPGRADES)}
                 if "gather" in spec:
@@ -520,7 +541,7 @@ class _Assembler:
                 "settings": {"tile_size": TILE, "lives": 1, "seed": self.seed, "zoom": 1.6,
                              "background": "#3aa0e8" if fm.island else "#4f8a3a",
                              "tile_style": "flat", "tiles": {"solid": {"color": "#00000000", "top": "#00000000"}},
-                             "terrain": fm.terrain, "season": season, "y_sort": True, "art": art},
+                             "terrain": fm.terrain, "season": season, "music": season, "y_sort": True, "art": art},
                 "entities": self.entities, "level": {"map": rows, "legend": legend}, "rules": self.rules}
 
     def _farm_target(self) -> int: