联机带AI版3D桌球游戏源码

已于 2022-04-27 12:29:24 修改
阅读量2.3k 收藏 5
点赞数 1
分类专栏： 游戏开发 文章标签： 游戏 算法
于 2022-04-26 20:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/twopointfive/article/details/124434362
版权

这是款联机版3D桌球游戏，带有自动挂机算法，支持单机npc和联网对战。添加了瞄准辅助线功能。统一的架构，可以方便的嵌入rpg中。选手模型可以使用mmorpg中的玩家的模型。

选手动画暂时只做了一个站姿击球和一个坐姿击球，当选手和桌面发生碰撞时会从站姿切换到坐姿，中间自动添加过渡动画。手部动画配合拉杆力度使用计算预制关键帧的方法。鼠标控制拉杆角度选手移动位置时，脚步动作使用上下分身控制不同的动作。

碰撞计算是离散的，没有使用物理引擎，没有考虑到转动惯量的影响，这里是一个可以改进的地方（目前默认击球点在球的正中部位）。

AI算法，寻找最佳目标球（白色球-目标球-某个袋 - 距离之和越小越好， 夹角越小越好，行进路线上不能有干扰球）。

球的碰撞及运动只同步了初始状态， 后续的运动本机模拟，正常情况下简单的实现了同步。碰撞结果也暂时本机模拟，有待host处理。 同步了玩家瞄准动画。

  

 

 

源代码：

 游戏类

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

#ifndef  __MiniGameBilliards__H__
#define  __MiniGameBilliards__H__

#include "Billiards/BilliardsBall.h"
#include "Rpg/MiniGame.h"
#include "Render/Texture.h"

#define BallCount 16    //球个数
#define pocketRadius 3  //球袋半径

//球ID
enum BallID
{
	WhiteBall = 0,
	yellow_solidBall,
	blue_solidBall,
	red_solidBall,
	purple_solidBall,
	orange_solidBall,
	green_solidBall,
	brown_solidBall,

	BlackBall = 8,

	yellow_stripeBall,
	blue_stripeBall,
	red_stripeBall,
	purple_stripeBall,
	orange_stripeBall,
	green_stripeBall,
	brown_stripeBall,
};

//队
enum TeamSide
{
	TeamSide_Null=-1,
	TeamSide_Stripe = 0,
	TeamSide_Solid,
};

//为了避免计算误差引起的不同步，otherplayer击球引发的ball rolling计算在本机不处理碰撞，碰撞信息由otherplayer发过来，否则小的角度误差导致不同步。
enum MiniBilliardsCmd
{
	CMD_PrepareShoot,//准备击球 同步所有球的位置
	CMD_StickMove,   //同步当前玩家杆子角度
	CMD_ShootStick  ,//击球
	//CMD_BallMove    ,//球碰撞及运动 自己模拟即可无需同步
	CMD_BallIn      ,//进球  同步结果避免差异或外挂    
	CMD_GameOver    ,
	CMD_Restart     ,
};
const char* BilliardsCmdToString(int enumeration);

class BilliardsPlayer;
class BilliardsPlayerRole;
class SoundChannel;

class MiniGameBilliards:public MiniGame
{
public:
	MiniGameBilliards();
	virtual~MiniGameBilliards();
	virtual bool Start();
	virtual bool Stop();
	virtual bool Render();
	virtual void RenderUI();
	virtual bool Update();
	virtual bool Free();
	virtual bool KeepResource(bool once,int& circle,String& nextTip);

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

	void DeflectBalls(BilliardsBall& left, BilliardsBall&right);
	void PocketInBall(BilliardsBall& ball,int pocket);

	//某方进球数
	int  InPocketNum(TeamSide side);

	//桌台边框碰撞点
	vec3 GetBoundPosFromInner(const vec3& pos,const vec3& dir);
	vec3 GetBoundPosFromOut(const vec3& pos,const vec3& dir);

	//处理游戏网络命令包
	virtual int  ProcessPacketCmd(PacketBase* packet);
	//virtual const char* CmdToString(const char* stream,int len);
	//发送推杆消息
	bool SendShootStick(float shootAngleRad,float shootPower);
	//发送瞄准动画消息
	bool SendStickMove(float shootAngleRad,float stickDistance);

	bool ShootStick(float shootAngleRad,float shootPower);

	bool SendPrepareShooting();

	//获得球所属的 实心还是花
	bool IsTeamSide(BallID id,TeamSide side);

	BilliardsPlayer* GetTurnPlayer();	

	enum GameState
	{
		PrepareShooting,
		BallRolling,
		Shooting,
	};
	GameState m_GameState;
	BilliardsPlayerRole* m_myRolePlayer;
	BilliardsBall    m_balls[BallCount];

	vec3  m_worldDeskMin;
	vec3  m_worldDeskMax;
	vec3  m_worldDeskCen;

	vec3  WhiteStartPos;
	vec3  PocketPos[6];

	int   m_curTurn;
	float m_prepareTime;           //准备时间
	float m_simulateTime;

private:
	RendSys::MovieClip* m_movieStick[2];
	RendSys::MovieClip* m_movieBalls[BallCount];

	RendSys::MovieClip* m_movieBestPocket;

	TexturePtr m_ballIcons[BallCount];
	TexturePtr m_powerBar;
	TexturePtr m_lazer;

	//黑8是否进洞
	bool       m_blackInPacket; 
	float      m_oldFov;
};

extern MiniGameBilliards* G_BilliardsGame;

#endif


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

#include "General/Pch.h"
#include "General/General.h"
#include "General/StringUtil.h"
#include "General/Timer.h"
#include "General/Window.h"
#include "Gui/GuiMgr.h"
#include "Gui/RpgGuis.h"
#include "Billiards/MiBilliardsBall_PlayGui.h"
#include "Billiards/BilliardsPlayer.h"
#include "Input/InputMgr.h"
#include "Billiards/MiniGameBilliards.h"
#include "Math/MathLibAdvance.h"
#include "Render/Camera.h"
#include "Render/Font.h"
#include "Render/MC_Misc.h"
#include "Render/RendDriver.h"
#include "Render/Shader.h"
#include "Packet/PacketMiniGame.h"
#include "Rpg/SyncGameInfo.h"
#include "Sound/ChannelSound.h"
#include "Sound/SoundManager.h"
#include "General/Pce.h"
#include "General/Option.h"



class CameraCtrlerBilliards:public CameraCtrlerTarget
{
public:
	CameraCtrlerBilliards();
	virtual void  Update();
	float m_dir;
	float m_pitch;
};

const char* BilliardsCmdToString(int enumeration)
{
	switch(enumeration)
	{
	case CMD_PrepareShoot:return "CMD_PrepareShoot";		
	case CMD_ShootStick  :return "CMD_ShootStick  ";		
//	case CMD_BallMove    :return "CMD_BallMove    ";		
	case CMD_BallIn      :return "CMD_BallIn      ";		
	case CMD_GameOver    :return "CMD_GameOver    ";		
	case CMD_Restart     :return "CMD_Restart     ";		     		       
	default             :return "CMD_unknow";
	}
	return "CMD_unknow";
}


CameraCtrlerBilliards::CameraCtrlerBilliards()
{
	m_dir = 0;
	m_pitch = -40;
}


