Beispiel #1
0
void Connection::processReceivedData()
{
	int bytesRead;

	while((bytesRead = socket->read(scrapBuffer, BUFFERSIZE)) > 0)
		receiveBuffer.append(scrapBuffer, bytesRead);
	
	if(bytesRead == -1)
		return;
	
	while(1)
	{
		Net::Packet packet;
	
		try
		{
			packet.readFromBuffer(receiveBuffer);
		}
		catch(Net::EndOfDataException)
		{
			break;		
		}
	}
	
	writeBufferedData();
}
Beispiel #2
0
void Connection::processPackets()
{
	if(socket.state() != QTcpSocket::ConnectedState)
		return;

	int read;

	while((read = socket.read(scrapBuffer, BUFFERSIZE)) > 0)
		receiveBuffer.append(scrapBuffer, read);

	if(read == -1)
		close();

	while(1)
	{
		Net::Packet packet;

		try
		{
			packet.readFromBuffer(receiveBuffer);

			if(packet.getType() == Protocol::GAME_STATE)
			{
				emit receivingGameState();

				std::string s;

				packet >> s;

				std::stringstream ss(s);

				Json::Value v;

				ss >> v;

				std::cout << v;

				try
				{
					state.reset(new Client::State(v, objectFactory));

					emit ready(state.get());
				}
				catch(std::runtime_error& e)
				{
					emit error(e.what());
				}
			}
		}
		catch(Net::EndOfDataException)
		{
			/*
			We don't have enough data for a packet, so we return.
			*/
			return;
		}

	}
}
Beispiel #3
0
void Socket::sendPacket(const net::Packet& packet){
	uint32_t payloadSize = packet.getPayload().getCapacity();

	// send payload size
	sendBfr(&payloadSize, sizeof(uint32_t));

	// send the actual data
	sendBfr(packet.getPayload().getData(), packet.getPayload().getCapacity());
}
Beispiel #4
0
void Socket::recvPacket(net::Packet& packet){
	uint32_t payloadSize = 0;

	// recieve payload size
	recvBfr(&payloadSize, sizeof(uint32_t));

	// initialize payload memory
	packet.clear();
	packet.getPayload().grow(payloadSize);

	recvBfr(packet.getPayload().getData(), packet.getPayload().getCapacity());
}
Beispiel #5
0
void PlayerProxy::makeCall(const std::string& method, const Json::Value& arguments)
{
	Json::Value call;

	call["objectType"] = "player";
	call["objectIndex"] = getIndex();
	call["method"] = method;
	call["arguments"] = arguments;

	Net::Packet packet;
	packet.setType(Protocol::REMOTE_INVOCATION);

	Json::FastWriter fw;

	packet << fw.write(call);

	connection.writeToServer(packet);

	std::cout << call;
}
Beispiel #6
0
void		NetworkModule::sendUDPPacket(Net::Packet &packet,
				std::list<Client*> const &list,
				bool needId, Client *player)
{
	for (std::list<Client*>::const_iterator it = list.begin();
		 it != list.end(); it++)
	{
		if (player == *it || (*it)->getUDPAddr().getSize() == 0)
			continue ;
		if (needId)
		{
			uint32_t	id;
			packet.wr_ptr(9);
			id = (*it)->getPacketId();
			packet << id;
			(*it)->addPacket(id, packet);
		}
		packet.setDestination((*it)->getUDPAddr());
		this->_udp.handleOutputPacket(packet);
	}
}
Beispiel #7
0
int			UdpHandler::spawn(Net::Packet &packet, uint64_t)
{
	uint32_t	id_packet;

	if (packet.size() != 29)
		return 0;
	packet >> id_packet;
	this->testPacketId(id_packet);
	GameCommand *gc = new GameCommand("spawn");
	packet >> gc->idResource;
	packet >> gc->idObject;
	packet >> gc->x;
	packet >> gc->y;
	packet >> gc->vx;
	packet >> gc->vy;
	/*if (_latency > 50)
	{		
		gc->x += (static_cast<double>(_latency) / 1000) * gc->vx;
		gc->y += (static_cast<double>(_latency) / 1000) * gc->vy;
	}*/
	//std::cout << "spawn de type " << gc->idResource << " x:" << gc->x << " y:" << gc->y << " vx:" << gc->vx << " vy:" << gc->vy << std::endl;
	CommandDispatcher::get().pushCommand(*gc);
	return 1;
}
Beispiel #8
0
int			UdpHandler::handleInputPacket(Net::Packet &packet)
{
	static int			(UdpHandler::* const methods[])(Net::Packet&, uint64_t) = {
			&UdpHandler::spawn,
			&UdpHandler::destroy,
			&UdpHandler::move,
			NULL,
			NULL,
			&UdpHandler::retrieve,
			&UdpHandler::ping,
			&UdpHandler::pong
	};
	uint64_t			time;
	uint8_t				type;

	if (packet.size() < 9)
		return 0;
	packet >> time;
	packet >> type;

	if (type < sizeof(methods) / sizeof(*methods) && methods[type] != NULL)
		return (this->*methods[type])(packet, time);
	return 0;
}
Beispiel #9
0
//TODO: implement correct sending (remote call api)
void Connection::writeToServer(const Net::Packet& packet)
{
	std::string str = packet.getString();

	socket.write(str.c_str(), str.size());
}
Beispiel #10
0
void Connection::writePacket(const Net::Packet& packet)
{
	std::string str = packet.getString();

	sendBuffer.append(str.c_str(), str.size());
}