Tool for Game Developers

PixelForge is a pixel font editor, where you can create and edit fonts and import/export them, all in the same place. Some of the features are:

• Import from and export to TTF files
• Full Unicode support up to U+FFFF
• Auto-updating text preview with custom text
• Multiple document editing
• Infinite undo/redo
• TTF meta-data editing
• Light and dark themes
• Tutorial to get started

Released version developed in C++, using SDL, OpenGL and Dear ImGui for graphics. Currently developing a rewrite in Godot with C#, implementing the TTF import/export from scratch. The project page gets around 1000 visits/month, with 300 downloads/month.

The main drawing canvas is implemented with a single GLSL shader, one draw call with the font atlas texture and parameters sent as uniforms.

Main website

Speedrunning platformer

Jumping and walljumping, short levels with lots of hazards. You can rewind time without limit, and slow down time. When manipulating time, penalty time is added to your regular time, encouraging you to use it as little as possible.

Different leaderboards showcase different speedrun categories:

• Standard category: it adds the penalty time to the run time. It's a nice middleground, you need to perform a good run, while it allows for some time manipulation.
• TAS category (Tool Assisted Speedrun): it ignores your penalty time. It showcases what a human could potentially do, if performing perfectly.
• Flawless category: can only qualify if you never use time manipulation in your run.

Unreleased, developed in Godot with C#, with all art also made by myself. Every physics tick needs to be saved to memory, so lots of care went into making the memory per tick as low as possible. Memory is a fixed-size unmanaged area, written and read with unsafe blocks and pointers, to optimize memory and time, avoiding the garbage collector.

Almost all particle effects require *zero* memory (they only use closed functions that only depend on current time). Randomness is managed by a stateless RNG set of functions that only depend on their parameters, e.g. object id and time-tick number, so particles that depend on randomness for spawning or moving, have a closed stateless solution given the RNG function and known parameters, requiring no serialization at all.

Jam game, with later expansion

Initially developed in 72h, then expanded after the game jam. With the theme "Delivery", you drive collecting packages in a city with limited time. Every package collected increases your time, but more cars appear in the street making traffic worse, including deadlocks.

Developed in Godot with GDScript, 3D assets by Kenney.

Expanded version improves graphics (including silhouetting for occlusions, see next section for more info), introduces better city generation, and better traffic AI.

Play expanded version on itch.io

Open-source graphics sample

Implementation of silhouettes in Godot, for showing objects that are occluded. Involves viewports, texture render targets, depth grabbing and writing, and two specialized shaders. More detailed information in the Github repo.

Github project

Jam game, using custom engine

Developed in 48h for Ludum Dare 51, theme "every 10 seconds". You are surrounded by increasingly bigger waves of enemies that you need to shoot.

Made in my custom C++ engine, see next section for more information.

Play on itch.io

Developed from scratch in C++, only dependencies are SDL, OpenGL, gl3w, SoLoud, and Dear ImGui. Includes:

• Standard library of classes inspired by C#, like Array, String (UTF8), DateTime, Dictionary, IO, List, Set, Stopwatch, Tuple.
• Graphics classes like Vector2, Vector3, Matrix4, Quaternion, Transform, Color.
• Entity/Component system based on composition, similar to Unity3D
• 2D rendering: sprites as textured 2D quads, with batching and layers
• Audio: one-shot sounds with caching, looping music
• Particle system with emitters and property interpolation
• Physics: AABB colliders, collision callbacks, ray casting, triggers, collision masks and layers, spatial hashing for performance, basic arcade platformer physics (gravity, velocity, acceleration)
• Inspector mode: during gameplay it can be opened, it has a debug camera, and it also displays with Dear ImGui a series of panels similar to Unity3D, all properties fully editable:
  • Global info: timers, audio properties, input system, batching...
  • Scene tree: selectable and collapsible entities
  • Entity properties: enable/disable, layer, transform, and all its components.
• Multiplatform: Exports to Linux, Windows and Web (using emscripten)

Also developed a Resource Compiler, that takes binary objects (images, fonts, audio, etc.), text objects (shaders, metadata, etc.), and sprites (to generate atlases) and generates C++ .h/.cpp pairs that embed the files in the code so that they can be statically compiled and directly accessed in the game, as they will be part of the RAM at all times at runtime.

You can see the engine in action in the jam game Onades.

Game for micro-console

Initially developed for the Thumby console, in MicroPython, also developed a compatibilty layer in PyGame to be able to play it in desktop and web, sharing almost all of the game code.

Play on itch.io Github project

Library for Unity3D C#

Alternative physics system for platformer games, supporting AABB colliders, with continuous detection, triggers, one-way platforms, ladders, gravity, buoyancy, pickable/throwable objects, pushable objects.

Effect for Unity3D

Script and shader that achieves a Gameboy effect for any scene. It pixelates the output to low resolution, quantizes to four colors with a palette, and adds pixel-border effect. It was made for an old version of Unity3D that didn't have Image Effects for the free version, so it uses less efficient methods to achieve that.

Github project