createjs

Ludum Dare is great! Not just because it motivates me to create (and finish) a new game, but also because I use it to update Creatine. So, as usual, after the compo I’m releasing another version creatine, now the release 1.0.0!

This version is big. It has a lot of new stuff and a lot of changes for the old features. But before talking about the modifications and additions to the library, let me talk about how I was felling about creatine 0.2…

To be honest, I wasn’t happy about the previous version, I added several classes to handle storage, sound, layout, scenes, among other things. But they weren’t working together, there were some annoying bugs (in special with transitions) and I was spending a good time rewriting the same base structure for new games, over and over.  So I decided to rethink some things: how can I make my development easier and faster? My conclusions and desires after that:

  • I want to use a visual editor to build my scenes, something like Overlap2D or one tool of my own.
  • I need more flexibility for fast prototypes (sometimes I just want to test some idea).
  • Modularity is cool, but is not a great deal. A class that controls all modules would be more useful and would save some time by eliminating the base common structure that I was rewriting every project.
  • I need more fluffy things, more juice, which means that have to be easy to add particles and visual or sound effects to the game.
  • I want to have a physic system and other predefined behaviors easy to use in my games (such as a platform system, or 2d top-down movement and collision system).
  • Other details that I don’t remember right now (it is Sunday 11PM, give me a break!).

With these things in mind, I started to update creatine.

Game

The main addition to creatine is the Game object. The game is now the core of my library, because it is the responsible to create and initialize all game systems. For example: it is the game that creates the canvas element; the game also stores all creatine helpers (now called managers), such as the director (SceneManager), the device,  display and many others.

The game class is based on Phaser core, so if you know Phaser you may find this familiar. A game has 5 states: ”boot”, “preload”, “create”, “update” and “draw”. In the boot state you can initialize 3th-party libraries and some configuration of the engine. In preload, you will set which files should be loaded by the engine and may be show a preload scene. In the create state you will create and initialize all game objects, including scenes and object pools. The update and draw states are the main loop, and are executed every tick. You can use these state by passing functions to the game:

var game = new tine.Game(null, {
  boot    : function() {},
  preload : function() {},
  create  : function() {},
  update  : function() {},
  draw    : function() {}
})

The first argument of the Game class is the configuration object. This could be only an url to a JSON file containing the configuration. Notice that, with this, I will try to keep all engine data-driven, so you will be able to configure everything using this parameter. Right now, it has the following default values:

{
  project          : 'creatine_game',
  width            : 800,
  height           : 600,
  container        : null,
  framerate        : 60,
  background_color : '#000',
  resources        : {
    base_path : './',
    manifest  : []
  }
}

To set configuration you can do:

var game = new tine.Game({framerate:30, width:300, height:500});

or yet:

var game = new tine.Game('myconfig.json')

where ‘myconfig.json’ is the json file containing the configuration values.

Resources and Factories

Creatine now have an interface to PreloadJS (the ResourceManager) and a factory manager. The resource manager helps you to load general assets in a more pleasant way and also helps you to load specific assets (such as spritesheets and audiosprites) in an easier way. For example, now you can set which files you want to preload in the preload state:

var game = new tine.Game(null, {
  preload: function() {
    game.load.image('id', 'src.png');
    game.load.spritesheet('id2', 'src.png', data);
    game.load.json('id3', 'data.json');
    ...
  }
});

Or you could define these assets in the manifest (pretty much like how you do with PreloadJS):

var game = new tine.Game({resources: {
  manifest: [
    {id:'id', src:'src.png'},
    {id:'id2', src:'src.png', data:{stuff here}, type:'spritesheet'},
    ...
  ]
}});

With your stuff loaded, you can create objects easier:

var game = new tine.Game(null, {
  preload: function() { ... },

  create: function() {
    var bitmap = game.create.bitmap('id', {x:100, y:400, regX:'center', regY:'bottom'});
    var sprite = game.create.sprite('id2', 'animation');
    var map = game.create.tilemap('id3');
  }
});

 

