Replace most of C strings with string_view

11 files changed, 37 insertions, 37 deletions

diff --git a/game/server/chat.cc b/game/server/chat.cc
index b7826b0..a0ceba8 100644
--- a/game/server/chat.cc
+++ b/game/server/chat.cc
@@ -23,33 +23,33 @@ void server_chat::init(void)
     globals::dispatcher.sink<protocol::ChatMessage>().connect<&on_chat_message_packet>();
 }
 
-void server_chat::broadcast(const char* message)
+void server_chat::broadcast(std::string_view message)
 {
     server_chat::broadcast(message, "server");
 }
 
-void server_chat::broadcast(const char* message, const char* sender)
+void server_chat::broadcast(std::string_view message, std::string_view sender)
 {
     protocol::ChatMessage packet;
     packet.type = protocol::ChatMessage::TEXT_MESSAGE;
-    packet.message = std::string(message);
-    packet.sender = std::string(sender);
+    packet.message = message;
+    packet.sender = sender;
 
     protocol::broadcast(globals::server_host, protocol::encode(packet));
 
     spdlog::info("<{}> {}", sender, message);
 }
 
-void server_chat::send(Session* session, const char* message)
+void server_chat::send(Session* session, std::string_view message)
 {
     server_chat::send(session, message, "server");
 }
 
-void server_chat::send(Session* session, const char* message, const char* sender)
+void server_chat::send(Session* session, std::string_view message, std::string_view sender)
 {
     protocol::ChatMessage packet;
     packet.type = protocol::ChatMessage::TEXT_MESSAGE;
-    packet.message = std::string(message);
-    packet.sender = std::string(sender);
+    packet.message = message;
+    packet.sender = sender;
     protocol::broadcast(globals::server_host, protocol::encode(packet));
 }
diff --git a/game/server/chat.hh b/game/server/chat.hh
index 524ea78..fdf1a75 100644
--- a/game/server/chat.hh
+++ b/game/server/chat.hh
@@ -7,10 +7,10 @@ struct Session;
 namespace server_chat
 {
 void init(void);
-void broadcast(const char* message);
-void broadcast(const char* message, const char* sender);
-void send(Session* session, const char* message);
-void send(Session* session, const char* message, const char* sender);
+void broadcast(std::string_view message);
+void broadcast(std::string_view message, std::string_view sender);
+void send(Session* session, std::string_view message);
+void send(Session* session, std::string_view message, std::string_view sender);
 } // namespace server_chat
 
 #endif // SERVER_CHAT_HH
