联机版乒乓球游戏

最新推荐文章于 2023-06-15 09:59:11 发布
原创 最新推荐文章于 2023-06-15 09:59:11 发布 · 937 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#游戏

13号，锅坏了，茶壶里煮水饺，肚里有货倒不出.....

这是个超简单的联机版乒乓球游戏，做了分屏渲染，以便可以放在vr眼镜中观看，由于没有vr眼镜所以没有检验效果正确性。单帧绘制左眼内容，双帧时绘制右眼内容，两帧之间没有禁止时间步进，可能有微小的不同。

设置摄像机的代码：


void Camera::SplitLookAt()
{
	if (G_Engine->IsSplitScreenX()==false)
		return;

	vec3 eyePos = m_eyePos;
	vec3 tarPos = m_eyePos+m_headDir;

	int   SplitFrame = G_Timer->GetCurrentFrame()%2 + 1;
	float HalfEyeDis = G_Engine->GetSplitEyeDis()/2;            //双目间距/2
	float ang = atan(HalfEyeDis/G_Engine->GetSplitEyeDepth());  //根据焦距计算双目偏转
	if (IsCurCtrler<CameraCtrlerTarget>())
	{
		ang = atan(HalfEyeDis/((CameraCtrlerTarget*)GetCurCtrler())->m_distToTar);
	}

	mat4 rot;
	if (SplitFrame==1)
	{
		eyePos += m_leftDir* HalfEyeDis;  //左眼
		rot.FromAxisAngle(m_upDir,-ang);
	}
	else if (SplitFrame==2)
	{
		eyePos -= m_leftDir* HalfEyeDis;  //右眼
		rot.FromAxisAngle(m_upDir,ang);
	}

	tarPos = eyePos + rot*m_headDir;

	G_RendDriver->LookAt(eyePos.x,eyePos.y,eyePos.z,	
		tarPos.x,tarPos.y,tarPos.z,
		m_upDir.x,m_upDir.y,m_upDir.z);

}

由于没有vr输入设备，鼠标或键盘只方便在两个维度上进行输入，无法模拟三维输入，加上不用vr眼镜无法感知球的深度，所以这个乒乓球游戏做了二维的限定，球只能在平面上移动，这样球拍才好接。也有些乒乓球游戏在桌面上标记了球的投影点来帮助判断球的高度。

加了部分打砖块的元素，球碰到砖块可能被反弹或得到相应奖励。砖块被打爆后上面的砖块自动下落。

 

 球类：

//========================================================
//  @Date:     2016.05
//  @File:     SourceDemoClient/PingPong/PingPongBall.h
//  @Brief:     PingPongBall
//  @Author:     LouLei
//  @Email:  twopointfive@163.com
//  @Copyright (Crapell) - All Rights Reserved
//========================================================

#ifndef  __PingPongBall__H__
#define  __PingPongBall__H__

#include "Math/MathLib.h"

namespace RendSys
{
	class MovieClip;
}
using namespace RendSys;
class SoundChannel;

//同步移动 航位推测法

//碰撞检测结果全放到host上，其它玩家只是把paddle移动发送到host上，防止不同步和外挂
enum HitType
{
	HitNull   = 0,
	HitPaddle,
	HitBrick,
	HitDesk,
	HitOut,
};
//球
class PingPongBall 
{
public:
	PingPongBall();
	~PingPongBall();
	void  Reset();
	void  Render();
	vec3  GetPos();
	void  SetPos(const vec3& pos);
	void  SetSpeed(const vec3& speed);
	bool  Update(float time);

	//预测球的位置 最长预测2秒 最多计算两次反弹 （deviation对于球的位置和速度引入误差）
	bool  Predict(const vec3& paddleHomePos,vec3& resPos,vec3& resSpeed,float deviation);

	void  PlayHitSound(HitType hitType);

	//private:
	int   ID;
	float m_mass;
	float m_radius;

	float m_maxSpeed;
	vec3  m_pos;
	vec3  m_homePos;
	vec3  m_speed;
	vec3  m_headDir;

	quat  m_rot;

	MovieClip*     m_movieBall;
	MovieClip*     m_movieTail;
	MovieClip*     m_movieExploid;
	float          m_exploidTime;
	SoundChannel*  m_sound;
};

enum BrickType
{
	Brick  , //砖
	Bonus  , //奖
	Penalty, //罚
};

//砖
class PingPongBrick 
{
public:
	MovieClip* m_movie;
	vec3 m_pos;
	vec3 m_homePos;

	int  ID;
	//bool m_visible;
};

#endif

//========================================================
//  @Date:     2016.05
//  @File:     SourceDemoClient/PingPong/PingPongBall.cpp
//  @Brief:     PingPongBall
//  @Author:     LouLei
//  @Email:  twopointfive@163.com
//  @Copyright (Crapell) - All Rights Reserved
//========================================================

#include "General/Pch.h"
#include "PingPong/PingPongBall.h"
#include "PingPong/MiniGamePingPong.h"
#include "PingPong/PingPongPlayer.h"
#include "Render/MC_MovieClip.h"
#include "Render/RendDriver.h"
#include "Sound/ChannelSound.h"
#include "Packet/PacketMiniGame.h"
#include "General/Timer.h"
#include "General/Pce.h"

PingPongBall::PingPongBall() 
:m_movieBall(NULL)
,m_movieTail(NULL)
,m_movieExploid(NULL)
{
	m_sound = new SoundChannel;
	Reset();
}
PingPongBall::~PingPongBall() 
{
	SafeDelete(m_sound);
}
void PingPongBall::Reset() 
{
	m_mass = 0.01f;
	m_radius = 8;
	m_maxSpeed = 100;
	m_speed = vec3(0,0,-m_maxSpeed);
	m_pos = m_homePos;
	m_headDir = vec3(0,0,-1);
	m_exploidTime = 0;
}

