プログラマ専用SNS ミクプラ

コード:

#include "DxLib.h"
//盤面の大きさ
#define BOARDSIZE 8

//状態を定義
#define NONE 0
#define BLACK 1
#define WHITE 2

int put(int x, int y, int turn);
int checkFlip(int sx, int sy, int turn, int vec);
void flip(int x, int y, int turn, int vec);



int sx = 0, sy = 0;
int Green;
int sentaku,sentaku_se;
int i, j;
int chip[3];
int vec_y[] = { -1, -1, 0, 1, 1, 1, 0, -1 };
int vec_x[] = { 0, 1, 1, 1, 0, -1, -1, -1 };
int moveflag = 0;
//白のターン:0 黒のターン:1
int turn = 0;
int vec = 0;
int flag = 0;

int Key[256];
//盤面
int board[BOARDSIZE][BOARDSIZE];

// キーの入力状態を更新する
int gpUpdateKey(){
	char tmpKey[256]; // 現在のキーの入力状態を格納する
	GetHitKeyStateAll(tmpKey); // 全てのキーの入力状態を得る
	for (int i = 0; i<256; i++){
		if (tmpKey[i] != 0){ // i番のキーコードに対応するキーが押されていたら
			Key[i]++;     // 加算
		}
		else {              // 押されていなければ
			Key[i] = 0;   // 0にする
		}
	}
	return 0;
}

//初期化関数
void setBoard(void)
{
	int i,j;
	for (i = 0; i < BOARDSIZE; i++){
		for (j = 0; j < BOARDSIZE; j++){
			board[i][j] = NONE;
			board[BOARDSIZE / 2 - 1][BOARDSIZE / 2] = BLACK; //[3][4]
			board[BOARDSIZE / 2][BOARDSIZE / 2 - 1] = BLACK; //[4][3]
			board[BOARDSIZE / 2][BOARDSIZE / 2] = WHITE;     //[4][4]
			board[BOARDSIZE / 2 - 1][BOARDSIZE / 2 - 1] = WHITE; //[3][3]
		}
	}
}

//盤面表示関数
void disp(void){
	int i, j;
	for (i = 0; i < BOARDSIZE; i++){
		for (j = 0; j < BOARDSIZE;j++){
			switch (board[i][j]){
			case NONE:
				DrawGraph(32 * i, 32 * j,chip[0],TRUE);
				break;
			case BLACK:
				DrawGraph(32 * i, 32 * j,chip[1],TRUE);
				break;
			case WHITE:
				DrawGraph(32 * i, 32 * j,chip[2],TRUE);
				break;
			default:
				DrawString(32 * i, 32 * j, "er",TRUE);
				break;
			}
		}
	}

	DrawGraph(sx * 32, sy * 32, sentaku, TRUE);
	DrawFormatString(270, 32, GetColor(255, 255, 255), "座標X:%d 座標Y:%d", sx+1,sy+1);

	if (turn == 0){
		DrawFormatString(270, 64, GetColor(255, 255, 255), "白のターン");
	}else{
		DrawFormatString(270, 64, GetColor(255, 255, 255), "黒のターン");
	}
}

void Choose(void){

	int kx = sx;
	int ky = sy;
	if (Key[KEY_INPUT_LEFT] == 1) { kx--; moveflag = 1; }
	if (Key[KEY_INPUT_RIGHT] == 1) { kx++; moveflag = 1; }
	if (Key[KEY_INPUT_UP] == 1) { ky--; moveflag = 1; }
	if (Key[KEY_INPUT_DOWN] == 1) { ky++; moveflag = 1; }

	if ((0 <= kx && kx <= 7) && (0 <= ky && ky <= 7)){
		sx = kx;
		sy = ky;
	}
	if (moveflag == 1){
		PlaySoundMem(sentaku_se, DX_PLAYTYPE_BACK, TRUE);
		moveflag = 0;
	}
}


void input(int turn){
	if (Key[KEY_INPUT_Z] == 1) {
		put(sx, sy, turn);
	}
}

