Official development blog

Beyond the Design Doc: Unplanned Cogmind Features

Building a solid game calls for a good design doc. Laying out at least the core vision, along with preferably additional details about how features and their implementation work together as a coherent whole, is a much safer way to develop rather than repeatedly wandering down the wrong path and having to backtrack.

Even back in 2012 the Cogmind 7DRL had a design doc, honestly even more important in that case because you need some real direction and focus to ensure completion of a game like that in a week! Not the best example, being my first ever attempt despite years of prior dev experience (during which I never finished a game, go figure!), but it served its purpose, and I’ve since written many more for other potential roguelikes.

The most relevant among those would be Cogmind’s own, which when the project was resurrected the next year (2013) grew from 1,119 to 18,000 words. That doc was updated and expanded throughout two years of pre-alpha development, natural during such a phase while the world and systems are still being molded into a concrete shape, and had grown to 30,000 words by the time Cogmind’s first version was released in May 2015. At that point the core of the game was complete, and the rest of the features necessary for the full experience had been mapped out, thus the plan was to more or less stick to the doc while finishing up the game.

But… things didn’t quite go down that way :P

With decent support for the alpha release, I immediately started instead looking at all the untapped potential that could be unleashed by filling gaps in the design, adding to the density of the experience rather than emphasizing its breadth. (The design doc was honestly more interested in the latter.) So I ended up setting aside the doc and working on other features--in fact, I didn’t even get back to working on stuff from the design doc proper until six months after the first release! (in December 2015 with Alpha 5)

So today I wanted to show what this means for a post-Alpha Cogmind. Essentially, how much of what has been implemented throughout two years of alpha development wasn’t actually planned to be part of the game to begin with? Sure the original game as described by the doc would’ve been good, but the extended “early access” development period has been a great success in terms of improving it further.

Each section below will also come with a mention of what else might be in store, because, well, we could be in Beta for a while as I continue adding stuff :D

Systems

Larger systems that hook into multiple aspects of the game are my favorite thing to add, where possible, since they allow strategic options to grow exponentially, forming the backbone of what players generally consider to be “depth” when it comes to gameplay.

Post-release Alpha development started out with a number of unplanned systems, features that made a lot of sense to add before expanding the breadth of the world (the layout of which was otherwise fairly linear when Cogmind was first released). Naturally the design behind new maps would be better off if they could take into account all the same systems at inception, rather than having to retroactively adjust all those maps later!

Traps

Traps are common enough in roguelikes, but honestly I’d never really considered them. Even the 7DRL design doc made no mention. The spark was a random comment on r/gamedev‘s Screenshot Saturday, one that apparently happened to come at just the right time. (Score another point for sharing info about your game with as many people as possible, as early as possible, and engaging them in conversation!)

cogmind_explosive_trap_step

Intentionally triggering an explosive trap to damage nearby bots (since they’re much weaker than Cogmind!).

Inclusion of traps in roguelikes is often controversial these days, though it’s easy to see where the faults lie and within Cogmind’s design it wasn’t too hard to circumvent those issues. The main reason it suddenly felt right to add traps at the time was that one of the more common requests from early Alpha players was that they wanted more environmental interactions. I didn’t want to go as far as full area-based environmental features like water, lava, smoke and whatnot because Cogmind’s design focus is on robots, plus such features would need to be built in from the ground up as a central consideration of many mechanics, the AI, overall map design, and more. (You either go all the way with it or don’t include it at all, otherwise it’ll feel out of place.)

But traps were a relatively simple way to provide more environmental interactions in the form of isolated objects. I’ve written a lot more about the subject here, and after that traps even became extractable so they could be carried around and relocated.

cogmind_using_gamma_bomb_trap

Luring a Sentry outside a garrison after placing EMPs.

 

cogmind_trap_art

Art for some of the trap items.

Fully implementing a new system also tends to suggest multiple related features, thus with traps came a new type of map area: Waste. Unlike shaft or chasm behavior found in other roguelikes, Chute Traps taking the player to a lower/earlier floor in Cogmind wouldn’t work very well. Instead, it brings them to a special “map between maps” that eventually leads them to another part of the same general floor they were on (after surviving whatever happens to be down there :D). Waste maps ended up having other implications for both lore and strategy as well.

Garrisons

The earliest versions of Cogmind had no garrisons or Garrison Access points. This presented a couple design problems, most importantly that it was a lot easier to find exits by simply searching in the direction from which newly dispatched pursuers were approaching. It also meant that since you might be quite far from any exits, enemy responses to your activity could seem fairly sluggish.

Adding Garrison Access, or a new type of “special entrance” for combat bots, both increased enemy response times and made escaping less trivial. The system also links into many other aspects of the world, such as affecting localized difficulty by dispatching reinforcements to fights in their vicinity (dangerous!) and offering a new avenue for hacking interactions (the access point itself). Because it wouldn’t do to have these robots coming from some unreachable place, it’s possible to enter the garrison itself, adding yet another type of “map between maps.” Opting to enter could be for the good combat loot, to take out relays and improve robot hacking potential, weaken enemy resistance capabilities in nearby maps, possibly tunnel to another map, or maybe just a last ditch effort to escape other problems?

cogmind_unlocking_garrison_access

Unlocking a Garrison Access point.

 

cogmind_garrison_layout_labeled

Sample garrison interior layout (labeled).

More detailed info about Garrisons was written back when they were first introduced.

Unauthorized Hacks

Also in early Alpha, with players of course still calling for more ways to interact with the environment, I decided that machine hacking could provide more variety there while remaining within the confines of Cogmind’s general design principles. Sure there were already a lot of regular commands/targets for players to hack, but what about all the possibilities that become available if we start allowing Cogmind to use interactive machines in ways that weren’t intended by their creators? :)

cogmind_trojan_detonate_effect

Nuclear Reactors previously infected with a Trojan that detonates them if an enemy passes by.

The system was first described in this post, covering the beginnings of both Trojans and brute force hacks that add strategic and/or tactical elements, depending on the hack. It’s great because with such a system already in place, there’s plenty of room to expand it, so I’ve been doing that bit by bit over the years with new hacks, and will continue to do so. (As of now there are 22 different unauthorized hacks, double the number introduced with Alpha 4.)

\\ZION

Beyond early Alpha there was a long lull in non-design-doc systems being added to the game, mainly because as mentioned earlier it becomes harder to insert them as the world grows (plus there was still a lot of meat to get on to anyway!). But as development reached into the end-game, enough time had passed to get a feel for the strategic value of mid-game areas, some of which were still clearly lacking. I want every area of the world to have its own reasonably useful purpose that not only fits into the lore, but also makes it a worthwhile visit for at least some play styles.

So during a second pass over some of those areas, a new form of (sort of) hacking was born. It’s rather spoilery so I won’t go into the details here, but it significantly impacts how a run plays out once Cogmind gains this ability. The idea was to give anyone, not just those with a good hackware setup, access to limited capabilities along the same lines that hackers have. This feature spans a wide range of benefits including information warfare, build assistance, combat support, and more, essentially tying it into the mechanics on multiple levels. With its minor drawbacks I’ll admit it’s somewhat OP in its current state, but I plan to address that later. For now it’s a nice crutch for those who want to take advantage of it :D

Derelict Logs

Data logs found lying around in various outlying cave areas were added for Alpha 7, which was the first release to finally include caves at all. Caves were planned from the beginning, but like many map designs bringing them to life and giving them strategic value required adding new mechanics and unique content. I didn’t always know what form that would take beforehand, but with caves it made a lot of sense to have them contain data collected by Derelicts, the area’s primary inhabitants, many of whom are also interested in keeping tabs on activity in the main complex.

These logs are essentially free information that improves the player’s chances of survival at a later point in the game, providing an extra benefit for going into the caves, which are otherwise somewhat dangerous and not always worth a trip (especially for those players who turn back before reaching the best rewards at the end).

cogmind_derelict_log_info

Derelict Log item.

This turned into a fairly big system on its own, as it was integrated into the terminal hacking and dialogue systems as well (meaning talking to certain NPCs could provide similar benefits), and the amounts and types of information logs reveal can vary greatly. Logs can locate stockpiles, traps, exits, hidden doors, sentry positions, key locations on the world map, and more.