diff --git a/game/server/game.cc b/game/server/game.cc
index 231c87b..de9af9c 100644
--- a/game/server/game.cc
+++ b/game/server/game.cc
@@ -69,7 +69,7 @@ void server_game::init(void)
 
 void server_game::init_late(void)
 {
-    server_game::password_hash = math::crc64(password_string.get());
+    server_game::password_hash = math::crc64(password_string.get_value());
 
     sessions::init_late();
 
diff --git a/game/server/main.cc b/game/server/main.cc
index fd940e2..deb0f97 100644
--- a/game/server/main.cc
+++ b/game/server/main.cc
@@ -32,7 +32,7 @@ int main(int argc, char** argv)
 
     shared_game::init(argc, argv);
 
-    spdlog::info("Voxelius Server {}", project_version_string);
+    spdlog::info("Voxelius Server {}", version::semver);
 
     globals::fixed_frametime = 0.0f;
     globals::fixed_frametime_avg = 0.0f;
diff --git a/game/server/sessions.cc b/game/server/sessions.cc
index 7ca0d7c..df74e01 100644
--- a/game/server/sessions.cc
+++ b/game/server/sessions.cc
@@ -61,14 +61,14 @@ static void on_login_request_packet(const protocol::LoginRequest& packet)
 
     // FIXME: calculate voxel registry checksum ahead of time
     // instead of figuring it out every time a new player connects
-    if(packet.voxel_registry_checksum != world::voxel_registry::calcualte_checksum()) {
+    if(packet.voxel_registry_checksum != world::voxel_registry::calculate_checksum()) {
         protocol::Disconnect response;
         response.reason = "protocol.voxel_registry_checksum";
         protocol::send(packet.peer, protocol::encode(response));
         return;
     }
 
-    if(packet.item_registry_checksum != world::item_registry::calcualte_checksum()) {
+    if(packet.item_registry_checksum != world::item_registry::calculate_checksum()) {
         protocol::Disconnect response;
         response.reason = "protocol.item_registry_checksum";
         protocol::send(packet.peer, protocol::encode(response));
@@ -297,11 +297,11 @@ void sessions::shutdown(void)
     dimension_listeners.clear();
 }
 
-Session* sessions::create(ENetPeer* peer, const char* client_username)
+Session* sessions::create(ENetPeer* peer, std::string_view client_username)
 {
     for(unsigned int i = 0U; i < sessions::max_players.get_value(); ++i) {
         if(!sessions_vector[i].peer) {
-            std::uint64_t client_identity = math::crc64(client_username);
+            std::uint64_t client_identity = math::crc64(client_username.data(), client_username.size());
 
             sessions_vector[i].client_index = i;
             sessions_vector[i].client_identity = client_identity;
@@ -309,7 +309,7 @@ Session* sessions::create(ENetPeer* peer, const char* client_username)
             sessions_vector[i].player_entity = entt::null;
             sessions_vector[i].peer = peer;
 
-            username_map[client_username] = &sessions_vector[i];
+            username_map[std::string(client_username)] = &sessions_vector[i];
             identity_map[client_identity] = &sessions_vector[i];
 
             peer->data = &sessions_vector[i];
@@ -323,9 +323,9 @@ Session* sessions::create(ENetPeer* peer, const char* client_username)
     return nullptr;
 }
 
-Session* sessions::find(const char* client_username)
+Session* sessions::find(std::string_view client_username)
 {
-    const auto it = username_map.find(client_username);
+    const auto it = username_map.find(std::string(client_username));
     if(it != username_map.cend()) {
         return it->second;
     }
diff --git a/game/server/sessions.hh b/game/server/sessions.hh
index ee5b22e..e9ce989 100644
--- a/game/server/sessions.hh
+++ b/game/server/sessions.hh
@@ -37,8 +37,8 @@ void shutdown(void);
 
 namespace sessions
 {
-Session* create(ENetPeer* peer, const char* client_username);
-Session* find(const char* client_username);
+Session* create(ENetPeer* peer, std::string_view client_username);
+Session* find(std::string_view client_username);
 Session* find(std::uint16_t client_index);
 Session* find(std::uint64_t client_identity);
 Session* find(ENetPeer* peer);
diff --git a/game/server/whitelist.cc b/game/server/whitelist.cc
index 8a858c6..4e53ee8 100644
--- a/game/server/whitelist.cc
+++ b/game/server/whitelist.cc
@@ -11,7 +11,7 @@
 #include "server/game.hh"
 #include "server/globals.hh"
 
-constexpr static const char* DEFAULT_FILENAME = "whitelist.txt";
+constexpr static std::string_view DEFAULT_FILENAME = "whitelist.txt";
 constexpr static char SEPARATOR_CHAR = ':';
 
 config::Boolean whitelist::enabled(false);
@@ -36,12 +36,12 @@ void whitelist::init_late(void)
         return;
     }
 
-    if(utils::is_whitespace(whitelist::filename.get())) {
+    if(utils::is_whitespace(whitelist::filename.get_value())) {
         spdlog::warn("whitelist: enabled but filename is empty, using default ({})", DEFAULT_FILENAME);
         whitelist::filename.set(DEFAULT_FILENAME);
     }
 
-    PHYSFS_File* file = PHYSFS_openRead(whitelist::filename.get());
+    PHYSFS_File* file = PHYSFS_openRead(whitelist::filename.c_str());
 
     if(file == nullptr) {
         spdlog::warn("whitelist: {}: {}", whitelist::filename.get(), PHYSFS_getErrorByCode(PHYSFS_getLastErrorCode()));
@@ -80,14 +80,14 @@ void whitelist::shutdown(void)
     // UNDONE: implement saving
 }
 
-bool whitelist::contains(const char* username)
+bool whitelist::contains(std::string_view username)
 {
-    return whitelist_map.contains(username);
+    return whitelist_map.contains(std::string(username));
 }
 
-bool whitelist::matches(const char* username, std::uint64_t password_hash)
+bool whitelist::matches(std::string_view username, std::uint64_t password_hash)
 {
-    const auto it = whitelist_map.find(username);
+    const auto it = whitelist_map.find(std::string(username));
 
     if(it == whitelist_map.cend()) {
         // Not whitelisted, no match
diff --git a/game/server/whitelist.hh b/game/server/whitelist.hh
index 8f909b9..b84a34c 100644
--- a/game/server/whitelist.hh
+++ b/game/server/whitelist.hh
@@ -23,8 +23,8 @@ void shutdown(void);
 
 namespace whitelist
 {
-bool contains(const char* username);
-bool matches(const char* username, std::uint64_t password_hash);
+bool contains(std::string_view username);
+bool matches(std::string_view username, std::uint64_t password_hash);
 } // namespace whitelist
 
 #endif // SERVER_WHITELIST_HH
diff --git a/game/server/world/overworld.cc b/game/server/world/overworld.cc
index ff0b6f7..fca3edf 100644
--- a/game/server/world/overworld.cc
+++ b/game/server/world/overworld.cc
@@ -70,7 +70,7 @@ static void compute_tree_feature(unsigned int height, world::Feature& feature, v
     }
 }
 
-world::Overworld::Overworld(const char* name) : Dimension(name, -30.0f)
+world::Overworld::Overworld(std::string_view name) : Dimension(name, -30.0f)
 {
     m_bottommost_chunk.set_limits(-64, -4);
     m_terrain_variation.set_limits(16, 256);
diff --git a/game/server/world/overworld.hh b/game/server/world/overworld.hh
index 4141105..3da0401 100644
--- a/game/server/world/overworld.hh
+++ b/game/server/world/overworld.hh
@@ -25,7 +25,7 @@ namespace world
 {
 class Overworld final : public Dimension {
 public:
-    explicit Overworld(const char* name);
+    explicit Overworld(std::string_view name);
     virtual ~Overworld(void) = default;
 
 public:
diff --git a/game/server/world/universe.cc b/game/server/world/universe.cc
index 9b031ca..fe840da 100644
--- a/game/server/world/universe.cc
+++ b/game/server/world/universe.cc
@@ -41,7 +41,7 @@ static std::string make_chunk_filename(const DimensionMetadata* metadata, const
 
 static void add_new_dimension(world::Dimension* dimension)
 {
-    if(globals::dimensions.count(dimension->get_name())) {
+    if(globals::dimensions.count(std::string(dimension->get_name()))) {
         spdlog::critical("universe: dimension named {} already exists", dimension->get_name());
         std::terminate();
     }
@@ -62,7 +62,7 @@ static void add_new_dimension(world::Dimension* dimension)
         std::terminate();
     }
 
-    globals::dimensions.insert_or_assign(dimension->get_name(), dimension);
+    globals::dimensions.insert_or_assign(std::string(dimension->get_name()), dimension);
 
     auto& mapped_metadata = metadata_map.insert_or_assign(dimension, metadata).first->second;
 
@@ -122,7 +122,7 @@ void world::universe::init_late(void)
         std::terminate();
     }
 
-    auto spawn_dimension = globals::dimensions.find(universe_spawn_dimension.get());
+    auto spawn_dimension = globals::dimensions.find(universe_spawn_dimension.get_value());
 
     if(spawn_dimension == globals::dimensions.cend()) {
         spdlog::critical("universe: {} is not a valid dimension name", universe_spawn_dimension.get());