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

               

---

dkutil_DataStruct.h

解説を見る。

#ifndef _dKingyo_DataStructure__
#define _dKingyo_DataStructure__

#include "dkutilConfig.h"
#include "dKingyoMacro.h"
//**********************************************************
//共通の定義
//**********************************************************

#define DKINGYO_NOT_MOUNTED -100

#define DKINGYO_NO_DEFINED_FUNCTION DKINGYO_NOT_MOUNTED

//**********************************************************
//識別するための定義
//**********************************************************

enum{//OSのバージョンを取得するための列挙
    enuWindows3_1=0,
    enuWindowsNT3_51,
    enuWindowsNT4_0,
    enuWindows95,
    enuWindows98,
    enuWindows2000,
    enuWindowsMe,
    enuWindowsXP
};

//dOpenDialog関数用のフラグ。DialogTypeFlagにぶち込む奴
enum{
    enu_dDialogOpen = 1,
    enu_dDialogSave,
    enu_dDialogTextSave,
};
//**********************************************************
//グローバルな？定数の設定
//**********************************************************
enum{
    enuExtendVaListLength = 256,
};


//**********************************************************
//**********************************************************
//dKingyoGameManager用の定義
//**********************************************************
//**********************************************************



//****************************************
//タスククラス用
//***************************************

//_______________________________________
//定義類｢
//システムタスクのプライオリティなどなど
#define HIGHEST_PRIORITY_OF_SYSTEM_TASK INT_MIN
#define LOWEST_PRIORITY_OF_SYSTEM_TASK INT_MAX
#define NO_NEXT_COUNTER -100//このカウンター値だと次のタスクに行かないように出来る。

//TASK STATE
enum{
    enuRUN=NULL,//処理する也
    enuSTOP,//今は処理しなくてよし
    enuTRASH,//もう廃棄済み
};


//TASK TYPE
enum{
    enuSYSTEM_TASK=NULL,//システムタスク
    enuDEFAULT,//デフォルト(普通はこれを入れるべき)
    enuSENTINEL,//番兵のタスク。これによってタスク挿入時に高速化を図れる
    enuKILLINGWAIT,//死刑待ちタスク。
};


enum{
    TASKNAME_SIZE = 80, //デバック用のタスクの名前を入れる文字列のサイズ
    TASKWORK_SIZE = 256,//タスクワークのサイズ。
    KILLQUEUE_SIZE =200, //死刑待ちの部屋デフォルトの数。(これ以上になると自動的に多く確保します。
};

//型情報をデバックとリリースで変える。
#ifdef _DEBUG

#   define ONETASKOBJ ONETASKDEBUG//一つの処理の構造体

#else//Release

#   define ONETASKOBJ ONETASK//一つの処理の構造体

#endif

typedef void (*VOIDFUNC)(void); 
typedef void (*VOIDARGFUNC)(void *);


//関数キューのデータ構造
typedef struct tugFunctionQueueData{
    VOIDFUNC func;
    int counter;
}FUNCTION_QUEUE_DATA;

typedef std::deque<FUNCTION_QUEUE_DATA>::iterator VOIDFUNCIT;


//ひとつのタスクのデータ構造
typedef struct tugTasClassTask{
    int         m_state;                // タスク状態(メッセージを入れる)
    int         m_type;             // タスクタイプ(親タスクとか子タスクとか
    int         m_prio;             // 実行プライオリティ
    struct tugTasClassTask *next,*prev;
    int counter;//ファンクションカウンター
    VOIDFUNC func;//実行関数
    VOIDFUNC kill;//しねしねぇ！(謎 デストラクタです。
    VOIDFUNCIT funcit;//ファンクションイテレータ
    union{//タスクワーク
        char work[TASKWORK_SIZE];
        char *pwork;
    };
    size_t worksize;//pworkのサイズ
    DWORD ID;//タスクプールから確保した時のID
#ifdef _DEBUG
    char name[TASKNAME_SIZE];//デバック用の名前。
    virtual void run(){
        if(func!=NULL)func();
        else MessageBox(NULL,"Task error:func = NULL","ERROR",MB_OK);
    }
#else
    virtual void run(){func();}
#endif
}TasClassTask;


