// Pass an array of encoded bytes to array and a preallocated BitStream to receive the output
void HuffmanEncodingTree::DecodeArray( unsigned char *input, unsigned sizeInBits, RakNet::BitStream * output )
{
HuffmanEncodingTreeNode * currentNode;
if ( sizeInBits <= 0 )
return ;
RakNet::BitStream bitStream( input, BITS_TO_BYTES(sizeInBits), false );
currentNode = root;
// For each bit, go left if it is a 0 and right if it is a 1. When we reach a leaf, that gives us the desired value and we restart from the root
for ( unsigned counter = 0; counter < sizeInBits; counter++ )
{
if ( bitStream.ReadBit() == false ) // left!
currentNode = currentNode->left;
else
currentNode = currentNode->right;
if ( currentNode->left == 0 && currentNode->right == 0 ) // Leaf
{
output->WriteBits( &( currentNode->value ), sizeof( char ) * 8, true ); // Use WriteBits instead of Write(char) because we want to avoid TYPE_CHECKING
currentNode = root;
}
}
}
std::vector<float> LexicalReorderingTableCompact::GetScore(const Phrase& f,
const Phrase& e,
const Phrase& c)
{
std::string key;
Scores scores;
if(0 == c.GetSize())
key = MakeKey(f, e, c);
else
for(size_t i = 0; i <= c.GetSize(); ++i)
{
Phrase sub_c(c.GetSubString(WordsRange(i,c.GetSize()-1)));
key = MakeKey(f,e,sub_c);
}
size_t index = m_hash[key];
if(m_hash.GetSize() != index)
{
std::string scoresString;
if(m_inMemory)
scoresString = m_scoresMemory[index];
else
scoresString = m_scoresMapped[index];
BitWrapper<> bitStream(scoresString);
for(size_t i = 0; i < m_numScoreComponent; i++)
scores.push_back(m_scoreTrees[m_multipleScoreTrees ? i : 0]->Read(bitStream));
return scores;
}
return Scores();
}
void CNetworkManager::PacketHandler(CPacket * pPacket)
{
CNetworkManager * pInstance = GetInstance();
if(!pInstance)
return;
// Pass it to the packet handler, if that doesn't handle it, pass it to the rpc handler
if(!pInstance->m_pClientPacketHandler->HandlePacket(pPacket) && !pInstance->m_pClientRPCHandler->HandlePacket(pPacket))
{
if(g_pClient->GetChatWindow())
{
if(pPacket->packetId == PACKET_RPC)
{
// Construct the bit stream
CBitStream bitStream(pPacket->ucData, pPacket->uiLength, false);
RPCIdentifier rpcId;
// Read the rpc id
if(bitStream.Read(rpcId))
g_pClient->GetChatWindow()->AddNetworkMessage("[NETWORK] Unhandled RPC (Type: %d)", rpcId);
}
else
g_pClient->GetChatWindow()->AddNetworkMessage("[NETWORK] Unhandled packet (Type: %d)", pPacket->packetId);
}
}
}
/// @brief Process a new snapshot of a player's user input
/// @params *pkt Packet containing the snapshot data
void NetworkCore::ProcessPlayerState( RakNet::Packet *pkt )
{
// UNUSED VARIABLE unsigned char bHasTime;
// UNUSED VARIABLE RakNet::Time timestamp;
unsigned char bPacketID;
PLAYER_INPUT_DATA playerInput;
RakNet::BitStream bitStream( pkt->data, pkt->length, false );
//bitStream.Read( bHasTime );
//bitStream.Read( timestamp );
bitStream.Read( bPacketID );
bitStream.Read( (char*)&playerInput, sizeof( PLAYER_INPUT_DATA ) );
// Create a new InputState object from received data
InputState *inputState = new InputState( playerInput.frwdPressed,
playerInput.backPressed, playerInput.leftPressed, playerInput.rghtPressed, playerInput.hndbPressed );
// Delete any old unused input state
if( GameCore::mPlayerPool->getPlayer( pkt->guid )->newInput != NULL )
delete( GameCore::mPlayerPool->getPlayer( pkt->guid )->newInput );
// Store the new state in the player's object
GameCore::mPlayerPool->getPlayer( pkt->guid )->newInput = inputState;
}
// server / authority code
RakNet::RM3SerializationResult DynamicActorReplicaComponent::serialize(RakNet::SerializeParameters *serializeParameters)
{
// note: take a look at preUpdate to understand how this works
if(_tickReplicated == _tickToReplicate) {
return RakNet::RM3SR_DO_NOT_SERIALIZE;
}
_tickSerialized = _tickToReplicate;
#if NL_DYNAMICACTORREPLICA_HAS_SERIALIZE_LOG
getReplica()->getPeer()->log(ELogType_Info, "serialize %d ", _tickToReplicate);
#endif
RakNet::BitStream& bitStream(serializeParameters->outputBitstream[0]);
//DONE: @David Compression
//Old-Way:
//bitStream.WriteAlignedBytes( (const unsigned char *)&_actorDatagram, sizeof(Dynamic2DActorDatagram) );
Compressed_Dynamic2DActorDatagram comValues;
comValues._x = _actorDatagram._x;
comValues._y = _actorDatagram._y;
comValues._fx = TCompressedFixpoint<float,char,8>::writeCompress(_actorDatagram._fx, -1.0f, 1.0f );
comValues._fy = TCompressedFixpoint<float,char,8>::writeCompress(_actorDatagram._fy, -1.0f, 1.0f );
comValues._killCount = _actorDatagram._killCount;
comValues._lvx = _actorDatagram._lvx;
comValues._lvy = _actorDatagram._lvy;
comValues._avz = _actorDatagram._avz;
comValues._updateTick = _actorDatagram._updateTick;
bitStream.WriteAlignedBytes( (const unsigned char *)&comValues, sizeof(Compressed_Dynamic2DActorDatagram));
return RakNet::RM3SR_SERIALIZED_ALWAYS_IDENTICALLY;
}
bool TankPlayerReplicaComponent::deserializeConstruction(RakNet::BitStream *constructionBitstream) {
RakNet::BitStream& bitStream(*constructionBitstream);
if (bitStream.GetNumberOfBitsUsed()==0)
return false;
return true;
}
bool CRPCHandler::HandlePacket(CPacket * pPacket)
{
// Is it an rpc packet?
if(pPacket->packetId == PACKET_RPC)
{
// Construct the bit stream
CBitStream bitStream(pPacket->ucData, pPacket->uiLength, false);
RPCIdentifier rpcId;
// Read the rpc id
if(bitStream.Read(rpcId))
{
RPCFunction * pFunction = GetFunctionFromIdentifier(rpcId);
// Does the function exist?
if(pFunction)
{
// Call the function
pFunction->rpcFunction(&bitStream, pPacket->playerSocket);
return true;
}
}
}
// Not handled
return false;
}
GTEST_TEST(BitStream, BitStream16LELSB) {
static const byte compValues[11] = { 0, 1, 0, 0, 1, 0, 0, 0, 0x04, 0x03, 0x01 };
static const byte data[8] = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
Common::MemoryReadStream stream(data);
Common::BitStream16LELSB bitStream(stream);
testBitStream(bitStream, compValues);
}
void MasterClient::ConnectionAttemptNotification(char *serverIP, unsigned short serverPort)
{
if (serverIP==0)
return;
BitStream bitStream(23);
bitStream.Write((unsigned char)ID_RELAYED_CONNECTION_NOTIFICATION);
bitStream.Write(localServer.connectionIdentifier.port); // Your own game client port
bitStream.Write(serverPort); // The game server you are connecting to port
stringCompressor->EncodeString(serverIP, 22, &bitStream); // The game server IP you are connecting to
rakPeer->Send(&bitStream, HIGH_PRIORITY, RELIABLE, 0, UNASSIGNED_PLAYER_ID, true);
}
void TalkTable_GFF::readString05(Entry &entry, bool bigEndian) const {
Common::ScopedPtr<Common::SeekableReadStream>
huffTree (_gff->getTopLevel().getData(kGFF4HuffTalkStringHuffTree)),
bitStream(_gff->getTopLevel().getData(kGFF4HuffTalkStringBitStream));
if (!huffTree || !bitStream)
return;
Common::SeekableSubReadStreamEndian huffTreeEndian(huffTree.get(), 0, huffTree->size(), bigEndian);
Common::SeekableSubReadStreamEndian bitStreamEndian(bitStream.get(), 0, bitStream->size(), bigEndian);
readString05(huffTreeEndian, bitStreamEndian, entry);
}
// client / slave code
bool DynamicActorReplicaComponent::deserializeConstruction(RakNet::BitStream *constructionBitstream) {
RakNet::BitStream& bitStream(*constructionBitstream);
if (bitStream.GetNumberOfBitsUsed()==0)
return false;
RakNet::RakString rakString;
bitStream.Read(rakString);
#if NL_DYNAMICACTOREPLICA_HAS_SERIALIZE_CONSTRUCTION_LOG
getReplica()->getPeer()->log(ELogType_Info, "deserializeConstruction %s ", rakString.C_String());
#endif
setConstructionDictionary(CCJSONConverter::dictionaryFrom(rakString.C_String()));
createActorSprite(getConstructionDictionary());
return true;
}
GTEST_TEST(BitStream, skip) {
static const byte data[4] = { 0 };
Common::MemoryReadStream stream(data);
Common::BitStream8MSB bitStream(stream);
EXPECT_EQ(bitStream.pos(), 0);
EXPECT_EQ(bitStream.size(), 8 * ARRAYSIZE(data));
bitStream.skip(1);
bitStream.skip(2);
bitStream.skip(3);
EXPECT_EQ(bitStream.pos(), 6);
bitStream.rewind();
EXPECT_EQ(bitStream.pos(), 0);
}
bool CPacketHandler::HandlePacket(CPacket * pPacket)
{
PacketFunction * pFunction = GetFunctionFromIdentifier(pPacket->packetId);
// Does the function exist?
if(pFunction)
{
// Construct the bit stream
CBitStream bitStream(pPacket->ucData, pPacket->uiLength, false);
// Call the function
pFunction->packetFunction(&bitStream, pPacket->pPlayerSocket);
return true;
}
// Not handled
return false;
}
// This will read the data from playerChangedId and send it to playerToSendToId
void RakServer::ChangeStaticClientData( PlayerID playerChangedId, PlayerID playerToSendToId )
{
RemoteSystemStruct * remoteSystem = GetRemoteSystemFromPlayerID( playerChangedId );
if ( remoteSystem == 0 )
return ; // No such playerChangedId
// Relay static data to the other systems but the sender
RakNet::BitStream bitStream( remoteSystem->staticData.GetNumberOfBytesUsed() + PlayerID_Size + sizeof(unsigned char) );
unsigned char typeId = ID_REMOTE_STATIC_DATA;
bitStream.Write( typeId );
bitStream.Write( playerChangedId.binaryAddress );
bitStream.Write( playerChangedId.port );
bitStream.Write( ( char* ) remoteSystem->staticData.GetData(), remoteSystem->staticData.GetNumberOfBytesUsed() );
Send( &bitStream, SYSTEM_PRIORITY, RELIABLE, 0, playerToSendToId, true );
}
void MasterServer::HandleDelistServer(Packet *packet)
{
PlayerID serverPlayerID;
int existingServerIndex;
BitStream bitStream(packet->data, packet->length, false);
bitStream.IgnoreBits(sizeof(unsigned char)*8); // Ignore the packet type enum
bitStream.Read(serverPlayerID.port);
serverPlayerID.binaryAddress=packet->playerId.binaryAddress;
existingServerIndex=gameServerList.GetIndexByPlayerID(serverPlayerID);
if (existingServerIndex>=0)
{
gameServerList.serverList[existingServerIndex]->Clear();
delete gameServerList.serverList[existingServerIndex];
gameServerList.serverList.RemoveAtIndex(existingServerIndex);
}
//else
// Server does not already exist
#ifdef _SHOW_MASTER_SERVER_PRINTF
printf("%i servers on the list\n", gameServerList.serverList.Size());
#endif
}
Packet* RakServer::Receive( void )
{
Packet * packet = RakPeer::Receive();
// This is just a regular time based update. Nowhere else good to put it
if ( RakPeer::IsActive() && occasionalPing )
{
unsigned int time = RakNet::GetTime();
if ( time > broadcastPingsTime || ( packet && packet->data[ 0 ] == ID_RECEIVED_STATIC_DATA ) )
{
if ( time > broadcastPingsTime )
broadcastPingsTime = time + 30000; // Broadcast pings every 30 seconds
unsigned i, count;
RemoteSystemStruct *remoteSystem;
RakNet::BitStream bitStream( ( PlayerID_Size + sizeof( short ) ) * 32 + sizeof(unsigned char) );
unsigned char typeId = ID_BROADCAST_PINGS;
bitStream.Write( typeId );
for ( i = 0, count = 0; count < 32 && i < remoteSystemListSize; i++ )
{
remoteSystem = remoteSystemList + i;
if ( remoteSystem->playerId != UNASSIGNED_PLAYER_ID )
{
bitStream.Write( remoteSystem->playerId.binaryAddress );
bitStream.Write( remoteSystem->playerId.port );
bitStream.Write( remoteSystem->pingAndClockDifferential[ remoteSystem->pingAndClockDifferentialWriteIndex ].pingTime );
count++;
}
}
if ( count > 0 ) // If we wrote anything
{
if ( packet && packet->data[ 0 ] == ID_NEW_INCOMING_CONNECTION ) // If this was a new connection
Send( &bitStream, SYSTEM_PRIORITY, RELIABLE, 0, packet->playerId, false ); // Send to the new connection
else
Send( &bitStream, SYSTEM_PRIORITY, RELIABLE, 0, UNASSIGNED_PLAYER_ID, true ); // Send to everyone
}
}
}
// This is just a regular time based update. Nowhere else good to put it
if ( RakPeer::IsActive() && synchronizedRandomInteger )
{
unsigned int time = RakNet::GetTime();
if ( time > nextSeedUpdate || ( packet && packet->data[ 0 ] == ID_NEW_INCOMING_CONNECTION ) )
{
if ( time > nextSeedUpdate )
nextSeedUpdate = time + 9000; // Seeds are updated every 9 seconds
seed = nextSeed;
nextSeed = randomMT();
if ( nextSeed % 2 == 0 ) // Even
nextSeed--; // make odd
/*
SetRandomNumberSeedStruct s;
s.ts = ID_TIMESTAMP;
s.timeStamp = RakNet::GetTime();
s.typeId = ID_SET_RANDOM_NUMBER_SEED;
s.seed = seed;
s.nextSeed = nextSeed;
RakNet::BitStream s_BitS( SetRandomNumberSeedStruct_Size );
s.Serialize( s_BitS );
*/
RakNet::BitStream outBitStream(sizeof(unsigned char)+sizeof(unsigned int)+sizeof(unsigned char)+sizeof(unsigned int)+sizeof(unsigned int));
outBitStream.Write((unsigned char) ID_TIMESTAMP);
outBitStream.Write((unsigned int) RakNet::GetTime());
outBitStream.Write((unsigned char) ID_SET_RANDOM_NUMBER_SEED);
outBitStream.Write(seed);
outBitStream.Write(nextSeed);
if ( packet && packet->data[ 0 ] == ID_NEW_INCOMING_CONNECTION )
Send( &outBitStream, SYSTEM_PRIORITY, RELIABLE, 0, packet->playerId, false );
else
Send( &outBitStream, SYSTEM_PRIORITY, RELIABLE, 0, UNASSIGNED_PLAYER_ID, true );
}
}
if ( packet )
{
// Intercept specific client / server feature packets. This will do an extra send and still pass on the data to the user
if ( packet->data[ 0 ] == ID_RECEIVED_STATIC_DATA )
{
if ( relayStaticClientData )
{
// Relay static data to the other systems but the sender
RakNet::BitStream bitStream( packet->length + PlayerID_Size );
unsigned char typeId = ID_REMOTE_STATIC_DATA;
bitStream.Write( typeId );
bitStream.Write( packet->playerId.binaryAddress );
bitStream.Write( packet->playerId.port );
bitStream.Write( packet->playerIndex );
bitStream.Write( ( char* ) packet->data + sizeof(unsigned char), packet->length - sizeof(unsigned char) );
Send( &bitStream, SYSTEM_PRIORITY, RELIABLE, 0, packet->playerId, true );
}
}
else
if ( packet->data[ 0 ] == ID_DISCONNECTION_NOTIFICATION || packet->data[ 0 ] == ID_CONNECTION_LOST || packet->data[ 0 ] == ID_NEW_INCOMING_CONNECTION )
{
// Relay the disconnection
RakNet::BitStream bitStream( packet->length + PlayerID_Size );
unsigned char typeId;
if ( packet->data[ 0 ] == ID_DISCONNECTION_NOTIFICATION )
typeId = ID_REMOTE_DISCONNECTION_NOTIFICATION;
else
if ( packet->data[ 0 ] == ID_CONNECTION_LOST )
typeId = ID_REMOTE_CONNECTION_LOST;
else
typeId = ID_REMOTE_NEW_INCOMING_CONNECTION;
bitStream.Write( typeId );
bitStream.Write( packet->playerId.binaryAddress );
bitStream.Write( packet->playerId.port );
bitStream.Write( ( unsigned short& ) packet->playerIndex );
Send( &bitStream, SYSTEM_PRIORITY, RELIABLE, 0, packet->playerId, true );
if ( packet->data[ 0 ] == ID_NEW_INCOMING_CONNECTION )
{
unsigned i;
for ( i = 0; i < remoteSystemListSize; i++ )
{
if ( remoteSystemList[ i ].playerId != UNASSIGNED_PLAYER_ID && packet->playerId != remoteSystemList[ i ].playerId )
{
bitStream.Reset();
typeId = ID_REMOTE_EXISTING_CONNECTION;
bitStream.Write( typeId );
bitStream.Write( remoteSystemList[ i ].playerId.binaryAddress );
bitStream.Write( remoteSystemList[ i ].playerId.port );
bitStream.Write( ( unsigned short ) i );
// One send to tell them of the connection
Send( &bitStream, SYSTEM_PRIORITY, RELIABLE, 0, packet->playerId, false );
if ( relayStaticClientData )
{
bitStream.Reset();
typeId = ID_REMOTE_STATIC_DATA;
bitStream.Write( typeId );
bitStream.Write( remoteSystemList[ i ].playerId.binaryAddress );
bitStream.Write( remoteSystemList[ i ].playerId.port );
bitStream.Write( (unsigned short) i );
bitStream.Write( ( char* ) remoteSystemList[ i ].staticData.GetData(), remoteSystemList[ i ].staticData.GetNumberOfBytesUsed() );
// Another send to tell them of the static data
Send( &bitStream, SYSTEM_PRIORITY, RELIABLE, 0, packet->playerId, false );
}
}
}
}
}
}
return packet;
}
PacketId CNetServer::ProcessPacket(RakNet::SystemAddress systemAddress, PacketId packetId, unsigned char * ucData, int iLength)
{
// Get the player id
EntityId playerId = (EntityId)systemAddress.systemIndex;
// Is the player not fully connected yet?
if(!IsPlayerConnected(playerId))
{
// Is this a disconnection or connection lost packet?
if(packetId == ID_DISCONNECTION_NOTIFICATION || packetId == ID_CONNECTION_LOST)
{
// Ignore it
return INVALID_PACKET_ID;
}
// Is this not a pre-connect packet?
if(packetId != ID_NEW_INCOMING_CONNECTION && packetId != ID_USER_PACKET_ENUM)
{
// Don't process the packet
return INVALID_PACKET_ID;
}
}
// Does the packet need processing?
switch(packetId)
{
case ID_NEW_INCOMING_CONNECTION: // Request initial data
{
// Construct the bit stream
CBitStream bitStream;
// Write the packet id
bitStream.Write((PacketId)ID_USER_PACKET_ENUM);
// Send the packet
Send(&bitStream, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, false);
return INVALID_PACKET_ID;
}
break;
case ID_USER_PACKET_ENUM: // Receive initial data
{
// Construct the bit stream
CBitStream bitStream(ucData, iLength, false);
// Read the network version
BYTE byteNetworkModuleVersion;
if(!bitStream.Read(byteNetworkModuleVersion))
{
// Reject the players connection
RejectKick(playerId);
return INVALID_PACKET_ID;
}
// Verify the network module version
if(byteNetworkModuleVersion != NETWORK_MODULE_VERSION)
{
// Reject the players connection
RejectKick(playerId);
return INVALID_PACKET_ID;
}
// Construct the new player socket
CPlayerSocket * pPlayerSocket = new CPlayerSocket;
// Set the player socket id
pPlayerSocket->playerId = playerId;
// Set the player socket binary address
pPlayerSocket->ulBinaryAddress = systemAddress.address.addr4.sin_addr.s_addr;
// Set the player socket port
pPlayerSocket->usPort = ntohs(systemAddress.address.addr4.sin_port);
// Add the player socket to the player socket list
m_playerSocketList.push_back(pPlayerSocket);
// Reset the bit stream for reuse
bitStream.Reset();
// Write the packet id
bitStream.Write((PacketId)(ID_USER_PACKET_ENUM + 1));
// Send the packet
Send(&bitStream, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, playerId, false);
return INVALID_PACKET_ID;
}
break;
case (ID_USER_PACKET_ENUM + 1): // Client is ready
return PACKET_NEW_CONNECTION;
break;
case ID_DISCONNECTION_NOTIFICATION:
return PACKET_DISCONNECTED;
break;
case ID_CONNECTION_LOST:
return PACKET_LOST_CONNECTION;
break;
}
// Is the packet a non processed RakNet packet?
if(packetId < INTERNAL_PACKET_END)
return INVALID_PACKET_ID;
// No processing needed
return packetId;
}
// client / slave code
void DynamicActorReplicaComponent::deserialize(RakNet::DeserializeParameters *deserializeParameters)
{
// a little base class magic
SLBaseClass::deserialize(deserializeParameters);
RakNet::BitStream& bitStream(deserializeParameters->serializationBitstream[0]);
if (bitStream.GetNumberOfBitsUsed()==0) {
return;
}
//Old Way:
//bitStream.ReadAlignedBytes( (unsigned char *)&_actorDatagram, sizeof(Dynamic2DActorDatagram) );
Compressed_Dynamic2DActorDatagram comValues;
bitStream.ReadAlignedBytes( (unsigned char *)&comValues, sizeof(Compressed_Dynamic2DActorDatagram) );
_actorDatagram._x = comValues._x;
_actorDatagram._y = comValues._y;
_actorDatagram._fx = TCompressedFixpoint<float,char,8>::readInflate(comValues._fx, -1.0f, 1.0f );
_actorDatagram._fy = TCompressedFixpoint<float,char,8>::readInflate(comValues._fy, -1.0f, 1.0f );
_killCount = _actorDatagram._killCount = comValues._killCount;
_actorDatagram._lvx = comValues._lvx;
_actorDatagram._lvy = comValues._lvy;
_actorDatagram._avz = comValues._avz;
_actorDatagram._updateTick = comValues._updateTick;
_killCount = _actorDatagram._killCount;
if(getActorSprite() == nullptr) {
return;
}
AbstractVehicle* vehicle(getActorSprite()->getVehicle());
if(vehicle != nullptr) {
Vec3 serverPosition(
_actorDatagram._x,
_actorDatagram._y,
0.0f
);
Vec3 serverForward(
_actorDatagram._fx,
_actorDatagram._fy,
0.0f
);
Vec3 serverLinearVelocity(
_actorDatagram._lvx,
_actorDatagram._lvy,
0.0f
);
Vec3 serverAngularVelocity(
0.0f,
0.0f,
_actorDatagram._avz
);
float linearInterpolationFactor(0.95f);
Vec3 newPosition(ProtocolUtilities::interpolateNetVector(vehicle->position(),
serverPosition, linearInterpolationFactor));
Vec3 newForward(ProtocolUtilities::interpolateNetVector(vehicle->forward(),
serverForward, linearInterpolationFactor));
Vec3 newLinearVelocity(ProtocolUtilities::interpolateNetVector(vehicle->linearVelocity(),
serverLinearVelocity, linearInterpolationFactor));
Vec3 newAngularVelocity(ProtocolUtilities::interpolateNetVector(vehicle->angularVelocity(),
serverAngularVelocity, linearInterpolationFactor));
vehicle->setPosition(newPosition);
vehicle->regenerateLocalSpace(newForward, 0.0f);
vehicle->setLinearVelocity(newLinearVelocity);
vehicle->setAngularVelocity(newAngularVelocity);
// very important to notify the vehicle that
// it's internal state has been changed from the outside
// see PhysicsVehicle::update
vehicle->setDirty();
_localSpaceData = vehicle->getLocalSpaceData();
_motionState.readLocalSpaceData(_localSpaceData);
}
}
Packet* RakClient::Receive( void )
{
Packet * packet = RakPeer::Receive();
// Intercept specific client / server feature packets
if ( packet )
{
RakNet::BitStream bitStream( ( char* ) packet->data, packet->length, false );
int i;
if ( packet->data[ 0 ] == ID_CONNECTION_REQUEST_ACCEPTED )
{
// ConnectionAcceptStruct cas;
// cas.Deserialize(bitStream);
// unsigned short remotePort;
// PlayerID externalID;
PlayerIndex playerIndex;
RakNet::BitStream inBitStream((char*)packet->data, packet->length, false);
inBitStream.IgnoreBits(8); // ID_CONNECTION_REQUEST_ACCEPTED
inBitStream.IgnoreBits(8 * sizeof(unsigned short)); //inBitStream.Read(remotePort);
inBitStream.IgnoreBits(8 * sizeof(unsigned int)); //inBitStream.Read(externalID.binaryAddress);
inBitStream.IgnoreBits(8 * sizeof(unsigned short)); //inBitStream.Read(externalID.port);
inBitStream.Read(playerIndex);
localPlayerIndex = playerIndex;
packet->playerIndex = playerIndex;
}
else if (
packet->data[ 0 ] == ID_REMOTE_NEW_INCOMING_CONNECTION ||
packet->data[ 0 ] == ID_REMOTE_EXISTING_CONNECTION ||
packet->data[ 0 ] == ID_REMOTE_DISCONNECTION_NOTIFICATION ||
packet->data[ 0 ] == ID_REMOTE_CONNECTION_LOST )
{
bitStream.IgnoreBits( 8 ); // Ignore identifier
bitStream.Read( packet->playerId.binaryAddress );
bitStream.Read( packet->playerId.port );
if ( bitStream.Read( ( unsigned short& ) packet->playerIndex ) == false )
{
DeallocatePacket( packet );
return 0;
}
if ( packet->data[ 0 ] == ID_REMOTE_DISCONNECTION_NOTIFICATION ||
packet->data[ 0 ] == ID_REMOTE_CONNECTION_LOST )
{
i = GetOtherClientIndexByPlayerID( packet->playerId );
if ( i >= 0 )
otherClients[ i ].isActive = false;
}
}
else if ( packet->data[ 0 ] == ID_REMOTE_STATIC_DATA )
{
bitStream.IgnoreBits( 8 ); // Ignore identifier
bitStream.Read( packet->playerId.binaryAddress );
bitStream.Read( packet->playerId.port );
bitStream.Read( packet->playerIndex ); // ADDED BY KURI
i = GetOtherClientIndexByPlayerID( packet->playerId );
if ( i < 0 )
i = GetFreeOtherClientIndex();
if ( i >= 0 )
{
otherClients[ i ].playerId = packet->playerId;
otherClients[ i ].isActive = true;
otherClients[ i ].staticData.Reset();
// The static data is what is left over in the stream
otherClients[ i ].staticData.Write( ( char* ) bitStream.GetData() + BITS_TO_BYTES( bitStream.GetReadOffset() ), bitStream.GetNumberOfBytesUsed() - BITS_TO_BYTES( bitStream.GetReadOffset() ) );
}
}
else if ( packet->data[ 0 ] == ID_BROADCAST_PINGS )
{
PlayerID playerId;
int index;
bitStream.IgnoreBits( 8 ); // Ignore identifier
for ( i = 0; i < 32; i++ )
{
if ( bitStream.Read( playerId.binaryAddress ) == false )
break; // No remaining data!
bitStream.Read( playerId.port );
index = GetOtherClientIndexByPlayerID( playerId );
if ( index >= 0 )
bitStream.Read( otherClients[ index ].ping );
else
{
index = GetFreeOtherClientIndex();
if ( index >= 0 )
{
otherClients[ index ].isActive = true;
bitStream.Read( otherClients[ index ].ping );
otherClients[ index ].playerId = playerId;
otherClients[ index ].staticData.Reset();
}
else
bitStream.IgnoreBits( sizeof( short ) * 8 );
}
}
DeallocatePacket( packet );
return 0;
}
else if ( packet->data[ 0 ] == ID_TIMESTAMP &&
packet->length == sizeof(unsigned char)+sizeof(unsigned int)+sizeof(unsigned char)+sizeof(unsigned int)+sizeof(unsigned int) )
{
/*
RakNet::BitStream s_BitS( (char *)packet->data, SetRandomNumberSeedStruct_Size, false );
SetRandomNumberSeedStruct s;
s.Deserialize( s_BitS );
*/
RakNet::BitStream inBitStream((char *)packet->data, packet->length, false);
/*
unsigned char ts;
unsigned int timeStamp;
unsigned char typeId;
unsigned int seed;
unsigned int nextSeed;
*/
unsigned int timeStamp;
unsigned char typeId;
unsigned int in_seed;
unsigned int in_nextSeed;
inBitStream.IgnoreBits(8); // ID_TIMESTAMP
inBitStream.Read(timeStamp);
inBitStream.Read(typeId); // ID_SET_RANDOM_NUMBER_SEED ?
// Check to see if this is a user TIMESTAMP message which
// accidentally has length SetRandomNumberSeedStruct_Size
if ( typeId != ID_SET_RANDOM_NUMBER_SEED )
return packet;
inBitStream.Read(in_seed);
inBitStream.Read(in_nextSeed);
seed = in_seed;
nextSeed = in_nextSeed;
nextSeedUpdate = timeStamp + 9000; // Seeds are updated every 9 seconds
DeallocatePacket( packet );
return 0;
}
}
return packet;
}
PacketId CNetClient::ProcessPacket(RakNet::SystemAddress systemAddress, PacketId packetId, unsigned char * ucData, int iLength)
{
// Get the player id
EntityId playerId = (EntityId)systemAddress.systemIndex;
// Are we not fully connected yet?
if(!m_bConnected)
{
// Is this not a pre-connect packet?
switch(packetId)
{
case ID_USER_PACKET_ENUM:
case (ID_USER_PACKET_ENUM + 1):
case PACKET_CONNECTION_REJECTED:
case ID_CONNECTION_ATTEMPT_FAILED:
case ID_ALREADY_CONNECTED:
case ID_NO_FREE_INCOMING_CONNECTIONS:
case ID_CONNECTION_BANNED:
case ID_INVALID_PASSWORD:
break;
default:
// Don't process the packet
return INVALID_PACKET_ID;
}
}
// Does the packet need processing?
switch(packetId)
{
//case ID_CONNECTION_REQUEST_ACCEPTED: // No longer used (See (ID_USER_PACKET_ENUM + 1))
case ID_USER_PACKET_ENUM: // Send initial data
{
// Construct the bit stream
CBitStream bitStream(ucData, iLength, false);
// Set our server address
m_serverAddress = systemAddress;
// Set the player socket id
m_serverSocket.playerId = playerId;
// Set the player socket binary address
m_serverSocket.ulBinaryAddress = systemAddress.address.addr4.sin_addr.s_addr;
// Set the player socket port
m_serverSocket.usPort = ntohs(systemAddress.address.addr4.sin_port);
// Reset the bit stream for reuse
CBitStream bitStreamSend;
// Write the packet id
bitStreamSend.Write((PacketId)ID_USER_PACKET_ENUM);
// Write the network module version
bitStreamSend.Write((BYTE)NETWORK_MODULE_VERSION);
// Send the packet
m_bConnected = true;
Send(&bitStreamSend, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, false);
m_bConnected = false;
return INVALID_PACKET_ID;
}
break;
case (ID_USER_PACKET_ENUM + 1): // Connection accepted
{
// Set our connected state
m_bConnected = true;
// Construct the bit stream
CBitStream bitStream;
// Write the packet id
bitStream.Write((PacketId)(ID_USER_PACKET_ENUM + 1));
// Send the packet
Send(&bitStream, PRIORITY_HIGH, RELIABILITY_RELIABLE_ORDERED, false);
return PACKET_CONNECTION_SUCCEEDED;
}
break;
case ID_CONNECTION_ATTEMPT_FAILED:
return PACKET_CONNECTION_FAILED;
break;
case ID_ALREADY_CONNECTED:
return PACKET_ALREADY_CONNECTED;
break;
case ID_NO_FREE_INCOMING_CONNECTIONS:
return PACKET_SERVER_FULL;
break;
case ID_DISCONNECTION_NOTIFICATION:
return PACKET_DISCONNECTED;
break;
case ID_CONNECTION_LOST:
return PACKET_LOST_CONNECTION;
break;
case PACKET_CONNECTION_REJECTED:
return PACKET_CONNECTION_REJECTED;
break;
case ID_CONNECTION_BANNED:
return PACKET_BANNED;
break;
case ID_INVALID_PASSWORD:
return PACKET_PASSWORD_INVALID;
break;
}
// Is the packet a non processed RakNet packet?
if(packetId < INTERNAL_PACKET_END)
return INVALID_PACKET_ID;
// No translation needed
return packetId;
}
std::string PhraseTableCreator::CompressEncodedCollection(std::string encodedCollection)
{
enum EncodeState {
ReadSymbol, ReadScore, ReadAlignment,
EncodeSymbol, EncodeScore, EncodeAlignment
};
EncodeState state = ReadSymbol;
unsigned phraseStopSymbolId;
if(m_coding == REnc)
phraseStopSymbolId = EncodeREncSymbol1(GetTargetSymbolId(m_phraseStopSymbol));
else if(m_coding == PREnc)
phraseStopSymbolId = EncodePREncSymbol1(GetTargetSymbolId(m_phraseStopSymbol));
else
phraseStopSymbolId = GetTargetSymbolId(m_phraseStopSymbol);
AlignPoint alignStopSymbol(-1, -1);
std::stringstream encodedStream(encodedCollection);
encodedStream.unsetf(std::ios::skipws);
std::string compressedEncodedCollection;
BitWrapper<> bitStream(compressedEncodedCollection);
unsigned symbol;
float score;
size_t currScore = 0;
AlignPoint alignPoint;
while(encodedStream) {
switch(state) {
case ReadSymbol:
encodedStream.read((char*) &symbol, sizeof(unsigned));
state = EncodeSymbol;
break;
case ReadScore:
if(currScore == m_numScoreComponent) {
currScore = 0;
if(m_useAlignmentInfo)
state = ReadAlignment;
else
state = ReadSymbol;
} else {
encodedStream.read((char*) &score, sizeof(float));
currScore++;
state = EncodeScore;
}
break;
case ReadAlignment:
encodedStream.read((char*) &alignPoint, sizeof(AlignPoint));
state = EncodeAlignment;
break;
case EncodeSymbol:
state = (symbol == phraseStopSymbolId) ? ReadScore : ReadSymbol;
m_symbolTree->Put(bitStream, symbol);
break;
case EncodeScore: {
state = ReadScore;
size_t idx = m_multipleScoreTrees ? currScore-1 : 0;
if(m_quantize)
score = m_scoreCounters[idx]->LowerBound(score);
m_scoreTrees[idx]->Put(bitStream, score);
}
break;
case EncodeAlignment:
state = (alignPoint == alignStopSymbol) ? ReadSymbol : ReadAlignment;
m_alignTree->Put(bitStream, alignPoint);
break;
}
}
return compressedEncodedCollection;
}
void Video::run(const char* ip) {
unsigned int maxConnectionsAllowed = 1;
unsigned int maxPlayersPerServer = 1;
unsigned short serverPort = 7000;
RakNet::RakPeerInterface *rakPeer = RakNet::RakPeerInterface::GetInstance();
RakNet::SocketDescriptor socketDescriptor(serverPort, 0);
if (rakPeer->Startup(maxConnectionsAllowed, &socketDescriptor, 1) != RakNet::RAKNET_STARTED) {
std::cerr << "Startup fail:" << std::endl;
RakNet::RakPeerInterface::DestroyInstance(rakPeer);
return;
}
rakPeer->SetMaximumIncomingConnections(maxPlayersPerServer);
RakNet::Packet *packet;
unsigned char typeId;
bool connected = false;
char key;
RakNet::SystemAddress address;
if (ip) {
std::cout << "Connect: " << ip << std::endl;
rakPeer->Connect(ip, serverPort, 0, 0);
}
cv::namedWindow("MyVideo", CV_WINDOW_AUTOSIZE | CV_GUI_NORMAL);
cv::createTrackbar("AlphaTrackbar", "MyVideo", &alpha_slider, 100);
capture.open(0);
if (!capture.isOpened()) {
std::cout << "Capture open fail" << std::endl;
return;
}
capture.set(CV_CAP_PROP_FRAME_WIDTH, 320);
capture.set(CV_CAP_PROP_FRAME_HEIGHT, 240);
capture.set(CV_CAP_PROP_FOURCC, CV_FOURCC('X', '2', '6', '4'));
cv::namedWindow("RemoteVideo", 1);
while (1) {
const time_t t = time(NULL);
struct tm* current_time = localtime(&t);
std::cout << "current time is " << current_time->tm_sec << std::endl;
cv::Mat frame;
capture.read(frame);
cv::imshow("MyVideo", frame);
packet = rakPeer->Receive();
if (packet) {
RakNet::BitStream bitStream(packet->data, packet->length, false);
bitStream.Read(typeId);
switch (typeId) {
case ID_CONNECTION_REQUEST_ACCEPTED:
{
std::cout << "ID_CONNECTION_REQUEST_ACCEPTED" << ip << std::endl;
address = packet->systemAddress;
connected = true;
break;
}
case ID_NEW_INCOMING_CONNECTION:
{
std::cout << "ID_NEW_INCOMING_CONNECTION" << ip << std::endl;
address = packet->systemAddress;
connected = true;
break;
}
case ID_DISCONNECTION_NOTIFICATION:
{
connected = false;
break;
}
case ID_CONNECTION_LOST:
{
connected = false;
break;
}
case ID_USER_PACKET_ENUM:
{
int cols, rows, type, channels, size;
bitStream.Read(cols);
bitStream.Read(rows);
bitStream.Read(type);
bitStream.Read(channels);
bitStream.Read(size);
char* data = new char[size];
bitStream.Read(data, size);
cv::Mat mat(cols, rows, type, (uchar*)data);
cv::imshow("RemoteVideo", mat.reshape(channels, rows));
delete data;
break;
}
default:
break;
}
rakPeer->DeallocatePacket(packet);
}
if (connected) {
int size = frame.total()*frame.elemSize();
RakNet::BitStream sendStream;
sendStream.Write((RakNet::MessageID)ID_USER_PACKET_ENUM);
sendStream.Write(frame.cols);
sendStream.Write(frame.rows);
sendStream.Write((int)frame.type());
sendStream.Write(frame.channels());
sendStream.Write(size);
sendStream.Write((const char *)frame.data, size);
rakPeer->Send(&sendStream, LOW_PRIORITY, UNRELIABLE_SEQUENCED, 0, address, false);
//rakPeer->Send(&sendStream, IMMEDIATE_PRIORITY, UNRELIABLE_SEQUENCED, 0, RakNet::UNASSIGNED_SYSTEM_ADDRESS, true);
}
key = cvWaitKey(10);
if (char(key) == 27) {
break;
}
}
rakPeer->Shutdown(300);
RakNet::RakPeerInterface::DestroyInstance(rakPeer);
cv::destroyAllWindows();
}