int check(int sx, int sy, int turn){
	int vec;

	//どれか一方向でもひっくり返るか確認
	for (vec = 0; vec < 8; ++vec){
		if (checkFlip(sx, sy, turn, vec) == 1) return 1;
	}
}

int checkFlip(int sx,int sy,int turn,int vec ){
	int flag = 0;
	int x = sx;
	int y = sy;
	while (1){
		y += vec_y[vec];
		x += vec_x[vec];

		//盤面の外に出ていたら終了
		if (x < 0 || y < 0 || x > BOARDSIZE - 1 || y > BOARDSIZE - 1) return 0;

		//空きマスだったら終了
		if (board[x][y] == NONE) return 0;

		//相手のコマがあったらフラグを立てる
		if (board[x][y] == (turn ? BLACK : WHITE)){
			flag = 1;
			continue;
		}

		//もしフラグがたっていればループ脱出。いなければ終了
		if (flag == 1) break;
		return 0;
	}
	return 1;
}

int put(int x, int y, int turn){
	//空白でなければ終了
	if (board[x][y] != NONE) return 0;

	//全方向について確認
	for (vec = 0; vec < 8; ++vec){
		if (checkFlip(x, y, turn, vec) == 1){
			//裏返す
			flip(x, y, turn, vec);
			flag = 1;
		}
	}
	if (flag == 1){
		//この場所にコマを置く
		board[x][y] = (turn ? WHITE : BLACK);
		return 1;
	}
	return 0;
}

void flip(int x, int y,int turn, int vec){

	while (1){
		y += vec_y[vec];
		x += vec_x[vec];

		//自分のコマがあったら終了
		if (board[x][y] == (turn ? WHITE : BLACK)) {
			turn = (turn + 1) % 2;
			break;
		}
		//それ以外なら自分のコマで塗りつぶす
		board[x][y] = (turn ? WHITE : BLACK);
	}
}


int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int){
	ChangeWindowMode(TRUE), DxLib_Init(), SetDrawScreen(DX_SCREEN_BACK); //ウィンドウモード変更と初期化と裏画面設定

	Green = GetColor(0, 256, 0);
	LoadDivGraph("chip.bmp", 3, 3, 1, 32, 32, chip);
	sentaku = LoadGraph("sentaku.png", TRUE);
	sentaku_se = LoadSoundMem("se01.mp3");
	setBoard();

	while (!ProcessMessage()){
		ClearDrawScreen();

		gpUpdateKey();
		Choose();

		disp();
		input(turn);

		ScreenFlip();
	}
	DxLib_End(); // DXライブラリ終了処理
	return 0;
}

コード:

#include "DxLib.h"

#define NONE 0
#define BLACK 1
#define WHITE 2

//碁盤生成
int board[3][3] = {
	{ 0, 0, 0 },
	{ 0, 0, 0 },
	{ 0, 0, 0 }
};

//ステータス
enum{
	PLAYING,
	WIN,
	LOSE
} status = PLAYING;

//プレイヤー
int px = 0, py = 0;
//ターン(黒が先手)
int turn = BLACK;
//選択チップ,駒チップ
int sentaku,chip[3];
//キーコード格納変数
int Key[256];
//色変数
int White = GetColor(255, 255, 255);

// キーの入力状態を更新する
int gpUpdateKey(){
	char tmpKey[256]; // 現在のキーの入力状態を格納する
	GetHitKeyStateAll(tmpKey); // 全てのキーの入力状態を得る
	for (int i = 0; i<256; i++){
		if (tmpKey[i] != 0){ // i番のキーコードに対応するキーが押されていたら
			Key[i]++;     // 加算
		}
		else {              // 押されていなければ
			Key[i] = 0;   // 0にする
		}
	}
	return 0;
}

void Putchip(void){
	int cx = px;
	int cy = py;
	if (Key[KEY_INPUT_Z] == 1){
		if (board[cx][cy] == 0){
			board[cx][cy] = turn;
			turn = 2 / turn;
		}
	}
}

