Alegría 2D Game Engine

Info

Alegría is an open-source 2D Game Engine for Windows being written in C++ . It makes use of OpenGL for rendering, Box2d for physics simulation, Win32 API for input and OpenAL for sound, and supports Python scripting.

Right now it's being developed by me, a student of the UPV as a didactic, non-profit project.

The last version of the engine with some demos can be found there: https://www.dropbox.com/s/iymviej8nekelqc/Alegria.zip

A postmortem of the project (as it's currently on hold) can be found here: http://www.reddit.com/r/gamedev/comments/1jrqr6/alegria_my_2d_gamedev_engine_editor_demos/

Engine features

• 2D hardware-accelerated rendering.
• Python scripting.
• Entity-Component architecture.
• Physics and collision detection (via Box2D).
• Sound (via OpenAL).
• Bitmap text support.
• Particle systems.

Editor features

• Completely GUI driven entity edition.
• 2D viewport for entity placement & transformation.
• Embedded script editor with syntax highlighting and text completion.
• Seamless integration with the engine. Press a button to run the scene you are editing.
• Image, sound and script management.

News

Update 20/06/2013

Update to the editor!

Update 21/03/2013

Working on my interactive portfolio while improving the engine, here are videos of some of the minigames I'm developing:

http://www.youtube.com/watch?feature=player_embedded&v=AkryhTgH9e0' target='_blank'>http://img.youtube.com/vi/AkryhTgH9e0/0.jpg' width='425' height=344 />

http://www.youtube.com/watch?feature=player_embedded&v=yuE8IzhBctc' target='_blank'>http://img.youtube.com/vi/yuE8IzhBctc/0.jpg' width='425' height=344 />

Update 30/January/2013

Great news! Alegria Engine (and its editor) has been approved as my Final Year Project for my Computer Science degree. This means that, from now on, I'll be able to work a lot more on the project, hence boosting its development and its documentation. It's going to be a lot of work, but I'm definitely very excited for this!

On other news, Alegria Editor is finally on a usable state! It meshes perfectly with the engine and some people are already using it to improve its use. Will post a binary soon for public use.

Update 22/January/2013

Aaaand, here I am again a year or so later. I got kind of tired of the project and decided to abandon it for a while to do other things (mostly partying and developing for Android). But after all I felt I needed to finish this. I'm full of energy and Alegria is alive again. These days I've been mostly working with the Alegria Editor, and finally supports full XML save and loads, which means that it's ACTUALLY close to release state. The bad news is that the engine itself needs major tweaks to match the editor, but I hope it doesn't take a lot.

Update 01/December/2011

Alegria Editor will be soon in release state! Probably in February, or so... Here goes a screenshot of its current state:

Update 21/October/2011

Long time since last update. Been working mostly on Alegria Editor, and the process is running smoothly, soon it will be usable and hence the Alegria package (must find a name for that) will be complete. Opened a new google code project for the editor so the updates can be tracked: http://code.google.com/p/alegria-editor/

On the other hand, about a week ago me and some friends entered a friendly-ish game jam using the Alegria Engine. It was a successful experience, as I managed to detect some bugs and proved the engine to be trustworthy and easy to learn. Here goes a video of the game (done in ~2 days).

http://www.youtube.com/watch?feature=player_embedded&v=5UUSUJhlh7o' target='_blank'>http://img.youtube.com/vi/5UUSUJhlh7o/0.jpg' width='425' height=344 />

Update 09/August/2011

Last couple of weeks I've been doing random stuff. This includes trying to improve the performance, fixing bugs, adding some features, documenting... Lots of things and none finished yet, there's a lot of work to do! Been toying around with QT too, seems like I will develop AlegriaEd with it, but it's a huge amount of work, will start when the summer is over, probably.

So, if you know about interface programing with QT and wanna help, email me! :D

Lastly, I've been playing around the Alegria Demo #1 idea, here's a video I've made.

http://www.youtube.com/watch?feature=player_embedded&v=0Oheut5JNtE' target='_blank'>http://img.youtube.com/vi/0Oheut5JNtE/0.jpg' width='425' height=344 />

Would be great to have someone helping me with the graphics too. Feelin' lonely today :D

Update 28/July/2011

Message subsystem implemented too. Gonna take a break from developing for a while, and will spend the next days/couple of weeks commenting the code properly, and documentating the overall project through the wiki.

Update 27/July/2011

Collision detection fixed too. I finally implemented the b2ContactListener and merged it into the Physics Subsystem, so now the collisions are more accurate.

Also updated the Physics component interface. Now the user can get both the entities the caller has collided with and the collision points.

Update 26/July/2011

Fixed some performance issues. Must fix some collision detection issues though. The code right now is a bit of a mess, need to clean it a bit. Maybe when Alegria Demo #1 is finished... and documentation too... sigh :)

On the other hand Particle Systems are implemented! It's nice to see the roadmap/feature list being completed day after day! Here goes a video showcasing it.

http://www.youtube.com/watch?feature=player_embedded&v=CoNkGkBgevE' target='_blank'>http://img.youtube.com/vi/CoNkGkBgevE/0.jpg' width='425' height=344 />

Update 23/July/2011

Been working hard these days! Here go the changes: * Sprite animation support implemented. Needs to be polished through animation playback functions. * Mouse support implemented. * Dynamic text implemented. Probably needs polishing too, but looks great so far.

Next goal: improve those things and implement a messaging system. Yay!

Update 22/July/2011

Added the "inv" parameter to the conditions. Conditions can now be inverted, so they trigger when, for example, a key is NOT pressed. The "omega" parameter is working perfectly now.

Also added the Always component. It lets the user call a script automatically, every frame (or with a given interval modifying the "omega" parameter of the condition).

Update 20/July/2011

Added the "omega" parameter to the conditions. Now conditions can be triggered at a given frequency. The higher the omega, the lower the frequency. Idea grabbed from the pulse mode mechanic from Blender's Game Engine. Not completely working, but will be soon.

I also started to think about the first demo made with the engine. It will be called "Alegria Demo #1". Yes, I suck at naming things :D It's probably going to be some kind of arkanoid shooter or something around that idea.

Update 05/July/2011

Big updates! Box2d is up and running, which means we've got physics in the engine! The interface to access to physical properties from python is still in an early phase, but it already lets the user apply forces, torques and impulses. I made a crappy video to show it up :)

http://www.youtube.com/watch?feature=player_embedded&v=cNo1gIyFlbo' target='_blank'>http://img.youtube.com/vi/cNo1gIyFlbo/0.jpg' width='425' height=344 />

This is taking shape!

Update 21/June/2011

Fixed all the C++/Python interactions mess, finally :) A cleaner new system has been implemented and will hopefully bring no memory/reference problems to the table. Already checked it in the To-Do list which you can visit here. (:

Update 20/June/2011

Just finished exams, time to get back to work :)

