Official development blog

Debugging Mapgen Seed Divergence

I rather enjoy debugging. It’s just another type of puzzle, one of the many challenges of gamedev approached with logic and the tools at hand. It should be noted I actually don’t much like debugging if it involves a bunch of code I didn’t write, but this is why I almost entirely use my own tech, stuff that I built, am familiar with and… capable of understanding :P

Most bugs die a swift death in Cogmind, since it’s built using a pretty simple architecture and literally the first thing I put together for the framework was its error detection and reporting system, always taking into account what could go wrong whenever anything new is added.

But one nightmare bug in particular has been in there for a very long time…

Background

“Seeding” a game’s RNG allows it to produce the same numbers in the same sequence, and is therefore a useful feature in roguelikes, especially where map generation is concerned. I’ve already written an article on seeds and how they work in Cogmind, along with their many applications, so I won’t go into all that again.

This time I’m here to talk about a specific seed-related issue that popped up and how it was uncovered and resolved.

Nightmare

Around early 2017 occasional reports of seeded runs not always generating the same maps in some cases started popping up. Now obviously this isn’t right, because the same seed should always produce the same map, so clearly some player action before that point had managed to affect the generation, causing the seeded content to “diverge.”

cogmind_mapgen_phases_major

Major mapgen phases in Cogmind.

Map generation can be divided into three main phases: layout, content, and player-affected content. It’s important to separate out all the latter stuff (C) so that it doesn’t affect the base map that everyone using the same seed should share (A/B), so I’m generally careful to do that, but obviously something had slipped in somewhere…

I say this bug was a “nightmare,” though honestly the effect on players was minimal since it rarely came into play and wasn’t a show-stopper or anything like that, it was a nightmare for me because I couldn’t easily track down something like this!

Nonetheless, this is a vital sort of bug to fix because not only are fully reliably consistent seeds important for built-in weekly seeds or other similar events (which are still something I’d like to do), but this bug had also already affected me several times before in other bug-solving efforts. Often times the quickest way to reproduce a bug in order to properly resolve it is to be able to generate a map using the same seed it was created from, especially when I get a random remote crash report which is nothing more than a stack trace and log containing the seed. More than once over the past couple years I couldn’t take that easiest route, or even recreate certain bugs at all since the seed results may not match what the player encountered!

So you can see why it was pretty important to fix this, and when kiedra suddenly brought it up and later offered relevant save files, I was happy to jump on it immediately, brushing aside my previously scheduled work for the day. (It’s best to do this sort of thing when the events are freshest in the player’s mind, in case I had any other questions.)

Data

kiedra provided exactly what I needed, two save files, each from separate runs, both from the map before the one in which the divergence was observed. The fact that Beta 6 added multiple interval autosaves to Cogmind made collecting these saves (and others needed for debugging) much easier, but solving this issue in particular still required that someone be playing actual seeded runs, and observing the differences, and be both able to save this data and willing to share it with me. Whew, finally got an, uh, convergence of all these variables ;)

Here are two screenshot excerpts demonstrating divergence on the same section of map:

cogmind_seed_divergence_comparison

Seed divergence demo. You can also see the full size maps here and here, opening them both and flipping between the two to see the total changes. Having added the new map output feature in Beta 7 was great for getting full-sized maps like those :)

You can see how the layout is identical, as are a couple machines and certain locations chosen for item placement, but other machine and item choices are actually different! Gotta find out where the changes started…

Sleuthing

My first guess was that it had something to do with global plot-related values. This is what I’d been thinking all along since I didn’t hear about this issue until much of the story and events were complete. In any case, this was really quick to check since we had two saves, so I loaded up each and just compared the list of globals…

cogmind_global_variable_file_comparison

Files match. D’oh!

That didn’t pan out, so I moved to comparing the values coming out of the RNG at several major points in the mapgen process, since if any value at a given point was different from that same point in the other save, then the divergence must be occurring between that point and the previous non-diverging one. Basically, if there’s a divergence the RNG must be handing out at least one extra number in one save, and that would entirely throw off where all the subsequent numbers are applied, hence different results from that point onward.

Even before that, based on just the screenshots I could pretty much narrow it down to placeRandomObjects(). “Narrow” is an overstatement though, because that’s also the bulk of the map content initialization process :P. Anyway, that’s where the number comparisons would start.

cogmind_seed_divergence_RNG_checks

The first 500 lines of placeRandomObjects(), marking major intervals where the latest RNG output was checked. (I just tested them by setting breakpoints in the debugger and recording the numbers on paper, nothing fancy.)

At the first three points the RNG gave the same number, so we can be pretty confident that the content generated prior to those points was identical between saves. Then comes the fourth check, and we have a winner! The RNG in each save gave a different number there, so they must have diverged somewhere between the last two checks.

Here I got a little ahead of myself and ended up wasting some time because I was excited about finally getting this close and immediately made an assumption based on the general code in that section. I thought it had something to do with how in a few cases later map generation stages were allowed to modify spawning restrictions for object types, different from what was set in the original layout. Problem was, this assumption was not at all based on actual evidence, so the lesson here is to follow the evidence, not your imagination, especially when there’s already a direct route to finding the solution. Oops.

Fortunately I realized my error when I was taking a quick break (it’s good to “get away” from problem solving for a bit, since it might allow for new perspectives, although clearly this was still rolling around in my head while on “break” xD).

I came up with a few ideas for narrowing down the problem space, and while most would solve the problem quickly once implemented, they’d also take a while to build and end up spending more time than they were worth, so I decided to just keep up the straightforward manual search. I did still chop out huge unrelated chunks of the content generation so that the resulting maps would have fewer distractions and be easier to visually analyze, possibly leading to more clues.

To go along with that view, I got a list of every room in the order they were filled, and what type of general content they included:

cogmind_seed_divergence_room_checks

General room comparison.

Getting closer! From the data above, it’s either an issue with Room 14 or 15. Room 15 has a different composition, but since composition is set first, it’s probably an issue with the room before it at (1,67) on the map…

cogmind_seed_divergence_room_comparison

Room 14 we have you now!

To confirm real quick I also visually checked the final output of several rooms listed above 14, and those were identical in both saves.

Seeing as the Terminal looks identical but there are different numbers and types of items, I decided to take a look at the items first. Stepping through the code line by line for that room I recorded a few values under the first save, then went to the second save, only to discover that the very first numbers it started with were already different, so it must’ve been before item placement even started in there!

cogmind_seed_divergence_room_item_loop_comparison

As usual when solving rather involved bugs, I have pages of notes recording the entire process and data along the way, so here we have this :P

Well there wasn’t much before the items… just the Terminal, so I eyed it suspiciously and had an epiphany: it must be something inside the Terminals.

Gotcha!

cogmind_seed_divergence_room_comparison_terminal_hacks

Caught red-handed with different hacking options!

As soon as I saw different hacks I knew the answer (although it becomes extra obvious by looking at the point from which the hacks change), recalling that schematic hacks at Terminals would favor the player by usually re-rolling if the randomly chosen schematic happened to be one they already had.

This kind of gameplay-improving tweak is fine, but it needs to be done in the player-affected content segment of mapgen! Here I’d checked for and applied the changes immediately, forgetting that we’re in the middle of the base content assignment. So if the player happened to already have a schematic which the game attempted to put on any Terminal on the new floor, it would roll again for a new one, advancing the RNG state and bam--everything after that point will be different.

This also explains why the issue tends to appear more often in the late-game (more time to accumulate schematics) and only for some players (those using schematics as part of their play style, and running seeds so they might actually notice it).

For the sake of double confirmation I did check that kiedra had different schematics in each save, four more in the second than the first, and one of them happened to be what was chosen for this Terminal.

Based on this finding I knew there were some other related instances, and fixed all of them at once. The same behavior exists (to varying degrees) with part schematics, robot schematics, lore records, and preloaded Fabricator schematics. Of course the fix is to move all these player-relative content modifications to the final mapgen phase.

The final check was to run the saves under the new code, and compare both those results to a completely fresh debug run using the same seed (which just teleports to that map so nothing at all can interfere with it). Same results across the board :D

And now seeds should be fully reliable once again!

Better Architecture

It’s worth mentioning (mainly to head off the inevitable comments to this effect :P) that there are ways to prevent this kind of thing from happening in the first place. Like if there are clear rules that should be obeyed, as there are here, then be sure to encapsulate all player-relative data and keep it hidden/inaccessible from the mapgen process until it’s allowed.

In any case, this made for an exciting debugging adventure ;)

Posted in Internal | Tagged , , , , , | 2 Responses

How to Make a Roguelike

I’ve always wanted to put together a comprehensive primer on how to make a roguelike, something that could hopefully be inspiring while including both general and specific advice. This year’s Roguelike Celebration seemed like the perfect opportunity to force myself to do that after having put it off for so long, so I gave a 30-minute talk on the subject.

I’ve got a fair bit of experience to draw from, having exclusively worked with the genre for the past seven years (Cogmind, Cogmind 7DRL, POLYBOT-7, REXPaint, X@COM), made it my full-time job for the past five, and over these years also helped build r/RoguelikeDev into the largest community of roguelike developers on the net.

The “How to Make a Roguelike” talk is available in video form below, but this article serves as a text version of that same talk for those who’d prefer a readable format, or to just take a closer look at the many images ;)

Intro

A couple years ago at the first Roguelike Celebration I did a talk about how I became a developer, but this time I wanted to talk about how anyone can go about making their own roguelike. It’s pretty common for roguelike players to at least dabble in development. We’re inspired by the games we play and want to make something better, something different, or just something of our own. My talk definitely isn’t a tutorial, it’s more about how to get started and general advice to help you along the way.

roguecel2018_how_to_make_a_roguelike_title

Making a roguelike can be pretty tough, not unlike journeying through a dungeon full of obstacles. In the diagram below, that’s you at the bottom starting out your journey. At the top is your target: a fun playable game.

mapgen_ready

Ready, set, @!

It’s very easy for your path to end up like this, wildly developing in every which direction as you try to add every system you’re thinking of without a clear overall path:

mapgen_indirect

Indirectly approaching your goal. One day… (This is an animation--open the image separately to see its process from the start.)

Yes you might finish and barely reach your goal, but at what cost? Maybe years of wasted effort and all of your hair :P. On the way it’s more likely you’ll develop yourself into too many difficult corners then get stuck, demoralized, and quit.

What you need to do is make a beeline for your target. With a basic plan and understanding of where to go, you can start with strong fundamentals and then, when you have that fun core game, expand on it all you want!

