Scope of Work: Mneme World Generator App

1. Overview

The Mneme World Generator is a progressive web app (PWA) built with React that procedurally generates near realistic star systems in a table format. The app is designed for use on any device that can run a browser—Linux, Windows, Android, iOS, etc.

References:

The Book: https://drive.google.com/file/d/11LVbqitqu90IeyFy7MMuWVngPKPvsvQs/view?usp=sharing

The Spreadsheet: https://docs.google.com/spreadsheets/d/1YiFA-THVnSGyMltVcDvS9nGlF4k8RFrjg89ZGNSw7ZM/edit?usp=drive_link Note: Copy this sheet and run the script when prompted (accepting the risks as stated).

Video how to use https://youtu.be/661aEOMOwKM?si=YTAXb0CU0FTK7rZM channel with more videos https://www.youtube.com/@gameinthebrain79/videos

2. Objectives

Develop a PWA: Create an offline-capable web app that functions seamlessly on multiple platforms.

React Tables Integration: Use React (with a table library, e.g., TanStack Table) to display star systems in a clear, nested table format.

Procedural Generation: Implement algorithms to generate a star based on current astronomical probabilities, including the option for binary or triple star systems.

Data Export/Import: Allow users to export generated star systems to CSV, TSV, or (if possible) a spreadsheet format, and import table data for editing.

Local Storage: Enable local saving of star system projects using a default naming convention based on date and time.

3. Deliverables

Functional PWA: A fully responsive and offline-capable progressive web app.

Star System Generator: A module that procedurally generates a star system (with primary star and potential companion stars) based on editable variables.

User Interface: A user-friendly interface featuring:

A button to generate a star system.

A React table view to display hierarchical star system data.

Options to toggle binary/triple star generation.

Data Management:

Local project saving with timestamped naming.

Export functionality (CSV/TSV and ideally spreadsheet output).

Import capability for editing existing tables.

Documentation and Comments: Code will be well-commented, especially around procedural generation variables, to facilitate future adjustments.

4. Technical Requirements

Frameworks & Libraries:

React (for the app structure and UI components)

TanStack Table (or similar) for advanced table features

Progressive Web App (PWA):

Offline capability using service workers

Responsive design for cross-platform use

Storage:

Use of local storage or IndexedDB for saving projects

Export/Import:

Functionality to export table data to CSV/TSV formats

(Optional) Enhanced output if spreadsheet integration is feasible

5. Functional Requirements

Procedural Generation:

Generate a star based on astronomical probability data.

Toggle options for binary or triple star systems.

Generate associated companions based on gravity well and mass distribution.

Data Display:

Render the generated star system in a React table.

Support nested or expandable rows for sub-level data (e.g., planets, disks).

User Interactions:

"Generate" button to create a new star system.

Options to edit variables (each variable should be commented in code and easily adjustable).

Save current project locally with a default naming convention (date & time).

Export and import functionalities for data management.

6. Design and User Interface

Responsive Layout: Ensure usability on desktop and mobile browsers.

Clean, Minimal Design: Focus on clarity of data presentation (table-driven view).

User Feedback: Include indicators for processing during generation, saving, importing, and exporting.

7. Tools and Support

Development Tools:

Node.js and npm for package management and build processes.

React development environment (e.g., Create React App or Vite).

Support Accounts:

Access to a Claude account as needed for guidance or integrations.

References for Development:

The Book and The Spreadsheet (links provided above).

8. Budget & Timeline

Budget: 10,000 PHP for the complete project.

Timeline: To be discussed and agreed upon with milestones for:

Initial setup and PWA configuration

Procedural generation module development

UI design and React table integration

Export/import functionalities

Testing and final adjustments

9. Acceptance Criteria

The app must work offline and be accessible on major platforms (Linux, Windows, Android, iOS).

The star system generation should align with the probabilities and data described in The Spreadsheet.

Users can successfully generate, save, export, and import star system data.

All code is well-documented, and variables are editable with clear comments.

Final delivery includes working code, documentation, and deployment instructions.

Sources Consulted (Not Directly Applicable)

During research, I reviewed general PWA and React-Table guides to align our milestones with best practices:

A Mobidev guide on PWA development best practices (e.g. offline support, service workers) MobiDev

The Simform “Master Guide to PWA” covering technical components and build steps Simform - Product Engineering Company

MDN’s Progressive Web Apps overview for cross-platform requirements MDN Web Docs

Contentful’s TanStack Table (React Table) guide for table capabilities ContentScales

A Medium tutorial on creating dynamic React tables with react-table DEV Community

CronJ’s “Managing React Development Projects” for milestone structuring CronJ

None of these addressed the specific Mneme mechanics or the internal spreadsheet logic, so the detailed milestones below draw on the project’s requirements rather than external templates.

Definitions:

Togglelable – This means the options – Rnd (which means proceedural) or various pre-determined options can be chosen. Some world-builders have a particular outcome in mind and they just want other details generated proceeduraly.

