获取当前帧的敌人的位置和自己的位置以及射击的角度，子弹的速度
每一帧获取一次
当有足够多的数据后，根据当前的位置和角度，获取之前最有可能打中地方的攻击方式。
Robocode    模式匹配和随机移动
波保存敌人的起始点、自己的起始点、与敌人的绝对夹角、敌人的距离、发现敌人的时间、射击角度、速度的水平分量、速度的垂直分量

“波”统计瞄准算法进行模式匹配

直线瞄准以及圆周瞄准算法都是全匹配算法

我们将拥有超级机器人“波”统计瞄准算法与直线瞄准和圆周瞄准算法的机器人进行比拼

//传播波的算法
package com.xalead.superrobot;
import java.awt.geom.Point2D;
import robocode.AdvancedRobot;
import robocode.Condition;
import robocode.Rules;
import robocode.util.Utils;
import com.xalead.superrobot.model.Battle;
public class Wave extends Condition{
       //自己的起始点坐标
       private Point2D.Double myStartPos = null;
       //创建这个波时敌人的绝对夹角
       private double absBearing = 0;
       //发现敌人的时间
       private double startTime;
       //敌人的距离
       private double dist;
       //速度垂直分量
       private double adSeg;
       //速度的水平分量
       private double velSeg;
       //这个值只有当波碰到敌人时才能产生
       private double angle;
       //战场模型的引用
       private Battle battle = null;
       //执有机器人的引用
       private WaveSurfing robot = null;
       public Wave(){}
       public Wave(Battle battle){
             this.battle = battle;
             robot = (WaveSurfing)battle.getRobot();
       }
       public Point2D.Double getMyStartPos() {
             return myStartPos;
       }
       public void setMyStartPos(Point2D.Double myStartPos) {
             this.myStartPos = myStartPos;
       }
       public double getAbsBearing() {
             return absBearing;
       }
       public void setAbsBearing(double absBearing) {
             this.absBearing = absBearing;
       }
       public double getStartTime() {
             return startTime;
       }
       public void setStartTime(double startTime) {
             this.startTime = startTime;
       }
       public double getDist() {
             return dist;
       }
       public void setDist(double dist) {
             this.dist = dist;
       }
       public double getAdSeg() {
             return adSeg;
       }
       public void setAdSeg(double adSeg) {
             this.adSeg = adSeg;
       }
       public double getVelSeg() {
             return velSeg;
       }
       public void setVelSeg(double velSeg) {
             this.velSeg = velSeg;
       }
       public double getAngle() {
             return angle;
       }
       public void setAngle(double angle) {
             this.angle = angle;
       }
       public Battle getBattle() {
             return battle;
       }
       public void setBattle(Battle battle) {
             this.battle = battle;
       }
       //传播波的算法
       public boolean test() {
             System.out.println(battle.getePos().getX() + ":" + battle.getePos().getY());
             //判断当前波传播的距离是否和敌人目前所在位置的距离接近
             if((robot.getTime() - this.getStartTime())
                           * Rules.getBulletSpeed(robot.BULLET_POWER) >= Point2D.distance(
                                        battle.getePos().getX(),battle.getePos().getY(),
                                        myStartPos.getX(),myStartPos.getY())){
                    this.angle =Utils.normalRelativeAngle(Utils.
                                  normalAbsoluteAngle(Math.atan2(battle.getePos().getX()
                                               - this.myStartPos.getX(),battle.getePos().getY()
                                               - this.myStartPos.getY())) - this.absBearing );
                    battle.getFireAngle().add(this);
                    robot.removeCustomEvent(this);
             }
             return false;
       }
}
//超级机器人  波统计瞄准算法
package com.xalead.superrobot;
import java.awt.geom.Point2D;
import com.xalead.superrobot.model.Battle;
import robocode.AdvancedRobot;
import robocode.ScannedRobotEvent;
import robocode.util.Utils;
public class WaveSurfing extends AdvancedRobot{
       private Battle battle = null;
       //子弹能量
       public static double BULLET_POWER = 2;
       public void run(){
             battle = new Battle(this);
             setAdjustGunForRobotTurn(true);
             setAdjustRadarForGunTurn(true);
             turnRadarRightRadians(Double.POSITIVE_INFINITY);
       }
       public void onScannedRobot(ScannedRobotEvent e){
             //雷达锁定
              setTurnRadarRightRadians(Utils.normalRelativeAngle((e.getBearingRadians() + getHeadingRadians() -getRadarHeadingRadians()))*2);
             //更新敌人位置坐标
             battle.update(e);
             //创建波
             battle.createWave(e);
             movement();
             //获得最佳匹配角并射击
             setFire(e.getDistance()<100 ?3 : BULLET_POWER);
             setTurnGunRightRadians(battle.getBestMatchFireAngle());
       }
       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);
                    }
             }
       }
}
//战场要素
package com.xalead.superrobot.model;
import java.awt.geom.Point2D;
import java.awt.geom.Point2D.Double;
import com.xalead.superrobot.Wave;
import com.xalead.superrobot.util.ArrayList;
import com.xalead.superrobot.util.Iterator;
import robocode.AdvancedRobot;
import robocode.ScannedRobotEvent;
import robocode.util.Utils;
public class Battle {
       private AdvancedRobot robot =null;
       private double battleFieldWidth;
       private double battleFieldHeight;
       //保存射击角度的模式库
       private ArrayList  fireAngle = new ArrayList();
       public Battle(){}
       public Battle(AdvancedRobot robot) {
             this.robot = robot;
             this.battleFieldHeight = robot.getBattleFieldHeight();
             this.battleFieldWidth = robot.getBattleFieldWidth();
       }
       public AdvancedRobot getRobot() {
             return robot;
       }
       public void setRobot(AdvancedRobot robot) {
             this.robot = robot;
       }
       public double getBattleFieldWidth() {
             return battleFieldWidth;
       }
       public void setBattleFieldWidth(double battleFieldWidth) {
             this.battleFieldWidth = battleFieldWidth;
       }
       public double getBattleFieldHeight() {
             return battleFieldHeight;
       }
       public void setBattleFieldHeight(double battleFieldHeight) {
             this.battleFieldHeight = battleFieldHeight;
       }
       //敌人最新的所在的位置
       private Point2D.Double ePos = null;
       /*
        * 敌人速度的水平分量
        * */
       private double dist;//距离
       //敌人速度的垂直分量
       private double velSeg;
       //敌人速度的水平分量
       private double adSeg ;
       private double absBearing;//敌人的所在方向的绝对夹角
       public void update(ScannedRobotEvent e) {
             absBearing  = e.getBearingRadians();//夹角
             dist = e.getDistance();//距离
             compute(dist,absBearing += robot.getHeadingRadians());
             velSeg = e.getVelocity() * Math.cos(e.getHeadingRadians() - absBearing);
             adSeg = e.getVelocity() * Math.sin(e.getHeadingRadians() - absBearing);
       }
       public void createWave(ScannedRobotEvent e) {
             Wave wave = new Wave(this);
             //雷达锁定敌人
             if(robot.getGunHeat() <= 0){
                    wave.setStartTime(robot.getTime());//记录创建波的时间
                    wave.setVelSeg(velSeg);//记录敌人速度的水平分量
                    wave.setAdSeg(adSeg);//记录敌人速度的垂直分量
                    wave.setMyStartPos(new Point2D.Double(robot.getX(),robot.getY()));//记录创建波时我们的起始位置
                    wave.setDist(dist);//敌人的距离
                    wave.setAbsBearing(absBearing);//敌人所在方向的绝对夹角
                    robot.addCustomEvent(wave);
             }
       }
       /*
        * 获得最佳匹配射击角
        * */
       public double getBestMatchFireAngle(){
             double aim =0;
             double distance;//存储欧几里德距离
             //定义一个匹配，初始化成一个非常大的值
             double maxMatch = java.lang.Double.POSITIVE_INFINITY;
             Iterator iter = fireAngle.iterator();
             while(iter.hasNext()){
                    Wave w = iter.next();
                    //计算欧几里德距离，匹配信号相似度
                    distance = Math.pow(velSeg - w.getVelSeg(),2)+Math.pow((adSeg - w.getAdSeg()),2)+Math.pow((w.getDist() - dist)/200,2);
                    if(distance < maxMatch){
                           maxMatch = distance;
                           aim = w.getAngle();
                    }
             }
             return Utils.normalRelativeAngle(absBearing - robot.getGunHeadingRadians() + aim);
       }
       