mapgen_direct

Head straight for the goal first and start with strong fundamentals. (This is an animation--open the image separately to see its process from the start.)

In this article I’ll mostly be covering the fundamentals, how to travel through this dungeon with a greater chance of success, especially when you’re just starting out and full of enthusiasm, but also aren’t sure how to proceed.

General table of contents:

  • Language
  • Scope
  • Core Mechanics
  • 7DRL
  • Resources
  • Hooks
  • Tips

Note that although this is an intro on how to start making a roguelike, it does not include how to stop making that roguelike. You’re on your own there ;)

Language

Let’s start by getting what is always the first and most common question out of the way: What language to use.

The answer is easy: Anything.

The slightly longer answer is that it doesn’t really matter a whole lot. If you already have experience with some language then that’s great, go ahead and use it. Language is a means to an end, and people have used just about every language to create a roguelike before.

Now that’s not to say there aren’t some easier options if you’re just starting out, so if you’re not sure then I’ll help you with a suggestion:

python_libtcod_tutorial_sample

Sample python code from the libtcod tutorial.

Python is often recommended for first-time roguelike developers because it’s pretty simple and straightforward to work with. Just look at that code. There’s not a whole lot of weird syntax, and if you don’t even know programming or python you can probably still figure out most of what’s going on here.

But don’t worry about “simple” being a limiting factor, as you can still do great things with python.

python_roguelike_ultima_ratio_regum

Ultima Ratio Regum is written in python, and it’s a beautiful and massive open world project which isn’t complete but nonetheless already incredibly impressive.

 

python_roguelike_temple_of_torment

Temple of Torment is another expansive and complete fantasy roguelike written in python.

There are literally hundreds of python roguelikes out there. All said you’ll have a smoother ride if you start with python, and we’ll come back to how to get started with it later on.

programming_languages_used_in_roguelikes

A sampling of programming languages used by roguelike developers.

More complex languages like C and C++ are good in that they’ve been popular for ages, meaning you’ll find numerous relevant resources and references out there. C++ is what I use, but that’s only because I was familiar with it to begin with. I wouldn’t recommend it for beginners, especially if your goal is to make a roguelike rather than spend all your time debugging! You’ll find a lot of other devs using python anyway, so you’ll still have access to plenty of resources.

Scope

Another issue that comes up often among new developers is that of building your “dream roguelike.” Should that be your first goal? Almost certainly not!

At first you’ll be learning a lot, making mistakes you don’t even realize yet, so it’s best to build up some experience first. More importantly, the focus of game development really changes from beginning to end, so it’s best to go through the entire process at least once or twice before starting larger serious projects. Keeping your scope small at first is also the best way to ensure you’ll actually have a complete something to show for your efforts.

Taking our dev map from earlier, that main path is what you need to focus on:

mapgen_stages_1

Main development path purely covering a sampling of required features (note that I tend to let “combat” carry a question mark because roguelikes do not necessarily involve combat!).

It can be both a complete game and a stable foundation on which to build more. All those other areas out there to explore are tempting, but try not to get drawn too far away from the main path early on. It’s like playing a roguelike: If you start by blindly running around in the unknown doing only what you feel like doing rather than what you probably should be doing, unless the RNG is totally on your side you’re probably going to die out there somewhere. Repeatedly. Sure this can be a fun way to play around, but building a roguelike is a different story and a bigger investment of time, so try to stay focused.

The cool thing is you can build roguelikes piecemeal. They’re basically a conglomeration of systems that can be tacked on if you think they’ll support the main game.

mapgen_stages_2

Building onto your roguelike core, piecemeal style.

After that you can just repeatedly expand and iterate, hopefully with player feedback.

mapgen_stages_3

More pieces!

In the end you’ve got so much stuff tacked on that you have no idea where the last ten years went xD

mapgen_stages_final

o_O

Looking at a roguelike project as a whole it can seem really daunting, but all you really need is a plan and perseverance. Starting small is important because you’re going to make mistakes, and you’re much more likely to fail if you aim big right away.

Core Mechanic

So what does a small roguelike really need? A core mechanic. This is where the experience starts. It should be explainable in a single sentence and this is what you want to prototype first. Go straight for the fun.

What’s the game’s unique take on rogueliking? If your game only has this mechanic, is it fun? If you’re thinking a little bigger, could this mechanic serve as a core for the rest of the game to sit on? Think about what the player is doing from minute-to-minute, which presumably has something to do with this core mechanic. If that repeated process isn’t fun, it’s not going to matter what you build on top of it!

mapgen_core_mechanic_final_shrunk

Visualizing the Core Mechanic as a foundation for roguelike design.

So in this initial proto-game, only implement as many of the outer elements as necessary to bring out and test the core mechanic. Again, the above visualization and its branches may look daunting, but it’s just a sample of what’s possible. Roguelikes can be really simple and yet really fun.

To explore core mechanics a little bit more, let’s look at 7DRLs.

7DRL

A “7DRL” is a roguelike made in 7 days. Every March or so there’s an event where lots of devs make their own 7DRL, already going on 14 years now. It’s great because as long as you finish you’ll definitely get at least a few people to play it and leave feedback. Judges will also score them in different areas, though most everyone treats 7DRL like a personal challenge (it’s not supposed to be a competition).

7DRL stats - successes by year

7DRL Successes by Year, 2005-2018.

Over a hundred new roguelikes come out of this event each year. It’s a lot of fun, and while I wouldn’t recommend doing a 7DRL as your first game (you don’t need that kind of pressure so early), it’s a good idea to participate once you have at least some experience and know what goes into a roguelike, especially the technical aspects, because having a deadline really does help.

7DRLs are great examples of “start small and expand as necessary after you’ve confirmed your core mechanic seems like a good idea.” So 7DRLs naturally make good prototypes, and many are experimental in nature. We see so many cool innovative ideas each year!

Let’s take a look at a few examples…

7DRL_2014_knight

Knight (2014 7DRL)

Knight is all about controlling your momentum. You’re mounted on a horse most of the time and that little blue block in the center or so is all you can move, only one space per turn, and that’s where you’ll end up next turn. So you can only accelerate, turn, and slow down so quickly, meaning you have to plan in order to line up your attacks on moving foes to behead them with your sword as you pass.

7DRL_2016_dodgeRL

A Roguelike Where You Dodge Projectiles (2016 7DRL)

I love how this 7DRL has its core mechanic right in the name (download). You’re a ship in space, and although you automatically attack enemies within range, enemy-fired projectiles move more slowly, and you can see their projected path for the next turn and need to maneuver so that you can both continue attacking and avoid being hit.

7DRL_2015_seven_day_band

Seven Day Band (2015 7DRL)

In Seven Day Band you create your own roguelike as you play it. Wandering around you’re faced with new unknown enemies and objects, and have to set their names and abilities as you encounter them for the first time, or when they start to matter. (“Band” here refers to making an Angband-like of your own.)

7DRL_2011_brokenbottle2

Broken Bottle (2011 7DRL)

In Broken Bottle you play an alcoholic in a post-apocalyptic world where alcohol consumption ties in to most of the experience, for better or worse depending on your choices. (It’s a pretty story-focused 7DRL.)

7DRL_2012_drakefire_chasm

Drakefire Chasm (2012 7DRL)

Drakefire Chasm has you playing a young dragon fighting caverns full of monsters, adventurers, and other dragons, but there are no items, just upgrading your dragon abilities and eating your foes in order to grow larger and advance. This one still gets occasional updates.

7DRL_2014_golden_krone_hotel

Golden Krone Hotel (2014 7DRL)

In Golden Krone Hotel you take advantage of the differing abilities of your vampire and human forms, including their interaction with dynamic light. This one eventually turned into a bigger commercial roguelike and has done pretty well on Steam since releasing a year ago.

7DRL_2012_cogmind

Cogmind 7DRL (2012)

Here’s my original Cogmind 7DRL, where you’re a robot building yourself from scratch using parts found and taken from other robots, with rampant item destruction so you’re forced to rebuild pretty often. Obviously this also became a much bigger commercial project later. I never expected my little 7DRL detour six years ago would turn into my job, but I’m really happy that I participated because that was perfect for proving the core mechanic was fun.

7DRL_2018_polybot7

POLYBOT-7 (2018 7DRL)

This year for 7DRL I did POLYBOT-7, which is kinda like Cogmind but plays extremely differently because there was a significant change to the core mechanic. Instead of the player choosing what items to attach, nearby items automatically fly over and attach themselves to you, and you can’t even remove them. The only way parts are removed is when they’re destroyed. I originally planned for it to be a kind of scaled-down Cogmind, but as 7DRL got closer I kept feeling like that wasn’t really a game worth making--it needed to be something with a truly unique hook to it, a completely new core mechanic. It turned out pretty fun, and also became a good reason to design numerous additional mechanics that would support this new type of experience (comparison here, and I also did a huge postmortem covering the process behind its development from beginning to end).

So while these games may have more than one system, it’s pretty clear where their core mechanic lies, and like many other 7DRLs they really stand out for it.

Non-7DRL Examples

While we’re at it let’s take a look at a few non-7DRL examples. These games took years to make, and certainly include a ton of systems and content, but you can still see how they revolve around their core mechanics.

mage_guild

Mage Guild

There’s Mage Guild, which has the greatest alchemy system that let’s you mix any two items, be they potions, monster remains, or whatever, and get all kinds of interesting new items and effects.

demon

Demon

In Demon you recruit a wide variety of autonomous follower demons and train them.

TGGW

The Ground Gives Way

There’s The Ground Gives Way with its completely item-based progression.

xenomarine

Xenomarine

Xenomarine is built around ranged combat and directional facing, not something you see in many roguelikes.

nethack

NetHack

And one of the NetHack devs once told me NetHack’s core mechanic is “if it seems like it should be possible to do something, then you probably can.” (This almost seems like an anti-core mechanic and not the kind of example you want to follow as a new developer, but yeah :P)

Resources

One of the most important things you’ll need access to for roguelike development is information. That includes learning the basics, getting answers to questions, getting into more advanced topics later, or just food for thought.

Your specific pitfalls will be different from other devs, because everyone’s got a somewhat different skill set and personality, but you can use online resources and friends to overcome those obstacles. While you probably won’t have anyone actually working with you on your project, others can step in with advice when you need it. But you have to ask! It took me far too long to learn that, and my early progress was pretty slow because I never reached out to people. So I’m here to tell you, there’s tons of help just waiting out there!

Let’s look at some of the most useful resources…

r/RoguelikeDev

