Raven is a checkers game program, for one or two players. While there are examples of excellent & free checkers programs out on the net (such as Martin Fierz’s Checkerboard), Raven has a few differences.

• Open-source code. Raven uses existing open source code as a basis (Martin Fierz’s Simple Checkers evaluation function and Peter Norvig’s search code from the AIMA project) for its AI engine.

• Cross-platform. Raven is written using Python 2.7 using its standard libraries and works on both Windows and Linux with its Tkinter GUI.

• Great for checkers study. Raven allows you to quickly set up board configurations using standard checkerboard notation. You can also describe your moves in the annotation window, and you can save and load games for later study. This is great for working through checkers books and learning techniques and tactics. I’ve included several training files in this version to show how well Raven works for studying endgame strategy.

I’m looking for volunteers to help with Raven! Take a look at future plans below and see if you’d be willing to join the project:

Most checkers or chess programs go the route of deep search combined with perfect opening and endgame databases. These techniques are well-explored and not really all that interesting to me. I plan on making a big change in future versions of Raven by relying more on planning than brute-force search.

Here’s what I’m thinking:

• Implement a behavior tree AI (perhaps using Owyl) that will devise opening themes and endgame strategies. These plans will be based on tactics and endings from Richard Pask’s books Starting Out in Checkers and Play Better Checkers & Draughts, which I use in my own checkers study.
• Add a transposition table and some move ordering to help with alpha-beta search depth. (I will probably make use of the transposition table code in PyChess or Chesstools.) Despite my preference for using a behavior tree for high-level plans, I would like to be able to fall back on good search for the early- and late-midgame when play becomes a bit more muddled.
• Release a Linux distribution. (I’d love to use PyInstaller or cx_freeze for this, but I have little experience. I could definitely use some help with this … my appeals for help to the StackOverflow community have gone largely unnoticed.)
• Switch the search/game tree algorithms to use generators instead of lists to improve speed & memory usage.
• Make the undo and redo work completely correct with the background AI processing.
• Improve the annotation feature (currently using a simple Creole text format) to be more WYSIWYG.

If you’re interested, browse the code or clone it, see what appeals to you in the list above, and let me know you want to jump in by posting on the newsgroup.

So for work at home, I figured I’d fully make the switch as well. That’s when I found an issue. While I had managed to get my Mac code completing well for my django app’s, my 9.04 ubuntu box at home wasn’t running so well. Just trying to code complete the django models object didn’t work.

After trying everything I’d seen via googling, I found that adding the following directories to the additional directories import seemed to work:

/usr/local/lib/python2.6/dist-packages

/usr/local/lib/python2.6/site-packages

I’m sure I’ll end up adding more directories to make it all work right… but these fixed the basic django code completion issues. Just thought I’d post this in case I forgot what I did.

• You have a list of objects whose state is continually updated.
• The objects are frequently added or deleted from the list, i.e. have limited lifetimes.
• You want to reuse the objects instead, to improve performance or simplify your code.

Introduction

When writing my game Asteroid Smash using Python, I used lists to keep track of on-screen objects like laser shots and asteroids. These objects all have limited lifetimes (for example, a laser shot that only goes a predetermined distance, or an asteroid that drifts across the screen until it gets destroyed). When it’s no longer needed, the object then gets deleted from its associated list. Here is a simplified example:

import random
 
MAX_SHOTS = 5
 
class Shot(object):
    def __init__(self, lifetime):
        self.lifetime = lifetime
 
    def update(self):
        self.lifetime -= 1
        return self.lifetime > 0
 
# create list of Shots with random lifetimes
lst = [Shot(random.randint(1,100)) for x in range(MAX_SHOTS)]
 
# update loop
while lst:
    delete_lst = []
    for i, x in enumerate(lst):
        if x.update(): # decrement object lifetime
            delete_lst.append(i)
 
    # delete any objects whose time count is 0
    for i in reversed(delete_lst):
        del lst[i]
print "Done!"