//このゲームマネージャーのセーブデータ
typedef struct tugGameManagerSaveDataProto{
    char DxLibSetupSaveDataName[MAX_PATH];//DxLibSetupのセーブファイルを入れるパス(名前も一緒に入れること)

}GAMEMANAGER_SAVEDATA_PROTO;



typedef struct tugGameManagerSaveData{
    DWORD dwSize;//この構造体のサイズ
    union{
        char Reserved[51200];//50KBあるらしい
        GAMEMANAGER_SAVEDATA_PROTO data;
    };

}GAMEMANAGER_SAVEDATA;

inline GAMEMANAGER_SAVEDATA *GetGameManagerSettingData(){
    static GAMEMANAGER_SAVEDATA data;
    return &data;
}
//**********************************************************
//ゲームマネージャーの抽象クラス

template<class TTASK>
class IdKingyoGameManager //: public gc_cleanup
{
protected:
    virtual int KillingTime() = 0;
public:
    IdKingyoGameManager(){}
    virtual ~IdKingyoGameManager(){}
    virtual int TaskRun() = 0;
    virtual int OpeningRun() = 0;
    virtual int InsertTask( TTASK *) = 0;
    virtual int DeleteTask( TTASK *) = 0;
    virtual int DeleteTask(int ) = 0;
    virtual int DeletePriorityTask(int min,int max) = 0;
    virtual int DebugWindow(int,int) = 0;
    virtual int GetVersion() = 0;
    virtual bool isOK() = 0;
};
//**********************************************************

typedef struct tugGameManagerDefaultData{
    VOIDFUNC TopTaskInit;
    VOIDFUNC TopTaskKill;
    VOIDFUNC TailTaskInit;
    VOIDFUNC TailTaskKill;
}GAMEMANAGER_DEFAULTGLOBALDATA;

enum{
    enuDefaultTasClassData=1,
};

//**********************************************************
//描画関係のマネージャー　描画順をソートしたりとか＾＾；
//**********************************************************


//描画方法の列挙！！！！！
enum{
    //注意!：これ以上enumを増やすときは後ろに増やすこと！
    //これを守らないとジャンプテーブルが狂う。
    //NULL=そのまんま描画
    enu2DNONE=1,//そのまんま
    enu2DROTATE,//回転（拡大縮小もできる）
    enu2DROTATE2,//回転の中心も変えれる回転（拡大縮小もできる）
    enu2DTURN,//左右反転
    enu2DEXTEND,//拡大縮小（DrawExtendGraph）
    enu2DMODI,//自由変形
    enu2DCHIPMAP,//マップチップ
    enu2DTEXT,//テキスト　
    enu2DLINE,//ライン(線 //DxLibの場合はこれ以降はif,switchで解決。ジャンプテーブルめんどくせぇ
    enu2DBOX,//箱(矩形
    enu2DCIRCLE,//円(正円
    enu2DOVAL,//楕円
    enu2DTRIANGLE,//三角
    enu2DPIXEL,//ドット
};

//上記のenumの数が下のDefineなのだ！
#define DRAW2D_TYPE_NUM 15//(NULLも入れて８個


enum{
    //NULL = そのまんま描画
    enu2DNOBLEND=1,//そのまんま東(謎
    enu2DBLENDADD,//加算
    enu2DBLENDSUB,//減算
    enu2DBLENDALPHA,//αブレンディング
};

#define DRAW2D_BLEND_NUM 5//NULLもいれて五個


enum{
    //NULL = NORMAL(なにもしない)
    enu2DOPTION_NEAREST,//NEAREST NEIVER で描画？
    enu2DOPTION_BILINEAR,//BILINEAR　で描画？
};

#define DRAW2D_OPTION_NUM 3//NULLもいれて３個



//__________________________________________________________
//DxLib 用 構造体

typedef struct DrawGraphData_{
    int x1,y1;
    bool trans_flag;//通過するか？
    int handle;//グラフィックハンドル
}DRAWGRAPHDATA;

