885 lines
29 KiB
C#
885 lines
29 KiB
C#
namespace Application.Domain;
|
|
|
|
public class UnitUserAttrService(ISqlSugarClient DbClient, IRedisCache redis) : IUnitUserAttrService, ITransient
|
|
{
|
|
#region 个人属性
|
|
|
|
public async Task<UserAttrModel> GetUserAttrModel(string userId, string scene = "Default")
|
|
{
|
|
UserAttrModel result = new UserAttrModel();
|
|
result.id = userId;
|
|
var userService = App.GetService<IUnitUserService>();
|
|
var userInfo = await userService.GetUserInfoByUserId(userId);
|
|
result.viceId = userInfo.userNo;
|
|
result.name = userInfo.nick;
|
|
result.area = (int)userInfo.areaId;
|
|
result.IsSystem = (int)userInfo.isSystem;
|
|
result.sex = userInfo.sex;
|
|
result.code = nameof(UserEnum.AttrCode.Person);
|
|
var unitAttr = await GetUserAttr(userId);
|
|
result.lev = (int)unitAttr.lev;
|
|
result.minAtk = (int)unitAttr.minAtk;
|
|
result.maxAtk = (int)unitAttr.maxAtk;
|
|
result.defense = (int)unitAttr.defense;
|
|
result.agility = (int)unitAttr.agility;
|
|
result.upBlood = (int)unitAttr.upBlood;
|
|
result.upMorale = (int)unitAttr.upMorale;
|
|
|
|
List<AttrItem> ExtendAttrData = new List<AttrItem>();
|
|
|
|
#region 构造基础加层体系
|
|
|
|
UserAttrModel temp = new UserAttrModel();
|
|
temp.minAtk = (int)unitAttr.minAtk;
|
|
temp.maxAtk = (int)unitAttr.maxAtk;
|
|
temp.defense = (int)unitAttr.defense;
|
|
temp.agility = (int)unitAttr.agility;
|
|
temp.upBlood = (int)unitAttr.upBlood;
|
|
temp.upMorale = (int)unitAttr.upMorale;
|
|
|
|
var equService = App.GetService<IGameEquService>();
|
|
var equTemp = await equService.GetUserEquAttrModel(userId);
|
|
temp = GameAttrTool.GetRoleAttrTempMerge(temp, equTemp);
|
|
//套装加层
|
|
var suitAttr = await equService.GetUserEquSuitAttrInfo(userId);
|
|
ExtendAttrData.AddRange(suitAttr);
|
|
|
|
#endregion
|
|
|
|
|
|
#region 参数
|
|
|
|
int minAtk = 0;
|
|
int maxAtk = 0;
|
|
int Agility = 0;
|
|
int Defense = 0;
|
|
int upBlood = 0;
|
|
int upMorale = 0;
|
|
|
|
#endregion 参数
|
|
|
|
#region 队伍加层
|
|
|
|
var teamService = App.GetService<IGameTeamService>();
|
|
var MyTeam = await teamService.GetUserTeamInfo(userId);
|
|
if (MyTeam.state == 1)
|
|
{
|
|
int teamCount = MyTeam.user.Count(it => it.isOnline == 1);
|
|
if (teamCount > 0)
|
|
{
|
|
decimal teamAdd = 0.05m * teamCount;
|
|
teamAdd = teamAdd > 0.2m ? 0.2m : teamAdd;
|
|
minAtk += Convert.ToInt32(temp.minAtk * teamAdd);
|
|
maxAtk += Convert.ToInt32(temp.maxAtk * teamAdd);
|
|
Defense += Convert.ToInt32(temp.defense * teamAdd);
|
|
result.atkTips += $"(队+{Convert.ToInt32(teamAdd * 100)}%)";
|
|
result.defTips += $"(队+{Convert.ToInt32(teamAdd * 100)}%)";
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region Buff加层
|
|
|
|
var MyState = await GetUserStateData(userId, scene);
|
|
if (MyState.Count > 0)
|
|
{
|
|
foreach (var item in MyState)
|
|
{
|
|
minAtk += Convert.ToInt32(GameAttrTool.GetAttrItemValue(GameEnum.AttrCode.Atk.ToString(), item.attr,
|
|
temp.minAtk));
|
|
maxAtk += Convert.ToInt32(GameAttrTool.GetAttrItemValue(GameEnum.AttrCode.Atk.ToString(), item.attr,
|
|
temp.maxAtk));
|
|
Defense += Convert.ToInt32(GameAttrTool.GetAttrItemValue(GameEnum.AttrCode.Defense.ToString(),
|
|
item.attr, temp.defense));
|
|
Agility += Convert.ToInt32(GameAttrTool.GetAttrItemValue(GameEnum.AttrCode.Agility.ToString(),
|
|
item.attr, temp.agility));
|
|
upBlood += Convert.ToInt32(GameAttrTool.GetAttrItemValue(GameEnum.AttrCode.Blood.ToString(), item.attr,
|
|
temp.upBlood));
|
|
upMorale += Convert.ToInt32(GameAttrTool.GetAttrItemValue(GameEnum.AttrCode.Morale.ToString(),
|
|
item.attr, temp.upMorale));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 加层处理
|
|
|
|
var otTemp = GameAttrTool.GetRoleAttrTemp(temp, ExtendAttrData);
|
|
result = GameAttrTool.GetRoleAttrTempMerge(result, otTemp); //加层其他
|
|
result = GameAttrTool.GetRoleAttrTempMerge(result, temp); //加层其他
|
|
|
|
result.minAtk += minAtk;
|
|
result.maxAtk += maxAtk;
|
|
result.defense += Defense;
|
|
result.agility += Agility;
|
|
result.upBlood += upBlood;
|
|
result.upMorale += upMorale;
|
|
|
|
#endregion
|
|
|
|
#region 数据效验
|
|
|
|
var userBlood = await GetUserBlood(userId);
|
|
result.blood = (int)userBlood.blood;
|
|
|
|
//士气
|
|
var userMorale = await GetUserMorale(userId);
|
|
result.morale = (int)userMorale.morale;
|
|
|
|
//负面状态处理
|
|
var loadState = await GetUserLoadState(userId);
|
|
result = await GameAttrTool.CheckRoleLoadBuff(result, loadState);
|
|
result = await ReviseUserRoleAttr(result);
|
|
return result;
|
|
|
|
#endregion
|
|
|
|
|
|
return result;
|
|
}
|
|
|
|
private async Task<UserAttrModel> ReviseUserRoleAttr(UserAttrModel result)
|
|
{
|
|
//处理上限数据
|
|
if (result.blood > result.upBlood)
|
|
{
|
|
result.blood = result.upBlood;
|
|
await UpdateUserBlood(result.id, 2, result.blood, true);
|
|
}
|
|
|
|
if (result.morale > result.upMorale)
|
|
{
|
|
result.morale = result.upMorale;
|
|
await UpdateUserMorale(result.id, 2, Convert.ToInt32(result.morale));
|
|
}
|
|
|
|
if (result.NoHarm > 0.8M) //免伤上限
|
|
{
|
|
result.NoHarm = 0.8M;
|
|
}
|
|
|
|
if (result.Atk_Next > 0.3M) //连击上限
|
|
{
|
|
result.Atk_Next = 0.3M;
|
|
}
|
|
|
|
//评分
|
|
decimal _score = result.maxAtk + result.defense + result.agility + result.upBlood / 3.00M + result.upMorale;
|
|
result.score = Math.Round(_score, 2);
|
|
return result;
|
|
}
|
|
|
|
public async Task<unit_user_attr> GetUserAttr(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "UserAttr");
|
|
var data = await redis.GetHashAsync<unit_user_attr>(key, userId);
|
|
if (data == null)
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_attr>();
|
|
data = await db.Queryable<unit_user_attr>().Where(it => it.userId == userId).SingleAsync();
|
|
await redis.AddHashAsync(key, userId, data);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
public async Task<int> GetUserLev(string userId)
|
|
{
|
|
int lev = 0;
|
|
var attrInfo = await GetUserAttr(userId);
|
|
if (attrInfo != null)
|
|
{
|
|
lev = (int)attrInfo.lev;
|
|
}
|
|
|
|
return lev;
|
|
}
|
|
|
|
private async Task ClearUserAttrCache(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "UserAttr");
|
|
await redis.DelHashAsync(key, userId);
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region 体力操作
|
|
|
|
public async Task<unit_user_blood> GetUserBlood(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "Blood");
|
|
var data = await redis.GetHashAsync<unit_user_blood>(key, userId);
|
|
if (data == null)
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_blood>();
|
|
data = await db.Queryable<unit_user_blood>().Where(it => it.userId == userId).SingleAsync();
|
|
await redis.AddHashAsync(key, userId, data);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
public async Task<bool> UpdateUserBlood(string userId, int op, int count, bool mustUp = false)
|
|
{
|
|
bool result = false;
|
|
unit_user_blood data = new unit_user_blood();
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "Blood");
|
|
if (op == 2)
|
|
{
|
|
data.userId = userId;
|
|
data.blood = count;
|
|
}
|
|
else
|
|
{
|
|
data = await GetUserBlood(userId);
|
|
if (op == 0)
|
|
{
|
|
data.blood -= count;
|
|
}
|
|
else if (op == 1)
|
|
{
|
|
data.blood += count;
|
|
var myAttr = await GetUserAttrModel(userId);
|
|
if (myAttr != null)
|
|
{
|
|
data.blood = data.blood > myAttr.upBlood ? myAttr.upBlood : data.blood;
|
|
}
|
|
}
|
|
}
|
|
|
|
data.blood = data.blood < 0 ? 0 : data.blood;
|
|
result = await redis.AddHashAsync(key, userId, data);
|
|
|
|
if (mustUp)
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_blood>();
|
|
result = await db.Updateable<unit_user_blood>().SetColumns(it => it.blood == data.blood)
|
|
.Where(it => it.userId == userId).ExecuteCommandAsync() > 0;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region 经验操作
|
|
|
|
public async Task<unit_user_exp> GetUserExp(string userId)
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_exp>();
|
|
return await db.Queryable<unit_user_exp>().Where(it => it.userId == userId).SingleAsync();
|
|
}
|
|
|
|
|
|
public async Task<bool> UpdateUserExp(string userId, long exp, int op = 1)
|
|
{
|
|
bool result = false;
|
|
bool IsUpUserAttr = false;
|
|
try
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_exp>();
|
|
await DbClient.AsTenant().BeginTranAsync();
|
|
if (op == 0) //扣除经验
|
|
{
|
|
result = await db.Updateable<unit_user_exp>().SetColumns(it => it.exp == it.exp - exp)
|
|
.Where(it => it.userId == userId).ExecuteCommandAsync() > 0;
|
|
}
|
|
else //增加经验
|
|
{
|
|
var MyExp = await db.Queryable<unit_user_exp>().Where(it => it.userId == userId).SingleAsync();
|
|
long onExp = (long)MyExp.exp + exp;
|
|
if (onExp < MyExp.upExp) //不足升级
|
|
{
|
|
result = await db.Updateable<unit_user_exp>().SetColumns(it => it.exp == onExp)
|
|
.Where(it => it.userId == userId).ExecuteCommandAsync() > 0;
|
|
}
|
|
else //足够升级
|
|
{
|
|
var myAttr = await GetUserAttr(userId);
|
|
int OnLev = (int)myAttr.lev + 1;
|
|
if (OnLev <= GameConfig.GameMaxLev)
|
|
{
|
|
long upExp = onExp - (long)MyExp.upExp;
|
|
decimal nextExp = GameTool.GetUserUpExp(OnLev);
|
|
result = await db.Updateable<unit_user_exp>().SetColumns(it => it.exp == upExp)
|
|
.SetColumns(it => it.upExp == nextExp).Where(it => it.userId == userId)
|
|
.ExecuteCommandAsync() > 0;
|
|
if (result) //更新成功，更新各项属性
|
|
{
|
|
var data = GameTool.GetAttrData(OnLev);
|
|
result = await db.Updateable<unit_user_attr>(data).Where(i => i.userId == userId)
|
|
.ExecuteCommandAsync() > 0;
|
|
int upVigour = GameConfig.GameBaseVigour + (OnLev * 10);
|
|
await UpdateUserUpVigour(userId, upVigour);
|
|
|
|
IsUpUserAttr = result;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
decimal maxOnExp = (decimal)MyExp.upExp - 1;
|
|
if ((decimal)MyExp.exp < maxOnExp)
|
|
{
|
|
result = await db.Updateable<unit_user_exp>().SetColumns(it => it.exp == maxOnExp)
|
|
.Where(it => it.userId == userId).ExecuteCommandAsync() > 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
await DbClient.AsTenant().CommitTranAsync();
|
|
}
|
|
catch
|
|
{
|
|
result = false;
|
|
await DbClient.AsTenant().RollbackTranAsync();
|
|
}
|
|
|
|
if (result && IsUpUserAttr)
|
|
{
|
|
await ClearUserAttrCache(userId);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#endregion 经验操作
|
|
|
|
#region 士气
|
|
|
|
public async Task<unit_user_morale> GetUserMorale(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "Morale");
|
|
var data = await redis.GetHashAsync<unit_user_morale>(key, userId);
|
|
if (data == null)
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_morale>();
|
|
data = await db.Queryable<unit_user_morale>().Where(it => it.userId == userId).SingleAsync();
|
|
await redis.AddHashAsync(key, userId, data);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
public async Task<bool> UpdateUserMorale(string userId, int op, int count)
|
|
{
|
|
bool result = false;
|
|
var data = await GetUserMorale(userId);
|
|
if (op == 1)
|
|
{
|
|
data.morale += count;
|
|
var myAttr = await GetUserAttrModel(userId);
|
|
data.morale = data.morale > myAttr.upMorale ? myAttr.upMorale : data.morale;
|
|
}
|
|
else if (op == 2)
|
|
{
|
|
data.morale = count;
|
|
}
|
|
else
|
|
{
|
|
data.morale -= count;
|
|
}
|
|
|
|
data.morale = data.morale < 0 ? 0 : data.morale;
|
|
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "Morale");
|
|
await redis.AddHashAsync(key, userId, data);
|
|
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_morale>();
|
|
result = await db.Updateable<unit_user_morale>().SetColumns(it => it.morale == data.morale)
|
|
.Where(it => it.userId == userId).ExecuteCommandAsync() > 0;
|
|
return result;
|
|
}
|
|
|
|
public async Task<bool> CheackRecoverMorale(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "Recover:Morale", userId);
|
|
return await redis.ExistsAsync(key);
|
|
}
|
|
|
|
public async Task LockRecoverMorale(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "Recover:Morale", userId);
|
|
await redis.SetAsync(key, DateTime.Now, TimeAssist.GetDateTimeYMD(1));
|
|
}
|
|
|
|
#endregion 士气
|
|
|
|
#region 活力
|
|
|
|
public async Task<unit_user_vigour> GetUserVigourInfo(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "Vigour");
|
|
var data = await redis.GetHashAsync<unit_user_vigour>(key, userId);
|
|
if (data == null)
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_vigour>();
|
|
data = await db.Queryable<unit_user_vigour>().Where(i => i.userId == userId).SingleAsync();
|
|
if (data != null)
|
|
{
|
|
await redis.AddHashAsync(key, userId, data);
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
private async Task ClearUserVigourCache(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "Vigour");
|
|
await redis.DelHashAsync(key, userId);
|
|
}
|
|
|
|
public async Task<bool> UpdateUserVigour(string userId, int op, long count, string UpTime = "")
|
|
{
|
|
if (op == 1)
|
|
{
|
|
var userVigour = await GetUserVigourInfo(userId);
|
|
long endVigour = (long)userVigour.upVitality - (long)userVigour.vitality;
|
|
count = endVigour > count ? count : endVigour;
|
|
}
|
|
|
|
bool result = false;
|
|
try
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_vigour>();
|
|
await DbClient.AsTenant().BeginTranAsync();
|
|
result = await db.Updateable<unit_user_vigour>()
|
|
.SetColumnsIF(op == 0, it => it.vitality == it.vitality - count)
|
|
.SetColumnsIF(op == 1, it => it.vitality == it.vitality + count)
|
|
.SetColumnsIF(op == 2, it => it.vitality == count)
|
|
.SetColumnsIF(!string.IsNullOrEmpty(UpTime), it => it.upTime == UpTime)
|
|
.Where(it => it.userId == userId).ExecuteCommandAsync() > 0;
|
|
await DbClient.AsTenant().CommitTranAsync();
|
|
}
|
|
catch
|
|
{
|
|
result = false;
|
|
await DbClient.AsTenant().RollbackTranAsync();
|
|
}
|
|
|
|
if (result)
|
|
{
|
|
await ClearUserVigourCache(userId);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public async Task<bool> UpdateUserUpVigour(string userId, decimal count)
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_vigour>();
|
|
bool isok = await db.Updateable<unit_user_vigour>().SetColumns(i => i.upVitality == count)
|
|
.Where(i => i.userId == userId).ExecuteCommandAsync() > 0;
|
|
if (isok)
|
|
{
|
|
await ClearUserVigourCache(userId);
|
|
}
|
|
|
|
return isok;
|
|
}
|
|
|
|
#endregion 活力
|
|
|
|
#region 在线时间
|
|
|
|
public async Task<bool> UpdateOnLineTime(string userId, string code, int time)
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_online_time>();
|
|
bool result = await db.Updateable<unit_user_online_time>()
|
|
.SetColumns(it => it.dayTime == it.dayTime + time)
|
|
.SetColumns(it => it.monthTime == it.monthTime + time)
|
|
.SetColumns(it => it.totalTime == it.totalTime + time)
|
|
.Where(it => it.userId == userId).ExecuteCommandAsync() > 0;
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 药品栏
|
|
|
|
public async Task<unit_user_drug> GetUserDrug(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "UserTool", "DrugColumn");
|
|
if (await redis.HExistsHashAsync(key, userId))
|
|
{
|
|
return await redis.GetHashAsync<unit_user_drug>(key, userId);
|
|
}
|
|
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_drug>();
|
|
var data = await db.Queryable<unit_user_drug>().Where(it => it.userId == userId).SingleAsync();
|
|
if (data == null)
|
|
{
|
|
data = new unit_user_drug();
|
|
data.userId = userId;
|
|
data.drug = new List<UserDrugModel>();
|
|
await db.Insertable(data).ExecuteCommandAsync();
|
|
}
|
|
|
|
await redis.AddHashAsync(key, userId, data);
|
|
return data;
|
|
}
|
|
|
|
public async Task<bool> UpdateUserDrug(unit_user_drug data)
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_drug>();
|
|
bool result = await db.Updateable<unit_user_drug>(data).ExecuteCommandAsync() > 0;
|
|
if (result)
|
|
{
|
|
await ClearUserDrug(data.userId);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public async Task<bool> UpdateUserDrug(string userId, string drugId, int op, int count)
|
|
{
|
|
var data = await GetUserDrug(userId);
|
|
foreach (var item in data.drug)
|
|
{
|
|
if (item.id == drugId)
|
|
{
|
|
if (op == 0)
|
|
{
|
|
item.count = item.count - count;
|
|
}
|
|
else
|
|
{
|
|
item.count = item.count + count;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool result = await UpdateUserDrug(data);
|
|
return result;
|
|
}
|
|
|
|
private async Task ClearUserDrug(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "UserTool", "DrugColumn");
|
|
await redis.DelHashAsync(key, userId);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region BUFF状态
|
|
|
|
private async Task<List<unit_user_state>> GetUserStateData(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "State");
|
|
var data = await redis.GetHashAsync<List<unit_user_state>>(key, userId);
|
|
if (data == null)
|
|
{
|
|
long endTime = TimeExtend.GetTimeStampSeconds;
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_state>();
|
|
data = await db.Queryable<unit_user_state>().Where(it => it.userId == userId && it.endTime > endTime)
|
|
.ToListAsync();
|
|
await redis.AddHashAsync(key, userId, data);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
public async Task<List<unit_user_state>> GetUserStateData(string userId, string scene = "Default")
|
|
{
|
|
var data = await GetUserStateData(userId);
|
|
if (scene == "ALL")
|
|
{
|
|
return data;
|
|
}
|
|
|
|
data = data.FindAll(it => it.scene == "Default" || it.scene == scene);
|
|
return data;
|
|
}
|
|
|
|
public async Task<bool> AddUserState(string userId, string groupId, string name, string scene, string tips,
|
|
List<AttrItem> attr, int time, int count = 1)
|
|
{
|
|
bool result = false;
|
|
long onTime = TimeExtend.GetTimeStampSeconds;
|
|
string usId = $"{userId}_{groupId}";
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_state>();
|
|
var usData = await db.Queryable<unit_user_state>().Where(it => it.usId == usId).SingleAsync();
|
|
if (usData == null)
|
|
{
|
|
usData = new unit_user_state();
|
|
usData.usId = usId;
|
|
usData.userId = userId;
|
|
usData.goodsId = groupId;
|
|
usData.name = name;
|
|
usData.scene = scene;
|
|
usData.tips = tips;
|
|
usData.attr = attr;
|
|
usData.addTime = onTime;
|
|
usData.endTime = onTime + (time * 60 * count);
|
|
result = await db.Insertable(usData).ExecuteCommandAsync() > 0;
|
|
}
|
|
else
|
|
{
|
|
if (usData.endTime > onTime)
|
|
{
|
|
usData.endTime = usData.endTime + (time * 60 * count);
|
|
}
|
|
else
|
|
{
|
|
usData.addTime = onTime;
|
|
usData.endTime = onTime + (time * 60 * count);
|
|
}
|
|
|
|
result = await db.Updateable(usData).ExecuteCommandAsync() > 0;
|
|
}
|
|
|
|
if (result)
|
|
{
|
|
await ClearUserState(userId);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private async Task ClearUserState(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "State");
|
|
await redis.DelHashAsync(key, userId);
|
|
}
|
|
|
|
public async Task<decimal> GetUserStateDataTotal(string userId, string scene = "Default")
|
|
{
|
|
var data = await GetUserStateData(userId, scene);
|
|
List<AttrItem> result = new List<AttrItem>();
|
|
foreach (var item in data)
|
|
{
|
|
result.AddRange(item.attr);
|
|
}
|
|
return GameAttrTool.GetAttrItemValue(nameof(GameEnum.AttrCode.AddExp), result, 0);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 游戏资源储备
|
|
|
|
private async Task<List<unit_user_stock>> GetUserStock(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "Stock");
|
|
var data = await redis.GetHashAsync<List<unit_user_stock>>(key, userId);
|
|
if (data == null)
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_stock>();
|
|
data = await db.Queryable<unit_user_stock>().Where(it => it.userId == userId).ToListAsync();
|
|
await redis.AddHashAsync(key, userId, data);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
public async Task<List<unit_user_stock>> GetUserStock(string userId, string code = "Default")
|
|
{
|
|
var data = await GetUserStock(userId);
|
|
if (code != "Default")
|
|
{
|
|
data = data.FindAll(it => it.code == code);
|
|
}
|
|
|
|
long endTime = TimeExtend.GetTimeStampSeconds;
|
|
data = data.FindAll(it =>
|
|
((it.type == "Number" && it.sign > 0) || it.type != "Number") && it.endTime > endTime);
|
|
return data;
|
|
}
|
|
|
|
public async Task<bool> AddUserStock(string userId, string goodsId, string name, string type, string code,
|
|
long sign,
|
|
string par = "",
|
|
int minute = 0)
|
|
{
|
|
if (minute == 0)
|
|
{
|
|
minute = 525600;
|
|
}
|
|
|
|
bool result = false;
|
|
string usId = $"{userId}_{goodsId}";
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_stock>();
|
|
var usInfo = await db.Queryable<unit_user_stock>().Where(it => it.usId == usId).SingleAsync();
|
|
if (usInfo == null)
|
|
{
|
|
long endTime = TimeExtend.GetTimeStampSeconds + minute * 60;
|
|
unit_user_stock stock = new unit_user_stock()
|
|
{
|
|
usId = usId,
|
|
userId = userId,
|
|
goodsId = goodsId,
|
|
name = name,
|
|
type = type,
|
|
code = code,
|
|
sign = sign,
|
|
par = par,
|
|
endTime = endTime
|
|
};
|
|
result = await db.Insertable(stock).ExecuteCommandAsync() > 0;
|
|
}
|
|
else
|
|
{
|
|
if (usInfo.type == nameof(GameEnum.GameStockType.Number))
|
|
{
|
|
usInfo.sign += sign;
|
|
usInfo.endTime = TimeExtend.GetTimeStampSeconds + minute * 60;
|
|
}
|
|
else if (usInfo.type == nameof(GameEnum.GameStockType.Time))
|
|
{
|
|
long onTime = TimeExtend.GetTimeStampSeconds;
|
|
if (usInfo.endTime > onTime)
|
|
{
|
|
usInfo.endTime = usInfo.endTime + (minute * 60);
|
|
}
|
|
else
|
|
{
|
|
usInfo.endTime = TimeExtend.GetTimeStampSeconds + (minute * 60);
|
|
}
|
|
}
|
|
|
|
result = await db.Updateable(usInfo).ExecuteCommandAsync() > 0;
|
|
}
|
|
|
|
if (result)
|
|
{
|
|
await ClearUserStockCache(userId);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private async Task ClearUserStockCache(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "Stock");
|
|
await redis.DelHashAsync(key, userId);
|
|
}
|
|
|
|
public async Task<bool> UpdateUserStock(unit_user_stock data)
|
|
{
|
|
var db = DbClient.AsTenant().GetConnectionWithAttr<unit_user_stock>();
|
|
var result = await db.Updateable(data).ExecuteCommandAsync() > 0;
|
|
if (result)
|
|
{
|
|
await ClearUserAttrCache(data.userId);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 负面状态
|
|
|
|
public async Task<List<unit_user_load>> GetUserLoadState(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "LoadState");
|
|
if (await redis.HExistsHashAsync(key, userId))
|
|
{
|
|
return await redis.GetHashAsync<List<unit_user_load>>(key, userId);
|
|
}
|
|
|
|
return new List<unit_user_load>();
|
|
}
|
|
|
|
public async Task<bool> AddUserLoadState(string userId, string name, string code)
|
|
{
|
|
bool result = false;
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "LoadState");
|
|
var data = await GetUserLoadState(userId);
|
|
var onData = data.Find(it => it.code == code);
|
|
if (onData == null)
|
|
{
|
|
unit_user_load load = new unit_user_load()
|
|
{
|
|
id = $"{userId}_{code}",
|
|
userId = userId,
|
|
name = name,
|
|
code = code,
|
|
count = 1
|
|
};
|
|
data.Add(load);
|
|
result = await redis.AddHashAsync(key, userId, data);
|
|
}
|
|
else
|
|
{
|
|
data.Remove(onData);
|
|
onData.count += 1;
|
|
onData.count = onData.count > 10 ? 10 : onData.count;
|
|
result = await redis.AddHashAsync(key, userId, data);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
public async Task AddUserLoadState(string userId, List<string> codes)
|
|
{
|
|
foreach (var code in codes)
|
|
{
|
|
string name = string.Empty;
|
|
switch (code)
|
|
{
|
|
case "Slow":
|
|
name = "迟缓";
|
|
break;
|
|
|
|
case "Poison":
|
|
name = "中毒";
|
|
break;
|
|
|
|
case "Curse":
|
|
name = "诅咒";
|
|
break;
|
|
|
|
case "Weaken":
|
|
name = "弱化";
|
|
break;
|
|
|
|
case "Depressed":
|
|
name = "消沉";
|
|
break;
|
|
|
|
case "Breach":
|
|
name = "突破";
|
|
break;
|
|
|
|
case "PalsyAtk":
|
|
name = "麻痹";
|
|
break;
|
|
}
|
|
await AddUserLoadState(userId, name, code);
|
|
}
|
|
}
|
|
public async Task<bool> RandomRemoveUserLoadState(string userId, int count)
|
|
{
|
|
var data = await GetUserLoadState(userId);
|
|
int opCount = data.Count - count;
|
|
opCount = opCount < 0 ? 0 : opCount;
|
|
if (opCount > 0)
|
|
{
|
|
RandomAssist random = new RandomAssist(opCount);
|
|
var result = random.RandomExtract(data);
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "LoadState");
|
|
await redis.AddHashAsync(key, userId, result);
|
|
}
|
|
else
|
|
{
|
|
await RemoveUserLoadState(userId);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public async Task RemoveUserLoadState(string userId)
|
|
{
|
|
string key = string.Format(UserCache.BaseCacheKeys, "AttrData", "LoadState");
|
|
await redis.DelHashAsync(key, userId);
|
|
}
|
|
|
|
|
|
#endregion
|
|
} |