Milestone 1: Prep Stage (2 000 PHP ● 16 % Progress)

Downpayment: Justin pays 2 000 PHP.

Core Tasks:

Learn Mneme Mechanics:

Read the Variant Rules document thoroughly.

Operate the provided spreadsheet end-to-end, confirming you can trigger its Google Apps Script.

Deliverable: A workflow diagram (e.g., via draw.io) showing your understanding of star-to-planet generation, zones, tables, and rolls.

Environment & Access Setup:

Create a dedicated browser profile for ojtai@comfac-it.com.

Test and configure the ChatGPT o4-mini paid account and tools.

Create a GitHub org/project, invite justinaquino@gmail.com, and arrange future transfer of ownership.

Establish communication channels with Roy, Clyde, and Jun for mentorship.

Cycling Task: Review and refine the diagram until Justin signs off.

Milestone 2: UI Stage (2 000 PHP ● 32 % Progress) : AUG 6 2025

Prerequisite: Steven fully understands Mneme mechanics and environment is ready.

Core Tasks:

Design Table-Driven Interface:

Define columns (user-hideable), expandable rows, and parent/child relationships.

Prototype both desktop and mobile layouts (responsive design).✅ UI

Trade-Off Analysis:

List limitations (e.g., nested depth, performance on low-end devices).

Propose compromises (e.g., virtual scrolling, pagination). 🟠Ongoing

Documentation & Demos:

Capture screenshots of the UI prototype on desktop and phone. ✅ UI

Post these on the GitHub blog and Bluesky to build interest. 🟠Ongoing

Deliverables Summary:

Wireframes or mockups (desktop + mobile). ✅ UI

A short report listing UI requirements, limitations, and chosen solutions.

Prioritize Mobile Nested Features.

System> Star(s) > Planet/Disk > Moon - (open to be nesting in the future; change tab for more detai; any child of this will be a different UI - future)

Share the GITHUB with me

Cycling Task: Iterate UI based on feedback until the design is approved.

250821 -

Finished

Determining Planetary System - Disk or Planet or Dwarf ✅

Remaining:

Moons - allow enduser to encode Moons - (TBD - moon generation step)

Name

Mass

Position

(notes how to add more fields)

For Testing and Acceptance - pay the 2000php milestone.

250815 -

Finished

Habitability

Inhabitants set up

Position

Remaining:

Mainworld

Summary

Power Structure

Planets/Disks

Share the Github Project with me.

Milestone 3: Star Generation Stage (4 400 PHP ● 48 % Progress) AUG 20?

Core Tasks:

Primary Star Logic: 2 200 PHP

Implement dice-roll function and lookup into the Stellar Class & Mass table.🟡 To be Scheduled

OBAFGKM stellar class and stellar grade – class grade. Luminosity, Habitability. Stellar mass. Companion star criteria (toggle). 🟡 To be Scheduled

Companion Stars (same – but these cannot be greater in mass than the primary star). Up to 3 companion stars.

Determine Zones: Infernal, Hot, Conservative Habitable, Cold, and Outer. 🟡 To be Scheduled

Compute luminosity and initial gravity well parameters. 🟡 To be Scheduled

Persistence & Export: 2 200 PHP

Save each star-system project locally (datatype: JSON/CSV, filename = YYMMDD-HHMMSS.json).

Implement export/import so users can transfer files between devices.

Deliverables Summary:

“Generate Star System” button with complete star + companions.

Local saving + CSV export/import working end-to-end.

Cycling Task: Test generation + save/load cycles, fix edge cases (e.g., no companions, max-roll recursion).

as

Milestone 4: Primary World Generator Stage (2 200 PHP ● 64 % Progress)

Core Tasks:

World Type Selection:

Toggle/Selectable - Tech Level

Implement toggles: Terrestrial, Dwarf, Habitat.

Allow pre-selection of attributes (temperature, atmosphere, size modifiers).

Procedural Rolls:

Integrate d66 random culture table to assign world culture.

Roll starport characteristics based on Habitability, TL, and wealth.

Data Persistence:

Extend save/export to include world properties alongside star data.

Deliverables Summary:

“Generate Primary World” feature with full chart of world stats, culture, starport.

Save/load plus export including world data.

Cycling Task: Allow user to re-roll attributes or undo/redo changes.

Milestone 5: Save/Load & Import/Export Stage (2 000 PHP ● 80 % Progress)

Core Tasks:

Unified Project Format:

Define a master JSON format covering stars, worlds, cultures, starports, and future bodies.

Cross-Platform Transfers:

Enable “Copy as Text” for pasting into Docs/LO/Google Docs.

Provide single-file export/import (JSON, CSV) for desktop↔phone.

Versioning & Recovery:

Implement undo/redo history stacks.

Trigger automatic backups on major changes.

Deliverables Summary:

Robust save/load/import/export system.

Documentation for file format and transfer steps.

Progress Note: For each stage that breaks on integration, a 500 PHP carve-out can be used to fix before advancing.

as