Scenes and Transitions

Scenes now have some default method that you should override to use, such as “enter”, “pause”, “resume”… To create a scene, you must define a new class inheriting the scene class, an easy way to do that is by using the new shortcut:

var MyScene = tine._scene({
  initialize: function() { ... },
  enter: function() { ... },
  update: function() { ... },
  ...
});

You can also create your scenes before starting the application and register them to the director, using an unique identifier:

var game = new tine.Game(null, {
  create: function() {
    // Create scenes here
    ...

    // Add your scenes to the director
    game.director.add('menu', new MyMenuScene());
    game.director.add('level', new MyLevelScene());

    // Run a scene
    game.director.replace('menu')
  }
});

Transitions are now working as they should be! You can use any transition in any function (replace, push or pop), repeatedly, or without having to wait the current transition.

Input handlers

We have input now! Keyboard, gamepads, mouse and touch. They don’t work together yet, but they are pretty cool already. Instead of putting code here, I suggest that you take a look into the creatine example folder and into the API documentation.

In the next releases I want to create a common Input or Control object that group all type of inputs together. So instead of checking the state of the keyboard, mouse and touch, you could simply check game.control.isDown(‘action a’) . Moreover, you should be able to redefine the input commands.

Particles!

Particles are so so so so cool! Creatine uses the cocos2d particle style. So if you want to create some fire you do:

var emitter = null;

var game = new tine.Game(null, {
  preload: function() {
    game.load.image('particle', 'assets/particle_red.png');
  },

  create: function() {
    var image = game.create.bitmap('particle', {regX:'center', regY:'center'});
    emitter = new tine.Emitter(image, 500);
    emitter.emitX = 512;
    emitter.emitY = 288;
    emitter.angle = -90;
    emitter.angleVar = 10;
    emitter.speed = 100;
    emitter.speedVar = 20;
    emitter.life = 2000;
    emitter.lifeVar = 500;
    emitter.emissionRate = 150;
    emitter.startScale = 0.3;
    emitter.compositeOperation = 'lighter';
    
    emitter.start(-1);
    game.stage.addChild(emitter);
  },

  update: function() {
    emitter.update(game.time.delta);

    if (game.mouse.isDown(tine.buttons.LEFT)) {
      emitter.emitX = game.mouse.x;
      emitter.emitY = game.mouse.y;
    }
  }

})

Unfortunately, the current particle system has some limitations. For example, it cannot change the particle colors due to performance. It also must be updated manually, sometimes I forget that!

Sounds and Storage

The SoundManager is simpler now, it does not separate music from sound effects, but you still can add sound groups to it. The coolest thing is that sound works together with the StorageManager, so when you change the volume or the mute, the sound manager stores this information locally and you don’t have to worry about that anymore!

Legacy Stuff

Some things will be changed to a better structure, such as the layout managers and the custom display objects. They are still in creatine but they weren’t updated this time.

Moar of Creatine

To now more about new stuffs in creatine, check it out:

You can also contact me for any doubt or suggestion.

Read more

The 32th ludum dare happened this weekend (April 16, 2015), with the theme “unconventional weapon“.

Theme

I have have to say that I hate this theme. Really, there were so many good themes there, why this one could win? Damn you!!!! The theme isn’t an excuse to not do a game, but I spent so much time thinking of what I could do with this… A game not based on fights? Weapon is love? The weapon must be abstract! This is clichê? Oh damn… I finally came up with an idea, after 14 hours (counting sleep time)!

My game entry is about “democracy”, with quotes. The democracy and progress are the weapon of the government in the game, they want you to attack other species in order to “spread democracy and progress through the galaxy”. The player controls the invasions to planets inhabited by bugs with the goal to kill the natives and collect the planet resources.

The game is a very humble tribute to starship troopers (novel by Robert Heinlein and film by Paul Verhoven and Edward Neumeier). I wanted to create, somehow, the sense of order and progress presented by movie.

