自动跟踪导弹算法(未整理)

最新推荐文章于 2024-02-27 18:26:44 发布
最新推荐文章于 2024-02-27 18:26:44 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： libgdx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ak4100/article/details/22379007
版权

自己写的自动跟踪导弹算法,内有自己引擎的一些变量,有点乱,但主要算法是有的,思想最重要.

MyAmmoClass.java

package game;

import game.config.dConfig;
import game.object.CObject;
import game.object.IObject;
import game.object.dActor;
import game.pak.Camera;
import android.graphics.Point;
import android.util.Log;

import com.changle.ui.Graphics;
import com.cl.libgdxjar.LibgdxImage;

/**
 * (导弹) 弹药，军火; (自动跟踪导弹)
 * @author maxuehuai
 *
 */
public class MyAmmoClass {
 Ammo ammo/*=new Ammo()*/;
// double speed=5;//导弹飞行速度 //ok1
// double speed=10;//导弹飞行速度
 double speed=15;//导弹飞行速度
 
// int AmmoX;//导弹X
// int AmmoY;//导弹Y
// double Ammorotation;//导弹角度
 
 final int GST_START=0;
 final int GST_FLYING=1;
 final int GST_DIE=2;
 final static int GST_DIEEX=3;
 
 int currentstate;
 
 double radian;//导弹和目标的弧度
 
 Point target=new Point();//目标
 short[] targetBox=new short[4];
 Point inittarget=new Point();//目标
 
// Point ammo=new Point();
 double angle;
   
 double vx;//导弹x速度
 double vy;//导弹y速度
 
// final int angularVelocity=5;// 因为角度需要慢慢的旋转到目标角度，所以给出一个常量角速度
// final double angularVelocity=3;//ok1
// final double angularVelocity=4;
// final double angularVelocity=6;
 final double angularVelocity=8;
 
 double thisAngle;
 double tempAngleV;
 double ammoRadian;
 
 double other;
 
 CObject targetObj=null;
 CObject startObj=null;
 
 /**
  * 传对象
  * @param bombImage1
  * @param bombImage2
  * @param AmmoImage
  * @param Ammorotation
  * @param startobj
  * @param targetobj
  */
 public MyAmmoClass(LibgdxImage bombImage1,LibgdxImage bombImage2,LibgdxImage AmmoImage,int Ammorotation,CObject startobj,CObject targetobj){

  startObj=startobj;  
  targetObj=targetobj;
  
  ammo=new Ammo(bombImage1,bombImage2,AmmoImage,startobj.m_x>>8,startobj.m_y>>8,Ammorotation);
 
  target.set(targetobj.m_x>>8, (targetobj.m_y>>8)-50);
  inittarget.set(targetobj.m_x>>8, (targetobj.m_y>>8)-50);
  
  targetObj.cObj_getActorBoxInfo(dActor.BOX_COLLIDE, targetBox);// 得到碰撞框
  
//  targetBox[0]=(short)(targetobj.m_x>>8);
//  targetBox[1]=(short)((targetobj.m_y>>8));
//  targetBox[2]=(short)((targetobj.m_x>>8)+20);
//  targetBox[3]=(short)((targetobj.m_y>>8)+20);
  
  currentstate=GST_START;
 }
 
 /**
  * 传坐标
  * @param bombImage1
  * @param bombImage2
  * @param AmmoImage
  * @param Ammox
  * @param Ammoy
  * @param Ammorotation
  * @param targetx
  * @param targety
  */
 public MyAmmoClass(LibgdxImage bombImage1,LibgdxImage bombImage2,LibgdxImage AmmoImage,int Ammox,int Ammoy,int Ammorotation,int  targetx,int targety ){
  ammo=new Ammo(bombImage1,bombImage2,AmmoImage,Ammox,Ammoy,Ammorotation);
  target.set(targetx, targety);
  inittarget.set(targetx, targety);
  
  targetBox[0]=(short)targetx;
  targetBox[1]=(short)targety;
  targetBox[2]=(short)(targetx+20);
  targetBox[3]=(short)(targety+20);
  
  
  
  currentstate=GST_START;
//  initammoRadian= (Math.PI / 180 * ammo.initrotation);  
 }
 
 
    void init(){
     ammo.x=ammo.initx;
     ammo.y=ammo.inity;
     ammo.rotation=ammo.initrotation;
     
     ammo.endx=ammo.initendx;
     
     ammo.endy=ammo.initendy;     
     time=0;    
//     target=inittarget;
     target.set(inittarget.x, inittarget.y);
    }
 
