Exemplo n.º 1
0
//=============================================================================
// 更新処理
//=============================================================================
void UpdateModel(void)
{
	///////////////////////////////////////
	//if (GetKeyboardTrigger(DIK_3))
	//	SetGameState(STATE_ENDING);
	///////////////////////////////////////
	//平行移動
	/*if(GetKeyboardPress(DIK_RIGHT) && Player.bPlayerMove){
		Player.moveModel.z = -cos(Player.rotModel.y + PI / 2) * MOVE_VOL;
		Player.moveModel.x = -sin(Player.rotModel.y + PI / 2) * MOVE_VOL;
	}
	if(GetKeyboardPress(DIK_LEFT) && Player.bPlayerMove){
		Player.moveModel.z = cos(Player.rotModel.y + PI / 2) * MOVE_VOL;
		Player.moveModel.x = sin(Player.rotModel.y + PI / 2) * MOVE_VOL;
	}*/
	if((GetKeyboardPress(DIK_UP) || GetKeyboardPress(DIK_W)) && Player.bPlayerMove){
		Player.moveModel.z = -cos(Player.rotModel.y) * MOVE_VOL;
		Player.moveModel.x = -sin(Player.rotModel.y) * MOVE_VOL;
		//if (GetKeyboardPress(DIK_RIGHT)) {
		//	Player.moveModel.z = -cos(Player.rotModel.y + PI / 4) * MOVE_VOL;
		//	Player.moveModel.x = -sin(Player.rotModel.y + PI / 4) * MOVE_VOL;
		//}
		//else if (GetKeyboardPress(DIK_LEFT)) {
		//	Player.moveModel.z = cos(Player.rotModel.y + PI / 4 * 3) * MOVE_VOL;
		//	Player.moveModel.x = sin(Player.rotModel.y + PI / 4 * 3) * MOVE_VOL;
		//}
	}
	/*if(GetKeyboardPress(DIK_DOWN) && Player.bPlayerMove){
		Player.moveModel.z = cos(Player.rotModel.y) * MOVE_VOL;
		Player.moveModel.x = sin(Player.rotModel.y) * MOVE_VOL;
		if (GetKeyboardPress(DIK_RIGHT)) {
			Player.moveModel.z = -cos(Player.rotModel.y + PI / 4 * 3) * MOVE_VOL;
			Player.moveModel.x = -sin(Player.rotModel.y + PI / 4 * 3) * MOVE_VOL;
		} else if (GetKeyboardPress(DIK_LEFT)) {
			Player.moveModel.z = cos(Player.rotModel.y + PI / 4) * MOVE_VOL;
			Player.moveModel.x = sin(Player.rotModel.y + PI / 4) * MOVE_VOL;
		}
	}*/
	// ジャンプ
	if(GetKeyboardTrigger(DIK_SPACE) && !Player.bPlayerJump){
		Player.bPlayerJump = true;
		PlaySound(SOUND_LABEL_SE_JUMP);
	}

	if (Player.bPlayerJump) {
		Player.moveModel.y = JUMP_VOL * Player.fJumpTime + 1.0f / 2.0f * GRAVITY_VOL * Player.fJumpTime * Player.fJumpTime;
		Player.fJumpTime ++;
	}
	/*
	if(GetKeyboardPress(DIK_I)){
		Player.posModel.y -= MOVE_VOL;
	}*/
	HitChecktoObject();

	// 移動量合算
	Player.posModel += D3DXVECTOR3(Player.moveModel.x, Player.moveModel.y, Player.moveModel.z);

	if (Player.posModel.y < DEFAULTPLAYER_POS.y && Player.bPlayerJump) {
		Player.bPlayerJump = false;
		Player.moveModel.y = 0.0f;
		Player.posModel.y = DEFAULTPLAYER_POS.y;
		Player.fJumpTime = 0;
	}

	Player.moveModel = D3DXVECTOR3(0, 0, 0);

	//回転
	if(GetKeyboardPress(DIK_A) || GetKeyboardPress(DIK_LEFT)){
		Player.rotModel.y -= ROTE_VOL;
	}
	if(GetKeyboardPress(DIK_D) || GetKeyboardPress(DIK_RIGHT)){
		Player.rotModel.y += ROTE_VOL;
	}

	//拡大縮小
	/*if(GetKeyboardPress(DIK_Q)){
		Player.scaleModel.x += SCALE_VOL;
	}
	if(GetKeyboardPress(DIK_W)){
		Player.scaleModel.y += SCALE_VOL;
	}
	if(GetKeyboardPress(DIK_E)){
		Player.scaleModel.z += SCALE_VOL;
	}
	if(GetKeyboardPress(DIK_A)){
		Player.scaleModel.x -= SCALE_VOL;
	}
	if(GetKeyboardPress(DIK_S)){
		Player.scaleModel.y -= SCALE_VOL;
	}
	if(GetKeyboardPress(DIK_D)){
		Player.scaleModel.z -= SCALE_VOL;
	}
	*/
	// 影の位置を設定
	SetPositionShadow(Player.nIdxShadow, Player.posModel);

	// Effect Setting
	SetEffect(Player.posModel, D3DXVECTOR3(0,0,0), D3DXCOLOR(1,1,0,1), 20, 20, 30);
}
Exemplo n.º 2
0
//=============================================================================
// 更新処理
//=============================================================================
void UpdateEnemy(float fTimeSpeed)
{
	CAMERA *pCamera = GetCamera();
	PLAYER *pPlayer = GetPlayer();
	int nCountAlive = 0;

	//PrintDebugProc("enemy mark %d\n", g_enemy[0].nSeePFrame);

	for(int nCntEnemy = 0; nCntEnemy < MAX_ENEMY; nCntEnemy++)
	{
		if(g_enemy[nCntEnemy].bUse)
		{
			nCountAlive++;

			{//プレイヤーに気づく判断処理
				if( !HitCheckMeshWall( g_enemy[nCntEnemy].pos, pCamera->posV, NULL, NULL) && pPlayer->bAlive && //壁に遮られたか 
					//HitCheckBall( g_enemy[nCntEnemy].pos, 1000.0f, pCamera->posV, 20.0f) && //一定の距離以内
					HitCheckViewArea( g_enemy[nCntEnemy].pos, pCamera->posV, g_enemy[nCntEnemy].rot, D3DXToRadian( 90.0f) ) && //後ろには見えない
					!IsDebugMode()) //デバッグモードのときに、当たり判定はなし
				{
					if( g_enemy[nCntEnemy].nSeePFrame <= 1000) g_enemy[nCntEnemy].nSeePFrame++;
					if( g_enemy[nCntEnemy].nSeePFrame >= 50)
					{
						g_enemy[nCntEnemy].bSeePlayer = true;

						//プレイヤーを見た時の情報を保存
						if( g_enemy[nCntEnemy].bPatrol)
						{
							//びっくりマークを設定
							SetFlashMessage(MSG_EXCLAMATION);

							g_enemy[nCntEnemy].bPatrol = false;
						
							g_enemy[nCntEnemy].posPatrol = g_enemy[nCntEnemy].pos;
							g_enemy[nCntEnemy].rotPatrol = g_enemy[nCntEnemy].rotTarget;
						}
					}
				}
				else if( HitCheckBall( g_enemy[nCntEnemy].pos, 120.0f, pCamera->posV, 20.0f) ) //一定の距離以内
				{
					if( g_enemy[nCntEnemy].nSeePFrame <= 65535) g_enemy[nCntEnemy].nSeePFrame++;
					if( g_enemy[nCntEnemy].nSeePFrame >= 50)
					{
						g_enemy[nCntEnemy].bSeePlayer = true;

						//プレイヤーを見た時の情報を保存
						if( g_enemy[nCntEnemy].bPatrol)
						{
							g_enemy[nCntEnemy].bPatrol = false;
						
							g_enemy[nCntEnemy].posPatrol = g_enemy[nCntEnemy].pos;
							g_enemy[nCntEnemy].rotPatrol = g_enemy[nCntEnemy].rotTarget;
						}
					}					
				}
				else
				{
					if( g_enemy[nCntEnemy].nSeePFrame > 0)
					{
						g_enemy[nCntEnemy].nSeePFrame--;
					}
					g_enemy[nCntEnemy].bSeePlayer = false;
				}
			}

			//CoolDown
			if( g_enemy[nCntEnemy].nCoolDown > 0)
			{
				g_enemy[nCntEnemy].nCoolDown -= 1 * fTimeSpeed;
				if(g_enemy[nCntEnemy].nCoolDown <= 0)
				{
					g_enemy[nCntEnemy].nCoolDown = -1;
					g_enemy[nCntEnemy].bShot = false;
				}
			}

			//プレイヤーに気づいたら、行動処理
			if( g_enemy[nCntEnemy].bSeePlayer || g_enemy[nCntEnemy].nSeePFrame >= 50)
			{
				if( !g_enemy[nCntEnemy].bEscaping)
				{
					//向き
					g_enemy[nCntEnemy].rotTarget = GetRotationAngle( g_enemy[nCntEnemy].pos, pCamera->posV, g_enemy[nCntEnemy].rot);		
				}

				//弾を発射
				if(!g_enemy[nCntEnemy].bShot)
				{
					//向き
					g_enemy[nCntEnemy].rot = GetRotationAngle( g_enemy[nCntEnemy].pos, pCamera->posV, g_enemy[nCntEnemy].rot);

					if(g_enemy[nCntEnemy].type == ENEMY_RED)
					{
						for(int cnt = 0; cnt < 3; cnt++)
						{
							SetEnemyBullet( g_enemy[nCntEnemy].pos, pCamera->posV + D3DXVECTOR3( rand() % 60 - 30, rand() % 40 - 20, rand() % 60 - 30));
						}

						g_enemy[nCntEnemy].bShot = true;
						g_enemy[nCntEnemy].nCoolDown = COOLDOWN + rand() % 60;
						
						PlaySound(SOUND_LABEL_SE_ESHOT);
					}
					else if(g_enemy[nCntEnemy].type == ENEMY_BLUE)
					{
						SetEnemyBullet( g_enemy[nCntEnemy].pos, pCamera->posV);
						g_enemy[nCntEnemy].bShot = true;
						g_enemy[nCntEnemy].nCoolDown = COOLDOWN/2 + rand() % 60;
						
						PlaySound(SOUND_LABEL_SE_ESHOT);					
					}
					else
					{
						SetEnemyBullet( g_enemy[nCntEnemy].pos, pCamera->posV);
						g_enemy[nCntEnemy].bShot = true;
						g_enemy[nCntEnemy].nCoolDown = COOLDOWN + rand() % 60;
						
						PlaySound(SOUND_LABEL_SE_ESHOT);					
					}

				}

			}
			else
			{
				if( g_enemy[nCntEnemy].bPatrol)
				{
					//nothing
				}
				else
				{
					//パトロールに戻る
					g_enemy[nCntEnemy].rotTarget = GetRotationAngle( g_enemy[nCntEnemy].pos, g_enemy[nCntEnemy].posPatrol, g_enemy[nCntEnemy].rot);
					D3DXVECTOR3 vec = g_enemy[nCntEnemy].pos - g_enemy[nCntEnemy].posPatrol;
					if( D3DXVec3Length( &vec) < VALUE_MOVE)
					{
						g_enemy[nCntEnemy].bPatrol = true;
						g_enemy[nCntEnemy].pos = g_enemy[nCntEnemy].posPatrol;
						g_enemy[nCntEnemy].rotTarget = g_enemy[nCntEnemy].rotPatrol;
					}
				}
			}

			//弾キレ、逃げる処理
			//if( g_enemy[nCntEnemy].bShot && !g_enemy[nCntEnemy].bEscaping)
			//{
			//	float movRot = rand() % 180 - 90;
			//	g_enemy[nCntEnemy].rotTarget.y = g_enemy[nCntEnemy].rot.y + D3DXToRadian(movRot);
			//	if( g_enemy[nCntEnemy].rotTarget.y > D3DX_PI)
			//	{
			//		g_enemy[nCntEnemy].rotTarget.y -= D3DX_PI * 2.0f;
			//	}
			//	g_enemy[nCntEnemy].bEscaping = true;
			//}

			bool bMove = true;
			//プレイヤーに近づき過ぎないように
			D3DXVECTOR3 vec = g_enemy[nCntEnemy].pos - pPlayer->pos;
			if( (D3DXVec3Length(&vec) < 200.0f) && g_enemy[nCntEnemy].bSeePlayer)
			{
				bMove = false;
			}

			{//移動処理


				if( bMove)
				{
					//移動慣性の初期化
					g_enemy[nCntEnemy].move.x = VALUE_MOVE;
					g_enemy[nCntEnemy].move.z = VALUE_MOVE;	

					if(g_enemy[nCntEnemy].type == ENEMY_BLUE)
					{
						g_enemy[nCntEnemy].move.x = 0;
						g_enemy[nCntEnemy].move.z = 0;
					}
				}


				//時計回り、または逆時計回りを決める
				g_enemy[nCntEnemy].rotAngle =  Get2VecRotAngle( g_enemy[nCntEnemy].rot, g_enemy[nCntEnemy].rotTarget, DIVIDE_ROTATE, -1);


				//回転慣性
				g_enemy[nCntEnemy].rotAngle += (-g_enemy[nCntEnemy].rotAngle) * 0.001f;

				//モデルY軸角度修正
				if(g_enemy[nCntEnemy].rot.y > D3DX_PI)
				{
					g_enemy[nCntEnemy].rot.y = g_enemy[nCntEnemy].rot.y - D3DX_PI*2;
				}
				else if(g_enemy[nCntEnemy].rot.y < 0.0f - D3DX_PI)
				{
					g_enemy[nCntEnemy].rot.y = g_enemy[nCntEnemy].rot.y + D3DX_PI*2;
				}

				//次の回転位置に到着したら
				if( fabs(g_enemy[nCntEnemy].rot.y - g_enemy[nCntEnemy].rotTarget.y) < VALUE_ROTATE &&
					fabs(g_enemy[nCntEnemy].rot.x - g_enemy[nCntEnemy].rotTarget.x) < VALUE_ROTATE &&
					fabs(g_enemy[nCntEnemy].rot.z - g_enemy[nCntEnemy].rotTarget.z) < VALUE_ROTATE
					)
				{
					g_enemy[nCntEnemy].rot = g_enemy[nCntEnemy].rotTarget;
					g_enemy[nCntEnemy].rotAngle = D3DXVECTOR3( 0, 0, 0);
				}
				else //次の回転位置にまだ到着してない
				{
					g_enemy[nCntEnemy].rot += g_enemy[nCntEnemy].rotAngle * fTimeSpeed;
				}	

				//回転していない時
				if(g_enemy[nCntEnemy].rotAngle == D3DXVECTOR3( 0, 0, 0))
				{
					//慣性処理
					g_enemy[nCntEnemy].move.x -= g_enemy[nCntEnemy].move.x * 0.05f;
					g_enemy[nCntEnemy].move.z -= g_enemy[nCntEnemy].move.z * 0.05f;

					D3DXVECTOR3 tNextPos = g_enemy[nCntEnemy].pos;
					tNextPos.x += g_enemy[nCntEnemy].move.x * sinf(g_enemy[nCntEnemy].rot.y);
					tNextPos.z += g_enemy[nCntEnemy].move.z * cosf(g_enemy[nCntEnemy].rot.y);

					D3DXVECTOR3 tSphere  = D3DXVECTOR3( 0, 0, 0);
					D3DXVECTOR3 front = tNextPos - g_enemy[nCntEnemy].pos;
					D3DXVec3Normalize( &tSphere, &front);
					tSphere *= MODEL_SPHERE;

					//壁の法線ベクトルを取得変数の初期化
					D3DXVECTOR3 wall_nor = D3DXVECTOR3(0,0,0);

					//Side
					g_enemy[nCntEnemy].posLSide.x = g_enemy[nCntEnemy].pos.x + 15.0f * sinf(g_enemy[nCntEnemy].rotTarget.y + D3DXToRadian(-90.0f));
					g_enemy[nCntEnemy].posLSide.z = g_enemy[nCntEnemy].pos.z + 15.0f * cosf(g_enemy[nCntEnemy].rotTarget.y + D3DXToRadian(-90.0f));

					g_enemy[nCntEnemy].posRSide.x = g_enemy[nCntEnemy].pos.x + 15.0f * sinf(g_enemy[nCntEnemy].rotTarget.y + D3DXToRadian(90.0f));
					g_enemy[nCntEnemy].posRSide.z = g_enemy[nCntEnemy].pos.z + 15.0f * cosf(g_enemy[nCntEnemy].rotTarget.y + D3DXToRadian(90.0f));

					//壁に当たったら
					if( HitCheckMeshWall( g_enemy[nCntEnemy].posLSide, g_enemy[nCntEnemy].posLSide + tSphere, &wall_nor, NULL) ||
						HitCheckMeshWall( g_enemy[nCntEnemy].posRSide, g_enemy[nCntEnemy].posRSide + tSphere, &wall_nor, NULL) )
					{

						if( g_enemy[nCntEnemy].bSeePlayer || !g_enemy[nCntEnemy].bPatrol)
						{
							//壁ずり処理:移動ベクトルを修正
							GetWallScratchVector( &front, front, wall_nor);
				
							D3DXVec3Normalize( &tSphere, &front);
							tSphere *= MODEL_SPHERE;

							if( !HitCheckMeshWall( g_enemy[nCntEnemy].pos, g_enemy[nCntEnemy].pos + tSphere, &wall_nor, NULL) )
							{
								//移動処理
								g_enemy[nCntEnemy].pos += front;
							}
						}
						
						if( g_enemy[nCntEnemy].bPatrol)
						{
							//180反転
							g_enemy[nCntEnemy].rotTarget.y = g_enemy[nCntEnemy].rot.y + D3DXToRadian(180.0f);
							if( g_enemy[nCntEnemy].rotTarget.y > D3DX_PI)
							{
								g_enemy[nCntEnemy].rotTarget.y -= D3DX_PI * 2.0f;
							}	
						}



					}
					else
					{
						//移動処理
						g_enemy[nCntEnemy].pos += front * fTimeSpeed;
					}		

				}			
			}

			//shadow
			SetPositionShadow( g_enemy[nCntEnemy].nIdxShadow, g_enemy[nCntEnemy].pos);

		}
	}

	if( nCountAlive == 0)
	{
		PlaySound( SOUND_LABEL_SE_CLEAR);
		SetGameStep(STEP_CLEAR);
	}

	//PrintDebugProc("\n敵の位置:(X:%f, Y:%f, Z:%f)\n", g_enemy[0].pos.x, g_enemy[0].pos.y, g_enemy[0].pos.z);
	//PrintDebugProc("敵の向き :(X:%f, Y:%f, Z:%f)\n", g_enemy[0].rot.x, D3DXToDegree(g_enemy[0].rot.y), g_enemy[0].rot.z);
	//if( g_enemy[0].bSeePlayer) PrintDebugProc("see Player\n");
	//if( g_enemy[0].bPatrol)PrintDebugProc("patral\n");

}
Exemplo n.º 3
0
//=============================================================================
// 更新処理
//=============================================================================
void UpdateBillboard(void)
{
	D3DXVECTOR3 rotCamera;

	// カメラの回転を取得
	rotCamera = GetRotCamera();

	if(GetKeyboardPress(DIK_LEFT))
	{
		if(GetKeyboardPress(DIK_UP))
		{// 左前移動
			
			
		}
		else if(GetKeyboardPress(DIK_DOWN))
		{// 左後移動
			
			
		}
		else
		{// 左移動
			
			
		}
	}
	else if(GetKeyboardPress(DIK_RIGHT))
	{
		if(GetKeyboardPress(DIK_UP))
		{// 右前移動
			
			
		}
		else if(GetKeyboardPress(DIK_DOWN))
		{// 右後移動
			
			
		}
		else
		{// 右移動
			
			
		}
	}
	else if(GetKeyboardPress(DIK_UP))
	{// 前移動
		
		
	}
	else if(GetKeyboardPress(DIK_DOWN))
	{// 後移動
		
		
	}

	if(GetKeyboardTrigger(DIK_SPACE))
	{// ジャンプ
		if(g_bEnableGravity == true)
		{	// 上方向へ速度を追加
			g_vecBillboard.y += 10.0f;
		}
	}

	// ビルボードの移動
	g_posBillboard.x += g_vecBillboard.x;
	g_posBillboard.y += g_vecBillboard.y;
	g_posBillboard.z += g_vecBillboard.z;

	// 減速
	g_vecBillboard.x += (0.0f - g_vecBillboard.x) * RATE_REGIST;
	g_vecBillboard.y += (0.0f - g_vecBillboard.y) * RATE_REGIST;
	g_vecBillboard.z += (0.0f - g_vecBillboard.z) * RATE_REGIST;

	// 範囲外チェック
	if(abs(g_vecBillboard.x) < 0.1 &&
		abs(g_vecBillboard.y) < 0.1 &&
		abs(g_vecBillboard.z) < 0.1 &&
		g_bUse){
		g_bUse = false;
		SetExplosion(g_posBillboard, 10, 10);
		ReleaseShadow(g_nIdxShadowBillboard);
		//g_posBillboard.z = 0.0f;
		g_vecBillboard.z = 0.0f;
		//SetVertexBillboard(BILLBOARD_SIZE_X, BILLBOARD_SIZE_Y);
		//g_nIdxShadowBillboard = CreateShadow(g_posBillboard, BILLBOARD_SIZE_X, BILLBOARD_SIZE_Y);
	}
	

	{// 影の設定
		// 位置
		SetPositionShadow(
			g_nIdxShadowBillboard,
			g_posBillboard
		);

		// サイズ
		float fSizeX = BILLBOARD_SIZE_X + (g_posBillboard.y - 9.0f) * 0.025f;
		if(fSizeX < BILLBOARD_SIZE_X)
		{
			fSizeX = BILLBOARD_SIZE_X;
		}
		float fSizeY = BILLBOARD_SIZE_Y + (g_posBillboard.y - 9.0f) * 0.025f;
		if(fSizeY < BILLBOARD_SIZE_Y)
		{
			fSizeY = BILLBOARD_SIZE_Y;
		}
		SetVertexShadow(g_nIdxShadowBillboard, fSizeX, fSizeY);

		// α値
		float colA = (400.0f - (g_posBillboard.y - 9.0f)) / 800.0f;
		if(colA < 0.0f)
		{
			colA = 0.0f;
		}
		SetColorShadow(g_nIdxShadowBillboard, D3DXCOLOR(1.0f, 1.0f, 1.0f, colA));
	}

}