Milestone 6: Celestial Bodies Stage & Final Testing (2 000 PHP ● 100 % Progress)

Core Tasks:

Generate Remaining Bodies:

Implement generation of giant planets, ice giants, minor worlds, and disks per the spreadsheet tables.

Full System Export & Visualization:

Ensure all nested data appears correctly in React Table with expandable rows.

Extensive Cross-Device QA:

Build a distributable package (ZIP) that can be loaded on Android, iOS, Windows, Linux.

Run full smoke tests: generation → save → export → import → display.

Deliverables Summary:

Complete WGPWA with all generation modules.

“Final Release” ZIP and installation instructions. A github page purely for Ticket Tracking.

Post-Launch Bonus:

2 000 PHP bonus if, after 30 days on DriveThruRPG, all reasonable feedback/bugfixes are addressed—no charge if no issues arise.

Version 2 of World generator Progressive Web app

Summary

Version 2 will split into two major subsystems—Procedural Children and 3D Visualization—built atop a robust PWA core. The Procedural Children module generates both physical (landmasses, satellites, habitats) and social (factions, groups) hierarchies with customizable toggles for everything from inhabitance flags to faction stability and competence. The PWA will support deep, nested tables on both desktop and mobile, leveraging a service worker for offline use. Finally, it will offer HTML/markup exports (e.g., Confluence, Markdown, custom HTML) so world-builders can seamlessly integrate generated data into wikis or websites. Budget is 2x as much.

WGPWA – ideally Mneme World Generator will sell an additional 1,0000 units (for total of 1250 units). This will be 3,500php of sales. 500-1000usd or around 25k-50k php will be allocated for version 2 while the rest will be for the 3D GODOT world generator. Converts the Files from the PWA into Scenes and Worlds.

1. Procedural Children Wikipedia

Version 2 introduces a Procedural Children system that automatically spawns hierarchical “child” elements beneath any parent object.

1.1 Physical Children Wikipedia

Land Masses (continents, regions) and Satellites/Habitats (moons, stations) can be generated via parameterized algorithms drawn from the existing PCG rules.

1.2 Social Children Wikipedia

Factions & Groups are created with randomized attributes—competence (ability to execute) and stability (likelihood to endure)—using seeded random functions.

1.3 Toggleable Tables Mendix Documentation

The UI will present a tree/table view where each column (e.g., Size, Atmosphere, Inhabited) can be shown or hidden.

Rows can be expanded/collapsed to reveal child entities, supporting arbitrarily deep nesting.

2. Progressive Web App Core

2.1 Deep Sub-Level Navigation MDN Web Docs

Utilizes a service worker for offline caching, enabling rapid tree-expansion even without connectivity.

2.2 Cross-Platform Compatibility Wikipedia

Built as an App Shell–model PWA, it installs on Android, iOS, Linux, Windows, and macOS browsers with native-like startup and offline support.

3. Godot 3D Visualization (Paid)

A Godot module to render star systems and worlds in 3D.

Live syncing between the React/PWA data store and Godot scenes.

4. Rich Export Options

4.1 HTML & Wiki Markup RedditWikipedia

Export generated tables and hierarchies to plain HTML, Markdown, or Confluence‐style wiki markup via tools like WikiConverter or Doxia.

4.2 Direct Wiki Integration Stack Overflow

One-click export to Confluence markup or other wiki formats so content can be pasted directly into collaborative platforms.

5. Workflow & Toggle Controls

Inhabited Toggle: whether a physical child is automatically populated.

Faction Toggle: enable/disable social-child generation per object.

Preselect Options: e.g., choose temperature, atmosphere, size presets before rolling.

This expanded Version 2 roadmap ensures world-builders can generate both the physical layout and social tapestry of any system, navigate deep nested data seamlessly on any device, and publish their results directly into blogs, wikis, or web pages.

Version 3

Version 3 is a Multi-Player version of Mneme World System –

If it sells around an additional 2,000 usd more or 7,000usd we can afford to work on:

MULTIPLAYER Environment. It becomes a VTT - Like Talespire, tabletop Simulator, Realm Engine, The RPG Engine, or Owlbear Rodeo – where by the Multiplayer settigns can allow people in the same network to control and view objects (in 3d) the Host grants permissions. Primarily for the Space version – allowing Players to see the Star System the Host is demonstrating and allowing them to explore it.

V2 features like lore can be saved and viewed by the users to see what each location or object is. When games can be run under the system (assuming everyone in a VPN) then this is ready for the P2P features

P2P: Configure Wireguard clients built into the MWS and connect to Game in the Brains WG relay servers to find other Peers/Clients to connect to. Basically people can play P2P. The Relay Server is FOSS – and anyone can run the script to deploy them – and share them. Anyone can run a P2P relay server and anyone can use it to run their games and find their friends – it is secure, anonymized, and no one has access to the information.

By this time – There will a dedicated Community Manager who will try to find out what new features and improvements people are willing to help fund. We just improve based on what the community wants.