Beware! Crazy and hopefully awesome ideas ahead! Multi-year potential with smaller pieces that could be done in stages.
I've been wanting to do a Dwarf Fortress style activity/credits log for a long time now, as contributors come and go and we make progress with Terasology. The idea grew over time and now includes a bunch of stuff. Further ideas, tweaks, better naming, etc highly appreciated
The World
Rather than a boring list, make a world generator that creates the same static world every time, akin to the one we want for L&S (finite with specific points of interest created). Make it go through a list of time-based events replaying the history of the project, starting simply with spawning NPCs named after contributors as they joined the project. This is kinda like what Gource can do with Git history, and there are stacks of similar visualizers out there.
Needs:
Beyond simply showing contributors add in project milestones, like releases, project birthdays, events, etc. These should also be represented in the world, probably via monuments. Could simply be an obelisk (we got the shapes!) that adds a block per relevant event. Make a few different obelisks for different types. Could also vary each tier of the obelisk to mean something (SemVer in colors?). Also set up some particle-based fireworks or other appropriate effects.
Needs:
So far we've mainly just tracked the engine and overall events. With Iota and releases in Jenkins becoming things we can start tracking modules better too. So make this world one of the things we bundle with Iota, and in fact make the module depend on every Iota module and for every module create a representation in-game demonstrating it! This will be easier for some modules than others, but "non-corporal" modules (like library mods) could probably be represented in a generic fashion or attached to a module that uses the functionality. Since the Iota modules should all be compatible (TTA, L&S, etc are not Iota, though some of their pieces are) activating them all together shouldn't result in conflicts and in fact would have interesting potential for testing ...
Needs:
Acceptance testing
So yeah, I mentioned testing! This is where it starts getting more interesting and useful. Currently if you want to test something in a module you go create a new world and then manually set up what you need to test. In TTA if you were to realistically explore the whole tech tree from start to finish this could take quite a while ... You might also need the console to fetch assets not naturally present in the world or in the player's starting inventory. Wouldn't it be handy if a world generated and automatically seeded a bunch of stuff you need to test?
Needs:
Donors
So we have an interesting and useful world already. It shows the credits, features, and progress of the project - how about we throw in mentions here for donors as well? Donating to the game gets you a NPC spawned in the world with your name, using a creature type marking your contribution level, growing larger / shinier if you keep donating, matching your total donations over time. If you pledge for an on-going tier at Patreon your creature gets something special while your pledge stays active, like a halo, a cape, etc. We can't do this for a player avatar in the actual game without a global account system, but we sure can ship a world with an NPC looking correctly!
Needs:
Wouldn't it be nice to have your acceptance testing done for you? This gets more challenging when you're dealing with a game running in an application window. But like you can automate tests against a web app by "driving" a browser using scripts you can do similar things to a normal application. Probably we need a way to run "agents" against a running version of the game, through a headless client, following a scripted set of tests. Unsure what tools are out there fitting to our case, but I imagine if we write the adapter (the agent running the tests against the game) the tests can be written in a wide variety of tools. Maybe Cucumber could be an option - got that written down from past research, not entirely sure why, heh.
Needs:
Multiplayer testing
Some features need multiple actors involved to test. Easy! Make Jenkins do it. You could also use this to set up a test server outside of formal testing in Jenkins, spinning up the special world, having agents connect and attempt their tests, while regular players can also connect and attempt to interfere with the tests to see what happens. This gets us part of the way to supporting bots - scriptable creatures of some sort you could employ for various purposes.
Needs:
Another piece of interesting potential, especially in Behavior Driven Development (like with Cucumber), is first writing out the features you want in acceptance test language, which leaves you with a bunch of tests failing while their features aren't implemented. Instead of simply having that run via command line or Jenkins to tell you what's wrong, find a way to attach world representation. Remember the world with module demos earlier? Simply picture that with empty lots representing unimplemented features, or partially implemented features. Like a broken, empty, demonstration. Walk around the project world and see where work is needed. Over time the world updates for free simply by virtue of having the features implemented and the tests/setup successfully execute. Automagic roadmap!
Needs:
Beyond simply showing features or modules with a physical world representation you could further decorate with results from analytics. For instance at build time after tests and code analytics have run write out a list in a format readable by the game that'll put gremlins around a module's land parcel corresponding to the amount of Checkstyle warnings, TODO tags, and so on. Poll the number of issues filed on Github and put actual bug creatures in the world with the nametag of each bug issue, another creature type for enhancements, and so on. If an issue has a bounty decorate its creature with a rainbow ending in a pot of gold and have the reward drop if the creature is killed (but only in in-game currency, naturally, gotta go fix the bug to claim the actual bounty!). If a bounty is claimed add an event in-world when it was fixed and who did it. Issue creatures actually could replay history with a bit of archiving added.
Needs:
You get the idea by now - we could go as nuts with this concept as we want, and the base setup isn't very hard (more the testing is - which is also the most useful). This would be an on-going project slowly getting fancier. For instance you could attach random sayings to notorious contributors based on quotes on IRC (heck, there are tools that'll do IRC analytics). I claim "Wololo!" and "Wizardry!" Beyond the base Iota world you could make additional worlds specific to the major gameplay series like TTA, L&S, etc, since they cannot coexist in the same world as everything else. More ideas? Throw them in!
Needs:
Edit: I had no idea this suggestion name would end up spelling something - wonder what a TWOVANA is
I've been wanting to do a Dwarf Fortress style activity/credits log for a long time now, as contributors come and go and we make progress with Terasology. The idea grew over time and now includes a bunch of stuff. Further ideas, tweaks, better naming, etc highly appreciated
The World
Rather than a boring list, make a world generator that creates the same static world every time, akin to the one we want for L&S (finite with specific points of interest created). Make it go through a list of time-based events replaying the history of the project, starting simply with spawning NPCs named after contributors as they joined the project. This is kinda like what Gource can do with Git history, and there are stacks of similar visualizers out there.
Needs:
- Finite world generator - also needed for L&S. Can of course skip for some time.
- Support for excluding seed selection for a world. Also skippable.
- Ability to write a list of time-based events in some nice format, probably like the text-based asset prefabs, that some system will play inside the world over time.
- Make these events write to the console log as well and we've got the text log version too.
- Generic NPC to represent contributors, just wandering around
- Floaty name tags
- Ship the special module with the Iota distro, possibly with data added at build time in Jenkins
Beyond simply showing contributors add in project milestones, like releases, project birthdays, events, etc. These should also be represented in the world, probably via monuments. Could simply be an obelisk (we got the shapes!) that adds a block per relevant event. Make a few different obelisks for different types. Could also vary each tier of the obelisk to mean something (SemVer in colors?). Also set up some particle-based fireworks or other appropriate effects.
Needs:
- Event format expansion to cover more stuff
- A way to pick a single static location to maintain a persistent structure that'll grow over time
- The persistent object that'll grow - a celebratory obelisk
- Fireworks!
So far we've mainly just tracked the engine and overall events. With Iota and releases in Jenkins becoming things we can start tracking modules better too. So make this world one of the things we bundle with Iota, and in fact make the module depend on every Iota module and for every module create a representation in-game demonstrating it! This will be easier for some modules than others, but "non-corporal" modules (like library mods) could probably be represented in a generic fashion or attached to a module that uses the functionality. Since the Iota modules should all be compatible (TTA, L&S, etc are not Iota, though some of their pieces are) activating them all together shouldn't result in conflicts and in fact would have interesting potential for testing ...
Needs:
- The world should put aside parcels of land for each module, tagging it for that module's use visibly in-world, and activating the demonstration functionality
- Maybe intelligently sort the parcels somehow. There are algorithms for fun stuff like coloring countries on maps without putting two alike next to each other, we could probably do something similar
- "Non-corporal" modules could probably sort so they're adjacent to their users
- Modules need a way to define a demo snippet showcasing its functionality.
- Tree asset module planting its trees when given a parcel of land
- Model asset module spawning its creatures
- World gen module generating an example of what it does (if too large perhaps generate then shrink the output like how the miniaturizer could make floaty mini chunks)
- Pathfinding creating a tiny maze and having a creature navigate it (might be a good example where three modules could live together)
- Inventory module might spawn a simple chest with items in it (again might need a secondary content module to actually do so)
- Similar milestone events should be supported for modules, perhaps obelisks in a fence surrounding the parcel of land.
- Hyperlink blocks so the player can open a browser to the modules home. Could even use QC codes on blocks so you can scan it on-screen via phone
Acceptance testing
So yeah, I mentioned testing! This is where it starts getting more interesting and useful. Currently if you want to test something in a module you go create a new world and then manually set up what you need to test. In TTA if you were to realistically explore the whole tech tree from start to finish this could take quite a while ... You might also need the console to fetch assets not naturally present in the world or in the player's starting inventory. Wouldn't it be handy if a world generated and automatically seeded a bunch of stuff you need to test?
Needs:
- Probably needs a second round of prep from modules. Previous section is really just a showcase while this would mean preparing to test exact features
- Some way to informally define acceptance test cases, maybe together with what generates the needed setup (more below)
- Might need more ways to place content in the world
- May get into "soft" or "supporting" module dependencies more - many scenarios need stuff from multiple modules that wouldn't normally have hard dependency chains (in addition to any actual hard dependency chains)
Donors
So we have an interesting and useful world already. It shows the credits, features, and progress of the project - how about we throw in mentions here for donors as well? Donating to the game gets you a NPC spawned in the world with your name, using a creature type marking your contribution level, growing larger / shinier if you keep donating, matching your total donations over time. If you pledge for an on-going tier at Patreon your creature gets something special while your pledge stays active, like a halo, a cape, etc. We can't do this for a player avatar in the actual game without a global account system, but we sure can ship a world with an NPC looking correctly!
Needs:
- Creature models and textures usable for donors
- Special effects / attachments for models (need those in-game for other reasons anyway)
- A way to automatically convert pledge levels and donation info to a format the game can read, generated at build time in Jenkins
- Actually having a nice looking Patreon / Donation page explaining this, probably other rewards too like sponsor blocks in the forum
Wouldn't it be nice to have your acceptance testing done for you? This gets more challenging when you're dealing with a game running in an application window. But like you can automate tests against a web app by "driving" a browser using scripts you can do similar things to a normal application. Probably we need a way to run "agents" against a running version of the game, through a headless client, following a scripted set of tests. Unsure what tools are out there fitting to our case, but I imagine if we write the adapter (the agent running the tests against the game) the tests can be written in a wide variety of tools. Maybe Cucumber could be an option - got that written down from past research, not entirely sure why, heh.
Needs:
- "Agents" serving as a test harness that can work the game somehow
- These need to support an assertion criteria to qualify a test as successful / failed
- Headless client mode - like headless server, just more clienty
- Maybe another layer of abstraction in the GUI layer so interactions can be faked by agents?
- More formally written test cases, possibly in some compatible framework
Multiplayer testing
Some features need multiple actors involved to test. Easy! Make Jenkins do it. You could also use this to set up a test server outside of formal testing in Jenkins, spinning up the special world, having agents connect and attempt their tests, while regular players can also connect and attempt to interfere with the tests to see what happens. This gets us part of the way to supporting bots - scriptable creatures of some sort you could employ for various purposes.
Needs:
- The headless agents should be able to connect to a server
- This could also be an interesting point to start testing different OSes for actually running the game, even if only in a headless client fashion. Can spin up dynamic VMs to do this.
- The headless server should be able to launch out of Jenkins and accept connections from headless agents
- We should be able to launch the special world in this way including the full demo of the project timeline while players can connect, watch, and screw things up.
Another piece of interesting potential, especially in Behavior Driven Development (like with Cucumber), is first writing out the features you want in acceptance test language, which leaves you with a bunch of tests failing while their features aren't implemented. Instead of simply having that run via command line or Jenkins to tell you what's wrong, find a way to attach world representation. Remember the world with module demos earlier? Simply picture that with empty lots representing unimplemented features, or partially implemented features. Like a broken, empty, demonstration. Walk around the project world and see where work is needed. Over time the world updates for free simply by virtue of having the features implemented and the tests/setup successfully execute. Automagic roadmap!
Needs:
- Further fleshing out of acceptance testing structure
- Adding structure to the special world. Picture it as a large city with the center made up by engine features, surrounded by Iota modules, then the distro with the big gameplay modules.
- Could add some city walls for categorization.
- Teams could also be represented if desired and doable in the architecture / layout somehow. Or decorate contributors with badges akin to in the forum.
- Volcano module has to go outside the wall! Same for Godzilla.
- Maybe an easy way to export this to a static image to place on a website. Let the world generate then have a headless agent take screenshots
Beyond simply showing features or modules with a physical world representation you could further decorate with results from analytics. For instance at build time after tests and code analytics have run write out a list in a format readable by the game that'll put gremlins around a module's land parcel corresponding to the amount of Checkstyle warnings, TODO tags, and so on. Poll the number of issues filed on Github and put actual bug creatures in the world with the nametag of each bug issue, another creature type for enhancements, and so on. If an issue has a bounty decorate its creature with a rainbow ending in a pot of gold and have the reward drop if the creature is killed (but only in in-game currency, naturally, gotta go fix the bug to claim the actual bounty!). If a bounty is claimed add an event in-world when it was fixed and who did it. Issue creatures actually could replay history with a bit of archiving added.
Needs:
- More assets you can put parsed data into for creating events, creatures, and so on
- Appropriate models and drops
- Parse out info from a list of bounties available and bounties claimed
- Parse out info from code analytics reports in Jenkins
- Maybe a way to trigger a hyperlink in-game if you find a bounty creature and want to see the associated issue
You get the idea by now - we could go as nuts with this concept as we want, and the base setup isn't very hard (more the testing is - which is also the most useful). This would be an on-going project slowly getting fancier. For instance you could attach random sayings to notorious contributors based on quotes on IRC (heck, there are tools that'll do IRC analytics). I claim "Wololo!" and "Wizardry!"
Beyond the base Iota world you could make additional worlds specific to the major gameplay series like TTA, L&S, etc, since they cannot coexist in the same world as everything else. More ideas? Throw them in!Needs:
- Speech bubbles for creatures
- More world manifests for other setups
- Brief module descriptions for stable modules that fall outside both Iota and the gameplay distro? We can summarize experimental modules without actually including them, like a module index site in-game just with screenshots only.
- Have contributor creatures actually path around the modules they've worked on
- ???
Edit: I had no idea this suggestion name would end up spelling something - wonder what a TWOVANA is
Last edited:
