12121

Service/Application.Domain/Cache/UserCache.cs

@@ -1,7 +1,7 @@
 namespace Application.Domain;
 
-public class UserCache
+public static class UserCache
 {
-    public static string BaseCacheKey = "BaseUserCache:{0}";
-    public static string BaseCacheKeys = "BaseUserCache:{0}:{1}";
+    public const string BaseCacheKey = "BaseUserCache:{0}";
+    public const string BaseCacheKeys = "BaseUserCache:{0}:{1}";
 }

Service/Application.Domain/Config/GameConfig.cs

@@ -16,4 +16,5 @@ public static class GameConfig
     public const int GameAutoBagGoodsId = 10001;//百宝箱物品ID
     public const int GameAutoDrugGoodsId = 10001;//急救箱物品ID
     public const int GameToMapNeedCopper = 5;//传送每海里费用
+    public const int TeamCacheTime = 300;//队伍缓存时间
 }

Service/Application.Domain/Enum/TeamEnum.cs

@@ -0,0 +1,11 @@
+namespace Application.Domain;
+
+public static class TeamEnum
+{
+    public enum TeamCode
+    {
+        Default,
+        Dup,
+        Ot
+    }
+}

Service/Application.Domain/Services/Interface/Pub/IGameTeamService.cs

@@ -0,0 +1,17 @@
+namespace Application.Domain;
+
+public interface IGameTeamService
+{
+    Task<List<TeamModel>> GetTeamDataPage(int area, string code, int page, int limit, RefAsync<int> total);
+    Task<unit_user_team> GetUserTeamData(string userId);
+    Task<game_team> GetTeamInfo(string teamId);
+    Task<List<unit_user_team>> GetTeamMember(string teamId);
+    Task<TeamModel> GetTeamDataByTeamId(string teamId);
+    Task<TeamModel> GetUserTeamInfo(string userId);
+
+    Task<bool> Add(string userId, string teamId, bool isAdd = false, string name = "", int area = 0, string code = "",
+        string par = "", int count = 0);
+    Task<bool> Remove(string userId, string teamId);
+    Task DisTeam(string teamId);
+    Task<bool> UpdateTeamName(string teamId, string name);
+}

Service/Application.Domain/Services/Service/Pub/GameTeamService.cs

