シューティングゲーム

現在C言語とDxlibを使用してシューティングゲームを作成しています。
左下に体力バーを表記して相手が衝突するたびに減少していき、ゼロになった場合ゲームオーバー画面が出る様にしたいのですが、どうプログラムすればいいのか分かりません。分かる方がいたらどう入力するべきなのか教えてください。

#include "Game.h"
#include "Common.h"
#include "DxLib.h"
//========================================//
struct OBJECT_DATA {
int image;
int x;
int y;
int width;
int height;
int speed;
int score;
int shot_index;
int shot_wait_time;

OBJECT_DATA( ) {
	this->image = 0;
	this->x = 0;
	this->y = 0;
	this->width = 0;
	this->height = 0;
	this->speed = 0;
	this->shot_index = 0;
	this->shot_wait_time = 0;
}
OBJECT_DATA( int image,
			 int x, int y,
			 int width, int height,
			 int speed,
			 int shot_index = 0, int shot_wait_time = 0 ) {
	this->image = image;
	this->x = x;
	this->y = y;
	this->width = width;
	this->height = height;
	this->speed = speed;
	this->shot_index = shot_index;
	this->shot_wait_time = shot_wait_time;
}

};
//========================================//
int run( );

void initialize( );
void update( );
void draw( );
void finish( );

void updatePlayer( );
void updateShot( );
void updateEnemy( );
void updateBg( );

BOOL hitJudge( OBJECT_DATA* obj_a, OBJECT_DATA* obj_b );
void drawObject( OBJECT_DATA* obj );
void drawScore();
void drawHp();
//========================================//
const char* PLAYER_IMAGE_NAME = RESOURCE_PATH "ダウンロード.png";
const int PLAYER_MOVE_SPEED = 7;
const int PLAYER_SIZE_WIDTH = 42;
const int PLAYER_SIZE_HEIGHT = 20;
const int PLAYER_SHOT_WAIT_TIME = 10;
const int SCORE = 80;
const int SCORE_TIME = 15;

const char* SHOT_IMAGE_NAME = RESOURCE_PATH "Btnw1kKCMAAKF7L.png";
const int MAX_SHOT_NUM = 20;
const int SHOT_MOVE_SPEED = 20;
const int SHOT_SIZE_WIDTH = 30;
const int SHOT_SIZE_HEIGHT = 32;

const char* ENEMY_IMAGE_NAME = RESOURCE_PATH "enemy.png";
const int MAX_ENEMY_NUM = 20;
const int ENEMY_MOVE_SPEED = 10;
const int ENEMY_SIZE_WIDTH = 32;
const int ENEMY_SIZE_HEIGHT = 40;
const int ENEMY_CREATE_WAIT_TIME = 10;

const char* BG_IMAGE_NAME = RESOURCE_PATH "bg.png";
const int MAX_BG_NUM = 2;
const int BG_MOVE_SPEED = 2;
const int BG_SIZE_WIDTH = 640;
const int BG_SIZE_HEIGHT = 480;

const char* END_IMAGE_NAME = RESOURCE_PATH "BYnaPvrCUAAwbQu.jpg";
//========================================//
static OBJECT_DATA g_player;
static OBJECT_DATA g_shot_array[ MAX_SHOT_NUM ];
static OBJECT_DATA g_enemy_array[ MAX_ENEMY_NUM ];
static OBJECT_DATA g_bg_array[ MAX_BG_NUM ];
static int g_enemy_create_wait = 0;
static int g_score = 0;
static int g_hp = 100;
static int g_damege = 0;
//========================================//
int run( ) {
int result = 0;

if ( initGame( ) == TRUE ) {
	initialize( );
	while ( isLoop( ) ) {
		update( );
		draw( );
		flip( );
	}
	finish( );
	endGame( );
} else {
	result = -1;
}

return result;

}