vec3 PingPongBall::GetPos()
{
	return m_pos;
}

void PingPongBall::SetPos(const vec3& pos)
{
	m_pos = pos;
}

void PingPongBall::Render()
{
	mat4 mat;
	G_RendDriver->PushMatrix();
	G_RendDriver->Translatef(m_pos.x, m_pos.y, m_pos.z);

	m_rot.ToMatrix(mat);
	G_RendDriver->MultMatrix(mat);

	m_movieBall->Advance();
	m_movieBall->RendClip();

	G_RendDriver->PopMatrix();

	if (m_movieTail)
	{
		m_movieTail->RendClip();
	}
	if (m_movieExploid)
	{
		m_movieExploid->RendClip();
	}
	
	G_RendDriver->DisableRendState(RS_TEXTURE_2D);
	G_RendDriver->DisableRendState(RS_LIGHTING);
	G_RendDriver->Color3f(1, 0, 0);	
	G_RendDriver->SetLineWidth(1);
	G_RendDriver->RendBegin(RS_LINES);
	{
		float time = G_Timer->GetStepTimeLimited();
		vec3  end  = m_pos + m_speed * time * 1000;
		G_RendDriver->Vertex3fv(m_pos);
		G_RendDriver->Vertex3fv(end);
	}
	G_RendDriver->RendEnd();
	G_RendDriver->EnableRendState(RS_LIGHTING);
}

bool PingPongBall::Update(float time) 
{
	if (G_PingPongGame->IsHost()
		&&m_speed.Length() > 0.001f) 
	{
		vec3 mov = m_speed * time * 1.1f;//稍微加长 防止穿透
		//
		RayMovieCollideRes res;
		res.vStart   = m_pos;
		res.vEnd     = m_pos + mov;
		res.justBond = false;
		res.face     = 1;
		int hitType  = HitNull;

		//hit paddle
		PingPongPlayer* thePlayer;
		if(hitType == 0)
		{
			for(int i = 0; i < G_PingPongGame->GetAllPlayerNum(); i++)
			{
				thePlayer = dynamic_cast<PingPongPlayer*>(G_PingPongGame->GetPlayerFromIndex(i));
				if(    thePlayer 
					&& thePlayer->m_moviePaddleCollide 
					&& thePlayer->m_moviePaddleCollide->IntersectTray(res))
				{
					hitType = HitPaddle;
					res.vEnd = res.resPos;
				}
			}
		}


		int brickID = 0;
		//hit brick
		if(hitType == 0)
		{
			for(int i = 0; i < G_PingPongGame->m_brickNum; i++)
			{
				PingPongBrick* theBrick = &G_PingPongGame->m_bricks[i];
				if(theBrick->m_movie 
					&& theBrick->m_movie->IsVisible()
					&& theBrick->m_movie->IntersectTray(res))
				{
					//todo 砖块按高度排序  砖块下面无支撑则下落砖块
					hitType = HitBrick;
					brickID = theBrick->ID;
					res.vEnd = res.resPos;
					theBrick->m_movie->SetVisible(false);
					m_exploidTime = 0.5f;
				}
			}
		}

		//hit desk
		if(hitType == 0)
		{
			if (G_PingPongGame->m_movieCollidePingpong->IntersectTray(res))
			{
				hitType = HitDesk;
				res.vEnd = res.resPos;
			}
		}

		//
		if (hitType==HitPaddle)
		{
			if (m_speed.Dot(res.resNorml)>0)
			{
				//背面碰撞导致穿透
				int a = 0;
			}
			//不是反弹 直接沿法线击出
			m_speed = res.resNorml*m_maxSpeed;

			////运动继承
			//vec3 mov = vec3(100,0,0)*thePlayer->m_movDir;
			//m_speed += mov;
		}
		else if (hitType==HitBrick || hitType==HitDesk)
		{
			m_speed = Reflect(m_headDir,res.resNorml)*m_maxSpeed;
		}

		if (abs(m_pos.x-G_PingPongGame->GetStartPos().x)>200)
		{
			hitType = HitOut;
			Reset();
		}
		if (abs(m_pos.z-G_PingPongGame->GetStartPos().z)>200)
		{
			hitType = HitOut;
			Reset();
		}
		if (hitType!=HitNull)
		{
			PlayHitSound((HitType)hitType);
			C2SPacketMiniGameCmd packet;
			packet.WriteHeader();
			packet.WriteValue(CMD_BallMove);
			packet.WriteValue(ID);
			packet.WriteValue(hitType);
			packet.WriteValue(brickID);
			packet.WriteValue(m_pos);
			packet.WriteValue(m_speed);
			G_MiniGame->SendPacketToOther(&packet);
		}
	} 

	//重新计算
	vec3  mov = m_speed * time;
	m_pos += mov;
	float speedLen = m_speed.Length();
	//
	if (m_speed.LengthSq()>0.001f)
	{
		m_headDir = m_speed;
		m_headDir.Normalize();
		vec3 rightDir(m_headDir.z,0.0f,- m_headDir.x);

		//
		float rotAngleRad = speedLen * time/ m_radius;
		//if (m_rotAngleRad > TWOPI)
		//	m_rotAngleRad =  m_rotAngleRad - TWOPI;

		quat omegaQ;
		omegaQ.FromAxisAngle(rightDir, rotAngleRad); 
		m_rot = omegaQ *m_rot;  
		m_rot.Normalize();
	}

	if (m_movieTail)
	{
		Frame frame;
		frame.SetPos(m_pos);
		m_movieTail->SetProgramFrame(&frame);
		m_movieTail->Advance();
	}

	if (m_movieExploid)
	{
		Frame frame;
		if (m_exploidTime >0)
		{
			m_exploidTime -= G_Timer->GetStepTimeLimited();
			frame.SetPos(m_pos);
		}
		else
		{
			frame.SetPos(vec3(0,-100,0));
		}
		m_movieExploid->SetProgramFrame(&frame);
		m_movieExploid->Advance();
	}
	
	return false;
}
//预测球的位置 最长预测2秒 最多计算两次反弹 （deviation对于球的位置和速度引入误差）
bool PingPongBall::Predict(const vec3& paddleHomePos,vec3& resPos,vec3& resSpeed,float deviation)
{
	//deviation 柏林误差 持续一段时间后才改变 防止震荡
	resPos   = m_pos;
	resSpeed = m_speed;

	//return true;	//不思考球的反弹

	//反弹
	if(deviation>0)
	{
		Srand(deviation*100);
		resPos.x += m_maxSpeed*RandRange(-1.0f,1.0f)*0.1f;
		resPos.z += m_maxSpeed*RandRange(-1.0f,1.0f)*0.1f;
		//
		mat4 rot;
		rot.FromRotateY(deviation); 
		resSpeed = rot*resSpeed;
		//resSpeed.x += m_maxSpeed*RandRange(-1.0f,1.0f)*0.1f;
		//resSpeed.z += m_maxSpeed*RandRange(-1.0f,1.0f)*0.1f;
	}

	bool ret = false;

	float time = 0.02f;
	vec3 mov;
	//
	RayMovieCollideRes res;
	res.justBond = false;

	int reflectNum = 0;
	for (int t=0;t<100;t++) //最长预测2秒
	{
		mov = resSpeed * time;
		res.vStart = resPos;
		res.vEnd = resPos + mov;

		int hitType = HitNull;

		//hit paddle line
		if(hitType == 0)
		{
			if(  abs(paddleHomePos.z-resPos.z) < m_radius*2)
			{
				ret = true;
				break;
			}
		}


		//hit brick
		if(hitType == 0 && reflectNum<2)
		{
			for(int i = 0; i < G_PingPongGame->m_brickNum; i++)
			{
				PingPongBrick* theBrick = &G_PingPongGame->m_bricks[i];
				if(theBrick->m_movie 
					&& theBrick->m_movie->IsVisible()
					&& theBrick->m_movie->IntersectTray(res))
				{
					//todo 砖块按高度排序  砖块下面无支撑则下落砖块
					hitType = HitBrick;
					res.vEnd = res.resPos;
				}
			}
		}

		//hit desk
		if(hitType == 0 /*&& reflectNum<2*/)
		{
			if (G_PingPongGame->m_movieCollidePingpong->IntersectTray(res))
			{
				hitType = HitDesk;
				res.vEnd = res.resPos;
			}
		}

		//
		if (hitType==HitBrick || hitType==HitDesk)
		{
			resSpeed.Normalize();
			resSpeed = Reflect(resSpeed,res.resNorml)*m_maxSpeed;
			//添加反弹误差
			reflectNum++;
		}

		resPos += resSpeed * time;
	}

	////若桌面最多2次反弹，预测位置可能超出台面
	//if (resPos.x < )
	//{
	//}

	if (ret == false)
	{
		//回中线机动
		//resPos = paddleHomePos; //超时未到达
	}
	return ret;
}

