Subscribe to GameFromScratch on YouTube Support GameFromScratch on Patreon
22. October 2015


As part of the ongoing Tiled Map Editor tutorial this part looks at using Object Layers, which can be used to interface your tiled map with your games code.  This particular example includes the code using TypeScript and the Phaser game library.  If you need more information on Phaser I’ve done a tutorial series here.


The video of this tutorial is available here or embedded below.


The Code



<!DOCTYPE html>

<html lang="en">
    <meta charset="utf-8" />
    <title>Hello Phaser</title>
    <link rel="stylesheet" href="app.css" type="text/css" />
    <script src="phaser.js"></script>
    <script src="app.js"></script>
    <div id="content"></div>


/// <reference path="phaser.d.ts"/>

class ObjectEntity {
    height: number;
    name: string;
    properties: any;
    rectange: boolean;
    rotation: number;
    type: string;
    visible: boolean;
    width: number;
    x: number;
    y: number;

class SimpleGame {
    game: Phaser.Game;
    map: Phaser.Tilemap;
    layer: Phaser.TilemapLayer;
    player: Phaser.Sprite;
    winZone: Phaser.Rectangle;

    constructor() { = new Phaser.Game(640, 480, Phaser.AUTO, 'content', {
            create: this.create, preload:
            this.preload, update: this.update, render: this.render
    preload() {"ItsTheMap", "newMap.json", null, Phaser.Tilemap.TILED_JSON);
        var img ="HF2_A2", "HF2_A2.png");"Decepticon", "decepticonLarge.png");
    update() {

        if (this.winZone.contains(this.player.x + this.player.width/2,this.player.y + this.player.height/2))
            alert("You Win!");

    render() {
    create() { ="ItsTheMap", 32, 32, 64, 32);"HF2_A2","HF2_A2");"Background").resizeWorld();

        this.player = new Phaser.Sprite(, 0, 0, "Decepticon");
        this.player.width = 64;
        this.player.height = 64;, 1);;

        var something =["GameObjects"][0];
        var start = <ObjectEntity>["GameObjects"][0];
        var end = <ObjectEntity>["GameObjects"][1];

        this.winZone = new Phaser.Rectangle(end.x, end.y, end.width, end.height);