More?

I’m the least certain about future possibilities for this particular feature category, since expansive new systems can be hard to edge in without without having too large a destabilizing effect on the rest of the experience, requiring a wave of rebalancing and in turn yet more unexpected ripple effects. Not to mention the later in development, the more work required to fully integrate each new system.

One of the larger Alpha changes back in mid-2016 was a revised Fabrication system, though that was more of a simplification than a complete rework so the subsequent negative impact was limited.

Robot hacking, on the other hand, is definitely slated to be replaced by a new system. I wrote about its first implementation before release, and made adjustments later in Alpha, but it was always an incomplete placeholder system that has repeatedly shown its weaknesses. (It was hard to settle on a good design in the abstract pre-release days during which there was extremely little full-run testing, so the plan was to wait and see. Actually machine hacking was handled similarly, but ended up easier to improve via incremental patching.) It’s taken a while to come up with an alternative robot hacking system, and building it will be quite a project, but will be worth it for the range of new play style possibilities.

World and Lore

As Alpha came to a close Cogmind had 31 map types, 5 of which were not mentioned in the design doc. Waste and Garrisons I covered earlier as part of their relevant systems--those were added more for mechanical reasons, but several other maps were created primarily to flesh out the story.

cogmind_world_map

World map interface with a sample route.

Although fairly easy to ignore for those players not interested, the story and its background are meant to be epic. But with that “epic story” only about three-quarters composed at the start of development, along the way I had to keep an eye out for the best opportunities to fill gaps as naturally as possible. (This approach worked out rather well, leaving a little bit of flexibility at the fringes.) That’s how we got the Deep Caves and Lab, and is also the reason Alpha 13 expanded Zion beyond its original scope. In fact, the major NPC now found there was not even part of the story to begin with!

Technically most maps grew beyond their initial scope as described in the design doc, as each needed enough content to make it a special experience of its own rather than just more of the same in a different flavor. This meant that adding a single new map could require up to two weeks: I ended up writing “mini design docs” for every single map, each of which became an avenue to introduce new items, robots, and even entire mechanics. The biggest deviation from the world plan involved one of the final maps. This most secret map of all was originally going to be not all that secret, nor all that hidden, but its nature changed significantly when it came time to actually create it, initially for lore purposes but then also to provide an even more difficult challenge.

With the world growing over time, and plot with it, the intended 3-4 different endings also weren’t quite enough. By the time development reached the end of all plot lines, it seemed that 7 endings was a more appropriate number :). Although many of the circumstances leading to each ending were achievable in earlier versions, proper endings weren’t added until Beta 1. Adding them intermittently, one at a time, would have been much less efficient, whereas implementing them all at once kept the quality consistent and made it possible to build a comprehensive system capable of satisfying the different needs of every ending at once.

cogmind_ending_animation_tracking

Tracking who what where why now?

(There are still other elements that fall into this category, but it’s hard to talk about them without posting too many spoilers. Examples include the map shortcuts and “DM conduit,” where the latter is a result of a pretty strong driving force throughout development: repeatedly asking the question “what should happen if the player decides to do… this?”)

More?

While it’s not a good idea to reveal absolutely every detail about the story (leaving just enough room for speculation and imagination helps draw players deeper into the world!), there is definitely more space to explore along the edges, even if only tangential to everything else that’s going on. In that vein I’ve been considering several more maps and even a couple new subfactions which might one day be added. And of course each map will in turn need more unique features to flesh it out…

Balance

As a roguelike grows along with its community, and the theory behind much of the design doc becomes the reality of watching players interact with systems and content, it’s inevitable there will be plenty of balance changes. While these changes don’t normally spawn entirely new systems (balance is more often about tweaking what’s already there), as part of efforts to cut down on experts using cheesy tactics to farm points I did introduce a “high security” mechanic. It’s a pretty heavy-handed reaction from the world that essentially tells players to “get out now while you still can” :P

Scrap was another unplanned feature added for balance purposes, piles of junk containing potentially useful parts. They can be a lifesaver in the caves where spare parts are otherwise scarce, and like traps they offer a new point of interaction with the environment (here the equivalent of treasure chests). Of course, that scarcity was created by another unplanned mechanic, self-destructing parts, which made it harder to salvage bots there in the first place! (And that bit was added to balance the caves in the larger picture.)

cogmind_scrap_info

Scrap item info.

Overall, though, Cogmind has reached a fairly balanced state. There are still a small number of exploits to address, strategies that have emerged organically from the mix of so many mechanics and systems, though by not dealing with them right away, directly, final solutions can be integrated into other features yet to come, holding the design together more tightly. For example it’s likely that a new type of clock will emerge as part of another non-design-doc feature that I’d like to add at some point, and that can be built in such a way that it closes off some exploits as well.

Quality of Life

“QoL” would have to be the largest single category of unplanned features, getting significant new additions with every Alpha release. While Cogmind has always been relatively accessible among traditional roguelikes, there are so many different ways players might want to approach the game’s information and UI, and not all of these will be apparent until lots of different players are actually playing!

Honestly there was almost no playtesting during pre-Alpha (the public 7DRL before had already proven the core mechanic was fun, and that was enough for me at the time!), but once everyone (including myself :P) started tackling full runs there were very obvious areas with room to streamline the experience. The first release was fun, but it would be annoying at best for the UI of today to go back to that state after getting so many extra features. Some of the bigger ones, for example…

cogmind_automated_inventory_management

Smart inventory management (Alpha 5c). Cogmind is full of inventory management decisions, but a number of them are no-brainers so why not have the game just take care of those automatically!

 

cogmind_part_sorting_animated_final

Automated part sorting (Alpha 9). Long parts lists are harder to parse when they’re not organized, and repeatedly doing it manually is probably a waste of time when the game can just group like parts for the player. (Note: The visual design process for this particular feature I’ve written about before.)

 

cogmind_evasion_UI

Evasion breakdown (Alpha 10). There was originally no way to easily check just how effective your evasive capabilities were at any given point, since it’s the sum of many factors, but now there’s a single number and summary available right on the HUD.

 

cogmind_manual_hacking_codes_machines

Manual hacking code recall menu (Alpha 10). Before this feature it was generally necessary to write down the 4-character codes you discovered and might want to use later, but they’re only valid during that run, and you may not even get a chance to use them anyway, so it was a pretty wasteful requirement.

 

cogmind_slot_based_part_swapping

Slot-based part swapping (Alpha 11). For a while those players using a large inventory as part of their strategy might have to spend too much time searching for the right item. Inventory sorting has always been a thing, which helped somewhat, but why not make it possible to quickly pull up a list of valid items to choose from? :D

 

cogmind_manual_hacking_autocomplete

Manual hack autocompletion (Alpha 12). While a command buffer was added early on to simplify the process of repeating manual hacks, there are also somewhat lesser used hacks that would end up far back in the buffer, not to mention the continually growing number of hacking possibilities (91 as of today…).

 

cogmind_part_info_visualization_with_values

Additional data visualization modes--only four were planned, but we now have eight, as well as accompanying number values. This feature was initially designed for bar graphs only, since the point was to show relative values, but it turns out that having specific numbers is useful as well.

Difficulty Modes

At first I was reluctant to add separate difficulty modes (discussed in detail here), but they do make a lot of sense for accessibility. So far they seem to be serving their purpose, but the true results won’t be in until available on Steam, where Cogmind will be exposed to a greater ratio of players not already familiar with the genre.

cogmind_easier_mode_option

Setting Cogmind’s difficulty in the options menu.

I did later adjust them such that some areas are inaccessible to easier modes, partially because those areas are quite difficult by their nature (regardless of mode), and also to give players who can consistently reach them in easier modes some impetus to up the challenge. (It’s still possible to win in any mode--these are just outlying special/lore areas.)

More?

With any sufficiently expansive game there is nearly endless potential for QoL improvements, much less a roguelike that continues to get new content updates over a long period. Most of the existing features are taken care of pretty well, but I’m sure this category is incomplete even now--it will grow in response to playtesting and feedback on new features (and to a lesser extent as a result of new types of players joining).

