I’m releasing my first game ‘Feoh the Fitter’. It is a puzzle grid game designed to test your spatial awareness and allow you to explore the rules of the game. If you like thinky puzzle games like sokobond or a good snowman is hard to build you may enjoy this game.

To download the game i’ve created an itch io page here (itch io page). It is pay what you want.

If you have any bugs that come up, any questions or just want to say hello, the best email is [email protected]

I made the game with the idea of building a system and exploring interesting consequences that arise. I have learnt a lot from this project. How to make a professional product (hopefully!), how you go about designing a game and most of all, actually finishing the product. All three of these were a big learning curve for me, but I’m happy to say I made it out alive

If you want to make your program look a bit more professional, one way is to set a icon on the exe, instead of the default icon.

Windows version:

• Convert your logo image to .ico format. There are free online convertors that do the job.
• Create a .rc file in your project. This is a script file windows will use to find out you want to set the icon.
• In this file write: uniqueId ICON “./path/to/file.ico”
  Where the uniqueid is a name of your choosing.
• You then compile this file using windows resource compiler, which takes .rc files and converts them to .res files. On the command line write: RC filename.rc where filename is the name of your .rc file you created.
• Now that you have a .res file, you can pass this to the compiler when you compile your .exe. You just have to pass the path/to/file.res

Thats it! Now the exe should have a unique icon to make it look more professional. Note: I believe the ico file is co

When we ask the GPU to render a sprite or mesh to the screen, the biggest bottleneck isn’t the actual rendering of the pixels, but sending the data from the CPU to the GPU. And what this comes down to is how many draw calls we issue in each frame. (A draw call being in OpenGl glDrawElements). So instancing is an optimisation technique in which we bundle as many render objects (render object being a sprite or mesh in our game world) into the same draw call.

In a perfect world we would have a draw call for each render object and we would set uniforms unique to that render object i.e. the color, the MVP matrix, the objects material etc. However if we had a even handful of render objects in our scene, our program would come to a slow unplayable halt. So we want to share as many things as possible across render objects. The only hard limit that we can’t share is the vertices & indices array we are drawing, and the shader we are drawing with. The rest is up for grabs. Even with t

Since starting this project for Handmade Network I think I've changed project five times, with different game ideas and a drawing app. None were being finished, so when One thing a Month challenge came up, I jumped on it eagerly. I made a tetris clone with a twist. From this I built it into a puzzle game, over the last couple of months.

I've made this project as simple as possible, with goal of finishing a complete game and releasing it.

Through the project so far, I realised a game doesn't have to take forever to finish. Just being in the space of creating things feels really good. I plan on releasing it in the next couple on months, hopefully on steam, itch.io, and apple & google play store. I'm using SDL for the platform layer so I hope it isn't to big a job to get it running on touch devices.

After making this game I realised I learnt to program more for designing interesting games, than engine development. I really like the whole process of building a game in the Hand

At the start of the year I switched to using my mac for programming instead of windows. With it came some changes. One was using the SDL library instead of Win32 for the platform layer. The other big change was using Xcode as the debugger instead of Visual Studio. My goal was to use it in a similar way to how Casey’s uses Visual Studio. Stepping through the code, setting breakpoints etc. but not actually using it as the text editor. Once I got used to using it, the flow process was pretty similar to how I was programming on Windows. I had my text editor and then run the program in the debugger and if it crashed, you could easily see why.

One day the breakpoints stopped working on Xcode. I’m not sure if I changed a setting or it was just undefined behaviour, but it would only honour breakpoints set in the file with the entry point, and ignore all others. I tried fixing it, then just used how it was for a while, but eventually this was a catalyst to just stop using a debugger. I

You hear the word designer a lot these days. Whether its a a ui designer, graphic designer or a level designer. In part of my mind I associate 'designer' with a more arty type like a graphics designer. But I like design and I'm not particularly an arty type. I like the idea of making something more functional. The engineer definition of design. But I have part of me that sees and believes every human activity is design. The chef designs food. A mechanic designs solutions to car problems. The physicist designs theories. If I think about it, the broader definition of design is understanding and using elements of a domain in ways that solve problems whether they be aesthetic or functional. We operate in a space of concepts.

The elements of physics are the law of conservation, calculus, theorems etc. and they are used to design theories. For a programmer the elements are 'for' loops, 'while' loops, caches, data. The spaces that we solve in also have different levels. If we are doing gr

