// ============================================================================= // Nat Ryall 11-Jul-2008 // ============================================================================= void CPlayer::Move(t_PlayerDirection iDirection) { m_pTargetBlock = m_pCurrentBlock->m_pAdjacents[iDirection]; m_iMoveDir = iDirection; m_iTransitionDir = iDirection; m_iTime = 0; m_fTransition = 0.f; if (m_pCurrentBlock->m_pAdjacents[iDirection]) SetState(PlayerState_Move); else { m_bLeaving = true; SetState(PlayerState_Warp); } // Network. if (NetworkManager.IsRunning()) { if (m_iLogicType == PlayerLogicType_Local || m_iLogicType == PlayerLogicType_AI) { BitStream xStream; xStream.Write((xuint8)PlayerStreamType_Move); xStream.Write((xuint8)m_iIndex); xStream.Write((xuint8)iDirection); NetworkManager.Broadcast(NULL, NetworkStreamType_PlayerUpdate, &xStream, HIGH_PRIORITY, RELIABLE_ORDERED); } } }
void TeamBalancer::NotifyNoTeam(RakNetGUID target) { BitStream bsOut; bsOut.Write((MessageID)ID_TEAM_BALANCER_TEAM_ASSIGNED); bsOut.Write((unsigned char)UNASSIGNED_TEAM_ID); rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,target,false); }
void RelayPlugin::SendMessageToRoom(StrAndGuidAndRoom **strAndGuidSender, BitStream* message) { if ((*strAndGuidSender)->currentRoom.IsEmpty()) return; for (unsigned int i=0; i < chatRooms.Size(); i++) { if (chatRooms[i]->roomName==(*strAndGuidSender)->currentRoom) { BitStream bsOut; bsOut.WriteCasted<MessageID>(ID_RELAY_PLUGIN); bsOut.WriteCasted<MessageID>(RPE_GROUP_MSG_FROM_SERVER); message->ResetReadPointer(); bsOut.WriteCompressed((*strAndGuidSender)->str); bsOut.AlignWriteToByteBoundary(); bsOut.Write(message); RP_Group *room = chatRooms[i]; for (unsigned int i=0; i < room->usersInRoom.Size(); i++) { if (room->usersInRoom[i].guid!=(*strAndGuidSender)->guid) SendUnified(&bsOut, HIGH_PRIORITY, RELIABLE_ORDERED, 0, room->usersInRoom[i].guid, false); } break; } } }
void LobbyMenu::HandleKey( int key, int x, int y ) { BaseMenu::HandleKey(key, x, y); if((key == KEY_ENTER) || (key == KEY_SPACE)) { switch(m_nSelectedItem) { case GOTO_LAST_MENU: { BaseMenu *menu = dynamic_cast<BaseMenu*>(menuSystem->mainMenu); if(menu != NULL) { menuSystem->Switch(menu); } } break; case 1: { menuSystem->StartGame(); BitStream * stream = new BitStream(); stream->Write((MessageID)END_YOUR_TURN); Network::GetInstance()->Message(stream); delete stream; } break; } } }
// ******************************************************************************************** void Block::StoreDNAHuf(BitStream &bit_stream, LzMatcher &lz_matcher, uchar *sym_code, HuffmanEncoder::Code *sym_huf_codes, bool try_lz) { // Info about LZ matches if (try_lz) { FindLzMatches(lz_matcher); StoreLzMatches(bit_stream, lz_matcher); for (uint32 i = 0; i < rec_count; ++i) { uint32 cur_sequence_len = records[i].sequence_len; uchar *cur_sequence = records[i].sequence; for (uint32 j = lz_matches[i].length; j < cur_sequence_len; ++j) { bit_stream.PutBits(sym_huf_codes[sym_code[cur_sequence[j]]].code, sym_huf_codes[sym_code[cur_sequence[j]]].len); } } } else { for (uint32 i = 0; i < rec_count; ++i) { uint32 cur_sequence_len = records[i].sequence_len; uchar *cur_sequence = records[i].sequence; for (uint32 j = 0; j < cur_sequence_len; ++j) { bit_stream.PutBits(sym_huf_codes[sym_code[cur_sequence[j]]].code, sym_huf_codes[sym_code[cur_sequence[j]]].len); } } } bit_stream.FlushPartialWordBuffer(); }
void TeamBalancer::NotifyTeamsLocked(RakNetGUID target, TeamId requestedTeam) { BitStream bsOut; bsOut.Write((MessageID)ID_TEAM_BALANCER_REQUESTED_TEAM_LOCKED); bsOut.Write(requestedTeam); rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,target,false); }
pair<SystemAddress, QueryData> QueryClient::Update(const RakNet::SystemAddress &addr) { qDebug() << "Locking mutex in QueryClient::Update(RakNet::SystemAddress addr)"; pair<SystemAddress, QueryData> server; BitStream bs; bs.Write((unsigned char) (ID_MASTER_UPDATE)); bs.Write(addr); mxServers.lock(); status = -1; int attempts = 3; pmu->SetServer(&server); do { if (Connect() == IS_NOT_CONNECTED) { qDebug() << IS_NOT_CONNECTED; qDebug() << "Unlocking mutex in QueryClient::Update(RakNet::SystemAddress addr)"; mxServers.unlock(); return server; } peer->Send(&bs, HIGH_PRIORITY, RELIABLE_ORDERED, CHANNEL_MASTER, masterAddr, false); status = GetAnswer(ID_MASTER_UPDATE); RakSleep(100); } while(status != ID_MASTER_UPDATE && attempts-- > 0); if(status != ID_MASTER_UPDATE) qDebug() << "Getting update was failed"; peer->CloseConnection(masterAddr, true); qDebug() << "Unlocking mutex in QueryClient::Update(RakNet::SystemAddress addr)"; mxServers.unlock(); return server; }
void NetInterface::handleConnectChallengeRequest(const NetAddress *addr, BitStream *stream) { char buf[256]; Net::addressToString(addr, buf); Con::printf("Got Connect challenge Request from %s", buf); if(!mAllowConnections) return; U32 connectSequence; stream->read(&connectSequence); if(!mRandomDataInitialized) initRandomData(); U32 addressDigest[4]; computeNetMD5(addr, connectSequence, addressDigest); BitStream *out = BitStream::getPacketStream(); out->write(U8(ConnectChallengeResponse)); out->write(connectSequence); out->write(addressDigest[0]); out->write(addressDigest[1]); out->write(addressDigest[2]); out->write(addressDigest[3]); BitStream::sendPacketStream(addr); }
int Golomb::decode(uint m, int *value, BitStream& bs){ int q = 0, r, v; int nbits = (int) floor(log2(m)) + 1; int err; uint32_t bit; do { if ((err=bs.readBit(&bit)) != 0) return err; if (bit == 0) break; q++; } while(true); if ((err = bs.readBits(nbits, &bit)) != 0) return err; r = (int) bit; v = q * m + r; if (v % 2 == 0) *value = v/2; else *value = -(v+1)/2; return 0; }
void RakClient::RequestClass( int classId ) { BitStream bsClass; bsClass.Write( classId ); g_RakClient->RPC( RPC_RequestClass, &bsClass ); }
void Character::GetCharBuildInfo(BitStream &src) { src.GetString(m_char_data.m_class_name); src.GetString(m_char_data.m_origin_name); qInfo() << "Loading Starting Character Settings..."; QSettings config(Settings::getSettingsPath(),QSettings::IniFormat,nullptr); config.beginGroup("StartingCharacter"); QRegExp space("\\s"); QStringList inherent_and_preorders = config.value(QStringLiteral("inherent_powers"), "Brawl").toString().remove(space).split(','); QStringList starting_temps = config.value(QStringLiteral("starting_temps"), "EMP_Glove").toString().remove(space).split(','); QStringList starting_insps = config.value(QStringLiteral("starting_inspirations"), "Resurgence").toString().remove(space).split(','); uint startlevel = config.value(QStringLiteral("starting_level"), "1").toUInt() -1; //convert from 1-50 to 0-49 uint startinf = config.value(QStringLiteral("starting_inf"), "0").toUInt(); config.endGroup(); m_char_data.m_level = startlevel; m_char_data.m_influence = startinf; // Temporary Powers MUST come first (must be idx 0) addStartingPowers(QStringLiteral("Temporary_Powers"), QStringLiteral("Temporary_Powers"), starting_temps); addStartingPowers(QStringLiteral("Inherent"), QStringLiteral("Inherent"), inherent_and_preorders); getPowerFromBuildInfo(src); // primary, secondary // Now that character is created. Finalize level and update hp and end finalizeLevel(); setHPToMax(*this); // set max hp setEndToMax(*this); // set max end // This must come after finalize addStartingInspirations(starting_insps); // resurgence and phenomenal_luck m_char_data.m_trays.serializefrom(src); }
void ImageSpatialExtentsProperty::writeBox(BitStream& output) { writeFullBoxHeader(output); output.write32Bits(mImageWidth); output.write32Bits(mImageHeight); updateSize(output); }
//================================================================================================= bool QuestManager::Read(BitStream& stream) { const int QUEST_MIN_SIZE = sizeof(int) + sizeof(byte) * 3; word quest_count; if(!stream.Read(quest_count) || !EnsureSize(stream, QUEST_MIN_SIZE * quest_count)) { Error("Read world: Broken packet for quests."); return false; } quests.resize(quest_count); int index = 0; for(Quest*& quest : quests) { quest = new PlaceholderQuest; quest->quest_index = index; if(!stream.Read(quest->refid) || !stream.ReadCasted<byte>(quest->state) || !ReadString1(stream, quest->name) || !ReadStringArray<byte, word>(stream, quest->msgs)) { Error("Read world: Broken packet for quest %d.", index); return false; } ++index; } return true; }
void Server::Net_cbDataReceived( Net_ConnID _id, BitStream &_data) { Network::NetEvents event = (Network::NetEvents) _data.getInt(8); switch( event ) { case Network::RConMsg: { std::string passwordSent = _data.getString(); if ( !gusGame.options.rConPassword.empty() && gusGame.options.rConPassword == passwordSent ) { //console.addQueueCommand(_data.getStringStatic()); console.parseLine(_data.getString()); } } break; case Network::ConsistencyInfo: { int clientProtocol = _data.getInt(32); if(clientProtocol != Network::protocolVersion) { network.disconnect(_id, Network::IncompatibleProtocol); } if(!gusGame.checkCRCs(_data) && network.checkCRC) // We call checkCRC anyway so that the stream is advanced network.disconnect(_id, Network::IncompatibleData); } break; } }
void test_bug2() { BitStream bs; bs.append_bit(0); bs.resize(3, 1); NUT_TA(bs.to_string() == "011"); }
int Golomb::encode(uint m, int value, BitStream& bs){ int q, r, i; int nbits = (int) floor(log2(m)) + 1; int err; if (value < 0 ) { value = 2*abs(value) - 1; } else { value *= 2; } q = value/m; r = value%m; for(i=0; i<q;i++) { if ((err = bs.writeBit(1))!= 0) return err; } if ((err = bs.writeBit(0))!= 0) return err; if ((err = bs.writeBits(r, nbits))!= 0){ return err; } return 0; }
void TeamBalancer::RequestAnyTeam(NetworkID memberId) { bool foundMatch=false; for (unsigned int i=0; i < myTeamMembers.Size(); i++) { if (myTeamMembers[i].memberId==memberId) { foundMatch=true; if (myTeamMembers[i].currentTeam!=UNASSIGNED_TEAM_ID) return; else myTeamMembers[i].requestedTeam=UNASSIGNED_TEAM_ID; break; } } if (foundMatch==false) { MyTeamMembers mtm; mtm.currentTeam=UNASSIGNED_TEAM_ID; mtm.memberId=memberId; mtm.requestedTeam=UNASSIGNED_TEAM_ID; myTeamMembers.Push(mtm, _FILE_AND_LINE_); } // Else send to the current host that we need a team. BitStream bsOut; bsOut.Write((MessageID)ID_TEAM_BALANCER_INTERNAL); bsOut.Write((MessageID)ID_REQUEST_ANY_TEAM); bsOut.Write(memberId); rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,hostGuid,false); }
void RelayPlugin::OnJoinGroupRequestFromClient(Packet *packet) { BitStream bsIn(packet->data, packet->length, false); bsIn.IgnoreBytes(sizeof(MessageID)*2); RakString groupName; bsIn.ReadCompressed(groupName); RelayPlugin::RP_Group *groupJoined = JoinGroup(packet->guid, groupName); BitStream bsOut; bsOut.WriteCasted<MessageID>(ID_RELAY_PLUGIN); if (groupJoined) { bsOut.WriteCasted<MessageID>(RPE_JOIN_GROUP_SUCCESS); bsOut.WriteCasted<uint16_t>(groupJoined->usersInRoom.Size()); for (unsigned int i=0; i < groupJoined->usersInRoom.Size(); i++) { bsOut.WriteCompressed(groupJoined->usersInRoom[i].str); } } else { bsOut.WriteCasted<MessageID>(RPE_JOIN_GROUP_FAILURE); } SendUnified(&bsOut, HIGH_PRIORITY, RELIABLE_ORDERED, 0, packet->guid, false); }
//-------------------------------------------------------------------------- void EntityS::SyncToClient() { if(m_pkAgent) { if(m_kSyncDirty.Size()) { BitStream kStream; kStream.Reset(); kStream << VeUInt8(ID_CLIENT_ENTITY_UPDATE); kStream << (const VeChar8*)m_kName; VE_ASSERT(m_kSyncDirty.Size() <= VE_UINT16_MAX); kStream << VeUInt16(m_kSyncDirty.Size()); m_kSyncDirty.BeginIterator(); while(!m_kSyncDirty.IsEnd()) { PropertySValue* pkValue = m_kSyncDirty.GetIterNode()->m_tContent; m_kSyncDirty.Next(); VE_ASSERT(pkValue); kStream << pkValue->GetField(); VE_ASSERT(pkValue->GetSize() <= 0xff); kStream.WriteAlignedBytesSafe((const VeChar8*)pkValue->GetClientData(), pkValue->GetClientSize(), VE_UINT8_MAX); } m_kSyncDirty.Clear(); m_pkAgent->SendPacket(kStream); } } }
bool UDPProxyClient::RequestForwarding(SystemAddress proxyCoordinator, SystemAddress sourceAddress, SystemAddress targetAddressAsSeenFromCoordinator, RakNet::TimeMS timeoutOnNoDataMS, RakNet::BitStream *serverSelectionBitstream) { // Return false if not connected ConnectionState cs = rakPeerInterface->GetConnectionState(proxyCoordinator); if (cs!=IS_CONNECTED) return false; // Pretty much a bug not to set the result handler, as otherwise you won't know if the operation succeeed or not RakAssert(resultHandler!=0); if (resultHandler==0) return false; BitStream outgoingBs; outgoingBs.Write((MessageID)ID_UDP_PROXY_GENERAL); outgoingBs.Write((MessageID)ID_UDP_PROXY_FORWARDING_REQUEST_FROM_CLIENT_TO_COORDINATOR); outgoingBs.Write(sourceAddress); outgoingBs.Write(true); outgoingBs.Write(targetAddressAsSeenFromCoordinator); outgoingBs.Write(timeoutOnNoDataMS); if (serverSelectionBitstream && serverSelectionBitstream->GetNumberOfBitsUsed()>0) { outgoingBs.Write(true); outgoingBs.Write(serverSelectionBitstream); } else { outgoingBs.Write(false); } rakPeerInterface->Send(&outgoingBs, MEDIUM_PRIORITY, RELIABLE_ORDERED, 0, proxyCoordinator, false); return true; }
void HevcSampleEntry::parseBox(BitStream& bitstr) { VisualSampleEntryBox::parseBox(bitstr); while (bitstr.numBytesLeft() > 0) { // Extract contained box bitstream and type std::string boxType; BitStream subBitStream = bitstr.readSubBoxBitStream(boxType); // Handle this box based on the type if (boxType == "hvcC") { mHevcConfigurationBox.parseBox(subBitStream); } else if (boxType == "ccst") { mCodingConstraintsBox.parseBox(subBitStream); mIsCodingConstraintsPresent = true; } else { logWarning() << "Skipping unknown box of type '" << boxType << "' inside HevcSampleEntry" << std::endl; } } }
//-------------------------------------------------------------------------- void ClientAgent::Disconnect() { BitStream kStream; kStream.Reset(); kStream << VeUInt8(ID_CLIENT_FORCE_DISCONNECT); SendPacket(kStream); }
void CompositionOffsetBox::parseBox(BitStream& bitstr) { // First parse the box header parseFullBoxHeader(bitstr); const std::uint32_t entryCount = bitstr.read32Bits(); if (getVersion() == 0) { for (uint32_t i = 0; i < entryCount; ++i) { EntryVersion0 entryVersion0; entryVersion0.mSampleCount = bitstr.read32Bits(); entryVersion0.mSampleOffset = bitstr.read32Bits(); mEntryVersion0.push_back(entryVersion0); } } else if (getVersion() == 1) { for (uint32_t i = 0; i < entryCount; ++i) { EntryVersion1 entryVersion1; entryVersion1.mSampleCount = bitstr.read32Bits(); entryVersion1.mSampleOffset = static_cast<std::int32_t>(bitstr.read32Bits()); mEntryVersion1.push_back(entryVersion1); } } }
void CLocalPlayer::DoDeathCheck() { // Have we not yet processed the death and is the local player dead? if(!CLocalPlayer::m_bIsDead && IsDead()) { // Get the kill info EntityId playerId = INVALID_ENTITY_ID; EntityId vehicleId = INVALID_ENTITY_ID; EntityId weaponId = INVALID_ENTITY_ID; GetKillInfo(&playerId, &vehicleId,&weaponId); CLogFile::Printf("HandleDeath(LocalPlayer, %d, %d, %d)", playerId, vehicleId, weaponId); g_pCore->GetChat()->Outputf(false, "HandleDeath(LocalPlayer, %d, %d, %d)", playerId, vehicleId, weaponId); // Send the death notification to the server BitStream bsSend; bsSend.WriteCompressed(playerId); bsSend.WriteCompressed(vehicleId); bsSend.WriteCompressed(weaponId); g_pCore->GetNetworkManager()->Call(GET_RPC_CODEX(RPC_PLAYER_DEATH), &bsSend, HIGH_PRIORITY, RELIABLE_ORDERED, true); // Mark ourselves as dead CLocalPlayer::m_bIsDead = true; // Delete the object CIVScript::DeleteObject(&m_pObj); // Reset vehicle entry/exit flags SetExitFlag(true); ResetVehicleEnterExit(); // Get current day time so we don't have to set the time always.. CGameFunction::GetTime(&m_iRespawnTime[0], &m_iRespawnTime[1]); } }
void EntityManager::sendEntities( BitStream &tgt ) const { Entity *pEnt = NULL; std::list<Entity *>::const_iterator iter = m_entlist.begin(); int last_idx; int delta;// sending delta between entities idxs -> assert(m_entlist.size()>0 && "Attempting to send empty entity list, the client will hang!"); if(iter!=m_entlist.end()) { pEnt = *iter; tgt.StorePackedBits(1,pEnt->getIdx()); last_idx = pEnt->getIdx(); pEnt->serializeto(tgt); iter++; } while(iter!=m_entlist.end()) { //assert(!"Only one for now"); pEnt = *iter; delta = pEnt->getIdx()-last_idx -1; tgt.StorePackedBits(1,delta); last_idx = pEnt->getIdx(); pEnt->serializeto(tgt); iter++; } // last entity marker tgt.StorePackedBits(1,0); // next ent tgt.StoreBits(1,1); // create/update -> create tgt.StoreBits(1,1); // empty entity. will finish the receiving loop }
void PreUpdateCommand::serializeto(BitStream &bs) const { bs.StorePackedBits(1, 13); for(const auto &command : m_contents) command->serializeto(bs); bs.StorePackedBits(1,0); // finalize the command list }
void Raknet::Disconnect() { // Tell Server we exited BitStream bsOut; bsOut.Write((RakNet::MessageID)ID_DISCONNECTION_NOTIFICATION); mPeer->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,mServerAddress,false); }
int getPackedBitsConditional( BitStream &bs,uint8_t numbits ) { if(bs.GetBits(1)) { return bs.GetPackedBits(numbits); } return 0; }
int NetStructure::getPackedBitsConditional( BitStream &bs,int numbits ) { if(bs.GetBits(1)) { return bs.GetPackedBits(numbits); } return 0; }
void TeamBalancer::NotifyTeamSwitchPending(RakNetGUID target, TeamId requestedTeam, NetworkID memberId) { BitStream bsOut; bsOut.Write((MessageID)ID_TEAM_BALANCER_REQUESTED_TEAM_FULL); bsOut.Write(requestedTeam); bsOut.Write(memberId); rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,target,false); }