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!

• 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

See you!
- Juan Pablo

There is a trivial solution, to sort the array:

… 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:

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:

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

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

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

Have a happy day as me
- Juan Pablo

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:

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 …

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

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

Usually players interpret it as a mouse lag because they don’t feel the mouse responding to their commands and it is the only reference they have in the interaction with the application (on mouse based games). Other name this problem receive is “floaty cursor” since the mouse gives the sensation of being floating or sliding over a soapy surface. The Lag is not a few milisecond response lag, it can be of up to a second in some cases which makes the game unplayable.

Actually, the issue has nothing to do with the mouse, there are mouse input lags problems as well but this one is not the case. To better understand why a mouse lag problem isn’t a problem with the mouse handling code, you should think it as a sympthom of a seekness, but not necesarilly the cause of the problem. Most developers attempt to ignore this problem because of many reasons: they have never seen the problem, it is too much sporadic so it is really hard to track it and it doesn’t seem to be connected to any cause and so it is really hard to fix it. But you are very lucky! Here you might find a lot of valuable information about this problem.

The problem is tied to Direct3D, there isn’t evidence of this problem happening on OpenGL, most games that allow both render systems usually fix this problem when switching to OpenGL (so if you are a user which experiment this problem you can try doing this if the game allows you to do it)

The real problem actually occurs in the D3D handling code, the lag experienced by the player is no other than a lag in the scene presentation.

It is a bit tricky to reproduce it voluntarially since it requieres many conditions and often the problem appears and dissapears with minimal changes in the program or hardware configuration. It usually happens on machines with a CPU faster than the GPU, it is not tied to any specific hardware vendor but some graphic cards are more prone to present the problem. The program also must have some characteristics, like having few instructions (low ammount of D3D commands with low geometry) and a lot of work to do (mostly a lot of pixel drawing). With those conditions given what happens is that the d3d driver queue got filled more often than can be handled, but the queue is big enough to handle many frames of instructions before overflowing, hence the lag.

You might think “… but I have set the flip to wait for the vertical sync!”, even worse, this won’t do other thing than increase the problem because the command will represent more delay in the queue flow. Except if you wait for the vertical sync by yourself with the WaitForVerticalBlank DirectDraw command, which is not very used because it blocks the CPU, or polling the GetVerticalBlankStatus function.

In any case, the vertical sync behavior can be superseded by the graphic driver, and the command queue can be filled faster than the current vertical sync so it is not a guarantee to fix the problem.

If you manage to reproduce the problem in your computer, you can test adding a clock to the game and so you will see that it is displaying too much back-in-time compared to the system clock. As well you can test checking the response to the keyboard, you will note so that every event seems to be delayed, but this is just a perception effect, the logic is working just on time, it is just the displaying of it the one which is delayed. You can tie a sound to the keyboard input as well, you should be hearing the sound before the graphic response.

Do I have to worry about this problem?, if you did an extensive Q&A testing with enough number of representative machines of your target and it never appeared, and your game has not the characteristics described for this problem, I would say that you shouldn’t worry about. However, if it is the opposite, you haven’t done the Q&A or your code characteristic are the ones of this problem you’d better do something about.

What can you do about it?

One of the biggest problem with this issue is the extrange behavior some cards have when handling the DX_WAIT or DX_DONOTWAIT flag in the flip or blit commands. Some cards completelly ignore the DX_DONOTWAIT flag and never return the DXERR_WASSTILLDRAWING error code which would tell you that the last frame haven’t been finished yet.

So the problem is to find a way to not overload the driver queue. Unfortunatelly, there isn’t any Flush command in Direct3D to do so.

Rendering on fixed rate wouldn’t  fix this problem, supousse you send 30 frames per second to the card but it really can only handle 29 … after 30 seconds you will have a tail of 30 frames in the driver queue.

You need to eighter now that the queue command queue is empty (to do a graceful frameskip in case not) or to wait at some point for the card to finish the work. A third solution would be to fill the driver queue with garbage so commands would be executed inmediatelly or not executed, but I don’t find it an apropiated solution because you can end with a severe performance penality.

If you work with DX9 you can use DirectX Event Queries to check if a frame has been fully processed. To do so just issue the event in the command buffer just after the Present command, then you just need to poll if this event has been processed to know if the frame has been presented. It is up to you to create a good strategy for this to not stall the CPU when polling and give it the enough flexiblity to allow the game flow smoothly.

Now, if you work with DX8 or DX7 it isn’t as easy, the only way known to flush the commands buffer so far is to lock for reading a surface of the flipping chain with all the consecuent drawbacks, which in our case it is mostly the CPU stall waiting for the AGP data to get into the ram. You can try to reduce them by locking just a tiny region of the surface, and locking the next surface to be used (if you have a tripple buffer). Of course you will try to lock the backbuffer surface and not the primary one (Vista Aereo doesn’t like the primary buffer to be locked).

Locking the buffer seems to work perfectly on every machine, but you again need to create a good strategy to reduce the secondary effects, this strategy will depend on your rendering system and the one which work best for you might be different from others systems so it is a matter of testing and experiment.

- Juan Pablo

We also thought on adding a third color but we don’t want to push it too much, maybe it will come with the time.

Here it is a first model we have worked out, I hope you like it.

We are making a lot of changes to our organization, we keep growing and we would like those changes to be reflected in our image …

- Juan Pablo