The RoguelikeDev subreddit is is the largest group of active roguelike developers in the universe. We’ve got a very welcoming and helpful community, and a well-organized sidebar pointing to a wide variety of useful resources.

r-roguelikedev_sidebar_highlight

r/RoguelikeDev and its informative sidebar.

Among those resources are tutorials in various languages and libraries, and we have members who’ve used them before and can help answer your questions.

Earlier I mentioned starting out with python, and the easiest way to do that is with the library known as “libtcod,” for which we have a tutorial (many, in fact).

libtcod_logo

libtcod logo

Like most game libraries, libtcod handles basic features like your game window, mouse and keyboard support, bitmap fonts, and palette and color manipulation. But it also does a lot of the roguelike-specific heavy lifting, like map generation, FOV, and pathfinding.

libtcod_features

Feature samples found in the interactive libtcod demo.

Ultima Ratio Regum and Temple of Torment, two roguelikes I showed earlier, both started with the game they created using this tutorial, and eventually grew into their own things. libtcod is pretty great, and has been receiving updates for ten years now.

Another way to get started is to join the r/RoguelikeDev summer code-along event. It follows the libtcod tutorial alongside other developers, if you need the extra motivation and pacing handled for you.

roguelikedev_does_the_complete_roguelike_tutorial_2018

r/RoguelikeDev summer code-along logo

We’ve done the tutorial for a couple years so far and interest has always been high. About 100 people participate each year. Technically you don’t even have to use libtcod or python to participate--many people use other languages and follow along with their own roguelike or similar tutorials.

At the end of two months you’ll have your own playable roguelike! Here are some of the games that came out of our event the past couple years:

r-roguelikedev_tutorial_sample_projects_2017-2018

r/RoguelikeDev summer code-along sample projects.

It’s a really nice walkthrough you can tack onto--it basically gives you the required technical background for a functioning roguelike, then you do the part where you let your imagination run wild :D

Later on in your RoguelikeDev travels we have FAQs that cover different aspects of development in order to get you thinking about how to approach various topics. We’ve done a fair number of them :P

faq_friday_topic_list_1-74

FAQ Friday topics #1-74

These include meta topics like planning and motivation, and details like common systems, design, all sorts of stuff! Over the years we’ve had quite a few devs contributing to these community FAQs, including many with well-known roguelikes.

Honestly we’ve got tons of developers hanging out in the subreddit in general, many with long-term hobby projects and who are knowledgeable and happy to help. We also have a Discord for real-time help and discussion. (We share the server with the r/Roguelikes subreddit, so you’ll also find lots of people playing and discussing all sorts of roguelikes in other channels.)

RogueBasin

Outside our subreddit, many years ago Santiago Zapata created this great website you may have heard of called RogueBasin. There you’ll find a whole section of development-focused articles.

roguebasin_articles

RogueBasin Articles table of contents.

There are quite a few articles (that list there is just the general table of contents!). Although a lot of the content is older, most of the articles are just as relevant today. This is actually where I got started years ago, and found the articles both inspiring and enlightening. (Also a little scary at first, but remember, roguelikes are developed piecemeal--take it one step at a time!)

Roguelike Radio

Darren Grey, Andrew Doull, Mark Johnson and others host the podcast Roguelike Radio.

roguelike_radio_topic_list_2011-2018

Roguelike Radio topic list (2011-2018).

Check out all those topics! They also include interviews with a wide range of roguelike devs. I’m even in two or three of them, including one where I say Cogmind might be done in 2016 or something like that. Hahahahaha… (The new year is 2019, but don’t hold me to that--more players keep finding it and I’m always adding new content and features because I can :D)

You’ll also see that a number of the podcasts cover the 7-day Roguelike Challenges, which are a pretty big thing in the community.

So we’ve got knowledge covered pretty well now, but another major consideration when it comes to game development in general is assets

Assets

Here are our assets:

cp437_ibm_pc

Roguelike development assets :P

Seriously though, ASCII is wonderful in so many ways, and makes it so easy to add new content. With the right combinations of foreground and background colors you can create some really pretty games.

brogue

Brogue!

If familiar with roguelikes already you’ll probably recognize that as Brogue, but over the years I’ve collected a large number of inspiring ASCII screenshots, and want to share a selection of those here to give you an idea of the breadth of possibilities:

roguecel2018_how_to_make_a_roguelike_ascii_roguelikes

22 images from a range of ASCII roguelikes. (And to head off the inevitable questions: You can find the names of these projects here.)

The variety is just amazing--there’s just so much room for unique styles!

When working with ASCII or ASCII-like monochrome tilesets you can also use my editor, REXPaint (and it integrates with libtcod--bonus!). For me it’s become a totally indispensable tool, and quite a few other roguelike devs rely on it now, too, for things like interface design, mapping, and art.

rexpaint_logo_and_ui_with_samples

REXPaint logo, partial interface, and sample images (note there are too many colors in this composite recording so the gif screws with the palette).

Tilesets

Of course, if you want more people to actually play your game (:P), or if it’ll help you get into your project, there are also some nice tilesets you can use, even if they’re just a placeholder. Many are free, or at least available at a reasonable price. You can find links to a bunch of tilesets in the r/RoguelikeDev sidebar.

roguelike_tileset_sample_sets

Sample 2D roguelike tilesets.

For some people tilesets have the advantage of sparking your imagination, if you need that to help with development. That said, you may have seen some of these tiles in other roguelikes before, and that can be one of the drawbacks (the visual style not necessarily being uniquely associated with your project), but good-looking free/inexpensive art is invaluable for indie devs.

roguelike_tileset_examples

Roguelike tileset demos by their respective artists.

Good Starting Points

For this last segment I want to take a look at where to start your real design process, what you want to focus on. You might be satisfied with just moving a little @ across the screen smashing into letters, or you might want to go a bit further than that, and hope that others enjoy it as much as you do.

Of course you’ll want some kind of hook to get people interested in the first place, but this hook can take a number of forms…

We already talked about having a core mechanic, which is one of the easier hooks since it ties most directly into the gameplay itself, and roguelikes first and foremost are all about gameplay. All those permadeaths aren’t going to be worth it if there’s no replayability.

Amazing audiovisual features aren’t traditionally as common, although we’re seeing more roguelikes headed in that direction, which is great because it attracts even more players to the genre. So that’s a useful hook.

But the one I want to emphasize now is theme, which is an excellent hook, but not taken advantage of nearly enough.

Theme

We have lots and lots of fantasy dungeon crawlers, so naturally if you want to really distinguish your project, go for any unique theme that’s not a fantasy dungeon crawler.

roguelike_theme_list

Brainstorming potential themes for roguelikes.

Roguelikes are generally based on good/interesting gameplay, but having a unique theme not only makes the entire experience unique, it also gives you a source from which to readily draw brand new mechanics. (A unique theme almost forces you to take this route.) In particular, historical and mythological themes offer a huge range of established material to explore and expand upon. People also always seem to want more sci-fi roguelikes than what we already have, a relatively underexplored group of themes compared to how broad it is, and how much sci-fi content we see out there in other genres and mediums.

We’ve seen some really unique themes in recent years.

MakaiRL

MakaiRL is a neat concept steeped in Japanese mythology and historical fantasy. I wanna play that!

 

The Skies of Bloody April

Skies of Bloody April is a World War I dogfighting roguelike.

These are the kinds of themes that really turn heads, especially of course once they reach a fully playable state (both of the above are still in early development).

One that’s already a very complete game is Lone Spelunker, where you explore the natural and sometimes dangerous wonders of subterranean caves.

lone spelunker

Lone Spelunker

As for some other themes frequently asked about in the roguelike community which haven’t been satisfied yet, pirates come up pretty often. We did have one game pop up, Pirate Rogue, which is among the highest ever voted threads on the Roguelikes subreddit.

r-piraterogue

Pirate Rogue concept art.

But Pirate Rogue was just a concept they were prototyping and the developer put it on hold since they realized their dream game was a bit beyond their experience level. The demand is clearly there, though.

Superheroes and cyberpunk are other themes that come up all the time. Someone do them.

There have been a lot of great stories coming out of the RoguelikeDev subreddit, just so many awesome projects in there, both new and long-term. But I wanted to share one in particular which I consider a pretty inspiring story, and that’s Armoured Commander.

armcom1

Armoured Commander

You’re in control of a single WW2 tank, within which you lead multiple crew members in overland campaigns. Gregory Scott, the developer, started this project with only limited programming experience, and just went at it with the libtcod python tutorial.

One year later it was finished and featured in Rock, Paper, Shotgun.

armcom1_rock_paper_shotgun_small

Armoured Commander in Rock, Paper, Shotgun.

That’s from no gamedev experience to a complete game featured in a top PC gaming opinion site in one year. Sure there’s luck involved in this sort of thing, but having a unique theme and sharing it around guarantees that more people are going to take notice.

So pick a unique theme and own it. This gets more people interested, and in turn that will help keep you motivated.

armcom2

Gregory’s now working on a sequel, ArmCom 2.

Remember that your game doesn’t have to be a strict roguelike. I’m going to be a little blasphemous here and say it’s not worth getting caught up in definitions. We often see people come up with a game idea they’d like to make, but then worry about whether or not everyone agrees it’s a roguelike. It doesn’t really matter, because there are as many definitions as there are players! As long as it’s internally consistent and follows your own plan, you’re all set. (But don’t worry, the Roguelikes subreddit will continue to bring you weekly arguments about whether or not something is a roguelike xD)

XRLs

Now to do a total 180. There’s another approach you can try which has its own advantages, the so-called “XRL.” These are based on existing IPs, and save you much of the planning and design effort that goes into making a game, as most of those questions will already be answered for you. At most you have to come up with how to adapt it to roguelike formulas. With an XRL you can focus on implementation and other fundamentals while you get your feet wet.

Lots of devs do this. A while back I made a list of examples on RogueBasin. All the roguelikes listed below are based on existing IPs.

roguebasin_roguelikes_based_on_existing_IPs

A partial list of XRLs.

Personally I think this is a good way to start out your early development efforts.

Perhaps the most famous XRL is DoomRL, officially now called just “DRL” after they were hit by a C&D from Zenimax for the name.

doomRL

DoomRL / DRL

Aside: Note you do have to be careful of particularly litigious companies, like Nintendo, for example (I’d advise against doing an explicitly Pokemon roguelike!), but in general roguelikes are so niche and under the radar that XRLs are fine for hobby projects. Only those that gain significant notoriety would have to worry about this sort of thing, and by that point you can either rebrand it to your own content, or should probably have enough experience to be comfortable working on your own ideas from scratch. XRLs are usually short-term, small-scale learning projects, although a number of XRLs have been in development over multiple years. (In any case, definitely forget having any commercial aspirations with an existing IP!)