Meta

There are many ways to add value to a game beyond the core experience, though naturally these kinds of things should wait until later in development so there’s actually something to build off (also so it’s more apparent where the greatest value for effort can be found). While I’ve always had some “meta” ideas floating around, none of those considered early on have been implemented. Instead, as alpha development neared completion I worked in newer ideas that seemed best at the time.

Lore Collection

The world of Cogmind contains quite a bit of useful (or just interesting) information among its lore. The way that lore is acquired, however, across many runs and from numerous different sources, doesn’t really lend itself to forming a coherent picture of what’s going on. This would be less of an issue if there were a single plot line, but the story is more a web of factions and NPCs with their own agendas and take on things. That and the lore includes quite a few tips regarding how the world works. So it eventually became obvious that we needed a central repository for all this lore, some way to conveniently reference it all.

cogmind_lore_UI

Testing the lore collection UI (Alpha 10).

Of course meta features are often also suitable for application outside a game (e.g. integration with external programs). For example players with a growing lore collection would like to be able to read it when not in game, or even in interact with it in some other format…

cogmind_lore_export_html

Sample HTML lore export, including links (Beta 2). (Also supports exporting to TXT and CSV.)

(More on the lore and story-related features here.)

Challenge Modes

As the world approached completion in late Alpha and a handful of players had seen much of what it had to offer at the time, special modes that add new rules or enforce certain restrictions on play seemed like a fun and easy way to increase replayability. There are currently eight such modes (ideas are sourced from the relevant forum thread), with many more to come. They’ll also need their own options menu UI, as opposed to the current method of control purely via the config file.

As with difficulty settings, early in development I’d never really thought about a need for extra challenges, aiming to create a world in which certain optional areas and approaches would naturally be more challenging. The ease of tacking on new challenges makes it really tempting at this point, though, considering there’s such a high reward-to-effort ratio!

Gallery Item Stats

Players had been asking for a while if they could have access to item information via their art gallery, essentially turning it into a makeshift stat compendium. During the Alpha design process I realized this is not the ideal way to present such information, and came up with an alternative, but that alternative would also require a rather long time to implement… In any case, enough players had been asking long enough that it was time to do something :)

cogmind_item_gallery_info_access

Item art gallery with stat access (Beta 2.1).

Sure enough, after adding this feature there were a few comments about how they’d now like it to be able to do XYZ. At least I can say that if it ever comes to be, the alternative could do that and more. That’s the thing about adding features as per player request--fulfilled requests often become the new launching ground for more requests xD

More?

Other meta features are generally of secondary concern, so it’s hard to say much about the future of this category other than that it’s far from exhausted. I’ve always wanted to redo the score sheet, though, a project waiting on the sidelines since it’s best done as late in development as possible where all the different needs it has to accommodate can be taken into account. (The only thing worse than redoing a feature is redoing it multiple times! Really though a first “redo” of the score sheet is warranted since it hasn’t been redesigned at all since the 2012 7DRL, just expanded again and again :P)

Miscellaneous

The broadest category of unplanned features is composed of numerous smaller bits used to fill cracks in the design, either for balance or sometimes just for fun.

One of the more frequent goals here has been to make combat more viable and varied, since the environment and overall mechanics otherwise tend to give the strategic advantage to those who prefer (and are capable of) avoiding confrontation. While that tendency will never be fully reversed, combat became a lot more interesting, and reliably winnable, as Alpha progressed.

Some examples involving differentiation of combat styles:

cogmind_secondary_targeting

“Gunslinging” was only added in Beta 1, allowing a single volley composed purely of guns to be redirected across multiple consecutive targets. Before this it was easy to waste shots on a target that was already destroyed. I originally considered that part of the tactical considerations necessary for turn-based volley combat--fire many weapons and risk overkill, or fire fewer and risk the target surviving to continue the fight? But the volley timing adjustments later in Alpha made that consideration less and less of a factor anyway because firing extra weapons required almost negligible additional time, just additional resources.

Cannons also got their day in the sun, with an overflow mechanic allowing surplus damage after destroying a single part to transfer to another part. This had the greatest effect on powerful late-game cannons that might otherwise blast a weak part but then have no other effect, making them randomly ineffective and unreliable. (There is still some room here to further differentiate cannons and guns, for which I have some ideas.)

Melee combat wasn’t part of the 7DRL version, and while I added it to the commercial version because it’s cool (and players would expect it!), it was meant to be relatively niche, had to be balanced against ranged combat, and ended up being underutilized for a while. By late Alpha the core combat styles were pretty clearly defined, so it was time to revisit melee and do something to make it more desirable. Many somethings were done :P

Actuators and other utilities were added to help builds with a melee focus (Alpha 11), sneak attacks provided another tactical edge (Alpha 12), multiple targets could be hit with a single swing (Alpha 14), and most importantly, melee-specific multiwielding became a thing.

cogmind_multiwielding_melee_parts

Attaching multiple melee weapons at once (Alpha 14). Players designate a primary weapon, and other weapons might contribute to attacks.

Additional damage types were also created (secret, so I won’t mention them here), and some of the existing types were given new effects:

Thermal weapons were given a dedicated heat transfer stat, rather than being a simple side effect of damage (Alpha 12). By decoupling the two, heat transfer could become a goal of its own, either to cause meltdowns or for its other negative modifiers. Before that the thermal weapon design space was quite limited because heat transfer always had to play a secondary role to damage, and a weapon with better damage would also be better at transferring heat, so it could only make good weapons even better rather than serving as a point of differentiation.

cogind_overheating_robot_highlight

Overheating a robot with lasers.

Electromagnetic weapons were given a “spectrum” (Alpha 4). Their attacks sometimes causing chain reactions in robot power sources made the EM tactics game somewhat more interesting, especially earlier in a run where it happens more often (due to the types of weapons).

cogmind_power_source_EM_spectrum_chain_reaction

Triggering a chain reaction in Grunt’s power source via EM Shotguns’ spectrum.

Impact weapons were always something to be avoided, in both senses :P. Essentially they were quite dangerous in enemy hands since they could smash your processors and weaker parts, but useless to the player who would rather outright destroy targets than cripple them. Once given the ability to inflict significant system corruption by smashing parts (Alpha 14) they became pretty decent.

cogind_impact_damage_corruption_effect

Corrupting bots with a Shock Maul.

Once the main game was completed earlier this year, it became easier to explore extra features that might work out, rather than focusing mostly on what absolutely had to be done at each phase of progress.

One result of this experimentation was “visible sound effects.” For a while I’d been thinking of closed-captioning sound effects for accessibility reasons, but simply showing color-coded sound effects would already be a big step in that direction, and far easier to implement. Plus it’s a tactically interesting new way for everyone to view the map, rather than just those who might benefit from captioning. It’s worked out pretty well!

cogmind_visible_sfx_combat

Visible sound effects for combat occurring nearby but out of view (Beta 1).

I also came up with an optional way for players who really want every single combat detail to get that rundown on the map rather than squished into a small secondary log not really made for that much info.

cogmind_map_combat_log_mirroring

On-map detailed combat log (shown here closer to the action than it really is) (Beta 1.2).

But the miscellaneous features I’m most interested in exploring, beyond the design doc, beyond even strict balance considerations, are unique parts with either excellent stats or sometimes completely new mechanics. Content like this won’t have to take into account balance in the same way as previous developments, because these parts are not at all guaranteed (unlike pretty much everything else in the world--an intentional design decision enabling players to somewhat plan their build/strategy ahead of time). I’ve relied on this principle in a few places in the world already, but prior to Beta it was more important to keep the core game balanced for proper testing. So there’s still a lot more that can be done here, and it should make Cogmind even more fun--after all, there’s nothing wrong with getting to feel OP for a while if it’s not something you can do every time!

Imagine…

Now, obviously a massive collection of features were planned from the beginning, but not nearly everything we have now! Technically none of the features discussed above would’ve happened had I strictly gone by the docs and worked straight through Alpha to 1.0. Imagine how different Cogmind would be without garrisons, trojans, imprinting, automated UI features… and all that other stuff!