void PingPongBall::PlayHitSound(HitType hitType)
{
	switch(hitType)
	{
	case HitNull:
		break;
	case HitPaddle:
		m_sound->PlaySound__("data/sound/event_shoot01.wav");
		break;
	case HitBrick:
		m_sound->PlaySound__("data/sound/event_glass.wav");
		break;
	case HitOut:
		m_sound->PlaySound__("data/sound/event_leveldown.wav");
		break;
	default:
		m_sound->PlaySound__("data/sound/ui_click.wav");
		break;
	}
}

玩家类：

//========================================================
//  @Date:     2016.05
//  @File:     SourceDemoClient/CarRacing/RacingCar.h
//  @Brief:     RacingCar
//  @Author:     LouLei
//  @Email:  twopointfive@163.com
//  @Copyright (Crapell) - All Rights Reserved
//========================================================
 

#ifndef  __PingPongPlayer__H__
#define  __PingPongPlayer__H__

#include "Rpg/MiniGame.h"
#include "AI/Entity/LogicCharacter.h"

namespace RendSys
{
	class Frame;
}


//对战模式 player、paddle只能在x轴方向移动
class PingPongPlayer: public LogicCharacter,public MiniPlayer
{
public:
	PingPongPlayer();
	virtual ~PingPongPlayer();

	virtual bool Start();
	//virtual bool Restart();
	//virtual bool Stop();
	virtual void Update();

	virtual void Render();

	int   m_side;   //队
	int   m_movDir; //移动方向
	vec3  m_homePos;//中心位置
	MovieClip* m_moviePaddle;  //球拍
	MovieClip* m_moviePaddleCollide; //球拍碰撞体
};


class PingPongPlayerRobot: public PingPongPlayer
{
public:
	PingPongPlayerRobot();
	virtual ~PingPongPlayerRobot();

	//virtual bool Start();
	////virtual bool Stop();
	virtual void Update();
	void SetWorkingWithAI(bool working);
	bool   m_workingWithAI;
	double m_thinkTime;
	float  m_deviation;  //误差，ai不能接太准
	float  m_hitOffset;  //击球角度

};


class PingPongPlayerRole: public PingPongPlayerRobot
{
public:
	PingPongPlayerRole();
	virtual ~PingPongPlayerRole();

	//virtual bool Start();
	////virtual bool Stop();
	virtual void Update();
	virtual void Render();

};

#endif

//========================================================
//  @Date:     2016.05
//  @File:     SourceDemoClient/CarRacing/RacingCar.cpp
//  @Brief:     RacingCar
//  @Author:     LouLei
//  @Email:  twopointfive@163.com
//  @Copyright (Crapell) - All Rights Reserved
//========================================================
 
