Closed
Description
Describe the project you are working on
I'm developing a simulation/manager game in Godot called "World Volleyball Challenge", focused on national teams, tournaments (group stage → knockout), and tactical systems, similar in structure to Football Manager. The game is heavily data-driven, and relies on saving/loading large sets of structured data like players, teams, results, tactics, and progression.
I need robust tools to manage structured save files, a tournament simulation engine, and an efficient UI system to present complex data. This also includes support for multiple data formats like JSON, XML, and binary, similar to Unity’s flexibility in serialization and resource matching.
Describe the problem or limitation you are having in your project
Godot currently lacks out-of-the-box tools to support the complexity of data-heavy simulation games:
- There’s no modular save system that supports saving/loading different parts of game data separately (like Unity or FM’s .fmf files).
- There's no built-in support for XML serialization or matching different file types with class/data structure.
- UI lacks a native TableView with sorting and filtering capabilities, essential for managing large datasets (e.g. players, matches).
- Tournament structures (group → knockout → final) must be custom-coded.
- Event-based match simulations require manually coded timelines or state machines.
- Mock data (e.g. fake players/teams) must be written manually for testing.
Describe the feature / enhancement and how it helps to overcome the problem or limitation
The following features would address these gaps and support a wide range of simulation/manager-style games:
- Modular Save/Load System: Support for chunk-based data saving (e.g. save/load only players, teams, results), with JSON/XML/binary format options. Ability to “match” data formats with types/classes, like Unity's serialization.
- Data Format Flexibility: Native support or adapters for multiple formats (JSON, XML, binary), possibly using a serialization layer or file matchers.
- TableView UI Kit: Built-in sortable, filterable tables for handling stats and rosters.
- Tournament Simulation Tools: Reusable tournament engine for group → knockout flow with automatic ranking and progression.
- Match Timeline: Simple timeline utility to simulate events set-by-set or minute-by-minute, with signal support.
- MockData Generator: Built-in script/class to auto-generate players, teams, and matches for testing.
Together, these features would dramatically reduce dev time for sim-heavy games and bring Godot closer to Unity’s flexibility in resource and data management.
Describe how your proposal will work, with code, pseudo-code, mock-ups, and/or diagrams
- Modular save:
save_chunk("players", data)
load_chunk("tactics")
Multi-format support:
gdscript
Kopyala
Düzenle
var xml = XMLParser.read("res://players.xml")
var json = JSON.parse("res://teams.json")
TableView:
gdscript
Kopyala
Düzenle
table.set_sort_by("energy")
table.set_filter("role", "Setter")
Tournament:
gdscript
Kopyala
Düzenle
tournament.advance_stage()
tournament.get_matchups("Quarter Final")
Match simulation:
gdscript
Kopyala
Düzenle
timeline.add_event(0.0, { "event": "start_set" })
timeline.add_event(15.0, { "event": "timeout", "team": "A" })
Mock data:
gdscript
Kopyala
Düzenle
var players = MockData.generate_players(12)
var teams = MockData.generate_teams(16)
yaml
Kopyala
Düzenle
---
---
✅ **If this enhancement will not be used often, can it be worked around with a few lines of script?**
```markdown
Yes, some parts like saving and timeline simulation can be scripted manually, but implementing and maintaining a modular save system, a tournament engine, and a manager-friendly UI from scratch is time-consuming and error-prone, especially for solo developers. Current workarounds are often fragmented or incomplete.
### If this enhancement will not be used often, can it be worked around with a few lines of script?
Some parts of the proposal (like save/load or simple table UIs) can be implemented with scripts or third-party plugins. However, implementing all of these features from scratch — especially modular save/load, tournament flow logic, and efficient data-driven UI components — requires hundreds or thousands of lines of code.
For solo developers or small teams, re-creating these systems each time is inefficient and leads to inconsistent solutions. Native support would ensure better performance, cross-platform stability, and reusable patterns for a wide range of game types beyond just sports managers.
### Is there a reason why this should be core and not an add-on in the asset library?
Yes. These systems (modular save/load, data-focused UI, simulation engines) address needs that are common across many genres — not just sports managers, but also RPGs, tycoon games, life sims, grand strategy, and more.
Having core-level or officially supported solutions ensures:
- Better integration with Godot’s serialization, resource system, and UI nodes.
- Higher performance and consistency across platforms.
- Long-term maintenance and version compatibility, which most asset library add-ons lack.
- Trust and adoption by studios building commercial-scale projects.
While asset library tools can help, making this part of the core (or official modules) would signal that Godot is production-ready for complex, data-driven simulation games.