diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/Team/XTeamDocument.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/Team/XTeamDocument.cs | 2016 |
1 files changed, 2016 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/Team/XTeamDocument.cs b/Client/Assets/Scripts/XMainClient/Team/XTeamDocument.cs new file mode 100644 index 00000000..fd662356 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Team/XTeamDocument.cs @@ -0,0 +1,2016 @@ +using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Threading;
+using KKSG;
+using UILib;
+using UnityEngine;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XTeamDocument : XDocComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XTeamDocument.uuID;
+ }
+ }
+
+ public List<XTeamBriefData> TeamList
+ {
+ get
+ {
+ return this._TeamList;
+ }
+ }
+
+ public XExpeditionDocument ExpDoc
+ {
+ get
+ {
+ bool flag = this.m_ExpDoc == null;
+ if (flag)
+ {
+ this.m_ExpDoc = XDocuments.GetSpecificDocument<XExpeditionDocument>(XExpeditionDocument.uuID);
+ }
+ return this.m_ExpDoc;
+ }
+ }
+
+ public bool bVoting
+ {
+ get
+ {
+ return this._bVoting;
+ }
+ }
+
+ public bool bAutoMatching
+ {
+ get
+ {
+ return this.m_bAutoMatching;
+ }
+ set
+ {
+ this.m_bAutoMatching = value;
+ }
+ }
+
+ public KMatchType SoloMatchType
+ {
+ get
+ {
+ return this.m_SoloMatchType;
+ }
+ }
+
+ public bool bSoloMatching
+ {
+ get
+ {
+ return this.m_SoloMatchType > KMatchType.KMT_NONE;
+ }
+ }
+
+ public bool bMatching
+ {
+ get
+ {
+ bool bInTeam = this.bInTeam;
+ bool result;
+ if (bInTeam)
+ {
+ result = (this._MyTeam.teamBrief.matchType > KMatchType.KMT_NONE);
+ }
+ else
+ {
+ result = this.bSoloMatching;
+ }
+ return result;
+ }
+ }
+
+ public XTeam MyTeam
+ {
+ get
+ {
+ return this._MyTeam;
+ }
+ set
+ {
+ this._MyTeam = value;
+ }
+ }
+
+ public bool bInTeam
+ {
+ get
+ {
+ return this._MyTeam != null;
+ }
+ }
+
+ public bool bIsLeader
+ {
+ get
+ {
+ return this._MyTeam != null && this._MyTeam.myData != null && this._MyTeam.myData.bIsLeader;
+ }
+ }
+
+ public bool bIsHelper
+ {
+ get
+ {
+ return this._MyTeam != null && this._MyTeam.myData != null && this._MyTeam.myData.bIsHelper;
+ }
+ }
+
+ public bool bIsTecket
+ {
+ get
+ {
+ return this._MyTeam != null && this._MyTeam.myData != null && this._MyTeam.myData.bIsTicket;
+ }
+ }
+
+ public int MatchingTime
+ {
+ get
+ {
+ return this.m_nMatchingTime;
+ }
+ }
+
+ public TeamBriefSortType TeamListSortType
+ {
+ get
+ {
+ return this.m_TeamListSortType;
+ }
+ set
+ {
+ bool flag = this.m_TeamListSortType != value;
+ if (flag)
+ {
+ this.m_TeamListSortDirection = XTeamBriefData.DefaultSortDirection[XFastEnumIntEqualityComparer<TeamBriefSortType>.ToInt(value)];
+ }
+ else
+ {
+ this.m_TeamListSortDirection = -this.m_TeamListSortDirection;
+ }
+ this.m_TeamListSortType = value;
+ }
+ }
+
+ public int TeamListSortDirection
+ {
+ get
+ {
+ return this.m_TeamListSortDirection;
+ }
+ }
+
+ public HashSet<int> TeamListSelectedCategories
+ {
+ get
+ {
+ return this.m_TeamListSelectedCategories;
+ }
+ }
+
+ public bool IsTarja
+ {
+ get
+ {
+ return this._tarja > 0u;
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("TeamDocument");
+
+ public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();
+
+ private static PveProfessionTable m_pveProfessionTables = new PveProfessionTable();
+
+ private static Dictionary<string, PveProfessionTable.RowData> m_pveProfessions = new Dictionary<string, PveProfessionTable.RowData>();
+
+ public XTeamListHandler TeamListView;
+
+ public XMyTeamHandler MyTeamView;
+
+ private List<XTeamBriefData> _TeamList = new List<XTeamBriefData>();
+
+ public XTeamListView AllListView;
+
+ public XTeamDungeonSelectorHandler DungeonSelector;
+
+ public ExpeditionTable.RowData currentExpInfo;
+
+ public uint currentDungeonID;
+
+ public string currentCategoryName;
+
+ public string currentDungeonName;
+
+ public TeamLevelType currentDungeonType = TeamLevelType.TeamLevelNone;
+
+ public string teamLeagueName;
+
+ private XExpeditionDocument m_ExpDoc = null;
+
+ public SceneTable.RowData currentSceneData;
+
+ public string password = "";
+
+ private bool _bVoting;
+
+ private bool m_bAutoMatching = false;
+
+ private KMatchType m_SoloMatchType = KMatchType.KMT_NONE;
+
+ private XTeam _MyTeam;
+
+ private bool bTryAutoJoin = false;
+
+ private static bool bFromHyperLink = false;
+
+ private float m_fMatchingTime = -1f;
+
+ private int m_nMatchingTime = -1;
+
+ private int m_AutoSelectFloatingLevel = -10;
+
+ private int m_TeamListSortDirection = 1;
+
+ private TeamBriefSortType m_TeamListSortType = TeamBriefSortType.TBST_MEMBER_COUNT;
+
+ private HashSet<int> m_TeamListSelectedCategories = new HashSet<int>();
+
+ private uint _tarja = 0u;
+
+ private bool m_bReqTeamListJustTarget;
+
+ private static ButtonClickEventHandler _EnterHandler = null;
+
+ private static IXUIButton _EnterButton = null;
+
+ private static bool _bCanEnter = false;
+
+ private static EventDelegate _EventDel;
+
+ private struct XPreviousTeamData
+ {
+ public TeamState state;
+
+ public int goldGroupIndex;
+
+ public int goldGroupItemID;
+
+ public bool bNewTeam;
+
+ public string leaderName;
+
+ public ExpeditionTable.RowData expData;
+
+ private XTeamDocument doc;
+
+ public XPreviousTeamData(XTeamDocument _doc)
+ {
+ this.doc = _doc;
+ this.state = TeamState.TEAM_WAITING;
+ this.goldGroupIndex = -1;
+ this.goldGroupItemID = 0;
+ this.bNewTeam = false;
+ this.leaderName = null;
+ this.expData = null;
+ }
+
+ public void PreserveTeamData(XTeam team)
+ {
+ this.state = team.teamBrief.actualState;
+ this.goldGroupIndex = team.teamBrief.goldGroup.index;
+ this.goldGroupItemID = team.teamBrief.goldGroup.itemid;
+ this.leaderName = team.teamBrief.leaderName;
+ this.expData = team.teamBrief.rowData;
+ }
+
+ public void CheckNewTeamData(XTeam team)
+ {
+ bool flag = this.state != team.teamBrief.actualState;
+ if (flag)
+ {
+ this.doc.ToggleVoting(team.teamBrief.actualState == TeamState.TEAM_VOTE);
+ }
+ bool flag2 = !this.bNewTeam && this.goldGroupIndex != team.teamBrief.goldGroup.index;
+ if (flag2)
+ {
+ int index = team.teamBrief.goldGroup.index;
+ bool flag3 = this.doc.currentExpInfo != null;
+ if (flag3)
+ {
+ bool flag4 = index < 0;
+ if (flag4)
+ {
+ bool flag5 = this.doc.MyTeam.myData.name == this.leaderName;
+ if (!flag5)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TeamGoldGroupTurnedOff"), "fece00");
+ }
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TeamGoldGroupTurnedOn", new object[]
+ {
+ XGoldGroupData.GetName(ref this.doc.currentExpInfo.CostType, index)
+ }), "fece00");
+ }
+ }
+ }
+ }
+ }
+
+ public void SortTeamListAndShow()
+ {
+ CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
+ Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(XSingleton<XGlobalConfig>.singleton.GetValue("Culture"));
+ bool bReqTeamListJustTarget = this.m_bReqTeamListJustTarget;
+ if (bReqTeamListJustTarget)
+ {
+ XTeamBriefData.dir = 1;
+ XTeamBriefData.sortType = TeamBriefSortType.TBST_MAX;
+ this._TeamList.Sort(new Comparison<XTeamBriefData>(XTeamBriefData.CompareToAccordingToRelation));
+ }
+ else
+ {
+ XTeamBriefData.dir = this.m_TeamListSortDirection;
+ XTeamBriefData.sortType = this.m_TeamListSortType;
+ this._TeamList.Sort();
+ }
+ Thread.CurrentThread.CurrentCulture = currentCulture;
+ bool flag = this.TeamListView != null && this.TeamListView.IsVisible();
+ if (flag)
+ {
+ this.TeamListView.RefreshPage();
+ }
+ bool flag2 = this.AllListView != null && this.AllListView.IsVisible();
+ if (flag2)
+ {
+ this.AllListView.RefreshPage();
+ }
+ }
+
+ public static void Execute(OnLoadedCallback callback = null)
+ {
+ XTeamDocument.AsyncLoader.AddTask("Table/PveProfession", XTeamDocument.m_pveProfessionTables, false);
+ XTeamDocument.AsyncLoader.Execute(callback);
+ }
+
+ public static string GetProfessionKey(uint profession, uint sceneid)
+ {
+ return XSingleton<XCommon>.singleton.StringCombine(profession.ToString(), "_", sceneid.ToString());
+ }
+
+ public static void OnTableLoaded()
+ {
+ XTeamDocument.m_pveProfessions.Clear();
+ int i = 0;
+ int num = XTeamDocument.m_pveProfessionTables.Table.Length;
+ while (i < num)
+ {
+ XTeamDocument.m_pveProfessions.Add(XTeamDocument.GetProfessionKey((uint)XTeamDocument.m_pveProfessionTables.Table[i].ProfessionID, XTeamDocument.m_pveProfessionTables.Table[i].SceneID), XTeamDocument.m_pveProfessionTables.Table[i]);
+ i++;
+ }
+ }
+
+ public void SetTarja(uint tarja)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("SetTarja:", tarja.ToString(), null, null, null, null);
+ this._tarja = tarja;
+ bool flag = this.MyTeamView != null && this.MyTeamView.IsVisible();
+ if (flag)
+ {
+ this.MyTeamView.RefreshPage();
+ }
+ bool flag2 = this.TeamListView != null && this.TeamListView.IsVisible();
+ if (flag2)
+ {
+ this.TeamListView.RefreshPage();
+ }
+ bool flag3 = this.AllListView != null && this.AllListView.IsVisible();
+ if (flag3)
+ {
+ this.AllListView.RefreshPage();
+ }
+ bool flag4 = this.DungeonSelector != null && this.DungeonSelector.IsVisible();
+ if (flag4)
+ {
+ this.DungeonSelector.RefreshData();
+ }
+ }
+
+ public static PveProfessionTable.RowData GetPveProfession(uint sceneID, uint profession)
+ {
+ bool flag = sceneID == 0u || profession == 0u;
+ PveProfessionTable.RowData result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ string professionKey = XTeamDocument.GetProfessionKey(profession, sceneID);
+ bool flag2 = !XTeamDocument.m_pveProfessions.ContainsKey(professionKey);
+ if (flag2)
+ {
+ result = null;
+ }
+ else
+ {
+ result = XTeamDocument.m_pveProfessions[professionKey];
+ }
+ }
+ return result;
+ }
+
+ public bool InTarja(uint profession)
+ {
+ return XTeamDocument.InTarja(this.currentDungeonID, profession);
+ }
+
+ public static bool InTarja(uint dungeonID, uint profession)
+ {
+ return XTeamDocument.GetPveProfession(dungeonID, profession) != null;
+ }
+
+ public bool ShowTarja(uint dungeonID)
+ {
+ bool isTarja = this.IsTarja;
+ bool result;
+ if (isTarja)
+ {
+ PveProfessionTable.RowData pveProfession = XTeamDocument.GetPveProfession(dungeonID, XSingleton<XAttributeMgr>.singleton.XPlayerData.TypeID);
+ bool flag = pveProfession == null;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XExpeditionDocument specificDocument = XDocuments.GetSpecificDocument<XExpeditionDocument>(XExpeditionDocument.uuID);
+ ExpeditionTable.RowData expeditionDataByID = specificDocument.GetExpeditionDataByID((int)dungeonID);
+ result = (expeditionDataByID != null && XSingleton<XAttributeMgr>.singleton.XPlayerData.GetAttr(XAttributeDefine.XAttr_POWER_POINT_Basic) < expeditionDataByID.DisplayPPT);
+ }
+ }
+ else
+ {
+ result = this.IsTarja;
+ }
+ return result;
+ }
+
+ public bool ShowTarja()
+ {
+ return this.ShowTarja(this.currentDungeonID);
+ }
+
+ public bool TryGetPveProfessionPPT(bool isTarja, uint profression, ref uint ppt)
+ {
+ bool flag = !isTarja;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ PveProfessionTable.RowData pveProfession = XTeamDocument.GetPveProfession(this.currentDungeonID, profression);
+ bool flag2 = pveProfession == null;
+ if (flag2)
+ {
+ result = false;
+ }
+ else
+ {
+ XExpeditionDocument specificDocument = XDocuments.GetSpecificDocument<XExpeditionDocument>(XExpeditionDocument.uuID);
+ ExpeditionTable.RowData expeditionDataByID = specificDocument.GetExpeditionDataByID((int)this.currentDungeonID);
+ bool flag3 = expeditionDataByID == null;
+ if (flag3)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag4 = ppt < expeditionDataByID.DisplayPPT;
+ if (flag4)
+ {
+ ppt = expeditionDataByID.DisplayPPT;
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ this._TeamList.Clear();
+ this.currentExpInfo = null;
+ this.currentDungeonID = 0u;
+ this.currentDungeonName = string.Empty;
+ this.currentCategoryName = string.Empty;
+ this.currentDungeonType = TeamLevelType.TeamLevelNone;
+ this.m_nMatchingTime = -1;
+ this.m_AutoSelectFloatingLevel = XSingleton<XGlobalConfig>.singleton.GetInt("TeamAutoSelectFloatingLevel");
+ this.m_SoloMatchType = KMatchType.KMT_NONE;
+ this.m_bAutoMatching = false;
+ this.TeamListSelectedCategories.Clear();
+ this.TeamListSelectedCategories.Add(0);
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.EventSubscribe();
+ base.RegisterEvent(XEventDefine.XEvent_JoinTeam, new XComponent.XEventHandler(this._OnJoinTeam));
+ base.RegisterEvent(XEventDefine.XEvent_LeaveTeam, new XComponent.XEventHandler(this._OnLeaveTeam));
+ base.RegisterEvent(XEventDefine.XEvent_FriendInfoChange, new XComponent.XEventHandler(this._OnFriendInfoChanged));
+ }
+
+ public void InitTeamListSelection()
+ {
+ bool flag = this.TeamListSelectedCategories.Contains(0) && this.TeamListSelectedCategories.Count == 1;
+ if (flag)
+ {
+ List<XTeamCategory> categories = this.ExpDoc.TeamCategoryMgr.m_Categories;
+ for (int i = 0; i < categories.Count; i++)
+ {
+ this.TeamListSelectedCategories.Add(categories[i].category);
+ }
+ }
+ }
+
+ private bool _OnJoinTeam(XEventArgs e)
+ {
+ DlgBase<XTeamConfirmView, XTeamConfirmBehaviour>.singleton.ClearInviteList();
+ return true;
+ }
+
+ private bool _OnLeaveTeam(XEventArgs e)
+ {
+ this.m_nMatchingTime = -1;
+ this.ToggleVoting(false);
+ bool flag = DlgBase<XTeamView, TabDlgBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XTeamView, TabDlgBehaviour>.singleton.ShowTeamView();
+ }
+ this._UpdateOtherUI();
+ return true;
+ }
+
+ private bool _OnFriendInfoChanged(XEventArgs e)
+ {
+ this.RefreshMyTeamView();
+ return true;
+ }
+
+ public override void OnEnterSceneFinally()
+ {
+ base.OnEnterSceneFinally();
+ bool flag = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
+ if (flag)
+ {
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._TaskNaviHandler.SetTeamMatching(this.bSoloMatching);
+ bool bInTeam = this.bInTeam;
+ if (bInTeam)
+ {
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._TaskNaviHandler.SetTeamMemberCount(this.MyTeam.members.Count);
+ }
+ else
+ {
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._TaskNaviHandler.SetTeamMemberCount(0);
+ }
+ }
+ else
+ {
+ bool flag2 = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.World;
+ if (flag2)
+ {
+ bool bInTeam2 = this.bInTeam;
+ if (bInTeam2)
+ {
+ bool flag3 = this.currentDungeonID != 2101u && this.currentDungeonID != 2102u && this.currentDungeonID != 2103u;
+ if (flag3)
+ {
+ XSingleton<XUICacheMgr>.singleton.CacheUI(XSysDefine.XSys_Team, EXStage.Hall);
+ }
+ }
+ }
+ }
+ }
+
+ public bool TryChangeToExpID(int expID)
+ {
+ bool flag = (ulong)this.currentDungeonID == (ulong)((long)expID);
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ bool bInTeam = this.bInTeam;
+ if (bInTeam)
+ {
+ bool bIsLeader = this.bIsLeader;
+ if (bIsLeader)
+ {
+ this.ReqTeamOp(TeamOperate.TEAM_CHANGE_EPXTEAMID, (ulong)((long)expID), null, TeamMemberType.TMT_NORMAL, null);
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ }
+ else
+ {
+ bool flag2 = this.currentDungeonID > 0u;
+ this._SetCurrentDungeon(expID);
+ bool flag3 = flag2;
+ if (flag3)
+ {
+ this.CancelMatch();
+ }
+ bool flag4 = this.TeamListView != null && this.TeamListView.IsVisible();
+ if (flag4)
+ {
+ this.TeamListView.OnCurrentDungeonChanged();
+ }
+ result = true;
+ }
+ }
+ return result;
+ }
+
+ public void TryAutoSelectExp()
+ {
+ bool flag = this.SoloMatchType > KMatchType.KMT_NONE;
+ if (flag)
+ {
+ TeamLevelType teamLevelType = XTeamDocument.MatchType2TeamType(this.SoloMatchType);
+ bool flag2 = teamLevelType > TeamLevelType.TeamLevelNone;
+ if (flag2)
+ {
+ List<ExpeditionTable.RowData> expeditionList = this.ExpDoc.GetExpeditionList(teamLevelType);
+ bool flag3 = expeditionList != null && expeditionList.Count > 0;
+ if (flag3)
+ {
+ bool flag4 = this.TryChangeToExpID(expeditionList[0].DNExpeditionID);
+ if (flag4)
+ {
+ return;
+ }
+ }
+ }
+ }
+ bool flag5 = this.currentDungeonID > 0u;
+ if (!flag5)
+ {
+ uint level = XSingleton<XAttributeMgr>.singleton.XPlayerData.Level;
+ int num = 0;
+ int num2 = int.MaxValue;
+ int num3 = int.MaxValue;
+ for (int i = 0; i < this.ExpDoc.TeamCategoryMgr.m_Categories.Count; i++)
+ {
+ XTeamCategory xteamCategory = this.ExpDoc.TeamCategoryMgr.m_Categories[i];
+ for (int j = 0; j < xteamCategory.expList.Count; j++)
+ {
+ ExpeditionTable.RowData rowData = xteamCategory.expList[j];
+ bool flag6 = rowData == null;
+ if (!flag6)
+ {
+ int num4 = Math.Abs((int)(rowData.DisplayLevel - level));
+ bool flag7 = num3 < num4;
+ if (!flag7)
+ {
+ bool flag8 = num4 == num3 && num2 < rowData.AutoSelectPriority;
+ if (!flag8)
+ {
+ bool flag9 = !xteamCategory.IsExpOpened(rowData);
+ if (!flag9)
+ {
+ num3 = num4;
+ num2 = rowData.AutoSelectPriority;
+ num = rowData.DNExpeditionID;
+ }
+ }
+ }
+ }
+ }
+ }
+ bool flag10 = num != 0;
+ if (flag10)
+ {
+ this.TryChangeToExpID(num);
+ }
+ }
+ }
+
+ private void _SetCurrentDungeon(int dungeonID)
+ {
+ ExpeditionTable.RowData expeditionDataByID = this.ExpDoc.GetExpeditionDataByID(dungeonID);
+ bool flag = expeditionDataByID != null;
+ if (flag)
+ {
+ TeamLevelType type = (TeamLevelType)expeditionDataByID.Type;
+ this._SetCurrentTeamInfo(expeditionDataByID);
+ this.currentSceneData = null;
+ uint sceneIDByExpID = this.ExpDoc.GetSceneIDByExpID(dungeonID);
+ this.currentSceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(sceneIDByExpID);
+ bool flag2 = type == TeamLevelType.TeamLevelTeamTower;
+ if (flag2)
+ {
+ this.ExpDoc.ExpeditionId = expeditionDataByID.DNExpeditionID;
+ }
+ }
+ }
+
+ private void _SetCurrentTeamInfo(ExpeditionTable.RowData rowData)
+ {
+ bool flag = this.currentDungeonID != (uint)rowData.DNExpeditionID;
+ if (flag)
+ {
+ bool flag2 = this.currentDungeonID == 0u;
+ this.currentExpInfo = rowData;
+ this.currentDungeonID = (uint)rowData.DNExpeditionID;
+ this.currentDungeonName = XExpeditionDocument.GetFullName(rowData);
+ this.currentDungeonType = (TeamLevelType)rowData.Type;
+ this.currentCategoryName = XTeamCategory.GetCategoryName(rowData.Category);
+ bool flag3 = !flag2 && this.bInTeam && !this.bIsLeader;
+ if (flag3)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TEAM_LEADER_CHANGE_EXP", new object[]
+ {
+ this.currentDungeonName
+ }), "fece00");
+ }
+ }
+ bool flag4 = this.MyTeamView != null && this.MyTeamView.IsVisible();
+ if (flag4)
+ {
+ this.MyTeamView.RefreshButtonStates();
+ }
+ bool flag5 = this.DungeonSelector != null && this.DungeonSelector.IsVisible();
+ if (flag5)
+ {
+ this.DungeonSelector.SetCurrentDungeon(true);
+ }
+ }
+
+ public XTeamBriefData GetTeamBriefByIndex(int index)
+ {
+ bool flag = index >= this._TeamList.Count;
+ XTeamBriefData result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ result = this._TeamList[index];
+ }
+ return result;
+ }
+
+ public XTeamBriefData GetTeamBriefByID(int teamID)
+ {
+ for (int i = 0; i < this._TeamList.Count; i++)
+ {
+ bool flag = this._TeamList[i].teamID == teamID;
+ if (flag)
+ {
+ return this._TeamList[i];
+ }
+ }
+ return null;
+ }
+
+ public void ReqTeamList(bool bJustTarget)
+ {
+ this.m_bReqTeamListJustTarget = bJustTarget;
+ if (bJustTarget)
+ {
+ bool flag = this.currentDungeonID > 0u;
+ if (flag)
+ {
+ RpcC2M_FetchTeamListC2M rpcC2M_FetchTeamListC2M = new RpcC2M_FetchTeamListC2M();
+ rpcC2M_FetchTeamListC2M.oArg.expID = this.currentDungeonID;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_FetchTeamListC2M);
+ }
+ }
+ else
+ {
+ bool flag2 = this.m_TeamListSelectedCategories.Count > 0;
+ if (flag2)
+ {
+ RpcC2M_FetchTeamListC2M rpcC2M_FetchTeamListC2M2 = new RpcC2M_FetchTeamListC2M();
+ foreach (int num in this.m_TeamListSelectedCategories)
+ {
+ bool flag3 = num != 0;
+ if (flag3)
+ {
+ rpcC2M_FetchTeamListC2M2.oArg.categoryID.Add((uint)num);
+ }
+ }
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_FetchTeamListC2M2);
+ }
+ else
+ {
+ this.ClearTeamList();
+ this.SortTeamListAndShow();
+ }
+ }
+ }
+
+ public void ClearTeamList()
+ {
+ for (int i = 0; i < this._TeamList.Count; i++)
+ {
+ this._TeamList[i].Recycle();
+ }
+ this._TeamList.Clear();
+ }
+
+ public void OnGetTeamList(FetchTeamListRes oRes)
+ {
+ this.ClearTeamList();
+ for (int i = 0; i < oRes.TheTeams.Count; i++)
+ {
+ TeamFullDataNtf teamFullDataNtf = oRes.TheTeams[i];
+ bool flag = teamFullDataNtf.teamBrief.teamState == 1;
+ if (!flag)
+ {
+ XTeamBriefData data = XDataPool<XTeamBriefData>.GetData();
+ data.SetData(teamFullDataNtf.teamBrief, this.ExpDoc);
+ data.SetMembers(teamFullDataNtf.members);
+ this._TeamList.Add(data);
+ }
+ }
+ this.SortTeamListAndShow();
+ bool flag2 = this.bTryAutoJoin;
+ if (flag2)
+ {
+ this._AutoJoin();
+ }
+ }
+
+ public void OnTeamInfoChanged(TeamChanged data)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("TeamInfoChanged", null, null, null, null, null);
+ XTeamDocument.XPreviousTeamData xpreviousTeamData = new XTeamDocument.XPreviousTeamData(this);
+ xpreviousTeamData.bNewTeam = false;
+ bool flag = this._MyTeam == null;
+ if (flag)
+ {
+ this._MyTeam = new XTeam();
+ xpreviousTeamData.bNewTeam = true;
+ }
+ xpreviousTeamData.PreserveTeamData(this._MyTeam);
+ this._MyTeam.PreUpdate();
+ this._MyTeam.teamBrief.SetData(data.teamBrief, this.ExpDoc);
+ bool flag2 = this._MyTeam.teamBrief.rowData == null;
+ if (flag2)
+ {
+ bool flag3 = xpreviousTeamData.bNewTeam || xpreviousTeamData.expData != null;
+ if (flag3)
+ {
+ XSingleton<UiUtility>.singleton.ShowModalDialog(XStringDefineProxy.GetString("LeaveTeamSinceNoConfig"), XStringDefineProxy.GetString(XStringDefine.COMMON_OK));
+ this.ReqTeamOp(TeamOperate.TEAM_LEAVE, 0UL, null, TeamMemberType.TMT_NORMAL, null);
+ }
+ }
+ else
+ {
+ for (int i = 0; i < data.leaveMember.Count; i++)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("Try Leave Teammember ", data.leaveMember[i].ToString(), null, null, null, null);
+ string text = this._MyTeam.RemoveMember(data.leaveMember[i]);
+ bool flag4 = this._MyTeam.teamBrief.matchType != KMatchType.KMT_NONE && this._MyTeam.teamBrief.matchType != KMatchType.KMT_EXP;
+ if (flag4)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TEAM_LEAVE_TEAM_MATCH", new object[]
+ {
+ text
+ }), "fece00");
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TEAM_LEAVE_TEAM", new object[]
+ {
+ text
+ }), "fece00");
+ }
+ }
+ for (int j = 0; j < data.addMember.Count; j++)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("Try Add Teammember ", data.addMember[j].memberID.ToString(), null, null, null, null);
+ this._MyTeam.AddMember(data.addMember[j]);
+ bool flag5 = !xpreviousTeamData.bNewTeam;
+ if (flag5)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TEAM_ADD_TEAM", new object[]
+ {
+ data.addMember[j].name
+ }), "fece00");
+ }
+ }
+ for (int k = 0; k < data.chgstateMember.Count; k++)
+ {
+ this._MyTeam.UpdateMember(data.chgstateMember[k]);
+ }
+ this._MyTeam.PostUpdate();
+ bool flag6 = this.MyTeam.members.Count > 1;
+ if (flag6)
+ {
+ XSingleton<XTutorialHelper>.singleton.HasTeam = true;
+ }
+ this._MyTeam.members.Sort();
+ this._PostTeamInfoChanged(xpreviousTeamData, data.teamBrief);
+ int num = data.addMember.Count - data.leaveMember.Count;
+ bool flag7 = num != 0;
+ if (flag7)
+ {
+ XTeamMemberCountChangedEventArgs @event = XEventPool<XTeamMemberCountChangedEventArgs>.GetEvent();
+ @event.oldCount = (uint)(this._MyTeam.members.Count - num);
+ @event.newCount = (uint)this._MyTeam.members.Count;
+ @event.Firer = XSingleton<XGame>.singleton.Doc;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+ }
+ }
+
+ private void _PostTeamInfoChanged(XTeamDocument.XPreviousTeamData previousData, TeamBrief brief)
+ {
+ this.teamLeagueName = brief.extrainfo.league_teamname;
+ bool flag = previousData.bNewTeam || this.currentDungeonID != this._MyTeam.teamBrief.dungeonID || this._MyTeam.bLeaderChanged;
+ if (flag)
+ {
+ this._SetCurrentDungeon((int)this._MyTeam.teamBrief.dungeonID);
+ }
+ bool bNewTeam = previousData.bNewTeam;
+ if (bNewTeam)
+ {
+ bool flag2 = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall && !XSingleton<XGame>.singleton.switchScene;
+ if (flag2)
+ {
+ bool flag3 = this.AllListView != null && this.AllListView.IsVisible();
+ if (flag3)
+ {
+ this.AllListView.SetVisibleWithAnimation(false, new DlgBase<XTeamListView, XTeamListBehaviour>.OnAnimationOver(DlgBase<XTeamView, TabDlgBehaviour>.singleton.ShowTeamView));
+ }
+ else
+ {
+ bool flag4 = DlgBase<XTeamInvitedListView, XTeamInvitedListBehaviour>.singleton.IsVisible();
+ if (flag4)
+ {
+ DlgBase<XTeamInvitedListView, XTeamInvitedListBehaviour>.singleton.SetVisibleWithAnimation(false, new DlgBase<XTeamInvitedListView, XTeamInvitedListBehaviour>.OnAnimationOver(DlgBase<XTeamView, TabDlgBehaviour>.singleton.ShowTeamView));
+ }
+ else
+ {
+ ExpeditionTable.RowData expeditionDataByID = this.ExpDoc.GetExpeditionDataByID((int)this.currentDungeonID);
+ bool flag5 = expeditionDataByID != null && XSingleton<XScene>.singleton.SceneType != SceneType.SKYCITY_WAITING;
+ if (flag5)
+ {
+ bool flag6 = expeditionDataByID.fastmatch == 0 || DlgBase<XTeamView, TabDlgBehaviour>.singleton.IsVisible();
+ if (flag6)
+ {
+ DlgBase<XTeamView, TabDlgBehaviour>.singleton.ShowTeamView();
+ }
+ }
+ }
+ }
+ XSingleton<XVirtualTab>.singleton.Cancel();
+ }
+ this.password = brief.password;
+ XJoinTeamEventArgs @event = XEventPool<XJoinTeamEventArgs>.GetEvent();
+ @event.dungeonID = this._MyTeam.teamBrief.dungeonID;
+ @event.Firer = XSingleton<XGame>.singleton.Doc;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+ previousData.CheckNewTeamData(this._MyTeam);
+ this.RefreshMyTeamView();
+ bool bVoting = this.bVoting;
+ if (bVoting)
+ {
+ DlgBase<XTeamBattleConfirmView, XTeamBattleConfirmBehaviour>.singleton.RefreshFightVote();
+ }
+ bool bMatching = this.bMatching;
+ if (bMatching)
+ {
+ bool flag7 = this.m_nMatchingTime < 0;
+ if (flag7)
+ {
+ this.m_nMatchingTime = 0;
+ this.m_fMatchingTime = Time.time;
+ }
+ }
+ else
+ {
+ this.m_nMatchingTime = -1;
+ }
+ this._UpdateOtherUI();
+ }
+
+ public void ReqTeamOp(TeamOperate op, ulong param = 0UL, object o = null, TeamMemberType memberType = TeamMemberType.TMT_NORMAL, string account = null)
+ {
+ XTeamDocument.bFromHyperLink = false;
+ bool flag = this._MyTeam == null;
+ if (flag)
+ {
+ bool flag2 = op == TeamOperate.TEAM_LEAVE || op == TeamOperate.TEAM_TOGGLE_READY;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Not in a team.", null, null, null, null, null);
+ return;
+ }
+ }
+ else
+ {
+ bool flag3 = this._MyTeam != null;
+ if (flag3)
+ {
+ bool flag4 = op == TeamOperate.TEAM_CREATE || op == TeamOperate.TEAM_JOIN;
+ if (flag4)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Already in a team.", null, null, null, null, null);
+ return;
+ }
+ }
+ }
+ RpcC2M_TeamRequestC2M rpcC2M_TeamRequestC2M = new RpcC2M_TeamRequestC2M();
+ switch (op)
+ {
+ case TeamOperate.TEAM_CREATE:
+ rpcC2M_TeamRequestC2M.oArg.expID = this.currentDungeonID;
+ rpcC2M_TeamRequestC2M.oArg.param = param;
+ rpcC2M_TeamRequestC2M.oArg.password = this.password;
+ goto IL_2CE;
+ case TeamOperate.TEAM_JOIN:
+ {
+ rpcC2M_TeamRequestC2M.oArg.teamID = (int)param;
+ XTeamBriefData teamBriefByID = this.GetTeamBriefByID((int)param);
+ bool flag5 = teamBriefByID != null;
+ if (flag5)
+ {
+ rpcC2M_TeamRequestC2M.oArg.expID = teamBriefByID.dungeonID;
+ }
+ rpcC2M_TeamRequestC2M.oArg.password = this.password;
+ goto IL_2CE;
+ }
+ case TeamOperate.TEAM_LEAVE:
+ rpcC2M_TeamRequestC2M.oArg.param = param;
+ goto IL_2CE;
+ case TeamOperate.TEAM_QUERYCOUNT:
+ goto IL_2CE;
+ case TeamOperate.TEAM_KICK:
+ case TeamOperate.TEAM_TRAHS_LEADER:
+ rpcC2M_TeamRequestC2M.oArg.roleid = param;
+ goto IL_2CE;
+ case TeamOperate.TEAM_START_BATTLE:
+ {
+ bool flag6 = o != null;
+ if (flag6)
+ {
+ TeamExtraInfo teamExtraInfo = new TeamExtraInfo();
+ teamExtraInfo.league_teamname = (o as string);
+ rpcC2M_TeamRequestC2M.oArg.extrainfo = teamExtraInfo;
+ }
+ goto IL_2CE;
+ }
+ case TeamOperate.TEAM_CHANGE_EPXTEAMID:
+ rpcC2M_TeamRequestC2M.oArg.expID = (uint)param;
+ goto IL_2CE;
+ case TeamOperate.TEAM_INVITE:
+ rpcC2M_TeamRequestC2M.oArg.roleid = param;
+ rpcC2M_TeamRequestC2M.oArg.account = account;
+ goto IL_2CE;
+ case TeamOperate.TEAM_START_MATCH:
+ case TeamOperate.TEAM_STOP_MATCH:
+ case TeamOperate.TEAM_DOWN_MATCH:
+ rpcC2M_TeamRequestC2M.oArg.expID = this.currentDungeonID;
+ rpcC2M_TeamRequestC2M.oArg.param = param;
+ goto IL_2CE;
+ case TeamOperate.TEAM_PPTLIMIT:
+ case TeamOperate.TEAM_COSTTYPE:
+ {
+ TeamExtraInfo teamExtraInfo2 = o as TeamExtraInfo;
+ bool flag7 = teamExtraInfo2 == null;
+ if (flag7)
+ {
+ return;
+ }
+ rpcC2M_TeamRequestC2M.oArg.extrainfo = teamExtraInfo2;
+ goto IL_2CE;
+ }
+ case TeamOperate.TEAM_CHANGE_PASSWORD:
+ rpcC2M_TeamRequestC2M.oArg.password = (o as string);
+ goto IL_2CE;
+ case TeamOperate.TEAM_MEMBER_TYPE:
+ rpcC2M_TeamRequestC2M.oArg.membertype = memberType;
+ goto IL_2CE;
+ }
+ bool flag8 = this._MyTeam == null;
+ if (flag8)
+ {
+ return;
+ }
+ rpcC2M_TeamRequestC2M.oArg.teamID = this._MyTeam.teamBrief.teamID;
+ rpcC2M_TeamRequestC2M.oArg.expID = this._MyTeam.teamBrief.dungeonID;
+ IL_2CE:
+ rpcC2M_TeamRequestC2M.oArg.request = op;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_TeamRequestC2M);
+ }
+
+ private string _GetRoleName(ulong roleID)
+ {
+ bool flag = XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID == roleID;
+ string result;
+ if (flag)
+ {
+ result = XStringDefineProxy.GetString("YOU");
+ }
+ else
+ {
+ bool flag2 = this.MyTeam != null;
+ if (flag2)
+ {
+ XTeamMember xteamMember = this.MyTeam.FindMember(roleID);
+ bool flag3 = xteamMember != null;
+ if (flag3)
+ {
+ result = xteamMember.name;
+ }
+ else
+ {
+ result = XStringDefineProxy.GetString("THIS_ROLE");
+ }
+ }
+ else
+ {
+ result = string.Empty;
+ }
+ }
+ return result;
+ }
+
+ public void ProcessTeamOPErrorCode(ErrorCode errcode, ulong roleID)
+ {
+ ErrorCode errorCode = errcode;
+ if (errorCode != ErrorCode.ERR_TEAM_NEED_ATLEAST_2_MEMBER)
+ {
+ if (errorCode != ErrorCode.ERR_TEAM_SERVER_OPEN_TIME)
+ {
+ bool flag = roleID > 0UL;
+ if (flag)
+ {
+ string text = this._GetRoleName(roleID);
+ bool flag2 = string.IsNullOrEmpty(text);
+ if (flag2)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(errcode, "fece00");
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString(string.Format("TEAM_{0}", errcode.ToString()), new object[]
+ {
+ text
+ }), "fece00");
+ }
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(errcode, "fece00");
+ }
+ }
+ }
+ else
+ {
+ string key = string.Format("TEAM_{0}", errcode.ToString());
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString(key, new object[]
+ {
+ this.currentExpInfo.PlayerLeastNumber
+ }), "fece00");
+ }
+ }
+
+ public void OnGetTeamOp(TeamOPArg oArg, TeamOPRes oRes)
+ {
+ bool flag = oRes.result > ErrorCode.ERR_SUCCESS;
+ if (flag)
+ {
+ this.ProcessTeamOPErrorCode(oRes.result, oRes.problem_roleid);
+ ErrorCode result = oRes.result;
+ if (result <= ErrorCode.ERR_SCENE_TODYCOUNTLIMIT)
+ {
+ if (result == ErrorCode.ERR_SCENE_NOFATIGUE)
+ {
+ bool flag2 = oRes.problem_roleid == 0UL || XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID == oRes.problem_roleid;
+ if (flag2)
+ {
+ DlgBase<XPurchaseView, XPurchaseBehaviour>.singleton.ReqQuickCommonPurchase(ItemEnum.FATIGUE);
+ }
+ goto IL_155;
+ }
+ if (result != ErrorCode.ERR_SCENE_TODYCOUNTLIMIT)
+ {
+ goto IL_155;
+ }
+ }
+ else if (result != ErrorCode.ERR_TEAM_NEST_DAYCOUNT)
+ {
+ if (result != ErrorCode.ERR_TEAM_SERVER_OPEN_TIME)
+ {
+ goto IL_155;
+ }
+ string text = this._GetRoleName(oRes.problem_roleid);
+ bool flag3 = text == null;
+ if (flag3)
+ {
+ text = string.Empty;
+ }
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<UiUtility>.singleton.TimeFormatSince1970((int)oRes.opentime, XStringDefineProxy.GetString("TEAM_ERR_TEAM_SERVER_OPEN_TIME", new object[]
+ {
+ text
+ }), true), "fece00");
+ goto IL_155;
+ }
+ bool flag4 = oRes.problem_roleid == 0UL || XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID == oRes.problem_roleid;
+ if (flag4)
+ {
+ ExpeditionTable.RowData expeditionDataByID = this.ExpDoc.GetExpeditionDataByID((int)oArg.expID);
+ bool flag5 = expeditionDataByID != null;
+ if (flag5)
+ {
+ TeamLevelType type = (TeamLevelType)expeditionDataByID.Type;
+ DlgBase<XBuyCountView, XBuyCountBehaviour>.singleton.PassiveShow(type);
+ }
+ }
+ IL_155:
+ TeamOperate request = oArg.request;
+ if (request == TeamOperate.TEAM_START_MATCH)
+ {
+ this.m_bAutoMatching = false;
+ }
+ }
+ else
+ {
+ TeamOperate request2 = oArg.request;
+ if (request2 <= TeamOperate.TEAM_STOP_MATCH)
+ {
+ switch (request2)
+ {
+ case TeamOperate.TEAM_CREATE:
+ {
+ bool flag6 = oArg.param > 0UL;
+ if (flag6)
+ {
+ this.ReqTeamOp(TeamOperate.TEAM_INVITE, oArg.param, null, TeamMemberType.TMT_NORMAL, null);
+ }
+ this.ExpDoc.TryShowPveAttrTips(oArg.expID);
+ break;
+ }
+ case TeamOperate.TEAM_JOIN:
+ this.TryChangeToExpID((int)oArg.expID);
+ break;
+ case TeamOperate.TEAM_LEAVE:
+ {
+ bool flag7 = oArg.param > 0UL;
+ if (flag7)
+ {
+ bool bHasPwd = (oArg.param & 4294967296UL) > 0UL;
+ ulong num = oArg.param & ulong.MaxValue;
+ XTeamView.TryJoinTeam((int)num, bHasPwd);
+ }
+ break;
+ }
+ default:
+ switch (request2)
+ {
+ case TeamOperate.TEAM_CHANGE_EPXTEAMID:
+ this._SetCurrentDungeon((int)oArg.expID);
+ break;
+ case TeamOperate.TEAM_INVITE:
+ {
+ bool flag8 = oArg.accountSpecified && !string.IsNullOrEmpty(oArg.account);
+ if (!flag8)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TEAM_INVITE_SUCCESS"), "fece00");
+ }
+ break;
+ }
+ case TeamOperate.TEAM_START_MATCH:
+ {
+ bool bAutoMatching = this.m_bAutoMatching;
+ if (bAutoMatching)
+ {
+ DlgBase<XTeamView, TabDlgBehaviour>.singleton.ShowTeamView();
+ }
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("BEGIN_MATCH"), "fece00");
+ break;
+ }
+ case TeamOperate.TEAM_STOP_MATCH:
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("CANCEL_MATCH"), "fece00");
+ break;
+ }
+ break;
+ }
+ }
+ else if (request2 != TeamOperate.TEAM_CHANGE_PASSWORD)
+ {
+ if (request2 == TeamOperate.TEAM_MEMBER_TYPE)
+ {
+ bool flag9 = TeamMemberType.TMT_USETICKET == oArg.membertype;
+ if (flag9)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("ERR_TEAM_TICKET_SUCCESS"), "fece00");
+ }
+ else
+ {
+ bool flag10 = TeamMemberType.TMT_HELPER == oArg.membertype;
+ if (flag10)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("SWITCH_TO_HELPER"), "fece00");
+ }
+ }
+ }
+ }
+ else
+ {
+ bool flag11 = string.IsNullOrEmpty(oArg.password);
+ if (flag11)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TEAM_REMOVE_PWD"), "fece00");
+ }
+ else
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TEAM_SET_PWD"), "fece00");
+ }
+ }
+ bool flag12 = XTeamDocument.bFromHyperLink;
+ if (flag12)
+ {
+ DlgBase<XTeamView, TabDlgBehaviour>.singleton.ShowTeamView();
+ }
+ }
+ }
+
+ public void OnLeaveTeam(LeaveTeamType errType)
+ {
+ bool flag = this._MyTeam == null;
+ if (flag)
+ {
+ bool flag2 = errType != LeaveTeamType.LTT_MS_CRASH;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Not in team now. Shouldnt receive leave team ptc.", null, null, null, null, null);
+ }
+ }
+ else
+ {
+ LeaveTeamType leaveTeamType = errType;
+ if (leaveTeamType != LeaveTeamType.LTT_BY_SELF)
+ {
+ if (leaveTeamType - LeaveTeamType.LTT_DEL_ROBOT > 1)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString(errType.ToString()), "fece00");
+ }
+ }
+ else
+ {
+ bool flag3 = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
+ if (flag3)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TEAM_LEAVE_TEAM", new object[]
+ {
+ XStringDefineProxy.GetString("YOU")
+ }), "fece00");
+ }
+ }
+ XLeaveTeamEventArgs @event = XEventPool<XLeaveTeamEventArgs>.GetEvent();
+ @event.dungeonID = this._MyTeam.teamBrief.dungeonID;
+ @event.Firer = XSingleton<XGame>.singleton.Doc;
+ this._MyTeam = null;
+ this.password = "";
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+ }
+
+ public void RefreshMyTeamView()
+ {
+ bool flag = this.MyTeamView != null && this.MyTeamView.IsVisible();
+ if (flag)
+ {
+ this.MyTeamView.RefreshPage();
+ }
+ }
+
+ public void RefreshRedPoint()
+ {
+ this._UpdateOtherUI();
+ }
+
+ private void _UpdateOtherUI()
+ {
+ bool flag = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded() && DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ bool flag2 = XSingleton<XScene>.singleton.SceneType != SceneType.SCENE_PVP && XSingleton<XScene>.singleton.SceneType != SceneType.SCENE_HEROBATTLE;
+ if (flag2)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.TeamMonitor.TeamInfoChangeOnBattle(this._MyTeam);
+ }
+ }
+ bool flag3 = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.IsVisible();
+ if (flag3)
+ {
+ bool flag4 = !DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._TaskNaviHandler.IsShowingTaskTab;
+ if (flag4)
+ {
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._TaskNaviHandler.TeamHandler.TeamInfoChange(this._MyTeam);
+ }
+ }
+ }
+
+ public override void Update(float fDeltaT)
+ {
+ base.Update(fDeltaT);
+ bool flag = this.MyTeam != null;
+ if (flag)
+ {
+ this.MyTeam.OnUpdate();
+ }
+ bool flag2 = this.m_nMatchingTime >= 0;
+ if (flag2)
+ {
+ int num = (int)(Time.time - this.m_fMatchingTime);
+ bool flag3 = num > this.m_nMatchingTime;
+ if (flag3)
+ {
+ this.m_nMatchingTime = num;
+ }
+ }
+ }
+
+ private void _AutoJoin()
+ {
+ this.bTryAutoJoin = false;
+ foreach (XTeamBriefData xteamBriefData in this._TeamList)
+ {
+ bool flag = xteamBriefData.state == XTeamState.TS_NOT_FULL;
+ if (flag)
+ {
+ this.ReqTeamOp(TeamOperate.TEAM_JOIN, (ulong)((long)xteamBriefData.teamID), null, TeamMemberType.TMT_NORMAL, null);
+ return;
+ }
+ }
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("TEAM_AUTOJOIN_FAILED"), "fece00");
+ }
+
+ public void ToggleVoting(bool bVote)
+ {
+ this._bVoting = bVote;
+ bool bVoting = this._bVoting;
+ if (bVoting)
+ {
+ DlgBase<XTeamBattleConfirmView, XTeamBattleConfirmBehaviour>.singleton.StartFightVote();
+ }
+ else
+ {
+ bool flag = !this.bInTeam || this.MyTeam.teamBrief.actualState != TeamState.TEAM_IN_BATTLE;
+ if (flag)
+ {
+ bool flag2 = DlgBase<XTeamBattleConfirmView, XTeamBattleConfirmBehaviour>.singleton.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XTeamBattleConfirmView, XTeamBattleConfirmBehaviour>.singleton.SetVisibleWithAnimation(false, null);
+ }
+ }
+ }
+ }
+
+ public static KMatchType TeamType2MatchType(TeamLevelType type)
+ {
+ KMatchType result;
+ if (type != TeamLevelType.TeamLevelCaptainPVP)
+ {
+ switch (type)
+ {
+ case TeamLevelType.TeamLevelHeroBattle:
+ return KMatchType.KMT_HERO;
+ case TeamLevelType.TeamLevelTeamLeague:
+ return KMatchType.KMT_LEAGUE;
+ case TeamLevelType.TeamLevelMultiPK:
+ return KMatchType.KMT_PKTWO;
+ case TeamLevelType.TeamLevelWeekendParty:
+ return KMatchType.KMT_WEEKEND_ACT;
+ case TeamLevelType.TeamLevelMoba:
+ return KMatchType.KMT_MOBA;
+ case TeamLevelType.TeamLevelCustomPKTwo:
+ return KMatchType.KMT_CUSTOM_PKTWO;
+ }
+ result = KMatchType.KMT_EXP;
+ }
+ else
+ {
+ result = KMatchType.KMT_PVP;
+ }
+ return result;
+ }
+
+ public static TeamLevelType MatchType2TeamType(KMatchType type)
+ {
+ switch (type)
+ {
+ case KMatchType.KMT_PVP:
+ return TeamLevelType.TeamLevelCaptainPVP;
+ case KMatchType.KMT_HERO:
+ return TeamLevelType.TeamLevelHeroBattle;
+ case KMatchType.KMT_LEAGUE:
+ return TeamLevelType.TeamLevelTeamLeague;
+ case KMatchType.KMT_PKTWO:
+ return TeamLevelType.TeamLevelMultiPK;
+ case KMatchType.KMT_MOBA:
+ return TeamLevelType.TeamLevelMoba;
+ case KMatchType.KMT_WEEKEND_ACT:
+ return TeamLevelType.TeamLevelWeekendParty;
+ case KMatchType.KMT_CUSTOM_PKTWO:
+ return TeamLevelType.TeamLevelCustomPKTwo;
+ }
+ return TeamLevelType.TeamLevelNone;
+ }
+
+ public bool IsSoloMatching(TeamLevelType type)
+ {
+ return this.SoloMatchType == XTeamDocument.TeamType2MatchType(type);
+ }
+
+ public bool IsMatching(TeamLevelType type)
+ {
+ bool bInTeam = this.bInTeam;
+ bool result;
+ if (bInTeam)
+ {
+ result = (this._MyTeam.teamBrief.matchType == XTeamDocument.TeamType2MatchType(type));
+ }
+ else
+ {
+ result = this.IsSoloMatching(type);
+ }
+ return result;
+ }
+
+ public void CancelMatch()
+ {
+ bool flag = this.bInTeam || !this.bSoloMatching;
+ if (!flag)
+ {
+ bool flag2 = this.SoloMatchType != KMatchType.KMT_EXP;
+ if (flag2)
+ {
+ TeamLevelType teamLevelType = XTeamDocument.MatchType2TeamType(this.SoloMatchType);
+ bool flag3 = teamLevelType == this.currentDungeonType;
+ if (flag3)
+ {
+ return;
+ }
+ }
+ KMatchType soloMatchType = this.SoloMatchType;
+ if (soloMatchType != KMatchType.KMT_EXP)
+ {
+ if (soloMatchType - KMatchType.KMT_PVP <= 1)
+ {
+ this.ReqMatchStateChange(this.SoloMatchType, KMatchOp.KMATCH_OP_STOP, false);
+ }
+ }
+ else
+ {
+ this.ReqTeamOp(TeamOperate.TEAM_STOP_MATCH, 0UL, null, TeamMemberType.TMT_NORMAL, null);
+ }
+ }
+ }
+
+ public void ForceMatching(bool matching)
+ {
+ bool flag = !matching;
+ if (flag)
+ {
+ this.ReqTeamOp(TeamOperate.TEAM_STOP_MATCH, 0UL, null, TeamMemberType.TMT_NORMAL, null);
+ this.m_bAutoMatching = false;
+ }
+ else
+ {
+ this.ReqTeamOp(TeamOperate.TEAM_START_MATCH, 0UL, null, TeamMemberType.TMT_NORMAL, null);
+ this.m_bAutoMatching = true;
+ }
+ }
+
+ public void SetAndMatch(int expid)
+ {
+ this.TryChangeToExpID(expid);
+ DlgBase<XTeamView, TabDlgBehaviour>.singleton.ShowTeamView();
+ }
+
+ public void ToggleMatching()
+ {
+ bool flag = this.IsMatching(this.currentDungeonType);
+ if (flag)
+ {
+ this.ReqTeamOp(TeamOperate.TEAM_STOP_MATCH, 0UL, null, TeamMemberType.TMT_NORMAL, null);
+ }
+ else
+ {
+ bool flag2 = this.currentDungeonType == TeamLevelType.TeamLevelTeamTower && this.ExpDoc.EnlargeMatch;
+ if (flag2)
+ {
+ this.ReqTeamOp(TeamOperate.TEAM_DOWN_MATCH, 0UL, null, TeamMemberType.TMT_NORMAL, null);
+ }
+ else
+ {
+ this.ReqTeamOp(TeamOperate.TEAM_START_MATCH, 0UL, null, TeamMemberType.TMT_NORMAL, null);
+ }
+ }
+ this.m_bAutoMatching = false;
+ }
+
+ private bool _ForceStart(IXUIButton btn)
+ {
+ this.ReqTeamOp(TeamOperate.TEAM_START_BATTLE_REMOVE_DISAGREE_MEMBER, 0UL, null, TeamMemberType.TMT_NORMAL, null);
+ XSingleton<UiUtility>.singleton.CloseModalDlg();
+ return true;
+ }
+
+ public int GetCurrentDayMaxCount()
+ {
+ return this.ExpDoc.GetDayMaxCount(this.currentDungeonType, this.currentSceneData);
+ }
+
+ public int GetMyDayCount()
+ {
+ return this.ExpDoc.GetDayCount(this.currentDungeonType, this.currentSceneData);
+ }
+
+ public void ReqSceneDayCount()
+ {
+ RpcC2G_QuerySceneDayCount rpcC2G_QuerySceneDayCount = new RpcC2G_QuerySceneDayCount();
+ rpcC2G_QuerySceneDayCount.oArg.type = 1u;
+ List<XTeamCategory> categories = this.ExpDoc.TeamCategoryMgr.m_Categories;
+ for (int i = 0; i < categories.Count; i++)
+ {
+ bool flag = !categories[i].HasOpened();
+ if (!flag)
+ {
+ List<ExpeditionTable.RowData> expList = categories[i].expList;
+ for (int j = 0; j < expList.Count; j++)
+ {
+ uint sceneIDByExpID = this.ExpDoc.GetSceneIDByExpID(expList[j].DNExpeditionID);
+ bool flag2 = sceneIDByExpID == 0u;
+ if (flag2)
+ {
+ break;
+ }
+ rpcC2G_QuerySceneDayCount.oArg.groupid.Add(sceneIDByExpID);
+ }
+ }
+ }
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_QuerySceneDayCount);
+ }
+
+ public void OnGetSceneDayCount(QuerySceneDayCountRes oRes)
+ {
+ bool flag = !DlgBase<XTeamView, TabDlgBehaviour>.singleton.IsVisible();
+ if (!flag)
+ {
+ this.TryAutoSelectExp();
+ }
+ }
+
+ protected override void OnReconnected(XReconnectedEventArgs arg)
+ {
+ RpcC2M_TeamRequestC2M rpcC2M_TeamRequestC2M = new RpcC2M_TeamRequestC2M();
+ rpcC2M_TeamRequestC2M.oArg.request = TeamOperate.TEAM_GET_FULL_DATA;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_TeamRequestC2M);
+ }
+
+ public void OnTeamFullDataNotify(TeamFullDataNtf data)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog("Team reconnect", null, null, null, null, null);
+ bool flag = !data.hasTeam && this.bInTeam;
+ if (flag)
+ {
+ this.OnLeaveTeam(LeaveTeamType.LTT_BY_SELF);
+ }
+ else
+ {
+ bool hasTeam = data.hasTeam;
+ if (hasTeam)
+ {
+ XTeamDocument.XPreviousTeamData previousData = new XTeamDocument.XPreviousTeamData(this);
+ bool flag2 = this.MyTeam == null;
+ if (flag2)
+ {
+ this._MyTeam = new XTeam();
+ previousData.bNewTeam = true;
+ }
+ previousData.PreserveTeamData(this._MyTeam);
+ this._MyTeam.Reset();
+ this._MyTeam.PreUpdate();
+ this._MyTeam.teamBrief.SetData(data.teamBrief, this.ExpDoc);
+ bool flag3 = this._MyTeam.teamBrief.rowData == null;
+ if (flag3)
+ {
+ XSingleton<UiUtility>.singleton.ShowModalDialog(XStringDefineProxy.GetString("LeaveTeamSinceNoConfig"), XStringDefineProxy.GetString(XStringDefine.COMMON_OK));
+ this.ReqTeamOp(TeamOperate.TEAM_LEAVE, 0UL, null, TeamMemberType.TMT_NORMAL, null);
+ }
+ else
+ {
+ for (int i = 0; i < data.members.Count; i++)
+ {
+ this._MyTeam.AddMember(data.members[i]);
+ }
+ this._MyTeam.PostUpdate();
+ bool flag4 = this.MyTeam.members.Count > 1;
+ if (flag4)
+ {
+ XSingleton<XTutorialHelper>.singleton.HasTeam = true;
+ }
+ this._MyTeam.members.Sort();
+ this._PostTeamInfoChanged(previousData, data.teamBrief);
+ }
+ }
+ }
+ }
+
+ public void ReqMatchStateChange(KMatchType type, KMatchOp op, bool isTeamMatch)
+ {
+ XSingleton<XDebug>.singleton.AddGreenLog(string.Concat(new object[]
+ {
+ "KKSG.KMatchType:",
+ type,
+ " KKSG.KMatchOp:",
+ op,
+ "\nisTeamMatch:",
+ isTeamMatch.ToString()
+ }), null, null, null, null, null);
+ RpcC2M_KMatchCommonReq rpcC2M_KMatchCommonReq = new RpcC2M_KMatchCommonReq();
+ rpcC2M_KMatchCommonReq.oArg.type = type;
+ rpcC2M_KMatchCommonReq.oArg.op = op;
+ rpcC2M_KMatchCommonReq.oArg.isteam = isTeamMatch;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_KMatchCommonReq);
+ }
+
+ public void OnRoleMatchStateNotify(RoleStateMatch matchData)
+ {
+ bool flag = matchData.matchtype > KMatchType.KMT_NONE;
+ if (flag)
+ {
+ bool flag2 = this.m_SoloMatchType != matchData.matchtype;
+ if (flag2)
+ {
+ this.m_nMatchingTime = 0;
+ this.m_fMatchingTime = Time.time;
+ }
+ }
+ else
+ {
+ this.m_nMatchingTime = -1;
+ }
+ this.m_SoloMatchType = matchData.matchtype;
+ bool flag3 = this.TeamListView != null && this.TeamListView.IsVisible();
+ if (flag3)
+ {
+ this.TeamListView.RefreshPage();
+ }
+ bool flag4 = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.IsLoaded();
+ if (flag4)
+ {
+ DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton._TaskNaviHandler.SetTeamMatching(this.bSoloMatching);
+ }
+ bool flag5 = DlgBase<XCaptainPVPView, XCaptainPVPBehaviour>.singleton.IsVisible();
+ if (flag5)
+ {
+ DlgBase<XCaptainPVPView, XCaptainPVPBehaviour>.singleton.RefreshButtonState();
+ }
+ bool flag6 = DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.IsVisible();
+ if (flag6)
+ {
+ DlgBase<HeroBattleDlg, HeroBattleBehaviour>.singleton.Refresh();
+ }
+ bool flag7 = DlgBase<MobaEntranceView, MobaEntranceBehaviour>.singleton.IsVisible();
+ if (flag7)
+ {
+ DlgBase<MobaEntranceView, MobaEntranceBehaviour>.singleton.RefreshMatch();
+ }
+ bool flag8 = DlgBase<XQualifyingView, XQualifyingBehaviour>.singleton.IsVisible();
+ if (flag8)
+ {
+ DlgBase<XQualifyingView, XQualifyingBehaviour>.singleton.RefreshMatch2v2Btn();
+ }
+ bool flag9 = DlgBase<ActivityWeekendPartyView, ActivityWeekendPartyBehaviour>.singleton.IsVisible();
+ if (flag9)
+ {
+ DlgBase<ActivityWeekendPartyView, ActivityWeekendPartyBehaviour>.singleton.RefreshMatchBtn();
+ }
+ }
+
+ public static bool GoSingleBattleBeforeNeed(ButtonClickEventHandler handler, IXUIButton btn)
+ {
+ XTeamDocument._EventDel = null;
+ XTeamDocument specificDocument = XDocuments.GetSpecificDocument<XTeamDocument>(XTeamDocument.uuID);
+ bool bCanEnter = XTeamDocument._bCanEnter;
+ bool result;
+ if (bCanEnter)
+ {
+ XTeamDocument._bCanEnter = false;
+ result = false;
+ }
+ else
+ {
+ XTeamDocument._EnterButton = btn;
+ XTeamDocument._EnterHandler = handler;
+ bool bInTeam = specificDocument.bInTeam;
+ if (bInTeam)
+ {
+ result = XTeamDocument.ShouldLeaveTeamFirst();
+ }
+ else
+ {
+ result = XTeamDocument.ShouldTips();
+ }
+ }
+ return result;
+ }
+
+ public static bool GoSingleBattleBeforeNeed(EventDelegate del)
+ {
+ XTeamDocument._EnterHandler = null;
+ XTeamDocument specificDocument = XDocuments.GetSpecificDocument<XTeamDocument>(XTeamDocument.uuID);
+ bool bCanEnter = XTeamDocument._bCanEnter;
+ bool result;
+ if (bCanEnter)
+ {
+ XTeamDocument._bCanEnter = false;
+ result = false;
+ }
+ else
+ {
+ XTeamDocument._EventDel = del;
+ bool bInTeam = specificDocument.bInTeam;
+ if (bInTeam)
+ {
+ result = XTeamDocument.ShouldLeaveTeamFirst();
+ }
+ else
+ {
+ result = XTeamDocument.ShouldTips();
+ }
+ }
+ return result;
+ }
+
+ public static bool ShouldTips()
+ {
+ bool flag = XSingleton<XScene>.singleton.SceneType == SceneType.SKYCITY_WAITING || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_HORSE || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_BIGMELEE_READY || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_BATTLEFIELD_READY;
+ bool result;
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowModalDialog(XStringDefineProxy.GetString("SKY_ARENA_LEAVE_SINGLE_TIP"), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL), new ButtonClickEventHandler(XTeamDocument._Enter));
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ return result;
+ }
+
+ public static bool ShouldLeaveTeamFirst()
+ {
+ bool flag = XSingleton<XScene>.singleton.SceneType == SceneType.SKYCITY_WAITING;
+ string @string;
+ if (flag)
+ {
+ @string = XStringDefineProxy.GetString("SKY_ARENA_LEAVE_TEAM_TIP");
+ }
+ else
+ {
+ @string = XStringDefineProxy.GetString("TEAM_SHOULD_LEAVE_TEAM_CONFIRM");
+ }
+ XSingleton<UiUtility>.singleton.ShowModalDialog(@string, XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL), new ButtonClickEventHandler(XTeamDocument._LeaveAndEnter));
+ return true;
+ }
+
+ private static bool _Enter(IXUIButton button)
+ {
+ XTeamDocument._bCanEnter = true;
+ bool flag = XTeamDocument._EnterHandler != null;
+ if (flag)
+ {
+ XTeamDocument._EnterHandler(XTeamDocument._EnterButton);
+ XTeamDocument._EnterHandler = null;
+ }
+ bool flag2 = XTeamDocument._EventDel != null;
+ if (flag2)
+ {
+ XTeamDocument._EventDel();
+ XTeamDocument._EventDel = null;
+ }
+ XSingleton<UiUtility>.singleton.CloseModalDlg();
+ return true;
+ }
+
+ private static bool _LeaveAndEnter(IXUIButton button)
+ {
+ XTeamDocument specificDocument = XDocuments.GetSpecificDocument<XTeamDocument>(XTeamDocument.uuID);
+ bool bInTeam = specificDocument.bInTeam;
+ if (bInTeam)
+ {
+ specificDocument.ReqTeamOp(TeamOperate.TEAM_LEAVE, 0UL, null, TeamMemberType.TMT_NORMAL, null);
+ }
+ XTeamDocument._bCanEnter = true;
+ bool flag = XTeamDocument._EnterHandler != null;
+ if (flag)
+ {
+ XTeamDocument._EnterHandler(XTeamDocument._EnterButton);
+ XTeamDocument._EnterHandler = null;
+ }
+ bool flag2 = XTeamDocument._EventDel != null;
+ if (flag2)
+ {
+ XTeamDocument._EventDel();
+ XTeamDocument._EventDel = null;
+ }
+ XSingleton<UiUtility>.singleton.CloseModalDlg();
+ return true;
+ }
+
+ public static void OnTeamHyperLinkClick(string param)
+ {
+ bool flag = XSingleton<XGame>.singleton.CurrentStage.Stage != EXStage.Hall;
+ if (!flag)
+ {
+ XTeamDocument specificDocument = XDocuments.GetSpecificDocument<XTeamDocument>(XTeamDocument.uuID);
+ bool bInTeam = specificDocument.bInTeam;
+ if (bInTeam)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(ErrorCode.ERR_TEAM_ALREADY_INTEAM, "fece00");
+ }
+ else
+ {
+ int teamID = 0;
+ uint num = 0u;
+ bool flag2 = !XLabelSymbolHelper.ParseTeamParam(param, ref teamID, ref num);
+ if (!flag2)
+ {
+ XExpeditionDocument specificDocument2 = XDocuments.GetSpecificDocument<XExpeditionDocument>(XExpeditionDocument.uuID);
+ ExpeditionTable.RowData expeditionDataByID = specificDocument2.GetExpeditionDataByID((int)num);
+ bool flag3 = expeditionDataByID == null;
+ if (flag3)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Invalid expedi ID ", num.ToString(), null, null, null, null);
+ }
+ else
+ {
+ bool flag4 = (long)expeditionDataByID.RequiredLevel > (long)((ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level);
+ if (flag4)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(ErrorCode.ERR_TEAM_LEVEL_REQUARE, "fece00");
+ }
+ else
+ {
+ XTeamDocument.bFromHyperLink = true;
+ RpcC2M_TeamRequestC2M rpcC2M_TeamRequestC2M = new RpcC2M_TeamRequestC2M();
+ rpcC2M_TeamRequestC2M.oArg.expID = num;
+ rpcC2M_TeamRequestC2M.oArg.teamID = teamID;
+ rpcC2M_TeamRequestC2M.oArg.request = TeamOperate.TEAM_JOIN;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2M_TeamRequestC2M);
+ specificDocument._SetCurrentTeamInfo(expeditionDataByID);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+}
|