typedef struct DrawTurnGraphData_{
    int x1,y1;
    bool trans_flag;//通過するか？
    int handle;//グラフィックハンドル
}DRAWTURNGRAPHDATA;

typedef struct DrawRotaGraphData_{
    int x1,y1;
    float extend_rate,angle;//拡大縮小率。回転アングル。(DrawRotaGraphで使用。
    bool trans_flag;//通過するか？
    int handle;//グラフィックハンドル
    bool turn_flag;//LR反転するかどうか？
}DRAWROTAGRAPHDATA;

typedef struct DrawRotaGraph2Data_{
    int x1,y1;//グラフィックの座標。
    int cx,cy;//グラフィックの中心座標。
    float extend_rate,angle;//拡大縮小、回転
    bool trans_flag;//通過フラグ
    int handle;
    bool turn_flag;
    /*
        DrawRotaGraph2( 
        int x, int y, 
        int cx, int cy,
        double ExtRate, double Angle ,
        int GrHandle , int TransFlag , 
        int TurnFlag = FALSE  ) ;   // グラフィックの回転描画２
    */
}DRAWROTAGRAPH2DATA;

typedef struct DrawExtendGraphData_{
    int x1,x2,y1,y2;
    bool trans_flag;//通過するか？
    int handle;//グラフィックハンドル
}DRAWEXTENDGRAPHDATA;

typedef struct DrawModiGraphData_{
    int x1,x2,x3,x4;
    int y1,y2,y3,y4;//32バイトも使用するのって引けるなぁ。…
    bool trans_flag;//通過するか？
    int handle;//グラフィックハンドル
}DRAWMODIGRAPHDATA;

typedef struct DrawChipMapData_{//これは本当に死ぬよ。…タスク内に収まるか？
    int MapWidth, MapHeight ;//: マップデータ全体の幅と高さ
    int *MapData ;//: マップデータが格納されたアドレス
    int ChipTypeNum ;//: マップに使うチップの種類の数
    int *ChipGrHandle ;//: チップのグラフィック配列のアドレス
    int TransFlag ;//: 透過色処理の有無
    int MapDrawPointX, MapDrawPointY ;//: 描画するマップの起点となる左上座標
    int MapDrawWidth, MapDrawHeight;// : 起点座標から描画するマップの幅と高さ
    int ScreenX, ScreenY ;//: マップを描画する画面上の座標 
}DRAWCHIPMAPDATA;//よく考えるとsizeof(int)*12だよ。48バイト…まぁいいかぁ。300バイト確保しているし

typedef struct DrawTextData_{
    int x,y;
    char *szStrPointer;
    int Color;
}DRAWSTRINGDATA;

typedef struct DrawFigureData_{
    int x1,y1;//主にｘ１、ｙ１に入れてください。
    union{
        int x2;//use for DrawLine,DrawBox,and DrawTriangle
        int rx;//use for DrawOval
        int r;//use for DrawCircle
    };
    union{
        int ry;//use for DrawOval
        int y2;//use for DrawLine ,DrawBox and DrawTriangle
    };
    int x3;//三角形描画の時に使うｘ３、ｙ３
    int y3;//Use for DrawTriangle x3 , y3
    int Color;//color data
    int FillFlag;//If this flag is TRUE, 
                            //an inside will be smeared away with the value of Color.
}DRAWFIGUREDATA;

//_____________END DXLIB TYPE STRUCTURE OBJECT DEFINED___


//__________________________________________________________
//汎用構造体＾＾；(全然汎用じゃないなぁ

