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

Use monotonic clock to avoid system time changes

Browse Source
This commit is contained in:
Benau 2019-05-06 15:17:19 +08:00
parent 2bfa7dd5f8
commit ebf95ee958
24 changed files with 95 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/audio/sfx_manager.cpp
View File

@ -478,9 +478,9 @@ void* SFXManager::mainLoop(void *obj)
{
// Wait some time to let other threads run, then queue an
// update event to keep music playing.
uint64_t t = StkTime::getRealTimeMs();
uint64_t t = StkTime::getMonoTimeMs();
StkTime::sleep(1);
t = StkTime::getRealTimeMs() - t;
t = StkTime::getMonoTimeMs() - t;
me->queue(SFX_UPDATE, (SFXBase*)NULL, float(t / 1000.0));
}
me->m_sfx_commands.lock();
@ -838,11 +838,11 @@ void SFXManager::reallyUpdateNow(SFXCommand *current)
if (m_last_update_time == std::numeric_limits<uint64_t>::max())
{
// first time
m_last_update_time = StkTime::getRealTimeMs();
m_last_update_time = StkTime::getMonoTimeMs();
}
uint64_t previous_update_time = m_last_update_time;
m_last_update_time = StkTime::getRealTimeMs();
m_last_update_time = StkTime::getMonoTimeMs();
float dt = float(m_last_update_time - previous_update_time) / 1000.0f;
assert(current->m_command==SFX_UPDATE);

2
src/input/multitouch_device.cpp
View File

@ -502,7 +502,7 @@ void MultitouchDevice::updateOrientationFromGyroscope(float z)
{
const float GYRO_SPEED_THRESHOLD = 0.005f;
uint64_t now = StkTime::getRealTimeMs();
uint64_t now = StkTime::getMonoTimeMs();
uint64_t delta = now - m_gyro_time;
m_gyro_time = now;
float timedelta = (float)delta / 1000.f;

14
src/main_loop.cpp
View File

@ -118,7 +118,7 @@ float MainLoop::getLimitedDt()
while( 1 )
{
m_curr_time = StkTime::getRealTimeMs();
m_curr_time = StkTime::getMonoTimeMs();
if (m_prev_time > m_curr_time)
{
m_prev_time = m_curr_time;
@ -157,7 +157,7 @@ float MainLoop::getLimitedDt()
while (dt == 0)
{
StkTime::sleep(1);
m_curr_time = StkTime::getRealTimeMs();
m_curr_time = StkTime::getMonoTimeMs();
if (m_prev_time > m_curr_time)
{
Log::error("MainLopp", "System clock keeps backwards!");
@ -313,7 +313,7 @@ void MainLoop::updateRace(int ticks, bool fast_forward)
*/
void MainLoop::run()
{
m_curr_time = StkTime::getRealTimeMs();
m_curr_time = StkTime::getMonoTimeMs();
// DT keeps track of the leftover time, since the race update
// happens in fixed timesteps
float left_over_time = 0;
@ -525,7 +525,7 @@ void MainLoop::run()
// in CutsceneWorld::enterRaceOverState
// Reset the timer for correct time for cutscene
m_frame_before_loading_world = false;
m_curr_time = StkTime::getRealTimeMs();
m_curr_time = StkTime::getMonoTimeMs();
left_over_time = 0.0f;
break;
}
@ -553,7 +553,7 @@ void MainLoop::run()
{
// irr_driver->getDevice()->run() loads the world
m_frame_before_loading_world = false;
m_curr_time = StkTime::getRealTimeMs();
m_curr_time = StkTime::getMonoTimeMs();
left_over_time = 0.0f;
}
@ -608,7 +608,7 @@ void MainLoop::renderGUI(int phase, int loop_index, int loop_size)
return;
}
uint64_t now = StkTime::getRealTimeMs();
uint64_t now = StkTime::getMonoTimeMs();
float dt = (now - m_curr_time)/1000.0f;
if (dt < 1.0 / 30.0f) return;
@ -624,7 +624,7 @@ void MainLoop::renderGUI(int phase, int loop_index, int loop_size)
m_request_abort = !irr_driver->getDevice()->run();
//TODO: remove debug output
// uint64_t now2 = StkTime::getRealTimeMs();
// uint64_t now2 = StkTime::getMonoTimeMs();
// Log::verbose("mainloop", " duration t %llu dt %llu", now, now2-now);
#endif
} // renderGUI

2
src/network/network_timer_synchronizer.hpp
View File

@ -68,7 +68,7 @@ public:
return;
}
const uint64_t cur_time = StkTime::getRealTimeMs();
const uint64_t cur_time = StkTime::getMonoTimeMs();
// Discard too close time compared to last ping
// (due to resend when packet loss)
// 10 packets per second as seen in STKHost

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

@ -422,7 +422,7 @@ void ClientLobby::update(int ticks)
if (!m_received_server_result)
{
m_received_server_result = true;
m_auto_back_to_lobby_time = StkTime::getRealTimeMs() + 5000;
m_auto_back_to_lobby_time = StkTime::getMonoTimeMs() + 5000;
// In case someone opened paused race dialog or menu in network game
GUIEngine::ModalDialog::dismiss();
GUIEngine::ScreenKeyboard::dismiss();
@ -431,7 +431,7 @@ void ClientLobby::update(int ticks)
World::getWorld()->enterRaceOverState();
}
if (NetworkConfig::get()->isAutoConnect() &&
StkTime::getRealTimeMs() > m_auto_back_to_lobby_time)
StkTime::getMonoTimeMs() > m_auto_back_to_lobby_time)
{
m_auto_back_to_lobby_time = std::numeric_limits<uint64_t>::max();
doneWithResults();

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

@ -55,9 +55,9 @@ void ConnectToPeer::asynchronousUpdate()
break;
}
// Each 2 second for a ping or broadcast
if (StkTime::getRealTimeMs() > m_timer + 2000)
if (StkTime::getMonoTimeMs() > m_timer + 2000)
{
m_timer = StkTime::getRealTimeMs();
m_timer = StkTime::getMonoTimeMs();
// Send a broadcast packet with the string aloha_stk inside,
// the client will use enet intercept to discover if server
// address or port is different from stk addons database.

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

@ -90,14 +90,14 @@ void ConnectToServer::getClientServerInfo()
assert(m_server);
// Allow up to 10 seconds for the separate process to fully start-up
bool started = false;
uint64_t timeout = StkTime::getRealTimeMs() + 10000;
uint64_t timeout = StkTime::getMonoTimeMs() + 10000;
const std::string& sid = NetworkConfig::get()->getServerIdFile();
assert(!sid.empty());
const std::string dir = StringUtils::getPath(sid);
const std::string server_id_file = StringUtils::getBasename(sid);
uint16_t port = 0;
unsigned server_id = 0;
while (StkTime::getRealTimeMs() < timeout)
while (StkTime::getMonoTimeMs() < timeout)
{
std::set<std::string> files;
file_manager->listFiles(files, dir);

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

@ -163,7 +163,7 @@ void LobbyProtocol::setup()
void LobbyProtocol::startVotingPeriod(float max_time)
{
m_max_voting_time = uint64_t(max_time*1000);
m_end_voting_period.store(StkTime::getRealTimeMs() + m_max_voting_time);
m_end_voting_period.store(StkTime::getMonoTimeMs() + m_max_voting_time);
} // startVotingPeriod
//-----------------------------------------------------------------------------
@ -171,9 +171,9 @@ void LobbyProtocol::startVotingPeriod(float max_time)
float LobbyProtocol::getRemainingVotingTime()
{
if (m_end_voting_period.load() == 0 ||
StkTime::getRealTimeMs() >= m_end_voting_period.load())
StkTime::getMonoTimeMs() >= m_end_voting_period.load())
return 0.0f;
uint64_t t = m_end_voting_period.load() - StkTime::getRealTimeMs();
uint64_t t = m_end_voting_period.load() - StkTime::getMonoTimeMs();
return t / 1000.0f;
} // getRemainingVotingTime
@ -182,7 +182,7 @@ float LobbyProtocol::getRemainingVotingTime()
bool LobbyProtocol::isVotingOver()
{
return m_end_voting_period.load() != 0 &&
m_end_voting_period.load() < StkTime::getRealTimeMs();
m_end_voting_period.load() < StkTime::getMonoTimeMs();
} // isVotingOver
//-----------------------------------------------------------------------------

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

@ -124,7 +124,7 @@ ServerLobby::ServerLobby() : LobbyProtocol(NULL)
}
m_rs_state.store(RS_NONE);
m_last_success_poll_time.store(StkTime::getRealTimeMs() + 30000);
m_last_success_poll_time.store(StkTime::getMonoTimeMs() + 30000);
m_server_owner_id.store(-1);
m_registered_for_once_only = false;
m_has_created_server_id_file = false;
@ -809,7 +809,7 @@ void ServerLobby::asynchronousUpdate()
if (NetworkConfig::get()->isWAN() &&
allowJoinedPlayersWaiting() && m_server_recovering.expired() &&
StkTime::getRealTimeMs() > m_last_success_poll_time.load() + 30000)
StkTime::getMonoTimeMs() > m_last_success_poll_time.load() + 30000)
{
Log::warn("ServerLobby", "Trying auto server recovery.");
registerServer(false/*now*/);
@ -874,7 +874,7 @@ void ServerLobby::asynchronousUpdate()
m_game_setup->isGrandPrixStarted()) &&
m_timeout.load() == std::numeric_limits<int64_t>::max())
{
m_timeout.store((int64_t)StkTime::getRealTimeMs() +
m_timeout.store((int64_t)StkTime::getMonoTimeMs() +
(int64_t)
(ServerConfig::m_start_game_counter * 1000.0f));
}
@ -886,7 +886,7 @@ void ServerLobby::asynchronousUpdate()
updatePlayerList();
m_timeout.store(std::numeric_limits<int64_t>::max());
}
if (m_timeout.load() < (int64_t)StkTime::getRealTimeMs() ||
if (m_timeout.load() < (int64_t)StkTime::getMonoTimeMs() ||
(checkPeersReady() &&
(int)players >= ServerConfig::m_min_start_game_players))
{
@ -1563,14 +1563,14 @@ void ServerLobby::update(int ticks)
resetPeersReady();
// Set the delay before the server forces all clients to exit the race
// result screen and go back to the lobby
m_timeout.store((int64_t)StkTime::getRealTimeMs() + 15000);
m_timeout.store((int64_t)StkTime::getMonoTimeMs() + 15000);
m_state = RESULT_DISPLAY;
sendMessageToPeers(m_result_ns, /*reliable*/ true);
Log::info("ServerLobby", "End of game message sent");
break;
case RESULT_DISPLAY:
if (checkPeersReady() ||
(int64_t)StkTime::getRealTimeMs() > m_timeout.load())
(int64_t)StkTime::getMonoTimeMs() > m_timeout.load())
{
// Send a notification to all clients to exit
// the race result screen
@ -1635,7 +1635,7 @@ bool ServerLobby::registerServer(bool now)
Log::info("ServerLobby",
"Server %d is now online.", server_id_online);
sl->m_server_id_online.store(server_id_online);
sl->m_last_success_poll_time.store(StkTime::getRealTimeMs());
sl->m_last_success_poll_time.store(StkTime::getMonoTimeMs());
return;
}
Log::error("ServerLobby", "%s",
@ -1933,8 +1933,8 @@ void ServerLobby::checkIncomingConnectionRequests()
// First poll every 5 seconds. Return if no polling needs to be done.
const uint64_t POLL_INTERVAL = 5000;
static uint64_t last_poll_time = 0;
if (StkTime::getRealTimeMs() < last_poll_time + POLL_INTERVAL ||
StkTime::getRealTimeMs() > m_last_success_poll_time.load() + 30000 ||
if (StkTime::getMonoTimeMs() < last_poll_time + POLL_INTERVAL ||
StkTime::getMonoTimeMs() > m_last_success_poll_time.load() + 30000 ||
m_server_id_online.load() == 0)
return;
@ -1948,7 +1948,7 @@ void ServerLobby::checkIncomingConnectionRequests()
}
// Now poll the stk server
last_poll_time = StkTime::getRealTimeMs();
last_poll_time = StkTime::getMonoTimeMs();
// ========================================================================
class PollServerRequest : public Online::XMLRequest
@ -1975,7 +1975,7 @@ void ServerLobby::checkIncomingConnectionRequests()
auto sl = m_server_lobby.lock();
if (!sl)
return;
sl->m_last_success_poll_time.store(StkTime::getRealTimeMs());
sl->m_last_success_poll_time.store(StkTime::getMonoTimeMs());
if (sl->m_state.load() != WAITING_FOR_START_GAME &&
!sl->allowJoinedPlayersWaiting())
{
@ -2758,7 +2758,7 @@ void ServerLobby::handleUnencryptedConnection(std::shared_ptr<STKPeer> peer,
else
{
auto_start_timer =
(m_timeout.load() - (int64_t)StkTime::getRealTimeMs()) / 1000.0f;
(m_timeout.load() - (int64_t)StkTime::getMonoTimeMs()) / 1000.0f;
}
message_ack->addUInt8(LE_CONNECTION_ACCEPTED).addUInt32(peer->getHostId())
.addUInt32(ServerConfig::m_server_version);

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

@ -246,7 +246,7 @@ private:
}
void addPeerConnection(const std::string& addr_str)
{
m_pending_peer_connection[addr_str] = StkTime::getRealTimeMs();
m_pending_peer_connection[addr_str] = StkTime::getMonoTimeMs();
}
void removeExpiredPeerConnection()
{
@ -255,7 +255,7 @@ private:
for (auto it = m_pending_peer_connection.begin();
it != m_pending_peer_connection.end();)
{
if (StkTime::getRealTimeMs() - it->second > 45000)
if (StkTime::getMonoTimeMs() - it->second > 45000)
it = m_pending_peer_connection.erase(it);
else
it++;

10
src/network/servers_manager.cpp
View File

@ -157,7 +157,7 @@ Online::XMLRequest* ServersManager::getLANRefreshRequest() const
char buffer[LEN];
// Wait for up to 0.5 seconds to receive an answer from
// any local servers.
uint64_t start_time = StkTime::getRealTimeMs();
uint64_t start_time = StkTime::getMonoTimeMs();
const uint64_t DURATION = 1000;
const auto& servers = ServersManager::get()->getServers();
int cur_server_id = (int)servers.size();
@ -168,7 +168,7 @@ Online::XMLRequest* ServersManager::getLANRefreshRequest() const
// because e.g. a local client would answer as 127.0.0.1 and
// 192.168.**.
std::map<irr::core::stringw, std::shared_ptr<Server> > servers_now;
while (StkTime::getRealTimeMs() - start_time < DURATION)
while (StkTime::getMonoTimeMs() - start_time < DURATION)
{
TransportAddress sender;
int len = broadcast->receiveRawPacket(buffer, LEN, &sender, 1);
@ -236,7 +236,7 @@ void ServersManager::setLanServers(const std::map<irr::core::stringw,
{
m_servers.clear();
for (auto i : servers) m_servers.emplace_back(i.second);
m_last_load_time.store(StkTime::getRealTimeMs());
m_last_load_time.store(StkTime::getMonoTimeMs());
m_list_updated = true;
}
@ -246,7 +246,7 @@ void ServersManager::setLanServers(const std::map<irr::core::stringw,
*/
bool ServersManager::refresh(bool full_refresh)
{
if (StkTime::getRealTimeMs() - m_last_load_time.load()
if (StkTime::getMonoTimeMs() - m_last_load_time.load()
< SERVER_REFRESH_INTERVAL)
{
// Avoid too frequent refreshing
@ -305,7 +305,7 @@ void ServersManager::setWanServers(bool success, const XMLNode* input)
}
m_servers.emplace_back(std::make_shared<Server>(*s));
}
m_last_load_time.store(StkTime::getRealTimeMs());
m_last_load_time.store(StkTime::getMonoTimeMs());
m_list_updated = true;
} // refresh

34
src/network/stk_host.cpp
View File

@ -297,7 +297,7 @@ void STKHost::init()
m_players_in_game.store(0);
m_players_waiting.store(0);
m_total_players.store(0);
m_network_timer.store(StkTime::getRealTimeMs());
m_network_timer.store(StkTime::getMonoTimeMs());
m_shutdown = false;
m_authorised = false;
m_network = NULL;
@ -435,7 +435,7 @@ void STKHost::setPublicAddress()
}
m_network->sendRawPacket(s, m_stun_address);
uint64_t ping = StkTime::getRealTimeMs();
uint64_t ping = StkTime::getMonoTimeMs();
freeaddrinfo(res);
// Recieve now
@ -443,7 +443,7 @@ void STKHost::setPublicAddress()
const int LEN = 2048;
char buffer[LEN];
int len = m_network->receiveRawPacket(buffer, LEN, &sender, 2000);
ping = StkTime::getRealTimeMs() - ping;
ping = StkTime::getMonoTimeMs() - ping;
if (sender.getIP() != m_stun_address.getIP())
{
@ -614,7 +614,7 @@ void STKHost::disconnectAllPeers(bool timeout_waiting)
for (auto peer : m_peers)
peer.second->disconnect();
// Wait for at most 2 seconds for disconnect event to be generated
m_exit_timeout.store(StkTime::getRealTimeMs() + 2000);
m_exit_timeout.store(StkTime::getMonoTimeMs() + 2000);
}
m_peers.clear();
} // disconnectAllPeers
@ -708,25 +708,25 @@ void STKHost::mainLoop()
}
}
uint64_t last_ping_time = StkTime::getRealTimeMs();
uint64_t last_update_speed_time = StkTime::getRealTimeMs();
uint64_t last_ping_time_update_for_client = StkTime::getRealTimeMs();
uint64_t last_ping_time = StkTime::getMonoTimeMs();
uint64_t last_update_speed_time = StkTime::getMonoTimeMs();
uint64_t last_ping_time_update_for_client = StkTime::getMonoTimeMs();
std::map<std::string, uint64_t> ctp;
while (m_exit_timeout.load() > StkTime::getRealTimeMs())
while (m_exit_timeout.load() > StkTime::getMonoTimeMs())
{
// Clear outdated connect to peer list every 15 seconds
for (auto it = ctp.begin(); it != ctp.end();)
{
if (it->second + 15000 < StkTime::getRealTimeMs())
if (it->second + 15000 < StkTime::getMonoTimeMs())
it = ctp.erase(it);
else
it++;
}
if (last_update_speed_time < StkTime::getRealTimeMs())
if (last_update_speed_time < StkTime::getMonoTimeMs())
{
// Update upload / download speed per second
last_update_speed_time = StkTime::getRealTimeMs() + 1000;
last_update_speed_time = StkTime::getMonoTimeMs() + 1000;
m_upload_speed.store(getNetwork()->getENetHost()->totalSentData);
m_download_speed.store(
getNetwork()->getENetHost()->totalReceivedData);
@ -754,11 +754,11 @@ void STKHost::mainLoop()
const float timeout = ServerConfig::m_validation_timeout;
bool need_ping = false;
if (sl && (!sl->isRacing() || sl->allowJoinedPlayersWaiting()) &&
last_ping_time < StkTime::getRealTimeMs())
last_ping_time < StkTime::getMonoTimeMs())
{
// If not racing, send an reliable packet at the 10 packets
// per second, which is for accurate ping calculation by enet
last_ping_time = StkTime::getRealTimeMs() +
last_ping_time = StkTime::getMonoTimeMs() +
(uint64_t)((1.0f / 10.0f) * 1000.0f);
need_ping = true;
}
@ -909,10 +909,10 @@ void STKHost::mainLoop()
{
auto lp = LobbyProtocol::get<LobbyProtocol>();
if (!is_server &&
last_ping_time_update_for_client < StkTime::getRealTimeMs())
last_ping_time_update_for_client < StkTime::getMonoTimeMs())
{
last_ping_time_update_for_client =
StkTime::getRealTimeMs() + 2000;
StkTime::getMonoTimeMs() + 2000;
if (lp && lp->isRacing())
{
auto p = getServerPeerForClient();
@ -1070,7 +1070,7 @@ void STKHost::mainLoop()
else
delete stk_event;
} // while enet_host_service
} // while m_exit_timeout.load() > StkTime::getRealTimeMs()
} // while m_exit_timeout.load() > StkTime::getMonoTimeMs()
delete direct_socket;
Log::info("STKHost", "Listening has been stopped.");
} // mainLoop
@ -1140,7 +1140,7 @@ void STKHost::handleDirectSocketRequest(Network* direct_socket,
}
if (ctp.find(peer_addr) == ctp.end())
{
ctp[peer_addr] = StkTime::getRealTimeMs();
ctp[peer_addr] = StkTime::getMonoTimeMs();
std::make_shared<ConnectToPeer>(sender)->requestStart();
}
}

4
src/network/stk_host.hpp
View File

@ -348,10 +348,10 @@ public:
{ return m_nts.get(); }
// ------------------------------------------------------------------------
uint64_t getNetworkTimer() const
{ return StkTime::getRealTimeMs() - m_network_timer.load(); }
{ return StkTime::getMonoTimeMs() - m_network_timer.load(); }
// ------------------------------------------------------------------------
void setNetworkTimer(uint64_t ticks)
{ m_network_timer.store(StkTime::getRealTimeMs() - ticks); }
{ m_network_timer.store(StkTime::getMonoTimeMs() - ticks); }
// ------------------------------------------------------------------------
std::pair<int, int> getAllPlayersTeamInfo() const;
// ------------------------------------------------------------------------

4
src/network/stk_peer.cpp
View File

@ -37,14 +37,14 @@ STKPeer::STKPeer(ENetPeer *enet_peer, STKHost* host, uint32_t host_id)
{
m_enet_peer = enet_peer;
m_host_id = host_id;
m_connected_time = StkTime::getRealTimeMs();
m_connected_time = StkTime::getMonoTimeMs();
m_validated.store(false);
m_average_ping.store(0);
m_waiting_for_game.store(true);
m_spectator.store(false);
m_disconnected.store(false);
m_warned_for_high_ping.store(false);
m_last_activity.store((int64_t)StkTime::getRealTimeMs());
m_last_activity.store((int64_t)StkTime::getMonoTimeMs());
} // STKPeer
//-----------------------------------------------------------------------------

6
src/network/stk_peer.hpp
View File

@ -142,7 +142,7 @@ public:
uint32_t getHostId() const { return m_host_id; }
// ------------------------------------------------------------------------
float getConnectedTime() const
{ return float(StkTime::getRealTimeMs() - m_connected_time) / 1000.0f; }
{ return float(StkTime::getMonoTimeMs() - m_connected_time) / 1000.0f; }
// ------------------------------------------------------------------------
void setAvailableKartsTracks(std::set<std::string>& k,
std::set<std::string>& t)
@ -225,12 +225,12 @@ public:
const std::string& getUserVersion() const { return m_user_version; }
// ------------------------------------------------------------------------
void updateLastActivity()
{ m_last_activity.store((int64_t)StkTime::getRealTimeMs()); }
{ m_last_activity.store((int64_t)StkTime::getMonoTimeMs()); }
// ------------------------------------------------------------------------
int idleForSeconds() const
{
int64_t diff =
(int64_t)StkTime::getRealTimeMs() - m_last_activity.load();
(int64_t)StkTime::getMonoTimeMs() - m_last_activity.load();
if (diff < 0)
return 0;
return (int)(diff / 1000);

6
src/states_screens/dialogs/player_rankings_dialog.cpp
View File

@ -165,12 +165,12 @@ GUIEngine::EventPropagation
}
else if (selection == m_refresh_widget->m_properties[PROP_ID])
{
static uint64_t timer = StkTime::getRealTimeMs();
static uint64_t timer = StkTime::getMonoTimeMs();
// 1 minute per refresh
if (StkTime::getRealTimeMs() < timer + 60000)
if (StkTime::getMonoTimeMs() < timer + 60000)
return GUIEngine::EVENT_BLOCK;
timer = StkTime::getRealTimeMs();
timer = StkTime::getMonoTimeMs();
*m_fetched_ranking = false;
updatePlayerRanking(m_name, m_online_id, m_ranking_info,
m_fetched_ranking);

4
src/states_screens/online/network_kart_selection.cpp
View File

@ -72,7 +72,7 @@ void NetworkKartSelectionScreen::init()
*/
void NetworkKartSelectionScreen::onUpdate(float dt)
{
if (StkTime::getRealTimeMs() > m_exit_timeout)
if (StkTime::getMonoTimeMs() > m_exit_timeout)
{
// Reset the screen to networking menu if failed to back to lobby
STKHost::get()->shutdown();
@ -154,7 +154,7 @@ bool NetworkKartSelectionScreen::onEscapePressed()
{
// Send go back lobby event to server with an exit timeout, so if
// server doesn't react in time we exit the server
m_exit_timeout = StkTime::getRealTimeMs() + 5000;
m_exit_timeout = StkTime::getMonoTimeMs() + 5000;
NetworkString back(PROTOCOL_LOBBY_ROOM);
back.addUInt8(LobbyProtocol::LE_CLIENT_BACK_LOBBY);
STKHost::get()->sendToServer(&back, true);

10
src/states_screens/online/networking_lobby.cpp
View File

@ -296,9 +296,9 @@ void NetworkingLobby::onUpdate(float delta)
m_config_button->setImage(m_config_texture);
m_client_live_joinable = false;
if (m_player_list && StkTime::getRealTimeMs() > m_ping_update_timer)
if (m_player_list && StkTime::getMonoTimeMs() > m_ping_update_timer)
{
m_ping_update_timer = StkTime::getRealTimeMs() + 2000;
m_ping_update_timer = StkTime::getMonoTimeMs() + 2000;
updatePlayerPings();
}
@ -415,7 +415,7 @@ void NetworkingLobby::onUpdate(float delta)
if (cur_player >= m_min_start_game_players &&
m_cur_starting_timer == std::numeric_limits<int64_t>::max())
{
m_cur_starting_timer = (int64_t)StkTime::getRealTimeMs() +
m_cur_starting_timer = (int64_t)StkTime::getMonoTimeMs() +
(int64_t)(m_start_timeout * 1000.0);
}
else if (cur_player < m_min_start_game_players)
@ -433,7 +433,7 @@ void NetworkingLobby::onUpdate(float delta)
if (m_cur_starting_timer != std::numeric_limits<int64_t>::max())
{
int64_t remain = (m_cur_starting_timer -
(int64_t)StkTime::getRealTimeMs()) / 1000;
(int64_t)StkTime::getMonoTimeMs()) / 1000;
if (remain < 0)
remain = 0;
//I18N: In the networking lobby, display the starting timeout
@ -752,5 +752,5 @@ void NetworkingLobby::initAutoStartTimer(bool grand_prix_started,
void NetworkingLobby::setStartingTimerTo(float t)
{
m_cur_starting_timer =
(int64_t)StkTime::getRealTimeMs() + (int64_t)(t * 1000.0f);
(int64_t)StkTime::getMonoTimeMs() + (int64_t)(t * 1000.0f);
} // setStartingTimerTo

2
src/states_screens/online/tracks_screen.cpp
View File

@ -674,7 +674,7 @@ void TracksScreen::onUpdate(float dt)
{
int list_id =
m_vote_list->getItemID(StringUtils::toString(m_winning_index));
//if (StkTime::getRealTimeMs() / 1000 % 2 == 0)
//if (StkTime::getMonoTimeMs() / 1000 % 2 == 0)
m_vote_list->setSelectionID(list_id);
//else
// m_vote_list->unfocused(PLAYER_ID_GAME_MASTER, NULL);

6
src/tracks/check_trigger.cpp
View File

@ -32,7 +32,7 @@ CheckTrigger::CheckTrigger(const Vec3& center, float distance,
m_center(center), m_distance2(distance * distance),
m_triggering_function(triggering_function)
{
m_last_triggered_time = StkTime::getRealTimeMs();
m_last_triggered_time = StkTime::getMonoTimeMs();
} // CheckSphere
// ----------------------------------------------------------------------------
@ -44,12 +44,12 @@ bool CheckTrigger::isTriggered(const Vec3 &old_pos, const Vec3 &new_pos,
// kart_id will be -1 if called by CheckManager::getChecklineTriggering
if (kart_id < 0 || kart_id >= (int)World::getWorld()->getNumKarts())
return false;
if (m_last_triggered_time + 2000 > StkTime::getRealTimeMs())
if (m_last_triggered_time + 2000 > StkTime::getMonoTimeMs())
return false;
AbstractKart* k = World::getWorld()->getKart(kart_id);
if ((k->getXYZ() - m_center).length2() < m_distance2)
{
m_last_triggered_time = StkTime::getRealTimeMs();
m_last_triggered_time = StkTime::getMonoTimeMs();
return true;
}
return false;

2
src/tracks/track_object_presentation.cpp
View File

@ -1142,7 +1142,7 @@ TrackObjectPresentationActionTrigger::TrackObjectPresentationActionTrigger(
// ----------------------------------------------------------------------------
void TrackObjectPresentationActionTrigger::onTriggerItemApproached()
{
if (m_reenable_timeout > StkTime::getRealTimeMs())
if (m_reenable_timeout > StkTime::getMonoTimeMs())
{
return;
}

8
src/tracks/track_object_presentation.hpp
View File

@ -412,20 +412,20 @@ public:
// ------------------------------------------------------------------------
/** Reset the trigger (i.e. sets it to active again). */
virtual void reset() OVERRIDE
{ m_reenable_timeout = StkTime::getRealTimeMs(); }
{ m_reenable_timeout = StkTime::getMonoTimeMs(); }
// ------------------------------------------------------------------------
/** Sets the trigger to be enabled or disabled. getRealTimeMs is used to
/** Sets the trigger to be enabled or disabled. getMonoTimeMs is used to
* to avoid called update which duplicated in network rewinding. */
virtual void setEnable(bool status) OVERRIDE
{
m_reenable_timeout = status ? StkTime::getRealTimeMs() :
m_reenable_timeout = status ? StkTime::getMonoTimeMs() :
std::numeric_limits<uint64_t>::max();
}
// ------------------------------------------------------------------------
void setReenableTimeout(float time)
{
m_reenable_timeout =
StkTime::getRealTimeMs() + (uint64_t)(time * 1000.0f);
StkTime::getMonoTimeMs() + (uint64_t)(time * 1000.0f);
}
}; // class TrackObjectPresentationActionTrigger

6
src/utils/time.cpp
View File

@ -24,6 +24,8 @@
#include <ctime>
irr::ITimer *StkTime::m_timer = NULL;
std::chrono::steady_clock::time_point
StkTime::m_mono_start = std::chrono::steady_clock::now();
/** Init function for the timer. It grabs a copy of the timer of the
* current irrlicht device (which is the NULL device). This way the
@ -94,14 +96,14 @@ void StkTime::getDate(int *day, int *month, int *year)
StkTime::ScopeProfiler::ScopeProfiler(const char* name)
{
Log::info("ScopeProfiler", "%s {\n", name);
m_time = getRealTimeMs();
m_time = getMonoTimeMs();
m_name = name;
} // StkTime::ScopeProfiler::ScopeProfiler
// ----------------------------------------------------------------------------
StkTime::ScopeProfiler::~ScopeProfiler()
{
uint64_t difference = getRealTimeMs() - m_time;
uint64_t difference = getMonoTimeMs() - m_time;
Log::info("ScopeProfiler", "} // took %d ms (%s)\n",
(int)difference, m_name.c_str());
} // StkTime::ScopeProfiler::ScopeProfiler

13
src/utils/time.hpp
View File

@ -47,6 +47,8 @@ private:
* (and the sfx threads needs real time at that time). */
static irr::ITimer *m_timer;
/** Initalized when STK starts. */
static std::chrono::steady_clock::time_point m_mono_start;
public:
typedef time_t TimeType;
@ -94,17 +96,14 @@ public:
*/
static double getRealTime(long startAt=0);
// ------------------------------------------------------------------------
/** Returns a time based since epoch.
/** Returns a time based since the starting of stk (monotonic clock).
* The value is a 64bit unsigned integer in milliseconds.
*/
static uint64_t getRealTimeMs()
static uint64_t getMonoTimeMs()
{
auto now = std::chrono::system_clock::now();
auto now_ms =
std::chrono::time_point_cast<std::chrono::milliseconds>(now);
auto epoch = now_ms.time_since_epoch();
auto duration = std::chrono::steady_clock::now() - m_mono_start;
auto value =
std::chrono::duration_cast<std::chrono::milliseconds>(epoch);
std::chrono::duration_cast<std::chrono::milliseconds>(duration);
return value.count();
}
// ------------------------------------------------------------------------