#include "General/Pch.h"
#include "General/Window.h"
#include "PingPong/PingPongPlayer.h"
#include "PingPong/PingPongBall.h"
#include "PingPong/MiniGamePingPong.h"
#include "General/Timer.h"
#include "Rpg/SyncGameInfo.h"
#include "Sound/SoundManager.h"
#include "Packet/PacketMiniGame.h"
#include "Render/RendDriver.h"
#include "Render/MC_MovieClip.h"
#include "Input/InputMgr.h"
#include "General/Pce.h"

PingPongPlayer::PingPongPlayer()
{
	m_movDir = 0;
}
PingPongPlayer::~PingPongPlayer()
{
}


bool PingPongPlayer::Start()
{
	MiniPlayer::Start();
	m_movDir = 0; 
	return true;
}

void PingPongPlayer::Update()
{
	MiniPlayer::Update();
			
	mat3 matRot;

	if (m_moviePaddleCollide)
	{
		Frame paddleFrame;
		paddleFrame.SetPos(m_pos-m_homePos);
		m_moviePaddle->SetProgramFrame(&paddleFrame);

		m_moviePaddleCollide->SetProgramFrame(&paddleFrame);
	}

	{
		vec3 mov = vec3(100,0,0)*m_movDir* G_Timer->GetStepTimeLimited();
		m_pos += mov;

		{
			GetRenderCharacter()->PlayAnim("standing_WalkRight01");
			if(m_movDir == 0)
			{
				GetRenderCharacter()->SetAnimSpeed(10);
			}
			else if ((GetPlayerInfo()->roomSlot==0 && m_movDir == -1)
				||(GetPlayerInfo()->roomSlot==1 && m_movDir == 1)
				)
			{
				GetRenderCharacter()->SetAnimSpeed(-30);
			}
			else
			{
				GetRenderCharacter()->SetAnimSpeed(30);
			}
		}

		//
		if (GetPlayerInfo()->roomSlot==0)
		{
			matRot.FromRotateY(_PI);
		}
		else
		{
			matRot.FromRotateY(0);
		}
		
		GetRenderCharacter()->SetPos(m_pos);
		GetRenderCharacter()->SetRot(matRot);
		GetRenderCharacter()->Update();
	}
}

void PingPongPlayer::Render()
{
	LogicCharacter::Render();
}

//==================^_^
PingPongPlayerRobot::PingPongPlayerRobot()
:m_thinkTime(0)
,m_deviation(0)
,m_hitOffset(0)
{
	m_workingWithAI = true;
}
PingPongPlayerRobot::~PingPongPlayerRobot()
{
}
void PingPongPlayerRobot::Update()
{
	PingPongPlayer::Update();

	int lasMovDir = m_movDir;

	//预测球的到达位置
	vec3 predictPos,predictSpeed;
	G_PingPongGame->m_balls[0].Predict(m_homePos,predictPos,predictSpeed,m_deviation);

	if (G_Timer->GetAccumTime() - m_thinkTime >= 0.5f)
	{
		m_thinkTime = G_Timer->GetAccumTime();
		Srand(m_thinkTime);//Predict will fix seed
		m_deviation = RandRange(0.1f,0.2f);
		//预测最佳击球方向 碰砖得分 让对手来不及接球的位置（体力消耗）
		m_hitOffset = RandRange(-8.0f,8.0f);
	}

	float ballX = predictPos.x + m_hitOffset;

	if (ballX > m_pos.x+2)
	{
		m_movDir = 1;
	}
	else if (ballX < m_pos.x-2)
	{
		m_movDir = -1;
	}
	else
	{
		m_movDir = 0;
	}

	if (m_movDir!=lasMovDir)
	{
		C2SPacketMiniGameCmd packet;
		packet.WriteHeader();
		packet.WriteValue(CMD_PaddleMove);
		packet.WriteValue(GetPlayerInfo()->roomSlot);
		packet.WriteValue(m_pos);
		packet.WriteValue(m_movDir);
		G_MiniGame->SendPacketToOther(&packet);
	}
}
void PingPongPlayerRobot::SetWorkingWithAI(bool working)
{
	m_workingWithAI = working;
	if (m_workingWithAI==false)
	{

	}
}

//==================^_^
PingPongPlayerRole::PingPongPlayerRole()
{
	m_workingWithAI = false;
}
PingPongPlayerRole::~PingPongPlayerRole()
{
}

void PingPongPlayerRole::Update()
{
	if(m_workingWithAI)
	{
		PingPongPlayerRobot::Update();
		return;
	}

	PingPongPlayer::Update();


	int lasMovDir = m_movDir;

	//播放死亡动画期间不能移动
	//if (m_state == Running)
	{
		m_movDir = 0;
		if(G_PingPongGame->IsKeyPressed(KeyLeft))
		{
			if (GetPlayerInfo()->roomSlot==0)
			{
				m_movDir = -1;
			}
			else
			{
				m_movDir = 1;
			}
		}
		if(G_PingPongGame->IsKeyPressed(KeyRight))
		{
			if (GetPlayerInfo()->roomSlot==0)
			{
				m_movDir = 1;
			}
			else
			{
				m_movDir = -1;
			}
		}
		if(G_PingPongGame->IsKeyPressed(KeyUp))
		{
		}
		if(G_PingPongGame->IsKeyPressed(KeyDown))
		{
		}
		if(G_Keyboard->IsKeyPressed(DIK_SPACE)||G_Joystick->GetValueOfAxisRZ()<0)
		{
		}

		if (m_movDir)
		{
			vec3 localPos = m_pos - m_homePos;
			if (  (localPos.x <= -150&& m_movDir < 0)
				||(localPos.x >= 150 && m_movDir > 0)
				)
			{
				m_movDir = 0;
			}
		}

	}

	if (m_movDir!=lasMovDir)
	{
		C2SPacketMiniGameCmd packet;
		packet.WriteHeader();
		packet.WriteValue(CMD_PaddleMove);
		packet.WriteValue(GetPlayerInfo()->roomSlot);
		packet.WriteValue(m_pos);
		packet.WriteValue(m_movDir);
		G_MiniGame->SendPacketToOther(&packet);
	}

	//UpdateListener();

	if (m_liveNum < 0)
	{
		G_PingPongGame->SetGameState(MS_End);
	}
}

