Tile Editor for Unity: Part II

As I mentioned before, for those who only want to use the editor, as soon as the Asset is available in the Unity Asset Store, you will be able to download it for free and use it.

This is the second part of a series of posts about a small tile editor I’m creating for Unity. If you haven’t read the first part yet, you can check it out here.

The whole explanation is divided in the following parts:

  1. Editor Window Creation
  2. Saving Status
  3. Menus
  4. Game Objects Actions: Create, Delete, Edit
  5. Layers
  6. Grid
  7. Snapping
  8. Transformations
  9. Snapping: Extended

This week we are going to cover point number 3: menus.


This section includes the concept of game object menu, which is an abstraction of a group of game objects (represented by prefabs) that are loaded inside a menu for the user to dynamically create instances of them in the editor.

As you can see in the picture above, this section was called “Game Objects” and represents a list of menus used to add new prefabs to the editor. It’s possible to add different menus, each one with a set of prefabs to add to the scene, it’s also possible to customize the menu a little to better organize the elements inside of it and remove it if necessary.

In the previous post, we created the main class file for out extension “LevelCreatorEditor”, which handles how the menus are created, all the operations for each menu and general operations as well. As we mentioned before, all the menus are rendered inside the method “OnGUI” and for this new section we added the “BuildMenuObjects” method.

  1. List menus;
  2. EditorObjectsMenu objMenu;
  4. void OnGUI()
  5. {
  6.    if (menus == null)
  7.       menus = new List();
  8.    //Header
  9.    BuildMenuHeader();
  10.   //Objects
  11.   BuildMenuObjects();
  12. }
  14. void BuildMenuObjects()
  15. {
  16.    int curSel;
  17.    List removedMenus;
  19.    //If the group is empty, we disable this section
  20.    EditorGUI.BeginDisabledGroup(layers.Count <= 0);
  21.    //You can change the label if you want
  22.    GUILayout.Label("GAME OBJECTS", EditorStyles.boldLabel);
  23.    //Add menu button
  24.    if (GUILayout.Button("Add Menu"))
  25.       menus.Add(new EditorObjectsMenu());
  26.    removedMenus = new List();
  27.    //GUILayout.BeginVertical();
  28.    gameobjectsScrollPos = GUILayout.BeginScrollView(gameobjectsScrollPos, false, true);
  29.    //Menus
  30.    foreach (EditorObjectsMenu m in menus)
  31.    {
  32.       //Title
  33.       GUILayout.Label("Menu: " + m.folder, EditorStyles.boldLabel);
  34.       //Columns
  35.       m.columns = EditorGUILayout.IntField("Columns", m.columns);
  36.       //Folder's location
  37.       EditorGUILayout.BeginHorizontal();
  38.       m.folder = EditorGUILayout.TextField("Folder Name", m.folder);
  39.       if (GUILayout.Button("Load"))
  40.          m.LoadPrefabs();
  41.       EditorGUILayout.EndHorizontal();
  42.       //Load elements
  43.       if (m.tiles != null && m.tiles.Length >= 0 && m.columns >= 0)
  44.       {
  45.          curSel = GUILayout.SelectionGrid(m.selGridInt, m.tiles, m.columns, GUILayout.Width(position.width - 20),GUILayout.Height(100));
  46.          if (curSel != m.selGridInt)
  47.          {
  48.             m.selGridInt = curSel;
  49.             objMenu = m;
  50.             DeactivateMenus();
  51.          }
  52.       }
  54.       //Remove menu
  55.       if (GUILayout.Button("Remove"))
  56.          removedMenus.Add(m);
  57.    }
  58.    GUILayout.EndScrollView();
  59.    EditorGUI.EndDisabledGroup();
  61.    //Clean menus
  62.    foreach (EditorObjectsMenu m in removedMenus)
  63.       menus.Remove(m);
  64. }
  66. void DeactivateMenus()
  67. {
  68.    foreach (EditorObjectsMenu m in menus)
  69.    {
  70.       if (objMenu == null)
  71.          m.selGridInt = -1;
  72.       else
  73.       {
  74.          if (objMenu != m)
  75.             m.selGridInt = -1;
  76.       }
  77.    }
  78. }