void CameraCtrlerBilliards::Update()
{
	if (G_BilliardsGame==NULL)
	{
		//游戏结束
		return;
	}
		
	//CheckBoderRot(-HALFPI/8,HALFPI/3);
	CheckWheelDis(40,150);
	//static float keyMoveSpeed = 100;
	static float mouseRotSpeed = 10;

	Camera* camera = G_Camera;
	float time = G_Timer->GetStepTime();

	//camera->SetRot(0,-40,0);

	//rotate
	//#ifdef WIN32APP
	if (G_Mouse->IsButtonPressed(MOUSE_RIGHT))
	{
		vec2 p = G_Mouse->GetMove();
		p *= -1;
		float dir = p.x*time*mouseRotSpeed;
		//camera->AddRot(dir,pitch,0);
		m_dir += dir;
	
		if (m_dir>180)
		{
			m_dir = -180;
		}
		else if (m_dir<-180)
		{
			m_dir = -180;
		}
	}
	else if (G_Mouse->IsButtonPressed(MOUSE_LEFT))
	{
		vec2 p = G_Mouse->GetMove();
		p *= -1;
		float dir = p.x*time*mouseRotSpeed;
		//camera->AddRot(dir,pitch,0);
		m_dir += dir;

		if (m_dir>180)
		{
			m_dir = -180;
		}
		else if (m_dir<-180)
		{
			m_dir = 180;
		}

		float pitch = p.y*time*mouseRotSpeed;
		m_pitch += pitch;
		if (m_pitch<-80)
		{
			m_pitch = -80;
		}
		else if (m_pitch>-20)
		{
			m_pitch = -20;
		}
	}

	G_Camera->SetEuler(m_dir,m_pitch,0);
	//#endif
	//move
	vec3 tarPos = G_BilliardsGame->m_worldDeskCen;
	//tarPos = m_balls[WhiteBall].m_pos;
	SetTarPos(tarPos);
	camera->SetEyePos(tarPos - camera->GetHeadDir()*m_distToTar);

}

MiniGameBilliards *G_BilliardsGame;

MiniGameBilliards::MiniGameBilliards()
    : m_myRolePlayer(NULL)
{
    G_BilliardsGame = this;
	CmdEnumToString = BilliardsCmdToString;
    for (int i = 0; i < BallCount; i++)
    {
        m_movieBalls[i] = NULL;
    }
	for (int i = 0; i < 2; i++)
	{
		m_movieStick[i] = NULL;
	}

}

MiniGameBilliards::~MiniGameBilliards()
{
	G_BilliardsGame = NULL;
}