       /*计算敌人坐标位置
        * dist 敌人的距离
        * d 敌人方向的绝对角
        * return 敌人的位置
        * */
       public Point2D.Double compute(double dist, double d) {
             return this.ePos = new Point2D.Double(robot.getX() + dist * Math.sin(d),robot.getY() + dist *Math.cos(d));
       }
       public ArrayList getFireAngle() {
             return fireAngle;
       }
       public void setFireAngle(ArrayList fireAngle) {
             this.fireAngle = fireAngle;
       }
       public Point2D.Double getePos() {
             return ePos;
       }
       public void setePos(Point2D.Double ePos) {
             this.ePos = ePos;
       } 
}
//迭代器
package com.xalead.superrobot.util;
import com.xalead.superrobot.Wave;
public interface Iterator {
       public boolean hasNext();
       public Wave next();
}
//集合
package com.xalead.superrobot.util;
import com.xalead.superrobot.Wave;
public class ArrayList {
       private Wave[] waves = new Wave[10];
       private int size = 0;
       public int size(){
             return size;
       }
       public boolean add(Wave wave){
             if(size < waves.length){
                    waves[size] = wave;
             }
             if(size >= waves.length){
                    Wave[] temp = new Wave[waves.length * 2];
                    for(int i=0; i<waves.length;i++){
                           temp[i]=waves[i];
                    }
                    temp[size] = wave;
                    waves = temp;
             }
             size++;
             return true;
       }
       public boolean remove(Wave wave){
             for(int i=0;i<size;i++){
                    if(waves[i] == wave){
                           for(int j =i;j<(size -1);j++){
                                 waves[j] = waves[j+1];
                           }
                           waves[size - 1] =null;
                           size--;
                           return true;
                    }
             }
             return false;
       }
       public Iterator iterator(){
             return new LIr();
       }
       private class LIr implements Iterator{
             private int cursor = 0;
//           public void offset(int offset){
//                  cursor = offset;
//           }
             public boolean hasNext(){
                    return cursor < size();
             }
             public Wave next(){
                    Wave w = waves[cursor];
                    if(w != null){
                           cursor++;
                    }
                    return w;
             }
       }

}