Menus are logically represented using a List of “EditorObjectsMenu” which is a new class that has handles all the functionality inside a menu: loading new prefabs and converting them into usable icons, serializing the data to store changes for future use, etc.

  1. public class EditorObjectsMenu
  2. {
  3.    //Default folder that appears in the folder field
  4.    public const string DEFAULT_FOLDER = "Tiles";
  5.    //This will change depending on the folder's name
  6.    public string name;
  7.    //Folder's name
  8.    public string folder;
  9.    //Selected element
  10.    public int selGridInt;
  11.    //To organize the elements graphically, number of columns
  12.    public int columns;
  13.    //Textures of each prefab (from SpriteRenderer)
  14.    public Texture[] tiles;
  15.    //Prefabs that represent game objects
  16.    public Object[] prefabs;
  18.    public EditorObjectsMenu()
  19.    {
  20.       selGridInt = -1;
  21.       name = DEFAULT_FOLDER;
  22.       folder = DEFAULT_FOLDER;
  23.       columns = 3;
  24.    }
  26.    /// Load all the prefabs in folder "folder"
  27.    public void LoadPrefabs()
  28.    {
  29.       GameObject obj;
  30.       prefabs = Resources.LoadAll(folder, typeof(Object));
  31.       tiles = new Texture[prefabs.Length];
  32.       for (int i = 0; i &lt; prefabs.Length; i++)
  33.       {
  34.          obj = ((GameObject)prefabs[i]);
  36.          if (obj.GetComponent().sprite == null)
  37.          {
  38.             for (int j = 0; j &lt; obj.transform.childCount; j++)
  39.             {
  40.                if (obj.transform.GetChild(j).GetComponent().sprite != null)
  41.                {
  42.                   tiles[i] = obj.transform.GetChild(j).GetComponent().sprite.texture;
  43.                   break;
  44.                }
  45.             }
  46.          }
  47.          else
  48.             tiles[i] = obj.GetComponent().sprite.texture;
  49.       }
  50.    }
  52.    /// Get the the selected element
  53.    public Object GetCurrentSelection()
  54.    {
  55.       Object sel;
  57.       sel = null;
  58.       if (selGridInt != -1)
  59.          sel = prefabs[selGridInt];
  61.       return sel;
  62.    }
  64.    /// Transform the object's parameters into a string (to save the state of the object)
  65.    public string Serialize()
  66.    {
  67.       return name + "," + folder + "," + selGridInt + "," + columns;
  68.    }
  70.    /// Takes a serialized string and loads all the parameters of the object
  71.    public void Deserialize(string data)
  72.    {
  73.       string[] attributes = data.Split(',');
  75.       name = attributes[0];
  76.       folder = attributes[1];
  77.       selGridInt = int.Parse(attributes[2]);
  78.       columns = int.Parse(attributes[3]);
  79.    }
  80. }

The EditorObjectsMenu class has properties such as: name, folder, selGridInt, columns, tiles and prefabs. Name and folder are the same but one is used to display the id in the GUI and the other to decide where should the prefabs be loaded from; selGridInt represents the selected element (prefab); columns, is there to customize the number of columns each menu displays; tiles is an array of textures that are mapped to the prefabs and help to display the prefabs buttons inside the menu.