The point is, design docs are really important, especially in clarifying the vision for the experience and setting down basic principles to build a world based on that vision, but in the best of cases it can also be treated as a flexible framework on which the development process can expand. Pre-Alpha and Alpha finished the design doc over four years and even let a lot of other features leak in at the same time, while with Beta it’s clear sailing with more ideas to explore on the horizon :D

Posted in Design | Tagged , , , , | 5 Responses

Cogmind Alpha Year 2 Sales Data (Pre-Steam)

Cogmind recently made it through a second whole year of its pre-Steam early access program, and as this period comes to an end I’d like to take the opportunity to, like the first year, share some data and pretty graphs :)

This is an interesting milestone because it more or less coincides with the completion of Cogmind’s primary content, represented by the Beta release just last month, meaning it took around two years of work to bring the game from Alpha 1 to Beta 1. And it’s still amazing that support has been sufficient to maintain full-time development for this long--Cogmind’s lifetime revenue passed the $100k mark in April :D. So a big thanks to everyone who has helped it reach this stage!

cogmind_fireworks_story_complete

@’s celebrate the Beta :)

For a more general summary of late-alpha progress you can check out the data in my 2016 annual review, whereas this article will instead be mostly looking at revenue and pricing. And while the first year of sales data was neat simply because it was seemingly the first time anyone in this genre has provided so much open data, the second year is much more interesting due to tier and pricing changes.

Revenue

Let’s jump right in: Cogmind made US$ 40,325 in its second year. Looking purely at the numbers, that’s only two-thirds of what it made the year before, but it’s important to note that a $25k chunk of year 1 revenue was earned in the first month of alpha alone, the result of pent up interest from two years of open pre-alpha development prior to that. In that light, the second year has technically been a little better than the first in terms of revenue, an 8% increase from $37k to $40k.

cogmind_revenue_year_2

Cogmind Year 2 daily gross revenue, annotated (Year 1 graph here). (Click on any image in this article to see at full size.)

Year 2 started with a minimum price drop, from $30 to $24.99 (albeit by adding a new lower tier without any perks, and keeping the old price as an option). This naturally sparked a good number of sales in the short term, which eventually died off as player growth returned to normal once those who’d been waiting for that to happen got their hands on it. At this point the price change didn’t seem to have any long-term impact, but we’ll get to data on that later.

The next noticeable bump coincides with the Roguelike Celebration, an awesome event at which I gave a talk and news about Cogmind subsequently made the rounds. The effects of that alone lasted for a good couple weeks.

Then the obvious spike is obvious :P. RPS has been following Cogmind since pre-alpha and I hadn’t expected to see anything more until after alpha, but it was a nice surprise to have a sudden article about my work arrive the following month.

Starting mid-November, buyers in the EU could finally get Cogmind “VAT-free,” which basically boils down to a loss for me though it’s technically the industry norm to include VAT in the list price. Considering I was still losing money throughout development it took me a year and a half to reach a point where I was willing to eat a 20% cut in revenue from those regions. Since I made that change, between November 15 and June 6th $5,085 of actual revenue received originated from EU countries, meaning $1,271 went to extra taxes (a low estimate). That’s all money I could’ve kept for development if Cogmind was available before 2015 when the EU introduced VAT for online purchases!

For New Year’s day I made an ASCII fireworks gif (actually the first iteration of the one shown at the top of this post) and that garnered some attention, which pretty much always translates to more sales. That’s not why I made it--it was just a fun side project to see if it was possible with the engine, but it’s nice that it had that side effect :)

Valve pre-announced the end of Greenlight in February, and since I 1) wasn’t sure whether I’d like what would replace it, 2) know that having a little Greenlight campaign is itself at least worth some exposure, and 3) already had all the required media on my own website anyway, I decided to put Cogmind up for voting. There was literally only two days between the time of this decision and hitting Publish :P. It was greenlit not long afterward, but that wasn’t really the point--notice that nice little spike in the graph… it’s nice to have some free exposure from Steam when people who’d rather not wait can already buy from my site! Putting Cogmind on Greenlight clearly contributed an instant $750 or so to revenue :D

In April I again lowered the price, to its current and final base price and the level at which I’ve always planned to sell Cogmind once the main game reached completion. In that sense the price change came a little earlier than expected, since the Beta release wasn’t to happen until early the following month, but sales had been flagging over the previous six weeks and I couldn’t let revenue fall too much since I’m relying on it to get by before bringing a mostly complete Cogmind to Steam. (Other reasons: It was also a good excuse/opportunity to do a little advertising that didn’t overlap with the upcoming Beta release, and I also wanted a longer buffer between the price change and Cogmind’s upcoming Steam debut.) I actually silently lowered the price a week before even announcing the change, just to see what kind of impact it would have on random visitors. It seems to have been beneficial, though one week is too short a period and there are too many other factors at play to really draw any conclusions. (I’ll share more data below to shed light on conversion rates.)

The most recent mini-surge surrounded the Beta release, a pretty big milestone considering it allowed me to declare Cogmind essentially complete by multiple metrics. A number of people were waiting to hear that, and the price had already been lowered the previous month, factors that combined to generate a decent amount of revenue for May.

Another factor that I find valuable in examining daily revenue graphs, but that you might not immediately notice above, are “zero days.” Any day during which there are no sales at all is a zero day, and too many of these, especially in a row, can honestly start to get demotivating. On the other hand, ongoing streaks of anything-but-zero days are quite motivational--even if just one or two sales. I always keep an eye on that sales number (it’s easy to follow because I receive an email for every purchase, and I don’t look at them but each one increments a label-based counter in my inbox :P), and if I start to see zeroes it means I’m not quite doing enough outward-facing development, like sharing my progress across social media. I always work harder when there are continued sales every day, so getting into a routine of posting updates is a nice long-term self-reinforcing cycle--especially when I wake up in the morning and get to see how many there were overnight! That’s been a ritual wake-up habit for the past two years now…

gridsagegames_email_inbox_order_counter

The all-important Order counter :P

Throughout Year 2 I made a more concerted effort to ensure there was always something to show at least once every week, and I believe this is reflected in the relative number of zero days: Year 1 was 9.8% (36) zero days, compared to 4.9% (18) in Year 2. In fact, the improvement is technically even better than that: notice a third of Year 2′s zero days occurred close together over summer 2016--that was during my one-month vacation. No work, no pay xD

cogmind_revenue_year_2_zero_days

Cogmind Year 2 revenue zero days.

Looking at revenue on a monthly basis, there’s been a clear positive trend over the past year. (May passed $3k with its Beta release, though isn’t shown here as it technically extends into the third year.)

cogmind_revenue_year_2_and_1_by_month

Cogmind monthly gross revenue, annotated.

I’ve labeled a few of the larger effects already discussed earlier, though I can find no reasonable explanation for March. The graph includes Year 1 for comparison, though I didn’t annotate those months--that stuff was covered with the first year’s data.

cogmind_revenue_year_2_by_country

Cogmind Year 2 monthly gross revenue by country.

By country the revenue data doesn’t hold many surprises. Comparing to Year 1′s country revenue graph, the only notable difference is that Germany overtook Australia, somewhat interesting because as an English-only game Cogmind is assumed to mostly sell in native English countries. Of course, Germany does have plenty of English speakers as well as three times the population of Australia, and (perhaps more key here) more than one German LP’er picked up Cogmind over the past year. (Plus there was the mentioned VAT change in November!)

That graph would be far more interesting if there were localization, but at least this gives you an idea of what an English-only fairly text-heavy game can achieve in an international sense. Localization is a great idea for any game that can manage it, but sadly it’s simply not possible with Cogmind.

Pricing

But we do have some extra interesting data to analyze for Cogmind’s second year of sales, now that we’ve been through multiple tier and pricing adjustments!

At the beginning of the year I wrote a lot about Cogmind’s first price change in 2016, including some common and not-so-common variables factored into my pricing decisions. Here I’ll add to that discussion with some final results of that change and the most recent third phase.

As a reminder, Cogmind’s base price was $30 for the first 12 months, $24.99 for the 11 months following that, then $19.88 for the last month of the second year (and on through today). In the context of daily revenue above I already talked about some of the more immediate effects of those price changes, but the bigger picture holds a few more details. One element I finally have enough data to explore is Cogmind’s conversion rate.

