gametable.cpp

网络泡泡被.net管理

// GameTable.cpp: implementation of the GameTable class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GameTable.h"
#include <math.h>

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

GameTable::GameTable()
{
	is_playing	= false;
	for(int i=0; i<NUM_CHAIR; i++)
	{
		player[i]	= 0;
		//m_player[i].SetTable(this);
	}
	m_num_playing	= 0;
	m_time_start_game		= 0;
}

GameTable::~GameTable()
{

}

bool GameTable::UserEnter(GameUser* pUser, int nChair)
{
	if(pUser==NULL)
		return false;
	m_set_user.insert(pUser->uid);
	if(m_set_user.size()==1)
	{
		is_playing	= false;
		m_num_playing	= 0;
	}
	NET_Packet* pPacket;
	if(is_playing==false)
	{
		if(nChair<0 || nChair>=NUM_CHAIR)
		{
			for(int i=0; i<NUM_CHAIR; i++)
			{
				if(player[i]==0)
				{
					nChair		= i;
					break;
				}
			}
		}
		if(player[nChair]==0)
		{
			player[nChair]	= pUser->uid;
			m_player[nChair].SetUser(pUser);
			m_player[nChair].SetTable(this);
			if (!m_player[nChair].IsValid())
			{
				m_player[nChair].Create(SCENE_WIDTH, SCENE_HEIGHT);
			}
			m_player[nChair].Reset();
			//m_num_playing++;
		}
	}
	pUser->us_table	= uid;
	pUser->uc_chair	= nChair;
	//更新玩家信息
	pPacket	= new NET_Packet;
	pPacket->setCmd(GSP_ADD_USER);
	pPacket->writeData((STRUCT_ADD_USER*)pUser, sizeof(STRUCT_ADD_USER));
	g_server.m_socket_player.PushSendPacket(pUser->uid, pPacket);
	//广播桌子信息
	pPacket = CreateTableInfoPacket();
	BroadcastPacket(pPacket);
	//广播新玩家椅子信息
	//if(is_playing)
	{
		//向新玩家发所有椅子的信息
		for(int i=0; i<NUM_CHAIR; i++)
		{
			if(player[i]>0 && player[i]!=pUser->uid)
			{
				GameUser*	ptr_user	= g_server.get_user(player[i]);
				if(pPacket	= m_player[i].CreateScenePacket())
					g_server.m_socket_player.PushSendPacket(pUser->uid, pPacket);
			}
		}
	}
	
//	std::set<ULONG>::iterator	it	= m_set_user.begin();
//	while(it!=m_set_user.end())
//	{
//		NET_Packet* pPacket		= 
//		it++;
//	}

	return true;
}

void GameTable::UserLeave(GameUser* pUser)
{
	if(pUser==NULL)
		return;
	for(int i=0; i<NUM_CHAIR; i++)
	{
		if(player[i]==pUser->uid)
		{
			player[i] = 0;
			if(is_playing)
			{
				if (m_player[i].GetState()==PLAYER_STATE_PLAYING)
				{
					m_num_playing--;
				}
				pUser->n_score -= 10;
				pUser->us_lost++;
				m_prize	+= 5;
				m_player[i].Lost();
				m_player[i].SetUser(NULL);
				CheckWinner();
			}
		}
	}
	m_set_user.erase(pUser->uid);
	pUser->us_table	= 0;
	pUser->uc_chair	= 0;
	//更新玩家信息
	NET_Packet* pPacket = new NET_Packet;
	pPacket->setCmd(GSP_ADD_USER);
	pPacket->writeData((STRUCT_ADD_USER*)pUser, sizeof(STRUCT_ADD_USER));
	g_server.m_socket_player.PushSendPacket(pUser->uid, pPacket);
	//广播桌子信息
	pPacket = new NET_Packet;
	pPacket->setCmd(GSP_ADD_TABLE);
	pPacket->writeData((STRUCT_TABLE_INFO*)this, sizeof(STRUCT_TABLE_INFO));
	BroadcastPacket(pPacket);
}
bool GameTable::IsPlaying()	
{
	return is_playing>0;
}


GamePlayer* GameTable::get_player(ULONG id_user)
{
	for(int i=0; i<NUM_CHAIR; i++)
	{
		if(player[i]==id_user)
		{
			return &m_player[i];
		}
	}
	return NULL;
}

void GameTable::on_user_enter_table(ULONG id_user)
{

}

void GameTable::BroadcastPacket(NET_Packet *pPacket, ULONG id_except)
{
	if(pPacket==NULL)
		return;
	std::set<ULONG>::iterator	it	= m_set_user.begin();
	if(it==m_set_user.end())
	{
		delete(pPacket);
		return;
	}
	ULONG uid  = *it;
	it++;
	if(uid==id_except)
	{//skip except
		if(it==m_set_user.end())
		{
			delete(pPacket);
			return;
		}
	}
	while( it !=m_set_user.end())
	{
		NET_Packet* ptr_packet		= pPacket->clone_packet();
		g_server.m_socket_player.PushSendPacket(uid, ptr_packet);
		uid	= *it;
		it++;
		if(uid==id_except)
		{//skip except
			if(it==m_set_user.end())
			{
				delete(pPacket);
				return;
			}
			uid	= *it;
			it++;
		}
	}
	g_server.m_socket_player.PushSendPacket(uid, pPacket);
}

bool GameTable::on_msg_shoot(GameUser* pUser, STRUCT_SHOOT_DATA *pShoot)
{
	if(pUser==NULL || pShoot==NULL)
		return	false;
	GamePlayer* ptr_player	= get_player(pUser->uid);
	if(NULL==ptr_player)
	{
		return false;
	}
	NET_Packet* pPacket;
	if(ptr_player->num_bubble_bad>0)
	{
//		STRUCT_SHOOT_DATA	ssd;
//		ssd.ftan	= tan(const_PI_DIV_2);
		if(ptr_player->num_bubble_bad>=BUBBLE_GROUP_BAD)
		{
			ptr_player->num_bubble_bad -= BUBBLE_GROUP_BAD;
			ptr_player->trigger_bubble_up(BUBBLE_GROUP_BAD);
		}
		else if (ptr_player->num_bubble_bad>0)
		{//60%机会得到魔法泡泡
			ptr_player->num_bubble_bad -= 1;
			ptr_player->trigger_bubble_up(1);
		}
	}	
	bool bRet	= ptr_player->on_user_shoot(*pShoot);
	pPacket = new NET_Packet;
	pPacket->setCmd(GSP_SHOOT);
	pPacket->write32(pUser->uid);
	pPacket->writeData(pShoot, sizeof(STRUCT_SHOOT_DATA));
	BroadcastPacket(pPacket);

	if (ptr_player->m_num_time_pop>=LIMIT_POP_EVENT)
	{
		ptr_player->m_num_time_pop	= 0;
		for (int i=0; i<NUM_CHAIR; i++)
		{
			if (player[i] && m_player[i].GetState()==PLAYER_STATE_PLAYING)
			{
				m_player[i].AddBadBubble(5);
				STRUCT_HANDLE_PLAYER shp;
				shp.user	= pUser->uid;
				shp.object	= player[i];
				shp.bubble_bad	= ptr_player->num_bubble_bad;
				shp.bubble_good	= ptr_player->num_bubble_store;
				shp.bubble_bad_obj	= m_player[i].num_bubble_bad;
				shp.bubble_good_obj	= m_player[i].num_bubble_store;
				shp.enum_handle	= ENUM_HANDLE_ADD_BAD;
				shp.score	= pUser->n_score;
				do_handle_player(&shp);
			}
		}
	}


	_update_player_state(pUser, ptr_player);

	return bRet;
}

bool GameTable::Start()
{
	if(is_playing)
		return false;
	m_num_playing	= 0;
	m_prize	= 2;
	for(int i=0; i<NUM_CHAIR; i++)
	{
		if(player[i]>0)
		{
			if(m_player[i].GetState()!=PLAYER_STATE_READY)
				return false;
			m_num_playing++;
		}
	}
	for(i=0; i<NUM_CHAIR; i++)
	{
		if(player[i]>0)
		{
			GameUser*	ptr_user	= g_server.get_user(player[i]);
			m_player[i].Reset();
			m_player[i].Start();
			m_prize	+= 3;
			if (m_num_playing==1)
			{
				m_player[i].num_bubble_bad	= 9;
			}
			for(int j=0; j<4; j++)
			{
				m_player[i].AddLevel();
			}
			NET_Packet* pPacket;
			if(pPacket	= m_player[i].CreateScenePacket())
				BroadcastPacket(pPacket);
		}
	}
	is_playing	= true;
	m_time_start_game		= Sys_GetTime();
	NET_Packet* pPacket	= new NET_Packet;
	pPacket->setCmd(GSP_GAME_CLOCK);
	pPacket->write32(0);
	BroadcastPacket(pPacket);
	g_server.on_update_table_info(this);
	return true;
}

bool GameTable::on_ui_cmd_ready(GameUser* pUser)
{	
	if(is_playing || pUser==NULL)
		return false;
	GamePlayer* ptr_player	= get_player(pUser->uid);
	if(ptr_player)
	{
		ptr_player->switch_ready();
		return true;
	}
	else
	{
		UserEnter(pUser, -1);
		g_server.on_update_table_info(this);
		ptr_player	= get_player(pUser->uid);
		if(ptr_player)
		{
			ptr_player->switch_ready();
			return true;
		}
	}
	return false;
}

bool GameTable::CheckWinner()
{
	if(m_num_playing<=1)
	{
		for(int i=0; i<NUM_CHAIR; i++)
		{
			if(player[i])
			{
				GameUser* ptr_user	= g_server.get_user(player[i]);
				if(ptr_user==NULL)
				{	
					player[i]=0;
					continue;
				}
				switch(m_player[i].GetState()) {
				case PLAYER_STATE_PLAYING:
					{
						m_player[i].Win();
						ptr_user->us_win++;
						do_score(ptr_user, m_prize);
					}
					break;
				case PLAYER_STATE_LOST:
					{
						m_player[i].Win();
						ptr_user->us_lost++;
						do_score(ptr_user, -3);
					}
					break;
				default:
					break;
				}
			}
		}
		is_playing	= false;
		g_server.on_update_table_info(this);
		return true;
	}
	return false;
}

void GameTable::DoUpdate()
{
	DWORD tick_cur	= Sys_GetTime();
	DWORD time_pass	= tick_cur - m_time_start_game;

	NET_Packet* pPacket;

	if (is_playing && time_pass/1000 != (m_time_game)/1000)
	{
		pPacket	= new NET_Packet;
		pPacket->setCmd(GSP_GAME_CLOCK);
		pPacket->write32(time_pass);
		BroadcastPacket(pPacket);
	}
	m_time_game	= time_pass;

	for (int i=0; i<NUM_CHAIR; i++)
	{
		if (player[i])
		{
			if (m_player[i].GetState()==PLAYER_STATE_PLAYING)
			{
				if (tick_cur - m_player[i].m_tick_last_shoot>LIMIT_SHOOT_DELAY)
				{//通知客户端必须要发射泡泡了
					m_player[i].m_tick_last_shoot	= tick_cur;
					pPacket	= new NET_Packet;
					pPacket->setCmd(GSP_UI_CMD);
					pPacket->write32(player[i]);
					pPacket->write16(_UI_CMD_SHOOT);
					g_server.m_socket_player.PushSendPacket(player[i], pPacket);
					//速度太慢了，冒1个泡泡
					m_player[i].trigger_bubble_up(1);
					_update_player_state(m_player[i].m_ptr_user, &m_player[i]);
				}
			}
		}
	}
	//if(time_pass)
//	for()
}

void GameTable::on_msg_handle_player(GameUser *ptr_obj, GameUser *ptr_user)
{
	if(ptr_obj==NULL || ptr_user==NULL)
		return;
	GamePlayer* ptr_player_obj	= get_player(ptr_obj->uid);
	GamePlayer* ptr_player_user	= get_player(ptr_user->uid);
	if(ptr_player_obj==NULL || ptr_player_user==NULL)
		return;
	if(ptr_player_obj->GetState()!=PLAYER_STATE_PLAYING)
		return;
	if(ptr_player_obj==ptr_player_user)
	{//对自己使用，消掉一些泡泡
		if(ptr_player_user->num_bubble_store>=64)
		{//大绝招，70%的几率消掉全屏里的每个的泡泡
			USHORT ap_pop[32];
			int n=0;
			for (int i=0; i<ptr_player_obj->m_num_data; i++)
			{
				if(ptr_player_obj->GetBubble(i)%10 && rand()*99.0f/RAND_MAX<70)
				{
					ptr_player_obj->PopBubble(ptr_player_obj->Index2X(i), ptr_player_obj->Index2Y(i), 1);
					ap_pop[n]	= i;
					n++;
					if(n>=32)
						break;
				}
			}
			if (n>0)
			{
				ptr_player_user->num_bubble_store -= 64;
				STRUCT_HANDLE_PLAYER shp;
				shp.user	= ptr_user->uid;
				shp.object	= ptr_obj->uid;