Unfortunately I was very busy in the last week. I was studying for the last exam this semester (investment & production). Today I’m driving with my girlfriend and some people to Berlin, Germany. I am going to visit the open house at the Games Academy in Berlin. Of course I am going to write a blog post about it. We’re going to stay a couple of days, to Tuesday and after arriving home again, I‘m going to continue studying. The resulting fact: My project is frozen over this time. I hope that when studying regularly in the next semester there’s time for the project. Greetings.

After writing the post about state machines I stumbled upon a website about ’10 Reasons the Age of Finite State Machines is over’. After reading that post I wasn’t excited about the thing called ‘behaviour tree’, but then I saw a video lecture on ‘behaviour trees’ here. What is a behaviour tree briefly explained? A behaviour tree is a mixture of hierachical state machines, scripting and planners. It’s a programming pattern. It describes the behaviour of a certain game object with events and conditions. It’s hierachical, and the behaviours can be reused. I’m not an expert, even an amateur on this topic, therefore I advise you to check out the video lecture. It really opened my eyes to the game AI behaviour designing. Have a nice weekend.

The weather gets colder, we’re approaching winter, at least autumn. The tip for today and the next days: stay in your castle for preventing get ill (if you get ill from going to work. stay at home while you’re ill). Use the time to focus your mind on important things like friends and family. Myself is relaxing in the evening, drinking tea and is going to watch a movie. The lines of code of my game project count round about 2300 lines. A good reason for illustrating something, to keep my creativity in balance.  On the left hand side I’ve placed an illustration i made shortly before the blog post. Maybe this could be a game asset in the near future, you’ll see. In the end of this short keep up-to-date post I like to greet my girlfriend and my friends!

As I mentioned in the end of the past week, i’ll now introduce my code kata to finite state machines for game objects. First I’ll describe the idea behind it, and then how I implemented it.The programming paradigm behind it is called ‘Automata-based programming‘.

The idea of finite state machines in game objects

State machines are a special type of graphs in graph theory. State machines can be used to define a behaviour of something with different states. It’s massively used in computer engineering. In this post I like to present you an example on how finite state machines can be used for game development. In a game it’s usual to manage game objects, each game object has its own logic code. Depending on other game objects, level or player interaction the behaviour of the game object should change. By letting the behaviour / action code (e.g. the sprite glows) depend on a state (e.g. mouse over) we can separate each behaviour / action code. The state changes within a transition, a transition from one state to another is applied if an event is fired (e.g. the mouse over event). For better comprehension or if you want to skip the source code explanation, here’s the example code.

General design and action function pointer

The code is quite complex, so you should be an average C programmer to read it. The orignal code in my project is separated into different compilation units, in this code kata it’s all packed up in one C file and kept simple as possible. The data and functions of the finite state machine are coupled with the block object. The block object is an example game object; the block object is defined by its structure and its functions. In the main function of the example source code the block is falling down.. until it hits the ground, then an event is fired (hit the ground) and the state and logic code of the game object changes. The game object block logic has to be called trough the interface function ‘block_action(struct block *_block)’. The block_action functions delegates to the current action function which holds the action code of the current state. This can be done by a function pointer ‘block->action’  in the block structure that points to the current action function. In the end of the next section I explain how we need the function pointer.

Hands on code

The design of the finite state machine follows: Current state of the game object is a data field in the block structure (block->state). The transition itself is a structure, with the data fields state (integer), event (integer), and a function pointer. The data fields of the transition structure define a transition in our finite state machine. The state data field represents the state from which the transition is being made. The event represents the event that has to occur for applying the transition and the function pointer points to a function which is called when the transition was applied.  block_fsm_run(struct block *_block) runs the finite state machine against the current state and a fired event. If there’s a transition from the current state with the fired event, the function pointer in the transition is called. All functions, the transitions point to, set the waiting event to none and set the action function pointer (block->action).

Enough words, lets dive into the example code if you haven’t seen it already. I hope you liked the tutorial / code kata on how you can use a finite state machine in game objects. It’s just one implementation and the tip of the iceberg. If you have an additions and question post it to the comments I’m glad to answer. A good start in the new week!