void PingPongPlayerRole::Render()
{
	PingPongPlayer::Render();
}

 游戏类：

//========================================================
//  @Date:     2016.05
//  @File:     SourceDemoClient/PingPong/MiniGamePingPong.h
//  @Brief:     MiniGamePingPong
//  @Author:     LouLei
//  @Email:  twopointfive@163.com
//  @Copyright (Crapell) - All Rights Reserved
//========================================================
 
#ifndef  __MiniGamePingPong__H__
#define  __MiniGamePingPong__H__

#include "Math/MathLib.h"
#include "Render/Texture.h"
#include "Rpg/MiniGame.h"
#include "Gui/GuiControlMisc.h"


class PingPongBrick;
class PingPongBall;
class PingPongPlayer;
class PingPongPlayerRole;

// 抽 盖 旋 特技 双打  
// 	   paddle size ( pixel) 	ball speed (pixels per second)	   score modification
//Easy	    72 - 180	            240 - 400	                          -20%
//Medium	72 - 144	            270 - 430	                            0
//Hard	    52 - 108	            300 - 450	                          +30%
enum MiniPingPongCmd
{
	CMD_BallMove  ,   
	CMD_PaddleMove,
	CMD_GameOver  ,
	CMD_Restart   ,
};
const char* PingPongCmdToString(int enumeration);

class MiniGamePingPong:public MiniGame
{
public:
	MiniGamePingPong();
	virtual ~MiniGamePingPong();

	virtual bool KeepResource(bool once,int& circle,String& nextTip);
	virtual bool Start();
	virtual bool Stop();
	virtual bool Render();
	virtual void RenderUI();
	virtual bool Update();
	virtual bool Free();
	virtual bool IsEnd();

	//三种类型结构
	virtual MiniPlayer*  CreatePlayer();
	virtual MiniPlayer*  CreateRobot ();
	virtual MiniPlayer*  CreateRole  ();

	PingPongPlayer* GetTurnPlayer();	

	//处理游戏网络命令包
	virtual int  ProcessPacketCmd(PacketBase* packet);
	//virtual const char* CmdToString(const char* stream,int len);

#define MaxBall 2
	//乒乓球
	PingPongBall*   m_balls;
	int             m_ballNum;

#define MaxBrick 64
	//砖块
	PingPongBrick*  m_bricks;
	int             m_brickNum;

	//球桌
	MovieClip*  m_movieCollidePingpong;

	PingPongPlayerRole* m_myRolePlayer;

	vec2I Offset;//左上角		


};
extern MiniGamePingPong* G_PingPongGame;
#endif 

//========================================================
//  @Date:     2016.05
//  @File:     SourceDemoClient/PingPong/MiniGamePingPong.cpp
//  @Brief:     MiniGamePingPong
//  @Author:     LouLei
//  @Email:  twopointfive@163.com
//  @Copyright (Crapell) - All Rights Reserved
//========================================================
 
#include "General/Pch.h"
#include "General/Window.h"
#include "General/Timer.h"
#include "Gui/GuiMgr.h"
#include "Gui/RpgGuis.h"
#include "Input/InputMgr.h"
#include "PingPong/PingPongPlayer.h"
#include "PingPong/MiniGamePingPong.h"
#include "Render/RendDriver.h"
#include "Render/Shader.h"
#include "PingPong/MiPingPong_PlayGui.h"
#include "Rpg/SyncGameInfo.h"
#include "Packet/PacketMiniGame.h"
#include "Net/PacketList.h"
#include "Render/Camera.h"
#include "Render/MC_MovieClip.h"
#include "PingPongBall.h"
#include "Render/MC_Misc.h"
#include "Rpg/RpgGame.h"
#include "General/Pce.h"
#include "General/Engine.h"


MiniGamePingPong* G_PingPongGame;

MiniGamePingPong::MiniGamePingPong()
{
	G_PingPongGame = this;
	CmdEnumToString = PingPongCmdToString;
}

MiniGamePingPong::~MiniGamePingPong()
{
	G_PingPongGame = NULL;
}

