iPhone/iPad用ドット絵エディタ「EDGE touch」

最近のエントリー

サンプルコードのダウンロード

では、まずサンプルコードをダウンロードし、解凍してください。
私はVisual C++6.0でコンパイルしているので、お持ちの方はVisual C++でプロジェクトファイルを開いてください(「game_11.dsw」をダブルクリックすれば開けます)。
圧縮ファイルに含まれる「game_11.exe」をダブルクリックし、実行してみてください。
どうでしょう?画面が切り替わり、フルスクリーン化すると思います。
そして、どこからか弾が沸き、自機(スライム)の方向へ飛んできますよね?

というわけで、今回は角度の算出とアニメーションについて説明していきたいと思います。

三角関数のお勉強 その1


第4回では、三角関数としてsin、cos、tanを説明しました。
しかし、これだけで、敵から、自機への角度を算出する事は出来ません。

そこで、今回はatan(アークタンジェント)というものを使用します。

普通のtanは

tanΘ=b/a

でしたが、アークタンジェントは

Θ=atan(b/a)

となります。要するに、タンジェントの逆算みたいな感じですね。

三角関数のお勉強 その2


というわけで、基本が解れば、あとは当てはめるだけですね。
左の図のように敵、自機が存在し、角度Θを求めたい場合、

Θ=atan((sy-my)/(sx-mx))

とすればいいですよね?

ただし、y/xが例えば1/1、-1/-1の場合、値は一緒ですよね?
という事で、atanの返値Θも半分の180度周期になってしまいます。(ちなみにsin,cosは360度周期,sin(0)=sin(360)=sin(360*n))

そこで、x,yの符号を利用して、ある条件の時はΘに180を足すと言った処理が必要になってきます。

また、xが0の場合、y/0=∞となってしまい、エラーとなってしまいます。
これも回避しなければなりません。

アークタンジェントをC言語で使用する

C言語でアークタンジェントを使用したい場合は、「math.h」をインクルードした後、atan( double v ) を呼び出せば出来ます。

ただ、上でも書いたように、返ってくる角度Θは180度周期だったり、xが0だった場合にエラーとなったりします。
で、いろいろ判定して正しい値を出そうとしがちですが、C言語にはatan2( double y, double x) という関数が用意されています。
この、yとxに値を引き渡してやると、360度周期で角度を返してくれます。しかも、xが0の時の処理もしっかりやってくれるので便利です。

ただ、atanもそうですが、atan2の返値の単位はラジアンです(0~360度=0~2π)。
atan2の場合は-π~+πまでが返ってくるので、atan2の返値をπで割れば、-1~+1までになりますよね?
そしてπは180°ですから、その値に180を掛けてやると、値は-180°~+180°になりますね?
これに、360°を足し、360で割った余りを出すと、0~359°の値が出てきます。

	double tmp;
	short angle;
	tmp=atan2(-double(sy-my),double(sx-mx));
	tmp/=3.1415926535;
	tmp*=180;
	tmp+=360;
	angle=(short)tmp%360;

こんな感じかな。

これで敵から自機への角度Θが出せますね?

サンプルコードの解説

今回のコードは、「第9回 キー入力によって弾を発射」を少し改良し、ランダムに弾を作成し、自機の方向へ飛ばすようにします。
弾の移動等、詳しい事は第9回を参照してください。

今回は、ついでに弾をアニメーションさせる事にするので、_bullet構造体にanimationという変数を
追加しておきます。

//弾用変数
struct _bullet{
	BOOL enable;	//使用:1  未使用:0
	float x,y;		//座標
	char animation;	//アニメーション
	short angle;	//進む角度
}bullet[BMAX];

では、メインループを見てみます。

//----------[ メインループ ]--------------------------------------------------------------------
void GameLoop(void){
	while(1){
		WaitSet();				//現在の時間(単位:ミリ秒)取得
		
		MovePlayer();				//自機移動

		Shoot();				//どこからともなく沸く弾作成

		MoveBullet();				//弾移動

		Show();					//画像表示
		Wait(1000/60);				//メッセージループへ
	}
}