To summarize what’s going on, a list of 5 Shot objects gets created, each with random lifetime values, and added to a list. After that, a loop is started that calls an update method on each Shot that decrements its lifetime variable by 1. (This roughly simulates what would happen during each pass of a typical game loop.) Once the object’s lifetime value reaches zero, then the object is added to a delete list. Any objects in the delete list get destroyed after each pass of the update loop.

This code works, but it’s clumsy. Note all the bookkeeping that’s necessary. I can’t delete items while I’m iterating through the list, or I’ll invalidate the iterator. This means I have to keep track of the index of which items need to be deleted, and then actually delete them in a second loop. Also, I have to delete the items in reverse order, or I’ll throw off the indexes and delete the wrong items.

To improve the code, I decided to try list comprehensions to shorten the amount of code in the update loop.

# new update loop with list comp
while lst:
    lst = [x for x in lst if x.update()]

This is much more appealing, single-pass approach. However, the list comprehension, while tidy looking, has a big disadvantage: it constantly creates and destroys a list during each iteration of the loop. This makes it a big problem if we pass around a reference to the list within our program, as the reference is immediately invalidated when the list is recreated. If we need to keep the reference to our list constant, then we have to try another approach.

Rethinking the problem

Perhaps if we want to make a better design, then we need to recast the problem slightly. Notice that once all the objects have a lifetime count of 0, then they can all be deleted at one time, which is a straightforward problem. This means filtering the list by deleting the objects turns out to be unnecessary; what we want is a way to separate objects that still need to be updated in the list from those that do not. Then, once all of the objects fail the update call, the entire list can be deleted.

A little-known algorithm in the C++ Standard Template Library (STL) called partition does the separation of elements mentioned above. Given a sequence, partition will reorder items in the sequence so that all items that satisfy a certain condition (like an update call!) precede those that fail the condition. One other great thing about partition is that it works in linear time; assuming a list of N items, then each use of partition will apply the condition check N times and swap items in the list at most N/2 times. [1]

Here’s what partition looks like in Python (translated from SGI’s version of the STL algorithm [2]; comments added by me based on the SGI docs.)

def partition(pred, seq, first, last):
    """ Partition reorders the elements in seq in the range [first, last)
        based on the function pred, such that the elements
        that satisfy pred precede the elements that fail to satisfy it.
        The postcondition is that, for some index value middle in the
        range [first, last), pred(x) is true for every item x in the
        range [first, middle) and false for every item x in the range
        [middle, last). The return value of partition is middle. """
 
    # quick error check on the list indices
    if first > last:
        return 0
 
    # find first element that fails to satisfy the predicate
    for i in range(first, last):
        if not pred(seq[i]):
            break
    else:
        return last
 
    # for all remaining elements in the sequence, if we find one
    # that satisfies the predicate, swap it with one that is known
    # to have (possibly) failed the test. All swaps are necessary
    # to preserve the correct ordering upon exit.
    for j in range(i+1, last):
        if pred(seq[j]):
            seq[i], seq[j] = seq[j], seq[i]
            i += 1
    return i

We also need a predicate function to use with partition, since the update method is actually part of our Shot class and can’t be called directly. We could use a lambda function instead, but that is somewhat slower than a named function.

def update_object(x):
    return x.update()

Using our new partition and update_object functions, our update loop changes to:

end = len(lst)
while end:
    end = partition(update_object, lst, 0, end)

This is one line longer than our list comprehension version, but we also don’t invalidate our reference to the list on each pass since partition performs in-place modification to our list. This makes it better on both counts.

One other item of interest is the variable end. After each pass of the loop, the end index marks the separation between “live” and “dead” objects in the list. As we noted earlier, once end reaches 0, all the items in the list can then be deleted. Look closely though … we were only deleting objects from the list before in order to filter those that didn’t need updating, but partition already does the filtering for us. Since all the objects in the list are, in fact, still good, to reuse one of them we just need to reset the object pointed to by the end index and then increment end by one. If we try to reuse one of the objects in the list and end goes beyond the last item in the list, then we can either expand the list or just ignore the request, depending on what behavior we want.

