South Winds Games :: Blog » Juan Pablo

Some of our bits …

Juan Pablo — Mon, 28 Feb 2011 18:54:44 +0000

Hi!

Today I did some minors changes to our main site (please tell us if there is something wrong ) and I thought it would be good to add another entry to the blog.
Well, since some time I was thinking about sharing this beautiful piece of code. It is beautiful because of the use we have given to it, we used this tool for almost everything.

template <class T, int N> class IntegratorBase {
protected:
T mV[N];

public:
T& operator[](const int i) { assert(i>=0 && i<N); return mV[i]; }
const T& operator[](const int i) const { assert(i>=0 && i<N); return mV[i]; }
};

template <class T> class FirstOrderIntegrator : public IntegratorBase<T,2> {
public:
FirstOrderIntegrator() { }

FirstOrderIntegrator(const T& x, const T& v)
{
this->mV[0] = x; this->mV[1] = v;
}

void Update(float t)
{
this->mV[0] += this->mV[1] * t;
}
};

template <class T> class SecondOrderIntegrator : public IntegratorBase<T,3> {
public:
SecondOrderIntegrator() { }

SecondOrderIntegrator(const T& x, const T& v, const T& a) {
this->mV[0] = x; this->mV[1] = v; this->mV[2] = a;
}

void Update(float t)
{
T vt = this->mV[2] * t;
this->mV[0] += (this->mV[1] + vt * 0.5f) * t;
this->mV[1] += vt;
}
};

// This is a fat one.
template <class T> class ThirdOrderIntegrator : public IntegratorBase<T,4> {
public:
ThirdOrderIntegrator() { }

ThirdOrderIntegrator(const T& x, const T& v, const T& a, const T& w) {
this->mV[0] = x; this->mV[1] = v; this->mV[2] = a; this->mV[3] = w;
}

void Update(float t) {
T mv3t = this->mV[3] * t;
T mv2t = (this->mV[2] + mv3t * 0.5f ) * t;
this->mV[2] += mv3t;
this->mV[0] += (this->mV[1] + mv2t * 0.5f) * t;
this->mV[1] += mv2t;
}
};

It is a template structure for elements that can be integrated over time.
It is Game development related and actually it is not as precise since it uses Euler integration. However, you can modify it to use the integration you want … and actually, it wouldn’t be as hard to create a RK4 version of the mechanic.

With this mechanic you will be able to access the derivatives with the index operator []:

X[0] -> The thing you are integrating
X[1] -> First derivative over time
X[2] -> Second derivative over time

Which is really really handy (you won’t believe me how much).

A tipical usage:

struct Particle {

FirstOrderIntegrator<Vector2f> mPosition;
FirstOrderIntegrator<Color4f> mColor;

void Update(float t) {
mPosition.Update(t);
mColor.Update(t);
}

void Draw( GraphicThing& gt ) {
gt.Draw( mPosition[0], mColor[0] );
}

void InvertDirection() {
mPosition[1] *= -1.0f;
}

};

You probably know about templates and integrators but haven’t thought about using them that way … yeah, there are many situations where this structure cannot help you, but in many cases it will save you to write a lot of code

See you later!

Airport Mania 2: Wild Trips

Juan Pablo — Wed, 22 Dec 2010 16:55:47 +0000

Hey!
It’s finally out

If you are in the US you can get it at Amazon.

If you are in Canada (or in the US as well) you can get it at Game House.

We are all really happy
- Juan Pablo

Inner Quest, our 4th game

Juan Pablo — Thu, 20 May 2010 00:34:16 +0000

Hi all!

Yeah! our fourth game is here. It is called “Inner Quest“, a match-3 game which was created having in mind the best user experience possible. We focused on make it smoother and soft, relaxing and pleasant

A video says more than a 1000 screen shots:

We are getting older, actually getting older is good for a company but anyway when I look back I feel some nostalgy (drop a tear).

The road until here was hard, and it seems that the upcoming road is harder, but as long as we can make games and eat every day we will be more than fine!

Thanks!

We finally changed our look :)

Juan Pablo — Sat, 24 Apr 2010 02:37:16 +0000

As we promissed after 2009 new year we finally changed our look
The work was:

Redesign the logo
Update the graphics in all our games (Dylo’s Adventure is the only one with the old logo)
Redesign our site (which was the biggest challenger)
Customize the order pages at Plimus (not as easy as it sounds)
Re-skin this blog
Buy new t-shirts with the new logo

Actually this has low priority over many things so it was a challenger to keep working on it with the time passing by.
I’m really proud of the result
- Juan Pablo

Simplz Zoo on Steam!

Juan Pablo — Mon, 05 Apr 2010 23:57:34 +0000

If you have an account on Steam you can now get Simplz Zoo with some of the Steam features like Achievements and Cloud file system.
Whatch out the free demo and full description here.

Airport Mania – Retail

Juan Pablo — Sun, 13 Dec 2009 15:37:09 +0000

Hi!
We were (are and will be) very busy because we are working on a new pretty ambitious project: www.simplzzoo.com. We expect it to be here really soon, will talk about it later.
Airport Mania hit Retail!
Just a little picture:

See you!
- Juan Pablo

Traversing an array in random order / Non repetitive Random Number Generator

Juan Pablo — Mon, 20 Jul 2009 17:30:38 +0000

The problem is simple. You have an array and you want to traverse it in random order.

There is a trivial solution, to sort the array:

for(int i=N; i>1; --i)
swap( array[ rand()%i ], array[ i-1 ] );

… but what if you can’t modify the array and having an array of indexes is too expensive, let’s say for example that you want to traverse all the pixels of the screen. What you actually need is a non repetitive random number generator which works in linear time.

There is a handy one around, it is called Linear Congruential Generator (LCG). This is the one most programming languages implement as their default random number generator.

The LCG equation is simple:
X’ = ( a * X + c) % m
Where X is the last generated number, X’ is the new one, a is an arbitrary constant multiplier, c an arbitrary constant increment and m is the modulus.
So this function jumps from number to number in a non sequential way, but to have a full period of m (to always fall in a different number without repeating it until m jumps) some conditions should be met:

a and c can be any finite number, positive or negative but it will be the same if they are 0 <= c < m, 0 <= a < m because of the modulus operation. For c it is easy to see it, but let see it for a:
Suppose we take a constant a’ which is any integer number, and represent it as a’ = a+m*i being a’ = a%m and i = a/m (all in integer arithmetic)
Then ( (a’+m*i)*X + c ) % m = ( a’*X + m*i*X + c ) % m
since (m*i*X) % m = 0 we end up with ( a’ * X + c ) % m
The next conditions are described thinking on a and c in ranges [0,m).

c and m should be relatively prime (coprime). This means that they don’t have any common divisor. Example: 22 = 11*2 and 25 = 5*5.

a-1 should be divisible by all prime factors of m. Suppose m is 1176 = 2*2*2*3*7*7, a-1 must be divisible by 2*3*7=42.

a-1 should be multiple of 4 if m is multiple of 4 (According to Donald E. Knuth).

The first X value can be any number, it will be the seed, after m iterations you will end in the same number(mod m).

When the LCG reach the initial value it will cycle in the same order it did the first time for ever (from a number X and the same constants you will always jump to the same number).

The quality of the randomness of the LCG is questionable for some critical computations, there are better random number generators, but for most requirements it is more than enough. The most important thing actually is to know what you are doing.
With different constants and seeds we will have different permutations of the numbers in the range [0,m).
Now the next problem is how to pick good constants.

If the size of the array is known in compilation time and only one way of traversing is needed you can simply chose the numbers doing some tests.
Now, if you don’t have the size of the array in compilation time and/or you need different ways of traversing the array it gets a bit more complicated.

Take into account that you can have an m bigger than N (the array size), when X >= N you can just discard this value in a way similar to:

do { X = LCG(X,a,c,m); } while( X >= N );

We can have a table of prime numbers, but figuring out which numbers to pick to either satisfy the coprime property with c and to get close to N will be a challenge as well …

Other approach would be to pick m to be a power of two:
– We can be sure to satisfy the coprime condition just making c odd.
– We can reduce the modulus operation to a bit mask operation gaining constant speed.
– a can be calculated with a = ( ( s*4 )+1) & (m-1) where s is just a random number bigger than 0 and a-1 is multiple of 4 and divisible by all prime factors of m (which is only the number two).

There are two disadvantages about using a power of two as m .
– First, we can end up with up to the double less one iterations to calculate all the X; N can be far away from m
– The quality of the random numbers generated is less because of the power of two modulus, the low bits of X will vary in a smaller cycle than m (this can be compensated with the discard behavior).

With this in mind you can create a templated forward iterator to just traverse any container which accepts random access iterators.

See you,
- Juan Pablo

Useful Open Source Libraries

Juan Pablo — Sun, 29 Mar 2009 20:32:39 +0000

Of course you won’t program everything from scratch, but there are situations where you can hesitate to create your own libraries or not.
In many cases the work involved and the results you can achieve with your own libraries is enough to satisfy your requirement but in other situations it isn’t even close.
One of the best things of programming in C/C++ is that there is plenty of resources of any kind to satisfy a wide variety of needs, usually there is more than one solution for one requirement.
There are Open Source and Closed Source libraries, and they can be free or paid, maybe free for non commercial projects or under a specific license.
Not all Open Source libraries are free, and even not all the free ones can be used in commercial projects, even more, there are some of them that allows you to dynamically link to your code for commercial use but not to statically link. Some licenses requires you to make the source of your project public. Many licenses as well require you to make public the changes you made to the library so you share any possible improvement.

Here at South Winds Games we use many 3rd party libraries.

For compressing and decompressing data we use the ZLIB
Zlib is very handy and easy to integrate and it has a very permissive license, you can statically link it to your code and you don’t need to even name them (we prefer to do it). ZLib is fast and well documented, it has been written in C so it has bindings to many languages, it is completely multi-platform. I don’t thing there is a replacement for it.

