20.3.1. TclRobots.pm, the Perl Interface to TclRobots

This module implements a thin API so you can write RCPs in your favorite language—Perl—and do battle with all the existing Tcl RCPs. It's one of the strangest modules around, mixing Exporter subroutines; Perl, Tk, and Tcl code; and inter-language, bidirectional communications. You never knowingly use this module; rather, it's included when tclrobots runs an instance of perl -MTclRobots, at which time this module is loaded and begins execution on behalf of your RCP. It creates the main window of the required dimensions and at the proper location on the display, and adds all the widgets, text, and images. When instructed by tclrobots, the module then loads your Perl RCP via require, so be sure the code returns a true value. From that point on, incoming TclRobots messages are dispatched to Perl emulation handlers, and Perl RCP commands are converted to Tcl syntax and sent to tclrobots. The communication is handled transparently via send and Tk::Receive.

20.3.2. Robot Control Programs

"Do I flee when scanned, or do I turn and attack? How do I know where I am? I've kept a list of enemy robots and their locations, which do I shoot at first? How do I keep from running into an arena wall? How do I steer? How do I get from point A to point B? How do I compensate for my motion when computing a firing solution?" We certainly won't answer these questions, but just in case you think writing an RCP is easy, think again!

A good way to start writing your own RCP is to examine the samples, and the tournament entries at http://www.neosoft.com/tcl/ftparchive/sorted/misc/TclRobots/. Or search the Web; I've found Computer Science courses that teach RCP programming! And, of course, read the manpage.

Let's take a quick look at the Perl version of a sample RCP, charger.ptr. It's one of the shortest RCPs I've seen, yet it's surprisingly effective. Its strategy is simple: scan with a wide resolution until an enemy robot is found, charge the opponent, pinpoint the target with a narrow scan, and fire the cannon. Notice the code is strictly Perl, no Tcl or Tk required. The $status callback, executed every 10 seconds, demonstrates how to emulate repeat if it's not part of the language. It posts the robot's current position and the hardware tick count in the debug window. The scanner command expects the direction and resolution of the scan and returns the distance to the first target found. The cannon command fires a shell in the specified direction for the specified distance.

use vars qw/$dir $closest $limit $nothing $rng $start $status/;
use strict;

$dir = 90;
$nothing = 0;
$closest = 0;

$status = sub {
    dputs "tick count=", tick, "location=(", loc_x, ",", loc_y, ")";
    after 10_000 => \&$status;
};
after 0 => \&$status;           # Tcl idiom for repeat( )

while (1) {
    $rng = scanner $dir, 10;    # look for an opponent
    if ($rng > 0 and $rng < 700) { # if found and in range
        $start  = ($dir+20)%360;   # begin narrow scan
        for ($limit = 1; $limit <= 40; $limit++) {
            $dir = ($start - $limit + 360) % 360;
            $rng = scanner $dir, 1;
            if ($rng > 0 and $rng < 700) {
                $nothing = 0;           # charge!  fire a shell, and backup
                cannon $dir, $rng;      # scan so not to miss a moving target
                drive $dir, 70;
                $limit -= 4;
            }
        }
    } else {
        $nothing++;
        $closest = $dir if $rng > 700;
    }

    drive 0, 0;

    if ($nothing >= 30) {  # check for nothing found in reasonable time
        $nothing = 0;
        drive $closest, 100;
        after 10000 => sub {drive 0, 0};
    }
    $dir = ($dir - 20 + 360) % 360;
}

1;

Unsurprisingly, trigonometry plays an important part in any nontrivial RCP. Here are two formulas I've found useful. The first computes the distance between two points:

[expr hypot( ($x-$x0),($y-$y0) )]

You might use this to check if the robot has reached a particular coordinate or to calculate the range to a target. The second equation computes a heading between two points:

[expr (round($R2D * atan2(($y-$y0),($x-$x0))) + 360) % 360]

This is useful for steering the robot. The variable $R2D converts radians to degrees and is given by:

set R2D [expr 180.0 / ]

Of course, by now, you are fully capable of computing and translating these simple Tcl statements to Perl.

Turn to Appendix C, "Complete Program Listings" for a listing of complex.ptr, a sophisticated RCP written in Perl. This RCP is completely state driven and uses clock ticks to schedule internal events. It moves in a path described by an n-sided polygon that approximates a circle. The direction of movement is randomly chosen during preset, eliminating "wall" code (although the RCP may perform a "crazy Ivan" if it cannot find an enemy). The RCP also attempts to move as fast as possible, thus tracks its cooling rate to coordinate turns, eliminating "flee" code. There is also some watchdog code that periodically checks the RCP's health. Finally, the robot recognizes team members and targets only real enemies.