直线瞄准算法与超级机器人：

运行结果:

圆周瞄准算法与超级机器人：

运行界面：

运行结果：

由此可知，算法不同，机器人攻击能力不一样，所以全匹配性机器人直线瞄准和圆周瞄准机器人不能打过超级机器人“波”统计瞄准算法。

Robocode 超级机器人 “波”统计瞄准算法相关推荐

  1. 斐波那契算法举例(iterative Fibonacci algorithm)

    // count_change.cpp : Defines the entry point for the console application. // #include "stdafx. ...

  2. java统计词频算法_java实现的统计字符算法示例

    本文实例讲述了java实现的统计字符算法.分享给大家供大家参考,具体如下: 统计字符: 概述:给定字符串,将它们进行分类,分别的去统计它们的个数及其字符 分类的有:字母 数字 中文 空格 等等 算法思 ...

  3. 【图像去噪】基于自适应小波阙值算法实现图像去噪附matlab代码

    1 内容介绍 基于 Donoho经典小波阈值去除图像噪声基本思路,分析常用硬阈值法和软阈值法在图像去噪中的缺陷.针对这些缺陷,提出一种改进的阈值去噪法,该方法不仅可克服硬阈值不连续的缺点,还能够有效解 ...

  4. 2.数据结构与算法：斐波那契算法

    1.介绍斐波那契数列: 描述:斐波那契数列(Fibonacci sequence),指的是这样一个数列:0.1.1.2.3.5.8.13.21.34.--在数学上,斐波那契数列以如下被以递推的方法定义 ...

  5. matlab实现鬼波信号压制算法（附鬼波算法压制工具包）  代码实践--第一篇 频率-空间域自适应鬼波压制

    matlab实现鬼波信号压制算法(附鬼波算法压制工具包)  代码实践 涵盖了频率-空间域.频率-波数域.拉东域鬼波压制算法     建议实践之前熟练掌握各个域鬼波压制方法的原理,才能对代码有更深入的了 ...

  6. 统计DES算法在密钥、明文固定下对密文的影响

    统计DES算法在密钥.明文固定下对密文的影响 实验代码在这里:实验代码 实验目的 统计DES算法在密钥固定情况,输入明文改变1位.2位,...64位时.输出密文位数改变情况. 统计DES算法在明文固定 ...

  7. 直接反投影 matlab,濾波反投影重建算法（FBP）實現及應用（matlab）

    濾波反投影重建算法實現及應用(matlab) 1. 濾波反投影重建算法原理 濾波反投影重建算法常用在CT成像重建中,背后的數學原理是傅立葉變換:對投影的一維傅立葉變換等效於對原圖像進行二維的傅立葉變換 ...

  8. 斐波那契算法详解(logn)

    ** 斐波那契算法详解 ** ** 1.斐波那契数列的一般解法: for循环强行计算 ** #include <stdio.h> int main() { int n ; int fn = ...

  9. 8方向连通域统计——two-pass算法（用于图像斑块数统计）

    8方向连通域统计--two-pass算法(用于图像斑块数统计) 问题描述 连通域标记问题 Two-Pass算法 First Pass Second Pass Python实现 例子 问题描述 现有一幅 ...

  10. 热词统计发现算法3则

    以搜索为例,点击类似.所有变换和简化须不影响排序结果. 排位变化 最初的算法参考电影排行榜,统计昨日Top词.前日Top词,然后计算每个词w两天的排位差,排位变化最大的就是最热的词.