@@ -0,0 +1,227 @@
+namespace Application.Domain;
+
+public class GameTeamService(ISqlSugarClient DbClient, IRedisCache redis) : IGameTeamService, ITransient
+{
+    public async Task<List<TeamModel>> GetTeamDataPage(int area, string code, int page, int limit, RefAsync<int> total)
+    {
+        var db = DbClient.AsTenant().GetConnectionWithAttr<game_team>();
+        var data = await db.Queryable<game_team>().Where(it => it.areaId == area && it.code == code)
+            .OrderByDescending(it => it.addTime).ToPageListAsync(page, limit, total);
+        List<TeamModel> result = new List<TeamModel>();
+        foreach (var item in data)
+        {
+            var temp = await GetTeamDataByTeamId(item.teamId);
+            if (temp.state == 1)
+            {
+                result.Add(temp);    
+            }
+        }
+
+        return result;
+    }
+
+    public async Task<unit_user_team> GetUserTeamData(string userId)
+    {
+        string key = string.Format(UserCache.BaseCacheKeys, "TeamData", "UserData");
+        if (await redis.HExistsHashAsync(key, userId))
+        {
+            return await redis.GetHashAsync<unit_user_team>(key, userId);
+        }
+
+        var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_team>();
+        var data = await db.Queryable<unit_user_team>().Where(it => it.userId == userId).SingleAsync();
+        await redis.AddHashAsync(key, userId, data);
+        return data;
+    }
+
+    public async Task<game_team> GetTeamInfo(string teamId)
+    {
+        string key = string.Format(UserCache.BaseCacheKeys, "TeamData", "TeamData");
+        if (await redis.HExistsHashAsync(key, teamId))
+        {
+            return await redis.GetHashAsync<game_team>(key, teamId);
+        }
+
+        var db = DbClient.AsTenant().GetConnectionWithAttr<game_team>();
+        var data = await db.Queryable<game_team>().Where(it => it.teamId == teamId).SingleAsync();
+        await redis.AddHashAsync(key, teamId, data);
+        return data;
+    }
+
+    public async Task<List<unit_user_team>> GetTeamMember(string teamId)
+    {
+        string key = string.Format(UserCache.BaseCacheKeys, "TeamData", "MemberData");
+        if (await redis.HExistsHashAsync(key, teamId))
+        {
+            return await redis.GetHashAsync<List<unit_user_team>>(key, teamId);
+        }
+
+        var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_team>();
+        var data = await db.Queryable<unit_user_team>().Where(it => it.teamId == teamId).ToListAsync();
+        await redis.AddHashAsync(key, teamId, data);
+        return data;
+    }
+
+    private async Task<TeamModel> GetTeamData(string userId)
+    {
+        TeamModel result = new TeamModel();
+        var userTeam = await GetUserTeamData(userId);
+        if (userTeam.teamId == "0")
+        {
+            result.state = 0;
+            result.user = new List<TeamUser>();
+            result.team = new game_team();
+            return result;
+        }
+        else
+        {
+            result = await GetTeamDataByTeamId(userTeam.teamId);
+            return result;
+        }
+    }
+
+    public async Task<TeamModel> GetTeamDataByTeamId(string teamId)
+    {
+        TeamModel result = new TeamModel();
+        var teamInfo = await GetTeamInfo(teamId);
+        if (teamInfo == null)
+        {
+            result.state = 0;
+            result.user = new List<TeamUser>();
+            result.team = new game_team();
+            return result;
+        }
+        else
+        {
+            var mapService = App.GetService<IGameMapService>();
+            result.state = 1;
+            result.team = teamInfo;
+            var members = await GetTeamMember(teamId);
+            List<TeamUser> user = new List<TeamUser>();
+            foreach (var member in members)
+            {
+                TeamUser temp = new TeamUser();
+                temp.user = await UserModelTool.GetUserView(member.userId);
+                var onMap = await mapService.GetUserOnMapInfo(member.userId);
+                temp.isOnline = onMap.isOnline;
+                user.Add(temp);
+            }
+
+            result.codeTips = "普通";
+            result.user = user;
+            return result;
+        }
+    }
+
+    public async Task<TeamModel> GetUserTeamInfo(string userId)
+    {
+        string key = string.Format(UserCache.BaseCacheKeys, "TeamData", userId);
+        if (await redis.ExistsAsync(key))
+        {
+            return await redis.GetAsync<TeamModel>(key);
+        }
+
+        var data = await GetTeamData(userId);
+        await redis.SetAsync(key, data, GameConfig.TeamCacheTime);
+        return data;
+    }
+
+
+    private async Task ClearTeamCache(string teamId)
+    {
+        var members = await GetTeamMember(teamId);
+        string key = string.Format(UserCache.BaseCacheKeys, "TeamData", "TeamData");
+        await redis.DelHashAsync(key, teamId);
+        key = string.Format(UserCache.BaseCacheKeys, "TeamData", "MemberData");
+        await redis.DelHashAsync(key, teamId);
+        List<string> memberDataKeys = new List<string>();
+        List<string> userDataKeys = new List<string>();
+        foreach (var member in members)
+        {
+            string mk = string.Format(UserCache.BaseCacheKeys, "TeamData", member.userId);
+            memberDataKeys.Add(mk);
+            userDataKeys.Add(member.userId);
+        }
+
+        await redis.DelAsync(memberDataKeys.ToArray());
+        string uk = string.Format(UserCache.BaseCacheKeys, "TeamData", "UserData");
+        await redis.DelHashAsync(uk, userDataKeys.ToArray());
+    }
+
+    public async Task<bool> Add(string userId, string teamId, bool isAdd = false, string name = "", int area = 0,
+        string code = "",
+        string par = "", int count = 0)
+    {
+        var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_team>();
+        if (isAdd)
+        {
+            game_team team = new game_team()
+            {
+                teamId = teamId,
+                areaId = area,
+                name = name,
+                code = code,
+                par = par,
+                count = count,
+                masterId = userId,
+                addTime = DateTime.Now
+            };
+            await db.Insertable(team).ExecuteCommandAsync();
+        }
+
+        var result = await db.Updateable<unit_user_team>()
+            .SetColumns(it => it.teamId == teamId)
+            .Where(it => it.userId == userId).ExecuteCommandAsync() > 0;
+        if (result)
+        {
+            if (isAdd == false)
+            {
+                await ClearTeamCache(teamId);
+            }
+
+            string key = string.Format(UserCache.BaseCacheKeys, "TeamData", "UserData");
+            await redis.DelHashAsync(key, userId);
+            key = string.Format(UserCache.BaseCacheKeys, "TeamData", userId);
+            await redis.DelAsync(key);
+        }
+
+        return result;
+    }
+
+    public async Task<bool> Remove(string userId, string teamId)
+    {
+        var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_team>();
+        var result = await db.Updateable<unit_user_team>()
+            .SetColumns(it => it.teamId == "0")
+            .Where(it => it.userId == userId).ExecuteCommandAsync() > 0;
+        if (result)
+        {
+            await ClearTeamCache(teamId);
+        }
+
+        return result;
+    }
+
+    public async Task DisTeam(string teamId)
+    {
+        var db = DbClient.AsTenant().GetConnectionWithAttr<game_team>();
+        await db.Deleteable<game_team>().Where(it => it.teamId == teamId).ExecuteCommandAsync();
+        await db.Updateable<unit_user_team>()
+            .SetColumns(it => it.teamId == "0")
+            .Where(it => it.teamId == teamId).ExecuteCommandAsync();
+        await ClearTeamCache(teamId);
+    }
+
+    public async Task<bool> UpdateTeamName(string teamId, string name)
+    {
+        var db = DbClient.AsTenant().GetConnectionWithAttr<game_team>();
+        bool result = await db.Updateable<game_team>().SetColumns(it => it.name == name)
+            .Where(it => it.teamId == teamId).ExecuteCommandAsync() > 0;
+        if (result)
+        {
+            await ClearTeamCache(teamId);
+        }
+
+        return result;
+    }
+}