void initialize( ) {
g_player = OBJECT_DATA( LoadGraph( PLAYER_IMAGE_NAME ),
0, ( WINDOW_SIZE_HEIGHT - PLAYER_SIZE_HEIGHT ) / 2,
PLAYER_SIZE_WIDTH, PLAYER_SIZE_HEIGHT,
PLAYER_MOVE_SPEED );

int shot_image = LoadGraph( SHOT_IMAGE_NAME );
for ( int i = 0; i < MAX_SHOT_NUM; i++ ) {
	g_shot_array[ i ] = OBJECT_DATA( shot_image,
									 WINDOW_SIZE_WIDTH, WINDOW_SIZE_HEIGHT,
									 SHOT_SIZE_WIDTH, SHOT_SIZE_HEIGHT,
									 SHOT_MOVE_SPEED );
}
int enemy_image = LoadGraph( ENEMY_IMAGE_NAME );
for ( int i = 0; i < MAX_ENEMY_NUM; i++ ) {
	g_enemy_array[ i ] = OBJECT_DATA( enemy_image,
									  -ENEMY_SIZE_WIDTH, 0,
									  ENEMY_SIZE_WIDTH, ENEMY_SIZE_HEIGHT,
									  ENEMY_MOVE_SPEED );
}

int bg_image = LoadGraph( BG_IMAGE_NAME );
for ( int i = 0; i < MAX_BG_NUM; i++ ) {
	g_bg_array[ i ] = OBJECT_DATA( bg_image,
								   BG_SIZE_WIDTH * i, 0,
								   BG_SIZE_WIDTH, BG_SIZE_HEIGHT,
								   BG_MOVE_SPEED );
}
g_enemy_create_wait = 0;
 g_score = 0;
g_damege = 0;

}

void update( ) {
updatePlayer( );
updateShot( );
updateEnemy( );
updateBg( );
}

void draw( ) {
int end_image = LoadGraph(END_IMAGE_NAME);
for ( int i = 0; i < MAX_BG_NUM; i++ ) {
drawObject( &g_bg_array[ i ] );
}

drawObject( &g_player );

for ( int i = 0; i < MAX_SHOT_NUM; i++ ) {
	drawObject( &g_shot_array[ i ] );
}

for (int i = 0; i < MAX_ENEMY_NUM; i++) {
	drawObject(&g_enemy_array[i]);
}
	drawScore();
	drawHp();
	if (g_hp <= 0) {
		DrawGraph(0, 0, end_image, FALSE);
}

}

void finish( ) {
DeleteGraph( g_player.image );
DeleteGraph( g_shot_array[ 0 ].image );
DeleteGraph( g_enemy_array[ 0 ].image );
DeleteGraph( g_bg_array[ 0 ].image );
}

void updatePlayer( ) {
if ( getKey( KEY_TYPE::HOLD_RIGHT ) ) {
g_player.x += g_player.speed;
}
if ( getKey( KEY_TYPE::HOLD_LEFT ) ) {
g_player.x += -g_player.speed;
}
if ( getKey( KEY_TYPE::HOLD_UP ) ) {
g_player.y += -g_player.speed;
}
if ( getKey( KEY_TYPE::HOLD_DOWN ) ) {
g_player.y += g_player.speed;
}
if ( getKey( KEY_TYPE::HOLD_BUTTON_A ) ) {
g_player.shot_wait_time++;
if ( g_player.shot_wait_time >= PLAYER_SHOT_WAIT_TIME ) {
g_shot_array[ g_player.shot_index ].x = g_player.x + g_player.width;
g_shot_array[ g_player.shot_index ].y = g_player.y + ( g_player.height - g_shot_array[ g_player.shot_index ].height ) / 2;
g_player.shot_wait_time = 0;
g_player.shot_index++;
g_player.shot_index %= MAX_SHOT_NUM;
}
}

g_player.x = max( g_player.x, 0 );
g_player.x = min( g_player.x, WINDOW_SIZE_WIDTH - PLAYER_SIZE_WIDTH );
g_player.y = max( g_player.y, 0 );
g_player.y = min( g_player.y, WINDOW_SIZE_HEIGHT - PLAYER_SIZE_HEIGHT );

}

void updateShot( ) {
for ( int i = 0; i < MAX_SHOT_NUM; i++ ) {
g_shot_array[ i ].x += SHOT_MOVE_SPEED;
}
}