bool MiniGameBilliards::Start()
{
	m_myRolePlayer = NULL;
	m_oldFov = G_Option->m_defaultFov;
    if(!MiniGame::Start())
        return false;

	vec3 localDeskMin;
	vec3 localDeskMax;

    if (m_movieScene == NULL)
    {
        LoadConfig loader(LoadConfig::GenDonotReShrinkBound, true, true);
        m_movieScene = new RendSys::MovieClip;
        m_movieScene->LoadFromFile("data/minigame/billiards/desk.movie", &loader);
        m_movieScene->Advance();

		localDeskMin = m_movieScene->GetMovieClip("tag_min")->GetCollideSys().m_min;
		localDeskMax = m_movieScene->GetMovieClip("tag_max")->GetCollideSys().m_min;
        vec3 min = localDeskMin;
        vec3 max = localDeskMax;
        //坐标系转换后可能不对了
        if (localDeskMax.y < min.y)
        {
            localDeskMax.y = min.y;
        }
        if (localDeskMin.y > max.y)
        {
            localDeskMin.y = max.y;
        }
        if (localDeskMax.z < min.z)
        {
            localDeskMax.z = min.z;
        }
        if (localDeskMin.z > max.z)
        {
            localDeskMin.z = max.z;
        }

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

	for (int i = 0; i < 2; i++)
	{
		if (m_movieStick[i] == NULL)
		{
			char buf[128];
			sprintf(buf,"data/minigame/billiards/stick0%d.movie",i+1);
			LoadConfig loader(LoadConfig::GenDonotReShrinkBound, true, true);
			m_movieStick[i] = new RendSys::MovieClip;
			m_movieStick[i]->LoadFromFile(buf, &loader);
			m_movieStick[i]->SetFrustumSkipEnable(false, Recursive);
			m_movieStick[i]->Advance();
		}
	}
 
	m_movieBestPocket = m_movieScene->GetMovieClip("bestPocket");

    if (m_movieScene->IsLoadComplete() == false)
    {
        m_gameState = MS_End;
        return false;
    }

	//
	for (int b = 0; b < BallCount; b++)
	{
		m_balls[b].Reset();
		m_balls[b].m_id = (BallID)b;
	}

	m_blackInPacket = false;
	m_prepareTime = 0;

    m_balls[0].SetPos(vec3(0.0f, 0 , localDeskMin.z - localDeskMin.z / 3));

    //初始靠的太紧，碰撞不平衡
    m_balls[15].SetPos(vec3(7.0f, 0 , 27.0f));
    m_balls[1 ].SetPos(vec3(3.5f, 0 , 27.0f));
    m_balls[14].SetPos(vec3(0.0f, 0 , 27.0f));
    m_balls[13].SetPos(vec3(-3.5f, 0 , 27.0f));
    m_balls[2 ].SetPos(vec3(-7.0f, 0 , 27.0f));

    m_balls[3 ].SetPos(vec3(5.25, 0 , 23.5f));
    m_balls[12].SetPos(vec3(1.75, 0 , 23.5f));
    m_balls[4 ].SetPos(vec3(-1.75, 0 , 23.5f));
    m_balls[11].SetPos(vec3(-5.25, 0 , 23.5f));

    m_balls[10].SetPos(vec3(3.5f, 0 , 20.0f));
    m_balls[8].SetPos(vec3(0.0f, 0 , 20.0f));//black 在中间
    m_balls[5].SetPos(vec3(-3.5f, 0 , 20.0f));

    m_balls[6].SetPos(vec3(1.75, 0 , 16.5f));
    m_balls[7].SetPos(vec3(-1.75, 0 , 16.5f));

    m_balls[9].SetPos(vec3(0.0f, 0 , 13.0f));


	m_worldDeskMin = m_startPos + localDeskMin;
	m_worldDeskMax = m_startPos + localDeskMax;
	m_worldDeskCen = (m_worldDeskMin+m_worldDeskMax)*0.5f;
	m_simulateTime = 0;

	for (int b = 0; b < BallCount; b++)
	{
		m_balls[b].m_pos += m_worldDeskCen;
	}

	WhiteStartPos = m_balls[0].GetPos();

	PocketPos[0] = vec3(m_worldDeskMin.x,  m_worldDeskCen.y, m_worldDeskMax.z);
	PocketPos[1] = vec3(m_worldDeskMax.x,  m_worldDeskCen.y, m_worldDeskMax.z);
	PocketPos[2] = vec3(m_worldDeskMin.x,  m_worldDeskCen.y, m_worldDeskCen.z);
	PocketPos[3] = vec3(m_worldDeskMax.x,  m_worldDeskCen.y, m_worldDeskCen.z);
	PocketPos[4] = vec3(m_worldDeskMin.x,  m_worldDeskCen.y, m_worldDeskMin.z);
	PocketPos[5] = vec3(m_worldDeskMax.x,  m_worldDeskCen.y, m_worldDeskMin.z);
	

	//==================^_^==================^_^==================^_^==================^_^

    for (int i = 0; i < m_allPlayerNum; i++)
    {
		BilliardsPlayer* thePlayer = dynamic_cast<BilliardsPlayer*>(m_miniPlayer[i]);

		thePlayer->m_turn = i;

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

		thePlayer->Start();
    }


	m_GameState = PrepareShooting;
    // First player in list starts the game
    dynamic_cast<BilliardsPlayer*>(m_miniPlayer[0])->m_shootNum = 1;
    m_curTurn = 0;

	//设置摄像机
	G_Camera->PopCtrler();
	CameraCtrlerBilliards* ctrl = new CameraCtrlerBilliards;
	ctrl->SetTarPos(m_worldDeskCen);
	G_Camera->PushCtrler(ctrl);
	//片头摄像机
	PushIntroCamera();

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

	G_Option->m_defaultFov = 60;
    return true;

}
MiniPlayer* MiniGameBilliards::CreatePlayer()
{
	return new BilliardsPlayer;
}

MiniPlayer* MiniGameBilliards::CreateRobot()
{
	return new BilliardsPlayerRobot;
}

MiniPlayer* MiniGameBilliards::CreateRole()
{
	m_myRolePlayer = new BilliardsPlayerRole;
	return m_myRolePlayer;
}
bool MiniGameBilliards::Stop()
{
	//
	G_Option->m_defaultFov = m_oldFov;

	G_Camera->PopCtrler();

    for (int i = 0; i < BallCount; i++)
    {
        SafeDelete(m_movieBalls[i]);
    }
	for (int i = 0; i < 2; i++)
	{
		SafeDelete(m_movieStick[i]);
		//SafeDelete(m_miniPlayer[i]);
	}

	G_GuiMgr->PopGui("MiBilliardsBall_PlayGui");

	
	{
		if (m_myRolePlayer && m_myRolePlayer->m_turn==m_curTurn)
		{
			G_GuiMgr->GetGui<Rpg_ResultDialog>()->ShowResult(true);
		}
		else
		{
			G_GuiMgr->GetGui<Rpg_ResultDialog>()->ShowResult(false);
		}
		G_GuiMgr->PushGui("Rpg_ResultDialog",GL_DIALOGBOTTOM); 
	}
	MiniGame::Stop();

    return true;
}

bool MiniGameBilliards::Render()
{
    m_movieScene->RendClip();

	//绘制玩家
	for (int i = 0; i < m_allPlayerNum; i++)
	{
		m_miniPlayer[i]->Render();
	}

    //绘制球  todo 调出高光效果 反射贴图 阴影贴图
    {
		mat4 mat;
        for (int p = 0; p < BallCount; p++)
        {
            G_RendDriver->PushMatrix();
			//G_RendDriver->LoadIdentity(); //ogl 没有单独的world 会把modelview一起清除
			m_balls[p].m_rot.ToMatrix(mat);
			mat.SetTranslate(m_balls[p].m_pos);
			G_RendDriver->MultMatrix(mat);

            m_movieBalls[p]->Advance();
            m_movieBalls[p]->RendClip();

            G_RendDriver->PopMatrix();
        }
    }

    if (m_GameState == PrepareShooting
		||m_GameState == Shooting)
    {
        //绘制球杆 todo billboard绘制更好看
        {
            G_RendDriver->PushMatrix();
            G_RendDriver->Translatef(m_balls[WhiteBall].m_pos.x, m_balls[WhiteBall].m_pos.y, m_balls[WhiteBall].m_pos.z);
            G_RendDriver->Rotatef(-GetTurnPlayer()->m_shootAngleRad * RAD2DEG + 90, 0.0f, 1.0f , 0.0f);
            G_RendDriver->Rotatef(-5.5f, 1.0f, 0.0f , 0.0f);
			//G_RendDriver->Rotatef(11.5f, 1.0f, 0.0f , 0.0f);
            G_RendDriver->Translatef(0.0f, 0.0f, GetTurnPlayer()->m_stickDistance*0.05f);
            m_movieStick[m_curTurn]->Advance();
            m_movieStick[m_curTurn]->RendClip();
            G_RendDriver->PopMatrix();
        }

		if(G_ShaderMgr)G_ShaderMgr->PushShader();

        //绘制指导线
        if (GetTurnPlayer()->m_useLazer == true
			&&( G_RendDriver->RendPassStepFlag==NormalPass|| G_RendDriver->RendPassStepFlag==PreRenderMrt)
			)
        {
			G_RendDriver->Color4f(1.0f, 1.0f, 1.0f, 0.5f);
			m_lazer->Bind();

			vec3  tar = GetBoundPosFromInner(m_balls[WhiteBall].m_pos,vec3(-cos(GetTurnPlayer()->m_shootAngleRad),0,-sin(GetTurnPlayer()->m_shootAngleRad)));

			float nearDist = 99999;
			vec3  whitePos = m_balls[WhiteBall].m_pos;
			vec3  dir = tar-whitePos; dir.Normalize();
			vec3  refDir;
			BilliardsBall* tarBall = NULL;
			Sphere sphere;
			sphere.r = m_balls[WhiteBall].m_radius*2;
			vec3 res;
			for (int p = 0; p < BallCount; p++)
			{
				if (p==WhiteBall)
				{
					continue;
				}
				sphere.c = m_balls[p].m_pos;
				float t = 0;
				if (IntersectRaySphere(whitePos,dir,sphere,t,res) && t<nearDist)
				{
					tarBall = &m_balls[p];
					nearDist = t;
					refDir = tarBall->m_pos - res;
					refDir.Normalize();
					tar = res;
					//
					//tar += refDir*m_balls[WhiteBall].m_radius;
				}
			}

			float tiley = (whitePos - tar).Length()/2;

			vec2 tex[6];
			tex[0] = vec2(0    ,tiley);
			tex[1] = vec2(0.25f ,tiley);
			tex[2] = vec2(0    ,0);
			tex[3] = vec2(0    ,0);
			tex[4] = vec2(0.25f,tiley);
			tex[5] = vec2(0.25f,0);
			//变色
			if (GetTurnPlayer()!=m_myRolePlayer)
			{
				for(int i=0;i<6;i++)
				{
					tex[i].x += 0.25f;
				}
			}
 
			//绘制指导线
			vec3 pos[6];
			vec3 left = dir.Cross(vec3(0,1,0));
			left.Normalize();
			left *= m_balls[WhiteBall].m_radius*0.8f;
			vec3 lev(0,-0.1f,0);
			pos[0] = whitePos - left + lev;
			pos[1] = whitePos + left + lev;
			pos[2] = tar - left + lev;
			pos[3] = tar - left + lev;
			pos[4] = whitePos + left + lev;
			pos[5] = tar + left + lev;
		
			G_RendDriver->RendTrigon(2,pos, tex);

			//绘制反射指导线1
			if (tarBall)
			{
				vec3 refTar = GetBoundPosFromInner(tar,refDir);
				float tiley = (tar- refTar).Length()/2;
				for(int i=0;i<6;i++)
				{
					if (tex[i].y>0)
					{
						tex[i].y = tiley;
					}
				}
				vec3 left = refDir.Cross(vec3(0,1,0));
				left.Normalize();
				left *= m_balls[WhiteBall].m_radius*0.8f;
				vec3 lev(0,-0.2f,0);
				pos[0] = tar - left + lev;
				pos[1] = tar + left + lev;
				pos[2] = refTar-left*0.5f + lev;
				pos[3] = refTar-left*0.5f + lev;
				pos[4] = tar + left + lev;
				pos[5] = refTar+left*0.5f + lev;
				G_RendDriver->RendTrigon(2,pos, tex);
			}

			//绘制反射指导线2
			//....

			//绘制碰撞点
			if (tarBall)
			{
				float tiley = 1;
				tex[0] = vec2(0.5f  ,tiley);
				tex[1] = vec2(0.75f ,tiley);
				tex[2] = vec2(0.5f  ,0);
				tex[3] = vec2(0.5f  ,0);
				tex[4] = vec2(0.75f ,tiley);
				tex[5] = vec2(0.75f ,0);
				vec3 left = refDir.Cross(vec3(0,1,0));
				left.Normalize();
				left *= m_balls[WhiteBall].m_radius;
				vec3 front = refDir*m_balls[WhiteBall].m_radius;
				pos[0] = tar - left - front;
				pos[1] = tar + left - front;
				pos[2] = tar - left + front;
				pos[3] = tar - left + front;
				pos[4] = tar + left - front;
				pos[5] = tar + left + front;
				G_RendDriver->RendTrigon(2,pos, tex);
			}
        }

		if(G_ShaderMgr)G_ShaderMgr->PopShader();

		//提示ai最佳袋子
		BilliardsPlayerRobot* robot = dynamic_cast<BilliardsPlayerRobot*>(GetTurnPlayer());
		Frame frame;
		if (robot && robot->m_workingWithAI)
		{
			frame.SetPos(PocketPos[robot->m_bestPocket] - m_startPos);
		}
		else
		{
			frame.SetPos(vec3());
		}
		m_movieBestPocket->SetProgramFrame(&frame);
    }

    return true;
}

void MiniGameBilliards::RenderUI()
{
	MiniGame::RenderUI();
	///
	G_RendDriver->BeginUI();
	G_RendDriver->Color4f(1,1,1,1);
	G_RendDriver->SetRenderStateEnable(RS_BLEND,true);
	G_RendDriver->BlendFunc(Blend_Filter);
	//G_ShaderMgr->PushShader();

    char shotBuffer[20];
    sprintf(shotBuffer, "%d", GetTurnPlayer()->m_shootNum);

    G_RendDriver->Color3f(1.0f, 1.0f, 1.0f);
    G_FontMgr->TextAtPos(vec2(80, 15), "Player: ");
    G_FontMgr->TextAtPos(vec2(80, 45), "Shots: ");

    G_RendDriver->Color3f(0.8f, 0.8f, 0.8f);
    G_FontMgr->TextAtPos(vec2(160, 15), GetTurnPlayer()->GetPlayerInfo()->playerName);
    G_FontMgr->TextAtPos(vec2(160, 45), shotBuffer);

    // 绘制玩家头像 move to ui

    //力度条
    if (m_GameState == PrepareShooting
		||m_GameState == Shooting)
    {
		RectF rect(130, 175, 180, 15);
		if (m_curTurn==1)
		{
			rect = RectF(G_Window->m_iWidth-130-180, 175, 180, 15);
		}
		RectF rect2(rect.x+1, rect.y+1, rect.width-2, rect.height-2);
        G_RendDriver->SetRenderStateEnable(RS_TEXTURE_2D, false);
        G_RendDriver->Color3f(1.0f, 1.0f, 0.0f);
        G_RendDriver->DrawRect(rect);

        G_RendDriver->Color3f(0.0f, 0.0f, 0.5f);
        G_RendDriver->DrawRect(rect2);

        G_RendDriver->Color3f(1.0f, 1.0f, 1.0f);
        G_RendDriver->SetRenderStateEnable(RS_TEXTURE_2D, true);
        m_powerBar->Bind();
        G_RendDriver->DrawTextureRect(RectF(rect2.x, rect2.y, GetTurnPlayer()->m_shootPower*rect2.width/100, rect2.height), RectF(0, 0, GetTurnPlayer()->m_shootPower / 100.0f, 1));
    }

    //已经进洞的球.
	if(GetTurnPlayer() && GetTurnPlayer()->m_teamSide>=0)
	{
		RectF rect(200+m_curTurn*300, 140, 32, 32);
		int startBall = (1-GetTurnPlayer()->m_teamSide)*8+1;
		for (int k = startBall; k < startBall+7; k++)
		{
			if (m_balls[k].m_inPocket == true)
			{
				G_RendDriver->Color3f(1.0f, 1.0f, 1.0f);
				m_ballIcons[k]->Bind();
				G_RendDriver->DrawTextureRect(rect);
				rect.x += 36.0f;
			}
		}
	}
	//G_ShaderMgr->PopShader();
}

bool MiniGameBilliards::Update()
{
    if (m_movieScene == NULL)
    {
        return false;
    }

    m_movieScene->Advance();

	switch(m_GameState)
	{
	case BallRolling:
		{
			bool moving = true;
			m_simulateTime += G_Timer->GetStepTimeLimited(); 

			//多个更新步模拟，避免单帧移动过大出现多次碰撞
			//减小模拟间隔 或使用连续性检测才能提高 robot的瞄准率

			float steptime = 0.002f;
			while(m_simulateTime>=steptime)
			{
				//steptime = min(0.01f,frametime);//最后一个剩余时间累积到下一帧,使得各方碰撞结果尽量几乎一致（更新时间步一致）
				m_simulateTime -= steptime;
				//球和球碰撞
				for (int b = 0; b < (BallCount - 1); b++)
				{
					for (int t =b+1; t < BallCount; t++)
					{
						DeflectBalls(m_balls[b], m_balls[t]);
					}
				}

				//球和洞碰撞
				for (int b = 0; b < BallCount; b++)
				{
					BilliardsBall& ball = m_balls[b];
					for (int p=0;p<6;p++)
					{
						if(ball.m_inPocket==false)
						{
							PocketInBall(m_balls[b], p);
						}	
					}
				}

				//球和桌面碰撞
				for (int b = 0; b < BallCount; b++)
				{
					BilliardsBall& ball = m_balls[b];
					if(ball.m_inPocket==false)
					{
						float minX = m_worldDeskMin.x;
						float minZ = m_worldDeskMin.z ;
						float maxX = m_worldDeskMax.x ;
						float maxZ = m_worldDeskMax.z ;

						float ballRadius = ball.m_radius;
						if (   ((ball.m_pos.x > maxX-ballRadius) && ball.m_speed.x >0 )
							|| ((ball.m_pos.x < minX+ballRadius) && ball.m_speed.x <0 )
							)
						{
							//速度摩擦力取反
							ball.m_speed *= 0.8f;
							ball.m_speed.x *= -1;
							ball.m_acc.x *= -1;
							m_sound->PlaySound__("data/sound/ui_click.wav");
						}

						if (   ((ball.m_pos.z > maxZ-ballRadius)  && ball.m_speed.z >0 )
							|| ((ball.m_pos.z < minZ+ballRadius)  && ball.m_speed.z <0 )
							)
						{
							//速度摩擦力取反
							ball.m_speed *= 0.8f;
							ball.m_speed.z *= -1;
							ball.m_acc.z *= -1;
							m_sound->PlaySound__("data/sound/ui_click.wav");
						}

						反射位置
						//if ((ball.m_pos.x > maxX-ballRadius) || (ball.m_pos.x < minX+ballRadius)
						//	||(ball.m_pos.z > maxZ-ballRadius) || (ball.m_pos.z < minZ+ballRadius))
						//{
						//	vec3 tar = GetBoundPosFromOut(ball.m_pos,ball.m_headDir*-1);
						//	//回退半径
						//	tar -= ball.m_headDir*ballRadius;
						//	//穿透力度
						//	//float interDis = (ball.m_pos - tar).Length()*0.8f;

						//	vec3 newDir = ball.m_speed;
						//	newDir.Normalize();

						//	//ball.m_pos = tar+newDir*interDis;

						//	m_sound->PlaySound__("data/sound/billiards/shoot.wav");
						//}
					}
				}
				moving = false;
				for (int p = 0; p < BallCount; p++)
				{
					if (m_balls[p].m_inPocket==false)
					{
						if (m_balls[p].UpdateMoving(steptime))
						{
							moving = true;
						}
					}
					m_balls[p].m_collided = false;
				}

				if (moving == false)
				{
					break;
				}
			}
			
			if (m_bHost== true
				//m_myRolePlayer&&
				//&&GetTurnPlayer()->m_turn == m_myRolePlayer->m_turn
				&& moving == false)
			{
				m_GameState = PrepareShooting;
				//滚动结束返还球
				if (m_balls[WhiteBall].m_inPocket)
				{
					m_balls[WhiteBall].SetPos(WhiteStartPos);
					m_balls[WhiteBall].m_speed = vec3();
					m_balls[WhiteBall].m_inPocket = false;
				}
				if (m_balls[BlackBall].m_inPocket && m_gameState != MS_End)
				{
					vec3 pos = m_worldDeskCen;
					//pos.z += m_localDeskMin.z*0.666f;
					m_balls[BlackBall].SetPos(pos);
					m_balls[BlackBall].m_speed = vec3();
					m_balls[BlackBall].m_inPocket = false;
				}

				//changeturn
				if (GetTurnPlayer()->m_shootNum<=0)
				{
					m_turnTime = 0;
					m_curTurn++;
					m_curTurn%=2;
					//换手后设置杆数
					if(GetTurnPlayer()->m_shootNum<=0)
					{
						GetTurnPlayer()->m_shootNum = 1;
					}
				}
				SendPrepareShooting();
			}
		}
		break;

	case PrepareShooting:
		m_prepareTime += G_Timer->GetStepTimeLimited(); 
		break;

	case Shooting:
		{
			//推杆动画
		}
		break;
	}
  
	m_turnTime += G_Timer->GetStepTimeLimited();

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

    return true;
}

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

bool MiniGameBilliards::KeepResource(bool once, int &circle, String &nextTip)
{

	char *ballTexFile[] =
	{
		"data/minigame/billiards/ball_white.png",
		"data/minigame/billiards/ball_yellow_solid.png",
		"data/minigame/billiards/ball_blue_solid.png",
		"data/minigame/billiards/ball_red_solid.png",
		"data/minigame/billiards/ball_purple_solid.png",
		"data/minigame/billiards/ball_orange_solid.png",
		"data/minigame/billiards/ball_green_solid.png",
		"data/minigame/billiards/ball_brown_solid.png",
		"data/minigame/billiards/ball_black.png",
		"data/minigame/billiards/ball_yellow_stripe.png",
		"data/minigame/billiards/ball_blue_stripe.png",
		"data/minigame/billiards/ball_red_stripe.png",
		"data/minigame/billiards/ball_purple_stripe.png",
		"data/minigame/billiards/ball_orange_stripe.png",
		"data/minigame/billiards/ball_green_stripe.png",
		"data/minigame/billiards/ball_brown_stripe.png",
	};

	for (int i = 0; i < BallCount; i++)
	{
		if (!m_movieBalls[i])
		{
			m_movieBalls[i] = new MovieClip;
			m_movieBalls[i]->LoadFromFile("data/minigame/billiards/ball.movie");
			m_movieBalls[i]->GetMovieClip("ball")->ReAttachTexture(ballTexFile[i]);
			m_movieBalls[i]->SetFrustumSkipEnable(false, Recursive);
		}
	}

	char *ballIconFiles[] =
	{
		"data/minigame/billiards/mini_white.png",
		"data/minigame/billiards/mini_yellow_solid.png",
		"data/minigame/billiards/mini_blue_solid.png",
		"data/minigame/billiards/mini_red_solid.png",
		"data/minigame/billiards/mini_purple_solid.png",
		"data/minigame/billiards/mini_orange_solid.png",
		"data/minigame/billiards/mini_green_solid.png",
		"data/minigame/billiards/mini_brown_solid.png",
		"data/minigame/billiards/mini_black.png",
		"data/minigame/billiards/mini_yellow_stripe.png",
		"data/minigame/billiards/mini_blue_stripe.png",
		"data/minigame/billiards/mini_red_stripe.png",
		"data/minigame/billiards/mini_purple_stripe.png",
		"data/minigame/billiards/mini_orange_stripe.png",
		"data/minigame/billiards/mini_green_stripe.png",
		"data/minigame/billiards/mini_brown_stripe.png",
	};
	for (int i = 0; i < BallCount; i++)
	{
		G_TextureMgr->AddTexture(m_ballIcons[i], ballIconFiles[i]);
	}

	G_TextureMgr->AddTexture(m_powerBar, "data/minigame/billiards/powerBar.png");
	G_TextureMgr->AddTexture(m_lazer, "data/minigame/billiards/lazer.png");

    return true;
}

void MiniGameBilliards::DeflectBalls(BilliardsBall &ballA, BilliardsBall &ballB)
{
	//减小模拟间隔 或使用连续性检测才能提高 robot的瞄准率
	if (ballA.m_inPocket 
		|| ballA.m_collided
		|| ballB.m_inPocket 
		|| ballB.m_collided
		) 
	{
		return;
	}

	vec3  posDif    = ballA.m_pos - ballB.m_pos;
	float posDifLen = posDif.Length();
	if (posDifLen >= (ballA.m_radius+ballB.m_radius)) 
	{
		if (ballA.m_collideBall == &ballB)
		{
			ballA.m_collideBall = NULL;
		}
		if (ballB.m_collideBall == &ballA)
		{
			ballB.m_collideBall = NULL;
		}
		//未接触
		return;
	} 

	vec3  speedDif = ballA.m_speed - ballB.m_speed;
	float speedLen = speedDif.Length();
	if (speedLen<_EPSILON)
	{
		return;
	}

    if (posDifLen <0.001f)
    {
        posDif = vec3(0, 0, 0.001f);
        posDifLen = 0.001f;
    }


	//ballA.m_pos += posDif * ((ballA.m_radius - posDifLen * 0.5f) / posDifLen);
	//ballB.m_pos -= posDif * ((ballB.m_radius - posDifLen * 0.5f) / posDifLen);

	//接触  回退到刚接触的时间点后再碰撞处理 更精确 保证robot的瞄准率
	float time = ((ballA.m_radius+ballB.m_radius)-posDifLen)/speedLen;
	ballA.m_pos -= ballA.m_speed * time;
	ballB.m_pos -= ballB.m_speed * time;
	posDif = ballA.m_pos - ballB.m_pos;


    ballA.m_collided = true;
    ballB.m_collided = true;

	if (ballA.m_collideBall != &ballB)
	{
		m_sound->PlaySound__("data/sound/ui_click.wav");
	}
	ballA.m_collideBall = &ballB;
	ballB.m_collideBall = &ballA;

    float impulse = 0.0f;
    float e       = 0.8f;

	//动量守恒
    impulse = ((-1) * (1.0f + e) * speedDif.Dot(posDif) ) / (posDif .Dot (posDif * (2.0f / ballA.m_mass)));

    ballA.m_speed += posDif*(impulse / ballA.m_mass);
    ballB.m_speed -= posDif*(impulse / ballB.m_mass);
}

//进洞
void MiniGameBilliards::PocketInBall(BilliardsBall& ball, int pocket)
{
	if (ball.m_inPocket)
	{
		return;
	}

	//
	vec3 dif = PocketPos[pocket]-ball.GetPos();
	dif.y = 0;
	if (dif.Length()<pocketRadius)
	{
		ball.m_inPocket = true;
	}

	//
	if (ball.m_inPocket)
	{
		BallID ballID = ball.m_id;
		ball.m_pos.y -= 5;
		ball.m_inPocket = true;
		//ball.m_rotAngleRad = 0;
		m_sound->PlaySound__("data/sound/billiards/sunk.wav");

		BilliardsPlayer* player = GetTurnPlayer();
		BilliardsPlayer* otherPlayer = dynamic_cast<BilliardsPlayer*>(m_miniPlayer[(m_curTurn + 1) % 2]);
		if ((ballID == WhiteBall))
		{
			//白球进洞返还
			if (m_blackInPacket == true)
			{
				//黑8同时进洞
				otherPlayer->m_shootNum = 2;
				player->m_shootNum = 0;
			}
		}
		else if (ballID == BlackBall)
		{
			//黑8球进洞
			int teamSide = player->m_teamSide;
			m_blackInPacket = true;
			if (teamSide != TeamSide_Null)
			{
				//7球全进，游戏结束
				if (InPocketNum(player->m_teamSide) == 7)
				{
					m_gameState = MS_End;
					//strcat(endGame, "Player wins");
				}
				else
				{
					//罚一杆 返还黑8
					otherPlayer->m_shootNum = 2;
					player->m_shootNum = 0;
				}
			}
		}
		else
		{
			if (player->m_teamSide == TeamSide_Null)
			{
				//第一次进球，决定花式
				player     ->m_teamSide = IsTeamSide(ballID,TeamSide_Solid)?TeamSide_Solid:TeamSide_Stripe;
				otherPlayer->m_teamSide = IsTeamSide(ballID,TeamSide_Solid)?TeamSide_Stripe:TeamSide_Solid;
			}


			if (m_blackInPacket == true)
			{
				//黑8同时进洞
				otherPlayer->m_shootNum = 2;
				player->m_shootNum = 0;
			}
			else
			{
				//自己花式进洞
				if (IsTeamSide(ballID,player->m_teamSide))
				{
					//加对方罚球可能是2
					if (player->m_shootNum<2)
					{
						player->m_shootNum++;
					}
				}
			}
		}
	}
}

int  MiniGameBilliards::InPocketNum(TeamSide side)
{
	int inPocketNum = 0;
	int startBall = (1-side)*8+1;
	for (int k = startBall; k < startBall+7; k++)
	{
		if (m_balls[k].m_inPocket == true)
			inPocketNum++;
	}
	return inPocketNum;
}

vec3 MiniGameBilliards::GetBoundPosFromInner(const vec3& pos,const vec3& dir)
{
	AABB aabb(m_worldDeskMin,m_worldDeskMax);
	vec3 newpos = pos+dir*1000;
	vec3 newdir = dir*-1;
	newdir.y = 0; //aabb.y 非常小
	float t;
	vec3 tar;
	IntersectRayAABB(newpos,newdir,aabb,t,tar);
	return tar;
}

vec3 MiniGameBilliards::GetBoundPosFromOut(const vec3& pos,const vec3& dir)
{
	vec3 tar;
	AABB aabb(m_worldDeskMin,m_worldDeskMax);
	float t;
	IntersectRayAABB(pos,dir,aabb,t,tar);
	return tar;
}



bool MiniGameBilliards::SendShootStick(float shootAngleRad,float shootPower)
{
	C2SPacketMiniGameCmd packet;
	packet.WriteHeader();
	packet.WriteValue(CMD_ShootStick);  
	packet.WriteValue(m_curTurn);
	packet.WriteValue(GetTurnPlayer()->m_shootNum);
	packet.WriteValue(shootAngleRad); 
	packet.WriteValue(shootPower); 
	G_MiniGame->SendPacketToOther(&packet);
	return true;
}

bool MiniGameBilliards::SendStickMove( float shootAngleRad,float stickDistance )
{
	C2SPacketMiniGameCmd packet;
	packet.WriteHeader();
	packet.WriteValue(CMD_StickMove);  
	//packet.WriteValue(m_curTurn);
	packet.WriteValue(shootAngleRad); 
	packet.WriteValue(stickDistance); 
	G_MiniGame->SendPacketToOther(&packet);
	return true;
}

bool MiniGameBilliards::SendPrepareShooting()
{
	m_prepareTime = 0;
	C2SPacketMiniGameCmd packet;
	packet.WriteHeader();
	packet.WriteValue(CMD_PrepareShoot); 
	packet.WriteValue(m_curTurn); //可能进洞 不一定换手
	packet.WriteValue(GetTurnPlayer()->m_shootNum); 
	for (int b=0;b<BallCount;b++)
	{
		packet.WriteValue(m_balls[b].m_inPocket); 
		packet.WriteValue(m_balls[b].m_pos); 
	}
	G_MiniGame->SendPacketToOther(&packet);
	return true;
}

bool MiniGameBilliards::ShootStick(float shootAngleRad,float shootPower)
{
	m_balls[WhiteBall].m_speed.x = shootPower * (cos(shootAngleRad)) * (-1.1f);
	m_balls[WhiteBall].m_speed.z = shootPower * (sin(shootAngleRad)) * (-1.1f);
	m_sound->PlaySound__("data/sound/billiards/shoot.wav");
	m_GameState = MiniGameBilliards::BallRolling;
	m_simulateTime = 0;
	m_blackInPacket = false;
	return true;
}

int  MiniGameBilliards::ProcessPacketCmd(PacketBase* packet)
{
	int cmd;
	packet->ReadValue(cmd);
	switch(cmd)
	{
	case CMD_PrepareShoot:
		m_prepareTime = 0;
		//不一定换手
		packet->ReadValue(m_curTurn);
		packet->ReadValue(GetTurnPlayer()->m_shootNum);
		m_turnTime = 0;

		for (int b=0;b<BallCount;b++)
		{
			packet->ReadValue(m_balls[b].m_inPocket); 
			packet->ReadValue(m_balls[b].m_pos); 
			m_balls[b].m_speed = vec3(0,0,0);
		}
		m_GameState = PrepareShooting;
		break;
	case CMD_StickMove:
		packet->ReadValue(GetTurnPlayer()->m_stickDistance);
		packet->ReadValue(GetTurnPlayer()->m_shootAngleRad);
		break;  

	//case CMD_BallIn:     //进球 
	case CMD_ShootStick://击球
		{
			对手
			//TetrisPlayer* otherPlayer = GetOtherPlayer();
			float shootAngleRad;
			float shootPower;
			packet->ReadValue(m_curTurn);
			packet->ReadValue(GetTurnPlayer()->m_shootNum); 
			packet->ReadValue(shootAngleRad); 
			packet->ReadValue(shootPower);
			ShootStick(shootAngleRad, shootPower);
		}
		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;
}

bool MiniGameBilliards::IsTeamSide(BallID ball,TeamSide side)
{
	if (ball == WhiteBall || ball == BlackBall)
	{
		return false;
	}

	if (side==TeamSide_Null)
	{
		return true;//一球未进 决定花式
	}

	if (ball > BlackBall && side==TeamSide_Stripe)
	{
		return true;
	}
	else if (ball < BlackBall && side==TeamSide_Solid)
	{
		return true;
	}
	return false;
}

BilliardsPlayer* MiniGameBilliards::GetTurnPlayer()
{
	return dynamic_cast<BilliardsPlayer*>(m_miniPlayer[m_curTurn]);
}

玩家类：

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

#ifndef  __BilliardsPlayer__H__
#define  __BilliardsPlayer__H__

#include "BilliardsBall.h"
#include "Rpg/MiniGame.h"
#include "Render/Texture.h"

enum TeamSide;

class BilliardsPlayer: public LogicCharacter,public MiniPlayer
{
public:
	BilliardsPlayer();
	virtual ~BilliardsPlayer();
	virtual bool Start();
	virtual void Update();
	virtual void Render();

	int      m_score;
	int      m_shootNum;
	TeamSide m_teamSide;
	int      m_turn;    //side 不等于turn	

	vec2     m_shootClickPos;
	float    m_shootPower;
	float    m_stickDistance;
	float    m_shootAngleRad;

	//指导线
	bool     m_useLazer;
};

class BilliardsPlayerRobot:public BilliardsPlayer
{
public:
	virtual bool Start();
	virtual void Update();
	void   SetWorkingWithAI(bool working);
	//寻找最佳目标球（白球-目标球-某个袋 距离和越小越好 夹角越小越好）
	void   FindBestGoal();
	bool   m_workingWithAI;	
	int    m_bestBall;
	int    m_bestPocket;
	float  m_bestPower;
	float  m_bestAngleRad;
		  
	float  m_dstPower;
	float  m_dstAngleRad;

	double m_thinkTime;
};

class BilliardsPlayerRole:public BilliardsPlayerRobot
{
public:
	virtual bool Start();
	virtual void Update();
};

#endif


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

#include "General/Pch.h"
#include "General/General.h"
#include "General/StringUtil.h"
#include "General/Timer.h"
#include "Gui/GuiMgr.h"
#include "Input/InputMgr.h"
#include "Billiards/MiniGameBilliards.h"
#include "Billiards/MiBilliardsBall_PlayGui.h"
#include "Billiards/BilliardsPlayer.h"
#include "Render/Camera.h"
#include "Render/Font.h"
#include "Render/MC_Misc.h"
#include "Render/RendDriver.h"
#include "Rpg/SyncGameInfo.h"
#include "Sound/ChannelSound.h"
#include "General/Pce.h"
#include "Math/MathLibAdvance.h"

//
BilliardsPlayer::BilliardsPlayer()
:m_useLazer(true)
{
}

BilliardsPlayer::~BilliardsPlayer()
{
}

bool BilliardsPlayer::Start()
{
	m_shootNum = 0;
	m_teamSide = TeamSide_Null;
    m_shootAngleRad = _PI + _PI / 2.0f;
	m_shootPower = 0;
	m_score = 0;
	m_stickDistance = 0;
	return false;
}

void BilliardsPlayer::Update()
{
	if (G_BilliardsGame->m_curTurn == m_turn)
	{
		switch(G_BilliardsGame->m_GameState)
		{
		case MiniGameBilliards::BallRolling:
			{
				//PlayAnim("stand");
			}
			break;
		case MiniGameBilliards::PrepareShooting:
			{
				mat4 rot;
				rot.FromRotateY(-(m_shootAngleRad + HALFPI));
				m_heading = rot* vec3(0, 0, 1);
				//	m_stickDistance 逆向运动学手部动画

				m_pos = G_BilliardsGame->m_balls[WhiteBall].m_pos - m_heading *30;
				m_pos.y -= 15;
				LogicCharacter::Update();

				//todo 
				AABB aabb(G_BilliardsGame->m_worldDeskMin,G_BilliardsGame->m_worldDeskMax);
				if(TestPointAABB(m_pos,aabb))
				{
					//PlayAnim("billiards_sit");//坐姿
				}
				else
				{
					//PlayAnim("billiards"); //站姿
				}
				//手部动画有待改进，可以加入逆向运动学解算或直接计算预制关键帧。 根据stickDistance设置播放头即可
			}
			break;
		}
	}
}

void BilliardsPlayer::Render()
{
	if (G_BilliardsGame->m_curTurn == m_turn)
	{
		LogicCharacter::Render();
	}
}

bool BilliardsPlayerRobot::Start()
{
	BilliardsPlayer::Start();
	m_workingWithAI = true;

	m_bestBall = 0;
	m_bestPocket = 0;
	m_bestPower = 0;

	return false;
}

void BilliardsPlayerRobot::Update()
{
	BilliardsPlayer::Update();
	if (G_BilliardsGame->m_curTurn == m_turn)
	{
		switch(G_BilliardsGame->m_GameState)
		{
		case MiniGameBilliards::BallRolling:
			{
				//球和球碰撞
				m_shootAngleRad = 0;
				m_shootPower = 0;
				m_bestPower = 0;
				m_bestAngleRad = 0;
			}
			break;

#define MaxThinkTime 3
		case MiniGameBilliards::PrepareShooting:
			//右键 开始拉杆
			
			if (G_BilliardsGame->m_prepareTime > MaxThinkTime)
			{
				//抬起开始推杆
				//最终决定误差 0.5°
				float amp = 1;
				m_shootAngleRad = m_bestAngleRad + 0.5f*DEG2RAD *(RandRange(-amp,amp));
				m_shootPower    = m_bestPower    + 10 *(RandRange(-amp,amp));
				m_shootAngleRad = fmod(m_shootAngleRad+TWOPI,TWOPI); 
				Clamp(m_shootPower, 0,100);
				G_BilliardsGame->m_GameState = MiniGameBilliards::Shooting;
			}
			else
			{
				//拉杆
				if (m_bestPower<_EPSILON)
				{
					//寻找最佳目标球
					FindBestGoal();

					//
					vec3  packetPos = G_BilliardsGame->PocketPos[m_bestPocket];
					vec3  hitPos = G_BilliardsGame->m_balls[m_bestBall].m_pos;
					vec3  difPD    = hitPos - packetPos;
					difPD.Normalize();
					//碰撞时白球所在的位置
					hitPos += difPD*(G_BilliardsGame->m_balls[WhiteBall].m_radius+G_BilliardsGame->m_balls[m_bestBall].m_radius);

					vec3  whitePos = G_BilliardsGame->m_balls[WhiteBall].m_pos;
					vec3  difWD = hitPos - whitePos;
					difWD.Normalize();
					m_bestAngleRad = _PI + atan2(difWD.z, difWD.x);

					//最佳力量 距离越远 需要力度越大
					m_bestPower = (packetPos-whitePos).Length();
					//撞击越偏（拐角越大）需要力度越大
					float dot = abs(difPD.Dot(difWD));
					dot = Max(dot,0.2f);
					m_bestPower /= dot;
					//计算白球反弹位置 到达某一区域 对下次击球更有利
					//...

					//m_bestAngleRad = fmod(m_bestAngleRad+TWOPI,TWOPI); 
					Clamp(m_shootPower, 0,100);
					m_thinkTime   = 999;
				}

				m_thinkTime+= G_Timer->GetStepTimeLimited();
				if (m_thinkTime>0.3f)
				{
					m_thinkTime = 0;
					float amp = 1-G_BilliardsGame->m_prepareTime/MaxThinkTime;
					amp = amp * amp;
					m_dstAngleRad = m_bestAngleRad + 45*DEG2RAD *(RandRange(-amp,amp));
					m_dstPower    = m_bestPower    + 50 *(RandRange(-amp,amp));
					m_dstAngleRad = fmod(m_dstAngleRad+TWOPI,TWOPI); 
					Clamp(m_dstPower, 0,100);
				}

				float difAngRad = m_dstAngleRad-m_shootAngleRad;
				bool  addRot    = (difAngRad>0&&difAngRad<_PI)||(difAngRad<0&&difAngRad<-_PI);
				m_shootAngleRad += (addRot ? 1:-1)*G_Timer->GetStepTimeLimited()*100*DEG2RAD; //旋转速度100°/s
				m_shootPower    += ((m_dstPower-m_shootPower)>0 ? 1:-1)*G_Timer->GetStepTimeLimited()*50;

				m_shootAngleRad = fmod(m_shootAngleRad+TWOPI,TWOPI); 
				Clamp(m_shootPower, 0,100);

				m_stickDistance = m_shootPower;

				//同步瞄准
				if (G_Timer->GetCurrentFrame()%10==0)
				{
					G_BilliardsGame->SendShootStick(m_shootAngleRad,m_shootPower);
				}
			}
			break;

		case MiniGameBilliards::Shooting:
			{
				//推杆动画
				if (m_stickDistance >= 3.0f)
				{
					m_stickDistance -= m_stickDistance / 2.0f;
				}
				else
				{
					m_shootNum -= 1;
					G_BilliardsGame->ShootStick(m_shootAngleRad,m_shootPower);
					G_BilliardsGame->SendShootStick(m_shootAngleRad,m_shootPower);
					m_shootPower = 3.0f;
				}
			}
			break;
		}
	}
}

//寻找最佳目标球（白球-目标球-某个袋 距离和越小越好 夹角越小越好）
void BilliardsPlayerRobot::FindBestGoal()
{
	//白球-目标球-某个袋 之间不能有干扰球

	//各球到白球的距离
	float ballRadX2 = G_BilliardsGame->m_balls[WhiteBall].m_radius*2.1f;
	vec3  whitePos = G_BilliardsGame->m_balls[WhiteBall].m_pos;
	float dis[BallCount];
	for (int p = 0; p < BallCount; p++)
	{
		dis[p] = (G_BilliardsGame->m_balls[p].m_pos - whitePos).Length();
	}

	//简单寻找最近的球
	m_bestBall = BlackBall;
	//if (G_BilliardsGame->InPocketNum(m_teamSide)<6)
	{
		float bestScore = 0;
		vec3  difPW;
		for (int p = 0; p < BallCount; p++)
		{
			BilliardsBall& pBall = G_BilliardsGame->m_balls[p];
			if(    pBall.m_inPocket==false //未进
				&& G_BilliardsGame->IsTeamSide((BallID)p,m_teamSide)
				)
			{
				//距离越近分越高
				float scoreWD = 1.0f/dis[p];

				bool visibleWD = true;//白球-目标球 之间无干扰球
				difPW = pBall.m_pos - whitePos;	
				for (int b = 0; b < BallCount; b++)
				{
					if (  dis[b] < dis[p]//距离更近才可能干扰
						&& b!=WhiteBall
						&& b!=p
					)
					{
						BilliardsBall& bBall = G_BilliardsGame->m_balls[b];
						float area = (bBall.m_pos - whitePos).Cross(difPW).Length();
						float h = area*2/dis[p];
						if(-ballRadX2<h && h<ballRadX2)
						{
							visibleWD = false;
							break;
						}
					}				
				}
				if (visibleWD)//无遮挡时加分
				{
					scoreWD += 10;
				}

				//寻找最佳的洞
				float scoreDP = 0;
				//int bestPocket = 0;
				//for (int i=0;i<6;i++)
				//{
				//	bool visibleDP = true;//目标球-袋 之间无干扰球
				//}
		
				float score = scoreWD + scoreDP;
				
				if (score > bestScore)
				{
					bestScore = score;
					m_bestBall = p;
					//m_bestPocket = bestPocket;
				}
			}
		}
	}

	//若没有不被干扰球 考虑二次碰撞击球 三次碰撞击球 判断难度（误差大小）
	//...

	//寻找最佳的洞
	m_bestPocket = 0;
	float maxDot = 0;
	vec3  pocketPos;
	vec3  hitPos = G_BilliardsGame->m_balls[m_bestBall].m_pos;
	vec3  dif = hitPos - whitePos;
	dif.Normalize();
	vec3  dif2;
	for (int i=0;i<6;i++)
	{
		pocketPos = G_BilliardsGame->PocketPos[i];
		dif2 = pocketPos-hitPos;
		dif2.Normalize();
		float dot = dif.Dot(dif2);
		if (dot>maxDot)
		{
			maxDot = dot;
			m_bestPocket = i;
		}
	}
}

void BilliardsPlayerRobot::SetWorkingWithAI(bool working)
{
	m_workingWithAI = working;
}

bool BilliardsPlayerRole::Start()
{
	BilliardsPlayerRobot::Start();
	m_workingWithAI = false;
	return false;
}

void BilliardsPlayerRole::Update()
{
	if (m_workingWithAI==true)
	{
		return BilliardsPlayerRobot::Update();
	}
	BilliardsPlayer::Update();
	if (G_BilliardsGame->m_curTurn == m_turn)
	{
		switch(G_BilliardsGame->m_GameState)
		{
		case MiniGameBilliards::BallRolling:
			{
				//球和球碰撞
			}
			break;

		case MiniGameBilliards::PrepareShooting:
			{
				vec3 head = G_Camera->GetHeadDir();
				m_shootAngleRad = _PI + atan2(head.z, head.x);

				//右键 开始拉杆
				if (G_Mouse->IsButtonDowning(MOUSE_RIGHT))
				{
					//G_BilliardsGame->m_GameState = MiniGameBilliards::Shooting;
					m_shootClickPos = G_Mouse->GetMousePos();
				}
				else if (G_Mouse->IsButtonUping(MOUSE_RIGHT))
				{
					//抬起开始推杆
					G_BilliardsGame->m_GameState = MiniGameBilliards::Shooting;
				}
				else if (G_Mouse->IsButtonPressed(MOUSE_RIGHT))
				{
					//拉杆
					m_shootPower = (G_Mouse->GetMousePos().y - m_shootClickPos.y) / 3;
					if (m_shootPower < 0)
					{
						m_shootPower = 0;
					}
					else if (m_shootPower > 100)
					{
						m_shootPower = 100;
					}
					m_stickDistance = m_shootPower;
					//同步瞄准
					if (G_Mouse->GetMove().LengthSq()>0)
					{
						G_BilliardsGame->SendShootStick(m_shootAngleRad,m_shootPower);
					}
				}
			}
			break;

		case MiniGameBilliards::Shooting:
			{
				//推杆动画
				if (m_stickDistance >= 3.0f)
				{
					m_stickDistance -= m_stickDistance / 2.0f;
				}
				else
				{
					m_shootNum -= 1;
					G_BilliardsGame->ShootStick(m_shootAngleRad,m_shootPower);
					G_BilliardsGame->SendShootStick(m_shootAngleRad,m_shootPower);
					m_shootPower = 3.0f;
				}
			}
			break;
		}
	}
}

娄磊lorry
关注
专栏目录
unity3d 台球源码_unity3D台球游戏源码
weixin_39889544的博客
12-20 888
压缩包内容概览：unity3D台球游戏源码-Table3D ; 装配-C尖锐第一通VS ; 装配C锐第一道次 ; 集合C ; 汇编C语言 ; 汇编统一脚本编辑器VS ; 汇编统一脚本第一遍 ; 资产 ; 图书馆 ; 项目设置 ; 表3D- CSHARP ; 材料 ; 模型 ; 预置 ; 资源 ; 场景 ; 声音 ; 标准的资产 ; 纹理 ; 关于 ; 关于.MAT ; 地区 ; 地区.MAT ; ...
unity游戏大全中的3D桌球游戏源代码
12-07
本资源提供了完整的3D桌球游戏源代码，为学习者提供了一个深入理解Unity引擎以及游戏逻辑的绝佳机会。让我们来详细探讨其中涉及的知识点。 首先，3D桌球游戏的核心是物理系统。Unity内置的物理引擎（Physics Engine...
台球游戏源代码
05-11
台球C++源代码 ，包含资源图片文件，WINDOWS下可编译 运行
桌球游戏源码
02-28
桌球游戏源码： ①游戏资源完整，包括图片、音效等。 ②代码内注释很全面，基本每几行就有一个注释，方便学习。 ③游戏为Unity引擎，C#语言编写。
经典桌球游戏开源项目教程
最新发布
gitblog_01098的博客
08-23 291
经典桌球游戏开源项目教程 Classic-Pool-GameClassic 8 Ball pool game written in JavaScript项目地址:https://gitcode.com/gh_mirrors/cl/Classic-Pool-Game 项目介绍 经典桌球游戏 是一个开源项目，位于 GitHub 上，由 henshmi 开发并维护。本项目旨在提供一个可复用且易于定制...
C语言版桌球游戏台球游戏源代码，含完整程序设计文档及答辩PPT，含可执行文件
Python代码大全
12-08 2945
C语言版桌球游戏台球游戏源代码，含完整程序设计文档及答辩PPT，含可执行文件 C语言实现，图形库使用Easy_X,开发环境使用VS2013。 init 初始化 show 游戏画面显示 refreshWithInput 与输入有关的刷新 refreshWithoutInput 与输入无关的刷新 碰撞模型： 碰撞条件： 球移动到边界或者两球的距离小于阈值 碰撞过程： 假设所有的球质量相等，，根据动量定理，一个球碰撞一个静止的小球或者两个运动的球相撞，两个球交换速度，根据矢量合成，两球交换x y上的速度; 判断碰
一个经典的3d台球游戏源码
02-23
一个经典的3d台球游戏源码很不错的..
激情台球游戏源码
chenli02的专栏
05-26 763
android游戏开发实例————桌面类游戏——《激情台球》 还有地图编辑源码和ppt 此系列游戏代码皆为 android游戏开发教程一书，仅为开发教学演示，非上线游戏代码             详细说明：http://android.662p.com/thread-750-1-1.html
web前端项目-3D台球游戏【附源码】
qiao_yue的博客
01-20 1485
【3D台球】这款游戏的操作简洁明了，玩家只需要简单的练习两分钟便能够掌握。玩家需要用鼠标控制击球的方向和力度，将白球打进洞中。每次进球后，玩家需要选择下一个要击打的球，直到所有的球都打进洞中。但要注意避免黑球进洞。
funcode桌球小游戏源码
03-09
【标题】"funcode桌球小游戏源码"指的是一个使用funcode编程语言开发的桌面台球游戏的源代码。这个项目可能是一个教学示例或个人练习，旨在帮助开发者熟悉funcode语言并提升游戏编程能力。 【描述】"符合指导书要求...
3d台球帧同步强联网cocos2d-x完整客户端
01-10
《3D台球游戏在Cocos2d-x框架下的帧同步与强联网实现》 Cocos2d-x是一款跨平台的2D游戏开发引擎，它以其高效、易用的特性深受开发者喜爱。在这个项目中，我们将深入探讨如何利用Cocos2d-x 3.10版本，结合Lua 5.1...
3D桌球(台球)游戏工程,源码
09-17
可以学习扩展资源,UI声音,音效控制,开始游戏,两种游戏打法,每种打法有两种模式,一倒计时模式,二练习模式,每种模式都有排行榜,排行榜没存储功能,对GUI的运用要有了解,希望对大家有帮助
台球游戏源码
08-28
台球 源码 用于android手机的一款台球游戏，打架可以玩一下
网络台球游戏的源代码(vc++)
04-19
源代码
趣味桌球小游戏源代码
07-25
趣味桌球小游戏源代码，包含各种素材。趣味桌球小游戏源代码，包含各种素材。趣味桌球小游戏源代码，包含各种素材。
小游戏——台球游戏（附带免费详细源码）
qq_41067077的博客
03-13 936
台球小游戏详细源码，拷贝下来就可用，关注博主不迷路，希望大家点赞收藏以此鼓励，感谢
Funcode桌球游戏源代码（可直接复制运行）
m0_59163654的博客
09-06 4897
一、实验要求 玩家通过移动球杆到单一的桌球处碰撞桌球运动，当桌球于一定速度通过桌面右方的同样颜色的球洞后，则该球进洞，在桌面左边重新分配新球开始游戏。要求如下： 1游戏的初始界面如图，其中左边有一个体积较小的桌球，其x方向位置固定，y方向位置随机。右边有八个颜色不一样，体积较大的球洞，游戏的目的是使用左边的桌球以一定小的速度穿过右边同样颜色的球洞就算桌球进洞，然后重新分配新球。 2球杆随鼠标运动而运动，单击球杆，桌球获取一个前进的速度同时往前有运动。桌球的前进方向有一段指示球运动方向的虚线。 3..
Unity3D台球游戏源码
11-16
unity3D台球游戏源码-游戏源码，用C#编写，可用Unity5.4版本打开，注释详细。Unity3D台球游戏源码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值