SEO		[PR] 爆速!無料ブログ 無料ホームページ開設 無料ライブ放送

BMLBulletML.h

#ifndef BML_BULLETML_H__
#define BML_BULLETML_H__

#include "BMLBulletPool.h"
#include <DxEx/DxExFixedData.h>

#ifndef M_PI
#define M_PI 3.141592
#endif

namespace bml{
//dxexを使う
using namespace dxex;

typedef bml_array_in_c simple_array_type;
typedef bml_array_in_c action_array_type;

//プロトタイプ宣言
class BMLRunner_in_c;

typedef smart_ptr<BMLRunner_in_c> smartaction_ptr;
typedef static_array_onebyone_ex<smartaction_ptr> smartaction_ptr_container;
typedef smartaction_ptr_container::handle sa_ptr_handle;

//typedef std::deque<action_array_type::handle> al_free_queue;
typedef std::pair<smartaction_ptr,BML_BULLET_DATA> al_pq_item;
typedef std::deque<al_pq_item> al_push_queue;

//typedef std::deque<BML_BULLET_DATA> al_push_queue;


typedef simple_array_type::iterator simple_iterator;
typedef simple_array_type::handle simple_handle;
typedef action_array_type::iterator action_iterator;
typedef action_array_type::handle action_handle;

typedef   std::pair<sa_ptr_handle,action_handle> al_fq_item;

typedef dkutil::set_to_deque_adapter<al_fq_item> al_free_queue;
/*
struct ActionBulletManager{
  smartaction_ptr_pool mPool;
  action_array_type mActionArray;

};
*/


struct BMLStaticData{

protected:
  static simple_array_type bullets;
  static action_array_type action_list;
  static smartaction_ptr_container sapc;

  static al_free_queue fq;
  static al_push_queue pq;
  static double mDefaultSpeed;
  static int mBulletNum;
  static int mFrame;
  static void ActionBulletInsertProcess();
  static void ActionBulletEraseProcess();
  static void ActionBulletRunningProcess();

public:
  static void arrangement_memory(){
    ActionBulletRunningProcess();
    ActionBulletEraseProcess();
    ActionBulletInsertProcess();
  }

  simple_iterator begin_s(){return bullets.begin();}
  simple_iterator end_s(){return bullets.end();}
  action_iterator begin_a(){return action_list.begin();}
  action_iterator end_a(){return action_list.end();}
  static simple_iterator s_begin_s(){return bullets.begin();}
  static simple_iterator s_end_s(){return bullets.end();}
  static action_iterator s_begin_a(){return action_list.begin();}
  static action_iterator s_end_a(){return action_list.end();}
  //配列のMAX添え字をゲット 
  static size_t GetSimpleSentinel(){return bullets.max_size();}
  static size_t GetActionSentinel(){return action_list.max_size();}
  //試し。
  //static int RealBulletNum(){ return action_list.size() + bullets.size();}

  //シンプル弾系
  static simple_handle PushSimpleBullet(const BML_BULLET_DATA &x);
  static void PopSimpleBullet(simple_iterator it);
  //アクション弾系
  static BML_BULLET_DATA &at_action_bullet(action_handle h){  
    return action_list.at(h);
  }
  static smartaction_ptr &at_action_ptr(sa_ptr_handle h){
    return sapc.at(h);
  }
  static void PushActionBullet(const smartaction_ptr &x,BML_BULLET_DATA &);
  static void PopActionBullet(action_iterator it);
  static void PopActionBullet(action_handle it);


  static bool Init(int bulletnum,double bulletspeed,int queuesize=200);
  static bool End();
  


  
  static int GetFrame(){  return mFrame;}
  static void IncFrame(){ mFrame++;}
  static void ClearFrame(){ mFrame = 0;}
  static int GetBulletNum(){  return mBulletNum;}