    int time; 
 public void doLogic(){ 
  
  switch(currentstate){
  case GST_START:   
   if(time<10){
    time++;
    ammo.rotation=-ammo.initrotation;
    ammoRadian= (Math.PI / 180 * (ammo.rotation));  
    
    double aa=Math.cos(ammoRadian);
    double bb=Math.cos(ammoRadian);
    
    vx = (Math.cos(ammoRadian) * speed);
    vy = (Math.sin(ammoRadian) * speed);
    
    ammo.x += vx;
    ammo.y += vy;
    ammo.endx=ammo.x-(ammo.image.getWidth()*Math.cos(ammo.initammoRadian));
    ammo.endy=ammo.y+(ammo.image.getHeight()*Math.sin(ammo.initammoRadian));
    
      //更新导弹碰撞框 
    ammo.ammoBox[0]=(short)ammo.x;
    ammo.ammoBox[1]=(short)ammo.y;
    ammo.ammoBox[2]=(short)(ammo.x+ammo.image.getWidth());
    ammo.ammoBox[3]=(short)(ammo.y+ammo.image.getHeight());    
   //    return;       
   }else{
    currentstate=GST_FLYING;
//    break; 
   }  
   break;
   
  case GST_FLYING:
   time++;  
   
   //如果已死亡或未被激活
   if(targetObj.cObj_testFlag(dActor.FLAG_BASIC_DIE)||targetObj.cObj_testFlag(dActor.FLAG_BASLIC_NOT_LOADABLE)){        
    Log.e("GST_FLYING****************************************************", "targetObj.cObj_m_actorID:"+targetObj.cObj_m_actorID);
    currentstate=GST_DIE;
    targetObj=null;
    return;   
   }
     
   if(targetObj!=null){//add by mxh 2013-11-7
    if(targetObj.cObj_m_currentState==IObject.ST_ACTOR_DIE||targetObj.cObj_m_currentState==IObject.ST_ACTOR_DIEEX){
     targetObj=null;
     Log.e("GST_FLYING##########################", "targetObj=null");
     currentstate=GST_DIE;
     return;
    }   
   }
   
   if(ammo_testColliding(targetBox)||time>120){ 
    currentstate=GST_DIE;
    return;
   } 
   
      
   if(targetObj!=null){//如果目标对象存在   //add by mxh 2013-11-7    有BUG死机  (对象死亡时targetObj并未置为null)
    if(target.x!=(targetObj.m_x>>8)){//坐标改变时更新坐标
     set_targetpodition(targetObj.m_x>>8,(targetObj.m_y>>8)-50);
    }            
   }
   
   
   radian=Math.atan2( (target.y - ammo.y), target.x - ammo.x );// 使用 Math.atan2可以计算到导弹和目标的弧度。
   angle=(radian * 180 / Math.PI); 将弧度转换为角度  
   angle = to360Angle(angle);  

   //如果导弹的角度较大则减。
   thisAngle= to360Angle(ammo.rotation);  
//   Log.e("doLogic", "thisAngle:"+thisAngle);
   
   if (thisAngle < angle){
  // tempAngleV = angularVelocity;
   if((angle-thisAngle)<angularVelocity){//角度调整 mxh add 防止导弹头浮动不平稳
    tempAngleV =angle-thisAngle;   
   }else{
    tempAngleV = angularVelocity;
   }   
   }else if (thisAngle > angle){
  //  tempAngleV = -angularVelocity;
    if((angle-thisAngle)>-angularVelocity){//角度调整 mxh add 防止导弹头浮动不平稳
     tempAngleV = angle-thisAngle;
    }else{
     tempAngleV = -angularVelocity;
    }      
   }else{
   tempAngleV = 0;
   }  
   other = 360 - Math.abs(angle - thisAngle);
   // 如果反方向的角度较小，则调换下角速度。
   if (other < Math.abs(angle - thisAngle))
   {
       tempAngleV *= -1;
   } 
   // 旋转导弹角度
   ammo.rotation += tempAngleV;  
   ammoRadian= (Math.PI / 180 * ammo.rotation);   
   vx = (Math.cos(ammoRadian) * speed);
   vy = (Math.sin(ammoRadian) * speed);
   ammo.x += vx;
   ammo.y += vy;
   
   ammo.endx=ammo.x-(ammo.image.getWidth()*Math.cos(ammo.initammoRadian));
   ammo.endy=ammo.y+(ammo.image.getHeight()*Math.sin(ammo.initammoRadian));
   
   //更新导弹碰撞框 
   ammo.ammoBox[0]=(short)ammo.x;
   ammo.ammoBox[1]=(short)ammo.y;
   ammo.ammoBox[2]=(short)(ammo.x+ammo.image.getWidth());
   ammo.ammoBox[3]=(short)(ammo.y+ammo.image.getHeight());
   
   break;
  case GST_DIE:
   if(CGame.curLevelID==1){//add by mxh 2013-11-4   导弹消失时生成炸弹(爆炸动画效果和受伤处理)
    CObject EnemyCreate =  new CObject();//出场对象临时变量
    EnemyCreate = CObject.cObj_allocActor(35, (int)(((int)ammo.x)<<8), (int)(((int)ammo.y)<<8), false,true);
    EnemyCreate.cObj_setState(IObject.ST_ACTOR_ATTACK);
    EnemyCreate.cObj_setAnimAction(2, false);     
   // currentstate=GST_DIEEX;      
   }else if(CGame.curLevelID==2){//add by mxh 2013-11-4   导弹消失时生成炸弹(爆炸动画效果和受伤处理)
    CObject EnemyCreate =  new CObject();//出场对象临时变量
    EnemyCreate = CObject.cObj_allocActor(43, (int)(((int)ammo.x)<<8), (int)(((int)ammo.y)<<8), false,true);
    EnemyCreate.cObj_setState(IObject.ST_ACTOR_ATTACK);
    EnemyCreate.cObj_setAnimAction(2, false);     
   // currentstate=GST_DIEEX;      
   }else if(CGame.curLevelID==7){//add by mxh 2013-11-4   导弹消失时生成炸弹(爆炸动画效果和受伤处理)
    CObject EnemyCreate =  new CObject();//出场对象临时变量
    EnemyCreate = CObject.cObj_allocActor(34, (int)(((int)ammo.x)<<8), (int)(((int)ammo.y)<<8), false,true);
    EnemyCreate.cObj_setState(IObject.ST_ACTOR_ATTACK);
    EnemyCreate.cObj_setAnimAction(2, false);     
   // currentstate=GST_DIEEX;      
   }
   currentstate=GST_DIEEX;   
   if(targetObj!=null){
    targetObj.IsAmmo=false;
   }
   
   break;
  case GST_DIEEX:
   
   
   
   break;
  
  
  }
 }
//  if(time<20){
//   time++;
//   ammo.rotation=-ammo.initrotation;
//   ammoRadian= (Math.PI / 180 * (ammo.rotation));  
//   
//   double aa=Math.cos(ammoRadian);
//   double bb=Math.cos(ammoRadian);
//   
//   vx = (Math.cos(ammoRadian) * speed);
//   vy = (Math.sin(ammoRadian) * speed);
//   
   vx =0;
   vy =-speed;
//   
//   ammo.x += vx;
//   ammo.y += vy;
//   ammo.endx=ammo.x-(ammo.image.getWidth()*Math.cos(ammo.initammoRadian));
//   ammo.endy=ammo.y+(ammo.image.getHeight()*Math.sin(ammo.initammoRadian));
   ammo.endx=ammo.x-ammo.image.getWidth();
   ammo.endy=ammo.y;
//   
//     //更新导弹碰撞框 
//   ammo.ammoBox[0]=(short)ammo.x;
//   ammo.ammoBox[1]=(short)ammo.y;
//   ammo.ammoBox[2]=(short)(ammo.x+ammo.image.getWidth());
//   ammo.ammoBox[3]=(short)(ammo.y+ammo.image.getHeight());
//   
//      return;    
//  }else if(time==20){
   time++;
   int xx=(int)(ammo.initx+inittarget.x/2);
   int yy=inittarget.y;
   set_targetpodition(xx,yy-60);
//   
   if(time==150){
    init();
    return;
   }
//  }else if(time==60){
//   time++;
   init();
//  }
//  
  if(ammo.x>target.x){   
   if(target.x!=inittarget.x){
    set_targetpodition(inittarget.x,inittarget.y);    
   }   
  } 
//  
//  if(ammo_testColliding(targetBox)){ 
//      
   time++;
   Log.e("doLogic!", "打中了!!!!!");
//   //init();
//   return;
//  }
//  
//  double aa=Math.atan2(1,1);
//  double bb=(aa * 180 / Math.PI); 将弧度转换为角度  
  Log.e("doLogic", "aa:"+aa);
//  radian=Math.atan2( (target.y - ammo.y), target.x - ammo.x );// 使用 Math.atan2可以计算到导弹和目标的弧度。
//  angle=(radian * 180 / Math.PI); 将弧度转换为角度  
//  angle = to360Angle(angle);  
//  //Log.e("", "")
  System.err.println("angle:" + angle);
//  //如果导弹的角度较大则减。
//  thisAngle= to360Angle(ammo.rotation);  
  Log.e("doLogic", "thisAngle:"+thisAngle);
//  
//  if (thisAngle < angle){
// // tempAngleV = angularVelocity;
//  if((angle-thisAngle)<angularVelocity){
//   tempAngleV =angle-thisAngle;   
//  }else{
//   tempAngleV = angularVelocity;
//  }   
//  }else if (thisAngle > angle){
// //  tempAngleV = -angularVelocity;
//   if((angle-thisAngle)>-angularVelocity){
//    tempAngleV = angle-thisAngle;
//   }else{
//    tempAngleV = -angularVelocity;
//   }  
   
//  }else{
//  tempAngleV = 0;
//  }  
//  other = 360 - Math.abs(angle - thisAngle);
//  // 如果反方向的角度较小，则调换下角速度。
//  if (other < Math.abs(angle - thisAngle))
//  {
//      tempAngleV *= -1;
//  } 
//  // 旋转导弹角度
//  ammo.rotation += tempAngleV;  
//  ammoRadian= (Math.PI / 180 * ammo.rotation);   
//  vx = (Math.cos(ammoRadian) * speed);
//  vy = (Math.sin(ammoRadian) * speed);
//  ammo.x += vx;
//  ammo.y += vy;
//  
//     //更新导弹碰撞框 
//  ammo.ammoBox[0]=(short)ammo.x;
//  ammo.ammoBox[1]=(short)ammo.y;
//  ammo.ammoBox[2]=(short)(ammo.x+ammo.image.getWidth());
//  ammo.ammoBox[3]=(short)(ammo.y+ammo.image.getHeight());
//  
     endx=x-AmmoImage.getWidth()*Math.cos(rotation);
     endy=y+AmmoImage.getWidth()*Math.sin(rotation);
  ammo.endx=ammo.x-(ammo.image.getWidth()*Math.cos(ammo.rotation));
  ammo.endy=ammo.y+(ammo.image.getWidth()*Math.sin(ammo.rotation));
//  
  ammo.endx=ammo.x-ammo.image.getWidth();
  ammo.endy=ammo.y;
//     
//  ammo.endx=ammo.x-(ammo.image.getWidth()*Math.cos(ammo.initammoRadian));
//  ammo.endy=ammo.y+(ammo.image.getHeight()*Math.sin(ammo.initammoRadian));
//  
  ammo.rotation= to360Angle(ammo.rotation);
  Log.e("****", "ammo.initammoRadian:"+ammo.initammoRadian);
  Log.e("%%%%%%%", "ammo.x:"+ammo.x+" | "+"ammo.y"+ammo.y);
  Log.e("&&&&&&&&&&&&&&", "ammo.endx:"+ammo.endx+"  |  "+"ammo.endy"+ammo.endy);
// }
   
   
 public void doLogic_old(){ 
  
//  if(time<150){
//   time++;
//  }
  
  if(time<20){
   time++;
   ammo.rotation=-ammo.initrotation;
   ammoRadian= (Math.PI / 180 * (ammo.rotation));  
   
   double aa=Math.cos(ammoRadian);
   double bb=Math.cos(ammoRadian);
   
   vx = (Math.cos(ammoRadian) * speed);
   vy = (Math.sin(ammoRadian) * speed);
   
//   vx =0;
//   vy =-speed;
   
   ammo.x += vx;
   ammo.y += vy;
   ammo.endx=ammo.x-(ammo.image.getWidth()*Math.cos(ammo.initammoRadian));
   ammo.endy=ammo.y+(ammo.image.getHeight()*Math.sin(ammo.initammoRadian));
//   ammo.endx=ammo.x-ammo.image.getWidth();
//   ammo.endy=ammo.y;
   
     //更新导弹碰撞框 
   ammo.ammoBox[0]=(short)ammo.x;
   ammo.ammoBox[1]=(short)ammo.y;
   ammo.ammoBox[2]=(short)(ammo.x+ammo.image.getWidth());
   ammo.ammoBox[3]=(short)(ammo.y+ammo.image.getHeight());
   
      return;    
  }else if(time==20){
//   time++;
//   int xx=(int)(ammo.initx+inittarget.x/2);
//   int yy=inittarget.y;
//   set_targetpodition(xx,yy-60);
   
//   if(time==150){
//    init();
//    return;
//   }
  }else if(time==60){
   time++;
//   init();
  }
  
//  if(ammo.x>target.x){   
//   if(target.x!=inittarget.x){
//    set_targetpodition(inittarget.x,inittarget.y);    
//   }   
//  } 
  
  if(ammo_testColliding(targetBox)){ 
//   time++;
//   Log.e("doLogic!", "打中了!!!!!");
   //init();
   return;
  }
  
  double aa=Math.atan2(1,1);
  double bb=(aa * 180 / Math.PI); 将弧度转换为角度  
//  Log.e("doLogic", "aa:"+aa);
  radian=Math.atan2( (target.y - ammo.y), target.x - ammo.x );// 使用 Math.atan2可以计算到导弹和目标的弧度。
  angle=(radian * 180 / Math.PI); 将弧度转换为角度  
  angle = to360Angle(angle);  
  //Log.e("", "")
//  System.err.println("angle:" + angle);
  //如果导弹的角度较大则减。
  thisAngle= to360Angle(ammo.rotation);  
//  Log.e("doLogic", "thisAngle:"+thisAngle);
  
  if (thisAngle < angle){
 // tempAngleV = angularVelocity;
  if((angle-thisAngle)<angularVelocity){
   tempAngleV =angle-thisAngle;   
  }else{
   tempAngleV = angularVelocity;
  }   
  }else if (thisAngle > angle){
 //  tempAngleV = -angularVelocity;
   if((angle-thisAngle)>-angularVelocity){
    tempAngleV = angle-thisAngle;
   }else{
    tempAngleV = -angularVelocity;
   }  
//   
  }else{
  tempAngleV = 0;
  }  
  other = 360 - Math.abs(angle - thisAngle);
  // 如果反方向的角度较小，则调换下角速度。
  if (other < Math.abs(angle - thisAngle))
  {
      tempAngleV *= -1;
  } 
  // 旋转导弹角度
  ammo.rotation += tempAngleV;  
  ammoRadian= (Math.PI / 180 * ammo.rotation);   
  vx = (Math.cos(ammoRadian) * speed);
  vy = (Math.sin(ammoRadian) * speed);
  ammo.x += vx;
  ammo.y += vy;
  
     //更新导弹碰撞框 
  ammo.ammoBox[0]=(short)ammo.x;
  ammo.ammoBox[1]=(short)ammo.y;
  ammo.ammoBox[2]=(short)(ammo.x+ammo.image.getWidth());
  ammo.ammoBox[3]=(short)(ammo.y+ammo.image.getHeight());
  
//     endx=x-AmmoImage.getWidth()*Math.cos(rotation);
//     endy=y+AmmoImage.getWidth()*Math.sin(rotation);
//  ammo.endx=ammo.x-(ammo.image.getWidth()*Math.cos(ammo.rotation));
//  ammo.endy=ammo.y+(ammo.image.getWidth()*Math.sin(ammo.rotation));
  
//  ammo.endx=ammo.x-ammo.image.getWidth();
//  ammo.endy=ammo.y;
     
  ammo.endx=ammo.x-(ammo.image.getWidth()*Math.cos(ammo.initammoRadian));
  ammo.endy=ammo.y+(ammo.image.getHeight()*Math.sin(ammo.initammoRadian));
  
//  ammo.rotation= to360Angle(ammo.rotation);
//  Log.e("****", "ammo.initammoRadian:"+ammo.initammoRadian);
//  Log.e("%%%%%%%", "ammo.x:"+ammo.x+" | "+"ammo.y"+ammo.y);
//  Log.e("&&&&&&&&&&&&&&", "ammo.endx:"+ammo.endx+"  |  "+"ammo.endy"+ammo.endy);
 }
 
 
 
 