Today DoomRL developer Kornel Kisielewicz is busy working on the DoomRL successor Jupiter Hell, a prime example of using an XRL to grow a large fan base, and then relying on them to support an even larger commercial roguelike.

In his early years Kornel also made two other XRLs: AliensRL, one of the first roguelikes I ever played, and DiabloRL.

aliensRL

AliensRL

 

diabloRL

DiabloRL

Prolific roguelike developer Slashie has made roguelikes based on Castlevania, Metroid, Zelda, Star Wars, Megaman, and probably like ten others he hasn’t told us about :P

XRL_by_slashie

Slashie’s collection of XRLs.

Even my own first semi-roguelike project, XCOMRL, belongs in this category. Based on the original UFO Defense, it started from an IP with mechanics I was already really familiar with and love, which helped a lot.

xcomrl_exodus_night

“X@COM”

From there I was able to branch out and add a lot of my own mechanics and content, doing experiments on top of an already solid foundation.

xcomrl_mods

X@COM modded maps, some of them complete conversions into a non-X-Com universe.

Another major advantage to XRLs is that you have instant fans, other people who enjoy both roguelikes and that same IP. This is great for motivation since you’ll always have people cheering you on. A number of my core supporters today are the same people who followed my early work on X@COM.

Tips for the Long Run

So some tips to help keep you in this for the long run…

Release Early and Often

“Release early and often” is the roguelike development mantra. It’s good to quickly get everything into a minimally playable state--again, build that prototype. Doing this will probably net you some good feedback, which is valuable for the long term.

roguebasin_release_announcements

RogueBasin release announcements history.

Sharing Saturday

Even before your first release, even with just a concept, and long after that, try participating in our weekly sharing threads in the RoguelikeDev subreddit.

For some this is a way to stay accountable to yourself, and it’s a nice way to review what you have, or have not, been up to. You can literally post about how your week was hell at work and you barely got anything done, and in the process make friends with others in the same boat. Or you can talk about the cool new feature you added or are thinking about. Or share funny bugs. Anything, really! It’s a great community :D

r-roguelikedev_sharing_saturday_1

Come share with us!

Keep a Blog

Besides Sharing Saturday it’s also nice to concentrate all the info about your development in one place. A public place. Blogging actually has a bunch of advantages; here’s a list of some of the major ones:

  • organize your thoughts
  • examine your work from a different angle
  • document the process
  • create a useful long-term reference
  • get feedback
  • build a community

I’ve been doing this for a while myself and found it to be incredibly valuable. Below are the topics I’ve covered over the years on my blog:

gridsagegames_blog_posts_2013_2018

Five years of blog posts from Grid Sage Games.

You’ll probably find a fair bit of useful info just sitting there for the taking :)

Accessibility is Important

Accessibility is important. Traditionally this wasn’t the case with roguelikes, but nowadays you have an opportunity to reach so many more players if you’re willing to put in the effort. This means sufficient documentation, a tutorial, full mouse support, a tileset, etc.

To demonstrate how valuable mouse support and a tileset can be, check out these player stats from Cogmind:

accessibility player stats

Cogmind player preferences: That’s a whole lotta mice and tiles!

Note that some accessibility features are important to consider in your design from the very beginning, but don’t worry about all this stuff in your first roguelike. Starting with an ASCII/keyboard-only game is just fine.

The Beginning

This is the end of my article, and the beginning of your great new roguelike.

Get to it :D

Posted in Gamedev | Tagged , , , , , , | 10 Responses

Roguelike Celebration 2018, the Experience

Another Roguelike Celebration! The biggest roguelike gathering of the year just keeps getting bigger :D

I had to miss last year due to my concussion, but it was great to finally meet up with everyone again. Back in 2016 I showed up just a few days before Roguecel and still wasn’t sleeping well when the time came around, and although the sheer excitement of being with all these roguelike developers and players was enough to keep me going through an entire day, I knew it’d be even better if I could participate fully refreshed. So this time I made a vacation of it, arriving in the US a couple weeks early to visit family near San Francisco, too.

roguecel2018_airport_at

I knew I was headed in the right direction as soon as I saw the sign at the airport.

Like 2017, this Roguecel was on a two-day schedule, which is just awesome. The feedback from 2016 was pretty much unanimous in that a single day was simply not enough, especially since that also forced the talks to be split into two tracks, meaning you’d always be watching one talk at the expense of another, which sucked. (After this year I’m hearing multiple calls of “two days is just not enough!” xD)

Pre-event Gathering

On Friday night (10/5) we had a pre-event meet-up at ThirstyBear Brewery. It was announced relatively late so there were only about 25 people or so, though this was probably for the better since the place was already packed and we had no reserved space. Instead we gradually assimilated tables as they were emptied, and in the meantime had to guess who among those entering the bar were actually here for roguelikes. This was not hard to guess ;)

I met up with lead organizer Noah, who said about 230 tickets were sold this year!? o_O \o/ roguelikes!

I spent most of the evening catching up with old friends Santiago and Thomas. All three of us hail from separate countries, but talk online and got to hang out in 2016.

roguecel2018_preparty_with_santiago_and_thomas

RogueBasin and Ananias creator Santiago, myself, and ADOM developer Thomas Biskup.

Santiago admitted he didn’t have a single slide prepared for his talk the next day (in the morning scheduled for right after mine). Quite the opposite of my approach, but surprisingly it turned out fine as you’ll see.

In the Beginning

Saturday marked the official start of the event, and the next morning I arrived early to help out a bit with setup. Roguecel 2018 was held at the GitHub offices in San Francisco, same as last year though different from 2016 so I hadn’t been here before.

roguecel2018_github_entrance1

Front doors to GitHub in SF.

GitHub is such an amazing space for hosting events, and we got to use it for free. Wow.

roguecel2018_github_open_area

Open area near the entrance.

 

roguecel2018_github_cafeteria

Cafeteria.

 

roguecel2018_github_speaking_area

Speaking area.

 

roguecel2018_github_stage

Stage.

 

roguecel2018_github_view_from_stage

View from stage.

As usual the decorations included various posters, letters, @ signs, and message log texts, so part of setting up was to hang these things around the area to make it a little less GitHubby and a little more roguelikey.

As a sponsor, Thomas had some Ultimate ADOM posters printed up, so he, Britta (another organizer) and I hung those around.

roguecel2018_decorations2

Ultimate ADOM posters.

 

roguecel2018_decorations1

The Altar has been a guaranteed fixture of the event each year.

 

roguecel2018_decorations3

Exactly what I want to see at the emergency exit.

Swag

Even before 9am people were scanning their tickets at the door and picking up their Roguelike Celebration memorabilia.

roguecel2018_registration

Let the rogueliking begin!

Every year there are @ socks for everyone to replenish their supply. And a new t-shirt design.

roguecel2018_swag_apparel

Roguecel t-shirt and socks. (Apparently only 2016 had a separate t-shirt design for speakers, one that is still one of my favorite shirts, and I brought and wore it on Sunday.)

But there was a great collection of other stuff, too…

roguelike2018_swag_misc

RC2018 swag!

Everyone got one of those awesome ASCII/@ tote bags, inside which is a notebook, marker (magic, of course), and pamphlets containing Ultimate ADOM mini-stories. Top-center there is a little roguelike map lapel pin! As a speaker I also got some nice chocolate and a custom thank you card with a hand-written message on it, signed by all the organizers <3

Food

All three meals were catered both days, except for dinner on Sunday. It was a healthy, tasty variety of options, so I was happy to see that (in addition being mostly stuff I wasn’t allergic to :D).

roguecel2018_breakfast

Saturday breakfast begins.

 

roguecel2018_breakfast2

People just starting to filter into the cafeteria. It was funny to see the high proportion of black clothing throughout the weekend, as many were wearing roguelike-related t-shirts.

 

roguecel2018_breakfast3

More and more people.

 

roguecel2018_breakfast4

There were eventually enough people that in looking back at my earliest pictures I’m surprised to see a number of them I didn’t even realize were there until much later!

After breakfast it was time for talks, so most everyone gradually moved over to the speaking area. There are technically linked monitors everywhere so it’s easy to see the talk from other sitting/standing areas, too (even, uh, the restrooms xD).

roguecel2018_pretalk_audience

Audience getting ready for the first talk of this year’s Roguelike Celebration.

The talks started a little late due to GitHub technical issues, and the first two ended up not being streamed, but at least they were recorded.

I was actually the opening talk! This is great because I could get it out my mind rather than worrying about it any longer. It also turns out that because my talk touched on a lot of different subtopics, a fair number of other speakers referred back to my presentation, which was kinda cool.

roguecell2018_noah_opening_remarks

Opening remarks by lead organizer Noah. (At this point I’d already set up my laptop and presentation so it’s ready to go, which is why it’s on all screens.)

How to Make a Roguelike

My own talk went pretty well. Back in 2016 at the first Roguelike Celebration when I gave the From Hobbyist to Full-time Roguelike Developer talk, I was quite nervous because 1) that was the first time I’d done any kind of speaking about anything since high school in the 90s and 2) I hadn’t even practiced what I was going to say, just put together a bunch of slides and notes (this is bad when you’re as easily nervous speaking before an audience as I am).

But this time I came prepared. Perhaps a little too prepared? I started my outline a few weeks in advance, on September 13th, and worked on the outline and content off and on up until the day before the Celebration. I finished with just enough time to practice it a couple times, and was happy that my (intentional) overestimates of how long each section would take ended up totaling an actual final time of about 26 minutes or so. At the time I guessed I’d spent maybe 40 hours on it, but on checking my time records now, apparently I spent freaking 59 hours preparing this talk xD

Well, it was worth it! This is something I’ve always wanted to put together, a comprehensive primer on how to make a roguelike, something that could hopefully be inspiring while including both general and specific advice. So this year’s Roguelike Celebration seemed like the perfect opportunity to force myself to do that after having put it off for so long.

The full talk is here:

In addition to the video presentation, I’ve made the slides publicly available here and will also be posting a full text version, perhaps with some edits and additions, here on the blog soon. Update 181024: Posted!

Santiago took some photos for me from the audience.

roguecel2018_kyzrati1

How to Make a Roguelike!

 

roguecel2018_kyzrati2

Core mechanic!

Morning Talks