  static void SetBulletNum(int n){mBulletNum = n;}
  static void IncBulletNum(){mBulletNum++;}
  static void DecBulletNum(){mBulletNum--;}
  
  
  static void SetBulletSpeed(double speed){ mDefaultSpeed = speed;}
  static double GetBulletSpeed(){return mDefaultSpeed;}



};

extern BMLStaticData gBMLData;


inline BMLStaticData &GetBMLStaticData(){
  return gBMLData;
}
inline void InitBulletWork(BML_BULLET_DATA *work,int flag,
                           double x,double y,
                           double ax,double ay,double direction,double speed,
                           int action_handle,
                           const char *data,size_t datasize)
{
  //この作業･･･C言語時代を思い出す〜〜
  work->x = x;
  work->y = y;
  work->accelx = ax;
  work->accely = ay;
  work->direction = direction;
  work->flag = flag;
  work->pos = -1;
  work->action_handle = action_handle;
  work->speed = speed;
  DKUTIL_NOT_ASSERT(datasize > sizeof(work->work));
  memcpy(work->work,data,sizeof(work->work));
}
inline bool CreateActionBulletHelper(smartaction_ptr ptr,BML_BULLET_DATA &rddata){

  BML_BULLET_DATA data;
  BML_BULLET_DATA &rd =  rddata;

  InitBulletWork(&data,ebmlACTION_BULLET,rd.x,rd.y,
    rd.accelx,rd.accely,rd.direction,rd.speed,
    NULL,//PushActionBulletでポインタへのIDを指定するのでNULL
    rd.work,sizeof(rd.work));

  GetBMLStaticData().PushActionBullet(ptr,data);
  return true;//多分＾＾；
}



//extern double jx,jy;
class BMLRunner_in_c : public BulletMLRunner 
{
public:
  //tagBulletData getBulletWork();
  typedef action_handle handle;
  handle mIt;
  int State;
  BML_GETPLAYER_DATA_CALLBACK mCallback;
  int getState(){return State;}
  void setState(int s){State=s;}
  double getX(){return getBulletWork().x;}
  double getY(){return getBulletWork().y;}
  /*virtual void dispose(){
    //別に何もしないよ〜〜。
  }
  virtual void *get_deleter(std::type_info const & ti){
    return NULL;
  }*/
  BML_BULLET_DATA &getBulletWork(){return gBMLData.at_action_bullet(mIt);}
  
public:
  void Move(){
    BML_BULLET_DATA &rd = getBulletWork();
    double speed = GetBMLStaticData().GetBulletSpeed();
#ifdef NDEBUG
    rd.x += getBulletSpeedX() * speed;
    rd.y += getBulletSpeedY() * speed;
#else
    double speedX = getBulletSpeedX();
    double speedY =  getBulletSpeedY();
    double tmpX = speedX * speed;
    double tmpY = speedY * speed;
    rd.x += tmpX;
    rd.y += tmpY;
    BML_BULLET_DATA *data = GetBMLStaticData().s_begin_a();

#endif


  }
  void setHandle(handle it){
     mIt = it;
  }
  handle getHandle(){
    return mIt;
  }
  BMLRunner_in_c(BulletMLParser* bulletml,
    BML_GETPLAYER_DATA_CALLBACK cback) : BulletMLRunner(bulletml) {
    //これらは後で入れる事にする。
    //setState( ebmlRUN );
    //getBulletWork().x = x0;
    //getBulletWork().y = y0;
    //getBulletWork().direction=180;
    //getBulletWork().speed=0;
    //getBulletWork().accelx=0;
    //getBulletWork().accely=0;
    DKUTIL_NOT_ASSERT(cback == NULL);
    mCallback = cback;
  }
  BMLRunner_in_c(BulletMLState* state,
    BML_GETPLAYER_DATA_CALLBACK cback) : BulletMLRunner(state) {
    //これらは後で入れる事にする。
    //setState( ebmlRUN );
    //getBulletWork().x = x0;
    //getBulletWork().y = y0;
    //getBulletWork().direction=dir0;
    //getBulletWork().speed=spd0;
    //getBulletWork().accelx=0;
    //getBulletWork().accely=0;

    DKUTIL_NOT_ASSERT(cback == NULL);
    mCallback = cback;
  }
  //~BMLRunner_in_c() {}
  double getBulletDirection() {return getBulletWork().direction;}
  inline int getX(RECT &collision){
    return collision.left + ((collision.right - collision.left) / 2);// >> 1
  }
  inline int getY(RECT &collision){
    return collision.top + ((collision.bottom - collision.top)  / 2);// >> 1
  }
  double getAimDirection() {
    int dx, dy;
    BML_PLAYER_CALLBACK_DATA player;
    if(FALSE==mCallback(&player)){
      dx = 340;//いい加減＾＾；；；
      dy = 240;
    }else{
      dx = getX(player.collision);
      dy = getY(player.collision);
    }
    //dODS("px=%d,py=%d,",dx,dy);
    BML_BULLET_DATA &rd = getBulletWork();
    dx = (int)(rd.x-dx);
    dy = (int)(dy-rd.y);
    //dkutil::dODS("dx=%d,dy=%d",dx,dy);
    


    if((dx==0)&&(dy==0)) return 180;
    else{
# ifdef NDEBUG
      return atan2((double)dx, (double)dy)/M_PI*180 + 180;
# else
      double d = atan2((double)dx, (double)dy)/M_PI*180 + 180;
      //dODS("atan2=%f",d);
      return d;
# endif
    }
  }
//  double getAimDirection() {return 0;}
  double getBulletSpeed() {return getBulletWork().speed;}
  double getDefaultSpeed() {
    return GetBMLStaticData().GetBulletSpeed();
    //return 1;
  }
  double getRank() {return 0.5;}
  void createSimpleBullet(double direction, double speed) {
    //int n = akiBullet(bmax);
    BML_BULLET_DATA b;
    //b.flag = 1;
    b.x = getBulletWork().x;
    b.y = getBulletWork().y;
    b.accelx = sin(direction/180*3.14)*speed;
    b.accely = -cos(direction/180*3.14)*speed;
    GetBMLStaticData().PushSimpleBullet(b);
//#error ここも

    
  }
  void createBullet(BulletMLState* state, double dir, double spd) 
  {
    smartaction_ptr ptr(
      new BMLRunner_in_c(state,mCallback)
      ); 
    BML_BULLET_DATA data;
    BML_BULLET_DATA &rd =  getBulletWork();

    InitBulletWork(&data,ebmlACTION_BULLET,rd.x,rd.y,
      rd.accelx,rd.accely,dir,spd,
      NULL,//PushActionBulletでポインタへのIDを指定するのでNULL
      rd.work,sizeof(rd.work));

    GetBMLStaticData().PushActionBullet(ptr,data);
    
    //CreateActionBulletHelper(ptr,getBulletWork());
      /*  BML_BULLET_DATA data;
    BML_BULLET_DATA &rd =  getBulletWork();
    InitBulletWork(&data,ebmlACTION_BULLET,rd.x,rd.y,
      rd.accelx,rd.accely,rd.direction,rd.speed,
      NULL,//PushActionBulletでポインタへのIDを指定するのでNULL
      rd.work,sizeof(rd.work));

    handle h = GetBMLStaticData().PushActionBullet(ptr,&data);
  */
    //getBulletWork().x,getBulletWork().y,dir,spd
//#error ここで
    //GetBMLStaticData().at_action(it)->setHandle(it); 
  }
    
