Java 如何在我的机器人代码中添加防墙功能？

我正在给一个机器人编程，它可以在计算机中运行。我的代码目前运行正常，我的坦克就像我希望它运行和移动一样运行。唯一的问题是，它在一场战斗中撞到墙上好几次，每次都会让我失去健康

我尝试使用getX（）和getY（）与run（）方法中网格的长度和宽度getBattleFieldWidth（）和getBattleFieldHeight（）比较我的主体的位置，但是，这似乎不起作用。我还尝试将此代码放在onScannedRobot（）方法中，但效果并不理想。我试图，当我的主题距离墙的每一侧接近50个单位时，改变主题的方向，使其与墙平行。然而，这尚未奏效。我也试着做同样的事情，但我的主题方向相反，但这也不起作用。我在run（）和onScannedRobot（）方法中都尝试过这一切，但尚未成功

我曾尝试使用中描述的算法：简单迭代墙平滑（由PEZ提供）、快速墙平滑（由Voidious提供）、非迭代墙平滑（由David Alves提供）和非迭代墙拥抱（由Simonton提供），但尚未成功

我正在使用Robocode版本1.7.3.6来运行此代码

如何在代码中添加墙避免，或者最好是墙平滑？这是我的密码：

package stephen.tanks;

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import robocode.*;
import robocode.util.Utils;


public class AimmaKickeraskTank extends AdvancedRobot {
    static int currentEnemyVelocity;
    static int aimingEnemyVelocity;
    double velocityToAimAt;
    boolean fired;
    Rectangle grid = new Rectangle(0, 0, 800, 600);
    double oldTime;
    int count;
    int averageCount;
    static double enemyVelocities[][] = new double[400][4];
    static double turn = 2;
    int turnDir = 1;
    int moveDir = 1;
    double oldEnemyHeading;
    double oldEnergy = 100;


    @Override
    public void run() {
        setBodyColor(Color.blue);
        setGunColor(Color.blue);
        setRadarColor(Color.black);
        setScanColor(Color.yellow);
        setAdjustGunForRobotTurn(true);
        setAdjustRadarForGunTurn(true);

        while (true) {
            turnRadarRightRadians(Double.POSITIVE_INFINITY);
        }
    }


    @Override
    public void onScannedRobot(ScannedRobotEvent e) {
        double absBearing = e.getBearingRadians() + getHeadingRadians();
        Graphics2D g = getGraphics();
        turn += 0.2 * Math.random();
        if (turn > 8) {
            turn = 2;
        }

        if(oldEnergy - e.getEnergy() <= 3 && oldEnergy - e.getEnergy() >= 0.1) {
            if (Math.random() > .5) {
                turnDir *= -1;
            }
            if(Math.random() > .8) {
                moveDir *= -1;
            }
        }

        setMaxTurnRate(turn);
        setMaxVelocity(12 - turn);
        setAhead(90 * moveDir);
        setTurnLeft(90 * turnDir);
        oldEnergy = e.getEnergy();

        if (e.getVelocity() < -2) {
            currentEnemyVelocity = 0;
        }
        else if (e.getVelocity() > 2) {
            currentEnemyVelocity = 1;
        }
        else if (e.getVelocity() <= 2 && e.getVelocity() >= -2) {
            if (currentEnemyVelocity == 0) {
                currentEnemyVelocity = 2;
            }
            else if (currentEnemyVelocity == 1) {
                    currentEnemyVelocity = 3;
            }
        }
        if (getTime() - oldTime > e.getDistance() / 12.8 && fired == true) {
            aimingEnemyVelocity=currentEnemyVelocity;
        }
        else {
            fired = false;
        }

        enemyVelocities[count][aimingEnemyVelocity] = e.getVelocity();
        count++;

        if(count==400) {
            count=0;
        }

        averageCount = 0;
        velocityToAimAt = 0;

        while(averageCount < 400) {
            velocityToAimAt += enemyVelocities[averageCount][currentEnemyVelocity];
            averageCount++;
        }

        velocityToAimAt /= 400;

        double bulletPower = Math.min(2.4, Math.min(e.getEnergy()/3.5, getEnergy()/9));
        double myX = getX();
        double myY = getY();
        double enemyX = getX() + e.getDistance() * Math.sin(absBearing);
        double enemyY = getY() + e.getDistance() * Math.cos(absBearing);
        double enemyHeading = e.getHeadingRadians();
        double enemyHeadingChange = enemyHeading - oldEnemyHeading;
        oldEnemyHeading = enemyHeading;
        double deltaTime = 0;
        double battleFieldHeight = getBattleFieldHeight();
        double battleFieldWidth = getBattleFieldWidth();
        double predictedX = enemyX, predictedY = enemyY;

        while ((++deltaTime) * (20.0 - 3.0 * bulletPower) < Point2D.Double.distance( myX, myY, predictedX, predictedY)) {      
            predictedX += Math.sin(enemyHeading) * velocityToAimAt;
            predictedY += Math.cos(enemyHeading) * velocityToAimAt;
            enemyHeading += enemyHeadingChange;
            g.setColor(Color.red);
            g.fillOval((int)predictedX - 2,(int)predictedY - 2, 4, 4);

            if (predictedX < 18.0 || predictedY < 18.0 || predictedX > battleFieldWidth - 18.0 || predictedY > battleFieldHeight - 18.0) {   
                predictedX = Math.min(Math.max(18.0, predictedX), battleFieldWidth - 18.0); 
                predictedY = Math.min(Math.max(18.0, predictedY), battleFieldHeight - 18.0);
                break;
            }
        }

        double theta = Utils.normalAbsoluteAngle(Math.atan2(predictedX - getX(), predictedY - getY()));
        setTurnRadarRightRadians(Utils.normalRelativeAngle(absBearing - getRadarHeadingRadians()) * 2);
        setTurnGunRightRadians(Utils.normalRelativeAngle(theta - getGunHeadingRadians()));

        if(getGunHeat() == 0) {
            fire(bulletPower);
            fired = true;
        }         
    }
}