void updateEnemy( ) {
for ( int i = 0; i < MAX_ENEMY_NUM; i++ ) {
g_enemy_array[ i ].x += -g_enemy_array[ i ].speed;

	for ( int j = 0; j < MAX_SHOT_NUM; j++ ) {
		if ( hitJudge( &g_shot_array[ j ], &g_enemy_array[ i ] ) ) {
			g_shot_array[ j ].x = WINDOW_SIZE_WIDTH;
			g_enemy_array[ i ].x = -g_enemy_array[ i ].width;
		}
	}

	if ( hitJudge( &g_player, &g_enemy_array[ i ] ) ) {
		g_player.y = WINDOW_SIZE_HEIGHT;
		g_enemy_array[ i ].x = -g_enemy_array[ i ].width;
	}
}

g_enemy_create_wait++;
if ( g_enemy_create_wait >= ENEMY_CREATE_WAIT_TIME ) {
	for ( int i = 0; i < MAX_ENEMY_NUM; i++ ) {
		if ( g_enemy_array[ i ].x <= -g_enemy_array[ i ].x ) {
			g_enemy_array[ i ].x = WINDOW_SIZE_WIDTH;
			g_enemy_array[ i ].y = getRandom( WINDOW_SIZE_HEIGHT - g_enemy_array[ i ].height );
			g_enemy_create_wait = 0;
			break;
		}
	}
}

}

void updateBg( ) {
for ( int i = 0; i < MAX_BG_NUM; i++ ) {
g_bg_array[ i ].x += -BG_MOVE_SPEED;
if ( g_bg_array[ i ].x <= -WINDOW_SIZE_WIDTH ) {
g_bg_array[ i ].x = WINDOW_SIZE_WIDTH;
}
}
}

BOOL hitJudge( OBJECT_DATA* obj_a, OBJECT_DATA* obj_b ) {
BOOL result = FALSE;
int cx = obj_a->x + obj_a->width / 2;
int cy = obj_a->y + obj_a->height / 2;
int tx = obj_b->x;
int ty = obj_b->y;
int tw = obj_b->width;
int th = obj_b->height;

if ( cx > tx &&
	 cx < tx + tw &&
	 cy > ty &&
	 cy < ty + th ) {
	result = TRUE;
}

return result;

}

void drawObject( OBJECT_DATA* obj ) {
int image = obj->image;
int x = obj->x;
int y = obj->y;
DrawGraph( x, y, image, TRUE );
}

void drawScore() {
DrawFormatString(550, 20, GetColor(255, 255, 0), "SCORE:%d", g_score);
}
void drawHp() {
DrawFormatString(0, 20, GetColor(255, 0, 255), "HP:%d", g_hp);
}

学校のC言語で課題が出されたので、サンプルのシューティングゲームを使ってゲームを制作しています。

###試したこと

###補足情報(言語/FW/ツール等のバージョンなど)
より詳細な情報

edom18

2017/02/23 07:24

コード部分は、バッククォート3つでくくるとハイライト・整形してくれるので、回答者の人が理解しやすくなるように必ず記述してください。（いい回答はいい質問から、です）

PineMatsu

2017/02/23 07:56

プログラムを記載するのはいいのですが、このプログラムがどこまで動いて何が動かないのかまたは何が出来てないのか、などもっと具体的に書いてもらわないと回答しようがありません。プログラムの全文を載せてこれを読んで（解読して）答えろというのは虫が良すぎます。回答者もそれほど暇じゃない。ましてやこのソースにはコメントが一切ないじゃないですか。

行動規範の内容に同意します

回答3件

if文で敵のXとY座標が機体のXとY座標を重なった際にHPが減るようにして、
if文でHPが0より小さくなったらGAMEOVERと描画されるようにすればいいと思います。

投稿2020/06/16 15:09

KZK13

総合スコア43

ソースコードは細かくは見ていませんが、自分だったらどうするかを書いていきます。

まず、実際のゲームシーンと、ゲームオーバーシーンで処理を分ける必要があるかと思います。

どうするかといいますと、ソースのupdate関数とdraw関数が実際のゲームシーンの処理と描画を行うと思われるので、それとは別にゲームオーバー用のupdate関数（例えばgameover_update関数）とdraw関数（例えばgameover_draw関数）を用意します。

それと現在ゲーム中なのかゲームオーバーシーンなのかを判定するためにグローバル変数（例えばg_now_scene）を用意し、ゲーム中であれば1、ゲームオーバーシーンなら2などを入れることにします。

つぎにメインループ（while(isLoop())）でこの変数を確認し
while ( isLoop( ) ) {
if (g_now_scene == 1) {
update( );
draw( );
} else if (g_now_scene == 2) {
gameover_update();
gameover_draw();
}
flip( );
}