cogmind_alpha_visitor_conversion_rate_price_tiers_buyhtml

Cogmind lifetime conversion rate (2015.5 ~ 2017.5) based on buy.html visitors.

I wouldn’t read too much into that graph because there are a lot of factors at play here, so many that this data is not quite as meaningful as it appears, but it’s fun so I wanted to talk about it anyway :P

First of all, notice that it’s specifically the buy page! Unlike most other indie developers, I don’t put a buy link on Cogmind’s main web page. In fact, I also don’t even put it front and center at the top of the buy page itself! I prefer to 1) avoid generating impulse buys and 2) manage potential player expectations. Thus I intentionally force visitors to wade through other stuff before finding a link to actually buy the game :). Yes, it’s counterproductive from a marketing standpoint, but I don’t care, I’m here to build a good game and foster a healthy community, not rake dollars from random people on the internet.

Thus this source data definitely skews the conversion rate higher, because anyone arriving on that page already has a somewhat higher interest in purchasing than the average visitor. (Note that based on general industry data, those rates are high.) For comparison I did the same with /cogmind/index.html.

cogmind_alpha_visitor_conversion_rate_price_tiers_indexhtml

Cogmind lifetime conversion rate (2015.5 ~ 2017.5) based on index.html visitors.

Part of the problem with sourcing stats from main page hits is that they’re filled with referral spam which can’t always be completely distinguished from real visits (which, like incessant referral spam, may simply leave without visiting other pages :P). This is why using the buy page provides nicer metrics, because it doesn’t get referral spam--we just have to remember all the additional factors that feed into the buy.html stats.

Getting back to those factors, Cogmind’s exposure comes primarily via roguelike-focused channels, so new visitors coming to the buy page are already going to be of a rogueliking disposition and even more likely to buy :)

Also specific to the fact that I prefer basing data on the buy page, there are a lot of people who have followed development for a long time, even years, who eventually make the decision to buy when it’s right for them, whether due to a lower price, the right timing, or a combination of other personal factors. I believe there’s a fairly steady stream of people who fall under this category, and they’ll naturally just go to the buy page and… buy. This is often after having mostly obtained information about the game through one of the other channels I frequently use,  like Twitter, r/Cogmind, the forums, the dev blog, TIGS, Bay 12, Facebook, etc…

Regarding what appears to be an upward trend in the conversion rate, while it makes some sense when paired with the fact that the price comes down for each period, I think that trend is much less meaningful on breaking down the average number of daily visitors and thinking about where those numbers are coming from. For example in its first year of release Cogmind had the greatest exposure on a number of major websites, so naturally visitors from those sites were less likely to be among the target audience. That was the highest average at 71.8 visitors per day. The second period, during which there was much less general exposure, saw a significantly lower 47.5 visitors/day. And the most recent period with the lowest price, albeit shorter, recorded only 43.5 visitors/day, yet had the highest conversion rate.

Of course, knowing this doesn’t negate the fact that Cogmind’s website and my frequent (if minimal) outreach efforts are fairly effective at selling the game to those who are interested. And on the reverse side, supporting the likelihood of an improving conversion rate, obviously during each consecutive period Cogmind was closer and closer to completion with a longer and longer history of steady releases. That helps convince anyone just discovering the game that it’s both a substantial and promising project.

One of the buyer behaviors I’ve really been looking forward to quantifying is the percentage of those opting to pay more than the minimum price, and how that changed along with the tier adjustments.

cogmind_alpha_buyers_opting_to_pay_more

Percent of Cogmind buyers opting to pay more. (This data just looks at the two lowest tiers for a given period, since the higher tiers are more complicated and aimed at group buys. The Prime tier and each respective basic tier are more directly comparable.)

After Cogmind’s first year, during which $30 (“Prime Tier”) was the lowest price, I added a new perk-less Alpha Tier for $24.99. For the next 11 months, buyers could decide whether they just wanted the game, or if they could afford and would like to contribute a little extra in return for having their name in the credits. Surprisingly 13.8% of individual buyers still chose the Prime tier!

Part of the equation here would be the relatively low difference in price, percentage-wise. Only 20% more for some extra perks and to support a project they like? Why not? Compare to the rate after the price was lowered to $19.88, which means a 50% (!) increase for Prime, and the ratio of buyers choosing that option was basically halved. Many of the long-time fans interested in paying more to back the project will have already done so anyway. (Though also note that data for the latter period was only collected for about a month, because the Prime tier was removed as of the Beta release. That said, I don’t suspect we’d see much of a difference if I continued to sell that tier--it was removed primarily because development was entering a new phase, and keeping the “early supporters” tier active for much longer didn’t seem right.)

In the end I’m very glad I chose to handle tiers and pricing the way I did, because otherwise Cogmind wouldn’t have gotten nearly as much pre-Steam development as it has! Lowering to $19.88 sooner also probably would’ve been a bad move based on what I’m seeing now, since over the long term there’s been no noticeable increase in the raw number of buyers. Anything in the $19-$30 range really falls into the “too expensive” category for a lot of people, even more so if it’s not on Steam where the convenience of purchases can take some of the edge off a price, or where there’s more likely to be some sort of discount to provide additional impetus. (I’m still not working at getting more exposure to make up for the loss in revenue per player--it’s just the same old social media channels--but that’s why I chose April/May to do this, around when it’s time to transition to Steam.)

However, I certainly wouldn’t claim that sticking with $24.99 would continue to generate a proportionally higher revenue. Conversion rates would likely drop if the price remained unchanged. Each time I’ve reduced the price over the past two years, I was already feeling that sales were starting to flag and would likely continue to do so if I didn’t take action. Even if that may not have come to pass, I also knew that there was already pent up interest in a lower price, and it was about time to lower the gates a bit further and let more fresh players in.

Investment

So where does this funding go? Well, as a solo dev with relatively low asset costs, much of it naturally goes to pay my meager salary, and my job is to both create and sell Cogmind :)

As always I’ve been maintaining my detailed records of development time, which show that compared to 3,065 hours of pre-alpha development and 2,177 hours for the first year of alpha, Year 2 continued at a stable 2,192 hours of work. These numbers aren’t too pretty, because it shows that this is a lot of work for the amount of revenue coming in--certainly not worth it in an economic sense, but that’s okay for now as long as it’s been sustainable.

cogmind_time_input_by_category_through_april_2017

Cogmind development time, July 2013 ~ April 2017 (excludes 2012 7DRL work).

There’s always more coding to do along with any new features, so that has of course continued its long-term upward drive, and community-related efforts are finally starting to catch up to it as I spend a little more time on promotional stuff as the core game approached completion. Content-focused development accelerated significantly over the past year, which is what ate into coding time.

Comparing only the major development categories of Year 1 and Year 2 more directly, the shift from code to content is clear, while other areas stayed more or less constant.

cogmind_time_input_by_major_category_alpha_only

Cogmind Alpha development time breakdown by major categories.

Because “what’s a good percentage of time to spend on outward-facing efforts?” is a common question among newer gamedevs, let’s also look at the major category breakdown for the project as a whole so far.

cogmind_time_input_by_major_category

Percentage of Cogmind development time invested in each major area, July 2013 ~ April 2017 (excludes 2012 7DRL work).

So altogether it’s 66.7% game stuff vs. 33.3% community/marketing. This is really a bare minimum, which I can get away with because the traditional roguelike community is pretty tight knit with a small number of key places to stay in touch with players, making that part of the job easier. Other experienced devs will say literally half or more of your effort needs to be some kind work that helps get your game noticed (or in my opinion just as valuable: serves as time spent interacting with the existing player base).

I have much more behind-the-scenes dev stats and dedicated analysis to share once Cogmind is complete, though wanted to share a little of it in this article to give the revenue more context. (There’s also a month-wise breakdown of development hours in the latest annual review.)

Aside from dev time there have been a number of other expenses, but they account for less than 6% of the total budget (which doesn’t really have room for anything more xD). Music is something I’ve been thinking about, but how much money can be budgeted there is still an unknown for something that may not be entirely necessary and for which there are multiple valid approaches at different cost levels.