void Choose(void){
	int kx = px;
	int ky = py;
	if (Key[KEY_INPUT_LEFT] == 1) { kx--; }
	if (Key[KEY_INPUT_RIGHT] == 1) { kx++; }
	if (Key[KEY_INPUT_UP] == 1) { ky--; }
	if (Key[KEY_INPUT_DOWN] == 1) { ky++; }
	if ((0 <= kx && kx <= 2) && (0 <= ky && ky <= 2)){
		px = kx;
		py = ky;
	}
}

void Load(void){
	LoadDivGraph("chip.bmp", 3, 3, 1, 32, 32, chip);
	sentaku = LoadGraph("sentaku.png", TRUE);
}

void Display(void){
	int i, j;
	for (i = 0; i < 3; i++){
		for (j = 0; j < 3; j++){
			switch (board[i][j]){
			case NONE:
				DrawGraph(32 * i, 32 * j, chip[0], TRUE);
				break;
			case BLACK:
				DrawGraph(32 * i, 32 * j, chip[1], TRUE);
				break;
			case WHITE:
				DrawGraph(32 * i, 32 * j, chip[2], TRUE);
				break;
			}
		}
	}
	DrawGraph(px * 32, py * 32, sentaku, TRUE);
	DrawFormatString(270, 32,White, "座標X:%d 座標Y:%d", px + 1, py + 1);
	DrawFormatString(270, 72,White, "%dのターン",turn);
	DrawString(270, 112, "Zキーで選択", White);
}

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int){
	ChangeWindowMode(TRUE);
	SetDrawScreen(DX_SCREEN_BACK);
	DxLib_Init();

	while (!ProcessMessage()){
		ClearDrawScreen();

		gpUpdateKey();
		Choose();
		Putchip();
		Load();
		Display();

		ScreenFlip();
	}
	DxLib_End(); // DXライブラリ終了処理
	return 0;
}

コード:

#include "DxLib.h"

#define NONE 0
#define BLACK 1
#define WHITE 2

//碁盤生成
int board[3][3] = {
	{ 0, 0, 0 },
	{ 0, 0, 0 },
	{ 0, 0, 0 }
};

//ステータス
enum Status{
	PLAYING,
	WIN,
	LOSE,
	EVEN
} status = PLAYING;



//プレイヤー
int px = 0, py = 0;
//ターン(黒が先手)
int turn = BLACK;
//選択チップ,駒チップ
int sentaku,chip[3];
//キーコード格納変数
int Key[256];
//色変数
int White = GetColor(255, 255, 255);
//ゲームカウント
int Gamecount = 0;

// キーの入力状態を更新する
int gpUpdateKey(){
	char tmpKey[256]; // 現在のキーの入力状態を格納する
	GetHitKeyStateAll(tmpKey); // 全てのキーの入力状態を得る
	for (int i = 0; i<256; i++){
		if (tmpKey[i] != 0){ // i番のキーコードに対応するキーが押されていたら
			Key[i]++;     // 加算
		}
		else {              // 押されていなければ
			Key[i] = 0;   // 0にする
		}
	}
	return 0;
}

void Check(void){
	if (Gamecount == 9) status = EVEN;
	if (board[0][0] == BLACK && board[0][1] == BLACK && board[0][2] == BLACK){
		status = WIN;
	}
	if (board[0][0] == BLACK && board[1][0] == BLACK && board[2][0] == BLACK){
		status = WIN;
	}
	if (board[0][0] == BLACK && board[1][1] == BLACK && board[2][2] == BLACK){
		status = WIN;
	}
	if (board[1][0] == BLACK && board[1][1] == BLACK && board[1][2] == BLACK){
		status = WIN;
	}
	if (board[2][0] == BLACK && board[2][1] == BLACK && board[2][2] == BLACK){
		status = WIN;
	}
	if (board[0][1] == BLACK && board[1][1] == BLACK && board[2][1] == BLACK){
		status = WIN;
	}
	if (board[0][2] == BLACK && board[1][2] == BLACK && board[2][2] == BLACK){
		status = WIN;
	}
	if (board[2][0] == BLACK && board[1][1] == BLACK && board[0][2] == BLACK){
		status = WIN;
	}
	if (board[0][0] == WHITE && board[0][1] == WHITE && board[0][2] == WHITE){
		status = LOSE;
	}
	if (board[0][0] == WHITE && board[1][0] == WHITE && board[2][0] == WHITE){
		status = LOSE;
	}
	if (board[0][0] == WHITE && board[1][1] == WHITE && board[2][2] == WHITE){
		status = LOSE;
	}
	if (board[1][0] == WHITE && board[1][1] == WHITE && board[1][2] == WHITE){
		status = LOSE;
	}
	if (board[2][0] == WHITE && board[2][1] == WHITE && board[2][2] == WHITE){
		status = LOSE;
	}
	if (board[0][1] == WHITE && board[1][1] == WHITE && board[2][1] == WHITE){
		status = LOSE;
	}
	if (board[0][2] == WHITE && board[1][2] == WHITE && board[2][2] == WHITE){
		status = LOSE;
	}
	if (board[2][0] == WHITE && board[1][1] == WHITE && board[0][2] == WHITE){
		status = LOSE;
	}
}