Right after me was Santiago, and his talk was great, surprisingly so considering he hadn’t done any slides until that morning (though he did admit the stress wasn’t worth it and he will try not to do that again in the future…).

roguecel2018_santiago_talk

Santiago Zapata talking about the origins and early history of roguelikes. Also helping immortalize Thomas’ amusing presentation from the ADOM Kickstarter campaign.

 

roguecel2018_andrew_talk

Andrew Aversa (Tangledeep creator) talking about roguelike difficulty.

 

roguecel2018_bob_talk

Bob Nystrom talking about Entity Component Systems. Bob’s book Game Programming Patterns is pretty popular among game developers, and he’s worked on his own roguelike as well.

Breaks

Then it was time for lunch…

roguecel2018_lunch_line

The lunch line was quite long, but no problem since there was plenty of good conversation to be had in line anyway. I mean, pretty everyone’s there due to a shared interest in the genre, yeah? :)

 

roguecel2018_lunch2

Post-food mingling.

 

roguecel2018_lunch1

Still mingling.

The weekend wasn’t packed with lots of back-to-back talks, either. In addition to meal times, there were additional breaks for mingling or whatever.

roguecel2018_random_thomas_santiago

Thomas and Santiago hanging out.

 

roguecel2018_random_jason_amit

Jason (Caves of Qud) and Amit (Red Blob Games) talking about Amit’s new real-time terrain modification methods, and plans for sharing a new A* heuristic, among other things.

Afternoon Talks

In the afternoon we came back to a great talk from Jim. Really all the Roguecel talks were great.

roguecel2018_jim_talk

Jim Shepard (Dungeonmans creator) talking about good storytelling in roguelikes, funny as ever.

 

roguecel2018_jongwoo_talk

Jongwoo Kim (designer at Kitfox) talking about subjective simulation design.

 

roguecel2018_alexei_talk

Alexei Pepers giving everyone a guided tour of fun stuff in the NetHack source code.

Then came the final presentation of the day, in which Thomas shared the first public demonstration of Ultimate ADOM, the new game the ADOM team has been working on for about nine months now.

roguecel2018_thomas_talk_adom1

Thomas begins the Ultimate ADOM demo, live in game.

 

roguecel2018_thomas_talk_adom2

Clearing a room with a spell in order to move along to another area for a different demo.

Although they’re focusing on the graphical version of course, the ASCII version actually also looks pretty neat. There’s also grafting of enemy parts in order to gain their abilities, which certainly sounds a lot like Cogmind :P, though Thomas does say he’s been taking inspiration from my work so yay ;)

Party and Arcade

Thomas also sponsored the Saturday evening party, so no complaints there!

roguecel2018_github_bar

After dinner the bar opened. GitHub has a bar right in its cafeteria…

In addition to the bar, a bunch of computers were set up for playing roguelikes and retro games. Among them, there were original VT320 and VT420 terminals from which to log into the Living Computer Museum and basically play Rogue and Hack as they were originally played. These naturally got a lot of attention :)

roguecel2018_arcade1

Logging in to play Rogue at the Roguelike Celebration 2018 Arcade.

 

roguecel2018_arcade2

Rogue on the VT320 (left) and Hack on the VT420 (right).

 

roguecel2018_arcade3

Playing Rogue on a VT320 @ Roguecel!

 

roguecel2018_arcade4

The machines had lines (or more like groups) for a while :P

 

roguecel2018_arcade5

One of the other arcade areas.

Some devs also just hung around with their own devices showing stuff.

roguecel2018_santiago_ananias

Santiago demonstrating the current state of Ananias, and its UI layout on different devices.

 

roguecel2018_party_end

The party was winding down when I left around 10pm.

Sunday Talks

Tarn Adams kicked off the second day of talks.

roguecel2018_tarn_talk

Tarn talking about how villains and their various behaviors can help naturally drive a story in DF adventure mode.

 

roguecel2018_tarn_talk_slide

Tarn did his slides in Paint, and despite the small number of slides he kept building on the content of each such that they tended to get quite messy. It was fun :D

Then came Brian Walker, who had sadly missed the first day because he had a vacation which was set before the Roguecel dates were even determined this year. So we didn’t get to hang out the day before, but at least he got in late that night and could still make Sunday.

roguecel2018_brian_walker_map

Brian talking about procedural level design in Brogue. This is my favorite pic from everything I shot during the Celebration, with Brian in his plaid shirt melding into the very map he’s explaining :P

For the latter portion of his presentation, Brian also shared info about his current project, a time-moves-only-when-you-do platformer roguelite that draws on the same map generation principles found in Brogue.

roguecel2018_brian_talk_platformer

The new project looks quite cool, and apparently it’s quite far along. Basically it’s a new playground for interesting map generation techniques, which is why he got into doing Brogue in the first place.

More Breaks

Of course there were more breaks to enjoy on Day 2 as well.

roguecel2018_random_amit_tyriq_brian

Tyriq Plummer demoing his simultaneous turn-based 2018 7DRL for us.

 

roguecel2018_random_santiago_travis

Santiago and Travis wanted to test out the Rogue machine but the VT320 wasn’t logged in at the time.

More Talks

rogecel2018_danny_talk

Danny Day talks about the advantages and disadvantages of event listeners in Desktop Dungeons.

Then Thomas came up for a second talk (well technically yesterday’s was a demo), this one about how they’re using ECS in Ultimate ADOM. So it was a lot more technical and source-heavy, with plenty of examples. I also got a shout out at the beginning, which was great :D

roguecel2018_thomas_talk_ECS

Thomas talking about the style of ECS they’re using in Ultimate ADOM.

 

roguecel2018_jonathan_talk

Jonathan Lessard talks about the Chess/Rogue hybrid he created with Pippin Barr. Lots of interesting design discussion regarding how to mix the two, and what did and did not work.

 

roguecel2018_leif_talk

Leif Bloomquist talking about his multiplayer roguelite built for the C64.

 

roguecel2018_max_talk

Max Kreminski talking about “gardening as a mode of play.”

 

roguecel2018_colin_talk

Colin Liotta talking about the roguelike puzzle game he designed for the 2017 MIT Mystery Hunt.

Last was the lightning talks series, where different speakers would come up for just five minutes or so and share some topic of interest.

roguecel2018_lightning_talk_alexei

Alexei was up on stage again, this time talking about visualizing the aggregate results of procedural generators.

 

roguecel2018_lightning_talk_kawa

Kawa talking about death as part of the roguelike experience.

 

roguecel2018_lightning_tall_eben

Eben Howard talking about his Java roguelike library SquidLib.

 

roguecel2018_lightning_tall_ignacio

Ignacio Bergkamp talking about his neat idea for a new approach to character death in roguelikes: On death allow the player to enter a free-form blurb of text to describe how they lost.

 

roguecel2018_lightning_tall_kate

Kate Compton talking about “Chancery,” her conversational bot framework.

 

roguecel2018_lightning_tall_thom

Thom Robertson talking about his procedural whale-seeking game.

After another break, Caves of Qud devs Jason Grinblat and Brian Bucklew narrated a “choose your own playthrough” run of Caves of Qud, controlled by Nick DeCapua.

roguecel2018_caves_of_qud_playthrough

Nick, Jason, Brian, and the audience playing Caves of Qud.

Dinner

Those two days sure went by fast. I took one last shot before heading out of the building.

roguecel2018_github_entrance_final

#roguelikecel logo still up at GitHub as we’re leaving.

For the final dinner there were maybe several dozen who’d stuck around, so we all walked a block up the road to the 21st Amendment Brewery.

roguecel2018_group_dinner1

On our way to 21st Amendment.

Fortunately there was still a fair amount of outdoor seating left, and we gradually took over additional tables until they were all ours, though a portion of the group walked further up the road to another restaurant to eat real quick before coming back later.

roguecel2018_group_dinner2

Arriving at 21st Amendment.

 

roguecel2018_group_dinner3

Hanging out before dinner at 21st Amendment.

And there we sat until closing time!

roguecel2018_dinner_table

Good times filled with conversations about roguelikes and of course plenty of other procedurally generated topics.

Such a great weekend, very much worth flying around the world for… I’m already looking forward to seeing everyone again next year!

Posted in Uncategorized | Tagged , , , , | 10 Responses

65 Robot Hacks

We’ve already covered the design behind the all-new robot hacking system, and now for the main course: the hacks themselves! The entire initial set is complete and ready for Beta 7, all 65 of them :D

I’ll be talking about most hacks in this post, and you’ll notice their names follow a certain pattern throughout--all composed of two words, a verb followed by a noun, separated by an underscore in between. Essentially “verb_noun.” This style was chosen to clearly distinguish them from machine hacks. By default Cogmind uses a small-caps typeface so this choice may not be apparent right away from the screenshots I use here, nor does it really matter in game, but it matters for discussion outside the game. Using a consistent format will make robot hacks immediately identifiable in conversation, even if someone has never heard of a given hack before.

There are several possible requirements for robot hacks, as described in the previous post. The vast majority of hacks require having both installed a Relay Interface Framework and attached the Relay Coupler applicable for the target class, in addition to of course carrying a Datajack to initiate the hack in the first place.

cogmind_robot_hacks_requirements_distribution

Robot hack distribution by requirements.

Wherever possible I tried to add some hacks with lower requirements, though again the main point of the system is to give it fairly significant powers, and the only way to justify that is by setting sufficient requirements.

In terms of combat vs. non-combat hacks, the latter are much more plentiful:

cogmind_robot_hacks_noncombat_vs_combat

Hacks targeting combat bots vs. those targeting non-combat bots (the total does not equal 65 because there is some overlap).

This makes sense simply because there are a larger number of unique non-combat robot classes, and even more so because there’s only so much you can do with combat in particular, at least within the Cogmind framework. Let’s start there…

Combat Hacks

“Combat hacks” refers to those targeting combat bots, even though not all of them are actually aimed at fighting. For design purposes I divided these hacks into groups, helping ensure each hack fit a role and was different enough from others. There are five categories in all:

cogmind_robot_hacks_combat_categories

Distribution of hacks targeting combat robots, by effect category.

I’ll talk about the hacks by category.

Mod