Cogmind still hasn’t broken even, but the hope is that it will as soon as it’s launched on Steam.

Next Step

It’s been a good two-year run of alpha releases (see history), and the ability to extend pre-Steam EA development has been wonderful for fleshing out the original vision--some of the stuff I’ve been adding, even entire maps, was totally not planned from the beginning! And as a result of sufficient support despite the previously higher prices, the player base could be kept from growing too large and distracting (as mentioned in my pricing article) while still getting constant feedback on new features and mechanics.

Now that the Beta is out and further development is mostly optional fun stuff, it’s time to seek out more exposure and put Cogmind on Steam :D. Performance there will be extremely important for the future of Grid Sage Games… so hopefully it can make a splash.

cogmind_reactor_chain_explosions_destruction

Making a splash.

Posted in Post-Mortem | Tagged , , , | 6 Responses

Cogmind’s Two-Year-Old New Logo

I enjoy sharing lots of information about Cogmind’s development process, and before the first alpha released two years ago, the main spot for followers to stay up to date on progress was this dev blog.

Sharing early dev stuff can in some cases become a problem later when related features, graphics, or some other aspect of a game are no longer representative of the game, but for me it’s never really caused many problems. In fact, it’s kinda interesting to even compare Cogmind’s very first mockup with how it actually looks today.

cogmind_mockup_vs_2017_screenshot

Cogmind 2013 mockup vs. 2017 screenshot. Note the older font, and others, are still available, and have a rather significant impact on the look (!), but honestly neither looks incredibly improved upon the other--even old media more or less represents the game today. One exception would be the addition of tiles, which didn’t exist during early pre-alpha and I use in about half of demo screenshots and GIFs these days.

There is one issue in particular where old info has come back to haunt me, though: The title logo design.

cogmind_logo_12x12

Cogmind’s current logo design, new as of… 2015 :P (12×12 cell version)

Back in 2015 I explained the logo design process, showing here on the blog how I used REXPaint to draw layers which were then animated separately in game. (No, I’m not even going to link it, but I’d also prefer to not edit or remove it outright--I believe it has its historical value.)

Some months after that, not too long before the first public release, I revisited the logo and made changes to its shape. Specifically, the original idea was to make the entire thing as square as possible, but the ‘D’ required a slight adjustment (missing corner) to help distinguish it from an ‘O’. In the end that didn’t look nicely balanced, so both the ‘C’ and ‘D’ got two rounded corners each. (I admit that the current style can still be interpreted as an ‘O’, but at least the whole thing looks better overall…)

But I wasn’t experienced enough at the time to realize that all those PNGs I’d put out there would be enshrined in Google Images to be found by anyone searching for Cogmind’s logo to use elsewhere… So in the time since, many people who’ve gone to create things like cover images for LPs just grab whatever Google Images tells them the logo is (no one bothers with press kits, it would seem, because Cogmind has lots of proper logo downloads in various sizes available there!).

In the end, there are a lot of incorrect logos being used out there. Some are even using the old 7DRL logo, or the non-ASCII logo used during pre-alpha development. It’s basically a mess :P

It’s possible that some logo searchers may want to try to save the header from the web site, and in those cases it’d be my fault that I stubbornly insist on using the GIF there, because it’s cool :)

cogmind_logo_10x10_animated

Cogmind Logo, 10×10 animated version. This was recorded from within the game, which actually animates the logo procedurally rather than itself using a recording, so it’s formed slightly differently each time the game is run :)

While it’s also possible to screenshot its long static frame, some people might not be set up to do that so easily, and from that source it’s only available in one size anyway, whereas logo seekers would like to check for other options as well.

You want more options? I’ve got more options!

cogmind_logo_4x4

Cogmind Logo (size 4) (animated version here)

cogmind_logo_5x5

Cogmind Logo (size 5)

cogmind_logo_6x6

Cogmind Logo (size 6)

cogmind_logo_8x8

Cogmind Logo (size 8)

cogmind_logo_10x10

Cogmind Logo (size 10)

The lesson is, be careful what you put out there, and how you do it :P. At least be aware of what can happen. Some developers are afraid to even put out screenshots or videos of their early progress (which may feature programmer art), lest it become attached to their game forever, though I believe this attitude has been shifting significantly over recent years with the indie boom as more developers share their progress--players are becoming more aware of the dev process and have a better understanding of what WIP means.

That said, I can understand why devs use code names for their projects before a proper release or marketing campaign. On a related note, at the start of pre-alpha I did at least foresee an issue with the old 7DRL stuff interfering with future reception of the game, the older jam version being as inferior as it is, so in 2013 I went and renamed all the original online content as “Cogmind 7DRL” to make the distinction more clear. That much worked out okay.

And yes, this post is a completely unveiled attempt to put more “official” logo images out there :P

Posted in Marketing | Tagged , | 5 Responses

Versioning Schemes

Normally I wouldn’t have another post up so soon, but the topic of versioning has become somewhat time-critical. I’ve been thinking over it quite a few times in recent months, but haven’t been able to make a final decision on where to go from here.

Why now? Well, know that in one sense--one of the more important senses, actually--next week Cogmind will be “done.” All the confirmed maps are in, all the major NPCs exist and are doing their thing, all the endings are in place… The story will be complete.

cogmind_fireworks_story_complete

*fanfare, cheering*

Development will continue, but this is a pretty significant milestone.

That said, there are still certain items left on the TODO list that keep me from calling it a true 1.0. And honestly I’m not ready to handle all the meta work that should come with a 1.0, anyway, mainly on the marketing side which at the very least requires putting together a new trailer and getting in touch with press/LPers. (I still like the two-year-old alpha trailer and am tempted to just update it using new visuals, but even that takes a while.)

So what to do about version numbers in the meantime?

cogmind_hacking_brute_force_static

Searching for version numbers in the matrix.

We could at least wait until the Steam EA release (as a different kind of milestone) before switching to a new system. However, rather than basing it on an external factor like that it’d be nice to keep the system a little more relevant to the current state of development, and we’re definitely switching some gears here (more on that later).

Greek

I wouldn’t say continuing along with “Alpha #” releases is off the table, making next week’s release Alpha 15 as expected. Plenty of games do Alpha 1-2-3 their way to 1.0, and I admit I’m fond of the Alpha system, if only because I’ve been using it for a good while. But there are a few reasons for which, if possible, I’d like to find a satisfactory alternative.

Another vote for switching away from the alpha designation is that for most people it implies a game is in a very unfinished state, probably even buggy or unenjoyable, neither of which would describe Cogmind even years ago. While it’s true I’ve wanted people on the outside to believe that for the past couple years of alpha so that I could reduce the number of buyers and instead focus on development (not unlike my approach to pricing), I’m now more willing to allow the terminology, and first impressions, to start inching into new territory :)

For a short while I was thinking of using “Beta,” as it naturally follows Alpha, but that’s technically more of a “this software is feature-complete though still subject to pre-1.0 tweaks and fixes” sort of state. If we wanted to judge Cogmind’s development in those software terms, it’s clearly still in alpha and will be for a while, since I plan to do lots more with it! Even major new features…

Hey, maybe we could do something off the wall and go with “Gamma” releases? Haha, okay that might cause some confusion.

R for Release

Some games and libraries simply increment an integer with each release: R1, R2, R3… Pretty straightforward. I like it. I’ve also used it before, for X@COM. Minor patches can just add a decimal or letter, e.g. R5.1 or R5a.

If I went this way, another thought is to skip straight to the actual release number, so “R15,” just to keep the sequence going rather than starting over, though an “R1″ is a pretty meaningful statement for that one release in its own way. A true new beginning rather than more of the same.

cogmind_fake_version_number

Maybe one day!

“RC#” is another option, though not too often used with games (?). Designating a Release Candidate is more akin to beta, or the final versions of beta software, not to refer to something that will continue receiving large feature updates for the foreseeable future. But then you have games like Starsector, which has been using an RC numbering system alongside their decimal-numbered releases for many years now :P

Decimals

Speaking of decimal systems, they’re definitely the most ubiquitous. But I don’t really like the idea of purely sticking with a bunch of numbers. (Just this week I posted about how and why I’ve circumvented numbers where seeds are concerned :P)

