using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
|
using LitJson;
|
using UnityEngine;
|
|
namespace vnxbqy.UI
|
{
|
|
|
public class CrossServerOneVsOneModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk
|
{
|
public string PkResultLocalSaveKey { get; private set; }
|
public List<CrossServerOneVsOnePkResult> localSaveResults { get; private set; }
|
CrossServerOneVsOneRewardModel rewardModel { get { return ModelCenter.Instance.GetModel<CrossServerOneVsOneRewardModel>(); } }
|
public event Action UpdateDayAwardsEvent;
|
public const int CrossServerDataMapId = 32010;
|
public event Action UpdatePlayerAppearEventForWindow;
|
|
DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
|
|
StoreModel storeModel { get { return ModelCenter.Instance.GetModel<StoreModel>(); } }
|
public string LocalSaveThirdTypeKey = string.Empty;
|
private int recordDataMapId;
|
private int loadSecond;
|
|
// 跨服竞技场改成匹配3个对象，进行选择挑战
|
public List<HC001_tagGCCrossRealmPKMatchOK.tagGCCrossRealmPKMatchPlayer> matchPlayers = new List<HC001_tagGCCrossRealmPKMatchOK.tagGCCrossRealmPKMatchPlayer>();
|
public event Action UpdateMatchPlayersEvent;
|
public float queryMatchTime; //查询匹配时间, 间隔查询
|
|
public Dictionary<int, GA_PlayerClient.PlayerInfo> robots = new Dictionary<int, GA_PlayerClient.PlayerInfo>();
|
|
public bool isSkipFightChoose {
|
get {
|
return LocalSave.GetBool("kftt" + PlayerDatas.Instance.baseData.PlayerID);
|
}
|
set
|
{
|
LocalSave.SetBool("kftt" + PlayerDatas.Instance.baseData.PlayerID, value);
|
}
|
}
|
public override void Init()
|
{
|
ParseFuncConfig();
|
SetHonorRedpoint();
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
loadSecond = 0;
|
StageLoad.Instance.onStageLoadFinish -= OnLoadMapFinish;
|
storeModel.RefreshBuyShopLimitEvent -= UpdateBuyShop;
|
TimeUtility.OnServerOpenDayRefresh -= UpdateServerOpenDay;
|
PlayerDatas.Instance.playerDataRefreshEvent -= UpdatePlayerData;
|
CrossServerOneVsOnePlayerInfo.Instance.UpdatePlayerInfoEvent -= UpdatePlayerInfo;
|
CrossServerOneVsOnePKSeason.Instance.updateSelfSeasonEvent -= UpdateSeason;
|
TimeMgr.Instance.OnMinuteEvent -= UpdateMinute;
|
GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
|
rewardModel.CrossRealmPKAwardStateUpdate -= UpdateDayAwardState;
|
CrossServerOneVsOnePlayerInfo.Instance.UpdatePlayerInfoEvent -= UpdateDayAwardState;
|
TimeMgr.Instance.OnDayEvent -= OnDay;
|
InitData();
|
robots.Clear();
|
matchPlayers.Clear();
|
queryMatchTime = 0;
|
isSkipFightChoose = false;
|
}
|
|
public void OnAfterPlayerDataInitialize()
|
{
|
int playerId = (int)PlayerDatas.Instance.baseData.PlayerID;
|
PkResultLocalSaveKey = StringUtility.Contact("PkResultLocalSaveKey", playerId);
|
LocalSaveThirdTypeKey = StringUtility.Contact("HonorStoreThirdType", playerId);
|
GetLocalSaveData();
|
}
|
|
|
public void OnPlayerLoginOk()
|
{
|
StageLoad.Instance.onStageLoadFinish += OnLoadMapFinish;
|
storeModel.RefreshBuyShopLimitEvent += UpdateBuyShop;
|
TimeUtility.OnServerOpenDayRefresh += UpdateServerOpenDay;
|
PlayerDatas.Instance.playerDataRefreshEvent += UpdatePlayerData;
|
CrossServerOneVsOnePlayerInfo.Instance.UpdatePlayerInfoEvent += UpdatePlayerInfo;
|
CrossServerOneVsOnePKSeason.Instance.updateSelfSeasonEvent += UpdateSeason;
|
TimeMgr.Instance.OnMinuteEvent += UpdateMinute;
|
GlobalTimeEvent.Instance.secondEvent += UpdateSecond;
|
rewardModel.CrossRealmPKAwardStateUpdate += UpdateDayAwardState;
|
CrossServerOneVsOnePlayerInfo.Instance.UpdatePlayerInfoEvent += UpdateDayAwardState;
|
TimeMgr.Instance.OnDayEvent += OnDay;
|
UpdateServerOpenDay();
|
UpdateDayAwardState();
|
UpdateCrossDayAwardsRedpoint();
|
UpdateCrossMatchRedpoint();
|
UpdateCanBuyRedpoint();
|
}
|
|
public override void UnInit()
|
{
|
|
}
|
|
private void InitData()
|
{
|
CrossServerOneVsOnePKSeason.Instance.InitData();
|
CrossServerOneVsOnePlayerInfo.Instance.InitData();
|
pkResultInfo = new CrossServerOneVsOnePkResult();
|
oneVsOneHistoryDict.Clear();
|
}
|
|
void OnDay()
|
{
|
queryMatchTime = 0;
|
}
|
|
private void UpdateSecond()
|
{
|
loadSecond += 1;
|
if (loadSecond >= 5)
|
{
|
recordDataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
|
GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
|
loadSecond = 0;
|
DebugEx.Log("UpdateSecond....." + recordDataMapId);
|
}
|
}
|
|
private void OnLoadMapFinish()
|
{
|
var dataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
|
if ((recordDataMapId == CrossServerDataMapId || recordDataMapId == 1000)
|
&& dataMapId != CrossServerDataMapId)
|
{
|
var pkSeason = CrossServerOneVsOnePKSeason.Instance;
|
if (pkSeason.IsEnterCrossServer())
|
{
|
WindowCenter.Instance.Open<CrossServerWin>(false, 0);
|
}
|
}
|
recordDataMapId = dataMapId;
|
if (dataMapId == CrossServerDataMapId || dataMapId == CrossServerQualifyingModel.DATA_MAPID)
|
{
|
PersonalEnemy.OnMirrorPlayerAppear += OnPlayerAppear;
|
}
|
}
|
|
private void OnPlayerAppear(GA_Player player)
|
{
|
CrossServerLogin.Instance.UpdatePKPlayerInfo(player);
|
PersonalEnemy.OnMirrorPlayerAppear -= OnPlayerAppear;
|
dungeonModel.dungeonFightStage = DungeonFightStage.Normal;
|
UpdatePlayerAppearEventForWindow?.Invoke();
|
}
|
|
private void UpdateMinute()
|
{
|
UpdateCrossMatchRedpoint();
|
}
|
|
public void UpdateDayAwardState()
|
{
|
var playerInfo = CrossServerOneVsOnePlayerInfo.Instance;
|
for (int i = 0; i < dayAwardTypelist.Count; i++)
|
{
|
var dayAward = dayAwardTypelist[i];
|
int awardType = dayAward.type;
|
switch (awardType)
|
{
|
case 1:
|
dayAward.IsReceived = rewardModel.IsAwardState(CrossRealmPKAwardStateEnum.DayWinCountAwardState, dayAward.index);
|
dayAward.SetCompletedNum(playerInfo.DayWinCount);
|
break;
|
case 2:
|
dayAward.IsReceived = rewardModel.IsAwardState(CrossRealmPKAwardStateEnum.DayPKCountAwardState, dayAward.index);
|
dayAward.SetCompletedNum(playerInfo.DayPKCount);
|
break;
|
}
|
}
|
|
if (UpdateDayAwardsEvent != null)
|
{
|
UpdateDayAwardsEvent();
|
}
|
|
UpdateCrossDayAwardsRedpoint();
|
}
|
|
private void UpdateSeason()
|
{
|
UpdateCrossMatchRedpoint();
|
UpdateCanBuyRedpoint();
|
}
|
|
private void UpdateBuyShop()
|
{
|
var pkSeason = CrossServerOneVsOnePKSeason.Instance;
|
if (!pkSeason.IsEnterCrossServer()) return;
|
|
UpdateCanBuyRedpoint();
|
}
|
|
private void UpdatePlayerInfo()
|
{
|
UpdateCrossDayAwardsRedpoint();
|
UpdateCrossMatchRedpoint();
|
}
|
|
|
public List<AwardType> GetDayAwardsList()
|
{
|
dayAwardTypelist.Sort(CompareByCompleteProgress);
|
return dayAwardTypelist;
|
}
|
|
public int CompareByCompleteProgress(AwardType start, AwardType end)
|
{
|
int x = (int)start.progress;
|
int y = (int)end.progress;
|
if (x.CompareTo(y) != 0) return x.CompareTo(y);
|
|
x = start.type;
|
y = end.type;
|
if (x.CompareTo(y) != 0) return x.CompareTo(y);
|
|
x = start.num;
|
y = end.num;
|
if (x.CompareTo(y) != 0) return x.CompareTo(y);
|
|
return 0;
|
}
|
|
public bool IsNewDay { get; private set; }
|
private void UpdateServerOpenDay()
|
{
|
var pkSeason = CrossServerOneVsOnePKSeason.Instance;
|
if (!pkSeason.IsEnterCrossServer()) return;
|
|
IsNewDay = false;
|
int openDay = TimeUtility.OpenDay;
|
if (!PlayerPrefs.HasKey(LocalSaveThirdTypeKey))
|
{
|
IsNewDay = true;
|
LocalSave.SetInt(LocalSaveThirdTypeKey, openDay);
|
}
|
else
|
{
|
int localOpenDay = LocalSave.GetInt(LocalSaveThirdTypeKey);
|
if (openDay != localOpenDay)
|
{
|
IsNewDay = true;
|
LocalSave.SetInt(LocalSaveThirdTypeKey, openDay);
|
}
|
}
|
|
UpdateCanBuyRedpoint();
|
}
|
|
#region 表数据
|
//挑战
|
public int freeMaxMatchNum { get; private set; } //每日免费匹配次数(挑战)
|
public int buyMaxMatchNum { get; private set; } //每日可购买次数(挑战)
|
public string priceFormula { get; private set; } //购买匹配次数需要价格公式(挑战)
|
|
//刷新匹配
|
public int freeMaxMatchRefreshNum { get; private set; } //每日免费刷新匹配次数(刷新)
|
public int buyMaxMatchRefreshNum { get; private set; } //每日可购买刷新次数(刷新)
|
public string priceRefreshFormula { get; private set; } //购买刷新匹配次数需要价格公式(刷新)
|
public int refreshMoneyType { get; private set; } //刷新匹配次数消耗货币类型(刷新)
|
|
public int[] winConstScoreArr { get; private set; } //胜利固定积分
|
public string winStreakScoreFormula { get; private set; } //连胜积分公式
|
public List<AwardType> dayAwardTypelist { get; private set; }
|
public int afterOpenDayOpenCross { get; private set; }
|
|
|
private void ParseFuncConfig()
|
{
|
var CrossRealmPKAward = FuncConfigConfig.Get("CrossRealmPKAward");
|
var dayMatchAwardData = JsonMapper.ToObject(CrossRealmPKAward.Numerical1);
|
var dayWinAwardData = JsonMapper.ToObject(CrossRealmPKAward.Numerical2);
|
dayAwardTypelist = new List<AwardType>();
|
int dayWinIndex = 0;
|
foreach (var num in dayWinAwardData.Keys)
|
{
|
int times = int.Parse(num);
|
var items = dayWinAwardData[num];
|
var awardType = new AwardType(times, 1, dayWinIndex);
|
dayAwardTypelist.Add(awardType);
|
if (items.IsArray)
|
{
|
for (int i = 0; i < items.Count; i++)
|
{
|
var itemInfo = items[i];
|
if (itemInfo.IsArray && itemInfo.Count >= 3)
|
{
|
int id = 0;
|
int.TryParse(itemInfo[0].ToString(), out id);
|
int count = 0;
|
int.TryParse(itemInfo[1].ToString(), out count);
|
int isBind = 0;
|
int.TryParse(itemInfo[2].ToString(), out isBind);
|
AwardItem awardItem = new AwardItem(id, count, isBind);
|
awardType.SetAwardItems(awardItem);
|
}
|
}
|
}
|
|
dayWinIndex += 1;
|
}
|
|
int dayPkIndex = 0;
|
foreach (var num in dayMatchAwardData.Keys)
|
{
|
int times = int.Parse(num);
|
var items = dayMatchAwardData[num];
|
var awardType = new AwardType(times, 2, dayPkIndex);
|
dayAwardTypelist.Add(awardType);
|
if (items.IsArray)
|
{
|
for (int i = 0; i < items.Count; i++)
|
{
|
var itemInfo = items[i];
|
if (itemInfo.IsArray && itemInfo.Count >= 3)
|
{
|
int id = 0;
|
int.TryParse(itemInfo[0].ToString(), out id);
|
int count = 0;
|
int.TryParse(itemInfo[1].ToString(), out count);
|
int isBind = 0;
|
int.TryParse(itemInfo[2].ToString(), out isBind);
|
AwardItem awardItem = new AwardItem(id, count, isBind);
|
awardType.SetAwardItems(awardItem);
|
}
|
}
|
}
|
|
dayPkIndex += 1;
|
}
|
|
var CrossRealmPKMatchCount = FuncConfigConfig.Get("CrossRealmPKMatchCount");
|
freeMaxMatchNum = int.Parse(CrossRealmPKMatchCount.Numerical1);
|
buyMaxMatchNum = int.Parse(CrossRealmPKMatchCount.Numerical2);
|
priceFormula = CrossRealmPKMatchCount.Numerical3;
|
|
var CrossRealmPKRefreshCount = FuncConfigConfig.Get("CrossRealmPKMatchRefresh");
|
freeMaxMatchRefreshNum = int.Parse(CrossRealmPKRefreshCount.Numerical1);
|
buyMaxMatchRefreshNum = int.Parse(CrossRealmPKRefreshCount.Numerical2);
|
priceRefreshFormula = CrossRealmPKRefreshCount.Numerical3;
|
refreshMoneyType = int.Parse(CrossRealmPKRefreshCount.Numerical4);
|
|
var CrossRealmPKScore = FuncConfigConfig.Get("CrossRealmPKScore2");
|
winConstScoreArr = JsonMapper.ToObject<int[]>(CrossRealmPKScore.Numerical1);
|
winStreakScoreFormula = CrossRealmPKScore.Numerical3;
|
|
var CrossRealmCfg = FuncConfigConfig.Get("CrossRealmCfg");
|
afterOpenDayOpenCross = int.Parse(CrossRealmCfg.Numerical1);
|
GeneralDefine.crossServerOneVsOneOpenDay = afterOpenDayOpenCross;
|
}
|
|
public class AwardType
|
{
|
public int type { get; private set; } //1 胜利奖励 2 匹配奖励
|
public int index { get; private set; }
|
public int num { get; private set; }
|
public int curCompletedNum { get; private set; }
|
public CompleteProgress progress { get; private set; }
|
public bool IsReceived { get; set; }
|
public List<AwardItem> awardItems = new List<AwardItem>();
|
public AwardType(int _num, int _type, int _index)
|
{
|
type = _type;
|
num = _num;
|
index = _index;
|
curCompletedNum = 0;
|
IsReceived = false;
|
progress = CompleteProgress.Completed;
|
awardItems.Clear();
|
}
|
|
public void SetAwardItems(AwardItem awardItem)
|
{
|
awardItems.Add(awardItem);
|
}
|
|
public void SetCompletedNum(int completedNum)
|
{
|
curCompletedNum = completedNum;
|
if (IsReceived)
|
{
|
curCompletedNum = num;
|
progress = CompleteProgress.AlreadyReceived;
|
}
|
else
|
{
|
progress = curCompletedNum < num ? CompleteProgress.UnCompleted : CompleteProgress.Completed;
|
}
|
}
|
|
public enum CompleteProgress
|
{
|
Completed = 0, //已达成
|
UnCompleted = 1, //未达成
|
AlreadyReceived = 2, //已领取
|
}
|
}
|
|
public struct AwardItem
|
{
|
public int itemId;
|
public int itemCount;
|
public int isBind;
|
public AwardItem(int _id, int _count, int _isBind)
|
{
|
itemId = _id;
|
itemCount = _count;
|
isBind = _isBind;
|
}
|
}
|
#endregion
|
|
#region 协议
|
public CrossServerOneVsOnePkResult pkResultInfo { get; private set; }
|
public event Action UpdatePkResultEvent;
|
public void UpdatePKResultInfo(HC003_tagGCCrossRealmPKOverInfo pKOverInfo)
|
{
|
pkResultInfo = new CrossServerOneVsOnePkResult();
|
pkResultInfo.UpdatePkResult(pKOverInfo);
|
SetPkInfoLocalSave(pkResultInfo);
|
if (UpdatePkResultEvent != null)
|
{
|
UpdatePkResultEvent();
|
}
|
}
|
|
public void UpdateOneVSOneMatch(HC001_tagGCCrossRealmPKMatchOK package)
|
{
|
matchPlayers.Clear();
|
for (int i = 0; i < package.MatchPlayerCount; i++)
|
{
|
int playerID = (int)package.MatchPlayer[i].PlayerID;
|
if (playerID > 10000)
|
{
|
string serverName = ServerListCenter.Instance.GetServerName((int)package.MatchPlayer[i].ServerID);
|
package.MatchPlayer[i].PlayerName = StringUtility.Contact(Language.Get("Z2002", serverName), package.MatchPlayer[i].PlayerName);
|
matchPlayers.Add(package.MatchPlayer[i]);
|
//服务端没有主动推送的话，这里需要请求一次玩家缓存数据
|
//ModelCenter.Instance.GetModel<RoleParticularModel>().ViewPlayerCacheData(playerID);
|
}
|
else
|
{
|
int job = (byte)UnityEngine.Random.Range(1, 3);
|
string name = ClientCrossServerOneVsOne.GetRandomOpponentName(job);
|
int level = 1;
|
int fightPower = 0;
|
int fightPowerEx = 0; //战力，整除亿部分
|
ulong tmpFightPower = 0;
|
if (playerID == 1)
|
{
|
level = Math.Min((int)(PlayerDatas.Instance.baseData.LV * 1.2), 999);
|
tmpFightPower = PlayerDatas.Instance.baseData.FightPoint*2;
|
}
|
else if (playerID == 2)
|
{
|
level = Math.Max((int)(PlayerDatas.Instance.baseData.LV * 0.8), 160);
|
tmpFightPower = (ulong)(PlayerDatas.Instance.baseData.FightPoint * 0.8);
|
}
|
else if (playerID == 3)
|
{
|
level = Math.Max((int)(PlayerDatas.Instance.baseData.LV * 0.6), 160);
|
tmpFightPower = (ulong)(PlayerDatas.Instance.baseData.FightPoint * 0.5);
|
}
|
fightPower = (int)(tmpFightPower % 100000000);
|
fightPowerEx = (int)(tmpFightPower / 100000000);
|
|
string serverName = ServerListCenter.Instance.GetServerName(ServerListCenter.Instance.currentServer.region_flag);
|
//机器人
|
matchPlayers.Add(new HC001_tagGCCrossRealmPKMatchOK.tagGCCrossRealmPKMatchPlayer()
|
{
|
PlayerID = (uint)playerID,
|
PlayerName = StringUtility.Contact(Language.Get("Z2002", serverName), name),
|
Job = (byte)job,
|
LV = (ushort)level,
|
RealmLV = PlayerDatas.Instance.baseData.realmLevel,
|
Face = (uint)AvatarHelper.GetAvatarDefaultID(job),
|
FacePic = (uint)AvatarHelper.GetAvatarFrameDefaultID(job),
|
FightPower = (uint)fightPower,
|
FightPowerEx = (uint)fightPowerEx,
|
ServerID = (uint)ServerListCenter.Instance.currentServer.region_flag
|
});
|
|
CreateRobot(matchPlayers[i]);
|
}
|
|
|
}
|
|
UpdateMatchPlayersEvent?.Invoke();
|
}
|
|
void CreateRobot(HC001_tagGCCrossRealmPKMatchOK.tagGCCrossRealmPKMatchPlayer player)
|
{
|
var job = player.Job;
|
var playerName = player.PlayerName;
|
var level = player.LV;
|
var scoreClass = CrossServerOneVsOnePlayerInfo.Instance.DanLV;
|
robots[(int)player.PlayerID] = ClientCrossServerOneVsOne.GetRandomOpponentPlayerInfo(scoreClass, job, playerName, level, 1);
|
}
|
|
BuffModel buffDatas { get { return ModelCenter.Instance.GetModel<BuffModel>(); } }
|
/// <summary>
|
/// 0-查询匹配；1-刷新匹配
|
/// </summary>
|
/// <param name="type"></param>
|
public void SendCrossMatch(int type)
|
{
|
if (type == 0)
|
{
|
if (queryMatchTime != 0 && Time.time - queryMatchTime < 240)
|
return;
|
queryMatchTime = Time.time;
|
}
|
|
var match = new CC101_tagCMCrossRealmPKMatch();
|
match.Type = (byte)type;
|
GameNetSystem.Instance.SendInfo(match);
|
CrossServerOneVsOneRewardModel.PkType = buffDatas.PkType;
|
}
|
|
public void SendBuyMatchCount()
|
{
|
var pKBuy = new CC102_tagCMCrossRealmPKBuy();
|
GameNetSystem.Instance.SendInfo(pKBuy);
|
}
|
|
//public bool TryGetMatchTip()
|
//{
|
// int mapId = PlayerDatas.Instance.baseData.MapID;
|
// bool isCrossDungeon = CrossServerUtility.IsCrossServer();
|
// if (isCrossDungeon)
|
// {
|
// SysNotifyMgr.Instance.ShowTip("CrossMatching3");
|
// return true;
|
// }
|
|
// var mapConfig = MapConfig.Get(mapId);
|
// bool isDungeon = mapConfig != null && mapConfig.MapFBType != 0 ? true : false;
|
// if (isDungeon)
|
// {
|
// SysNotifyMgr.Instance.ShowTip("CrossMatching4");
|
// return true;
|
// }
|
|
// var deadModel = ModelCenter.Instance.GetModel<PlayerDeadModel>();
|
// if (deadModel.playerIsDie)
|
// {
|
// SysNotifyMgr.Instance.ShowTip("CrossMatching5");
|
// return true;
|
// }
|
|
// var teamModel = ModelCenter.Instance.GetModel<TeamModel>();
|
// bool isTeamMatch = teamModel.isMatching;
|
// if (isTeamMatch)
|
// {
|
// SysNotifyMgr.Instance.ShowTip("CrossMatching6");
|
// return true;
|
// }
|
|
// bool isDungeonPrepare = teamModel.teamPrepare.isPreparing;
|
// if (isDungeonPrepare)
|
// {
|
// SysNotifyMgr.Instance.ShowTip("CrossMatching7");
|
// return true;
|
// }
|
|
// int remainMatchNum = CrossServerOneVsOnePlayerInfo.Instance.GetDayRemainNum();
|
// if (remainMatchNum <= 0)
|
// {
|
// SysNotifyMgr.Instance.ShowTip("CrossMatching16");
|
// return true;
|
// }
|
|
// return false;
|
|
//}
|
|
public bool TryGetBuyMatchTimes(string key)
|
{
|
if (!CrossServerOneVsOnePKSeason.Instance.isSatisfyMatch)
|
{
|
SysNotifyMgr.Instance.ShowTip(key);
|
return false;
|
}
|
|
int remainNum = CrossServerOneVsOnePlayerInfo.Instance.GetDayRemainNum();
|
if (remainNum >= freeMaxMatchNum)
|
{
|
SysNotifyMgr.Instance.ShowTip("CrossMatching13");
|
return false;
|
}
|
return true;
|
}
|
|
#endregion
|
|
#region 历史记录
|
Dictionary<int, CrossServerOneVsOneHistory> oneVsOneHistoryDict = new Dictionary<int, CrossServerOneVsOneHistory>();
|
public event Action oneVsOneHistoryRefresh;
|
public void OnReceivePackage(HC103_tagMCCrossRealmPKPlayerHisSeasonInfo package)
|
{
|
oneVsOneHistoryDict.Clear();
|
for (int i = 0; i < package.Count; i++)
|
{
|
var data = package.SeasonList[i];
|
oneVsOneHistoryDict[data.SeasonID] = new CrossServerOneVsOneHistory()
|
{
|
season = data.SeasonID,
|
division = data.DanLV,
|
order = data.Order,
|
rewardLevel = data.AwardLV,
|
score = (int)data.Score
|
};
|
}
|
if (oneVsOneHistoryRefresh != null)
|
{
|
oneVsOneHistoryRefresh();
|
}
|
}
|
|
public bool TryGetOneVsOneHistory(int session, out CrossServerOneVsOneHistory history)
|
{
|
return oneVsOneHistoryDict.TryGetValue(session, out history);
|
}
|
|
public struct CrossServerOneVsOneHistory
|
{
|
public int season;
|
public int order;
|
public int division;
|
public int rewardLevel;
|
public int score;
|
}
|
#endregion
|
|
#region 匹配记录
|
|
private void GetLocalSaveData()
|
{
|
localSaveResults = new List<CrossServerOneVsOnePkResult>();
|
string[] localJsons = LocalSave.GeStringArray(PkResultLocalSaveKey);
|
if (localJsons != null)
|
{
|
for (int i = 0; i < localJsons.Length; i++)
|
{
|
CrossServerOneVsOnePkResult resultInfo = JsonMapper.ToObject<CrossServerOneVsOnePkResult>(localJsons[i]);
|
localSaveResults.Add(resultInfo);
|
}
|
}
|
}
|
|
public void SetPkInfoLocalSave(CrossServerOneVsOnePkResult resultInfo)
|
{
|
if (localSaveResults.Count >= 30)
|
{
|
localSaveResults.RemoveAt(localSaveResults.Count - 1);
|
}
|
localSaveResults.Insert(0, resultInfo);
|
string[] localJsons = new string[localSaveResults.Count];
|
for (int i = 0; i < localJsons.Length; i++)
|
{
|
string json = JsonMapper.ToJson(localSaveResults[i]);
|
localJsons[i] = json;
|
}
|
LocalSave.SetStringArray(PkResultLocalSaveKey, localJsons);
|
}
|
|
#endregion
|
|
#region 红点
|
|
public const int CrossOneVsOneRedKey = 21301;
|
public Redpoint crossOneVsOneRedpoint = new Redpoint(CrossServerUtility.CrossServerRedKey, CrossOneVsOneRedKey);
|
public const int CrossArenaRedKey = 2130101;
|
public Redpoint crossArenaRedpoint = new Redpoint(CrossOneVsOneRedKey, CrossArenaRedKey);
|
public const int CrossDayAwardsRedKey = 21301011;
|
public Redpoint crossDayAwardsRedpoint = new Redpoint(CrossArenaRedKey, CrossDayAwardsRedKey);
|
public const int CrossMatchRedKey = 21301012;
|
public Redpoint crossMatchRedpoint = new Redpoint(CrossArenaRedKey, CrossMatchRedKey);
|
|
public void UpdateCrossDayAwardsRedpoint()
|
{
|
bool isReceive = false;
|
for (int i = 0; i < dayAwardTypelist.Count; i++)
|
{
|
var awardType = dayAwardTypelist[i];
|
if (awardType.progress == AwardType.CompleteProgress.Completed)
|
{
|
isReceive = true;
|
break;
|
}
|
}
|
|
if (isReceive)
|
{
|
crossDayAwardsRedpoint.state = RedPointState.Simple;
|
}
|
else
|
{
|
crossDayAwardsRedpoint.state = RedPointState.None;
|
}
|
|
CrossServerUtility.UpdateCrossServerRedpoint();
|
}
|
|
public void UpdateCrossMatchRedpoint()
|
{
|
var playerInfo = CrossServerOneVsOnePlayerInfo.Instance;
|
var pkSeason = CrossServerOneVsOnePKSeason.Instance;
|
|
if (pkSeason.isSatisfyMatch && playerInfo.GetDayRemainNum() > 0)
|
{
|
crossMatchRedpoint.state = RedPointState.Simple;
|
}
|
else
|
{
|
crossMatchRedpoint.state = RedPointState.None;
|
}
|
|
if (crossMatchRedpoint.state != RedPointState.None)
|
{
|
CrossServerUtility.UpdateCrossServerRedpoint();
|
}
|
}
|
|
|
#region 荣誉商店红点
|
|
public const int CrossHonorStoreRedKey = 2130104;
|
public Redpoint crossHonorStoreRedpoint = new Redpoint(CrossOneVsOneRedKey, CrossHonorStoreRedKey);
|
private Dictionary<int, Redpoint> honorRedpointDict = new Dictionary<int, Redpoint>();
|
public void SetHonorRedpoint()
|
{
|
honorRedpointDict.Clear();
|
List<StoreConfig> storelist = StoreConfig.GetValues();
|
for (int i = 0; i < storelist.Count; i++)
|
{
|
StoreConfig storeConfig = storelist[i];
|
int redKey = 0;
|
Redpoint redpoint = null;
|
if (storeConfig.ShopType == (int)StoreFunc.CrossOneVsOneHonor)
|
{
|
redKey = CrossHonorStoreRedKey * 100 + storeConfig.ID;
|
redpoint = new Redpoint(CrossHonorStoreRedKey, redKey);
|
honorRedpointDict.Add(storeConfig.ID, redpoint);
|
}
|
}
|
}
|
|
public Redpoint GetRedpointById(int shopId)
|
{
|
Redpoint redpoint = null;
|
honorRedpointDict.TryGetValue(shopId, out redpoint);
|
return redpoint;
|
}
|
|
private void UpdatePlayerData(PlayerDataType type)
|
{
|
switch (type)
|
{
|
case PlayerDataType.CDBPlayerRefresh_Honor:
|
UpdateCanBuyRedpoint();
|
break;
|
}
|
|
}
|
|
public void UpdateCanBuyRedpoint()
|
{
|
var pkSeason = CrossServerOneVsOnePKSeason.Instance;
|
if (!pkSeason.IsEnterCrossServer()) return;
|
|
List<StoreModel.StoreData> storeDatas = storeModel.TryGetStoreDatas(StoreFunc.CrossOneVsOneHonor);
|
if (storeDatas != null)
|
{
|
for (int i = 0; i < storeDatas.Count; i++)
|
{
|
var storeData = storeDatas[i];
|
var storeConfig = storeData.storeConfig;
|
int type = 0;
|
TryGetRedTypeByShopId(storeConfig.ID, out type);
|
if (type == 6)
|
{
|
string key = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", storeData.shopId);
|
int remainNum = 0;
|
honorRedpointDict[storeConfig.ID].state = RedPointState.None;
|
if (!storeModel.TryGetIsSellOut(storeConfig, out remainNum))
|
{
|
if (!PlayerPrefs.HasKey(key) || IsNewDay)
|
{
|
if (UIHelper.GetMoneyCnt(storeConfig.MoneyType) >= (ulong)storeConfig.MoneyNumber)
|
{
|
honorRedpointDict[storeConfig.ID].state = RedPointState.Simple;
|
LocalSave.SetBool(key, true);
|
}
|
}
|
else
|
{
|
if (LocalSave.GetBool(key))
|
{
|
if (UIHelper.GetMoneyCnt(storeConfig.MoneyType) >= (ulong)storeConfig.MoneyNumber)
|
{
|
honorRedpointDict[storeConfig.ID].state = RedPointState.Simple;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
CrossServerUtility.UpdateCrossServerRedpoint();
|
}
|
|
public bool TryGetRedTypeByShopId(int shopId, out int type)
|
{
|
type = 0;
|
var ruleDict = storeModel.storeRedRuleDict;
|
foreach (var key in ruleDict.Keys)
|
{
|
List<int> idlist = ruleDict[key];
|
if (idlist.Contains(shopId))
|
{
|
type = key;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public void ClearRedpoint(int shopId)
|
{
|
IsNewDay = false;
|
string record = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", shopId);
|
if (honorRedpointDict[shopId].state != RedPointState.None)
|
{
|
honorRedpointDict[shopId].state = RedPointState.None;
|
LocalSave.SetBool(record, false);
|
}
|
}
|
#endregion
|
|
#endregion
|
}
|
}
|