LoadPredabs takes the folder path (which should be inside the physical folder “Resources” and loads all the prefabs inside that path. This data is stored in the textures and prefabs arrays to be displayed in the menu.

GetCurrentSelection just returns which of the current element was selcted by the user and with that we can create instances of that object in the editor.

Finally Serialize and Deserialize were created to easily convert the data to strings and store it as we explained in the previous post.

Going back to the previous method “BuildMenuObjects” now that the EditorsObjectMenu is defined, we can see that the new attribute called “menus” is a list of elements of EditorsObjectMenu class. With this variable we represent logically all the menus that are rendered in the GUI.

Adding Menus

We create a new button inside the GUI called “Add Menu”, the code can be seen in the “BuildMenuObjects” function above:

  1. if (GUILayout.Button("Add Menu"))
  2.    menus.Add(new EditorObjectsMenu());

Here we just create a new instance of the class and add it to the menu list and it automatically will render the information and inputs for that new menu.

Rendering Menus

All the menus are rendered inside a foreach instruction that handles each input of the menu separately:

  1. foreach (EditorObjectsMenu m in menus)
  2. {
  3.    //Title
  4.    GUILayout.Label("Menu: " + m.folder, EditorStyles.boldLabel);
  5.    //m.name = EditorGUILayout.TextField("Title", m.name);
  6.    //Columns
  7.    m.columns = EditorGUILayout.IntField("Columns", m.columns);
  8.    //Folder's location
  9.    EditorGUILayout.BeginHorizontal();
  10.    m.folder = EditorGUILayout.TextField("Folder Name", m.folder);
  11.    if (GUILayout.Button("Load"))
  12.    m.LoadPrefabs();
  13.    EditorGUILayout.EndHorizontal();
  14.    //Load elements
  15.    if (m.tiles != null && m.tiles.Length >= 0 && m.columns >= 0)
  16.    {
  17.       curSel = GUILayout.SelectionGrid(m.selGridInt, m.tiles, m.columns, GUILayout.Width(position.width - 20),GUILayout.Height(100));
  18.       if (curSel != m.selGridInt)
  19.       {
  20.          m.selGridInt = curSel;
  21.          objMenu = m;
  22.          cursorState = CursorState.Add;
  23.          DeactivateMenus();
  24.       }
  25.    }
  27.    //Remove menu
  28.    if (GUILayout.Button("Remove"))
  29.       removedMenus.Add(m);
  30. }


Here basically we handle basic information for the menu: name, location. There is also a field called “Folder Name” that specifies the path of the data. After the user writes the name of thr folder down, clicks “Load” and all the prefabs will be loaded automatically inside the menu, using the SpriteRenderer’s texture as icon image. In case that the SpriteRenderer for a prefab is empty, the algorithm automatically searches inside the children of this prefab and takes the first non null texture and use it.

Removing Menus

In the previous code we can see that a “removedMenus” list was created in additio to the general menus list. This is emptied everytime before the cycle for rendering menus starts so if the user removes a menu using the remove button, it will add it to this new list and delete all menus from the main list after the cycle finishes. This is done to prevent collection changes inside the cycle.

Deactivate Menus

Finally, this method verifies if any of the elements on any menu was selected and in case it was not selected it deactivates the whole menu. This was used to have only one element selected at the time, if we do not do this, then two different menus could have one element selected each and we don’t want that when creating new instances.

With the menu deactivation I want to close this post, I’ll continue explaining the rest of the code in upcoming articles. If you have questions, leave in them in the comments.


Tile Editor for Unity: Part II

Tile Editor for Unity: Part I


Before starting to talk about today’s topic, I would like to announce we have a new image: new logo, appeareance and website. This new website includes released games, current projects and prototypes that will hopefully become released projects soon. Hope you like it!


So, today’s post consists of the first of a series of short posts about how the tile editor for Unity was created and explain the basic functionality of it.

For those who only want to use it and are not really interested about how it was built, as soon as the Asset is available in the Unity Asset Store, you will be able to download it for free and use it.

This is only the beginning of this tool, I would like to keep improving it along with the development of the game I’m currently creating.

The whole explanation is divided in the following parts:

  1. Editor Window Creation
  2. Saving Status
  3. Menus
  4. Game Objects Actions: Create, Delete, Edit
  5. Layers
  6. Grid
  7. Snapping
  8. Transformations
  9. Snapping: Extended

For this post we will cover only the first two parts, the rest of the explanation will be covered in the upcoming weeks.


The first thing we need to do is to create a folder called “Editor” in our Project manager, this is a special folder designed to extend the functionality of the basic Editor.

As you can see, I added the folder inside a folder called “FSLevelEditor”, you can really put this folder wherever you want and you can also create multiple folders in different locations, if they are named “Editor”, that should be enough for it to work well.

After creating this folder, inside of it, we want to create a new class which will be the main class for our extension. In this particular case, I called the main class “LevelCreatorEditor”, you can customize this name as you like.

  1. using UnityEditor;
  2. using UnityEngine;
  3. public class LevelCreatorEditor : EditorWindow
  4. {
  5.    // Add menu named "My Window" to the Window menu
  6.    [MenuItem("Window/Level Editor")]
  7.    static void Init()
  8.    {
  9.       //Get existing open window or if none, make a new one:
  10.       LevelCreatorEditor window;
  11.       window = (LevelCreatorEditor)EditorWindow.GetWindow(typeof(LevelCreatorEditor));
  12.       window.Show();
  13.    }
  14. }

This new class should inherit from “EditorWindow” which is the base class for new extensions in Unity. You can see more details about this class in the manual. The class EditorWindow belongs to the UnityEditor library so we need to import it as well.

In this class a new static method called “Init” has to be added to show the new window and assign a name for it in the menu. In line 6 in the code above you can see that I set the path of the new menu to “Window/Level Editor”, the location “Window” represents the Window menu in the Unity editor, you can choose whichever menu you prefer to have your new extension. You can also customize the name of the new item in the menu by changing the “Level Editor” for whatever you like.

  1. int gridSize;
  2. float gridX;
  3. float gridY;
  4. Color gridColor = Color.white * 0.8f;
  5. Color cursorColor = Color.red;
  6. Color selectColor = Color.blue;
  7. bool showGrid = true;
  8. void OnGUI()
  9. {
  10.    //Header
  11.    BuildMenuHeader();
  12. }
  13. void BuildMenuHeader()
  14. {
  15.    GUILayout.Label("GRID SETTINGS", EditorStyles.boldLabel);
  16.    gridSize = EditorGUILayout.IntField("Grid Size (px)", gridSize);
  17.    gridX = gridSize / 100f;
  18.    gridY = gridSize / 100f;
  19.    gridColor = EditorGUILayout.ColorField("Grid Color", gridColor);
  20.    cursorColor = EditorGUILayout.ColorField("Cursor Color", cursorColor);
  21.    selectColor = EditorGUILayout.ColorField("Select Color", selectColor);
  22.    showGrid = EditorGUILayout.Toggle("Show Grid",showGrid);
  23. }

The “OnGUI” function is the one that renders all the elements you want inside your new window. In this particular case, I’m adding general properties for the grid just to illustrate how it works. You can directly put the GUI code inside this function but I’m getting the exact code I made for the tile editor, that’s why I added the “BuildMenuHeader” function.

The “BuildMenuHeader” basically includes all the elements that affect the grid and change the variable values according to whatever the user chooses.

We can see in line 16 a short example about how the variables are modified in real time, “EditorGUILayout.ColorField” takes a couple of parameters, the label for that element and also the current value, this function returns the modified value in real time, that’s why we use and modify the “gridSize” variable in the same line.


The previous section was about creating a very basic window with few elements that make our variables change in real time. The other important step for this post is about how to take those values we change and keep using them after we close the window. If we don’t do this, everytime that we close and re-open our new extension’s window, all the parameters will be initiallized again.

  1. bool loaded;
  2. void OnEnable()
  3. {
  4.    LoadData();
  5. }
  7. void OnDisable()
  8. {
  9.    SaveData();
  10. }
  12. void OnDestroy()
  13. {
  14.    SaveData();
  15. }
  17. ///
  18. /// Saves the current editor's status
  19. ///
  20. public void SaveData()
  21. {
  22.    string id;
  24.    id = PlayerSettings.productName;
  25.    EditorPrefs.SetInt(id + "-GridSize", gridSize);
  26.    EditorPrefs.SetString(id + "-CursorColor", FromColorToString(cursorColor));
  27.    EditorPrefs.SetString(id + "-GridColor", FromColorToString(gridColor));
  28.    EditorPrefs.SetString(id + "-SelectColor", FromColorToString(selectColor));
  29.    EditorPrefs.SetBool(id + "-ShowGrid", showGrid);
  30. }
  32. ///
  33. /// Convert an object from class Color into a serialized string
  34. ///
  35. public string FromColorToString(Color color)
  36. {
  37.    return color.r + "," + color.g + "," + color.b + "," + color.a;
  38. }
  40. ///
  41. /// Convert a string into an object from Color
  42. ///
  43. public Color FromStringToColor(string color)
  44. {
  45.    string[] desColor;
  46.    desColor = color.Split(',');
  48.    return new Color(float.Parse(desColor[0]), float.Parse(desColor[1]), float.Parse(desColor[2]), float.Parse(desColor[3]));
  49. }
  51. ///
  52. /// Restore the editor's status
  53. ///
  54. public void LoadData()
  55. {
  56.    string id;
  58.    id = PlayerSettings.productName;
  60.    if (EditorPrefs.HasKey(id + "-GridSize"))
  61.       gridSize = EditorPrefs.GetInt(id + "-GridSize");
  63.    if (EditorPrefs.HasKey(id + "-ShowGrid"))
  64.       showGrid = EditorPrefs.GetBool(id + "-ShowGrid");
  66.    if (EditorPrefs.HasKey(id + "-CursorColor"))
  67.       cursorColor = FromStringToColor(EditorPrefs.GetString(id + "-CursorColor"));
  69.    if (EditorPrefs.HasKey(id + "-GridColor"))
  70.       gridColor = FromStringToColor(EditorPrefs.GetString(id + "-GridColor"));
  72.    if (EditorPrefs.HasKey(id + "-SelectColor"))
  73.       selectColor = FromStringToColor(EditorPrefs.GetString(id + "-SelectColor"));
  75.    loaded = true;
  76. }

We have the “OnEnable” function that is executed every time the window is enabled; the “OnDisable” function that runs everytime the window is disabled and finally the “OnDestroy” function that runs when the window is closed. In these functions the status of the editor is saved and restored.

There are a couple of helpers in this part that make easier to save and restore objects from the Color class. “FromStringToColor” and “FromColorToString” are functions that transform the data to make the saving and restoring process easier.

The “SaveData” function basically stores all the important values in an internal storage (Editor Preferences). Depending on the type of data we want to save, we use different functions.

One important thing that has to be highlighted here is this: EditorPrefs.SetInt(id + “-variable id”, variable), the reason why we are using the “id” variable (this represents the name of the project) in the variable’s name is that this internal storage does not distinguish between projects, it means that if we do not add a project identifier, those values will be replaced if you try to use the editor again and we don’t want that.

The “LoadData” function just restores the data in the same way that the we save it but using the appropriate functions.


In this first post of a series on how to create a tile editor extension for Unity, we covered two basic steps: how to create a new window and how to store the data we modify using that window.

With these basic concepts you can create whatever you want, add more elements to the menu, include a different functionality or develop a completely different extension, I recommend testing all the elements you can add to a menu and play with it to understand better how it works, that’s what I did.

Upcoming posts will have details about the rest of the code and I will let you know as soon as the full extension is approved in the Unity Asset Store so you can download it and use it for your projects.

Tile Editor for Unity: Part I

Progress, Level Edition and Game Jam’s Feedback

This week I would like to talk about three different topics, the progress I’ve been making on the games I’m creating, the status of the Unity Level Editor and some thoughts on the past Ludum Dare 38 experience.


Fiery Squirrel is currently working on a couple of games. One of them is (tentatively) called Zin, which is the game that is benefiting from the new tile editor. There is also another game I mentioned in previous posts, Kuon’s Saga, developed in collaboration with Gabriel Uguet, illustrator and creator of Serpentarius, an online comic.


Zin is a action-puzzle game that narrates the story of a little creature unable to move by itself due to a magic curse. The creature needs to recover its powers and escape from its captors. This is a very simple game for computer and consoles that involves mastering different kinds of abilities and gameplay mechanics.

The game is still in very early stage of development, I’m currently focused on designing and testing the first level, including concept art, sounds, etc. The game is divided in four different chapters, each one with four levels.

In case you are curious, you can play a very early prototype made for Ludum Dare some time ago in Newgrounds. The game now includes many more things and it’s bigger but the essence is still the same.

For this week, the focus was to create and test levels with the new editor, which is really helping a lot with the new tiles and perspective of the art. I hope next will show some new screenshots and progress.

Kuon’s Saga

This is a game that has been in development for some time, despite its simplicity and its casual nature, we created different versions of the game and tested too many things on a very slow development pace.

The game is planned to be released for free at some point next month and will include one level with 24 waves for players to enjoy. Progressively, depending on players’ feedback and reactions, we will keep adding new content with new levels and challeneges. This will be available for Android and iOS.

This week has been basically working on completing all the final elements for the gameplay, including graphical stuff and level design. By next week we will have a very solid demo to show.

Level Edition

I have good news about the Unity Tile Editor. All the basic functionality is already working properly and we submitted it for approval to the Unity Asset Store. The editor will be free and available for people to download.

This first version is a beta that will be expanded in the upcoming weeks, there are a lot of things to improve, from the functionality side of the editor to the usability, we plan to add new stuff to help automatize cumbersome tasks and create levels faster and easier.

For all of you that are interested in the details on how was the editor created, I’ll be posting details about the code in future articles. If you have specific questions, please let me know.

The video shows all the current features that will be available for people when the asset is approved on the Asset Store.

Game Jam’s Feedback

As I mentioned in a previous post, I was part of the Ludum Dare 38 three weeks ago. After playing a lot of different games and receiving feedback from people on the game I made, I have some thoughts that might be useful for people making games out there.

First of all I want to thank people for their observations, getting feedback is really nice and one of the reasons I like participating in this event. Comments from people really help improving our work, they show us a perspective that we probably do not have or just different ideas that enrich our way of thinking.


When I talk about feedback, it’s not only players’ comments, ideas and bug reports. Feedback is also related to that concept of making your game react to the player’s input and be able to clearly show in the screen or  through speakers what is going on in your game.

I decided to talk a little about this because my most recurrent comment on other people’s games was exactly that: “it would improve a lot if it had more feedback”.

And this is something that I really think developers can easiy do. Feedback does not really require super high art making skills or 3D modeling years of experience, this is all about the feeling of the game, this is related to showing the status of the game in a very clear way.

In SORLD for example, although I know there is a lot to improve and much more feedback to add, the basic actions have clear feedback and they were implemented in very few time. Shooting, being hit, recovering, dying and making progress are some of the basic actions that this game includes and they were represented with particles, screen shake, sprite rotation, sound effects, etc.

Seriously, with few changes on the feedback side, adding particles, sound effects, changing the rotation a little, zooming in and out, in most of the cases make the game feel much better and meaninful and it’s not really a difficult thing to do.

Jan Willem Nijman from Vlambeer has more experience than me on this topic and he gave a nice talk about “Game Feel” which is related to what I mentioned here. Enjoy the talk if you haven’t already and hope this helps you make better games!

This was basically it for this week. A lot of things going on, I’m trying to keep people up to date about what we are doing here and get some comments on what would be interesting to talk about for future post.

Have a great weekend!

Progress, Level Edition and Game Jam’s Feedback

Level Editor


I’ve been slowly working in a project for computer and console devices, a puzzle-action game based on a prototype I made for Ludum Dare back in 2013. The idea evolved quite a bit and I’m focused now on more puzzles and action, the idea actually changed a lot but the base is still the same.


Since last year I’ve been writing code for physics, gameplay, etc using OpenFL for this projects and after a while I decided to start working with Unity (I want to release the game for consoles as well and it seemed easier). The game involves big levels now and a lot of level creation, so I wanted to use a tool to create levels easy and simple, this really saves a lot of time when testing and changing features.


First I decided to use Inkscape as a level editor, the tool itself is very good and combined with its possibility of generating XML code from the elements you add to the document (graphically) it’s very handy. I wrote a small parser on Haxe for a small prototype I created last year, also used in the first version of this new project I’m currently working on.

It really worked very well when I was using OpenFL. After deciding to work with Unity, I also tried to do the same thing because I wanted to keep the levels separated from the game engine and also Inkscape itself runs faster and better when I’m focused on creating only levels. I wrote a parser in C# of the XML code that Inkscape generates and it worked well too.

Generally speaking, Inkscape is a really good tool for creating levels, it is lightweight and very flexible. Inkscape was also doing the basic functionality I needed from the editor but there was still work to do to really make it good enough for this project.

Unity and Custom editors

Since I’m still in the process of learning about Unity and all its features, I didn’t know you could customize the editor and include custom scripts to minimize the efforts when doing cumbersome or repetitive tasks.

This week while reviewing some code, I found out that you can actually create your own menus and customize a lot of things. So I decided to play a little bit with that and try to create a very small tile editor for this game.

After struggling a bit about understanding how to make everything work, I was able to put together the most basic functionality for the tile editor I wanted: adding tiles as fast as possible, having a grid that snapped tiles automatically to it, removing and moving tiles.

Having this functionality inside the editor while creating levels and the possibility of adding more stuff like rotation, layering, etc is really a great advantage if you want to save time and avoid doing repetitive tasks. I will keep improving what I have so far, keep posting about it and share it when it’s in a decent state for people to play with it.


Before writing this post I thought about detailed explaining how to write a parser for Inkscape and how to create a custom editor for Unity, however, I’m not really sure if it’s worth it. A lot of people have done this before and probably they explain it better than me.

If someone wants to know details about what I did, I’ll definitely explain everything step by step, meanwhile, you can check out the following links that helped me a lot understanding how to both processes work.

Once I clean up the code for the Unity editor I wrote and the Inkscape parser, I’ll upload them to my repository in Github.

Ah, in addition to the new project, Fiery Squirrel is also focused on this new mobile game: Kuon’s Saga, I’ll talk more about it soon!

Level Editor

SORLD: Ludum Dare 38

This will be a short post about the result of a game I made for Ludum Dare 38 last weekend. I will basically cover why did I decide to participate and how did I come up with the idea.


Recently I’ve been very busy working on other projects that are planned to be released this year. However, after the theme was unvelied, I decided that if could find something that had a message I could transmit somehow (I want to make a full educational game in the future), I was going to participate.

In this case, I focused the brainstorming in two topics: what’s going on in Venezuela (my country) now  and global warming. I decided to go with the first topic because this is how I feel can contribute to what’s going on there, we can all contribute to a cause from different perspectives and my perspective is from the game development side.


The Jam lasts only two days and there was not a lot of time to decide what to do. As always I try to keep things as simple as possible and concentrate on a small idea.

important points for the game

  • Choose a message
  • Communicate the message clearly
  • Make something dynamic
  • Try as hard as possible make it fun
  • Polish as much as possible until the Jam is over


As message, I just wanted people to be aware of what’s going on in other countries, make people think about what’s happening in other parts of the world. I wanted people to understand that despite the fact that we have different cultures, live in different places and have different ways of thinking, we all belong to the same planet and should care about each other.

I said earlier that I wanted to focus on what is happening in Venezuela and it’s true, however I also think it’s important to take a look at other countries because people are suffering everywhere.


The message is communicated not only in an explicit way in the end of the game but also the whole mechanics are based on the idea of caring about others, helping and cooperating.

The rules of the game are:

  • Beat the aliens: To beat the aliens, members have to combine the power of their colors to attack
  • Stay alive: You need at least one house in your territory to respawn
  • You can attack any alien
  • You can give one of your houses away
  • You can repair your or someone else’s house

The game is made in a way that these rules are not explicitly taught. From the game you know you can move, grab and place houses, you can shoot and you can repair houses, but I don’t tell the player “to beat the aliens you need to cooperate”. The idea was that the player understood the rules by looking at the NPC or just using common sense.

The NPCs have different behaviors:

  • Attack an alien in my territory
  • If someone helps me, I’ll help too
  • Stay alive
  • Give the player a house if he is out of them

Since I didn’t have enough time to make things smoother, I included a condition to randomly decide to help someone sometimes, so the player could understand easier what to do.


The game is really simple. Since the theme of the jam was a small world, I just decided to make everything in a very small world created from four different parts. To add a fast pace, the aliens attack non-stop in a random way. In addition, all the NPCs work very hard to attack the aliens and try to stay alive too.

The focus here was trying to stay concentrated on the main message and make something enjoyable.


After all the basic elements were complete, I just focus on trying to add things that improved the experience of players.

I think that when time is very limited like in a game jam, one should focus first on adding important feedback after finishing the basic mechanichs of the game. Shooting, receiving damage, reparing a house and subtle details to explain how to play were the core of this part.

Also the planet reacts to what is happening in the game, if it’s attacked, everything shakes and when something good happens (like defeating an alien), it winks.

These things are very small but they improve the experience of the game as a whole. I really wanted to put more efforts here but… not enough time.

Wrapping up

This is it, I wanted to make a small post and I feel it’s very long already, so to wrap up, this jam for me was different and interesting for the following reasons:

  • First time I base everything on communicating a message
  • First experience using Unity for a game jam
  • I tried to make simple but pretty graphics with a different palette of what I use to
  • Programming the NPC was a challenge but really fun

So if you have any questions, let me know.

You can visit the Ludum Dare 38 entry here and play the game online or download it in your computer.

By the way, I’ll still think about the idea for the global warming game, I think it’s an important issue.


SORLD: Ludum Dare 38