Numbers aren’t as easy to remember, and more importantly any sub-1.0 version numbers might be assumed to reflect the amount of development remaining until completion (e.g. 0.5 is half finished), even if they’re not intended that way. Given that there’s a huge number of possible future features, and I can’t say exactly which will make it in, it’s tough for me to nail down where a given release stands in terms of numbers.

Trivia: Technically Cogmind does have decimal version numbers, but they’re all simply 0.10 (a common “this is an early build lots more to do!” number) followed by the date, e.g. 0.10.170509. These are just for my reference, because I find it really useful to have the date in the “version” itself.

One way devs work around the boring number version issue is to give releases unique names. I did this for X@COM, for example “Sheer Terror” when adding terror missions, “Sound Like a Hero” when I added sfx, “Chryssalids in my Backyward” for… the chryssalid update :o. They’re a fun and easy way to remember, more interesting to read, and useful for setting the theme of a release.

xcomrl_blaster_bombs_in_town

Revenge with Blaster Bombs in an X@COM town. Damn that game’s a blast and I want to work on it…

I’ve thought of naming Cogmind releases for a long time, even retroactively naming older ones for consistency, but never went ahead with the plan.

Actually, I have sort of named each Cogmind release, if only in one place: IndieDB. For release announcement posts there I always name the release rather than reporting it as a number like elsewhere, just to give the post title a less boring look since it appears listed with other games, and also to give a hint of what the release includes. The next release is already dubbed “The End,” Alpha 14 was “Hack ‘n Slash” (melee multi-wielding), Alpha 13 was “Rise of Zion” (new plot thread), Alpha 12 was “The Place No One Lives to Tell About” (boss map), etc. While we’re at it, do you have any opinions on named releases?

In any case, version names are really just supplementary to another system, as ideally a game’s versioning should reflect some kind of sequence.

Dev Cycle

As far as other considerations go, the decision here depends somewhat on the future release schedule.

In the past it was easy to maintain a 4/5-week release cycle, with a couple weeks of adding a big chunk of content centered around a new map or branch, followed by a week of bigger feature(s) and then some little ones. While I really like that approach, which makes each release pretty substantial (and discussion-worthy!), future updates won’t usually have new maps to be focused around, which themselves lead to lots of other related required content, features, and mechanics.

I’m also looking forward to the pace being a little more flexible and responsive, such as releasing smaller batches of new features every two weeks or so. This change in pace would be another reason to depart from the original alpha designation, if only because sticking to the ongoing “Alpha #” system can distort and dilute the effort and value of the previous releases, each of which took a lot of work to complete.

gridsagegames_release_history_170504

Grid Sage Games release history as of 170504.

I very much enjoy the practice of releasing with meatier changelogs, but then players also appreciate more rapid development, so there’s a good chance I’ll be heading in that direction for a while, at least for much of 2017 (once past the “actually releasing on Steam” hurdle).

Are you done yet?

No, this is cathartic and I might be coming close to a decision :P

Having written all of this out, I’m leaning a lot more strongly towards an R# system, maybe calling it R1, kinda like a fake 1.0.

And beyond that? I guess then we can, okay, eventually declare a release the 1.0, and then I imagine there will be updates even beyond that (I probably won’t be able to stop myself even if I wanted to), so then we could go with numbers since there is no longer some kind of commonly-assumed target after 1.0, which just breeds updates like 1.01, and so on. Alongside it we’ll probably just continue with the R-numbering as well.

Anyway, regardless of what versioning we go with for now, I’ll keep up the same date-appended pure number version (still 0.10!).

So what do you think--have I overthought this enough yet? :P

I… still can’t decide. Because after sleeping on this post I woke up thinking about it from another angle and started to question the whole R-thing, in that unlike a < 1.0 decimal version number, or clearly having an “alpha” right in the version name, using something like “R” doesn’t even hint that the game still has a fair bit of development coming, or that it’s technically “early access.” That information has to be expressed externally to the versioning, which is somewhat annoying. Maybe just let innertia do its thing, call it Alpha 15 and stop thinking about this? Or is it time for something new? Hm.

Maybe Beta? It’s different from Alpha but clearly “not done,” and we can ignore what it really means in terms of software development (most games ignore it…). Hm.

 

Update later same day: For scheduling reasons I had to make a quick decision since it’s Friday and for some reason I really thought it was still Thursday :P. So… Beta it is. Huge feature preview for Cogmind’s Beta milestone is now posted!

Posted in Gamedev | Tagged , , | 10 Responses

Working with Seeds

No, not plant seeds.

As most fans of the genre are aware, a fair portion of a given roguelike run is determined based on values returned by a pseudorandom number generator, commonly referred to as the RNG. Before it can do its job, an RNG must be “seeded,” or given a value that starts the entire chain of values to be returned beyond that point.

Certainly when a roguelike starts up all it has to do is seed the RNG with the current time (the most common practice) and then not worry about it after that--the RNG helps create maps, chooses what populates that map, determines the outcome of actions, and so much more. But it turns out there are many other seed-related considerations and applications when developing games with procedural content.

Important to all this is the understanding that the seed used to initialize the RNG doesn’t have to be random. If manually set to the same number each time, the resulting chain of numbers it spits out will also be the same!

Cogmind’s Seed Structure

For reasons we’ll get to, Cogmind doesn’t just store one seed. There is of course The One Seed, actually called “worldSeed,” which is the single seed from which all others are derived. So in a normal run the world seed is simply based on the current clock time (meaning yes, players who start their run at exactly the same millisecond will technically be getting the same world layout!). And by reusing a specific world seed value in a future run, the exact same world can be generated again and again. Or by simply starting a new run at a different time, the world generated will be completely different.

But if that’s true, then why do we need more than one seed? The answer in two parts: 1) individual maps are not generated until the player reaches them; 2) different players may visit maps in a different order. Therefore at the very beginning of world generation, right after the world seed is determined, it then creates the world layout and within the data for each potential future map it stores the seed to be used to create that map if and when the player arrives there.

cogmind_source_MapLink_seed

Every map has its own mapSeed, generated by the worldSeed (some extraneous comments and code trimmed for clarity).

When the player arrives at a new map, the map generator loads the seed for that map before starting the process. This ensures that everyone visiting that map via the same world seed will also get the same map, regardless of how they reached it.

Development and Debugging

As you can imagine, the ability to force the world to generate in a predictable, repeatable pattern by manually setting the seed is extremely useful for perfecting a map generator like the ones I’ve talked about before.

My first use of seeds in Cogmind would have to be during early pre-alpha development, where much of the focus was on map generation. Being able to seed the generator to recreate the same map again and again when working out problems with the underlying algorithms saved a ridiculous amount of time compared to just waiting for specific problems to pop up. So I could keep skipping through procedural maps until finding an issue, check whatever seed led to it, force the generator to use that seed, then step through the process to find out what went wrong (or could be improved). It’s really easy to track down isolated issues by simply putting a breakpoint in the debugger for a specific coordinate in question, and examine what’s up with it.

cogmind_map_generation_storage

I spent a lot of my time looking at maps like this, waiting for a “bad seed” to investigate.

After releasing the alpha, bugs either reported by players or that I discover myself are sometimes related to the initial state of a map, and in cases like that it’s ridiculously useful to be able to just load up whatever seed produced that map and take a closer look. Being able to reliably repeat a bug is the first, and biggest, step to actually resolving it! The alternatives are not too pretty--if unable to guess the cause from a simple report, having to wait for it to appear again to get more details is an annoying drawn out process, not to mention much more difficult to do remotely.

cogmind_random_seed_locations

A run’s seed is output to run.log while the game is running, as well as added to the final score sheet.

Preserving Consistency

It turns out there are all sorts of places where a seed can go wrong :P

Ideally a world and its maps and all the little details within those maps originating from a single seed should be the same for each player using it, so there are important game-specific considerations aimed at preventing “divergence.”