 public void set_targetpodition(int x,int y){
  target.set(x, y);
  
//  targetBox[0]=(short)x;
//  targetBox[1]=(short)y;
//  targetBox[2]=(short)(x+20);
//  targetBox[3]=(short)(y+20);
  
  if(targetObj!=null){
   targetObj.cObj_getActorBoxInfo(dActor.BOX_COLLIDE, targetBox);// 得到碰撞框
  }
  
  
  
 }
 
 
 boolean bombglg=false;
 
// double initammoRadian;
 public void paint(){
  
  if(currentstate==GST_DIE||currentstate==GST_DIEEX){
   return;
  }
  
  if(ammo.image!=null){   
 //  Log.e("paint###########", "ammo.rotation:"+ammo.rotation);   
   ammo.image.setRorate(true, (int)(-(ammo.rotation)-ammo.initrotation), ammo.image.getWidth()/2, ammo.image.getHeight()/2);
   ammo.image.draw((int)ammo.x-Camera.cameraLeft, (int)ammo.y-Camera.cameraTop, 0);  
//   ammo.image.draw((int)ammo.endx, (int)ammo.endy, 0);   
   if(bombglg){
    bombglg=false;
    ammo.bombimage2.setRorate(true, (int)(-(ammo.rotation)-ammo.initrotation), (int)(ammo.image.getWidth()/2+ammo.image.getWidth()*Math.cos(ammo.initammoRadian)), (int)(ammo.image.getHeight()/2+ammo.image.getHeight()*Math.sin(ammo.initammoRadian)));
    ammo.bombimage2.draw((int)ammo.endx-Camera.cameraLeft, (int)ammo.endy-Camera.cameraTop, 0);
//    int xxx=(int)(int)(ammo.image.getWidth()/2+ammo.image.getWidth()*Math.cos(ammo.initammoRadian));
//    int yyy=(int)(ammo.image.getHeight()/2-ammo.image.getHeight()*Math.sin(ammo.initammoRadian));
//    Log.e("&&&&&&&&&&&&&&", "xxx:" +xxx+  " || "+"yyy:"+yyy);
    
   }else{
    bombglg=true;
    ammo.bombimage1.setRorate(true, (int)(-(ammo.rotation)-ammo.initrotation),(int)(ammo.image.getWidth()/2+ammo.image.getWidth()*Math.cos(ammo.initammoRadian)), (int)(ammo.image.getHeight()/2+ammo.image.getHeight()*Math.sin(ammo.initammoRadian)));
    ammo.bombimage1.draw((int)ammo.endx-Camera.cameraLeft, (int)ammo.endy-Camera.cameraTop, 0);
   }
  
   
  }

 }
 
