pixel-space-asset-toolkit 0.1.0__tar.gz

pixel_space_asset_toolkit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pixel Space Asset Toolkit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pixel_space_asset_toolkit-0.1.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: pixel-space-asset-toolkit
+Version: 0.1.0
+Summary: Deterministic pixel-art sci-fi asset utilities for starfields, asteroid tiles, cleanup, and previews.
+Author: Pixel Space Asset Toolkit contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NonniGB/godot-production-toolkit/tree/main/pixel-space-asset-toolkit
+Project-URL: Issues, https://github.com/NonniGB/godot-production-toolkit/issues
+Keywords: pixel-art,procedural,godot,space,assets,gamedev
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=10
+Dynamic: license-file
+
+# Pixel Space Asset Toolkit
+
+Deterministic procedural tools for pixel-art sci-fi prototypes: starfields, hex asteroid tiles, transparent-background cleanup, preview sheets, and Godot import guidance.
+
+This repo is intentionally more visual than the audit tools, but it still behaves like a production CLI: fixed seeds, manifests, tests, and repeatable outputs.
+
+## Install
+
+```powershell
+python -m pip install -e .
+```
+
+When published:
+
+```powershell
+python -m pip install pixel-space-asset-toolkit
+```
+
+## Quick Start
+
+```powershell
+pixel-space-assets starfield --width 1080 --height 1920 --seed 42 --stars 900 --output generated\starfield.png --manifest generated\starfield.json
+pixel-space-assets asteroid-hex --material ferric --count 32 --size 64 --seed 7 --output generated\ferric
+pixel-space-assets strip-background input.png --output cleaned.png --tolerance 4
+pixel-space-assets preview generated\ferric --columns 8 --cell-size 64 --output generated\ferric_preview.png
+pixel-space-assets starfield --width 1080 --height 1920 --seed 42 --stars 900 --output generated\starfield.png --format json
+```
+
+## Tools
+
+- `starfield`: deterministic pixel starfield backgrounds.
+- `asteroid-hex`: deterministic transparent hex asteroid tiles.
+- `strip-background`: converts a flat corner-color background to alpha.
+- `preview`: builds contact sheets for review.
+
+## Sample Gallery
+
+Generated from fixed seeds:
+
+![Generated starfield](examples/gallery/starfield_64.png)
+
+![Ferric asteroid preview](examples/gallery/ferric_preview.png)
+
+Open `examples/gallery/index.html` for a simple static gallery view.
+
+## Documentation
+
+- [Starfields](docs/STARFIELDS.md)
+- [Asteroids](docs/ASTEROIDS.md)
+- [Background stripping](docs/BACKGROUND_STRIPPING.md)
+- [Preview sheets](docs/PREVIEWS.md)
+- [Godot import guide](docs/GODOT_IMPORT.md)
+- [CI usage](docs/CI.md)
+
+## Development
+
+```powershell
+python -m pip install -e .
+python -m unittest discover -s tests -v
+pixel-space-assets starfield --width 64 --height 64 --seed 1 --stars 20 --output generated\starfield.png
+```
+
+Examples are generic and reproducible. Private project-specific art should stay outside the published repository unless intentionally released.

pixel_space_asset_toolkit-0.1.0/README.md

