Bamboo & Silk: The Weaver's Journey

Bamboo & Silk is a 2D point-and-click adventure game set in a small Chinese village during the Ming dynasty. You play as Meilin, a young weaver whose family has depended on silk for generations. A severe drought has killed the mulberry trees, threatening the village's livelihood. Meilin must venture to nearby towns, trade with merchants, and rediscover ancient weaving techniques to revive the silk trade.

The game emphasizes exploration, dialogue, and light puzzle-solving. There's no combat; conflicts are resolved through persuasion, bartering, or clever use of items. The art style is inspired by traditional Chinese ink wash painting, realized with pixel art using a limited palette to evoke that aesthetic. Audio is minimal: a few ambient tracks created in LMMS and sound effects sourced from free repositories.

Development is done entirely with free, open-source tools: Godot Engine, Piskel for sprites, and Audacity for audio. The small team (or solo developer) relies on historical references from public domain Ming dynasty paintings and texts. The game aims for a 2-3 hour experience, with a branching narrative based on which allies Meilin helps or fails to help. The shoestring budget means no voice acting, no orchestral score, and no marketing spend—just a passion project shared on itch.io and community forums.

The itch this scratches is twofold: First, there's a glaring lack of accessible historical games set in non-Western cultures, especially those that treat ordinary people with dignity rather than exoticism. Second, the indie space is saturated with horror, platformers, and roguelikes; a quiet, narrative-driven point-and-click about craft and community offers a refreshing alternative. The game also addresses the desire for low-tech games that run on any laptop, making development and play accessible to people with limited resources.

• Create a 2-3 hour point-and-click adventure with a complete story arc
• Depict Ming dynasty village life authentically using public-domain references
• Use only free, open-source tools (Godot, Piskel, Audacity, LMMS)
• Include a branching narrative with at least 3 distinct endings
• Implement simple crafting mechanics (weaving patterns from collected recipes)
• Optimize for low-end hardware (runs on 5+ year old laptops)
• Release for free on itch.io with a 'pay what you want' option
• Build a small community around the game via dev logs on forums like TIGSource

• No combat or violence mechanics
• No voice acting (to keep budget near-zero)
• No 3D graphics or complex lighting
• No real-time elements; turn-based or menu-driven only
• No inventory of more than 10 items; each is meaningful
• No multiple save slots or cloud saves (simple single-save system)
• No DRM or monetization beyond voluntary donations
• No attempts to compete with commercial historical sims like Assassin's Creed

Game Engine: Godot Engine 3.5 (free, open-source, 2D-focused) Art: Piskel (free pixel art editor) and GIMP (for UI mockups) Audio: Audacity (editing), LMMS (music composition), freesound.org (SFX, CC0) Writing & Planning: Google Docs, Twine (for dialogue branching) Version Control: Git + GitLab (free private repos) Reference Materials: Public-domain Ming dynasty paintings from the Metropolitan Museum of Art, Wikipedia articles on sericulture Distribution: itch.io (free hosting)

The game is structured as a series of interconnected scenes (locations) managed by Godot's SceneTree. Each scene contains interactive objects (sprites with collision shapes) and dialogue triggers. The narrative state is stored in a global Singleton (autoload) as a dictionary of flags and variables. Player input is handled via mouse clicks: clicking on an object triggers a proximity check and then either a dialogue block or an inventory interaction.

Dialogue runs through a custom branching system: each line has an ID, speaker name, and optional choices. Choices update the global flags and may unlock new scenes or items. Puzzles are simple: combine inventory item A with scene object B to produce item C (e.g., 'mulberry bark' + 'spring water' = 'paper pulp' for a puzzle). The weaving minigame is a drag-and-drop pattern matching game where players arrange colored threads on a loom to unlock new silk recipes.

The game's economy is tied to the barter system: Meilin has a 'favor' counter with each NPC, increased by helping them. Higher favor unlocks better trade options for needed supplies. No gold or currency; everything is a trade of services or items.

The entire game runs in one executable with no external dependencies. Save files are plain text (JSON) stored in the user data folder, containing only the current scene name and the global flags dictionary. This keeps the save system simple and cross-platform.

1. Historical inaccuracy: Relying on public-domain references might miss cultural nuances. Risk reduced by consulting free online resources from universities.
2. Scope creep: Adding too many puzzles or endings could delay release. Mitigated by strict adherence to the 2-3 hour target and trimming features.
3. Audio quality: Free samples may sound amateurish. The risk is accepted as part of the shoestring aesthetic.
4. Low discoverability: Without marketing, the game may remain obscure. Mitigated by active engagement on itch.io, Reddit, and indie dev forums.
5. Burnout: Solo developer (or small team) might lose interest. Mitigated by setting small, celebratory milestones.

• Should we include a 'historical notes' screen that explains Ming dynasty context for each major item or character?
• How to handle multiple endings without bloating the dialogue tree? Possibly a final dialogue checkpoint that branches based on a few key flags.
• What's the best way to implement the weaving minigame? A drag-and-drop pattern game, or a rhythm-based button press?
• Should the game be translated to Chinese (Simplified) to reach the target audience? That would require a translator.
• How to ensure the game runs on Linux/Windows/Mac without extensive testing? Godot's export should work, but we may need community testers.

The creator started prototyping but hit a wall when they decided to research Ming dynasty sericulture in depth. They realized it would take at least six months of part-time study to get it right. Meanwhile, they landed a full-time job, and the project lost momentum. The game remains a beloved plan on a hard drive, waiting for a sabbatical or a collaborator who knows Chinese history.

The game's title comes from the two main materials in silk-making: bamboo frames and silk fabric. The shoestring theme parallels the protagonist's resourcefulness. The open-source toolchain ensures anyone can contribute or fork the project. This plan was heavily inspired by the free RPG 'Stone Story RPG' and the historical adventure 'Sorcery!' series.