 //此方法返回的角度为0~360度。
 double to360Angle(double angle)
 {
 angle = angle % 360;
 if (angle < 0)
 angle += 360;
 return angle;
 } 
 
 public boolean  ammo_testColliding(short[] box){
  
   if(CTools.isIntersecting(ammo.ammoBox, box)){
    return true;
   }
   return false;
   }
 
 
 public void set_ammoState(int state){
  currentstate=state;
 }
 
 public void dispose(){
  
 }
}

 class Ammo {
 
    LibgdxImage image;
    LibgdxImage bombimage;
    LibgdxImage bombimage1;
    LibgdxImage bombimage2;
   
    double x;//导弹X
    double y;//导弹Y   
    double rotation;//导弹角度 
   
    double initx;//导弹X
    double inity;//导弹Y
    double initrotation;//初始导弹角度 
   
    double initendx;//导弹尾焰X
    double initendy;//导弹尾焰Y
   
    double endx;//导弹尾焰X
    double endy;//导弹尾焰Y
    double initammoRadian;
   
    short[] ammoBox=new short[4];
   
   
    public Ammo(){
  
       }
    public Ammo(LibgdxImage BombImage1,LibgdxImage BombImage2,LibgdxImage AmmoImage,double Ammox,double Ammoy,double Ammorotation){
//     bombimage=BombImage;
     bombimage1=BombImage1;
     bombimage2=BombImage2;
     image=AmmoImage;
     x=Ammox-AmmoImage.getWidth()/2;
     y=Ammoy-AmmoImage.getHeight()/2;
     rotation=Ammorotation;
    
     initx=x;
     inity=y; 
     initrotation=Ammorotation;
//     endx=x-AmmoImage.getWidth();
//     endy=y;
     initammoRadian= (Math.PI / 180 * initrotation);  
     endx=x-(image.getWidth()*Math.cos(initammoRadian));  
     endy=y+(image.getHeight()*Math.sin(initammoRadian));
   
   initendx=x;
   initendy=endy;
     
   ammoBox[0]=(short)x;
   ammoBox[1]=(short)y;
   ammoBox[2]=(short)(x+AmmoImage.getWidth());
   ammoBox[3]=(short)(y+AmmoImage.getHeight());
   
//     endx=x-AmmoImage.getWidth()*Math.cos(rotation);
//     endy=y+AmmoImage.getWidth()*Math.sin(rotation);    
       }
  
   }


 

 

 