Update 22/May/2011

Probably the last thing I'll do before exams end, here's a kind of roadmap for the project: Road Map

Update 21/May/2011

Been coding a lot since last update. I'm happy to say that the engine is somewhat alive now. Here are the updates:

• Rendering subsystem running smoothly, both normal (textured) and wire modes.

• Keyboard subsystem coded. Need to do some tweaks but it works just fine.

• Python embedding working, but need some fixes on references, I think.

• Logic system coded too. It's based on Conditions, Triggers and script calls. When exams are over I'll write some documentation on that matter.

The immediate consequence of those parts being finished is that now the user can relate one or more actions (v.g. pressing a key) to a python script.

I'll be coding a lot less until exams are over (17th of June). Then I'll fix and tweak some things and get my hands on coding the other subsystems, like mouse input, physics and particle systems (I'm REALLY looking forward to this one, sounds exciting!).

I'm also starting to design AlegriaEd, the graphical editor, but it's not a priority. Before that, this summer I'll try to do a pong-like demo, and if everything goes okay, also make a promotional-like video showing some of the capabilities of the engine.

Update 12/May/2011

Couldn't do much the last two months, but I'm definitely back. Just finished programming the AK_Window class, which contains the Windows-specific code to create the main window the application runs on. Wasn't too difficult but I'm happy about it (:

Next step: Code subsystems, mostly Render and Input ones, and connect them with the main window message-processing function. This will involve some global variables, which I hate. Just don't tell anyone.

Update 11/March/2011

After 8 months since the project started, Alegria's core structure already completed. It was just about time! Slow programmer (:

This includes (but is not limited to): * Image, text and pseudo-xml file classes.

• Different kind of managers (v.g Image Manger, Entity Manager, Archtype Manager...)

• Python integration of core objects, like components (AK_Component) and entities (AK_Entity).

Next step: Code window/rendering subsystem. This includes dealing with Win32 API and OpenGL. Hope it doesn't take too much!