Previous Section  < Day Day Up >  Next Section

Hack 43 A Continuity Bot

figs/moderate.gif figs/hack43.gif

What was everyone talking about just before you joined the middle of their conversation?

Joining an IRC channel in the middle of a conversation can be a frustrating experience for all concerned, so wouldn't it be nice if there were someone there to tell you what people were talking about? Wouldn't you like to know if the awkward silence following your appearance was because everyone was busy insulting you before you joined? Now, with the miracle of the Continuity Bot Hack, you can ease seamlessly into the conversation and find out what your friends really think of you in the bargain.

This hack takes the form of cont, a simple bot based on the PircBot framework. When someone joins the channel it sits on, the bot sends her the last 10 events that occurred there via private message. Many people set up their clients to join multiple channels on startup. As the history is sent via private message, you may want to modify the message format to include the channel name in this case.

Do not run multiple versions of this bot on the same server—when your client autojoins multiple channels on startup, the messages from the multiple bots will get all jumbled up.

For the sake of simplicity, this bot will keep track of only what is said in a channel. This requires only normal messages and actions to be monitored.

6.5.1 The Code

The file will contain the code that is used to keep an eye on what people are saying in the channel. The Cont class inherits from the PircBot class to make this rather straightforward.

Save the following as

import org.jibble.pircbot.*;

import java.util.*;

public class Cont extends PircBot {

    // Remember up to 10 things that happened in the channel.

    private ContextList contextList = new ContextList(10);

    private CurrentTime now = new CurrentTime( );

    // Constructor used to set the name of the bot.

    public Cont( ) {




    // Handle on-channel messages.

    public void onMessage(String channel, String sender,

            String login, String hostname, String message) {

        contextList.add(now + " <" + sender + "> " + message);


    // Handle actions.

    public void onAction(String sender, String login,

            String hostname, String target, String action) {

        contextList.add(now + " * " + sender + " " + action);


    // Handle people joining the channel.

    public void onJoin(String channel, String sender,

            String login, String hostname) {

        if (!sender.equals(getName( ))) {

            // Send out the history of messages to the new channel user.

            Iterator messageIt = contextList.iterator( );

            while (messageIt.hasNext( )) {

                sendMessage(sender, ).toString( ));





As you may have noticed, the Cont class makes use of two classes that haven't been made yet! The first of these is ContextList , which has the responsibility of remembering the last 10 events seen by the bot. The second is CurrentTime, which performs the trivial task of creating a simple timestamp, similar to that used by most IRC clients.

ContextList is what you might call a ring buffer. It is an ordered list, but its size is limited to 10 items in this case. If the list is full and a new item is added, the oldest item in the list is simply removed. The bot uses this class to store the last 10 (or fewer) events that occurred on-channel, ready to be sent to each user who joins the channel.

Now create the file

import java.util.*;

public class ContextList extends Vector {

    private int maxListSize;

    public ContextList(int maxListSize) {

        this.maxListSize = maxListSize;


    public boolean add(Object o) {

        if (this.size( ) >= maxListSize) {

            // Remove the first item if the list is full.



        // Add the new item to the end of the list.

        return super.add(o);



To give the user a greater feel of temporal location, it is useful to apply timestamps to the messages. It often helps if you can tell if a message was sent 30 seconds ago or 30 minutes ago. The quickest way of getting the current time is to call the toString() method on a new instance of the java.util.Date class. This method may return slightly different things depending on your locale, but it will look something like this:

Sat Feb 14 14:45:13 GMT 2004

This is rather long for messages that appear in an IRC window, and most of it is unnecessary. Not many channels are idle for more than a year, and if they are, it's unlikely that you'll want to keep your bot running in there. The CurrentTime class will generate a timestamp like 14:45.

Save this as


import java.util.*;

import java.text.*;

public class CurrentTime {

    private SimpleDateFormat shortDateFormat = new SimpleDateFormat("H:mm");

    private FieldPosition fp = new FieldPosition(0);

    public String toString( ) {

        Date now = new Date( );

        StringBuffer output = new StringBuffer( );

        try {

            shortDateFormat.format(now, output, fp);


        catch (NullPointerException e) {

            // Date cannot be null. Ignore this.


        return output.toString( );



All you need to do now is create a main method to run the bot from, and you're done. Save the following as :

public class ContMain {

    public static void main(String[] args) throws Exception {


        Cont bot = new Cont( );


        // Connect to a server and join a channel.





6.5.2 Running the Hack

Compile the classes with the javac command:

C:\java\ContBot> javac -classpath .;pircbot.jar *.java

Start the continuity bot by running the main method in the ContMain class:

C:\java\ContBot> java -classpath .;pircbot.jar ContMain

If all goes well, the bot should spring into life.

When a user joins the channel, the bot will send private messages containing the last 10 lines of text sent to the channel, as shown in Figure 6-3.

Figure 6-3. Receiving private messages from the bot

Using a bot like this is a great way of making sure nobody feels lost when he enters the middle of a conversation.

Steve Jolly

    Previous Section  < Day Day Up >  Next Section