ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renamed NewNetworkString to NetworkString.

Browse Source
This commit is contained in:
hiker
2016-02-28 14:58:15 +11:00
parent 1e49595c53
commit 9a16595261
27 changed files with 119 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/main.cpp
View File

@@ -1670,7 +1670,7 @@ static void cleanUserConfig()
void runUnitTests()
{
GraphicsRestrictions::unitTesting();
NewNetworkString::unitTesting();
NetworkString::unitTesting();
// Test easter mode: in 2015 Easter is 5th of April - check with 0 days
// before and after
int saved_easter_mode = UserConfigParams::m_easter_ear_mode;

2
src/network/event.cpp
View File

@@ -46,7 +46,7 @@ Event::Event(ENetEvent* event)
}
if (m_type == EVENT_TYPE_MESSAGE)
{
m_data = new NewNetworkString(event->packet->data,
m_data = new NetworkString(event->packet->data,
event->packet->dataLength);
}
else

8
src/network/event.hpp
View File

@@ -29,7 +29,7 @@
#include "enet/enet.h"
class NewNetworkString;
class NetworkString;
class STKPeer;
/*!
@@ -59,7 +59,7 @@ private:
LEAK_CHECK()
/** Copy of the data passed by the event. */
NewNetworkString *m_data;
NetworkString *m_data;
/** Type of the event. */
EVENT_TYPE m_type;
@@ -83,12 +83,12 @@ public:
/** \brief Get a const reference to the received data.
* This is empty for events like connection or disconnections.
*/
const NewNetworkString& data() const { return *m_data; }
const NetworkString& data() const { return *m_data; }
// ------------------------------------------------------------------------
/** \brief Get a non-const reference to the received data.
* A copy of the message data. This is empty for events like
* connection or disconnections. */
NewNetworkString& data() { return *m_data; }
NetworkString& data() { return *m_data; }
// ------------------------------------------------------------------------
}; // class Event

2
src/network/network.cpp
View File