typedef struct tugDKINGYO_DRAW_2D_DATA{
    int LibFlag;//描画ライブラリフラグ
    int DrawTypeFlag;//ドローフラグ(描画の仕方(回転とか左右反転とかStringとか))
    int BlendFlag;//ブレンドフラグ
    int BlendPercent;//ブレンド率
    int OptionFlag;//オプションとか
    int red,green,blue;//RGBのデータ。(描画輝度
    int Priority;//描画順番。いわいる3DのZ値みたいな奴
    union{//各ライブラリの描画用データの構造
        //DxLib
        DRAWGRAPHDATA DrawGraph;
        DRAWTURNGRAPHDATA DrawTurnGraph;
        DRAWROTAGRAPHDATA DrawRotaGraph;
        DRAWROTAGRAPH2DATA DrawRotaGraph2;
        DRAWEXTENDGRAPHDATA DrawExtendGraph;
        DRAWCHIPMAPDATA DrawChipMap;
        DRAWMODIGRAPHDATA DrawModiGraph;
        DRAWSTRINGDATA DrawString;
        DRAWFIGUREDATA DrawFigure;
    };
    //
    //int x1; int y1; int x2; int y2;//左上右上座標
    //int x3; int y3; int x4; int y4;//左下右下座標
    //double ExtRate;//拡大率
    //double Angle;//回転角度
    //int GrHandle;//グラフィックハンドル
    //int TransFlag; //通過フラグ
}DKINGYO_DRAW_2D_DATA;

typedef struct dKingyoDrawOption{
    int m_DrawBlend;//ブレンドモードの設定
    int m_BlendPercent;//ブレンドパーセント
    int m_DrawType;//ドロータイプ(回転とか拡大とか？
    //構造体のメンバはどんどん後ろに宣言していくこと。
}DKINGYO_DRAW_OPTION;


//2D描画ラッパー(なんかそっけないけど＾＾；
template<class T>
class IdKingyoDraw2D{
public:
    virtual int Draw2D(T) = 0;
    virtual int Draw2DPQ(T) = 0;//PQ = Priority Queue

};

//同じく基本図形描画ラッパ
template<class T>
class IdKingyoDrawFigure{
public:
    virtual int DrawFigure(T) = 0;
    virtual int DrawFigurePQ(T) = 0;
};

//さらにテキスト描画系らっぱ(ラッパーってAdapterともいうらしい？
template<class T>
class IdKingyoDrawText{
public:
    virtual int DrawText(T) = 0;
    virtual int DrawTextPQ(T) = 0;
};


//ドローマネージャー
template<class T>
class IdKingyoDrawManager{
public:
    virtual int Draw2D(T) = 0;
    virtual int Draw3D(T) = 0;
    virtual int DrawText(T) = 0;
    virtual int DrawFigure(T) = 0;
    virtual int SetDrawBlend(int,int) = 0;
    virtual int SetDrawOption(int) = 0;
    virtual int SetDrawBright(int,int,int) = 0;
    virtual int SetDrawType(int) = 0;
    virtual int sort() = 0;//描画キューをソートします。
    virtual int SortDraw() = 0;//ソートして描画します。
    virtual int UserGivesDefinitionDraw(T) = 0;//ユーザーが定義する描画関数
    virtual int Display() = 0;//いわいるFlipです。
};

typedef int (*DK_DRAW2D_GP)(DKINGYO_DRAW_2D_DATA *);
typedef DKINGYO_DRAW_2D_DATA* DXLIB_GRAPH_DATA ;

enum{
    enuMEDIA_NORMAL = 1,
    enuMEDIA_BACKGROUND,
    enuMEDIA_LOOP,
};


typedef struct tugDKINGYO_MEDIA_OPTION_DATA{
    int Volume;
    int Pan;
    int Frequency;
    int LoadHandle;
    short PlayType;
}DKINGYO_MEDIA_OPTION_DATA;

template<class T>
class IdKingyoMediaManager{
public:
    virtual int Play(T) = 0;
    virtual int Stop(int //handle
                                    ) = 0;
    virtual int Stop(T);
    virtual int AllStop() = 0;
    virtual int Pause(T) = 0;
    virtual int Pause(int //handle
                                    ) = 0;
    virtual int AllPause() = 0;
    virtual int RePlay(T) = 0;
    virtual int RePlay(int //handle
                                    ) = 0;
    virtual int AllRePlay() = 0;
    virtual int SetForcedMediaOption(T) = 0;
    virtual int CancellForcedMediaOption() = 0;
    virtual int SetPlayingMediaOption(T) = 0;
    virtual int SetPlayingMediaOption(int //handle
                                    ) = 0;
    virtual int CancellPlayingMediaOption() = 0;
    virtual int CheckPlaying(int //handle
                                    ) = 0;
    virtual int CheckPlaying(T) = 0;
};

