516 lines
22 KiB
C#
516 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using AutoMapper;
|
|
using Common;
|
|
using Common.Utils;
|
|
using CommonDomain;
|
|
using CommonDomain.BaseModel;
|
|
using CommonDomain.Enum;
|
|
using DotNetCore.CAP;
|
|
using MongoRepository;
|
|
using RedisService;
|
|
using UserDomain;
|
|
using UserDomain.Entity;
|
|
using UserDomain.Enum;
|
|
using UserService.Response;
|
|
using UserService.GameConfigs;
|
|
using UserService.Param;
|
|
|
|
namespace UserService.BattleOrder
|
|
{
|
|
public class BattleOrderService : IBattleOrderService
|
|
{
|
|
private readonly IMongoBaseRepository<UserBattleOrder> _userBattleOrderMongo;
|
|
private readonly IMongoBaseRepository<UserEntity> _userEntityMongo;
|
|
private readonly IActivityConfigService _activityConfigService;
|
|
private readonly ICapPublisher _capPublisher;
|
|
private readonly IRedisService _redisService;
|
|
private readonly IMapper _mapper;
|
|
|
|
public BattleOrderService(
|
|
IMongoBaseRepository<UserBattleOrder> userBattleOrderMongo,
|
|
IMongoBaseRepository<UserEntity> userEntityMongo,
|
|
IActivityConfigService activityConfigService,
|
|
ICapPublisher capPublisher,
|
|
IRedisService redisService,
|
|
IMapper mapper)
|
|
{
|
|
_userBattleOrderMongo = userBattleOrderMongo;
|
|
_userEntityMongo = userEntityMongo;
|
|
_activityConfigService = activityConfigService;
|
|
_capPublisher = capPublisher;
|
|
_redisService = redisService;
|
|
_mapper = mapper;
|
|
}
|
|
|
|
public async Task<UserBattleOrder> GetUserBattleOrderAsync(string userId)
|
|
{
|
|
var config = await _activityConfigService.Get();
|
|
var configuredEndTime = config?.BattleOrderConfig?.EndTime ?? 0;
|
|
var userBattleOrder = await _userBattleOrderMongo.FindOneAsync(c => c.UserId == userId);
|
|
if (userBattleOrder == null)
|
|
{
|
|
userBattleOrder = await CreateOrResetBattleOrderAsync(userId);
|
|
}
|
|
else if (userBattleOrder.EndTime != configuredEndTime &&
|
|
(configuredEndTime == 0 || configuredEndTime > DateTimeOffset.UtcNow.ToUnixTimeSeconds()))
|
|
{
|
|
userBattleOrder = await CreateOrResetBattleOrderAsync(userId);
|
|
}
|
|
return userBattleOrder;
|
|
}
|
|
|
|
public async Task<BattleOrderResponse> GetUserBattleOrderWithConfigAsync(string userId)
|
|
{
|
|
var config = await _activityConfigService.Get();
|
|
var battleOrderConfig = config.BattleOrderConfig;
|
|
BattleOrderGiftProductHelper.Enrich(battleOrderConfig, _redisService.GetGameConfig());
|
|
|
|
if (!IsActivityActive(battleOrderConfig))
|
|
{
|
|
return new BattleOrderResponse
|
|
{
|
|
IsOpen = false,
|
|
Message = "战令未开启或已结束"
|
|
};
|
|
}
|
|
|
|
var userBattleOrder = await GetUserBattleOrderAsync(userId);
|
|
int maxLevel = battleOrderConfig.LevelConfig?.Count ?? 0;
|
|
|
|
var canReceiveLevels = new List<int>();
|
|
for (int i = 1; i <= userBattleOrder.Level && i <= maxLevel; i++)
|
|
{
|
|
bool canReceive = false;
|
|
if (!userBattleOrder.NormalReceivedLevels.Contains(i))
|
|
canReceive = true;
|
|
if ((userBattleOrder.PurchasedAdvances.Contains(1) || userBattleOrder.PurchasedAdvances.Contains(3))
|
|
&& !userBattleOrder.LuxuryReceivedLevels.Contains(i))
|
|
canReceive = true;
|
|
if ((userBattleOrder.PurchasedAdvances.Contains(2) || userBattleOrder.PurchasedAdvances.Contains(3))
|
|
&& !userBattleOrder.SupremeReceivedLevels.Contains(i))
|
|
canReceive = true;
|
|
|
|
if (canReceive)
|
|
canReceiveLevels.Add(i);
|
|
}
|
|
|
|
var levelConfigs = battleOrderConfig.LevelConfig?.Select(l => new BattleOrderLevelInfo
|
|
{
|
|
Level = l.Level,
|
|
Exp = l.Exp,
|
|
NormalGiftList = l.NormalGiftList ?? new List<GiftConfig>(),
|
|
LuxuryGiftList = l.LuxuryGiftList ?? new List<GiftConfig>(),
|
|
SupremeGiftList = l.SupremeGiftList ?? new List<GiftConfig>()
|
|
}).ToList();
|
|
|
|
var advanceGifts = battleOrderConfig.AdvanceGift?.Select(a => new BattleOrderAdvanceInfo
|
|
{
|
|
Type = a.Type,
|
|
Name = a.Name,
|
|
Count = a.Count,
|
|
PayType = a.PayType,
|
|
PayCount = a.PayCount
|
|
}).ToList();
|
|
|
|
return new BattleOrderResponse
|
|
{
|
|
IsOpen = true,
|
|
UserBattleOrder = new UserBattleOrderInfo
|
|
{
|
|
UserId = userBattleOrder.UserId,
|
|
Level = userBattleOrder.Level,
|
|
Exp = userBattleOrder.Exp,
|
|
IsLuxury = userBattleOrder.PurchasedAdvances.Contains(1) || userBattleOrder.PurchasedAdvances.Contains(3),
|
|
IsSupreme = userBattleOrder.PurchasedAdvances.Contains(2) || userBattleOrder.PurchasedAdvances.Contains(3),
|
|
ReceivedLevels = userBattleOrder.NormalReceivedLevels,
|
|
PurchasedAdvances = userBattleOrder.PurchasedAdvances
|
|
},
|
|
Config = new BattleOrderConfigInfo
|
|
{
|
|
EndTime = battleOrderConfig.EndTime,
|
|
RuleDesc = battleOrderConfig.RuleDesc,
|
|
BuyDesc = battleOrderConfig.BuyDesc,
|
|
AdvanceGiftDesc = battleOrderConfig.AdvanceGiftDesc,
|
|
LevelConfig = levelConfigs,
|
|
AdvanceGift = advanceGifts
|
|
}
|
|
};
|
|
}
|
|
|
|
public async Task<(bool success, int newLevel, long remainExp)> AddExpAsync(string userId, long exp)
|
|
{
|
|
exp = exp * 100;
|
|
if (exp <= 0)
|
|
return (false, 1, 0);
|
|
|
|
var userBattleOrder = await GetUserBattleOrderAsync(userId);
|
|
var config = await _activityConfigService.Get();
|
|
var battleOrderConfig = config.BattleOrderConfig;
|
|
|
|
if (!IsActivityActive(battleOrderConfig))
|
|
return (false, userBattleOrder.Level, userBattleOrder.Exp);
|
|
|
|
int maxLevel = battleOrderConfig.LevelConfig?.Count ?? 1;
|
|
if (maxLevel <= 0) maxLevel = 1;
|
|
|
|
if (userBattleOrder.Level >= maxLevel)
|
|
return (true, maxLevel, userBattleOrder.Exp);
|
|
|
|
long totalExp = userBattleOrder.Exp + exp;
|
|
int currentLevel = userBattleOrder.Level;
|
|
|
|
while (currentLevel < maxLevel)
|
|
{
|
|
var levelConfig = battleOrderConfig.LevelConfig?.FirstOrDefault(c => c.Level == currentLevel + 1);
|
|
if (levelConfig == null)
|
|
break;
|
|
|
|
long nextLevelExp = levelConfig.Exp;
|
|
if (totalExp >= nextLevelExp)
|
|
{
|
|
totalExp -= nextLevelExp;
|
|
currentLevel++;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (currentLevel >= maxLevel)
|
|
{
|
|
currentLevel = maxLevel;
|
|
totalExp = 0;
|
|
}
|
|
|
|
userBattleOrder.Level = currentLevel;
|
|
userBattleOrder.Exp = totalExp;
|
|
await _userBattleOrderMongo.ReplaceOneAsync(userBattleOrder);
|
|
|
|
return (true, currentLevel, totalExp);
|
|
}
|
|
|
|
public async Task<(bool success, string message, List<GiftConfig> rewards)> ReceiveAllRewardsAsync(string userId)
|
|
{
|
|
var userBattleOrder = await GetUserBattleOrderAsync(userId);
|
|
var config = await _activityConfigService.Get();
|
|
var battleOrderConfig = config.BattleOrderConfig;
|
|
|
|
if (!IsActivityActive(battleOrderConfig))
|
|
return (false, "战令未开启或已结束", new List<GiftConfig>());
|
|
|
|
List<GiftConfig> allRewards = new List<GiftConfig>();
|
|
int maxLevel = battleOrderConfig.LevelConfig?.Count ?? 0;
|
|
|
|
for (int level = 1; level <= userBattleOrder.Level && level <= maxLevel; level++)
|
|
{
|
|
var levelConfig = battleOrderConfig.LevelConfig?.FirstOrDefault(c => c.Level == level);
|
|
if (levelConfig == null) continue;
|
|
|
|
if (!userBattleOrder.NormalReceivedLevels.Contains(level) && levelConfig.NormalGiftList != null && levelConfig.NormalGiftList.Count > 0)
|
|
{
|
|
userBattleOrder.NormalReceivedLevels.Add(level);
|
|
allRewards.AddRange(levelConfig.NormalGiftList);
|
|
}
|
|
|
|
if ((userBattleOrder.PurchasedAdvances.Contains(1) || userBattleOrder.PurchasedAdvances.Contains(3))
|
|
&& !userBattleOrder.LuxuryReceivedLevels.Contains(level)
|
|
&& levelConfig.LuxuryGiftList != null && levelConfig.LuxuryGiftList.Count > 0)
|
|
{
|
|
userBattleOrder.LuxuryReceivedLevels.Add(level);
|
|
allRewards.AddRange(levelConfig.LuxuryGiftList);
|
|
}
|
|
|
|
if ((userBattleOrder.PurchasedAdvances.Contains(2) || userBattleOrder.PurchasedAdvances.Contains(3))
|
|
&& !userBattleOrder.SupremeReceivedLevels.Contains(level)
|
|
&& levelConfig.SupremeGiftList != null && levelConfig.SupremeGiftList.Count > 0)
|
|
{
|
|
userBattleOrder.SupremeReceivedLevels.Add(level);
|
|
allRewards.AddRange(levelConfig.SupremeGiftList);
|
|
}
|
|
}
|
|
|
|
await _userBattleOrderMongo.ReplaceOneAsync(userBattleOrder);
|
|
|
|
return (true, $"领取成功，共{allRewards.Count}个奖励", allRewards);
|
|
}
|
|
|
|
public async Task<(bool success, string message, List<GiftConfig> rewards)> ReceiveLevelRewardAsync(string userId, int level)
|
|
{
|
|
var userBattleOrder = await GetUserBattleOrderAsync(userId);
|
|
var config = await _activityConfigService.Get();
|
|
var battleOrderConfig = config.BattleOrderConfig;
|
|
|
|
if (!IsActivityActive(battleOrderConfig))
|
|
return (false, "战令未开启或已结束", new List<GiftConfig>());
|
|
|
|
if (level <= 0 || level > userBattleOrder.Level)
|
|
return (false, "等级不满足", new List<GiftConfig>());
|
|
|
|
var levelConfig = battleOrderConfig.LevelConfig?.FirstOrDefault(c => c.Level == level);
|
|
if (levelConfig == null)
|
|
return (false, "等级配置不存在", new List<GiftConfig>());
|
|
|
|
List<GiftConfig> rewards = new List<GiftConfig>();
|
|
|
|
if (!userBattleOrder.NormalReceivedLevels.Contains(level) && levelConfig.NormalGiftList != null && levelConfig.NormalGiftList.Count > 0)
|
|
{
|
|
userBattleOrder.NormalReceivedLevels.Add(level);
|
|
rewards.AddRange(levelConfig.NormalGiftList);
|
|
}
|
|
|
|
if ((userBattleOrder.PurchasedAdvances.Contains(1) || userBattleOrder.PurchasedAdvances.Contains(3))
|
|
&& !userBattleOrder.LuxuryReceivedLevels.Contains(level)
|
|
&& levelConfig.LuxuryGiftList != null && levelConfig.LuxuryGiftList.Count > 0)
|
|
{
|
|
userBattleOrder.LuxuryReceivedLevels.Add(level);
|
|
rewards.AddRange(levelConfig.LuxuryGiftList);
|
|
}
|
|
|
|
if ((userBattleOrder.PurchasedAdvances.Contains(2) || userBattleOrder.PurchasedAdvances.Contains(3))
|
|
&& !userBattleOrder.SupremeReceivedLevels.Contains(level)
|
|
&& levelConfig.SupremeGiftList != null && levelConfig.SupremeGiftList.Count > 0)
|
|
{
|
|
userBattleOrder.SupremeReceivedLevels.Add(level);
|
|
rewards.AddRange(levelConfig.SupremeGiftList);
|
|
}
|
|
|
|
if (rewards.Count == 0)
|
|
return (false, "没有可领取的奖励", new List<GiftConfig>());
|
|
|
|
await _userBattleOrderMongo.ReplaceOneAsync(userBattleOrder);
|
|
|
|
return (true, "领取成功", rewards);
|
|
}
|
|
|
|
public async Task<(bool success, string message, int newLevel, int cost)> BuyLevelsAsync(string userId, int levelCount)
|
|
{
|
|
if (levelCount <= 0)
|
|
return (false, "购买数量不正确", 0, 0);
|
|
|
|
var userBattleOrder = await GetUserBattleOrderAsync(userId);
|
|
var config = await _activityConfigService.Get();
|
|
var battleOrderConfig = config.BattleOrderConfig;
|
|
|
|
if (!IsActivityActive(battleOrderConfig))
|
|
return (false, "战令未开启或已结束", userBattleOrder.Level, 0);
|
|
|
|
int maxLevel = battleOrderConfig.LevelConfig?.Count ?? 1;
|
|
int availableLevels = maxLevel - userBattleOrder.Level;
|
|
if (availableLevels <= 0)
|
|
return (false, "已达到最高等级", userBattleOrder.Level, 0);
|
|
|
|
int actualBuyCount = Math.Min(levelCount, availableLevels);
|
|
|
|
int totalCost = 0;
|
|
for (int i = 0; i < actualBuyCount; i++)
|
|
{
|
|
int targetLevel = userBattleOrder.Level + i + 1;
|
|
var levelConfig = battleOrderConfig.LevelConfig?.FirstOrDefault(c => c.Level == targetLevel);
|
|
if (levelConfig != null)
|
|
{
|
|
totalCost += levelConfig.PayCount;
|
|
}
|
|
}
|
|
|
|
if (totalCost <= 0)
|
|
return (false, "价格计算错误", userBattleOrder.Level, 0);
|
|
|
|
var user = await _userEntityMongo.FindByIdAsync(userId);
|
|
if (user == null)
|
|
return (false, "用户不存在", userBattleOrder.Level, 0);
|
|
|
|
var levelConfig1 = battleOrderConfig.LevelConfig?.FirstOrDefault(c => c.Level == userBattleOrder.Level + 1);
|
|
int payType = levelConfig1?.PayType ?? 1;
|
|
|
|
if (payType == 1 && user.Assets.Gold < totalCost)
|
|
return (false, "金币不足", userBattleOrder.Level, 0);
|
|
if (payType == 2 && user.Assets.Diamond < totalCost)
|
|
return (false, "钻石不足", userBattleOrder.Level, 0);
|
|
|
|
var assetChangeType = payType == 1 ? UserAssetChangeTypeEnum.减少 : UserAssetChangeTypeEnum.减少;
|
|
_capPublisher.Publish(TopicKeys.用户资产变更, new UserAssetParam()
|
|
{
|
|
ChangeType = assetChangeType,
|
|
UserId = userId,
|
|
Gold = payType == 1 ? -totalCost : 0,
|
|
Diamond = payType == 2 ? -totalCost : 0,
|
|
Remark = $"购买战令等级×{actualBuyCount}",
|
|
Source = RewardSource.战令购买
|
|
});
|
|
|
|
userBattleOrder.Level += actualBuyCount;
|
|
userBattleOrder.Exp = 0;
|
|
await _userBattleOrderMongo.ReplaceOneAsync(userBattleOrder);
|
|
|
|
return (true, $"购买成功，等级提升{actualBuyCount}级", userBattleOrder.Level, totalCost);
|
|
}
|
|
|
|
public async Task<(bool success, string message, List<int> purchasedAdvances)> BuyAdvanceAsync(string userId, int type)
|
|
{
|
|
if (type <= 0 || type > 3)
|
|
return (false, "进阶类型不正确", new List<int>());
|
|
|
|
var userBattleOrder = await GetUserBattleOrderAsync(userId);
|
|
var config = await _activityConfigService.Get();
|
|
var battleOrderConfig = config.BattleOrderConfig;
|
|
|
|
if (!IsActivityActive(battleOrderConfig))
|
|
return (false, "战令未开启或已结束", userBattleOrder.PurchasedAdvances);
|
|
|
|
if (!CanPurchaseAdvance(userBattleOrder.PurchasedAdvances, type))
|
|
{
|
|
return (false, "该进阶已购买或无法购买", userBattleOrder.PurchasedAdvances);
|
|
}
|
|
|
|
var advanceConfig = battleOrderConfig.AdvanceGift?.FirstOrDefault(c => c.Type == type);
|
|
if (advanceConfig == null)
|
|
return (false, "进阶配置不存在", userBattleOrder.PurchasedAdvances);
|
|
|
|
var user = await _userEntityMongo.FindByIdAsync(userId);
|
|
if (user == null)
|
|
return (false, "用户不存在", userBattleOrder.PurchasedAdvances);
|
|
|
|
int payType = advanceConfig.PayType;
|
|
int payCount = advanceConfig.PayCount;
|
|
|
|
if (payType == 1 && user.Assets.Gold < payCount)
|
|
return (false, "金币不足", userBattleOrder.PurchasedAdvances);
|
|
if (payType == 2 && user.Assets.Diamond < payCount)
|
|
return (false, "钻石不足", userBattleOrder.PurchasedAdvances);
|
|
if (payType == 3)
|
|
return (false, "暂不支持现金支付", userBattleOrder.PurchasedAdvances);
|
|
|
|
var assetChangeType = UserAssetChangeTypeEnum.减少;
|
|
_capPublisher.Publish(TopicKeys.用户资产变更, new UserAssetParam()
|
|
{
|
|
ChangeType = assetChangeType,
|
|
UserId = userId,
|
|
Gold = payType == 1 ? -payCount : 0,
|
|
Diamond = payType == 2 ? -payCount : 0,
|
|
Remark = $"购买战令进阶:{advanceConfig.Name}",
|
|
Source = RewardSource.战令购买
|
|
});
|
|
|
|
userBattleOrder.PurchasedAdvances.Add(type);
|
|
await _userBattleOrderMongo.ReplaceOneAsync(userBattleOrder);
|
|
|
|
return (true, $"购买成功", userBattleOrder.PurchasedAdvances);
|
|
}
|
|
|
|
public async Task<UserBattleOrder> CreateOrResetBattleOrderAsync(string userId)
|
|
{
|
|
var config = await _activityConfigService.Get();
|
|
var battleOrderConfig = config.BattleOrderConfig;
|
|
|
|
var existing = await _userBattleOrderMongo.FindOneAsync(c => c.UserId == userId);
|
|
if (existing != null)
|
|
{
|
|
existing.Level = 1;
|
|
existing.Exp = 0;
|
|
existing.PurchasedAdvances = new List<int>();
|
|
existing.NormalReceivedLevels = new List<int>();
|
|
existing.LuxuryReceivedLevels = new List<int>();
|
|
existing.SupremeReceivedLevels = new List<int>();
|
|
existing.StartTime = DateTime.Now.ToTimeStamp();
|
|
existing.EndTime = battleOrderConfig?.EndTime ?? DateTime.Now.AddDays(30).ToTimeStamp();
|
|
await _userBattleOrderMongo.ReplaceOneAsync(existing);
|
|
return existing;
|
|
}
|
|
|
|
var userBattleOrder = new UserBattleOrder
|
|
{
|
|
UserId = userId,
|
|
Level = 1,
|
|
Exp = 0,
|
|
PurchasedAdvances = new List<int>(),
|
|
NormalReceivedLevels = new List<int>(),
|
|
LuxuryReceivedLevels = new List<int>(),
|
|
SupremeReceivedLevels = new List<int>(),
|
|
StartTime = DateTime.Now.ToTimeStamp(),
|
|
EndTime = battleOrderConfig?.EndTime ?? DateTime.Now.AddDays(30).ToTimeStamp()
|
|
};
|
|
|
|
await _userBattleOrderMongo.InsertOneAsync(userBattleOrder);
|
|
return userBattleOrder;
|
|
}
|
|
|
|
public async Task<BattleOrderLevelStatusResponse> GetLevelRewardStatusAsync(string userId)
|
|
{
|
|
var config = await _activityConfigService.Get();
|
|
var battleOrderConfig = config.BattleOrderConfig;
|
|
var userBattleOrder = await GetUserBattleOrderAsync(userId);
|
|
int maxLevel = battleOrderConfig.LevelConfig?.Count ?? 0;
|
|
bool isLuxury = userBattleOrder.PurchasedAdvances.Contains(1) || userBattleOrder.PurchasedAdvances.Contains(3);
|
|
bool isSupreme = userBattleOrder.PurchasedAdvances.Contains(2) || userBattleOrder.PurchasedAdvances.Contains(3);
|
|
|
|
var list = new List<BattleOrderLevelStatus>();
|
|
for (int i = 1; i <= maxLevel; i++)
|
|
{
|
|
var lc = battleOrderConfig.LevelConfig[i - 1];
|
|
var status = new BattleOrderLevelStatus
|
|
{
|
|
Level = i,
|
|
Exp = lc.Exp,
|
|
NormalGiftList = lc.NormalGiftList ?? new List<GiftConfig>(),
|
|
LuxuryGiftList = isLuxury ? (lc.LuxuryGiftList ?? new List<GiftConfig>()) : new List<GiftConfig>(),
|
|
SupremeGiftList = isSupreme ? (lc.SupremeGiftList ?? new List<GiftConfig>()) : new List<GiftConfig>()
|
|
};
|
|
|
|
status.NormalStatus = GetSingleStatus(i, userBattleOrder.Level, userBattleOrder.NormalReceivedLevels);
|
|
status.LuxuryStatus = isLuxury
|
|
? GetSingleStatus(i, userBattleOrder.Level, userBattleOrder.LuxuryReceivedLevels)
|
|
: 0;
|
|
status.SupremeStatus = isSupreme
|
|
? GetSingleStatus(i, userBattleOrder.Level, userBattleOrder.SupremeReceivedLevels)
|
|
: 0;
|
|
|
|
list.Add(status);
|
|
}
|
|
|
|
return new BattleOrderLevelStatusResponse
|
|
{
|
|
CurrentLevel = userBattleOrder.Level,
|
|
CurrentExp = userBattleOrder.Exp,
|
|
IsLuxury = isLuxury,
|
|
IsSupreme = isSupreme,
|
|
LevelStatusList = list
|
|
};
|
|
}
|
|
|
|
private static int GetSingleStatus(int level, int userLevel, List<int> receivedLevels)
|
|
{
|
|
if (receivedLevels.Contains(level))
|
|
return 3;
|
|
if (userLevel >= level)
|
|
return 2;
|
|
return 1;
|
|
}
|
|
|
|
private static bool IsActivityActive(BattleOrderConfig config)
|
|
{
|
|
if (!config.IsOpen) return false;
|
|
return config.EndTime <= 0 || config.EndTime > DateTimeOffset.UtcNow.ToUnixTimeSeconds();
|
|
}
|
|
|
|
private bool CanPurchaseAdvance(List<int> purchasedAdvances, int newType)
|
|
{
|
|
if (purchasedAdvances.Contains(3))
|
|
return false;
|
|
|
|
if (purchasedAdvances.Contains(newType))
|
|
return false;
|
|
|
|
if (newType == 3 && purchasedAdvances.Contains(1))
|
|
return false;
|
|
|
|
if (newType == 3 && purchasedAdvances.Contains(2))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|