This first article will feature message queue and publisher classes.  They are quite simple, yet certainly useful.

Message Queue

The message queue class is very short and simple.

class MsgQueue:
    def __init__(self):
        self.messages = []

    def post(self, msg, category, *args):
        self.messages.append((msg, category, args))

    def get(self):
        for msg in self.messages:
            yield msg
        self.messages = []

Messages can be posted to it and retrieved from it through the ‘post’ and ‘get’ functions.  The messages that are posted are tuples of message, category, and arguments.  The categories can be used to group messages of similar types together.  For example, in a game there might be a category called ‘switches,’ where a message is posted each time a switch in the level is turned on or off.

The ‘get’ function is a generator for iterating through the messages then clearing the list of messages.

#Example Use for MsgQueue
q = MsgQueue()
q.post("red switch on", "switches")
q.post("red switch off", "switches", "with an extra argument")

# elsewhere in a sea of code ...

for msg,category,args in q.get():
    if category == "switches":
        if msg == "red switch on":
            fire_laser_beams("Pew! Pew!")
        elif msg == "red switch off":
            stop_firing_those_lasers()

Publisher With Message Queues Subscribers

Message queues can subscribe to message categories within this message publisher class.

class MsgPublisher:
    def __init__(self):
        self.categories = {}

    def subscribe(self, subscriber, category='default'):
        if not self.categories.has_key(category):
            self.categories[category] = []

        self.categories[category].append(subscriber)

    def unsubscribe(self, subscriber, category = None):
        if category is None:
            for c in self.categories.itervalues():
                c.remove(subscriber)

        else:
            if self.categories.has_key(category):
                self.categories[category].remove(subscriber)

    def post(self, msg, category='default', *args):
        if self.categories.has_key(category):
            for subscription in self.categories[category]:
                subscription.post(msg, category, *args)

The method ‘subscribe’ is used to subscribe a message queue to a publisher.  Categories are used to group subscriptions so that a single publisher can serve several uses.  A subscribing message queue will need to subscribe to each of these categories separately. If category is blank ‘default’ will be used.

The method ‘unsubscribe’ removes a subscribed message queue from it’s subscription list(s).  If category is ‘None’ (default) it will be unsubscribed from all of the categories.

The method ‘post’ is used for posting messages to the subscribed message queues.  Each message will be sent to all of the message queues that have subscribed to the specified category.

#Example use of MsgPublisher
qa = MsgQueue()
qb = MsgQueue()
qc = MsgQueue()

p = MsgPublisher()
p.subscribe(qa)
p.subscribe(qb)
p.subscribe(qb, "new category")
p.subscribe(qc, "new category")

p.post("message")  # sent to qa and qb
p.post("something else", "new category")  # sent to qb and qc

p.unsubscribe(qa)
p.unsubscribe(qb, "new category")  # qb will be removed from "new category"
p.unsubscribe(qb)  # now qb removed from all categories
p.unsubscribe(qc)  # will be removed from all categories

Opportunities for Use

There are many times when speed and direct interaction are not needed but flexibility is.  In a game objects can simply plug in and listen to the messages being sent — creating an easy and modular system.  Also it is more like asking for things to happen than telling other parts of your program to do things.  These messages can be ignored.

Some instances where message queues and publishers might be useful include: game state changes, abstraction to other systems such as sound, world dynamics, communications between game entities, etc.