第9回と見た目が同じですが、Shoot()とMoveBullet()、Show()の中身を変更しています。(他は全部同じ)

//----------[ 弾発射判定 ]----------------------------------------------------------------------
void Shoot(void){
	//1/100の確率で弾作成
	int x,y,angle;
	if(rand()%100==0){
		x=rand()%640;	//x,y座標はランダム
		y=rand()%480;
		angle=GetAngle(x+8,y+8,(int)player.x+16,(int)player.y+16);	//自機への角度取得
		CreateBullet((float)x,(float)y,angle);
	}
}

ここでは、1/100の確立で適当な位置を出し、自機への角度を取得して、弾を作成しています。
rand()という関数は0~RAND_MAXまでの乱数を返してくれるので、適当な値pで割った余りを出せば、0からpのランダム値が出せます(度数分布が崩れるので本当はあまりよろしくない)。

で、GetAngle(int mx,int my,int sx,int sy);関数は自作関数で、mx,myからsx,syまでの角度を算出します。
GetAngle(x+8,y+8,(int)player.x+16,(int)player.y+16);のx+8,y+8というように、ある値を足していますが、自機などの座標は、画像の左端を表わしているため、画像の中心を表わすためには、画像サイズの半分の値を足せばいいですよね?

//----------[ 角度取得 ]------------------------------------------------------------------------
short GetAngle(int mx,int my,int sx,int sy){
	return short(atan2(-double(sy-my),double(sx-mx))/3.141592*180+360)%360;
}

