using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
|
namespace vnxbqy.UI
|
{
|
|
public class OSRedEnvelopeModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk, IOpenServerActivity
|
{
|
AchievementModel m_AchievementModel;
|
AchievementModel achieveModel
|
{
|
get
|
{
|
return m_AchievementModel ?? (m_AchievementModel = ModelCenter.Instance.GetModel<AchievementModel>());
|
}
|
}
|
|
RedEnvelopeModel m_RedEnvelopeModel;
|
RedEnvelopeModel envelopeModel
|
{
|
get
|
{
|
return m_RedEnvelopeModel ?? (m_RedEnvelopeModel = ModelCenter.Instance.GetModel<RedEnvelopeModel>());
|
}
|
}
|
|
bool servereInited = false;
|
|
public override void Init()
|
{
|
ParseConfig();
|
achieveModel.achievementCompletedEvent += AchievementCompletedEvent;
|
achieveModel.achievementProgressUpdateEvent += AchievementProgressUpdateEvent;
|
FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
|
TimeUtility.OnServerOpenDayRefresh += OnServerOpenDayRefresh;
|
envelopeModel.EnvelopeUpdateEvent += EnvelopeUpdateEvent;
|
envelopeModel.EnvelopeDelEvent += EnvelopeUpdateEvent;
|
envelopeModel.EnvelopeGetEvent += EnvelopeGetEvent;
|
OpenServerActivityCenter.Instance.Register(2, this);
|
}
|
|
public override void UnInit()
|
{
|
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
servereInited = false;
|
}
|
|
private void OnFuncStateChangeEvent(int func)
|
{
|
if (m_AllFuncs.Contains(func))
|
{
|
UpdateAchieveRedpoint();
|
}
|
if (func == (int)FuncOpenEnum.OpenServerRedEnvelope)
|
{
|
UpdateRedpackRedpoint();
|
UpdateAchieveRedpoint();
|
if (OSRedEnvelopeUpdateEvent != null)
|
{
|
OSRedEnvelopeUpdateEvent();
|
}
|
if (onStateUpdate != null)
|
{
|
onStateUpdate(2);
|
}
|
}
|
}
|
|
private void OnServerOpenDayRefresh()
|
{
|
UpdateAchieveRedpoint();
|
UpdateRedpackRedpoint();
|
}
|
|
public event Action FuncChangeEvent;
|
private int m_SelectType = 1;
|
public int selectType
|
{
|
get { return m_SelectType; }
|
set
|
{
|
m_SelectType = value;
|
ModelCenter.Instance.GetModel<RedPacketModel>().RedBagId = 0;
|
if (FuncChangeEvent != null)
|
{
|
FuncChangeEvent();
|
}
|
}
|
}
|
|
public int JumpType { get; set; }
|
public bool autoOpen { get; set; }
|
|
#region 配置
|
public List<int> m_OSRedAchieves { get; private set; }
|
public Dictionary<int, OSRedAchieve> m_OSRedAchieveDict { get; private set; }
|
private List<int> m_AllAchieves = new List<int>();
|
public List<int> m_AllFuncs { get; private set; }
|
public int openDays { get; private set; }
|
public int OSRedEnvelopeType { get; private set; }
|
public float envelopeVoiceCD { get; private set; }
|
public int addCounts { get; private set; }
|
public DateTime overTime = DateTime.Now;
|
void ParseConfig()
|
{
|
var _allCfgs = OSRedAchieveConfig.GetValues();
|
m_OSRedAchieveDict = new Dictionary<int, OSRedAchieve>();
|
m_OSRedAchieves = new List<int>();
|
m_AllFuncs = new List<int>();
|
for (int i = 0; i < _allCfgs.Count; i++)
|
{
|
for (int k = 0; k < _allCfgs[i].Achieves.Length; k++)
|
{
|
m_AllAchieves.Add(_allCfgs[i].Achieves[k]);
|
}
|
m_OSRedAchieveDict.Add(_allCfgs[i].id, new OSRedAchieve()
|
{
|
id = _allCfgs[i].id,
|
achieves = _allCfgs[i].Achieves
|
});
|
m_OSRedAchieves.Add(_allCfgs[i].id);
|
if (!m_AllFuncs.Contains(_allCfgs[i].func))
|
{
|
m_AllFuncs.Add(_allCfgs[i].func);
|
}
|
}
|
|
var _cfg = FuncConfigConfig.Get("OpenServerRedPacketCfg");
|
openDays = int.Parse(_cfg.Numerical1);
|
addCounts = int.Parse(_cfg.Numerical5);
|
_cfg = FuncConfigConfig.Get("OpenServerRedPacketType");
|
OSRedEnvelopeType = int.Parse(_cfg.Numerical1);
|
_cfg = FuncConfigConfig.Get("RedEnvelopeVoiceCd");
|
envelopeVoiceCD = float.Parse(_cfg.Numerical1) / 1000;
|
}
|
|
public class OSRedAchieve
|
{
|
public int id;
|
|
public int[] achieves;
|
|
AchievementModel achieveModel
|
{
|
get
|
{
|
return ModelCenter.Instance.GetModel<AchievementModel>();
|
}
|
}
|
|
public int CurrentAchieve
|
{
|
get
|
{
|
for (int i = 0; i < achieves.Length; i++)
|
{
|
Achievement achievement;
|
if (achieveModel.TryGetAchievement(achieves[i], out achievement))
|
{
|
if (!achievement.completed)
|
{
|
return achieves[i];
|
}
|
}
|
}
|
return achieves[achieves.Length - 1];
|
}
|
}
|
|
public bool Contains(int _achieve)
|
{
|
for (int i = 0; i < achieves.Length; i++)
|
{
|
if (achieves[i] == _achieve)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
}
|
#endregion
|
|
#region 红点
|
private Redpoint m_OpenServerRedPackRedpoint = new Redpoint(MainRedDot.REDPOINT_OPENSERVER, 20902);
|
public Redpoint m_RedAchieveRedpoint = new Redpoint(20902, 2090201);
|
public Redpoint m_OpenServerGetRedpin = new Redpoint(20902, 2090202);
|
public void UpdateAchieveRedpoint()
|
{
|
m_RedAchieveRedpoint.state = RedPointState.None;
|
if (TimeUtility.OpenDay >= openDays)
|
{
|
return;
|
}
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.OpenServerRedEnvelope))
|
{
|
return;
|
}
|
foreach (var _achieve in m_OSRedAchieveDict.Values)
|
{
|
var _cfg = OSRedAchieveConfig.Get(_achieve.id);
|
if (_cfg.func != 0 && FuncOpen.Instance.IsFuncOpen(_cfg.func))
|
{
|
continue;
|
}
|
var _id = _achieve.CurrentAchieve;
|
Achievement achievement;
|
if (achieveModel.TryGetAchievement(_id, out achievement))
|
{
|
if (Achievement.IsReach(_id, achievement.progress) && !achievement.completed)
|
{
|
m_RedAchieveRedpoint.state = RedPointState.Simple;
|
break;
|
}
|
}
|
}
|
}
|
|
public void UpdateRedpackRedpoint(bool _checkVoice = false)
|
{
|
bool hasRed = m_OpenServerGetRedpin.state == RedPointState.GetReward;
|
m_OpenServerGetRedpin.state = RedPointState.None;
|
if (CanGetEnvelope())
|
{
|
m_OpenServerGetRedpin.state = RedPointState.GetReward;
|
if (_checkVoice && !hasRed && servereInited && HasOtherRedpack() && !HasSelfRedpack())
|
{
|
CheckRedEnvelopeVoice();
|
}
|
}
|
}
|
|
DateTime beforePlayTime = DateTime.Now;
|
private void CheckRedEnvelopeVoice()
|
{
|
if ((DateTime.Now - beforePlayTime).TotalSeconds < envelopeVoiceCD)
|
{
|
return;
|
}
|
SoundPlayer.Instance.PlayUIAudio(632);
|
beforePlayTime = DateTime.Now;
|
}
|
#endregion
|
|
public void OnPlayerLoginOk()
|
{
|
UpdateAchieveRedpoint();
|
if (TimeUtility.OpenDay < openDays)
|
{
|
overTime = TimeUtility.ServerNow.AddDays(openDays - TimeUtility.OpenDay);
|
DateTime.TryParse(overTime.ToString("yyyy-MM-dd"), out overTime);
|
}
|
EnvelopeUpdateEvent();
|
servereInited = true;
|
}
|
|
public event Action<int> OSRedAchieveUpdateEvent;
|
private void AchievementCompletedEvent(int _achieve)
|
{
|
if (!m_AllAchieves.Contains(_achieve))
|
{
|
return;
|
}
|
OSRedAchieve _redAchieve;
|
m_OSRedAchieves.Sort(CompareAchievement);
|
if (TryGetOSRedAchieve(_achieve, out _redAchieve))
|
{
|
if (OSRedAchieveUpdateEvent != null)
|
{
|
OSRedAchieveUpdateEvent(_redAchieve.id);
|
}
|
}
|
UpdateAchieveRedpoint();
|
}
|
|
public bool TryGetOSRedAchieve(int _achieve, out OSRedAchieve _osRedAchieve)
|
{
|
_osRedAchieve = null;
|
foreach (var _redAchieve in m_OSRedAchieveDict.Values)
|
{
|
if (_redAchieve.CurrentAchieve == _achieve)
|
{
|
_osRedAchieve = _redAchieve;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private void AchievementProgressUpdateEvent(int _achieve)
|
{
|
if (!m_AllAchieves.Contains(_achieve))
|
{
|
return;
|
}
|
OSRedAchieve _redAchieve;
|
if (TryGetOSRedAchieve(_achieve, out _redAchieve))
|
{
|
if (OSRedAchieveUpdateEvent != null)
|
{
|
OSRedAchieveUpdateEvent(_redAchieve.id);
|
}
|
}
|
UpdateAchieveRedpoint();
|
}
|
|
public List<int> m_OSRedEnvelopes = new List<int>();
|
public event Action OSRedEnvelopeUpdateEvent;
|
private void EnvelopeUpdateEvent()
|
{
|
envelopeModel.GetEnvelopes(OSRedEnvelopeType, ref m_OSRedEnvelopes);
|
m_OSRedEnvelopes.Sort(CompareEnvelope);
|
if (OSRedEnvelopeUpdateEvent != null)
|
{
|
OSRedEnvelopeUpdateEvent();
|
}
|
UpdateRedpackRedpoint(true);
|
}
|
|
private void EnvelopeGetEvent(int _id)
|
{
|
RedEnvelopeModel.RedEnvelope _envelope;
|
if (envelopeModel.TryGetEnvelope(_id, out _envelope))
|
{
|
if (_envelope.player == PlayerDatas.Instance.PlayerId &&
|
_envelope.type == OSRedEnvelopeType
|
&& _envelope.state == 1)
|
{
|
envelopeModel.cacheEnvelopeId = _envelope.id;
|
envelopeModel.envelopeSfx = _envelope.id;
|
CAB12_tagCMGrabFamilyRedPacket _pak = new CAB12_tagCMGrabFamilyRedPacket();
|
_pak.RedPaketID = (uint)_envelope.id;
|
_pak.GetWay = 5;
|
GameNetSystem.Instance.SendInfo(_pak);
|
}
|
}
|
}
|
|
public bool CanGetEnvelope()
|
{
|
if (TimeUtility.OpenDay >= openDays)
|
{
|
return false;
|
}
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.OpenServerRedEnvelope))
|
{
|
return false;
|
}
|
if (HasSelfRedpack())
|
{
|
return true;
|
}
|
if (getEnvelopeTimes <= 0)
|
{
|
return false;
|
}
|
for (int i = 0; i < m_OSRedEnvelopes.Count; i++)
|
{
|
RedEnvelopeModel.RedEnvelope _envelope;
|
if (envelopeModel.TryGetEnvelope(m_OSRedEnvelopes[i], out _envelope))
|
{
|
if (_envelope.state == 1)
|
{
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
public bool HasSelfRedpack()
|
{
|
for (int i = 0; i < m_OSRedEnvelopes.Count; i++)
|
{
|
RedEnvelopeModel.RedEnvelope _envelope;
|
if (envelopeModel.TryGetEnvelope(m_OSRedEnvelopes[i], out _envelope))
|
{
|
if (_envelope.state == 1 && _envelope.player == PlayerDatas.Instance.PlayerId)
|
{
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
public bool HasOtherRedpack()
|
{
|
for (int i = 0; i < m_OSRedEnvelopes.Count; i++)
|
{
|
RedEnvelopeModel.RedEnvelope _envelope;
|
if (envelopeModel.TryGetEnvelope(m_OSRedEnvelopes[i], out _envelope))
|
{
|
if (_envelope.state == 1 && _envelope.player != PlayerDatas.Instance.PlayerId)
|
{
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
public int totalJadeGet { get; private set; }
|
public int getEnvelopeTimes { get; private set; }
|
|
public bool IsOpen
|
{
|
get
|
{
|
return TimeUtility.OpenDay < openDays && FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.OpenServerRedEnvelope);
|
}
|
}
|
|
public bool priorityOpen
|
{
|
get
|
{
|
return m_RedAchieveRedpoint.state == RedPointState.Simple
|
|| m_OpenServerGetRedpin.state == RedPointState.GetReward;
|
}
|
}
|
|
public bool IsAdvance
|
{
|
get
|
{
|
return false;
|
}
|
}
|
|
public event Action OSRedEnvelopeInfoEnvent;
|
public event Action<int> onStateUpdate;
|
|
public void UpdateOSRedEnvelope(HAB24_tagMCOpenServerRedPacketInfo _pak)
|
{
|
totalJadeGet = (int)_pak.MoneyNum;
|
getEnvelopeTimes = _pak.GrabCnt;
|
if (OSRedEnvelopeInfoEnvent != null)
|
{
|
OSRedEnvelopeInfoEnvent();
|
}
|
UpdateRedpackRedpoint();
|
}
|
|
public int cacheAchievement = 0;
|
public void RequestSendAchieveEnvelope(int _id)
|
{
|
if (!WindowCenter.Instance.IsOpen<OSRedEnvelopeSendWin>())
|
{
|
OSRedEnvelopeSendWin.achievementId = _id;
|
WindowCenter.Instance.Open<OSRedEnvelopeSendWin>();
|
}
|
}
|
|
public int CompareAchievement(int x, int y)
|
{
|
OSRedAchieve xRedAchieve;
|
OSRedAchieve yRedAchieve;
|
if (m_OSRedAchieveDict.TryGetValue(x, out xRedAchieve)
|
&& m_OSRedAchieveDict.TryGetValue(y, out yRedAchieve))
|
{
|
Achievement xAchievement;
|
Achievement yAchievement;
|
if (achieveModel.TryGetAchievement(xRedAchieve.CurrentAchieve, out xAchievement)
|
&& achieveModel.TryGetAchievement(yRedAchieve.CurrentAchieve, out yAchievement))
|
{
|
if (xAchievement.completed.CompareTo(yAchievement.completed) != 0)
|
{
|
return xAchievement.completed.CompareTo(yAchievement.completed);
|
}
|
bool xReach = Achievement.IsReach(xAchievement.id, xAchievement.progress);
|
bool yReach = Achievement.IsReach(yAchievement.id, yAchievement.progress);
|
if (xReach.CompareTo(yReach) != 0)
|
{
|
return -xReach.CompareTo(yReach);
|
}
|
}
|
}
|
return x.CompareTo(y);
|
}
|
|
public int CompareEnvelope(int x, int y)
|
{
|
RedEnvelopeModel.RedEnvelope xEnvelope;
|
RedEnvelopeModel.RedEnvelope yEnvelope;
|
if (envelopeModel.TryGetEnvelope(x, out xEnvelope)
|
&& envelopeModel.TryGetEnvelope(y, out yEnvelope))
|
{
|
if (xEnvelope.state.CompareTo(yEnvelope.state) != 0)
|
{
|
return xEnvelope.state.CompareTo(yEnvelope.state);
|
}
|
return -xEnvelope.time.CompareTo(yEnvelope.time);
|
}
|
return -x.CompareTo(y);
|
}
|
}
|
}
|
|
