Difference between revisions of "Thread:User talk:Gertjan1996/I have to make a 1v1 robot/reply (2)"
Jump to navigation
Jump to search
m |
m |
||
Line 56: | Line 56: | ||
turnGunRight(90); | turnGunRight(90); | ||
turnRight(90); | turnRight(90); | ||
+ | |||
+ | while (true) { | ||
+ | // Look before we turn when ahead() completes. | ||
+ | peek = true; | ||
+ | // Move up the wall | ||
+ | ahead(moveAmount); | ||
+ | // Don't look now | ||
+ | peek = false; | ||
+ | // Turn to the next wall | ||
+ | turnRight(90); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | /** | ||
+ | * onHitRobot: Move away a bit. | ||
+ | */ | ||
+ | public void onHitRobot(HitRobotEvent e) { | ||
+ | // If he's in front of us, set back up a bit. | ||
+ | if (e.getBearing() > -90 && e.getBearing() < 90) { | ||
+ | back(100); | ||
+ | } // else he's in back of us, so set ahead a bit. | ||
+ | else { | ||
+ | ahead(100); | ||
+ | } | ||
+ | } | ||
+ | |||
+ | /** | ||
+ | * onScannedRobot: Fire! | ||
+ | */ | ||
+ | public void onScannedRobot(ScannedRobotEvent e) { | ||
+ | fire(2); | ||
+ | // Note that scan is called automatically when the robot is moving. | ||
+ | // By calling it manually here, we make sure we generate another scan event if there's a robot on the next | ||
+ | // wall, so that we do not start moving up it until it's gone. | ||
+ | if (peek) { | ||
+ | scan(); | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | </syntaxhighlight> | ||
+ | <syntaxhighlight> | ||
+ | /******************************************************************************* | ||
+ | * Copyright (c) 2001-2014 Mathew A. Nelson and Robocode contributors | ||
+ | * All rights reserved. This program and the accompanying materials | ||
+ | * are made available under the terms of the Eclipse Public License v1.0 | ||
+ | * which accompanies this distribution, and is available at | ||
+ | * http://robocode.sourceforge.net/license/epl-v10.html | ||
+ | *******************************************************************************/ | ||
+ | package gertjan1996; | ||
+ | |||
+ | |||
+ | import robocode.HitRobotEvent; | ||
+ | import robocode.Robot; | ||
+ | import robocode.ScannedRobotEvent; | ||
+ | |||
+ | import java.awt.*; | ||
+ | |||
+ | |||
+ | /** | ||
+ | * Walls - a sample robot by Mathew Nelson, and maintained by Flemming N. Larsen | ||
+ | * <p/> | ||
+ | * Moves around the outer edge with the gun facing in. | ||
+ | * | ||
+ | * @author Mathew A. Nelson (original) | ||
+ | * @author Flemming N. Larsen (contributor) | ||
+ | */ | ||
+ | public class Walls extends Robot { | ||
+ | |||
+ | boolean peek; // Don't turn if there's a robot there | ||
+ | double moveAmount; // How much to move | ||
+ | |||
+ | /** | ||
+ | * run: Move around the walls | ||
+ | */ | ||
+ | public void run() { | ||
+ | // Set colors | ||
+ | setBodyColor(Color.black); | ||
+ | setGunColor(Color.black); | ||
+ | setRadarColor(Color.orange); | ||
+ | setBulletColor(Color.cyan); | ||
+ | setScanColor(Color.cyan); | ||
+ | |||
+ | // Initialize moveAmount to the maximum possible for this battlefield. | ||
+ | moveAmount = Math.max(getBattleFieldWidth(), getBattleFieldHeight()); | ||
+ | // Initialize peek to false | ||
+ | peek = false; | ||
+ | |||
+ | // turnLeft to face a wall. | ||
+ | // getHeading() % 90 means the remainder of | ||
+ | // getHeading() divided by 90. | ||
+ | turnLeft(getHeading() % 90); | ||
+ | ahead(moveAmount); | ||
+ | // Turn the gun to turn right 90 degrees. | ||
+ | peek = true; | ||
+ | turnGunRight(90); | ||
+ | import robocode.util.Utils; | ||
+ | |||
+ | public void run() { | ||
+ | // ... | ||
+ | |||
+ | turnRadarRightRadians(Double.POSITIVE_INFINITY); | ||
+ | do { | ||
+ | // Check for new targets. | ||
+ | // Only necessary for Narrow Lock because sometimes our radar is already | ||
+ | // pointed at the enemy and our onScannedRobot code doesn't end up telling | ||
+ | // it to turn, so the system doesn't automatically call scan() for us | ||
+ | // [see the javadocs for scan()]. | ||
+ | scan(); | ||
+ | } while (true); | ||
+ | } | ||
+ | |||
+ | public void onScannedRobot(ScannedRobotEvent e) { | ||
+ | double radarTurn = | ||
+ | // Absolute bearing to target | ||
+ | getHeadingRadians() + e.getBearingRadians() | ||
+ | // Subtract current radar heading to get turn required | ||
+ | - getRadarHeadingRadians(); | ||
+ | |||
+ | setTurnRadarRightRadians(Utils.normalRelativeAngle(radarTurn)); | ||
+ | |||
+ | // ... | ||
+ | } | ||
while (true) { | while (true) { |
Revision as of 21:09, 21 May 2014
http://robowiki.net/wiki/One_on_One_Radar
/*******************************************************************************
* Copyright (c) 2001-2014 Mathew A. Nelson and Robocode contributors
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://robocode.sourceforge.net/license/epl-v10.html
*******************************************************************************/
package sample;
import robocode.HitRobotEvent;
import robocode.Robot;
import robocode.ScannedRobotEvent;
import java.awt.*;
/**
* Walls - a sample robot by Mathew Nelson, and maintained by Flemming N. Larsen
* <p/>
* Moves around the outer edge with the gun facing in.
*
* @author Mathew A. Nelson (original)
* @author Flemming N. Larsen (contributor)
*/
public class Walls extends Robot {
boolean peek; // Don't turn if there's a robot there
double moveAmount; // How much to move
/**
* run: Move around the walls
*/
public void run() {
// Set colors
setBodyColor(Color.black);
setGunColor(Color.black);
setRadarColor(Color.orange);
setBulletColor(Color.cyan);
setScanColor(Color.cyan);
// Initialize moveAmount to the maximum possible for this battlefield.
moveAmount = Math.max(getBattleFieldWidth(), getBattleFieldHeight());
// Initialize peek to false
peek = false;
// turnLeft to face a wall.
// getHeading() % 90 means the remainder of
// getHeading() divided by 90.
turnLeft(getHeading() % 90);
ahead(moveAmount);
// Turn the gun to turn right 90 degrees.
peek = true;
turnGunRight(90);
turnRight(90);
while (true) {
// Look before we turn when ahead() completes.
peek = true;
// Move up the wall
ahead(moveAmount);
// Don't look now
peek = false;
// Turn to the next wall
turnRight(90);
}
}
/**
* onHitRobot: Move away a bit.
*/
public void onHitRobot(HitRobotEvent e) {
// If he's in front of us, set back up a bit.
if (e.getBearing() > -90 && e.getBearing() < 90) {
back(100);
} // else he's in back of us, so set ahead a bit.
else {
ahead(100);
}
}
/**
* onScannedRobot: Fire!
*/
public void onScannedRobot(ScannedRobotEvent e) {
fire(2);
// Note that scan is called automatically when the robot is moving.
// By calling it manually here, we make sure we generate another scan event if there's a robot on the next
// wall, so that we do not start moving up it until it's gone.
if (peek) {
scan();
}
}
}
/*******************************************************************************
* Copyright (c) 2001-2014 Mathew A. Nelson and Robocode contributors
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://robocode.sourceforge.net/license/epl-v10.html
*******************************************************************************/
package gertjan1996;
import robocode.HitRobotEvent;
import robocode.Robot;
import robocode.ScannedRobotEvent;
import java.awt.*;
/**
* Walls - a sample robot by Mathew Nelson, and maintained by Flemming N. Larsen
* <p/>
* Moves around the outer edge with the gun facing in.
*
* @author Mathew A. Nelson (original)
* @author Flemming N. Larsen (contributor)
*/
public class Walls extends Robot {
boolean peek; // Don't turn if there's a robot there
double moveAmount; // How much to move
/**
* run: Move around the walls
*/
public void run() {
// Set colors
setBodyColor(Color.black);
setGunColor(Color.black);
setRadarColor(Color.orange);
setBulletColor(Color.cyan);
setScanColor(Color.cyan);
// Initialize moveAmount to the maximum possible for this battlefield.
moveAmount = Math.max(getBattleFieldWidth(), getBattleFieldHeight());
// Initialize peek to false
peek = false;
// turnLeft to face a wall.
// getHeading() % 90 means the remainder of
// getHeading() divided by 90.
turnLeft(getHeading() % 90);
ahead(moveAmount);
// Turn the gun to turn right 90 degrees.
peek = true;
turnGunRight(90);
import robocode.util.Utils;
public void run() {
// ...
turnRadarRightRadians(Double.POSITIVE_INFINITY);
do {
// Check for new targets.
// Only necessary for Narrow Lock because sometimes our radar is already
// pointed at the enemy and our onScannedRobot code doesn't end up telling
// it to turn, so the system doesn't automatically call scan() for us
// [see the javadocs for scan()].
scan();
} while (true);
}
public void onScannedRobot(ScannedRobotEvent e) {
double radarTurn =
// Absolute bearing to target
getHeadingRadians() + e.getBearingRadians()
// Subtract current radar heading to get turn required
- getRadarHeadingRadians();
setTurnRadarRightRadians(Utils.normalRelativeAngle(radarTurn));
// ...
}
while (true) {
// Look before we turn when ahead() completes.
peek = true;
// Move up the wall
ahead(moveAmount);
// Don't look now
peek = false;
// Turn to the next wall
turnRight(90);
}
}
/**
* onHitRobot: Move away a bit.
*/
public void onHitRobot(HitRobotEvent e) {
// If he's in front of us, set back up a bit.
if (e.getBearing() > -90 && e.getBearing() < 90) {
back(100);
} // else he's in back of us, so set ahead a bit.
else {
ahead(100);
}
}
/**
* onScannedRobot: Fire!
*/
public void onScannedRobot(ScannedRobotEvent e) {
fire(2);
// Note that scan is called automatically when the robot is moving.
// By calling it manually here, we make sure we generate another scan event if there's a robot on the next
// wall, so that we do not start moving up it until it's gone.
if (peek) {
scan();
}
}
}