package.tanks；
导入java.awt.Color；
导入java.awt.Graphics2D；
导入java.awt.Rectangle；
导入java.awt.geom.Point2D；
导入java.awt.geom.Rectangle2D；
进口机器人代码。*；
导入robocode.util.Utils；
公共类AimmaKickeraskTank扩展高级机器人{
静态电流速度；
静态内对准性；
双速瞄准；
布尔激发；
矩形网格=新矩形（0,0,800,600）；
双倍旧时；
整数计数；
int平均计数；
静态双灌肠速度[][]=新双[400][4]；
静态双圈=2；
int-turnDir=1；
int moveDir=1；
双老麦穗；
双倍能量=100；
@凌驾
公开募捐{
setBodyColor（颜色：蓝色）；
setGunColor（颜色：蓝色）；
setRadarColor（颜色：黑色）；
设置颜色（颜色为黄色）；
setAdjustGunForRobotTurn（真）；
setAdjustRadarForGunTurn（真）；
while（true）{
turnRadarRightRadians（双正无穷大）；
}
}
@凌驾
CannedRobot上的公共空间（扫描机器人事件e）{
双轴承=e.getBearingRadians（）+getHeadingRadians（）；
Graphics2D g=getGraphics（）；
turn+=0.2*Math.random（）；
如果（转身>8）{
匝数=2；
}
if（oldEnergy-e.getEnergy（）=0.1）{
if（Math.random（）>.5）{
turnDir*=-1；
}
if（Math.random（）>.8）{
moveDir*=-1；
}
}
设置最大周转率（周转率）；
设置最大速度（12转）；
设置提前（90*moveDir）；
设置左转（90*turnDir）；
oldEnergy=e.getEnergy（）；
如果（如getVelocity（）<-2）{
currentEnemyVelocity=0；
}
否则如果（如getVelocity（）>2）{
currentEnemyVelocity=1；
}
否则如果（例如getVelocity（）=-2）{
如果（currentEnemyVelocity==0）{
currentEnemyVelocity=2；
}
else if（currentEnemyVelocity==1）{
currentEnemyVelocity=3；
}
}
if（getTime（）-oldTime>e.getDistance（）/12.8&&fired==true）{
aimingemyvelocity=当前速度；
}
否则{
解雇=假；
}
EnemyVelocity[count][aimingememyvelocity]=e.getVelocity（）；
计数++；
如果（计数=400）{
计数=0；
}
平均计数=0；
速度目标=0；
而（平均计数<400）{
velocityToAimAt+=EnemyVelocies[平均计数][当前EnemyVelocity]；
averageCount++；
}
速度目标/=400；
double bulletPower=Math.min（2.4，Math.min（e.getEnergy（）/3.5，getEnergy（）/9））；
double myX=getX（）；
双myY=getY（）；
double-enemyX=getX（）+e.getDistance（）*Math.sin（ABS）；
双重enemyY=getY（）+e.getDistance（）*Math.cos（absBearing）；
双enemyHeading=e.getHeadingRadians（）；
双灌肠头更改=灌肠头-旧灌肠头；
OldEneyHeading=EneyHeading；
双deltaTime=0；
双战场高度=获取战场高度（）；
双战场宽度=getBattleFieldWidth（）；
双重预测X=灌肠，预测Y=灌肠；
而（++deltaTime）*（20.0-3.0*bulletPower）战场宽度-18.0 | |预测Y>战场高度-18.0）{
predictedX=Math.min（Math.max（18.0，predictedX），战场宽度-18.0）；
predictedY=Math.min（Math.max（18.0，predictedY），战场高度-18.0）；
打破
}
}
double theta=Utils.normalAbsoluteAngle（Math.atan2（predictedX-getX（），predictedY-getY（））；
setTurnRadarRightRadians（Utils.normalRelativeAngle（absBearing-getRadarHeadingRadians（））*2）；
setTurnGunRightRadians（Utils.normalRelativeAngle（θ-getGunHeadingRadians（））；
如果（getGunHeat（）==0）{
火力（火力）；
激发=真；
}