C++ net::CBuffer类代码示例

	void CMessageHoundCharge::deserialize(Net::CBuffer& buffer) {
		buffer.read( &_isActive, sizeof(_isActive) );

		// Solo si la habilidad esta activa se mandan el resto 
		// de los atributos
		if(_isActive) {
			buffer.read( &_filterMask, sizeof(_filterMask) );
			buffer.read( &_force, sizeof(_force) );
		}	
	}

	Net::CBuffer CMessageHoundCharge::serialize() {
		Net::CBuffer buffer;
		buffer.serialize( std::string("CMessageHoundCharge"), true );

		buffer.write( &_isActive, sizeof(_isActive) );
		// El resto de los atributos nos interesan solo si se
		// activa la habilidad
		if(_isActive) {
			buffer.write( &_filterMask, sizeof(_filterMask) );
			buffer.write( &_force, sizeof(_force) );
		}

		return buffer;
	}//

	void CMessageInt::deserialize(Net::CBuffer &data)
	{

		CMessage::deserialize(data);
		data.read(&_int,  sizeof(_int));
			
	} // deserialize

	void CMessageBool::serialize(Net::CBuffer &data)
	{
		CMessage::serialize(data);
		data.write((void*) (&_bool),	sizeof(_bool));
		
					
	} // serialize

	void CMessageSetOwner::deserialize(Net::CBuffer& buffer) {
		TEntityID id;
		// Por problemas con enumerados utilizamos directamente
		// el read en vez del deserialize
		buffer.read( &id, sizeof(id) );

		_entity = Logic::CServer::getSingletonPtr()->getMap()->getEntityByID(id);
	}

	void CMessageBool::deserialize(Net::CBuffer &data)
	{

		CMessage::deserialize(data);
		data.read(&_bool,	sizeof(_bool));
		
			
	} // deserialize

	// TODO FRS no es necesario enviar todo el transform siempre -> solo posicion / rotacion en eje vertical
	void CMessageTF::serialize(Net::CBuffer &data)
	{
		CMessage::serialize(data);

		for(int i = 0; i < 4; ++i)
			for(int j = 0; j < 4; ++j)
				data.write((void*)&_transform[i][j], sizeof(_transform[i][j]));
			
	} // serialize

	void CMessageTF::deserialize(Net::CBuffer &data)
	{
		CMessage::deserialize(data);

		for(int i = 0; i < 4; ++i)
			for(int j = 0; j < 4; ++j)
				data.read(&_transform[i][j], sizeof(_transform[i][j]));
			
	} // deserialize

	void CGameServerState::disconnectionPacketReceived(Net::CPaquete* packet) {
		// Obtenemos el puntero al gestor de jugadores y el id de red del cliente que se quiere desconectar
		Net::NetID playerNetId = packet->getConexion()->getId();

		// Eliminamos la entidad manejada por el cliente que se quiere desconectar.
		// Para ello comprobamos si tiene asignado un id de entidad. Si no lo tiene, es que
		// no ha sido creada ninguna entidad (podria estar conectandose).
		if( _playersMgr->existsByNetId(playerNetId) ) {
			std::pair<Logic::TEntityID, bool> logicIdPair = _playersMgr->getPlayerId(playerNetId);
			if(logicIdPair.second) {
				Logic::CEntity* entityToBeDeleted = _map->getEntityByID(logicIdPair.first);
				Logic::CEntityFactory::getSingletonPtr()->deferredDeleteEntity(entityToBeDeleted, true);

				// A nivel logico, conviene que los clientes sepan quien se desconecta,
				// especialmente para eliminar cosas del hud
				Net::NetMessageType ackMsg = Net::PLAYER_OFF_MATCH;
				Net::CBuffer disconnectMsg;
				disconnectMsg.write(&ackMsg, sizeof(ackMsg));
				disconnectMsg.write(&playerNetId, sizeof(playerNetId));
				disconnectMsg.serialize(entityToBeDeleted->getName(), false);

				_netMgr->broadcast(disconnectMsg.getbuffer(), disconnectMsg.getSize());
			}

			// Eliminamos el jugador que se desconecta del manager de jugadores
			_playersMgr->removePlayer(playerNetId);
		}
	} // disconnexionPacketReceived

	void CMessageAudio::serialize(Net::CBuffer &data)
	{
		CMessage::serialize(data);
		
		unsigned int size = _path.size();  
		data.write(&size,sizeof(size));		
		data.write((void*)_path.c_str(),size);

		size = _id.size();  
		data.write(&size,sizeof(size));		
		data.write((void*)_id.c_str(),size);

		data.write((void*)(&_position.x), sizeof(_position.x));
		data.write((void*)(&_position.y), sizeof(_position.y));
		data.write((void*)(&_position.z), sizeof(_position.z));

		data.write((void*) (&_notIfPlay),	sizeof(_notIfPlay));
		data.write((void*) (&_isPlayer),	sizeof(_isPlayer));
	
	}

	void CMessageAudio::deserialize(Net::CBuffer &data) {

		unsigned int size;
			data.read(&size, sizeof(size)); 		
		char* aux = new char[size];		
			data.read(aux, size);
			_path.assign(aux,size); 
			delete[] aux;

		unsigned int size1;
			data.read(&size1, sizeof(size1)); 		
		char* aux1 = new char[size1];		
			data.read(aux1, size1);
			_id.assign(aux1,size1); 
			delete[] aux1;

		data.read(&_position.x, sizeof(_position.x));
		data.read(&_position.y, sizeof(_position.y));
		data.read(&_position.z, sizeof(_position.z));

		data.read(&_notIfPlay,	sizeof(_notIfPlay));
		data.read(&_isPlayer,	sizeof(_isPlayer));

	}

	void CMessageControl::deserialize(Net::CBuffer& buffer) {
		buffer.deserialize(_seq);
		buffer.read(&_controlType, sizeof(_controlType));
		
	}

	void CMessagePrimarySpell::deserialize(Net::CBuffer& buffer) {
		buffer.deserialize(_spell);
	}

	void CMessagePrimaryShoot::deserialize(Net::CBuffer& buffer) {
		buffer.deserialize(_shoot);
	}

	void CMessageMouse::deserialize(Net::CBuffer& buffer) {
		_controlType = Control::MOUSE;
		buffer.deserialize(_seq);
		buffer.deserialize(_mouse[0]);
		buffer.deserialize(_mouse[1]);
	}