Game Engines Galore

Hello everyone,

Before I start, I just want to say, this post is reflecting my own opinions about different game engine and it is not intended to be taken beyond that scope.

I had a chat with Dan (a friend of mine at the Game Innovation Lab) about how many new game developers don’t know a lot about different game engines. Once the discussion ended, he asked me to post about game engines, and rate them according to difficulty and complexity. Nowadays there are more game engines than in the early days of indiegame development. The funny thing is only a few of them are popular such as Unity, Unreal Engine, and Game Maker.

To list all engines, I am going to divide them into categories: Educational (made for children), Specialized (for a single genre/type of games), and Generic engines. This categorization is just to help you find the best tool for what you are doing, but really any tool that allows you to add some programming, either by writing code or using logic trees (logic trees are a way of programming by building a tree of conditions), can be used to create any game. The problem is using any of these tools outside its intended scope is harder than using an other tool. Engines vary in popularity. Popular game engines have a big user base which helps a lot when you have bugs. While using unpopular engine can be a good thing as you work very close to the developers themselves and you can request changes easier from them. Also, these developer can help you in promoting your game more than popular engines because the success of your game is also reflect the success of their engine.

Warning, this is a long post and if you don’t have time, you can jump to a summary table that outlines them all at the end of the post (link).

Educational Engines:

These are tools designed to encourage people to design games and to help them to learn how to do it.

  • Bitsy (http://ledoux.io/bitsy/editor.html): is a simple browser based game editor that doesn’t need any coding or even logic. The tool itself has predefined types of sprites and actions. The user needs only to draw different images and define dialogues for each game character, connect everything together, and TADAAAAAA, you finished a simple html game. All games created by it are topdown story based games where the player can talk to different objects.
  • Dungeon Decorator (https://lorenschmidt.itch.io/dungeon-decorator): is similar to Bitsy, except it designs platformers. The user needs to design the map, some dialogues, and they have a game. All games created by the tool are platformer story based games where the player can talk to different objects.
  • Scratch (https://scratch.mit.edu/): is an MIT tool that helps children to create stories, animation, and games. The tool allows you to program your own logic, by designing logic trees and attaching them to different objects in the scene. Scratch is more generic than you can expect, but it is hard to design very complicated games using it. Scratch produces html games to be played in the web, and all the created games are hosted on their website. You can check their top games here (https://scratch.mit.edu/studios/121998/)

Specialized Engines:

These are tools designed to prototype certain game genres/types in a very fast/efficient way.

Generic Engines:

These are the most generic tools to create games. Unity, Unreal, and Game Maker are part of it, but they are not everything. Always choose the tool that is suitable for the project and for your capabilities. Don’t pick a tool that needs programming if you are not good at it. Don’t worry: all generic tools can do everything, so just pick what fits you.

These are some of the game engines that have a neat and nice IDE to help you in developing. There is other game engines that I didn’t list because they are only code based. Some of these engine are popular between game developers such as Phaser (JavaScript), PlayCanvas (JavaScript), LibGDX (Java), Defold (Lua), Flixel (ActionScript), OpenFl (HaXe), MonoGame (C#), FlashPunk (ActionScript), HaxeFlixel (HaXe), Starling (ActionScript), HaxePunk (HaXe), Love (Lua), Otter (C#), Ogre3D (C++) and etc. There are more engines out there than most people know. This game engine list is sorted by how complex the engine is, then how famous the engine is. Now, after knowing about all these, you have to choose wisely what fits you.

The following table summarize all the tools (All generic tools can be used for 2D or 3D games.):

Engine Name Type Coding


Target Outputs Popularity Cost
Bitsy Educational (2D Story based Topdown) No Web IDE HTML5 Not popular Free
Dungeon Decorator Educational (2D Story based Platformer) No Web IDE HTML5 only in the program Not popular Free
Scratch Educational (2D Generic) No Web IDE HTML5 only in the program Popular between children Free
Twine Specific (Interactive Stories) Optional (Javascript) Web IDE HTML5 Popular Free
ChoiceScript Specific (Interactive Stories) No Any text editor HTML5 Popular Free
Ink Specific (Interactive Stories) No Win / Mac / Linux Any Target Moderate Free
Inform Specific (Interactive Stories) No Win / Mac / Linux HTML5 Moderate Free
Adventure Game Studio Specific (2D Point Click Adventure) No Win Win Moderate Free
RPG in a Box Specific (3D RPG) No Win / Mac / Linux Win / Mac / Linux Not popular $20
RPG Maker Specific (2D JRPG) Optional (Ruby / Javascript) Win / Mac Crossplatform Moderate Limited ($80)
PuzzleScript Specific (2D Turnbase Puzzle) No Web IDE HTML5 Moderate Free
Construct 2 Generic (2D) No Win Crossplatform Popular Limited ($100)
Stencyl Generic (2D) Optional (HaXe) Win / Mac / Linux Crossplatform Popular Limited ($100)
Game Maker Generic (2D) Optional (GML) Win Crossplatform Popular Limited (>$99)
Multimedia Fusion 2.5 Generic (2D) No Win Crossplatform Moderate Limited (>$100)
GDevelop Generic (2D) No Win / Mac / Linux / iOS / Android Crossplatform Not popular Free
Gamesalad Generic (2D) No Win/Mac Crossplatform Not popular Subscription ($17)
Gamebuilder Studio Generic (2D) No Win / Mac Crossplatform Not popular Limited ($100)
Buildbox Generic (2D) No Win/Mac Crossplatform Not popular Subscription ($99)
Voxatron Generic (3D) Not sure Win/Mac/Linux HTML5 Not popular $20
Pico-8 Generic (2D) Yes (Lua) Win / Mac / Linux HTML5 Moderate $15
PixelVision 8 Generic (2D) Yes (Lua) Win / Mac / Linux Crossplatform Not popular $10
Unity Generic (2D/3D) Yes (C#/JavaScript) Win / Mac / Linux Crossplatform Popular Free (Subscription >$35)
Unreal Engine Generic (3D) Yes (C++) Win / Mac Crossplatform Popular Free (pay %5 revenue)
Cryengine Generic (3D) Yes (Lua) Win Win / Linux / Xbox / PS4 Moderate Subscription (>$50)
Cocos Creator Generic (2D) Yes (JavaScript or CoffeeScript) Win / Mac Crossplatform Moderate Free
MightyEditor Generic (2D) Yes (JavaScript) Web IDE Crossplatform High Subscription (>$5)
Phaser Editor Generic (2D) Yes (JavaScript) Win / Linux Crossplatform High 1 Year Free (>$45)
Superpowers Generic (2D/3D) Yes (Typescript) Win / Mac / Linux HTML5 Not popular Free
Godot Generic (2D/3D) Yes (Python) Win / Mac / Linux Crossplatform Not popular Free

In the end, I would love to thank my friends Gabriella Barros and Dan Gopstein for all their effort, feedback and help in creating this post.

Bye Bye
Ahmed Khalifa


Different Time Systems

Hello everyone,
I attended IRDC last weekend. There was a talk by Brett Gildersleeve (the developer of Rogue Space Marine and Helix). The talk is called Real Time Synchronous Turn Systems in Roguelikes. It’s about analyzing the current turn base systems in Roguelike and comparing it to his game Rogue Space Marine. This talk inspired me to write about different systems and which games use which. His talk was astonishing but missing lots of ideas that can be done (It just covered the classic stuff). Here is the ideas about the systems:


Asynchronous Turn Based System: The player plays and after it finished each enemy play its turn. This is the most classic technique used in lots of games (NetHack, Moria, Dungeon Dashers, and …etc).

Synchronous Turn Based System: The player plays at the same time of the enemy. The system resolve the collision by some precedence. Some games adds a speed parameter to have different enemies. Every enemy or npc move related to the player so if he is slower this means he might take more than 1 turn to move but if he is faster than the player he might be moving two tiles with every one player move. For example Cardinal Quest and Super-W-Hack!.

Real Time System: Everything runs at each frame. Everything is continuous and running smooth. The collision happens at each frame. For example Nuclear Throne, The Binding of Isaac, Spelunky, and …etc.

Real Time Synchronous System: This is the system he was talking about in his game. The player move in tile based and when he is moving everything else work in real time (enemy bullets can be avoided). For example Rogue Space Marine.

Bullet Time System: The game move in real time till enemies come near then the game goes in bullet time. Right now there is no roguelike use this system but it would be amazing if some one used it. The current game used it is SuperHot.

Physics Based Turn System: The player move with a speed and the turn ends when the physics stops simulation. For example Billiard Dungeon.

Real Time Pause System: Everything runs in real time and if the player didn’t move nothing move. For example The Spooky Cave.

Real Time Rhythm System: Everything moves on a rhythm if the player didn’t move enemies will move. Missing the rhythm make enemies move while player is still at same location. For example Crypt of the Necrodancer.

Real Time Slot Pause System: The game is totally paused where the player can make all his decisions then the game turns into real time for a fixed time slot. The only game that used that is not a roguelike but it would be cool in a Roguelike. The only game is The Random Encounter.

Time Accumulation Synchronous System: The game saves the amount of time the user not doing his turn and when he plays it repeat the action for the this amount of time. It seems weird and complicated but we might make maximum of the saved time. Its not done before and I would love to try doing it at one day. But if this system is used to penaltize the player it might be similar to Real Time Rhythm System (when not doing anything the game penaltize the player by moving the enemies).

These are all the systems I can think of that can be used in roguelike games. I think I need to organize it and make like 2D matrix for the different parameter that can be mixed.

Bye Bye


IRDC NYC 2016 – Day 1

Hello everyone,
I went to the International Roguelike Developer Conference (IRDC 2016). It was fun, you can watch it on twitch and they are gonna stream tomorrow (link).

Here is the recap on the talks:

Markov Text Generation:
Caves of Quds text/books/tomes/realms/lore are generated using Markov Chain models. They use Markov Chain models to generate paragraphs (3 to 6 sentences) and books (4 to 8 paragraphs). Some other people do two direction Markov Chain instead of one direction Markov Chain. For book titles they used a template filling like Tracery but this technique is kinda limited so they replaced it by a generated sentence from Markov Chain models with limited length then shove off the unwanted words from the beginning and the end of the sentence. For hidden secrets in the book, he generate all the secrets first then he add them to the Markov Chain model. Also he told to check (The Annals of the Parrigues) by Emily Short.

Writing Better Code:
It was about tricks and hints to write better readable code. For example, use code review, read a book (Writing Solid Code by Steve Maguire), read other people code, and …etc. Examples for stuff that make the code better is always make the write the constant on the left of the condition, comment beside any else to understand which “if-condition” its related to it, unroll big long “if-condition” statement to multiple short ones, and …etc.

Applications of Dijkstra Maps in Roguelikes:
This talk is about using Dijkstra Maps instead of A* algorithm. A* algorithm (check A* Pathfinding video by Sebastian Lague) is widely used, easy to implement, call on demand, and efficient when points are close but you need to recalculate the path when something changes and its expensive when used by tons of NPCs. Dijkstra is done over the whole map and can be used by all actors but its more expensive than A* and there is no off the shelf implementations. Dijkstra produces a map of numbers where each number equal to the number of steps to reach the goal. In order to find the path just move from the npc location towards the goal in the direction of decreasing number till reaching the goal. Dijkstra can be used for autoexploring, procedural generation for rivers, optimal range for ranged enemies, find the path towards the mouse location, and …etc.

He is the creator of Barony game. Now he is working on Space Punk which an open world metroidvania where the Enemy AI is the challenge. Also he used Chai script language to allow modding.

Procedural Dialect Generation:
That was super interesting talk about a game called Ultima Ratio Regum. The game generate history for NPCs, religions, names, dialects. You have to try it if you are into exploring stories and understanding different cultures.

Quick Talks:
The day ends by couple of very fast talks from the audience themselves talking about different stuff for example using BFXR, Queneau Assembly instead of Markov Chains to generate text, and Procedural Rap Generator.

Tomorrow I will write a wrap up on the whole day too.

Bye Bye


GECCO16: General Video Game Level Generation

Hello everyone,
This is my talk in GECCO16 for our paper “General Video Game Level Generation“.

GVG-LG Framework GECCO.001

Hello everyone, I am Ahmed Khalifa a PhD student at NYU Tandon’s school of engineering and today I am gonna present my paper General Video Game Level Generation

GVG-LG Framework GECCO.002

We want to design a framework that allows people to develop general level generator for any game described in video game description language.

GVG-LG Framework GECCO.003

So what is level generation? It using computer algorithm to design levels for games. People in industry have been using it since very long time. At the beginning the reason due to technical difficulties but now to provide more content to user and it enables a new type of games. The problem with level generation is all the well known generators are designed for a specific game. So it depends on domain knowledge to make sure levels are as perfect as possible. Doing that for every new game seems a little exhaustive so we wanted to have on single algorithm that can be used on multiple games. In order to do that we need a way to describe the game for the generators.

GVG-LG Framework GECCO.004

That’s why we are using Video Game Description Language. It’s a scripting language that enables creating different games super easily. So the script written is for that game which is kinda like dungeon system from legend of Zelda. VGDL is simple u need to define 4 sections, SpriteSet, LevelMapping, InteractiveSet, and TerminationSet. SpriteSet to define game objects such as goal, interactionset to define the interactions between different objects, termination set define how the game should end.

GVG-LG Framework GECCO.005

Here some extra examples that shows that vgdl is able to design different games such as freeway where the user try to reach the exit by crossing the street.

GVG-LG Framework GECCO.006

Snowman which is a puzzle game where the player try to build a snowman at the end position by placing the peices correctly. It’s inspired by a snowman is hard to build a famous Indiegame about creating snowmen and giving them names and hugging them.

GVG-LG Framework GECCO.007

Let’s get back to the framework, we want to create it as simple as possible so each user write a level generator where he gets a vgdl description of the game and he has to return a generated level

GVG-LG Framework GECCO.008

The game description object give the user all the information in vgdl and also give tags to the sprites according to their interaction. For example if object block the player movement and don’t react with anything else, is considered solid, if is the player then tagged as avatar, if it could kill the player then it’s a harmful object, collectible object is stuff that get destroyed

GVG-LG Framework GECCO.009

We designed 3 different level generations and shipped them with the framework, the first one is the random generator where it place all game objects in different location on the map

GVG-LG Framework GECCO.010

The second one is the constructive generator where it tries to use information available and design a good level. So it starts by calculate percentages for each object type then it draws a level layout, then place the avatar at random location then place harmful object in a position proportional to the distance to the avatar, then add goal objects. After that it goes through a post processing where it add more goal objects if needed to satisfy goal constraints.

GVG-LG Framework GECCO.011

The third one is a search based generator where it uses feasible infeasible 2 population genetic algorithm to generate the level. We populated with levels generated from the constructive algorithm to ensure that GA will find better levels. We use one point crossover where two levels are swapped around certain point. While mutations used is create where it creates random object at random tile, delete: deletes all objects from a random position,

GVG-LG Framework GECCO.012

We used several constraints to ensure playability of the levels. First one is cover percentage so we never generate an over populated levels or very sparse levels

GVG-LG Framework GECCO.013

Make sure there is one avatar becz if it’s not there it’s impossible to play the game

GVG-LG Framework GECCO.014

Sprite number constraint where it makes sure there is at least one sprite from each type, to make sure the levels are playable. For example if there is no key u can’t win the level

GVG-LG Framework GECCO.015

Goal Constraint to make sure that all goal conditions are not satisfied becz if they are satisfied then u win when the game starts

GVG-LG Framework GECCO.016

Death constraint is to make sure for the 40 game steps if the player did nothing he won’t die becz if the player dies at the beginning it’s unplayable game becz humans are not as fast as expected

GVG-LG Framework GECCO.017

Last one is win constraint and solution length is make sure the levels are winnable and not straight forward win, the best agent takes amount of steps before finishing.

GVG-LG Framework GECCO.018

These are all the constraints, about the fitness, it consists of two parts. The first part is score difference fitness inspired from Nielsen work. He found that the difference in score between the best agent (Explorer) and his worst agent (DoNothing) is big in good designed levels compared to random generated ones. We used the difference between our best agent and worst agent for that.

GVG-LG Framework GECCO.019

The second fitness is unique rule fitness, we noticed by analyzing all games that agents playing good designed levels encounter more unique intersection rules than random designed levels.

GVG-LG Framework GECCO.020

In order to verify that we did a user study, where the user plays two levels from a certain game and choose which is better. We used 3 different games without including puzzle games as there is no agent excels in playing puzzle games so far.

GVG-LG Framework GECCO.021

The results shows that users prefered search based levels over constructive which was expected while they prefered random over constructive without huge significance.

GVG-LG Framework GECCO.022

One of the main reason we think is people can’t differentiate between constructive and random but random always ensure all sprites there which make its levels playable while constructive although it looks better sometimes it misses a key or something.

GVG-LG Framework GECCO.023

We ran a level generation competition one week ago, we had 4 competitors (1 based on cellular automata, 3 based on search based approaches)

GVG-LG Framework GECCO24.001

It was simple because the cellular automata didn’t put tons of objects in the level which made it somehow playable while all the others overloaded the levels with tons of object so players die insatiately

GVG-LG Framework GECCO.025

Our future work, is enhancing search based generator to get better designed levels, enhance the framework based on competitors feedback, rerunning the competition again and encouraging more people to participate.

GVG-LG Framework GECCO.026

That’s it, Thanks.

That’s it for now.
Bye, Bye


IJCAI16 Talk: Modifying MCTS for Humanlike Video Game Playing

Hello everyone,
Ages since last post 😀 on Thursday July 14th I gave a talk about my paper “Modifying MCTS for Humanlike Video Game Playing” with Aaron Isaksen, Andy Nealen, and Julian Togelius at IJCAI16. Thanks to Aaron, he captured a video of my talk. Here is it:

Also we did a poster for the conference which looked amazing. Here is the poster:

Humanlike MCTS Poster.001

If the video is not clear, I am posting the slides here with my comments:

Humanlike MCTS New.001

Hello everyone, I am Ahmed Khalifa, PhD student at NYU Tandon’s School of Engineering. Today I am gonna talk about my paper “Modifying MCTS for Humanlike Video Game Playing”.

Humanlike MCTS New.002

We are trying to modifying Monte Carlo Tree Search algorithm to play different games like human player. We are using General Video Game Playing Framework to test our algorithm.

Humanlike MCTS New.003

Why do we need that? One important reason is create humanlike NPCs. One of the reason people play Multiplayer games is the lack of realistic NPCs to play with or against. Also evaluating levels and games for AI-assisted tools. For example if you gave these two levels to a human, he will pick the one on the left as its playable by human while the one of the right is super difficult, it might even be impossible to be played.

Humanlike MCTS New.004

Before we start, whats general video game playing which we are using its framework. Its a competition for general intelligence where competitors create different agents that plays different unseen games. These games are written in a scripting language called Video Game Description Language. Every 40msec the agent should select one of the available actions. Like up, down, left, right, use button, nil which is do nothing. A game play trace is a sequence of actions.

Humanlike MCTS New.005

Here are two videos that shows the difference between human player and MCTS agent. On the left you can see humans tends to go towards their goal and only do actions when necessary (for example only attack when monster is near). While MCTS agent on the right is stuck in the upper left corner moving in walls, attacking the air and walls.

Humanlike MCTS New.006

By analyzing the play traces for both human players and MCTS agent on different games. We found that humans tends to repeat the same action multiple times before changing. In the first graph it shows human have tendency to repeat the same action twice by 50%. Also humans tends to use more NILs and tends to repeat it more during the play trace. While in the third graph it shows the MCTS have a higher tendency to change actions more often than humans. Humans 70% of the time don’t change their action.

Humanlike MCTS New.007

In order to achieve similar play traces, we need to modify MCTS. These are the main 4 steps for MCTS.

Humanlike MCTS New.008

We tried to modify each step on its own but none of them have a big change in the distribution except for the selection step.

Humanlike MCTS New.009

Selection step depends on UCB equation to select the next node.

Humanlike MCTS New.010

UCB equation consists of two terms, exploitation term and exploration term. The exploitation term bias the selection to select the best node while the exploration term push MCTS to explore less visited nodes.

Humanlike MCTS New.011

We modified the equation by adding a new bonus term which consists of 3 parts:
Human Modeling
Trivial Branch Pruning
Map Exploration Bonus
Also we modified the Exploitation term with a MixMax term.
We are going to explain all these terms in details in the upcoming slides.

Humanlike MCTS New.012

We added a bonus value that shift the MCTS distribution to be similar to human distribution. As you see from the video the agent tends to repeat the same action and do more NILs with lower action to new action frequency. But as we see, it is still stupid, stuck in the corner, attacking air, moving into walls.

Humanlike MCTS New.013

Thats why we added the second term which avoids selecting stupid nodes (like attacking walls and moving into walls) As we see the agent stopped attacking the air and whenever it get stuck in a wall, it changes the action or apply nil. But its still stuck in the corner.

Humanlike MCTS New.014

So we added a bonus term that reward nodes that have less visited positions on the map. As we can see the agent now go every where and explore. But as we see the agent is coward, it avoids attacking the spiders.

Humanlike MCTS New.015

So we used MixMax term instead of the exploitation term which use the mixture between the best value and the average value of the node instead of the average value only. As we can see the agent become courageous and moves towards the enemies and kill them.

Humanlike MCTS New.016

Analyzing the play traces after all these modifications. our BoT (Bag of Tricks) algorithm tends to be more similar to human compared to MCTS in action repetition, nil repetition. Also having less action to new action changes.

Humanlike MCTS New.017

In order to verify these results we conducted a user study. In the study, each user watch two videos and he was to specify which is more likely to be human and why?

Humanlike MCTS New.018

From the study our BoT algorithm was more human than MCTS but still not as good as humans, except for PacMan where deceived the humans by 60%.

Humanlike MCTS New.019

When we analyzed the human comments we found that the main reason for recognizing agent are the same as we stuff we tries to solve. Jitterness (changing directions very quickly), Useless moves (attacking walls, moving into them), No long term planning (stuck in one of the corners), too fast reaction time, over confidence (killing all enemies and become over achiever)

Humanlike MCTS New.020

Thanks for listening.

That’s everything for now.


Super-W-Hack! Incubator Pitch

Hello everyone,
Today me and Gabriella gave a talk about Super-W-Hack for the incubator program. I felt it would be nice to share the talk with you people.

Hello everyone, I am Ahmed and this is Gabriella. We are PhD students at the game innovation lab here at NYU. We are going to talk today about our game Super-W-Hack!

Super-W-Hack! is a roguelike game with retro aesthetics as a tribute to the roguelike genre. Our game takes the procedural content generation (PCG) up to the next level. We use it to generate everything in the game.

Levels are procedurally generated, names, layouts, enemy distributions.

Player weapons: weapon pattern, names, sounds.

Even bosses are procedurally generated.

All game main features are done. But since our research is in PCG and we know how amazing it can generate stuff so we want to embrace it more. Generate the main character (his back story, why he is going to the dungeon). Generate variable weapons like teleportation, mines, bombs. Also our game still needs music. Since we have lots of PCG so we need lots of testing to make sure it works correctly.

We plan to finish the game and release it by the end of the year over Desktop such as Steam and Itch.io as Desktop has always been the land of roguelikes and the hugest fanbase. Since the game has simple controls and small decisions to take at each step. We believe it will do well on Mobile markets such as App Store and Google Play. We are going to send our game to all the major events such as IGF, IndieCade, and PAX. We believe with the help of the incubator we will be able to reach all these goals.

Thanks everyone for listening any questions.

Level Layout
(Then we played this video in the background while taking questions)

We got couple of questions and concern about the play session time, ensuring the game is playable and interesting to the player, and what’s a roguelike.

I just wanted to share my talk about the game and here is the link (www.amidos-games.com/blog/super-w-hack/) to the alpha version if anyone wanna try it. In the current state its still a little hard to understand in the beginning but as soon as you understand it. It so intuitive and interesting to be played.



Video Game Description Language (VGDL) & General Video Game Playing Framework (GVG-AI)

This post is a presentation I did couple of weeks ago at Game Innovation Lab (GIL). It supposes to help people at the lab to understand VGDL and GVG-AI framework. I think that if we want VGDL to evolve, more people should know about it and use it. This evolution won’t happen without showing to people the power of GVG-AI Framework and VGDL. There is lots of development happening to improve the framework and language and making it more accessible to people (creating an Interactive Visual Editor with computer assist). The following paragraphs are my slides with a description for each slide.



General Video Game Playing (GVGP) is creating an AI agent that can play different video games (not a certain game) efficiently. The hard constrain on these agents that they need to have a response time in about 40 msec.


Video Game Description Language (VGDL) was invented to help to prototype different games quickly for the GVGP and have a common framework to work with. VGDL was initially written in python but now ported for java (to be faster). The language is tree structured like xml files. It supports grid physics like old arcade games (PcMan, Space Invaders, …etc). It is human readable and easy to prototype lots of different games using it (PcMan, Frogs, Space Invaders, Sokoban, …etc)


The current drawbacks of the VGDL: It hasn’t a visual editor, It hasn’t a good online documentation for the language, It has limited physics (no continuous physics to prototype games like Cut the Rope), and It has limited events (all game events are restricted with collision events between objects). Right now people are working to improve these drawbacks and make the VGDL more accessible to more people. Check the current draft of documentation and may be you could help improve the writing and improve it (link).


In order to write a game using VGDL, you need to provide two files (Game Description File and Level Description File). The Game Description File describes the whole game (What are the game sprites? What’s the termination condition? How do sprites interact? …etc). The Level Description File describes the level layout (Sprite arrangement).


Let’s take an example. This game is called WaterGame. It’s super simple game where you have to move the avatar towards the exit. The problem is the path is always blocked by water. If avatar touches water, it will die. In order to pass the water, the avatar should push boxes over it (Box destroys the water, you can think it floats).


That’s the Game Description File for that game. It is divided into 4 sections (SpriteSet, TerminationSet, InteractionSet, and LevelMapping).

  • SpriteSet: explains all the game sprites (their type, their rendered image). For example “avatar” is defined as of type “MovingAvatar” which means it can move in all 4 directions and it has an image called “avatar” (All images must be in sprites folder).
  • TerminationSet: explains how should the game ends? For example “SpriteCounter stype=avatar limit=0 win=False” means if the number of “avatar” sprites are equal to zero, you lose the game.
  • InteractionSet: explains the result of collision between sprites. For example the first collision says if “avatar” collides with “wall”, the “avatar” should “stepBack” which means undo its last movement.
  • LevelMapping: just helps the VGDL engine to parse the Level Description File. The VGDL engine just replace each character with the corresponding sprites.


The Level Description File is a 2D matrix of characters described in the LevelMapping section. The VGDL engine just replace each character with the correct sprites and voila the level appears.


Let’s now talk about the different types of sprites we can define. There is several amount of sprites but I just categorize it into the following:

  • Portal & Spawn Points: Like doors, teleports, portals that spawn objects, and …etc
  • NPC: there is chasing npc (follows a certain sprite), fleeing npc (runs away from certain sprite), random npc (moves randomly), and …etc
  • Resource: objects that can be collected and change certain defined variable value. This value can be anything like score, health, ammo, …etc
  • Avatar: It is controlled by the player (using keyboard or an agent). It can be moving avatar (moves everywhere), shooting avatar (which moves and can shoot), …etc
  • Movable: It is an object that is affected with physics like missiles.
  • Static: It is not affected with any physics even its applied on it like walls.


There is only three different types of termination condition:

  • SpriteCounter: It terminates the game when the number of certain sprite is larger than or equal to certain value.
  • MultiSpriteCounter: It terminates the game when the summation of two different sprites equal to certain value.
  • TimeOut: It terminates the game when the game time is larger than or equal to certain value.


There is lots of different interactions that can be used on collision between different sprites. The following are categorization for them:

  • Kill Sprite
  • Spawn Sprite
  • Undo Movement
  • Change Orientation
  • Change Position
  • Collect Resource


The following slides will focus on the GVG-AI framework and what does it offer? For more details check GVG-AI website documentation (link).


You can integrate an AI Agent that plays VGDL games just by extending AbstractPlayer class and providing a constructor and an act function which returns the avatar action every single game step.


The framework also supports a StateObservation class that wraps the current game status (winning, score, and time), avatar status (speed, position, and orientation), grid observation for all the game (also it supports arrays for different sprite types), and Event History for all collisions happened due to the avatar or a sprites spawned by it.


The StateObservation class provides forward model that can predict the future but not exactly as most games are some how stochastic.


Last thing the framework comes with couple of sample agents to help you understand how to write your AI agent. For example: Random Agent, One Look Ahead, Genetic Algorithm, and Monte Carlo Tree Search.


That’s the whole presentation. I hope it encourages you to use VGDL to prototype your games or even participate in the next GVG-AI competition (link). The Game Innovation Lab is trying to improve all the drawbacks of the VGDL language and even start a PCG competition track (link).

Bye Bye


Literature Review of PCG in Puzzle Games

Long time since posting (the usual me) but This post will be short and long at same time.

“How is that?” That’s easy, the post itself will be very short (just few words) but it will have an attached document (around 16 pages) which is the third chapter in my Master’s Thesis. This chapter is the literature review chapter (the third biggest chapter in my thesis) which I think one of the most entertaining chapters (to read obviously not to write :D).

“Why do I think its entertaining?” That’s also easy to reply, I combined lots of previous work about level and rule generation (look at the references), and a friend of mine enjoyed reading it and thought its the most entertaining chapter.

“You just said its a short post.” Yes, sorry for that but I want also to improve my writing capabilities. Here is the link to the document: http://amidos-games.com/blog/documents/LiteratureReviewPCG.pdf.

Bye Bye


PCG in my Games

Hello everybody,
Long time with no posts or updates here. It seems like desert, sorry for that but I am sure people who follow me on twitter knows I was busy with my Master’s Thesis in Procedural Content Generation (PCG). I have always used PCG in my games as an excuse for being lazy and not designing levels (as I am not amazing level designer). In this post I will wrap up quickly some of the PCGs I used in my games. In the next post will talk about PCG in my Master’s Thesis.

As most of people noticed lots of my arcade games used PCG especially top down shooters (Clean’Em Up and Alone in the Park). All these games don’t have levels designed in advance, but instead they have enemy numbers and types to be generated. The system afterwards choose the most suitable location (away from the player position) and insert them. Pace Maker was a little different where the system generates the types and numbers based on the level of difficulty so as difficulty increase the number of enemies and variety of types increased.

Match a Number used PCG technique to generate the map. The idea is super easy

  • Insert random tiles (numbers and types) over the whole grid
  • Choose the solution length based on the player score (define the difficulty).
  • Generate a random path of the specified length without any loops.
  • Calculate the value of this path and consider it as player target

For the puzzle mode instead of generating paths, the whole playground is divided into sets according to the number of sets required at the beginning and then calculate the value of each set separately.

Atomic+ bullet pattern was generated based on a certain equation of difficult. The bullet generator is divided into the following features and by combining these features we can get a new shooter

  • Bullet Path (bp): how the bullet moves in the game (straight line, sin wave, spring, and circular path).
  • Number of Spawner (ns): how many places bullets should fire from the center (1, 2, 3, and 4).
  • Rate of Spawning (rs): how many milliseconds does the spawner need to spawn a bullet (800, 750, 700, 650, and 600).
  • Number of Burst bullets (nbb): how many bullets should the spawner generate at everyshot (1, 2, and 3).
  • Number of Bullets (nb): how many bullets the spwaner should shoot after each other (1, 2, and 3).
  • Spawner movement (sm): how the spawner update its position (no movement, circular movement, and ping pong circular movement)

Each of values for each feature has a specific difficulty score. This score is inserted in a difficulty equation and if the output difficulty is near the target difficulty then this generator is used else repick another random generator. The difficult equation is:

difficulty = sm * rs * bp * ns * nbb * nb

Last game I am going to talk about is DivCircle. The music and the rotation are both chosen by the computer. For the game music. The music is divided into several tracks overlayed over each other as the rotation speed increased each layer of the music got activated and as the rotation speed decrease the layers gets lower. Also as the player approach more towards the death, all layers volume decreased while sounds of talking people increases. That’s everything with the music and Ben Burnes did an amazing job in helping me to reach that. About the rotations, I divided the game into 14 sequence each one with its own difficulty score. These sequences are:

  • Speed Up
  • Speed Up Fast
  • Slow Down
  • Slow Down Fast
  • Reverse
  • Speed Reverse
  • Slow Reverse
  • Reverse, Reverse
  • Speed Up Fast, Speed Up Fast, Slow Down Fast
  • Slow Down Fast, Speed Up Fast
  • Speed Reverse, Slow Down Fast, Speed Reverse
  • Reverse, Speed Up Fast, Reverse, Slow Down, Reverse
  • Speed Up Fast, Speed Up Fast, Reverse
  • Speed Reverse, Slow Reverse, Speed Reverse

All actions are stored in a queue and every amount of time an action is activated and new action sequence is inserted in the list based on the current player score and current rotation speed and how old is the reverse. The amount of time for inserting and applying new action is decreased as the score increase.

This is everything for now, Hope its a little bit entertainment and useful. Stay tuned for the next post which is gonna be about General Level Generation for Puzzle Script (which is a part of my Master’s Thesis).

Bye Bye for now


Help is Needed

Hello everyone,


Sorry for being away for long time, but as you all know I am working on my master’s thesis in Procedural Content Generation (PCG) of puzzle games and levels for Puzzle Script engine by Stephan Lavelle. I generated lots of levels using different methods for 5 different games and I need some human feedback on everything.

If you have some free time to help me with it please consider playing a handcrafted game and then one of the techniques (playing handcrafted give you reference to the best designed games) (link). Do the assessment after finishing every level to remember it because after playing 16 levels you may forget some games.

Please try playing some of the game at the end of the list such DestroyGame, GemGame, BlockFaker. As most of assessment is done on Sokoban and slightly on LavaGame.

Thanks everyone, I will publish my thesis and my code and everything once its done to be open source with all the results and data. Hope my work in PCG helps game developers in understanding more about games and how to design it and may be use or improve on my techniques.

The link for the games and the assessments: http://amidos-games.com/blog/puzzlescript-pcg/

Bye Bye