  int getTurn() {return GetBMLStaticData().GetFrame();}
  void doVanish() {
    GetBMLStaticData().PopActionBullet(mIt);
  }


  void doChangeDirection(double direction) { getBulletWork().direction = direction; } 
  void doChangeSpeed(double speed) { getBulletWork().speed = speed; }
  void doAccelX(double dx) { getBulletWork().accelx = dx; }
  void doAccelY(double dy) { getBulletWork().accely = dy; }
  double getBulletSpeedX() {
    BML_BULLET_DATA &rd = getBulletWork();
    return dxex::gTrig.fsin(rd.direction / 180 * 3.14) * rd.speed + rd.accelx;
    //return sin(getBulletWork().direction/180*3.14)*getBulletWork().speed  + getBulletWork().accelx; 
  }
  double getBulletSpeedY() {
    BML_BULLET_DATA &rd = getBulletWork();
    return -dxex::gTrig.fcos(rd.direction / 180 * 3.14) * rd.speed + rd.accely;
    //return -cos(getBulletWork().direction/180*3.14)*getBulletWork().speed + getBulletWork().accely; 
  }

};







class BulletMLManager //: public DxExBMLStaticVariable{
{
public:

  typedef dxex::BulletMLParserDxEx BULLETML_PARSER;
  typedef smart_ptr<BULLETML_PARSER> DXEX_XMLPARSER_PTR;
  typedef dkutil::array_onebyone_ex<DXEX_XMLPARSER_PTR> PARSED_XML_CONTAINER;
  typedef  PARSED_XML_CONTAINER::handle xml_handle;
  
  //typedef BMLRunner::GET_COLLISION_FP GET_COLLISION_FP;


