Punctuation

: is clearly superior to the - . At least some people seem to think so. I never was much a : guy, or even a ; So perhaps the - is where its at? Who knows. Mysteries of the universe I suppose.

I know I said it last time, but Flash really does suck the fat one, in the most unflattering of ways. I went back to refine my checkers, and found that a little function gets called twice, when it only needed to be called once at the top of my stack. This might not seem like much, but when it was being called a second time, it was when move "n+1" was being evaluated, where n is the current search depth. This meant that this particular function was getting called alot. Taking it out, and a few minor adjustments dropped my AI think time by 50%. W00t! Well, almost a woot, its still slow as molasses.

Then I got the idea - actually I read the idea - that bitboards would be the way to go - and hey, Flash actually supports bit operations like OR,XOR, left shift, etc. Being that I don't normally program AI I hadn't used this, but I immediately saw just how clever this solution is (which its cleverness has been around for a long time, imagine my surprise). You see, we could represent the board as a bunch of 0s and 1s. A 0 would be an empty square, while a 1 would have a checker in it. So the opening board of checkers would look like:

10101010
01010101
10101010
00000000
00000000
10101010
01010101
10101010

And then you would also have a bitboard representing ONLY the red checkers, ONLY the red kings, ONLY black checkers, and ONLY black kings. And then maybe 2 more, one for all the red pieces and all the black pieces (just to make things a bit faster)

So, instead of searching through an array of pieces and positions to find valid moves, you can just use the bit operations to see what you can do.

For example, a black checker (bottom) would have a move bit board of say

00000000
00000000
00000000
00000000
00000101
000000#0
00000000
00000000

The checker would be located at # (which would still be a 0, but I put the # in there to illustrate)
You can then compare that bitboard to the one holding all the pieces and quickly see if its occupied.

The real value of this (while still helpful in checkers) would be something like chess where a rook would move something like (again the # for illustration on location)


00000010
00000010
00000010
00000010
11 11 1 1#1
00000010
00000010
00000010

Anyway, there's plenty on the subject on Google's "chess bitboard"

So here's my a great idea, that could probabyl help speed things up marvelously, but can flash do it? No! Of course not! Why? Because it sucks the big fat one remember? Bitwise operations can only return 32bit intergers which means you can toss the chess/checkers board right out the window since each square is a bit, and there are 8 rows x 8 cols of bits (that's 64 for you non math majors ;) )