bool MiniGamePingPong::Start()
{
	m_myRolePlayer = NULL;
	if(!MiniGame::Start())
		return false;

	G_Engine->SetSplitScreenX(true,10,100);//由于桌子被放大，人眼距也要放大

	m_gameState= MS_Gamming;

	char buf[512];
	if (m_movieScene == NULL)
	{
		LoadConfig loader(LoadConfig::GenDonotReShrinkBound,true,true);
		m_movieScene = new RendSys::MovieClip;
		if(m_movieScene->LoadFromFile("data/minigame/pingpong/scene.movie",&loader)==false)
			return false;

		Frame frame;
		frame.SetPos(m_startPos);
		m_movieScene->SetProgramFrame(&frame);
		m_movieScene->Advance();

		m_movieCollidePingpong = m_movieScene->GetMovieClip("ground_collide");
		if (m_movieCollidePingpong==NULL)
		{
			return false;
		}
	}

	//
	m_balls = new PingPongBall[MaxBall];
	m_ballNum = 1;
	for (int i = 0; i < MaxBall; i++)
	{
		m_balls[i].ID = i;
		MovieClip* movie = m_movieScene->GetMovieClip("ball");
		m_balls[i].m_movieBall = movie;
		if (movie==NULL)
		{
			return false;
		}
		m_balls[i].m_radius = 8;
		m_balls[i].m_homePos = movie->GetCollideSys().m_center;
		m_balls[i].m_pos = m_balls[i].m_homePos;
		m_balls[i].m_speed = vec3(0,0,-m_balls[i].m_maxSpeed);

		movie->SetInheritParentFrame(false);
		movie->SetFrustumSkipEnable(false, Recursive);
		((MC_Frame*)movie)->ZeroFrames();
		movie->Advance();

		movie = m_movieScene->GetMovieClip("balltail");
		m_balls[i].m_movieTail = movie;
		if (movie)
		{
			movie->SetInheritParentFrame(false);
			movie->SetFrustumSkipEnable(false, Recursive);
			if(dynamic_cast<MC_Particle*>(movie))
				dynamic_cast<MC_Particle*>(movie)->ZeroFrames();
			movie->Advance();
		}
		

		movie = m_movieScene->GetMovieClip("exploid");
		m_balls[i].m_movieExploid = movie;
		m_balls[i].m_exploidTime = 0;
		if (movie)
		{
			movie->SetInheritParentFrame(false);
			movie->SetFrustumSkipEnable(false, Recursive);
			if(dynamic_cast<MC_Particle*>(movie))
				dynamic_cast<MC_Particle*>(movie)->ZeroFrames();
			movie->Advance();
		}
		
	}

	//
	m_bricks = new PingPongBrick[MaxBrick];
	m_brickNum = 0;
	for (int i = 0; i < MaxBrick; i++)
	{
		if(m_brickNum>=MaxBrick)
			break;
		sprintf(buf,"Brick%02d",i+1);
		MovieClip* movie = m_movieScene->GetMovieClip(buf);
		if (movie)
		{
			//m_bricks[m_brickNum].m_visible = true;
			m_bricks[m_brickNum].ID = m_brickNum;
			m_bricks[m_brickNum].m_movie = movie;
			m_bricks[m_brickNum].m_homePos = movie->GetCollideSys().m_center;
			m_bricks[m_brickNum].m_pos = movie->GetCollideSys().m_center;
			//movie->SetInheritParentFrame(false);
			//movie->SetFrustumSkipEnable(false, Recursive);
			//((MC_Frame*)movie)->ZeroFrames();
			movie->Advance();
			m_brickNum++;
		}
	}


	//
	for(int i = 0; i < m_allPlayerNum; i++)
	{
		MyRoomPlayerInfo* playerInfo = G_SyncMyRoomInfo->GetPlayerFromIndex(i);
		if(playerInfo)
		{
		}
	
		PingPongPlayer* thePlayer = dynamic_cast<PingPongPlayer*>(m_miniPlayer[i]);
		PingPongPlayerRobot* theRobot = dynamic_cast<PingPongPlayerRobot*>(thePlayer);
		PingPongPlayerRole* theRole = dynamic_cast<PingPongPlayerRole*>(thePlayer);
		if (theRole)
		{
			theRole->SetWorkingWithAI(false);
		}
		else if (theRobot)
		{
			theRobot->SetWorkingWithAI(true);
		}

		Style* style = G_StyleMgr->GetStyle(thePlayer->GetPlayerInfo()->style);
		thePlayer->SetStyle(style);
		thePlayer->GetRenderCharacter()->SetScale(vec3(3.0f,3.0f,3.0f));
		thePlayer->GetRenderCharacter()->PlayAnim("stand");

		//player->m_side = (i==0?SideRed:SideBlack);
		sprintf(buf,"paddle0%d",i+1);
		thePlayer->m_moviePaddle = m_movieScene->GetMovieClip(buf);
		if (thePlayer->m_moviePaddle==NULL)
		{
			return false;
		}

		sprintf(buf,"paddleCollide0%d",i+1);
		thePlayer->m_moviePaddleCollide = m_movieScene->GetMovieClip(buf);
		if (thePlayer->m_moviePaddleCollide==NULL)
		{
			return false;
		}
		thePlayer->m_moviePaddleCollide->SetVisible(false);

		thePlayer->m_homePos = thePlayer->m_moviePaddleCollide->GetCollideSys().m_center;
		thePlayer->SetPos(thePlayer->m_homePos);
	}



	//
	for(int i = 0; i < m_allPlayerNum; i++)
	{
		m_miniPlayer[i]->Start();
	}


	//进入miniplaygui，（选人、选关卡都已在房间里进行完毕)。
	if(GetStyle()) G_GuiMgr->PushGui(GetStyle()->playGUI.c_str(),GL_DIALOG);

	//设置摄像机
	CameraCtrlerTarget* ctrler = new CameraCtrlerTarget;
	ctrler->SetDistToTar(300);
	ctrler->SetTarPos(m_startPos);
	G_Camera->PushCtrler(ctrler);	
	if (m_myRolePlayer->GetPlayerInfo()->roomSlot==0)
	{
		G_Camera->SetEuler(0,-45,0);
	}
	else
	{
		G_Camera->SetEuler(180,-45,0);
	}
	//片头摄像机
	PushIntroCamera();

	return true;
}

bool MiniGamePingPong::Stop()
{
	G_Engine->SetSplitScreenX(false);
	SafeDeleteArray(m_balls);
	SafeDeleteArray(m_bricks);
	G_Camera->PopCtrler();
	{
		if (m_myPlayer && m_myPlayer->m_liveNum>0)
		{
			G_GuiMgr->GetGui<Rpg_ResultDialog>()->ShowResult(true);
		}
		else
		{
			G_GuiMgr->GetGui<Rpg_ResultDialog>()->ShowResult(false);
		}
		G_GuiMgr->PushGui("Rpg_ResultDialog",GL_DIALOGBOTTOM); 
	}
	return MiniGame::Stop();
}

MiniPlayer* MiniGamePingPong::CreatePlayer()
{
	return new PingPongPlayer;
}

MiniPlayer* MiniGamePingPong::CreateRobot()
{
	return new PingPongPlayerRobot;
}