Service/Application.Domain/Services/Service/User/UnitUserService.cs

@@ -256,6 +256,12 @@ public class UnitUserService(ISqlSugarClient DbClient, IRedisCache redis) : IUni
             onlineTime.monthTime = 0;
             onlineTime.totalTime = 0;
             db.Insertable(onlineTime).AddQueue();
+            
+            //注册队伍
+            unit_user_team team = new unit_user_team();
+            team.userId = userId;
+            team.teamId = "0";
+            db.Insertable(team).AddQueue();
 
             await db.SaveQueuesAsync(false);
         }

Service/Application.Domain/Tool/Base/GameBus.cs

@@ -158,7 +158,7 @@ public class GameBus
                 isok = false;
             }
         }
-        else if (item.code ==nameof(  GameEnum.PropCode.vigour)) //活力
+        else if (item.code == nameof(GameEnum.PropCode.vigour)) //活力
         {
             var attrService = App.GetService<IUnitUserAttrService>();
             var MyAcc = await attrService.GetUserVigourInfo(userId);
@@ -168,7 +168,7 @@ public class GameBus
                 isok = false;
             }
         }
-        else if (item.code ==nameof(  GameEnum.PropCode.lev))
+        else if (item.code == nameof(GameEnum.PropCode.lev))
         {
             var attrService = App.GetService<IUnitUserAttrService>();
             var MyLev = await attrService.GetUserLev(userId);
@@ -177,6 +177,7 @@ public class GameBus
                 isok = false;
             }
         }
+
         result.result = isok;
         result.isDeal = isDeal;
         result.isGive = isGive;
@@ -218,4 +219,102 @@ public class GameBus
     }
 
     #endregion
+
+    #region 概率
+
+    public static List<TowerGet> GetRandomGoods(RandomModel random, int count = 1, int luck = 0)
+    {
+        List<TowerGet> result = new List<TowerGet>();
+        for (int i = 0; i < count; i++)
+        {
+            List<RandomData> timeAward = new List<RandomData>();
+            if (random.code == nameof(RandomModel.RandomCode.Weight))
+            {
+                timeAward = RandomHandleByWeight(random, luck);
+            }
+            else
+            {
+                timeAward = RandomHandleByChance(random, luck);
+            }
+
+            foreach (var item in timeAward)
+            {
+                var onAward = result.FindIndex(it => it.code == item.code && it.parameter == item.par);
+                if(onAward>-1)
+                {
+                    result[onAward].count += item.count;
+                }
+                else
+                {
+                    TowerGet add = new TowerGet()
+                    {
+                        code = item.code,
+                        name = item.name,
+                        parameter = item.par,
+                        count = item.count
+                    };
+                    result.Add(add);
+                }
+            }
+            
+        }
+
+        return result;
+    }
+
+    private static List<RandomData> RandomHandleByWeight(RandomModel random, int luck = 0)
+    {
+        var _randomInstance = new Random();
+        List<RandomData> result = new List<RandomData>();
+        int empty = random.empty - luck;
+        if (_randomInstance.Next(0, 100) < empty)
+        {
+            return result;
+        }
+        if (random.data.Count == 0)
+        {
+            return result;
+        }
+        double totalWeight = random.data.Sum(it => it.chance);
+        int rnd = _randomInstance.Next(Convert.ToInt32(totalWeight) + 1);
+        double current = 0;
+        foreach (var item in random.data)
+        {
+            current += item.chance;
+            if (rnd < current)
+            {
+                result.Add(item);
+                return result;
+            }
+        }
+
+        return result;
+    }
+    private static List<RandomData> RandomHandleByChance(RandomModel random, int luck = 0)
+    {
+        var _randomInstance = new Random();
+        List<RandomData> result = new List<RandomData>();
+        int empty = random.empty - luck;
+        if (_randomInstance.Next(0, 100) < empty)
+        {
+            return result;
+        }
+        if (random.data.Count == 0)
+        {
+            return result;
+        }
+        
+        foreach (var item in random.data)
+        {
+            double rnd = _randomInstance.NextDouble();
+            double okChance = item.chance / 100;
+            if (rnd < okChance)
+            {
+                result.Add(item);
+            }
+        }
+        return result;
+    }
+
+    #endregion
 }

Service/Application.Domain/Tool/ModelTool/UserModelTool.cs

@@ -13,6 +13,7 @@ public class UserModelTool
         UserModel result = new UserModel();
         if (userId == "0")
         {
+            result.userId = "0";
             result.userNo = "0";
             result.nick = "海精灵";
             result.sex = "女";
@@ -29,6 +30,7 @@ public class UserModelTool
             var userInfo = await userService.GetUserInfoByUserId(userId);
             if (userInfo != null)
             {
+                result.userId = userInfo.userId;
                 result.userNo = userInfo.userNo;
                 result.nick = userInfo.nick;
                 result.sex = userInfo.sex;