mirror of
https://github.com/tym1116/BH3.git
synced 2025-12-16 16:34:41 +01:00
800 lines
21 KiB
C#
800 lines
21 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using proto;
|
|
|
|
namespace MoleMole
|
|
{
|
|
public class EndlessModule : BaseModule
|
|
{
|
|
private const int INVISIBLE_ITEM_ID = 70015;
|
|
|
|
private int UID;
|
|
|
|
public GetEndlessDataRsp endlessData;
|
|
|
|
private Dictionary<int, EndlessPlayerData> endlessPlayerDataDict;
|
|
|
|
private Dictionary<int, PlayerFriendBriefData> playerDataDict;
|
|
|
|
public GetEndlessTopGroupRsp topGroupData;
|
|
|
|
private DateTime _lastTimeGetTopGroupData = DateTime.Now.AddDays(-1.0);
|
|
|
|
private List<int> _playerRankList;
|
|
|
|
public Stack<EndlessWarInfo> warInfoList;
|
|
|
|
private Dictionary<int, EndlessItem> _playerItemDict;
|
|
|
|
private Dictionary<int, EndlessItemFrozenInfo> _itemFrozenInfoDict;
|
|
|
|
private Dictionary<int, EndlessAvatarHp> avatarHPDict;
|
|
|
|
public EndlessToolDataItem justBurstBombData;
|
|
|
|
private List<int> _promoteRankList;
|
|
|
|
private List<int> _normalRankList;
|
|
|
|
private List<int> _demoteRankList;
|
|
|
|
private List<EndlessToolDataItem> _waitToEffectToolDataList;
|
|
|
|
public int TopGroupLevel
|
|
{
|
|
get
|
|
{
|
|
return EndlessGroupMetaDataReader.GetItemList().Count;
|
|
}
|
|
}
|
|
|
|
public DateTime BeginTime
|
|
{
|
|
get
|
|
{
|
|
return Miscs.GetDateTimeFromTimeStamp(endlessData.begin_time);
|
|
}
|
|
}
|
|
|
|
public DateTime EndTime
|
|
{
|
|
get
|
|
{
|
|
return Miscs.GetDateTimeFromTimeStamp(endlessData.end_time);
|
|
}
|
|
}
|
|
|
|
public DateTime SettlementTime
|
|
{
|
|
get
|
|
{
|
|
return Miscs.GetDateTimeFromTimeStamp(endlessData.close_time);
|
|
}
|
|
}
|
|
|
|
public int CurrentRewardID
|
|
{
|
|
get
|
|
{
|
|
SetupRankList();
|
|
EndlessGroupMetaData endlessGroupMetaDataByKey = EndlessGroupMetaDataReader.GetEndlessGroupMetaDataByKey((int)endlessData.group_level);
|
|
foreach (int promoteRank in _promoteRankList)
|
|
{
|
|
if (UID == promoteRank)
|
|
{
|
|
return endlessGroupMetaDataByKey.prototeRewardID;
|
|
}
|
|
}
|
|
foreach (int normalRank in _normalRankList)
|
|
{
|
|
if (UID == normalRank)
|
|
{
|
|
return endlessGroupMetaDataByKey.normalRewardID;
|
|
}
|
|
}
|
|
foreach (int demoteRank in _demoteRankList)
|
|
{
|
|
if (UID == demoteRank)
|
|
{
|
|
return endlessGroupMetaDataByKey.demoteRewardID;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
public RankUpDownStatus CurrentRankStatus
|
|
{
|
|
get
|
|
{
|
|
SetupRankList();
|
|
foreach (int promoteRank in _promoteRankList)
|
|
{
|
|
if (UID == promoteRank)
|
|
{
|
|
return RankUpDownStatus.Up;
|
|
}
|
|
}
|
|
foreach (int normalRank in _normalRankList)
|
|
{
|
|
if (UID == normalRank)
|
|
{
|
|
return RankUpDownStatus.Stay;
|
|
}
|
|
}
|
|
foreach (int demoteRank in _demoteRankList)
|
|
{
|
|
if (UID == demoteRank)
|
|
{
|
|
return RankUpDownStatus.Down;
|
|
}
|
|
}
|
|
return RankUpDownStatus.Stay;
|
|
}
|
|
}
|
|
|
|
public int CurrentRank
|
|
{
|
|
get
|
|
{
|
|
SetupRankList();
|
|
List<int> rankListSorted = GetRankListSorted();
|
|
for (int i = 0; i < rankListSorted.Count; i++)
|
|
{
|
|
if (UID == rankListSorted[i])
|
|
{
|
|
return i + 1;
|
|
}
|
|
}
|
|
return 100;
|
|
}
|
|
}
|
|
|
|
public int CurrentFinishProgress
|
|
{
|
|
get
|
|
{
|
|
return (int)endlessPlayerDataDict[UID].progress;
|
|
}
|
|
}
|
|
|
|
public int currentGroupLevel
|
|
{
|
|
get
|
|
{
|
|
return (int)endlessData.group_level;
|
|
}
|
|
}
|
|
|
|
public int randomSeed
|
|
{
|
|
get
|
|
{
|
|
if (endlessData.random_seedSpecified)
|
|
{
|
|
return (int)endlessData.random_seed;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public int maxLevelEverReach
|
|
{
|
|
get
|
|
{
|
|
return (int)endlessPlayerDataDict[UID].max_progress;
|
|
}
|
|
}
|
|
|
|
private EndlessModule()
|
|
{
|
|
Singleton<NotifyManager>.Instance.RegisterModule(this);
|
|
UID = Singleton<PlayerModule>.Instance.playerData.userId;
|
|
endlessData = null;
|
|
endlessPlayerDataDict = new Dictionary<int, EndlessPlayerData>();
|
|
playerDataDict = new Dictionary<int, PlayerFriendBriefData>();
|
|
warInfoList = new Stack<EndlessWarInfo>();
|
|
_playerItemDict = new Dictionary<int, EndlessItem>();
|
|
_itemFrozenInfoDict = new Dictionary<int, EndlessItemFrozenInfo>();
|
|
_promoteRankList = new List<int>();
|
|
_normalRankList = new List<int>();
|
|
_demoteRankList = new List<int>();
|
|
_waitToEffectToolDataList = new List<EndlessToolDataItem>();
|
|
_playerRankList = new List<int>();
|
|
InitAvatarHPDict();
|
|
}
|
|
|
|
public override bool OnPacket(NetPacketV1 pkt)
|
|
{
|
|
switch (pkt.getCmdId())
|
|
{
|
|
case 140:
|
|
return OnGetEndlessDataRsp(pkt.getData<GetEndlessDataRsp>());
|
|
case 150:
|
|
return OnGetEndlessAvatarHpRsp(pkt.getData<GetEndlessAvatarHpRsp>());
|
|
case 151:
|
|
return OnEndlessPlayerDataUpdateNotify(pkt.getData<EndlessPlayerDataUpdateNotify>());
|
|
case 142:
|
|
return OnEndlessStageBeginRsp(pkt.getData<EndlessStageBeginRsp>());
|
|
case 144:
|
|
return OnEndlessStageEndRsp(pkt.getData<EndlessStageEndRsp>());
|
|
case 146:
|
|
return OnGetLastEndlessRewardDataRsp(pkt.getData<GetLastEndlessRewardDataRsp>());
|
|
case 153:
|
|
return OnEndlessWarInfoNotify(pkt.getData<EndlessWarInfoNotify>());
|
|
case 148:
|
|
return OnUseEndlessItemRsp(pkt.getData<UseEndlessItemRsp>());
|
|
case 152:
|
|
return OnEndlessItemDataUpdateNotify(pkt.getData<EndlessItemDataUpdateNotify>());
|
|
case 220:
|
|
return OnGetEndlessTopGroupRsp(pkt.getData<GetEndlessTopGroupRsp>());
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private bool OnGetEndlessDataRsp(GetEndlessDataRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0)
|
|
{
|
|
ClearData();
|
|
endlessData = rsp;
|
|
foreach (EndlessPlayerData item in rsp.endless_data_list)
|
|
{
|
|
if (item.uid == UID && item.is_just_bomb_burstSpecified)
|
|
{
|
|
EndlessPlayerData selfEndlessData = GetSelfEndlessData();
|
|
EndlessWaitBurstBomb val = null;
|
|
EndlessWaitBurstBomb bombData;
|
|
foreach (EndlessWaitBurstBomb item2 in selfEndlessData.wait_burst_bomb_list)
|
|
{
|
|
bombData = item2;
|
|
if (item.wait_burst_bomb_list.FindLast((EndlessWaitBurstBomb data) => data.item_id == bombData.item_id) == null)
|
|
{
|
|
val = bombData;
|
|
break;
|
|
}
|
|
}
|
|
justBurstBombData = new EndlessToolDataItem((int)val.item_id);
|
|
}
|
|
endlessPlayerDataDict[(int)item.uid] = item;
|
|
}
|
|
foreach (PlayerFriendBriefData item3 in rsp.brief_data_list)
|
|
{
|
|
playerDataDict[(int)item3.uid] = item3;
|
|
}
|
|
foreach (EndlessWarInfo item4 in rsp.war_info_list)
|
|
{
|
|
warInfoList.Push(item4);
|
|
}
|
|
foreach (EndlessItemFrozenInfo item5 in rsp.item_frozen_list)
|
|
{
|
|
_itemFrozenInfoDict[(int)item5.target_uid] = item5;
|
|
}
|
|
_playerItemDict.Clear();
|
|
foreach (EndlessItem item6 in rsp.item_list)
|
|
{
|
|
if (EndlessToolMetaDataReader.TryGetEndlessToolMetaDataByKey((int)item6.item_id) != null)
|
|
{
|
|
_playerItemDict[(int)item6.item_id] = item6;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void ClearData()
|
|
{
|
|
endlessPlayerDataDict.Clear();
|
|
playerDataDict.Clear();
|
|
warInfoList.Clear();
|
|
_playerItemDict.Clear();
|
|
_itemFrozenInfoDict.Clear();
|
|
_promoteRankList.Clear();
|
|
_normalRankList.Clear();
|
|
_demoteRankList.Clear();
|
|
_waitToEffectToolDataList.Clear();
|
|
_playerRankList.Clear();
|
|
endlessData = null;
|
|
}
|
|
|
|
private int GroupRankSortComparor(int palyerAUid, int PlayerBUid)
|
|
{
|
|
EndlessPlayerData val = endlessPlayerDataDict[palyerAUid];
|
|
EndlessPlayerData val2 = endlessPlayerDataDict[PlayerBUid];
|
|
if (val.progress != val2.progress)
|
|
{
|
|
return (int)(val2.progress - val.progress);
|
|
}
|
|
if (val.progress_time != val2.progress_time)
|
|
{
|
|
return (int)(val.progress_time - val2.progress_time);
|
|
}
|
|
return (int)(val.uid - val2.uid);
|
|
}
|
|
|
|
private int TopGroupRankSortComparor(EndlessPlayerData playerA, EndlessPlayerData playerB)
|
|
{
|
|
if (playerA.progress != playerB.progress)
|
|
{
|
|
return (int)(playerB.progress - playerA.progress);
|
|
}
|
|
if (playerA.progress_time != playerB.progress_time)
|
|
{
|
|
return (int)(playerA.progress_time - playerB.progress_time);
|
|
}
|
|
return (int)(playerA.uid - playerB.uid);
|
|
}
|
|
|
|
private bool OnGetEndlessAvatarHpRsp(GetEndlessAvatarHpRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0)
|
|
{
|
|
Dictionary<int, EndlessAvatarHp> dictionary = new Dictionary<int, EndlessAvatarHp>();
|
|
foreach (EndlessAvatarHp item in rsp.avatar_hp_list)
|
|
{
|
|
dictionary[(int)item.avatar_id] = item;
|
|
}
|
|
foreach (AvatarDataItem userAvatar in Singleton<AvatarModule>.Instance.UserAvatarList)
|
|
{
|
|
int avatarID = userAvatar.avatarID;
|
|
if (dictionary.ContainsKey(avatarID))
|
|
{
|
|
avatarHPDict[avatarID] = dictionary[avatarID];
|
|
continue;
|
|
}
|
|
EndlessAvatarHp val = avatarHPDict[avatarID];
|
|
val.hp_percent = 100u;
|
|
val.is_die = false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnEndlessPlayerDataUpdateNotify(EndlessPlayerDataUpdateNotify rsp)
|
|
{
|
|
if (rsp.player_data.uid == UID && rsp.player_data.is_just_bomb_burstSpecified)
|
|
{
|
|
EndlessPlayerData selfEndlessData = GetSelfEndlessData();
|
|
EndlessWaitBurstBomb val = null;
|
|
EndlessWaitBurstBomb bombData;
|
|
foreach (EndlessWaitBurstBomb item in selfEndlessData.wait_burst_bomb_list)
|
|
{
|
|
bombData = item;
|
|
if (rsp.player_data.wait_burst_bomb_list.FindLast((EndlessWaitBurstBomb data) => data.item_id == bombData.item_id) == null)
|
|
{
|
|
val = bombData;
|
|
break;
|
|
}
|
|
}
|
|
justBurstBombData = new EndlessToolDataItem((int)val.item_id);
|
|
}
|
|
endlessPlayerDataDict[(int)rsp.player_data.uid] = rsp.player_data;
|
|
foreach (PlayerFriendBriefData item2 in rsp.brief_data_list)
|
|
{
|
|
playerDataDict[(int)item2.uid] = item2;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnEndlessStageBeginRsp(EndlessStageBeginRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0 && rsp.progressSpecified)
|
|
{
|
|
endlessPlayerDataDict[UID].progress = rsp.progress;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnEndlessStageEndRsp(EndlessStageEndRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0 && rsp.progressSpecified)
|
|
{
|
|
endlessPlayerDataDict[UID].progress = rsp.progress;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnGetLastEndlessRewardDataRsp(GetLastEndlessRewardDataRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0 && rsp.reward_list.Count > 0)
|
|
{
|
|
Singleton<MiHoYoGameData>.Instance.LocalData.LastRewardData = rsp;
|
|
Singleton<MiHoYoGameData>.Instance.Save();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnEndlessWarInfoNotify(EndlessWarInfoNotify rsp)
|
|
{
|
|
warInfoList.Push(rsp.war_info);
|
|
return false;
|
|
}
|
|
|
|
private bool OnUseEndlessItemRsp(UseEndlessItemRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_001c: Expected O, but got Unknown
|
|
if ((int)rsp.retcode == 0 && rsp.target_uidSpecified)
|
|
{
|
|
EndlessItemFrozenInfo val = new EndlessItemFrozenInfo();
|
|
val.target_uid = rsp.target_uid;
|
|
val.frozen_time = rsp.item_frozen_time;
|
|
_itemFrozenInfoDict[(int)rsp.target_uid] = val;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnEndlessItemDataUpdateNotify(EndlessItemDataUpdateNotify rsp)
|
|
{
|
|
foreach (EndlessItem item in rsp.item_list)
|
|
{
|
|
if (EndlessToolMetaDataReader.TryGetEndlessToolMetaDataByKey((int)item.item_id) != null)
|
|
{
|
|
if (item.num < 1)
|
|
{
|
|
_playerItemDict.Remove((int)item.item_id);
|
|
}
|
|
else
|
|
{
|
|
_playerItemDict[(int)item.item_id] = item;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool OnGetEndlessTopGroupRsp(GetEndlessTopGroupRsp rsp)
|
|
{
|
|
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
|
|
if ((int)rsp.retcode == 0)
|
|
{
|
|
_lastTimeGetTopGroupData = TimeUtil.Now;
|
|
topGroupData = rsp;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void InitAvatarHPDict()
|
|
{
|
|
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_002e: Expected O, but got Unknown
|
|
avatarHPDict = new Dictionary<int, EndlessAvatarHp>();
|
|
foreach (AvatarDataItem userAvatar in Singleton<AvatarModule>.Instance.UserAvatarList)
|
|
{
|
|
EndlessAvatarHp val = new EndlessAvatarHp();
|
|
val.avatar_id = (uint)userAvatar.avatarID;
|
|
val.hp_percent = 100u;
|
|
val.next_recover_time = (uint)TimeUtil.Now.AddDays(1.0).Ticks;
|
|
val.is_die = false;
|
|
avatarHPDict[userAvatar.avatarID] = val;
|
|
}
|
|
}
|
|
|
|
public int GetAvatarRemainHP(int avatarId)
|
|
{
|
|
EndlessAvatarHp value;
|
|
avatarHPDict.TryGetValue(avatarId, out value);
|
|
if (value == null)
|
|
{
|
|
return -1;
|
|
}
|
|
return (int)value.hp_percent;
|
|
}
|
|
|
|
public EndlessAvatarHp GetEndlessAvatarHPData(int avatarId)
|
|
{
|
|
EndlessAvatarHp value;
|
|
avatarHPDict.TryGetValue(avatarId, out value);
|
|
if (value == null)
|
|
{
|
|
return null;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
public void SetAvatarHP(int avatarHPPercent, int avatarId)
|
|
{
|
|
EndlessAvatarHp value;
|
|
avatarHPDict.TryGetValue(avatarId, out value);
|
|
if (value != null)
|
|
{
|
|
value.hp_percent = (uint)avatarHPPercent;
|
|
}
|
|
}
|
|
|
|
public void CheckAllAvatarHPChanged()
|
|
{
|
|
foreach (EndlessAvatarHp value in avatarHPDict.Values)
|
|
{
|
|
CheckAvatarHPChanged(value);
|
|
}
|
|
}
|
|
|
|
public DateTime CheckAvatarHPChanged(EndlessAvatarHp avatarHPData)
|
|
{
|
|
if (avatarHPData.hp_percent < 100 && avatarHPData.next_recover_timeSpecified)
|
|
{
|
|
DateTime dateTimeFromTimeStamp = Miscs.GetDateTimeFromTimeStamp(avatarHPData.next_recover_time);
|
|
if (TimeUtil.Now >= dateTimeFromTimeStamp)
|
|
{
|
|
Singleton<NetworkManager>.Instance.RequestEndlessAvatarHp();
|
|
}
|
|
return dateTimeFromTimeStamp;
|
|
}
|
|
return DateTime.MinValue;
|
|
}
|
|
|
|
public PlayerFriendBriefData GetPlayerBriefData(int playerUid)
|
|
{
|
|
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_0017: Expected O, but got Unknown
|
|
if (!playerDataDict.ContainsKey(playerUid))
|
|
{
|
|
PlayerFriendBriefData val = new PlayerFriendBriefData();
|
|
val.nickname = LocalizationGeneralLogic.GetText("Menu_DefaultNickname", playerUid);
|
|
playerDataDict.Add(playerUid, val);
|
|
}
|
|
return playerDataDict[playerUid];
|
|
}
|
|
|
|
public EndlessPlayerData GetPlayerEndlessData(int playerUid)
|
|
{
|
|
return endlessPlayerDataDict[playerUid];
|
|
}
|
|
|
|
public EndlessPlayerData GetSelfEndlessData()
|
|
{
|
|
return endlessPlayerDataDict[UID];
|
|
}
|
|
|
|
public PlayerFriendBriefData GetTopGroupPlayerBriefData(int playerUid)
|
|
{
|
|
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
|
|
//IL_005b: Expected O, but got Unknown
|
|
foreach (PlayerFriendBriefData item in topGroupData.brief_data_list)
|
|
{
|
|
if (item.uid != playerUid)
|
|
{
|
|
continue;
|
|
}
|
|
return item;
|
|
}
|
|
PlayerFriendBriefData val = new PlayerFriendBriefData();
|
|
val.nickname = LocalizationGeneralLogic.GetText("Menu_DefaultNickname", playerUid);
|
|
return val;
|
|
}
|
|
|
|
public EndlessPlayerData GetTopGroupPlayerEndlessData(int playerUid)
|
|
{
|
|
foreach (EndlessPlayerData item in topGroupData.endless_data_list)
|
|
{
|
|
if (item.uid == playerUid)
|
|
{
|
|
return item;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public EndlessActivityStatus GetEndlessActivityStatus()
|
|
{
|
|
if (TimeUtil.Now < BeginTime)
|
|
{
|
|
return EndlessActivityStatus.WaitToStart;
|
|
}
|
|
if (TimeUtil.Now < EndTime)
|
|
{
|
|
return EndlessActivityStatus.InProgress;
|
|
}
|
|
if (TimeUtil.Now < SettlementTime)
|
|
{
|
|
return EndlessActivityStatus.WaitToSettlement;
|
|
}
|
|
if (TimeUtil.Now >= SettlementTime)
|
|
{
|
|
Singleton<NetworkManager>.Instance.RequestEndlessData();
|
|
return EndlessActivityStatus.None;
|
|
}
|
|
return EndlessActivityStatus.None;
|
|
}
|
|
|
|
public DateTime GetFrozenEndTime(int targetUid)
|
|
{
|
|
EndlessItemFrozenInfo value;
|
|
_itemFrozenInfoDict.TryGetValue(targetUid, out value);
|
|
if (value == null)
|
|
{
|
|
return TimeUtil.Now.AddDays(-1.0);
|
|
}
|
|
return Miscs.GetDateTimeFromTimeStamp(value.frozen_time);
|
|
}
|
|
|
|
public List<EndlessItem> GetPlayerEndlessItemList()
|
|
{
|
|
List<EndlessItem> list = new List<EndlessItem>(_playerItemDict.Values);
|
|
list.Sort((EndlessItem left, EndlessItem right) => (int)(left.item_id - right.item_id));
|
|
return list;
|
|
}
|
|
|
|
public List<int> GetRankListSorted()
|
|
{
|
|
_playerRankList.Clear();
|
|
foreach (EndlessPlayerData value in endlessPlayerDataDict.Values)
|
|
{
|
|
_playerRankList.Add((int)value.uid);
|
|
}
|
|
_playerRankList.Sort(GroupRankSortComparor);
|
|
return _playerRankList;
|
|
}
|
|
|
|
public List<EndlessToolDataItem> GetAppliedToolDataList()
|
|
{
|
|
_waitToEffectToolDataList.Clear();
|
|
List<EndlessWaitEffectItem> wait_effect_item_list = endlessPlayerDataDict[UID].wait_effect_item_list;
|
|
List<EndlessWaitBurstBomb> wait_burst_bomb_list = endlessPlayerDataDict[UID].wait_burst_bomb_list;
|
|
for (int i = 0; i < wait_effect_item_list.Count; i++)
|
|
{
|
|
EndlessWaitEffectItem val = wait_effect_item_list[i];
|
|
EndlessToolDataItem item = new EndlessToolDataItem((int)val.item_id);
|
|
_waitToEffectToolDataList.Add(item);
|
|
}
|
|
foreach (EndlessWaitBurstBomb item3 in wait_burst_bomb_list)
|
|
{
|
|
EndlessToolDataItem item2 = new EndlessToolDataItem((int)item3.item_id);
|
|
_waitToEffectToolDataList.Add(item2);
|
|
}
|
|
if (SelfInvisible())
|
|
{
|
|
_waitToEffectToolDataList.Add(new EndlessToolDataItem(70015));
|
|
}
|
|
return _waitToEffectToolDataList;
|
|
}
|
|
|
|
private void SetupRankList()
|
|
{
|
|
EndlessGroupMetaData endlessGroupMetaDataByKey = EndlessGroupMetaDataReader.GetEndlessGroupMetaDataByKey((int)endlessData.group_level);
|
|
int num = 0;
|
|
int num2 = 0;
|
|
List<int> rankListSorted = GetRankListSorted();
|
|
for (num2 = 0; num + num2 < rankListSorted.Count && GetPlayerEndlessData(rankListSorted[num + num2]).progress != 0 && num + num2 < endlessGroupMetaDataByKey.promoteRank; num2++)
|
|
{
|
|
}
|
|
_promoteRankList = rankListSorted.GetRange(num, num2);
|
|
num += num2;
|
|
for (num2 = 0; num + num2 < rankListSorted.Count && (endlessGroupMetaDataByKey.groupLevel <= 1 || GetPlayerEndlessData(rankListSorted[num + num2]).progress != 0) && num + num2 < endlessGroupMetaDataByKey.demoteRank - 1; num2++)
|
|
{
|
|
}
|
|
_normalRankList = rankListSorted.GetRange(num, num2);
|
|
num += num2;
|
|
for (num2 = 0; num + num2 < rankListSorted.Count; num2++)
|
|
{
|
|
}
|
|
_demoteRankList = rankListSorted.GetRange(num, num2);
|
|
}
|
|
|
|
private void SetupTopGroupRankList()
|
|
{
|
|
if (CanSeeTopGroupInfo())
|
|
{
|
|
EndlessGroupMetaData endlessGroupMetaDataByKey = EndlessGroupMetaDataReader.GetEndlessGroupMetaDataByKey(TopGroupLevel);
|
|
int num = 0;
|
|
int num2 = 0;
|
|
List<EndlessPlayerData> endless_data_list = topGroupData.endless_data_list;
|
|
endless_data_list.Sort(TopGroupRankSortComparor);
|
|
for (num2 = 0; num + num2 < endless_data_list.Count && endless_data_list[num + num2].progress != 0 && num + num2 < endlessGroupMetaDataByKey.promoteRank; num2++)
|
|
{
|
|
}
|
|
_promoteRankList.Clear();
|
|
for (int i = 0; i < num2; i++)
|
|
{
|
|
_promoteRankList.Add((int)endless_data_list[num + i].uid);
|
|
}
|
|
num += num2;
|
|
for (num2 = 0; num + num2 < endless_data_list.Count && (endlessGroupMetaDataByKey.groupLevel <= 1 || endless_data_list[num + num2].progress != 0) && num + num2 < endlessGroupMetaDataByKey.demoteRank - 1; num2++)
|
|
{
|
|
}
|
|
_normalRankList.Clear();
|
|
for (int j = 0; j < num2; j++)
|
|
{
|
|
_normalRankList.Add((int)endless_data_list[num + j].uid);
|
|
}
|
|
num += num2;
|
|
for (num2 = 0; num + num2 < endless_data_list.Count; num2++)
|
|
{
|
|
}
|
|
_demoteRankList.Clear();
|
|
for (int k = 0; k < num2; k++)
|
|
{
|
|
_demoteRankList.Add((int)endless_data_list[num + k].uid);
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<int> GetPromoteRank(EndlessMainPageContext.ViewStatus viewStatus = EndlessMainPageContext.ViewStatus.ShowCurrentGroup)
|
|
{
|
|
switch (viewStatus)
|
|
{
|
|
case EndlessMainPageContext.ViewStatus.ShowCurrentGroup:
|
|
SetupRankList();
|
|
break;
|
|
case EndlessMainPageContext.ViewStatus.ShowTopGroup:
|
|
SetupTopGroupRankList();
|
|
break;
|
|
}
|
|
return _promoteRankList;
|
|
}
|
|
|
|
public List<int> GetNormalRank(EndlessMainPageContext.ViewStatus viewStatus = EndlessMainPageContext.ViewStatus.ShowCurrentGroup)
|
|
{
|
|
switch (viewStatus)
|
|
{
|
|
case EndlessMainPageContext.ViewStatus.ShowCurrentGroup:
|
|
SetupRankList();
|
|
break;
|
|
case EndlessMainPageContext.ViewStatus.ShowTopGroup:
|
|
SetupTopGroupRankList();
|
|
break;
|
|
}
|
|
return _normalRankList;
|
|
}
|
|
|
|
public List<int> GetDemoteRank(EndlessMainPageContext.ViewStatus viewStatus = EndlessMainPageContext.ViewStatus.ShowCurrentGroup)
|
|
{
|
|
switch (viewStatus)
|
|
{
|
|
case EndlessMainPageContext.ViewStatus.ShowCurrentGroup:
|
|
SetupRankList();
|
|
break;
|
|
case EndlessMainPageContext.ViewStatus.ShowTopGroup:
|
|
SetupTopGroupRankList();
|
|
break;
|
|
}
|
|
return _demoteRankList;
|
|
}
|
|
|
|
public bool CanRequestTopGroupInfo()
|
|
{
|
|
if (endlessData.cur_top_group_level < TopGroupLevel || endlessData.group_level == TopGroupLevel)
|
|
{
|
|
return false;
|
|
}
|
|
if (topGroupData == null)
|
|
{
|
|
return true;
|
|
}
|
|
if (_lastTimeGetTopGroupData.AddHours(1.0) < TimeUtil.Now)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool CanSeeTopGroupInfo()
|
|
{
|
|
return endlessData.cur_top_group_level == TopGroupLevel && endlessData.group_level != TopGroupLevel;
|
|
}
|
|
|
|
public bool PlayerInvisible(int uid)
|
|
{
|
|
EndlessPlayerData val = endlessPlayerDataDict[uid];
|
|
if (val.hidden_expire_timeSpecified && Miscs.GetDateTimeFromTimeStamp(val.hidden_expire_time) > TimeUtil.Now)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool SelfInvisible()
|
|
{
|
|
return PlayerInvisible(UID);
|
|
}
|
|
}
|
|
}
|