/// <summary>选择流派忍者众信息</summary>
private ASObject RoleSelectGenre(TGGSession session, tg_role role, int type)
{
if (type >= (int)RoleGenreType.SCHOOL_2 && type <= (int)RoleGenreType.SCHOOL_12)
{
if (role.role_genre != 0)
{
return(Result((int)ResultType.ROLE_GENRE_SELECTOK)); //验证是否已经选择流派信息
}
role.role_genre = type;
}
else if (type >= (int)RoleGenreType.NINJA_13 && type <= (int)RoleGenreType.NINJA_21)
{
if (role.role_ninja != 0)
{
return(Result((int)ResultType.ROLE_GENRE_SELECTOK));
}
role.role_ninja = type;
}
//更新家臣信息
if (!tg_role.UpdateByRole(role))
{
return(Result((int)ResultType.DATABASE_ERROR));
}
var rmain = session.Player.Role.Kind;
if (role.id == rmain.id) //主角则更新session
{
session.Player.Role.Kind = role;
}
var rolevo = (new Share.Role()).BuildRole(role.id);
return(new ASObject(Common.GetInstance().RoleLoadData((int)ResultType.SUCCESS, rolevo)));
}
/// <summary> 获取成功率</summary>
private int GetProbability(tg_role role)
{
var myvalue = tg_role.GetSingleTotal(RoleAttributeType.ROLE_BRAINS, role);
var pro = Variable.BASE_BUILD.FirstOrDefault(q => q.content == (int)BuildStepType.MAKE_BUILD && q.value <= myvalue);//智谋
return(pro == null ? 0 : pro.probability);
}
/// <summary>消耗体力日志</summary>
public void PowerLog(tg_role oldrole, int modulenumber, int command)
{
try
{
var cost = RuleConvert.GetCostPower();
var newrole = tg_role.GetRoleById(oldrole.id);
if (newrole == null)
{
return;
}
var oldpower = tg_role.GetTotalPower(oldrole);
string logdata;
var s = GetCommandString(command);
var m = GetModuleString(command);
if (oldrole.role_state == (int)RoleStateType.PROTAGONIST)
{
var totalpower = tg_role.GetTotalPower(newrole);
logdata = string.Format("{0}_{1}_{2}_{3}", "Power", oldpower, cost, totalpower);
(new Log()).WriteLog(oldrole.user_id, (int)LogType.Use, modulenumber, command, m, s, "主角体力", (int)GoodsType.TYPE_POWER, cost, totalpower, logdata);
}
else
{
logdata = string.Format("{0}_{1}_{2}_{3}", "Power", oldpower, cost, newrole.power);
(new Log()).WriteLog(oldrole.user_id, (int)LogType.Use, modulenumber, command, m, s, "武将体力", (int)GoodsType.TYPE_POWER, cost, newrole.power, logdata);
}
}
catch (Exception ex)
{
XTrace.WriteException(ex);
}
}
/// <summary> 职业任务推送 </summary>
private void VocationTaskPush(Int64 userid, tg_role role, int oldlevel)
{
if (role.role_state != (int)RoleStateType.PROTAGONIST)
{
return; //主角验证
}
var baseinfo = Variable.BASE_MODULEOPEN.FirstOrDefault(q => q.id == 19); //职业任务面板开启等级
if (baseinfo == null && role.role_level != baseinfo.level)
{
return;
}
if (!Variable.OnlinePlayer.ContainsKey(userid))
{
return;
}
var session = Variable.OnlinePlayer[userid] as TGGSession;
if (session == null)
{
return;
}
if (oldlevel >= baseinfo.level || role.role_level < baseinfo.level)
{
return;
}
var newtasks = tg_task.GetTaskQueryByType(userid, (int)TaskType.VOCATION_TASK);
var aso = BuildVocationData(newtasks);
var pv = session.InitProtocol((int)ModuleNumber.TASK,
(int)TaskCommand.TASK_PUSH, (int)ResponseType.TYPE_SUCCESS, aso);
session.SendData(pv);
}
/// <summary>消耗体力日志插入</summary>
/// <param name="role"></param>
/// <param name="power">消耗体力</param>
/// <param name="mn">模块号</param>
/// <param name="cn">指令号</param>
/// <param name="mnname">模块名字</param>
/// <param name="cnname">指令名字</param>
public void LogInsert(tg_role role, int power, ModuleNumber mn, int cn, string mnname, string cnname)
{
try
{
var r = tg_role.FindByid(role.id);
if (r == null)
{
return;
}
var oldp = role.power + role.buff_power;
var newp = r.power + r.buff_power;
var logdata = "体力" + "_" + oldp + "_" + power + "_" + newp;
if (role.role_state == (int)RoleStateType.PROTAGONIST)
{
(new Share.Log()).WriteLog(role.user_id, (int)LogType.Use, (int)mn, cn, mnname, cnname, "主角体力", (int)GoodsType.TYPE_POWER, power, r.power + r.buff_power, logdata);
}
else
{
(new Share.Log()).WriteLog(role.user_id, (int)LogType.Use, (int)mn, cn, mnname, cnname, "武将体力", (int)GoodsType.TYPE_POWER, power, r.power + r.buff_power, logdata);
}
}
catch (Exception ex)
{
XTrace.WriteException(ex);
}
}
/// <summary>创建武将</summary>
private RoleItem CreateRoleItem(BaseRoleInfo baserole, tg_user user, BaseIdentity baseIdentity)
{
var role = new tg_role
{
role_id = baserole.id,
role_identity = baseIdentity.id,
base_captain = baserole.captain,
base_force = baserole.force,
base_brains = baserole.brains,
base_charm = baserole.charm,
base_govern = baserole.govern,
power = baserole.power,
att_life = baserole.life,
user_id = user.id,
role_state = (int)RoleStateType.IDLE,
role_level = 1,
};
return(new RoleItem()
{
Kind = role,
LifeSkill = new tg_role_life_skill(),
FightSkill = new List <tg_role_fight_skill>(),
});
}
/// <summary>
/// 获取新的身份和功勋值
/// </summary>
/// <param name="roleinfo">武将实体</param>
/// <param name="vocation">职业</param>
/// <param name="oldidentify">之前的身份值</param>
private bool GetNewHonorAndIdentify(tg_role roleinfo, int vocation, int oldidentify)
{
var baseidentify = Variable.BASE_IDENTITY.LastOrDefault(q => q.SumHonor <= roleinfo.total_honor && q.vocation == vocation);
var last = Variable.BASE_IDENTITY.LastOrDefault(q => q.vocation == vocation);
if (baseidentify == null || last == null)
{
return(false);
}
var newhonor = roleinfo.total_honor - baseidentify.SumHonor;
//最后一个身份功勋处理
if (baseidentify == last && baseidentify.honor < newhonor)
{
newhonor = baseidentify.honor;
}
roleinfo.role_identity = baseidentify.id;
roleinfo.role_honor = newhonor;
roleinfo.Update();
//主角刚达到大名身份
if (roleinfo.role_identity > oldidentify && roleinfo.role_identity == last.id && vocation != (int)VocationType.Roles)
{
WarDataInit(roleinfo.user_id, roleinfo.id, roleinfo.role_id);
}
return(true);
}
/// <summary>领取家臣任务奖励</summary>
public void GetReward(string reward, tg_role role)
{
if (reward == "")
{
return;
}
var rewardlist = reward.Split('|');
foreach (var item in rewardlist)
{
var typelist = item.Split('_');
var type = Convert.ToInt32(typelist[0]);
switch (type)
{
#region 功勋
case (int)GoodsType.TYPE_HONOR:
{
var count = Convert.ToInt32(typelist[1]);
new Upgrade().UserIdentifyUpdate(role.user_id, count, role, (int)VocationType.Roles); //用户身份是否提升
}
break;
#endregion
}
}
}
/// <summary> tg_role TO Role </summary>
private Role ConvertRole(tg_role model)
{
if (model == null)
{
return(null);
}
return(new Role
{
damage = 0,
id = model.id,
angerCount = 0,
hp = model.att_life,
lv = model.role_level,
baseId = model.role_id,
user_id = model.user_id,
buffVos = new List <Buff>(),
buffVos2 = new List <Buff>(),
hurtReduce = model.att_sub_hurtReduce,
monsterType = (int)FightRivalType.ROLE,
critAddition = tg_role.GetTotalCritAddition(model),
hurtIncrease = model.att_sub_hurtIncrease,
attack = tg_role.GetTotalAttack(model),
defense = Convert.ToInt32(model.att_defense),
critProbability = tg_role.GetTotalCritProbability(model),
dodgeProbability = tg_role.GetTotalDodgeProbability(model),
mystery = BuildSkill(tg_role_fight_skill.FindByid(model.art_mystery)),
mystery_probability = tg_role.GetTotalMysteryProbability(model),
cheatCode = BuildSkill(tg_role_fight_skill.FindByid(model.art_cheat_code)),
});
}
/// <summary>获取修行属性值</summary>
public double GetTrainAtt(tg_role role, int attribute)
{
switch (attribute)
{
case (int)RoleAttributeType.ROLE_CAPTAIN:
{
return(role.base_captain_train);
}
case (int)RoleAttributeType.ROLE_CHARM:
{
return(role.base_charm_train);
}
case (int)RoleAttributeType.ROLE_FORCE:
{
return(role.base_force_train);
}
case (int)RoleAttributeType.ROLE_GOVERN:
{
return(role.base_govern_train);
}
case (int)RoleAttributeType.ROLE_BRAINS:
{
return(role.base_brains_train);
}
}
return(0);
}
/// <summary>PlayerDetailed 实体转换</summary>
public static PlayerDetailed ToPlayerDetailed(tg_user model, tg_role role, List <String> areas, int loginstate, int cars, int viplevel, string identity, string vocation, string office)
{
var player = new PlayerDetailed()
{
id = model.id,
rid = role.id,
code = model.user_code,
name = model.player_name,
vocation = vocation,
login_state = loginstate == 0 ? "不在线" : "在线",
vip = viplevel,
identity = identity,
level = role.role_level,
office = office,
gold = model.gold,
coin = model.coin,
spirit = model.spirit,
fame = model.fame,
merit = model.merit,
honor = role.total_honor,
cars = cars,
Areas = areas,
};
return(player);
}
/// <summary>tg_role实体转换RoleFight</summary>
private FightRole ConvertRoleFight(tg_role model)
{
return(new FightRole
{
damage = 0,
id = model.id,
angerCount = 0,
hp = model.att_life,
lv = model.role_level,
baseId = model.role_id,
user_id = model.user_id,
buffVos = new List <BuffVo>(),
hurtReduce = model.att_sub_hurtReduce,
monsterType = (int)FightRivalType.ROLE,
critAddition = tg_role.GetTotalCritAddition(model),
hurtIncrease = model.att_sub_hurtIncrease,
attack = tg_role.GetTotalAttack(model),
defense = Convert.ToInt32(model.att_defense),
critProbability = tg_role.GetTotalCritProbability(model),
dodgeProbability = tg_role.GetTotalDodgeProbability(model),
mystery = list_skill.FirstOrDefault(m => m.id == model.art_mystery),
mystery_probability = tg_role.GetTotalMysteryProbability(model),
cheatCode = list_skill.FirstOrDefault(m => m.id == model.art_cheat_code),
});
}
/// <summary>武将身份更新 </summary>
public void UserIdentifyUpdate(Int64 userid, int count, tg_role roleinfo, int vocation, int modulenumber, int command)
{
if (roleinfo == null || count <= 0)
{
return;
}
var oldidentify = roleinfo.role_identity; var oldhonor = roleinfo.role_honor;
var oldsum = roleinfo.total_honor;
roleinfo.total_honor += count;
roleinfo.total_honor = tg_user.IsHonorMax(oldsum, count, roleinfo.role_state); //功勋上限限定
if (!GetNewHonorAndIdentify(roleinfo, vocation, oldidentify))
{
return;
}
if (oldidentify < roleinfo.role_identity && roleinfo.role_state == (int)RoleStateType.PROTAGONIST)
{
SetTaskInit(userid);
SetWorkTaskSend(userid, roleinfo.role_identity);
(new Share.ActivityOpenService()).IdentityAdd(userid, roleinfo.role_identity);
(new Share.ActivityOpenService()).ActivityIdentityAdd(userid, roleinfo.role_identity);
}
//格式：武将主键id_基表id_获得功勋数|升级前身份_升级后|原始总功勋_升级后
var logdata = string.Format("RI_{0}_{1}_{2}|{3}_{4}|{5}_{6}|{7}_{8}|",
roleinfo.id, roleinfo.role_id, count, oldidentify, roleinfo.role_identity, oldhonor, roleinfo.role_honor, oldsum, roleinfo.total_honor);
var tuple = GetName(modulenumber, command);
new Share.Log().WriteLog(userid, (int)LogType.Update, (int)ModuleNumber.ROLE, 0, tuple.Item1, tuple.Item2, "功勋", (int)GoodsType.TYPE_HONOR, count, roleinfo.total_honor, logdata);
SendRoleAddHonor(userid, roleinfo, roleinfo.role_identity > oldidentify);
}
/// <summary>
/// 获取其他武将新的等级和经验
/// </summary>
/// <param name="roleinfo"></param>
/// <param name="mainrole"></param>
/// <returns></returns>
private bool GetNewExpAndLevel(tg_role roleinfo, tg_role mainrole)
{
var baselv = Variable.BASE_ROLELVUPDATE.LastOrDefault(q => q.SumExp <= roleinfo.total_exp);
var lastelv = Variable.BASE_ROLELVUPDATE.LastOrDefault();
if (baselv == null || lastelv == null)
{
return(false);
}
if (roleinfo.total_exp > mainrole.total_exp)
{
roleinfo.total_exp = mainrole.total_exp;
}
var newlevel = baselv.level;
var baseexp = roleinfo.total_exp - baselv.SumExp;
if (baselv == lastelv && baselv.exp < baseexp)
{
baseexp = baselv.exp;
}
roleinfo.role_level = newlevel;
roleinfo.role_exp = baseexp;
return(true);
}
public bool RoleLvUpdate1(Int64 userid, int count, tg_role roleinfo)
{
if (roleinfo == null || count <= 0)
{
return(false);
}
var oldlevel = roleinfo.role_level; var oldlife = roleinfo.att_life; var oldexp = roleinfo.role_exp;
roleinfo.total_exp += count; //经验增加
var mainrole = GetMainRole(userid);
if (mainrole == null)
{
return(false);
}
if (!GetNewExpAndLevel(roleinfo, mainrole))
{
return(false);
}
tg_role.GetLevelExpUpdate(roleinfo.role_level, roleinfo.role_exp, roleinfo.id, roleinfo.att_life, roleinfo.total_exp);
//写入日志
WriteLog(roleinfo.id, roleinfo.role_id, count, oldlevel, oldexp, oldlife, roleinfo);
var strings = new List <String>()
{
"experience"
};
if (roleinfo.role_level > oldlevel)
{
strings.Add("level"); strings.Add("life");
}
SendRoinLevelUp(userid, roleinfo, strings); //向在线玩家发送协议
return(true);
}
/// <summary>
/// 武将体力更新
/// </summary>
/// <param name="model">武将实体</param>
/// <param name="power">消耗体力值</param>
/// <param name="userid">用户id</param>
public void PowerUpdate(tg_role model, int power, Int64 userid)
{
if (model.buff_power > 0)
{
model.buff_power -= power;
if (model.buff_power < 0) //体力buff不够，则用基础体力来扣，因为为power负数，所以用+=
{
model.power += model.buff_power;
model.buff_power = 0;
}
}
else
{
model.power -= power;
}
tg_role.UpdatePower(model);
if (!Variable.OnlinePlayer.ContainsKey(userid))
{
return;
}
var session = Variable.OnlinePlayer[userid] as TGGSession;
if (session == null)
{
return;
}
if (model.role_state == (int)RoleStateType.PROTAGONIST) //主角
{
session.Player.Role.Kind.power = model.power;
session.Player.Role.Kind.buff_power = model.buff_power;
}
}
/// <summary>验证武将是否穿戴同类型装备</summary>
private Int64 CheckOldTitle(tg_role role, int type, Int64 ntid)
{
Int64 oid = 0;
switch (type)
{
case (int)TitleGetType.USE_SWORD: if (role.title_sword != 0)
{
oid = role.title_sword;
}
role.title_sword = ntid; break;
case (int)TitleGetType.USE_GUN: if (role.title_gun != 0)
{
oid = role.title_gun;
}
role.title_gun = ntid; break;
case (int)TitleGetType.USE_TEA_TABLE: if (role.title_tea != 0)
{
oid = role.title_tea;
}
role.title_tea = ntid; break;
case (int)TitleGetType.BARGARN_SUCCUSS: if (role.title_eloquence != 0)
{
oid = role.title_eloquence;
}
role.title_eloquence = ntid; break;
}
return(oid);
}
/// <summary>武将信息验证</summary>
private ASObject CheckRole(TGGSession session, tg_role role, BaseRoleTitle btitle, tg_role_title title)
{
var mainrole = session.Player.Role.Kind.CloneEntity();
var otid = CheckOldTitle(role, btitle.methods, title.id); //被替换称号id
if (otid != 0)
{
role = CheckRoleInfo(role, (int)RoleDatatype.ROLEDATA_LOSE, otid);
} //更新武将信息
if (string.IsNullOrEmpty(btitle.attAddition))
{
return(Error((int)ResultType.BASE_TABLE_ERROR)); //验证加成信息
}
Common.GetInstance().UpdateRole(role, (int)RoleDatatype.ROLEDATA_ADD, btitle.attAddition); //加成武将属性信息
if (!tg_role.UpdateByRole(role))
{
return(Error((int)ResultType.DATABASE_ERROR));
}
if (mainrole.id == role.id)
{
session.Player.Role.Kind = role; //装备武将为主角武将
}
Common.GetInstance().RoleUpdatePush(mainrole.user_id, role.id); //推送武将信息
if (!tg_role_title.UpdateByTitle(title))
{
return(Error((int)ResultType.DATABASE_ERROR));
}
return(new ASObject(Common.GetInstance().BuildLoadData((int)ResultType.SUCCESS, title)));
}
/// <summary>更新武将信息</summary>
/// <param name="role">武将信息</param>
/// <param name="type">加成或是削减</param>
/// <param name="value">值</param>
public tg_role UpdateRole(tg_role role, int type, string value)
{
if (string.IsNullOrEmpty(value))
{
return(role);
}
if (value.Contains("|"))
{
var add = value.Split("|").ToList();
foreach (var item in add)
{
if (!item.Contains("_"))
{
continue;
}
var str = item.Split("_").ToList();
var addType = Convert.ToInt32(str[0]);
var sum = Convert.ToInt32(str[1]);
role = AddTionUpdate(role, type, addType, sum);
}
}
else if (value.Contains("_"))
{
var str = value.Split("_").ToList();
var addType = Convert.ToInt32(str[0]);
var sum = Convert.ToInt32(str[1]);
role = AddTionUpdate(role, type, addType, sum);
}
return(role);
}
/// <summary>处理武将信息</summary>
private ASObject UpdateRole(TGGSession session, tg_role role, int basetid, tg_role_title title)
{
var mainrole = session.Player.Role.Kind.CloneEntity();
var btitle = Variable.BASE_ROLETITLE.FirstOrDefault(m => m.id == basetid);
if (btitle == null)
{
return(Error((int)ResultType.BASE_TABLE_ERROR)); //验证称号基表信息
}
if (string.IsNullOrEmpty(btitle.attAddition))
{
return(Error((int)ResultType.BASE_TABLE_ERROR)); //验证属性加成信息
}
role = RoleUpdateTitle(role, title.id); //更新武将身上称号信息
role = Common.GetInstance().UpdateRole(role, (int)RoleDatatype.ROLEDATA_LOSE, btitle.attAddition);
if (!tg_role.UpdateByRole(role))
{
return(Error((int)ResultType.DATABASE_ERROR));
}
if (mainrole.id == role.id)
{
session.Player.Role.Kind = role;
}
Common.GetInstance().RoleUpdatePush(mainrole.user_id, role.id); //推送武将属性更新
return(new ASObject(Common.GetInstance().BuildLoadData((int)ResultType.SUCCESS, title)));
}
/// <summary>处理武将基础属性</summary>
public tg_role AddTionUpdate(tg_role role, int type, int addType, double value)
{
if (type == (int)RoleDatatype.ROLEDATA_ADD)
{
switch (addType)
{
case (int)RoleAttributeType.ROLE_CAPTAIN: role.base_captain_title += value; break; //统率
case (int)RoleAttributeType.ROLE_FORCE: role.base_force_title += value; break; //武力
case (int)RoleAttributeType.ROLE_BRAINS: role.base_brains_title += value; break; //智谋
case (int)RoleAttributeType.ROLE_GOVERN: role.base_govern_title += value; break; //政务
case (int)RoleAttributeType.ROLE_CHARM: role.base_charm_title += value; break; //魅力
}
}
else
{
switch (addType)
{
case (int)RoleAttributeType.ROLE_CAPTAIN: role.base_captain_title -= value; break;
case (int)RoleAttributeType.ROLE_FORCE: role.base_force_title -= value; break;
case (int)RoleAttributeType.ROLE_BRAINS: role.base_brains_title -= value; break;
case (int)RoleAttributeType.ROLE_GOVERN: role.base_govern_title -= value; break;
case (int)RoleAttributeType.ROLE_CHARM: role.base_charm_title -= value; break;
}
role = CheckRoleAtt(role);
}
return(role);
}
/// <summary>卸载称号向下验证武将属性</summary>
public tg_role CheckRoleAtt(tg_role role)
{
if (role.base_captain_title < 0)
{
role.base_captain_title = 0;
}
if (role.base_force_title < 0)
{
role.base_force_title = 0;
}
if (role.base_brains_title < 0)
{
role.base_brains_title = 0;
}
if (role.base_govern_title < 0)
{
role.base_govern_title = 0;
}
if (role.base_charm_title < 0)
{
role.base_charm_title = 0;
}
if (role.att_sub_hurtIncrease < 0)
{
role.att_sub_hurtIncrease = 0;
}
if (role.att_sub_hurtReduce < 0)
{
role.att_sub_hurtReduce = 0;
}
if (role.att_attack < 0)
{
role.att_attack = 0;
}
if (role.att_defense < 0)
{
role.att_defense = 0;
}
if (role.att_life < 0)
{
role.att_life = 0;
}
if (role.att_crit_addition < 0)
{
role.att_crit_addition = 0;
}
if (role.att_crit_probability < 0)
{
role.att_crit_probability = 0;
}
if (role.att_dodge_probability < 0)
{
role.att_dodge_probability = 0;
}
if (role.att_mystery_probability < 0)
{
role.att_mystery_probability = 0;
}
return(role);
}
/// <summary>武将技能学习</summary>
private ASObject RoleSkillLearn(TGGSession session, tg_role role, BaseFightSkill skill)
{
if (!string.IsNullOrEmpty(skill.studyCondition)) //验证所需前置技能信息
{
var item = SkillData(skill.studyCondition); //获取前置技能集合信息
foreach (var id in item)
{
if (Convert.ToInt32(id) == 0)
{
continue;
}
var condition = tg_role_fight_skill.GetSkillByRidSkillId(role.id, Convert.ToInt32(id));
if (condition == null)
{
return(Result((int)ResultType.SKILL_CONDITION_LACK)); //验证前置技能
}
if (condition.skill_level < skill.conditionLevel)
{
return(Result((int)ResultType.SKILL_CONDITION_LEVEL_LACK)); //验证前置技能等级
}
}
}
if (role.role_level < skill.studyLevel)
{
return(Result((int)ResultType.BASE_ROLE_LEVEL_ERROR)); //验证武将等级
}
var power = RuleConvert.GetCostPower(); //固定消耗体力
if (!Common.GetInstance().PowerOperate(role, power))
{
return(Result((int)ResultType.BASE_ROLE_POWER_ERROR)); //验证体力
}
return(LearningSkill(session, skill, role, power)); //学习过程处理
}
/// <summary>消耗体力日志</summary>
public void PowerLog(tg_role role, int modulenumber, int command)
{
try
{
var cost = Variable.BASE_RULE.FirstOrDefault(m => m.id == "1010");
if (cost == null)
{
return;
}
var _role = tg_role.GetRoleById(role.id);
if (_role == null)
{
return;
}
var oldpower = tg_role.GetTotalPower(role);
string logdata;
if (role.role_state == (int)RoleStateType.PROTAGONIST)
{
var totalpower = tg_role.GetTotalPower(_role);
logdata = string.Format("{0}_{1}_{2}_{3}", "Power", oldpower, Convert.ToInt32(cost.value), totalpower);
(new Log()).WriteLog(role.user_id, (int)LogType.Use, modulenumber, command, "技能", "生活技能学习", "主角体力", (int)GoodsType.TYPE_POWER, Convert.ToInt32(cost.value), totalpower, logdata);
}
else
{
logdata = string.Format("{0}_{1}_{2}_{3}", "Power", oldpower, Convert.ToInt32(cost.value), _role.power);
(new Log()).WriteLog(role.user_id, (int)LogType.Use, modulenumber, command, "技能", "生活技能学习", "武将体力", (int)GoodsType.TYPE_POWER, Convert.ToInt32(cost.value), _role.power, logdata);
}
}
catch (Exception ex)
{
XTrace.WriteException(ex);
}
}
/// <summary>验证体力是否足够</summary>
private bool CheckPower(tg_role role)
{
var power = RuleConvert.GetCostPower();
var totalpower = tg_role.GetTotalPower(role);
return(totalpower >= power);
}
/// <summary>检验大名令是否开启</summary>
private void CheckDaMing(Int64 userid, tg_role role, int oldlevel)
{
if (!Variable.OnlinePlayer.ContainsKey(userid))
{
return;
}
var session = Variable.OnlinePlayer[userid] as TGGSession;
if (session == null)
{
return;
}
if (role.role_state != (int)RoleStateType.PROTAGONIST)
{
return;
}
if (oldlevel >= 30 || role.role_level < 30)
{
return;
}
var player = session.Player.CloneEntity();
player.UserExtend.dml = 1;
player.UserExtend.Update();
session.Player = player;
}
/// <summary>武将身份更新 </summary>
public void UserIdentifyUpdate(Int64 userid, int count, tg_role roleinfo, int vocation)
{
using (var scope = new TransactionScope())
{
if (roleinfo == null || count <= 0)
{
scope.Complete(); return;
}
var oldident = roleinfo.role_identity; var oldhonor = roleinfo.role_honor;
var totalhonor = roleinfo.total_honor;
var isup = 0;
roleinfo.role_honor = tg_user.IsHonorMax(roleinfo.role_honor, count); //功勋增加
var lastidentity = Variable.BASE_IDENTITY.LastOrDefault(q => q.vocation == vocation);
var baseidentify = Variable.BASE_IDENTITY.FirstOrDefault(q => q.id == roleinfo.role_identity);
if (baseidentify == null || lastidentity == null)
{
scope.Complete(); return;
}
if (lastidentity.id == baseidentify.id)
{
scope.Complete(); return;
} //最后一个身份不进行更新
var basehonor = baseidentify.honor;
while (basehonor <= roleinfo.role_honor)//身份提升过程
{
var baseinfo = Variable.BASE_IDENTITY.FirstOrDefault(q => q.id == roleinfo.role_identity);
if (baseinfo == null)
{
scope.Complete(); return;
}
if (baseinfo.id == lastidentity.id)
{
roleinfo.role_honor = basehonor; break;
} //最后一个身份,功勋归为最大值
roleinfo.role_identity++; isup++;
if (roleinfo.role_state == (int)RoleStateType.PROTAGONIST) //主角
{
SetTaskInit(userid);
SetWorkTaskSend(userid, roleinfo.role_identity);
}
roleinfo.role_honor -= Convert.ToInt32(baseinfo.honor);
var basedata = Variable.BASE_IDENTITY.FirstOrDefault(q => q.id == roleinfo.role_identity);
if (basedata == null)
{
break;
}
basehonor = basedata.honor;
}
roleinfo.total_honor += count;
roleinfo.Update();
//格式：武将主键id_基表id_获得功勋数|升级前身份_升级后|原始总功勋_升级后
var logdata = string.Format("RI_{0}_{1}_{2}|{3}_{4}|{5}_{6}|{7}_{8}|",
roleinfo.id, roleinfo.role_id, count, oldident, roleinfo.role_identity, oldhonor, roleinfo.role_honor, totalhonor, roleinfo.total_honor);
new Share.Log().WriteLog(userid, (int)LogType.Update, (int)ModuleNumber.ROLE, 0, logdata);
SendRoleAddHonor(userid, roleinfo, isup);
scope.Complete();
}
}
/// <summary>武将属性推送更新</summary>
public void RoleInfoToRole(Int64 userid, tg_role role, string name)
{
var list = new List <string> {
name
};
new RoleAttUpdate().RoleUpdatePush(role, userid, list);
}
/// <summary>属性点向下验证</summary>
private void CheckAtt(tg_role role)
{
role.base_captain_level = role.base_captain_level < 0 ? 0 : role.base_captain_level;
role.base_force_level = role.base_force_level < 0 ? 0 : role.base_force_level;
role.base_brains_level = role.base_brains_level < 0 ? 0 : role.base_brains_level;
role.base_govern_level = role.base_govern_level < 0 ? 0 : role.base_govern_level;
role.base_charm_level = role.base_charm_level < 0 ? 0 : role.base_charm_level;
}
/// <summary>验证属性点信息</summary>
private Boolean CheckLimit(List <int> list, tg_role role, double limit, double st)
{
role.base_captain_level += Convert.ToDouble(list[0]); //统率
if (role.base_captain_level > limit)
{
return(false);
}
if (Total(RoleAttributeType.ROLE_CAPTAIN, role) > st)
{
return(false);
}
role.base_force_level += Convert.ToDouble(list[1]); //武力
if (role.base_force_level > limit)
{
return(false);
}
if (Total(RoleAttributeType.ROLE_FORCE, role) > st)
{
return(false);
}
role.base_brains_level += Convert.ToDouble(list[2]); //智谋
if (role.base_brains_level > limit)
{
return(false);
}
if (Total(RoleAttributeType.ROLE_BRAINS, role) > st)
{
return(false);
}
role.base_govern_level += Convert.ToDouble(list[3]); //政务
if (role.base_govern_level > limit)
{
return(false);
}
if (Total(RoleAttributeType.ROLE_GOVERN, role) > st)
{
return(false);
}
role.base_charm_level += Convert.ToDouble(list[4]); //魅力
if (role.base_charm_level > limit)
{
return(false);
}
if (Total(RoleAttributeType.ROLE_CHARM, role) > st)
{
return(false);
}
var tadd = role.base_captain_level + role.base_force_level + role.base_brains_level + role.base_govern_level + role.base_charm_level;
return(!(tadd > limit));
}