Since December I stopped working on Mind Man as I was lacking direction. In the mean time I started working on some other projects, most notably a text adventure engine. Originally my plan was to make a video series using C to make games . The first project was a text adventure game just on the command line. However I was enjoying it so much, I forgot about the video series, and started developing it past the initial plans. While I was making it I was programming with a modular approach in mind. I wanted to create some reusable header files that I could drop into any project in the future, and give functionality like openGL, dynamic arrays etc.

I eventually lost steam with the text adventure game. It has most of the functionality, but I didn't have a good story idea, which worked well with the text adventure style.

The feature I like a lot it that I can declare the gam

Recently I decided to learn how to use the IMGUI library. However by the end, I had gone down a rabbit hole of learning about libraries.

At first I was compiling the IMGUI library as a unity build with my own code. It was taking upward of five seconds each compile. So I decided to pull it out into its own library image. There are two main kinds of libraries: static and dynamic. Static libraries are essentially archived ‘object’ files (.o). The library file will have an extension of .a on mac and linux and .lib on windows. When you compile them into your own code, the linker outputs the actual code into your executable. This means, you can’t seperate out the library from your program.

The benefits are that you will never have any dependency issues. You can’t not find your own executable. The downsides to this are wasted computer resources. If multiple programs are using the same library, why not load one version of the library into RAM and everyone shares that one insta

At the end of december I decided to port the game to SDL so I could use my mac computer. I knew I liked programming in the style of Handmade Hero but I didn't have the motivation to learn objective-C and the Cocoa framework for Mac. I had looked at implementations using NS classes a couple of times but never got very far. I had heard about SDL and decided to look into it a bit more. I also wanted to program using OpenGL and do most stuff myself, but not have to think too much about creating a window, outputting sound etc. I also really like the layout of the MSDN wiki and the docs.gl, which I couldn't seem to find a similar style wiki for mac.

As I learnt how to use SDL, the more I liked it. It still held the concepts of the level of programming I liked, but provided a easy to use API, like SDL_CreateWindow, and SDL_GL_CreateContext for a Opengl Context, so I didn't have to learn the ins and outs mac platform programming. SDL also has a really easy API wiki that tells you what t

I haven't been doing much on the game this month. I have rethought the puzzles an looking for the next steps to take in the game design. This will also inform where the programming will go from here: what needs to be developed, expanded upon and simplified.

In the mean time here is some stuff I wrote after watching the interview with Mike Acton and Casey at Handmade Con 2015 https://www.youtube.com/watch?v=qWJpI2adCcs&list=PLEMXAbCVnmY5MtDW5Q0EuWmBW5kEMYhm1

The Practice of Programming In an interview by Mike Acton about programming and engine development, Mike said that practice was the thing he wished programmers did more of. That just 30 minutes a day spent implementing an idea from scratch or researching a topic was beneficial for the development of the programmer.

He was adamant that the practice session should be completely new each time, and not taking off from an existing project. By doing this you allow the brain to come up with different solut

When approaching the game design, I had some ideas that I wanted to base the game around. One of these ideas was the decision to avoid having the game be solved by a bot. This inspiration comes from the January music toy (link posted in the projects description). A bot could easily play the game with the game only having three key inputs. But as there are no end goals or progression, it would miss the point of the game. You just enjoy the sounds that are made.

As Mind Man uses discrete movement steps for entities on a discrete board, it is a very clear candidate for a bot. I wondered what the game would look like if we couldn't program a machine to derive the purpose from the game.

One way would be to have no end goal (like January). At the moment the game does progress to different levels. However the goal to the game could be a higher purpose that isn't explicitly explained. In Braid there is a very clear progression to the game, with levels and boss fights. However the u

As this game is based around puzzles, one of the requirements for the engine was a strong level editor. One in which I could easily iterate on puzzle designs without much overhead. I knew i wanted to be able to drag entities around, create entities, edit the board, and easily edit the path finding of the AI.

The first step was to create a simple UI system in which I could easily create UI menus in the code, and add actions to buttons. The api looks like the following:

PushUIElement(UIState, UI_Moveable,  UISet);
        {
            UISet.Type = UISet.Name = "Save Level";
            AddUIElement(GameState->UIState, UI_Button, UISet);
            
            UISet.ValueLinkedToPtr = &GameState->RenderMainChunkType;
            UISet.Name = "Render Main Chunk Type";
            AddUIElement(GameState->UIState, UI_CheckBox, UISet);
        }
PopUIElement(UIState);

        UISet.ValueLinkedToPtr = &GameState->RenderMainChunkType;
        UISet.Name = "Render Main Chunk Type";
        AddUIElement(GameState->UIState, UI_CheckBox, UISet);
    }

PopUIElement(UIState); [/code]

Instead of having callback functions for the buttons like in javascript and java, I str