@@ -0,0 +1,63 @@
+# Pixel Space Asset Toolkit
+
+Deterministic procedural tools for pixel-art sci-fi prototypes: starfields, hex asteroid tiles, transparent-background cleanup, preview sheets, and Godot import guidance.
+
+This repo is intentionally more visual than the audit tools, but it still behaves like a production CLI: fixed seeds, manifests, tests, and repeatable outputs.
+
+## Install
+
+```powershell
+python -m pip install -e .
+```
+
+When published:
+
+```powershell
+python -m pip install pixel-space-asset-toolkit
+```
+
+## Quick Start
+
+```powershell
+pixel-space-assets starfield --width 1080 --height 1920 --seed 42 --stars 900 --output generated\starfield.png --manifest generated\starfield.json
+pixel-space-assets asteroid-hex --material ferric --count 32 --size 64 --seed 7 --output generated\ferric
+pixel-space-assets strip-background input.png --output cleaned.png --tolerance 4
+pixel-space-assets preview generated\ferric --columns 8 --cell-size 64 --output generated\ferric_preview.png
+pixel-space-assets starfield --width 1080 --height 1920 --seed 42 --stars 900 --output generated\starfield.png --format json
+```
+
+## Tools
+
+- `starfield`: deterministic pixel starfield backgrounds.
+- `asteroid-hex`: deterministic transparent hex asteroid tiles.
+- `strip-background`: converts a flat corner-color background to alpha.
+- `preview`: builds contact sheets for review.
+
+## Sample Gallery
+
+Generated from fixed seeds:
+
+![Generated starfield](examples/gallery/starfield_64.png)
+
+![Ferric asteroid preview](examples/gallery/ferric_preview.png)
+
+Open `examples/gallery/index.html` for a simple static gallery view.
+
+## Documentation
+
+- [Starfields](docs/STARFIELDS.md)
+- [Asteroids](docs/ASTEROIDS.md)
+- [Background stripping](docs/BACKGROUND_STRIPPING.md)
+- [Preview sheets](docs/PREVIEWS.md)
+- [Godot import guide](docs/GODOT_IMPORT.md)
+- [CI usage](docs/CI.md)
+
+## Development
+
+```powershell
+python -m pip install -e .
+python -m unittest discover -s tests -v
+pixel-space-assets starfield --width 64 --height 64 --seed 1 --stars 20 --output generated\starfield.png
+```
+
+Examples are generic and reproducible. Private project-specific art should stay outside the published repository unless intentionally released.

pixel_space_asset_toolkit-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pixel-space-asset-toolkit"
+version = "0.1.0"
+description = "Deterministic pixel-art sci-fi asset utilities for starfields, asteroid tiles, cleanup, and previews."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "Pixel Space Asset Toolkit contributors" }]
+keywords = ["pixel-art", "procedural", "godot", "space", "assets", "gamedev"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Multimedia :: Graphics",
+  "Topic :: Games/Entertainment"
+]
+dependencies = ["Pillow>=10"]
+
+[project.urls]
+Homepage = "https://github.com/NonniGB/godot-production-toolkit/tree/main/pixel-space-asset-toolkit"
+Issues = "https://github.com/NonniGB/godot-production-toolkit/issues"
+
+[project.scripts]
+pixel-space-assets = "pixel_space_assets.cli:entrypoint"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