Development

I always start by the core mechanics because it is the main component of the game – if I can’t find time to make graphics, at least I have a block-based game.

I also always wanted to create a game in a circular world, that was my excuse. I had no idea how to do that, but at is was pretty simple. You have a world centered at (0, 0) with radius (r), than you can set the origin of all objects in the world to (0, r) and only manipulate the rotation to place than in the world.

After the basic world structure, I could drop structures, and these structures could create units. To control the units, I created a behavior tree to control each unit – the first time I really use behavior3js – and a behavior tree to control the bugs strategy. Figure below show these behaviors trees:

Behavior tree for player and enemy units.

Behavior tree for player and enemy units – Click to see in full size.

Behavior tree for the nests, its used to create orders to enemy units

Behavior tree for the nests, its used to create orders to enemy units – Click to see in full size.

Then it came to particles and easing! Man, I love these two. The animation below shows the game at this point:

Sample of democracy

After 28 hours I started to create the sprites and visual things in the world. I was stupid enough to lost time adding some details to sprites that don’t even will see because the sprites are very small (about 20 pixels). I also spend a good time trying to create a futurist screen aspect, which ended up very cool.

I added some scenes, UI and some other effects to the graphics:

sample3

When the clock marked 5 hours to end the competition I started create sounds effects and music. I was desperate because of the time, I still had to adjust the levels of my game and I didn’t know what to do with sounds. At the end it was pretty simple and I didn’t do much, actually recorded some sounds with Audacity, generated most of them in BFXR and generated the music in SoundHelix.

I finished the game in the packing hour, the extra hour after 48, the time to deploy and write about your game.

Summary:

Good stuff:

  • Game finished is always good!
  • I’m using BTs successfully, even to control hundreds of creatures.
  • A circular world (always wanted to try).
  • Visually smooth and lot of cool PARTICLES!!!!!
  • Generative music and sounds worked well.

Bad stuff:

  • Balancing is hard as hell, I couldn’t do that properly.
  • Some details missing, especially the visual feedback when you win the game and the bug when restarting a level before a tween is complete.
  • Isn’t much fun due to balance, few types of units, and few levels.

I’m very critic about my games, I really fell for to not balance properly and create more content to the game, but well, it was made in 48 hours and this time the good stuff was really good! Moreover, this was the most complex and complete game I ever made for LD, it was really hard to do, thus of course some things would be missing.

logo-full

PLAY HERE | LUDUM DARE

Read more

This week we finally had the new release of CreateJS, with a lot of changes, starting with the new site and new visual identity! All libraries (EaselJS, PreloadJS, TweenJS and SoundJS) have major updates that improve performance and the architecture.

Some important updates:

New class model with performance improvements:

In the old CreateJS, attributes were defined in the classes prototypes. By moving the definition from prototype to instance, EaselJS could decreases the canvas update time (by stage.update) in more than 2 times (a 100%-150% improvement).

The tick propagation was also improved with a small change: the tick event is reused for all display objects through the propagation of the tick, i.e., the tick event is instantiated only a single time. By avoiding redundant instantiation, the tick propagation has also an improvement of ~100%.

See:

New inheritance model

The inheritance model were updated following the modification of the class model. Now, if you want to inherit some class in CreateJS, you need to use createjs.extend and createjs.promote.

The createjs.extend function set up the prototype and constructor of a new class. The code is pretty simple:

createjs.extend = function(subclass, superclass) {
    function o() { this.constructor = subclass; }
    o.prototype = superclass.prototype;
    return (subclass.prototype = new o());
}

 and this function must be called right after the creation of the new class constructor.

The createjs.promote back up the superclass methods that were overridden. For example, if you create a FlexibleBitmap inheriting from Bitmap and override the method draw, createjs.promote back up the method bitmap draw by creating an alias Bitmap_draw inside the new FlexibleBitmap.

See:

All classes now implement properties for getters and setters

Some changes are pretty straightforward, e.g., Container.getNumChildren() is now replaced by Container.numChildren; but some names have been updated too, e.g., Ticker.getFPS() is now Ticker.framerate. Using properties instead of getters and setters is a good practice, nice to see that on CreateJS.

See:

Other updates

See https://github.com/CreateJS/EaselJS/blob/master/VERSIONS.txt for a full list of changes.

Read more

CreateJS is a collection of 4 libraries: EaselJS, PreloadJS, SoundJS and TweenJS. EaselJS provides tools to work with the HTML5 canvas; PreloadJS helps you to load the application assets; SoundJS to work with all kind of sounds; and finally, TweenJS provides interpolation functions for easing effects. Together, they allow you to create graphical and interactive applications in an easy and fast manner.

The thing is, the CreateJS suite does not focus on game development, thus, it lacks of important structures and algorithms that helps you to develop games. creatine logo

Having this in mind, I’m developing Creatine, which the first version was published today. Creatine aims to provide all algorithms and structures present in games today and that are not implemented on the CreateJS suite.

Take a look at some examples above, use the following code as base:

<!DOCTYPE html>
<html>
<head>

<script src="http://code.createjs.com/createjs-2013.12.12.min.js"></script>
<script src="creatine-0.1.min.js"></script>

<script>
    var canvas   = null;
    var stage    = null;
    var director = null;

    function init() {
        // code here

        createjs.Ticker.addEventListener('tick', onTick);
    }

    // update stage every tick
    function onTick() {
        stage.update();
    }
</script>
</head>
<body onLoad="init();">

<canvas id="canvas" width="600" height="300">alternate content</canvas>

</body>
</html>

 

Creating some Random Scenes

Let’s create some random scenes using Creatine. First you need to create the base objects:

function init() {
    canvas   = document.getElementById('canvas');
    stage    = new createjs.Stage(canvas);
    director = new creatine.Director(stage);
    
    director.replace(newScene());
    
    createjs.Ticker.addEventListener('tick', onTick);
}

Together with the base object, we create a new scene and add it to director at line 6, and registered 2 events at lines 8 and 9. The line 6 uses the function newScene(), let’s define it:

function getRandomColor() {
    var letters = '0123456789ABCDEF'.split('');
    var color = '#';
    for (var i = 0; i < 6; i++ ) {
        color += letters[Math.round(Math.random() * 15)];
    }
    return color;
}

function createScene() {
    var scene = new creatine.Scene();

    var background = new createjs.Shape();
    background.graphics.beginFill(getRandomColor());
    background.graphics.drawRect(0, 0, canvas.width, canvas.height);
    scene.addChild(background);

    return scene;
}

The createScene function create a new empty scene and add a background with a random color. Now, when the user click on the stage let’s change the scene. Put this on init:

stage.on('stagemousedown', onClick);

And create the function onClick:

function onClick() {
    director.replace(createScene());
}

Done! Now check it out the result:

 Changing Scenes with Effects

To put some effect on the scene transition, just change the onClick function:

director.replace(createScene(), new creatine.transitions.MoveOut(creatine.LEFT));

Resulting on:

Learn More

To see more examples, check it out the official repository: https://github.com/renatopp/creatine

To know more about creatine, take a look at the official page: http://guineashots.com/creatine/

Read more

Beneath The Sea is the game I created to Ludum Dare 29, under the theme “Beneath The Surface“. In this post I will talk a little bit about how was the process to create it, including all the good and the bad things that happened on the way.

icon

The Game

As all Ludum Dare games (in the solo competition), this game was created in 48 hours. Well, actually, it was around 30 for me.

Initially, I was thinking in creating a platform game using physics and tiles. The player would have to run, jump, grab and climb to make his way out from a desolated and unknown cave. I would like to related this “run-away-from-a-dark-cave” game with clinical depression and how hard is to be free from it and how easy it is to fall into this dark cave.

