Logos -> Loading screen -> Main menu -> ….

After main menu, you could go to any number of states such as playing the game, loading a save, configuration, etc…  The first three states though, will always follow the same path and can be combined down into one state.  This is great on paper and pencil because now you have less things to draw.  When translating this into the software world each “state” can be represented as its own object or method.  So we’ve also cut down on the typing we had to do in software.  Such an “optimization” was probably not a good thing though.   If the code has to change later we’ll have to break apart the state to put in a new state.

It’s best to leave the states as separate states (objects,methods) in the software.  This allows the code to easily be changed later if and when it does (because it will always change).  By having objects/methods do TOO much, it has a level of complexity that does not and should not be there.  Break things up into smaller, simpler parts.  Maybe you have already heard of Cyclomatic complexity (Firefox hasn’t though, as it comes up as a spelling error.)  There are a number of tools on the web that will measure the this on each method/class in program.

If the three initial states were merged we’d end up with one state that was 3x more complex than the individual states.  In terms of maintainability, this isn’t a good thing.  Merging the states also did not make anything faster, and might have made things slower.  Instead of the state machine deciding which of the three states we are in, the new ‘optimized’ state much decide which of the three states it is in, so there are two decision points instead of one.

Having lots of small methods, classes,objects in a program is not a bad thing.  Merging them down into larger objects is not a good thing.  Keep the code broken up as possible, or it will become unmaintainable mess of large objects with very specific (and sometimes redundant) functions .   Think of code like building blocks.  As long as the objects are small you can mix and match them anywhere to build things.  The larger pieces can only be used for a few things and are limited in their use.  Look at some of the Lego sets you can buy.  Some are made with very generic parts that can be used for almost anything.  Others have very specific (often large) pieces that serve specific functions.  Such as a cockpit on the spaceship, or a fancy roof for a building.

.NET has a simular feature called Delegates.  These are basicly pointers to function.  Most people will use these for callbacks and events.  Something interesting you can do is use them in properties.

class Foo
{
  delegate void Fn(string s);
  Fn bar;
  Fn baz
  public Fn Bar{
    get{ return bar; }
    set{ bar = value; }
  }
  public Fn Baz{
    get{ return baz; }
    set{ baz = value; }
  }
}

Using this class you can now assign the class methods at runtime.

Calling the method:

f.Baz("something")

and reassign the function to print out a line

f.Baz = f => Console.WriteLine(f);


The class looks just like it has normal methods, but they are not assignable.

Timezones tell you how to convert your datetime from one timezone to the other.  10am in NYC is not the same 10am in Tokyo.  What makes this all the more fun is the wonder idea of daylight savings time.  Time will go backwards and forwards or seeming random days.  Suddenly there are 2 different 11:59pm.

When you look at a file in windows explort, did you ever think about the missing timezone on the dates?  You probably didn’t give it a second thought.  But you should.  You probably assume that it is showing the times in your current time zone.   Sadly you are more correct then you think.  I found out about this after I read this link.  It seems windows uses your CURRENT timezone to display the datetime.  Whats the problem with this?  If a file was created at 3/1 10:00pm and you look at the file in April, windows shows the file date as 11:00pm, even though the correct time should be 10:00pm.

Windows is smart enough to store the date in UTC/GMT/ZULU time, but when converting it back to your local timezone, it just uses your CURRENT timezone offset, instead of figuring out what it was on that date with DST factored in.  I wonder if someone was trying to optimize out a few CPU cycles.

So next time you are looking at the access times on your files, remember that they could be up to an hour off from what the actual time was.

tmp = a
a = b
b = tmp


This requires using an extra variable tmp to store A while it is overwritten with b.  Wouldn’t it be great if you could swap the two without using an extra variable?  The XOR swap algorithm is just what you need

a^=b^=a^=b

This ends up with A and B swapped.  Still 3 assignments but with out the extra variable.  If you want a good explaination of how that works read the wikipedia article.

A word of warning though, the above code only works in C/C++.   It will not work in an VM language like Java or .NET.    This has to do with how the languages are implemented.  Java and .NET are stack based VMs where as C/C++ is register based (and not a VM).  This means that values are pushed onto the stack and then poped off to calculate values.

For example

int a = 1;
int b = 1;
int c1 = (a++) + a;
int c2 = b + (b++);


