C++ BitStream::Write方法代码示例

void TeamBalancer::NotifyTeamSwitchPending(RakNetGUID target, TeamId requestedTeam)
{
	BitStream bsOut;
	bsOut.Write((MessageID)ID_TEAM_BALANCER_REQUESTED_TEAM_CHANGE_PENDING);
	bsOut.Write(requestedTeam);
	rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,target,false);
}

void TeamBalancer::NotifyTeamsLocked(RakNetGUID target, TeamId requestedTeam)
{
	BitStream bsOut;
	bsOut.Write((MessageID)ID_TEAM_BALANCER_TEAMS_LOCKED);
	bsOut.Write(requestedTeam);
	rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,target,false);
}

void TeamBalancer::NotifyNoTeam(NetworkID memberId, RakNetGUID target)
{
	BitStream bsOut;
	bsOut.Write((MessageID)ID_TEAM_BALANCER_TEAM_ASSIGNED);
	bsOut.Write((unsigned char)UNASSIGNED_TEAM_ID);
	bsOut.Write(memberId);
	rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,target,false);
}

// misc functions
void  RakClient::SendDeath( uint16_t killerId, uint8_t reason )
{
    BitStream bsDeath;

    bsDeath.Write( reason );
    bsDeath.Write( killerId );
    g_RakClient->RPC( RPC_Death, &bsDeath );
}

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 TeamBalancer::NotifyTeamAssigment(unsigned int teamMemberIndex)
{
    RakAssert(teamMemberIndex < teamMembers.Size());
    if (teamMemberIndex>=teamMembers.Size())
        return;

    BitStream bsOut;
    bsOut.Write((MessageID)ID_TEAM_BALANCER_TEAM_ASSIGNED);
    bsOut.Write(teamMembers[teamMemberIndex].currentTeam);
    rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,teamMembers[teamMemberIndex].memberGuid,false);
}

void RelayPlugin::SendGroupMessage(const RakNetGUID &relayPluginServerGuid, BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel)
{
	BitStream bsOut;
	bsOut.WriteCasted<MessageID>(ID_RELAY_PLUGIN);
	bsOut.WriteCasted<MessageID>(RPE_GROUP_MESSAGE_FROM_CLIENT);
	bsOut.WriteCasted<unsigned char>(priority);
	bsOut.WriteCasted<unsigned char>(reliability);
	bsOut.Write(orderingChannel);
	bsOut.Write(bitStream);
	SendUnified(&bsOut, priority, reliability, orderingChannel, relayPluginServerGuid, false);
}

void  RakClient::SendSCMEvent( int vehicleID, int eventId, int param1, int param2 )
{
    BitStream bsScmEvent;

    bsScmEvent.Write ( vehicleID );
    bsScmEvent.Write ( param1 );
    bsScmEvent.Write ( param2 );
    bsScmEvent.Write ( eventId );

    RPC( RPC_ScmEvent, &bsScmEvent );
}

void MasterClient::DelistServer(void)
{
	BitStream bitStream;
	listServer=false;
	if (serverListed)
	{
		bitStream.Write((unsigned char)ID_MASTER_SERVER_DELIST_SERVER);
		bitStream.Write(localServer.connectionIdentifier.port);
        rakPeer->Send(&bitStream, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_PLAYER_ID, true);
		serverListed=false;
	}
}

// Send a message to a server running RelayPlugin, to forward a message to the system identified by \a key
void RelayPlugin::SendToParticipant(const RakNetGUID &relayPluginServerGuid, const RakString &key, BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel)
{
	BitStream bsOut;
	bsOut.WriteCasted<MessageID>(ID_RELAY_PLUGIN);
	bsOut.WriteCasted<MessageID>(RPE_MESSAGE_TO_SERVER_FROM_CLIENT);
	bsOut.WriteCasted<unsigned char>(priority);
	bsOut.WriteCasted<unsigned char>(reliability);
	bsOut.Write(orderingChannel);
	bsOut.WriteCompressed(key);
	bsOut.Write(bitStream);
	SendUnified(&bsOut, priority, reliability, orderingChannel, relayPluginServerGuid, false);
}

void TeamBalancer::CancelRequestSpecificTeam(void)
{
    // Clear out that we have requested a team.
    requestedTeam=UNASSIGNED_TEAM_ID;

    // Send packet to the host to remove our request flag.
    BitStream bsOut;
    bsOut.Write((MessageID)ID_TEAM_BALANCER_INTERNAL);
    bsOut.Write((MessageID)ID_CANCEL_TEAM_REQUEST);
    rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,hostGuid,false);

    expectingToReceiveTeamNumber=false;
}

void CText::Show(bool show)
{
	m_bShow = show;

	CPlayerManager * pPlayerManager = pNetowkManager->GetPlayerManager();
	for(EntityId i = 0; i < MAX_PLAYERS; i++) {
		if(pPlayerManager->GetSlotState(i)) {
			BitStream bsSend;
			bsSend.Write(m_iID);
			bsSend.Write(m_bShow);
			pNetowkManager->GetRPC4()->Call("Script_toggleTextForPlayer", &bsSend, HIGH_PRIORITY, RELIABLE, 0, pNetowkManager->GetRakPeer()->GetSystemAddressFromIndex(i), 0);
		}
	}
}

void TeamBalancer::RequestAnyTeam(void)
{
    // If we currently have a team, just return (does nothing)
    if (GetMyTeam()!=UNASSIGNED_TEAM_ID)
        return;

    // 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);
    rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,hostGuid,false);

    expectingToReceiveTeamNumber=true;
}

bool TeamBalancer::RequestSpecificTeam(TeamId desiredTeam)
{
    // Send desiredTeam to the current host.
    // Also flag that we have requested a team, and record desiredTeam in case the host changes and it needs to be resent.
    BitStream bsOut;
    bsOut.Write((MessageID)ID_TEAM_BALANCER_INTERNAL);
    bsOut.Write((MessageID)ID_REQUEST_SPECIFIC_TEAM);
    bsOut.Write(desiredTeam);
    rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,hostGuid,false);

    if (desiredTeam!=UNASSIGNED_TEAM_ID)
        expectingToReceiveTeamNumber=true;

    return true;
}

void CText::SetText(const char * szText)
{
	m_szText = szText;

	CPlayerManager * pPlayerManager = pNetowkManager->GetPlayerManager();
	for(EntityId i = 0; i < MAX_PLAYERS; i++) {
		if(pPlayerManager->GetSlotState(i)) {
			BitStream bsSend;
			bsSend.Write(m_iID);
			bsSend.Write(strlen(szText));
			bsSend.Write(szText, strlen(szText));
			pNetowkManager->GetRPC4()->Call("Script_SetText", &bsSend, HIGH_PRIORITY, RELIABLE, 0, pNetowkManager->GetRakPeer()->GetSystemAddressFromIndex(i), 0);
		}
	}
}