using vnxbqy.UI;
|
using System;
|
using System.Collections.Generic;
|
using UnityEngine.UI;
|
using System.Linq;
|
using LitJson;
|
using UnityEngine;
|
using System.Collections;
|
|
|
//跨服排位赛的数据来源上一赛季的跨服天梯前64位
|
public class CrossServerQualifyingModel : ILModel<CrossServerQualifyingModel>
|
{
|
public const int DATA_MAPID = 32070;
|
public int selectIndex; // 跨服排位主标签选择
|
public int select64Index = 0; // 选中的64强比赛标签，非当前赛程
|
public List<uint> groupBtnMarks = new List<uint>() { 64, 32, 16 };//64强标签按钮对应的赛程
|
public List<uint> group8BtnMarks = new List<uint>() { 8, 4, 2 };//8强
|
public uint select64Mark
|
{
|
get { return groupBtnMarks[select64Index]; }
|
}
|
|
public int actID; // 活动ID，活动ID不同则可重置前端排位赛相关缓存数据
|
public int stateError; // 本次活动是否已经出现流程状态异常；如服务器异常或维护服务器导致跳过步骤，则会废弃该次比赛，直到下次新活动；
|
public int zoneID; //上一赛季所在的赛区ID, 以C015为准过滤其他不匹配的封包
|
public int officialZoneID; //官职相关所在赛区可能是上上赛季的赛区
|
|
//所有参赛者总名单
|
public Dictionary<uint, CrossChampionshipPKPlayer> fightersInfo = new Dictionary<uint, CrossChampionshipPKPlayer>();
|
//赛程对战列表 <赛程分组（如64强/32强）,<赛程内分组, 分组信息>>
|
public Dictionary<uint, Dictionary<uint, CrossChampionshipPKBattle>> battleInfo = new Dictionary<uint, Dictionary<uint, CrossChampionshipPKBattle>>();
|
public event Action UpdateCrossChampionshipPKZoneGroupInfoEvent;
|
//当前赛程（如64强/32强），0代表不在比赛流程中
|
public uint nowGroupMark
|
{
|
get
|
{
|
var battleID = GetBattleID();
|
if (battleID == -1) return 0;
|
var state = ILChampionshipTimeConfig.Get(battleID).StateValue;
|
if (state == 80) return 64; //8强竞猜
|
if (state == 40) return 8; //四强竞猜
|
return (uint)state / 10;
|
}
|
}
|
|
public List<DateTime> openTimes = new List<DateTime>();
|
|
//竞猜公共和个人信息
|
public Dictionary<int, int> guess8Common = new Dictionary<int, int>();
|
public Dictionary<int, int> guess4Common = new Dictionary<int, int>();
|
public Dictionary<int, Int2> guess8Personal = new Dictionary<int, Int2>();
|
public Dictionary<int, Int2> guess4Personal = new Dictionary<int, Int2>(); //投注额度和名次
|
public List<int> guessPlayer64List = new List<int>();
|
public List<int> guessPlayer8List = new List<int>(); //8强名单，由16强列表中筛选胜者
|
public Dictionary<int, int> myGuessInfo = new Dictionary<int, int>();
|
public event Action UpdateGuessEvent;
|
|
public int guessMoneyType;
|
public int guessMoney;
|
public int guessMaxCnt;
|
public bool isNetPackRefreshGuess4; //界面打开的情况下 封包刷新不刷名次，避免玩家选名次后被刷0
|
//对阵表
|
public List<int> raceList = new List<int>() { 82, 82, 82, 82, 42, 42, 42, 42, 22, 22, 22, 22 };
|
|
//官职ID：官职信息
|
public Dictionary<int, ChampionshipOfficial> rankOfficialDict = new Dictionary<int, ChampionshipOfficial>();
|
|
public int myOfficialID = 0; //我的官职
|
public int selectOffcialID; //选中的界主官场
|
public int selectOffcialSub;//0上界 1中界
|
public int selectApplyOfficialID; //申请列表的仙官 或者查看挑战的仙官
|
//官职上下管理 界主下包含哪些官职分上中界
|
public Dictionary<int, List<List<int>>> offcialOperList = new Dictionary<int, List<List<int>>>();
|
public event Action UpdateOffcialEvent;
|
|
public int applyMaxTimes; //可同时申请的不同官位数量
|
public int applyPlayerMaxCnt; //一个官可以有几个玩家申请
|
public int offcialNeedRealm;
|
public int kickSeconds;
|
public int myApplyCnt;
|
|
Redpoint redpoint = new Redpoint(MainRedPoint.CrossServerQualifyingRedPoint);
|
public Redpoint mobaiRedpoint = new Redpoint(MainRedPoint.CrossServerQualifyingRedPoint, 4232);//膜拜
|
public Redpoint officialRedpoint = new Redpoint(MainRedPoint.CrossServerQualifyingRedPoint, 4233);
|
public Redpoint loginRedpoint = new Redpoint(MainRedPoint.CrossServerQualifyingRedPoint, 4239);//登录
|
|
public int worshipCntToday; //今日膜拜次数
|
public event Action UpdateWorshipEvent;
|
public int worshipMaxCnt;
|
public int[][] doubleTimeArr;
|
public int challengeMaxCnt; //挑战次数
|
|
public Action<uint, uint> QueryRaceScoreEvent; // 查询比分
|
|
DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
|
ServerMirrorFightModel mirrorFightModel { get { return ModelCenter.Instance.GetModel<ServerMirrorFightModel>(); } }
|
|
protected override void Init()
|
{
|
ParseConfig();
|
GameEvent.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;
|
GlobalTimeEvent.Instance.minuteEvent += OnMinuteEvent;
|
GameEvent.playerLoginOkEvent += PlayerLoginOkEvent;
|
}
|
|
protected override void UnInit()
|
{
|
GameEvent.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;
|
GlobalTimeEvent.Instance.minuteEvent -= OnMinuteEvent;
|
GameEvent.playerLoginOkEvent -= PlayerLoginOkEvent;
|
}
|
|
void ParseConfig()
|
{
|
var config = FuncConfigConfig.Get("CrossChamFB");
|
var openTimeArr = JsonMapper.ToObject<string[]>(config.Numerical1);
|
for (int i = 0; i < openTimeArr.Length; i++)
|
{
|
openTimes.Add(Convert.ToDateTime(openTimeArr[i]));
|
}
|
|
config = FuncConfigConfig.Get("CrossChamGuess");
|
var moneyInfo = config.Numerical1.Split('|');
|
guessMoneyType = int.Parse(moneyInfo[0]);
|
guessMoney = int.Parse(moneyInfo[1]);
|
guessMaxCnt = int.Parse(config.Numerical2);
|
|
for (int i = 1; i <= 8; i++)
|
{
|
var subArr = JsonMapper.ToObject<int[]>(ILChampionshipOfficialConfig.Get(i).JuniorOfficialIDList);
|
|
if (!offcialOperList.ContainsKey(i))
|
{
|
List<List<int>> tmp = new List<List<int>>();
|
tmp.Add(new List<int>());
|
tmp.Add(new List<int>());
|
offcialOperList[i] = tmp;
|
}
|
|
for (int j = 0; j < subArr.Length; j++)
|
{
|
if (ILChampionshipOfficialConfig.Get(subArr[j]).CanBeReplace == 0)
|
{
|
//上界
|
offcialOperList[i][0].Add(subArr[j]);
|
}
|
else
|
{
|
//中界
|
offcialOperList[i][1].Add(subArr[j]);
|
}
|
}
|
}
|
|
config = FuncConfigConfig.Get("CrossChamOfficial");
|
applyPlayerMaxCnt = int.Parse(config.Numerical1);
|
applyMaxTimes = int.Parse(config.Numerical2);
|
offcialNeedRealm = int.Parse(config.Numerical3);
|
kickSeconds = int.Parse(config.Numerical4);
|
|
config = FuncConfigConfig.Get("CrossChamWorship");
|
worshipMaxCnt = int.Parse(config.Numerical1);
|
doubleTimeArr = JsonMapper.ToObject<int[][]>(config.Numerical3);
|
|
config = FuncConfigConfig.Get("CrossChamMirrorPK");
|
challengeMaxCnt = int.Parse(config.Numerical1);
|
}
|
|
|
//下一次开启时间
|
public int GetNextOpenTimeIndex()
|
{
|
for (int i = 0; i < openTimes.Count; i++)
|
{
|
if (ILTimeUtility.ServerCrossNow < openTimes[i])
|
{
|
return i;
|
}
|
}
|
|
return -1;
|
}
|
|
//获取当前开启阶段
|
public int GetOpenTimeIndex()
|
{
|
if (openTimes.Count == 0) return -1;
|
var index = 0;
|
for (int i = 0; i < openTimes.Count; i++)
|
{
|
if (ILTimeUtility.ServerCrossNow < openTimes[i])
|
{
|
return index;
|
}
|
index = i;
|
}
|
|
return index;
|
}
|
|
//界面可打开的情况，判断是否赛程中
|
public bool IsOpen()
|
{
|
if (stateError != 0)
|
{
|
return false;
|
}
|
|
if (fightersInfo.Count == 0)
|
{
|
return false;
|
}
|
|
return true;
|
}
|
|
public void UpdateCrossChampionshipPKZoneGroupInfo(HC015_tagGCCrossChampionshipPKZoneGroupInfo netPack)
|
{
|
stateError = netPack.StateError;
|
|
if (actID != (int)netPack.ActID)
|
{
|
actID = (int)netPack.ActID;
|
zoneID = netPack.ZoneID;
|
fightersInfo.Clear();
|
battleInfo.Clear();
|
}
|
|
for (int i = 0; i < netPack.PlayerList.Length; i++)
|
{
|
var player = netPack.PlayerList[i];
|
fightersInfo[player.PlayerID] = new CrossChampionshipPKPlayer()
|
{
|
PlayerID = player.PlayerID,
|
PlayerName = player.PlayerName,
|
FightPower = (long)player.FightPowerEx * (long)Constants.ExpPointValue + player.FightPower,
|
Job = player.Job,
|
LV = player.LV,
|
Face = player.Face,
|
FacePic = player.FacePic,
|
};
|
}
|
|
for (int i = 0; i < netPack.GroupList.Length; i++)
|
{
|
var group = netPack.GroupList[i];
|
if (!battleInfo.ContainsKey(group.GroupMark))
|
{
|
battleInfo[group.GroupMark] = new Dictionary<uint, CrossChampionshipPKBattle>();
|
}
|
for (int j = 0; j < group.BattleList.Length; j++)
|
{
|
var battleList = group.BattleList[j];
|
battleInfo[group.GroupMark][battleList.BattleNum] = new CrossChampionshipPKBattle()
|
{
|
BattleNum = battleList.BattleNum,
|
WinPlayerID = battleList.WinPlayerID,
|
PlayerIDA = battleList.PlayerIDA,
|
PlayerIDB = battleList.PlayerIDB,
|
battleResult = ConfigParse.ParseIntArray2Dict(battleList.BattleRet),
|
};
|
}
|
}
|
|
UpdateCrossChampionshipPKZoneGroupInfoEvent?.Invoke();
|
}
|
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
actID = 0;
|
zoneID = 0;
|
officialZoneID = 0;
|
fightersInfo.Clear();
|
battleInfo.Clear();
|
guessPlayer8List.Clear();
|
guessPlayer64List.Clear();
|
guess8Common.Clear();
|
guess4Common.Clear();
|
guess8Personal.Clear();
|
guess4Personal.Clear();
|
myGuessInfo.Clear();
|
rankOfficialDict.Clear();
|
myOfficialID = 0;
|
myApplyCnt = 0;
|
worshipCntToday = 0;
|
pushGroupMark = 0;
|
isShowRaceInfoYet = false;
|
}
|
|
//获取当前的比赛赛程节点，-1代表当前时间不在排位赛流程中
|
public int GetBattleID()
|
{
|
var index = GetOpenTimeIndex();
|
if (index == -1) return -1;
|
var startDay = openTimes[index];
|
if (startDay > ILTimeUtility.ServerCrossNow)
|
{
|
//流程未开始
|
return -1;
|
}
|
//第一天 从1开始
|
var passDays = (ILTimeUtility.ServerCrossNow - startDay).Days + 1;
|
|
var keys = ILChampionshipTimeConfig.GetKeys();
|
//流程结束
|
if (ILChampionshipTimeConfig.Get(keys[keys.Count - 1]).StartDay < passDays)
|
return -1;
|
for (int i = 0; i < keys.Count; i++)
|
{
|
var config = ILChampionshipTimeConfig.Get(keys[i]);
|
if (passDays != config.StartDay && config.EndDay == config.StartDay)
|
continue;
|
|
var startTime = startDay.AddDays(config.StartDay - 1).AddSeconds(config.StartHour * 60 * 60 + config.StartMinute * 60);
|
var endTime = startDay.AddDays(config.EndDay - 1).AddSeconds(config.EndHour * 60 * 60 + config.EndMinute * 60 + 59);
|
if (ILTimeUtility.ServerCrossNow >= startTime && ILTimeUtility.ServerCrossNow <= endTime)
|
return int.Parse(keys[i]);
|
}
|
|
return -1;
|
}
|
|
//获取流程的开始时间
|
public string GetStartBattleTime(int battleID)
|
{
|
var index = GetOpenTimeIndex();
|
if (index == -1) return string.Empty;
|
var startDay = openTimes[index];
|
|
var config = ILChampionshipTimeConfig.Get(battleID);
|
var startTime = startDay.AddDays(config.StartDay - 1).AddSeconds(config.StartHour * 60 * 60 + config.StartMinute * 60);
|
|
return startTime.ToString("yyyy-MM-dd HH:mm");
|
}
|
|
//获取流程的结束时间 分钟，负数代表未开始
|
public double GetRaceEndRemindMinute(int battleID)
|
{
|
var index = GetOpenTimeIndex();
|
if (index == -1) return -1;
|
var startDay = openTimes[index];
|
|
var config = ILChampionshipTimeConfig.Get(battleID);
|
var endTime = startDay.AddDays(config.StartDay - 1).AddSeconds(config.EndHour * 60 * 60 + config.EndMinute * 60);
|
|
return (endTime - ILTimeUtility.ServerCrossNow).TotalMinutes;
|
}
|
|
public struct CrossChampionshipPKPlayer
|
{
|
public uint PlayerID;
|
public string PlayerName;
|
public byte Job;
|
public long FightPower;
|
public ushort LV;
|
public ushort RealmLV;
|
public uint Face; //基本脸型
|
public uint FacePic; //头像框
|
}
|
|
public struct CrossChampionshipPKBattle
|
{
|
public byte BattleNum; // 对战组编号 1~n
|
public uint WinPlayerID; // 获胜玩家ID
|
public uint PlayerIDA; // 玩家IDA
|
public uint PlayerIDB; // 玩家IDB
|
public Dictionary<int, int[][]> battleResult; // 战斗结果明细 {"playerID":[[第1局胜负,第1局总积分,胜负基础分,hp分,时间分], ...], ...}
|
}
|
|
public struct ChampionshipOfficial
|
{
|
public uint LastDismissJuniorTime; // 上次辞退下级仙官时间戳，跨服时间，如果自己是本界主时，用于计算辞退CD
|
public uint WorshipCount; // 被膜拜次数
|
public byte WorshipDouble; // 今日是否双倍膜拜，仅在规定时间点内有用
|
public CrossChampionshipPKPlayer OfficialPlayer; // 任职玩家信息，可能没有
|
public List<CrossChampionshipPKPlayer> ApplyPlayerList; // 申请该仙官玩家列表
|
}
|
|
|
//进入跨服排位赛，借用跨服竞技1v1模拟
|
public void EnterCrossServerQualifying()
|
{
|
uint tagPlayerID;
|
var battleResult = GetMyBattleInfo(nowGroupMark, out tagPlayerID);
|
int challengeCnt = battleResult.ContainsKey((int)PlayerDatas.Instance.baseData.PlayerID) ? battleResult[(int)PlayerDatas.Instance.baseData.PlayerID].Length : 0;
|
if (challengeCnt >= challengeMaxCnt)
|
{
|
SysNotifyMgr.Instance.ShowTip("CrossServerQualifying11");
|
return;
|
}
|
|
int error;
|
if (!dungeonModel.CanEnter(out error))
|
{
|
dungeonModel.ProcessEnterError(error);
|
return;
|
}
|
|
|
var teamModel = ModelCenter.Instance.GetModel<TeamModel>();
|
if (teamModel.isMatching)
|
{
|
teamModel.RequestCancelAutoMatchTeam();
|
}
|
|
|
var otherPlayerInfo = fightersInfo[tagPlayerID];
|
|
var opponent = new HC001_tagGCCrossRealmPKMatchOK.tagGCCrossRealmPKMatchPlayer();
|
opponent.Job = otherPlayerInfo.Job;
|
opponent.PlayerName = otherPlayerInfo.PlayerName;
|
opponent.PlayerID = otherPlayerInfo.PlayerID;
|
|
opponent.LV = otherPlayerInfo.LV;
|
opponent.RealmLV = otherPlayerInfo.RealmLV;
|
opponent.Face = otherPlayerInfo.Face;
|
opponent.FacePic = otherPlayerInfo.FacePic;
|
opponent.FightPower = (uint)((ulong)otherPlayerInfo.FightPower % Constants.ExpPointValue);
|
opponent.FightPowerEx = (uint)((ulong)otherPlayerInfo.FightPower / Constants.ExpPointValue);
|
|
CrossServerLogin.Instance.InitOneVsOnePlayerInfo(opponent);
|
mirrorFightModel.SendMirrorFight(DATA_MAPID, (ushort)(zoneID * 100 + nowGroupMark), tagPlayerID, 0);
|
return;
|
}
|
|
//查找自己是否有比赛,包含竞猜 分组和战斗结束的缓存时间
|
public bool HaveMyBattle(uint groupMark)
|
{
|
if (battleInfo.ContainsKey(groupMark))
|
{
|
var playerID = PlayerDatas.Instance.baseData.PlayerID;
|
var battle = battleInfo[groupMark];
|
var battleNums = battle.Keys.ToList();
|
for (int i = 0; i < battleNums.Count; i++)
|
{
|
var battleNum = battleNums[i];
|
//搜索玩家是否参赛者
|
if (battle[battleNum].PlayerIDA == playerID || battle[battleNum].PlayerIDB == playerID)
|
{
|
return true;
|
}
|
}
|
}
|
|
return false;
|
}
|
|
// 8强之前，查找玩家的下一场比赛，胜出未分组前也算
|
public int GetMyNextBattle()
|
{
|
int nextGroupMark = 0;
|
bool haveBattle = false;
|
for (int k = 0; k < groupBtnMarks.Count; k++)
|
{
|
var groupMark = groupBtnMarks[k];
|
nextGroupMark = (int)groupMark;
|
if (battleInfo.ContainsKey(groupMark))
|
{
|
var playerID = PlayerDatas.Instance.baseData.PlayerID;
|
var battle = battleInfo[groupMark];
|
var battleNums = battle.Keys.ToList();
|
for (int i = 0; i < battleNums.Count; i++)
|
{
|
var battleNum = battleNums[i];
|
//搜索玩家是否参赛者
|
if (battle[battleNum].WinPlayerID == playerID)
|
{
|
haveBattle = true;
|
continue;
|
}
|
if (battle[battleNum].PlayerIDA == playerID || battle[battleNum].PlayerIDB == playerID)
|
{
|
haveBattle = true;
|
return nextGroupMark;
|
}
|
}
|
}
|
}
|
|
return haveBattle ? nextGroupMark : 0;
|
}
|
|
|
//当前的比赛比分情况
|
public Dictionary<int, int[][]> GetMyBattleInfo(uint groupMark, out uint tagPlayerID)
|
{
|
tagPlayerID = 0;
|
if (battleInfo.ContainsKey(groupMark))
|
{
|
var playerID = PlayerDatas.Instance.baseData.PlayerID;
|
var battle = battleInfo[groupMark];
|
var battleNums = battle.Keys.ToList();
|
for (int i = 0; i < battleNums.Count; i++)
|
{
|
var battleNum = battleNums[i];
|
|
if (battle[battleNum].PlayerIDA == playerID || battle[battleNum].PlayerIDB == playerID)
|
{
|
tagPlayerID = battle[battleNum].PlayerIDA == playerID ? battle[battleNum].PlayerIDB : battle[battleNum].PlayerIDA;
|
return battle[battleNum].battleResult;
|
}
|
}
|
}
|
|
return null;
|
}
|
|
public CrossChampionshipPKBattle QueryPKScoreInfoByPlayerID(uint groupMark, uint playerID)
|
{
|
if (battleInfo.ContainsKey(groupMark))
|
{
|
var battle = battleInfo[groupMark];
|
var battleNums = battle.Keys.ToList();
|
for (int i = 0; i < battleNums.Count; i++)
|
{
|
var battleNum = battleNums[i];
|
if (battle[battleNum].PlayerIDA == playerID || battle[battleNum].PlayerIDB == playerID)
|
{
|
return battle[battleNum];
|
}
|
}
|
}
|
|
return new CrossChampionshipPKBattle();
|
}
|
|
|
|
|
public uint WinnerID; // 胜方ID
|
public int score;
|
|
public void UpdatePKResult()
|
{
|
if (dungeonModel.dungeonResult.isWin == 1)
|
{
|
WinnerID = PlayerDatas.Instance.baseData.PlayerID;
|
}
|
else
|
{
|
WinnerID = 0;
|
}
|
|
score = dungeonModel.dungeonResult.addScore;
|
|
if (WindowCenter.Instance.IsOpen<FightingPKWin>())
|
{
|
WindowCenter.Instance.Close<FightingPKWin>();
|
}
|
WindowCenter.Instance.OpenIL<CrossServerQualifyingSettlementWin>();
|
}
|
|
|
|
//竞猜公共信息：支持人数
|
public void UpdateGuessCommon(IL_HC022_tagGCChampionshipGuessPubInfo netPack)
|
{
|
for (int i = 0; i < netPack.GuessList.Length; i++)
|
{
|
if (netPack.GuessList[i].GuessType == 8)
|
{
|
for (int j = 0; j < netPack.GuessList[i].GuessPlayerList.Length; j++)
|
{
|
var player = netPack.GuessList[i].GuessPlayerList[j];
|
guess8Common[(int)player.PlayerID] = (int)player.SupportCount;
|
}
|
}
|
else if (netPack.GuessList[i].GuessType == 4)
|
{
|
for (int j = 0; j < netPack.GuessList[i].GuessPlayerList.Length; j++)
|
{
|
var player = netPack.GuessList[i].GuessPlayerList[j];
|
guess4Common[(int)player.PlayerID] = (int)player.SupportCount;
|
}
|
}
|
}
|
|
UpdateGuessEvent?.Invoke();
|
}
|
|
//竞猜个人信息：投注额度和名次
|
public void UpdateGuessPersonal(IL_HC023_tagGCChampionshipGuessPriInfo netPack)
|
{
|
for (int i = 0; i < netPack.GuessList.Length; i++)
|
{
|
if (netPack.GuessList[i].GuessType == 8)
|
{
|
for (int j = 0; j < netPack.GuessList[i].GuessPlayerList.Length; j++)
|
{
|
var player = netPack.GuessList[i].GuessPlayerList[j];
|
guess8Personal[(int)player.PlayerID] = new Int2((int)player.MoneyTotal, player.GuessRank);
|
}
|
}
|
else if (netPack.GuessList[i].GuessType == 4)
|
{
|
for (int j = 0; j < netPack.GuessList[i].GuessPlayerList.Length; j++)
|
{
|
var player = netPack.GuessList[i].GuessPlayerList[j];
|
guess4Personal[(int)player.PlayerID] = new Int2((int)player.MoneyTotal, player.GuessRank);
|
if (player.GuessRank != 0)
|
{
|
myGuessInfo[player.GuessRank] = (int)player.PlayerID;
|
}
|
}
|
}
|
}
|
|
UpdateGuessEvent?.Invoke();
|
}
|
|
////竞猜列表顺序，是否投注-战力-玩家ID
|
public void Player64ListSort()
|
{
|
guessPlayer64List.Clear();
|
|
var tList = fightersInfo.Keys.ToList();
|
for (int i = 0; i < tList.Count; i++)
|
{
|
guessPlayer64List.Add((int)tList[i]);
|
}
|
guessPlayer64List.Sort(CompareGuess64);
|
return;
|
}
|
|
int CompareGuess64(int idA, int idB)
|
{
|
bool isGuessA = guess8Personal.ContainsKey(idA);
|
bool isGusssB = guess8Personal.ContainsKey(idB);
|
|
if (isGuessA != isGusssB)
|
{
|
return isGusssB.CompareTo(isGuessA);
|
}
|
|
long fightPowerA = fightersInfo[(uint)idA].FightPower;
|
long fightPowerB = fightersInfo[(uint)idB].FightPower;
|
|
if (fightPowerA != fightPowerB)
|
{
|
return fightPowerB.CompareTo(fightPowerA);
|
}
|
|
return idA.CompareTo(idB);
|
}
|
|
//8强名单来源于 16强淘汰赛后的胜者
|
public void Player8ListSort()
|
{
|
if (!battleInfo.ContainsKey(16))
|
{
|
return;
|
}
|
guessPlayer8List.Clear();
|
var tList = battleInfo[16].Keys.ToList();
|
for (int i = 0; i < tList.Count; i++)
|
{
|
var battle = battleInfo[16][tList[i]];
|
if (battle.WinPlayerID != 0)
|
{
|
guessPlayer8List.Add((int)battle.WinPlayerID);
|
}
|
}
|
|
guessPlayer8List.Sort(CompareGuess8);
|
return;
|
}
|
|
int CompareGuess8(int idA, int idB)
|
{
|
bool isGuessA = guess4Personal.ContainsKey(idA);
|
bool isGusssB = guess4Personal.ContainsKey(idB);
|
|
if (isGuessA != isGusssB)
|
{
|
return isGusssB.CompareTo(isGuessA);
|
}
|
|
long fightPowerA = fightersInfo[(uint)idA].FightPower;
|
long fightPowerB = fightersInfo[(uint)idB].FightPower;
|
|
if (fightPowerA != fightPowerB)
|
{
|
return fightPowerB.CompareTo(fightPowerA);
|
}
|
|
return idA.CompareTo(idB);
|
}
|
|
public bool isShowRaceInfoYet = false; //是否已经显示过赛程信息小提示
|
uint pushGroupMark = 0; //每场比赛只推送一次
|
void OnMinuteEvent()
|
{
|
if (!WindowCenter.Instance.IsOpen("CrossServerQualifyingWin") &&
|
dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID) != DATA_MAPID)
|
{
|
uint nowMark = nowGroupMark;
|
//准备入场的时候推送
|
if (pushGroupMark != nowMark && HaveMyBattle(nowMark))
|
{
|
int battleID = GetBattleID();
|
if (ILChampionshipTimeConfig.Get(battleID).StateValue % 10 == 2)
|
{
|
HeroControler.Instance.FuncPush(210);
|
pushGroupMark = nowMark;
|
}
|
}
|
}
|
}
|
|
//官职
|
public void UpdateOfficialInfo(HC018_tagGCChampionshipOfficialInfo netPack)
|
{
|
officialZoneID = netPack.ZoneID;
|
var playerID = PlayerDatas.Instance.baseData.PlayerID;
|
for (int i = 0; i < netPack.OfficialList.Length; i++)
|
{
|
var officialInfo = netPack.OfficialList[i];
|
List<CrossChampionshipPKPlayer> applyList = new List<CrossChampionshipPKPlayer>();
|
|
for (int j = 0; j < officialInfo.ApplyPlayerList.Length; j++)
|
{
|
applyList.Add(new CrossChampionshipPKPlayer()
|
{
|
PlayerID = officialInfo.ApplyPlayerList[j].PlayerID,
|
Job = officialInfo.ApplyPlayerList[j].Job,
|
PlayerName = officialInfo.ApplyPlayerList[j].PlayerName,
|
FightPower = officialInfo.ApplyPlayerList[j].FightPowerEx * (long)Constants.ExpPointValue + officialInfo.ApplyPlayerList[j].FightPower,
|
RealmLV = officialInfo.ApplyPlayerList[j].RealmLV,
|
Face = officialInfo.ApplyPlayerList[j].Face,
|
FacePic = officialInfo.ApplyPlayerList[j].FacePic,
|
});
|
}
|
|
rankOfficialDict[(int)officialInfo.OfficialID] = new ChampionshipOfficial()
|
{
|
LastDismissJuniorTime = officialInfo.LastDismissJuniorTime,
|
WorshipCount = officialInfo.WorshipCount,
|
WorshipDouble = officialInfo.WorshipDouble,
|
|
OfficialPlayer = new CrossChampionshipPKPlayer()
|
{
|
PlayerID = officialInfo.OfficialPlayer.PlayerID,
|
Job = officialInfo.OfficialPlayer.Job,
|
PlayerName = officialInfo.OfficialPlayer.PlayerName,
|
FightPower = officialInfo.OfficialPlayer.FightPowerEx * (long)Constants.ExpPointValue + officialInfo.OfficialPlayer.FightPower,
|
RealmLV = officialInfo.OfficialPlayer.RealmLV,
|
Face = officialInfo.OfficialPlayer.Face,
|
FacePic = officialInfo.OfficialPlayer.FacePic,
|
},
|
|
ApplyPlayerList = applyList,
|
};
|
if (myOfficialID == (int)officialInfo.OfficialID && playerID != (int)officialInfo.OfficialPlayer.PlayerID)
|
{
|
//被辞退了
|
myOfficialID = 0;
|
officialRedpoint.state = RedPointState.Simple;
|
LocalSave.SetInt("myOfficialID", 0);
|
}
|
if (playerID == (int)officialInfo.OfficialPlayer.PlayerID)
|
{
|
myOfficialID = (int)officialInfo.OfficialID;
|
if (LocalSave.GetInt("myOfficialID") == 0 && ILChampionshipOfficialConfig.Get(myOfficialID).CanBeReplace == 0)
|
{
|
//申请通过
|
officialRedpoint.state = RedPointState.Simple;
|
}
|
LocalSave.SetInt("myOfficialID", myOfficialID);
|
}
|
}
|
RefreshMyApplyCnt();
|
RefreshRedPoint();
|
UpdateOffcialEvent?.Invoke();
|
}
|
|
//界主的申请列表红点
|
void RefreshRedPoint()
|
{
|
RefreshMobaiRedpoint();
|
if (myOfficialID > 0 && myOfficialID <= 8)
|
{
|
officialRedpoint.state = RedPointState.None;
|
//写死了前4个申请
|
for (int i = 0; i < 4; i++)
|
{
|
var id = myOfficialID * 100 + i + 1;
|
if (GetOfficialPlayer(id).PlayerID != 0)
|
{
|
return;
|
}
|
if (rankOfficialDict.ContainsKey(id) && rankOfficialDict[id].ApplyPlayerList.Count != 0)
|
{
|
officialRedpoint.state = RedPointState.Simple;
|
}
|
}
|
}
|
}
|
|
void RefreshMyApplyCnt()
|
{
|
if (myOfficialID != 0)
|
{
|
myApplyCnt = 0;
|
return;
|
}
|
var playerID = PlayerDatas.Instance.baseData.PlayerID;
|
var keys = rankOfficialDict.Keys.ToList();
|
myApplyCnt = 0;
|
for (int i = 0; i < keys.Count; i++)
|
{
|
var applyList = rankOfficialDict[keys[i]].ApplyPlayerList;
|
for (int j = 0; j < applyList.Count; j++)
|
{
|
if (playerID == applyList[j].PlayerID)
|
{
|
myApplyCnt++;
|
}
|
}
|
}
|
}
|
|
public CrossChampionshipPKPlayer GetOfficialPlayer(int officialID)
|
{
|
|
if (!rankOfficialDict.ContainsKey(officialID))
|
return new CrossChampionshipPKPlayer();
|
|
return rankOfficialDict[officialID].OfficialPlayer;
|
}
|
|
public int GeDefaultOffcialSub()
|
{
|
if (myOfficialID <= 8)
|
return 0;
|
if (offcialOperList[selectOffcialID][1].IndexOf(myOfficialID) != -1)
|
{
|
return 1;
|
}
|
return 0;
|
}
|
|
public bool IsInApply(int officialID)
|
{
|
var playerID = PlayerDatas.Instance.baseData.PlayerID;
|
if (!rankOfficialDict.ContainsKey(officialID))
|
{
|
return false;
|
}
|
var applyList = rankOfficialDict[officialID].ApplyPlayerList;
|
for (int i = 0; i < applyList.Count; i++)
|
{
|
if (applyList[i].PlayerID == playerID)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public void UpdateChampionshipOfficialChallengeRet(IL_HC020_tagGCChampionshipOfficialChallengeRet netPack)
|
{
|
string tip;
|
if (netPack.Ret == 0)
|
tip = "CrossServerQualifying59";
|
else if (netPack.Ret == 1)
|
tip = "CrossServerQualifying61";
|
else
|
tip = "CrossServerQualifying60";
|
|
ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get(tip));
|
}
|
|
public void UpdateChampionshipOfficialApplyReplyRet(IL_HC019_tagGCChampionshipOfficialApplyReplyRet netPack)
|
{
|
if (netPack.IsOK == 1)
|
{
|
SysNotifyMgr.Instance.ShowTip("CrossServerQualifying9");
|
}
|
else
|
{
|
SysNotifyMgr.Instance.ShowTip("CrossServerQualifying10");
|
}
|
}
|
|
public string challengeRecord;
|
public void UpdateChampionshipOfficialChallengeRecordInfo(IL_HC021_tagGCChampionshipOfficialChallengeRecordInfo netPack)
|
{
|
for (int i = 0; i < netPack.RecordList.Length; i++)
|
{
|
var record = netPack.RecordList[i];
|
if (record.Ret == 1)
|
{
|
challengeRecord += Language.Get("CrossServerQualifying62",
|
TimeUtility.GetTime(record.ChallengeTime).ToString("yyyy-MM-dd HH:mm:ss"), record.PlayerName);
|
}
|
else
|
{
|
challengeRecord += Language.Get("CrossServerQualifying63",
|
TimeUtility.GetTime(record.ChallengeTime).ToString("yyyy-MM-dd HH:mm:ss"), record.PlayerName);
|
}
|
}
|
WindowCenter.Instance.OpenIL<CrossServerQualifyingOfficialNoteWin>();
|
}
|
|
|
public void UpdateWorship(IL_HC109_tagMCChampionshipPlayerInfo netPack)
|
{
|
worshipCntToday = netPack.WorshipCount;
|
RefreshMobaiRedpoint();
|
UpdateWorshipEvent?.Invoke();
|
}
|
|
bool queryKai = false; //进入游戏后请求一次即可
|
uint lastGroupMark = 0; //从非0到0说明需要更新界主
|
public List<uint> playerIDList = new List<uint>();
|
|
//查询界主信息
|
public void QueryAllKaiKingInfo()
|
{
|
if (queryKai)
|
{
|
if (!(lastGroupMark != 0 && nowGroupMark == 0))
|
{
|
return;
|
}
|
}
|
|
playerIDList.Clear();
|
for (int i = 1; i <= 8; i++)
|
{
|
var playerID = GetOfficialPlayer(i).PlayerID;
|
if (playerID == 0)
|
break;
|
playerIDList.Add(playerID);
|
}
|
if (playerIDList.IsNullOrEmpty())
|
return;
|
|
SnxxzGame.Instance.StartCoroutine(PlayerQuery());
|
lastGroupMark = nowGroupMark;
|
queryKai = true;
|
}
|
|
private IEnumerator PlayerQuery()
|
{
|
for (int i = 0; i < playerIDList.Count; i++)
|
{
|
QueryKaiKingInfo(playerIDList[i]);
|
yield return null;
|
}
|
}
|
|
public void QueryKaiKingInfo(uint playerID)
|
{
|
ModelCenter.Instance.GetModel<RoleParticularModel>().ViewCrossPlayerCacheData((int)playerID);
|
}
|
|
void PlayerLoginOkEvent()
|
{
|
RefreshMobaiRedpoint();
|
loginRedpoint.state = RedPointState.Simple;
|
}
|
|
void RefreshMobaiRedpoint()
|
{
|
mobaiRedpoint.state = RedPointState.None;
|
if (rankOfficialDict.Count == 0)
|
return;
|
for (int i = 1; i <= 8; i++)
|
{
|
if (GetOfficialPlayer(1).PlayerID != 0)
|
{
|
//有膜拜对象且有次数
|
if (worshipCntToday < worshipMaxCnt)
|
{
|
mobaiRedpoint.state = RedPointState.Simple;
|
}
|
return;
|
}
|
}
|
|
}
|
}
|