Man, it’s been a long time since i wrote my last blog post – 3 days ago. However, I’ve been quite busy at the moment, cause old clients want some add-ons to their web applications and I rather work on that – money is always useful. On the other hand, I have absolutely no time for my project. But I’m willing to give you another tutorial on game development soon. It’s about formulating your game entities as finite state machines. In addition to that, I’m writing some C example code.  Well, stay tuned for the next tutorial code kata, and have a great start into the new week!

Greetings, jpzk (tired, and is going to sleep now)

Good evening readers, I find it quite funny, that people think if they got a nice idea, they’ll be rich anyhow. But the important part of making ideas real is the part of motivation and passion while converting the blueprints of an idea to a working, useful, thing. I think most of the programmers, at least I do,  are perfectionists and like solving problems elegantly (only if there’s no real or almost no deadline). Furthermore I think we’re passionate about our code, and like to see it as poetry or as a well-designed masterpiece.

However, besides that there are days when you lose your motivation about the project – In my opinion, don’t force yourself writing the code, find new energy (drink tea, meet friends, watch a movie e.g.) and then think of your own masterpiece and what it should be. For those code poets among us, let the spirit of code poetry come to your fingertips again (you’re coding, what you want to code), and for those software architects  among us, think of your design, the patterns and how does it work together.

Greetings, your jpzk

A neighbour-aware grid

While I drink my China Lung Ching also known as Dragon Well I refreshed my energy working on the project. For my current project I need a neighbour-aware grid. Because I’m a big fan of Goban/Go and it’s a really good example I illustrated the drawing on the left hand side. The Problem is of getting the neighbours of a specific cell (and checking them against conditions in dependence to their attributes). The performance of the solution is relevant. So at first I thought of the graph theory, which in fact could pretty much handle. Instead of using a “full-blown” graph theory library, I just take the idea of graphs and use it in my solution. If you want to, see this blog article as a code kata for a neighbour-aware grid.

The data structure

At first I have to say that I implement the data structure in C, because it produces no extra memory footprint. Lets consider the picture on the left hand side. If you interpret the two-dimensional array of the image as an array you could formulate equations for an index of top, right, bottom and left neighbour and dependence to the current cell. To be  more flexible with location-based updates (and save calculation time), I have implemented a data structure, which stores a two-dimensional grid (as a one-dimensional) and four pointers in each cell (in code: grid element) to its neighbours. Each cell is implemented as a struct and is able to store some extra information, like type, resistance and so on.

To set up the pointers the computer goes through the one-dimensional grid and set the pointers to top, right, bottom, left neighbour if the cell is in a position, where there are neighbours to the according sides. Remember that the index of the first cell is 0. In the picture on the left hand side the width and height of the grid are three and three. The conditions are four if clauses which check for existence of top neighbour (the row index of the current cell hast to be greater than zero), existence of right neighbour (the column index of the current cell has to be smaller than the width of the two-dimensional grid), existence of bottom neighbour (the row index of the current cell has to be smaller than the height of the grid) and the existence of left neighbour (the column  index of the current cell has to be greater than zero).

Implementation in C

Enough Text, let’s see my implementation (see implementation). It’s not yet finished, because location-based updates are relevant to my project to increase the execution speed, but if you have suggestions for further enhancements please let me know and write it to the comments!

Thanks for reading, and have a nice day!

I just read an article on C versus C++, you can check it out here. It’s an overview of his programming experiences with C and C++. On many aspects of the author mentioned I agree. And if you’re in conflict which language you want to choose, you should definitely read the blog post. He also mentioned the object oriented programming style in C, which I use for my projects. In the end I decided to keep my work on in C with the argument, that my projects are relative small (means round about 10 “classes”) and most work is already implemented by the game engine.

Greetings and have a nice day, jpzk

it’s been a while since i started working on the Made with Tea projects, now that i set up the development blog I got the opportunity to show the game ideas. But till the first release i keep them hided. The game will be released on WebOS and it’s written in C and uses the brick engine which is a 2D engine build on top of SDL. It’s a very customizable engine and fits my needs. Unlike other engines, the brick engine is very lightweight and some essential features are missing, which i have to implement, too. I am currently working on a prototype of the game with all fundamental services which are needed.

Greetings, jpzk