top of page
  • paulbaalham

How To Simulate Hacking A Computer?

The resolution mechanism for skill checks (actions) in Spaceship 47 is:

The player knows a target number (for example 7). They then decide how many attributes points they will spend - up to a maximum amount allowed by their character. They then roll an 8 sided dice and add what they rolled to the number of attribute points spent, and if the result is equal to or greater than the target number, then they succeed.

I like this mechanism as it is simple and fast. It gives the payer the interesting choice of how many of their finite attribute points to spend to help them achieve the target number.

However, when I was designing Episode 2 of the game, I needed to simulate the characters hacking a computer. How do I do this? The obvious way to do this is to require X amount of successful checks. This feels boring to me, just repeating the same check over and over until you get enough successes to complete the task. The rest of this blog post is predicated on the fact that the current approach is boring and needs to change. If I am wrong, let me know and I will stick with the current approach.

I want one-off actions and multi-turn tasks to feel different but not to use entirely different mechanisms.

Current Approach

Require X amount of successful checks to complete the task. To hack a computer, the players need three successful skill checks where the number is 6. A player can then make an Intelligence check as an action and each time the player gets 6 or more, they tick off one success. The computer is hacked after three successes.

Pros: Very much the same mechanism as resolving one-off actions, just repeated.

Cons: I think this might be boring; the multi-turn actions and the single check actions would not feel distinct enough.

“Ladder” Approach

Have a target number that is not the target number for a single check, but rather the target number for multiple checks all totalled together. For example, the target number is 22. A player rolls 5 and has spent 2 attribute points, totalling 7. Then a player rolls 7 and has spent 3 attribute points totalling 10, the cumulative total is now 17. This isn’t enough to complete the task. If a player spends 1 attribute point and rolls at least a 4, then the cumulative total is now at least 22, meaning that the players have completed the task.

Pros: Feels slightly different to single-check actions; still uses the mechanism of deciding on how many attribute points to use added to a die roll.

Cons: Feels like a more granular version of the previous resolution mechanism.

Moving Through A Grid

This is similar to the ladder approach mentioned previously, but a grid replaces the ladder. The grid has multiple paths for the player to decide to use and some extra bits that I don’t think complicates the game but creates a bit more design space.

The computer that the players are trying to hack is represented by a grid like below:

An example of the Multi-turn tasks grid

As you can see, there are two coloured paths starting from 0, leading to 32. The players put a cube on 0. Each time they make a check; they move the cube along the path a number of spaces equal to the result of their die roll plus attribute points. Before making a check, the Engineer can switch the cube from its current number to the same number on the other coloured path. There would be special equipment that the players can use on these multi-turn tasks, such as Data Pads for hacking computers; scanners for tracking enemies, etc. These pieces of special equipment would allow the player to use the six-sided blue die in place of the eight-sided die. However, during the movement of the cube when using the six-sided die, a player can move the cube from a blue space to an adjacent blue space even if it is not the next space numerically (in the example above, this would be from 4 to 10, from 8 to 13 and from 20 to 23 on the orange path and from 25 to 20 on the green path).

Pros: Gives the player some choice; it’s a nice visual representation of what’s going on; Introduces a little more design space with items that can help.

Cons: Might still be boring. I would need to handle the fact that with an eight-sided die and 0 to 3 attribute points being added, that the range of numbers for each roll is quite large.

Replacing the Current Core Mechanism

I have been playing the video game Mass Effect lately and the way it does hacking tasks is you have an arrow that you need to move through concentric rings until you get to the middle. However, each circle revolves (I believe at different speeds) and each circle contains blocks. If the arrow touches a block, then you have to start again. In addition to all of that, there is a time pressure as well! You need to get your arrow to the centre before the timer runs out. You can see a set up below:

Image taken from Mass Effect Wiki:

This got me thinking about how you could use cards to achieve a similar effect. Instead of using dice to resolve actions, I could use cards. I have been loathe to use cards to resolve checks, because I didn’t want people to think I was copying Gloomhaven and also I think people like rolling dice.

In the system I came up with, each player has a deck of cards. Each card would have one or more arrows pointing against the long edge of the card. We can see two examples below:

Two examples of cards used by the players in the "arrow and gap mechanism"

Enemies would have blocks along the edges of their card, with each edge representing a different defence. An example is shown below:

An example of a enemy card using the "arrows and gaps" mechanism

When the player attacks an enemy, the player would draw a card and compare it to the edge of the enemy card. The player has succeeded if any of the arrows points at a gap. Actions on the map that characters can perform (like trying to spot something in the distance), would have blocks on the edge of particular section where the action takes place.

that's all well and good for single turn checks, but what about multi-turn checks? I thought of a grid like this:

An example of a Multi-turn Task grid using the "Arrows and Gaps" mechanism

The player draws a card from their deck and as was the case with attacking the enemies, if at least one arrow is pointing at a gap, then the player has succeeded. However, a success here just means the player advances one level up the grid.

The player can choose to bank their current progress or pull another card. If no arrows are pointing at gaps, the player loses all of their progress. The next time a player attempts it, they will start from the last banked position or if there have been no banked positions, then they start from the beginning.

One advantage that this card system has over the current dice-driven approach is that it can solve another problem I have been having - handling attacks that can target multiple enemies. Each card could have multiple arrows on, each arrow designated to a particular enemy. You can see this in the image below:

An example of a card for the Engineer which resolves multi-target attacks using the "Arrows and Gaps" mechanism

Pros: It has a more visual representation of whether you hit something; the multi-turn action resolution has a certain push-your-luck element that appeals to me.

Cons: It would mean changing the core resolution mechanism of the game and I really should be at the point now where things are being locked down.

30 views0 comments


bottom of page