/// <summary>统计每日完成度</summary>
private void CheckReward(tg_user_extend ex)
{
var finish = Variable.BASE_RULE.FirstOrDefault(m => m.id == "30004");
if (finish == null)
{
return;
}
var total = Convert.ToInt32(finish.value);
if (ex.game_finish_count >= total || ex.game_receive != (int)GameRewardType.TYPE_UNREWARD)
{
ex.Update(); return;
}
ex.game_finish_count++;
if (ex.game_finish_count < total) //未达到领奖条件
{
ex.Update(); return;
}
ex.game_receive = (int)GameRewardType.TYPE_CANREWARD;
ex.Update();
}
/// <summary>偷窃逻辑处理</summary>
private ASObject StealNpc(TGGSession session, tg_user_extend extend, BaseNpcMonster basenpc, tg_train_home npc)
{
var userid = session.Player.User.id;
var nprob = GetProbability(session.Player.Role.LifeSkill.sub_ninjitsu, session.Player.Role.LifeSkill.sub_ninjitsu_level); //忍术加成概率
var bprob = GetBrainProb(session.Player.Role); //智谋加成概率
var equip = Common.GetInstance().RandomEquip(userid, basenpc, nprob, bprob);
if (equip != null) //偷窃成功
{
npc.is_steal = (int)TrainHomeStealType.STEAL_YES;
if (!tg_train_home.UpdateNpc(npc))
{
return(Error((int)ResultType.DATABASE_ERROR));
}
AcquireEquip(session, equip); //获得装备信息处理
var logdata = string.Format("{0}_{1}", "EquipSteal", equip.base_id); //记录偷窃获得装备信息
(new Share.Log()).WriteLog(userid, (int)LogType.Get, (int)ModuleNumber.ROLETRAIN, (int)RoleTrainCommand.TRAIN_HOME_NPC_STEAL, logdata);
log.BagInsertLog(equip, (int)ModuleNumber.ROLETRAIN, (int)RoleTrainCommand.TRAIN_HOME_NPC_STEAL, 0); //记录日志
}
else
{
extend.steal_fail_count++;
extend.Update();
session.Player.UserExtend = extend;
if (IsEnterPrison(extend.steal_fail_count))
{
new Share.Prison().PutInPrison(userid);
} //推送进入监狱
}
(new Share.DaMing()).CheckDaMing(userid, (int)DaMingType.武将宅偷窃);
return(new ASObject(Common.GetInstance().NpcStealData((int)ResultType.SUCCESS, npc.is_steal)));
}
/// <summary>获取讲价后的价格</summary>
private Int64 GetBargainPrice(tg_user_extend extend, RoleItem role, Int64 total, int type, ref bool success)
{
//根据概率来计算讨价是否成功
var prob = GetEloquence(role.LifeSkill.sub_eloquence, role.LifeSkill.sub_eloquence_level);
var rs = new RandomSingle();
success = rs.IsTrue(prob.Eloquence);
#if DEBUG
success = true;
#endif
if (!success)
{
return(total);
}
//判断用户家臣称号是否达成---LZH
(new Share.Title()).IsTitleAcquire(extend, (int)TitleGetType.BARGARN_SUCCUSS); //判断称号信息
var calculate = GetCalculate(role.LifeSkill.sub_calculate, role.LifeSkill.sub_calculate_level);
if (type == (int)BusinessType.Buy)
{
total -= Convert.ToInt32(total * calculate.Buy / 100);
}
else
{
total += Convert.ToInt32(total * calculate.Sell / 100);
}
return(total);
}
/// <summary>初始用户扩展信息</summary>
public tg_user_extend InitUserExtend(tg_user user)
{
if (user == null || user.id <= 0)
{
return(null);
}
var _b = Variable.BASE_RULE.FirstOrDefault(q => q.id == "4001");
var _t = Variable.BASE_RULE.FirstOrDefault(q => q.id == "17001");
var _s = Variable.BASE_RULE.FirstOrDefault(q => q.id == "9002");
if (_b == null || _t == null || _s == null)
{
return(new tg_user_extend());
}
var base_bag = Convert.ToInt32(_b.value);
var base_train_bar = Convert.ToInt32(_t.value);
var shot_count = Convert.ToInt32(_s.value);
var model = new tg_user_extend {
user_id = user.id, bag_count = base_bag, train_bar = base_train_bar, shot_count = shot_count
};
model.Save();
return(model);
}
/// <summary>在线玩家扩展信息重置</summary>
private void OnlineReset(tg_user_extend extend)
{
foreach (var player in Variable.OnlinePlayer.Values)
{
var session = player as TGGSession;
if (session == null) continue;
var ext = session.Player.UserExtend;
ext.daySalary = extend.daySalary;
ext.donate = extend.donate;
ext.task_role_refresh = extend.task_role_refresh;
ext.task_vocation_refresh = extend.task_vocation_refresh;
ext.shot_count = extend.shot_count;
ext.bargain_count = extend.bargain_count;
ext.npc_refresh_count = extend.npc_refresh_count;
ext.challenge_count = extend.challenge_count;
ext.power_buy_count = extend.power_buy_count;
ext.task_vocation_isgo = extend.task_vocation_isgo;
ext.salary_state = extend.salary_state;
ext.eloquence_count = extend.eloquence_count;
ext.tea_count = extend.tea_count;
ext.calculate_count = extend.calculate_count;
ext.ninjutsu_count = extend.ninjutsu_count;
ext.ball_count = extend.ball_count;
ext.game_finish_count = extend.game_finish_count;
ext.game_receive = extend.game_receive;
ext.refresh_count = extend.refresh_count;
ext.steal_fail_count = extend.steal_fail_count;
ext.fight_count = extend.fight_count;
ext.fight_buy = extend.fight_buy;
session.Player.UserExtend = ext;
}
}
/// <summary>组装返回的次数list集合</summary>
private List <int> ListCount(tg_user_extend extend)
{
var value = new List <int>
{
extend.sword_win_count,
extend.gun_win_count,
extend.tea_table_count,
extend.bargain_success_count
};
return(value);
}
/// <summary> 组装HomeHireVo </summary>
public static HomeHireVo ToRoleHomeHireVo(tg_user_extend extend)
{
var model = new HomeHireVo
{
id = extend.id,
baseId = extend.hire_id,
time = extend.hire_time,
state = extend.hire_id == 0 ? 0 : 1,
};
return(model);
}
/// <summary>初始化背包数据</summary>
public BagItem InitBag(tg_user user, tg_user_extend extend)
{
var bag = new BagItem {
BagIsFull = false, Surplus = 0,
};
var count = tg_bag.GetFindCount(user.id);
bag.Surplus = extend.bag_count - count;
bag.BagIsFull = bag.Surplus <= 0;
return(bag);
}
/// <summary>判断次数</summary>
private void JudgeCount(tg_user_extend extend, int type, int count)
{
var list = Variable.BASE_ROLETITLE.Where(m => m.methods == type && m.count <= count).ToList();
if (!list.Any())
{
return;
}
foreach (var item in list)
{
UpdateTitle(extend.user_id, item);
}
}
/// <summary>判断称号是否达成</summary>
private void IsGetTitle(tg_user_extend extend, int type)
{
switch (type)
{
case (int)TitleGetType.USE_SWORD: JudgeCount(extend, type, extend.sword_win_count); break;
case (int)TitleGetType.USE_GUN: JudgeCount(extend, type, extend.gun_win_count); break;
case (int)TitleGetType.USE_TEA_TABLE: JudgeCount(extend, type, extend.tea_table_count); break;
case (int)TitleGetType.BARGARN_SUCCUSS: JudgeCount(extend, type, extend.bargain_success_count); break;
}
}
/// <summary>创建游艺园vo</summary>
/// <param name="type">游戏类型</param>
/// <param name="tggame">游艺园实体</param>
/// <param name="userextend">拓展表实体</param>
/// <param name="list">游艺园基表集合</param>
/// <returns>游艺园vo</returns>
public YouYiyuanVo CreateGame(int type, tg_game tggame, tg_user_extend userextend, IEnumerable <BaseYouYiYuan> list)
{
int count;
var game = list.FirstOrDefault(m => m.type == type);
if (game == null)
{
return(null);
}
var youvo = new YouYiyuanVo();
switch (type)
{
case (int)GameEnterType.辩驳游戏:
{
count = game.num - userextend.eloquence_count;
youvo = EntityToVo.ToYouYiyuanVo(type, count, tggame.eloquence_max_pass);
}
break;
case (int)GameEnterType.花月茶道:
{
count = game.num - userextend.tea_count;
youvo = EntityToVo.ToYouYiyuanVo(type, count, tggame.tea_max_pass);
}
break;
case (int)GameEnterType.老虎机:
{
count = game.num - userextend.calculate_count;
youvo = EntityToVo.ToYouYiyuanVo(type, count, tggame.calculate_max_pass);
}
break;
case (int)GameEnterType.猜宝游戏:
{
count = game.num - userextend.ninjutsu_count;
youvo = EntityToVo.ToYouYiyuanVo(type, count, tggame.ninjutsu_max_pass);
}
break;
case (int)GameEnterType.猎魂:
{
count = game.num - userextend.ball_count;
youvo = EntityToVo.ToYouYiyuanVo(type, count, tggame.spirit_max_pass);
}
break;
}
return(youvo);
}
/// <summary>玩家扩展数据重置</summary>
private void SetUserTimerUpdate()
{
var _s = Variable.BASE_RULE.FirstOrDefault(q => q.id == "9002");
if (_s == null)
{
return;
}
var _n = Variable.BASE_RULE.FirstOrDefault(q => q.id == "9008");
if (_n == null)
{
return;
}
var shot_count = Convert.ToInt32(_s.value);
var npc_refresh_count = Convert.ToInt32(_n.value);
var model = new tg_user_extend
{
daySalary = 0,
donate = 0,
task_role_refresh = 0,
task_role_experience = 0,
task_vocation_refresh = 0,
shot_count = shot_count,
bargain_count = 0,
npc_refresh_count = npc_refresh_count,
challenge_count = 1,
power_buy_count = 0,
task_vocation_isgo = 0,
salary_state = (int)SalaryStateType.NO_RECEIVE,
eloquence_count = 0,
tea_count = 0,
ninjutsu_count = 0,
calculate_count = 0,
ball_count = 0,
game_finish_count = 0,
game_receive = 0,
refresh_count = 0,
steal_fail_count = 0,
fight_count = 0,
fight_buy = 0,
devote_limit = 0,
train_home_gold = 0,
};
tg_user_extend.GetEntityUpdate(model);
tg_user_login_log.GetTimerUpdate();
OnlineReset(model);
}
/// <summary>更新记录完成度信息</summary>
private tg_user_extend UpdateExt(tg_user_extend ext, int grade, int percent)
{
switch (grade)
{
case (int)GradeType.Bule: ext.card_blue_percent = percent; break;
case (int)GradeType.Purple: ext.card_purple_percent = percent; break;
case (int)GradeType.Orange: ext.card_orange_percent = percent; break;
case (int)GradeType.Red: ext.card_red_percent = percent; break;
}
ext.Save();
return(ext);
}
/// <summary>更新游戏使用次数</summary>
/// <param name="type">游戏类型</param>
/// <param name="ex">拓展表实体</param>
private void GameCountUpdate(int type, tg_user_extend ex)
{
switch (type)
{
case (int)GameEnterType.辩驳游戏: ex.eloquence_count++; break;
case (int)GameEnterType.老虎机: ex.calculate_count++; break;
case (int)GameEnterType.花月茶道: ex.tea_count++; break;
case (int)GameEnterType.猜宝游戏: ex.ninjutsu_count++; break;
case (int)GameEnterType.猎魂: ex.ball_count++; break;
}
ex.Save();
}
/// <summary>
/// 用户刷新次数更新
/// </summary>
/// <param name="type">刷新类型</param>
/// <param name="userextend">用户扩展信息</param>
/// <param name="session"></param>
private void GetReflashUpdate(int type, tg_user_extend userextend, TGGSession session)
{
switch (type)
{
case 1:
userextend.task_vocation_refresh++;
break;
case 2:
userextend.task_vocation_refresh = 0;
userextend.task_vocation_isgo = 0;
break;
}
userextend.Update();//更新用户和用户扩展
session.Player.UserExtend = userextend;
}
/// <summary>判断返回称号获取途径的次数</summary>
private int Count(tg_user_extend extend, int type)
{
var count = 0;
switch (type)
{
case (int)TitleGetType.USE_SWORD: count = extend.sword_win_count; break;
case (int)TitleGetType.USE_GUN: count = extend.gun_win_count; break;
case (int)TitleGetType.USE_TEA_TABLE: count = extend.tea_table_count; break;
case (int)TitleGetType.BARGARN_SUCCUSS: count = extend.bargain_success_count; break;
}
return(count);
}
/// <summary> 验证剩余次数</summary>
/// <param name="type">小游戏类型</param>
/// <param name="ex">tg_user_extend</param>
/// <returns></returns>
public bool CheckCount(int type, tg_user_extend ex)
{
var rule = Variable.BASE_YOUYIYUAN.FirstOrDefault(m => m.type == type);
if (rule == null)
{
return(false);
}
var total = rule.num; //闯关总次数
switch (type)
{
case (int)GameEnterType.花月茶道: if (ex.tea_count >= total)
{
return(false);
}
break;
case (int)GameEnterType.辩驳游戏: if (ex.eloquence_count >= total)
{
return(false);
}
break;
case (int)GameEnterType.老虎机: if (ex.calculate_count >= total)
{
return(false);
}
break;
case (int)GameEnterType.猜宝游戏: if (ex.ninjutsu_count >= total)
{
return(false);
}
break;
case (int)GameEnterType.猎魂: if (ex.ball_count >= total)
{
return(false);
}
break;
default: return(false);
}
return(true);
}
/// <summary>判断称号是否达到-----（跑商讲价）</summary>
/// <param name="extend">用户拓展信息</param>
/// <param name="type">获取方式</param>
public void IsTitleAcquire(tg_user_extend extend, int type)
{
switch (type)
{
case (int)TitleGetType.USE_SWORD: extend.sword_win_count += 1; break; //剑
case (int)TitleGetType.USE_GUN: extend.gun_win_count += 1; break; //枪
case (int)TitleGetType.USE_TEA_TABLE: extend.tea_table_count += 1; break; //茶席
case (int)TitleGetType.BARGARN_SUCCUSS: extend.bargain_success_count += 1; break; //讲价成功
}
if (!tg_user_extend.GetUpdate(extend))
{
return;
}
IsGetTitle(extend, type);
}
/// <summary>
/// 组装家族vo
/// </summary>
/// <param name="familymyself">家族信息</param>
/// <param name="ranking">排名</param>
/// <returns></returns>
public FamilyVo FamilyInfo(tg_family familymyself, int ranking, tg_user_extend userextend)
{
var list_member = new List <FamilyMemberVo>();
var list = view_user_role_family_member.GetAllById(familymyself.id); //家族成员信息
var loglist = new List <tg_user_login_log>();
if (list.Count > 0)
{
if (list.Count == 1)
{
var userid = list[0].userid;
loglist.Add(tg_user_login_log.GetLoginLogById(userid));
}
else
{
var userids = string.Join(",", list.ToList().Select(m => m.userid).ToArray());
loglist = tg_user_login_log.GetLoginLogByIds(userids);
}
}
foreach (var fm in list) //家族成员登陆时间
{
foreach (var log in loglist)
{
if (fm.userid != log.user_id)
{
continue;
}
if (Variable.OnlinePlayer.ContainsKey(fm.userid))
{
decimal debarktime = (log.logout_time - 621355968000000000) / 10000;
list_member.Add(EntityToVo.ToFamilyMemberVo(1, fm, debarktime));
}
else
{
decimal debarktime = (log.logout_time - 621355968000000000) / 10000;
list_member.Add(EntityToVo.ToFamilyMemberVo(0, fm, debarktime));
}
}
}
var familyvo = EntityToVo.ToFamilyVo(familymyself, ranking, list_member, userextend);
return(familyvo);
}
/// <summary>返回前端结果</summary>
/// <param name="game">游艺园实体</param>
/// <param name="userextend">拓展表实体</param>
/// <param name="list">游艺园基表集合</param>
/// <returns></returns>
private ASObject Result(tg_game game, tg_user_extend userextend, List <BaseYouYiYuan> list)
{
var volist = new List <YouYiyuanVo>();
var youvo = Common.GetInstance().CreateGame((int)GameEnterType.猎魂, game, userextend, list);
if (youvo == null)
{
return(Error((int)ResultType.BASE_TABLE_ERROR));
}
volist.Add(youvo);
youvo = Common.GetInstance().CreateGame((int)GameEnterType.猜宝游戏, game, userextend, list);
if (youvo == null)
{
return(Error((int)ResultType.BASE_TABLE_ERROR));
}
volist.Add(youvo);
youvo = Common.GetInstance().CreateGame((int)GameEnterType.老虎机, game, userextend, list);
if (youvo == null)
{
return(Error((int)ResultType.BASE_TABLE_ERROR));
}
volist.Add(youvo);
youvo = Common.GetInstance().CreateGame((int)GameEnterType.花月茶道, game, userextend, list);
if (youvo == null)
{
return(Error((int)ResultType.BASE_TABLE_ERROR));
}
volist.Add(youvo);
youvo = Common.GetInstance().CreateGame((int)GameEnterType.辩驳游戏, game, userextend, list);
if (youvo == null)
{
return(Error((int)ResultType.BASE_TABLE_ERROR));
}
volist.Add(youvo);
return(new ASObject(Common.GetInstance().BuilData((int)ResultType.SUCCESS, volist, game.week_max_pass, userextend.game_finish_count, userextend.game_receive)));
}
/// <summary>组装FamilyVo</summary>
/// <param name="model">家族实体</param>
/// <param name="ranking">排名</param>
/// <param name="list_member_vo">家族成员实体集合</param>
/// <param name="userextend">用户拓展实体</param>
/// <returns>前端FamilyVo</returns>
public static FamilyVo ToFamilyVo(tg_family model, int ranking, List <FamilyMemberVo> list_member_vo, tg_user_extend userextend)
{
return(new FamilyVo()
{
id = model.id,
name = model.family_name,
level = model.family_level,
rankings = ranking,
number = model.number,
resource = model.resource,
renown = model.renown,
notice = model.notice,
clanbadge = model.clanbadge,
familyMemberArrVo = list_member_vo,
daySalary = userextend.daySalary,
dayDonate = userextend.donate,
});
}
