Trabant

Single keystroke to interact with your idea.

Trabant is a rapid game prototyping engine that keeps you focused on a single task: testing your mechanic and controls. It is absolutely vital to prototype your idea before going all-in, since creating games are extremely time-consuming and, more importantly, games are often found to be boring at a late stage of development.

In Trabant prototyping everything is code. You'll be stunned by how little effort is required to create a prototype. First off, look at the diversity of some sample prototypes:

Agility.

Easily the best thing about Trabant is the development cycle is quick. And with a short development cycle you'll automatically keep exploring rather than refining, which is important for ideas to blossom.

This insightful graphic was found on Intercom's blog. Ponder the wisdom!

Instead of building a single prototype, build five! Don't try to keep some goal or plan in mind, simply build as fast and diverse as you can and let evolution do the work for you.

One of the the ways Trabant will let you accomplish this high speed of development is with a small but elegant API. With Trabant you'll move faster than a great cat, with the power of a charging bull elephant.

No dignity.

Polishing a turd will get you dirty fingers at best and a lousy game at third best. Trabant is visually repelling by design. Your game mechanic – the core of your gameplay – can't hide behind fancy rendering or ambiance. Either it's good. Or it's awful. No amount of obfuscation is going to hide it from your players, and you shouldn't hide it from yourself either.

Models are built in source code using ascii art, which is a quick and sensationally capable way of visualizing your idea. Your intentions are apparent not only to yourself now, but also to yourself tomorrow and to a collaborator in a year.

The asciifant (right) might not fly in Serengeti, but the spaceship (left) will. But none of this matters. Your prototype is never going to be run on in Serengeti. Adjust your mindset accordingly.

Take for instance casual games like Limbo or Badland. They are not fun to play due to their atmosphere, they are fun to play due to the game mechanic. This fact is even more obvious in classic games from the 80'ies and 90'ies. Ambiance is bonus, not core. Trabant strips of you of your dignity and leaves you with the all-important core laid bare.

2D, 3D, physics.

Trabant renders in 3D, but if you just want to use two dimensions, you simply set one axis to zero and you have 2D. Physics is built-in and active by default, but if you prefer you can move around static objects yourself. Or you can simply disable collision detection if you want to have your own interaction code but still keep the built-in support for velocity, acceleration, actuators and joints.

Cuboids and spheres have come to rest. A floor is simply created with a static=True flag.

Touch.

Naturally you want to develop for touch devices, just not on them. And while Trabant for iOS has a code editor, I recommend you use a proper one, on a computer. With the press of a key you can synchronize your source code between the computer and the iOS device, and during normal development you'll be running your prototype code on the computer while the remote simulator shows the result on the iOS device (again with a single keypress). All you need to do on the first run is to enter the name of the device in your computer and set the "allow synchronize" switch to on in the app.

The synchronization feature enables you to upload your code to the iPhone or iPad, fiddle with it in the cafeteria, then synchronize again to fetch your updates back into the computer when you come back from your despicable latte macchiato.

Eliminate risk, planning, preparations.

With Trabant you build a throwaway prototype. The outcome is the idea, not the code, and the technical risk is zero. It's not even possible to be an architect astronaut, just a doer. Each prototype is made singlehandedly so coordination goes out the window too. Your prototype is done before the toxic planning meeting has even started.

The perhaps most impressive thing about Trabant is that it is only code. Ignore sound effects; don't do textures; models not necessary. You just write a little bit of code and you're done. In need a complex model? –Use ascii art to create it! From the first line of code you write you can test it. The only risks you'll be able to take are creative risks. And that's a good thing.

How to implement.

You build your prototype in Python code, but fret not ye of little Python faith! With Trabant it's very simple. You only need a few lines to create a basic object.

from trabant import *
create_box()

A one meter cube is created at origin, and it immediately start falling since gravity is 9.8 m/s2 downwards by default. Those two lines is the complete program — no setup is necessary. You might have noticed that the program terminates right away since there is no loop.

So let's look at a slightly more sophisticated example. Here we create a space ship out of ascii art and a main loop around keyboard controls:

from trabant import *

shipmodel = r'''
 \
<XXX>
 /
'''
gravity((0,0,0))
ship = create_ascii_object(shipmodel, col='#888')

while loop():
    move_direction = keydir()*0.1
    ship.pos(ship.pos() + move_direction)

First we declare the ascii model, to the right seen as it is displayed in the simulator. Then gravity is set to zero in all directions. (Things don't fall down in outer space, if we are to believe the motion picture industry.) In the main loop we take the keyboard direction, as given by the arrow keys or WASD, and use that to move the ship.[1]

The function pos() is called twice in the last line, which obviously doubles as both a getter and a setter of the position (depending on whether a parameter is supplied). The same style of coding allow easy manipulation of velocity, angular velocity, orientation, color and so forth.

Trabant comes with a bunch of sample prototypes which can help you dive right in. Samples includes Minecraft, Angry Birds, Pac-Man, Slime Volleyball, Space Invaders, Candy Crush and two dozen others. The samples are remarkably comprehensible as they each are written in only a couple of pages of easy-to-read code. (Btw: the polaroids captions at the top show pages of code.)

One important thing to note is that Trabant uses a right-handed coordinate system where positive X as expected is to the right, but positive Y is inward and positive Z is upward. This is what most mathematicians and physicists use, while most programmers are used to a left-handed coordinate system for historical reasons. For brevity this was not included in the example above, but causes the up-arrow key on the keyboard to move the spaceship inward. You can fix this by swapping Y and Z on the row before setting the position:
```
move_direction.y, move_direction.z = move_direction.z, move_direction.y
```

Distribution of ideas.

You can easily share your prototype with colleagues and friends: a click of the mouse exports your prototype to a standalone executable binary. Or create a gist for the source code if the recipient is also using Trabant.