caliverse_server/GameServer/Entity/Party/Helper/PartyHelper.cs

using Nettention.Proud;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;


using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;


using USER_GUID = System.String;
using PARTY_GUID = System.String;


namespace GameServer;

public class PartyHelper
{
    public static void sendToClient(ClientToGame message, HostID target_client)
    {
        GameServerApp.getServerLogic().onSendPacketToHost(target_client, RmiContext.ReliableSend, message);
    }

    public static void sendToClient(ClientToGame message, USER_GUID userGuid)
    {
        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
        if (!player_manager.tryGetUserByPrimaryKey(userGuid, out var player)) return;

        sendToClient(message, player.getHostId());
    }
    
    public static void BroadcastToClients(GlobalPartyDetail party, ClientToGame message, IReadOnlyList<USER_GUID> except_users)
    {
        var party_action = party.getEntityAction<GlobalPartyDetailAction>();
        ArgumentNullException.ThrowIfNull(party_action);
        
        var party_member_attribute = party.getEntityAttribute<PartyMemberAttribute>();
        ArgumentNullException.ThrowIfNull(party_member_attribute);

        var users = party_member_attribute.getPartyMembers().Select(member => member.Key).ToList();
        BroadcastToClients(users, message, except_users);
    }

    public static void BroadcastToClients(IReadOnlyList<USER_GUID> target_users, ClientToGame message,
        IReadOnlyList<USER_GUID> except_users)
    {
        var target_clients = new List<HostID>();
        var player_manager = GameServerApp.getServerLogic().getPlayerManager();
        
        foreach (var user in target_users)
        {
            if (except_users.Contains(user)) continue;
            if (!player_manager.tryGetUserByPrimaryKey(user, out var member)) continue;

            target_clients.Add(member.getHostId());
        }
        
        GameServerApp.getServerLogic().onSendPacketToHosts(target_clients.ToArray(), RmiContext.ReliableSend, message);
    }

    public static void sendToServer(ServerMessage message, string dest_server)
    {
        var rabbit_mq = GameServerApp.getServerLogic().getRabbitMqConnector() as RabbitMqConnector;
        ArgumentNullException.ThrowIfNull(rabbit_mq);
        rabbit_mq.SendMessage(dest_server, message);
    }
    
    public static async Task sendToServerByTargetClient(USER_GUID target_user_guid, ServerMessage message)
    {
        var login_cache = await getOtherUserLoginCache(target_user_guid);
        if (null == login_cache) return;
        
        sendToServer(message, login_cache.CurrentServer);
    }

    public static void BroadcastToServers(GlobalPartyDetail party, ServerMessage message, bool except_me)
    {
        var party_server_attribute = party.getEntityAttribute<PartyServerAttribute>();
        ArgumentNullException.ThrowIfNull(party_server_attribute);

        BroadcastToServers(party_server_attribute.getPartyServers().ToList(), message, except_me);
    }

    public static void BroadcastToServers(IReadOnlyList<PARTY_GUID> servers, ServerMessage message, bool except_me)
    {
        var rabbit_mq = GameServerApp.getServerLogic().getRabbitMqConnector() as RabbitMqConnector;
        ArgumentNullException.ThrowIfNull(rabbit_mq);
        
        foreach (var server in servers)
        {
            if (except_me && server == GameServerApp.getServerLogic().getServerName()) continue;
            rabbit_mq.SendMessage(server, message);
        }
    }

    public static async Task<string?> getUserNicknameFromGuid(USER_GUID userGuid)
    {
        var find = await NicknameDoc.findNicknameFromGuid(userGuid);
        NullReferenceCheckHelper.throwIfNull(find);
        NullReferenceCheckHelper.throwIfNull(find.attrib, () => $"find.attrib is null !!!");
        return find.result.isFail() ? null : find.attrib.Nickname;
    }

    public static LoginCacheRequest? getOwnUserLoginCacheRequest(Player player)
    {
        var game_login_action = player.getEntityAction<GameLoginAction>();
        var login_cache_request = game_login_action.getLoginCacheRequest();

        return login_cache_request;
    }
    
    public static async Task<LoginCache?> getOtherUserLoginCache(USER_GUID user_guid)
    {
        var login_cache_request =
            new LoginCacheOtherUserRequest(GameServerApp.getServerLogic(), GameServerApp.getServerLogic().getRedisConnector(), user_guid);
        var result = await login_cache_request.fetchLogin();
        
        return result.isFail() ? null : login_cache_request.getLoginCache();
    }

    public static async Task<LoginCache?> getOtherUserLoginCache(UserBase requester, USER_GUID user_guid)
    {
        var login_cache_request =
            new LoginCacheOtherUserRequest(requester, GameServerApp.getServerLogic().getRedisConnector(), user_guid);
        var result = await login_cache_request.fetchLogin();
        
        return result.isFail() ? null : login_cache_request.getLoginCache();
    }

    public static PartyMemberInfo makePartyMember(string user_guid, string nickname)
    {
        var server_logic = GameServerApp.getServerLogic();
        var user = new PartyMemberInfo();
        user.Summon = new();
        user.UserGuid = user_guid;
        user.Nickname = nickname;
        user.JoinTime = Timestamp.FromDateTime(DateTime.UtcNow);
            
        if (false == server_logic.getPlayerManager().tryGetUserByPrimaryKey(user_guid, out var player))
        {
            user.LocationInfo = new UserLocationInfo();
            user.LocationInfo.Id = 0;
            user.LocationInfo.IsChannel = server_logic.getServerType().toServerType() == ServerType.Channel ? 1 : 0;
            user.LocationInfo.ChannelNumber = (1 == user.LocationInfo.IsChannel) ? (int)server_logic.getChannelNo() : 0;
        }
        else
        {
            user.LocationInfo = player.getUserLocationInfo();
        }
        
        return user;
    }

    public static float calculateDistance(Pos standard, Pos target)
    {
        var from_vector = new System.Numerics.Vector3(standard.X, standard.Y, standard.Z);
        var to_vector = new System.Numerics.Vector3(target.X, target.Y, target.Z);
        
        return Vector3Helper.distance(from_vector, to_vector);
    }

    public static string getPartyGuidFromPartyInstanceRoomId(string roomId)
    {
        var split = roomId.Split(":");
        if (split.Length < 2) return string.Empty;
        
        return split[1];
    }
}