refactor!: Replace premake5 with CMake. (#551)

Co-authored-by: tupoy-ya <tupoy-ya@users.noreply.github.com>

src/services/players/player.cpp

@@ -0,0 +1,114 @@
+#include "player.hpp"
+#include "network/CNetGamePlayer.hpp"
+#include "services/friends/friends_service.hpp"
+#include "gta_util.hpp"
+
+namespace big
+{
+	player::player(CNetGamePlayer* net_game_player)
+		: m_net_game_player(net_game_player)
+	{
+		m_is_friend = friends_service::is_friend(net_game_player);
+	}
+
+	CVehicle* player::get_current_vehicle() const
+	{
+		if (const auto ped = this->get_ped(); ped != nullptr)
+			if (const auto vehicle = ped->m_vehicle; vehicle != nullptr)
+				return vehicle;
+		return nullptr;
+	}
+
+	const char* player::get_name() const
+	{
+		return m_net_game_player == nullptr ? "" : m_net_game_player->get_name();
+	}
+
+	rage::rlGamerInfo* player::get_net_data() const
+	{
+		return m_net_game_player == nullptr ? nullptr : m_net_game_player->get_net_data();
+	}
+
+	CNetGamePlayer* player::get_net_game_player() const
+	{
+		return m_net_game_player;
+	}
+
+	CPed* player::get_ped() const
+	{
+		if (const auto player_info = this->get_player_info(); player_info != nullptr)
+			if (const auto ped = player_info->m_ped; ped != nullptr)
+				return ped;
+		return nullptr;
+	}
+
+	CPlayerInfo* player::get_player_info() const
+	{
+		if (m_net_game_player != nullptr && m_net_game_player->m_player_info != nullptr)
+			return m_net_game_player->m_player_info;
+		return nullptr;
+	}
+
+	rage::snPlayer* player::get_session_player()
+	{
+		for (std::uint32_t i = 0; i < gta_util::get_network()->m_game_session_ptr->m_player_count; i++)
+		{
+			if (gta_util::get_network()->m_game_session_ptr->m_players[i]->m_player_data.m_host_token == get_net_data()->m_host_token)
+			{
+				return gta_util::get_network()->m_game_session_ptr->m_players[i];
+			}
+		}
+
+		if (gta_util::get_network()->m_game_session_ptr->m_local_player.m_player_data.m_host_token == get_net_data()->m_host_token)
+			return &gta_util::get_network()->m_game_session_ptr->m_local_player;
+
+		return nullptr;
+	}
+
+	rage::snPeer* player::get_session_peer()
+	{
+		for (std::uint32_t i = 0; i < gta_util::get_network()->m_game_session_ptr->m_peer_count; i++)
+		{
+			if (gta_util::get_network()->m_game_session_ptr->m_peers[i]->m_peer_data.m_gamer_handle_2.m_rockstar_id == get_net_data()->m_gamer_handle_2.m_rockstar_id)
+			{
+				return gta_util::get_network()->m_game_session_ptr->m_peers[i];
+			}
+		}
+
+		return nullptr;
+	}
+
+	uint8_t player::id() const
+	{
+		return m_net_game_player == nullptr ? -1 : m_net_game_player->m_player_id;
+	}
+
+	bool player::is_host() const
+	{
+		return m_net_game_player == nullptr ? false : m_net_game_player->is_host();
+	}
+
+	bool player::is_friend() const
+	{
+		return m_is_friend;
+	}
+
+
+	bool player::is_valid() const
+	{
+		return m_net_game_player == nullptr ? false : m_net_game_player->is_valid();
+	}
+
+	bool player::equals(const CNetGamePlayer* net_game_player) const
+	{
+		return net_game_player == m_net_game_player;
+	}
+
+	std::string player::to_lowercase_identifier() const
+	{
+		std::string lower = this->get_name();
+		std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
+
+		return lower;
+	}
+}

src/services/players/player.hpp

@@ -0,0 +1,54 @@
+#pragma once
+#include "player_service.hpp"
+#include "vehicle/CVehicle.hpp"
+#include "network/snSession.hpp"
+
+namespace big
+{
+	class player final
+	{
+		friend class player_service;
+
+		CNetGamePlayer* m_net_game_player = nullptr;
+		std::string m_identifier;
+		bool m_is_friend;
+
+	public:
+		explicit player(CNetGamePlayer* net_game_player);
+		~player() = default;
+
+		player(const player&) = default;
+		player(player&&) noexcept = default;
+		player& operator=(const player&) = default;
+		player& operator=(player&&) noexcept = default;
+
+		float screen_position_x = -1.f;
+		float screen_position_y = -1.f;
+
+		[[nodiscard]] CVehicle* get_current_vehicle() const;
+		[[nodiscard]] const char* get_name() const;
+		[[nodiscard]] rage::rlGamerInfo* get_net_data() const;
+		[[nodiscard]] CNetGamePlayer* get_net_game_player() const;
+		[[nodiscard]] CPed* get_ped() const;
+		[[nodiscard]] CPlayerInfo* get_player_info() const;
+		[[nodiscard]] class rage::snPlayer* get_session_player();
+		[[nodiscard]] class rage::snPeer* get_session_peer();
+
+		[[nodiscard]] uint8_t id() const;
+
+		[[nodiscard]] bool is_friend() const;
+		[[nodiscard]] bool is_host() const;
+		[[nodiscard]] bool is_valid() const;
+
+		bool never_wanted = false;
+
+		std::chrono::system_clock::time_point m_last_transition_msg_sent{};
+		int m_num_failed_transition_attempts = 0;
+
+	protected:
+		bool equals(const CNetGamePlayer* net_game_player) const;
+
+		[[nodiscard]] std::string to_lowercase_identifier() const;
+
+	};
+}

src/services/players/player_service.cpp

@@ -0,0 +1,105 @@
+#include "gta_util.hpp"
+#include "player_service.hpp"
+
+namespace big
+{
+	player_service::player_service()
+		: m_self(), m_selected_player(m_dummy)
+	{
+		g_player_service = this;
+
+		const auto network_player_mgr = gta_util::get_network_player_mgr();
+		if (!network_player_mgr)
+			return;
+
+		m_self = &network_player_mgr->m_local_net_player;
+
+		for (uint16_t i = 0; i < network_player_mgr->m_player_limit; ++i)
+			player_join(network_player_mgr->m_player_list[i]);
+	}
+
+	player_service::~player_service()
+	{
+		g_player_service = nullptr;
+	}
+
+	void player_service::do_cleanup()
+	{
+		m_selected_player = m_dummy;
+		m_players.clear();
+	}
+
+	player_ptr player_service::get_by_name(std::string name)
+	{
+		std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+
+		if (const auto it = m_players.find(name); it != m_players.end())
+			return it->second;
+		return nullptr;
+	}
+
+	player_ptr player_service::get_by_msg_id(uint32_t msg_id) const
+	{
+		for (const auto& [_, player] : m_players)
+			if (player->get_net_game_player()->m_msg_id == msg_id)
+				return player;
+		return nullptr;
+	}
+
+	player_ptr player_service::get_by_id(uint32_t id) const
+	{
+		for (const auto& [name, player] : m_players)
+			if (player->id() == id)
+				return player;
+		return nullptr;
+	}
+
+	player_ptr player_service::get_by_host_token(uint64_t token) const
+	{
+		for (const auto& [name, player] : m_players)
+			if (player->get_net_data()->m_host_token == token)
+				return player;
+		return nullptr;
+	}
+
+	player_ptr player_service::get_selected() const
+	{
+		return m_selected_player;
+	}
+
+	player_ptr player_service::get_self()
+	{
+		if (!m_self_ptr || !m_self_ptr->equals(*m_self))
+		{
+			m_self_ptr = std::make_shared<player>(*m_self);
+		}
+
+		return m_self_ptr;
+	}
+
+	void player_service::player_join(CNetGamePlayer* net_game_player)
+	{
+		if (net_game_player == nullptr || net_game_player == *m_self) return;
+
+		auto plyr = std::make_shared<player>(net_game_player);
+		m_players.emplace(
+			plyr->to_lowercase_identifier(),
+			std::move(plyr)
+		);
+	}
+
+	void player_service::player_leave(CNetGamePlayer* net_game_player)
+	{
+		if (net_game_player == nullptr) return;
+		if (m_selected_player && m_selected_player->equals(net_game_player))
+			m_selected_player = m_dummy;
+
+		auto plyr = std::make_unique<player>(net_game_player);
+		m_players.erase(plyr->to_lowercase_identifier());
+	}
+
+	void player_service::set_selected(player_ptr plyr)
+	{
+		m_selected_player = plyr;
+	}
+}

src/services/players/player_service.hpp

@@ -0,0 +1,56 @@
+#pragma once
+#include "player.hpp"
+
+namespace big
+{
+	class player;
+
+	using player_ptr = std::shared_ptr<player>;
+	using player_entry = std::pair<std::string, player_ptr>;
+	using players = std::map<std::string, player_ptr>;
+
+	class player_service final
+	{
+		CNetGamePlayer** m_self;
+
+		player_ptr m_self_ptr;
+
+		players m_players;
+
+		player_ptr m_dummy = std::make_shared<player>(nullptr);
+		player_ptr m_selected_player;
+	public:
+
+		player_service();
+		~player_service();
+
+		player_service(const player_service&) = delete;
+		player_service(player_service&&) noexcept = delete;
+		player_service& operator=(const player_service&) = delete;
+		player_service& operator=(player_service&&) noexcept = delete;
+
+		void do_cleanup();
+
+		[[nodiscard]] player_ptr get_self();
+
+		[[nodiscard]] player_ptr get_by_name(std::string name);
+		[[nodiscard]] player_ptr get_by_msg_id(uint32_t msg_id) const;
+		[[nodiscard]] player_ptr get_by_id(uint32_t id) const;
+		[[nodiscard]] player_ptr get_by_host_token(uint64_t token) const;
+		[[nodiscard]] player_ptr get_selected() const;
+
+		void player_join(CNetGamePlayer* net_game_player);
+		void player_leave(CNetGamePlayer* net_game_player);
+
+		players& players()
+		{ return m_players; }
+
+		void iterate(const std::function< void(const player_entry &entry) > func)
+		{ for (const auto &iter : m_players) func(iter); }
+
+		void set_selected(player_ptr plyr);
+
+	};
+
+	inline player_service* g_player_service{};
+}