Development Update: Simplifying Circuitry

This is the first in a series of development updates that I’m going to be posting roughly monthly to keep everyone apprised on the game’s progress, talk openly about how I’m trying to solve game design problems as a first time game designer, and hopefully elicit some feedback and excitement for things to come. For this first entry, I want to talk about some new circuit components I’ve added to not only expand the types of puzzles in the game, but also to make the puzzles more interactive, more accessible, and simpler to design – without sacrificing challenge. I’m also going to talk about circuits and logic on a more rudimentary level in this post in the hopes that it will help people (who might be unfamiliar with things like logic circuits) understand and feel comfortable with The Technician’s gameplay.

The Basics

If you’ve watched the announce trailer for The Technician, then you’ve seen a few of the basic components that circuit puzzles can be made out of. Power sources, switches, buttons, wires, logic gates like AND and OR, and so on. All of these behave like relatively ‘traditional’ bits of circuitry: they read an “on” signal from their inputs (or don’t), maybe run some rudimentary logic, and send an “on” signal (or don’t) to their outputs. On some level, that’s all a logic circuit really needs; basic gates and the like will let you build all kinds of circuits provided you have the patience and board space. The problem is that complicated circuits are, obviously, complicated. Not everyone is the type of nerd that finds an endless field of boolean gates appealing, either. The bad news is that you’ll probably have to be at least a little bit that kind of nerd to find The Technician appealing, but the good news is that since this isn’t a “real” circuit simulator, we can fudge a lot of things to make complicated circuits simpler, allow for a wider range of interactions, and make it all around more accessible. At least, that’s my hope! Let’s take a look at some specific things that I’m trying in order to accomplish this.


This update is all about numbers. Traditional circuitry represents numbers by breaking them down into a series of those “on” and “off” signals. I don’t want to get into a primer on binary numbers here, so let’s just say that this can quickly get very complicated, despite how much your friend with the Computer Science degree might insist otherwise. However, since we’re fudging things, our circuits don’t have to bother with this; they can just send a number directly. When you see a lit wire in The Technician, that “on” signal actually contains data. In this case, that data is a number ranging from 1 to 255, with an “off” signal having a value of 0. Easy! But what do we do with these numbers now that they’re flying around? Let’s start by just saving them.


If you wanted to build a circuit that stored a numeric value, you could do so with the basic logic gates that I mentioned earlier. This wouldn’t be easy though, and for the player solving this type of puzzle it would be a harrowing experience, at best. Instead, let’s just cheat some more and use these:

A Register

This is a basic register. Registers can receive information on their ‘data’ input, save it when they receive a ‘load’ signal, and continue to send it to their output until they receive a ‘clear.’ They come in a variety of flavors, too. Here’s a quick look at the standard, secure, and readable registers:


The standard register has a display that handily shows whatever value it is currently holding. Very convenient for the endeavoring technician. Display register


A secure register is just like a standard one, but decidedly less convenient for would-be hackers. Without a display, the number stored in these isn’t plainly visible and can only be determined by figuring out the source or analyzing the output. Secure register


Some secure registers aren’t completely secure. These models have ‘maintenance’ ports that a properly-equipped technician can exploit to read the values stored inside. Readable register

Now in addition to being able to move numbers from place to place, we can also hold on to them for future use. So what kind of uses do we have? Let’s start with the obvious one: math!


An Arithmetic Logic Unit, or ALU, is kind of like a calculator without a keypad. In keeping with my goal to make things simpler, ALUs in The Technician are simplified versions of the “real” ones. ALUs take up to three inputs (two operands and an operation), do whatever math their current operation dictates, and output the result. To further simplify, these ALUs also have a wider array of more complex operations than are traditionally present. I won’t list all of them here, but let’s take a look at a few notable ones:

Addition (+)

Doesn’t get much simpler than this; the ALU reads inputs A and B, and outputs A+B. It may be worth noting that numeric values in The Technician only range from 0 to 255, so any operation that results in a value outside of these ranges “wraps around” to the other end of the range. This means 255+1=0, 0-1=255, 255+10=9, etc. ALU Addition

Increment (A+1)

ALUs don’t necessarily need both inputs to function. With the increment (or decrement) function, the ALU reads only one input, adds 1 to it, and send the output. When set up in a ‘loop’ with itself, this can effectively turn the ALU into a counter. ALU Increment

Equality (=)

When set to this operation, an ALU outputs the value that it reads from input A, but when it equals the value it reads from input B. In the case where B is 0, the ALU outputs the maximum value (255) when A is also 0. ALU Equals

Where does all this lead?

These are some basic building blocks that open up a whole lot of potential complexity for circuits, which means that the technician’s job can be made a whole lot harder. It also, I hope, makes it understanding the technician’s job a whole lot easier. Now there are secret numbers need to be ferreted out, values that need to be hacked and changed, and tricky new configurations of logic to be deciphered; not to mention the fact that trying to do math in your head while you’re in a gunfight can be a bit challenging. This also means that the technician now needs tools that can read numbers from components, as well tools for injecting or overwriting values in the circuitry.

I’m hoping this continues to lead to more challenging and fun variations of gameplay in The Technician so keep an eye out for more updates soon and in the meantime leave a comment to let me know what you think!

One Reply to “Development Update: Simplifying Circuitry”

  1. Oooo, this seems like a really good addition! Now I can stare at a circuit thinking “well if I vs. Just get a 64 to HERE or a 7 THERE then I’ve got this!” instead of purely staring at it thinking “well a true on this line means Not here but that’s an OR so…” and that seems like a solid bit of variety. Nice job making the design of the ALUs clear too.

Comments are closed.