MiniPlayer* MiniGamePingPong::CreateRole()
{
	m_myRolePlayer = new PingPongPlayerRole;
	return m_myRolePlayer;
}

PingPongPlayer* MiniGamePingPong::GetTurnPlayer()
{
	////return dynamic_cast<PingPongPlayer*>(m_miniPlayer[m_curSide]);
	//for(int i = 0; i < m_allPlayerNum; i++)
	//{
	//	PingPongPlayer* player = dynamic_cast<PingPongPlayer*>(m_miniPlayer[i]);
	//	if (player->m_side == m_curSide)
	//	{
	//		return player;
	//	}
	//}
	return NULL;
}


bool MiniGamePingPong::KeepResource(bool once,int& circle,String& nextTip)
{
	{
		G_SkeletonMgr->KeepAnim("data/modelcharacter/commonman/commonman_standing_WalkRight01.bone");
	}
	return true;
}




bool MiniGamePingPong::Render()
{
	G_RendDriver->EndUI();

	if (m_movieScene)
	{
		m_movieScene->RendClip();
	}

	//renderBalls
	for (int p = 0; p < m_ballNum; p++)
	{
		m_balls[p].Render();
	}

	//
	for(int i = 0; i < m_allPlayerNum; i++)
	{
		dynamic_cast<PingPongPlayer*>(m_miniPlayer[i])->Render();
	}

	G_RendDriver->BeginUI();
	G_RendDriver->Color4f(1,1,1,1);
	G_RendDriver->SetRenderStateEnable(RS_BLEND,true);
	G_RendDriver->BlendFunc(Blend_Filter);
	G_ShaderMgr->PushShader();

	G_RendDriver->EndUI();
	G_ShaderMgr->PopShader();
	return true;
}

void MiniGamePingPong::RenderUI()
{
	Render();
}
bool MiniGamePingPong::Update()
{
	m_turnTime += G_Timer->GetStepTimeLimited();
	if (m_movieScene)
	{
		m_movieScene->Advance();
	}

	for(int i = 0; i < m_allPlayerNum; i++)
	{
		dynamic_cast<PingPongPlayer*>(m_miniPlayer[i])->Update();
	}
	for (int i=0;i<m_ballNum;i++)
	{
		m_balls[i].Update(G_Timer->GetStepTimeLimited());
	}
	return true;
}

bool MiniGamePingPong::Free()
{
	MiniGame::Free();
	return true;
}

bool MiniGamePingPong::IsEnd()
{
	return m_gameState == MS_End;
}

int  MiniGamePingPong::ProcessPacketCmd(PacketBase* packet)
{
	int cmd;
	packet->ReadValue(cmd);
	switch(cmd)
	{
	case CMD_BallMove:
		{
			int ballID = 0;
			int hitType;
			int brickID;
			vec3 pos;
			vec3 speed;
			packet->ReadValue(ballID);
			packet->ReadValue(hitType);
			packet->ReadValue(brickID);
			packet->ReadValue(pos);
			packet->ReadValue(speed);
			m_balls[ballID].m_pos = pos;
			m_balls[ballID].m_speed = speed;
			m_balls[ballID].PlayHitSound((HitType)hitType);
			switch(hitType)
			{
			case HitBrick:
				m_bricks[brickID].m_movie->SetVisible(false);
				m_balls[ballID].m_exploidTime = 0.5f;
				break;
			default:
				break;
			}
		}
		break;	
	case CMD_PaddleMove:
		{
			int paddle = 0;
			vec3 pos;
			int  movDir;
			packet->ReadValue(paddle);
			packet->ReadValue(pos);
			packet->ReadValue(movDir);
			PingPongPlayer* thePlayer = (PingPongPlayer*)GetPlayerFromSlot(paddle);
			thePlayer->SetPos(pos);
			thePlayer->m_movDir = movDir;
		}
		break;
	case CMD_GameOver:
		{
	////		int turn = 0;
	////		packet->ReadValue(turn);
	////		m_winnerTurn = turn;
	////		m_turnTime = 0;
	////		m_gameStatus = Resulting;

	////		char sound[256];
	////		if (m_winnerTurn == m_lordTurn)
	////		{
	////			sprintf(sound,"data/sound/poker/play_lord_win");
	////		}
	////		else
	////		{
	////			sprintf(sound,"data/sound/poker/play_farmer_win");
	////		}
	////		if (m_winnerTurn%2) //
	////			strcat(sound,"_femail.wav");
	////		else
	////			strcat(sound,".wav");
	////		m_players[m_winnerTurn]->m_sound->PlaySound__(sound);

		}
		break;
	case CMD_Restart:
	////	Free();
	////	Start();
		break;
	}
	return 0;
}



const char* PingPongCmdToString(int enumeration)
{
	switch(enumeration)
	{
	case CMD_BallMove  :return "CMD_BallMove  ";		
	case CMD_PaddleMove:return "CMD_PaddleMove";		
	case CMD_GameOver  :return "CMD_GameOver  ";		
	case CMD_Restart   :return "CMD_Restart   ";			
	default             :return "CMD_unknow";
	}
	return "CMD_unknow";
}