この自作関数は上の方で説明したので解りますね(^^;

で、弾をアニメーションさせるためには、弾移動中にanimationの値をどんどん増やしていきます。

//----------[ 弾移動 ]--------------------------------------------------------------------------
void MoveBullet(void){
	int i;
	float mv=6.0f;

	for(i=0;i<BMAX;i++){
		if(bullet[i].enable==0)	//未使用データだったら次の処理へ
			continue;

		//移動
		bullet[i].x+=fcos[bullet[i].angle]*mv;
		bullet[i].y-=fsin[bullet[i].angle]*mv;
		
		//アニメーション
		bullet[i].animation++;
		if(bullet[i].animation>=12)
			bullet[i].animation=0;
		//++bullet[i].animation%=12;  と書いても可

		//画面外に出たら未使用データにする
		if(bullet[i].x<-16 || bullet[i].x>640 || bullet[i].y<-16 || bullet[i].y>480)
			bullet[i].enable=0;
	}
}

今回使用する画像はです。弾のアニメーションは12パターンありますよね?
ですから、animationの値は0~11の間を繰り返し変化するようにプログラムしてやります。

で、後は、このanimationの値をうまく画像に照らし合わせて画面に表示してやればいいわけです。
1つの弾の画像サイズが16×16で左にスライムが32ドットあるので、弾画像のx座標は32+16×アニメーションという事になりますよね?

//----------[ 画像表示 ]------------------------------------------------------------------------
void Show(void){
	ClearScreen(lpBack);		//バックバッファ初期化
	DdTextOut(lpBack,0,0,"カーソルキーで移動 pauseキーで終了",255);

	int i;
	//弾表示
	for(i=0;i<BMAX;i++)
		if(bullet[i].enable==1)
			BltClip(lpBack,(int)bullet[i].x,(int)bullet[i].y,
				16,16,lpWork,32+16*bullet[i].animation,0,1);

	//自機転送
	BltClip(lpBack,(int)player.x,(int)player.y,32,32,lpWork,0,0,1);
	//フリップ
	Flip();
}

このアニメーションは、繰り返し行われる弾やら敵に限りますね。
自機のようなキー入力によって画像を変えたいときには使えません。

サンプルコードのダウンロード

では、まずサンプルコードをダウンロードし、解凍してください。
私はVisual C++6.0でコンパイルしているので、お持ちの方はVisual C++でプロジェクトファイルを開いてください(「game_10.dsw」をダブルクリックすれば開けます)。
圧縮ファイルに含まれる「game_10.exe」をダブルクリックし、実行してみてください。
どうでしょう?画面が切り替わり、フルスクリーン化すると思います。
そして、スペースキーを押すと、スライムがジャンプすると思います。

というわけで今回は、ジャンプについて解説したいと思います。

ジャンプ

さて、ジャンプと言うと重力が関係してくるので、なんとなく物理法則(奇数の法則だったかな・・・忘れた)っぽいものを思い浮かべそうですが、そんなムツカシー法則は一切
使いません(爆。第6回 慣性の時と処理が似ている(というかほとんど一緒)のですが、違うのは、Y座標に進む値(今回はsy)に重力として毎回一定の値を足すだけです。

ではサンプルコードを見ていきます。

今回は画面下が地面という設定にします。

//----------[ メイン関数 ]----------------------------------------------------------------------
int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow){
    
	<略>

	int cx=320-16;
	float cy=448.0f;
	float sy=0.0f;

	//メインループ
	while(1){
		WaitSet();			//現在の時間(単位:ミリ秒)取得
		ClearScreen(lpBack);		//バックバッファ初期化
		DdTextOut(lpBack,0,0,"スペースキーでジャンプ  pauseキーで終了",255);

		//ジャンプ開始
		if(keyg[32] && cy==448.0f)
			sy=-12.0f;	//ジャンプ力
		
		cy+=sy;			//慣性(?
		sy+=0.3f;			//重力を加える
		
		if(cy>=448)		//画面より下に行かないようにする
			cy=448.0f;
		
		//キャラクタ表示
		BltClip(lpBack,cx,(int)cy,32,32,lpWork,0,0,1);
		Flip();					//フリップ
		Wait(1000/60);				//メッセージループへ
	}	

自然落下は、空から地面に向かって重力によって加速しながら進んでいきますよね?
車で言えば、どんどんアクセル踏んでスピード出して加速していくようなものです。
で、今回のプログラムの場合、syがスピードのようなものになり、重力によってそのスピードが
どんどん増加していく形になります。

サンプルコードのダウンロード

では、まずサンプルコードをダウンロードし、解凍してください。
私はVisual C++6.0でコンパイルしているので、をお持ちの方はVisual C++でプロジェクトファイルを開いてください(「game_09.dsw」をダブルクリックすれば開けます)。
圧縮ファイルに含まれる「game_09.exe」をダブルクリックし、実行してみてください。
どうでしょう?カーソルキーで自機が移動し、スペースキーを押すと、弾が発射されると思います。

というわけで今回は、弾処理について解説したいと思います。

構造化プログラミング基礎

ここのプログラミング講座を見ている人は、ほとんどが初心者だと思います。
そして初心者にプログラムを組ませてみると、高い確率で、WinMain(またはmain)関数内にひたすら書きまくるようです。
たしかに、それでも動くには動くのですが、プログラムが複雑になってくると、どうしても管理がしにくくなってきますよね?
そこで、ある程度固まった処理、例えば「キー入力でキャラを動かす」だとか「キャラクターを表示する」
というような処理を区切って記述してやります。
そうする事で、プログラムを管理しやすくなったり、バグを発見しやすくなります。

ようするに役割ごとにサブルーチン化するって事です。

弾処理のアルゴリズム基礎

弾の発射から消えて無くなるまでの大まかな流れは以下の通りです。

  1. 弾用の変数(構造体等)を複数、用意する
  2. キー入力があったら、弾データを作成する
  3. 弾を移動させる
  4. 弾が画面外に出たら、弾データを消す
  5. 弾表示
  6. 2へ

重要なポイントは、弾のデータを作ったら、その後、弾のデータを移動させたり削除したりする事でしょうかねぇ。

実際にプログラムを組む

では、判りやすい(たぶん)ように、順番に説明していきたいと思います。

まず、構造化プログラムという事で、必要な変数等をグローバル変数として宣言してやります(ソースの出来るだけ上に書く。

//サイン、コサイン テーブル
float fcos[360],fsin[360];

//自機用変数
struct _player{
	float x,y;		//座標
	int renda;		//連打用フラグ
}player={320.0f-32,240.0f-32,0};//初期化

#define BMAX 100		//画面内に最大100弾とする(爆

//弾用変数
struct _bullet{
	BOOL enable;		//使用:1  未使用:0
	float x,y;		//座標
	short angle;		//進む角度
}bullet[BMAX];

こうする事で、どこでも(どの自作関数内でも)これらの変数を参照する事が出来るようになります。
今まで、プレイヤーの座標はWinMain関数内でcx,cyと宣言し、それらを使用していましたが、今回は構造体(_player)として宣言します。
_bullet構造体は、弾の処理に使用します。
今回使う変数はとりあえず、使用・未使用を表すフラグ(enable)と
座標(x,y)と、進む方向(angle)だけです。

では、一番最初に実行するWinMain関数を見てみましょう。

//----------[ メイン関数 ]----------------------------------------------------------------------
int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow){

	//ウィンドウ作成
	if(!InitWindow(hInstance,hPrevInstance,nCmdShow))
		Quit("ウィンドウ作成に失敗しました。");
	
	//DirectDraw開始
	if(!StartDirectDraw(hw))
		Quit("DirectDrawの初期化に失敗しました。");

	//ゲーム初期化
	InitGame();

	//ゲームループへ
	GameLoop();
	
	return(FALSE);
}

いやぁ、今まではここ(↑)にひたすら書いていたので、今回のプログラムは結構すっきり見えますね。

InitWindow()はウィンドウを作成する処理を書いてあるだけの自作関数なので解説省略。

で、DirectDrawを初期化したらInitGame();を呼び出していますね?
これはゲームに必要な処理を先にしておく自作関数です。中を見てみましょう。


//----------[ ゲーム初期化 ]--------------------------------------------------------------------
void InitGame(void){
	//ビットマップからパレット読み込み
	LoadPalette("ss.bmp");

	//オフスクリーンサーフェイス(lpWork)へビットマップ読み込み
	LoadBitmap(lpWork,"ss.bmp",0,0,72,64);

	//透明色指定(パレット0番の黒色を透明色とする)
	SetTransColor(lpWork,0);

	//弾データ初期化
	for(int i=0;i<BMAX;i++)
		bullet[i].enable=0;		//全て未使用データとする

	//サイン、コサインテーブル作成
	for(i=0;i<360;i++){
		fsin[i]=(float)sin(i*3.1415926535/180);
		fcos[i]=(float)cos(i*3.1415926535/180);
	}
}


まず、作業用サーフェイス(lpWork)にキャラの画像を読み込んでおきます(左の絵)。
で、_bullet構造体のメンバ変数「enable」を0に設定しておきます(全て)。
enableが0だったら、その構造体は使用していないという事にします。

で、ここの処理が終わると、処理はWinMainの方へ戻って、次はGameLoop();を呼び出していますよね?
この関数はゲームのループ用の自作関数です。コードは次のようになっています。

//----------[ メインループ ]--------------------------------------------------------------------
void GameLoop(void){
	while(1){
		WaitSet();				//現在の時間(単位:ミリ秒)取得
		
		MovePlayer();				//自機移動
		Shoot();					//弾発射判定

		MoveBullet();				//弾移動

		Show();					//画像表示
		Wait(1000/60);				//メッセージループへ
	}
}

whileの中の最初と最後のWaitSet()、Wait()については既にやっているので解説省略。

で、まずMovePlayer()関数を呼び出していますよね?こいつはキー入力により自機を動かす処理をする自作関数です。

//----------[ 自機移動 ]------------------------------------------------------------------------
void MovePlayer(void){
	
	int angle=-1;				//とりあえず角度を-1にしておく
	//[38]↑	[40]↓	[37]←	[39]→
	if(keyg[38] && keyg[39])	//右上
		angle=45;
	else
     ・
     ・
     ・
	(略)

	//angleの値が変わっていたらキャラクタの座標を変更する
	float mv=4.0f;	//移動量
	if(angle!=-1){
		player.x+=fcos[angle]*mv;
		player.y-=fsin[angle]*mv;
	}
}

この関数内でやっていることは第5回で説明したので、みりゃ判りますね?

ここの処理が終わったら、GameLoopの方へ戻って、次にShoot()関数が呼ばれています。

Shoot()関数では、スペースキーが押されているか判定し、押されていれば弾を作成します。

ここでは、シューティングゲームで使うような、押しっぱなしでも連射できる処理をやります。

//----------[ 弾発射判定 ]----------------------------------------------------------------------
void Shoot(void){
	int i;
	//弾発射判定
	if(keyg[32]){			//キーが押されている場合
		
		if(!player.renda)		//変数rendaが0なら打つ
			for(i=-2;i<=2;i++)	//弾作成
				CreateBullet(player.x+28,player.y-5,90+i*15);

		player.renda++;
		player.renda%=10;		//打つ間隔
	
	} else {				//キーが押されていない場合
		if(player.renda){
			player.renda++;
			player.renda%=10;
		}
	}
}

ここでは、ちょっとした工夫が必要ですかね。
スペースキーが押されていた場合に弾を作成するだけでは、
押している間、毎回弾が作成されてしまいますよね?
シューティングゲームのように、一定間隔で弾を撃ちたい場合は、一つ変数を用意し(今回はplayer.renda)、スペースキーが押されている間はこの変数に1を足し、10になったら0に戻してやります。
で、この変数が0の時だけ弾を作成すれば、処理的には10ループに1回弾を発射する事になります。

さて、ここで極端な例を挙げてみます。この弾を出す間隔が10では無く、1000だとしましょう。
普通、ゲームで発射キーを押しっぱなしにする場合、発射キーを押した瞬間に弾が発射され、一定間隔で弾がでますよね?
で、もし変数「player.renda」が仮に500で止まっていたらどうでしょう。
発射キーを押しても、player.rendaは0でないため、しばらく発射されませんね?

これではマズイので、発射キーが押されていない時、player.rendaが0で無い場合には、player.rendaに1を足し、ある数を越えたら0にする、といった処理を付け加えてやります。こうすれば、発射キーを離している間でもplayer.rendaの値が変化するので、発射キーを離し、しばらくして発射キーを押した瞬間に、弾を発射させる事が可能となります。

ついでですが、発射キーが押されていない時にplayer.rendaを0にすると、いつでも発射キーを押した瞬間に弾が出せます(実際にやってみてください)。

ここの関数内では弾を作成する時にCreateBullet( x座標 , y座標 , 角度(0~359) )自作関数を呼び出しています。
ではどういった処理をしているのか見てみましょう。

//----------[ 弾作成 ]--------------------------------------------------------------------------
void CreateBullet(float x,float y,short angle){
	int i;
	int no=-1;	//作成する弾のデータ番号
	
	//構造体の中で、空いている(未使用)データを探す
	for(i=0;i<BMAX;i++)
		if(bullet[i].enable==0){
			no=i;
			break;
		}

	//空いているデータが見つからなかったら作成せずに戻る
	if(no==-1)
		return;

	//データ詰める
	bullet[no].x=x;
	bullet[no].y=y;
	bullet[no].angle=angle;
	bullet[no].enable=1;	//使用中にする
}

さて、初めの方で呼び出したInitGame()内では_bullet構造体の全てのenableを0にし、未使用データとしましたね?
ですから、ここ(CreateBullet)では、構造体の配列の0番からBMAX-1(今回は99)までを順に参照し、enableが0(つまり未使用となっているデータ)を探します。

そんでもって、空いているデータが見つかったら、その番号の構造体に情報を詰め込んでやります。
最後にenableを1とし、no番の構造体を使用データという事にしていますよね?
ですから、次にCreateBullet関数内で空いているデータを順に探した時も、no番のenableは0では無いので
上から新しくデータが詰められる事はありません。

でShoot()関数へ戻り、GameLoop()の方へ戻り、次にMoveBullet()を呼び出しています。

//----------[ 弾移動 ]--------------------------------------------------------------------------
void MoveBullet(void){
	int i;
	float mv=6.0f;

	for(i=0;i<BMAX;i++){
		if(bullet[i].enable==0)	//未使用データだったら次の処理へ
			continue;

		//移動
		bullet[i].x+=fcos[bullet[i].angle]*mv;
		bullet[i].y-=fsin[bullet[i].angle]*mv;
		
		//画面外(今回は画面上)に出たら未使用データにする
		if(bullet[i].y<-32)
			bullet[i].enable=0;
	}
}

ここでは、構造体_bulletの配列を0から順番に参照し、enableが0でないデータ(つまり使用しているデータ)だけを処理します。
角度による移動自体は第4回で説明したので省略。

そして、画面外に出たらenableを0にし、未使用データとしてやります。

GameLoop()に戻り、次にShow()が呼び出されます。これは、ディスプレイに一連の表示をする
自作関数です。
コードを見てみましょう。

//----------[ 画像表示 ]------------------------------------------------------------------------
void Show(void){
	ClearScreen(lpBack);		//バックバッファ初期化
	DdTextOut(lpBack,0,0,"カーソルキーで移動 spaceキーで弾発射 pauseキーで終了",255);

	int i;
	//弾表示
	for(i=0;i<BMAX;i++)
		if(bullet[i].enable==1)
			BltClip(lpBack,(int)bullet[i].x,(int)bullet[i].y,8,32,lpWork,64,0,1);

	//自機転送
	BltClip(lpBack,(int)player.x,(int)player.y,64,64,lpWork,0,0,1);
	//フリップ
	Flip();
}

まぁ、ここは見りゃ判りますね(爆

弾は使用しているものだけ表示してやります。

とりあえず、これで説明は終わりです(^^;

今回のプログラムの流れを図で表すと、こんな感じになるのかも

矢印は関数の呼び出しです。

おまけ

今回は弾のデータ構造に構造体の配列を使用しましたが、この場合、配列中に使用しているデータと使用していないデータが両方含まれていたり、弾数に制限があったりして少し不便ですよね?
そんなときはリスト構造を使用すると結構スッキリ記述できます。
Space Soldierは双方向リスト構造でやってました。

サンプルコードのダウンロード

では、まずサンプルコードをダウンロードし、解凍してください。
私はVisual C++6.0でコンパイルしているので、お持ちの方はVisual C++でプロジェクトファイルを開いてください(「game_08.dsw」をダブルクリックすれば開けます)。
圧縮ファイルに含まれる「game_08.exe」をダブルクリックし、実行してみてください。
どうでしょう?画面が切り替わり、フルスクリーン化すると思います。
そして、何かキーを押すと、そのキーコードが画面に表示されると思います。
というわけで今回は、キー入力について解説したいと思います。

二次元座標同士の当たり判定


右の図のように、座標上に2つの長方形が存在したとします。
ここで、この2つの物体(長方形)が重なっているか(当たっているか)を調べるときに、次のような式をよく使います。

if(ax2<bx1 || ax1>bx2 || ay1<by2 || ay2>by1)
	当たっていない
else
	当たっている

ただ、例によって(?)数学上の座標とパソコンのディスプレイの座標ではY軸の向きが逆なので、

if(ax2<bx1 || ax1>bx2 || ay1>by2 || ay2<by1)
	当たっていない
else
	当たっている

これが正しい式となります。まぁ、当たった時の判定だけしたいのならば、「!」を使えば直ぐに出来ますね。

if(!(ax2<bx1 || ax1>bx2 || ay1>by2 || ay2<by1))
	当たっている

実際にゲームに使用する場合は、キャラクターの全体もしくは、その一部を当たり判定とし、その部分を長方形として扱い、上の式へ代入します。
ただ、この方法はシューティングゲーム等のような、「あまり精度にはこだわらないから速度の速い方法がいい」という場合に使用してください。

レッツプログラミング

ではサンプルコードを見ていきます。

今回は、「第3回 キー入力によって複数のキャラクタを動かす」の最後の方へちょこっと加え、2匹のスライムが重なった(当たった)時にそのメッセージを表示するようにします。

//----------[ メイン関数 ]----------------------------------------------------------------------
int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow){
	
	<略>

	//座標
	int cx[2]={160-16,480-16},cy[2]={240-16,240-16};
	
	//キーテーブル
	unsigned char key_up[2]={38,104},key_down[2]={40,98},
		key_left[2]={37,100},key_right[2]={39,102};
	
	//その他の変数
	int i,mv=3;

	//メインループ
	while(1){
		WaitSet();			//現在の時間(単位:ミリ秒)取得
		ClearScreen(lpBack);		//バックバッファ初期化
		DdTextOut(lpBack,0,0,"カーソルキー、テンキー(4,6,8,2)で移動 pauseキーで終了",255);

		for(i=0;i<2;i++){
			//キャラクター移動
			if(keyg[key_up[i]])	//↑
				cy[i]-=mv;
			else
			if(keyg[key_down[i]])	//↓
				cy[i]+=mv;
			else
			if(keyg[key_left[i]])	//←
				cx[i]-=mv;
			else
			if(keyg[key_right[i]])	//→
				cx[i]+=mv;
			
			//キャラクタ表示
			BltClip(lpBack,cx[i],cy[i],32,32,lpWork,32*i,0,1);
		}

		//当たり判定
		if(!(cx[0]>cx[1]+31 || cx[0]+31<cx[1] || cy[0]+31<cy[1] || cy[0]>cy[1]+31))
			DdTextOut(lpBack,0,16,"当たっている",255);
		
		
		Flip();					//フィリップ
		Wait(1000/60);				//メッセージループへ
	}

解説するまでも無いですね。

サンプルコードのダウンロード

では、まずサンプルコードをダウンロードし、解凍してください。
私はVisual C++6.0でコンパイルしているので、をお持ちの方はVisual C++でプロジェクトファイルを開いてください(「game_07.dsw」をダブルクリックすれば開けます)。
圧縮ファイルに含まれる「game_07.exe」をダブルクリックし、実行してみてください。
どうでしょう?画面が切り替わり、フルスクリーン化すると思います。
そして、何かキーを押すと、そのキーコードが画面に表示されると思います。
というわけで今回は、キー入力について解説したいと思います。

よくわからない解説

ではサンプルコードを見ていきます。


//----------[ メイン関数 ]----------------------------------------------------------------------
int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdParam, int nCmdShow){
    
	<略>

#define CMAX 81	//記憶しておく座標の数
#define OSTEP 20	//オプションを配置する間隔

	//    cx:座標 cy:座標  mv:移動量   
	float cx[CMAX],cy[CMAX],mv=3.0f;
		
	//座標初期化
	int i;
	for(i=0;i<CMAX;i++){
		cx[i]=float(320-16);
		cy[i]=float(240-16);
	}
	
	int angle=0;

	//サイン、コサインテーブル作成
	float fsin[360],fcos[360];

	for(i=0;i<360;i++){
		fsin[i]=(float)sin(i*3.1415926535/180);
		fcos[i]=(float)cos(i*3.1415926535/180);
	}

	//メインループ
	while(1){
		WaitSet();					//現在の時間(単位:ミリ秒)取得
		ClearScreen(lpBack);		//バックバッファ初期化
		DdTextOut(lpBack,0,0,"↑、↓、→、←で移動 pauseキーで終了",255);
		
		angle=-1;	//とりあえず角度を-1にしておく

		//[38]↑	[40]↓	[37]←	[39]→
		if(keyg[38] && keyg[39])	//右上
			angle=45;
		else
		・
		・
		・
		<キー入力省略>

		//angleの値が変わっていたらキャラクタの座標を変更する
		if(angle!=-1){

			//座標を記憶しておく(バックアップ
			for(i=CMAX-2;i>=0;i--){
				cx[i+1]=cx[i];
				cy[i+1]=cy[i];
			}

			cx[0]+=fcos[angle]*mv;
			cy[0]-=fsin[angle]*mv;
		}

		//キャラクタ表示
		//オプション
		//後ろ(古い座標)から表示
		for(i=CMAX-1;i>0;i-=OSTEP)
			BltClip(lpBack,(int)cx[i],(int)cy[i],32,32,lpWork,32,0,1);
		
		//本体
		BltClip(lpBack,(int)cx[0],(int)cy[0],32,32,lpWork,0,0,1);
		
		
		Flip();					//フィリップ
		Wait(1000/60);				//メッセージループへ
	}	

グラディウスのオプションは、本体(自機)の通った跡を遅れて通りますよね?
ですから、こういった処理は、自機の座標をいくつか記憶しておき、古い座標の所へオプションを配置してやればいいのです。

まず、キャラクタ(自機)の座標を配列でいくつか確保してやります。

#define CMAX 81	//記憶しておく座標の数
float cx[CMAX],cy[CMAX];

このとき、一番新しい座標をcx[0],cy[0]とし、一番古い座標をcx[CMAX-1],cy[CMAX-1]とします。
ゲーム中、キー入力があり、自機の座標が変更されようとしたら、cx[0],cy[0]~cx[CMAX-2],cy[CMAX-2]の中身を
cx[1],cy[1]~cx[CMAX-1],cy[CMAX-1]へコピーします(つまり1つ後ろへずらす)。
それで、cx[0],cy[0]の値を変更してやればいいのです。

	if(angle!=-1){
		//座標を記憶しておく(バックアップ
		for(i=CMAX-2;i>=0;i--){
			cx[i+1]=cx[i];
			cy[i+1]=cy[i];
		}
		cx[0]+=fcos[angle]*mv;
		cy[0]-=fsin[angle]*mv;
	}

座標を一つ後ろへずらす時、

	for(i=0;i<CMAX-1;i++){
		cx[i+1]=cx[i];
		cy[i+1]=cy[i];
	}

こんなふうに前からコピーしてしまうと、cx[0]の値がcx[1]へ、cx[1]の値がcx[2]へ・・・というように
全て同じ値になってしまうので、やめましょう(爆。ちゃんと後ろからコピーしていきましょう。

で、自機の座標跡を作っていったら、次は表示ですね。

#define OSTEP 20	//オプションを配置する間隔

	<略>

	//後ろ(古い座標)から表示
	for(i=CMAX-1;i>0;i-=OSTEP)
		BltClip(lpBack,(int)cx[i],(int)cy[i],32,32,lpWork,32,0,1);
		
	//本体
	BltClip(lpBack,(int)cx[0],(int)cy[0],32,32,lpWork,0,0,1);

オプション用の画像は自機の座標跡の古い所から表示してやります。
優先度の問題なのですが、先に描いた方が画面の後ろに表示されますよね?
なので、新しい座標の所程、後で描いてやります(自機は一番最後)

上のようなプログラムだと、
80,60,40,20番目の座標へ順番にオプションを配置し0番の座標へ自機を配置しています。