The largest category revolves around simply modifying the target in some way, usually affecting behavior or hit chances (the text here is taken directly from the context help available in game):

  • focus_fire: Force system to prioritize attacking Cogmind wherever possible.
  • reboot_propulsion: Render propulsion unusable for 15 turns while the control subsystem reboots.
  • tweak_propulsion: Rewrite sections of the propulsion control subsystem to permanently halve movement speed.
  • scatter_targeting: Offset targeting algorithms to approximately halve their chance of achieving optimal aim.
  • mark_system: Mark this bot to make it the most attractive target to all allies, as well as improve accuracy against it by 10%.
  • link_complan: Tap into system’s combat decision-making processes in real time, increasing your accuracy and damage against this bot by 25% while also impairing its accuracy against you by 25%.
  • broadcast_data: Openly share the local combat network’s defensive coordination values, giving yourself and all allies 25% better accuracy against this and all 0b10 combat bots within a range of 3.
  • disrupt_area: Actively interfere with the local combat network’s offensive coordination calculations, reducing the accuracy of this bot by 25%, and that of all 0b10 combat bots within a range of 3.

This category is almost too large, as some of the hacks overlap a bit, though they still have distinct enough roles that I felt it was worth adding them all anyway to see which ones might get more use. Most of these hacks won’t make sense against weaker enemies, but that’s a standard side effect of Cogmind’s environment--most bots don’t pose much of a threat individually, the threat lies in the composite danger presented by multiple hostiles, even more so if they have different complementary capabilities. Against a stronger enemy, however, it could be worth taking the time to weaken them first, or apply a modification with some other ulterior motive.

Groups of weaker enemies are also why some of these hacks come with area effects, to work at addressing the fact that combat hacks against an individual bot may not be worth it compared to simply pulverizing them with a cannon.

Intel

Information gathering accounts for nearly half of all hacks, combat bots or not. Although there are fewer intel options available from combat bots, they still make up a relatively large category and can be quite useful in the right situations:

  • find_shortcuts: Reveal and label all hidden doors within a range of 50. (There are a lot of ways to detect emergency access doors, but none with reach like this. Could come in handy in the long run.)
cogmind_robot_hacking_find_shortcuts

find_shortcuts demo

  • find_garrison: Locate the nearest Garrison Access.
  • show_paths: Highlight all current patrol squad routes. Only effective when targeting a patrol squad leader. (It will take a observation to identify which squads are considered to be patrolling, much less find a leader, and the route data is only valid while they’re still patrolling it, so I’m not sure how useful this will be in practice, but it looks cool and can also reveal lots of valid pathways in unknown areas of the map so it might catch on. parse_system will help find/teach about patrol squads and leaders.)
cogmind_robot_hacking_show_paths_tiles

show_paths demo (paths glow intermittently, and are always visible while panning the map for easy reference; lines are color coded by squad type, and these records disappear after a while since they only matter for so long)

  • link_fov: Tap into system’s visual feed for 100 turns. Must remain within a range of 20 to maintain the link.
  • parse_system: (more on this later)

Damage

“Methods to deal outright damage” is a tiny category because merely doing damage doesn’t generally make much sense for a hacker--you either want to take down the target or achieve some other special effect. So even these hacks don’t deal direct damage, but are instead alternatives with their own niche.

  • spike_heat: Destabilize power systems to induce a massive surge of heat. (This is essentially a way to instantly get the target ready for meltown, which anyone who knows about thermal transfer from TH weaponry understands that it could start causing all manner of nasty side effects that can even start to compound. Overall it’s a very cheap way to possibly take down a target, if not very reliable because you’re at the mercy of random side effects with this one.)
  • overload_power: Cause power source to explode. Process takes 4-6 turns to reach critical point. (The effect is equivalent to EM spectrum chain reactions, and being able to trigger it at will offers a lot of tactical possibilities… Plus it’s just fun. And you’ve gotta time it right :). It’s the readily available AOE time bomb you’ve all been waiting for!)
cogmind_robot_hacking_overload_power

overload_power demo (also a demonstration of the effectiveness of doing this next to an array of power conduits :P)

Disable

This category’s hacks are akin to mods, but completely disabling systems is often an even stronger effect, though still without doing any actual damage.

  • wipe_record: Remove any record of Cogmind from memory, and block new Cogmind records from being created for 10 turns. (This effectively makes you invisible to that robot for a little while, which is pretty cool and unique.)
  • disable_weapons: Disable all weapon systems for 20 turns. (There you go, you finally have a way to do this, heh. This has been brought up a few times before by the community with regard to targeting specific systems, though until the new robot hacking there hasn’t been a reasonable way to make it a potentially frequent tactic.)
  • reboot_system: Force a complete reboot. The entire sequence requires anywhere from 15 to 25 turns to complete. (The previous system’s good old REBOOT hack is back in its new form, which does… the exactly the same thing :P)
  • go_dormant: Wipe memory and force immediate dormant state. (This is a relatively cheap way to permanently remove a target from action, as long a you can get out of view quickly and no one else is around to wake them up. In that way it can be even better than a reboot--it’s a “reboot with a catch.” If you recall, dormant combat bots only have a chance to wake when enemies are in view, or if they’re alerted by another robot.)

Assimilate

Assimilation has always been the highest goal of robot hacking, and while it’ll definitely still be useful, I’m sure it won’t be as desirable as before, or as good as other cheaper hacks that might require more creativity :)

  • overwrite_iff: Trick system into believing it is allied with Cogmind. After 10 turns the network will perform an automated quickboot to restore it to normal, a process which takes anywhere from 5 to 10 turns. (Temporary assimilation combined with a bit of a reboot is probably even better than outright assimilation in many cases--I can see this being popular.)
  • streamctrl_high: Hijack the control node to force system to act as an ally. Must remain within a range of 5 to maintain the connection. This bot will follow while in this mode. (An alternative situational assimilation, cheaper than completely assimilating a target, but of course it comes with a bit of a caveat.)
  • formatsys_high: Rewrite all system data, permanently converting it into a fully controllable ally. Requires 6 turns to complete the process. (As you can see, the old full-on ASSIMILATE hack is still here, although it’s fairly expensive so you [probably] won’t be raising large armies with it!)

The latter two hacks were originally named stream_control and format_system, and applied to both combat and non-combat bots, but I later decided it was important (and made sense) for the coupler cost to be cheaper when used against the latter group. It would’ve been possible to simply show and apply a different cost for these hacks depending on the target, but I wanted to remain consistent--one hack, one cost, so I gave them somewhat different names instead. As you’d expect, the other versions end with _low :). Technically there are 67 different robot hacks, but these pairs are equivalent in effect so I didn’t count the duplicates.

Non-Combat Hacks

Most hacks target non-combat bots, which is more in line with a hacker’s non-confrontational style, using other bots to make exploration or combat easier, or helping avoid the latter altogether. However, the wide variety of hacks also means that just about any kind of player can benefit from at least some of the system, allowing for all sorts of hybrids.

Like the combat hacks, here I’ve broken down non-combat hacks into categories, though note that I only did it for fun/demonstration purposes--it wasn’t part of the design process like it was above.

cogmind_robot_hacks_noncombat_categories

Distribution of hacks targeting non-combat robots, by effect category.

Understandably intel is by far the largest category, considering there are so many different classes with their own responsibilities and knowledge to “share,” while most other hacks deal with controlling the target and/or their surroundings in some way.

Although normally non-combat bots see Datajack hits as a threat, in cases where a hack is some kind of order they’ll override that reaction and instead do what they’re told.

Even where bots do consider it an attack, or are affected by a hack, there are currently no effects on alert level. This is cool and logical in a hacker sense, though we’ll have to see how abusable it is. That said, by extension hacks don’t score points, either--they’re just recorded in stats as usual. In any case, robot hacking is meant to be pretty good within its niche, since 1) sacrifices need to be made in terms of plot and build, and 2) it only applies to 0b10 bots.

One major area of differentiation between combat and non-combat hacks: the former requires numerous couplers, one for each target type, whereas all non-combat hacks are processed through a single Relay Coupler [NC]. That’s going to be a popular one… (it’s also the most common). If combat hacks were similarly accessible it would trivialize combat and robot hacking strategies, and the system would be less interesting overall.

Just look at all these [NC] robots that can be hacked…

cogmind_robot_hacks_noncombat_class_distribution

Distribution of robot hacks by non-combat robot class.

Any

Some basic hacks can be used on any non-combat robot, so this category is general purpose stuff which’ll be available almost everywhere.

  • no_distress: Prevent this system from generating distress signals.
  • generate_anomaly: Induce an energy anomaly resembling a long-range distress signal that will attract nearby patrols and sentries to investigate. Anomaly detectable up to a range of 15.
cogmind_robot_hacking_generate_anomaly

generate_anomaly demo

cogmind_robot_hacking_generate_anomaly_easier

Under easier difficulty modes this hack also indicates the positions of robots that will respond to the anomaly.

  • generate_echo: Destabilize power systems to generate a wave of energy which can be analyzed to temporarily pinpoint robots at a distance. Beyond a range of 20 the echo becomes too weak to be useful.
cogmind_robot_hacking_generate_echo

generate_echo demo

  • start_evac: Instruct system to follow local evacuation protocols by heading to another 0b10-controlled level.
  • link_fov, overload_power, streamctrl_low, and formatsys_low are equivalent to the combat hacks.
cogmind_robot_hacking_link_fov_multiple_ascii

link_fov demo (blue circles indicate the range outside of which the connection is lost)

  • parse_system: (more on this later)

Operator

As the most connected 0b10 class central to operations, Operators make juicy hacking targets. For similar reasons some players like to have one of these following them around as an ally, though the benefits are not identical (in a general sense, robot hacks have more potential because the bot still has greater access to 0b10 systems at the time, unlike once it’s been assimilated).

  • check_alert: Query system for current alert level.
  • purge_threat: Lower the alert level. (A useful hack, but it’s also the most expensive by far.)
  • find_terminal: Locate the nearest Terminal.
  • locate_traps: Reveal and mark all traps within a range of 30.
  • disarm_traps: Disarm the nearest trap array within a range of 30.
cogmind_robot_hacking_locate_traps_disarm_traps

locate_traps/disarm_traps demo

  • reprogram_traps: Reveal and reprogram the nearest trap array within a range of 30.
  • block_reporting: Block ability to report hostiles at a Terminal.
  • summon_haulers: Force system’s call for reinforcements to instead redirect any Haulers within a range of 50.
  • recall_investigation: Recall the most recently dispatched investigation squad.
  • clear_repairs: Clear the sector-wide repair queue and any pending Builder orders.
  • clear_recycling: Clear the sector-wide part collection queue and any pending Recycler orders.

Researcher