最新文章

  1. 数学建模之图像处理---颜色建模
  2. python 排列组合之itertools
  3. FIO工具测试延迟、带宽、IOPS
  4. 结构化程序设计03 - 零基础入门学习Delphi12
  5. 一图胜千言！Python数据可视化多维讲解
  6. iOS中 openGL常用函数记录（部分）
  7. 防备电脑死机故障技巧的8个方法
  8. 图书管理系统/库存管理系统等计算机毕业论文设计
  9. hulu dpp_如何取消您的Hulu订阅
  10. 初一计算机课程表,初中课程表空白表格
  11. matlab 求拟合直线的斜率_如何用matlab求出图中各条直线的斜率
  12. 五则运算c语言程序,C语言算术运算示例程序
  13. Python基础知识梳理
  14. OB2263MP小知识
  15. 智能合约--如何实现可升级的智能合约
  16. 微信公众号发送小程序卡片_微信公众号群发文章支持添加小程序卡片
  17. 1.27 Watermelon
  18. oracle 断电起不来，解决方案
  19. 查看Office授权信息
  20. FI--SAP财务成本知识库 .

热门文章

  1. node-sass安装失败完美解决方法
  2. webstorm破解版
  3. 数理统计————思维导图（上岸必备）
  4. java笔试题算法题，吐血整理
  5. Linux系统高级编程系列教程
  6. 快速在多个word文件里面检索到关键字
  7. dos攻击工具如何使用？两款dos攻击工具介绍
  8. 程序员必备的10款工具软件！最后一款简直绝了！
  9. 【Chrome】如何对Chrome浏览器内容进行长截图
  10. Qt编写Onvif搜索及云台控制工具