/// <summary>发放奖励</summary>
public void PushReward(tg_task task)
{
var userid = task.user_id;
var _base = Variable.BASE_TASKVOCATION.FirstOrDefault(q => q.id == task.task_id);
if (_base == null)
{
return;
}
if (task.task_state != (int)TaskStateType.TYPE_REWARD)
{
return;
}
var b = Variable.OnlinePlayer.ContainsKey(task.user_id);
if (!b)
{
return;
}
var session = Variable.OnlinePlayer[task.user_id] as TGGSession;
var rewardstring = GetRewardString(_base, session); //领取奖励
new Share.Reward().GetReward(rewardstring, userid, (int)ModuleNumber.TASK, (int)TaskCommand.TASK_VOCATION_UPDATE);
}
/// <summary>守护线程</summary>
public void WatchThreading(int time, tg_task newtask)
{
# if DEBUG
//time = 10;
#endif
try
{
/// <summary>完成任务并推送</summary>
private void TaskUpdateAndSend(tg_task task, string finishstep)
{
var taskinfo = Variable.TaskInfo.FirstOrDefault(q => q.userid == task.user_id);
if (taskinfo == null)
{
return;
}
//更新对应任务戒严场景id
switch (task.task_step_type)
{
case (int)TaskStepType.ARREST_RUMOR: taskinfo.ArrestRumorSceneId = 0; break;
case (int)TaskStepType.ARREST_FIRE: taskinfo.ArrestFireSceneId = 0; break;
case (int)TaskStepType.ARREST_BREAK: taskinfo.ArrestBreakSceneId = 0; break;
case (int)TaskStepType.ARREST_SEll_WINE: taskinfo.ArrestSellSceneId = 0; break;
}
task.task_step_data = finishstep;
task.task_state = (int)TaskStateType.TYPE_REWARD;
task.Update();
(new Share.TGTask()).AdvancedTaskPush(task.user_id, task); //推送协议
}
/// <summary>更新谣言任务</summary>
private bool CheckRumorTask(tg_task task, string finishstep)
{
task.task_step_data = finishstep;
task.task_state = (int)TaskStateType.TYPE_REWARD;
task.Update();
return(true);
}
//private bool CheckQueue(Int64 userid)
//{
// if (dic.ContainsKey(userid)) return false;
// dic.TryAdd(userid, true);
// return true;
//}
//private void RemoveQuene(Int64 userid)
//{
// Boolean tryremove;
// dic.TryRemove(userid, out tryremove);
//}
#region 任务验证
/// <summary>
/// 接受任务验证
/// </summary>
/// <param name="task">tg_task实体</param>
/// <param name="npcid">接取任务npcid</param>
/// <param name="npc">前端提交npcid</param>
/// <param name="session"></param>
/// <returns>验证后返回的数据</returns>
private ASObject ReceiveTaskCheck(tg_task task, Int32 npcid, int npc)
{
if (!Variable.OnlinePlayer.ContainsKey(task.user_id))
{
return(new ASObject(BulidReturnData((int)ResultType.UNKNOW_ERROR, null)));
}
if (npcid != npc)
{
return(new ASObject(BulidReturnData((int)ResultType.TASK_NPC_FALSE, null)));
}
if (task.task_state != (int)TaskStateType.TYPE_UNRECEIVED)
{
return(new ASObject(BulidReturnData((int)ResultType.TASK_RECEIVED, null)));
}
task.task_state = (int)TaskStateType.TYPE_UNFINISHED;
tg_task.GetTaskUpdate(task.task_state, task.task_step_data, task.task_id, task.id, task.user_id);
var session = Variable.OnlinePlayer[task.user_id] as TGGSession;
session.MainTask.task_state = (int)TaskStateType.TYPE_UNFINISHED;
// RemoveQuene(task.user_id);
return(new ASObject(BulidReturnData((int)ResultType.SUCCESS, task)));
}
/// <summary>谣言类任务</summary>
/// <param name="player">玩家信息 player</param>
/// <param name="task">任务信息 task</param>
/// <param name="finishstep">任务步骤 finishstep</param>
/// <param name="npcid">对话npcid </param>
/// <returns>ASObject</returns>
public ASObject RumorTask(Player player, tg_task task, string finishstep, int npcid)
{
var userid = task.user_id;
var myscene = Scene.GetSceneInfo((int)ModuleNumber.PRISON, player.User.id);
if (myscene != null)
{
CommonHelper.ErrorResult((int)ResultType.TASK_VOCATION_PRISON); //验证是否在监狱中
}
//验证对话npc是否正确
if (!CheckNpc(task.task_step_data, npcid))
{
return(CommonHelper.ErrorResult((int)ResultType.TASK_VOCATION_NOTASK));
}
//验证谣言任务是否成功
var istrue = (new Share.TGTask()).IsTaskSuccess(player.Role, task.task_step_type);
var gtask = GetWorkInfo(userid);
if (istrue) //成功 更新任务
{
if (!CheckRumorTask(task, finishstep))
{
return(CommonHelper.ErrorResult((int)ResultType.DATABASE_ERROR));
}
UpdateFailCount(task.task_step_type, gtask); //更新失败次数
}
else
{
UpdateAndPush(task, gtask, player.User.id, player.User.player_name, player.Scene.scene_id); //更新失败次数并验证是否入狱
}
return(new ASObject(BulidData((int)ResultType.SUCCESS, task)));
}
/// <summary> 评定结束</summary>
public void CommandStart(tg_task task)
{
#if DEBUG
XTrace.WriteLine("任务{0}评定结束{1}--{2}", task.id, task.user_id, "PUSH_TASK_END");
#endif
Common.GetInstance().AppraiseEnd(task);
if (Variable.OnlinePlayer.ContainsKey(task.user_id))
{
var session = Variable.OnlinePlayer[task.user_id] as TGGSession;
if (session == null)
{
return;
}
#if DEBUG
XTrace.WriteLine("玩家{0}在线，向前端推送任务结束{0}", task.id);
#endif
var dic = new Dictionary <string, object>()
{
{ "task", EntityToVo.ToRoleVo(task) }
};
var aso = new ASObject(dic);
var pv = session.InitProtocol((int)ModuleNumber.APPRAISE,
(int)AppraiseCommand.PUSH_TASK_END, (int)ResponseType.TYPE_SUCCESS, aso);
session.SendData(pv);
}
}
/// <summary> 任务数据更新 </summary>
public void TaskUpdate(tg_task task, string newstep, string basestep)
{
if (task == null)
{
return;
}
if (!Variable.OnlinePlayer.ContainsKey(task.user_id))
{
return;
}
var session = Variable.OnlinePlayer[task.user_id] as TGGSession;
if (session == null || session.MainTask == null)
{
return;
}
task.task_step_data = newstep;
if (newstep == basestep)
{
task.task_state = (int)TaskStateType.TYPE_REWARD;
}
tg_task.GetTaskUpdate(task.task_state, task.task_step_data, task.task_id, task.id, task.user_id);
if (task.task_type == (int)TaskType.MAIN_TASK)
{
session.MainTask.task_state = task.task_state;
session.MainTask.task_step_data = task.task_step_data;
session.MainTask.task_id = task.task_id;
}
}
/// <summary>多个npc完成总对话次数 任务验证 </summary>
private bool CheckTwoNpc(string basestep, int npc, tg_task task)
{
var steplist = task.task_step_data.Split('_');
var npccheck = false;
for (var i = 0; i < steplist.Count(); i++)
{
if (steplist[i] != npc.ToString())
{
continue;
}
npccheck = true;
break;
}
if (npccheck == false)
{
return(false);
}
var countindex = steplist.Count() - 1;
var count = Convert.ToInt32(steplist[countindex]);
var needcount = Convert.ToInt32(basestep.Split('_')[countindex]);
count++;
if (count > needcount)
{
return(false);
}
steplist[3] = count.ToString();
var newstep = string.Join("_", steplist);
Common.getInstance().TaskUpdate(task, newstep, basestep);
return(true);
}
/// <summary>
/// 开启新线程
/// </summary>
/// <param name="time"></param>
/// <param name="mytask"></param>
/// <param name="finishstep"></param>
public void NewTaskStart(Int64 time, tg_task mytask, string finishstep)
{
try
{
var token = new CancellationTokenSource();
var task = new System.Threading.Tasks.Task(() => SpinWait.SpinUntil(() =>
{
var taskinfo = Common.getInstance().GetWorkInfo(mytask.user_id);
if (taskinfo.GuardSceneId == 0)
{
token.Cancel();
return(true);
}
return(false);
}, (int)time * 1000), token.Token);
task.Start();
task.ContinueWith(m =>
{
TaskUpdateAndSend(mytask, finishstep);
token.Cancel();
}, token.Token);
}
catch (Exception ex)
{
XTrace.WriteException(ex);
}
}
/// <summary>
/// 验证是否是最后一个主线任务
/// </summary>
/// <param name="task"></param>
/// <param name=" baseindex"></param>
/// <returns>bool:是否最后一个任务 BaseTaskMain：新任务基表数据 ASObject：最后一个任务返回前端数据</returns>
private Tuple <bool, ASObject> CheckIsLastTask(tg_task task, int baseindex)
{
if (task == null)
{
return(Tuple.Create(false, BulidReturnData((int)ResultType.UNKNOW_ERROR, null)));
}
if (baseindex == Variable.BASE_TASKMAIN.Count - 1) //判断是不是最后一个主线任务
{
task.task_state = (int)TaskStateType.TYPE_FINISHED;
tg_task.GetTaskUpdate(task.task_state, task.task_step_data, task.task_id, task.id, task.user_id);
if (!Variable.OnlinePlayer.ContainsKey(task.user_id))
{
return(Tuple.Create(false, BulidReturnData((int)ResultType.UNKNOW_ERROR, null)));
}
var session = Variable.OnlinePlayer[task.user_id] as TGGSession;
if (session == null || session.MainTask == null)
{
return(Tuple.Create(false, BulidReturnData((int)ResultType.UNKNOW_ERROR, null)));
}
session.MainTask.task_state = (int)TaskStateType.TYPE_FINISHED;
var aso = !new Share.Reward().GetReward(Variable.BASE_TASKMAIN[baseindex].reward, task.user_id, (int)ModuleNumber.TASK, (int)TaskCommand.TASK_FINISH) ?
BulidReturnData((int)ResultType.BAG_ISFULL_ERROR, null)
: BulidReturnData((int)ResultType.SUCCESS, null);
// RemoveQuene(task.user_id);
return(Tuple.Create(true, aso));
}
// RemoveQuene(task.user_id);
return(Tuple.Create(false, new ASObject()));
}
/// <summary> 推送协议 </summary>
/// <param name="session">session</param>
/// <param name="task">任务实体</param>
public void SendProtocol(TGGSession session, tg_task task)
{
var aso = new ASObject(BulidData(task));
var pv = session.InitProtocol((int)ModuleNumber.WORK, (int)WorkCommand.WORK_PUSH_UPDATE, (int)ResponseType.TYPE_SUCCESS, aso);
session.SendData(pv);
}
/// <summary> 开启新线程 </summary>
public void NewTaskStart(decimal time, tg_task newtask)
{
try
{
if (time < 0)
{
return;
}
if (Variable.RoleTask.ContainsKey(newtask.id))
{
return;
}
Variable.RoleTask.TryAdd(newtask.id, true);
var token = new CancellationTokenSource();
var task = Task.Factory.StartNew(() => SpinWait.SpinUntil(() => false, (int)time), token.Token);
task.ContinueWith(m =>
{
if (Variable.RoleTask.ContainsKey(newtask.id))
{
var a = true;
Variable.RoleTask.TryRemove(newtask.id, out a);
}
var taskcheck = tg_task.FindByid(newtask.id); //验证该任务是否还存在，如果武将已经被放逐，任务则不存在
if (taskcheck != null)
{
PUSH_TASK_END.GetInstance().CommandStart(newtask);
}
token.Cancel();
}, token.Token);
}
catch (Exception ex)
{
XTrace.WriteException(ex);
}
}
/// <summary>高级任务推送</summary>
/// <param name="user_id">玩家编号</param>
/// <param name="task">推送任务实体</param>
public void AdvancedWorkPush(Int64 user_id, tg_task task)
{
var token = new CancellationTokenSource();
Object obj = new TaskObject {
user_id = user_id, task = task
};
System.Threading.Tasks.Task.Factory.StartNew(m =>
{
var entity = m as TaskObject;
if (entity == null)
{
return;
}
if (!Variable.OnlinePlayer.ContainsKey(user_id))
{
return;
}
var session = Variable.OnlinePlayer[entity.user_id] as TGGSession;
if (session == null)
{
return;
}
var data = new ASObject(BulidData((int)ResultType.SUCCESS, entity.task));
Push(session, data, (int)WorkCommand.WORK_PUSH_UPDATE);
token.Cancel();
}, obj, token.Token);
}
private Dictionary <String, Object> BulidData(int result, tg_task newtask)
{
return(new Dictionary <string, object>
{
{ "result", result },
{ "workVo", newtask == null ? null : EntityToVo.ToVocationTaskVo(newtask) }
});
}
/// <summary> 组装数据 </summary>
private Dictionary <String, Object> BulidData(tg_task task)
{
return(new Dictionary <string, object>
{
{ "result", (int)ResultType.SUCCESS },
{ "workVo", EntityToVo.ToVocationTaskVo(task) },
});
}
/// <summary>
/// 组装数据
/// </summary>
/// <param name="result"></param>
/// <param name="task"></param>
/// <returns></returns>
private ASObject BuildData(int result, tg_task task)
{
return(new ASObject(new Dictionary <string, object>()
{
{ "result", result },
{ "workVo", task == null?null:EntityToVo.ToVocationTaskVo(task) }
}));
}
public void TaskUpdate(tg_task task, string newstep, string basestep)
{
task.task_step_data = newstep;
if (newstep == basestep)
{
task.task_state = (int)TaskStateType.TYPE_REWARD;
}
task.Update();
}
/// <summary>
/// 装换成主线任务vo
/// </summary>
/// <param name="task">tg_task实体</param>
public static TaskVo ToTaskVo(tg_task task)
{
return(new TaskVo()
{
id = Convert.ToDouble(task.id),
state = task.task_state,
stepData = task.task_step_data,
baseId = task.task_id,
});
}
/// <summary> 组装数据 </summary>
private Dictionary <String, Object> BulidReturnData(int result, tg_task newtask)
{
var dic = new Dictionary <string, object>
{
{ "result", result },
{ "mainTask", newtask == null ? null : EntityToVo.ToTaskVo(newtask) }
};
return(dic);
}
/// <summary> 任务失败 </summary>
private ASObject TaskFightLose(TGGSession session, tg_task newtask)
{
var mainid = newtask.id;
newtask = Common.GetInstance().WorkTasksInit(newtask);
newtask.id = mainid;
newtask.Update();
SendProtocol(session, newtask);
return(new ASObject(BulidData()));
}
private ASObject BuildData(tg_task task)
{
var dic = new Dictionary <string, object>()
{
{ "result", result },
{ "task", task == null ? null : EntityToVo.ToRoleVo(task) }
};
return(new ASObject(dic));
}
/// <summary>组装数据 </summary>
private ASObject BuildData(int result, Int64 time, tg_task task)
{
var dic = new Dictionary <string, object>()
{
{ "result", result },
{ "time", time },
{ "workVo", task == null?null:EntityToVo.ToVocationTaskVo(task) }
};
return(new ASObject(dic));
}
/// <summary>
/// 转换成职业任务vo
/// </summary>
/// <param name="task">tg_task实体</param>
public static VocationTaskVo ToVocationTaskVo(tg_task task)
{
return(new VocationTaskVo()
{
id = task.id,
state = task.task_state,
stepData = task.task_step_data,
baseId = task.task_id,
endTime = task.task_endtime,
});
}
public static RoleTaskVo ToRoleVo(tg_task task)
{
return(new RoleTaskVo()
{
id = task.id,
roleId = task.rid,
time = task.task_endtime,
baseId = task.task_id,
beginTime = task.task_starttime,
state = task.task_state,
});
}
/// <summary>启动任务线程</summary>
/// <param name="task">任务实体</param>
private void TaskThreadStart(tg_task task)
{
switch (task.task_step_type)
{
case (int)TaskStepType.RAISE_COIN:
{
Common.GetInstance().RaiseTaskThread(task);
(new Share.Work()).AdvancedWorkPush(task.user_id, task);
break;
}
}
}
public ASObject TASK_VOCATION_REFRESH(TGGSession session)
{
string data = "202|1_200055_1|8_15020034_3_0";
var task = new tg_task();
task.task_step_data = "202|1_200055_0|8_15020034_0_0";
task.user_id = 1;
task.task_type = 0;
var aso = TGG.Module.Task.Service.Common.getInstance().ContinueFight(session, task, data, 200055);
return(aso);
}
/// <summary>
/// 任务步骤更新验证
/// </summary>
/// <param name="task">tg_task实体</param>
/// <param name="basestep">基表任务条件</param>
/// <param name="npc">前端提交npcid</param>
/// <returns>验证后返回的数据</returns>
private ASObject FinishTaskCheck(tg_task task, string basestep, int npc)
{
var tuple = new Share.TGTask().CheckTaskStep(basestep, task.task_step_data, task.user_id, npc);
if (tuple.Item1 < 0)
{
return(new ASObject(BulidReturnData(tuple.Item1, null)));
}
Common.getInstance().TaskUpdate(task, tuple.Item2, basestep);
// RemoveQuene(task.user_id);
return(new ASObject(BulidReturnData((int)ResultType.SUCCESS, task)));
}
/// <summary>开启戒严线程</summary>
private void NewArrestStart(decimal time, tg_task mytask, string finishstep)
{
try
{
var token = new CancellationTokenSource();
var task = new System.Threading.Tasks.Task(() => SpinWait.SpinUntil(() =>
{
var taskinfo = Variable.TaskInfo.FirstOrDefault(q => q.userid == mytask.user_id);
if (taskinfo == null)
{
token.Cancel(); return(true);
}
switch (mytask.task_step_type) //根据对应类型验证是否取消线程
{
case (int)TaskStepType.ARREST_RUMOR: if (taskinfo.ArrestRumorSceneId == 0)
{
token.Cancel(); return(true);
}
break;
case (int)TaskStepType.ARREST_FIRE: if (taskinfo.ArrestFireSceneId == 0)
{
token.Cancel(); return(true);
}
break;
case (int)TaskStepType.ARREST_BREAK: if (taskinfo.ArrestBreakSceneId == 0)
{
token.Cancel(); return(true);
}
break;
case (int)TaskStepType.ARREST_SEll_WINE: if (taskinfo.ArrestSellSceneId == 0)
{
token.Cancel(); return(true);
}
break;
}
return(false);
}, (int)time * 1000), token.Token);
task.Start();
task.ContinueWith(m =>
{
TaskUpdateAndSend(mytask, finishstep);
token.Cancel();
}, token.Token);
}
catch (Exception ex)
{
XTrace.WriteException(ex);
}
}
/// <summary> 得到新的家臣任务 </summary>
private tg_task GetNewTask(tg_task task, IEnumerable <tg_task> newtasks)
{
var baseids = newtasks.Select(q => q.task_id).ToList();
var basetask = Variable.BASE_APPRAISE.Where(q => !baseids.Contains(q.id)).ToList();
if (!basetask.Any())
{
return(null);
}
var indexlist = RNG.Next(0, basetask.Count - 1);
return(indexlist >= basetask.Count ? null : new Share.TGTask().BuildNewRoleTask(basetask[indexlist].id, task.user_id));
}
