TIS-100 (PC)

TIS-100 (“Tessellated Intelligence System”), from Zachtronics, is a programming puzzle game where you use simplified assembly language to repair segments of a computer. According to the Steam Store page: “It’s the assembly language programming game you never asked for!” Going into this game, I wasn’t sure who the intended audience was, but read on to find out this developer’s perspective.

Storyline

Let’s just get it out of the way and say the storyline, in my opinion, is kind of lame. Honestly, I thought the game startup was the best part, and most people wouldn’t have cared about that. In the startup, your computer is now the TIS-100 booting up, and it encounters a problem. You then have to write code to repair the corrupted segments. The only plot after that point is that in most levels, you’ll encounter nodes (more on what this is later) with communication errors that can’t be used but contain a message in a microcode dump. The messages are from someone who got ahold of this computer, and as he discovers the power of this device, you can see him slowly unravel into a crazy, glued-to-the-screen-24/7 hermit. The messages are annoyingly filled with random characters that make it hard to read and give you a slight push towards getting to the last level where you’re supposed to discover some secret. The ending was disappointing as well. This thing that you’ve been waiting for happens and it barely lasts for a second. I could barely make out what I was seeing. I went and looked it up, and I wasn’t having any revelations or feeling any excitement.

Gameplay

Okay, now that the storyline is out of the way, let’s talk gameplay. Each level essentially looks the same: you’ll see the instructions, the TIS-100’s nodes, the skeleton of where your code will go, some inputs that you’ll get, and some buttons for running and debugging your program. What is unique about the TIS-100 is that it is highly parallelized, with each of its individual processors being very simple. Being parallelized means that each of the processors (in the game, called “nodes” because it includes its ports) can start running code line by line on its own, separately from the others.

Each node on the screen contains space for you to type code, two registers, and a few stats that are relevant when running your program. A register is just a fast memory location in the node, where you can store a single number. Each node also has in and out ports connected to the other nodes around it, which allows you to send numbers around to other nodes. The catch with the two registers is that only one is addressable and can have mathematical operations performed on it, while the other cannot be directly accessed by the code. If you want to get to it, you need to swap it with the number in the ACC register, the one that’s addressable. Then to put the number back you’ll need to swap it back with the SWP instruction or use SAV to write over (and lose) the other number that is now in it. This is made into a bigger deal by the fact that that space for you to write your code is really small. Whatever space you see on the screen is what you get. No scrolling around to get to more blank space in width or height. So let’s say I’ve got two numbers and I want to add one to one of them and I want to add two to the other one. If using only one node, you would need to do: ADD 1, SWP, ADD 2.  And let’s say I need to get to the first number later on. That adds another SWP. That’s 4 lines used (you can’t put multiple opcodes on the same line). You only have 15 lines to work with per node.

Now, I realize I haven’t really given an introduction to programming in general, but I jumped (See what I did there? No? There is an instruction JMP for “jump”) right into it because each line of code starts with an instruction which literally just tells the node what to do when it gets to it. That is followed by one or two operands that give needed information. So MOV 3, ACC would move the number three into the ACC register. ADD 1 would make the number three become four. MOV ACC, DOWN would pass the number four down to the node below it for it to use, but only when that node gets to a line such as MOV UP, ACC which moves it in. See? Not so bad. You got it! There are other instructions, like conditionals which are used for comparisons. Beyond that, there’s really not much else because the instruction set for this game is small and simple, which is good because it opens it up more to beginners.

The game also introduces what they call a stack node about halfway through the levels. A stack is a common data structure in the real world. Think of it like those spring- loaded stacks of plates you’d find at a cafeteria, but with numbers or other data. Whatever you put on the stack most recently is at the top, and that’s the only thing you have access to until you take it off to get to the next one. This was a nice mechanism to mix things up and to add functionality. Each stack could hold quite a few numbers, which was very welcome since normal nodes can only hold two each.

You may be wondering what tasks the game actually presents for you to accomplish with your highly parallelized computer (that you “didn’t ask for”). According to the TIS-100 Reference Manual, “The Tessellated Intelligence System is ideal for applications requiring complex data stream processing, such as automated financial trading, bulk data collection, and civilian behavioral analysis.” Ha. That’s not quite what you do. When it comes to writing in assembly code, the small victories are big. Here is a sampling of the segments’ titles: “Signal Amplifier”, “Sequence Peak Detector”, “Signal Pattern Detector”, “Sequence Generator”, “Sequence Reverser”, and “Image Test Pattern 1”. Though they sound fancy, you’re really just producing some output based on an input. “Sequence Reverser” is self explanatory.  “Signal Amplifier” has you multiply each input by 2. “Signal Pattern Detector” has you output a 1 instead of a 0 when the sequence 0, 0, 0 is detected.

