diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/Guild/XGuildDailyTaskDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/Guild/XGuildDailyTaskDocument.cs | 1200 |
1 files changed, 1200 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/Guild/XGuildDailyTaskDocument.cs b/Client/Assets/Scripts/XMainClient/Guild/XGuildDailyTaskDocument.cs new file mode 100644 index 00000000..ded1df9d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Guild/XGuildDailyTaskDocument.cs @@ -0,0 +1,1200 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XGuildDailyTaskDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XGuildDailyTaskDocument.uuID;
+ }
+ }
+
+ public static XGuildDailyTaskDocument Doc
+ {
+ get
+ {
+ return XSingleton<XGame>.singleton.Doc.GetXComponent(XGuildDailyTaskDocument.uuID) as XGuildDailyTaskDocument;
+ }
+ }
+
+ public uint TaskRoleLevel
+ {
+ get
+ {
+ return this._taskRoleLevel;
+ }
+ set
+ {
+ this._taskRoleLevel = value;
+ this.ResetRewardsMap();
+ }
+ }
+
+ public uint AskedNum
+ {
+ get
+ {
+ return this._askedNum;
+ }
+ set
+ {
+ this._askedNum = value;
+ }
+ }
+
+ public uint Count
+ {
+ get
+ {
+ return this._count;
+ }
+ set
+ {
+ this._count = value;
+ }
+ }
+
+ public bool IsRewarded
+ {
+ get
+ {
+ return this._isRewarded;
+ }
+ set
+ {
+ this._isRewarded = value;
+ }
+ }
+
+ public List<DailyTaskRefreshRoleInfo> DailyTaskRefreshRoleInfoList
+ {
+ get
+ {
+ return this._dailyTaskRefreshRoleInfoList;
+ }
+ }
+
+ public List<DailyTaskRefreshRoleInfo> AskInfoList
+ {
+ get
+ {
+ return this._askInfoList;
+ }
+ }
+
+ public List<DailyTaskRefreshInfo> DailyTaskRefreshRecordList
+ {
+ get
+ {
+ return this._dailyTaskRefreshRecordList;
+ }
+ }
+
+ public uint Refresh_num
+ {
+ get
+ {
+ return this._refresh_num;
+ }
+ }
+
+ public uint CurScore
+ {
+ get
+ {
+ return this._curScore;
+ }
+ }
+
+ public uint TodayBuyNumber
+ {
+ get
+ {
+ return this._todayBuyNum;
+ }
+ }
+
+ public uint HelpNum
+ {
+ get
+ {
+ return this._helpNum;
+ }
+ }
+
+ public uint MyLuck
+ {
+ get
+ {
+ return this._myLuck;
+ }
+ }
+
+ public bool DailyTaskHelpRefreshIcon { get; set; }
+
+ public bool DailyTaskBeenRefreshIcon { get; set; }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("GuildDailyTaskDocument");
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ private static DailyTask _dailyTaskInfoTable = new DailyTask();
+
+ public static DailyTaskReward DailyTaskRewardTable = new DailyTaskReward();
+
+ private Dictionary<uint, DailyTaskReward.RowData> _guildTaskRewardWithMap = new Dictionary<uint, DailyTaskReward.RowData>();
+
+ private List<GuildDailyTaskInfo> _curGuildDailyTaskList = new List<GuildDailyTaskInfo>();
+
+ private uint _taskRoleLevel = 1u;
+
+ private uint _askedNum = 0u;
+
+ private uint _count = 0u;
+
+ private bool _isRewarded = false;
+
+ private List<DailyTaskRefreshRoleInfo> _dailyTaskRefreshRoleInfoList = new List<DailyTaskRefreshRoleInfo>();
+
+ private uint _myLuck = 1u;
+
+ private uint _refresh_num;
+
+ private uint _todayBuyNum;
+
+ private List<DailyTaskRefreshRoleInfo> _askInfoList = new List<DailyTaskRefreshRoleInfo>();
+
+ private uint _helpNum;
+
+ private List<DailyTaskRefreshInfo> _dailyTaskRefreshRecordList = new List<DailyTaskRefreshInfo>();
+
+ private uint _curScore;
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XGuildDailyTaskDocument.AsyncLoader.AddTask("Table/DailyTask", XGuildDailyTaskDocument._dailyTaskInfoTable, false);
+ XGuildDailyTaskDocument.AsyncLoader.AddTask("Table/DailyTaskReward", XGuildDailyTaskDocument.DailyTaskRewardTable, false);
+ XGuildDailyTaskDocument.AsyncLoader.Execute(callback);
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ this.DailyTaskHelpRefreshIcon = false;
+ this.DailyTaskBeenRefreshIcon = false;
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.EventSubscribe();
+ base.RegisterEvent(XEventDefine.XEvent_TaskStateChange, new XComponent.XEventHandler(this.OnTaskStateChanged));
+ }
+
+ public override void OnDetachFromHost()
+ {
+ base.OnDetachFromHost();
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ this.InitFromServerData(arg.PlayerInfo.task_record);
+ }
+
+ public override void OnEnterSceneFinally()
+ {
+ base.OnEnterSceneFinally();
+ }
+
+ public void SendGetDailyTaskInfo()
+ {
+ RpcC2G_GetDailyTaskInfo rpc = new RpcC2G_GetDailyTaskInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetDailyTasks(GetDailyTaskInfoRes res)
+ {
+ this.UpdateTaskContent(res.task);
+ this.TaskRoleLevel = res.accept_level;
+ this.AskedNum = res.askhelp_num;
+ this.Count = res.count;
+ this.IsRewarded = res.is_rewarded;
+ this._curScore = res.score;
+ this._refresh_num = res.remain_refresh_count;
+ this._myLuck = Math.Max(1u, res.luck);
+ bool flag = DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.RefreshTaskContent();
+ }
+ }
+
+ public void GiveUpTask()
+ {
+ RpcC2G_DailyTaskGiveUp rpc = new RpcC2G_DailyTaskGiveUp();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGiveUpTask(DailyTaskGiveUpRes oRes)
+ {
+ bool flag = oRes.result == ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ bool flag2 = DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.SetVisibleWithAnimation(false, null);
+ }
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.result, "fece00");
+ }
+ }
+
+ private bool OnTaskStateChanged(XEventArgs e)
+ {
+ XTaskStatusChangeArgs xtaskStatusChangeArgs = e as XTaskStatusChangeArgs;
+ bool flag = xtaskStatusChangeArgs.status == TaskStatus.TaskStatus_Taked;
+ if (flag)
+ {
+ uint id = xtaskStatusChangeArgs.id;
+ TaskTableNew.RowData taskData = XTaskDocument.GetTaskData(id);
+ bool flag2 = taskData != null;
+ if (flag2)
+ {
+ bool flag3 = taskData.TaskType == 4u;
+ if (flag3)
+ {
+ DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.SetVisibleWithAnimation(true, null);
+ }
+ bool flag4 = taskData.TaskType == 7u;
+ if (flag4)
+ {
+ DlgBase<XGuildWeeklyBountyView, XGuildWeeklyBountyBehavior>.singleton.SetVisibleWithAnimation(true, null);
+ }
+ }
+ }
+ return true;
+ }
+
+ private void UpdateTaskContent(List<DailyTaskInfo> task)
+ {
+ this._curGuildDailyTaskList.Clear();
+ for (int i = 0; i < task.Count; i++)
+ {
+ DailyTaskInfo dailyTaskInfo = task[i];
+ this._curGuildDailyTaskList.Add(new GuildDailyTaskInfo
+ {
+ taskID = dailyTaskInfo.id,
+ step = dailyTaskInfo.step,
+ isRewarded = dailyTaskInfo.is_rewarded,
+ hasAsked = dailyTaskInfo.ask_help
+ });
+ }
+ this._curGuildDailyTaskList.Sort(new Comparison<GuildDailyTaskInfo>(this.SortDailyTask));
+ }
+
+ public DailyTaskReward.RowData GetSingleTaskRewardInfoByID(GuildTaskType type, uint taskID)
+ {
+ DailyTask.RowData dailyTaskTableInfoByID = this.GetDailyTaskTableInfoByID(taskID);
+ bool flag = dailyTaskTableInfoByID != null;
+ if (flag)
+ {
+ uint mappingValueWithQualityAndType = XGuildDailyTaskDocument.GetMappingValueWithQualityAndType(type, 1u, dailyTaskTableInfoByID.taskquality);
+ DailyTaskReward.RowData result;
+ bool flag2 = this._guildTaskRewardWithMap.TryGetValue(mappingValueWithQualityAndType, out result);
+ if (flag2)
+ {
+ return result;
+ }
+ }
+ return null;
+ }
+
+ public DailyTaskReward.RowData GetTotalTaskRewardInfo(GuildTaskType type, uint count)
+ {
+ uint mappingValueWithQualityAndType = XGuildDailyTaskDocument.GetMappingValueWithQualityAndType(type, 2u, count);
+ DailyTaskReward.RowData rowData;
+ bool flag = this._guildTaskRewardWithMap.TryGetValue(mappingValueWithQualityAndType, out rowData);
+ DailyTaskReward.RowData result;
+ if (flag)
+ {
+ result = rowData;
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public bool GoToTakeTask()
+ {
+ XTaskDocument specificDocument = XDocuments.GetSpecificDocument<XTaskDocument>(XTaskDocument.uuID);
+ XTaskRecord taskRecord = specificDocument.TaskRecord;
+ for (int i = 0; i < taskRecord.Tasks.Count; i++)
+ {
+ bool flag = taskRecord.Tasks[i].Status == TaskStatus.TaskStatus_CanTake && taskRecord.Tasks[i].TableData.TaskType == 4u;
+ if (flag)
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public int GetRewardedTaskCount()
+ {
+ int num = 0;
+ for (int i = 0; i < this._curGuildDailyTaskList.Count; i++)
+ {
+ bool isRewarded = this._curGuildDailyTaskList[i].isRewarded;
+ if (isRewarded)
+ {
+ num++;
+ }
+ }
+ return num;
+ }
+
+ internal GuildDailyTaskInfo GetTaskInfoByIndex(int index)
+ {
+ bool flag = index < this._curGuildDailyTaskList.Count;
+ GuildDailyTaskInfo result;
+ if (flag)
+ {
+ result = this._curGuildDailyTaskList[index];
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public int GetTaskItemCount()
+ {
+ return this._curGuildDailyTaskList.Count;
+ }
+
+ public void SendToGetMyTaskReward(uint type, uint id)
+ {
+ RpcC2G_GetDailyTaskReward rpcC2G_GetDailyTaskReward = new RpcC2G_GetDailyTaskReward();
+ rpcC2G_GetDailyTaskReward.oArg.type = type;
+ rpcC2G_GetDailyTaskReward.oArg.id = id;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_GetDailyTaskReward);
+ }
+
+ public void OnGetDailyTaskReward(GetDailyTaskRewardArg oArg, GetDailyTaskRewardRes oRes)
+ {
+ bool flag = oRes.code == ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XLevelSealDocument specificDocument = XDocuments.GetSpecificDocument<XLevelSealDocument>(XLevelSealDocument.uuID);
+ int rewardedTaskCount = XGuildDailyTaskDocument.Doc.GetRewardedTaskCount();
+ bool flag2 = rewardedTaskCount >= XSingleton<XGlobalConfig>.singleton.GetInt("DailyTaskMinTotalTaskCount") && oArg.type == 2u;
+ if (flag2)
+ {
+ DailyTaskReward.RowData totalTaskRewardInfo = this.GetTotalTaskRewardInfo(GuildTaskType.DailyTask, (uint)rewardedTaskCount);
+ bool flag3 = totalTaskRewardInfo == null;
+ if (flag3)
+ {
+ return;
+ }
+ List<ItemBrief> list = new List<ItemBrief>();
+ SeqListRef<uint>? rewadsByScore = this.GetRewadsByScore(totalTaskRewardInfo, this._curScore);
+ bool flag4 = rewadsByScore != null;
+ if (flag4)
+ {
+ for (int i = 0; i < (int)rewadsByScore.Value.count; i++)
+ {
+ ItemBrief itemBrief = new ItemBrief();
+ itemBrief.itemID = rewadsByScore.Value[i, 0];
+ int num = (int)rewadsByScore.Value[i, 1];
+ bool flag5 = itemBrief.itemID == 4u && specificDocument.IsInLevelSeal();
+ if (flag5)
+ {
+ num = (int)((double)num * 0.5);
+ }
+ itemBrief.itemCount = (uint)num;
+ list.Add(itemBrief);
+ }
+ }
+ bool flag6 = rewardedTaskCount >= this.GetTaskItemCount();
+ if (flag6)
+ {
+ List<GuildTaskReward> additionalRewards = this.GetAdditionalRewards();
+ foreach (GuildTaskReward guildTaskReward in additionalRewards)
+ {
+ ItemBrief itemBrief2 = new ItemBrief();
+ itemBrief2.itemID = guildTaskReward.itemID;
+ uint num2 = guildTaskReward.count;
+ bool flag7 = guildTaskReward.itemID == 4u && specificDocument.IsInLevelSeal();
+ if (flag7)
+ {
+ num2 = (uint)(num2 * 0.5);
+ }
+ itemBrief2.itemCount = num2;
+ list.Add(itemBrief2);
+ }
+ }
+ DlgBase<RewdAnimDlg, RewdAnimBehaviour>.singleton.ShowByTitle(list, XSingleton<XStringTable>.singleton.GetString("DailyTaskRewards"), null);
+ }
+ this.UpdateTaskContent(oRes.task);
+ bool flag8 = oArg.type == 1u;
+ if (flag8)
+ {
+ bool flag9 = DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.IsVisible();
+ if (flag9)
+ {
+ DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.RefreshTaskItemByID(oArg.id);
+ }
+ }
+ else
+ {
+ bool flag10 = oArg.type == 2u;
+ if (flag10)
+ {
+ bool flag11 = DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.IsVisible();
+ if (flag11)
+ {
+ DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.SetVisibleWithAnimation(false, null);
+ }
+ }
+ }
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.code, "fece00");
+ }
+ }
+
+ public GuildDailyTaskInfo GetTaskInfoByID(uint id)
+ {
+ for (int i = 0; i < this._curGuildDailyTaskList.Count; i++)
+ {
+ bool flag = this._curGuildDailyTaskList[i].taskID == id;
+ if (flag)
+ {
+ return this._curGuildDailyTaskList[i];
+ }
+ }
+ return null;
+ }
+
+ public DailyTask.RowData GetDailyTaskTableInfoByID(uint taskID)
+ {
+ for (int i = 0; i < XGuildDailyTaskDocument._dailyTaskInfoTable.Table.Length; i++)
+ {
+ DailyTask.RowData rowData = XGuildDailyTaskDocument._dailyTaskInfoTable.Table[i];
+ bool flag = rowData.taskID == taskID;
+ if (flag)
+ {
+ return rowData;
+ }
+ }
+ return null;
+ }
+
+ public List<GuildTaskReward> GetAdditionalRewards()
+ {
+ for (int i = 0; i < XGuildDailyTaskDocument.DailyTaskRewardTable.Table.Length; i++)
+ {
+ DailyTaskReward.RowData rowData = XGuildDailyTaskDocument.DailyTaskRewardTable.Table[i];
+ uint num = rowData.level[0];
+ uint num2 = rowData.level[1];
+ SeqListRef<uint>? extraRewadsByScore = this.GetExtraRewadsByScore(rowData, this._curScore);
+ bool flag = this._taskRoleLevel >= num && this._taskRoleLevel <= num2 && extraRewadsByScore != null && extraRewadsByScore.Value.count > 0;
+ if (flag)
+ {
+ List<GuildTaskReward> list = new List<GuildTaskReward>();
+ for (int j = 0; j < extraRewadsByScore.Value.Count; j++)
+ {
+ list.Add(new GuildTaskReward
+ {
+ itemID = extraRewadsByScore.Value[j, 0],
+ count = extraRewadsByScore.Value[j, 1]
+ });
+ }
+ return list;
+ }
+ }
+ return null;
+ }
+
+ public static uint GetMappingValueWithQualityAndType(GuildTaskType category, uint type, uint quality)
+ {
+ return (uint)(10000 * (int)category + (int)(1000u * type) + (int)quality);
+ }
+
+ public SeqListRef<uint>? GetRewadsByScore(DailyTaskReward.RowData data, uint score)
+ {
+ SeqListRef<uint>? result;
+ switch (score)
+ {
+ case 0u:
+ result = new SeqListRef<uint>?(data.reward_d);
+ break;
+ case 1u:
+ result = new SeqListRef<uint>?(data.reward_c);
+ break;
+ case 2u:
+ result = new SeqListRef<uint>?(data.reward_b);
+ break;
+ case 3u:
+ result = new SeqListRef<uint>?(data.reward_a);
+ break;
+ case 4u:
+ result = new SeqListRef<uint>?(data.reward_s);
+ break;
+ default:
+ result = null;
+ break;
+ }
+ return result;
+ }
+
+ public SeqListRef<uint>? GetExtraRewadsByScore(DailyTaskReward.RowData data, uint score)
+ {
+ SeqListRef<uint>? result;
+ switch (score)
+ {
+ case 0u:
+ result = new SeqListRef<uint>?(data.extrareward_d);
+ break;
+ case 1u:
+ result = new SeqListRef<uint>?(data.extrareward_c);
+ break;
+ case 2u:
+ result = new SeqListRef<uint>?(data.extrareward_b);
+ break;
+ case 3u:
+ result = new SeqListRef<uint>?(data.extrareward_a);
+ break;
+ case 4u:
+ result = new SeqListRef<uint>?(data.extrareward_s);
+ break;
+ default:
+ result = null;
+ break;
+ }
+ return result;
+ }
+
+ private int SortDailyTask(GuildDailyTaskInfo x, GuildDailyTaskInfo y)
+ {
+ bool flag = x.isRewarded ^ y.isRewarded;
+ int result;
+ if (flag)
+ {
+ result = (x.isRewarded ? 1 : -1);
+ }
+ else
+ {
+ DailyTask.RowData dailyTaskTableInfoByID = this.GetDailyTaskTableInfoByID(x.taskID);
+ DailyTask.RowData dailyTaskTableInfoByID2 = this.GetDailyTaskTableInfoByID(y.taskID);
+ bool flag2 = dailyTaskTableInfoByID == null || dailyTaskTableInfoByID2 == null;
+ if (flag2)
+ {
+ result = 0;
+ }
+ else
+ {
+ bool flag3 = dailyTaskTableInfoByID.taskquality != dailyTaskTableInfoByID2.taskquality;
+ if (flag3)
+ {
+ result = (int)(dailyTaskTableInfoByID2.taskquality - dailyTaskTableInfoByID.taskquality);
+ }
+ else
+ {
+ result = (int)(dailyTaskTableInfoByID.taskID - dailyTaskTableInfoByID2.taskID);
+ }
+ }
+ }
+ return result;
+ }
+
+ private void ResetRewardsMap()
+ {
+ this._guildTaskRewardWithMap.Clear();
+ for (int i = 0; i < XGuildDailyTaskDocument.DailyTaskRewardTable.Table.Length; i++)
+ {
+ DailyTaskReward.RowData rowData = XGuildDailyTaskDocument.DailyTaskRewardTable.Table[i];
+ uint num = rowData.level[0];
+ uint num2 = rowData.level[1];
+ bool flag = this._taskRoleLevel >= num && this._taskRoleLevel <= num2;
+ if (flag)
+ {
+ uint mappingValueWithQualityAndType = XGuildDailyTaskDocument.GetMappingValueWithQualityAndType((GuildTaskType)rowData.category, rowData.tasktype, rowData.taskquality);
+ bool flag2 = !this._guildTaskRewardWithMap.ContainsKey(mappingValueWithQualityAndType);
+ if (flag2)
+ {
+ this._guildTaskRewardWithMap.Add(mappingValueWithQualityAndType, rowData);
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog(string.Concat(new object[]
+ {
+ "Same taskType and quality",
+ this._taskRoleLevel,
+ " type",
+ rowData.tasktype,
+ " quality",
+ rowData.taskquality,
+ " index",
+ i
+ }), null, null, null, null, null);
+ }
+ }
+ }
+ }
+
+ public void SendDailyTaskAskHelp(PeriodTaskType type, uint taskID)
+ {
+ RpcC2G_DailyTaskAskHelp rpcC2G_DailyTaskAskHelp = new RpcC2G_DailyTaskAskHelp();
+ rpcC2G_DailyTaskAskHelp.oArg.task_id = taskID;
+ rpcC2G_DailyTaskAskHelp.oArg.task_type = type;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_DailyTaskAskHelp);
+ }
+
+ public void OnGetDailyHelpReply(DailyTaskAskHelpArg oArg, DailyTaskAskHelpRes oRes)
+ {
+ bool flag = oRes.code == ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("ReqHelpSuccess"), "fece00");
+ DailyTask.RowData dailyTaskTableInfoByID = this.GetDailyTaskTableInfoByID(oArg.task_id);
+ this.SendGuildDonateReq(dailyTaskTableInfoByID.conditionNum, dailyTaskTableInfoByID.conditionId[0], oRes.ask_uid, NoticeType.NT_GUILD_Daily_DONATE_REQ);
+ GuildDailyTaskInfo taskInfoByID = this.GetTaskInfoByID(oArg.task_id);
+ bool flag2 = taskInfoByID != null;
+ if (flag2)
+ {
+ taskInfoByID.hasAsked = true;
+ uint askedNum = this.AskedNum;
+ this.AskedNum = askedNum + 1u;
+ bool flag3 = DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.IsVisible();
+ if (flag3)
+ {
+ DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.RefreshTaskItemByID(oArg.task_id);
+ }
+ }
+ }
+ }
+
+ public void SendToRefreshTasks()
+ {
+ RpcC2M_GetDailyTaskRefreshInfo rpc = new RpcC2M_GetDailyTaskRefreshInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetTaskRefreshInfo(GetDailyTaskRefreshInfoRes oRes)
+ {
+ this._dailyTaskRefreshRoleInfoList = oRes.friendinfo;
+ this._myLuck = Math.Max(1u, oRes.luck);
+ this._refresh_num = oRes.refresh_num;
+ this._todayBuyNum = oRes.today_buy_num;
+ this._dailyTaskRefreshRoleInfoList.Sort(new Comparison<DailyTaskRefreshRoleInfo>(this.SortTaskRefreshInfo));
+ this._dailyTaskRefreshRoleInfoList.Insert(0, new DailyTaskRefreshRoleInfo
+ {
+ luck = this._myLuck,
+ refresh_num = this._refresh_num,
+ roleid = XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID,
+ profession = XSingleton<XAttributeMgr>.singleton.XPlayerData.Profession,
+ already_ask = (this._refresh_num <= 0u),
+ name = XSingleton<XAttributeMgr>.singleton.XPlayerData.Name
+ });
+ bool flag = DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.RefreshContent();
+ }
+ }
+
+ private int SortTaskRefreshInfo(DailyTaskRefreshRoleInfo x, DailyTaskRefreshRoleInfo y)
+ {
+ bool flag = x.luck != y.luck;
+ int result;
+ if (flag)
+ {
+ result = (int)(y.luck - x.luck);
+ }
+ else
+ {
+ bool flag2 = x.time != y.time;
+ if (flag2)
+ {
+ result = (int)(y.time - x.time);
+ }
+ else
+ {
+ int friendDegreeAll = (int)DlgBase<XFriendsView, XFriendsBehaviour>.singleton.GetFriendDegreeAll(x.roleid);
+ int friendDegreeAll2 = (int)DlgBase<XFriendsView, XFriendsBehaviour>.singleton.GetFriendDegreeAll(y.roleid);
+ result = friendDegreeAll2 - friendDegreeAll;
+ }
+ }
+ return result;
+ }
+
+ public void SendToGetAskRefreshTaskInfo()
+ {
+ RpcC2M_GetDailyTaskAskHelp rpc = new RpcC2M_GetDailyTaskAskHelp();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetTaskHelpInfo(GetDailyTaskAskHelpRes oRes)
+ {
+ this._askInfoList = oRes.askinfos;
+ bool flag = this._askInfoList.Count == 0;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("DailyTaskRefreshOutdate"), "fece00");
+ }
+ this._helpNum = oRes.help_num;
+ this._myLuck = Math.Max(1u, oRes.luck);
+ this.RefreshRequestSysIcon();
+ bool flag2 = DlgBase<XGuildDailyHandleRefreshDlg, XGuildDailyHandleRefreshBehavior>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XGuildDailyHandleRefreshDlg, XGuildDailyHandleRefreshBehavior>.singleton.RefreshContent();
+ }
+ }
+
+ public void SendToGetRefreshLogInfo()
+ {
+ RpcC2M_GetDailyTaskRefreshRecord rpc = new RpcC2M_GetDailyTaskRefreshRecord();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetRefreshRecordInfo(GetDailyTaskRefreshRecordRes oRes)
+ {
+ this._dailyTaskRefreshRecordList = oRes.records;
+ this._dailyTaskRefreshRecordList.Reverse();
+ bool flag = DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.IsVisible();
+ if (flag)
+ {
+ bool flag2 = false;
+ for (int i = 0; i < this._dailyTaskRefreshRecordList.Count; i++)
+ {
+ bool isnew = this._dailyTaskRefreshRecordList[i].isnew;
+ if (isnew)
+ {
+ flag2 = true;
+ break;
+ }
+ }
+ bool flag3 = flag2;
+ if (flag3)
+ {
+ DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.RefreshLogContent();
+ }
+ }
+ }
+
+ public void SendToRefreshTaskOp(DailyRefreshOperType type, ulong roleID)
+ {
+ RpcC2M_DailyTaskRefreshOper rpcC2M_DailyTaskRefreshOper = new RpcC2M_DailyTaskRefreshOper();
+ rpcC2M_DailyTaskRefreshOper.oArg.type = type;
+ rpcC2M_DailyTaskRefreshOper.oArg.roleid = roleID;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_DailyTaskRefreshOper);
+ }
+
+ public void OnGetTaskRefreshOperResult(DailyTaskRefreshOperArg oArg, DailyTaskRefreshOperRes oRes)
+ {
+ bool flag = oRes.result == ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ switch (oArg.type)
+ {
+ case DailyRefreshOperType.DROT_Refresh:
+ {
+ bool flag2 = this._refresh_num > 0u;
+ if (flag2)
+ {
+ this._refresh_num -= 1u;
+ }
+ for (int i = 0; i < this._askInfoList.Count; i++)
+ {
+ bool flag3 = this._askInfoList[i].roleid == oArg.roleid;
+ if (flag3)
+ {
+ this._askInfoList[i].refresh_num -= 1u;
+ this._askInfoList[i].score = oRes.score;
+ List<int> intList = XSingleton<XGlobalConfig>.singleton.GetIntList("DailyGuildRefreshNotifyLevel");
+ bool flag4 = intList.Contains((int)oRes.score);
+ if (flag4)
+ {
+ this.SendNotifyToGuildChannel(this._askInfoList[i], (int)oRes.score);
+ }
+ bool flag5 = this._askInfoList[i].refresh_num <= 0u || oRes.score == 4u;
+ if (flag5)
+ {
+ this._askInfoList.RemoveAt(i);
+ }
+ break;
+ }
+ }
+ bool flag6 = oArg.roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag6)
+ {
+ this._curScore = oRes.score;
+ bool flag7 = DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.IsVisible();
+ if (flag7)
+ {
+ bool flag8 = this._dailyTaskRefreshRoleInfoList.Count > 0 && this._dailyTaskRefreshRoleInfoList[0].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag8)
+ {
+ this._dailyTaskRefreshRoleInfoList[0].refresh_num = this._refresh_num;
+ this._dailyTaskRefreshRoleInfoList[0].already_ask = (this._dailyTaskRefreshRoleInfoList[0].refresh_num <= 0u);
+ }
+ DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.RefreshContent();
+ }
+ }
+ else
+ {
+ this._helpNum -= 1u;
+ }
+ bool flag9 = DlgBase<XGuildDailyHandleRefreshDlg, XGuildDailyHandleRefreshBehavior>.singleton.IsVisible();
+ if (flag9)
+ {
+ DlgBase<XGuildDailyHandleRefreshDlg, XGuildDailyHandleRefreshBehavior>.singleton.RefreshContent();
+ }
+ DlgBase<XGuildTaskRefreshResultDlg, XGuildTaskRefreshResultDlgBehavior>.singleton.AfterScore = oRes.score;
+ DlgBase<XGuildTaskRefreshResultDlg, XGuildTaskRefreshResultDlgBehavior>.singleton.BeforeScore = oRes.oldscore;
+ DlgBase<XGuildTaskRefreshResultDlg, XGuildTaskRefreshResultDlgBehavior>.singleton.SetVisibleWithAnimation(true, null);
+ XGuildMemberDocument specificDocument = XDocuments.GetSpecificDocument<XGuildMemberDocument>(XGuildMemberDocument.uuID);
+ specificDocument.RefreshMemberTaskScore(oArg.roleid, oRes.score);
+ bool flag10 = DlgBase<XGuildMembersView, XGuildMembersBehaviour>.singleton.IsVisible();
+ if (flag10)
+ {
+ DlgBase<XGuildMembersView, XGuildMembersBehaviour>.singleton.OnRefreshDailyTaskReply();
+ }
+ break;
+ }
+ case DailyRefreshOperType.DROT_Refuse:
+ {
+ for (int j = 0; j < this._askInfoList.Count; j++)
+ {
+ bool flag11 = this._askInfoList[j].roleid == oArg.roleid;
+ if (flag11)
+ {
+ this._askInfoList.RemoveAt(j);
+ break;
+ }
+ }
+ bool flag12 = this._askInfoList.Count == 0;
+ if (flag12)
+ {
+ this.DailyTaskHelpRefreshIcon = false;
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_GuildDailyRequest, true);
+ }
+ bool flag13 = DlgBase<XGuildDailyHandleRefreshDlg, XGuildDailyHandleRefreshBehavior>.singleton.IsVisible();
+ if (flag13)
+ {
+ DlgBase<XGuildDailyHandleRefreshDlg, XGuildDailyHandleRefreshBehavior>.singleton.RefreshContent();
+ }
+ break;
+ }
+ case DailyRefreshOperType.DROT_BuyCount:
+ {
+ this._refresh_num += 1u;
+ this._todayBuyNum += 1u;
+ bool flag14 = this._dailyTaskRefreshRoleInfoList.Count > 0 && this._dailyTaskRefreshRoleInfoList[0].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag14)
+ {
+ this._dailyTaskRefreshRoleInfoList[0].refresh_num = this._refresh_num;
+ this._dailyTaskRefreshRoleInfoList[0].already_ask = (this._dailyTaskRefreshRoleInfoList[0].refresh_num <= 0u);
+ }
+ bool flag15 = DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.IsVisible();
+ if (flag15)
+ {
+ DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.RefreshContent();
+ }
+ break;
+ }
+ case DailyRefreshOperType.DROT_AskHelp:
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("DailyAskForHelpSuccess"), "fece00");
+ for (int k = 0; k < this._dailyTaskRefreshRoleInfoList.Count; k++)
+ {
+ bool flag16 = this._dailyTaskRefreshRoleInfoList[k].roleid == oArg.roleid;
+ if (flag16)
+ {
+ this._dailyTaskRefreshRoleInfoList[k].already_ask = true;
+ break;
+ }
+ }
+ bool flag17 = DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.IsVisible();
+ if (flag17)
+ {
+ DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.RefreshContent();
+ }
+ break;
+ }
+ }
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.result, "fece00");
+ bool flag18 = oArg.roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID && oArg.type == DailyRefreshOperType.DROT_Refresh && oRes.result == ErrorCode.ERR_DAILY_TASK_NO_REFRESH_COUNT;
+ if (flag18)
+ {
+ this._refresh_num = 0u;
+ bool flag19 = DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.IsVisible();
+ if (flag19)
+ {
+ bool flag20 = this._dailyTaskRefreshRoleInfoList.Count > 0 && this._dailyTaskRefreshRoleInfoList[0].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag20)
+ {
+ this._dailyTaskRefreshRoleInfoList[0].refresh_num = this._refresh_num;
+ this._dailyTaskRefreshRoleInfoList[0].already_ask = (this._dailyTaskRefreshRoleInfoList[0].refresh_num <= 0u);
+ }
+ DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.RefreshContent();
+ }
+ }
+ bool flag21 = oArg.type == DailyRefreshOperType.DROT_Refuse || oArg.type == DailyRefreshOperType.DROT_Refresh;
+ if (flag21)
+ {
+ for (int l = 0; l < this._askInfoList.Count; l++)
+ {
+ bool flag22 = this._askInfoList[l].roleid == oArg.roleid;
+ if (flag22)
+ {
+ this._askInfoList.RemoveAt(l);
+ break;
+ }
+ }
+ }
+ this.RefreshRequestSysIcon();
+ bool flag23 = DlgBase<XGuildDailyHandleRefreshDlg, XGuildDailyHandleRefreshBehavior>.singleton.IsVisible();
+ if (flag23)
+ {
+ DlgBase<XGuildDailyHandleRefreshDlg, XGuildDailyHandleRefreshBehavior>.singleton.RefreshContent();
+ }
+ }
+ }
+
+ private void SendNotifyToGuildChannel(DailyTaskRefreshRoleInfo dailyTaskRefreshRoleInfo, int level)
+ {
+ XGuildDocument specificDocument = XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID);
+ bool flag = !specificDocument.CheckInGuild();
+ if (!flag)
+ {
+ XInvitationDocument specificDocument2 = XDocuments.GetSpecificDocument<XInvitationDocument>(XInvitationDocument.uuID);
+ NoticeTable.RowData noticeData = specificDocument2.GetNoticeData(NoticeType.NT_GUILD_Daily_Refresh_Thanks_REQ);
+ bool flag2 = noticeData == null;
+ if (!flag2)
+ {
+ string itemQualityName = XSingleton<UiUtility>.singleton.GetItemQualityName(level);
+ List<string> stringList = XSingleton<XGlobalConfig>.singleton.GetStringList("LuckyLevel");
+ int index = Math.Min((int)(this._myLuck - 1u), stringList.Count - 1);
+ List<ChatParam> list = new List<ChatParam>();
+ ChatParam chatParam = new ChatParam();
+ chatParam.link = new ChatParamLink();
+ chatParam.link.id = noticeData.linkparam;
+ chatParam.link.content = noticeData.linkcontent;
+ ChatParam chatParam2 = new ChatParam();
+ chatParam2.role = new ChatParamRole();
+ chatParam2.role.uniqueid = XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ chatParam2.role.name = XSingleton<XAttributeMgr>.singleton.XPlayerData.Name;
+ chatParam2.role.profession = XSingleton<XAttributeMgr>.singleton.XPlayerData.TypeID;
+ ChatParam chatParam3 = new ChatParam();
+ chatParam3.role = new ChatParamRole();
+ chatParam3.role.uniqueid = dailyTaskRefreshRoleInfo.roleid;
+ chatParam3.role.name = dailyTaskRefreshRoleInfo.name;
+ chatParam3.role.profession = (uint)dailyTaskRefreshRoleInfo.profession;
+ list.Add(chatParam2);
+ list.Add(chatParam3);
+ list.Add(chatParam);
+ DlgBase<XChatView, XChatBehaviour>.singleton.SendChatContent(string.Format(noticeData.info, stringList[index], itemQualityName), (ChatChannelType)noticeData.channel, true, list, true, 0UL, 0f, false, false);
+ }
+ }
+ }
+
+ public void OnGetDailyTaskEvent(PtcM2C_DailyTaskEventNtf roPtc)
+ {
+ bool flag = roPtc.Data.type == DailyTaskIconType.DailyTaskIcon_AskHelp;
+ if (flag)
+ {
+ this.DailyTaskHelpRefreshIcon = true;
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_GuildDailyRequest, true);
+ }
+ else
+ {
+ bool flag2 = roPtc.Data.type == DailyTaskIconType.DailyTaskIcon_BeHelp;
+ if (flag2)
+ {
+ this.DailyTaskBeenRefreshIcon = true;
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_GuildDailyTask, true);
+ }
+ else
+ {
+ bool flag3 = roPtc.Data.type == DailyTaskIconType.DailyTaskIcon_AskHelpDispear;
+ if (flag3)
+ {
+ this.DailyTaskHelpRefreshIcon = false;
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_GuildDailyRequest, true);
+ }
+ }
+ }
+ }
+
+ public DailyTaskRefreshRoleInfo GetTaskAskInfoByIndex(int index)
+ {
+ bool flag = index < this._askInfoList.Count;
+ DailyTaskRefreshRoleInfo result;
+ if (flag)
+ {
+ result = this._askInfoList[index];
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public DailyTaskRefreshRoleInfo GetRefreshTaskItemInfo(int index)
+ {
+ bool flag = index < this._dailyTaskRefreshRoleInfoList.Count;
+ DailyTaskRefreshRoleInfo result;
+ if (flag)
+ {
+ result = this._dailyTaskRefreshRoleInfoList[index];
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public DailyTaskRefreshInfo GetRefreshTaskLogInfo(int index)
+ {
+ bool flag = index < this._dailyTaskRefreshRecordList.Count;
+ DailyTaskRefreshInfo result;
+ if (flag)
+ {
+ result = this._dailyTaskRefreshRecordList[index];
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public DailyTaskRefreshInfo GetRefreshTaskLogInfoByRoleID(ulong roleID)
+ {
+ for (int i = 0; i < this._dailyTaskRefreshRecordList.Count; i++)
+ {
+ bool flag = this._dailyTaskRefreshRecordList[i].roleid == roleID;
+ if (flag)
+ {
+ return this._dailyTaskRefreshRecordList[i];
+ }
+ }
+ return null;
+ }
+
+ public void SendGuildDonateReq(uint number, uint itemID, uint reqID, NoticeType type = NoticeType.NT_GUILD_Daily_DONATE_REQ)
+ {
+ XGuildDocument specificDocument = XDocuments.GetSpecificDocument<XGuildDocument>(XGuildDocument.uuID);
+ bool flag = !specificDocument.CheckInGuild();
+ if (!flag)
+ {
+ XInvitationDocument specificDocument2 = XDocuments.GetSpecificDocument<XInvitationDocument>(XInvitationDocument.uuID);
+ NoticeTable.RowData noticeData = specificDocument2.GetNoticeData(type);
+ bool flag2 = noticeData == null;
+ if (!flag2)
+ {
+ List<ChatParam> list = new List<ChatParam>();
+ ChatParam chatParam = new ChatParam();
+ chatParam.link = new ChatParamLink();
+ chatParam.link.id = noticeData.linkparam;
+ chatParam.link.param.Add((ulong)reqID);
+ chatParam.link.content = noticeData.linkcontent;
+ ChatParam chatParam2 = new ChatParam();
+ chatParam2.role = new ChatParamRole();
+ chatParam2.role.uniqueid = XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ chatParam2.role.name = XSingleton<XAttributeMgr>.singleton.XPlayerData.Name;
+ chatParam2.role.profession = XSingleton<XAttributeMgr>.singleton.XPlayerData.TypeID;
+ ChatParam chatParam3 = new ChatParam();
+ chatParam3.item = new ChatParamItem();
+ chatParam3.item.item = new ItemBrief();
+ chatParam3.item.item.itemCount = number;
+ chatParam3.item.item.itemID = itemID;
+ list.Add(chatParam2);
+ list.Add(chatParam3);
+ list.Add(chatParam);
+ DlgBase<XChatView, XChatBehaviour>.singleton.SendChatContent(noticeData.info, (ChatChannelType)noticeData.channel, true, list, true, 0UL, 0f, false, false);
+ }
+ }
+ }
+
+ public void InitFromServerData(RoleTask roleTask)
+ {
+ bool flag = roleTask.dailytask.Count == 0;
+ if (flag)
+ {
+ XSingleton<XGameSysMgr>.singleton.SetSysRedPointState(XSysDefine.XSys_GuildDailyTask, false);
+ }
+ else
+ {
+ XSingleton<XGameSysMgr>.singleton.SetSysRedPointState(XSysDefine.XSys_GuildDailyTask, roleTask.daily_red_point);
+ }
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_GuildDailyTask, true);
+ XGuildDonateDocument.Doc.DailyDonatedNum = roleTask.today_donate_count;
+ }
+
+ public void ClearRequesetItems()
+ {
+ this._askInfoList.Clear();
+ bool flag = DlgBase<XGuildDailyHandleRefreshDlg, XGuildDailyHandleRefreshBehavior>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XGuildDailyHandleRefreshDlg, XGuildDailyHandleRefreshBehavior>.singleton.RefreshContent();
+ }
+ this.RefreshRequestSysIcon();
+ }
+
+ public void OnTaskRefreshNtf(PtcM2C_TaskRefreshNtf roPtc)
+ {
+ this._curScore = roPtc.Data.score;
+ this._refresh_num = roPtc.Data.remain_refresh_count;
+ bool flag = DlgBase<XGuildDailyTaskView, XGuildDailyTaskBehavior>.singleton.IsVisible();
+ if (flag)
+ {
+ this.SendGetDailyTaskInfo();
+ }
+ bool flag2 = DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.IsVisible();
+ if (flag2)
+ {
+ bool flag3 = this._dailyTaskRefreshRoleInfoList.Count > 0 && this._dailyTaskRefreshRoleInfoList[0].roleid == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag3)
+ {
+ this._dailyTaskRefreshRoleInfoList[0].refresh_num = this._refresh_num;
+ this._dailyTaskRefreshRoleInfoList[0].already_ask = (this._dailyTaskRefreshRoleInfoList[0].refresh_num <= 0u);
+ }
+ DlgBase<XGuildDailyRefreshTaskDlg, XGuildDailyRefreshTaskBehavior>.singleton.RefreshContent();
+ }
+ }
+
+ private void RefreshRequestSysIcon()
+ {
+ bool flag = this._askInfoList.Count == 0;
+ if (flag)
+ {
+ this.DailyTaskHelpRefreshIcon = false;
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_GuildDailyRequest, true);
+ }
+ }
+ }
+}
|