Robocode 圆周瞄准算法机器人

该方法是圆周瞄准算法

使用了SpinBot机器人以及下方法的机器人

s//战场类

package type.com.xalead;

public class Enemy {

// public static void main(String[] args) {

// Enemy e1 = new Enemy();

// Enemy e2 = new Enemy();

// Enemy e3 = new Enemy();

// Enemy e4 = new Enemy();

// e1.PI = 3.14159265;

// System.err.println(e2.PI);

// Enemy.PI = 333;

// Enemy.work();

// }

// static double PI = 3.14;

// public static void work(){}

//attribute

private double bearing;

private double distance = 3000;

private double heading;

private double speed;

public double getSpeed() {

return speed;

}

public void setSpeed(double speed) {

this.speed = speed;

}

public double getDistance() {

return distance;

}

public void setDistance(double distance) {

this.distance = distance;

}

public double getHeading() {

return heading;

}

//property

public void setHeading(double heading) {

if(!(heading < 0.0)){

this.heading = heading;

}

/**

* bearing锟斤拷锟斤拷锟斤拷锟�

* @return

public double getBearing(){

return this.bearing;

}

/**

* bearing锟斤拷锟斤拷锟�

* @param bearing

public void setBearing(double bearing){

this.bearing = bearing;

}

//测试机器人

package type.com.xalead;

import java.awt.geom.Point2D;

import robocode.AdvancedRobot;

import robocode.Rules;

import robocode.ScannedRobotEvent;

import robocode.util.Utils;

public class TestRobot extends AdvancedRobot {

public static void main(String[] args) {

// double a = Math.tan(Math.toRadians(135));

// System.err.println(a);

// double a = Math.toDegrees(Math.atan2(10, -10));

// System.err.println(a);

System.out.println(Math.random());

}

private double time1 = 0;

private Enemy enemy = new Enemy();

private boolean discover = false;

private double heading = 0.0;

private double radarHeading = 0.0;

private double bPower = 3;

private double time = 0;

private double distance = 3000;

@Override

public void onScannedRobot(ScannedRobotEvent e) {

discover = true;

preTime = time1;

time1 = getTime();

enemy.setBearing(e.getBearingRadians());

enemy.setSpeed(e.getVelocity());

enemy.setDistance(e.getDistance());

preHeading = enemy.getHeading();

enemy.setHeading(e.getHeadingRadians());

time = distance / Rules.getBulletSpeed(bPower);

}

//装饰方法

private void dressing() {

}

//旋转方法

private void severance() {

setAdjustGunForRobotTurn(true);

setAdjustRadarForGunTurn(true);

}

//简单移动的方法

private void simpleMove() {

double increment = 0;

if (enemy.getBearing() > 0) {

increment = Math.PI / 2 - enemy.getBearing();

setTurnLeftRadians(increment);

} else {

increment = Math.PI / 2 + enemy.getBearing();

setTurnRightRadians(increment);

}

setAhead(1000);

}

private double safDis = 100;//安全距离

//高级移动方法

private void movement() {

if (getDistanceRemaining() < 1) {

double nx = 0;

double ny = 0;

nx = Math.random() * (getBattleFieldWidth() - 2 * safDis) + safDis;

ny = Math.random() * (getBattleFieldHeight() - 2 * safDis) + safDis;

double headArg = 90 - Math.atan2(ny - getY(), nx - getX());

headArg = Utils.normalAbsoluteAngle(headArg);

double dis = Point2D.distance(getX(), getY(), nx, ny);

if (headArg - getHeadingRadians() > Math.PI / 2) {

setTurnRightRadians(headArg - getHeadingRadians() + Math.PI);

setAhead(-dis);

} else {

setTurnRightRadians(headArg - getHeadingRadians());

setAhead(dis);

}

private void doScan() {

if (discover) {

heading = this.getHeadingRadians();

radarHeading = this.getRadarHeadingRadians();

double temp = radarHeading - heading - enemy.getBearing();

temp = Utils.normalRelativeAngle(temp);

temp *= 1.2;

setTurnRadarLeftRadians(temp);

}

private double firePower() {

return bPower;

}

/**

private double immidate() {

double increment = heading + enemy.getBearing()

- getGunHeadingRadians();

increment %= 2 * Math.PI;

increment = Utils.normalRelativeAngle(increment);

return increment;

}

/**

* 开枪

private void gun() {

// double increment = immidate();

double increment = circle();

setTurnGunRightRadians(increment);

}

private double preHeading = 0.0;//锟斤拷锟斤拷

private double preTime = 0.0;//前一锟斤拷时锟斤拷

*曲线射击

private double circle(){

double t = 0.0;

double ea = Utils.normalAbsoluteAngle(getHeadingRadians() + enemy.getBearing());

double ex = getX() + enemy.getDistance() * Math.sin(ea);

double ey = getY() + enemy.getDistance() * Math.cos(ea);

double offsetHeading = enemy.getHeading() - preHeading;

double dv = offsetHeading /(time1 - preTime);

if(Math.abs(dv)<0.00001){

dv+=0.00001;

}

double r = enemy.getSpeed()/dv;

double preDistance= enemy.getDistance();

for(int i = 0; i<8;i++){

double bulletTime = preDistance / Rules.getBulletSpeed(bPower);

double nextHeading = enemy.getHeading()+dv*bulletTime;

double nextx = ex + r * Math.cos(enemy.getHeading())- r * Math.cos(nextHeading);

double nexty = ey + r * Math.sin(nextHeading)- r * Math.cos(enemy.getHeading());

preDistance = Point2D.distance(getX(), getY(),nextx, nexty);

t = Math.atan2(nexty - getY(), nextx - getX());

}

return Utils.normalRelativeAngle((Math.PI / 2 - t - getGunHeadingRadians())

% (2 * Math.PI));

}

/**

* 直线射击

* @return

private double line() {

double ea = Utils.normalAbsoluteAngle(getHeadingRadians() + enemy.getBearing());

double ex = getX() + enemy.getDistance() * Math.sin(ea);

double ey = getY() + enemy.getDistance() * Math.cos(ea);

double s = 0;

if (enemy.getSpeed() >= Rules.MAX_VELOCITY - 0.1) {

s = enemy.getSpeed() * time;

} else if (enemy.getSpeed() > 0.0) {

double as = (Math.pow(Rules.MAX_VELOCITY, 2) - Math.pow(

enemy.getSpeed(), 2))

/ 2 * Rules.ACCELERATION;

double vs = (time - (Rules.MAX_VELOCITY - enemy.getSpeed())

/ Rules.ACCELERATION)

* Rules.MAX_VELOCITY;

s = as + vs;

} else {

s = 0.0;

}

double nextx = ex + s * Math.sin(enemy.getHeading());

double nexty = ey + s * Math.cos(enemy.getHeading());

distance = Point2D.distance(getX(), getY(), nextx, nexty);

double t = Math.atan2(nexty - getY(), nextx - getX());

return Utils.normalRelativeAngle((Math.PI / 2 - t - getGunHeadingRadians())

% (2 * Math.PI));

}

public void run() {

dressing();

severance();

// setTurnRadarLeft(400);

// execute();

while (true) {

if (!discover) {

setTurnRadarLeftRadians(Math.PI * 2.1);

execute();

} else {

movement();

double fire = firePower();

doScan();

gun();

// if (getGunTurnRemaining() <= 0) {

setFire(fire);

execute();

// }

loseTarget();

execute();

}

private void loseTarget() {

if ((getTime() - time1) >= 4)

discover = false;

}

运行界面：

运行结果：

Robocode 圆周瞄准算法机器人相关推荐

机器学习算法机器人足球_购买足球队：一种机器学习方法
机器学习算法机器人足球 An approach that is better than random guessing or choosing players from a pool of 18000 ...
【Matlab路径规划】蚁群算法机器人大规模栅格地图最短路径规划【含源码 1860期】
一.代码运行视频(哔哩哔哩) [Matlab路径规划]蚁群算法机器人大规模栅格地图最短路径规划[含源码 1860期] 二.蚁群算法及栅格地图简介随着机器人技术在诸多领域的应用, 如机器人协作焊接.灾 ...
【Matlab路径规划】A_star算法机器人栅格地图路径规划【含源码 116期】
一.代码运行视频(哔哩哔哩) [Matlab路径规划]A_star算法机器人栅格地图路径规划[含源码 116期] 二.matlab版本及参考文献 1 matlab版本 2014a 2 参考文献 [1] ...
【路径规划】基于matlab DWA算法机器人局部避障路径规划【含Matlab源码 890期】
⛄一.获取代码方式获取代码方式1: 完整代码已上传我的资源:[路径规划]基于matlab DWA算法机器人局部避障路径规划[含Matlab源码 890期] 获取代码方式2: 通过订阅紫极神光博客付费 ...
凭借Google新算法机器人自学行走平均只需3.5小时
在机器人领域,让机器人保持站立并进行平稳的运动一直是一个棘手的挑战,因为这需要超高的专业知识和设计水平.尽管一些传统的机器人能在人工控制的情况下完成站立和运动,但它们的活动范围也充满了各种局限性. 图 ...
算法学习系列(贪心算法)—机器人攀登问题
问题描述: 要举办一场机器人攀登接力赛,规定攀登总高度为m米,每队参赛机器人个数为n(2≤n≤10),每个机器人只能攀登1次,至少攀登1米,至多攀登k(1≤k≤20)米,并且只能在整米处接力.某队有n ...
【路径规划】基于matlab蚁群算法机器人栅格地图最短路径规划【含Matlab源码 119期】
⛄一.简介路径规划是实现移动机器人自主导航的关键技术,是指在有障碍物的环境中,按照一定的评价标准(如距离.时间.能耗等),寻找到一条从起始点到目标点的无碰撞路径,这里选取最短距离路径规划的评价标准, ...
【路径规划】基于matlab蚁群算法机器人大规模栅格地图最短路径规划【含Matlab源码 1860期】
⛄一.蚁群算法及栅格地图简介随着机器人技术在诸多领域的应用, 如机器人协作焊接.灾后搜救.军事.太空探索.深海勘探.家用和服务行业等, 机器人的发展正向智能化方向延伸, 要求其具有自组织.自学习.自 ...
【路径规划】基于matlab A_star算法机器人避障最短路径规划【含Matlab源码 2295期】
⛄一.A_star算法简介 1 A Star算法及其应用现状进行搜索任务时提取的有助于简化搜索过程的信息被称为启发信息.启发信息经过文字提炼和公式化后转变为启发函数.启发函数可以表示自起始顶点至目标 ...
【栅格地图路径规划】基于matlab D星和D星_Lite算法机器人栅格地图路径规划【含Matlab源码 2530期】
⛄一.简介 "D*算法"的名称源自 Dynamic A Star,最初由Anthony Stentz于"Optimal and Efficient Path Planni ...

Robocode 圆周瞄准算法机器人

Robocode 圆周瞄准算法机器人相关推荐

最新文章

热门文章