void Putchip(void){
	int cx = px;
	int cy = py;
	if (Key[KEY_INPUT_Z] == 1){
		if (board[cx][cy] == 0){
			board[cx][cy] = turn;
			turn = 2 / turn;
			Gamecount++;
		}
	}
}

void Choose(void){
	int kx = px;
	int ky = py;
	if (Key[KEY_INPUT_LEFT] == 1) { kx--; }
	if (Key[KEY_INPUT_RIGHT] == 1) { kx++; }
	if (Key[KEY_INPUT_UP] == 1) { ky--; }
	if (Key[KEY_INPUT_DOWN] == 1) { ky++; }
	if ((0 <= kx && kx <= 2) && (0 <= ky && ky <= 2)){
		px = kx;
		py = ky;
	}
}

void Load(void){
	LoadDivGraph("chip.bmp", 3, 3, 1, 32, 32, chip);
	sentaku = LoadGraph("sentaku.png", TRUE);
}

void Display(void){
	int i, j;
	for (i = 0; i < 3; i++){
		for (j = 0; j < 3; j++){
			switch (board[i][j]){
			case NONE:
				DrawGraph(32 * i, 32 * j, chip[0], TRUE);
				break;
			case BLACK:
				DrawGraph(32 * i, 32 * j, chip[1], TRUE);
				break;
			case WHITE:
				DrawGraph(32 * i, 32 * j, chip[2], TRUE);
				break;
			}
		}
	}
	DrawGraph(px * 32, py * 32, sentaku, TRUE);
	DrawFormatString(270, 32,White, "座標X:%d 座標Y:%d", px + 1, py + 1);
	DrawFormatString(270, 72,White, "%dのターン",turn);
	DrawString(270, 112, "Zキーで選択", White);
	DrawFormatString(270,200, White, "%dターン目", Gamecount);
}

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int){
	ChangeWindowMode(TRUE);
	SetDrawScreen(DX_SCREEN_BACK);
	DxLib_Init();

	while (!ProcessMessage()){
		ClearDrawScreen();

		gpUpdateKey();
		Choose();
		Putchip();
		Check();
		Load();
		Display();

		switch (status){
		case EVEN:
			DrawString(270, 300, "引き分けです", White);
			WaitTimer(1000);
			DxLib_End();
			break;
		case WIN:
			DrawString(270, 300, "あなたの勝ちです", White);
			WaitTimer(1000);
			DxLib_End();
			break;
		case LOSE:
			DrawString(270, 300, "あなたの負けです", White);
			WaitTimer(1000);
			DxLib_End();
			break;
		}

		ScreenFlip();
	}
	DxLib_End(); // DXライブラリ終了処理
	return 0;
}

コード:

#include "DxLib.h"

#define NONE 0
#define BLACK 1
#define WHITE 2

//ステータス
enum Status{ PLAYING, WIN, LOSE, EVEN } status = PLAYING;
//碁盤生成
int board[3][3] = {
	{ 0, 0, 0 },
	{ 0, 0, 0 },
	{ 0, 0, 0 }
};
//プレイヤー(選択カーソル)
int px = 0, py = 0;
//ターン(黒が先手)
int turn = BLACK;
//選択チップ,駒チップ
int sentaku,chip[3];
//キーコード格納変数(新ゲームプログラミングの館より)
int Key[256];
//色変数
int White = GetColor(255, 255, 255);
//ゲームカウント
int Gamecount = 0;

