Suggested The World Of Varied And Noteworthy Achievements

Cervator

Org Co-Founder & Project Lead
Contributor
Design
Logistics
SpecOps
#1
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:
  • 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
Milestones

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!
Module progress

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 ;)
I figure it is important for maintainability to not code the examples in the central world module. They should live and be maintained with their own module. Possibly this could lead to some test / content type material in library modules? Could we perhaps support a resources/tests type location in modules that are normally ignored / not dependency checked unless in this special world module?

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)
With something like this in place you could run this special world and test your stuff easily, while around you the credits/milestone events continue to run, so you might spot if something has stopped working as expected even if you aren't looking for it. This could be a hugely useful tool to maintain stability as we enter beta and beyond.

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
Automated acceptance testing

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
This could again build on the special world, entering an automated player who then takes certain actions like pathfinding to a module's land parcel and performing actions against the stuff that should've spawned. For instance finding and attacking a deer, then validating the kill and that something was dropped. This would run in Jenkins after builds and not be interactive for normal players in this shape.

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.
Roadmap

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 :D
Analytics

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
Extras

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:

Cervator

Org Co-Founder & Project Lead
Contributor
Design
Logistics
SpecOps
#2
Addendum after discussion in old issue #241 - finally closing it after so long with good compatibility logging at least and at last in place :)

Graphics Testing

Having a "steady state" world should allow us, with some effort, to generate screenshots of the world in very specific spots that at a static time with identical config should always look the same on any one system. This could help catch graphics quirks as they happen. It could also help test different OSes as something could break on one system but not another.

Needs:
  • The headless client should be able to simulate screenshots (render to a file)
  • There should be a way to freeze time / game state to ensure the screenshots are always taken at the exact same time (position of sun, etc)
    • For instance simulate the world for exactly x ticks then pause the game loop for everything except player movement. Could also be an interesting feature to examine a scene, especially if could be used as part of a "replay" type functionality
  • Some sort of pixel-level diff tool / analytics
  • Some way of presenting the screenshots in historical lineups and/or related numbers (maybe a way to write out "test" stats in Jenkins just like other analytics)
  • Defining and recording the scenarios we want to test (torches, effect of closed versus open space on lighting, differing graphic settings, etc)
 

metouto

Active Member
Contributor
Art
#3

Edit: I had no idea this suggestion name would end up spelling something - wonder what a TWOVANA is
Two = meaning double

Vana = Called Queen of Blossoming Flowers and the Ever-young, Vána is the younger sister of Yavanna and wife of Oromë. "All flowers spring as she passes and open if she glances upon them; and all birds sing at her coming." She dwells in gardens filled with golden flowers and often comes to the forests of Oromë. Tolkien wrote that Vána was "the most perfectly 'beautiful' in form and feature (also 'holy' but not august or sublime), representing the natural unmarred perfection of form in living things".

So .............

TWOVANA = the most perfectly 'beautiful' in form and feature (also 'holy' but not august or sublime), representing the natural unmarred perfection of form in living things ........ doubled. :coffee:

Is that not what dreams are made of .......:rofl:
 

Cervator

Org Co-Founder & Project Lead
Contributor
Design
Logistics
SpecOps
#5
Another quick addition: Project and module activity could be reflected by the number of busy worker bee NPCs roaming the appropriate area. So if a particular module / module series is seeing a lot of work lately (based on commit count) make more workers run around banging on the walls there.
 

Cervator

Org Co-Founder & Project Lead
Contributor
Design
Logistics
SpecOps
#6