using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Text.RegularExpressions;
|
using LitJson;
|
using TableConfig;
|
using UnityEngine;
|
using UnityEngine.UI;
|
|
namespace Snxxz.UI
|
{
|
public class FairyLeagueModel : Model, IAfterPlayerDataInitialize, IBeforePlayerDataInitialize, IPlayerLoginOk
|
{
|
public event Action OnRefreshFairyLeagueEvent;
|
private FairyLeagueStage m_FairyLeagueStage = FairyLeagueStage.Prepare;
|
public FairyLeagueStage fairyLeagueStage
|
{
|
get
|
{
|
if (StepRing())
|
{
|
return FairyLeagueStage.Over;
|
}
|
return m_FairyLeagueStage;
|
}
|
}
|
public int fairyLeagueRing
|
{
|
get
|
{
|
if (IsNextWeek)
|
{
|
return 0;
|
}
|
var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
|
if (_dayOfWeek < groupTimes[1].dayOfWeek || _dayOfWeek > resultTimes[1].dayOfWeek)
|
{
|
return 0;
|
}
|
else if (_dayOfWeek == groupTimes[1].dayOfWeek)
|
{
|
if (TimeUtility.ServerNow.Hour < groupTimes[1].startHour)
|
{
|
return 0;
|
}
|
else if (TimeUtility.ServerNow.Hour == groupTimes[1].startHour &&
|
TimeUtility.ServerNow.Minute < groupTimes[1].startMinute)
|
{
|
return 0;
|
}
|
}
|
return 1;
|
}
|
}
|
public int OpenServerWeek
|
{
|
get;
|
private set;
|
}
|
public int ringCnt
|
{
|
get;
|
private set;
|
}
|
public bool IsNextWeek
|
{
|
get
|
{
|
if (TimeUtility.OpenWeekCnt >= OpenServerWeek)
|
{
|
var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
|
if (_dayOfWeek > resultTimes[1].dayOfWeek && _dayOfWeek <= 7)
|
{
|
return true;
|
}
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
}
|
|
public override void Init()
|
{
|
ParseConfig();
|
m_JoinFairyLeagueRedpoint = new Redpoint(10704, 1070401);
|
dataRequestDict.Add(FairyLeagueStage.Grouping, false);
|
dataRequestDict.Add(FairyLeagueStage.Fight, false);
|
dataRequestDict.Add(FairyLeagueStage.Over, false);
|
TimeUtility.OnServerOpenDayRefresh += OnServerOpenDayRefresh;
|
DTCA003_tagUniversalGameRecInfo.onGetUniversalGameInfo += OnGetUniversalGameInfo;
|
PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
|
StageManager.Instance.onStageLoadFinish += OnStageLoadFinish;
|
fairyLeagueHelp = new FairyLeagueHelp();
|
}
|
|
public override void UnInit()
|
{
|
DTCA003_tagUniversalGameRecInfo.onGetUniversalGameInfo -= OnGetUniversalGameInfo;
|
}
|
public void OnBeforePlayerDataInitialize()
|
{
|
ClearFairyWarHelp();
|
fairyLeagueFairyId = 0;
|
fairyLeagueFairyName = string.Empty;
|
}
|
public void OnAfterPlayerDataInitialize()
|
{
|
for (int i = 0; i < fairyStages.Length; i++)
|
{
|
dataRequestDict[fairyStages[i]] = false;
|
}
|
TimeMgr.Instance.OnSyntonyEvent -= OnSyntonyEvent;
|
TimeMgr.Instance.OnSyntonyEvent += OnSyntonyEvent;
|
}
|
public void OnPlayerLoginOk()
|
{
|
CheckFairyLeagueStage();
|
CheckFairyLeagueData();
|
UpdateRedpoint();
|
}
|
private void OnServerOpenDayRefresh()
|
{
|
CheckFairyLeagueStage();
|
}
|
|
private void PlayerDataRefreshInfoEvent(PlayerDataRefresh _type)
|
{
|
if (_type == PlayerDataRefresh.MapID)
|
{
|
UpdateRedpoint();
|
}
|
}
|
|
private void OnStageLoadFinish()
|
{
|
if (StageManager.Instance.CurrentStage is DungeonStage &&
|
PlayerDatas.Instance.baseData.MapID == FAIRY_LEAGUE_DUNGEON)
|
{
|
UpdateRedpoint();
|
}
|
}
|
|
private void OnSyntonyEvent(TimeMgr.SyntonyType type)
|
{
|
if (type == TimeMgr.SyntonyType.FairyLeaugeStage)
|
{
|
CheckFairyLeagueStage();
|
CheckFairyLeagueData();
|
if (OnRefreshFairyLeagueEvent != null)
|
{
|
OnRefreshFairyLeagueEvent();
|
}
|
UpdateRedpoint();
|
}
|
}
|
#region 配置
|
public const int FAIRY_LEAGUE_DUNGEON = 31220;
|
public const int FAIRY_LEAGUE_BATTLE = 68;
|
public readonly int[] groupRingStates = new int[] { 11, 21 };
|
public readonly int[] fightRingStates = new int[] { 12, 22 };
|
public readonly int overRingStates = 99;
|
public WeekTime[] groupTimes { get; private set; }
|
public WeekTime[] fightTimes { get; private set; }
|
public WeekTime[] resultTimes { get; private set; }
|
public WeekTime overTime { get; private set; }
|
public readonly WeekTime skipWeekTime = new WeekTime(1, 0, 0, 0, 0);
|
public List<WeekTime> fairyLeagueWeekTimes = new List<WeekTime>();
|
private string[] guideImgKeys;
|
public string[] GuideImgKeys
|
{
|
get
|
{
|
return guideImgKeys;
|
}
|
}
|
private readonly FairyLeagueStage[] fairyStages = new FairyLeagueStage[]
|
{
|
FairyLeagueStage.Grouping,
|
FairyLeagueStage.Fight, FairyLeagueStage.Over
|
};
|
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<AwardItem>> finalWarAwardDict = new Dictionary<int, List<AwardItem>>();
|
public Dictionary<int, List<AwardItem>> finalWarChampionAwardDict = new Dictionary<int, List<AwardItem>>();
|
private Dictionary<int, float> crystalRateDict = new Dictionary<int, float>();
|
private void ParseConfig()
|
{
|
FuncConfigConfig cfg = ConfigManager.Instance.GetTemplate<FuncConfigConfig>("FamilyMatchGuide");
|
if (cfg != null)
|
{
|
guideImgKeys = ConfigParse.GetMultipleStr(cfg.Numerical1);
|
}
|
ringCnt = groupRingStates.Length;
|
groupTimes = new WeekTime[groupRingStates.Length];
|
DungeonStateTimeConfig stateCfg = null;
|
for (int i = 0; i < groupRingStates.Length; i++)
|
{
|
stateCfg = DungeonStateTimeConfig.DungeonStateTime(FAIRY_LEAGUE_DUNGEON, groupRingStates[i]);
|
if (stateCfg != null)
|
{
|
OpenServerWeek = stateCfg.OpenServerWeek;
|
groupTimes[i] = new WeekTime(stateCfg.StartWeekday, stateCfg.StartHour,
|
stateCfg.StartMinute, stateCfg.EndHour, stateCfg.EndMinute);
|
fairyLeagueWeekTimes.Add(groupTimes[i]);
|
}
|
}
|
fightTimes = new WeekTime[fightRingStates.Length];
|
resultTimes = new WeekTime[fightRingStates.Length];
|
for (int i = 0; i < fightRingStates.Length; i++)
|
{
|
stateCfg = DungeonStateTimeConfig.DungeonStateTime(FAIRY_LEAGUE_DUNGEON, fightRingStates[i]);
|
if (stateCfg != null)
|
{
|
fightTimes[i] = new WeekTime(stateCfg.StartWeekday, stateCfg.StartHour,
|
stateCfg.StartMinute, stateCfg.EndHour, stateCfg.EndMinute);
|
fairyLeagueWeekTimes.Add(fightTimes[i]);
|
resultTimes[i] = new WeekTime(stateCfg.StartWeekday, stateCfg.EndHour, stateCfg.EndMinute, 0, 0);
|
fairyLeagueWeekTimes.Add(resultTimes[i]);
|
}
|
}
|
stateCfg = DungeonStateTimeConfig.DungeonStateTime(FAIRY_LEAGUE_DUNGEON, overRingStates);
|
overTime = new WeekTime(stateCfg.StartWeekday, stateCfg.StartHour,
|
stateCfg.StartMinute, stateCfg.EndHour, stateCfg.EndMinute);
|
fairyLeagueWeekTimes.Add(overTime);
|
fairyLeagueWeekTimes.Sort(CompareTime);
|
|
cfg = ConfigManager.Instance.GetTemplate<FuncConfigConfig>("FamilyMatchResourcePoint");
|
if (cfg != null)
|
{
|
crystalSortDict = new Dictionary<int, int[]>();
|
var _sortArray = JsonMapper.ToObject<int[][]>(cfg.Numerical3);
|
for (int i = 0; i < _sortArray.Length; i++)
|
{
|
crystalSortDict.Add(i + 1, _sortArray[i]);
|
}
|
fairyLeagueCrystals = JsonMapper.ToObject<int[]>(cfg.Numerical2);
|
fairyWarResUpperLimit = int.Parse(cfg.Numerical5);
|
}
|
cfg = ConfigManager.Instance.GetTemplate<FuncConfigConfig>("FamilyMatchRandomBuff");
|
if (cfg != null)
|
{
|
if (RandomBuffPos_Regex.IsMatch(cfg.Numerical1))
|
{
|
foreach (Match match in RandomBuffPos_Regex.Matches(cfg.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]+):\[(.*?\])\]");
|
cfg = ConfigManager.Instance.GetTemplate<FuncConfigConfig>("FamilyMatchRankReward");
|
if (_regex.IsMatch(cfg.Numerical1))
|
{
|
foreach (Match match in _regex.Matches(cfg.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[]>(cfg.Numerical2);
|
}
|
cfg = ConfigManager.Instance.GetTemplate<FuncConfigConfig>("FamilyMatchRankOneReward");
|
if (_regex.IsMatch(cfg.Numerical1))
|
{
|
foreach (Match match in _regex.Matches(cfg.Numerical1))
|
{
|
var _worldLv = int.Parse(match.Groups[1].Value);
|
List<AwardItem> _list = ParseAward(StringUtility.Contact('[', match.Groups[2].Value, ']'));
|
finalWarAwardDict.Add(_worldLv, _list);
|
}
|
}
|
cfg = ConfigManager.Instance.GetTemplate<FuncConfigConfig>("FamilyMatchSRankOneReward");
|
if (_regex.IsMatch(cfg.Numerical1))
|
{
|
foreach (Match match in _regex.Matches(cfg.Numerical1))
|
{
|
var _worldLv = int.Parse(match.Groups[1].Value);
|
List<AwardItem> _list = ParseAward(StringUtility.Contact('[', match.Groups[2].Value, ']'));
|
finalWarChampionAwardDict.Add(_worldLv, _list);
|
}
|
}
|
cfg = ConfigManager.Instance.GetTemplate<FuncConfigConfig>("FamilyMatchPersonalScore");
|
integralAddition = int.Parse(cfg.Numerical5);
|
cfg = ConfigManager.Instance.GetTemplate<FuncConfigConfig>("FamilyMatchResourcePoint1");
|
crystalRateDict = ConfigParse.GetDic<int, float>(cfg.Numerical1);
|
}
|
private List<AwardItem> ParseAward(string _config)
|
{
|
List<AwardItem> _list = new List<AwardItem>();
|
var _array = JsonMapper.ToObject<int[][]>(_config);
|
if (_array != null)
|
{
|
for (int i = 0; i < _array.Length; i++)
|
{
|
AwardItem _item = new AwardItem();
|
_item.item.id = _array[i][0];
|
_item.item.count = _array[i][1];
|
_item.isBind = _array[i][2];
|
_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 = ConfigManager.Instance.GetTemplate<SkillConfig>(buffTypeId);
|
_lv = Mathf.Min(_lv, _buffTypeCfg.SkillMaxLV);
|
return ConfigManager.Instance.GetTemplate<SkillConfig>(buffTypeId + _lv - 1);
|
}
|
|
public bool TryGetCrystalRate(int _npcId, out float _rate)
|
{
|
return crystalRateDict.TryGetValue(_npcId, out _rate);
|
}
|
#endregion
|
public void CheckFairyLeagueStage()
|
{
|
var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
|
if (IsNextWeek)
|
{
|
m_FairyLeagueStage = FairyLeagueStage.Prepare;
|
return;
|
}
|
for (int i = 0; i < fairyLeagueWeekTimes.Count; i++)
|
{
|
var _weekTime = fairyLeagueWeekTimes[i];
|
if (_dayOfWeek < _weekTime.dayOfWeek)
|
{
|
m_FairyLeagueStage = GetFairyLeagueStage(i);
|
return;
|
}
|
if (_dayOfWeek == _weekTime.dayOfWeek)
|
{
|
if (TimeUtility.Hour < _weekTime.startHour)
|
{
|
m_FairyLeagueStage = GetFairyLeagueStage(i);
|
return;
|
}
|
if (TimeUtility.Hour == _weekTime.startHour &&
|
TimeUtility.Minute < _weekTime.startMinute)
|
{
|
m_FairyLeagueStage = GetFairyLeagueStage(i);
|
return;
|
}
|
}
|
}
|
var _nowTime = new WeekTime(_dayOfWeek, TimeUtility.Hour, TimeUtility.Minute, 0, 0, TimeUtility.Second);
|
TimeMgr.Instance.Register(TimeMgr.SyntonyType.FairyLeaugeStage,
|
(float)(skipWeekTime - _nowTime).TotalSeconds);
|
m_FairyLeagueStage = FairyLeagueStage.Prepare;
|
}
|
private FairyLeagueStage GetFairyLeagueStage(int _index)
|
{
|
var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
|
var _nowTime = new WeekTime(_dayOfWeek, TimeUtility.Hour, TimeUtility.Minute, 0, 0, TimeUtility.Second);
|
TimeMgr.Instance.Register(TimeMgr.SyntonyType.FairyLeaugeStage,
|
(float)(fairyLeagueWeekTimes[_index] - _nowTime).TotalSeconds);
|
switch (_index)
|
{
|
case 0:
|
return FairyLeagueStage.Prepare;
|
case 1:
|
case 4:
|
return FairyLeagueStage.Grouping;
|
case 2:
|
case 5:
|
return FairyLeagueStage.Fight;
|
case 3:
|
case 6:
|
return FairyLeagueStage.Over;
|
}
|
return FairyLeagueStage.Prepare;
|
}
|
private int CompareTime(WeekTime x, WeekTime y)
|
{
|
if (x.dayOfWeek.CompareTo(y.dayOfWeek) != 0)
|
{
|
return x.dayOfWeek.CompareTo(y.dayOfWeek);
|
}
|
if (x.startHour.CompareTo(y.startHour) != 0)
|
{
|
return x.startHour.CompareTo(y.startHour);
|
}
|
return x.startMinute.CompareTo(y.startMinute);
|
}
|
#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 bool IsAlreadyBattleGuide()
|
{
|
return QuickSetting.Instance.GetQuickSettingBool(QuickSetting.QuickSettingType.FairyLeagueGuide, 0);
|
}
|
public void SetBattleGuide()
|
{
|
QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.FairyLeagueGuide, true);
|
QuickSetting.Instance.SendPackage();
|
}
|
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 _ring = fairyLeagueRing;
|
if (_ring == 0 &&
|
fairyLeagueBattleDict.ContainsKey(_ring)
|
&& fairyLeagueBattleDict[_ring].ContainsKey(5))
|
{
|
var _list = fairyLeagueBattleDict[_ring][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,
|
ring = (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();
|
for (int i = 0; i < fairyStages.Length; i++)
|
{
|
dataRequestDict[fairyStages[i]] = fairyStages[i] == fairyLeagueStage ? true : false;
|
}
|
}
|
}
|
public bool SelfFairyInBattle(out int _error)
|
{
|
_error = 3;
|
var _ring = fairyLeagueRing;
|
var _fairyId = PlayerDatas.Instance.fairyData.fairy.FamilyID;
|
if (!fairyLeagueBattleDict.ContainsKey(_ring))
|
{
|
return false;
|
}
|
var _dict = fairyLeagueBattleDict[_ring];
|
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 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.Family)
|
{
|
_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 _ring = fairyLeagueRing;
|
_ring = fairyLeagueStage == FairyLeagueStage.Fight || fairyLeagueStage == FairyLeagueStage.Over ? 1 - _ring : _ring;
|
if (_ring == 1)
|
{
|
var _param = StringUtility.Contact(Language.Get(StringUtility.Contact("Weekday", groupTimes[_ring].dayOfWeek)),
|
fightTimes[1].startHour.ToString("D2"), ":", fightTimes[1].startMinute.ToString("D2"));
|
SysNotifyMgr.Instance.ShowTip("LeagueCannotGo1", _param);
|
}
|
else
|
{
|
var _param = StringUtility.Contact(Language.Get("Next"), Language.Get(StringUtility.Contact("Weekday", groupTimes[_ring].dayOfWeek)),
|
fightTimes[0].startHour.ToString("D2"), ":", fightTimes[0].startMinute.ToString("D2"));
|
SysNotifyMgr.Instance.ShowTip("LeagueCannotGo2", _param);
|
}
|
break;
|
case 6:
|
SysNotifyMgr.Instance.ShowTip("PlayerWarFamilyIDIsChange");
|
break;
|
}
|
}
|
|
private Dictionary<FairyLeagueStage, bool> dataRequestDict = new Dictionary<FairyLeagueStage, bool>();
|
public void CheckFairyLeagueData()
|
{
|
//if (dataRequestDict.ContainsKey(fairyLeagueStage) && !dataRequestDict[fairyLeagueStage])
|
//{
|
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 _ring = fairyLeagueRing;
|
var _fairyId = PlayerDatas.Instance.fairyData.fairy.FamilyID;
|
if (!fairyLeagueBattleDict.ContainsKey(_ring))
|
{
|
return null;
|
}
|
var _dict = fairyLeagueBattleDict[_ring];
|
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 StepRing(int _grade = 5)
|
{
|
if (fairyLeagueRing == 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 GetBattleFirstPlayer()
|
{
|
if (fairyLeagueResults.Count == 0)
|
{
|
return -1;
|
}
|
for (int i = 0; i < fairyLeagueResults.Count; i++)
|
{
|
if (fairyLeagueResults[i].IsWin)
|
{
|
return i;
|
}
|
}
|
return 0;
|
}
|
#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
|
}
|
public struct WeekTime
|
{
|
public int dayOfWeek { get; private set; }
|
public int startHour { get; private set; }
|
public int startMinute { get; private set; }
|
public int startSeconds { get; private set; }
|
public int endHour { get; private set; }
|
public int endMinute { get; private set; }
|
|
public WeekTime(int _weekDay, int _startHour, int _startMinute, int _endHour, int _endMinute, int _startSeconds = 0)
|
{
|
dayOfWeek = _weekDay;
|
startHour = _startHour;
|
startMinute = _startMinute;
|
startSeconds = _startSeconds;
|
endHour = _endHour;
|
endMinute = _endMinute;
|
}
|
public static TimeSpan operator -(WeekTime y, WeekTime x)
|
{
|
var _totalSeconds = 0;
|
int i = x.dayOfWeek;
|
for (i = x.dayOfWeek; i != y.dayOfWeek; i = i == 7 ? 1 : i + 1)
|
{
|
if (i == x.dayOfWeek)
|
{
|
_totalSeconds += (23 - x.startHour) * 3600 + (59 - x.startMinute) * 60 + 60 - x.startSeconds;
|
}
|
else
|
{
|
_totalSeconds += 24 * 3600;
|
}
|
}
|
if (i == y.dayOfWeek)
|
{
|
if (x.dayOfWeek == i)
|
{
|
var _timeSpany = new TimeSpan(y.startHour, y.startMinute, y.startSeconds);
|
var _timeSpanx = new TimeSpan(x.startHour, x.startMinute, x.startSeconds);
|
_totalSeconds += (int)(_timeSpany.TotalSeconds - _timeSpanx.TotalSeconds);
|
}
|
else
|
{
|
_totalSeconds += y.startHour * 3600;
|
}
|
}
|
return new TimeSpan(_totalSeconds * TimeSpan.TicksPerSecond);
|
}
|
|
private static WeekTime s_Now = new WeekTime();
|
public static WeekTime Now
|
{
|
get
|
{
|
var _dayOfWeek = TimeUtility.ServerNow.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)TimeUtility.ServerNow.DayOfWeek;
|
s_Now.dayOfWeek = _dayOfWeek;
|
s_Now.startHour = TimeUtility.Hour;
|
s_Now.startMinute = TimeUtility.Minute;
|
s_Now.startSeconds = TimeUtility.Second;
|
return s_Now;
|
}
|
}
|
}
|
public enum FairyLeagueStage
|
{
|
Prepare,
|
Grouping,
|
Fight,
|
Over,
|
}
|
public enum FairyCampType
|
{
|
None,
|
Red = 1,
|
Blue = 2
|
}
|
public class FairyLeagueBattleData
|
{
|
public int grade;
|
public int ring;
|
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 = ConfigManager.Instance.GetTemplate<ItemConfig>(_itemId);
|
m_ItemIcon.gameObject.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.gameObject.SetActive(_isBind == 1);
|
}
|
}
|
}
|
}
|