//**********************************************************
//User SetupTools
//**********************************************************
template<class T>
class IdKingyoSetupTools{
protected:
    typedef std::list<T> DATA_LIST;
public:
    IdKingyoSetupTools(){}
    virtual ~IdKingyoSetupTools(){}
    virtual int FileNameSet(char *str) = 0;
    virtual int MyDefinedDataSet(T &InsertData)=0;
    virtual T *MyDefinedDataGet(T *data=NULL)=0;
    virtual HWND GetDialogWindowHandle()=0;
    virtual int OpenDialog() = 0;
    virtual int CloseDialog() = 0;
    virtual int Construct(HINSTANCE hInstance,HINSTANCE hPrevInstance,
        LPSTR lpCmdLine,int nCmdShow,int flag) = 0;
    virtual int UnenableWindowInDialog(int ID) = 0;
};


//**********************************************************
//d金魚が使うソフトウェア自身のデータ＾＾；
//**********************************************************
/*
enum{
    enuDKINGYO_USE_DXLIB,
    enuDKINGYO_USE_YANESDK3RD,
};


#define _DKINGYO_SOFTWARENAME_LEN MAX_PATH


//d金魚が使う、ソフトウェア自身のデータ。
typedef struct dKingyoSOFTWAREDATA{
    //dKingyoSOFTWAREDATA(HINSTANCE hInst,HINSTANCE hPrev,LPCTSTR CmdLine,int CmdShow
        
    //WinMainの引数郡
    HINSTANCE m_hInstance;
    HINSTANCE m_hPrevInstance;
    LPCTSTR m_lpCmdLine;
    int m_nCmdShow;
    //ソフトの名前
    char SoftwareName[_DKINGYO_SOFTWARENAME_LEN];
    int LibraryFlag;//DirectXライブラリのフラグ。
}DKINGYO_SOFTWAREDATA;

int dKingyoSoftwareDataInit(DKINGYO_SOFTWAREDATA &d){
    
    d.LibraryFlag = enuDKINGYO_USE_DXLIB;
    d.m_hInstance = 0;
    d.m_hPrevInstance = 0;
    d.m_lpCmdLine = 0;
    d.m_nCmdShow = 0;
    strncpy(d.SoftwareName,"dKingyoGameManager Used Game" ,_DKINGYO_SOFTWARENAME_LEN);
    return 0;
}
inline DKINGYO_SOFTWAREDATA *GetdKingyoSoftwareData(){
    static DKINGYO_SOFTWAREDATA data;
    static int once=dKingyoSoftwareDataInit(data);      
    return &data;
}
inline DKINGYO_SOFTWAREDATA &GetdKingyoSoftwareDataRef(){
    return *GetdKingyoSoftwareData();
}

class IdKingyoSoftwareDataManager{
protected:
    DKINGYO_SOFTWAREDATA *m_pData;
    //DKINGYO_SOFTWAREDATA &m_data;
public:
    IdKingyoSoftwareDataManager(){
        m_pData=GetdKingyoSoftwareData();
    }
    virtual ~IdKingyoSoftwareDataManager(){}
    virtual int Initialize(HINSTANCE hInstance,HINSTANCE hPrevInstance,
        LPCTSTR lpCmdLine,int nCmdShow){
        DKINGYO_SOFTWAREDATA m_data= *m_pData;
        m_data.m_hInstance=hInstance;
        m_data.m_hPrevInstance=hPrevInstance;
        m_data.m_lpCmdLine = lpCmdLine;
        m_data.m_nCmdShow = nCmdShow;
        return 0;
    }
    virtual HINSTANCE WinMainArg1()const{return m_pData->m_hInstance;}
    virtual HINSTANCE WinMainArg2()const{return m_pData->m_hPrevInstance;}
    virtual LPCTSTR WinMainArg3()const{return m_pData->m_lpCmdLine;}
    virtual int WinMainArg4()const{return m_pData->m_nCmdShow ;}
    virtual void SetSoftwareName(char *str){
        strncpy(m_pData->SoftwareName,str,_DKINGYO_SOFTWARENAME_LEN);
    }
    virtual char *GetSoftwareName()const{return m_pData->SoftwareName;}
    virtual void SetLibraryFlag(int f){m_pData->LibraryFlag=f;}
    virtual int GetLibraryFlag()const{return m_pData->LibraryFlag;}
};
*/