c1 will be set to 3 and c2 will be set to 2.   Written in C/C++ both will give the answer of 2.  The operator a++ will increment a by 1 but return its original value.  With a stack base, the 1st part of the equation, (a++), is calculated and the answer ( 1 ) push onto the stack.   The next part of the equation (a) is calculated and the answer (2) and push onto the static.   Why is the 2nd part of the equation 2?  When the add operation is run, it retrieves the actual values of the variable one of which is the returned ‘original value’ of a and the other is the current value of A.

An alternate way of writing the XOR swap that works on stack based (and non stack based) VMs is as follows.

a^=b
b^=a
a^=b

Note:  This does not work if A and B are the same object.  You shouldn’t be swapping in the case any ways.

The short moral of the story is dont use shortcut code to put a bunch of commands on the same line.  It may not do what you think it will.

wrapper.zip
Edit:  Updated exe to C++.    C#/.NET doesn’t allow exec like processes

Since then, the screen turns white. It just fizzles out and turns completely white. This isn’t a software problem because it happens anytime, from the BIOS start screen, to inside XP. This was only a few weeks after I had got it back from being repaired. Sigh… So I sent it back again (another $20) to be fixed. Each time I sent it, its at least 2 weeks before I got it back.

Its been pretty good since then, until this week. It started turning white again. I only got it back a little over a month ago. Not again. So rather then send it back again (For another $20 and 2 weeks) I looked at what I could do.

Looking “White screen of death” up on the internet, showed that it could be problems with the LCD boards. I was lucky enough to find a repair manual for the laptop though. The manual showed some LCD parts above the keyboard. This looked like a good place to start. Since my screen was not almost permanently white, I figured it wouldn’t hurt to poke around.

After removing a cover, I had access to the connectors. After poking and wiggling a few of them, the screen came back. It seems the LCD cable is loose. Its not connected to the motherboard completely, and comes partially loose. Hmm.. seems someone didn’t put my computer back together quite that well after replacing the motherboard. As far as I can see though, the connection is tight and all the way in. It just isn’t staying in. Bad design?

Anywho, instead replacing a pricey inverter or back light or controller card for the LCD, it was just a partially loose connection. And to think, I could have sent it back to Acer to be fixed for another $20 and 2 weeks.

(Edit Dec 22 2007)

I notice a lot of people finding this page when searching for ‘acer white screen’.  From my findings, a white screen means that your LCD cable has partially loose.   Either take it into a shop to get fixed, or do it yourself.  To do it yourself, you probably need to open the top of your laptop above the keyboard.  Unplug the LCD connection and plug it back it, and secure it in place somehow.

The first most obvious thing to try was to up the FPS. Flash defaults it to 12, which seems rather slow for animation doesn’t it? So I updated it to 30, which didn’t seem the to change anything. 60fps offered a slight improvement. So it logically concludes that 120fps (the max you can set in flash) would give the best performance, and it seemed like it did. But the program was still using a ton of CPU power, and had a very low fps.

Was there a way i could squeeze a few more fps out of the program? Well there happens to be a function called updateAfterEvent() which basically tells the program to issue another screen refresh immediately. The only problem is that you can only call it from certain functions., one of which is NOT onEnterFrame. It would only work if called from an event, such as a mouse movement or key press. It also would work for a periodically ran function called through setInterval(). This looked like the option to try.

The function has this basic format:

setInterval(function, ms, params)

It takes a pointer to a function, the number of milliseconds in between calls to the function, and any params you would like to send it. That sounded wonderful, just set a really low ms, and pass in the function that does the same thing my current onEnterFrame does, and it should run as fast as I want. Well, not really. The one gotcha with this function is that it will only call the function at most, as often as onEnterFrame is called. The resolution of this timer is only as fine as the FPS in the movie. Even if i set the ms to 0, it would still only be called as often as onEnterFrame. Back the square one again, or was I? The new difference now was that I could call updateAfterEvent in the function, because it was called through setInterval. Yea! So i put the new code in, removed the old onEnterFrame, left out updateAfterEVents, set the ms to 10 and watched to see if there was any improvement.