  typedef BMLStaticData BML_STATIC_DATA;
  //typedef BML_STATIC_DATA::simple_handle simple_handle;//弾のハンドル。
  //typedef BML_STATIC_DATA::simple_iterator simple_iterator;
  //typedef BML_STATIC_DATA::action_iterator action_iterator;
  //typedef BML_STATIC_DATA::DATA_TYPE DATA_TYPE;


private:
  PARSED_XML_CONTAINER mXMLC;
protected:

public:
  struct action_iteration{
    typedef action_iterator iterator;
    iterator begin(){return BML_STATIC_DATA::s_begin_a();}
    iterator end(){return BML_STATIC_DATA::s_end_a();}
  };
  struct simple_iteration{
    typedef simple_iterator iterator;
    iterator begin(){return BML_STATIC_DATA::s_begin_s();}
    iterator end(){return BML_STATIC_DATA::s_end_s();}
  };
    //bool empty()const{return BML_STATIC_DATA::empty();}
  BulletMLManager(){
    //mBmlPool.clear();
  }
  virtual ~BulletMLManager(){
    //clear();

    //GetPool().DoubleEntryKill();
    //FreeMemoryHelper();
    //GetPool().RealDestructor();
  }
//準備系
  bool Init(int bulletnum,double bulletspeed,int queuenum){
    return BML_STATIC_DATA::Init(bulletnum,bulletspeed,queuenum);
  }
  bool End(){
    return BML_STATIC_DATA::End();
  }

//イテレーション系
  BML_BULLET_DATA *GetSimpleAddress(){return BML_STATIC_DATA::s_begin_s();}
  BML_BULLET_DATA *GetActionAddress(){return BML_STATIC_DATA::s_begin_a();}

  BML_BULLET_DATA *GetSimpleAddressSentinel(){return BML_STATIC_DATA::s_end_s();}
  BML_BULLET_DATA *GetActionAddressSentinel(){return BML_STATIC_DATA::s_end_a();}

  size_t GetSimpleSentinel(){return BML_STATIC_DATA::GetSimpleSentinel();}
  size_t GetActionSentinel(){return BML_STATIC_DATA::GetActionSentinel();}
  
//弾の生成、削除系
  
  void DeleteSimpleBullet(BML_BULLET_DATA *data){
    BML_STATIC_DATA::PopSimpleBullet(data);
  }
  void DeleteActionBullet(BML_BULLET_DATA *data){
    BML_STATIC_DATA::PopActionBullet(data);
  }
  bool CreateBullet(xml_handle xml_h,int x,int y,
    const char *work,size_t worksize,BML_GETPLAYER_DATA_CALLBACK fp){

    BML_BULLET_DATA data;
    //ここの初期か間違えているかもしれない。スピードとかDIRECTIONとか設定していないし。
    InitBulletWork(&data,ebmlNULL,x,y,
      0,//accelx
      0,//accely
      180,//direction
      0,//speed
      0,//action handle... (後々入れる
      work,worksize);

    BulletMLManager::BULLETML_PARSER *parser = ReferenceBML(xml_h).get();
    smartaction_ptr ptr(new BMLRunner_in_c(parser,fp));

    CreateActionBulletHelper(ptr,data);
  

    return (false==ptr.isNull());
  }




//BML XML ロードアンロード系  
  
  DXEX_XMLPARSER_PTR &ReferenceBML(xml_handle h){
    return mXMLC.at(h);
  }
  xml_handle LoadBMLFile(const char *filename);

  xml_handle LoadBML(const char *memory_image_str);



  bool UnloadBML(xml_handle h,bool isCheck=true);
  

//フレーム系
  
  int GetFrame()const{
    return BML_STATIC_DATA::GetFrame();
  }
  void ClearFrame(){
    BML_STATIC_DATA::ClearFrame();
  }
  void IncFrame(){
    BML_STATIC_DATA::IncFrame();
  }

//弾の数
  
  UINT GetBulletNum()const{
    return BML_STATIC_DATA::GetBulletNum();
  }

//弾の速さ

  void SetBulletSpeed(double s){
    BML_STATIC_DATA::SetBulletSpeed(s);
  }
  
  double GetBulletSpeed(){return BML_STATIC_DATA::GetBulletSpeed();}

//libBulletMLの処理

  void Move();
  void Update();

  
  
};



}//end of bml namespace







#endif

---