For reading XML we use irrXML, we tried many other like TinyXML and libxml bur IrrXML situed best for our requirements.
IrrXML uses the same license of ZLIB. One problem IrrXML has is that it doesn’t support UTF-8 despite it says it does, but it works perfectly with all the other encodings.
IrrXML doesn’t provides a tool to write xml files, so we coded our own. If you were looking for a tool to write XML in UTF8 format (the only format it supports) here you can grab ours: xmlwriter (it has a zlib license as well). IrrXML is a C++ library and I guess it is only supported in C++, it works on Mac OS X on Intel and PowerPC computers as well as Windows, it should work on Linux as well.

To read PNG graphic files we use libpng. The libpng library internally uses the zlib so you should take this into account to only have one instance of the zlib in your linking process. The libpng is distributed with the the zlib license and there are plenty of bindings for many languages as it has been written in C. It is updated regularly.

We also use the jpeglib which allow us to read JPEG graphic files. This library was last updated in 1998 but it seems that it isn’t a problem.
This library has a different license which require you to add this line in a part of your software documentation (the readme would be the best place).

“this software is based in part on the work of the Independent JPEG Group”.

Also the lib has been written in C and it shouldn’t take too much work to bind it to other languages.

From the xiph open source community we use two very important libraries and archive formats, both related to media, one for sound and other for video.

For sound we use the Ogg-Vorbis royalty free format. The quality obtained with the ogg format is head to head with the mp3’s one and if you use the famous mp3 format you must pay royalties, both are very similar one is free, the decision is easy.

For video playback we had the non reliable CODEC problem: You can use the operative system services to stream video, you have directshow on windows or the Windows Video Api and QuickTime on MacOs X but unfortunately Windows only had very bad codecs installed by default. Other option is to include the codecs on the download, but as well many of them require royalties, so we opted for the multi-platform royalty free way of doing the things. Theora is not hardware accelerated so it uses the CPU to decode the video which is not a fast process, but it is well optimized to run smoothly on a Pentium III 750 mhz (our low-end testing machine).

Both libraries are written in C and well documented, there are bindings to many languages for them.
Both libraries use the BSD license which is a variation of the MIT license. This allow you to close the code and use it on commercial projects, but you must include somewhere in your software documentation the copyright license included in the library.

We recommend you to read all the licenses of all the libraries you are using, some libraries aren’t as permissive and some others may require you to mention them or show in your software the copyright message attached to the library.

- Juan Pablo

Best of Casual Gameplay 2008 – Airport Mania

Juan Pablo — Fri, 30 Jan 2009 03:06:14 +0000

Jayisgames.com (a very important game news and reviews site) has just published the results of its annual Best of the year, and it was a really nice surprise to find Airport Mania as the winner in the Time Management category.

The article describes why it was chosen capturing the essence of the game in a very faithful way.

You may want to read the full article:
Nominations
And the winner is …

Have a happy day as me
- Juan Pablo

Fast Integer Log2 function in C/C++

Juan Pablo — Tue, 20 Jan 2009 03:14:14 +0000

Some times, it happens that you need to have a high performance function that you usually use in a not optimized way. And since you never needed to optimize it you hesitated before realising it can be severly improved. Probably, this is what you would think of the integer log2 function, in general this function is used on not critic code so it can be “slow” without creating any problem (often used to calculate the size of a power of 2 texture to hold an image)

The usual way of calculating this log2 function is testing until the base elevated to the log is bigger than the value. This is easy with the << operator.
This function returns the truncated to the integer unit log2 of value:

inline unsigned int iLog2(unsigned int value)
{
unsigned int l = 0;
while( (value >> l) > 1 ) ++l;
return l;
}

Easy, isn’t it? And it is quite fast! you will do 8 comparations to return the log2 of 256.
But what if we do a binary search instead of this linear search …

inline unsigned int Log2(unsigned int value)
{
unsigned int f=0, s=32;
while(s) {
s>>=1;
if( value > 1<<(f+s) ) f+=s;
}
return f;
}

Even faster since we will be doing a fixed number of comparations.
And so, if they are fixed …

inline unsigned int ilog2(register unsigned int x)
{
register unsigned int l=0;
if(x >= 1<<16) { x>>=16; l|=16; }
if(x >= 1<<8) { x>>=8; l|=8; }
if(x >= 1<<4) { x>>=4; l|=4; }
if(x >= 1<<2) { x>>=2; l|=2; }
if(x >= 1<<1) l|=1;
return l;
}

You can hardcode the answers and the bit settings, and this one compiles really well!
If you want to go further you can expand the ifs to 32 branches with 32 results, and so you will collapse the search time to the minimal (I cannot think on something better), but it is up to you if you want to go further. As well this function can be bounded with template arguments, but I don’t think this will ever pay off.

Probably you won’t find this function useful (except if you are here because you were looking for it), but in any case I liked this function so much and I wanted to share it because it shows us that even the most every day used things can be improved, refined, and can be prepared for different contexts. It isn’t all invented, you can keep discovering and creating

- Juan Pablo