//**********************************************************
//メモリ管理系
//**********************************************************


typedef struct tugFreeDomainArray{
    tugFreeDomainArray(DWORD getp,DWORD getnum) : 
        point(getp) , num(getnum){}
    DWORD point;//どこの配列の添え字からか
    DWORD num;//point後は何個か？
}FREEDOMAINARRAY;


template<class ReturnValue,class ArgType>
class IdKingyoArray{
public:
    IdKingyoArray(){};
    virtual ~IdKingyoArray(){}
    virtual int ReallocateMemory() = 0;
    virtual int Init(size_t,int,void *) = 0;
    virtual ReturnValue *GetArray(size_t,ArgType *) = 0;
    virtual int ReleaseArray(ArgType *) = 0;
    virtual int Compaction() = 0;
    virtual int AllFree() = 0;
    virtual bool isOK() = 0;
    virtual void PRINT_DEBUG(char *str,...) = 0;
    virtual void DEBUG_PRINT() = 0;
};


template<class ReturnType,class ArgType>
class IdKingyoArrayOneByOne{
protected:
public:
    IdKingyoArrayOneByOne(){}
    virtual ~IdKingyoArrayOneByOne(){}
    virtual int End() = 0;
    virtual int Init(size_t memory_count,int flag=NULL,ReturnType *p=NULL) = 0;
    virtual int Reallocate() = 0;//配列を拡張する。
    virtual int Compaction() = 0;//コンパクションする。(いちおう空の値で実装して！？
    virtual ReturnType *GetArray(ArgType) = 0;//空いている要素を返す(使用フラグを立てる
    virtual int ReleaseArray(ArgType) = 0;//使用フラグを下ろす
    virtual void PrintDebug(char *str,...) = 0;//デバック用文字列を描画する
    virtual void DebugPrint() = 0;//デバックログを残す
    virtual bool isOK() = 0;//コンストラクタが成功したかどうか？
};








//d金魚が２００３年５月ごろ使っていたもの
class IdKingyoAllocateManager
{
public:
    virtual void *Malloc(size_t) = 0;
    virtual void Free(void *) = 0;
    //void *Calloc( size_t, size_t) = 0;
    virtual void *Realloc(void *,size_t) = 0;
};

//16:55 2003/05/25　頃から製作開始。ガベコレもどき
template <class T=void *> 
class IdKingyoAllocatorGC
{
public:
  typedef size_t    size_type;
  typedef ptrdiff_t difference_type;
  typedef T*        pointer;
  typedef const T*  const_pointer;
  typedef T&        reference;
  typedef const T&  const_reference;
  typedef T         value_type;

    virtual void *MallocGC(size_t,bool,char *) = 0;
    virtual int FreeGC(void *,bool) = 0;
    virtual void *ReallocGC(void *,size_t,bool,char *) = 0;
    virtual int Collection() = 0;//ガベコレもどきをする。
  
    virtual pointer       address(reference x) const = 0;
  virtual const_pointer address(const_reference x) const = 0;
  virtual pointer allocate(size_type n, const void* hint = 0) = 0;
  virtual void deallocate(pointer p, size_type n = 0) = 0;
  virtual size_type max_size() const = 0;
  virtual void construct(pointer p, const T& val) = 0;
  virtual void destroy(pointer p) = 0;
  virtual char* _Charalloc(size_type n) = 0;
};

