Latest Entries »

My story continues…

So we finally had a lot of the ground work behind us in terms of admin but we had only made a few of the design decisions, mainly that it would be a 2D top-down shooter. In terms of content, details, and platform, we were still fairly unsure. Now from what I’ve seen, a lot of people frown upon using other games as derivatives for ideas and inspiration. But the truth is that is exactly how we came about our core game play and its mechanics. Most of us had followed or played Crimson Land while some of us had also played some tower defense games from DoTA to web/flash games. So after discussions based on these two denominators, we decided to make a hybrid shooter/tower defense game.

Another important aspect to the design process was the target platform, which is something we still debate to date. We ended up deciding to focus on Xbox360 as our main platform simply because we mainly visualized Zita Asteria (ZA) being played by a bunch of friends having a braai (barbecue for the internationals reading this) with a good beer or two playing a game for some good team work on a ferocious shooter. So a group of friends playing a team based shooter was an important facet which the console catered more for, and Xbox 360 was obviously easier to develop for considering our experience and base framework was already written using the XNA SDK.

Those decisions behind us, we started throwing together a list of features, functions and aspects that we wanted to put together that would be complimentary to the “group of friends” concept. Without giving away too much, we came up with some ideas and weapons that worked on the team play idealism. In hind sight, this was probably one of the largest scope creep propagators. Just from what I’ve seen from other game developers though, scope creep is a regular part of any creative work. Another point of debate was the name, which at the time was still “Pilot Project”. We eventually set up a poll on our project website to vote for various names that we had brain stormed. Ironically the name we ended up voting for was taken after doing some research, and we ended up with the name Zita Asteria, not even in our original poll but we were pushed for time before giving a basic demo to the local IGDA group. Simply a derivative and play on Greek words meaning “Searching the Stars” if I remember correctly.

So with the development underway, our simple “2D” top down arcade shooter had begun building up momentum at least amongst the team as well as with some of the friends and family we had told about our little project. Enjoying the work and getting into the game concept, we continued to grow the scope and change/add features to best suit the game. One of the largest initial changes which we didn’t plan for was a 3D terrain engine. You read that right, 3D, with 2D sprites rendered over the terrain. When I first saw the guys developing the terrain engine propose the idea, I loved it. It gave the game a sense of quality and depth (yes I just said that) that I really liked. I had little to no idea at the time how this would affect the scope and design. Bear in mind this was supposed to be an after-hours project that would be simple and relatively quick to put together(3-6 months). To be honest, despite the amount of extra work that the 3D terrain decision caused, I don’t regret it. The level and quality that we could step up to would not have been possible in a purely 2D, sprite based world. The process of refactoring design and code became periodic and habitual eventually, but my own experience in business systems has shown me this is a fact of software development, not only game development.

The next leg in ZA’s development brought us to a more competitive point in the project’s development…… but you’ll have to wait for the next post to find out J

( I promise to try put in some legacy screen shots if I can find them J )

I thought it would be a good idea to post my thoughts on the first year of working on Zita Asteria. Next month (Oct 2011) will be a year since the original team came together to discuss and eventually develop the arcade shooter we now call Zita Asteria. I’ll try to continue posting episodes into the future regarding my experience. This first episode though I will break up into parts to cover the first year.

Just as a bit of background… I was originally looking for computer graphics and game programming courses in early 2010. I eventually found AD Courses which at the time did an introductory and intermediate course in game programming in XNA. It was here that I met my future team mates for Zita Asteria.

A number of us were very new to the area of game/graphics development while some of us at least had some experience in business systems development. Although I myself had tinkered with Ogre3D and OpenGL at least a little, my knowledge of the area was weak at best. With this in mind we started discussing the possibility of trying to develop a fully playable game and release it to the world. With all of us being gamers, there was a great number of ideas in terms of game concepts. So we decided to give it a try. Let’s face it, creating a new world is exciting. So in late October we started brainstorming ideas on a game we would all enjoy making, and eventually playing. With a total of seven people on the team all with varying skills, we had fair resources for a hobbyist indie group. With that said we were mostly programmers, not artists (I can hear your eyes rolling). We had one artist in the group as well as one of the coders with some experience working with sprites and basic 3D models. But that was pretty much it. Some of the challenges we encountered around content creation I will discuss a little later.

After our original meetings around game ideas, we had decided to go with an arcade shooter. It was only a few weeks later that we decided to go with a top down perspective, despite having a basic framework for a side-scroller already. The other major design decision that was made early on was to make the game 2D to try keep content creation as well as the game framework as simple as possible.

Our next step was to try set up a process to use our resources productively without stepping on each other’s toes. Bear in mind that we didn’t technically have a project manager although some of our industrial experience did include it. This brought us to our next major decision… roles for each of us to give us a field of responsibility. To name a few of the roles, Level Lord, Graphics Guru, Effects Ninja, Marketing Maiden, Traffic Controller. As cheesy as they may sound, they did give us some boundaries to work towards.

Although as we later learned, specializing roles in a team this small is not completely practical. It’s amazing how many different facets there are to making a game from start to finish, which requires more of a Jack-Of-All-Trade skill set to get through all the items on a To-Do list. With that said, having these boundaries did give us a primary area of responsibility while other miscellaneous areas could be secondary.

Up to this point we had laid some of the ground work for our project but we still needed to make some crucial decisions, such as what the game idea was going to be on. But this is where I’m going to stop my story for now. That is year 1 part 1 of my story Zita Asteria thus far.

Stay tuned for the next part…

Just a quick post today regarding something I’ve been tinkering with. My experience with Zita Asteria included doing a few of its particle systems and they can be a lot of fun to play with. I might do a more general tutorial on creating particle systems some day when they come more naturally to me. For now I suggest a more informal approach, by simply visualizing the system before coding.

As usual, a list of ingredients :

–          Visual Studio C# Express 2010

–          XNA 4.0

–          DPSF ( Dynamic Particle System Framework )

The DPSF API is pretty well black boxed but I want to still give a run down of the basic lines of code you’ll need to get particle systems running.

The following should be enough to get started :

1)   An attribute, the particle system manager of type ParticleSystemManager

2)  Adding the particle systems needed using particleSystemManager.AddParticleSystem(particleSystem);

3)  An update call – particleSystemManager.UpdateAllParticleSystems(elapsedTime)

4)  Config calls

a.  particleSystemManager.SetCameraPositionForAllParticleSystems(cameraLocation)

b.  particleSystemManager.SetWorldViewProjectionMatricesForAllParticleSystems(msWorldMatrix, msViewMatrix, msProjectionMatrix);

5)  A draw call – particleSystemManager.DrawAllParticleSystems()


Any other code needed will be specific to the particle system you might be using.

The particle system I put together to demo this is extremely simplistic but it does demo the basics of one of DPSF’s classes. It also incorporates basic rotation using some of the DPSF utility methods although I didn’t use the traditional DPSF delegates for simplicity’s sake.

Each particle essentially has two aspects to its behaviour :

1)      Rotational velocity relative to the emitter’s location ( not the center of the particle )

2)      Vertical linear velocity ( essentially increasing  y-component )

That’s this system in a nutshell. Here is a screenshot of it running :


A thanks goes to the DPSF project team for the textures supplied in the source!

I hope this helps someone. Well implemented particle systems add quality to any visuals.

If you want the project source : Whirlwind Particle System Demo

Ciao All

Hi All

Just an update regarding the odds and ends that I have been working on:

– Numerical Methods 2 : Solving systems of equations

This is a nice simple implementation of gaussian methods for solving matrices. I still need to test this algorithm and its implementation thoroughly though.

– Particle Systems : A Simple Demo

A basic standalone particle system done in XNA using DPSF as a framework with a focus on tweaking the particle system itself. This is still a work in progress.

– Projectile Motion Demo

A simplistic 2D demo that I would like to use as a test bed for testing and experimenting with trajectories.

I have also started a basic game in DirectX with a very simple concept in mind. This is largely still on the drawing board though and is a means for me to dig into DX more thoroughly.

As I am working on these items I am also finishing up Zita Asteria and as such these projects have had to take a lower priority. But we are probably in the last quarter of our release schedule(hopefully). We are also however finding that the last 20% of a project really is 80% of the work.

I just felt a quick update was in order. I’ll do my best to get a project or two out before my exams start in November.

Ciao 😀

Numerical Methods

Hi Everybody

This post will cover my first encounter with numerical methods (NM) after doing an introduction at university. Needless to say I thoroughly enjoyed such a fresh approach to mathematics and I plan to try look more at numerical methods in the future.

What the hell are numerical methods? Well I guess in a nutshell I would define them as a computer’s solution to DOING mathematics. If someone had to ask you how on earth would you write a program to do integral calculus and all its applications, numerical methods would be your answer. One of the fundamental paradigm shifts I went through when I started looking at NM was how to do mathematics numerically as opposed to analytically which is essentially how mathematics is taught at school. Analytical mathematics relies heavily on an intuitive feel for the problem, and the numerical methods essentially rely on predefined problem sets. I would essentially say that analytical mathematics is a super set for NM and also precedes NM in terms of the problem solving process.

