Welcome to the world of non-static IPs! =P There's things like http://www.no-ip.com/services/managed_dns/free_dynamic_dns.html that could help and give you a free domain name that will change with your ip.

That it would be the best thing since literally sliced bread.  I don't really think it would be that hard, you just have to tell everyone maybe a couple months ahead, and then whoever can do it, can do it!  And if you can't, we can turn it into a biannual thing so there'll always be another one! (If you miss it, I mean)

In light of the contest, I figured I might post all the amazing updates I've made to JIRC if anyone wants to use java and make their life easy

Updated example:
import com.up.jirc.*;
import java.io.*;
import java.text.DateFormat;
import java.util.*;
import java.util.regex.*;

public class Test {
   
    static PrintStream sout = System.out;
    static BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));
    static String ActiveIRCChannel = "";
   
    public static void main(String args[]) {
        JIRC omni = new JIRC("withg.us.to", "JIRC_Test", "Test Implementation of JIRC", 6667) {
            protected void onConnect() {
                sout.println("Connected!");
            }

            protected void onPingged(String server) {
                sout.println("Ping? Pong!");
            }

            protected void onServerMessage(String message) {
                try {
                    ServerResponse sr = ServerResponse.parseString(message);
                    switch (sr.numeric) {
                        case MOTD:
                            sout.println("MOTD " + sr.response);
                            break;
                        case MOTDSTART:
                            sout.println("Message of the Day, " + sr.server);
                            break;
                        case ENDOFMOTD:
                            sout.println("End of MOTD");
                            break;
                        default:
                            sout.println(sr.numeric.toString() + ": " + sr.response);
                            break;
                    }
                } catch (Exception e) {
                    sout.println("[" + DateFormat.getTimeInstance(DateFormat.SHORT).format(new Date()) + "] - " + message);
                }
            }

            protected void onChannelMessageReceive(String channel, String nick, String message) {
                sout.println("[" + DateFormat.getTimeInstance(DateFormat.SHORT).format(new Date()) + "] #" + channel + ": <" + nick + "> " + message);
            }

            protected void onPrivateMessageReceive(String nick, String message) {
                sout.println("[" + DateFormat.getTimeInstance(DateFormat.SHORT).format(new Date()) + "] <" + nick + "> " + message);
            }

            protected void onChannelMemberPart(String channel, String nick) {
                sout.println(channel + ": " + nick + " has left");
            }

            protected void onChannelMemberJoin(String channel, String nick) {
                sout.println(channel + ": " + nick + " has joined");
            }

            protected void onChannelMemberQuit(String nick, String message) {
                sout.println(nick + " has quit (" + message + ")");
            }
        };
        omni.setAddColors(true);
//        BLACKF "\033[30m"
//        GREYF "\033[1;30m"
//        REDF "\033[31m"
//        LIGHTREDF "\033[1;31m"
//        GREENF "\033[32m"
//        LIGHTGREENF "\033[1;32m"
//        YELLOWF "\033[33m"
//        LIGHTYELLOWF "\033[1;33m"
//        BLUEF "\033[34m"
//        LIGHTBLUEF "\033[1;34m"
//        MAGENTAF "\033[35m"
//        LIGHTMAGENTAF "\033[1;35m"
//        CYANF "\033[36m"
//        LIGHTCYANF "\033[1;36m"
//        WHITEF "\033[37m"
//        LIGHTWHITEF "\033[1;37m"
//        RESET "\033[0m"
        omni.setColors(new String[] {"\033[37m", "\033[30m", "\033[34m", "\033[32m", "\033[1;31m", "\033[31m", "\033[35m", "\033[1;31m", "\033[1;33m", "\033[1;32m", "\033[36m", "\033[1;36m", "\033[1;34m", "\033[1;35m", "\033[1;30m", "\033[1;30m", "\033[0m"});
        omni.start();
Pattern JoinCommand = Pattern.compile("/(?:join|j) (.+)", Pattern.CASE_INSENSITIVE);
Pattern PartCommand = Pattern.compile("/(?:part|p)", Pattern.CASE_INSENSITIVE);
Pattern CACCommand = Pattern.compile("/cac (.+)", Pattern.CASE_INSENSITIVE);
Pattern NickCommand = Pattern.compile("/(?:nick|n) (.+)", Pattern.CASE_INSENSITIVE);
Pattern OpCommand = Pattern.compile("/op (.+)", Pattern.CASE_INSENSITIVE);
Pattern DeOpCommand = Pattern.compile("/deop (.+)", Pattern.CASE_INSENSITIVE);
Pattern RawCommand = Pattern.compile("/raw (.+)", Pattern.CASE_INSENSITIVE);
Pattern ListCommand = Pattern.compile("/(?:list|l) #(.+)", Pattern.CASE_INSENSITIVE);
Pattern ExitCommand = Pattern.compile("/(?:exit|e)", Pattern.CASE_INSENSITIVE);
        try {
            while (true) {
                while (sin.ready()) {
                    String msg = sin.readLine();
                    if (msg != null) {
                        Matcher m;
                        if ((m = JoinCommand.matcher(msg)).find(0)) {
                            omni.joinChannel(m.group(1).replace("#", ""));
                        } else if ((m = PartCommand.matcher(msg)).find(0)) {
                            omni.partChannel(ActiveIRCChannel);
                        } else if ((m = NickCommand.matcher(msg)).find(0)) {
                            omni.changeNick(m.group(1));
                        } else if ((m = OpCommand.matcher(msg)).find(0)) {
                            omni.opChannelMember(ActiveIRCChannel, m.group(1));
                        } else if ((m = DeOpCommand.matcher(msg)).find(0)) {
                            omni.deOpChannelMember(ActiveIRCChannel, m.group(1));
                        } else if ((m = CACCommand.matcher(msg)).find(0)) {
                            ActiveIRCChannel = m.group(1).replace("#", "");
                            sout.println("Changed the active channel to " + ActiveIRCChannel);
                        } else if ((m = ListCommand.matcher(msg)).find(0)) {
                            Channel curchan = omni.getChannelList().get(JIRC.inChannelList(omni.getChannelList(), m.group(1)));
                            Person[] People = curchan.getAllMembers();
                            for (int x = 0; x < People.length; x++) {
                                sout.println(People[x].getName() + " (" + People[x].getModes() + ") Active: " + People[x].isActive());
                            }
                        } else if ((m = RawCommand.matcher(msg)).find(0)) {
                            omni.sendRawMessage(m.group(1));
                        } else if ((m = ExitCommand.matcher(msg)).find(0)) {
                            sout.close();
                            sin.close();
                            System.exit(0);
                        } else if (msg.startsWith("/")) {

                        } else {
                            omni.sendMessage(ActiveIRCChannel, msg);
                            sout.println("#" + ActiveIRCChannel + ": <" + omni.getNick() + "> " + msg);
                        }
                    }
                }
                Thread.sleep(10);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


Major things:
-Package change, now is com.up.jirc instead of just jirc
-Color support
-Server response parsing.  Does not include every single IRC response numeric, or even most of them, but it does have most of the more common ones, I probably will add the rest eventually =P
-And then just fixing a lot of stupid various connection things
-Also, the constructor now requires the port to connect to

I dislike how much time I spent javadoc-ing though...  And I still left a lot un-done! D= That's why I like personal projects, documentation is for losers ;P

Okay, here's an example I made that shows loading a gif and displaying it as an animation.  You should be able to look at this and adapt it for what you need.  If you need help, just ask, or if you want me to try and adapt it for you, I could try, you'll just need to provide a little more info on the code structure of the project =P

import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.Iterator;
import javax.imageio.*;
import javax.imageio.metadata.*;
import javax.imageio.stream.*;
import org.w3c.dom.*;

public class GIFTEST {
    public static void main(String[] args) throws IOException {
        File input = new File("cat.gif");
        ImageInputStream stream = ImageIO.createImageInputStream(input);
        Iterator readers = ImageIO.getImageReaders(stream);
        if (!readers.hasNext()) throw new RuntimeException("No image reader found");
        ImageReader reader = (ImageReader)readers.next();
        reader.setInput(stream);
        int num = reader.getNumImages(true);
        GifFrame[] frames = new GifFrame[num];
        for (int i = 0; i < num; i++) {
            frames[i] = new GifFrame();
            BufferedImage image = reader.read(i);
            frames[i].i = image;
            IIOMetadata meta = reader.getImageMetadata(i);
            NodeList nodes = meta.getAsTree(meta.getNativeMetadataFormatName()).getChildNodes();
            for (int x = 0; x < nodes.getLength(); x++) {
                Node n = nodes.item(x);
                if (n.getLocalName().equals("GraphicControlExtension")) {
                    NamedNodeMap atts = n.getAttributes();
                    frames[i].time = Integer.parseInt(atts.getNamedItem("delayTime").getNodeValue());
                    frames[i].dispose = atts.getNamedItem("disposalMethod").getNodeValue();
                    frames[i].wait = Boolean.parseBoolean(atts.getNamedItem("userInputFlag").getNodeValue());
                }
            }
        }
        stream.close();
       
        Frame f = new Frame("GIF Test");
        GifAnimator ga = new GifAnimator(frames);
        ga.setSize(400, 400);
        f.add(ga);
        f.pack();
        f.setVisible(true);
        ga.start();
    }
}

class GifFrame {
    public Image i;
    public int time;
    public String dispose;
    public boolean wait;
}

class GifAnimator extends Canvas {
    private GifFrame[] frames;
    private Thread animator;
    private boolean run = false;
    private int f = 0;
   
    public GifAnimator(GifFrame[] frames) {
        this.frames = frames;
    }
   
    public void start() {
        run = true;
        animator = new Thread() {

            @Override
            public void run() {
                while (run) {
                    for (int i = 0; i < frames.length; i++) {
                        f = i;
                        repaint();
                        try {sleep(frames[i].time * 10);} catch (Exception e) {}
                    }
                }
            }
           
        };
        animator.start();
    }
   
    public void stop() {
        run = false;
    }
   
    @Override
    public void paint(Graphics g) {
        g.drawImage(frames[f].i, 0, 0, null);
    }
   
    @Override
    public void update(Graphics g) {
        paint(g);
    }
}


It's about 80% unit calculations I'd guess.  The mapper/drawing stuff is pretty fast, although i'm sure it could be a bit faster too.

Wut? O_o The info page says GMT-5 1:00, and its just about 12 GMT-5...

Way later than I wanted, but a couple screenshots. These showcase the viec, which auto-spawns units as you have the bodies (its a harvester viec), harvesters, which are collecting the dead, and a plain zombie, which is attacking the harvesters (Just for testing, obviously not what really happens =P), and a couple other things such as auto-targeting, target lines, etc.  It'll be close, and definitely not the full version that I envision, but we'll see if i can get a good enough version for the contest.

Haha, yeah, I haven't been working on a lot of cal stuff lately, probably the most TI thing I've been working on before this is TFE =P  And yeah, I totally thought of that title, and I'm like, "OMG, that would be perfect for a game name! Now how the hell  would a game with a title like that be?" =P So then I wrote that storyline to fit.  And the one thing I will say now before I finish up everything for a real post about the game is that it's a sort of RTS where, as you can probably gather, you play as the zombies taking over the world.