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

Use shared_ptr of STKPeer if needed

Browse Source
This commit is contained in:
Benau 2018-03-09 23:54:13 +08:00
parent e439e68b60
commit 5600d01b2c
8 changed files with 45 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/network/network_console.cpp
View File

@ -34,7 +34,7 @@ namespace NetworkConsole
// ----------------------------------------------------------------------------
void kickAllPlayers(STKHost* host)
{
const std::vector<STKPeer*> &peers = host->getPeers();
auto peers = host->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
peers[i]->disconnect();

6
src/network/protocol.cpp
View File

@ -119,11 +119,7 @@ void Protocol::requestTerminate()
void Protocol::sendMessageToPeersChangingToken(NetworkString *message,
bool reliable)
{
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
peers[i]->sendPacket(message, reliable);
}
STKHost::get()->sendPacketToAllPeers(message, reliable);
} // sendMessageToPeersChangingToken
// ----------------------------------------------------------------------------

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

@ -239,7 +239,7 @@ void ConnectToServer::update(float dt)
{
// lobby room protocol if we're connected only
if (STKHost::get()->getPeerCount() > 0 &&
STKHost::get()->getPeers()[0]->isConnected() &&
STKHost::get()->getServerPeerForClient()->isConnected() &&
!m_server_address.isUnset())
{
// Let main thread create ClientLobby for better

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

@ -82,30 +82,23 @@ bool GameEventsProtocol::notifyEvent(Event* event)
*/
void GameEventsProtocol::collectedItem(Item* item, AbstractKart* kart)
{
GameSetup* setup = STKHost::get()->getGameSetup();
assert(setup);
NetworkString *ns = getNetworkString(7);
ns->setSynchronous(true);
// Item picked : send item id, powerup type and kart race id
uint8_t powerup = 0;
if (item->getType() == Item::ITEM_BANANA)
powerup = (int)(kart->getAttachment()->getType());
else if (item->getType() == Item::ITEM_BONUS_BOX)
powerup = (((int)(kart->getPowerup()->getType()) << 4) & 0xf0)
+ (kart->getPowerup()->getNum() & 0x0f);
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
NetworkString *ns = getNetworkString(7);
ns->setSynchronous(true);
// Item picked : send item id, powerup type and kart race id
uint8_t powerup = 0;
if (item->getType() == Item::ITEM_BANANA)
powerup = (int)(kart->getAttachment()->getType());
else if (item->getType() == Item::ITEM_BONUS_BOX)
powerup = (((int)(kart->getPowerup()->getType()) << 4) & 0xf0)
+ (kart->getPowerup()->getNum() & 0x0f);
ns->addUInt8(GE_ITEM_COLLECTED).addUInt32(item->getItemId())
.addUInt8(powerup).addUInt8(kart->getWorldKartId());
peers[i]->sendPacket(ns, /*reliable*/true);
delete ns;
Log::info("GameEventsProtocol",
"Notified a peer that a kart collected item %d.",
(int)(kart->getPowerup()->getType()));
}
ns->addUInt8(GE_ITEM_COLLECTED).addUInt32(item->getItemId())
.addUInt8(powerup).addUInt8(kart->getWorldKartId());
Log::info("GameEventsProtocol",
"Notified a peer that a kart collected item %d.",
(int)(kart->getPowerup()->getType()));
STKHost::get()->sendPacketToAllPeers(ns, /*reliable*/true);
delete ns;
} // collectedItem
// ----------------------------------------------------------------------------

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

@ -56,7 +56,7 @@ bool LatencyProtocol::notifyEventAsynchronous(Event* event)
uint32_t request = data.getUInt8();
uint32_t sequence = data.getUInt32();
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
auto peers = STKHost::get()->getPeers();
assert(peers.size() > 0);
// Find the right peer id. The host id (i.e. each host sendings its
@ -124,7 +124,7 @@ void LatencyProtocol::asynchronousUpdate()
float current_time = float(StkTime::getRealTime());
if (NetworkConfig::get()->isServer() && current_time > m_last_time+1)
{
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
auto peers = STKHost::get()->getPeers();
for (unsigned int i = 0; i < peers.size(); i++)
{
NetworkString *ping_request =

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

@ -449,7 +449,6 @@ void ServerLobby::signalRaceStartToClients()
{
Log::verbose("Server", "Signaling race start to clients at %lf",
StkTime::getRealTime());
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
NetworkString *ns = getNetworkString(1);
ns->addUInt8(LE_START_RACE);
sendMessageToPeersChangingToken(ns, /*reliable*/true);
@ -485,7 +484,6 @@ void ServerLobby::startSelection(const Event *event)
event->getPeer());
return;
}
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
NetworkString *ns = getNetworkString(1);
// Start selection - must be synchronous since the receiver pushes
// a new screen, which must be donefrom the main thread.
@ -606,8 +604,6 @@ void ServerLobby::checkIncomingConnectionRequests()
}
}
const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
NetworkString *total = getNetworkString(1 + karts_results.size());
total->setSynchronous(true);
total->addUInt8(LE_RACE_FINISHED);