Suddenly there was a 10x speed up. The animation wasn’t as sluggish and it responded to the uses key presses immediately. That didn’t make any sense. The same amount of code was being ran on every frame, the program should run the same speed. I tried changing the ms down to 1 and the animation only got faster. I changed the FPS of the program down to 12, and the animation was still just as smooth. I wondered if the function was being called more often the the screen updated, so I turned the FPS down to 1. A FPS of 1 resulted in jerky animation just as expected. So the function was still only being called as often as the screen updated. Turning the fps back to 12 (the default). I ran the program and watched the cpu usage, it was only around 10-20%, instead of the whopping 70% it was using before. Changing the FPS had the most effect on the CPU usage. A higher FPS resulted in more processor usage. But changing the MS in setInterval had barely any effect on CPU usage. Hmmm…. So i went around and changed all my onEnterFrame to setInterval code. This resulted in a much more responsive program, that had lower CPU usage. I still don’t know what the problem with putting code in onEnterFrame is, but I dont think I’ll be useing onEnterFrame much anymore.

The moral of the story:

DO NOT USE onEnterFrame in flash, its slow. Only use it if you absolutely must, but I don’t know why you would.
Changing the FPS does NOT result in faster code. Only MORE CPU usage.
USE setInterval(…) instead with a lowish FPS (such as 12)

This class takes takes an Array of items (data) and divides it into two sections. The first section is the already randomized items, the other is the items that haven’t been shuffled yet. When you request the next item, it picks a random item from the remaining set and swaps it onto the end of the shuffled set. When the non-shuffled set is empty, it starts from the beginning of the array again. At this point the whole array would have been shuffled already so no more swapping will be needed.
Here is the entire class in C#
class Shuffle
{
Random r = new Random();
Object[] data;

int split; // where the split is in the array
bool shuffled = false; // has the entire array been shuffled
public Shuffle(Object[] q)
{
split = 0;
data = q;
}

public Object Next()
{
if (split == data.Length)
{
split = 0;
shuffled = true;
}

if (!shuffled)
{
// find the next one
int idx = r.Next(data.Length – split);
// swap the positions
Object tmp = data[split];
data[split] = data[idx];
data[idx] = tmp;
}

return data[split++];
}
}This class shuffles the list in constant time. It only shuffles when a new item is requested from the list, and only shuffles that one item. This is many many times faster than shuffling all the items at once.

Enjoy.

Anyway, I went a made my own combination generator.  For those wondering what a Combination is, its arranging K items from a set of N items, order doesn’t matter.  So given 5 items, and only taking 3 at a time you would get

0,1,2
0,1,3
0,1,4
0,2,3
0,2,4
0,3,4
1,2,3
1,2,4
1,3,4
2,3,4
The way this works is quite simple.  Each column has a min and max value that it can hold.  The first column goes from 0-2 (or 0 to (N-K) ), the last column goes from N-K to N-1.  You can easily generalize this into column C can hold a value from C to N-K+C.  The value of N-K can be precomputed.  Armed with this knowledge you can now make all your combinations.  First start with the identity (0,1,2,…,n).  To get the next combination, start at the right most item, and move left until you hit the first item that can be incremented, in other words, the value is between C and N-K+C.  Increment this value, then move back right and set each of these columns equal to 1 more than the item at its left (ie   c[i] = c[i-1]+1).

So given 0,3,4,  we start at the right (4).  4 is the max value for this column, so we move left.  3 is also the max value for this column, so we move left again.  0 is between 0 and 2, so we can still increment it.  We increment it to 1.  Now the array is 1,3,4.  Next we go back right and add set each column to one more than the column at its right, so we change the 3 into 1+1, which is 2.  We change the 4 into 2+1, which is 3.  This leaves us with the next combination of 1,2,3.

The last combination has the pattern of the first item equal to N-K (or 2 in our case).  When we reach this case we stop.

Ok, thats my little walk through on combinations. I’ll put something up about permutations next

I originally tried to write a program to solve this problem using a brute force method. Needless to say, this was very slow and almost never ran to completion. I thought about it for a while and finally figured it out. It boils down to just solving a graph of connected nodes. Since I wanted to learn ruby, I used this to learn the language.

The basic idea to solve this is:

Have we reach the end state (desired amount)?
Loop through each from jug (i)
Loop through each to jug (j)
Calculate the new state of the jugs (water level in each)
Have we seen this “state” before? If not, store the new state. If we have, then move on
If this is a new state, go to step 1 with new state
old state, continue looping

Obviously, this wont find the optimal solution, but it will find a solution. If you want to find the optimal, you will have to store the steps to get to a state, and see if you have found a quicker path to a state. If you want, I still have the ruby file to solve this.