A simple example would be scrap piles in the caves, which are kind of like treasure chests that drop loot. If I didn’t care about proper seed support my normal approach would be to simply generate the loot on the fly when the player steps on the pile, but each player will have taken different actions before that point, meaning the RNG will give each of them different items! For consistency, all players using the same seed should have access to the same “random” loot. Of course the brute force method would be to pre-generate and store all the loot when the map is first created, but this is wasteful in terms of both time and memory. Instead each pile just stores its own unique “loot seed,” and when necessary that seed is used to seed an RNG which generates the loot on the fly. That way it comes out the same for everyone on the same map. (It also means that attempting to save scum to get different loot won’t work :P)

cogmind_searching_scrap

Determining loot from scrap at the point of interaction.

An example of a system that required a more involved solution to ensure consistent game worlds is the unique encounter handling. While some encounters in Cogmind are generic and might occur more than once, many are unique and should at most happen only once per run. (It would be weird to meet the same named NPC and specific encounter more than once in the same run :P) But because maps aren’t generated until the player reaches them, there’s no way to know which map might use a certain unique (or otherwise limited-count!) encounter. A given encounter may be allowed to appear on any number of maps, but what if player 1 visits map A first and gets that encounter, while player 2 instead visits map B first and gets that same encounter. Their maps will generate differently! And they’ll have even more divergent experiences if they then visit their respective “other map.”

To address that, all unique or limited encounters are randomly assigned a valid map when the world layout is first generated, and they will be chosen from among the pool of encounters available for their map, which may or may not use them--it can’t be sure because there may be other conditions required for that encounter to actually appear (conditions that cannot be confirmed until the map itself is created), but at least it’s known that said encounters cannot appear on other maps and cause divergent runs from the same seed!

Seed-based map generation also requires explicitly separating out a number of components that factor into the initial state of a map, where those components are derived from player actions. Actions like bringing allies from one map to another, or plot-related content through which the player can affect future events, all need to be taken into consideration to prevent prior actions from affecting the base map, which should remain as consistent as possible aside from purely what the player influences. For this reason I’m careful to exclude anything player-specific from the map generation process until the very end.

cogmind_source_mapgen_player_specific_changes

Cogmind mapgen source transition from the underlying map to player-specific adjustments.

Other changes to the usual behavior are necessary when players manually seed their own run. This is to make sure that the handful of automated player-specific meta features are deactivated. These are features aimed at newer players, such as the tutorial map, which normally replaces the first map for a player’s first three games. Another example is an encounter inserted only the first time a player enters a Waste map, wherein a Derelict says a little dialogue before running ahead and getting brutally crushed so the player immediately realizes that’s not something they want to do :P

cogmind_waste_entrance_warning

Bad things are about to happen.

Seed Formats

Seeds don’t have to be numbers! Well, they are internally, but developers shouldn’t place dev restrictions on players where unnecessary. It’s time for more “ergonomic” seeds :)

Number-based seeds are boring, and not as easy to remember or share, so early on I made sure to allow any alphanumeric strings to count as valid seed input. Players can, for example, try out using their name as a seed, or some other interesting words or phrases. I’ve even had one player go through multiple runs, changing the seed to a new phrase each time, which when read together formed a longer message and appeared in the upload stats :P

Of course, internally these string-based seeds are no different from numbers. Each character is converted to its decimal value, all of which are multiplied against one another to create a final number the RNG can use as a seed.

So manual seeds have always allowed strings, but random seeds (i.e. the majority of seeds players are using by default) have still been represented by numbers. More recently I decided that I wanted to take this a step further and have even random seeds be expressed in words, but how would they be determined?

The solution was inspired by gfycat, which instead of generating a string of random characters for their URLs uses an AdjectiveAdjectiveAnimal format (see the end of their about page). My first thought was to go with lists of Cogmind-relevant words that I’d draw up myself, but that looked like it would be quite a lot of work--there had to be a quicker solution. And there is!

Cogmind already has a bunch of relevant adjectives and nouns in the game data itself, so why not just use those? Specifically, most items are named in a predictable Adjective + Noun format, and those words can be extracted for use in mixing and matching. Cogmind has nearly a thousand items, and the number of permutations if we pick three sub-words in a row gives plenty of variety. AdjectiveAdjectiveNoun it is :D

To create a seed, the entire list of existing item names is parsed according to various rules, creating a separate word pool for adjectives and nouns. Nouns are generally assumed to be the last word in an item name, and all the others are treated as adjectives. Other filters to keep some of the weirder items from creating seeds with odd formatting:

  • Word must contain at least three characters
  • First two characters must be different from one another
  • No words including punctuation or digits
  • Word cannot be entirely upper case

And finally no duplicate words are added to the pool (which would weight them higher). In the end we get random seeds like this:

cogmind_random_seeds_shortlist

Randomized “fake item names” as seeds--much better than something like “1477302648″! (see a longer list of samples here)

These fake item names are a heck of a lot more fun than numbers, and there’s the added bonus of seeing words in there that you may not recognize, as a kind of teaser for other items that are actually out there somewhere. As mentioned before, the random seed used to create a run appears in the score sheet, and each is also listed alongside its run in the composite score history.

cogmind_random_seed_score_history

Scorehistory.txt, with fake item seeds.

Miscellaneous Applications

We’re not done yet! Seeds have a surprising number of applications, so let’s check out some more of them…

Community

Roguelikes are single-player games, but there are plenty of features with community-building potential. One of those is so-called “weekly seeds,” where a single seed is played through by multiple people who can then share their experiences, or compete with one another for the best score, knowing that they are at least playing with the same fundamental circumstances.

Cogmind has had… semi-weekly seeds for the past couple years. Although not as popular as they were in the early days (when lots of the regular players were on the forums instead of chat :P), I’m sure they’ll pick up again when the player base expands again this year. Some roguelikes such as Caves of Qud even have the weekly seeds built into the game itself (with separate leaderboards!), something I haven’t done yet but probably should at some point.

Replays

One thing I’ve always wished I could to do is enable full replays of a run, which is most easily accomplished by combining a seed with the player’s recorded input. But a couple of architecture road blocks have made that all but impossible :/. Cogmind’s animation system is mixed in with the game logic, so features like adjusting the speed of animations (or canceling them altogether) are not possible. For replays to work there’s also a need to use different RNGs for the game logic and any rendering-related functionality, which is something I didn’t do. Essentially, this kind of feature should be built in from the beginning to make sure it works, rather than trying to tack it onto a sprawling 120,000-line code base :P

Obviously replays also add a lot of value with respect to learning and community-building. At least we always have streams and LPs, in any case.

Regarding that replay technique, it can even be used to implement saving. Instead of actually saving the entire state of the game, save all of the player’s input from the beginning. Then when it’s time to load, seed the RNG using the same value, followed by all the same input to get the same final result! I’ve heard that Brogue saves work this way, although “replays” are such a complicated thing that I’ve also heard Brogue’s saves are prone to breaking in some cases, which prevents loading that saved game :/. Still, a very cool system overall!

Saving Large Worlds

Another type of seed-based saving is useful for large open-world games, in which storing the entirety of the game state isn’t feasible (too much space!), nor is keeping every visited location in memory. Instead the world is divided into chunks, each with its own seed (essentially how Cogmind’s map-specific seeds work), and a chunk is only generated when the player nears it. Storing that area on traveling elsewhere, or saving the game, is simply a matter of storing its seed along with whatever changes occurred between its generation and the time it’s stored. So even games with destructible terrain and other player- or NPC-induced changes can take advantage of this kind of “delta map” system to keep system requirements within reason, despite having nearly infinite space to explore. (Literal space exploration games can use this same method. One such example was Infiniverse, but sadly its site and some relevant technical articles are no longer available…)

Seed Catalog

One of the more unique seed applications I’ve seen is the Brogue “seed catalog,” which comes with the game and contains a list of every item found on each of the first five floors for the first thousand seeds.

brogue_seed_catalog_excerpt

Excerpt from Brogue’s seed catalog.

Basically it’s a meta-approach for adjusting the difficulty, or perhaps to look for a seed more suitable for a desired play style (since early-game items in that roguelike can have a significant impact on long-term strategy).

Have you heard of any other uses for seeds? I’m sure there have to be more out there…

Posted in Gamedev | Tagged , , , | 2 Responses