Managing details

Here’s the interesting thing: by switching our code to use partition, what we’ve created is a simple object pool. At this point though, there are too many bookkeeping details, and it would be better to encapsulate the pool inside a class.

class ObjectPool:
    def __init__(self, **kwargs):
        self._clsname = kwargs['classname']
        self._args = kwargs.get('args') or []
        self._num_objects = max(kwargs['num'], 0)
        self._pred = kwargs['update_func']
        self._max_objects = kwargs.get('max', self._num_objects)
 
        # Create the objects
        self._objs = [apply(self._clsname, self._args)
                      for x in range(self._num_objects)]
        self._end = len(self._objs)
 
    def _extend_list(self, args):
        """ default policy is to add one object, up to max_objects ...
        override with different behavior if needed. """
        self._objs.append(apply(self._clsname, args))
        self._num_objects += 1
 
    def add(self, *args):
        """ Add one new (live) object to the pool. """
        newend = self._end + 1
        # if we reach our predefined maximum number of objects,
        # don't create any more.
        if newend > self._max_objects:
            return None
        # if we bump up against the end of our list but are below the
        # max number of objects, extend the list
        if newend > len(self._objs):
            self._extend_list(args)
        else:
            self._objs[self._end].reset(*args)
        self._end += 1
        return self._end - 1
 
    def update(self, *args):
        """ Update each object in the pool, using the pred function. """
        self._end = partition(self._pred, self._objs, 0, self._end, args)
        return self._end

That’s perhaps a lot to digest. Let’s look at a short code sample of how to use the new class that will make it easier to understand.

shots = ObjectPool(classname=Shot, update_func=update_object, num=5)
while shots.update():
    pass
print "Done!"

You can see here that the ObjectPool class takes keyword parameters. The first parameter, classname, specifies the name of each object’s class in the pool. The second parameter, update_func, specifies the predicate function used to update the objects. The third parameter, num, specifies the initial number of objects created. (There is also an optional fourth parameter, max, that specifies the maximum number of objects within the pool; if max isn’t explicitly specified, then it will default to num.)

Besides the update method we’ve already discussed, the add method will attempt to either insert a new object in the pool or reset an existing object whose lifetime has expired. (The add method assumes that each object in the pool has implemented a reset method that reinitializes the object.) If neither option is possible (the pool has reached its max or no objects have expired), then add will simply return None to indicate a failure. (You can override the _extend_list method if you wish to change this default behavior.)

A short demo of object pooling

To demonstrate the utility of this code, I’ve modified Alex Holkner’s Noisy demo in the pyglet 1.1.2 distribution to use my ObjectPool class. His example program displays balls bouncing around the edges of a windowed display. Normally the balls bounce indefinitely until the user presses a Delete key, but I changed the demo to have the balls exist for only a short time before they are deleted from the display. The sample also demonstrates how the ObjectPool prevents you from adding more than the max number of objects defined in its constructor. This demo, along with the provided unit tests, should give you a good starting point for using ObjectPool in your own games or applications.

Download op.zip (17 Kb)

References:
[1] http://www.sgi.com/tech/stl/partition.html
[2] http://www.sgi.com/tech/stl/stl_algo.h

So for completeness sake, I have documented the scenario like this:

On a MySQL server, you just need a simple little table:

CREATE TABLE `test_table` (
`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
`test_col_1` VARCHAR(20) NOT NULL,
`test_col_2` VARCHAR(20) NOT NULL,
PRIMARY KEY  (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=2 DEFAULT CHARSET=latin1

Then the Python code (obviously you’ll need to set the connection stuff appropriately):

import MySQLdb
 
print "-----------------------------------------------------"
print MySQLdb.version_info
print "-----------------------------------------------------"
 
sqlStringItems = """INSERT INTO test_table
(test_col_1,test_col_2)
VALUES
(%(test1)s, %(test2)s);"""
 
dtlDict = {'test1':'test value 1','test2':'test value 2'}
 
con = MySQLdb.connect(host="localhost",user="myuser",passwd="mypassword",db="test")
cur = con.cursor()
exitval = cur.executemany(sqlStringItems,[dtlDict])
 
print "exit value from executemany= " + str(exitval)
cur.close()

version (1, 2, 2, ‘final’, 0) yields:

ValueError: incomplete format

Whereas version (1, 2, 1, ‘final’, 2) works fine.

Also, doing the same thing, but with execute instead of executemany works fine (and of course taking the dict out of the list). So this seems to be purely an issue with executemany. Looking at the MySQLdb code, it’s obvious that between the two versions it was pretty radically changed.

I guess I need to report this as a bug, but I’m just finding it hard to believe that I didn’t do something wrong.

Update (2008-06-03)
Back in January, I reported this issue (1874176). Then in late April, Raphael Guillet submitted a possible fix. I haven’t spent much time looking at the right vs. wrong of the fix, but I have tried it and it appears to work. So for those looking, here’s the possible fix which as near as I can tell has still not been cut into the official version.

The change is in the cursors.py file. So you have to hunt that down wherever it is stored in your particular OS version and/or install.

Comment out lines 201 and 202:

        #e = m.end(1)
        #qv = m.group(1)

And then add right after that:

        e=len(query)
        qv = query[p:e]

I’ll try to continue to monitor this.

This is perfect for this little blog concerned with trivial and small things. I noticed that my Peanuts calendar on my desk is essentially a reproduction of the 1990 calendar. Obviously, they all have to be reproductions because Charles Schulz died in 2000. So looking more closely, I realized they’d chosen 1990 primarily because the dates and days of 1990 match 2007. So a quick hack with the ‘cal’ program under linux and I was off and searching for what will most likely be next year’s calendar. Since 2008 is a leap year and obviously 1991 is not, I knew that wasn’t going to work.

First I generated target calendar with:

cal 2008 > cal2008.txt

Then, I just manually (although I could have written a script) looped through a few known leap years and found that 1980 seems to match perfectly as well.

cal 1980|diff - cal2008.txt

Obviously, what we’re looking for is a diff of only the first line, the year. Side note: the selection of 1952 (also a match), would seem to be fairly unlikely.

For 2009, there are a bunch of choices including: 1953, 1959, 1970, 1981, 1987 and 1998.

Why am I posted this? I don’t know other than it was fun to use ‘cal’ and ‘diff’ to anticipate which Peanuts calendar would be next.

UPDATE

I couldn’t resist doing a Python solution to this little problem. I know this isn’t as efficient as someone else could make it, but it was entertaining for me to do it. It took about 5 or 6 minutes to write and ran correctly the first time (matching my previous results):

import sys 
import datetime
def matchCals(inputYear,minYear,maxYear):
    sDayOfWeek = datetime.date(inputYear,1,1).weekday()
    eDayOfWeek = datetime.date(inputYear,12,31).weekday()
    for testYear in range(minYear,maxYear+1):
        if (sDayOfWeek == datetime.date(testYear,1,1).weekday() and eDayOfWeek == datetime.date(testYear,12,31).weekday()):
            print "Match Found... %s = %s" % (str(testYear) , str(inputYear))
 
if __name__ == "__main__":
    matchCals(int(sys.argv[1]), int(sys.argv[2]), int(sys.argv[3]))

Here I just check the day of the week on the first day of the year, and the last day of the year. If both of those fall on the same day, I assume the calendars for those years are the same. And since we’re dealing with a limited set of dates (valid complete Peanuts calendars running roughly 1951 to 1999, it handles a min and max year for input as well. So to run it for 2008, you just type in:

python ./caltest.py 2008 1951 1999

Of course, there is no error checking… so if you enter a string or an invalid year… that’s your own problem. I just wanted to see how quick I could do it. Obviously, I’ve waisted more of my time… and more of your time.