Researchers have a lot of options because they know stuff. Stuff you might want to know, too.

  • find_scanalyzer: Locate the nearest Scanalyzer.
  • disable_scanner: Permanently disable an active stasis system to prevent scanning and analysis.
  • locate_prototypes: Mark all prototypes and alien tech across the map, also providing their IDs.
  • report_prototypes: Force system to reveal 10 new prototype IDs.
  • report_schematics: Force system to reveal 10 new part schematics.
  • report_analyses: Force system to reveal 3 new robot analyses.

Worker

K-01 Serfs are all over the place, so it’s nice to have some things to do with these little guys. Hacking them can even be extremely useful…

  • find_chute: Reveal and mark the chute this Worker might use if immediately tasked with disposal.
  • deconstruct_machine: Dismantle the nearest non-interactive machine.
cogmind_robot_hacking_deconstruct_machine

deconstruct_machine demo (you can also try what happens when they start taking apart an explosive machine ;))

  • hold_bot: Latch onto the nearest visible non-prototype 0b10 bot to hold it in place. This task is automatically cancelled after 25 turns.
  • start_disposal: Dispose of currently held bot via a chute, if possible. Huge bots are too large to push.

Hauler

For just being defenseless bots that ferry parts, Haulers have some decent hacking options!

  • find_fabricator: Locate the nearest Fabricator.
  • drop_inventory: Force a complete inventory dump, fully identifying contents in the process.
cogmind_robot_hacking_drop_inventory

drop_inventory demo (sure you could just blow them up, but that’s unreliable and won’t give you the advantage of knowing whether any of the contents are faulty/dangerous!)

  • recall_reinforcements: Recall reinforcement squad requested by this Hauler.
  • locate_stockpiles: Mark all common part stockpiles.

Mechanic

Mechanics aren’t all that common, but aside from those operating from a Repair Station, assault squads do sometimes have one in tow, which may be a bad idea for them if you’re a hacker :P

  • find_station: Locate the nearest Repair Station.
  • release_backups: Force the system to release all backup parts from compressed internal storage.
cogmind_robot_hacking_release_backups

release_backups demo

  • deconstruct_bot: Disassemble the nearest allied visible non-huge non-prototype 0b10 bot into its constituent parts.

Watcher

Hacker’s paradise when it comes to intel. I mean, that’s their job, right?

  • map_route: Show scan information from along this Watcher’s patrol route. (While it’s possible to get unlucky and find a Watcher with a really short route, this hack can also be a gold mine of info.)
cogmind_robot_hacking_map_route_exit_ascii

map_route demo (finds an exit)

cogmind_robot_hacking_map_route_items_ascii

map_route demo (here hacking from the middle of its route, and labeling discovered items)

cogmind_robot_hacking_map_route_storage_loop

map_route demo (tiles)

  • mark_security: Mark all active security positions within a range of 40.
  • relay_feed: Permanently hook into the sensor feed system, receiving scan data transmissions from up to a range of 20 from Watcher’s position. (Basically you get a remote Sensor Array, pretty good if you don’t have one of your own, and even better if it’s a high-level watcher.)
cogmind_robot_hacking_relay_feed

relay_feed demo

Protector

Protectors are generally only found supporting assaults, and all they really have to their name are shields, so…

  • disable_shields: Permanently disable an active shield or force field system.
  • redirect_shields: Permanently reprogram defensive system to protect yourself and allies from attacks, instead of Protector’s allies. (This one’s more expensive, but if you and/or allies are close enough to take advantage of it, it’s a pretty nice buff for you plus debuff for enemies. Remote force fields are really annoying to fight through, so you want them on your side.)

Engineer

No you’re still not allowed to build new walls, sorry ;)

  • ignore_repairs: Block system messages regarding the repair queue.
  • map_walls: Reveal all walls and emergency access points within a range of 25.
cogmind_robot_hacking_map_walls

map_walls demo

Tunneler

T-07 Excavators generally hang out at lower depths where you won’t be doing much robot hacking anyway, but just in case…

  • randomize_corridors: Permanently add new paths to the local complex layout. (This is one of the few hacks I don’t think will be very useful, but added it anyway just to give them something extra related to their regular tasks.)
  • map_earth: Reveal all earth within a range of 25.
cogmind_robot_hacking_map_earth

map_earth demo

Recycler

Cogmind’s #1 annoying bot can now also be dealt with by hacking it directly, though there are already other pretty effective methods of handling them (like just shooting :P).

  • find_recycling: Locate the nearest Recycling Unit.
  • ignore_parts: Block system messages regarding the part collection queue.

Compactor

Hackers ain’t afraid of no Crushers! A single [NC] coupler is enough to pacify an entire Waste sector’s worth of these menaces (and you normally don’t need to confront nearly that many on your way out).

  • ignore_targets: Block system messages regarding waste processing targets.
cogmind_robot_hacking_ignore_targets

ignore_targets demo

And with that we’ve covered all 65 hacks, except for that one…

Universal Hack

The combat and non-combat lists above both refer to “parse_system,” a special hack that works on any bot, even non-0b10 bots. All it takes is a Datajack to access it, and it’ll always appear when hacking bots, just like the Manual command.

PARSE was available under the old system, although never really used. I had originally added it mainly for fun, thinking it might eventually become something, and now it has! For one it gives more details than it used to, including info about the AI, squads, and more.

cogmind_robot_hacking_parse_system_composite

parse_system demo (multiple)

But the most tangible advantage is the fact that it both lists all parts attached to the bot, identifies them all even if unknown or prototypes, and even adds them to your gallery if not already there! This will be a new non-evil method to get records for some of those cool parts your friends and/or NPCs are using without, you know, murdering them :P

By extension, using a Datajack on a friendly will no longer be considered a hostile action, allowing you to parse them, too.

In the past completing the full item gallery required either straight up killing your friends (preferably with weapons that increase salvage rates), or getting really lucky and not only meeting valuable allies but having them be killed and drop their special gear for you. Some people understandably disliked the former for roleplay reasons, and the latter isn’t really a feasible long-term approach given how many rare allies and parts there are.

Balance

Last time I talked about one of the first important elements of balance: access to Relay Couplers. The other main one would be the cost of the hacks themselves.

I only made a few references to cost above, though obviously these values will factor highly in terms of each hack’s relative strategic applications. Hacks can range anywhere from free to consuming an entire Coupler in one go, so for reference I’m posting my design spreadsheet used to set the costs in the first place.

cogmind_robot_hacking_design_spreadsheet_new_combat

Combat hacking Coupler costs. You can see how they’re divided into the categories described earlier.

I start with the number of hacks I think is reasonable for a single coupler, and it calculates the rest automatically so that things are quick and easy to adjust. Costs have changed a bit as I worked through the implementation process, and will likely see some more adjustments in the future, but this is a good starting point.

Here’s the cost info for all non-combat hacks:

cogmind_robot_hacking_design_spreadsheet_new_noncombat

Non-combat hacking Coupler costs.

For fun you can compare to the design spreadsheet for the old pre-Beta 7 robot hacking system, which was much more complex, and because it’s based on a percentage system isn’t very reliable--players would only bother with it if they could reach near or at 100% on their desired hack!

cogmind_robot_hacking_old_chance_system_design_spreadsheet

Pre-Beta 7 robot hacking system design spreadsheet.

We went from 5 hacks straight to 65 :P. And this is just the first batch--more could be added, or some might be tweaked or even removed down the line depending on what hacks players use and how. We’ll have to see how Beta 7 turns out first!

Update: The RIF system itself also has been expanded with passive permanent effects that can be gained as abilities similar to some of these hacks, and more.

Posted in Mechanics | Tagged , , , , , | 2 Responses

Robot Hacking, Take 2

Over three years ago, before Cogmind’s first alpha version was released, I wrote about robot hacking. Well we can keep that post around for posterity and historical research purposes, but as of the next version robot hacking is undergoing radical changes and a major expansion. This post will explain the fundamentals of the new system (much of this content was originally serialized in a series of SITREPs on the forums and Steam news).

Background

First a bit of history.

Back in the pre-Alpha days (2015 and earlier), robot hacking was never fully realized. Ideally it would be designed to fit in with all the other systems, but there had really been almost no playtesting since the 7DRL and three quarters of the world had yet to be created, so there wasn’t much to go on at the time. Rather than build up something large right away, a better long-term approach would be to just add a smaller functional placeholder that could be tweaked or possibly replaced when necessary as the rest of the game took shape.

So then, as now in Beta 6, there were just a handful of general options running the spectrum from “temporarily disable” to “permanently assimilate.” As it was clearly an underdeveloped system tangential to everything else going on, Alpha players almost entirely ignored robot hacking for a long while, exploring other mechanics instead.

Then came late Alpha, and it was discovered that a Cogmind could stack Hackware like there’s no tomorrow and literally own anything in the complex, especially later in a run. Here’s an example of this type of build, in a screenshot shared by zxc:

cogmind_zxc_late_game_robot_hacker_build_alpha

zxc’s uberhacker loadout.

A +247% to hacking and the ability to hack robots around corners before they even know you’re there? That sounds mighty OP! (zxc used such a build in early 2017 to achieve the highest-ever Cogmind score, a record which still stands to this day)

Certainly it takes skill to set up, but roguelikes should technically get more challenging as a run progresses, not easier, and that’s generally how Cogmind works except when it came to strategies abusing this mechanic :P

Flight hackers had their fun with magic wands for a while, then of course I had to nerf it, explaining the diminishing returns of high-level robot hacking over the length of a run as a result of the system adapting its defenses. That said, even the nerf itself was just a temporary band-aid, because clearly much bigger changes were necessary as part of a new system, and that point would be coming in late Beta given that all the other systems were pretty much done.

And that’s where we are now, adding Cogmind’s last major system (“last” on the FAQ’s main roadmap, but I have more secrets planned, plus of course there’s always this which might happen :D).

I collected and mulled over numerous ideas for how to revamp the robot hacking system for more than a year. There were quite a few reasonable possibilities to think through, but also a lot of potential pitfalls! Devs are unlikely to get a system absolutely perfect the first time, but as long as it has a solid foundation it can be tweaked and expanded without too much trouble if necessary. So this foundation is extra important. I’ve never spent this long designing a single system before (21 hours just designing!), and it went through lots of iterations and refinements (all on paper) as it started to look both relatively balanced and interesting.

It’s also worth pointing out that I’m very glad I didn’t move on this system earlier, or try to have a complete extensive system available from Alpha 1. It would have had a negative, limiting impact on other developments, and much about the current state of Cogmind’s world and content has enabled me to make smarter choices about how to best integrate robot hacking into it all, be it the tactics, strategy, or lore. In short, doing this earlier would’ve meant more wasted effort and less pleasing results.

So what is this new system already…

