Let's have a look on Static.java. AnimationCore propagates its functionality to its user through a class called Animation. Its constructor looks like this:

    public Animation(
        AbstractEmbodiedAgent<UT2004SyncLockableWorldView> agent,
        AgentInfo agentInfo, Items itemsModule, Players playersModule,
        UT2004SyncLockableWorldView worldView,
        ICommandSerializer commandSerializer,
        Logger log, String ipAddress, int port)
        throws IOException, PogamutException

We don't have these classes instantiated yet:

In order to instantiate them, we have this code:

    // Instantiate modules.
        game = new Game(worldView, this.getLogger().platform());
        info = new AgentInfo(worldView, game, this.getLogger().platform());
        players = new Players(worldView, info, this.getLogger().platform());
        items = new Items(worldView, info, this.getLogger().platform());

Now we are ready to instantiate the animation module. Since its constructor can throw two types of exceptions, it is enclosed in a try statement:

    // Try to instantiate new animation module.
        animation = new Animation(this, info,
          items, players, worldView, commandSerializer,
          this.getLogger().getCategory("Animation"), "127.0.0.1", 3002);

Pay attention to the last two parameters, since they have to correspond with an IP address and port of GameBotsAnim. Port 3002 is the default port and "127.0.0.1" represents your present computer. We have experienced some issues with the way Java looks up and/or connects to server. In case the connection doesn't work, change "127.0.0.1" to "localhost".

After this, we have to supply a plan to our newly created animation module. That can be done through a method called setPlanner of the animation module. But first we have to create it.

The first planner we will make our bot to execute will be an instance of SimpleAnimationPlanner called WristFlapAnimationSimplePlanner. This planner makes the bot do a simple wrist flapping animation (as the name suggests). So let's instantiate it and assign it to the animation module:

    // Try to create and set a new planner,
    WristFlapAnimationSimplePlanner planner = new WristFlapAnimationSimplePlanner();
    // then assign it.
    animation.setPlanner(planner);

Ok we are almost done in the bot's constructor. There are only two more things you should know about and you can do in the constructor.

The first one is that you can attach event listeners to animation module, that listens for report that animation module finished the planner. A listener has to implement an AnimationListener interface. We will get more into detail about it a bit later in the tutorial. The second one is that you can also listen for the message ANIMSTOP coming from GameBots2004 (through standard means), that reports that bot has returned from animating state, to normal state and you can do all the standard things that you can do with an unarmed scenario bot. Listener for this event is a standard Pogamut event listener and as such implements IWorldEventListener with a type parameter AnimationStop. More on that later as well.

In order to take advantage of these feature, examine this code:

    // Set a listener to PlannerFinished event.
    animation.addAnimationListener(moduleListener);
    // Set a listener to ANIMSTOP message coming from GameBots2004
    // (GameBotsAnim communicates using a different binary connection)
    worldView.addEventListener(AnimationStop.class, serverListener);

As you already know, doLogic is where most of the bots actions originate from. This is also the place the animation module gets ticked from, since animation module required this kind of tick as well. In order to give you some time to Alt+Tab back into the game, first few (25) iterations are skipped using a simple counter. The pause between each iteration is handled by Pogamut itself, since it calls doLogic in set intervals.

After the first iterations pass, the "beef" of doLogic comes to hand. The beef consists of two parts:

Starting animation gets done by calling startAnimation method on animation module. This is to be done after each assignment of a new plan and positioning a bot to the target location of animation execution. Ticking the animation module should be happen every time since bot's starting animation up until it stops. In the next section we will cover how that is reported to you.

Two kinds of events should be of particular interested for you. We have mentioned them in the section called “Finishing touches to the bot's constructor”.

    protected class AnimListener implements AnimationListener {

        boolean once = false;

        @Override
        public void plannerFinished(IAnimationPlanner planner) {
            // We want to restart the planner only once.
            if (!once) {
                once = true;
                try {
                    // Change input file as you wish.
                    IAnimationPlanner new_planner = new BMLAnimationPlanner("BMLExample2.xml");
                    animation.setPlanner(new_planner);
                    animation.startAnimation();
                } catch (PogamutException e) {
                    getLogger().user().severe(e.getMessage());
                }
            }
        }
    }