public async Task <IEnumerable <long> > GetInviter(string platform)
{
var allInviter = await RedisOpt.GetZsetAllKeyAsync(KeyGenTool.GenKey
(platform, "Invited"));
return(allInviter.Select(x => long.Parse(x)));
}
public async Task <WrappedResponse <MoneyInfo> > Handle(GetMoneyCommand request, CancellationToken cancellationToken)
{
var moneyInfo = await _moneyRedisRep.GetMoneyInfo(request.Id);
if (moneyInfo == null)
{
using (var locker = _moneyRedisRep.Locker(KeyGenTool.GenUserKey(request.Id,
MoneyInfo.ClassName)))
{
await locker.LockAsync();
moneyInfo = await _moneyRep.FindAndAdd(request.Id,
new MoneyInfo(request.Id, 0, 0, 0, 0, 0));
_ = _moneyRedisRep.SetMoneyInfo(moneyInfo);
}
if (moneyInfo == null)
{
return(new WrappedResponse <MoneyInfo>(ResponseStatus.GetMoneyError, null, null));
}
}
WrappedResponse <MoneyInfo> response = new WrappedResponse <MoneyInfo>
(ResponseStatus.Success, null, moneyInfo);
Log.Debug($"GetMoneyCommand:{moneyInfo.CurCoins},{moneyInfo.Carry}");
return(response);
}
public async Task <OneGameActivityInfo> GetGameActivity(DateTime time, long id, string activityId)
{
var dic = await RedisOpt.GetHashAllAsync <string, GameSubActInfo>
(KeyGenTool.GenUserDayKey(time, id, "GameActivity", activityId));
return(new OneGameActivityInfo(activityId, dic.ToDictionary(x => x.Key, y => y.Value)));
}
public async Task <WrappedResponse <RewardInfoVm> > Handle(GetLoginRewardCommand request, CancellationToken cancellationToken)
{
DateTime tnow = DateTime.Now;
int dayOfWeek = (int)tnow.DayOfWeek;
using var locker = _redis.Locker(KeyGenTool.GenUserWeekKey(tnow, request.Id, nameof(LoginRewardInfo)));
var rewardInfo = await _redis.GetLoginReward(tnow, request.Id);
long rewardCoins = 0;
if (rewardInfo == null || !rewardInfo.GettedDays.Contains(dayOfWeek))
{
rewardCoins = RewardManager.LoginRewardConf.DayRewards[dayOfWeek];
if (rewardInfo == null)
{
rewardInfo = new LoginRewardInfo(request.Id, new List <int>());
}
rewardInfo.GettedDays.Add(dayOfWeek);
await _redis.SetUserLoginReward(tnow, rewardInfo);
_ = _mqBus.Publish(new AddMoneyMqCmd(request.Id, rewardCoins, 0, AddReason.LoginReward));
}
else
{
return(new WrappedResponse <RewardInfoVm>(ResponseStatus.RewardGetted));
}
return(new WrappedResponse <RewardInfoVm>(ResponseStatus.Success, null, new RewardInfoVm(rewardCoins)));
}
public static async Task <WrappedResponse <NullBody> > OnUserApplySit(long id, string gameKey, Int64 blind, string roomId)
{
using var locker = _redis.Locker(KeyGenTool.GenUserKey(id, nameof(UserRoomInfo)));
await locker.LockAsync();
var userRoomInfo = await _redis.GetUserRoomInfo(id);
if (userRoomInfo != null)
{
return(new WrappedResponse <NullBody>(ResponseStatus.Error, new List <string>()
{
"user already in room "
}));
}
if (!RoomManager.JoinOneRoom(gameKey, roomId))
{
return(new WrappedResponse <NullBody>(ResponseStatus.Error, new List <string>()
{
"room is full "
}));
}
_ = _redis.SetUserRoomInfo(new UserRoomInfo(id, roomId, gameKey, blind, MatchingStatus.Success));
return(new WrappedResponse <NullBody>(ResponseStatus.Success, null));
}
public async Task <GameSubActInfo> GetGameActProgress(DateTime time, long id, string activityId, string subId)
{
GameSubActInfo subAct = await RedisOpt.GetHashValueAsync <GameSubActInfo>
(KeyGenTool.GenUserDayKey(time, id, "GameActivity", activityId), subId);
return(subAct);
}
public static async Task <WrappedResponse <RoomMatchResponseVm> > MatchRoom(long id, long blind, string curRoomId)
{
//获取这个玩家的redis锁
using var locker = _redis.Locker(KeyGenTool.GenUserKey(id, nameof(UserRoomInfo)));
if (!await locker.TryLockAsync())
{
return(new WrappedResponse <RoomMatchResponseVm>(ResponseStatus.IsMatching, null, null));
}
//查询redis是否有这个玩家
RoomInfo roomInfo = null;
var userRoomInfo = await _redis.GetUserRoomInfo(id);
if (userRoomInfo != null)
{
roomInfo = new RoomInfo(userRoomInfo.RoomId, 0, userRoomInfo.GameKey, userRoomInfo.Blind);
}
else
{
roomInfo = await RoomManager.GetRoom(blind);
}
try
{
WrappedResponse <JoinGameRoomMqResponse> roomResponse =
await RoomManager.SendToGameRoom <JoinGameRoomMqCmd, WrappedResponse <JoinGameRoomMqResponse> >
(roomInfo.GameKey, new JoinGameRoomMqCmd(id, roomInfo.RoomId, roomInfo.GameKey));
if (roomResponse.ResponseStatus == ResponseStatus.Success)
{
_ = _redis.SetUserRoomInfo(new UserRoomInfo(id, roomInfo.RoomId, roomInfo.GameKey, blind, MatchingStatus.Success));
return(new WrappedResponse <RoomMatchResponseVm>(ResponseStatus.Success, null,
new RoomMatchResponseVm(roomInfo.RoomId, roomInfo.Blind, roomInfo.GameKey)));
}
else
{
if (roomResponse.Body != null)
{
RoomInfo newRoomInfo = new RoomInfo(roomResponse.Body.RoomId, roomResponse.Body.UserCount,
roomResponse.Body.GameKey, roomResponse.Body.Blind);
RoomManager.UpdateRoom(newRoomInfo);
}
_ = _redis.DeleteUserRoomInfo(id);
return(new WrappedResponse <RoomMatchResponseVm>(roomResponse.ResponseStatus, roomResponse.ErrorInfos, null));
}
}
catch
{
_ = _redis.DeleteUserRoomInfo(id);
Log.Error($"user {id} join room {roomInfo.RoomId} error");
return(new WrappedResponse <RoomMatchResponseVm>(ResponseStatus.BusError, null, null));
}
}
public static async Task OnSiteFailed(long id, string gameKey, string roomId, string group)
{
if (group != matchingGroup)
{
return;
}
using var locker = _redis.Locker(KeyGenTool.GenUserKey(id, nameof(UserRoomInfo)));
await locker.LockAsync();
_ = _redis.DeleteUserRoomInfo(id);
RoomManager.JoinOneRoomFailed(gameKey, roomId);
}
public async Task Handle(FinishRegisterRewardEvent notification, CancellationToken cancellationToken)
{
using var loker = _redisRep.Locker(KeyGenTool.GenUserKey(notification.Id, nameof(AccountInfo)));
loker.Lock();
AccountInfo info = await _redisRep.GetAccountInfo(notification.Id);
if (info == null)
{
info = await _accountRep.GetByIdAsync(notification.Id);
}
info.FinishRegister();
await Task.WhenAll(_accountRep.UpdateAsync(info), _redisRep.SetAccountInfo(info));
}
public async Task <WrappedResponse <MoneyInfo> > Handle(AddMoneyCommand request, CancellationToken cancellationToken)
{
using var locker = _moneyRedisRep.Locker(KeyGenTool.GenUserKey(request.Id, MoneyInfo.ClassName));
await locker.LockAsync();
Log.Debug($"AddMoneyCommand add begin:{request.AddCoins},{request.AddCarry} {request.AggregateId}");
var moneyInfo = await _moneyRedisRep.GetMoneyInfo(request.Id);
if (moneyInfo == null)
{
moneyInfo = await _moneyRep.FindAndAdd(request.Id,
new MoneyInfo(request.Id, 0, 0, 0, 0, 0));
}
if (request.AddCoins < 0 &&
System.Math.Abs(request.AddCoins) >
moneyInfo.CurCoins)
{
Log.Debug($"AddMoneyCommand add end:{request.AddCoins},{request.AddCarry} {request.AggregateId}--1");
return(new WrappedResponse <MoneyInfo>
(ResponseStatus.NoEnoughMoney, null, null));
}
if (request.AddCarry < 0 &&
System.Math.Abs(request.AddCarry) > moneyInfo.Carry)
{
Log.Debug($"AddMoneyCommand add end:{request.AddCoins},{request.AddCarry} {request.AggregateId}--2");
return(new WrappedResponse <MoneyInfo>
(ResponseStatus.NoEnoughMoney, null, null));
}
moneyInfo.AddCoins(request.AddCoins);
moneyInfo.AddCarry(request.AddCarry);
moneyInfo.UpdateMaxCoins();
long coinsChangedCount = request.AddCoins + request.AddCarry;
var moneyevent = new MoneyChangedMqEvent
(moneyInfo.Id, moneyInfo.CurCoins,
moneyInfo.CurDiamonds, moneyInfo.MaxCoins,
moneyInfo.MaxDiamonds, coinsChangedCount, 0, request.Reason);
_ = _busCtl.Publish(moneyevent);
// _busCtl.PublishServerReqExt(moneyInfo.Id, moneyevent);
await Task.WhenAll(_moneyRedisRep.SetMoneyInfo(moneyInfo),
_moneyRep.ReplaceAsync(moneyInfo));
Log.Debug($"AddMoneyCommand add end:{request.AddCoins},{request.AddCarry} {request.AggregateId} curCoins:{moneyInfo.CurCoins} curCarry:{moneyInfo.Carry}--3");
return(new WrappedResponse <MoneyInfo>(ResponseStatus.Success, null,
new MoneyInfo(request.Id, moneyInfo.CurCoins, moneyInfo.CurDiamonds,
moneyInfo.MaxCoins, moneyInfo.MaxDiamonds, moneyInfo.Carry)));
}
public Task RemovInviteFriend(IEnumerable <long> allInviter, string platform)
{
List <Task> allTasks = new List <Task>
{
RedisOpt.DeleteKeyAsync(KeyGenTool.GenKey
(platform, "Invited"))
};
foreach (var oneInviter in allInviter)
{
allTasks.Add(RedisOpt.DeleteZsetValueAsync(KeyGenTool.GenUserKey
(oneInviter, "Inviter"), platform));
}
return(Task.WhenAll(allTasks));
}
/*public static Task OnJoinGame(long id, string gameKey, string roomId, long blind, int userCount, string group)
* {
* if (group != matchingGroup)
* {
* return;
* }
*
* using (var locker = _redis.Locker(KeyGenHelper.GenUserKey(id, UserRoomInfo.className)))
* {
* await locker.LockAsync();
* _ = _redis.SetUserRoomInfo(new UserRoomInfo(id, roomId, gameKey, blind, MatchingStatus.Success));
*
* }
*
* _roomManager.OnUserCountChange(gameKey, roomId, blind, userCount);
* return Task.CompletedTask;
* }*/
public static async Task OnLeaveGame(long id, string gameKey, string roomId, long blind, int userCount, string group)
{
if (group != matchingGroup)
{
return;
}
using (var locker = _redis.Locker(KeyGenTool.GenUserKey(id, nameof(UserRoomInfo))))
{
await locker.LockAsync();
_ = _redis.DeleteUserRoomInfo(id);
}
RoomManager.OnUserCountChange(gameKey, roomId, -1);
}
public async Task <WrappedResponse <MoneyInfo> > Handle(BuyInCommand request, CancellationToken cancellationToken)
{
using var locker = _moneyRedisRep.Locker(KeyGenTool.GenUserKey(request.Id, MoneyInfo.ClassName));
await locker.LockAsync();
Log.Debug($"AddMoneyCommand add begin:{request.MinBuy},{request.MaxBuy}, {request.AggregateId}");
var moneyInfo = await _moneyRedisRep.GetMoneyInfo(request.Id);
if (moneyInfo == null)
{
moneyInfo = await _moneyRep.FindAndAdd(request.Id,
new MoneyInfo(request.Id, 0, 0, 0, 0, 0));
}
if (moneyInfo.CurCoins + moneyInfo.Carry < request.MinBuy)
{
return(new WrappedResponse <MoneyInfo>
(ResponseStatus.NoEnoughMoney, null, null));
}
long realBuy;
if (moneyInfo.CurCoins + moneyInfo.Carry >= request.MaxBuy)
{
realBuy = request.MaxBuy;
}
else
{
realBuy = moneyInfo.CurCoins + moneyInfo.Carry;
}
long left = moneyInfo.Carry - realBuy;
if (left < 0)
{
moneyInfo.AddCoins(left);
moneyInfo.AddCarry(realBuy);
}
var moneyevent = new MoneyChangedMqEvent
(moneyInfo.Id, moneyInfo.CurCoins,
moneyInfo.CurDiamonds, moneyInfo.MaxCoins,
moneyInfo.MaxDiamonds, 0, 0, request.Reason);
_ = _busCtl.Publish(moneyevent);
await Task.WhenAll(_moneyRedisRep.SetMoneyInfo(moneyInfo), _moneyRep.ReplaceAsync(moneyInfo));
return(new WrappedResponse <MoneyInfo>(ResponseStatus.Success, null,
new MoneyInfo(request.Id, moneyInfo.CurCoins, moneyInfo.CurDiamonds,
moneyInfo.MaxCoins, moneyInfo.MaxDiamonds, moneyInfo.Carry)));
}
public async Task SetInviteFriend(long id, string platform)
{
string keyInvited = KeyGenTool.GenKey(platform, "Invited");
string keyInviter = KeyGenTool.GenUserKey(id, "Inviter");
var t1 = RedisOpt.AddZsetValueAsync(keyInvited, id.ToString(),
DateTime.Now.ToTimeStamp());
var t2 = RedisOpt.AddZsetValueAsync(keyInviter, platform,
DateTime.Now.ToTimeStamp());
await Task.WhenAll(t1, t2);
var t3 = RedisOpt.ExpiryAsync(keyInvited, TimeSpan.FromDays(30));
var t4 = RedisOpt.ExpiryAsync(keyInviter, TimeSpan.FromDays(30));
var t5 = RedisOpt.DeleteZsetValueRangeAsync(keyInvited, 0, DateTime.Now.ToTimeStamp() - TimeSpan.FromDays(30).TotalSeconds);
var t6 = RedisOpt.DeleteZsetValueRangeAsync(keyInviter, 0, DateTime.Now.ToTimeStamp() - TimeSpan.FromDays(30).TotalSeconds);
await Task.WhenAll(t3, t4, t5, t6);
}
public async Task <WrappedResponse <GameInfo> > Handle(GetGameInfoCommand request, CancellationToken cancellationToken)
{
GameInfo gameinfo = await _redisRepository.GetGameInfo(request.Id);
if (gameinfo == null)
{
using var loker = _redisRepository.Locker(KeyGenTool.GenUserKey(request.Id, GameInfo.ClassName));
loker.Lock();
gameinfo = await _gameRepository.FindAndAdd(request.Id, new GameInfo(request.Id, 0, 0, 0));
_ = _redisRepository.SetGameInfo(gameinfo);
}
WrappedResponse <GameInfo> response = new WrappedResponse <GameInfo>(ResponseStatus.Success,
null, gameinfo);
return(response);
}
public async Task <WrappedResponse <RewardInfoVm> > Handle(GetBankruptcyRewardCommand request, CancellationToken cancellationToken)
{
var getMoneyResponse = await _getMoneyClient.
GetResponseExt <GetMoneyMqCmd, WrappedResponse <MoneyMqResponse> >
(new GetMoneyMqCmd(request.Id));
var moneyInfo = getMoneyResponse.Message;
if (moneyInfo.ResponseStatus != ResponseStatus.Success)
{
return(new WrappedResponse <RewardInfoVm>(ResponseStatus.RewardNotAvailable));
}
if (moneyInfo.Body.CurCoins > RewardManager.BankruptcyConf.BankruptcyLimit)
{
return(new WrappedResponse <RewardInfoVm>(ResponseStatus.RewardNotAvailable));
}
DateTime tnow = DateTime.Now;
using var locker = _rewardRedis.Locker(KeyGenTool.GenUserDayKey(tnow, request.Id, nameof(BankruptcyInfo)));
await locker.LockAsync();
var bankruptcyInfo = await _rewardRedis.GetBankruptcyInfo(tnow, request.Id);
int totalTimes = RewardManager.BankruptcyConf.BankruptcyRewards.Count;
if (bankruptcyInfo == null)
{
bankruptcyInfo = new BankruptcyInfo(0);
}
if (bankruptcyInfo.CurTimes >= 2)
{
return(new WrappedResponse <RewardInfoVm>(ResponseStatus.RewardNotAvailable));
}
long rewardCoins = RewardManager.BankruptcyConf.BankruptcyRewards[bankruptcyInfo.CurTimes];
++bankruptcyInfo.CurTimes;
await _rewardRedis.SetBankruptcyInfo(tnow, bankruptcyInfo);
_ = _mqBus.Publish(new AddMoneyMqCmd(request.Id, rewardCoins, 0, AddReason.Bankruptcy));
return(new WrappedResponse <RewardInfoVm>(ResponseStatus.Success, null, new RewardInfoVm(rewardCoins)));
}
public async Task <WrappedResponse <LevelInfo> > Handle(GetLevelInfoCommand request, CancellationToken cancellationToken)
{
LevelInfo levelinfo = await _redisRepository.GetLevelInfo(request.Id);
if (levelinfo == null)
{
//从数据库中获取
using var loker = _redisRepository.Locker(KeyGenTool.GenUserKey(request.Id, LevelInfo.ClassName));
loker.Lock();
levelinfo = await _levelRepository.FindAndAdd(request.Id,
new LevelInfo(request.Id, 1, 0, LevelManager.GetNeedExp(1)));
_ = _redisRepository.SetLevelInfo(levelinfo);
}
WrappedResponse <LevelInfo> response = new WrappedResponse <LevelInfo>(ResponseStatus.Success,
null, levelinfo);
return(response);
}
public void DealOneRoom(DateTime time, List <long> players, string actId, string subId)
{
ParallelLoopResult result = Parallel.ForEach(players, async player =>
{
using var locker = _redis.Locker(KeyGenTool.GenUserDayKey(time, player, "GameActivity", actId));
await locker.LockAsync();
var oneSub = await _redis.GetGameActProgress(time, player, actId, subId);
if (oneSub == null)
{
oneSub = new GameSubActInfo(0, 0);
}
if (oneSub.State == 1)
{
return;
}
++oneSub.CurCount;
await _redis.SetGameActProgress(time, player, actId, subId, oneSub);
});
}
public async Task <WrappedResponse <RewardInfoVm> > Handle(GetGameActRewardCommand request,
CancellationToken cancellationToken)
{
DateTime tnow = DateTime.Now;
var roomConfig = RewardManager.GameActConf.AllGameConfigs
.Find(x => x.ActivityId == request.ActId).RoomConfigs
.Find(x => x.SubId == request.SubId);
using var locker = _redis.Locker(KeyGenTool.GenUserDayKey(tnow, request.Id, "GameActivity", request.ActId));
await locker.LockAsync();
var subAct = await _redis.GetGameActProgress(tnow, request.Id, request.ActId, request.SubId);
if (subAct == null)
{
return(new WrappedResponse <RewardInfoVm>(ResponseStatus.Error));
}
long rewardCoins = 0;
if (subAct.State == 1)
{
return(new WrappedResponse <RewardInfoVm>(ResponseStatus.Error));
}
if (subAct.CurCount >= roomConfig.NeedCount)
{
rewardCoins = roomConfig.RewardCoins;
_ = _mqBus.Publish(new AddMoneyMqCmd(request.Id, rewardCoins, 0, AddReason.GameAct));
subAct.State = 1;
await _redis.SetGameActProgress(tnow, request.Id, request.ActId, request.SubId, subAct);
return(new WrappedResponse <RewardInfoVm>(ResponseStatus.Success,
null, new RewardInfoVm(rewardCoins)));
}
else
{
return(new WrappedResponse <RewardInfoVm>(ResponseStatus.Error));
}
}
public Task SetGameInfo(GameInfo info)
{
RedisOpt.SetStringNoWait(KeyGenTool
.GenUserKey(info.Id, GameInfo.ClassName), info, TimeSpan.FromDays(7));
return(Task.CompletedTask);
}
public Task <GameInfo> GetGameInfo(long id)
{
return(RedisOpt.GetStringAsync <GameInfo>(KeyGenTool.GenUserKey(id, GameInfo.ClassName)));
}
public Task SetLoginCheckInfo(string account, AccountInfo info)
{
return(RedisOpt.SetStringAsync(KeyGenTool.GenKey(account, nameof(LoginCheckInfo)),
new LoginCheckInfo(info.Id, info.PlatformAccount, info.Type),
TimeSpan.FromDays(7)));
}
public Task SetAccountInfo(AccountInfo info)
{
return(RedisOpt.SetStringAsync(KeyGenTool.GenUserKey(info.Id,
nameof(AccountInfo)), info, TimeSpan.FromDays(7)));
}
public Task <LoginCheckInfo> GetLoginCheckInfo(string platformAccount)
{
return(RedisOpt.GetStringAsync <LoginCheckInfo>(KeyGenTool.GenKey(platformAccount,
nameof(LoginCheckInfo))));
}
public Task <AccountInfo> GetAccountInfo(long id)
{
return(RedisOpt.GetStringAsync <AccountInfo>(KeyGenTool.GenUserKey(id,
nameof(AccountInfo))));
}
public Task DeleteUserRoomInfo(long id)
{
return(RedisOpt.DeleteKeyAsync(KeyGenTool.GenUserKey(id, nameof(UserRoomInfo))));
}
public Task SetUserRoomInfo(UserRoomInfo info)
{
return(RedisOpt.SetStringAsync <UserRoomInfo>(KeyGenTool.GenUserKey(info.Id, nameof(UserRoomInfo)),
info, TimeSpan.FromHours(1)));
}
public Task <UserRoomInfo> GetUserRoomInfo(long id)
{
return(RedisOpt.GetStringAsync <UserRoomInfo>(KeyGenTool.GenUserKey(id, nameof(UserRoomInfo))));
}
public Task SetServiceTemplateInfo(ServiceTemplateInfo info)
{
return(RedisOpt.SetStringAsync(KeyGenTool.GenUserKey(info.Id,
nameof(ServiceTemplateInfo)), info, TimeSpan.FromDays(7)));
}
public Task <ServiceTemplateInfo> GetServiceTemplateInfo(long id)
{
return(RedisOpt.GetStringAsync <ServiceTemplateInfo>(KeyGenTool.GenUserKey(id,
nameof(ServiceTemplateInfo))));
}
