How we used Entity Component System (ECS) approach at Gemserk - 2/2

So, after our first attempt on using ECS, when we started to develop mobile games and moved to the LibGDX framework, we decided to abandon our ComponentsEngine and start over.

We were still reading about ECS while we were creating our set of tools and code over LibGDX. At some point in time, some of the Java community developers started Artemis, a lightweight ECS, and we decided to give it a try.


This is a simplified core architecture diagram:

Note: we used a modified version of Artemis with some additions like enable/disable an Entity.

In this pure approach, Entities and Components are just data, and they are related by identifiers, like these tables in a relational database:

Where we have two entities, both with a PositionComponent and only one of them with MovementComponent.

An example of this components in code:

public class PositionComponent : Component {
    public float x, y;

public class MovementComponent: Component {
    public float speed;

EntitySystems perform the game logic. They normally work on a subset of Components from an Entity but they could need it in order to enable/disable/destroy it (if it is part of its logic).

An example of a System is LimitLinearVelocitySystem, used in multiple of our games to limit the physics velocity of an Entity with PhysicsComponent and LimitVelocityLimitComponent:

public void process(Entity e) {
    PhysicsComponent physicsComponent = 
    Body body = physicsComponent.getPhysics().getBody();

    LinearVelocityLimitComponent limitComponent = 
    Vector2 linearVelocity = body.getLinearVelocity();

    float speed = linearVelocity.len();
    float maxSpeed = limitComponent.getLimit();

    if (speed > maxSpeed) {
        float factor = maxSpeed / speed;

There are some extra classes like the TagManager which allows assigning a unique string identifier to an Entity in order to find it, and the GroupManager which allows adding entities to groups identified by a name, which is more like how tags are used everywhere else.

Even though it could look similar to our ComponentsEngine where the Properties in that engine correspond to the Components in this one, and Components to Systems, there is an important difference: Systems are not part of an Entity and work horizontally over all entities with specific Components (data). So, in this approach, changing only data from entities indeed change their behaviour in the game, so it is really data driven.

Since Entities and Components are just data, their instances in memory are easier to reuse. An Entity is just an id, so it is obvious. A Component is a set of data that doesn't care too much which Entity it belongs to. So, after the Entity doesn't need it anymore, it could be reused elsewhere, improving a lot memory usage and garbage collection.

Artemis, and other pure ECS implementations, are really lightweight and performant frameworks. The real power comes from the Systems and Components built over them. In our case, we created a lot of Systems that we started to reuse between games, from SuperFlyingThing to VampireRunner and even in Clash of the Olympians.


One of the most interesting ones is the Scripting framework we created over Artemis. It was really useful and gave us a lot of power to overcome some of the limitations we were facing with the pure approach when we need to create a specific logic for a specific moment during the game and (probably) never again and we didn't want a System for that.

They work similar to Unity MonoBehaviours and our logic Components from ComponentsEngine, and they also belong to the Entity lifecycle. One difference, however, is that they try to avoid storing data in their instances as much as possible and instead try to store and read data from Components, like Systems do.

Here is an example Script from one of our games:

public class MovementScript extends ScriptJavaImpl {
  public void update(World world, Entity e) {

    MovementComponent movementComponent = Components.getMovementComponent(e);
    SpatialComponent spatialComponent = Components.getSpatialComponent(e);
    ControllerComponent controllerComponent = Components.getControllerComponent(e);
    Controller controller = controllerComponent.controller;
    Movement movement = movementComponent.getMovement();
    Spatial spatial = spatialComponent.getSpatial();
    float rotationAngle = controllerComponent.rotationSpeed * GlobalTime.getDelta();
    Vector2 linearVelocity = movement.getLinearVelocity();
    if (controller.left) {
        spatial.setAngle(spatial.getAngle() + rotationAngle);
    } else if (controller.right) {
        spatial.setAngle(spatial.getAngle() - rotationAngle);

Note: GlobalTime.getDelta() is similar to Unity's Time API.

One problem about the Scripting framework is that it is not always clear when some logic should be in a Script or a System, and that made reusability a bit harder. In the case of the example above, it is obvious it should be moved to a System.


Another useful thing we did over Artemis was using templates to build entities in a specific way, similar to what we had in ComponentsEngine.

We used also a concept of Parameters in templates in order to customize parts of them. Similar to ComponentsEngine, templates could apply other templates and different templates could be applied to the same Entity.

Here is an example of an Entity template:

public void apply(Entity entity) {

    String id = parameters.get("id");
    String targetPortalId = parameters.get("targetPortalId");
    String spriteId = parameters.get("sprite", "PortalSprite");
    Spatial spatial = parameters.get("spatial");
    Script script = parameters.get("script", new PortalScript());

    Sprite sprite = resourceManager.getResourceValue(spriteId);

    entity.addComponent(new TagComponent(id));
    entity.addComponent(new SpriteComponent(sprite, Colors.darkBlue));
    entity.addComponent(new Components.PortalComponent(targetPortalId, spatial.getAngle()));
    entity.addComponent(new RenderableComponent(-5));
    entity.addComponent(new SpatialComponent(spatial));
    entity.addComponent(new ScriptComponent(script));

    Body body = bodyBuilder //
            .fixture(bodyBuilder.fixtureDefBuilder() //
                    .circleShape(spatial.getWidth() * 0.35f) //
                    .categoryBits(CategoryBits.ObstacleCategoryBits) //
                    .maskBits((short) (CategoryBits.AllCategoryBits & ~CategoryBits.ObstacleCategoryBits)) //
                    .sensor()) //
            .position(spatial.getX(), spatial.getY()) //
            .mass(1f) //
            .type(BodyType.StaticBody) //
            .userData(entity) //

    entity.addComponent(new PhysicsComponent(new PhysicsImpl(body)));


That template configures a Portal entity in SuperFlyingThing which teleports the main ship from one place to another. Click here for the list of templates used in that game.

Interacting with other systems

Sometimes you already have a solution for something, like the physics engine, and you want to integrate it with the ECS. The way we found was to create a way to synchronize data from that system to the ECS and vice versa, sometimes having to replicate a bit of data in order to have it easier for the game to use it.


Even though we had to do some modifications and we know it could still be improved, we loved using a pure ECS in the way we did.

It was used to build different kind of games/prototypes and even a full game like the Clash of the Olympians for mobile devices, and it worked pretty well.

What about now?

Right now we are not using any of this in Unity. However we never lost interest nor feith in ECS, and there are starting to appear new solutions over Unity in the last years that caught our attention. Entitas is one of them. The Unity team is working towards this path too as shown in this video. Someone who din't want to wait started implementing that solution in his own way. We've also watched some Unite and GDC talks about using this approach in big games and some of them even have a Scripting layer too, which is awesome since, in some way, it validates we weren't so wrong ;).

I am exited to try ECS approach again in the near future. I believe it could be a really good foundation for multiplayer games and that is something I'm really interested in doing at some point in my life.

Thanks for reading.




VN:F [1.9.22_1171]
Rating: 0.0/5 (0 votes cast)

How we used Entity Component System (ECS) approach at Gemserk - 1/2

When we started Gemserk eight years ago, we didn't know which was the best way to make games. So before starting, we did some research. After reading some articles and presentations we were really interested in trying an Entity Component System (ECS) approach for our games. However, since we didn't find a clear guide or implementation at that point we had to create our own solution while exploring and understanding it. We named our engine ComponentsEngine.

Components Engine

The following image shows a simplified core architecture diagram:

Note: part of the design was inspired by a Flash ECS engine named PushButtonEngine.

An Entity is just a holder of state and logic. In an ECS, anything can be an Entity, from an enemy ship to the concept of a player or even a file path to a level definition. It depends a lot on the game you are making and how you want to structure it.

A Property is part of the state of an Entity, like the health or the position in the world, anything that means something for the state of the game. It can be accessed and modified from outside.

Components perform logic updating one or more Properties to change the Entity state. A component could for example change the position of an Entity given a speed and a moving direction.

They normally communicate with each other either by modifying common Properties (when on the same Entity) or by sending and receiving Messages through a MessageDispatcher (when on the same or on different Entities). They just have to register a method to handle a message. In some way, this is pretty similar to using SendMessage() method in Unity and having the proper methods in the MonoBehaviours that need to react to those messages.

EntityTemplates are an easy way to define and build specific game entities, they just add Properties and Components (and more stuff) to make an Entity behave in one way or another.

For example, a ShipTemplate could add position, velocity and health properties and some components to perform movement and to process damage from bullet hits:

public void build() {
        // ... more stuff 
        property("position", new Vector2f(0, 0));
        property("direction", new Vector2f(1, 0));

        property("speed", 5.0f);

        property("currentHealth", 100.0f);
        property("maxHealth", 100.0f);

        component(new MovementComponent());
        component(new HealthComponent());

An example of the MovementComponent:

public class MovementComponent() {

   Vector2f position;

   Vector2f direction;

   Float speed;

   public void update(Message message) {
      Property<Float> dt = message.getProperty("deltaTime");
      position += direction * speed * dt.get();


In some way, EntityTemplates are similar to Unity Prefabs or Unreal Engine Blueprints, represeting in some way a (not pure) Prototype pattern.

Some interesting stuff of our engine:

  • Since templates are applied to Entities, we can apply multiple templates to the same one. In this way, we could have common templates to add generic features like motion for example. So we could do something like OrcTemplate.apply(e) to add the orc properties and components and then MovableTemplate.apply(e), so now we have an Orc that moves.
  • Templates can apply other templates inside them. So we could do the same as before but inside OrcTemplate, we could apply MovableTemplate there. Or even use this to create specific templates, like OrcBossTemplate which is an Orc with a special ability.
  • Entities have also tags which are defined when applying a template too and are used to quickly identify entities of interest. For example, if we want to identify all bullets in the game, we could add the tag "Bullet" during the Entity creation and then, when processing a special power, we get all the bullets in the scene and make them explode. Note: in some ECS a "flag" component is used for this purpose.
  • The Property abstraction is really powerful, it can be implemented in any way, for example, an expression property like "my current health is my speed * 2". We used that while prototyping.

Some bad stuff:

  • Execution speed wasn't good, we had a lot of layers in the middle, a lot of reflection, send and receive messages (even for the update method), a lot of boxing and unboxing, etc. It worked ok in desktop but wasn't a viable solution for mobile devices.
  • The logic started to be distributed all around and it wasn't easy to reuse, and we started to have tons of special cases, when we couldn't reuse something we simply copy-pasted and changed it.
  • There was a lot of code in the Components to get/set properties instead of just doing the important logic.
  • Indirection in Properties code was powerful but we end up with stuff like this (and we didn't like it since it was too much code overhead):
e.getProperty("key").value = e.getProperty("key").value + 1.
  • We didn't manage to have a good data driven approach which is one of the best points of ECS. In order to have different behaviours we were forced to add both properties, components and even tags instead of just changing data.

Note: Some of these points can be improved but we never worked on that.

Even though we don't think the achitecture is bad, it guided us to do stuff in a way we didn't like it and didn't scale. We feel that Unity does the same thing with its GameObjects and MonoBehaviours, all the examples in their documentation go in that direction.

That was our first try to the ECS approach. In case you are interested, ComponentsEngine and all the games we did with it are on Github and even though they are probably not compiling, they could be used as reference.

This post will continue with how we later transitioned to use a more pure approach with Artemis, when we were more dedicated to mobile games.


Evolve your hierarchy - Classic article about Entity Component System.

PushButtonEngine - Flash Entity Component System we used as reference when developing our ComponentsEngine.

Game architecture is different - A quick transformation from normal game architecture to ECS.

Slick2D - The game library we were using during ComponentsEngine development.


VN:F [1.9.22_1171]
Rating: 0.0/5 (0 votes cast)

Pigs Mayhem in Space, our Ludum Dare Jam #38 entry

After some years of Ludum Dare (LD from now on) inactivity, we decided to participate in LD #38 Jam. And when I say we I mean Rubén and I! Of course, since we are great artists, we joined forces with Thony, a young artist who is really really good (just open the link and see it by yourself).

The theme of this LD was "A small world" and our game was Pigs Mayhem in Space:

After iterating over a thousand ideas (yeah, I like to exaggerate, they were only 999) the first day, we ended up with a 3d, turn by turn game where you have to use projectiles and physics to kill the other players (like Worms). This is one of the first concept:

And this is the how the game looked at the end:

Play the game!

Small post mortem

The bad

  • It took us a lot of time to define the game, and that means we did a lot of work on stuff we didn't use.
  • We didn't spend time polishing the controls and when we wanted it was already too late. That affected a lot the game experience.

The good

  • We were aligned with the game we wanted to do and with almost every decision.
  • The art style was quickly defined and without setbacks. It helped a lot to visualize the final game.
  • Working together was really smooth, the game was first and all decisions were to make the game better.


Even though Rubén and I work together at Ironhide, we are not in the same team and even though we share stuff between projects, I missed a lot working directly with him in the same project, since, you know, we fight discuss a lot but the results are always better 🙂

This was my first time working with Thony (Rubén and Thony work in the same team at Ironhide) and it was prety awesome. He has good control on 3d tools and Unity and does great 2d art (the game proves it!).

As always, it was a great experience, it helped on exercising the creative process of developing games and learning how different kind of games are made.


The game at itchio

Thony's ArtStation page

Some visual references










VN:F [1.9.22_1171]
Rating: 0.0/5 (0 votes cast)

Did you miss us?

Hi guys, long time no see.

It's been a while since we came here and write, and we want to share why.

What happened

By the end of 2012, after we finished Clash of the Olympians to Android and iOS working hand in hand with Ironhide Game Studio, we had no ideas to work on. We weren't really excited in working by ourselves anymore because we didn't feel we could create something of the quality of Clash. Also, we really enjoyed working with Ironhide's team. In addition, Ironhide was looking for programmers and they told us they enjoyed working with us as well, so they offered us a job and we couldn't refuse (and we are still glad we did not).

Working at Ironhide

Two words: Indescribable awesomeness.

We are part of an excellent and diverse team composed by artists, developers, game designers and more. The workplace is comfy and the game development workflow is pretty dynamic. We can participate in a lot of game decisions and that rocks!

Working really close with artists allowed us to validate how much we needed one at Gemserk to define ideas and visualize, in an easy way, how our games should look like. It also works as motivation since you really want to see that art in the game.

Game design was another flaw at Gemserk, and we now see and understand it much better.

We learn new stuff each day and we also collaborate and share our knowledge to make the game and the team better. And at the end of the day, that feels really good. We hope it lasts long.

What about Gemserk

As company, Gemserk is kinda dead. We never reached what we wanted with our creations, and in those terms, we weren't successful. However, we don't see Gemserk as a failure either since we accomplished a lot in terms of technical knowledge and relationship with other game developers and tool makers and we are really happy with that.

We have no plans to work on anything Gemserk related for now but we believe we still have some stuff to share.

Thanks for reading our blog and hope we could still write interesting posts in the future.

The Gemserk team.

VN:F [1.9.22_1171]
Rating: 4.4/5 (9 votes cast)

Our participation in Global Game Jam 2012 Uruguay

Uruguay decided to join the Global Game Jam 2012 (GGJ12) for the first time and we (as Gemserk) decided to join them.

The Global Game Jam is an event where all around the world people get together in different locations and split into teams in order to make games in 48 hours following a theme set by the organizers.

This year, the theme was this picture:


That image represents the Ouroboros which represents the perpetual cyclic renewal of life, the eternal return, and represents the cycle of life, death and rebirth, leading to immortality, as in the phoenix.

The Team

Our team was composed game by José Pedro Gioscia (The Artist), Washington Miranda (Programmer) and us (both Programmers). Hernán Gonzales Martinez from Tono Sound Production provided the music and sound effects for our game, he did the same thing for most of the other teams on our location.

The Game

The game was named Medusa - “La viborita multiloca”, you play the game as a serpent on space and you move horizontally around a cave eating or being hit by other monsters. Whenever the monsters or the obstacles hit your body it breaks from that point. If the remaining part of your body is too short, you are weakened and can't eat monsters anymore. You die if you hit an obstacle or hit a monster while you are weakened.

The interesting part of the game is that after death comes rebirth. When you die, you revive at the start of the level with an echo of your past lives. They will help you in your journey eating the monsters in their path but they will leave parts of their bodies as new obstacles when they are injured.

Right now the game has no defined objective, it is more an experimental test of the mechanics and when you play you make your own objectives enjoying going through the random level and interacting with your past lives on the world.

Play the game online, or download a runnable jar to play it. Control the snake with the arrow keys.

Conclusions about the Global Game Jam

What went wrong

  • Ironically even though the venue was in a building of the biggest ISP on Uruguay (Antel) the wifi sucked, it used a captive portal method of authentication and forced you to reauthenticate all the time, luckily we could steal the LAN connection from some unused PCs.

What went right

  • We delivered a finished game
  • We were able to meet and talk with lots of people that are working locally in the video games industry (Batoví, Powerful Robot, Belfry Games, Sebagames).
  • We were finally able to get to talk a little with Pablo Realini from IronHide Game Studio makers of the awesome Kindom Rush, who confessed that he is the biggest fan of Gemserk 😉
  • The whole organization and the people who coordinated the GGJ in Uruguay were awesome, the venue was really nice, we had food and drinks available (from the second best carbonated beverage and the second best big burger chain).
  • Everyone on the jam was really nice, included our team members, there were no problems between the participants, and it was great meeting all of them.
  • This was the first time we worked face to face with an artist.
  • We had fun 🙂

Advice for other jams

  • Take your time to refine your game idea, don't just start implementing right away, think a little about how will the gameplay work, what will the player do, how will he feel when playing, are the mechanics natural, how will you explain them, etc.
  • A good way to split work between programmers is to make small prototypes of different parts of the game (in our case we started prototyping the snake behaviour while we were building the skeleton for the rest of the game)
  • Try to rest, trying to stay up both nights of the event will be too much for your body to handle, and you will be tired and it will be difficult to concentrate, making you make lots of mistakes. In our case we went home to sleep on Friday night after we had defined the game idea, and we started Saturday morning well rested.
    • Play the other games for the GGJ12 from Uruguay here.

      We hope you like it.

      VN:F [1.9.22_1171]
      Rating: 4.0/5 (1 vote cast)

Ludum dare 22 - Leave me alone!! - Post mortem

Leave me Alone!! was my game for Ludum Dare 22 introduced in this post, now I want to make a small post mortem as I did for my previous Ludum Dare games.

First of all, I was about to not enter this LD because I couldn't spend all the weekend to develop a game but in the end I did because I didn't want to break the habit.

As I explained in the previous post (it has images and videos), Leave me Alone is casual game where you use the mouse (on PC at least) to move an orange particle which has to be isolated from incoming blue and green particles with different behaviors.

LD rating stage finished the previous Saturday and these are the results for my game:

	#114	Fun		3.04
	#168	Community	2.93
	#380	Overall		2.62
	#409	Innovation	2.28
	#458	Theme		2.35
	#519	Humor		1.42  (how??)
	#585	Coolness	17%
	#592	Mood		1.61
	#594	Audio		1.00
	#650	Graphics	1.68

What went wrong

  • Didn't like the theme Alone too much and my first ideas in mind were too complex.
  • My dedication time was limited and I couldn't work a complex idea instead the one I made, or even spend more time to add more value to the selected idea.
  • Didn't dedicate too much time to gain visibility (more info later).
  • My graphics were too simple, there is no background, no effects, no nothing. There are no sounds either.
  • I made a timelapse but I was out all the time and it sucks so I never uploaded it to youtube.
  • Didn't worked on the Android version controls and current one is almost unplayable, that means no Android players.

What went well

  • Even though I had little time to spend on the game, I refine one of the possible game ideas to make it smaller and be able to finish it on time.
  • Game is fun despite being small and simple (could be better of course).
  • The game had some visibility even though I spend almost no time in promoting it (more info later).
  • Even though some people "called me crazy" 😛 for using a physics engine for a game like this one, I believe it was a correct choice since I know Box2d enough to simplify my life. For example, all movements in the game are made using forces on each body (the particles) and the result is a good simulation of a real movement. Also, all collision logic is solved for me so I have to code less.

How to get visibility to your game

When you make games in LD you have to make other LD participants to rate your game since is the only way to get rated. There are different ways to improve the visibility of your game:

  • Have already a lot of visibility, for example, if you are a known celebrity like Notch (soooo many comments) or Kevglass, between others, your game will be played (at least I will play them).
  • Make a great game (the main idea of the LD), then people will start to make comments about it, tell to friends, make blog posts, etc.
  • Promote the game during the development by making blog posts on LD blog, record timelapse and stream your development, between other possibilities, this allows you to get a lot of players when the game is released.
  • Promote it by making it easy to play, maybe an online mutiplatform version (applet or flash), if you make your game only for win7 with XNA 8.0 you will probably lose some potential players. Make a good gameplay video too so people could watch your game without having to play it, maybe you could even convince them to install XNA 8.0 to play your game 😉
  • If you have time after development, play other LD games, rate them and make comments about them because this is one of the best ways to get other participants to play your game and, in the best case scenario, to rate it and even make comments.

In conclusion, it always feels nice to participate in LD, and I am happy with the game I did Although I had not so much time to spend. Next time maybe I could do better.

Hope you like the post 😀

VN:F [1.9.22_1171]
Rating: 5.0/5 (2 votes cast)

Vampire Runner score on Ludum Dare 21

Ludum Dare 21 is finished and rating time too and we have the rating results.

Vampire Runner was #290, not so good as other of our previous Ludum Dare games, but on the other hand there was a lot of games in this one, almost three times the games of the previous Ludum Dares.

Here are the scores Vampire Runner got in this Ludum Dare:

Position	Category	Score

#87		Community	3.22
#144		Coolness	4%
#159		Fun		2.94
#168		Humor		2.18
#290		Overall		2.75
#305		Graphics	2.50
#339		Audio		1.29
#345		Innovation	2.38
#450		Theme		2.00

Now, I want to share a small post mortem of the game and explain why I feel the score is what I expected.

What went wrong

  • As the game started like some kind of Canabalt clone, because my lack of imagination, I was a bit unmotivated so Saturday progress was really slow and unproductive.
  • I feel I lost too much time making the vampire animations and forgot about the environment assets.
  • The game lack of audio and that goes against the Ludum Dare score.
  • I forgot to reflect inside the game the connection with Ludum Dare's theme.
  • Missing on-line high scores: it shouldn't be so hard to add it as I have Face Hunt (and other games) experience but I was a bit lazy and didn't. One reason to have this one is to make the game more competitive and also to know who is playing the game.

What went right

  • On Sunday, I almost restarted the way I was making the game and focused on making it really small and fun. It kinda worked.
  • Making the game available on a lot of platforms: Linux, Mac, Windows and Android.


I totally agree with the score of the game because I started with no motivation and for that reason I didn't tried so hard, obviously that goes against making a good game. Here is a list of why I agree or not with each score.

  • Community: I shared a lot of stuff: source code, timelapse, made it work on multiple platforms. I believe that counts as community rating, so 3.22 is right for me.
  • Fun: Game IS fun (at least I feel that and some other people does), so 2.94 is right for me (maybe a bit more).
  • Humor: Game has a bit of humor when the vampire explodes, and maybe the vampire graphics are funny too, but only that, so 2.18 is right for me (even more than I expected).
  • Graphics: Only the vampire animation is something worth to value here, the background and obstacles are not so cool, so 2.50 is around what I expected.
  • Audio: Game has no audio, I am not agree with the score of 1.29.
  • Innovation: Game is almost a clone of Canabalt with some modifications, it has a bit of innovation but not too much, so I agree with a score of 2.38.
  • Theme: If you read the game description, it says what was the intention of the theme connection but as I failed to reflect that inside the game I believe 2.00 is right for me.

Thats all, hope you like it.

VN:F [1.9.22_1171]
Rating: 5.0/5 (1 vote cast)

Ludum Dare 19 Results

Well, Ludum Dare 19 is finished, obviously Discover the Way didn't won any category, but at least we have some feedback.

The game made position 58 of 133, this is its rating:

Inn Fun The Gra Aud Hum Ove Com
3 3 3 4 2 - 3 -
2 3 2 3 2 2 3 5
4 3 2 3 2 2 3 3
3 3 2 3 3 - 3 3
2 1 1 3 1 1 2 -
3 4 5 3 - 2 4 5
2 2 2 3 2 1 2 -
2 3 2 4 2 1 3 4
3 3 1 3 3 - 3 3
4 5 3 4 3 1 4 3
2 2 1 3 3 - 3 3
3 3 2 3 2 2 3 2
3 3 2 3 3 - 3 3
3 1 1 3 2 - 2 2
3 3 3 3 2 - 3 4
4 2 4 4 4 - 3 4
2.88 2.75 2.25 3.25 2.40 1.50 2.94 3.38

Follow the link to the game page at the contest if you want to see users comments, remember though that people rated the first version which was not polished nor balanced enough.

Here you can see all Ludum Dare 19 results.

Some final thoughts:

First of all, I really liked the idea of the game, but on the other hand I knew it wasn't going to win. However, I believe I made some mistakes that made the game have a worse rating.

The first mistake was the name, I named the game Discover the Name because I had no game by that moment, I was deciding what to do and though it was a funny name. After realizing the main objective was to discover a safe path between two points, then I thought to change the name to Discover the Way or Discover the Path, to give the player an idea of what he has to do, but I didn't. That caused confusion to the players because they were expecting they have to discover a hidden name, not a hidden path.

Another mistake was to be to lazy to make some balance to the game before the contest ends, I finished the game about 2hs before but I was tired so I entered that version. The day after, I took less than 1hr to balance it a bit, and the game changed a lot, it became more playable and it gave more importance to the main objective because the player couldn't take shortcuts to the targets any more, he has to discover a safe path, that is the real relation to the contest Theme (Discovery).

The third mistake, less important than the others was to remove the gameplay video from the game's page. The game's entry allow contestants to put only 5 links. At fist I put a link to the game, to the source code, a link to our blog, a link to the a gameplay video and a link to the jam version of the game, but after I uploaded the timelapse video to youtube I had to remove one of the links and the gameplay video seemed to be the best choice because I had a link to it inside our blog. That was a mistake because new players watched the gameplay video to see what they have to do in the game, it was some kind of tutorial, without it players felt disoriented.

I made a short postmortem at Ludum Dare's blog, follow the link if you want to read it.

That's all, thanks for reading.

UPDATE: added game position and updated link to Ludum Dare 19 results in order.

VN:F [1.9.22_1171]
Rating: 0.0/5 (0 votes cast)