1. This Week Cover as much Robocode strategy as we can Monday: Robocode
NN Homework Review
Hand in Picbreeder hw if you haven’t
Grades: Can’t give you an A if you haven’t at least turned in the assignments
me if you’d like to double check my records against yours (which assignments you turned in and how many points you received for each)

2. This Week Continued Tuesday: Quiz Wednesday: Robocode
Explain how a neural network can represent a solution to a particular problem. Explain how you would input data and interpret the output.
Wednesday: Robocode
Thursday: Competition and prizes – My last day (no late robots)
Friday: AI Jeopardy with Dan DeBlasio

3. Robocode Homework

4. Robocode and Robocode Strategies
(taken from citations at the end)

5. Excellent Sources of Information
My First Robot
FAQs

6. From Last Time Robocode tanks are java programs
We saw this when we added a line of code, compiled, and ran the code
Robocode tanks are event driven
There is a main loop
The main loop can be interrupted by handling different events

7. From Last Time The tank default behavior is in a loop defined in run()
Different events interrupt this loop execution

8. Example public class MyRobot extends Robot { public void run() {
while(true) {
ahead(100);
turnGunRight(360);
back(100); }
This is an example main loop. This robot doesn’t have any event handlers so it executes these exact actions until it either wins (very unlikely) or dies (very likely).

9. Example public class MyRobot extends Robot { public void run() {
while(true) {
ahead(100);
turnGunRight(360);
back(100); }
public void onHitByBullet(HitByBulletEvent e) {
turnLeft(90 - e.getBearing());
This example has an event handler. It will continue executing this loop until we get hit by a bullet. When we get hit, we turn toward the enemy.

10. Inheritance in Java Ideas: Inhertiance
common components are inherited, rather than duplicated
allows similar though distinct objects to exhibit their common capabilities without requiring the code to be in two places

11. Inheritance in Java Class GoldenRetriever extends Dog
GoldenRetriever has any properties that Dog has:
Canis lupus familiaris
Four legs
GoldenRetriever has extra properties not common to all dogs
Gold hair
Playful demeanor
Tall

12. Inheritance in Java Class Dog extends Mammal Mammals have: Dogs have:
Hair
Legs
Lungs
Dogs have:
Canis lupus familiaris
Four legs

13. Inheritance in Java
To give our robots all of the methods defined in the robot API, we have been extending the Robot class. This is so we don’t have to define all the methods that are already defined for us.
We could also extend the AdvancedRobot class
Note: Beginners
I don’t expect you to fully implement this concept
I do expect you to understand what happens when we extend a class (inherit from a class)

14. Robocode Basics Tank properties Game play Energy Time Fire Radar
How to determine a winner (not necessarily last tank standing)
How the Robocode engine updates

15. Tank Basics: Energy
Tanks start with a certain amount of health (energy)
100
Tanks lose health by:
getting shot
bumping into things (the walls, other robots)
shooting bullets
fighting for too long
(Note: tanks that hit each other lose equal amounts of health)
Tanks gain health by shooting other tanks
Tanks that run out of health by shooting too much are disabled (If the tanks bullet hits a target it can gain energy back)

16. Game Play (point distribution)
Robots on the field when another robot dies – 50 points
Last robot alive given extra points – 10 points per dead robot
Every point of fire damage inflicted on target robot – 1 point
Every opponent ram – 2 points per damage inflicted by ramming
Killing a target robot by firing at it– 20% of total damage inflicted
Death by ramming – 30% of total damage inflicted

17. Tank Basics: Time Rotating the gun, radar, and vehicle takes time
Vehicle takes the longest amount of time
Radar takes the least amount of time
Bullets take time to hit things (need to shoot where you expect the target to be when the bullet should arrive)
Gun has a short cooldown period in between shots
Radar must be pointed at a target to see it
Detects velocity, bearing, heading, and energy remaining.

18. Tank Basics: Fire 3 levels of firing
fire(1) – costs the least health, does the least damage
fire(2) -costs intermediate health, does intermediate damage
fire(3) – costs the most health, does the most damage

19. Tank Basics: Radar Infinite range One degree scan width
Returns enemy position, orientation, bearing, gun angle, and energy.
Tank knows its own position, oreintation, bearing, gun angle, and energy

20. Game Play (how Robocode updates)
All robots execute their code until taking action
Time is updated
All bullets move and check for collisions
All robots move (heading, acceleration, velocity, distance, in that order)
All robots perform scans (and collect team messages)
The battlefield draws

21. Robocode Strategies
Seeing other robots – how the robot controls its radar
Choosing an enemy
Moving – where the robot should go
Targeting and Shooting - when, how powerful and in which direction to shoot.

22. Radar Strategies – Seeing other robots
Remember that scanning takes time
Simple – scan 360 degrees (while alive), looking for target robots, remember where these robots are
Problem: Robots aren’t typically evenly distributed

23. Example: Scan 360 public class MyFirstRobot extends Robot {
public void run() {
while (true) {
ahead(100);
turnGunRight(360); }
}  
public void onScannedRobot(ScannedRobotEvent e) { fire(1); } }

24. Radar Strategies – Seeing other robots
Locked scanning strategy – radar finds a target and sticks with it
Implemented by moving the radar back and forth a little to keep track of the robot, it could scan the direction based on the target robot’s heading
Problem: Not good for bigger battles since you could pass by easier to kill robots
Radar can be used to guess when an opponent’s bullet has fired
Any ideas on how we could do this?
Look at what we can gather from the radar API

25. Example: Target Lock //Follows the robot around the battlefield.
public void run() { // ... turnRadarRightRadians(Double.POSITIVE_INFINITY);
do { scan(); } while (true); }
public void onScannedRobot(ScannedRobotEvent e) {
double absoluteBearing = getHeadingRadians() + e.getBearingRadians();
double radarTurn = absoluteBearing - getRadarHeadingRadians(); setTurnRadarRightRadians(Utils.normalRelativeAngle(radarTurn)); // ... }

26. Radar Strategy – Methods (AdvancedRobots)
scan() - Scans the arena using the radar at its current setting. Robocode calls this for each robot at each turn.
setTurnRadarLeft and turnRadarLeft.
setTurnRadarRight and turnRadarRight
setAdjustRadarForRobotTurn - Enables or disables the radar locking to the vehicle
setAdjustRadarForGunTurn - Enables or disables the radar locking to the gun

27. Choosing an Enemy Weakest Enemy – Pick the guy with the lowest health
Problem: This target could be far away. Another robot could dip below target robot’s health in the mean time!
Closest Enemy – Pick the guy closest to you
Problem: He could be the winner. Dying earlier means you receive less points overall

28. Choosing an Enemy No explicit methods provided by Robocode
Neural Network Targeting Today if we have time

29. Movement Strategies (MS)
None – easy to hit
Straight line
Problem: Easy for enemies to predict
Curve
Problem: Also easy for enemies to predict
Oscillating
Random
Problem: Run a larger chance of hitting walls

30. Movement Strategies (MS)
Anti-gravity – keeps the robot from dangerous areas and attracts it toward advantageous areas
Many different implementations
These and more discussed here –

31. Shooting Strategies Stationary Linear Circular Oscillatory
Movement pattern matching

32. Shooting Strategies
Stationary – Assume the robot is not going to move and fire directly at the target robot’s current location
Problem: If the target moves, we miss
Target Robot
Our Robot

33. Example: Stationary Shooting
onScanRobot() {
fire(1); }
//This method just fires where we saw the robot without taking into account where it may be going

34. Shooting Strategies
Linear – Assume that the robot is moving in a straight line, fire at where the robot should be in the time it takes to fire (Assumes constant velocity)
All robot motion can be approximated for a short period of time this way
Problem: Not effective over longer periods of time
Target Robot
Our Robot X

35. Shooting Strategies
Circular- Assumes the target moves at a constant velocity and angular velocity (slightly better than linear targeting)
Problem: Can be avoided by stopping/starting quickly or changing directions sporadically
Target Robot
Our Robot X

36. Shooting Strategies Circular
change in x = cos(initialheading) * radius - cos(initialheading + changeinheading) * radius
change in y = sin(initialheading + changeinheading) * radius - sin(initialheading) * radius

37. Shooting Strategies
Oscillatory – Assumes that the target robot is moving back and forth
(not many robots do this)
Target Robot
Our Robot X

38. Shooting Strategies
Movement pattern matching – Predicts target robots position based on past moves
Problems: Time expensive
Target Robot
Our Robot X

39. Recall how inheritance works
common components are inherited, rather than duplicated
allows similar though distinct objects to exhibit their common capabilities without requiring the code to be in two places

40. Creating Your Own Event
Note: We’ve been extending the Robot class
If we extend the AdvancedRobot class, we can create our own events

41. Creating Your Own Event
Events happen when a certain condition is met
E.g.
onScanRobot() – checks to see if another robot is found, returns true if a robot is found, event fires
Event needs to check for some kind of “behavior,” call this a condition
Your robots onCustomEvent(CustomEvent e) method is called when the test condition is true

42. Creating Your Own Event
addCustomEvent(Condition condition) Registers a custom event to be called when a condition is met.
Condition() Creates a new, unnamed Condition with the default priority.
Condition(String name) Creates a new Condition with the specified name, and default priority.
Condition(String name, int priority) Creates a new Condition with the specified name and priority.

43. Example: Our own event public class MyEvent extends AdvancedRobot {
... public void run() {
//the condition is given a name “canFire”
addCustomEvent(new Condition(“canFire")
public boolean test()
// When the gun has cooled off, test returns true
return (getGunHeat() == 0); }; } );

44. Example: Handling our event
public void onMyEvent(CustomEvent ev) {
fire(3); }

45. Citations… http://people.csail.mit.edu/jacobe/papers/robocode.pdf