pony-Stark
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
opencv动态目标跟踪学习总结
bcbobo21cn的专栏
03-15 8万+
用opencv实现对视频中动态目标的追踪 第一步，是要建立一个编程环境，然后加载opencv的库路径等等。具体步骤在 http://www.opencv.org.cn/ 的“安装”中 有详细介绍。 第二步，建立一个MFC的对话框程序，做两个按钮，一个“打开视频文件”，一个“运动跟踪处理”。 具体操作： 1 建立MFC对话框程序的框架：File  ->New  -> MFC A
超燃！利用 Python 实现导弹自动追踪，这个算法几人能看懂_def initiation() # 下落目标初始状态和参数(英制单位)warhead = {}wa(1)
最新发布
2401_84139676的博客
05-02 2014
Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
Dr_can的B站自动控制原理相关视频笔记整理
热门推荐
擦擦擦大侠的博客
03-30 3万+
自动控制原理 1 1.1 开环与闭环系统 简单的开环系统 闭环系统转换成为闭环系统： 1.2 稳定性分析2 对于一个系统，如果没有稳定性的先决条件，那么其他的（稳态误差分析、瞬态误差分析）将无从说起。稳定性：传递函数极点在极坐标中的左半边。（横坐标为极点，纵坐标为零点） 零点和极点的定义如下： 分析为什么极点为负的，系统是稳定的： 下面这个图要更加直观： 那么我们如何设计控制器？...
11-4 AEB 算法原理及系统组成
AIgraphX
06-13 4107
本专题旨在探讨如何利用仿真软件开发自动紧急制动系统AEB，主要通过整理开发流程，实现从需求到验证的全流程掌握，为后续开发提供支持；同时，研究了如何在汽车自动驾驶仿真工具中开发自己的算法，并解决了从ISO、E-CNAP、GB/T以及交通法规等提炼出功能需求的问题，以快速实现原型模型的开发。本专题重点讲解了AEB的工作原理、系统/软件架构和需求、算法模型及实现、CCRs/CCRb/CCRm建模与仿真、VRU-AEB-B/P/M建模与仿真，同时还提供了测试用例，期待将AEB算法成功地产品化。
多传感器数据融合算法整理
weixin_41602564的博客
04-28 1万+
1 基本概念及融合原理 1．1 多传感器数据融合概念 数据融合又称作信息融合或多传感器数据融合，对数据融合还很难给出一个统一、全面的定义。随着数据融合和计算机应用技术的发展，根据国内外研究成果，多传感器数据融合比较确切的定义可概括为：充分利用不同时间与空间的多传感器数据资源，采用计算机技术对按时间序列获得的多传感器观测数据，在一定准则下进行分析、综合、支配和使用，获得对被测对象的一致性解释与描述，...
检测概率与目标状态相关时的PHD滤波器
guanyifu9的博客
02-27 838
当检测概率与目标状态相关时，PHD滤波器的处理方式略有不同，因为这种情况下的不再是一个常数，而是一个关于目标状态的函数。这样的模型更加复杂，因为它需要处理状态依赖的检测概率，但它也能提供更加精确的目标跟踪。
读书笔记 | 自动驾驶中的雷达信号处理（引言）
【调皮连续波】雷达技术领域知识博主
08-31 920
本文编辑：调皮连续波整理发布：调皮哥的小助理。
OpenCV目标跟踪之质心跟踪(Centroid)
Every moment of My life !!!
07-27 1万+
Casevision公司的AVT21自动视频跟踪算法模块提供了多种跟踪算法：质心跟踪算法（Centroid）、多目标跟踪算法（MTT）、相关跟踪算法（Correlation）、边缘跟踪算法（Edge）、相位相关跟踪算法（Phase Correlation），场景锁定算法（SceneLock）和组合（Combined）跟踪算法。 质心跟踪算法（Centroid） 这种跟踪方式用于跟踪有界目标
OpenCV 常用算法
知至智
03-03 3790
6月8日 关于直方图     图像直方图是图像处理中一种十分重要的图像分析工具，它描述了一幅图像的灰度级内 容。          从数学上来说图像直方图是图像各灰度值统计特性与图像灰度值的函数，它统计一幅图像中各个灰度级出现的次数或概率；          从图形上来说，它是一个二维图， 横坐标表示图像中各个像素点的灰度级，纵坐标为各个灰度级上图像各个像素点出现的 次
UNITY自动追踪导弹源码
01-01
描述中提到的链接是一个CSDN博客文章，提供了关于导弹自动追踪算法的详细信息。虽然具体内容没有直接给出，但可以推测这篇文章可能涵盖了导弹追踪的基本原理、实现方法以及如何在Unity中应用这些算法。通常，自动...
Unity导弹追踪算法演示
03-12
1. **目标检测**：导弹首先需要锁定目标，这通常通过碰撞检测或者射线投射实现，确保导弹能够识别和跟踪正确的目标。 2. **目标运动分析**：获取目标的速度和位置信息，根据这些信息预测未来的运动轨迹。 3. **...
MATLAB目标跟踪机动卡尔曼算法扩展卡尔曼滤波的一种
03-10
无论是军事应用中的导弹制导系统，还是民用领域的自动驾驶汽车，都需要精确的目标位置估计来确保系统的安全性和有效性。卡尔曼滤波作为一种经典的线性最小方差估计方法，在目标跟踪中扮演着极其重要的角色。然而，当...
论文研究-基于几何关系的多导弹协同跟踪算法.pdf
09-20
论文研究-基于几何关系的多导弹协同跟踪算法.pdf, 多武器平台同时探测、处理机动目标信息, 一定程度上可以提高目标的跟踪精度, 特别是对于多导弹协同作战而言, 协同跟踪...
目标跟踪算法综述_卢湖川
04-05
### 目标跟踪算法综述 #### 一、引言 目标跟踪作为计算机视觉领域的重要研究方向，在诸如导弹制导、视频监控、无人机追踪等多个领域发挥着关键作用。近年来，随着计算机硬件性能的提升以及图像处理技术和人工智能...
自己整理的粒子系统管理(是不是太简单了?)
AK41君的专栏
03-28 971
自己整理的粒子系统管理,是不是太简单了? LibParticle.java package game.pak; import java.util.ArrayList; import android.util.Log; import com.badlogic.gdx.Gdx; import com.badlogic.gdx.graphics.g2d.BitmapFont; impo
Libgdx 圆形冷却框绘制
AK41君的专栏
04-14 802
MyGame.java: package com.potato; import com.badlogic.gdx.ApplicationListener; import com.badlogic.gdx.Gdx; import com.badlogic.gdx.assets.AssetManager; import com.badlogic.gdx.audio.Sound; imp
libgdx仿西瓜刀光
AK41君的专栏
03-28 785
LibBlade.java package game.pak; import game.CGame; import game.config.dConfig; import java.util.ArrayList; import java.util.List; import android.util.Log; import com.badlogic.gdx.Gdx; import c
目标跟踪算法进展：挑战与深度学习解决方案
目标跟踪算法综述是计算机视觉领域的核心研究课题，它在导弹制导、视频监控、无人机导航等众多应用中扮演着关键角色。本文由作者卢湖川、李佩霞和王栋合作撰写，旨在系统性地梳理和分析当前目标跟踪算法的发展状况...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值