Robocode 1

COMP 1010 Home > Back to Extra Labs

Introduction Want to see why Robocode is awesome? Check this video out! In this lab you will learn to play the exciting coding game called Robocode. Robocode is an event driven program that allows us to create, modify, and test virtual warrior robots in a virtual battlefield. If you are not familiar with event driven programming you should consider completing the GUI Lab Part 1 or at least read Step 3 from that lab. Completing this lab and Robocode Part 2 will also give you a head start in understanding and using Application Programming Interfaces (APIs).

Installation

• Download and run the latest version of robocode-x.x.x.x-setup.jar file from: http://sourceforge.net/projects/robocode/files/

After Robocode is installed you can run it by either executing the supplied shortcut or by navigating to your installation folder and running the robocode.bat file.

Upon first boot of the game you will see a short battle demo.

When the demo ends you will be presented with a scoreboard of the demo battle as well as the Main Menu. Close the scoreboard as we have no use for it. Let us focus on the main menu for now.

The Main Menu

At the top of the main menu you will find the toolbar which you will use to start virtual battles. The main menu is also used to design Robots.

---

Selecting Battle from the toolbar allows you to setup a virtual battle. You can start from scratch by selecting New, this creates a new virtual battle. Selecting Open lets you open a pre-existing battle. The Open option also allows you to make modifications to the settings if so desired, or you can simply run the battle as is.

---

The Robot menu provides Robot development options. Selecting Editor within the Robot menu will open the Robot Editor. You will soon use the Robot Editor to design your first Robot.

---

For now this is all you need to know to get started and move around using Robocode. Do not worry about the other options just yet.

Sample battle

To better familiarize yourself with Robocode and understand what the game is all about let us first look at setting up a sample battle using some of the predefined Robots that came with the installation of Robocode. Let us create a virtual battle with 3 Robots that goes for 5 rounds. To do so:

1. Click on the Battle menu and select New (Or Press Ctrl+N). This will open the New Battle Screen.
   
   
   
2. Double click on any 3 Robots from the Available Robots pane. Upon adding Robots you should be able to see them pop up on the Selected Robots pane on the right.
   
   
   
3. Change the number of rounds value to 5.
   
   
   
   • Each battle consists of consecutive rounds. Since the Robots are randomly dropped on the the battlefield we can have multiple rounds to make the game fair.
     
     
4. Click on Start Battle and enjoy.

In Robocode you do not have control over any Robot during the battle. Your programming skills in designing your Robot will determine how well your Robot does in combat. So without further ado, go ahead and read the next section which tells you how to create your first Robot.

Create your first Robot

Now that you have the basics down, let us create your first Robot.

1. From the Robot menu, select Editor (Or Press Ctrl+E). This opens up the Robot Editor where you will make, edit, and compile your Robot. It should bring up a window with the following menu items available:
   
   
   
2. From the File menu, select New, then select Robot. (Or press Ctrl+N).
   
   
   
3. Enter a name for your Robot. This name cannot contain any spaces and is similar to Java variables in this respect. Click Ok.
   
   
   
4. Enter a short package name for your Robot. This should be somewhat different than your Robot's name.
   
   
   

There you have it, your Robot has been created. As you can see the Robot code pops up and is ready to edit. Your Robot is essentially an object as defined in object oriented programming. Robots have some basic methods in their source code. These include run(), onScannedRobot(ScannedRobotEvent e), onHitByBullet(HitByBulletEvent e), and onHitWall(HitWallEvent e).

Making the Robot Move

Now that your code for your Robot has been created, it is time to add in some functionality. By default the Robot has some movement functionality already in it. Now we will take a look at the run method to examine this default movement.

 public void run() {
   // Initialization of the Robot should be put here

   // After trying out your Robot, try uncommenting the import at the top,
   // and the next line:

   // setColors(Color.red,Color.blue,Color.green); // body,gun,radar

   // Robot main loop
   while(true) {
      // Replace the next 4 lines with any behavior you would like
      ahead(100);
      turnGunRight(360);
      back(100);
      turnGunRight(360);
   }
} 

As you can see there appears to be some movements called ahead(100) and back(100) in the main while loop. Let's test out these movements and see if our Robot actually does this.

1. Let's increase ahead(100) to ahead(150).
2. Compile your Robot by going to Compiler, select Compile (Or press Ctrl+B).
   
   
   
3. Once it successfully compiles click Ok. Your Robot is now compiled and ready to move around the map.
4. Go back to the main GUI and import your Robot.
5. Click Battle.
6. Click New (Or press Ctrl+N).
7. Locate your package under the Packages section.
8. Click your package to see your Robot under the Robots section.
9. Click Add -> to add your Robot to the list of selected Robots. Now it is time to see if your Robot actually moves.
10. Click on Start Battle.

Unless you added other Robots, your Robot should just run around aimlessly for 10 rounds, but we have now verified that movement works. If you like, you can start experimenting with different values to ahead(150), turnGunRight(360), back(100), and turnGunRight(360).

Firing on Other Robots

Now that we know our Robot can move around, let's make it fire on other Robots. By default, when your Robot was created it had a method called onScannedRobot. This method will automatically fire on any robots that your robot detects.

We are going to keep this functionality but also add two more.

1. Add in fire(1) underneath ahead(100).
2. Add in fire(1) underneath back(100).

 public void run() {
   // Initialization of the Robot should be put here

   // After trying out your Robot, try uncommenting the import at the top,
   // and the next line:

   // setColors(Color.red,Color.blue,Color.green); // body,gun,radar

   // Robot main loop
   while(true) {
      // Replace the next 4 lines with any behavior you would like
      ahead(100);
      fire(1);
      turnGunRight(360);
      back(100);
      fire(1);
      turnGunRight(360);
   }
} 

After recompiling your Robot, let's test our new firing functionalities on another Robot.

1. Select a new Battle.
2. Add in your Robot from your package as you did earlier.
3. Add in, from the sample Package, SittingDuck.
4. Click Start Battle to begin firing!

Feel free to add in other scenarios when you want your Robot to fire.

Additional Methods

Now that we have covered the run() method, let's add in some more functionality to three other methods: onScannedRobot(), onHitByBullet(), and onHitWall().

onScannedRobot()

By default, all you have in this method is:

 public void onScannedRobot(ScannedRobotEvent e) {
   // Replace the next line with any behavior you would like
   fire(1);
} 

1. Add in a turnGunLeft(360) just above your fire(1) method's call.
2. Increase the fire to 2 instead of 1.

onHitByBullet()

By default, all you have in this method is:

 public void onHitByBullet(HitByBulletEvent e) {
   // Replace the next line with any behavior you would like
   back(10);
} 

Let's change this up a bit.

1. Insert a turnRight(90) before the back(10).
2. Change back(10) to ahead(20) .

onHitWall()

By default, all you have in this method is:

 public void onHitWall(HitWallEvent e) {
   // Replace the next line with any behavior you would like
   back(20);
} 

1. Add in a turnLeft(180) above the back(20).

Battle your Robot

Now it is time to show the TA the cool new things you have learned in this lab. Your Robot is now ready for battle. Feel free to add in more functionality to your Robot. For a more in depth look at improved functionality, see the next lab Robocode Part 2.