That wasn’t going very well. I’ve implemented the tile system using CreateJS and Tiled and integrate the physics engine. But after 12 hours, I’ve realized that it is pretty hard to create a good platform game. I mean, you have to tweak a lot of variables to make a satisfactory gameplay. To make things worse, my plan also included pixel art, but I also realized that I have no idea how to create pixel art!

So, in half Saturday, I forgot my first idea and had to formulate a plan B. Now, I wanted to create something simple, using only the mouse or a single key button, and I wanted to create something using vector art, because I can do it on Inkscape pretty well.

Last week I was taking a look into the Orisinal games, and I remembered their Silent Water, which is an example of simplicity and which I could based my game.

With these conditions and references, Beneath The Sea came up. I thought in put the player in the charge of a battleship with the task of killing the evil summons of an ancient badass god, holding them as long as he/she can. I know that this isn’t an original idea, but it was what I could do with the 30 remaining hours.

Graphics

I’ve started with the background and the core sprites because I think it is easier to see want you will need in the game – despite the fact, that is so much better to program a game with pretty graphics.

I choose to use only silhouettes to represent the battleship, the bullets and the creeps because it was the easier and faster alternative I could find. Silhouettes also have the advantage to work well with a various graphical styles.

The background was based on classical vector art tutorials, other water games, and sponge bob. If I had more time, I would make the clouds, sun and water animated. I also wanted to put some bubbles and explosion effects, but the time was short.

Programming

Programming Beneath The Sea was pretty easy. I used the CreateJS bundle and some utilities functions (such as scene management, scene transitions, layout management and flexible images) I had here. Notice that, you can only use personal code if you make it public before the beginning of competition.

The code logic is pretty simple: create creeps and make them go toward the surface; create bullets and make them go toward the bottom; check collisions among bullets and creeps; check collisions among the ship and creeps.

Then, after a long night of work, and an exhausting Sunday morning, I had the games mechanics ready to go.

Sounds

Sounds were my biggest problem. I had no previous experience on audio edition or composition and I only know how to use Guitar Pro.

As a priority, I created the main music, which is the most important audio in the game. You can’t put several sound effects without a background music! I’ve based on the Terminator theme, with a lot of bass beats. After trying several instruments, melodies and combinations, my music was complete.

For shoots sounds I’ve used drum beats amplified and equalized on Audacity. To the explosion I’ve recorded the sound me lightening a match, and slowed and equalized it on Audacity. Finally, for the overheat signal I’ve just whistled.

I hate the sound effects I put on Beneath The Sea, I had just a few hours to finish the game and I still needed to adjust the gameplay and the kongregate api.

Gameplay

I’ve tweaked the gameplay as fast I could. I added the overheating system to control the bullet flow and created a mechanism to increase the spawn rate of creeps and weapons relative to the time.

Summary

Based on my experience on this Ludum Dare, I can summarize some important things:

  • Keep It Simple, Stupid! I didn’t followed the KISS principle when I was creating the conception of the game on Friday night. As a result, I’ve lost a lot of precious time.
  • Do what you know. My first plan involved too many technologies, mechanisms and techniques that I am not familiar with. You can’t learn everything in 48 hours.
  • Take a break, periodically. The lack of sleep and fatigue are your enemies. Without sleep, you can’t concentrate very well, so you need to take some breaks periodically to rest a bit.
  • Make TODO lists. Without concentration, you lose efficiency and time, so, make TODO lists to keep tracking what you are doing. Before starting the development of the game, create the TODO of the features. Before starting each feature, make a TODO of the tasks need to complete the feature. Before each task, make a TODO of simple changes and additions to the game.
  • Prioritize the features of your game. You probably won’t finish your game, so, prioritize the core features. If you finish the important parts and got some time, then you can do the fluffy things.

Results

Check it out the screenshots of the game:

You can play Beneath The Sea on kongregate

You can see the entry on Ludum Dare

Read more