// 書き出し

char cBgm[ 64 ] = "";

char  cSe[ 64 ] = "";

sprintf( cBgm, "%d", iBgmVolume ); // 文字列に変換

sprintf( cSe,  "%d", iSeVolume  ); // 文字列に変換



// 書き出し( セクション名、パラム名、書き出す文字、ファイル名 )

WritePrivateProfileString( "SOUND", "BGM_VOLUME", cBgm, "CONFIG.INI" );

WritePrivateProfileString( "SOUND", "SE_VOLUME",  cSe,  "CONFIG.INI" );



// 読み込み( セクション名、パラム名、データが無かった時の戻り値、ファイル名 )

iBgmVolume = GetPrivateProfileInt( "SOUND", "BGM_VOLUME", 100, "CONFIG.INI" );

iSeVolume  = GetPrivateProfileInt( "SOUND", "SE_VOLUME",  100, "CONFIG.INI" );



// CONFIG.INIの中

[SOUND]

BGM_VOLUME=100

SE_VOLUME=100

#pragma once



#include <map>

#include <string>

#include <fstream>

#include <sstream>

#include <iostream>



class StatusFile

{

private:

	std::map<std::string, std::string> m_data;



public:

	StatusFile(void)

	{

		clear();

	}



	~StatusFile(void)

	{

	}



	void clear(void)

	{

		m_data.clear();

	}



	void set(std::string name, std::string data)

	{

		m_data.insert(std::map<std::string, std::string>::value_type(name, data));

	}



	void set(const char* name, std::string data)

	{

		std::string buf = name;

		set(buf, data);

	}



	std::string get(std::string name)

	{

		return m_data[name];

	}



	std::string get(const char* name)

	{

		std::string buf = name;

		return get(buf);

	}



	bool save(const char* path)

	{

		std::fstream fs(path, std::ios::out);

		if (fs.fail() == true)

		{

			return false;

		}



		for each (const std::pair<std::string, std::string> buf in m_data)

		{

			fs << buf.first << "=" << buf.second << std::endl;

		}

		fs.close();

		return true;

	}



	bool load(const char* path)

	{

		std::fstream fs(path, std::ios::in);

		if (fs.fail() == true)

		{

			return false;

		}



		m_data.clear();

		while (fs.eof() == false)

		{

			std::string buf, pat("="), rep(" ");

			std::getline(fs, buf);

			if (buf.length() < 3) continue;

			buf = replace(buf, pat, rep);

			std::stringstream ss(buf);

			std::string name, data;

			ss >> name >> data;

			set(name, data);

		}

		fs.close();

		return true;

	}



private:

	std::string replace(const std::string& source, const std::string& pattern, const std::string& placement)

	{

		std::string result;

		std::string::size_type pos_before = 0;

		std::string::size_type pos = 0;

		std::string::size_type len = pattern.size();

		while ((pos = source.find(pattern, pos)) != std::string::npos)

		{

			result.append(source, pos_before, pos - pos_before);

			result.append(placement);

			pos += len;

			pos_before = pos;

		}

		result.append(source, pos_before, source.size() - pos_before);

		return result;

	}

private:

};





#include <string>

#include <sstream>



template <class Type>

class Convert

{

public:

	static std::string toString(const Type& val)

	{

		std::stringstream ss;

		ss << val;

		return ss.str();

	}



	static Type toValue(std::string str)

	{

		std::stringstream ss;

		ss << str;

		Type type;

		ss >> type;

		return type;

	}

};

#include <iostream>

#include "StatusFile.h"



void main(void)