乒乓球游戏电路设计
c99LYF的博客
06-30 3355
1.实验目的： 使用verilog HDL硬件描述语言乒乓球游戏电路设计 2.实验内容： 3.实验原理：按照视书上的内容，书写和运行代码，完成仿真操作 实验代码： （1） module pingp(clk, reset, push1, push0, led, decode1, decode2, decode3, decode4, clk_out); input clk, reset; input push1, push0; output [6:0] led, decode1, decode2
【TB作品】51单片机 Proteus仿真00016 乒乓球游戏机
q742971636的博客
07-07 1195
单片机: 用于控制LED的亮灭和处理按键输入。LED: 显示灯的状态。按键: 用于控制灯的反弹。串口连接: 实现两台单片机之间的数据通信。本课题设计了一个两机联机乒乓球游戏，通过串口通信实现两台单片机的同步显示和控制。系统设计合理，功能实现完整。测试结果表明各模块工作正常，满足设计要求。通过本次实验，对单片机串口通信、LED控制和按键检测有了更深入的理解和掌握。在未来的设计中，可以考虑增加更多功能，如增加难度调节、计分系统等，以提升游戏的趣味性和挑战性。
python小游戏——乒乓球大战2.0版本の双人联机对战功能的实现
timberman666的博客
03-29 991
python小游戏——乒乓球大战2.0版本の双人联机对战功能的实现
虚拟乒乓球连接不上服务器,虚拟乒乓球联机版
weixin_34551614的博客
08-09 2338
虚拟乒乓球是一款相当好用的乒乓球游戏，在游戏之中玩家们需要操控自己的乒乓球拍，和自己的好友进行对战，在里面只需要你们联机进入一个房间，就能在手机上也来一场真实的乒乓球对决，谁才能狗成为真正的乒乓球球手呢，喜欢这款乒乓游戏的玩家们就下载这个联机版本的游戏和自己的朋友一起玩玩看吧，具体如下：虚拟乒乓球联机版游戏介绍1.虚拟乒乓球是唯一一款3D实时物理效果和支持在线对战的乒乓球游戏。2.在游戏之中玩家们...
JAVA练习小游戏——本地双人联机乒乓球小游戏
timberman666的博客
06-15 793
JAVA练习小游戏——本地双人联机乒乓球小游戏
乒乓球游戏电路
twoyu的博客
07-01 2985
乒乓球游戏电路 1.设计的目的： 随着科学技术日益迅速的发展，数字系统己深入到生活的各个方面，它具有技术效果好、经济效益高、技术先进、造价低、可靠性高、维修方便等许多优点。所以我们更应当熟练掌握数字系统的设计，以便将来更好地应用在实践方面。下面通过学过的venlog HDL硬件描述语言，设计一款乒乓球游戏电路，通过给定的一个信号来满足灯的亮、灭与移动的速度，进而来实现迷你型的乒乓球游戏。 2．课程设计题目描述和要求 该游戏电路的实际效果图如下所示。游戏共有两人，分别为甲方和乙方，双方轮流发球，按下按键表示发
51单片机 Proteus仿真 联机乒乓球游戏机
q742971636的博客
07-15 1165
基于51单片机protues仿真的联机乒乓球游戏分离版设计（仿真图、源代码）
最新发布
06-15
基于51单片机protues仿真的联机乒乓球游戏分离版设计（仿真图、源代码） 设计题目：两机联机乒乓球游戏图1课题任务示意图 具体说明： （1）共有两个单片机，每个单片机接8个LED和1个按键，两个单片机使用串口连接。...
Python乒乓球小游戏，可以双人本地联机，也可与人机对战
01-24
Python乒乓球小游戏，可以双人本地联机，也可与人机对战 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用...
Python乒乓球游戏实现本地双人联机及人机对战
资源摘要信息:"本资源提供了一个使用Python语言开发的乒乓球小游戏项目，具有双人本地联机模式和人机对战模式。该项目是一个优秀的学习资源，适合计算机科学与技术、人工智能、通信工程、自动化、电子信息等相关专业...
[pygame] pygame设计联机对战桌游（一）
wxlxy316的博客
02-10 2537
[pygame] pygame设计联机对战桌游（一）fddsff fd sdf dsff sdfsdf
迷宫随机生成算法
twopointfive的专栏
03-23 6259
迷宫随机生成算法
拳皇格斗游戏3D版源代码
twopointfive的专栏
04-08 5724
这是多年前写的一个格斗小游戏，类似拳皇的玩法。今天把代码贴出来。
联机棋类游戏《憋尿罐》实现源码
twopointfive的专栏
05-20 5435
自己写的一个棋类小游戏，支持3D和2D显示，支持联机对弈和ai对弈。这是上小学时经常玩的一个小游戏，不知道叫什么名字，我们那叫“憋尿罐”。分为两个阶段，前期可以用 ‘顶’、‘夹‘、’挑’ 来吃棋子，后期只剩一个棋子时有点像民间游戏围虎棋，将最后一个棋子围入‘尿罐’即胜利。
随机音乐生成器
twopointfive的专栏
02-10 5046
全部源代码如下：（简单的框架，具体算法有待加强） #include "stdafx.h" #include <windows.h> #include <mmsystem.h> #pragma comment(lib,"Winmm.lib") //音节 class Syllable { public: long phoneme;//音阶 音符 long tambe...
扑克类游戏斗地主、蜘蛛纸牌源码
twopointfive的专栏
04-11 4254
这是移植自网上搜索到的两个扑克类游戏，原游戏是MFC做的，移植到了D3d中。两者的渲染方式不同，架构有所改变。 扑克类游戏主要是数据结构要列好，算法都是初级的入门算法，繁琐但是并不困难。继续给游戏添加了联机和自动出牌功能。
魔塔类游戏实现源码及关卡生成
twopointfive的专栏
06-09 3264
《魔塔》》是一种策略类的固定数值RPG游戏。 本篇主要讨论红塔游戏，侧重于路线的寻找。 一般RPG类游戏可以使用脚本语言来编写任务剧情，这样可以使得剧情更复杂和灵活多变，这同样适用于魔塔游戏。但是为了自动生成关卡的目的，还是使用数据驱动的方法来实现游戏逻辑，这样方便编写搜索算法。 游戏关卡的设计一般可以使用编辑器来编辑，编辑器很好实现，但要设计一个耐玩的关卡似乎不太简单，后面会做一些自动生成的尝试。...
游戏动画引擎 -（Crapell Game Engine Design - animation）
twopointfive的专栏
01-25 2909
动画重定向和逆向运动学
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值