pixel_space_asset_toolkit-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pixel_space_asset_toolkit-0.1.0/src/pixel_space_asset_toolkit.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: pixel-space-asset-toolkit
+Version: 0.1.0
+Summary: Deterministic pixel-art sci-fi asset utilities for starfields, asteroid tiles, cleanup, and previews.
+Author: Pixel Space Asset Toolkit contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/NonniGB/godot-production-toolkit/tree/main/pixel-space-asset-toolkit
+Project-URL: Issues, https://github.com/NonniGB/godot-production-toolkit/issues
+Keywords: pixel-art,procedural,godot,space,assets,gamedev
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=10
+Dynamic: license-file
+
+# Pixel Space Asset Toolkit
+
+Deterministic procedural tools for pixel-art sci-fi prototypes: starfields, hex asteroid tiles, transparent-background cleanup, preview sheets, and Godot import guidance.
+
+This repo is intentionally more visual than the audit tools, but it still behaves like a production CLI: fixed seeds, manifests, tests, and repeatable outputs.
+
+## Install
+
+```powershell
+python -m pip install -e .
+```
+
+When published:
+
+```powershell
+python -m pip install pixel-space-asset-toolkit
+```
+
+## Quick Start
+
+```powershell
+pixel-space-assets starfield --width 1080 --height 1920 --seed 42 --stars 900 --output generated\starfield.png --manifest generated\starfield.json
+pixel-space-assets asteroid-hex --material ferric --count 32 --size 64 --seed 7 --output generated\ferric
+pixel-space-assets strip-background input.png --output cleaned.png --tolerance 4
+pixel-space-assets preview generated\ferric --columns 8 --cell-size 64 --output generated\ferric_preview.png
+pixel-space-assets starfield --width 1080 --height 1920 --seed 42 --stars 900 --output generated\starfield.png --format json
+```
+
+## Tools
+
+- `starfield`: deterministic pixel starfield backgrounds.
+- `asteroid-hex`: deterministic transparent hex asteroid tiles.
+- `strip-background`: converts a flat corner-color background to alpha.
+- `preview`: builds contact sheets for review.
+
+## Sample Gallery
+
+Generated from fixed seeds:
+
+![Generated starfield](examples/gallery/starfield_64.png)
+
+![Ferric asteroid preview](examples/gallery/ferric_preview.png)
+
+Open `examples/gallery/index.html` for a simple static gallery view.
+
+## Documentation
+
+- [Starfields](docs/STARFIELDS.md)
+- [Asteroids](docs/ASTEROIDS.md)
+- [Background stripping](docs/BACKGROUND_STRIPPING.md)
+- [Preview sheets](docs/PREVIEWS.md)
+- [Godot import guide](docs/GODOT_IMPORT.md)
+- [CI usage](docs/CI.md)
+
+## Development
+
+```powershell
+python -m pip install -e .
+python -m unittest discover -s tests -v
+pixel-space-assets starfield --width 64 --height 64 --seed 1 --stars 20 --output generated\starfield.png
+```
+
+Examples are generic and reproducible. Private project-specific art should stay outside the published repository unless intentionally released.

pixel_space_asset_toolkit-0.1.0/src/pixel_space_asset_toolkit.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+src/pixel_space_asset_toolkit.egg-info/PKG-INFO
+src/pixel_space_asset_toolkit.egg-info/SOURCES.txt
+src/pixel_space_asset_toolkit.egg-info/dependency_links.txt
+src/pixel_space_asset_toolkit.egg-info/entry_points.txt
+src/pixel_space_asset_toolkit.egg-info/requires.txt
+src/pixel_space_asset_toolkit.egg-info/top_level.txt
+src/pixel_space_assets/__init__.py
+src/pixel_space_assets/__main__.py
+src/pixel_space_assets/asteroids.py
+src/pixel_space_assets/cli.py
+src/pixel_space_assets/preview.py
+src/pixel_space_assets/starfield.py
+src/pixel_space_assets/strip_background.py
+tests/test_asteroids.py
+tests/test_background_preview.py
+tests/test_cli.py
+tests/test_starfield.py

pixel_space_asset_toolkit-0.1.0/src/pixel_space_asset_toolkit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pixel_space_asset_toolkit-0.1.0/src/pixel_space_asset_toolkit.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pixel-space-assets = pixel_space_assets.cli:entrypoint

pixel_space_asset_toolkit-0.1.0/src/pixel_space_asset_toolkit.egg-info/requires.txt

@@ -0,0 +1 @@
+Pillow>=10

pixel_space_asset_toolkit-0.1.0/src/pixel_space_asset_toolkit.egg-info/top_level.txt

@@ -0,0 +1 @@
+pixel_space_assets

pixel_space_asset_toolkit-0.1.0/src/pixel_space_assets/__init__.py

@@ -0,0 +1,3 @@
+"""Deterministic pixel-space asset utilities."""
+
+__version__ = "0.1.0"

pixel_space_asset_toolkit-0.1.0/src/pixel_space_assets/__main__.py

@@ -0,0 +1,5 @@
+from .cli import entrypoint
+
+
+if __name__ == "__main__":
+    entrypoint()