// キーの入力状態を更新する(新ゲームプログラミングの館より)
int gpUpdateKey(){
	char tmpKey[256]; // 現在のキーの入力状態を格納する
	GetHitKeyStateAll(tmpKey); // 全てのキーの入力状態を得る
	for (int i = 0; i<256; i++){
		if (tmpKey[i] != 0){ // i番のキーコードに対応するキーが押されていたら
			Key[i]++;     // 加算
		}
		else {              // 押されていなければ
			Key[i] = 0;   // 0にする
		}
	}
	return 0;
}

//勝利判定関数
void Check(void){
	if (Gamecount == 9) status = EVEN;
	int i,color;
	for (color = 1; color < WHITE + 1; color++){
		for (i = 0; i < 3; i++){
			//横
			if (board[0][i] == color && board[1][i] == color && board[2][i] == color){
				if (color == 1)status = WIN;
				if (color == 2)status = LOSE;
			}
			//縦
			if (board[i][0] == color && board[i][1] == color && board[i][2] == color){
				if (color == 1)status = WIN;
				if (color == 2)status = LOSE;
			}
			//斜め
			if (board[0][0] == color && board[1][1] == color && board[2][2] == color){
				if (color == 1)status = WIN;
				if (color == 2)status = LOSE;
			}
			if (board[2][0] == color && board[1][1] == color && board[0][2] == color){
				if (color == 1)status = WIN;
				if (color == 2)status = LOSE;
			}
		}
	}
}

//コマを置く関数
void Putchip(int px, int py){
	int cx = px;
	int cy = py;
	if (Key[KEY_INPUT_Z] == 1){
		if (board[cx][cy] == 0){
			board[cx][cy] = turn;
			turn = 2 / turn;
			Gamecount++;
		}
	}
}

//選択カーソルの関数
void Choose(void){
	int kx = px;
	int ky = py;
	if (Key[KEY_INPUT_LEFT] == 1) { kx--; }
	if (Key[KEY_INPUT_RIGHT] == 1) { kx++; }
	if (Key[KEY_INPUT_UP] == 1) { ky--; }
	if (Key[KEY_INPUT_DOWN] == 1) { ky++; }
	if ((0 <= kx && kx <= 2) && (0 <= ky && ky <= 2)){
		px = kx;
		py = ky;
	}
}

//画像読み込み
void Load(void){
	LoadDivGraph("chip.jpg", 3, 3, 1, 32, 32, chip);
	sentaku = LoadGraph("sentaku.png", TRUE);
}

//表示関数
void Display(void){
	int i, j;
	for (i = 0; i < 3; i++){
		for (j = 0; j < 3; j++){
			switch (board[i][j]){
			case NONE:
				DrawGraph(32 * i, 32 * j, chip[0], TRUE);
				break;
			case BLACK:
				DrawGraph(32 * i, 32 * j, chip[1], TRUE);
				break;
			case WHITE:
				DrawGraph(32 * i, 32 * j, chip[2], TRUE);
				break;
			}
		}
	}
	DrawGraph(px * 32, py * 32, sentaku, TRUE);
	DrawFormatString(270, 32,White, "座標X:%d 座標Y:%d", px + 1, py + 1);
	if (turn == 1){ 
		DrawString(270, 72,"先手のターン",White);
	}
	else if (turn == 2){
		DrawString(270, 72,"後手のターン",White);
	}
	DrawString(270, 112, "Zキーで駒を置きます", White);
	DrawFormatString(270,200, White, "総ターン数:%d", Gamecount);
}

void Statuscheck(int status){
	switch (status){
	case EVEN:
		DrawString(270, 300, "引き分けです", White);
		WaitTimer(1000);
		DxLib_End();
		break;
	case WIN:
		DrawString(270, 300, "あなたの勝ちです", White);
		WaitTimer(1000);
		DxLib_End();
		break;
	case LOSE:
		DrawString(270, 300, "あなたの負けです", White);
		WaitTimer(1000);
		DxLib_End();
		break;
	}
}