18
src/network/stk_host.cpp
View File

@ -920,11 +920,11 @@ std::vector<NetworkPlayerProfile*> STKHost::getMyPlayerProfiles()
/** \brief Return the only server peer for client.
* \return STKPeer the STKPeer of server.
*/
STKPeer* STKHost::getServerPeerForClient() const
std::shared_ptr<STKPeer> STKHost::getServerPeerForClient() const
{
assert(m_peers.size() == 1);
assert(NetworkConfig::get()->isClient());
return m_peers.begin()->second.get();
return m_peers.begin()->second;
} // getServerPeerForClient
// ----------------------------------------------------------------------------
@ -945,6 +945,20 @@ bool STKHost::isConnectedTo(const TransportAddress& peer)
return false;
} // isConnectedTo
//-----------------------------------------------------------------------------
/** Sends data to all peers
* \param data Data to sent.
* \param reliable If the data should be sent reliable or now.
*/
void STKHost::sendPacketToAllPeers(NetworkString *data, bool reliable)
{
std::lock_guard<std::mutex> lock(m_peers_mutex);
for (auto p : m_peers)
{
p.second->sendPacket(data, reliable);
}
} // sendPacketExcept
//-----------------------------------------------------------------------------
/** Sends data to all peers except the specified one.
* \param peer Peer which will not receive the message.

14
src/network/stk_host.hpp
View File

@ -180,7 +180,9 @@ public:
} // requestExit
//-------------------------------------------------------------------------
void shutdown();
//-------------------------------------------------------------------------
void sendPacketToAllPeers(NetworkString *data, bool reliable = true);
//-------------------------------------------------------------------------
void sendPacketExcept(STKPeer* peer,
NetworkString *data,
bool reliable = true);
@ -191,7 +193,7 @@ public:
void stopListening();
bool peerExists(const TransportAddress& peer_address);
bool isConnectedTo(const TransportAddress& peer_address);
STKPeer *getServerPeerForClient() const;
std::shared_ptr<STKPeer> getServerPeerForClient() const;
std::vector<NetworkPlayerProfile*> getMyPlayerProfiles();
void setErrorMessage(const irr::core::stringw &message);
bool isAuthorisedToControl() const;
@ -221,14 +223,14 @@ public:
m_network->sendRawPacket(buffer, dst);
} // sendRawPacket
// ------------------------------------------------------------------------
/** Returns a const reference to the list of peers. */
std::vector<STKPeer*> getPeers()
/** Returns a copied list of peers. */
std::vector<std::shared_ptr<STKPeer> > getPeers()
{
std::lock_guard<std::mutex> lock(m_peers_mutex);
std::vector<STKPeer*> peers;
std::vector<std::shared_ptr<STKPeer> > peers;
for (auto p : m_peers)
{
peers.push_back(p.second.get());
peers.push_back(p.second);
}
return peers;
}