@@ -160,7 +160,7 @@ int Network::receiveRawPacket(char *buffer, int buf_len,
/** \brief Broadcasts a packet to all peers.
* \param data : Data to send.
*/
void Network::broadcastPacket(const NewNetworkString& data, bool reliable)
void Network::broadcastPacket(const NetworkString& data, bool reliable)
{
ENetPacket* packet = enet_packet_create(data.getData(), data.size() + 1,
reliable ? ENET_PACKET_FLAG_RELIABLE

4
src/network/network.hpp
View File

@@ -34,7 +34,7 @@
#include <stdio.h>
class BareNetworkString;
class NewNetworkString;
class NetworkString;
class TransportAddress;
/** \class EnetHost
@@ -65,7 +65,7 @@ public:
const TransportAddress& dst);
int receiveRawPacket(char *buffer, int buf_len,
TransportAddress* sender, int max_tries = -1);
void broadcastPacket(const NewNetworkString& data,
void broadcastPacket(const NetworkString& data,
bool reliable = true);
// ------------------------------------------------------------------------
/** Returns a pointer to the ENet host object. */

2
src/network/network_console.cpp
View File

@@ -173,7 +173,7 @@ void NetworkConsole::kickAllPlayers()
} // kickAllPlayers
// ----------------------------------------------------------------------------
void NetworkConsole::sendPacket(const NewNetworkString& data, bool reliable)
void NetworkConsole::sendPacket(const NetworkString& data, bool reliable)
{
m_localhost->broadcastPacket(data, reliable);
} // sendPacket

4
src/network/network_console.hpp
View File

@@ -23,7 +23,7 @@
#include "pthread.h"
class NewNetworkString;
class NetworkString;
class STKHost;
class NetworkConsole
@@ -44,7 +44,7 @@ public:
virtual void run();
void kickAllPlayers();
virtual void sendPacket(const NewNetworkString& data,
virtual void sendPacket(const NetworkString& data,
bool reliable = true);
// ------------------------------------------------------------------------
void setMaxPlayers(uint8_t count) { m_max_players = count; }

4
src/network/network_string.cpp
View File

@@ -26,9 +26,9 @@
// ============================================================================
/** Unit testing function.
*/
void NewNetworkString::unitTesting()
void NetworkString::unitTesting()
{
NewNetworkString s(PROTOCOL_LOBBY_ROOM);
NetworkString s(PROTOCOL_LOBBY_ROOM);
assert(s.getProtocolType() == PROTOCOL_LOBBY_ROOM);
assert(s.getProtocolType() != PROTOCOL_KART_UPDATE);
assert(!s.isSynchronous());

10
src/network/network_string.hpp
View File

@@ -290,29 +290,29 @@ public:
* so that the protocols would not see this byte). But this is implemented
* now by using a base pointer (and not by moving the buffer content).
*/
class NewNetworkString : public BareNetworkString
class NetworkString : public BareNetworkString
{
public:
static void unitTesting();
/** Constructor for a message to be sent. It sets the
* protocol type of this message. */
NewNetworkString(ProtocolType type, int capacity=16)
NetworkString(ProtocolType type, int capacity=16)
: BareNetworkString(capacity)
{
m_buffer.push_back(type);
addUInt32(0); // add dummy token for now
} // NewNetworkString
} // NetworkString
// ------------------------------------------------------------------------
/** Constructor for a received message. It automatically ignored the first
* 5 bytes which contain the type and token. Those will be access using
* special functions. */
NewNetworkString(const uint8_t *data, int len)
NetworkString(const uint8_t *data, int len)
: BareNetworkString((char*)data, len)
{
m_current_offset = 5; // ignore type and token
} // NewNetworkString
} // NetworkString
// ------------------------------------------------------------------------
/** Returns the protocol type of this message. */

14
src/network/protocol.cpp
View File

@@ -51,15 +51,15 @@ Protocol::~Protocol()
/** Returns a network string with the given type.
* \capacity Default preallocated size for the message.
*/
NewNetworkString* Protocol::getNetworkString(int capacity)
NetworkString* Protocol::getNetworkString(int capacity)
{
return new NewNetworkString(m_type, capacity);
return new NetworkString(m_type, capacity);
} // getNetworkString
// ----------------------------------------------------------------------------
bool Protocol::checkDataSizeAndToken(Event* event, unsigned int minimum_size)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data.size() < minimum_size || data[0] != 4)
{
Log::warn("Protocol", "Receiving a badly "
@@ -81,7 +81,7 @@ bool Protocol::checkDataSizeAndToken(Event* event, unsigned int minimum_size)
// ----------------------------------------------------------------------------
bool Protocol::isByteCorrect(Event* event, int byte_nb, int value)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data[byte_nb] != value)
{
Log::info("Protocol", "Bad byte at pos %d. %d "
@@ -129,7 +129,7 @@ void Protocol::requestTerminate()
* followed by the token of this client and then actual message).
* \param message The actual message content.
*/
void Protocol::sendMessageToPeersChangingToken(NewNetworkString *message)
void Protocol::sendMessageToPeersChangingToken(NetworkString *message)
{
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
@@ -140,13 +140,13 @@ void Protocol::sendMessageToPeersChangingToken(NewNetworkString *message)
} // sendMessageToPeersChangingToken
// ----------------------------------------------------------------------------
void Protocol::sendMessage(const NewNetworkString &message, bool reliable)
void Protocol::sendMessage(const NetworkString &message, bool reliable)
{
ProtocolManager::getInstance()->sendMessage(message, reliable);
} // sendMessage
// ----------------------------------------------------------------------------
void Protocol::sendMessage(STKPeer* peer, const NewNetworkString &message,
void Protocol::sendMessage(STKPeer* peer, const NetworkString &message,
bool reliable)
{
ProtocolManager::getInstance()->sendMessage(peer, message, reliable);

10
src/network/protocol.hpp
View File

@@ -28,7 +28,7 @@
#include "utils/types.hpp"
class Event;
class NewNetworkString;
class NetworkString;
class STKPeer;
@@ -121,13 +121,13 @@ public:
virtual void asynchronousUpdate() = 0;
/// functions to check incoming data easily
NewNetworkString* getNetworkString(int capacity=16);
NetworkString* getNetworkString(int capacity=16);
bool checkDataSizeAndToken(Event* event, unsigned int minimum_size);
bool isByteCorrect(Event* event, int byte_nb, int value);
void sendMessageToPeersChangingToken(NewNetworkString *message);
void sendMessage(const NewNetworkString &message,
void sendMessageToPeersChangingToken(NetworkString *message);
void sendMessage(const NetworkString &message,
bool reliable = true);
void sendMessage(STKPeer* peer, const NewNetworkString &message,
void sendMessage(STKPeer* peer, const NetworkString &message,
bool reliable = true);
void requestStart();
void requestPause();

6
src/network/protocol_manager.cpp
View File

@@ -176,14 +176,14 @@ void ProtocolManager::propagateEvent(Event* event)
} // propagateEvent
// ----------------------------------------------------------------------------
void ProtocolManager::sendMessage(const NewNetworkString &message, bool reliable)
void ProtocolManager::sendMessage(const NetworkString &message, bool reliable)
{
STKHost::get()->sendMessage(message, reliable);
} // sendMessage
// ----------------------------------------------------------------------------
void ProtocolManager::sendMessage(STKPeer *peer,
const NewNetworkString &message,
const NetworkString &message,
bool reliable)
{
peer->sendPacket(message, reliable);
@@ -191,7 +191,7 @@ void ProtocolManager::sendMessage(STKPeer *peer,
// ----------------------------------------------------------------------------
void ProtocolManager::sendMessageExcept(STKPeer *peer,
const NewNetworkString &message,
const NetworkString &message,
bool reliable)
{
STKHost::get()->sendPacketExcept(peer, message, reliable);

6
src/network/protocol_manager.hpp
View File

@@ -162,13 +162,13 @@ private:
public:
virtual void abort();
virtual void propagateEvent(Event* event);
virtual void sendMessage(const NewNetworkString &message,
virtual void sendMessage(const NetworkString &message,
bool reliable = true);
virtual void sendMessage(STKPeer* peer,
const NewNetworkString &message,
const NetworkString &message,
bool reliable = true);
virtual void sendMessageExcept(STKPeer* peer,
const NewNetworkString &message,
const NetworkString &message,
bool reliable = true);
virtual uint32_t requestStart(Protocol* protocol);
virtual void requestPause(Protocol* protocol);

52
src/network/protocols/client_lobby_room_protocol.cpp
View File

@@ -60,12 +60,12 @@ void ClientLobbyRoomProtocol::setup()
void ClientLobbyRoomProtocol::requestKartSelection(const std::string &kart_name)
{
NewNetworkString *request = getNetworkString(6+1+kart_name.size());
NetworkString *request = getNetworkString(6+1+kart_name.size());
// size_token (4), token, size kart name, kart name
request->setToken(m_server->getClientServerToken());
request->addUInt8(LE_KART_SELECTION).encodeString(kart_name);
NewNetworkString *r = getNetworkString(7+kart_name.size());
NetworkString *r = getNetworkString(7+kart_name.size());
r->setToken(m_server->getClientServerToken());
r->addUInt8(LE_KART_SELECTION).addUInt8(4).encodeString(kart_name);
sendMessage(*r, true);
@@ -76,7 +76,7 @@ void ClientLobbyRoomProtocol::requestKartSelection(const std::string &kart_name)
void ClientLobbyRoomProtocol::voteMajor(uint32_t major)
{
NewNetworkString *request = getNetworkString(8);
NetworkString *request = getNetworkString(8);
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size major(1),major
request->addUInt8(LE_VOTE_MAJOR).addUInt8(4)
@@ -89,7 +89,7 @@ void ClientLobbyRoomProtocol::voteMajor(uint32_t major)
void ClientLobbyRoomProtocol::voteRaceCount(uint8_t count)
{
NewNetworkString *request = getNetworkString(8);
NetworkString *request = getNetworkString(8);
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size race count(1), count
request->addUInt8(LE_VOTE_RACE_COUNT).addUInt8(4)
@@ -102,7 +102,7 @@ void ClientLobbyRoomProtocol::voteRaceCount(uint8_t count)
void ClientLobbyRoomProtocol::voteMinor(uint32_t minor)
{
NewNetworkString *request = getNetworkString(8);
NetworkString *request = getNetworkString(8);
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size minor(1),minor
request->addUInt8(LE_VOTE_MINOR).addUInt8(4)
@@ -116,7 +116,7 @@ void ClientLobbyRoomProtocol::voteMinor(uint32_t minor)
void ClientLobbyRoomProtocol::voteTrack(const std::string &track,
uint8_t track_nb)
{
NewNetworkString *request = getNetworkString(8+1+track.size());
NetworkString *request = getNetworkString(8+1+track.size());
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size track, track, size #track, #track
request->addUInt8(LE_VOTE_TRACK).addUInt8(4)
@@ -129,7 +129,7 @@ void ClientLobbyRoomProtocol::voteTrack(const std::string &track,
void ClientLobbyRoomProtocol::voteReversed(bool reversed, uint8_t track_nb)
{
NewNetworkString *request = getNetworkString(9);
NetworkString *request = getNetworkString(9);
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size reversed(1),reversed, size #track, #track
request->addUInt8(LE_VOTE_REVERSE).addUInt8(4)
@@ -142,7 +142,7 @@ void ClientLobbyRoomProtocol::voteReversed(bool reversed, uint8_t track_nb)
void ClientLobbyRoomProtocol::voteLaps(uint8_t laps, uint8_t track_nb)
{
NewNetworkString *request = getNetworkString(10);
NetworkString *request = getNetworkString(10);
request->setToken(m_server->getClientServerToken());
// size_token (4), token, size laps(1),laps, size #track, #track
request->addUInt8(LE_VOTE_LAPS)
@@ -167,7 +167,7 @@ bool ClientLobbyRoomProtocol::notifyEvent(Event* event)
assert(m_setup); // assert that the setup exists
if (event->getType() == EVENT_TYPE_MESSAGE)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
assert(data.size()); // assert that data isn't empty
uint8_t message_type = data[0];
if (message_type != LE_KART_SELECTION_UPDATE &&
@@ -194,7 +194,7 @@ bool ClientLobbyRoomProtocol::notifyEventAsynchronous(Event* event)
assert(m_setup); // assert that the setup exists
if (event->getType() == EVENT_TYPE_MESSAGE)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
assert(data.size()); // assert that data isn't empty
uint8_t message_type = data[0];
@@ -260,7 +260,7 @@ void ClientLobbyRoomProtocol::update()
std::string name_u8 = StringUtils::wideToUtf8(name);
const std::string &password = NetworkConfig::get()->getPassword();
NewNetworkString *ns = getNetworkString(6+1+name_u8.size()
NetworkString *ns = getNetworkString(6+1+name_u8.size()
+1+password.size());
// 4 (size of id), global id
ns->addUInt8(LE_CONNECTION_REQUESTED).encodeString(name)
@@ -319,7 +319,7 @@ void ClientLobbyRoomProtocol::update()
*/
void ClientLobbyRoomProtocol::newPlayer(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data[0] != 1)
{
Log::error("ClientLobbyRoomProtocol",
@@ -367,7 +367,7 @@ void ClientLobbyRoomProtocol::newPlayer(Event* event)
*/
void ClientLobbyRoomProtocol::disconnectedPlayer(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data.size() != 2 || data[0] != 1)
{
Log::error("ClientLobbyRoomProtocol",
@@ -401,7 +401,7 @@ void ClientLobbyRoomProtocol::disconnectedPlayer(Event* event)
*/
void ClientLobbyRoomProtocol::connectionAccepted(Event* event)
{
NewNetworkString &data = event->data();
NetworkString &data = event->data();
// At least 12 bytes should remain now
if (data.size() < 3)
{
@@ -481,7 +481,7 @@ void ClientLobbyRoomProtocol::connectionAccepted(Event* event)
*/
void ClientLobbyRoomProtocol::connectionRefused(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data.size() != 2 || data[0] != 1) // 2 bytes remains now
{
Log::error("ClientLobbyRoomProtocol",
@@ -522,7 +522,7 @@ void ClientLobbyRoomProtocol::connectionRefused(Event* event)
*/
void ClientLobbyRoomProtocol::kartSelectionRefused(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data.size() != 2 || data[0] != 1)
{
Log::error("ClientLobbyRoomProtocol",
@@ -561,7 +561,7 @@ void ClientLobbyRoomProtocol::kartSelectionRefused(Event* event)
*/
void ClientLobbyRoomProtocol::kartSelectionUpdate(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data.size() < 3 || data[0] != 1)
{
Log::error("ClientLobbyRoomProtocol",
@@ -596,7 +596,7 @@ void ClientLobbyRoomProtocol::kartSelectionUpdate(Event* event)
*/
void ClientLobbyRoomProtocol::startGame(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data.size() < 5 || data[0] != 4)
{
Log::error("ClientLobbyRoomProtocol", "A message notifying a kart "
@@ -630,7 +630,7 @@ void ClientLobbyRoomProtocol::startGame(Event* event)
*/
void ClientLobbyRoomProtocol::startSelection(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data.size() < 5 || data[0] != 4)
{
Log::error("ClientLobbyRoomProtocol", "A message notifying a kart "
@@ -662,7 +662,7 @@ void ClientLobbyRoomProtocol::startSelection(Event* event)
*/
void ClientLobbyRoomProtocol::raceFinished(Event* event)
{
NewNetworkString &data = event->data();
NetworkString &data = event->data();
if (data.size() < 5)
{
Log::error("ClientLobbyRoomProtocol", "Not enough data provided.");
@@ -745,7 +745,7 @@ void ClientLobbyRoomProtocol::raceFinished(Event* event)
*/
void ClientLobbyRoomProtocol::playerMajorVote(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 9))
return;
if (!isByteCorrect(event, 5, 1))
@@ -768,7 +768,7 @@ void ClientLobbyRoomProtocol::playerMajorVote(Event* event)
*/
void ClientLobbyRoomProtocol::playerRaceCountVote(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 9))
return;
if (!isByteCorrect(event, 5, 1))
@@ -791,7 +791,7 @@ void ClientLobbyRoomProtocol::playerRaceCountVote(Event* event)
*/
void ClientLobbyRoomProtocol::playerMinorVote(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 9))
return;
if (!isByteCorrect(event, 5, 1))
@@ -815,7 +815,7 @@ void ClientLobbyRoomProtocol::playerMinorVote(Event* event)
*/
void ClientLobbyRoomProtocol::playerTrackVote(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 10))
return;
if (!isByteCorrect(event, 5, 1))
@@ -842,7 +842,7 @@ void ClientLobbyRoomProtocol::playerTrackVote(Event* event)
*/
void ClientLobbyRoomProtocol::playerReversedVote(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 11))
return;
if (!isByteCorrect(event, 5, 1))
@@ -868,7 +868,7 @@ void ClientLobbyRoomProtocol::playerReversedVote(Event* event)
*/
void ClientLobbyRoomProtocol::playerLapsVote(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (!checkDataSizeAndToken(event, 9))
return;
if (!isByteCorrect(event, 5, 1))

8
src/network/protocols/controller_events_protocol.cpp
View File

@@ -50,7 +50,7 @@ bool ControllerEventsProtocol::notifyEventAsynchronous(Event* event)
if (event->getType() != EVENT_TYPE_MESSAGE)
return true;
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data.size() < 17)
{
Log::error("ControllerEventsProtocol",
@@ -59,14 +59,14 @@ bool ControllerEventsProtocol::notifyEventAsynchronous(Event* event)
return true;
}
uint32_t token = data.getUInt32();
NewNetworkString pure_message = data;
NetworkString pure_message = data;
pure_message.removeFront(4);
if (token != event->getPeer()->getClientServerToken())
{
Log::error("ControllerEventsProtocol", "Bad token from peer.");
return true;
}
NewNetworkString ns = pure_message;
NetworkString ns = pure_message;
ns.removeFront(4);
uint8_t client_index = -1;
@@ -157,7 +157,7 @@ void ControllerEventsProtocol::controllerAction(Controller* controller,
uint8_t serialized_2 = (uint8_t)(controls->m_accel*255.0);
uint8_t serialized_3 = (uint8_t)(controls->m_steer*127.0);
NewNetworkString *ns = getNetworkString(17);
NetworkString *ns = getNetworkString(17);
ns->setToken(STKHost::get()->getPeers()[0]->getClientServerToken());
ns->addFloat(World::getWorld()->getTime());
ns->addUInt8(controller->getKart()->getWorldKartId());

10
src/network/protocols/game_events_protocol.cpp
View File

@@ -38,7 +38,7 @@ bool GameEventsProtocol::notifyEvent(Event* event)
{
if (event->getType() != EVENT_TYPE_MESSAGE)
return true;
NewNetworkString &data = event->data();
NetworkString &data = event->data();
if (data.size() < 5) // for token and type
{
Log::warn("GameEventsProtocol", "Too short message.");
@@ -85,7 +85,7 @@ void GameEventsProtocol::collectedItem(Item* item, AbstractKart* kart)
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
NewNetworkString *ns = getNetworkString(11);
NetworkString *ns = getNetworkString(11);
ns->setToken(peers[i]->getClientServerToken());
ns->setSynchronous(true);
// Item picked : send item id, powerup type and kart race id
@@ -110,7 +110,7 @@ void GameEventsProtocol::collectedItem(Item* item, AbstractKart* kart)
// ----------------------------------------------------------------------------
/** Called on the client when an itemCollected message is received.
*/
void GameEventsProtocol::collectedItem(const NewNetworkString &data)
void GameEventsProtocol::collectedItem(const NetworkString &data)
{
if (data.size() < 6)
{
@@ -135,7 +135,7 @@ void GameEventsProtocol::collectedItem(const NewNetworkString &data)
*/
void GameEventsProtocol::kartFinishedRace(AbstractKart *kart, float time)
{
NewNetworkString *ns = getNetworkString(20);
NetworkString *ns = getNetworkString(20);
ns->setSynchronous(true);
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
@@ -157,7 +157,7 @@ void GameEventsProtocol::kartFinishedRace(AbstractKart *kart, float time)
* event from the server. It updates the game with this information.
* \param ns The message from the server.
*/
void GameEventsProtocol::kartFinishedRace(const NewNetworkString &ns)
void GameEventsProtocol::kartFinishedRace(const NetworkString &ns)
{
uint8_t kart_id = ns.getUInt8(0);
float time = ns.getFloat(1);

4
src/network/protocols/game_events_protocol.hpp
View File

@@ -22,9 +22,9 @@ public:
virtual void setup();
virtual void update();
void collectedItem(Item* item, AbstractKart* kart);
void collectedItem(const NewNetworkString &ns);
void collectedItem(const NetworkString &ns);
void kartFinishedRace(AbstractKart *kart, float time);
void kartFinishedRace(const NewNetworkString &ns);
void kartFinishedRace(const NetworkString &ns);
// ------------------------------------------------------------------------
virtual void asynchronousUpdate() {}
// ------------------------------------------------------------------------

2
src/network/protocols/get_public_address.cpp
View File

@@ -140,7 +140,7 @@ std::string GetPublicAddress::parseStunResponse()
return "STUN response contains no data at all";
// Convert to network string.
NewNetworkString datas((uint8_t*)buffer, len);
NetworkString datas((uint8_t*)buffer, len);
// check that the stun response is a response, contains the magic cookie
// and the transaction ID

6
src/network/protocols/kart_update_protocol.cpp
View File

@@ -38,7 +38,7 @@ bool KartUpdateProtocol::notifyEvent(Event* event)
{
if (event->getType() != EVENT_TYPE_MESSAGE)
return true;
NewNetworkString &ns = event->data();
NetworkString &ns = event->data();
if (ns.size() < 33)
{
Log::info("KartUpdateProtocol", "Message too short.");
@@ -80,7 +80,7 @@ void KartUpdateProtocol::update()
if (NetworkConfig::get()->isServer())
{
World *world = World::getWorld();
NewNetworkString *ns = getNetworkString(4+world->getNumKarts()*29);
NetworkString *ns = getNetworkString(4+world->getNumKarts()*29);
ns->setSynchronous(true);
ns->addFloat( world->getTime() );
for (unsigned int i = 0; i < world->getNumKarts(); i++)
@@ -98,7 +98,7 @@ void KartUpdateProtocol::update()
}
else
{
NewNetworkString *ns =
NetworkString *ns =
getNetworkString(4+29*race_manager->getNumLocalPlayers());
ns->setSynchronous(true);
ns->addFloat(World::getWorld()->getTime());

54
src/network/protocols/server_lobby_room_protocol.cpp
View File

@@ -78,7 +78,7 @@ bool ServerLobbyRoomProtocol::notifyEventAsynchronous(Event* event)
assert(m_setup); // assert that the setup exists
if (event->getType() == EVENT_TYPE_MESSAGE)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
assert(data.size()); // message not empty
uint8_t message_type;
message_type = data[0];
@@ -226,7 +226,7 @@ void ServerLobbyRoomProtocol::startGame()
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
NewNetworkString *ns = getNetworkString(6);
NetworkString *ns = getNetworkString(6);
ns->setToken(peers[i]->getClientServerToken());
ns->addUInt8(LE_START_RACE).addUInt8(4);
sendMessage(peers[i], *ns, true); // reliably
@@ -253,7 +253,7 @@ void ServerLobbyRoomProtocol::startSelection(const Event *event)
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
NewNetworkString *ns = getNetworkString(6);
NetworkString *ns = getNetworkString(6);
ns->setToken(peers[i]->getClientServerToken());
// start selection
ns->addUInt8(LE_START_SELECTION).addUInt8(4);
@@ -342,7 +342,7 @@ void ServerLobbyRoomProtocol::checkRaceFinished()
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
NewNetworkString *queue = getNetworkString(karts_results.size()*2);
NetworkString *queue = getNetworkString(karts_results.size()*2);
for (unsigned int i = 0; i < karts_results.size(); i++)
{
queue->addUInt8(1).addUInt8(karts_results[i]); // kart pos = i+1
@@ -351,7 +351,7 @@ void ServerLobbyRoomProtocol::checkRaceFinished()
}
for (unsigned int i = 0; i < peers.size(); i++)
{
NewNetworkString *total = getNetworkString();
NetworkString *total = getNetworkString();
total->setSynchronous(true);
total->setToken(peers[i]->getClientServerToken());
total->addUInt8(LE_RACE_FINISHED).addUInt8(4);
@@ -402,7 +402,7 @@ void ServerLobbyRoomProtocol::kartDisconnected(Event* event)
STKPeer* peer = event->getPeer();
if (peer->getPlayerProfile() != NULL) // others knew him
{
NewNetworkString *msg = getNetworkString(3);
NetworkString *msg = getNetworkString(3);
msg->addUInt8(LE_PLAYER_DISCONNECTED).addUInt8(1)
.addUInt8(peer->getPlayerProfile()->getGlobalPlayerId());
sendMessage(*msg);
@@ -433,13 +433,13 @@ void ServerLobbyRoomProtocol::kartDisconnected(Event* event)
void ServerLobbyRoomProtocol::connectionRequested(Event* event)
{
STKPeer* peer = event->getPeer();
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
// can we add the player ?
if (m_setup->getPlayerCount() >= NetworkConfig::get()->getMaxPlayers() ||
m_state!=ACCEPTING_CLIENTS )
{
NewNetworkString *message = getNetworkString(3);
NetworkString *message = getNetworkString(3);
// Len, error code: 2 = busy, 0 = too many players
message->addUInt8(LE_CONNECTION_REFUSED).addUInt8(1)
.addUInt8(m_state!=ACCEPTING_CLIENTS ? 2 : 0);
@@ -474,7 +474,7 @@ void ServerLobbyRoomProtocol::connectionRequested(Event* event)
// Notify everybody that there is a new player
// -------------------------------------------
NewNetworkString *message = getNetworkString(8);
NetworkString *message = getNetworkString(8);
// size of id -- id -- size of local id -- local id;
message->addUInt8(LE_NEW_PLAYER_CONNECTED).addUInt8(1).addUInt8(new_player_id)
.encodeString(name_u8).addUInt8(new_host_id);
@@ -493,7 +493,7 @@ void ServerLobbyRoomProtocol::connectionRequested(Event* event)
const std::vector<NetworkPlayerProfile*> &players = m_setup->getPlayers();
// send a message to the one that asked to connect
// Size is overestimated, probably one player's data will not be sent
NewNetworkString *message_ack = getNetworkString(14 + players.size() * 7);
NetworkString *message_ack = getNetworkString(14 + players.size() * 7);
message_ack->setToken(token);
// connection success -- size of token -- token
message_ack->addUInt8(LE_CONNECTION_ACCEPTED).addUInt8(new_player_id)
@@ -542,7 +542,7 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
return;
}
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 6))
return;
@@ -552,7 +552,7 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
// check if selection is possible
if (!m_selection_enabled)
{
NewNetworkString *answer = getNetworkString(3);
NetworkString *answer = getNetworkString(3);
// selection still not started
answer->addUInt8(LE_KART_SELECTION_REFUSED).addUInt8(1).addUInt8(2);
sendMessage(peer, *answer);
@@ -562,7 +562,7 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
// check if somebody picked that kart
if (!m_setup->isKartAvailable(kart_name))
{
NewNetworkString *answer = getNetworkString(3);
NetworkString *answer = getNetworkString(3);
// kart is already taken
answer->addUInt8(LE_KART_SELECTION_REFUSED).addUInt8(1).addUInt8(0);
sendMessage(peer, *answer);
@@ -572,7 +572,7 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
// check if this kart is authorized
if (!m_setup->isKartAllowed(kart_name))
{
NewNetworkString *answer = getNetworkString(3);
NetworkString *answer = getNetworkString(3);
// kart is not authorized
answer->addUInt8(LE_KART_SELECTION_REFUSED).addUInt8(1).addUInt8(1);
sendMessage(peer, *answer);
@@ -580,7 +580,7 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
return;
}
// send a kart update to everyone
NewNetworkString *answer = getNetworkString(3+1+kart_name.size());
NetworkString *answer = getNetworkString(3+1+kart_name.size());
// This message must be handled synchronously on the client.
answer->setSynchronous(true);
// kart update (3), 1, race id
@@ -606,7 +606,7 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
*/
void ServerLobbyRoomProtocol::playerMajorVote(Event* event)
{
NewNetworkString &data = event->data();
NetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 7))
return;
@@ -617,7 +617,7 @@ void ServerLobbyRoomProtocol::playerMajorVote(Event* event)
m_setup->getRaceConfig()->setPlayerMajorVote(player_id, major);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NewNetworkString *other = getNetworkString(6+data.size());
NetworkString *other = getNetworkString(6+data.size());
other->addUInt8(LE_VOTE_MAJOR).addUInt8(1).addUInt8(player_id); // add the player id
*other += data; // add the data
sendMessageToPeersChangingToken(other);
@@ -638,7 +638,7 @@ void ServerLobbyRoomProtocol::playerMajorVote(Event* event)
*/
void ServerLobbyRoomProtocol::playerRaceCountVote(Event* event)
{
NewNetworkString &data = event->data();
NetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 7))
return;
@@ -648,7 +648,7 @@ void ServerLobbyRoomProtocol::playerRaceCountVote(Event* event)
m_setup->getRaceConfig()->setPlayerRaceCountVote(player_id, data[6]);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NewNetworkString *other = getNetworkString(3+data.size());
NetworkString *other = getNetworkString(3+data.size());
other->addUInt8(LE_VOTE_RACE_COUNT).addUInt8(1)
.addUInt8(player_id); // add the player id
*other += data; // add the data
@@ -670,7 +670,7 @@ void ServerLobbyRoomProtocol::playerRaceCountVote(Event* event)
*/
void ServerLobbyRoomProtocol::playerMinorVote(Event* event)
{
NewNetworkString &data = event->data();
NetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 7))
return;
@@ -681,7 +681,7 @@ void ServerLobbyRoomProtocol::playerMinorVote(Event* event)
m_setup->getRaceConfig()->setPlayerMinorVote(player_id, minor);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NewNetworkString *other = getNetworkString(3+data.size());
NetworkString *other = getNetworkString(3+data.size());
other->addUInt8(LE_VOTE_MINOR).addUInt8(1).addUInt8(player_id);
*other += data; // add the data
sendMessageToPeersChangingToken(other);
@@ -702,7 +702,7 @@ void ServerLobbyRoomProtocol::playerMinorVote(Event* event)
*/
void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
{
NewNetworkString &data = event->data();
NetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 8))
return;
@@ -714,7 +714,7 @@ void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
m_setup->getRaceConfig()->setPlayerTrackVote(player_id, track_name, data[N+6]);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NewNetworkString *other = getNetworkString(3+data.size());
NetworkString *other = getNetworkString(3+data.size());
other->addUInt8(LE_VOTE_TRACK).addUInt8(1).addUInt8(player_id);
*other += data; // add the data
sendMessageToPeersChangingToken(other);
@@ -737,7 +737,7 @@ void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
*/
void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
{
NewNetworkString &data = event->data();
NetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 9))
return;
@@ -750,7 +750,7 @@ void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
data[6]!=0, data[8]);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NewNetworkString *other = getNetworkString(3+data.size());
NetworkString *other = getNetworkString(3+data.size());
other->addUInt8(LE_VOTE_REVERSE).addUInt8(1).addUInt8(player_id);
*other += data; // add the data
sendMessageToPeersChangingToken(other);
@@ -771,7 +771,7 @@ void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
*/
void ServerLobbyRoomProtocol::playerLapsVote(Event* event)
{
NewNetworkString &data = event->data();
NetworkString &data = event->data();
STKPeer* peer = event->getPeer();
if (!checkDataSizeAndToken(event, 9))
return;
@@ -783,7 +783,7 @@ void ServerLobbyRoomProtocol::playerLapsVote(Event* event)
m_setup->getRaceConfig()->setPlayerLapsVote(player_id, data[6], data[8]);
// Send the vote to everybody (including the sender)
data.removeFront(5); // remove the token
NewNetworkString *other = getNetworkString(3+data.size());
NetworkString *other = getNetworkString(3+data.size());
other->addUInt8(LE_VOTE_LAPS).addUInt8(1).addUInt8(player_id);
*other += data; // add the data
sendMessageToPeersChangingToken(other);

4
src/network/protocols/start_game_protocol.cpp
View File

@@ -123,7 +123,7 @@ void StartGameProtocol::setup()
// ----------------------------------------------------------------------------
bool StartGameProtocol::notifyEventAsynchronous(Event* event)
{
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data.size() < 5)
{
Log::error("StartGameProtocol", "Too short message.");
@@ -219,7 +219,7 @@ void StartGameProtocol::ready()
if (NetworkConfig::get()->isClient())
{
assert(STKHost::get()->getPeerCount() == 1);
NewNetworkString *ns = getNetworkString(5);
NetworkString *ns = getNetworkString(5);
ns->setToken(STKHost::get()->getPeers()[0]->getClientServerToken());
ns->addUInt8(1);
Log::info("StartGameProtocol", "Player ready, notifying server.");

6
src/network/protocols/synchronization_protocol.cpp
View File

@@ -43,7 +43,7 @@ bool SynchronizationProtocol::notifyEventAsynchronous(Event* event)
if (event->getType() != EVENT_TYPE_MESSAGE)
return true;
const NewNetworkString &data = event->data();
const NetworkString &data = event->data();
if (data.size() < 9)
{
Log::warn("SynchronizationProtocol", "Received a too short message.");
@@ -79,7 +79,7 @@ bool SynchronizationProtocol::notifyEventAsynchronous(Event* event)
{
// Only a client should receive a request for a ping response
assert(NetworkConfig::get()->isClient());
NewNetworkString *response = getNetworkString(10);
NetworkString *response = getNetworkString(10);
response->setToken(token);
// The '0' indicates a response to a ping request
response->addUInt8(0).addUInt32(sequence);
@@ -171,7 +171,7 @@ void SynchronizationProtocol::asynchronousUpdate()
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
NewNetworkString *ping_request = getNetworkString(13);
NetworkString *ping_request = getNetworkString(13);
ping_request->setToken(peers[i]->getClientServerToken());
ping_request->addUInt8(1).addUInt32(m_pings[i].size());
// Server adds the countdown if it has started. This will indicate

4
src/network/stk_host.cpp
View File

@@ -440,7 +440,7 @@ bool STKHost::connect(const TransportAddress& address)
* \param data Message to sent.
* \param reliable If the message is to be sent reliable.
*/
void STKHost::sendMessage(const NewNetworkString& data, bool reliable)
void STKHost::sendMessage(const NetworkString& data, bool reliable)
{
if (NetworkConfig::get()->isServer())
broadcastPacket(data, reliable);
@@ -743,7 +743,7 @@ uint16_t STKHost::getPort() const
* \param data Data to sent.
* \param reliable If the data should be sent reliable or now.
*/
void STKHost::sendPacketExcept(STKPeer* peer, const NewNetworkString &data,
void STKHost::sendPacketExcept(STKPeer* peer, const NetworkString &data,
bool reliable)
{
for (unsigned int i = 0; i < m_peers.size(); i++)

6
src/network/stk_host.hpp
View File

@@ -145,9 +145,9 @@ public:
void requestShutdown();
void shutdown();
void sendMessage(const NewNetworkString& data, bool reliable = true);
void sendMessage(const NetworkString& data, bool reliable = true);
void sendPacketExcept(STKPeer* peer,
const NewNetworkString& data,
const NetworkString& data,
bool reliable = true);
void setupClient(int peer_count, int channel_limit,
uint32_t max_incoming_bandwidth,
@@ -181,7 +181,7 @@ public:
} // receiveRawPacket
// --------------------------------------------------------------------
void broadcastPacket(const NewNetworkString& data,
void broadcastPacket(const NetworkString& data,
bool reliable = true)
{
m_network->broadcastPacket(data, reliable);

2
src/network/stk_peer.cpp
View File

@@ -62,7 +62,7 @@ void STKPeer::disconnect()
* \param data The data to send.
* \param reliable If the data is sent reliable or not.
*/
void STKPeer::sendPacket(NewNetworkString const& data, bool reliable)
void STKPeer::sendPacket(NetworkString const& data, bool reliable)
{
TransportAddress a(m_enet_peer->address);
Log::verbose("STKPeer", "sending packet of size %d to %s",

4
src/network/stk_peer.hpp
View File

@@ -29,7 +29,7 @@
#include <enet/enet.h>
class NetworkPlayerProfile;
class NewNetworkString;
class NetworkString;
class TransportAddress;
/*! \class STKPeer
@@ -59,7 +59,7 @@ public:
STKPeer(ENetPeer *enet_peer);
virtual ~STKPeer();
virtual void sendPacket(const NewNetworkString &data,
virtual void sendPacket(const NetworkString &data,
bool reliable = true);
void disconnect();
bool isConnected() const;

2
src/states_screens/networking_lobby.cpp
View File

@@ -141,7 +141,7 @@ void NetworkingLobby::eventCallback(Widget* widget, const std::string& name,
if(name==m_start_button->m_properties[PROP_ID])
{
// Send a message to the server to start
NewNetworkString start(PROTOCOL_LOBBY_ROOM);
NetworkString start(PROTOCOL_LOBBY_ROOM);
start.addUInt8(LobbyRoomProtocol::LE_REQUEST_BEGIN);
STKHost::get()->sendMessage(start, true);
}