void CPU(){
		int CPUrand, CPUx, CPUy;
		if (turn == 2){
			CPUrand = GetRand(8);
			CPUx = CPUrand % 3;
			CPUy = CPUrand / 3;
			Putchip(CPUx, CPUy);
			if (turn == WHITE && !(Gamecount == 9) && status == PLAYING){
				CPU();
			}
		}
}

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int){
	ChangeWindowMode(TRUE);
	SetDrawScreen(DX_SCREEN_BACK);
	DxLib_Init();

	while (!ProcessMessage()){
		ClearDrawScreen();

		gpUpdateKey();
		Choose();
		Putchip(px,py);
		Check();
		Load();
		CPU();
		Display();
		Statuscheck(status);
		ScreenFlip();
	}
	DxLib_End(); // DXライブラリ終了処理
	return 0;
}

コード:

//現在のカーソルの座標から8方向
#define VECTOR_ALL 8
//チップ画像変数
static int m_Chip[3];
//ボード状態を格納する変数
static int m_Board[BOARD_WIDTH][BOARD_HEIGHT];
//ベクトル変数
static int vector_x[VECTOR_ALL] = { 0, 1, 1, 1, 0, -1, -1, -1 };
static int vector_y[VECTOR_ALL] = { -1, -1, 0, 1, 1, 1, 0, -1 };

//ボード初期化
void Board_Init(){
	int i, j;
	for (i = 0; i < BOARD_WIDTH; i++){
		for (j = 0; j < BOARD_HEIGHT; j++){
			m_Board[i][j] = 0;
		}
	}
	LoadDivGraph("img/chip.png", 3, 3, 1, BOARDCHIP_SIZE, BOARDCHIP_SIZE, m_Chip);

	m_Board[3][3] = 2;
	m_Board[4][3] = 1;
	m_Board[3][4] = 1;
	m_Board[4][4] = 2;
}

int Board_Check(){
	int vec;
	//どれか一方向でもひっくり返るか確認
	for (vec = 0; vec < VECTOR_ALL; ++vec){
		if (Board_Checkflip(vec) == 0) { return 0; }
	}
	return 1;
}

int Board_Checkflip(int i){
	int flag = 0,j;

	static Cursor_t tmp_CursorData = Cursor_Get();
	int kx = tmp_CursorData.cursor_x;
	int ky = tmp_CursorData.cursor_y;
	for (j = 0; j < BOARDCHIP_SIZE; j++){

		kx = kx + (j+1) * vector_x[i];
		ky = ky + (j+1) * vector_y[i];

		//盤面の外に出ていたら終了
		if (kx < 0 || ky < 0 || kx > BOARDCHIP_SIZE - 1 || ky > BOARDCHIP_SIZE - 1) return 1;

		//空きマスだったら終了
		if (m_Board[kx][ky] == NONE) return 1;

		//相手のコマがあったらフラグを立てる
		if (m_Board[kx][ky] == (2 / MainData.turn)){ flag = 1; continue; }

		if (m_Board[kx][ky] == MainData.turn && flag == 1){ return 0; }
	}
	return 1;
}

int Board_Flip(int i){

	return 0;
}

//ボードにコマを置く関数
int Board_Putchip(int Board_x, int Board_y){
	if (Board_Check() == 0 && m_Board[Board_x][Board_y] == 0){
			m_Board[Board_x][Board_y] = MainData.turn;
			MainData.turn = 2 / MainData.turn;
			MainData.Gamecount++;
			return 0;
	}
	return 1;
}

コード:

int Board_CheckandFlip(int Board_x, int Board_y,int mode){
	int vec;
	int i,j,k;
	int flag = 0;
	int kx, ky;
	int funcmode = mode;
	//どれか一方向でもひっくり返るか確認
	for (vec = 0; vec < VECTOR_ALL; ++vec){
		//ベクトル代入
		kx = Board_x + vector_x[vec];
		ky = Board_y + vector_y[vec];
		//盤面の外に出ていたら終了
		if (kx < 0 || ky < 0 || kx > BOARDCHIP_SIZE - 1 || ky > BOARDCHIP_SIZE - 1) { continue; }
		//空白もしくは自分の駒だったら終了
		if (m_Board[kx][ky] == NONE || m_Board[kx][ky] == MainData.turn){ continue; }
		//相手の駒を見つけたら
		if (m_Board[kx][ky] == (2 / MainData.turn)){
			for (i = 0; i < BOARDCHIP_SIZE; i++){
				kx += vector_x[vec];
				ky += vector_y[vec];
				if (m_Board[kx][ky] == NONE){
					if (i > 0){	
						j = i;
						for (k = 0; k < j + 1; k++){
							kx -= vector_x[vec];
							ky -= vector_y[vec];
							m_Board[kx][ky] = 2 / MainData.turn;
						}
					}
					break;
				}
				if (funcmode == MODE_FLIP){
					m_Board[kx - vector_x[vec]][ky - vector_y[vec]] =MainData.turn;
				}
				if (m_Board[kx][ky] == MainData.turn){
					flag = 1;
					break;
				}
			}
		}
	}
	if (flag == 1){ return 0; }
	return 1;
}

//ボードにコマを置く関数
int Board_Putchip(int Board_x, int Board_y){
	if (Board_CheckandFlip(Board_x,Board_y,MODE_CHECK) == 0 && m_Board[Board_x][Board_y] == 0){
		Board_CheckandFlip(Board_x, Board_y, MODE_FLIP);
		m_Board[Board_x][Board_y] = MainData.turn;
		MainData.turn = 2 / MainData.turn;
		MainData.Gamecount++;
		return 0;
	}
	return 1;
}

コード:

/////////////////////////////////////////////////////////
//ボードに駒を置く関数(戻り値は反転したコマの数)
/////////////////////////////////////////////////////////

int Board_Putchip(int x, int y, bool put_flag){
	//変数宣言
	int flipsum = 0, check_x, check_y, direction_x, direction_y,
		tmp_flip_x[BOARD_WIDTH], tmp_flip_y[BOARD_HEIGHT], count,flipcount;
	//反転終了フラグ
	bool flipend;
	//ステータスがプレイ中 かつ マウスで指している座標が黒駒か白駒
	if (MainData.status == PLAYING && (m_Board[x][y] == BLACK || m_Board[x][y] == WHITE)){
		return 0;
	}
	//方向走査
	for (direction_x = -1; direction_x <= 1; direction_x++){
		for (direction_y = -1; direction_y <= 1; direction_y++){
			//反転終了フラグ初期化
			flipend = false;
			//無限ループ(一つの方向にひたすら進む)
			for (count = 0;; count++){
				//まずチェックする座標を代入
				check_x = x + direction_x * (count + 1);
				check_y = y + direction_y * (count + 1);
				//盤の外か駒が置いていない場合はループを抜ける
				if (check_x < 0 || check_x >= (BOARD_WIDTH ) ||
					check_y < 0 || check_y >= (BOARD_HEIGHT) ||
					m_Board[check_x][check_y] == NONE) break;
				//自分の駒がおいてある場合
				if (m_Board[check_x][check_y] == MainData.turn && put_flag){
					for (flipcount = 0; flipcount < count; flipcount++){
						m_Board[tmp_flip_x[flipcount]][tmp_flip_y[flipcount]] = MainData.turn;
						flipsum += count;
					}
					//反転終了後フラグを立てる
					flipend = true;
				}
				//一時変数に格納
				tmp_flip_x[count] = check_x;
				tmp_flip_y[count] = check_y;
				//反転終了した場合、次の方向を走査する
				if (flipend) break;
			}
		}
	}
	//反転後コマを置く、ターンを変える、ターン数を増やす
	if (flipsum > 0 && put_flag){
		m_Board[x][y] = MainData.turn;
		MainData.turn = 2 / MainData.turn;
		MainData.Gamecount++;
		return flipsum;
	}
	//何も反転できなかった場合
	return 0;
}