diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XMentorshipDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XMentorshipDocument.cs | 1742 |
1 files changed, 1742 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XMentorshipDocument.cs b/Client/Assets/Scripts/XMainClient/XMentorshipDocument.cs new file mode 100644 index 00000000..1eacfc2d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XMentorshipDocument.cs @@ -0,0 +1,1742 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using UILib;
+using UnityEngine;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XMentorshipDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XMentorshipDocument.uuID;
+ }
+ }
+
+ public static XMentorshipDocument Doc
+ {
+ get
+ {
+ return XSingleton<XGame>.singleton.Doc.GetXComponent(XMentorshipDocument.uuID) as XMentorshipDocument;
+ }
+ }
+
+ public bool HasRedPointOnTasks
+ {
+ get
+ {
+ return this._hasRedPointOnTasks;
+ }
+ set
+ {
+ this._hasRedPointOnTasks = value;
+ this._gettedData = false;
+ DlgBase<XFriendsView, XFriendsBehaviour>.singleton.SetRedPoint(TabIndex.Mentorship, this.IsHasRedDot());
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_Friends, true);
+ }
+ }
+
+ public bool LeaveFootprint { get; set; }
+
+ public string MentorshipApplyWords
+ {
+ get
+ {
+ return this._mentorshipApplyWords;
+ }
+ set
+ {
+ this._mentorshipApplyWords = value;
+ }
+ }
+
+ public bool TipIconHasRedPoint
+ {
+ get
+ {
+ return this._tipIconHasRedPoint;
+ }
+ }
+
+ public bool HasApplyMsg
+ {
+ get
+ {
+ return this._hasApplyMsg;
+ }
+ }
+
+ public static MentorCompleteRewardTable MentorCompleteReward
+ {
+ get
+ {
+ return XMentorshipDocument._mentorCompleteReward;
+ }
+ set
+ {
+ XMentorshipDocument._mentorCompleteReward = value;
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("MentorshipDocument");
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ private static MentorCompleteRewardTable _mentorCompleteReward = new MentorCompleteRewardTable();
+
+ private static MentorTaskTable _mentorTaskTable = new MentorTaskTable();
+
+ public readonly int MaxRelationCount = 2;
+
+ private bool _gettedData = false;
+
+ private MyMentorship _myMentorship = MyMentorship.None;
+
+ private List<MentorRelationInfo> _relationList = new List<MentorRelationInfo>();
+
+ private List<MentorshipTaskInfo> _myMentorshipTaskList = new List<MentorshipTaskInfo>();
+
+ private PupilApplyInfo _pupilApplyInfo = new PupilApplyInfo();
+
+ private List<MasterApplyInfoItem> _masterApplyInfoList = new List<MasterApplyInfoItem>();
+
+ private List<MentorBeenApplyedInfo> _beenApplyedInfoList = new List<MentorBeenApplyedInfo>();
+
+ private MessageShowInfoItem _tempShowInfo = new MessageShowInfoItem();
+
+ public CandidatesViewType CurViewType = CandidatesViewType.None;
+
+ public CandidatesViewRecommendType CurRecommendType = CandidatesViewRecommendType.None;
+
+ private string _mentorshipApplyWords = string.Empty;
+
+ public int ReceiveingProtocolTime = 0;
+
+ public ulong ClickedMainSceneRoleID = 0UL;
+
+ public MentorApplyStatus ClickedRoleMentorshipStatus;
+
+ private bool _hasRedPointOnTasks = false;
+
+ private bool _tipIconHasRedPoint;
+
+ private bool _hasApplyMsg;
+
+ private int timeForReceive;
+
+ private int _myApplyPupilRefreshTime = 0;
+
+ private int _myApplyMasterRefreshTime = 0;
+
+ private uint _countDownTimerID = 0u;
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XMentorshipDocument.AsyncLoader.AddTask("Table/MentorCompleteReward", XMentorshipDocument._mentorCompleteReward, false);
+ XMentorshipDocument.AsyncLoader.AddTask("Table/MentorTask", XMentorshipDocument._mentorTaskTable, false);
+ XMentorshipDocument.AsyncLoader.Execute(callback);
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ this._gettedData = false;
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.EventSubscribe();
+ }
+
+ public override void OnDetachFromHost()
+ {
+ base.OnDetachFromHost();
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ }
+
+ public override void OnEnterSceneFinally()
+ {
+ base.OnEnterSceneFinally();
+ }
+
+ public MentorTaskTable.RowData GetTableTaskInfoByTaskID(uint taskID)
+ {
+ return XMentorshipDocument._mentorTaskTable.GetByTaskID(taskID);
+ }
+
+ public MyMentorship GetMyMentorShip()
+ {
+ return this._myMentorship;
+ }
+
+ public void OnRecordExplanationStart()
+ {
+ bool useApollo = XChatDocument.UseApollo;
+ if (useApollo)
+ {
+ XSingleton<XChatApolloMgr>.singleton.StartRecord(VoiceUsage.MENTORHIP, null);
+ }
+ else
+ {
+ XSingleton<XChatIFlyMgr>.singleton.StartRecord(VoiceUsage.MENTORHIP, null);
+ }
+ }
+
+ public void SendMentorshipInfoReq()
+ {
+ RpcC2M_GetMyMentorInfo rpc = new RpcC2M_GetMyMentorInfo();
+ XSingleton<XClientNetwork>.singleton.Send(rpc);
+ }
+
+ public void OnGetMyMentorInfo(GetMyMentorInfoRes ores)
+ {
+ this._gettedData = true;
+ this._myMentorship = MyMentorship.None;
+ this.ReceiveingProtocolTime = ores.curTime - (int)Time.time;
+ this.timeForReceive = (int)Time.time;
+ this._mentorshipApplyWords = ores.mentorWords;
+ this.LeaveFootprint = ores.isNeedStudent;
+ bool flag = ores.mentorRelationList.Count > 0;
+ if (flag)
+ {
+ EMentorRelationPosition pos = (EMentorRelationPosition)ores.mentorRelationList[0].pos;
+ bool flag2 = pos == EMentorRelationPosition.EMentorPosMaster;
+ if (flag2)
+ {
+ this._myMentorship = MyMentorship.Mentorship_Pupil;
+ }
+ else
+ {
+ bool flag3 = pos == EMentorRelationPosition.EMentorPosStudent;
+ if (flag3)
+ {
+ this._myMentorship = MyMentorship.Mentorship_Master;
+ }
+ }
+ this._relationList.Clear();
+ for (int i = 0; i < ores.mentorRelationList.Count; i++)
+ {
+ OneMentorRelationInfo2Client oneMentorRelationInfo2Client = ores.mentorRelationList[i];
+ this._relationList.Add(new MentorRelationInfo
+ {
+ roleInfo = oneMentorRelationInfo2Client.roleInfo,
+ status = oneMentorRelationInfo2Client.curStatus,
+ inheritStatus = oneMentorRelationInfo2Client.inheritStatus,
+ inheritApplyRoleID = oneMentorRelationInfo2Client.inheritApplyRoleID,
+ breakApplyRoleID = oneMentorRelationInfo2Client.breakApplyRoleID
+ });
+ List<MentorRelationTime> statusTimeList = this._relationList[i].statusTimeList;
+ for (int j = 0; j < oneMentorRelationInfo2Client.relationlist.Count; j++)
+ {
+ statusTimeList.Add(new MentorRelationTime
+ {
+ status = (MentorRelationStatus)oneMentorRelationInfo2Client.relationlist[j].status,
+ time = oneMentorRelationInfo2Client.relationlist[j].time
+ });
+ }
+ List<MentorshipTaskInfo> taskList = this._relationList[i].taskList;
+ this.AddTaskInfoUtil(oneMentorRelationInfo2Client.studentTaskList, taskList);
+ }
+ this._myMentorshipTaskList.Clear();
+ bool flag4 = ores.mentorSelfInfo != null;
+ if (flag4)
+ {
+ this.AddTaskInfoUtil(ores.mentorSelfInfo.selfTaskList, this._myMentorshipTaskList);
+ }
+ }
+ bool flag5 = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsVisible();
+ if (flag5)
+ {
+ XMentorshipPupilsHandler mentorshipHandler = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.MentorshipHandler;
+ bool flag6 = mentorshipHandler != null && mentorshipHandler.IsVisible();
+ if (flag6)
+ {
+ mentorshipHandler.RefreshUI();
+ }
+ }
+ bool flag7 = DlgBase<DramaDlg, DramaDlgBehaviour>.singleton.IsVisible();
+ if (flag7)
+ {
+ XDramaDocument specificDocument = XDocuments.GetSpecificDocument<XDramaDocument>(XDramaDocument.uuID);
+ XDramaOperate openedOperate = specificDocument.GetOpenedOperate(XSysDefine.XSys_Mentorship);
+ bool flag8 = openedOperate != null;
+ if (flag8)
+ {
+ XMentorshipPupilsDramaOperate xmentorshipPupilsDramaOperate = openedOperate as XMentorshipPupilsDramaOperate;
+ bool flag9 = xmentorshipPupilsDramaOperate != null;
+ if (flag9)
+ {
+ xmentorshipPupilsDramaOperate.RefreshOperateStatus();
+ }
+ }
+ }
+ this.RefreshMainUIRedPoint();
+ }
+
+ public bool IsHasRedDot()
+ {
+ bool flag = XSingleton<XAttributeMgr>.singleton.XPlayerData == null;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag2 = !this._gettedData;
+ if (flag2)
+ {
+ result = this._hasRedPointOnTasks;
+ }
+ else
+ {
+ int i = 0;
+ int count = this._relationList.Count;
+ while (i < count)
+ {
+ bool oneRedStausByIndex = this.GetOneRedStausByIndex(i);
+ if (oneRedStausByIndex)
+ {
+ return true;
+ }
+ i++;
+ }
+ result = false;
+ }
+ }
+ return result;
+ }
+
+ public bool GetOneRedStausByIndex(int mentorShipIndex)
+ {
+ bool flag = this._myMentorship == MyMentorship.Mentorship_Pupil;
+ if (flag)
+ {
+ MentorRelationInfo mentorRelationInfo = this._relationList[mentorShipIndex];
+ bool flag2 = mentorRelationInfo.inheritStatus == EMentorTaskStatus.EMentorTask_AlreadyReport && mentorRelationInfo.inheritApplyRoleID != XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag2)
+ {
+ return true;
+ }
+ bool flag3 = !this.IsAllReported(mentorRelationInfo.roleInfo.roleID);
+ if (flag3)
+ {
+ return true;
+ }
+ }
+ bool flag4 = this._myMentorship == MyMentorship.Mentorship_Master;
+ if (flag4)
+ {
+ MentorRelationInfo mentorRelationInfo2 = this._relationList[mentorShipIndex];
+ bool flag5 = mentorRelationInfo2.inheritStatus == EMentorTaskStatus.EMentorTask_AlreadyReport && mentorRelationInfo2.inheritApplyRoleID != XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ if (flag5)
+ {
+ return true;
+ }
+ bool flag6 = !this.IsAllAgreed(mentorRelationInfo2.roleInfo.roleID);
+ if (flag6)
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public ulong GetMentorShipInTime(ulong currentRoleID)
+ {
+ ulong result = 0UL;
+ MentorRelationInfo relationTargetInfoByRoleID = this.GetRelationTargetInfoByRoleID(currentRoleID);
+ bool flag = relationTargetInfoByRoleID != null;
+ if (flag)
+ {
+ for (int i = 0; i < relationTargetInfoByRoleID.statusTimeList.Count; i++)
+ {
+ bool flag2 = relationTargetInfoByRoleID.statusTimeList[i].status == MentorRelationStatus.MentorRelationIn;
+ if (flag2)
+ {
+ result = (ulong)relationTargetInfoByRoleID.statusTimeList[i].time;
+ break;
+ }
+ }
+ }
+ return result;
+ }
+
+ public bool IsAllAgreed(ulong roleID)
+ {
+ List<MentorshipTaskInfo> taskListWithRoleID = this.GetTaskListWithRoleID(roleID);
+ bool flag = taskListWithRoleID == null;
+ bool result;
+ if (flag)
+ {
+ result = true;
+ }
+ else
+ {
+ for (int i = 0; i < taskListWithRoleID.Count; i++)
+ {
+ List<MentorshipTaskStatus> taskStatusList = taskListWithRoleID[i].taskStatusList;
+ for (int j = 0; j < taskStatusList.Count; j++)
+ {
+ bool flag2 = taskStatusList[j].status == 3u;
+ if (flag2)
+ {
+ return false;
+ }
+ }
+ }
+ result = true;
+ }
+ return result;
+ }
+
+ public bool IsAllReported(ulong roleID)
+ {
+ ulong mentorShipInTime = this.GetMentorShipInTime(roleID);
+ for (int i = 0; i < this._myMentorshipTaskList.Count; i++)
+ {
+ List<MentorshipTaskStatus> taskStatusList = this._myMentorshipTaskList[i].taskStatusList;
+ for (int j = 0; j < taskStatusList.Count; j++)
+ {
+ bool flag = taskStatusList[j].roleID == roleID && taskStatusList[j].status == 2u;
+ if (flag)
+ {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ public int GetRelationTargetsCount()
+ {
+ return this._relationList.Count;
+ }
+
+ public MentorRelationInfo GetRelationTargetInfo(int index)
+ {
+ bool flag = index < this._relationList.Count;
+ MentorRelationInfo result;
+ if (flag)
+ {
+ result = this._relationList[index];
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public int GetRelationIndexByRoleID(ulong roleID)
+ {
+ int result = -1;
+ for (int i = 0; i < this._relationList.Count; i++)
+ {
+ bool flag = this._relationList[i].roleInfo.roleID == roleID;
+ if (flag)
+ {
+ result = i;
+ break;
+ }
+ }
+ return result;
+ }
+
+ public MentorRelationInfo GetRelationTargetInfoByRoleID(ulong roleID)
+ {
+ for (int i = 0; i < this._relationList.Count; i++)
+ {
+ MentorRelationInfo mentorRelationInfo = this._relationList[i];
+ bool flag = mentorRelationInfo.roleInfo.roleID == roleID;
+ if (flag)
+ {
+ return mentorRelationInfo;
+ }
+ }
+ return null;
+ }
+
+ public MentorRelationInfo GetInheritStatusByRoleID(ulong roleID)
+ {
+ for (int i = 0; i < this._relationList.Count; i++)
+ {
+ bool flag = this._relationList[i].roleInfo.roleID == roleID;
+ if (flag)
+ {
+ return this._relationList[i];
+ }
+ }
+ return null;
+ }
+
+ public void SendToGetMyApplyPupilsInfo(bool refreh = false)
+ {
+ RpcC2M_GetMyApplyStudentInfo rpcC2M_GetMyApplyStudentInfo = new RpcC2M_GetMyApplyStudentInfo();
+ rpcC2M_GetMyApplyStudentInfo.oArg.isRefresh = refreh;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_GetMyApplyStudentInfo);
+ }
+
+ public void OnGetMyApplyPupilsInfo(GetMyApplyStudentInfoRes oRes)
+ {
+ this._pupilApplyInfo.applyTargetInfoList.Clear();
+ for (int i = 0; i < oRes.canApplyList.Count; i++)
+ {
+ OneMentorApplyStudentShow oneMentorApplyStudentShow = oRes.canApplyList[i];
+ this._pupilApplyInfo.applyTargetInfoList.Add(new PupilTargetItemInfo
+ {
+ roleInfo = oRes.canApplyList[i].oneStudent,
+ isApplied = oRes.canApplyList[i].hasApply,
+ applyWords = oRes.canApplyList[i].applyWords
+ });
+ }
+ this._myApplyPupilRefreshTime = oRes.leftRefreshTime;
+ this.StartCountDown();
+ this.RefreshViewCD();
+ bool flag = DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshUI();
+ }
+ }
+
+ public void SendToGetMyApplyMasterInfo(bool refresh = false)
+ {
+ RpcC2M_GetMyApplyMasterInfo rpcC2M_GetMyApplyMasterInfo = new RpcC2M_GetMyApplyMasterInfo();
+ rpcC2M_GetMyApplyMasterInfo.oArg.isRefresh = refresh;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_GetMyApplyMasterInfo);
+ }
+
+ public void OnGetMyApplyMasterInfo(GetMyApplyMasterInfoRes oRes)
+ {
+ this._masterApplyInfoList.Clear();
+ for (int i = 0; i < oRes.canApplyMasters.Count; i++)
+ {
+ OneMentorApplyMasterShow oneMentorApplyMasterShow = oRes.canApplyMasters[i];
+ this._masterApplyInfoList.Add(new MasterApplyInfoItem
+ {
+ applyWords = oneMentorApplyMasterShow.applyWords,
+ hasApply = oneMentorApplyMasterShow.hasApply,
+ roleInfo = oneMentorApplyMasterShow.oneMaster
+ });
+ }
+ this._myApplyMasterRefreshTime = oRes.leftRefreshTime;
+ this.StartCountDown();
+ this.RefreshViewCD();
+ bool flag = DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshUI();
+ }
+ }
+
+ public void SendCandidatesOpReq(EMentorMsgOpType opType, ulong roleID = 0UL, MentorMsgApplyType type = MentorMsgApplyType.MentorMsgApplyMax, int taskID = 0, bool isAll = false)
+ {
+ RpcC2M_MentorMyBeAppliedMsg rpcC2M_MentorMyBeAppliedMsg = new RpcC2M_MentorMyBeAppliedMsg();
+ rpcC2M_MentorMyBeAppliedMsg.oArg.operation = opType;
+ rpcC2M_MentorMyBeAppliedMsg.oArg.msgType = type;
+ rpcC2M_MentorMyBeAppliedMsg.oArg.roleID = roleID;
+ rpcC2M_MentorMyBeAppliedMsg.oArg.taskID = taskID;
+ rpcC2M_MentorMyBeAppliedMsg.oArg.operatingAllTask = isAll;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_MentorMyBeAppliedMsg);
+ }
+
+ public void OnGetMyBeenApplyedMsg(MentorMyBeAppliedMsgArg oArg, MentorMyBeAppliedMsgRes oRes)
+ {
+ bool flag = oArg.operation != EMentorMsgOpType.EMentorMsgOp_Get;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("OperateSuccess"), "fece00");
+ }
+ switch (oArg.operation)
+ {
+ case EMentorMsgOpType.EMentorMsgOp_Get:
+ {
+ bool flag2 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag2)
+ {
+ this._beenApplyedInfoList.Clear();
+ for (int i = 0; i < oRes.msgList.Count; i++)
+ {
+ OneMentorBeAppliedMsg oneMentorBeAppliedMsg = oRes.msgList[i];
+ this._beenApplyedInfoList.Add(new MentorBeenApplyedInfo
+ {
+ applyType = oneMentorBeAppliedMsg.type,
+ time = oneMentorBeAppliedMsg.time,
+ reportTaskID = oneMentorBeAppliedMsg.reportTaskID,
+ roleInfo = oneMentorBeAppliedMsg.roleBrief
+ });
+ }
+ bool flag3 = DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.IsVisible();
+ if (flag3)
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshUI();
+ }
+ bool flag4 = DlgBase<XMentorshipApplicationsView, XMentorshipApplicationBehavior>.singleton.IsVisible();
+ if (flag4)
+ {
+ DlgBase<XMentorshipApplicationsView, XMentorshipApplicationBehavior>.singleton.RefreshUI();
+ }
+ this.RefreshMsgMainSceneIcon();
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.error, "fece00");
+ }
+ break;
+ }
+ case EMentorMsgOpType.EMentorMsgOpType_Clear:
+ {
+ bool flag5 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag5)
+ {
+ this.RemoveApplyNewsButInheritReport(oArg);
+ bool flag6 = DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.IsVisible();
+ if (flag6)
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshUI();
+ }
+ bool flag7 = DlgBase<XMentorshipApplicationsView, XMentorshipApplicationBehavior>.singleton.IsVisible();
+ if (flag7)
+ {
+ DlgBase<XMentorshipApplicationsView, XMentorshipApplicationBehavior>.singleton.RefreshUI();
+ }
+ this.RefreshMsgMainSceneIcon();
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.error, "fece00");
+ }
+ break;
+ }
+ case EMentorMsgOpType.EMentorMsgOpType_Agree:
+ {
+ bool flag8 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag8)
+ {
+ bool flag9 = oArg.msgType == MentorMsgApplyType.MentorMsgApplyInherit;
+ if (flag9)
+ {
+ for (int j = 0; j < this._relationList.Count; j++)
+ {
+ MentorRelationInfo mentorRelationInfo = this._relationList[j];
+ bool flag10 = mentorRelationInfo.roleInfo.roleID == oArg.roleID;
+ if (flag10)
+ {
+ mentorRelationInfo.inheritStatus = EMentorTaskStatus.EMentorTask_ConfirmReport;
+ bool flag11 = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsVisible();
+ if (flag11)
+ {
+ XMentorshipPupilsHandler mentorshipHandler = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.MentorshipHandler;
+ bool flag12 = mentorshipHandler != null && mentorshipHandler.IsVisible();
+ if (flag12)
+ {
+ mentorshipHandler.UpdateInheritTaskItem();
+ }
+ }
+ this.RefreshMainUIRedPoint();
+ break;
+ }
+ }
+ }
+ else
+ {
+ bool flag13 = oArg.msgType == MentorMsgApplyType.MentorMsgApplyReportTask;
+ if (flag13)
+ {
+ List<MentorshipTaskInfo> taskListWithRoleID = this.GetTaskListWithRoleID(oArg.roleID);
+ bool flag14 = taskListWithRoleID != null;
+ if (flag14)
+ {
+ for (int k = 0; k < taskListWithRoleID.Count; k++)
+ {
+ MentorshipTaskInfo mentorshipTaskInfo = taskListWithRoleID[k];
+ bool flag15 = mentorshipTaskInfo.taskID == oArg.taskID;
+ if (flag15)
+ {
+ List<MentorshipTaskStatus> taskStatusList = mentorshipTaskInfo.taskStatusList;
+ bool flag16 = false;
+ for (int l = 0; l < taskStatusList.Count; l++)
+ {
+ bool flag17 = taskStatusList[l].roleID == oArg.roleID;
+ if (flag17)
+ {
+ taskStatusList[l].status = 4u;
+ flag16 = true;
+ break;
+ }
+ }
+ bool flag18 = flag16;
+ if (flag18)
+ {
+ this.RefreshTaskItems();
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.error, "fece00");
+ }
+ bool flag19 = oArg.operatingAllTask && oArg.msgType == MentorMsgApplyType.MentorMsgApplyReportTask;
+ if (flag19)
+ {
+ for (int m = this._beenApplyedInfoList.Count - 1; m >= 0; m--)
+ {
+ bool flag20 = this._beenApplyedInfoList[m].applyType == MentorMsgApplyType.MentorMsgApplyReportTask;
+ if (flag20)
+ {
+ this._beenApplyedInfoList.RemoveAt(m);
+ }
+ }
+ }
+ else
+ {
+ for (int n = this._beenApplyedInfoList.Count - 1; n >= 0; n--)
+ {
+ bool flag21 = this._beenApplyedInfoList[n].roleInfo.roleID == oArg.roleID && oArg.msgType == this._beenApplyedInfoList[n].applyType;
+ if (flag21)
+ {
+ bool flag22 = oArg.msgType == MentorMsgApplyType.MentorMsgApplyMaster || oArg.msgType == MentorMsgApplyType.MentorMsgApplyStudent;
+ if (flag22)
+ {
+ this._beenApplyedInfoList.RemoveAt(n);
+ }
+ else
+ {
+ bool flag23 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag23)
+ {
+ bool flag24 = this._beenApplyedInfoList[n].applyType == MentorMsgApplyType.MentorMsgApplyReportTask && this._beenApplyedInfoList[n].reportTaskID == oArg.taskID;
+ if (flag24)
+ {
+ this._beenApplyedInfoList.RemoveAt(n);
+ }
+ else
+ {
+ bool flag25 = this._beenApplyedInfoList[n].applyType != MentorMsgApplyType.MentorMsgApplyReportTask;
+ if (flag25)
+ {
+ this._beenApplyedInfoList.RemoveAt(n);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ this.RefreshMsgMainSceneIcon();
+ this.RefreshRedPointWithoutData();
+ bool flag26 = DlgBase<XMentorshipApplicationsView, XMentorshipApplicationBehavior>.singleton.IsVisible();
+ if (flag26)
+ {
+ DlgBase<XMentorshipApplicationsView, XMentorshipApplicationBehavior>.singleton.RefreshUI();
+ }
+ bool flag27 = DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.IsVisible();
+ if (flag27)
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshUI();
+ }
+ break;
+ }
+ case EMentorMsgOpType.EMentorMsgOpType_Reject:
+ {
+ bool flag28 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag28)
+ {
+ for (int num = this._beenApplyedInfoList.Count - 1; num >= 0; num--)
+ {
+ bool flag29 = this._beenApplyedInfoList[num].roleInfo.roleID == oArg.roleID && this._beenApplyedInfoList[num].applyType == oArg.msgType;
+ if (flag29)
+ {
+ this._beenApplyedInfoList.RemoveAt(num);
+ }
+ }
+ this.RefreshMsgMainSceneIcon();
+ bool flag30 = DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.IsVisible();
+ if (flag30)
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshUI();
+ }
+ bool flag31 = DlgBase<XMentorshipApplicationsView, XMentorshipApplicationBehavior>.singleton.IsVisible();
+ if (flag31)
+ {
+ DlgBase<XMentorshipApplicationsView, XMentorshipApplicationBehavior>.singleton.RefreshUI();
+ }
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.error, "fece00");
+ }
+ break;
+ }
+ }
+ }
+
+ private void RefreshRedPointWithoutData()
+ {
+ this._hasRedPointOnTasks = false;
+ for (int i = 0; i < this._beenApplyedInfoList.Count; i++)
+ {
+ bool flag = this._beenApplyedInfoList[i].applyType == MentorMsgApplyType.MentorMsgApplyInherit || this._beenApplyedInfoList[i].applyType == MentorMsgApplyType.MentorMsgApplyReportTask;
+ if (flag)
+ {
+ this._hasRedPointOnTasks = true;
+ }
+ }
+ this.RefreshMainUIRedPoint();
+ }
+
+ private void RefreshMainUIRedPoint()
+ {
+ this._hasRedPointOnTasks = this.IsHasRedDot();
+ DlgBase<XFriendsView, XFriendsBehaviour>.singleton.SetRedPoint(TabIndex.Mentorship, this._hasRedPointOnTasks);
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_Friends, true);
+ bool flag = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XFriendsView, XFriendsBehaviour>.singleton.UpdateRedpointUI();
+ }
+ }
+
+ private void RefreshMsgMainSceneIcon()
+ {
+ bool flag = this._beenApplyedInfoList.Count == 0;
+ if (flag)
+ {
+ this._hasApplyMsg = false;
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_MentorshipMsg_Tip, true);
+ }
+ }
+
+ private void RemoveApplyNewsButInheritReport(MentorMyBeAppliedMsgArg oArg)
+ {
+ for (int i = this._beenApplyedInfoList.Count - 1; i >= 0; i--)
+ {
+ bool flag = this._beenApplyedInfoList[i].applyType == MentorMsgApplyType.MentorMsgApplyStudent || this._beenApplyedInfoList[i].applyType == MentorMsgApplyType.MentorMsgApplyMaster;
+ if (flag)
+ {
+ this._beenApplyedInfoList.RemoveAt(i);
+ }
+ }
+ }
+
+ public MentorBeenApplyedInfo GetMentorshipCandidateInfoByIndex(int index)
+ {
+ bool flag = index < this._beenApplyedInfoList.Count;
+ MentorBeenApplyedInfo result;
+ if (flag)
+ {
+ result = this._beenApplyedInfoList[index];
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ private void AddTaskInfoUtil(List<OneMentorTaskInfo> src, List<MentorshipTaskInfo> des)
+ {
+ for (int i = 0; i < src.Count; i++)
+ {
+ OneMentorTaskInfo oneMentorTaskInfo = src[i];
+ MentorshipTaskInfo mentorshipTaskInfo = new MentorshipTaskInfo
+ {
+ taskID = oneMentorTaskInfo.taskID,
+ completeProgress = oneMentorTaskInfo.completeProgress,
+ completeTime = oneMentorTaskInfo.completeTime
+ };
+ List<MentorshipTaskStatus> taskStatusList = mentorshipTaskInfo.taskStatusList;
+ for (int j = 0; j < oneMentorTaskInfo.taskApplyStatus.Count; j++)
+ {
+ taskStatusList.Add(new MentorshipTaskStatus
+ {
+ roleID = oneMentorTaskInfo.taskApplyStatus[j].key,
+ status = oneMentorTaskInfo.taskApplyStatus[j].value
+ });
+ }
+ des.Add(mentorshipTaskInfo);
+ bool flag = this._myMentorship == MyMentorship.Mentorship_Pupil && des == this._myMentorshipTaskList;
+ if (flag)
+ {
+ for (int k = 0; k < this._relationList.Count; k++)
+ {
+ bool flag2 = false;
+ ulong num = 0UL;
+ for (int l = 0; l < taskStatusList.Count; l++)
+ {
+ bool flag3 = this._relationList[k].roleInfo.roleID == taskStatusList[l].roleID;
+ if (flag3)
+ {
+ flag2 = true;
+ break;
+ }
+ }
+ bool flag4 = !flag2;
+ if (flag4)
+ {
+ for (int m = 0; m < this._relationList[k].statusTimeList.Count; m++)
+ {
+ bool flag5 = this._relationList[k].statusTimeList[m].status == MentorRelationStatus.MentorRelationIn;
+ if (flag5)
+ {
+ num = (ulong)this._relationList[k].statusTimeList[m].time;
+ break;
+ }
+ }
+ bool flag6 = mentorshipTaskInfo.completeTime != 0;
+ if (flag6)
+ {
+ bool flag7 = (long)mentorshipTaskInfo.completeTime < (long)num;
+ if (flag7)
+ {
+ taskStatusList.Add(new MentorshipTaskStatus
+ {
+ roleID = this._relationList[k].roleInfo.roleID,
+ status = 5u
+ });
+ }
+ else
+ {
+ taskStatusList.Add(new MentorshipTaskStatus
+ {
+ roleID = this._relationList[k].roleInfo.roleID,
+ status = 2u
+ });
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ public MessageShowInfoItem GetCandidateMsgShowInfo(int index)
+ {
+ bool flag = this.CurViewType == CandidatesViewType.Application;
+ if (flag)
+ {
+ while (index < this._beenApplyedInfoList.Count)
+ {
+ MentorBeenApplyedInfo mentorshipCandidateInfoByIndex = this.GetMentorshipCandidateInfoByIndex(index);
+ bool flag2 = mentorshipCandidateInfoByIndex != null && mentorshipCandidateInfoByIndex.applyType != MentorMsgApplyType.MentorMsgApplyInherit && mentorshipCandidateInfoByIndex.applyType != MentorMsgApplyType.MentorMsgApplyReportTask;
+ if (flag2)
+ {
+ this._tempShowInfo.taskID = mentorshipCandidateInfoByIndex.reportTaskID;
+ this._tempShowInfo.roleInfo = mentorshipCandidateInfoByIndex.roleInfo;
+ this._tempShowInfo.msgType = mentorshipCandidateInfoByIndex.applyType;
+ this._tempShowInfo.audioTime = mentorshipCandidateInfoByIndex.audioTime;
+ this._tempShowInfo.audioID = mentorshipCandidateInfoByIndex.audioID;
+ this._tempShowInfo.promiseWords = mentorshipCandidateInfoByIndex.applyWords;
+ return this._tempShowInfo;
+ }
+ index++;
+ }
+ }
+ else
+ {
+ bool flag3 = this.CurViewType == CandidatesViewType.Recommend;
+ if (flag3)
+ {
+ bool flag4 = this.CurRecommendType == CandidatesViewRecommendType.Master;
+ if (flag4)
+ {
+ bool flag5 = index < this._masterApplyInfoList.Count;
+ if (flag5)
+ {
+ MasterApplyInfoItem masterApplyInfoItem = this._masterApplyInfoList[index];
+ this._tempShowInfo.roleInfo = masterApplyInfoItem.roleInfo;
+ this._tempShowInfo.promiseWords = masterApplyInfoItem.applyWords;
+ this._tempShowInfo.applied = masterApplyInfoItem.hasApply;
+ return this._tempShowInfo;
+ }
+ }
+ else
+ {
+ bool flag6 = index < this._pupilApplyInfo.applyTargetInfoList.Count;
+ if (flag6)
+ {
+ this._tempShowInfo.roleInfo = this._pupilApplyInfo.applyTargetInfoList[index].roleInfo;
+ this._tempShowInfo.promiseWords = this._pupilApplyInfo.applyTargetInfoList[index].applyWords;
+ this._tempShowInfo.applied = this._pupilApplyInfo.applyTargetInfoList[index].isApplied;
+ return this._tempShowInfo;
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ public int GetMyPupilTaskTotalNumber(ulong roleID)
+ {
+ List<MentorshipTaskInfo> taskListWithRoleID = this.GetTaskListWithRoleID(roleID);
+ bool flag = taskListWithRoleID != null;
+ int result;
+ if (flag)
+ {
+ result = taskListWithRoleID.Count;
+ }
+ else
+ {
+ result = 0;
+ }
+ return result;
+ }
+
+ public List<MentorshipTaskInfo> GetTaskListWithRoleID(ulong roleID)
+ {
+ for (int i = 0; i < this._relationList.Count; i++)
+ {
+ bool flag = this._relationList[i].roleInfo.roleID == roleID;
+ if (flag)
+ {
+ return this._relationList[i].taskList;
+ }
+ }
+ return null;
+ }
+
+ public int GetRelationPassedDays(ulong _currentRoleID, MentorRelationStatus status)
+ {
+ for (int i = 0; i < this._relationList.Count; i++)
+ {
+ bool flag = this._relationList[i].roleInfo.roleID == _currentRoleID;
+ if (flag)
+ {
+ uint num = 0u;
+ List<MentorRelationTime> statusTimeList = this._relationList[i].statusTimeList;
+ for (int j = 0; j < statusTimeList.Count; j++)
+ {
+ bool flag2 = statusTimeList[j].status == status;
+ if (flag2)
+ {
+ num = statusTimeList[j].time;
+ }
+ }
+ return TimeSpan.FromSeconds((double)((long)this.ReceiveingProtocolTime + (long)((ulong)((uint)Time.time)) - (long)((ulong)num))).Days;
+ }
+ }
+ return 0;
+ }
+
+ public bool IsMentorshipInDaysEnough(ulong roleID)
+ {
+ int @int = XSingleton<XGlobalConfig>.singleton.GetInt("Mentor_NormalCompleteDay");
+ int relationPassedDays = XMentorshipDocument.Doc.GetRelationPassedDays(roleID, MentorRelationStatus.MentorRelationIn);
+ bool flag = relationPassedDays >= @int;
+ bool result;
+ if (flag)
+ {
+ result = true;
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("ERR_MENTOR_COMPLETE_IN_RELATION_NEED_DAYS"), "fece00");
+ result = false;
+ }
+ return result;
+ }
+
+ public bool IsCompletedTaskEnough(ulong roleID)
+ {
+ int completedTaskCount = XMentorshipDocument.Doc.GetCompletedTaskCount(roleID);
+ int @int = XSingleton<XGlobalConfig>.singleton.GetInt("Mentor_NormalComplete");
+ bool flag = completedTaskCount >= @int;
+ bool result;
+ if (flag)
+ {
+ result = true;
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("ERR_MENTOR_COMPLETE_IN_RELATION_NEED_DAYS"), "fece00");
+ result = false;
+ }
+ return result;
+ }
+
+ public MentorshipTaskInfo GetTaskInfoWithIndexAndRoleID(int index, ulong roleID)
+ {
+ List<MentorshipTaskInfo> taskListWithRoleID = this.GetTaskListWithRoleID(roleID);
+ bool flag = taskListWithRoleID != null && index < taskListWithRoleID.Count;
+ MentorshipTaskInfo result;
+ if (flag)
+ {
+ result = taskListWithRoleID[index];
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public int GetCanidatesShowMsgCount()
+ {
+ bool flag = this.CurViewType == CandidatesViewType.Application;
+ int result;
+ if (flag)
+ {
+ int num = 0;
+ for (int i = 0; i < this._beenApplyedInfoList.Count; i++)
+ {
+ bool flag2 = this._beenApplyedInfoList[i].applyType != MentorMsgApplyType.MentorMsgApplyReportTask && this._beenApplyedInfoList[i].applyType != MentorMsgApplyType.MentorMsgApplyInherit;
+ if (flag2)
+ {
+ num++;
+ }
+ }
+ result = num;
+ }
+ else
+ {
+ bool flag3 = this.CurViewType == CandidatesViewType.Recommend;
+ if (flag3)
+ {
+ bool flag4 = this.CurRecommendType == CandidatesViewRecommendType.Master;
+ if (flag4)
+ {
+ result = this._masterApplyInfoList.Count;
+ }
+ else
+ {
+ result = this._pupilApplyInfo.applyTargetInfoList.Count;
+ }
+ }
+ else
+ {
+ result = 0;
+ }
+ }
+ return result;
+ }
+
+ public int GetBeenApplyMsgCount()
+ {
+ return this._beenApplyedInfoList.Count;
+ }
+
+ public int GetBeenApplyReportsMsgCount()
+ {
+ int num = 0;
+ for (int i = 0; i < this._beenApplyedInfoList.Count; i++)
+ {
+ bool flag = this._beenApplyedInfoList[i].applyType == MentorMsgApplyType.MentorMsgApplyReportTask;
+ if (flag)
+ {
+ num++;
+ }
+ }
+ return num;
+ }
+
+ public MentorBeenApplyedInfo GetBeenApplyInfoByIndex(int index)
+ {
+ bool flag = index < this._beenApplyedInfoList.Count;
+ MentorBeenApplyedInfo result;
+ if (flag)
+ {
+ result = this._beenApplyedInfoList[index];
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public int GetMyMentorshipTaskCount()
+ {
+ return this._myMentorshipTaskList.Count;
+ }
+
+ public MentorshipTaskInfo GetMyMentorshipTaskInfoByIndex(int index)
+ {
+ bool flag = index < this._myMentorshipTaskList.Count;
+ MentorshipTaskInfo result;
+ if (flag)
+ {
+ result = this._myMentorshipTaskList[index];
+ }
+ else
+ {
+ result = null;
+ }
+ return result;
+ }
+
+ public MessageShowInfoItem GetApplicationViewMsgInfoByIndex(int index)
+ {
+ bool flag = index < this._myMentorshipTaskList.Count;
+ MessageShowInfoItem result;
+ if (flag)
+ {
+ MentorshipTaskInfo mentorshipTaskInfo = this._myMentorshipTaskList[index];
+ result = this._tempShowInfo;
+ }
+ else
+ {
+ index -= this._myMentorshipTaskList.Count;
+ bool flag2 = index < this._beenApplyedInfoList.Count;
+ if (flag2)
+ {
+ result = this._tempShowInfo;
+ }
+ else
+ {
+ result = null;
+ }
+ }
+ return result;
+ }
+
+ public void SetCandidatesViewVisible(CandidatesViewType viewType, CandidatesViewRecommendType recommendType = CandidatesViewRecommendType.None)
+ {
+ this.CurViewType = viewType;
+ this.CurRecommendType = recommendType;
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.SetVisibleWithAnimation(true, null);
+ }
+
+ public void ResetCandidatesView()
+ {
+ this.CurViewType = CandidatesViewType.None;
+ this.CurRecommendType = CandidatesViewRecommendType.None;
+ }
+
+ public void SendMentorRelationOp(MentorRelationOpType opType, ulong roleID, int taskID = 0)
+ {
+ RpcC2M_MentorRelationOp rpcC2M_MentorRelationOp = new RpcC2M_MentorRelationOp();
+ rpcC2M_MentorRelationOp.oArg.destRoleID = roleID;
+ rpcC2M_MentorRelationOp.oArg.operation = opType;
+ rpcC2M_MentorRelationOp.oArg.reportTaskID = taskID;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_MentorRelationOp);
+ }
+
+ public void OnGetMentorshipOpReply(MentorRelationOpArg oArg, MentorRelationOpRes oRes)
+ {
+ bool flag = oRes.error == ErrorCode.ERR_FAILED;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.error, "fece00");
+ }
+ else
+ {
+ bool flag2 = oRes.error == ErrorCode.ERR_MENTOR_ASKMAXTODAY;
+ if (flag2)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.error, "fece00");
+ }
+ else
+ {
+ switch (oArg.operation)
+ {
+ case MentorRelationOpType.MentorRelationOp_ApplyMaster:
+ {
+ int num = -1;
+ for (int i = 0; i < this._masterApplyInfoList.Count; i++)
+ {
+ bool flag3 = this._masterApplyInfoList[i].roleInfo.roleID == oArg.destRoleID;
+ if (flag3)
+ {
+ num = i;
+ break;
+ }
+ }
+ bool flag4 = num >= 0;
+ if (flag4)
+ {
+ bool flag5 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag5)
+ {
+ this._masterApplyInfoList[num].hasApply = true;
+ bool flag6 = DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.IsVisible();
+ if (flag6)
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshAllVisible();
+ }
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("SendMessageSuccess"), "fece00");
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.error, "fece00");
+ this._masterApplyInfoList.RemoveAt(num);
+ bool flag7 = DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.IsVisible();
+ if (flag7)
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshUI();
+ }
+ }
+ }
+ break;
+ }
+ case MentorRelationOpType.MentorRelationOp_ApplyStudent:
+ {
+ int num2 = -1;
+ for (int j = 0; j < this._pupilApplyInfo.applyTargetInfoList.Count; j++)
+ {
+ PupilTargetItemInfo pupilTargetItemInfo = this._pupilApplyInfo.applyTargetInfoList[j];
+ bool flag8 = pupilTargetItemInfo.roleInfo.roleID == oArg.destRoleID;
+ if (flag8)
+ {
+ num2 = j;
+ break;
+ }
+ }
+ bool flag9 = num2 >= 0;
+ if (flag9)
+ {
+ bool flag10 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag10)
+ {
+ this._pupilApplyInfo.applyTargetInfoList[num2].isApplied = true;
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("SendMessageSuccess"), "fece00");
+ bool flag11 = DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.IsVisible();
+ if (flag11)
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshAllVisible();
+ }
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.error, "fece00");
+ this._pupilApplyInfo.applyTargetInfoList.RemoveAt(num2);
+ bool flag12 = DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.IsVisible();
+ if (flag12)
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshUI();
+ }
+ }
+ }
+ break;
+ }
+ case MentorRelationOpType.MentorRelationOp_Inherit:
+ {
+ bool flag13 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag13)
+ {
+ for (int k = 0; k < this._relationList.Count; k++)
+ {
+ bool flag14 = this._relationList[k].roleInfo.roleID == oArg.destRoleID;
+ if (flag14)
+ {
+ this._relationList[k].inheritStatus = EMentorTaskStatus.EMentorTask_AlreadyReport;
+ this._relationList[k].inheritApplyRoleID = XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
+ bool flag15 = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsVisible();
+ if (flag15)
+ {
+ XMentorshipPupilsHandler mentorshipHandler = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.MentorshipHandler;
+ bool flag16 = mentorshipHandler != null && mentorshipHandler.IsVisible();
+ if (flag16)
+ {
+ mentorshipHandler.UpdateInheritTaskItem();
+ }
+ }
+ break;
+ }
+ }
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.error, "fece00");
+ }
+ break;
+ }
+ case MentorRelationOpType.MentorRelationOp_ReportTask:
+ {
+ bool flag17 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag17)
+ {
+ List<MentorshipTaskInfo> myMentorshipTaskList = this._myMentorshipTaskList;
+ foreach (MentorshipTaskInfo mentorshipTaskInfo in myMentorshipTaskList)
+ {
+ bool flag18 = mentorshipTaskInfo.taskID == oArg.reportTaskID;
+ if (flag18)
+ {
+ bool flag19 = false;
+ for (int l = 0; l < mentorshipTaskInfo.taskStatusList.Count; l++)
+ {
+ bool flag20 = mentorshipTaskInfo.taskStatusList[l].roleID == oArg.destRoleID;
+ if (flag20)
+ {
+ mentorshipTaskInfo.taskStatusList[l].status = (uint)XFastEnumIntEqualityComparer<EMentorTaskStatus>.ToInt(EMentorTaskStatus.EMentorTask_AlreadyReport);
+ flag19 = true;
+ }
+ }
+ bool flag21 = !flag19;
+ if (flag21)
+ {
+ mentorshipTaskInfo.taskStatusList.Add(new MentorshipTaskStatus
+ {
+ roleID = oArg.destRoleID,
+ status = (uint)XFastEnumIntEqualityComparer<EMentorTaskStatus>.ToInt(EMentorTaskStatus.EMentorTask_AlreadyReport)
+ });
+ }
+ }
+ }
+ MentorRelationInfo relationTargetInfoByRoleID = this.GetRelationTargetInfoByRoleID(oArg.destRoleID);
+ bool flag22 = relationTargetInfoByRoleID != null;
+ if (flag22)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(string.Format(XSingleton<XStringTable>.singleton.GetString("ReportToTarget"), relationTargetInfoByRoleID.roleInfo.name), "fece00");
+ }
+ this.RefreshTaskItems();
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.error, "fece00");
+ }
+ break;
+ }
+ case MentorRelationOpType.MentorRelationOp_ReportAllTask:
+ {
+ bool flag23 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag23)
+ {
+ this.SendMentorshipInfoReq();
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(oRes.error, "fece00");
+ }
+ break;
+ }
+ case MentorRelationOpType.MentorRelationOp_Break:
+ {
+ bool flag24 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag24)
+ {
+ for (int m = 0; m < this._relationList.Count; m++)
+ {
+ bool flag25 = this._relationList[m].roleInfo.roleID == oArg.destRoleID;
+ if (flag25)
+ {
+ this._relationList[m].status = MentorRelationStatus.MentorRelationBreak;
+ this._relationList[m].statusTimeList.Add(new MentorRelationTime
+ {
+ status = MentorRelationStatus.MentorRelationBreak,
+ time = (uint)oRes.curTime
+ });
+ break;
+ }
+ }
+ }
+ this.FireMentorOperationEvent(oArg, oRes);
+ break;
+ }
+ case MentorRelationOpType.MentorRelationOp_BreakCancel:
+ case MentorRelationOpType.MentorRelationOp_NormalComplete:
+ case MentorRelationOpType.MentorRelationOp_ForceComplete:
+ {
+ bool flag26 = oRes.error == ErrorCode.ERR_SUCCESS;
+ if (flag26)
+ {
+ for (int n = this._relationList.Count - 1; n >= 0; n--)
+ {
+ bool flag27 = this._relationList[n].roleInfo.roleID == oArg.destRoleID;
+ if (flag27)
+ {
+ this._relationList[n].status = MentorRelationStatus.MentorRelationIn;
+ List<MentorRelationTime> statusTimeList = this._relationList[n].statusTimeList;
+ for (int num3 = statusTimeList.Count - 1; num3 >= 0; num3--)
+ {
+ bool flag28 = statusTimeList[num3].status == MentorRelationStatus.MentorRelationBreak;
+ if (flag28)
+ {
+ statusTimeList.RemoveAt(num3);
+ }
+ }
+ break;
+ }
+ }
+ }
+ this.FireMentorOperationEvent(oArg, oRes);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ public int GetCompletedTaskCount(ulong roleID)
+ {
+ int num = 0;
+ ulong mentorShipInTime = this.GetMentorShipInTime(roleID);
+ List<MentorshipTaskInfo> taskList = this.GetTaskList(roleID);
+ bool flag = taskList != null;
+ if (flag)
+ {
+ for (int i = 0; i < taskList.Count; i++)
+ {
+ List<MentorshipTaskStatus> taskStatusList = taskList[i].taskStatusList;
+ for (int j = 0; j < taskStatusList.Count; j++)
+ {
+ bool flag2 = taskStatusList[j].roleID == roleID && taskStatusList[j].status != 1u && taskStatusList[j].status != 2u && taskStatusList[j].status != 3u;
+ if (flag2)
+ {
+ num++;
+ }
+ }
+ }
+ }
+ return num;
+ }
+
+ public int GetTotalTaskNum(ulong roleID)
+ {
+ List<MentorshipTaskInfo> taskList = this.GetTaskList(roleID);
+ return (taskList != null) ? taskList.Count : 0;
+ }
+
+ private List<MentorshipTaskInfo> GetTaskList(ulong roleID)
+ {
+ List<MentorshipTaskInfo> result = null;
+ bool flag = this._myMentorship == MyMentorship.Mentorship_Master;
+ if (flag)
+ {
+ for (int i = 0; i < this._relationList.Count; i++)
+ {
+ bool flag2 = this._relationList[i].roleInfo.roleID == roleID;
+ if (flag2)
+ {
+ result = this._relationList[i].taskList;
+ }
+ }
+ }
+ else
+ {
+ bool flag3 = this._myMentorship == MyMentorship.Mentorship_Pupil;
+ if (flag3)
+ {
+ result = this._myMentorshipTaskList;
+ }
+ }
+ return result;
+ }
+
+ private void RefreshTaskItems()
+ {
+ bool flag = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ XMentorshipPupilsHandler mentorshipHandler = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.MentorshipHandler;
+ bool flag2 = mentorshipHandler != null && mentorshipHandler.IsVisible();
+ if (flag2)
+ {
+ mentorshipHandler.RefreshTaskItems();
+ }
+ }
+ this.RefreshMainUIRedPoint();
+ }
+
+ public void SendUpdateMentorshopSetting(string words, bool isChecked)
+ {
+ RpcC2M_UpdateMentorApplyStudentInfo rpcC2M_UpdateMentorApplyStudentInfo = new RpcC2M_UpdateMentorApplyStudentInfo();
+ rpcC2M_UpdateMentorApplyStudentInfo.oArg.applyWords = words;
+ rpcC2M_UpdateMentorApplyStudentInfo.oArg.isNeedStudent = !isChecked;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_UpdateMentorApplyStudentInfo);
+ }
+
+ public void OnGetMentorshipSetting(UpdateMentorApplyStudentInfoArg oArg, UpdateMentorApplyStudentInfoRes oRes)
+ {
+ this.MentorshipApplyWords = oArg.applyWords;
+ this.LeaveFootprint = oArg.isNeedStudent;
+ bool flag = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ XMentorshipPupilsHandler mentorshipHandler = DlgBase<XFriendsView, XFriendsBehaviour>.singleton.MentorshipHandler;
+ bool flag2 = mentorshipHandler != null && mentorshipHandler.IsVisible();
+ if (flag2)
+ {
+ mentorshipHandler.OnSettingOk();
+ }
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("MentorshipSettingOk"), "fece00");
+ }
+ }
+
+ public void SendGetOtherMentorStatus(ulong roleID)
+ {
+ RpcC2M_GetOtherMentorStatus rpcC2M_GetOtherMentorStatus = new RpcC2M_GetOtherMentorStatus();
+ rpcC2M_GetOtherMentorStatus.oArg.roleid = roleID;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_GetOtherMentorStatus);
+ }
+
+ public void OnGetOtherMentorStatus(GetOtherMentorStatusArg oArg, GetOtherMentorStatusRes oRes)
+ {
+ bool flag = oArg.roleid == this.ClickedMainSceneRoleID;
+ if (flag)
+ {
+ this.ClickedRoleMentorshipStatus = oRes.status;
+ bool flag2 = DlgBase<XCharacterCommonMenuView, XCharacterCommonMenuBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XCharacterCommonMenuView, XCharacterCommonMenuBehaviour>.singleton.RefreshBtns();
+ }
+ }
+ }
+
+ public void OnGetMentorshipNotify(PtcM2C_NotifyMentorApply roPtc)
+ {
+ EMentorRelationPosition pos = roPtc.Data.pos;
+ this._tipIconHasRedPoint = roPtc.Data.hasInheritOrReportTask;
+ this._hasApplyMsg = roPtc.Data.hasMsg;
+ List<MentorBreakApplyInfo> appliedBreakInfos = roPtc.Data.appliedBreakInfos;
+ bool flag = appliedBreakInfos.Count > 0;
+ if (flag)
+ {
+ MentorBreakApplyInfo mentorBreakApplyInfo = appliedBreakInfos[0];
+ string arg = (mentorBreakApplyInfo.pos == EMentorRelationPosition.EMentorPosMaster) ? XSingleton<XStringTable>.singleton.GetString("Master") : XSingleton<XStringTable>.singleton.GetString("Pupil");
+ string text = XSingleton<XStringTable>.singleton.GetString("Break_Tell");
+ text = string.Format(text, arg, mentorBreakApplyInfo.roleName, XSingleton<UiUtility>.singleton.TimeDuarationFormatString(mentorBreakApplyInfo.breakTime, 5));
+ XSingleton<UiUtility>.singleton.ShowModalDialog(text, XStringDefineProxy.GetString("COMMON_OK"));
+ }
+ else
+ {
+ bool flag2 = pos != EMentorRelationPosition.EMentorPosMax && !this._hasApplyMsg;
+ if (flag2)
+ {
+ bool flag3 = roPtc.Data.pos == EMentorRelationPosition.EMentorPosStudent;
+ string @string;
+ string string2;
+ if (flag3)
+ {
+ @string = XSingleton<XStringTable>.singleton.GetString("ToGetStudent");
+ string2 = XSingleton<XStringTable>.singleton.GetString("ToGetStudentTip");
+ }
+ else
+ {
+ @string = XSingleton<XStringTable>.singleton.GetString("ToGetTeacher");
+ string2 = XSingleton<XStringTable>.singleton.GetString("ToGetTeacherTip");
+ }
+ XSingleton<UiUtility>.singleton.ShowModalDialog(XSingleton<XStringTable>.singleton.GetString("Mentorship"), string2, @string, XSingleton<XStringTable>.singleton.GetString("TempNoNeed"), new ButtonClickEventHandler(this.ToOpenNews), new ButtonClickEventHandler(this.ToNoShowing), true, XTempTipDefine.OD_START, 50);
+ }
+ }
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.RefreshH5ButtonState(XSysDefine.XSys_MentorshipMsg_Tip, true);
+ }
+
+ private bool ToNoShowing(IXUIButton button)
+ {
+ XSingleton<UiUtility>.singleton.CloseModalDlg();
+ this.SendUpdateMentorshopSetting("", true);
+ return true;
+ }
+
+ private bool ToOpenNews(IXUIButton button)
+ {
+ XSingleton<UiUtility>.singleton.CloseModalDlg();
+ bool flag = XMentorshipDocument.Doc.GetMyPossibleMentorship() == MyMentorship.Mentorship_Pupil;
+ if (flag)
+ {
+ XMentorshipDocument.Doc.SetCandidatesViewVisible(CandidatesViewType.Recommend, CandidatesViewRecommendType.Master);
+ XMentorshipDocument.Doc.SendToGetMyApplyMasterInfo(false);
+ }
+ else
+ {
+ XMentorshipDocument.Doc.SetCandidatesViewVisible(CandidatesViewType.Recommend, CandidatesViewRecommendType.Pupil);
+ XMentorshipDocument.Doc.SendToGetMyApplyPupilsInfo(false);
+ }
+ return true;
+ }
+
+ public MyMentorship GetMyPossibleMentorship()
+ {
+ uint level = XSingleton<XAttributeMgr>.singleton.XPlayerData.Level;
+ XLevelSealDocument specificDocument = XDocuments.GetSpecificDocument<XLevelSealDocument>(XLevelSealDocument.uuID);
+ uint sealType = specificDocument.GetSealType();
+ LevelSealTypeTable.RowData levelSealType = XLevelSealDocument.GetLevelSealType(sealType);
+ bool flag = levelSealType == null;
+ MyMentorship result;
+ if (flag)
+ {
+ result = MyMentorship.Mentorship_Master;
+ }
+ else
+ {
+ bool flag2 = (ulong)level >= (ulong)((long)levelSealType.ApplyStudentLevel);
+ if (flag2)
+ {
+ result = MyMentorship.Mentorship_Master;
+ }
+ else
+ {
+ result = MyMentorship.Mentorship_Pupil;
+ }
+ }
+ return result;
+ }
+
+ private void FireMentorOperationEvent(MentorRelationOpArg oArg, MentorRelationOpRes oRes)
+ {
+ XMentorRelationOpArgs @event = XEventPool<XMentorRelationOpArgs>.GetEvent();
+ @event.oArg = oArg;
+ @event.oRes = oRes;
+ @event.Firer = XSingleton<XGame>.singleton.Doc;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+
+ private void StartCountDown()
+ {
+ bool flag = this._countDownTimerID > 0u;
+ if (flag)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._countDownTimerID);
+ }
+ this._countDownTimerID = XSingleton<XTimerMgr>.singleton.SetTimerAccurate(1f, new XTimerMgr.AccurateElapsedEventHandler(this.TimerCD), null);
+ }
+
+ private void TimerCD(object param, float delay)
+ {
+ bool flag = this._myApplyMasterRefreshTime > 0;
+ if (flag)
+ {
+ this._myApplyMasterRefreshTime--;
+ }
+ bool flag2 = this._myApplyPupilRefreshTime > 0;
+ if (flag2)
+ {
+ this._myApplyPupilRefreshTime--;
+ }
+ this.RefreshViewCD();
+ bool flag3 = this._myApplyMasterRefreshTime <= 0 && this._myApplyPupilRefreshTime <= 0;
+ if (flag3)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._countDownTimerID);
+ this._countDownTimerID = 0u;
+ }
+ else
+ {
+ this.StartCountDown();
+ }
+ }
+
+ private void RefreshViewCD()
+ {
+ bool flag = this.CurViewType == CandidatesViewType.Recommend && DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.IsVisible();
+ if (flag)
+ {
+ bool flag2 = this.CurRecommendType == CandidatesViewRecommendType.Master;
+ if (flag2)
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshCDTimeLabel(this._myApplyMasterRefreshTime);
+ }
+ else
+ {
+ DlgBase<XMentorshipCandidatesView, XMentorshipCandidatesBehavior>.singleton.RefreshCDTimeLabel(this._myApplyPupilRefreshTime);
+ }
+ }
+ }
+ }
+}
|