{

	// StatusFileクラスの実体を作成する

	StatusFile sf;



	// 保存したいデータをセットしていく

	sf.set("HP", Convert<int>::toString(10));

	sf.set("MP", Convert<int>::toString(20));

	sf.set("AP", Convert<int>::toString(30));

	sf.set("DP", Convert<int>::toString(40));

	sf.set("SP", Convert<int>::toString(50));

	sf.set("PositionX", Convert<double>::toString(123.45));

	sf.set("PositionY", Convert<double>::toString(678.90));

	sf.set("EventFlag", Convert<bool>::toString(true));

	sf.set("String", Convert<char*>::toString("TestString"));



	// パスを指定して保存する

	sf.save("test.txt");



	// パスを指定してStatusFileクラス内へデータを展開する

	sf.load("test.txt");



	// 値を取り出して、文字列→数値へ

	int hp = Convert<int>::toValue(sf.get("HP"));

	int mp = Convert<int>::toValue(sf.get("MP"));

	int ap = Convert<int>::toValue(sf.get("AP"));

	int dp = Convert<int>::toValue(sf.get("DP"));

	int sp = Convert<int>::toValue(sf.get("SP"));

	double posx = Convert<double>::toValue(sf.get("PositionX"));

	double posy = Convert<double>::toValue(sf.get("PositionY"));

	bool flag = Convert<bool>::toValue(sf.get("EventFlag"));

}

エラーに書いてある通り、

------------------------------------------------------------

構造体"ch_t"の中に"shot_cnt"というメンバは存在しませんよ？

------------------------------------------------------------

という意味です。



で、構造体"ch_t"は下記の様になっているみたいですね。

------------------------------------

typedef struct{

        int flag;       //フラグ

        int cnt;        //カウンタ

        int power;      //パワー

        int point;      //ポイント

        int score;      //スコア

        int num;        //残機数

        int mutekicnt;  //無敵状態とカウント

        int shot_mode;  //ショットモード

        int money;      //お金

        int img;        //画像

        int slow;       //スローかどうか

        double x,y;     //座標

}ch_t;

------------------------------------



見たところ、"shot_cnt"というメンバは無いようなので、下記の様に変更すればよいと思います。

"shot_cnt"は、多分ショットのカウンタだと思いますので、とりあえずint型にしてます。

（勝手に推測してしまいましたので、確認をしておいた方が良いと思います。）



------------------------------------

typedef struct{

        int flag;       //フラグ

        int cnt;        //カウンタ

        int power;      //パワー

        int point;      //ポイント

        int score;      //スコア

        int num;        //残機数

        int mutekicnt;  //無敵状態とカウント

        int shot_mode;  //ショットモード

        int shot_cnt    //ショットカウンタ（？）

        int money;      //お金

        int img;        //画像

        int slow;       //スローかどうか

        double x,y;     //座標

}ch_t;

------------------------------------

 

shot[n].bullet[k].x     =enemy[shot[n].num].x+cos(PI/2-PI/150*t)*100;

shot[n].bullet[k].y     =enemy[shot[n].num].y+sin(PI/2-PI/150*t)*100;

void out(){

        for(int i=0;i<ENEMY_TOTAL_SHOT_NUM;i++){//ショットの全列分

        	if(EnemyShot[i].flag==1){//その弾が発射中なら

                	for(int s=0;s<ENEMY_TOTAL_NUM;s++){//全敵100体分

                        	if(enemy[s].flag==1){//その敵のショットが出現中なら

                                	double x,y;

                                        int range;

                                        x=(int)(Player.x-EnemyShots[i].x);

                                        y=(int)(Player.y-EnemyShots[i].y);

                                	range=5;

                                        if( (int)sqrt(x*x+y*y) < range+Player.range){

                                                        Player.flag=0;

							EnemyShot[i].flag=0;

                                                        if(CheckSoundMem(sound_player_death)==1)

                                                                StopSoundMem(sound_player_death);

                            		PlaySoundMem(sound_player_death,DX_PLAYTYPE_BACK);

                                                }

                                        }

                                }

                        }

                }

        }

enemy[i].range=(MONSTER1_X_SIZE-60)/2.0f*enemy[i].size;

if(敵.life > 0)

{

	弾を撃つ処理

}

