Diese Seite enthält Code Stücke die wir für die 2020 Frühlings Heim Challenge verwendet haben.
Robocode
Die Roboter, die wir für die Herausforderung verwenden, basieren auf dem JuniorRobot,public class Day2 extends JuniorRobot
Alle Methoden und Variablen, die im JuniorRobot verfügbar sind, sind auf https://robocode.sourceforge.io/docs/robocode/robocode/JuniorRobot.html
dokumentiert, bitte verwende diese Seiten als Referenz
Wie kann man die Farbe eines Roboters einstellen?
Robocode verwendet die setColors Methode, um Farben des JuniorRobot den wir für die Herausforderung verwenden, zu definieren, Wir setzen die Farben in der run() Methode, damit sind die Farben beim Erstellen des Roboters festgelegt:
// Vordefinierte Farben (in Englisch): // blue, yellow, black, white, red, // blau, gelb, schwarz, weiss, rot // pink, brown, grey, orange… // rosa, braun, grau, orange // Sets these colors (robot parts): body, gun, radar, bullet, scan_arc // Die Farben werden für verschiedene Teile des Roboters gesetzt // Körper, Kanone, Radar, Kugel, Radar-Bogen setColors(orange, blue, white, yellow, black);
Wie kann ich meinen Roboter gegen den von mir gescannten Roboter drehen?
Sehr ähnlich wie wir den Day3 Roboter gemacht haben, schau bitte auch dieses Dokument als Referenz an.
Um den Roboter in Richtung eines gescannten Feindes zu drehen, müssen wir die onScannedRobot() ändern und die turnTo(degrees) Methode verwenden. Es steht Dir eine Variable namens scannedAngle zur Verfügung, die auf die Richtung (in Grad) gesetzt ist, in der ein Gegner erkannt wird. Die variable scannedAngle wird direkt vor dem Aufruf der onScannedRobot() Methode gesetzt, aber sie wird zurückgesetzt, sobald sich die Kanone oder der Roboter zu drehen beginnt. Dies ist wichtig, da du den Roboter in Richtung des Feindes drehen willst, und dann sicherstellen musst, dass die Kanone auf den Feind zeigt, nachdem Dein Roboter gedreht wurde. Andernfalls wird Dein Roboter auf den Feind gerichtet, aber da die Kanone mit dem Körper gedreht wurde, zeigt die Waffe nicht mehr auf den gescannten Roboter.
Also definieren wir eine lokale Variable, um den gescannten Winkel (scannedAngle ) zu speichern, so dass Du sowohl den Roboter als auch die Waffe in Richtung des Feindes drehen kannst. So sollte die onScannedRobot() – Methode aussehen:
public void onScannedRobot() {
// store the angle the enemy is scanned
// speichere den Winken auf dem wir den Feind gesehen haben
int iScanAngle = scannedAngle;
turnTo(iScanAngle); // turn the body - drehe den Roboter
turnGunTo(iScanAngle); // turn the gun - drehe die Kanone
}
Wie kann ich meinen Roboter an einer Wand sitzen lassen und sein Radar um 180 Grad nach links und rechts drehen lassen?
Wir zeigen Dir, wie Du dies auf Norden (d.h. der oberen Wand) machst, aber Du kannst den Code bearbeiten, um an eine der vier Wände zu fahren. Zuerst müssen wir die Richtungen verstehen. Der obere Rand der Karte ist in Richtung von 0 Grad, rechts ist 90 Grad, unten ist 180 Grad und links ist 270 Grad. Also muss der Tank nach oben (Richtung 0 Grad) fahren, bis er die Wand berührt. Biege dann nach links ab (270 Grad). Dann drehe das Radar zwischen 90 Grad (rechts) und 270 Grad (links). Einfach! Hier ist der ganze Code mit Kommentaren, die erklären, was passiert:
package HomeChallenge;
import robocode.*;
public class WallCrawler extends JuniorRobot {
// tells us to move forwards or backwards
// sagt uns ob wir uns vorwärts oder rückwärts bewegen
// tells us to sweep our gun left or right
// sagt uns ob wir die Kanone links oder rechts herum drehen
private boolean bSweepLeft = true;
// tells us if we are on a wall
// sagt uns wenn wir an der Wand sind
private boolean bOnWall = false;
public void run() {
// if the tank is on the wall, then do the sweeping
// der Roboter ist an der Wand - beginne zu suchen
if (bOnWall) {
if (bSweepLeft) {
// sweep the gun left (from 270 degrees to 90 degrees)
// drehe die Kanone links (von 270 Grad zu 90 Grad)
turnGunLeft(2);
// if gun is all the way to the right,
// then sweep the other way
// falls die Kanone ganz nach rechts zeigt
// drehen wir sie in die andere Richtung
if (gunHeading <= 90)
bSweepLeft = false;
}
// sweep the gun right (from 90 degrees to 270 degrees)
// drehe die Kanone rechts (von 90 Grad zu 270 Grad)
else {
turnGunRight(2);
// if gun is all the way to the right
// then sweep the other way
// falls die Kanone ganz nach rechts zeigt
// drehen wir sie in die andere Richtung
if (gunHeading >= 270)
bSweepLeft = true;
}
// move along the wall
// fahre der Wand entlang
if (bGoForward) {
ahead(10);
}
else {
back(10);
}
}
else { // the tank is not at a wall
// der Tank ist nicht an der Wand
// turn north - drehen nach Norden
turnTo(0);
// and move - with 1000 we will hit the top wall
// und fahre - mit 1000 bis zur oberen Wand
ahead(1000);
}
}
public void onScannedRobot() {
// Big Bullets - Grosse Kugeln
fire(3);
}
public void onHitByBullet() {
// Stationary Target - turn to where we were hit from
// Ziel ist stationär - wir drehen zum Ziel
turnGunTo(hitByBulletAngle);
// Big Bullets - Grosse Kugeln
fire(3);
}
public void onHitWall() {
if (bOnWall) {
// we are on the wall - change direction
// wir sind an der Wand - ändere die Richtung
bGoForward = !bGoForward;
}
else { // we have just hit the North wall
// wir sind das erste mal an der Nordwand
bOnWall = true;
// Turn to face left - drehe um gegen links zu schauen
turnTo(270);
// Turn the gun to face left - auch die Kanone nach links
turnGunTo(270);
}
}
}
Wie find ich die nächste Wand und fahre zu dieser Wand?
Erweitere den WallCrawler, indem Du zur nächsten Wand fährst. Wie findest Du die nächste Wand und fährst zu dieser?
// die Anfangs Richtung des Roboters an einer Wand
// Index
// 0 == oben - fahre links - 270 Grad
// 1 == links - fahre nach unten - 180 Grad
// 2 == unten - fahre nach rechts - 90 Grad
// 3 == rechts - fahre nach oben - 0 Grad
private int[] iInitDir = { 270, 180, 90, 0 };
// das erste Mal wenn wir in der run() Methode sind
private int iWhatWall = -1;
public void run()
{
// nicht initialisiert - das erste Mal
if (iWhatWall == -1)
{
int iVertDist, iHorzDist, iWhereNext;
// finde die nächste Wand
// Zur Erinnerung, das Koordinaten System 0,0 ist unten rechts
// robotX , robotY - Position dieses Roboters
// fieldWidth, fieldHeight - Grösse des Feldes
if (robotY < (fieldHeight/2)) // untere oder obere Hälfte
iVertDist = robotY; // Distanz von unten
else
iVertDist = fieldHeight-robotY; // Distanz von oben
// linke oder rechte Hälfte?
if (robotX < (fieldWidth/2))
iHorzDist = robotX; // Distanz von links
else
iHorzDist= fieldWidth-robotX; // Distanz von rechts
if (iVertDist < iHorzDist) // Vertikal ist näher
{
if (robotY < (fieldHeight/2))
iWhereNext = 2; // Fahre zur unteren Wand
else
iWhereNext = 0; // Fahre zur oberen Wand
} else { // horizontal
if (robotX < (fieldWidth/2))
iWhereNext = 1; // Fahre zur linken Wand
else
iWhereNext = 3; // Fahre zur rechten Wand
}
iWhatWall = (iWhereNext+3)%4;
// Richtung zu der Wand
turnTo(iInitDir[iWhatWall]);
// Anfangs Richtung bearGunTo(270);
// relative zum Roboter - 90 Grad linke Seite
// nun fahre - Maximale Distanz zur Wand
ahead(Math.max(iVertDist , iHorzDist));
}
else ….
// normale run Methode
} ~