Principles

While reviewing all the concepts floated over the past year, I identified the major areas that a new robot hacking system would need to address in order to fit in with Cogmind’s many other systems and also be enjoyable but balanced in its own right. The resulting underlying principles of the new hacking system:

  • Decouple machine and robot hacking. Even just machine hacking alone provides a wide range of extremely effective abilities, so there’s no reason to keep both types of hacking under the same umbrella of supporting parts. Thus robot hacking shouldn’t be based on standard hackware, we’ll need something else.
  • Control the snowball effect seen with robot hacking during alpha testing. Sufficient stacking of machine hackware makes pretty much any hack a success, and this is fine for players willing to invest that kind of slot use, but applying the same approach to robots makes it far too easy to eliminate any and all danger by accumulating more and more allies, or at least nearly effortlessly taking out enemies. We’ll need upper limits on what is possible.
  • Remove much of the RNG. Under the old system, anything but a good robot hacking setup is too unreliable--you have to hit with a Datajack, penetrate to their system, and then there’s still the final hack chance to succeed at. RNG works well for machine hacking, but with robots the time element is much more limiting, and the consequences of failures are too dire, especially for bots that are not necessarily set up for combat! Too much RNG in a system like this makes planning much more difficult, thus keeping the RNG would basically work against the combat hacker style itself. Removing the RNG here will be very good for balance.

Compared to the old robot hacking system, overall there are more limiting factors under the new system, but by extension that means it can be more effective! More effective is more interesting, as it also increases the range of possibilities. The goal is not to become OP, it’s to gain tools for solving a subset of unique situations and challenges, and being creative in how these are deployed.

Relay Interface Framework

This is where it all begins, with this machine:

cogmind_RIF_installer

Interfacing with an RIF Installer.

Every garrison will now contain an RIF Installer, and it’s your choice whether to use it and deal with the consequences, and of course take advantage of the benefits! You’ll only have to do it once, and the first garrison appears on -8, so that would be your earliest opportunity, though you can also choose to install at any garrison after that as well. You still get all the other benefits of a garrison on top of that, and there will be another advantage particular to robot hackers that we’ll get to later. Basically I liked the idea pioneered by the original system that robot hacking is linked to garrisons (albeit manifested differently), so the new system really emphasizes that link, and as a better system should also better incentivize the occasional garrison visit!

“RIF” stands for Relay Interface Framework, and with that you’ll gain access to dozens of ways to manipulate other robots via the complex-wide garrison relay network. Like a number of other major strategic decisions, however, this comes with a drawback as it will prevent you from forming certain… alliances. Such is the strategic cost of effectively linking up with 0b10 to facilitate access to their systems. And from this point you can probably infer that the new robot hacking system only works on Unaware! This is just the first of several limiting factors--robot hacking will be quite useful, but not a panacea. It’ll be what an interesting system should be: very effective when used creatively, but also challenging you to create manageable situations to begin with. Unlike the Alpha approach of “it’s an enemy, reboot/assimilate it!!!” there will be many unique encounters and different methods of approaching each. As with other strategies, planning ahead will be very beneficial, and to me that also really fits the theme of a robot hacker, whether a stealth hacker or combat hacker or anything in between.

Planning ahead will also be facilitated by the fact that the new system removes much of the RNG from robot hacking :D

Relay Couplers

The hacking process itself starts similar to how it exists now: Datajacks are still a thing, and you have to both hit the target and penetrate to its system, but after that the processes diverge significantly. Robot hackers will often want to make use of a new type of Hackware dedicated to robot hacking: Relay Couplers. As Hackware these are destroyed on removal in normal fashion, and even have limited uses, but they enable all the best hacks.

cogmind_relay_coupler_grunt_sample

Sample Relay Coupler.

Successfully attaching a Relay Coupler requires that an RIF already be installed, otherwise Couplers fry themselves due to incompatibility.

cogmind_relay_coupler_no_rif_self_destruct

Self-destructing Relay Couplers. Oops, better get that RIF.

Couplers come in a variety of types (there are 12) and must match the target’s class to gain access to high-level hacks for that target. For example a “Relay Coupler [Grunt]” is used to hack Grunts. The one exception is Relay Coupler [NC], which applies to all “non-combat” bots, so that one alone will be much more widely applicable.

The alternative approach would’ve been to have Hackware that enables specific hacks, rather than targeting specific bots, taking the system in a completely different direction, but I believe it’s far more interesting to be able to do almost any kind of hack to a specific kind of robot than the same hack to any robot. This both opens the door to a greater variety of strategy and tactics, and will essentially force that variety in many cases because there’s no one-hack-suits-all ability.

Note that not all hacks require a Coupler, or even an RIF. So Datajacks will still have some robot hacking purpose aside from their other functions. The new PARSE behavior will serve that purpose alone, as it’s free and always works, usable on almost any robot. (I’ll demonstrate that later once it’s implemented.) There are also some cost-free hacks that still require an RIF, for use against non-combat bots.

Most hacks do, however, require a target-appropriate Coupler to pull off. These hacks appear in their own box with a “Coupler” header.

cogmind_robot_hack_ui_description_coupler_related

Robot hacking UI diagram.

The numbers off to the right aren’t the percentages you might expect given the other/previous systems, but are instead static costs for executing each hack. That cost is directly deducted from the Relay Coupler value seen at the top and the hack takes effect, period. So Couplers are expendable, and each has its own “remaining value” before it is depleted. You can carry or attach as many Couplers as you want, and if you have more than one applicable Coupler for the current target robot their values are combined into a new total.

As you can see, the new system is easier to balance by forcing a trade of valuable slot/inventory space for guaranteed hacking effects, whether you want them to play a non-combat role, a supporting role, or a fully confrontational “I own you all” role.

cogmind_robot_hacking_build_sample_couplers

Sample robot hacking build with Datajack and a few active Relay Couplers.

As mentioned before, hack costs are static--there is currently no way to influence the cost via utility or other means, and allowing for the modification of costs would make it easy for robot hacking to creep into OP territory again. Better to have only one variable at play, the Coupler value, which can in some cases be higher than normal so that there’s room to get more out of a single Coupler!

I’ve generally avoided consumables in Cogmind’s design, at least in the traditional sense, but Couplers don’t really fit that sense anyway since they have multiple uses and are also quite flexible in what they can be used to accomplish.

Coupler value is a factor of two elements: its source, and the type of robot it applies to. An individual [Behemoth] Coupler won’t let you do much, though you could combine more than one to do just about anything! A lone [Grunt] Coupler, on the other hand, will last for a lot more hacks, depending on what you want do accomplish. There are five ways to acquire Relay Couplers, two of which I’ll leave for you to discover, but here are some of the main ones:

cogmind_destroy_garrison_relay_for_couplers

Garrison Relay.

Straight to the source! Like previous and current versions of Cogmind in which Garrison Relays play a role in robot hacking (albeit through a different mechanism), so do they under the new system. Venture into a Garrison itself and blow up relays to collect the most valuable Couplers inside.

cogmind_destroy_garrison_access_for_couplers

Garrison Access destruction releasing Relay Couplers. Doing this will likely tempt some players to try out robot hacking ;)

Destroying Garrison Access locations will net you some Couplers as well. They’re partially used and thus not as valuable, but at least they’re fairly easy to acquire!

If lucky you can also find special caches in a Garrison containing lots of high-value Couplers, but don’t count on it :P

UI Upgrades

Manual hacking of robots is already a thing, but it’s a pretty simple system that’s always been used purely as a way to enter random codes you might collect as a result of certain encounters. There’s not much of a need to type out any commands to begin with, considering there’s a complete context menu that appears to recall all the codes, as seen here using the old hack list:

cogmind_robot_hacking_manual_codes

Sample special codes menu during robot manual hacking (old hack options).

But with the number of hacks increasing significantly in Beta 7, some keyboard players might be more likely to prefer entering hacks by typing them out rather than finding them in the menu. Of course no one’s going to bother if you have to type out the entire command, so like manual machine hacking we’ll need to facilitate the process! For this I added both autocompletion and a command buffer:

cogmind_robot_hacking_autocomplete_and_buffer

Robot hacking autocompletion and command buffer demo (parse_system effect at the end is a placeholder for things to come).

It kinda sucked to have to switch the whole manual robot hacking system over from its original simple architecture (which already worked nicely) to one that could support these new features, and many hacks were involved, but hey everything once again works as expected so I won’t complain! QoL FTW!

While at it I also added an advanced option to alter the default cost-wise method of sorting Coupler-based hacks:

cogmind_robot_hack_sorting_options_sample

Two different preferences for sorting Coupler-based hacking options.

Another tweak made even more recently (after all the above media was created :P) was to have the header for any Relay Coupler hacks highlight the remaining value to make that clearer:

cogmind_robot_hacking_relay_coupler_value_highlight

Robot hacking UI with highlighted Coupler value.

I had noticed the potential issue while creating the original mockup weeks before, but didn’t see any immediate fixes so decided to leave it like that for the time being. And of course as soon as I started sharing gifs there was already a comment about that value not being clear enough, so… yeah, I put some more time into finding a decent solution :D

In a departure from the machine hacking standard for the past five years, robot hacking is also getting context help! All listed hacks indicate exactly what they do when accessed via right-click or shift+letter key.

cogmind_robot_hacking_context_help

Sampling context help for robot hacks.

Unlike machine hacking it’s quite important to know precise effects in advance because robot hacking often has real consequences while facing off against enemies (one of the principles discussed earlier with regard to the switch away from a percentage-based system). Obviously it’s also good for learning the mechanics, and having easy direct access to what hacks do so that infrequent players don’t have to remember their effects. It’s possible this feature will also come to machines later (I talked a bit about that dilemma in SITREP #32).

And one last UI feature for completeness sake: Automatic removal of newly-depleted Relay Couplers also comes with its own animation in the parts list.

cogmind_relay_coupler_expended

Relay Coupler depletion.

That about covers the fundamentals of the upcoming robot hacking system. There’s a lot more work to do lore-wise and with regard to other peripheral elements, not to mention putting together all the actual hacks themselves, but the latter is a topic for another day!

I’m pretty confident this system will serve as a good foundation for a new play style, as well as augment existing styles, and do the concept of robot hacking justice even if its finer points require a little tweaking down the line.

So no there will not be a Take 3 ;)

But we do now have a follow-up, an article covering the first 65 hacks available under this system!

Update 2: The RIF system has also itself now been expanded with abilities/upgrades!

Posted in Mechanics | Tagged , , , , , | Leave a comment