if( Stage == 3 ) { 		// TRUE

	if( ZK_MapX <= 680 ) { 	// TRUE

		ZK_MapX += 5;

----scene.h-----

void Init();

void MainLoop();

void Draw();

void Finish();

----------------



----init.c----

#include "scene.h"

void Init()

{

　　処理

}

--------------

----mainloop.c----

#include "scene.h"

void MainLoop()

{

　　処理

}

--------------

//現在のプログラムのイメージ

//main.c

enum{SCENE_START,SCENE_GAME,SCENE_LAST}

void Init(void);

int Scene_Num = SCENE_START;



main関数{

	Init();

	Loop();

	Draw();

	Finish();

}

void Init(void){

	switch(Scene_Num){

		case SCENE_START:

			〜処理〜

			break;

		case SCENE_GAME:

			〜処理〜

			break;

		case SCENE_LAST:

			〜処理〜

			break;

	}	

}

〜LOOPなども同様〜

---scene.h---

enum{SCENE_START,SCENE_GAME,SCENE_LAST};



void Init(int sn);

void Loop(int sn);

//...





---init.cpp---

#include "scene.h"



void Init(int sn)

{

	switch(sn)

	{

	case SCENE_START:

		//...

		break;

	case SCENE_GAME:

		//...

		break;

	case SCENE_LAST:

		//...

		break;

	}

}





---loop.cpp---

#include "scene.h"



void Loop(int sn)

{

	//...

}





---main.cpp---

#include "scene.h"



int main()

{

	Init(SCENE_START);

	//...

	return 0;

}

//strat_scene.cpp

	Init(){}

	Loop(){}

	Draw(){}

	Finish(){}



//game_scene.cpp

	Init(){}

	Loop(){}

	Draw(){}

	Finish(){}

//finish_scene.cpp

	Init(){}

	Loop(){}

	Draw(){}

	Finish(){}

//main.cpp

main{

〜シーンを呼び出す処理〜

SceneChange(SCENE_START);

}

//strat_scene.cpp

	start_Init(){}

	start_Loop(){}

	start_Draw(){}

	start_Finish(){}



//game_scene.cpp

	game_Init(){}

	game_Loop(){}

	game_Draw(){}

	game_Finish(){}

start_scene.h

//////////////

const SceneFunc *GetSceneFunc_Start(); 



start_scene.cpp

//////////////

#include "DxLib.h"

#include "main.h"



//  画像の読み込み

int H_Chr = LoadGraph("BMP/chr.png");



static void Init(){

} 

static void Loop(){} 

static void Draw(){

	//DrawGraph( (int)Play.Px , (int)Play.Py , H_Chr , true );

	

	DrawGraph( 0 , 0 , H_Chr , true );

} 

static void Finish(){}



const SceneFunc *GetSceneFunc_Start(){ 

    static const SceneFunc func = { &Init, &Loop, &Draw, &Finish }; 

    return &func; 

} 



main.cpp

//////////////

#include "DxLib.h"

#include "main.h"

#include "start_scene.h"



typedef enum SceneID{ 

    SCENE_START, 

    SCENE_GAME, 

    SCENE_MAX 

}SceneID; 



// シーンIDから呼び出す関数の情報を取得 

const SceneFunc *GetSceneFunc(SceneID id) 

{ 

    const SceneFunc *sceneFunc; 

    switch(id){ 

    case SCENE_START: 

        sceneFunc = GetSceneFunc_Start(); 

        break; 

    case SCENE_GAME:

        break; 

    default: 

     //   sceneFunc = NULL; 

        break; 

    } 

    return sceneFunc; 

}





int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,LPSTR lpCmdLine, int nCmdShow ){



	ChangeWindowMode(true);						//  ウインドウの変更　フルスクリーン・ウインドウ

    SetDrawScreen( DX_SCREEN_BACK ) ;           // 描画先を裏画面に設定



	// ＤＸライブラリ初期化処理

	if( DxLib_Init() == -1 ){

		 return -1;				// エラーが起きたら直ちに終了

	}



	const SceneFunc *sceneFunc = GetSceneFunc(SCENE_START); 

//    if(sceneFunc){ 

//      if(sceneFunc->init)		sceneFunc->init();

//		if(sceneFunc->loop)		sceneFunc->loop(); 

        

//      if(sceneFunc->finish)	sceneFunc->finish(); 

//   } 





	//  処理

	while(1){



		//　ＢＭＰ画像の表示

		ClearDrawScreen();

		if(sceneFunc->draw)	sceneFunc->draw(); 

		ScreenFlip();



		//　処理の終了

		if(CheckHitKey(KEY_INPUT_ESCAPE)) break;



	}

	// 描画が終ったのでグラフィックをメモリ上から削除する

//	DeleteGraph( H_Chr ) ;



	DxLib_End() ;				// ＤＸライブラリ使用の終了処理

	

	return 0 ;					// ソフトの終了

}