pixel_space_asset_toolkit-0.1.0/src/pixel_space_assets/asteroids.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import json
+import math
+import random
+from pathlib import Path
+
+from PIL import Image, ImageDraw
+
+PALETTES = {
+    "ferric": [(63, 43, 47, 255), (126, 72, 57, 255), (214, 117, 77, 255), (255, 188, 112, 255)],
+    "ice": [(37, 58, 82, 255), (72, 118, 145, 255), (145, 214, 226, 255), (232, 255, 255, 255)],
+    "carbon": [(20, 24, 32, 255), (48, 55, 69, 255), (92, 102, 118, 255), (170, 186, 202, 255)],
+}
+
+
+def generate_asteroid_tiles(
+    output: Path,
+    *,
+    material: str,
+    count: int,
+    size: int,
+    seed: int,
+) -> dict[str, object]:
+    output.mkdir(parents=True, exist_ok=True)
+    palette = PALETTES.get(material, PALETTES["carbon"])
+    tiles = []
+    for index in range(count):
+        tile_seed = seed + index
+        image = _generate_tile(size=size, palette=palette, seed=tile_seed)
+        filename = f"{material}_{index:03d}.png"
+        image.save(output / filename)
+        tiles.append({"file": filename, "seed": tile_seed})
+    manifest = {"type": "asteroid-hex", "material": material, "count": count, "size": size, "seed": seed, "tiles": tiles}
+    (output / "manifest.json").write_text(json.dumps(manifest, indent=2, sort_keys=True), encoding="utf-8")
+    return manifest
+
+
+def _generate_tile(*, size: int, palette: list[tuple[int, int, int, int]], seed: int) -> Image.Image:
+    rng = random.Random(seed)
+    image = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(image)
+    center = (size / 2, size / 2)
+    radius = size * rng.uniform(0.34, 0.44)
+    points = []
+    for side in range(6):
+        angle = math.radians(60 * side - 30)
+        jitter = rng.uniform(0.82, 1.12)
+        points.append((center[0] + math.cos(angle) * radius * jitter, center[1] + math.sin(angle) * radius * jitter))
+    draw.polygon(points, fill=palette[1], outline=palette[3])
+    for _ in range(max(3, size // 8)):
+        x = rng.randrange(size)
+        y = rng.randrange(size)
+        if image.getpixel((x, y))[3] == 0:
+            continue
+        color = rng.choice(palette)
+        draw.rectangle((x, y, min(size - 1, x + rng.randrange(1, 4)), min(size - 1, y + rng.randrange(1, 4))), fill=color)
+    return image

pixel_space_asset_toolkit-0.1.0/src/pixel_space_assets/cli.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from PIL import Image
+
+from .asteroids import generate_asteroid_tiles
+from .preview import build_contact_sheet
+from .starfield import generate_starfield
+from .strip_background import strip_background
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    if args.command == "starfield":
+        return _starfield(args)
+    if args.command == "asteroid-hex":
+        manifest = generate_asteroid_tiles(
+            Path(args.output),
+            material=args.material,
+            count=args.count,
+            size=args.size,
+            seed=args.seed,
+        )
+        _emit_status(
+            args,
+            {
+                "status": "ok",
+                "command": "asteroid-hex",
+                "outputs": {
+                    "directory": str(Path(args.output)),
+                    "manifest": str(Path(args.output) / "manifest.json"),
+                },
+                "manifest": manifest,
+            },
+        )
+        return 0
+    if args.command == "strip-background":
+        return _strip_background(args)
+    if args.command == "preview":
+        return _preview(args)
+    parser.print_help()
+    return 2
+
+
+def entrypoint() -> None:
+    raise SystemExit(main())
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="pixel-space-assets", description="Deterministic pixel-space asset tools.")
+    parser.add_argument("--version", action="version", version="pixel-space-assets 0.1.0")
+    subparsers = parser.add_subparsers(dest="command")
+
+    starfield = subparsers.add_parser("starfield")
+    starfield.add_argument("--width", type=int, required=True)
+    starfield.add_argument("--height", type=int, required=True)
+    starfield.add_argument("--seed", type=int, required=True)
+    starfield.add_argument("--stars", type=int, default=200)
+    starfield.add_argument("--output", required=True)
+    starfield.add_argument("--manifest")
+    starfield.add_argument("--format", choices=["text", "json"], default="text")
+
+    asteroid = subparsers.add_parser("asteroid-hex")
+    asteroid.add_argument("--material", default="carbon", choices=["carbon", "ferric", "ice"])
+    asteroid.add_argument("--count", type=int, default=16)
+    asteroid.add_argument("--size", type=int, default=64)
+    asteroid.add_argument("--seed", type=int, default=1)
+    asteroid.add_argument("--output", required=True)
+    asteroid.add_argument("--format", choices=["text", "json"], default="text")
+
+    strip = subparsers.add_parser("strip-background")
+    strip.add_argument("input")
+    strip.add_argument("--output", required=True)
+    strip.add_argument("--tolerance", type=int, default=0)
+    strip.add_argument("--format", choices=["text", "json"], default="text")
+
+    preview = subparsers.add_parser("preview")
+    preview.add_argument("input")
+    preview.add_argument("--output", required=True)
+    preview.add_argument("--columns", type=int, default=4)
+    preview.add_argument("--cell-size", type=int, default=64)
+    preview.add_argument("--format", choices=["text", "json"], default="text")
+    return parser
+
+
+def _starfield(args: argparse.Namespace) -> int:
+    output = Path(args.output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    image = generate_starfield(width=args.width, height=args.height, seed=args.seed, stars=args.stars)
+    image.save(output)
+    if args.manifest:
+        manifest = {
+            "type": "starfield",
+            "width": args.width,
+            "height": args.height,
+            "seed": args.seed,
+            "stars": args.stars,
+            "output": str(output),
+        }
+        manifest_path = Path(args.manifest)
+        manifest_path.parent.mkdir(parents=True, exist_ok=True)
+        manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True), encoding="utf-8")
+    _emit_status(
+        args,
+        {
+            "status": "ok",
+            "command": "starfield",
+            "outputs": {
+                "image": str(output),
+                "manifest": str(Path(args.manifest)) if args.manifest else None,
+            },
+            "parameters": {
+                "width": args.width,
+                "height": args.height,
+                "seed": args.seed,
+                "stars": args.stars,
+            },
+        },
+    )
+    return 0
+
+
+def _strip_background(args: argparse.Namespace) -> int:
+    with Image.open(args.input) as image:
+        stripped = strip_background(image, tolerance=args.tolerance)
+    output = Path(args.output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    stripped.save(output)
+    _emit_status(
+        args,
+        {
+            "status": "ok",
+            "command": "strip-background",
+            "outputs": {"image": str(output)},
+            "parameters": {"input": args.input, "tolerance": args.tolerance},
+        },
+    )
+    return 0
+
+
+def _preview(args: argparse.Namespace) -> int:
+    root = Path(args.input)
+    paths = sorted(root.glob("*.png")) if root.is_dir() else [root]
+    sheet = build_contact_sheet(paths, columns=args.columns, cell_size=args.cell_size)
+    output = Path(args.output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    sheet.save(output)
+    _emit_status(
+        args,
+        {
+            "status": "ok",
+            "command": "preview",
+            "outputs": {"image": str(output)},
+            "parameters": {
+                "input": args.input,
+                "columns": args.columns,
+                "cell_size": args.cell_size,
+                "source_count": len(paths),
+            },
+        },
+    )
+    return 0
+
+
+def _emit_status(args: argparse.Namespace, payload: dict[str, object]) -> None:
+    if getattr(args, "format", "text") == "json":
+        print(json.dumps(payload, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pixel_space_asset_toolkit-0.1.0/src/pixel_space_assets/preview.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import math
+from pathlib import Path
+
+from PIL import Image
+
+
+def build_contact_sheet(paths: list[Path], *, columns: int, cell_size: int) -> Image.Image:
+    if not paths:
+        return Image.new("RGBA", (cell_size, cell_size), (0, 0, 0, 0))
+    rows = math.ceil(len(paths) / columns)
+    sheet = Image.new("RGBA", (columns * cell_size, rows * cell_size), (8, 10, 18, 255))
+    for index, path in enumerate(paths):
+        with Image.open(path) as image:
+            tile = image.convert("RGBA")
+            tile.thumbnail((cell_size, cell_size), Image.Resampling.NEAREST)
+            x = (index % columns) * cell_size + (cell_size - tile.width) // 2
+            y = (index // columns) * cell_size + (cell_size - tile.height) // 2
+            sheet.alpha_composite(tile, (x, y))
+    return sheet

pixel_space_asset_toolkit-0.1.0/src/pixel_space_assets/starfield.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import random
+
+from PIL import Image, ImageDraw
+
+STAR_COLORS = [
+    (124, 247, 255, 255),
+    (255, 255, 255, 255),
+    (255, 218, 121, 255),
+    (198, 176, 255, 255),
+]
+
+
+def generate_starfield(*, width: int, height: int, seed: int, stars: int) -> Image.Image:
+    rng = random.Random(seed)
+    image = Image.new("RGBA", (width, height), (5, 7, 18, 255))
+    draw = ImageDraw.Draw(image)
+    for _ in range(stars):
+        x = rng.randrange(width)
+        y = rng.randrange(height)
+        color = rng.choice(STAR_COLORS)
+        size = 1 if rng.random() < 0.86 else 2
+        draw.rectangle((x, y, min(width - 1, x + size - 1), min(height - 1, y + size - 1)), fill=color)
+        if rng.random() < 0.12:
+            glow = (color[0], color[1], color[2], 90)
+            if x > 0:
+                image.putpixel((x - 1, y), glow)
+            if x + 1 < width:
+                image.putpixel((x + 1, y), glow)
+    return image

pixel_space_asset_toolkit-0.1.0/src/pixel_space_assets/strip_background.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from PIL import Image
+
+
+def strip_background(image: Image.Image, *, tolerance: int = 0) -> Image.Image:
+    source = image.convert("RGBA")
+    background = source.getpixel((0, 0))
+    output = Image.new("RGBA", source.size, (0, 0, 0, 0))
+    for y in range(source.height):
+        for x in range(source.width):
+            pixel = source.getpixel((x, y))
+            if _within_tolerance(pixel, background, tolerance):
+                output.putpixel((x, y), (pixel[0], pixel[1], pixel[2], 0))
+            else:
+                output.putpixel((x, y), pixel)
+    return output
+
+
+def _within_tolerance(pixel: tuple[int, int, int, int], background: tuple[int, int, int, int], tolerance: int) -> bool:
+    return max(abs(pixel[index] - background[index]) for index in range(3)) <= tolerance

pixel_space_asset_toolkit-0.1.0/tests/test_asteroids.py

@@ -0,0 +1,23 @@
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from pixel_space_assets.asteroids import generate_asteroid_tiles
+
+
+class AsteroidTests(unittest.TestCase):
+    def test_generates_tiles_and_manifest(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            output = Path(tmp)
+
+            manifest = generate_asteroid_tiles(output, material="ferric", count=3, size=32, seed=7)
+
+            self.assertEqual(len(list(output.glob("*.png"))), 3)
+            self.assertEqual(manifest["material"], "ferric")
+            self.assertEqual(len(manifest["tiles"]), 3)
+            self.assertEqual(json.loads((output / "manifest.json").read_text(encoding="utf-8"))["seed"], 7)
+
+
+if __name__ == "__main__":
+    unittest.main()

pixel_space_asset_toolkit-0.1.0/tests/test_background_preview.py

@@ -0,0 +1,33 @@
+import tempfile
+import unittest
+from pathlib import Path
+
+from PIL import Image
+
+from pixel_space_assets.preview import build_contact_sheet
+from pixel_space_assets.strip_background import strip_background
+
+
+class BackgroundPreviewTests(unittest.TestCase):
+    def test_strip_background_makes_corner_color_transparent(self) -> None:
+        image = Image.new("RGBA", (2, 2), (255, 0, 255, 255))
+        image.putpixel((1, 1), (10, 20, 30, 255))
+
+        stripped = strip_background(image, tolerance=0)
+
+        self.assertEqual(stripped.getpixel((0, 0))[3], 0)
+        self.assertEqual(stripped.getpixel((1, 1))[3], 255)
+
+    def test_contact_sheet_dimensions_follow_columns(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            for index in range(3):
+                Image.new("RGBA", (8, 8), (index, index, index, 255)).save(root / f"{index}.png")
+
+            sheet = build_contact_sheet(sorted(root.glob("*.png")), columns=2, cell_size=8)
+
+            self.assertEqual(sheet.size, (16, 16))
+
+
+if __name__ == "__main__":
+    unittest.main()

pixel_space_asset_toolkit-0.1.0/tests/test_cli.py

@@ -0,0 +1,81 @@
+import tempfile
+import unittest
+from contextlib import redirect_stdout
+from io import StringIO
+from pathlib import Path
+import json
+
+from pixel_space_assets.cli import main
+
+
+class CliTests(unittest.TestCase):
+    def test_cli_prints_version(self) -> None:
+        stdout = StringIO()
+
+        with self.assertRaises(SystemExit) as raised:
+            with redirect_stdout(stdout):
+                main(["--version"])
+
+        self.assertEqual(raised.exception.code, 0)
+        self.assertIn("pixel-space-assets 0.1.0", stdout.getvalue())
+
+    def test_starfield_cli_writes_image_and_manifest(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            output = Path(tmp) / "starfield.png"
+            manifest = Path(tmp) / "manifest.json"
+
+            exit_code = main(
+                [
+                    "starfield",
+                    "--width",
+                    "16",
+                    "--height",
+                    "16",
+                    "--seed",
+                    "5",
+                    "--stars",
+                    "5",
+                    "--output",
+                    str(output),
+                    "--manifest",
+                    str(manifest),
+                ]
+            )
+
+            self.assertEqual(exit_code, 0)
+            self.assertTrue(output.exists())
+            self.assertTrue(manifest.exists())
+
+    def test_starfield_cli_can_print_json_status_for_automation(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            output = Path(tmp) / "starfield.png"
+            stdout = StringIO()
+
+            with redirect_stdout(stdout):
+                exit_code = main(
+                    [
+                        "starfield",
+                        "--width",
+                        "16",
+                        "--height",
+                        "16",
+                        "--seed",
+                        "5",
+                        "--stars",
+                        "5",
+                        "--output",
+                        str(output),
+                        "--format",
+                        "json",
+                    ]
+                )
+
+            payload = json.loads(stdout.getvalue())
+            self.assertEqual(exit_code, 0)
+            self.assertEqual(payload["status"], "ok")
+            self.assertEqual(payload["command"], "starfield")
+            self.assertTrue(payload["outputs"]["image"].endswith("starfield.png"))
+
+
+if __name__ == "__main__":
+    unittest.main()

pixel_space_asset_toolkit-0.1.0/tests/test_starfield.py

@@ -0,0 +1,20 @@
+import hashlib
+import unittest
+
+from pixel_space_assets.starfield import generate_starfield
+
+
+class StarfieldTests(unittest.TestCase):
+    def test_starfield_is_deterministic_for_seed(self) -> None:
+        first = generate_starfield(width=32, height=32, seed=42, stars=20)
+        second = generate_starfield(width=32, height=32, seed=42, stars=20)
+
+        self.assertEqual(first.size, (32, 32))
+        self.assertEqual(
+            hashlib.sha256(first.tobytes()).hexdigest(),
+            hashlib.sha256(second.tobytes()).hexdigest(),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()