A look into the Nova Engine

I know I don’t update this frequently, but when I do, o Man I bring big news.


After a year of training in react, redux and electron I’m starting a new piece of software:

Nova Engine

This engine is made in electron, yet it’s super green and unstable.

My idea is to make an engine for making 2D video games on javascript, but without writting code!

But wait, there are already programs like this, but this will force you into an Entity-Component-System way of working.  Wich means you can build many times of games quite easy.

I hope I can nail it to make it fun to use, and the games run well.


See you when I remember to write here.



How the entity-component-system blew my mind.

Ok, now, let’s get the new and funny experiment going…

Do you use Unity?

If yes, well, the idea behind the models, and behaviours, joined between scenes looks cool and promising, but…

What if I tell you there is a probably cooler way to work with?

Here I will talk about the alternative, similar yet different:

Entity-Component-System architecture.

How does it work, well, let’s put it simple.

We will think all of our usual models just entities, entities are that, a player, a tree, an enemy, everything you could think of it as a “model” by the MVC, is valid.

Except when it’s not. An entity doesn’t have any properties, but it behaves more likely a bag of components.

Components are small bits of models, for example, a component for position may only have  and x and a y as numbers, a sprite component may have a file attached to it.

And so on.

But you say, where is my game logic then?

And here is where the system appears.

A system is well, it takes a list of entities, and makes some processes on it.

For example, a movement system needs to have both entities with position an acceleration, or a drawing system must be all entities with an sprite or background attached, and so on.

You could think your entities are static, but the real power of this comes when the entities allow to add or remove components on the fly.

Yes, imagine this, you are playing an rpg, and your character gets petrified, then you just remove the “ActingComponent” of your Entity “Player” and then, the system automatically excludes your player from acting.

Also, you may want to disable entirely a system, imagine your character suddenly goes into space.

You just need to remove the “GravitySystem” and everything will run smoothly as you may expect.

Other alternative would be, if you have an “InputSystem” for “ControllerComponents” you could convert AI characters into playable characters and back to AI characters, by adding and removing this “ControllerComponent” from them.

This will make your life a lot easier to code, believe me.

At first I was confused, a lot, it looks confusing, but after a while it gets a lot simpler.

The difference between this system and the monolitic behaviour of Unity, is than here the true pivot of action is not the GameObject itself (or the entity), but the responsibility goes to the system instead.

Both alternatives have the ability to be really usable on game development, and both are entirely dynamic, you can attach or remove things from a game object, but nothing coordinates them by itself. Here your system are unique and shared among data.

So it may consume less memory, sometimes.

The disadvantage is of course, having to update a lot of systems may cost some performance. But as an Indie developer I don’t mind much, your game usually has processing power for this.

Another good thing, is than system could run in parallel, yes, parallel programming.

One should be careful of this anyway, because you know, race conditions and such.

Again, tools are tools, each has it’s uses, but if you ask me it’s like perfect for RPGs, and tactical games.

Probably a platform game won’t benefit much from it, still a platform game could be done this way.

If you want to really learn more, I suggest you take a look at Ashley, by far it’s simple to get what they try to teach probably a lot better than myself.

And this is now the looong part

Yes, I am still working on my project but there are some… *cough* problems.

Well not problems, but the scope is to be an online html5 game, this means than I need to make a lot of boilerplate before I can start with my game.

The scope of this game is mix forum, wiki, game and integrate the community with it, while you can play it for free (it’s not like this game is expensive to produce…)

Except for music, I really want to deploy an alpha and play with some alpha testers (wich they are interested at least a small group of 5 people)

I really hope I could make a public closed beta, but at the moment I can only test on local networks.

Sorry for this status, but it’s a way to remind myself of how I am working on it.

8-bit maps!

Well, I decide to make each writting for each little I am advancing with this project.

After taking some time I have to admit… 8 bit retro graphics are really easy, more if you try to work like nes, but with today’s technology.

Here is an updated version of the battle scene:

Of course, NES game would love to have something like this..
Of course, NES game would love to have something like this..

And here is a map for testings as the first town… Because rpgs must always start in a town in the middle of nowhere with a casttle to the north, right?

Tows in 8-bit feel so pacefull and so vibrant...
Tows in 8-bit feel so pacefull and so vibrant…

See you next time guys

Nostalgia, nostalgia, nostalgia

Hello, I’m planning on doing a NES-like game taking accout limitations it has on the ’80 and how hard was to make a game…

graphics are easy to do, kinda, of course it will be an RPG.

Here is a concept about how the game will look

Tribute to nostalgia
A tribute to nostalgia

Of course if it looks similar to other game, you may know why…

wich one ?

It’s a secret because trademarks will burn me alive D:

See ya fellas!

I was thinking lately…

Well, arround one year and a half ago, I became an engineer, and as my final project I made practically rgss again (at least 90% of it is done) it is done with openGL and other open source libraries, but my code is not open source, at the moemnt.

I have a friend who says I should keep my code “private” but I don’t want to touch it anymore, so I may release it if people are interested in seeing and improving it.

I will release it as a GPL editor (wich is the worst part anyway), but as a MIT game library…

Logo complete

Finally a clean design wich I like.

Usually is hard for me to like my own pixel art, but this is awesome. At least ok.

Now to start to fill this with real content at all. Use the banner if you like I won’t close my old blog just to make this one, the other will be archived as one.

Checking wich grammar should I use as my language goes on…

I am writting this because I am implementing a custom language (or at least, trying to)

Sonner or later there will be a github repository with all the info you may need, for now, let me keep it simple.

This post is to write about how the grammar of my language is planned to be, and how error will be handled.

First of all, I plan to do an open object system, like javascript does with its objects. But I may add classes and simple inheritance.

Do you want to see how I plan to make my code looks?

my_age: 23

Wich means 23 is assigned to a variable called my_age.

The code will try to use the python idea of identation meaning scope.

While this may look odd for programmers (we usually use = as assignment.. right?) this feels more natural as a language itself.

Let me add another thing:

my_obj : new Object

This looks like an object initialization like javascript, wich is good because classes are metaclasses here, more on the next part.

There is a function called import() wich will let you import a sandobex version of other file into your own, like ruby’s require, but inside a namespace.

system: import('system')

A new addition, the safe keyword:

My idea of a keyword used to check for errors, is a way to avoid the cluster of “try, catch, finally” and allow you to control your flow, safe can be used before any expression and after that it returns the expresion’s value or of course, an error.

system: safe import('system') # look at the safe here

You can check, if an error was executed or not, by doing something as simple as:

if system is Error
   # uh, oh, I couldn't load this
   # And take an "if example" too

looks clean, right ?

Oh, you want to send your own errors, then why not throw them as always?

throw new Error('I had bad news for you...')

Yes, that works.

The grammar aims to be as simple as it can be, that is why I’m taking so long to even make some decent progress, but after 1 year, I am happy with my result of studying how to makr my grammar clean.

Stay sync, good bye