This is my first project looking at numerical methods. I started the original project as part of my numerical methods course at university, but I find these little projects become great test beds for miscellaneous experiments. Before I give a basic run down on the project, here is what I used to put the project together :

–          Visual Studio 2010 Express ( C++ )

–          Book : Applied Numerical Methods ( Gerald & Wheatley ) 7th Edition ( referred to as ANA )

–          The Internet

This first version of the project only has algorithms to deal with solving equations of different forms for different purposes. They are generally taught as a means of calculating roots of given equations but they could be manipulated and used for finding more generic points as well (such as maxima or minima). I’ll give the wiki links as well for more comprehensive reading not to mention I refer to it for my own explanation while trying to keep my version remotely human. Also bear in mind that the algorithms implemented come almost completely and directly from the book Applied Numerical Methods, I would recommend this book to anyone interested in the subject as it is both down to earth and thorough.

From an implementation point of view, I have not optimized the project’s structure as of yet and have aimed to keep it relatively simplistic.

I will not be going into any theoretical detail of these algorithms, nor am I qualified to do so. But I will give a quick description and one or two links for further study.

The algorithms are as follows:

“The Derivative” :

This is my home baked method of calculating a derivative of a function at a specific point on the function based on the rise-and-run method. I originally implemented it simply because Newton’s method will require the use of derivatives. It served my purpose but I still want to keep a look out for alternatives in the future.

Newton’s Method

( Check out : )

I’ll give you only one attempt to guess who this algorithm is named after. Newton’s Method (sometimes called the Newton-Raphson method; see wiki) is probably one of the most commonly known algorithms for NM. It is a method used for root-finding and is probably the easiest to understand.

Rate of Convergence: Quadratic


–          Within reasonable approximation of the root, it is rapidly convergent

–          Relatively simple to understand


–          Requires to function evaluations per iteration

–          A note given by ANA :

  • “The method may converge to a root different from the expected one or diverge if the starting value is not close enough to the root”

For those too lazy to google the algorithm I have included my own diagram showing an example of Newton’s Method at work:












This style of diagram is a cliché in numerical methods. But they are very useful for visualizing the behaviours of the variables used. In this case after several iterations the x0 and x1 variables should eventually collide (to within the margins specified). For any algorithms you are trying to work out, I would suggest drawing up atleast 3 of these diagrams in sequence with an update of values for each iteration.

Fixed Point Iteration (FPI) (AKA : x = g(x) )

( Check out : )

A less common algorithm used for finding a fixed point on an iterative function. This algorithm has a particular unique twist. The equation that is processed by the FPI algorithm needs to be manipulated by solving for x. I personally found this algorithm to be fairly temperamental and particularly susceptible to divergence. This may however be an implementation issue. It is however a very simple algorithm.

Rate of Convergence: Linear


–          Rate of convergence can potentially be increased by using Aitken’s Acceleration


–          Requires the input equation to be “pre-processed”

–          Convergence can be both oscillatory and monotonic, and can be difficult to determine if the process is diverging.

Muller’s Method

( Check out : )

A verbose but powerful algorithm. Also considered a part of the householder algorithms ( algorithms used for root finding ) and is based on the secant method. It however does not use a linear equation with one or two points on the function to traverse the function, but instead uses three points using a quadratic polynomial to find the root.

Rate of Convergence: Quadratic


–          Despite the verbosity of the algorithm, will attain reasonable precision in fewer iterations


–          Denominator of the quadratic equation may not be zero or the algorithm will fail

–          The delta value of the square root (b^2 – 4ac may not be negative )

–          Verbose and requires multiple evaluations per iteration


That pretty much covers what I have implemented into this project thus far. There are some shortcomings that I still want to look at in the future…….

What I have not dealt with yet:

–          Checking for traversal into infinity. The project could essentially run into an infinite loop depending on algorithm’s idiosyncrasies and given initial boundary values

–          Aitken’s Method, used to accelerate convergence of iterative methods

–          Methods of Linear Interpolation (Regula Falsi and the Secant Method)

–         Function definition : Evaluated functions are hard-coded! This will be a post on its own(at least).

Here is the download for the project:

Edit : I’ve added a refactored version of the project as well to correct some layout mistakes


NumericalMethodsCPU – Revised

As with any and all projects that I work on, please feel free to give feedback or let me know of any bugs, limitations or problems. I especially welcome any advice regarding misunderstandings that I may have in the topic’s theory (in this case, numerical methods).

I hope this helps. Despite it being a tough subject to wrap your head around initially, it is also a lot of fun!

Ciao 🙂