The Cuttlefish Engine has been designed from the start with multiple devices in mind. If a given feature works in the simulator, it works on every single device the engine supports. Our methodology is to keep it clean and simple – you won’t find a whole bunch of esoteric features that look awesome but only work on one phone (which nobody owns). Instead, you’ll find an engine with the tools you need to create anything, and the simplicity to create it fast. And, if you really need that one awesome feature for that one phone, the engine has extensive customization and augmentation avenues.
Keep in mind one of Cuttlefish’s maxims – creating hard-core games is great, if you’re a triple A, multi-million dollar studio. In mobile games, the spoils go to the close-knit team building simple but great games that work on a huge variety of phones. Cuttlefish’s lead architect is an IGF finalist (class of 2000) and a long-time professional console game developer, so you get the engine that brings you the pro toolset that you need.
With that in mind, here’s what Cuttlefish is all about.
We’ve integrated the box2D physics engine, which supports everything you need to do physics based games. Rigid bodies, joints, engines, you name it – more information is available on the Box2D site.
WiFi support for low-latency multiplayer games (up to 8 players) is included. By setting some parameters in the designer, you can easily create games in which each player has their own view of your game world, as well as games where everyone sees the same playfield (think Smash Bros). Multiplayer can be simulated in the designer, complete with artifical latency and bandwidth controls, and you can use Bluetooth and 3G connectivity for high-latency (i.e. turn-based) games. We’ve got play by email on our radar.
Layered, Tiled Worlds
Take Photoshop and cross it with your favorite tile editor. Cuttlefish’s tile-based editor is multi-layer, and layers can be manipulated at runtime via Cuttlescript (scroll down for more info about Cuttlescript). Got a secret passage that opens when the user steps on a tile? Put a trigger over that tile, add an action to it that says “hide this tile layer” and you’re done. Tiles can have polygonal physics-based collision, so you can create slope tiles and see your physics objects bounce off them realistically. Beyond device memory, there is no limit to the size of a tile layer, or the number of number of layers you have on a map, and it’s trivial for you to set up parallax scrolling effects by making layers scroll at different speeds relative to each other.
Tile Brush and Landscape Functionality
Cuttlefish’s tile editor is not MS paint for tiles; it’s not like we said, OK, here’s your tile pencil, go for it. We know that to create compelling maps, you need advanced tools – so in the designer, you can define tile brushes to automatically sprinkle random tiles across an area. You can create landscape definitions to automatically place the correct “transition tiles” between land and water (or any number of terrains you define). You can bulk select tiles using rectangular or circular lassos. You can set up hotkeys to switch tiles and tools. All of this towards the goal of making tile maps less about mouse clicking and more about creativity. Also, your game is instantly preview-able from within our built-in simulator, so playtesting your levels is cake.
What game would be complete without particles? We’ve got an integrated particle editor that supports multiple emitters, script triggers, different blend modes, and crazy-fast rendering. Particle effects are visible as you place objects on your tile map, or can be previewed atop any image file you want, so you can tweak your effects in their natural habitat.
Animations and Blend Modes
Easily import single animation frames or entire sprite sheets in any popular image format (png, tga, animated gif, and more). We’ve got realtime reload of PSD files, so if you work in photoshop, all you do is save your PSD, then alt+tab back over to the Designer and see your changes instantly. Additive blending, images with alpha channels, and all the other usual suspects are supported.
In the engine, you define a “body” for each of the objects used in your game. For example, you might have an enemy made up of a couple of physics boxes attached together with a spring. To each box, any number of particle systems or animations can be attached. The Designer gives you the tools you need to intuitively create and edit complex objects, and game objects can inherit from each other so you can share bodies.
Every Cuttlefish game object is fully state aware. That means for the same event (collide with player, say), there can be multiple responses. Say you’re scripting Pac-Man’s ghosts. In the “normal” state, the collide event kills the player, but in the “power pellet state” the ghost is blue, and a collision means the player eats the ghost. Defining states and state transitions is done in the designer UI.
Scripting in Cuttlefish is a bit of a misnomer. Because even the fastest scripting language runs several orders of magnitude slower than native code, there is no interpreted code on the phone, ever. At build time the engine converts script into high-performance native code. This gives you the best of both worlds – an intuitive scripting language so you can build game logic fast, and also, tons of frames per second on the phone. Cuttlefish supports event-based scripting (say, script that runs in response to a player stepping on a tile, or colliding with a physics object), as well as what the game industry calls “latent actions.”
A common feature of $600,000 engines, like Unreal, but we’ve got ’em too. Latent actions make writing enemy behaviors child’s play. Say you want an enemy to walk back and forth on the screen. Programmers are used to writing tick code, running several times a second, that says, “Am I walking towards point A? If so, is point A to the left of me? If so, walk left. Am I at the x-coordinate for point A? If so, switch directions.” This way of thinking is unnatural. So instead, in Cuttlefish, your enemy code looks like this: “Walk To Point A. Walk To Point B. Loop.” Through the designer, you create an easy to understand list of actions – actions that may take several ticks each to complete. You write code sequentially, the engine takes care of converting that into a tick function. And if things aren’t working as you expect, the Designer provides a fully integrated action debugger.
Officially, The Cuttlefish engine uses Cuttlescript as its scripting language. Beneath every latent action, Cuttlescript is there (but you don’t have to be). It looks very similar to C#, and is as powerful as you need without being irritatingly different than every other language. The syntax is exactly the same as in C# or C++, and we give you a fully integrated code editor complete with syntax highlighting and drop-down auto-complete (“Intellisense”) features.
Are you a programmer? Cool, then hey, not only can you write your own latent actions and Tick() functions in Cuttlescript, we also let you inject your own objects – we compile the code you’ve written straight into the script layer, so your hand-written native code is callable from Cuttlescript. Native functions can (and usually, must) have completely different code between devices (usually in different languages, for example Java and ObjC). You can organize your native code into objects, and bundle up a bunch of objects into a package, and can easily reference that package in any number of games you make.
Music and sound effects assets are straightforward to use, memory-efficient, and fast. A sound effect exists as a cue, and that cue can contain a single WAV file, or multiple WAVs from which it chooses randomly. Other basic parameters are supported, including seperation of sound effects and music channels (so that your players can listen to their own MP3s and still hear sounds from your game).
… and more!
This list is always growing, not only in functionality but also in the number of devices supported!