        this.player.position.set(start.x, start.y); => {
            this.player.position.add(-32, 0);
        }); => {
            this.player.position.add(32, 0);
        }); => {
        }); => {
            this.player.position.add(0, 32);

window.onload = () => {
    var game = new SimpleGame();



The Video


Art Design Programming

14. October 2015


Tiled is a popular open source map editor for creating 2D maps using tiled graphics.  I have used Tiled in several previous tutorials and no doubt will be using Tiled in several future series, so instead of covering it partially over and over again, I decided to do a Tiled video tutorial series that I will simply link to.  This is that tutorial series.  As I add new tutorials I will link them below.


Right now the contents consist of:


An earlier text based introduction to Tiled from GameFromScratch is available here.

If you are interested in learning out to make isometric tiles in Blender check this tutorial.


Previous tutorials that have used Tiled include:


Direct version of the videos embedded below:

Art Programming

13. August 2015


Paradox ships with a full 3D editor named Paradox Studio.  In this tutorial we are going to take a look at what it can do and how it works. 


Once again, there is an HD video version of this tutorial available.


Paradox Studio Introduction


This is Paradox Studio:



This is where you can import assets, create entities, add components and instantiate them into scenes.  In a nutshell, it’s where you can visually compose the elements of your game.  Using Studio is strictly optional ( as is using Visual Studio ) but it can make your life a great deal simpler.


The majority of panels are configurable, can be minimized or re-docked in whatever pattern you prefer:



I am going to cover each panel one at a time.


Scene Graph


This is where you compose the entities that make up your game.  All game elements are entities, which in turn are containers for components, that can themselves consume or use assets.  Don’t worry, we will cover this in more detail later.  Just think of it this way… the Scene Graph is the stuff that composes your world, and all the “stuff” in your game is ultimately an Entity.  In the above screen shot, you can see the default scene created when you create a new project, it consists of a Scene that has a Sphere(Mesh), Ground(Mesh), Camera(Camera), Directional Light(Light) and Skybox(Light) entities.


If you create multiple scenes (I’ll show you how shortly), they will appear across the top in tab form.



This is only panel that cannot be minimized or moved, although it can be resized.  I suppose I should point out that the Scenegraph and 3D view are actually the same window, but they serve very different functions, so I will treat them as a separate windows for this tutorial.


You can create new entities using the imageicon, which will drop down the following menu:



Remember, an Entity is simply a container for Components, all of which have a default component called Transform, that allows them to be positioned in the world.  This means you can create the equivalent of a Point light entity by creating an Empty entity and adding a Light component to it.  We will see the component options later on.  When you create a new entity, it will be created (and automatically selected) in the 3D view:



Clicking the small magnifying glass beside the entity will automatically focus the 3D view on that entity, zooming in on it.


One last important concept to understand is parenting.  If you create a new entity with an entity selected, the new entity will be parented to the selected entity, like so:



The newly created light will now inherit transforms applied to it’s parent, but can also be transformed independently.  The inheritance only goes down the genealogy, not up.



Solution Explorer



The ultimate file format for a Paradox project is actually an sln file, in other words, a Visual Studio Solution file.  On top of that, Paradox provides a format for bundling codes and assets together, the package ( pdxpkg file extension ).  The Solution Explorer is where you manage the contents and dependencies of your project.


You can create sub folders to better organize your assets:



Even create entire new packages:



You can also create new assets directly from the Solution explorer:



Asset View




The asset view shows you the assets in the currently selected folder from the Solution View.  You can select an Asset (to edit it’s properties in the Property Grid, which we will cover shortly) by left clicking it. 

You can create new assets, or import existing ones, using these two toolbar buttons:


You can also import an asset using drag and drop from Windows Explorer:



You can also drag and drop Assets to the 3D view to create new Entities.  Here for example is dragging and dropping a 3D model asset.



Asset Preview / History / References

These three panels are all actually separate, but by default appear together and are pretty straight forward, so I will cover them as a single entity.  Much of the functionality in these panels requires you to select an asset in the asset view.

Action History


Simply a stack of actions you’ve performed.  You can undo/redo using the typical CTRL+Z | CTRL+Y hotkey.  In all honesty, not sure why you would use this panel.  It’s display only, you cant change anything.


Asset Preview


A handy quick preview of how an asset would look.  The above screenshot is with a material asset selected, you can then pick a geometric shape to apply your material to.  For 3D models, it instead loads a simple model viewer.  Can be controlled via the mouse, scroll wheel zoom, right button pans and left button orbits the camera.




There are two modes of operation for this panel, References and Referencers.  It’s a great way to see what assets/entities use an asset, and in turn, what assets an asset depends on.  The above example is the Referencers tab with the default Sphere material selected, you can see that the Sphere Procedural Model uses this asset.


Property Grid



This is probably the most important panel in Paradox Studio.  The contents are entirely dynamic, depending on what you have selected in the editor.  The above example shows the properties with a Material asset select.  As you can see, numerous material properties can be configured here.  The settings vary from asset type to asset type.  Below for example shows a Model asset selected:



This nicely illustrates the relationship between assets.  Remember earlier when I selected the Sphere Material and it showed the Procedural Model as a Referencer?  Well this is where that reference was set.  You can see that the material attached is a Sphere Material ( the example I showed earlier in the Property Grid ).  You can easily select these relationships by clicking the Hand icon:



This will in turn bring up the Asset Picker dialog, and show compatible assets:



As you can see, you can access the entire solution, in case your asset exists in a different folder or package entirely.


The Property Grid functionality changes completely however if you have an Entity from the Scenegraph selected instead of an Asset, like so:



This is where you can both configure existing, or add new components to your entity.  As I said earlier, Entities are simply containers for components.  The above example is a camera, which you can see is composed of a Transform component and a Camera component.

You can also add new components to an entity using the Add Component button.



I will cover the entire process in more detail later, including how to do this all using code instead.


3D View


Finally we have the 3D view ( which technically is the same panel as the Scene graph as mentioned earlier ).  This is a 3D representation of your game world.  As we saw earlier, we can create new instances of an asset by dragging and dropping.  You can also easily select and transform assets in your scene.  If you are comfortable with a 3D application like Max or Maya this concept should be immediately comfortable to you.


You can move, rotate and scale using the toolbar across the top. 


Or using the following hot keys:

  • Q – Select
  • W – Translate/Move
  • E – Rotate
  • R – Scale

When you select an object, a 3d manipulator widget is displayed, like this one for rotating:


Each color corresponds with a particular axis, so the blue circle rotates around the Z axis, green around the Y and red around the X.  You can also use the grey ball in the middle to transform along all 3 axis at the same time.

You can also use these control bar buttons:


To configure which coordinates the manipulator should work on, world space, local space, or camera.




Across the top of the application is the above toolbar.  The icon on the far left opens the project in Visual Studio.  The grayed out button syncs changes between the two.  The next button enables you to compile your code, Visual Studio is not required.  The play icon enables you to run your game and it will run for the platform selected in the drop down to the right.  The final button enables live scripting, something we will talk about later.



Using the View menu you can toggle the visibility of every single panel we just discussed.



Pressing Ctrl + Shift + D or Help Menu->Show Debug Window, brings up the above invaluable tool.  It contains the various logs and handy debugging details as your game runs.  If something goes wrong, this is the first place you should go for details.


The Video



14. July 2015


Since picking up the Humble Bundle a few days back, I’ve been playing around with Stencyl ( expect more later ) a little bit.  While Stencyl provides a drag and drop programming interface, it ultimately enables you to generate Haxe code ( more seamlessly than you probably expect ).  My preferred Haxe editing environment is the IntelliJ IDE.  This tutorial looks at configuring one to work with the other.


First go download and install the community version of IntelliJ IDEA if you haven’t already.

Next run IntelliJ, we need to configure the Haxe plugin.  With IntelliJ loaded, select Configure->Plugins:


Click Browse Repositories



Type Haxe into the search field, select Haxe plugin and click Install plugin



Click yes when prompted, the plugin will be downloaded, then click Close/OK and let IntelliJ IDEA restart.


Now load Stencyl if you haven’t already.  Click File->Preferences or Alt+Enter:



Click the Editors tab, drop down the combo under Code Editor and select Choose Application… and navigate to the idea.exe:



Next Apply Changes.


Next we need some code to edit.  One easy way is to create a new Behavior.   From the Dashboard, select Actor Behaviors, Create New



Fill in the resulting dialog like so (Select Code Mode and name it), then click Create:



You new behavior will be created and opened in the built in code editor.  Now click Open In External Editor:



This will open in IntelliJ, but you wont have any code completion or intellisense.  Let’s fix that now.  To do this we need to configure the Haxe SDK.  To do so, right click the generated project name and select Open Module Settings or hit F4 with the project selected.



Click SDKs, then + then Haxe toolkit



Then navigate to the Stencyl install directory, then plaf/haxe and click OK.



Finally we want to add the additional libraries so IntelliJ knows about them.  Select ClassPath, then + and add /lib.



Finally we need to tell IntelliJ that this project is a Haxe project.  Still in settings (F4 to go back if you’ve closed it), go to Project and select Haxe as SDK.



In the future, this last step should be the only one you have to perform, unless you change your Stencyl install.


Now your code in IntelliJ should have full autocomplete:



Now when you save in IntelliJ, it will automatically sync in Stencyl.


27. May 2015


So today I fired up Steam to finally pull the trigger on Pillars of Eternity and what do I see….



It seems that Degica games, the makers of the popular RPG Maker series of game building tools are having a sale today.  Their flagship product RPG Maker VX Ace ( … quite the name ) is currently on sale for 80% off.


On top of RPG Maker Vx Ace, RPG Maker XP and RPG Maker 2003 are all also discounted, 80% and 50% respectively.  What perhaps caught my eye most of all however wasn’t the RPG Maker line of products, but Spriter is also on sale for 75% off.   Spriter was a successfully kickstarted project made by BrashMonkey, I had no idea Degica was now the publisher.


About Each Program


RPG Maker



This is a program that has been around for a very long time, first released in 1988.  As the title suggests, it’s a game building tool for making RPG’s, generally of the classic jRPG format.


That said, this is a proper game building application, a number of commercially shipped games were created using the various iterations of RPG Maker.  RPG Maker was mentioned as an option in my guide to getting kids started in game development.  Bundled with a ton of premade assets, it is a good way to get your hands wet in game development.  In addition to world, character, dialog, etc… building tools, there is also a programmatic layer using the Ruby programming language. 




Perhaps of most interest to GameFromScratch readers is Spriter.  Spriter is essentially a modular 2D animation system.  You basically cut your sprites up into multiple independent pieces which in turn can be animated.  You can also apply an IK chain ( inverse kinematics… think skeleton ) that controls the animation for you.  You can then export the resulting animation as a sprite sheet, sequence of images or as an animated gif.


Most likely though you will want to use the Spriter API, or one of the pre-existing plugins, and use the Spriter animations directly in your game engine, such as Construct, Unity or LibGDX.


Truth is, I did a pretty lousy job there describing Spriter, so I will just show their video instead…



Both are on sale until May the 29th. 


Oh, and as I finish typing this up, the Steam page for the sale now appears to be broken…


GFS On YouTube

See More Tutorials on!

Month List