typedef struct tugdKingyoAllocatorGC_DEBUG{
    tugdKingyoAllocatorGC_DEBUG(size_t get_size,void *get_address,char *getstr) :
        size(get_size),address(get_address),str(getstr){}
    size_t size;
    void *address;
    std::string str;
    //union{
        //int uniReserved[5];//sizeof(int) * 5
}DKINGYOALLOCATOR_GC_DEBUG;


#   ifdef USE_DKINGYO_DEBUG_VIEW
typedef struct tugdKingyoFrameMemory{
    tugdKingyoFrameMemory(VOIDFUNC func,DWORD GetID,size_t memsize,
        DWORD begin_frame_point,char *getstr) :
            Destructor(func),ID(GetID),size(memsize),
            point(begin_frame_point),str(getstr){}

    VOIDFUNC Destructor;
    DWORD ID;
    size_t size;
    DWORD point;//byte charでのポイント
    std::string str;
}DKINGYO_FRAME_MEMORY;

#   else //デバッグビューを使わないならば
typedef struct tugdKingyoFrameMemory{
    tugdKingyoFrameMemory(VOIDFUNC func,DWORD GetID,size_t memsize,
        DWORD begin_frame_point,char *getstr) :
            Destructor(func),ID(GetID),size(memsize),
            point(begin_frame_point){}

    VOIDFUNC Destructor;
    DWORD ID;
    size_t size;
    DWORD point;//byte charでのポイント
}DKINGYO_FRAME_MEMORY;
#   endif

//**********************************************************
//データのラッピング用
//**********************************************************

//このライブラリが例外として投げかけるもの
#define DKINGYO_DATA_WRAPPER_FAILED -1 //失敗
#define DKINGYO_DATA_WRAPPER_OVERWRITE -2 //上書き


template<class V,class K>
class IdKingyoDataWrapper{
public:
    IdKingyoDataWrapper(){}
    virtual ~IdKingyoDataWrapper(){}
    virtual V GetData(K) = 0;
    virtual bool SetData(K,V) = 0;
    virtual bool DeleteDataByKey(K) = 0;
    virtual bool DeleteDataByValue(V) =0;
};


//**********************************************************
//乱数生成用
//**********************************************************

template<typename T>
class IdKingyoRandom{
#ifdef _DEBUG
    public:
#else
    protected:
#endif
    unsigned long m_ulSeed;
    T m_Seed;
    T m_Max;
public:
    IdKingyoRandom(){}
    virtual ~IdKingyoRandom(){}
    virtual T Rand() = 0;
    virtual T Random(T) = 0;
    virtual T RandomDomain(T min,T max) = 0;
    virtual T RandomDomainSafety(T min,T max) = 0;
    virtual T GetRandMax() = 0;
    virtual void SetSeed(T) = 0;
    virtual T MesBox(char *str,...) = 0;

};

//よく使うメンバ関数はすでに定義させておく
template<typename T>
class dKingyoRandom_BasicMember : public IdKingyoRandom<T>{
public:
    dKingyoRandom_BasicMember(){}
    virtual ~dKingyoRandom_BasicMember(){}
    virtual T MesBox(char *str,...){
        char s[256];
        SET_VA_LIST(s,256,str);
        return (T) MessageBox(NULL,s,"DEBUG MESSAGE",MB_OK);
    }
    virtual T GetRandMax(){return m_Max;}
    virtual void SetSeed(T set){m_ulSeed=m_Seed = set;}
};

//**********************************************************
//デバッグ用のデータ構造とか(実際あまり意味はない　拡張する時に使う
//**********************************************************

typedef int (*printfunc)(char *);
typedef std::deque<std::string> debug_string_queue;


//**********************************************************
//ユーザーが定義するdkutilのグローバルオブジェクト?
//ともかく各クラスが使う汎用的な部品たち
//**********************************************************

class IdKingyoGlobalProcess{
public:
    IdKingyoGlobalProcess(){}
    virtual ~IdKingyoGlobalProcess(){}
    virtual int LockThread() = 0;//スレッドをロックする
    virtual int UnlockThread() = 0;//スレッドをアンロックする
};

#endif

---