using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text.RegularExpressions;
|
using LitJson;
|
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace vnxbqy.UI
|
{
|
|
public class FairyLeagueModel : Model, IAfterPlayerDataInitialize, IBeforePlayerDataInitialize, IPlayerLoginOk, IOpenServerActivity
|
{
|
public event Action OnRefreshFairyLeagueEvent;
|
|
public FairyLeagueWeekTime currentWeekTime
|
{
|
get
|
{
|
if (TimeUtility.IsMixServer && TimeUtility.MixOpenDay < GeneralDefine.mixServerCustomDays)
|
{
|
var week = GetMixServerWeek(TimeUtility.MixOpenDay);
|
var lastWeek = GetMixServerWeek(GeneralDefine.mixServerCustomDays - 1);
|
if (mixServerWeekTimes.ContainsKey(week)
|
&& (week < lastWeek || TimeUtility.MixOpenDay <= mixServerWeekTimes[week].lastMixServerDay))
|
{
|
return mixServerWeekTimes[week];
|
}
|
if (week < lastWeek)
|
{
|
return null;
|
}
|
else if (week == lastWeek)
|
{
|
var date = TimeUtility.ServerNow.AddTicks(-TimeUtility.MixOpenDay * TimeSpan.TicksPerDay);
|
var lastDayOfWeek = date.AddTicks((GeneralDefine.mixServerCustomDays - 1) * TimeSpan.TicksPerDay).DayOfWeek;
|
var dayOfWeek = lastDayOfWeek == DayOfWeek.Sunday ? 7 : (int)lastDayOfWeek;
|
if (dayOfWeek >= fairyLeagueWeekTime.rings[0].dayOfWeek)
|
{
|
return null;
|
}
|
}
|
}
|
var openServerWeekDay = TimeUtility.openServerDayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.openServerDayOfWeek;
|
if (specialLeagueTimes.ContainsKey(openServerWeekDay))
|
{
|
var dict = specialLeagueTimes[openServerWeekDay];
|
var weekCount = TimeUtility.OpenWeekCnt;
|
if (dict.ContainsKey(weekCount))
|
{
|
return dict[weekCount];
|
}
|
}
|
if (TimeUtility.OpenWeekCnt < 1)
|
{
|
return null;
|
}
|
return fairyLeagueWeekTime;
|
}
|
}
|
|
public FairyLeagueWeekTime nextWeekTime
|
{
|
get
|
{
|
if (TimeUtility.IsMixServer && TimeUtility.MixOpenDay < GeneralDefine.mixServerCustomDays)
|
{
|
var week = GetMixServerWeek(TimeUtility.MixOpenDay);
|
if (mixServerWeekTimes.ContainsKey(week + 1))
|
{
|
return mixServerWeekTimes[week + 1];
|
}
|
}
|
var openServerWeekDay = TimeUtility.openServerDayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.openServerDayOfWeek;
|
if (specialLeagueTimes.ContainsKey(openServerWeekDay))
|
{
|
var dict = specialLeagueTimes[openServerWeekDay];
|
var weekCount = TimeUtility.OpenWeekCnt + 1;
|
if (dict.ContainsKey(weekCount))
|
{
|
return dict[weekCount];
|
}
|
}
|
return fairyLeagueWeekTime;
|
}
|
}
|
|
FairyLeagueStage cacheLeagueStage = FairyLeagueStage.Prepare;
|
|
public FairyLeagueStage fairyLeagueStage
|
{
|
get
|
{
|
if (currentWeekTime == null)
|
{
|
return FairyLeagueStage.Prepare;
|
}
|
return currentWeekTime.fairyLeagueStage;
|
}
|
}
|
|
public int fairyLeagueSession
|
{
|
get
|
{
|
if (currentWeekTime == null)
|
{
|
return 0;
|
}
|
return currentWeekTime.currentSession;
|
}
|
}
|
|
public int fairyLeagueRing
|
{
|
get
|
{
|
if (currentWeekTime == null)
|
{
|
return 0;
|
}
|
return currentWeekTime.currentRing;
|
}
|
}
|
|
public int OpenServerWeek
|
{
|
get;
|
private set;
|
}
|
|
public bool IsNextWeek
|
{
|
get
|
{
|
if (currentWeekTime == null)
|
{
|
return true;
|
}
|
return currentWeekTime.IsNextWeek;
|
}
|
}
|
|
bool serverInited = false;
|
|
FairyModel fairyModel { get { return ModelCenter.Instance.GetModel<FairyModel>(); } }
|
|
public override void Init()
|
{
|
ParseConfig();
|
m_JoinFairyLeagueRedpoint = new Redpoint(10704, 1070401);
|
TimeUtility.OnServerOpenDayRefresh += OnServerOpenDayRefresh;
|
DTCA003_tagUniversalGameRecInfo.onGetUniversalGameInfo += OnGetUniversalGameInfo;
|
PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
|
StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
|
TimeMgr.Instance.OnMinuteEvent += MinuteEvent;
|
TimeMgr.Instance.OnDayEvent += DayEvent;
|
fairyLeagueHelp = new FairyLeagueHelp();
|
OpenServerActivityCenter.Instance.Register(12, this);
|
}
|
|
public override void UnInit()
|
{
|
DTCA003_tagUniversalGameRecInfo.onGetUniversalGameInfo -= OnGetUniversalGameInfo;
|
TimeMgr.Instance.OnMinuteEvent -= MinuteEvent;
|
TimeMgr.Instance.OnDayEvent -= DayEvent;
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
ClearFairyWarHelp();
|
frontFairyList.Clear();
|
mixServerWeekTimes.Clear();
|
fairyLeagueFairyId = 0;
|
fairyLeagueFairyName = string.Empty;
|
afterGroupWorldLevel = 0;
|
serverInited = false;
|
}
|
|
public void OnAfterPlayerDataInitialize()
|
{
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
ParseMixServerLeagueTimes();
|
ResetFairyLeagueTime();
|
cacheLeagueStage = fairyLeagueStage;
|
CheckFairyLeagueData();
|
UpdateRedpoint();
|
UpdateNoticeRedpoint();
|
serverInited = true;
|
}
|
|
private void OnServerOpenDayRefresh()
|
{
|
ParseMixServerLeagueTimes();
|
ResetFairyLeagueTime();
|
cacheLeagueStage = fairyLeagueStage;
|
CheckFairyLeagueData();
|
UpdateRedpoint();
|
}
|
|
private void DayEvent()
|
{
|
ResetFairyLeagueTime();
|
}
|
|
private void MinuteEvent()
|
{
|
if (!(StageLoad.Instance.currentStage is DungeonStage) || !serverInited)
|
{
|
return;
|
}
|
if (cacheLeagueStage != fairyLeagueStage)
|
{
|
cacheLeagueStage = fairyLeagueStage;
|
if (cacheLeagueStage != FairyLeagueStage.Prepare)
|
{
|
CheckFairyLeagueData();
|
}
|
if (OnRefreshFairyLeagueEvent != null)
|
{
|
OnRefreshFairyLeagueEvent();
|
}
|
UpdateNoticeRedpoint();
|
}
|
}
|
|
void ResetFairyLeagueTime()
|
{
|
if (OnRefreshFairyLeagueEvent != null)
|
{
|
OnRefreshFairyLeagueEvent();
|
}
|
}
|
|
private void PlayerDataRefreshInfoEvent(PlayerDataType _type)
|
{
|
if (_type == PlayerDataType.MapID)
|
{
|
UpdateRedpoint();
|
}
|
}
|
|
private void OnStageLoadFinish()
|
{
|
if (StageLoad.Instance.currentStage is DungeonStage &&
|
PlayerDatas.Instance.baseData.MapID == FAIRY_LEAGUE_DUNGEON)
|
{
|
UpdateRedpoint();
|
}
|
}
|
|
#region 配置
|
public const int FAIRY_LEAGUE_DUNGEON = 31220;
|
public const int FAIRY_LEAGUE_BATTLE = 68;
|
private string[] guideImgKeys;
|
public string[] GuideImgKeys
|
{
|
get
|
{
|
return guideImgKeys;
|
}
|
}
|
|
public int fairyWarResUpperLimit
|
{
|
get;
|
private set;
|
}
|
public readonly int buffTypeId = 22203;
|
public Dictionary<int, List<IntegralRankItem>> integralRankAwardDict = new Dictionary<int, List<IntegralRankItem>>();
|
public int[] integralRankAwardPer { get; private set; }
|
public int integralAddition { get; private set; }
|
public Dictionary<int, int[]> crystalSortDict { get; private set; }
|
/// <summary>
|
/// key----世界等级
|
/// </summary>
|
public Dictionary<int, List<Item>> finalWarWinAwardDict = new Dictionary<int, List<Item>>();
|
public Dictionary<int, List<Item>> finalWarChampionWinAwardDict = new Dictionary<int, List<Item>>();
|
public Dictionary<int, List<Item>> finalWarDefeatAwardDict = new Dictionary<int, List<Item>>();
|
public Dictionary<int, List<Item>> finalWarChampionDefeatAwardDict = new Dictionary<int, List<Item>>();
|
private Dictionary<int, float> crystalRateDict = new Dictionary<int, float>();
|
readonly List<int> fairyLeagueStateValues = new List<int>() { 11, 12, 13, 21, 22, 23 };
|
FairyLeagueWeekTime fairyLeagueWeekTime = new FairyLeagueWeekTime();
|
Dictionary<int, Dictionary<int, FairyLeagueWeekTime>> specialLeagueTimes = new Dictionary<int, Dictionary<int, FairyLeagueWeekTime>>();
|
Dictionary<int, FairyLeagueWeekTime> mixServerWeekTimes = new Dictionary<int, FairyLeagueWeekTime>();
|
public Dictionary<int, int> leagueNoticeWeapons { get; private set; }
|
private void ParseConfig()
|
{
|
var funcConfig = FuncConfigConfig.Get("FamilyMatchGuide");
|
if (funcConfig != null)
|
{
|
guideImgKeys = ConfigParse.GetMultipleStr(funcConfig.Numerical1);
|
}
|
var configs = DungeonStateTimeConfig.GetValues();
|
for (int i = 0; i < configs.Count; i++)
|
{
|
if (configs[i].DataMapID == FAIRY_LEAGUE_DUNGEON && fairyLeagueStateValues.Contains(configs[i].StateValue))
|
{
|
fairyLeagueWeekTime.AddStage(configs[i]);
|
}
|
}
|
fairyLeagueWeekTime.Sort();
|
var specialStateTimes = DungeonSpecialStateTimeConfig.GetDungeonTimes(FAIRY_LEAGUE_DUNGEON);
|
for (int i = 0; i < specialStateTimes.Count; i++)
|
{
|
var specialConfig = specialStateTimes[i];
|
if (fairyLeagueStateValues.Contains(specialConfig.StateValue))
|
{
|
Dictionary<int, FairyLeagueWeekTime> dict;
|
if (!specialLeagueTimes.TryGetValue(specialConfig.OpenServerWeek, out dict))
|
{
|
dict = new Dictionary<int, FairyLeagueWeekTime>();
|
specialLeagueTimes.Add(specialConfig.OpenServerWeek, dict);
|
}
|
var dayOfWeek = 0;
|
var index = GetIndexOfWeek(specialConfig.OpenServerWeek, specialConfig.OpenServerDay, out dayOfWeek);
|
FairyLeagueWeekTime leagueTime;
|
if (!dict.TryGetValue(index, out leagueTime))
|
{
|
leagueTime = new FairyLeagueWeekTime();
|
dict.Add(index, leagueTime);
|
}
|
leagueTime.AddStage(specialConfig, dayOfWeek);
|
}
|
}
|
foreach (var dict in specialLeagueTimes.Values)
|
{
|
foreach (var leagueTime in dict.Values)
|
{
|
leagueTime.Sort();
|
}
|
}
|
funcConfig = FuncConfigConfig.Get("FamilyMatchResourcePoint");
|
if (funcConfig != null)
|
{
|
crystalSortDict = new Dictionary<int, int[]>();
|
var _sortArray = JsonMapper.ToObject<int[][]>(funcConfig.Numerical3);
|
for (int i = 0; i < _sortArray.Length; i++)
|
{
|
crystalSortDict.Add(i + 1, _sortArray[i]);
|
}
|
fairyLeagueCrystals = JsonMapper.ToObject<int[]>(funcConfig.Numerical2);
|
fairyWarResUpperLimit = int.Parse(funcConfig.Numerical5);
|
}
|
funcConfig = FuncConfigConfig.Get("FamilyMatchRandomBuff");
|
if (funcConfig != null)
|
{
|
if (RandomBuffPos_Regex.IsMatch(funcConfig.Numerical1))
|
{
|
foreach (Match match in RandomBuffPos_Regex.Matches(funcConfig.Numerical1))
|
{
|
crystalPosList.Add(new Vector2(float.Parse(match.Groups[1].Value) / 2,
|
float.Parse(match.Groups[2].Value) / 2));
|
}
|
}
|
}
|
Regex _regex = new Regex(@"([0-9]+):\[(.*?\])\]");
|
funcConfig = FuncConfigConfig.Get("FamilyMatchRankReward");
|
if (_regex.IsMatch(funcConfig.Numerical1))
|
{
|
foreach (Match match in _regex.Matches(funcConfig.Numerical1))
|
{
|
var _rank = int.Parse(match.Groups[1].Value);
|
var _value = StringUtility.Contact('[', match.Groups[2].Value, ']');
|
List<IntegralRankItem> _list = ParseAward(LitJson.JsonMapper.ToObject<int[][]>(_value));
|
integralRankAwardDict.Add(_rank, _list);
|
}
|
integralRankAwardPer = JsonMapper.ToObject<int[]>(funcConfig.Numerical2);
|
}
|
funcConfig = FuncConfigConfig.Get("FamilyMatchRankOneReward");
|
if (_regex.IsMatch(funcConfig.Numerical1))
|
{
|
foreach (Match match in _regex.Matches(funcConfig.Numerical1))
|
{
|
var _worldLv = int.Parse(match.Groups[1].Value);
|
List<Item> _list = ParseAward(StringUtility.Contact('[', match.Groups[2].Value, ']'));
|
finalWarWinAwardDict.Add(_worldLv, _list);
|
}
|
}
|
if (_regex.IsMatch(funcConfig.Numerical2))
|
{
|
foreach (Match match in _regex.Matches(funcConfig.Numerical2))
|
{
|
var _worldLv = int.Parse(match.Groups[1].Value);
|
List<Item> _list = ParseAward(StringUtility.Contact('[', match.Groups[2].Value, ']'));
|
finalWarDefeatAwardDict.Add(_worldLv, _list);
|
}
|
}
|
funcConfig = FuncConfigConfig.Get("FamilyMatchSRankOneReward");
|
if (_regex.IsMatch(funcConfig.Numerical1))
|
{
|
foreach (Match match in _regex.Matches(funcConfig.Numerical1))
|
{
|
var _worldLv = int.Parse(match.Groups[1].Value);
|
List<Item> _list = ParseAward(StringUtility.Contact('[', match.Groups[2].Value, ']'));
|
finalWarChampionWinAwardDict.Add(_worldLv, _list);
|
}
|
}
|
if (_regex.IsMatch(funcConfig.Numerical2))
|
{
|
foreach (Match match in _regex.Matches(funcConfig.Numerical2))
|
{
|
var _worldLv = int.Parse(match.Groups[1].Value);
|
List<Item> _list = ParseAward(StringUtility.Contact('[', match.Groups[2].Value, ']'));
|
finalWarChampionDefeatAwardDict.Add(_worldLv, _list);
|
}
|
}
|
funcConfig = FuncConfigConfig.Get("FamilyMatchPersonalScore");
|
integralAddition = int.Parse(funcConfig.Numerical5);
|
funcConfig = FuncConfigConfig.Get("FamilyMatchResourcePoint1");
|
crystalRateDict = ConfigParse.GetDic<int, float>(funcConfig.Numerical1);
|
funcConfig = FuncConfigConfig.Get("FamilyForcast");
|
leagueNoticeWeapons = ConfigParse.GetDic<int, int>(funcConfig.Numerical1);
|
|
var leagueRankAwards = FairyLeagueRankAwardConfig.GetValues();
|
foreach (var rankAwardConfig in leagueRankAwards)
|
{
|
Dictionary<int, List<Item>> rankAwards;
|
if (!m_FairyLeagueRankRewards.TryGetValue(rankAwardConfig.WorldLV, out rankAwards))
|
{
|
rankAwards = new Dictionary<int, List<Item>>();
|
m_FairyLeagueRankRewards.Add(rankAwardConfig.WorldLV, rankAwards);
|
}
|
List<Item> awardItems;
|
if (!rankAwards.TryGetValue(rankAwardConfig.Rank, out awardItems))
|
{
|
awardItems = new List<Item>();
|
rankAwards.Add(rankAwardConfig.Rank, awardItems);
|
}
|
var itemArray = LitJson.JsonMapper.ToObject<int[][]>(rankAwardConfig.RankAuctionItem);
|
for (int i = 0; i < itemArray.Length; i++)
|
{
|
awardItems.Add(new Item()
|
{
|
id = itemArray[i][0],
|
count = itemArray[i][1],
|
});
|
}
|
|
awardItems.Reverse();
|
//awardItems.Sort((x, y) =>
|
//{
|
// var config_x = ItemConfig.Get(x.id);
|
// var config_y = ItemConfig.Get(y.id);
|
// if (config_x.ItemColor != config_y.ItemColor)
|
// {
|
// return -config_x.ItemColor.CompareTo(config_y.ItemColor);
|
// }
|
// return 0;
|
//});
|
|
if (rankAwardConfig.Rank > fairyLeagueRankAwardMaxRank)
|
{
|
fairyLeagueRankAwardMaxRank = rankAwardConfig.Rank;
|
}
|
}
|
}
|
|
int GetIndexOfWeek(int _openWeekDay, int _openDays, out int dayOfWeek)
|
{
|
var index = (_openWeekDay + _openDays - 2) / 7;
|
dayOfWeek = (_openWeekDay + _openDays - 1) % 7;
|
dayOfWeek = dayOfWeek == 0 ? 7 : dayOfWeek;
|
return index;
|
}
|
|
private List<Item> ParseAward(string _config)
|
{
|
List<Item> _list = new List<Item>();
|
var _array = JsonMapper.ToObject<int[][]>(_config);
|
if (_array != null)
|
{
|
for (int i = 0; i < _array.Length; i++)
|
{
|
Item _item = new Item();
|
_item.id = _array[i][0];
|
_item.count = _array[i][1];
|
_list.Add(_item);
|
}
|
}
|
return _list;
|
}
|
|
private List<IntegralRankItem> ParseAward(int[][] itemsArray)
|
{
|
List<IntegralRankItem> _list = new List<IntegralRankItem>();
|
if (itemsArray != null)
|
{
|
for (int i = 0; i < itemsArray.Length; i++)
|
{
|
IntegralRankItem _item = new IntegralRankItem();
|
_item.id = itemsArray[i][0];
|
_item.count = itemsArray[i][1];
|
_item.bind = itemsArray[i][2];
|
_item.isPer = itemsArray[i].Length > 3 ? itemsArray[i][3] : 1;
|
_list.Add(_item);
|
}
|
}
|
return _list;
|
}
|
public SkillConfig GetRandomAttrBuff(int _lv)
|
{
|
SkillConfig _buffTypeCfg = SkillConfig.Get(buffTypeId);
|
_lv = Mathf.Min(_lv, _buffTypeCfg.SkillMaxLV);
|
return SkillConfig.Get(buffTypeId + _lv - 1);
|
}
|
|
public bool TryGetCrystalRate(int _npcId, out float _rate)
|
{
|
return crystalRateDict.TryGetValue(_npcId, out _rate);
|
}
|
|
void ParseMixServerLeagueTimes()
|
{
|
mixServerWeekTimes.Clear();
|
if (!TimeUtility.IsMixServer)
|
{
|
return;
|
}
|
var configs = DungeonMixServerStateTimeConfig.GetDungeonTimes(FAIRY_LEAGUE_DUNGEON);
|
foreach (var config in configs)
|
{
|
var week = GetMixServerWeek(config.MixServerDay - 1);
|
FairyLeagueWeekTime leagueTime;
|
if (!mixServerWeekTimes.TryGetValue(week, out leagueTime))
|
{
|
leagueTime = new FairyLeagueWeekTime();
|
mixServerWeekTimes.Add(week, leagueTime);
|
}
|
var date = TimeUtility.ServerNow.AddTicks(-TimeUtility.MixOpenDay * TimeSpan.TicksPerDay);
|
var dayOfWeek = date.AddTicks((config.MixServerDay - 1) * TimeSpan.TicksPerDay).DayOfWeek;
|
leagueTime.AddStage(config, dayOfWeek == DayOfWeek.Sunday ? 7 : (int)dayOfWeek);
|
}
|
foreach (var weekTime in mixServerWeekTimes.Values)
|
{
|
weekTime.Sort();
|
}
|
}
|
|
int GetMixServerWeek(int mixDays)
|
{
|
var date = TimeUtility.ServerNow.AddTicks(-TimeUtility.MixOpenDay * TimeSpan.TicksPerDay);
|
var dayOfWeek = date.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)date.DayOfWeek;
|
var week = Mathf.CeilToInt((mixDays - (7 - dayOfWeek)) / (float)7);
|
return week;
|
}
|
#endregion
|
|
#region 仙盟联赛副本
|
public int[] fairyLeagueCrystals
|
{
|
get;
|
private set;
|
}
|
public int fairyLeagueWinFaction
|
{
|
get;
|
private set;
|
}
|
public int fairyLeagueTotalTime
|
{
|
get;
|
private set;
|
}
|
public int fairyLeagueGroupId
|
{
|
get;
|
private set;
|
}
|
|
public uint fairyLeagueFairyId { get; private set; }//仙盟联赛第一轮分配时玩家所在仙盟，默认0代表本仙盟
|
|
public string fairyLeagueFairyName { get; private set; }
|
|
public event Action UpdateWarRankEvent;
|
|
public List<FairyLeagueResultData> fairyLeagueResults = new List<FairyLeagueResultData>();
|
public void UpdateFairyResult(HB210_tagMCFamilyWarBillboard _package)
|
{
|
fairyLeagueResults.Clear();
|
fairyLeagueGroupId = _package.GroupID;
|
for (int i = 0; i < _package.BillboardCount; i++)
|
{
|
var _sResult = _package.FBBillboardPlayer[i];
|
var _cResult = new FairyLeagueResultData(
|
(int)_sResult.PlayerID, _sResult.PlayerName,
|
(int)_sResult.CrystalCount, (int)_sResult.KillPlayerCount,
|
(int)_sResult.RandBuffCount, (int)_sResult.FightTime,
|
(int)_sResult.Point, _sResult.Faction == _package.WinFaction,
|
_sResult.Faction
|
);
|
fairyLeagueResults.Add(_cResult);
|
}
|
if (UpdateWarRankEvent != null)
|
{
|
UpdateWarRankEvent();
|
}
|
if (_package.WinFaction != 0 && _package.TotalFightTime > 0)
|
{
|
fairyLeagueTotalTime = _package.TotalFightTime;
|
fairyLeagueWinFaction = _package.WinFaction;
|
WindowCenter.Instance.CloseAll(WindowCenter.CloseAllIgnoreType.BaseAndCustom);
|
WindowCenter.Instance.Open<MainInterfaceWin>();
|
WindowCenter.Instance.Open<FairyLeagueDungeonSettleWin>();
|
}
|
}
|
|
public void UpdateFairyLeagueFairy(HA40B_tagGCPlayerJoinFamilyWarInfo package)
|
{
|
fairyLeagueFairyId = package.JoinFamilyID;
|
fairyLeagueFairyName = UIHelper.ServerStringTrim(package.JoinFamilyName);
|
UpdateRedpoint();
|
}
|
public int GetCrystalIndex(int _npcId)
|
{
|
var _array = crystalSortDict[1];
|
if (crystalSortDict.ContainsKey((int)PlayerDatas.Instance.baseData.faction))
|
{
|
_array = crystalSortDict[(int)PlayerDatas.Instance.baseData.faction];
|
}
|
for (int i = 0; i < _array.Length; i++)
|
{
|
if (fairyLeagueCrystals[_array[i] - 1] == _npcId)
|
{
|
return i;
|
}
|
}
|
return -1;
|
}
|
|
public bool BattleChampion()
|
{
|
var _session = fairyLeagueSession;
|
if (_session == 0 &&
|
fairyLeagueBattleDict.ContainsKey(_session)
|
&& fairyLeagueBattleDict[_session].ContainsKey(5))
|
{
|
var _list = fairyLeagueBattleDict[_session][5];
|
return _list.Count == 1;
|
}
|
return false;
|
}
|
public List<Vector2> crystalPosList = new List<Vector2>();
|
private readonly Regex RandomBuffPos_Regex = new Regex(@"\[([0-9]+),([0-9]+)\]");
|
#endregion
|
#region 协议
|
public event Action onFairyLeagueBattleEvent;
|
private Dictionary<int, Dictionary<int, List<FairyLeagueBattleData>>> fairyLeagueBattleDict = new Dictionary<int, Dictionary<int, List<FairyLeagueBattleData>>>();
|
private void OnGetUniversalGameInfo(HA003_tagUniversalGameRecInfo package)
|
{
|
if (package.Type == FAIRY_LEAGUE_BATTLE)
|
{
|
fairyLeagueBattleDict.Clear();
|
if (package.Count > 0)
|
{
|
for (int i = 0; i < package.Count; i++)
|
{
|
var _pakData = package.UniversalGameRec[i];
|
Dictionary<int, List<FairyLeagueBattleData>> dic = null;
|
fairyLeagueBattleDict.TryGetValue((int)_pakData.Value2 - 1, out dic);
|
if (dic == null)
|
{
|
dic = new Dictionary<int, List<FairyLeagueBattleData>>();
|
fairyLeagueBattleDict.Add((int)_pakData.Value2 - 1, dic);
|
}
|
List<FairyLeagueBattleData> list = null;
|
if (dic.TryGetValue((int)_pakData.Value1, out list) == false)
|
{
|
list = new List<FairyLeagueBattleData>();
|
dic.Add((int)_pakData.Value1, list);
|
}
|
FairyLeagueBattleData battleData = new FairyLeagueBattleData()
|
{
|
grade = (int)_pakData.Value1,
|
session = (int)_pakData.Value2 - 1,
|
fairyId1 = (int)_pakData.Value3,
|
fairyId2 = (int)_pakData.Value4,
|
winFairyId = (int)_pakData.Value5,
|
fairyName1 = _pakData.StrValue1,
|
fairyName2 = _pakData.StrValue2,
|
dissolveFairys = JsonMapper.ToObject<int[]>(_pakData.StrValue3),
|
};
|
list.Add(battleData);
|
}
|
}
|
if (onFairyLeagueBattleEvent != null)
|
{
|
onFairyLeagueBattleEvent();
|
}
|
UpdateRedpoint();
|
}
|
}
|
public bool SelfFairyInBattle(out int _error)
|
{
|
_error = 3;
|
var _session = fairyLeagueSession;
|
var _fairyId = PlayerDatas.Instance.fairyData.fairy.FamilyID;
|
if (!fairyLeagueBattleDict.ContainsKey(_session))
|
{
|
return false;
|
}
|
var _dict = fairyLeagueBattleDict[_session];
|
foreach (var _grade in _dict.Keys)
|
{
|
if (_dict[_grade] == null)
|
{
|
continue;
|
}
|
foreach (var _fairyBattle in _dict[_grade])
|
{
|
if (_fairyBattle.fairyId1 == _fairyId || _fairyBattle.fairyId2 == _fairyId)
|
{
|
var _battleFairyId = _fairyBattle.fairyId1 == _fairyId ? _fairyBattle.fairyId2 : _fairyBattle.fairyId1;
|
if (_battleFairyId == 0 || _fairyBattle.IsFairyDissolve(_battleFairyId))
|
{
|
_error = 4;
|
return false;
|
}
|
if (_fairyBattle.winFairyId != 0)
|
{
|
_error = 5;
|
}
|
return _fairyBattle.winFairyId == 0;
|
}
|
}
|
}
|
return false;
|
}
|
|
public bool RequireFairyLeagueRemind(int session)
|
{
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.FairyLeague))
|
{
|
return false;
|
}
|
if (!PlayerDatas.Instance.fairyData.HasFairy)
|
{
|
return false;
|
}
|
var _fairyId = PlayerDatas.Instance.baseData.FamilyId;
|
if (!fairyLeagueBattleDict.ContainsKey(session))
|
{
|
return false;
|
}
|
var dict = fairyLeagueBattleDict[session];
|
foreach (var grade in dict.Keys)
|
{
|
if (dict[grade] == null)
|
{
|
continue;
|
}
|
foreach (var battleList in dict[grade])
|
{
|
if (battleList.fairyId1 == _fairyId
|
|| battleList.fairyId2 == _fairyId)
|
{
|
return battleList.fairyId1 != 0 && battleList.fairyId2 != 0;
|
}
|
}
|
}
|
return false;
|
}
|
|
public bool SatisfyEnterLeague(out int _error)
|
{
|
_error = 0;
|
if (!PlayerDatas.Instance.fairyData.HasFairy)
|
{
|
_error = 1;
|
return false;
|
}
|
if (fairyLeagueStage != FairyLeagueStage.Fight)
|
{
|
return false;
|
}
|
if (!SelfFairyInBattle(out _error))
|
{
|
return false;
|
}
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.FairyLeague))
|
{
|
_error = 2;
|
return false;
|
}
|
if (fairyLeagueFairyId != 0 && fairyLeagueFairyId != PlayerDatas.Instance.baseData.FamilyId)
|
{
|
_error = 6;
|
return false;
|
}
|
return true;
|
}
|
|
public void DisplayErrorTip(int _error)
|
{
|
switch (_error)
|
{
|
case 1:
|
SysNotifyMgr.Instance.ShowTip("LeagueCannotGo5");
|
break;
|
case 2:
|
FuncOpen.Instance.ProcessorFuncErrorTip((int)FuncOpenEnum.FairyLeague);
|
break;
|
case 3:
|
SysNotifyMgr.Instance.ShowTip("LeagueCannotGo3");
|
break;
|
case 4:
|
SysNotifyMgr.Instance.ShowTip("LeagueCannotGo4");
|
break;
|
case 5:
|
var _session = fairyLeagueSession;
|
var isNextWeek = IsNextWeek;
|
FairyLeagueWeekTime.Session session;
|
var weekTime = isNextWeek ? nextWeekTime : currentWeekTime;
|
weekTime.TryGetSession(fairyLeagueRing, 1 - _session, out session);
|
var fightStage = session.stages.Find((x) =>
|
{
|
return x.stage == FairyLeagueStage.Fight;
|
});
|
if (_session == 0)
|
{
|
var _param = StringUtility.Contact(Language.Get(StringUtility.Contact("Weekday", weekTime.GetDayOfWeek(fairyLeagueRing))),
|
fightStage.startHour.ToString("D2"), ":", fightStage.startMinute.ToString("D2"));
|
SysNotifyMgr.Instance.ShowTip("LeagueCannotGo1", _param);
|
}
|
else
|
{
|
var _param = StringUtility.Contact(isNextWeek ? Language.Get("Next") : Language.Get("ThisTime"),
|
Language.Get(StringUtility.Contact("Weekday", weekTime.GetDayOfWeek(fairyLeagueRing))),
|
fightStage.startHour.ToString("D2"), ":", fightStage.startMinute.ToString("D2"));
|
SysNotifyMgr.Instance.ShowTip("LeagueCannotGo2", _param);
|
}
|
break;
|
case 6:
|
SysNotifyMgr.Instance.ShowTip("PlayerWarFamilyIDIsChange");
|
break;
|
}
|
}
|
|
public void CheckFairyLeagueData()
|
{
|
CA001_tagViewUniversalGameRec _pak = new CA001_tagViewUniversalGameRec();
|
_pak.ViewType = (byte)FAIRY_LEAGUE_BATTLE;
|
GameNetSystem.Instance.SendInfo(_pak);
|
}
|
|
public List<FairyLeagueBattleData> GetFairyLeague(int _ring, int _grade)
|
{
|
Dictionary<int, List<FairyLeagueBattleData>> dic = null;
|
List<FairyLeagueBattleData> list = null;
|
fairyLeagueBattleDict.TryGetValue(_ring, out dic);
|
if (dic != null)
|
{
|
dic.TryGetValue(_grade, out list);
|
}
|
return list;
|
}
|
public event Action UpdateFairyWarHelpEvent;
|
public event Action UpdateWarBuffEvent;
|
public event Action UpdateWarCrystalEvent;
|
public event Action CrystalBelongChangeEvent;
|
public FairyLeagueHelp fairyLeagueHelp
|
{
|
get;
|
private set;
|
}
|
private const string FairyWarBuffHelpKey = "familyWar_Buff";
|
private const string FairyWarCrystalAtkHelpKey = "familyWar_CrystalAtk";
|
private const string FairyWarCrystalKey = "familyWar_Crystal";
|
private const string FairyWarHelpInfoKey = "familyWar_HelpInfo";
|
private const string FairyWarEnterHelpKey = "familyWar_Enter";
|
public void UpdateFairyWarHelp(string _mission)
|
{
|
var _jsonData = JsonMapper.ToObject(_mission);
|
foreach (var _key in _jsonData.Keys)
|
{
|
switch (_key)
|
{
|
case FairyWarBuffHelpKey:
|
fairyLeagueHelp.fairyWarBuffs = JsonMapper.ToObject<FairyLeagueHelp.FairyWarBuff[]>(_jsonData[_key].ToJson());
|
if (UpdateWarBuffEvent != null)
|
{
|
UpdateWarBuffEvent();
|
}
|
break;
|
case FairyWarCrystalAtkHelpKey:
|
fairyLeagueHelp.FairyWarCrystalAtks = JsonMapper.ToObject<int[]>(_jsonData[_key].ToJson());
|
if (UpdateWarCrystalEvent != null)
|
{
|
UpdateWarCrystalEvent();
|
}
|
break;
|
case FairyWarCrystalKey:
|
fairyLeagueHelp.fairyWarCrystalDict.Clear();
|
var json = _jsonData[_key];
|
foreach (var _camp in json.Keys)
|
{
|
fairyLeagueHelp.fairyWarCrystalDict.Add(int.Parse(_camp), JsonMapper.ToObject<int[]>(json[_camp].ToJson()));
|
}
|
if (UpdateWarCrystalEvent != null)
|
{
|
UpdateWarCrystalEvent();
|
}
|
if (CrystalBelongChangeEvent != null)
|
{
|
CrystalBelongChangeEvent();
|
}
|
break;
|
case FairyWarHelpInfoKey:
|
fairyLeagueHelp.fairyWarHelpInfos =
|
JsonMapper.ToObject<FairyLeagueHelp.FairyWarHelpInfo[]>(_jsonData[_key].ToJson());
|
break;
|
case FairyWarEnterHelpKey:
|
fairyLeagueHelp.fairyWarEnter = JsonMapper.ToObject<FairyLeagueHelp.FairyWarEnter>(_jsonData[_key].ToJson());
|
break;
|
}
|
}
|
if (UpdateFairyWarHelpEvent != null)
|
{
|
UpdateFairyWarHelpEvent();
|
}
|
}
|
private void ClearFairyWarHelp()
|
{
|
fairyLeagueGroupId = 0;
|
fairyLeagueTotalTime = 0;
|
fairyLeagueWinFaction = 0;
|
fairyLeagueHelp.fairyWarBuffs = null;
|
fairyLeagueHelp.FairyWarCrystalAtks = null;
|
fairyLeagueHelp.fairyWarCrystalDict.Clear();
|
fairyLeagueHelp.fairyWarHelpInfos = null;
|
fairyLeagueHelp.fairyWarEnter = default(FairyLeagueHelp.FairyWarEnter);
|
}
|
|
public FairyLeagueBattleData GetSelfBattleInfo()
|
{
|
var _session = fairyLeagueSession;
|
var _fairyId = PlayerDatas.Instance.fairyData.fairy.FamilyID;
|
if (!fairyLeagueBattleDict.ContainsKey(_session))
|
{
|
return null;
|
}
|
var _dict = fairyLeagueBattleDict[_session];
|
foreach (var _grade in _dict.Keys)
|
{
|
if (_dict[_grade] == null)
|
{
|
continue;
|
}
|
foreach (var _fairyBattle in _dict[_grade])
|
{
|
if (_fairyBattle.fairyId1 == _fairyId || _fairyBattle.fairyId2 == _fairyId)
|
{
|
return _fairyBattle;
|
}
|
}
|
}
|
return null;
|
}
|
|
public bool IsSessionOneWinGroup()
|
{
|
var _fairyId = PlayerDatas.Instance.baseData.FamilyId;
|
|
var battleDatas = GetFairyLeague(0, fairyLeagueGroupId);
|
for (int i = 0; i < battleDatas.Count; i++)
|
{
|
if (battleDatas[i].fairyId1 == _fairyId
|
|| battleDatas[i].fairyId2 == _fairyId)
|
{
|
return battleDatas[i].winFairyId == _fairyId;
|
}
|
}
|
return false;
|
}
|
|
public bool StepSession(int _grade = 5)
|
{
|
if (fairyLeagueSession == 1)
|
{
|
if (!fairyLeagueBattleDict.ContainsKey(1))
|
{
|
return true;
|
}
|
if (fairyLeagueBattleDict.ContainsKey(0) &&
|
fairyLeagueBattleDict[0].ContainsKey(_grade) && fairyLeagueBattleDict[0][_grade].Count == 1)
|
{
|
return true;
|
}
|
else if (!fairyLeagueBattleDict[0].ContainsKey(_grade))
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public string GetBattleFairyName(int _playerId)
|
{
|
var _fairy = PlayerDatas.Instance.fairyData.fairy;
|
if (PlayerDatas.Instance.PlayerId == _playerId)
|
{
|
return _fairy == null ? string.Empty : _fairy.FamilyName;
|
}
|
else if (PlayerDatas.Instance.fairyData.GetMember(_playerId) != null)
|
{
|
return _fairy == null ? string.Empty : _fairy.FamilyName;
|
}
|
else
|
{
|
FairyLeagueBattleData _battle = GetSelfBattleInfo();
|
return _battle.fairyId1 == _fairy.FamilyID ? _battle.fairyName2 : _battle.fairyName1;
|
}
|
}
|
|
public FairyCampType GetBattleCampType(int _playerId)
|
{
|
if (_playerId == PlayerDatas.Instance.PlayerId ||
|
PlayerDatas.Instance.fairyData.GetMember(_playerId) != null)
|
{
|
return (FairyCampType)PlayerDatas.Instance.baseData.faction;
|
}
|
return PlayerDatas.Instance.baseData.faction == 1 ? (FairyCampType)2 : (FairyCampType)1;
|
}
|
|
public string GetFairyFlagKey(int _playerId)
|
{
|
var _camp = GetBattleCampType(_playerId);
|
return _camp == FairyCampType.Blue ? "FlagBlue" : "FlagRed";
|
}
|
|
public int GetBattleWinFirstPlayer()
|
{
|
if (fairyLeagueResults.Count == 0)
|
{
|
return -1;
|
}
|
for (int i = 0; i < fairyLeagueResults.Count; i++)
|
{
|
if (fairyLeagueResults[i].IsWin)
|
{
|
return i;
|
}
|
}
|
return 0;
|
}
|
|
public int GetBattleDefeatFirstPlayer()
|
{
|
if (fairyLeagueResults.Count == 0)
|
{
|
return -1;
|
}
|
for (int i = 0; i < fairyLeagueResults.Count; i++)
|
{
|
if (!fairyLeagueResults[i].IsWin)
|
{
|
return i;
|
}
|
}
|
return 0;
|
}
|
|
#region 前16名仙盟列表
|
List<PlayerFairyData.FairyData> frontFairyList = new List<PlayerFairyData.FairyData>();
|
public event Action frontFairyUpdate;
|
public void SearchLeagueFrontFairy()
|
{
|
CA412_tagCGPySearchFamily pak = new CA412_tagCGPySearchFamily();
|
pak.MsgLen = 0;
|
pak.Msg = string.Empty;
|
pak.IsSearching = 100;
|
pak.LV = (byte)fairyModel.fairyLeagueLimit;
|
pak.MaxCount = 16;
|
GameNetSystem.Instance.SendInfo(pak);
|
}
|
|
public void UpdateFrontLeagueFairy(HA408_tagGCPyAllFamilyView package)
|
{
|
if (package.IsSearching == 100)
|
{
|
frontFairyList.Clear();
|
for (int i = 0; i < package.PageCount; i++)
|
{
|
PlayerFairyData.FairyData data = new PlayerFairyData.FairyData();
|
frontFairyList.Add(data);
|
PlayerFairyData.SetFairyViewData(data, package.Family[i]);
|
}
|
if (frontFairyUpdate != null)
|
{
|
frontFairyUpdate();
|
}
|
}
|
}
|
|
public List<PlayerFairyData.FairyData> frontLeagueFairy
|
{
|
get { return frontFairyList; }
|
}
|
#endregion
|
#endregion
|
#region 红点
|
private Redpoint m_LeagueRedpoint = new Redpoint(107, 10704);
|
public Redpoint m_JoinFairyLeagueRedpoint { get; private set; }
|
|
public void UpdateRedpoint()
|
{
|
m_JoinFairyLeagueRedpoint.state = RedPointState.None;
|
int _error = 0;
|
if (!SatisfyEnterLeague(out _error))
|
{
|
return;
|
}
|
if (PlayerDatas.Instance.baseData.MapID == FAIRY_LEAGUE_DUNGEON)
|
{
|
return;
|
}
|
m_JoinFairyLeagueRedpoint.state = RedPointState.Simple;
|
}
|
#endregion
|
|
#region 仙盟联赛预告
|
private void OnFuncStateChangeEvent(int func)
|
{
|
if (func == 142)
|
{
|
if (onStateUpdate != null)
|
{
|
onStateUpdate(12);
|
}
|
UpdateNoticeRedpoint();
|
}
|
}
|
|
public event Action<int> onStateUpdate;
|
public bool IsOpen
|
{
|
get
|
{
|
return FuncOpen.Instance.IsFuncOpen(142) && !IsAfterFirstLeague();
|
}
|
}
|
public bool IsAdvance
|
{
|
get { return false; }
|
}
|
|
public bool priorityOpen
|
{
|
get { return false; }
|
}
|
|
public int GetBeforeFirstLeagueTime()
|
{
|
var seconds = 0;
|
if (TimeUtility.OpenWeekCnt < 1)
|
{
|
if (IsAfterFirstLeague())
|
{
|
return 0;
|
}
|
var weekTime = currentWeekTime == null ? nextWeekTime : currentWeekTime;
|
var ring = weekTime.rings[0];
|
var session = ring.sessions[0];
|
var fightStage = session.stages.Find((x) =>
|
{
|
return x.stage == FairyLeagueStage.Fight;
|
});
|
var time = TimeUtility.ServerNow.AddTicks((weekTime.rings[0].openServerDay - TimeUtility.OpenDay - 1) * TimeSpan.TicksPerDay);
|
time = new DateTime(time.Year, time.Month, time.Day, fightStage.startHour, fightStage.startMinute, 0);
|
seconds = (int)(time - TimeUtility.ServerNow).TotalSeconds;
|
seconds = Mathf.Max(seconds, 0);
|
}
|
return seconds;
|
}
|
|
public bool IsAfterFirstLeague()
|
{
|
if (TimeUtility.OpenWeekCnt < 1)
|
{
|
var openServerWeekDay = TimeUtility.openServerDayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.openServerDayOfWeek;
|
if (specialLeagueTimes.ContainsKey(openServerWeekDay))
|
{
|
var dict = specialLeagueTimes[openServerWeekDay];
|
var weekCount = TimeUtility.OpenWeekCnt;
|
if (dict.ContainsKey(0) && weekCount > 0)
|
{
|
return true;
|
}
|
if (currentWeekTime == null)
|
{
|
return false;
|
}
|
var weekTime = currentWeekTime == null ? nextWeekTime : currentWeekTime;
|
if (weekTime.IsNextWeek)
|
{
|
return true;
|
}
|
if (weekTime.rings.Count > 1 && weekTime.currentRing == 1)
|
{
|
return true;
|
}
|
return weekTime.currentSession == 1 && weekTime.fairyLeagueStage == FairyLeagueStage.Over;
|
}
|
}
|
return true;
|
}
|
|
Redpoint fairyLeagueNoticeRedpoint = new Redpoint(MainRedDot.REDPOINT_OPENSERVER, 20912);
|
void UpdateNoticeRedpoint()
|
{
|
fairyLeagueNoticeRedpoint.state = RedPointState.None;
|
if (!DayRemind.Instance.GetDayRemind(DayRemind.LEAGUE_NOTICE_REDPOINT)
|
&& IsOpen)
|
{
|
fairyLeagueNoticeRedpoint.state = RedPointState.Simple;
|
}
|
}
|
|
public void SetViewLeagueNotice()
|
{
|
if (fairyLeagueNoticeRedpoint.state == RedPointState.Simple)
|
{
|
DayRemind.Instance.SetDayRemind(DayRemind.LEAGUE_NOTICE_REDPOINT, true);
|
UpdateNoticeRedpoint();
|
}
|
}
|
#endregion
|
|
#region 仙盟联赛排名奖励
|
Dictionary<int, Dictionary<int, List<Item>>> m_FairyLeagueRankRewards = new Dictionary<int, Dictionary<int, List<Item>>>();
|
|
public int afterGroupWorldLevel { get; private set; }
|
public int fairyLeagueRankAwardMaxRank { get; private set; }
|
public List<Item> GetFairyLeagueRankReward(int worldLevel, int rank)
|
{
|
List<Item> items = null;
|
|
var maxWorldLevel = m_FairyLeagueRankRewards.Keys.Last();
|
if (worldLevel >= maxWorldLevel)
|
{
|
foreach (var _rank in m_FairyLeagueRankRewards[maxWorldLevel].Keys)
|
{
|
if (rank <= _rank)
|
{
|
items = m_FairyLeagueRankRewards[maxWorldLevel][_rank];
|
return items;
|
}
|
}
|
}
|
|
foreach (var _worldLevel in m_FairyLeagueRankRewards.Keys)
|
{
|
if (worldLevel <= _worldLevel)
|
{
|
foreach (var _rank in m_FairyLeagueRankRewards[_worldLevel].Keys)
|
{
|
if (rank <= _rank)
|
{
|
items = m_FairyLeagueRankRewards[_worldLevel][_rank];
|
return items;
|
}
|
}
|
}
|
}
|
return items;
|
}
|
|
public void OnReceivePackage(HAC01_tagGCFamilyWarInfo package)
|
{
|
afterGroupWorldLevel = package.WorldLV;
|
}
|
#endregion
|
}
|
|
public class FairyLeagueWeekTime
|
{
|
public List<Ring> rings = new List<Ring>();
|
|
public bool IsNextWeek
|
{
|
get
|
{
|
return rings.Count == 0 || rings[rings.Count - 1].IsOver(TimeUtility.ServerNow);
|
}
|
}
|
|
public FairyLeagueStage fairyLeagueStage
|
{
|
get
|
{
|
if (IsNextWeek)
|
{
|
return FairyLeagueStage.Prepare;
|
}
|
Ring ring;
|
if (TryGetCurrentRing(out ring))
|
{
|
Session session;
|
if (ring.TryGetSession(TimeUtility.ServerNow, out session))
|
{
|
Stage stage;
|
if (session.TryGetStage(TimeUtility.ServerNow, out stage))
|
{
|
return stage.stage;
|
}
|
}
|
}
|
return FairyLeagueStage.Prepare;
|
}
|
}
|
|
public int currentRing
|
{
|
get
|
{
|
var ring = 0;
|
for (int i = 0; i < rings.Count; i++)
|
{
|
if (rings[i].InRing(TimeUtility.ServerNow))
|
{
|
return i;
|
}
|
if (rings[i].IsOver(TimeUtility.ServerNow))
|
{
|
ring++;
|
}
|
}
|
return Mathf.Min(ring, rings.Count - 1);
|
}
|
}
|
|
public int GetDayOfWeek(int _index)
|
{
|
if (_index >= 0 && _index < rings.Count)
|
{
|
return rings[_index].dayOfWeek;
|
}
|
return 0;
|
}
|
|
public int currentSession
|
{
|
get
|
{
|
Ring ring;
|
if (TryGetCurrentRing(out ring))
|
{
|
return ring.currentSession;
|
}
|
return 0;
|
}
|
}
|
|
public int lastMixServerDay
|
{
|
get
|
{
|
return rings[rings.Count - 1].mixServerDay;
|
}
|
}
|
|
public void AddStage(DungeonStateTimeConfig config)
|
{
|
var ring = rings.Find((x) =>
|
{
|
return x.dayOfWeek == config.StartWeekday;
|
});
|
if (ring == null)
|
{
|
ring = new Ring();
|
rings.Add(ring);
|
ring.dayOfWeek = config.StartWeekday;
|
}
|
ring.ParseConfig(config);
|
}
|
|
public void AddStage(DungeonSpecialStateTimeConfig config, int dayOfWeek)
|
{
|
var ring = rings.Find((x) =>
|
{
|
return x.dayOfWeek == dayOfWeek;
|
});
|
|
if (ring == null)
|
{
|
ring = new Ring();
|
rings.Add(ring);
|
ring.dayOfWeek = dayOfWeek;
|
}
|
ring.ParseConfig(config, dayOfWeek);
|
}
|
|
public void AddStage(DungeonMixServerStateTimeConfig config, int dayOfWeek)
|
{
|
var ring = rings.Find((x) =>
|
{
|
return x.dayOfWeek == dayOfWeek;
|
});
|
|
if (ring == null)
|
{
|
ring = new Ring();
|
rings.Add(ring);
|
ring.dayOfWeek = dayOfWeek;
|
}
|
ring.ParseConfig(config, dayOfWeek);
|
}
|
|
public void Sort()
|
{
|
rings.Sort((Ring x, Ring y) =>
|
{
|
return x.dayOfWeek.CompareTo(y.dayOfWeek);
|
});
|
for (int i = 0; i < rings.Count; i++)
|
{
|
rings[i].Sort();
|
}
|
}
|
|
public bool TryGetCurrentRing(out Ring ring)
|
{
|
ring = null;
|
for (int i = 0; i < rings.Count; i++)
|
{
|
if (rings[i].InRing(TimeUtility.ServerNow))
|
{
|
ring = rings[i];
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool TryGetSession(int _ring, int _session, out Session session)
|
{
|
session = null;
|
if (_ring >= 0 && _ring < rings.Count)
|
{
|
if (_session >= 0 && _session < rings[_ring].sessions.Count)
|
{
|
session = rings[_ring].sessions[_session];
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public class Ring
|
{
|
public List<Session> sessions = new List<Session>();
|
|
public int currentSession
|
{
|
get
|
{
|
for (int i = 0; i < sessions.Count; i++)
|
{
|
if (sessions[i].InSession(TimeUtility.ServerNow))
|
{
|
return i;
|
}
|
}
|
return 0;
|
}
|
}
|
|
public int dayOfWeek { get; set; }
|
|
public int openServerDay { get; private set; }
|
|
public int mixServerDay { get; private set; }
|
|
public void Sort()
|
{
|
sessions.Sort((Session x, Session y) =>
|
{
|
return x.session.CompareTo(y.session);
|
});
|
for (int i = 0; i < sessions.Count; i++)
|
{
|
sessions[i].Sort();
|
}
|
}
|
|
public void ParseConfig(DungeonStateTimeConfig config)
|
{
|
var session = sessions.Find((x) =>
|
{
|
return x.session == (config.StateValue < 20 ? 0 : 1);
|
});
|
if (session == null)
|
{
|
session = new Session();
|
session.session = config.StateValue < 20 ? 0 : 1;
|
sessions.Add(session);
|
}
|
session.ParseConfig(config);
|
}
|
|
public void ParseConfig(DungeonSpecialStateTimeConfig config, int dayOfWeek)
|
{
|
openServerDay = config.OpenServerDay;
|
|
var session = sessions.Find((x) =>
|
{
|
return x.session == (config.StateValue < 20 ? 0 : 1);
|
});
|
if (session == null)
|
{
|
session = new Session();
|
session.session = config.StateValue < 20 ? 0 : 1;
|
sessions.Add(session);
|
}
|
session.ParseConfig(config, dayOfWeek);
|
}
|
|
public void ParseConfig(DungeonMixServerStateTimeConfig config, int dayOfWeek)
|
{
|
mixServerDay = config.MixServerDay - 1;
|
|
var session = sessions.Find((x) =>
|
{
|
return x.session == (config.StateValue < 20 ? 0 : 1);
|
});
|
if (session == null)
|
{
|
session = new Session();
|
session.session = config.StateValue < 20 ? 0 : 1;
|
sessions.Add(session);
|
}
|
session.ParseConfig(config, dayOfWeek);
|
}
|
|
public bool InRing(DateTime time)
|
{
|
for (int i = 0; i < sessions.Count; i++)
|
{
|
if (sessions[i].InSession(time))
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool TryGetSession(DateTime time, out Session session)
|
{
|
session = null;
|
for (int i = 0; i < sessions.Count; i++)
|
{
|
if (sessions[i].InSession(time))
|
{
|
session = sessions[i];
|
return true;
|
}
|
}
|
return false;
|
}
|
public bool IsOver(DateTime time)
|
{
|
bool allOver = true;
|
for (int i = 0; i < sessions.Count; i++)
|
{
|
if (!sessions[i].IsOver(time))
|
{
|
allOver = false;
|
break;
|
}
|
}
|
return allOver;
|
}
|
}
|
|
public class Session
|
{
|
public List<Stage> stages = new List<Stage>();
|
|
public int session { get; set; }
|
|
public void Sort()
|
{
|
var fightStage = stages.Find((x) =>
|
{
|
return x.stage == FairyLeagueStage.Fight;
|
});
|
var overStage = stages.Find((x) =>
|
{
|
return x.stage == FairyLeagueStage.Over;
|
});
|
overStage.startHour = fightStage.endHour;
|
overStage.startMinute = fightStage.endMinute;
|
stages.Sort(Compare);
|
}
|
|
public void ParseConfig(DungeonStateTimeConfig config)
|
{
|
var state = config.StateValue % 10;
|
var stage = new Stage()
|
{
|
stage = state == 1 ? FairyLeagueStage.Grouping : (state == 2 ? FairyLeagueStage.Fight : FairyLeagueStage.Over),
|
dayOfWeek = config.StartWeekday,
|
startHour = config.StartHour,
|
endHour = config.EndHour,
|
startMinute = config.StartMinute,
|
endMinute = config.EndMinute
|
};
|
stages.Add(stage);
|
}
|
|
public void ParseConfig(DungeonSpecialStateTimeConfig config, int dayOfWeek)
|
{
|
var state = config.StateValue % 10;
|
var stage = new Stage()
|
{
|
stage = state == 1 ? FairyLeagueStage.Grouping : (state == 2 ? FairyLeagueStage.Fight : FairyLeagueStage.Over),
|
dayOfWeek = dayOfWeek,
|
startHour = config.StartHour,
|
endHour = config.EndHour,
|
startMinute = config.StartMinute,
|
endMinute = config.EndMinute
|
};
|
stages.Add(stage);
|
}
|
|
public void ParseConfig(DungeonMixServerStateTimeConfig config, int dayOfWeek)
|
{
|
var state = config.StateValue % 10;
|
var stage = new Stage()
|
{
|
stage = state == 1 ? FairyLeagueStage.Grouping : (state == 2 ? FairyLeagueStage.Fight : FairyLeagueStage.Over),
|
dayOfWeek = dayOfWeek,
|
startHour = config.StartHour,
|
endHour = config.EndHour,
|
startMinute = config.StartMinute,
|
endMinute = config.EndMinute
|
};
|
stages.Add(stage);
|
}
|
|
public bool InSession(DateTime time)
|
{
|
var groupStage = stages.Find((x) =>
|
{
|
return x.stage == FairyLeagueStage.Grouping;
|
});
|
var overStage = stages.Find((x) =>
|
{
|
return x.stage == FairyLeagueStage.Over;
|
});
|
var _dayOfWeek = time.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)time.DayOfWeek;
|
if (_dayOfWeek != groupStage.dayOfWeek)
|
{
|
return false;
|
}
|
if (time.Hour < groupStage.startHour || time.Hour > overStage.endHour)
|
{
|
return false;
|
}
|
if (time.Hour == groupStage.startHour && time.Minute < groupStage.startMinute)
|
{
|
return false;
|
}
|
if (time.Hour == overStage.endHour && time.Minute >= overStage.endMinute)
|
{
|
return false;
|
}
|
return true;
|
}
|
|
public bool TryGetStage(DateTime time, out Stage stage)
|
{
|
stage = default(Stage);
|
for (int i = 0; i < stages.Count; i++)
|
{
|
if (stages[i].InStage(time))
|
{
|
stage = stages[i];
|
return true;
|
}
|
if (stages[i].IsOver(time))
|
{
|
stage = stages[i];
|
}
|
}
|
return !stage.Equals(default(Stage));
|
}
|
|
public bool IsOver(DateTime time)
|
{
|
var stage = stages.Find((x) =>
|
{
|
return x.stage == FairyLeagueStage.Over;
|
});
|
return stage.IsOver(time);
|
}
|
|
int Compare(Stage x, Stage y)
|
{
|
return x.stage.CompareTo(y.stage);
|
}
|
}
|
|
public class Stage
|
{
|
public FairyLeagueStage stage;
|
public int dayOfWeek;
|
public int startHour;
|
public int endHour;
|
public int startMinute;
|
public int endMinute;
|
|
public bool InStage(DateTime time)
|
{
|
var _dayOfWeek = time.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)time.DayOfWeek;
|
if (dayOfWeek != _dayOfWeek)
|
{
|
return false;
|
}
|
if (time.Hour < startHour || time.Hour > endHour)
|
{
|
return false;
|
}
|
if (time.Hour == startHour && time.Minute < startMinute)
|
{
|
return false;
|
}
|
if (time.Hour == endHour && time.Minute >= endMinute)
|
{
|
return false;
|
}
|
return true;
|
}
|
|
public bool IsOver(DateTime time)
|
{
|
var _dayOfWeek = time.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)time.DayOfWeek;
|
if (_dayOfWeek > dayOfWeek)
|
{
|
return true;
|
}
|
if (dayOfWeek == _dayOfWeek)
|
{
|
if (time.Hour > endHour)
|
{
|
return true;
|
}
|
if (time.Hour == endHour && time.Minute >= endMinute)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
}
|
}
|
|
public enum FairyLeagueStage
|
{
|
Prepare,
|
Grouping,
|
Fight,
|
Over,
|
}
|
public enum FairyCampType
|
{
|
None,
|
Red = 1,
|
Blue = 2
|
}
|
public class FairyLeagueBattleData
|
{
|
public int grade;
|
public int session;
|
public int fairyId1;
|
public int fairyId2;
|
public int winFairyId;
|
public int[] dissolveFairys;
|
public string fairyName1;
|
public string fairyName2;
|
|
public bool IsFairyDissolve(int _fairyId)
|
{
|
if (dissolveFairys == null || dissolveFairys.Length == 0)
|
{
|
return false;
|
}
|
for (int i = 0; i < dissolveFairys.Length; i++)
|
{
|
if (dissolveFairys[i] == _fairyId)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
public bool IsFairyWin(int _fairyId)
|
{
|
return _fairyId == winFairyId;
|
}
|
public string GetWinFairyName()
|
{
|
return fairyId1 == winFairyId ? fairyName1 : fairyId2 == winFairyId ? fairyName2 : string.Empty;
|
}
|
public int GetWinFairyId()
|
{
|
return fairyId1 == winFairyId ? fairyId1 : fairyId2 == winFairyId ? fairyId2 : 0;
|
}
|
public string GetLoserFairyName()
|
{
|
return fairyId1 == winFairyId ? fairyName2 : fairyName1;
|
}
|
public int GetLoserFairyId()
|
{
|
return fairyId1 == winFairyId ? fairyId2 : fairyId1;
|
}
|
}
|
public struct FairyLeagueResultData
|
{
|
public int PlayerId
|
{
|
get;
|
private set;
|
}
|
public string PlayerName
|
{
|
get;
|
private set;
|
}
|
public int TakeCrystals
|
{
|
get;
|
private set;
|
}
|
public int KillNums
|
{
|
get;
|
private set;
|
}
|
public int TakeBuffs
|
{
|
get;
|
private set;
|
}
|
public int FightTime
|
{
|
get;
|
private set;
|
}
|
public int Integral
|
{
|
get;
|
private set;
|
}
|
public bool IsWin
|
{
|
get;
|
private set;
|
}
|
public int Faction
|
{
|
get;
|
private set;
|
}
|
|
public FairyLeagueResultData(int _playerId, string _playerName, int _crystal, int _killNum,
|
int _buffs, int _fightTime, int _integral, bool _isWin, int _faction)
|
{
|
PlayerId = _playerId;
|
PlayerName = _playerName;
|
TakeCrystals = _crystal;
|
KillNums = _killNum;
|
TakeBuffs = _buffs;
|
FightTime = _fightTime;
|
Integral = _integral;
|
IsWin = _isWin;
|
Faction = _faction;
|
}
|
}
|
public class FairyLeagueHelp
|
{
|
public FairyWarBuff[] fairyWarBuffs;
|
public int[] FairyWarCrystalAtks;
|
public Dictionary<int, int[]> fairyWarCrystalDict = new Dictionary<int, int[]>();
|
public FairyWarHelpInfo[] fairyWarHelpInfos;
|
public FairyWarEnter fairyWarEnter;
|
|
public int GetCrystalBelongCamp(int _npcId)
|
{
|
foreach (var _camp in fairyWarCrystalDict.Keys)
|
{
|
if (fairyWarCrystalDict[_camp] == null)
|
{
|
continue;
|
}
|
for (int i = 0; i < fairyWarCrystalDict[_camp].Length; i++)
|
{
|
if (_npcId == fairyWarCrystalDict[_camp][i])
|
{
|
return _camp;
|
}
|
}
|
}
|
return 0;
|
}
|
public struct FairyWarBuff
|
{
|
public int PosIndex;
|
public int NPCID;
|
public int Atk;
|
}
|
public struct FairyWarHelpInfo
|
{
|
public double ResPoint;
|
public int MemCount;
|
public int BuffResPoint;
|
public int BuffResPointPer;
|
public int BuffAttrLV;
|
}
|
public struct FairyWarEnter
|
{
|
public int[] WinCount;
|
public int IsFinalMatch;
|
}
|
}
|
|
public struct IntegralRankItem
|
{
|
public int id;
|
public int count;
|
public int bind;
|
public int isPer;
|
}
|
|
[Serializable]
|
public class AwardItemUI
|
{
|
[SerializeField] Image m_ItemIcon;
|
[SerializeField] Image m_BindIcon;
|
[SerializeField] Image m_ItemBg;
|
[SerializeField] Text m_ItemCnt;
|
|
public Text itemCnt { get { return m_ItemCnt; } }
|
|
public void Init(int _itemId, int _itemCnt, int _isBind = 0)
|
{
|
ItemConfig _itemCfg = ItemConfig.Get(_itemId);
|
m_ItemIcon.SetActive(_itemCfg != null);
|
if (_itemCfg != null)
|
{
|
m_ItemIcon.SetSprite(_itemCfg.IconKey);
|
if (m_ItemBg != null)
|
{
|
m_ItemBg.SetItemBackGround(_itemCfg.ItemColor);
|
}
|
}
|
m_ItemCnt.text = _itemCnt <= 1 ? string.Empty : _itemCnt.ToString();
|
if (m_BindIcon != null)
|
{
|
m_BindIcon.SetActive(_isBind == 1);
|
}
|
}
|
}
|
}
|