“Image Pattern Test 1” is one of a few segments where you’re tasked with getting a specified pixel pattern to output onto a little screen. These were actually some of my favorite levels. Since I am a programmer, you might think that I would find the solving of a problem to be the most rewarding part. While, I have a growing appreciation for this, I really care mostly about the end product. I’m not one to sit and do Sudoku puzzles because I don’t really find a bunch of numbers on the page at the end to be too rewarding. And I’m not saying that everyone should think that, but it’s the way I operate. I would probably prefer a picture puzzle because of the more positive visual feedback. So that’s why I enjoyed these imaging levels. I also liked that it brought variety to the game and I was able to program in a bit of a different style.

When you run your solution, you can run it at normal or fast speed. Sometimes when I knew I was about to succeed, I would let it go at the normal speed to watch my fine tuned machine work away which was fairly satisfying. When you run your code and achieve the desired output, you get some statistics shown that are meant to encourage you to optimize your code. The statistics are cycle count, node count, and instruction count. They’re shown on a histogram so you can compare your solution relative to others. Sometimes I did go for optimizing a bit.

Technical Details and Graphics

Earlier, I mentioned that there is a reference manual. This is your way of learning everything you need to know to play the game, since there are no tutorials or in-game hints. When I tried to open itthis for the first time, I got an app crash and could never open it. “Wow,” I thought, “they made this so well that you even have to figure out how to get to the instructions.” I was actually a little excited that this might be the case and also frustrated that I couldn’t see the instructions. Conveniently, I have Visual Studio and had the option to click to debug the process in question. I don’t remember what the exception was but there was one. Ultimately, I just went into the Program Files and found the pdf and opened it. And some time later, this bug (it actually was a bug) was fixed. Since this issue is fixed, there are really no other issues to complain about. Bugs happen, and this one was fixed, but I thought I’d share the fun story. It got me thinking about how the developers used higher-level code to implement assembly code, which actually sounds pretty fun to me.

The graphics are what you’d expect. Most things are black and white and the only colored things are nodes with communication errors and colors in the images used in the imaging levels. Given the low level nature of assembly code and theme of the game, I think this is the best choice, despite what I said about wanting nice visual feedback.


Summary

TIS-100 gets you to think in a different way than you would in usual programming. Multi-threaded programming is real-world, but it’s not normal that you’d have to write so many tightly coupled little segments of code all within one field of view. The limited code space and storage of each node forces you to be resourceful. You quickly learn how to delegate things like, “Hey, other node, take this number and hand it back to me in just a second”. And how to break up a task into its tiniest little components. This game presented some positive challenges.

But overall, I thought this game was just okay. My thing is that I already solve problems by writing code all day (which I do enjoy!) and in order to make this into a really fun game, there needs to be some cinematic effect, some plot – something that would just not happen in real life! And TIS-100 did not do that for me. As I’ve expressed though, it had its satisfying moments and captured my general interest. Surprisingly, when I unlocked the final segment I was expecting to see a task waiting for me that was going to appear insane and insurmountable. On the contrary, I found the final level to be one of the easiest to beat. I guess that’s okay? It saved me time at least. Maybe a proportionally difficult, but doable task would be more appropriate. I will admit that I looked up the solution to just one out of all the levels that I beat. I wanted to see what was in that last segment. Honestly, I was glad that I looked it up because it got me reading optimization tips on Reddit and I actually learned a very useful way to use one of the instructions that I had not thought of before by looking at a solution. Which again brings me to the point that this game has no tutorial or examples. I had no problem reading through the documentation to learn; I do that all the time. But I really think that putting in just one or two examples in the game would go a long way towards making this game more playable for a wider audience. I actually would recommend this game for someone interested in learning assembly language because all the basic instructions are there. I wouldn’t recommend it for someone looking for a highly engaging plot or a really exciting game. (Ed Lynch)


Comments:
Your comment has been saved!!!
The Captcha element applies the Captcha validation, which uses reCaptcha's anti-bot service to reduce spam submissions.

2016-09-09 20:46:57... - ondrast

sgfswzrdfc


2016-09-09 20:39:48... - ondrast

supr


2015-12-08 13:23:11... - Mézà

super


2015-11-11 17:32:25... - TTGHGamer

:D


TIS-100 Screenshots
TIS-100 Screenshots
TIS-100 Screenshots
TIS-100 Screenshots
TIS-100 Screenshots
TIS-100 Screenshots
TIS-100 Screenshots
TIS-100 Screenshots
TIS-100 Screenshots
TIS-100 Screenshots
TIS-100 Screenshots
TIS-100 Screenshots
TIS-100 Screenshots