using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
namespace vnxbqy.UI
|
{
|
|
|
public class FestivalRedpackModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk, IOpenServerActivity
|
{
|
Dictionary<int, FestivalRedpack> festivalRedpacks = new Dictionary<int, FestivalRedpack>();
|
Dictionary<int, List<FestivalRedpackAchievement>> achievements = new Dictionary<int, List<FestivalRedpackAchievement>>();
|
List<int> taskRedpacks = new List<int>();
|
|
bool serverInited = false;
|
|
public List<int> systemDisplayRedpacks = new List<int>();
|
public List<FestivalRedpackAchievement> displayAchievements = new List<FestivalRedpackAchievement>();
|
public List<int> taskDisplayRedpacks = new List<int>();
|
public int systemOverdueCount { get; set; }
|
|
int m_SelectType;
|
public int selectType
|
{
|
get { return m_SelectType; }
|
set
|
{
|
if (m_SelectType != value)
|
{
|
m_SelectType = value;
|
if (selectTypeRefresh != null)
|
{
|
selectTypeRefresh();
|
}
|
}
|
}
|
}
|
|
int m_SelectDateIndex;
|
public int selectDateIndex
|
{
|
get { return m_SelectDateIndex; }
|
set
|
{
|
if (m_SelectDateIndex != value)
|
{
|
m_SelectDateIndex = value;
|
if (selectDateIndexRefresh != null)
|
{
|
selectDateIndexRefresh();
|
}
|
}
|
}
|
}
|
|
public int jumpType { get; set; }
|
|
public bool autoOpen { get; set; }
|
|
|
public bool IsOpen
|
{
|
get
|
{
|
return OperationTimeHepler.Instance.SatisfyOpenCondition(Operation.FestivalRedpack);
|
}
|
}
|
|
public bool IsAdvance { get { return false; } }
|
|
public bool priorityOpen { get { return redpoint.state == RedPointState.Simple; } }
|
|
public int festivalDay
|
{
|
get
|
{
|
OperationFestivalRedpack operation;
|
if (OperationTimeHepler.Instance.TryGetOperation(Operation.FestivalRedpack, out operation))
|
{
|
return IsOpen ? operation.GetCurrentDay() : operation.totalDays;
|
}
|
return 0;
|
}
|
}
|
|
public int operationDay
|
{
|
get
|
{
|
OperationFestivalRedpack operation;
|
if (OperationTimeHepler.Instance.TryGetOperation(Operation.FestivalRedpack, out operation))
|
{
|
return IsOpen ? operation.GetIndexOfTime() : operation.totalDays;
|
}
|
return 0;
|
}
|
}
|
|
public int grabRedpackTimes { get; private set; }
|
|
public int grabTotalJade { get; private set; }
|
|
public float redpackVoiceInterval { get; private set; }
|
|
DateTime voicePlayTime = DateTime.Now;
|
|
public const int FESTIVALTASKREDPACKTYPE = 33;
|
public const int FESTIVALSYSTEMREDPACK1 = 31;
|
public const int FESTIVALSYSTEMREDPACK2 = 32;
|
|
|
const int REDPOINTID = 20919;
|
|
public readonly Redpoint redpoint = new Redpoint(MainRedDot.REDPOINT_OPENSERVER, REDPOINTID);
|
public readonly Redpoint systemRedpoint = new Redpoint(REDPOINTID, 2091901);
|
public readonly Redpoint taskRedpoint = new Redpoint(REDPOINTID, 2091902);
|
public readonly Redpoint receiveRedpoint = new Redpoint(REDPOINTID, 2091903);
|
public readonly Redpoint dailyRemindRedpoint = new Redpoint(REDPOINTID, 2091910);
|
|
public event Action<int> onStateUpdate;
|
public event Action redpackGrabRefresh;
|
public event Action selectTypeRefresh;
|
public event Action selectDateIndexRefresh;
|
public event Action<int> achievementRefresh;
|
public event Action taskRedpackRefresh;
|
|
RedEnvelopeModel envelopeModel { get { return ModelCenter.Instance.GetModel<RedEnvelopeModel>(); } }
|
AchievementModel achievementModel { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }
|
|
public override void Init()
|
{
|
OperationTimeHepler.Instance.operationStartEvent += OperationStartEvent;
|
OperationTimeHepler.Instance.operationEndEvent += OperationEndEvent;
|
OperationTimeHepler.Instance.dayResetEvent += DayResetEvent;
|
envelopeModel.EnvelopeUpdateEvent += EnvelopeUpdateEvent;
|
envelopeModel.EnvelopeDelEvent += EnvelopeDelEvent;
|
envelopeModel.EnvelopeGetEvent += EnvelopeGetEvent;
|
achievementModel.achievementCompletedEvent += AchievementCompletedEvent;
|
achievementModel.achievementProgressUpdateEvent += AchievementProgressUpdateEvent;
|
ParseConfig();
|
OpenServerActivityCenter.Instance.Register(19, this);
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
grabRedpackTimes = 0;
|
grabTotalJade = 0;
|
serverInited = false;
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
UpdateRedpoint();
|
serverInited = true;
|
}
|
|
public override void UnInit()
|
{
|
OperationTimeHepler.Instance.operationStartEvent -= OperationStartEvent;
|
OperationTimeHepler.Instance.operationEndEvent -= OperationEndEvent;
|
OperationTimeHepler.Instance.dayResetEvent -= DayResetEvent;
|
envelopeModel.EnvelopeUpdateEvent -= EnvelopeUpdateEvent;
|
envelopeModel.EnvelopeDelEvent -= EnvelopeDelEvent;
|
envelopeModel.EnvelopeGetEvent -= EnvelopeGetEvent;
|
achievementModel.achievementCompletedEvent -= AchievementCompletedEvent;
|
achievementModel.achievementProgressUpdateEvent -= AchievementProgressUpdateEvent;
|
}
|
|
void ParseConfig()
|
{
|
{
|
var configs = FestivalRedpackTaskConfig.GetValues();
|
foreach (var config in configs)
|
{
|
List<FestivalRedpackAchievement> list;
|
if (!achievements.TryGetValue(config.FeastDay, out list))
|
{
|
list = new List<FestivalRedpackAchievement>();
|
achievements.Add(config.FeastDay, list);
|
}
|
list.Add(new FestivalRedpackAchievement()
|
{
|
id = config.ID,
|
achievements = config.achievements,
|
});
|
}
|
}
|
|
{
|
var configs = RedPackConfig.GetValues();
|
foreach (var config in configs)
|
{
|
if (config.RedEnvelopeType == FESTIVALSYSTEMREDPACK1
|
|| config.RedEnvelopeType == FESTIVALSYSTEMREDPACK2)
|
{
|
var openTime = ParseTime(config.PacketOpenTime);
|
festivalRedpacks.Add(config.id, new FestivalRedpack()
|
{
|
id = config.id,
|
openTime = openTime,
|
endTime = openTime.AddTicks(config.ValidMinutes * TimeSpan.TicksPerMinute),
|
type = config.RedEnvelopeType,
|
});
|
}
|
}
|
}
|
|
{
|
var config = FuncConfigConfig.Get("RedEnvelopeVoiceCd");
|
redpackVoiceInterval = float.Parse(config.Numerical1) / 1000;
|
}
|
}
|
|
DateTime ParseTime(string timeString)
|
{
|
var year = 2018;
|
var month = 1;
|
var day = 1;
|
var hour = 1;
|
var minute = 20;
|
var array = timeString.Split(' ');
|
if (array != null && array.Length == 2)
|
{
|
var dateArray = array[0].Split('-');
|
if (dateArray != null && dateArray.Length == 3)
|
{
|
year = int.Parse(dateArray[0].Trim());
|
month = int.Parse(dateArray[1].Trim());
|
day = int.Parse(dateArray[2].Trim());
|
}
|
var timeArray = array[1].Split(':');
|
if (timeArray != null && timeArray.Length == 2)
|
{
|
hour = int.Parse(timeArray[0].Trim());
|
minute = int.Parse(timeArray[1].Trim());
|
}
|
}
|
return new DateTime(year, month, day, hour, minute, 0);
|
}
|
|
public bool IsSystemRedpackOverdue(int id)
|
{
|
if (festivalRedpacks.ContainsKey(id))
|
{
|
return TimeUtility.ServerNow >= festivalRedpacks[id].endTime;
|
}
|
return false;
|
}
|
|
public bool IsExistSystemRedpack(int id, out int redpackId)
|
{
|
redpackId = 0;
|
if (festivalRedpacks.ContainsKey(id))
|
{
|
List<int> redpacks = null;
|
if (envelopeModel.TryGetEnvelopes(festivalRedpacks[id].type, out redpacks))
|
{
|
foreach (var serverId in redpacks)
|
{
|
RedEnvelopeModel.RedEnvelope envelope;
|
if (envelopeModel.TryGetEnvelope(serverId, out envelope))
|
{
|
if (TimeUtility.GetTime(envelope.time).Equals(festivalRedpacks[id].openTime))
|
{
|
redpackId = serverId;
|
return true;
|
}
|
}
|
}
|
}
|
}
|
return false;
|
}
|
|
public bool IsContainsAchievement(List<FestivalRedpackAchievement> list, int achievementId)
|
{
|
foreach (var festivalRedpackAchievement in list)
|
{
|
if (festivalRedpackAchievement.Contains(achievementId))
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
public bool TryGetRedpack(int id, out FestivalRedpack redpack)
|
{
|
return festivalRedpacks.TryGetValue(id, out redpack);
|
}
|
|
public bool TryGetAchievements(int index, out List<FestivalRedpackAchievement> list)
|
{
|
return achievements.TryGetValue(index, out list);
|
}
|
|
public int SystemRedpackSort(int lhs, int rhs)
|
{
|
bool lhsOverdue = IsSystemRedpackOverdue(lhs);
|
bool rhsOverdue = IsSystemRedpackOverdue(rhs);
|
var lhsServerId = 0;
|
var rhsServerid = 0;
|
IsExistSystemRedpack(lhs, out lhsServerId);
|
IsExistSystemRedpack(rhs, out rhsServerid);
|
RedEnvelopeModel.RedEnvelope lhsEnvelope;
|
RedEnvelopeModel.RedEnvelope rhsEnvelope;
|
var lhsState = 0;
|
var rhsState = 0;
|
if (envelopeModel.TryGetEnvelope(lhsServerId, out lhsEnvelope))
|
{
|
lhsState = lhsEnvelope.state;
|
}
|
if (envelopeModel.TryGetEnvelope(rhsServerid, out rhsEnvelope))
|
{
|
rhsState = rhsEnvelope.state;
|
}
|
|
bool lhsGrab = lhsState == 1 && !lhsOverdue;
|
bool rhsGrab = rhsState == 1 && !rhsOverdue;
|
if (lhsGrab != rhsGrab)
|
{
|
return -lhsGrab.CompareTo(rhsGrab);
|
}
|
|
bool lhsExist = lhsState == 0 && !lhsOverdue;
|
bool rhsExist = rhsState == 0 && !rhsOverdue;
|
if (lhsExist != rhsExist)
|
{
|
return -lhsExist.CompareTo(rhsExist);
|
}
|
|
bool lhsGot = lhsState == 2;
|
bool rhsGot = rhsState == 2;
|
if (lhsGot != rhsGot)
|
{
|
return -lhsGot.CompareTo(rhsGot);
|
}
|
|
bool lhsDone = lhsState == 3;
|
bool rhsDone = rhsState == 3;
|
if (lhsDone != rhsDone)
|
{
|
return -lhsDone.CompareTo(rhsDone);
|
}
|
|
if (lhsOverdue != rhsOverdue)
|
{
|
return lhsOverdue.CompareTo(rhsOverdue);
|
}
|
|
if (festivalRedpacks.ContainsKey(lhs)
|
&& festivalRedpacks.ContainsKey(rhs))
|
{
|
return festivalRedpacks[lhs].openTime.CompareTo(festivalRedpacks[rhs].openTime);
|
}
|
return 0;
|
}
|
|
public int AchievementSort(FestivalRedpackAchievement lhs, FestivalRedpackAchievement rhs)
|
{
|
Achievement lhsAchievement;
|
Achievement rhsAchievement;
|
if (achievementModel.TryGetAchievement(lhs.CurrentAchieve, out lhsAchievement)
|
&& achievementModel.TryGetAchievement(rhs.CurrentAchieve, out rhsAchievement))
|
{
|
if (lhsAchievement.completed.CompareTo(rhsAchievement.completed) != 0)
|
{
|
return lhsAchievement.completed.CompareTo(rhsAchievement.completed);
|
}
|
bool xReach = Achievement.IsReach(lhsAchievement.id, lhsAchievement.progress);
|
bool yReach = Achievement.IsReach(rhsAchievement.id, rhsAchievement.progress);
|
if (xReach.CompareTo(yReach) != 0)
|
{
|
return -xReach.CompareTo(yReach);
|
}
|
}
|
return lhs.id.CompareTo(rhs.id);
|
}
|
|
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);
|
}
|
|
public void OnReceivePackage(HAB25_tagMCFeastRedPackInfo package)
|
{
|
grabRedpackTimes = package.GrabCnt;
|
grabTotalJade = (int)package.MoneyNum;
|
if (redpackGrabRefresh != null)
|
{
|
redpackGrabRefresh();
|
}
|
UpdateRedpoint();
|
}
|
|
private void DayResetEvent(int resetType)
|
{
|
OperationBase operationBase;
|
if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.FestivalRedpack, out operationBase))
|
{
|
if (resetType == operationBase.resetType)
|
{
|
UpdateRedpoint();
|
}
|
}
|
}
|
|
private void OperationEndEvent(Operation type, int state)
|
{
|
if (type == Operation.FestivalRedpack && state == 0)
|
{
|
UpdateRedpoint();
|
if (onStateUpdate != null)
|
{
|
onStateUpdate(19);
|
}
|
}
|
}
|
|
private void OperationStartEvent(Operation type, int state)
|
{
|
if (type == Operation.FestivalRedpack && state == 0)
|
{
|
UpdateRedpoint();
|
if (onStateUpdate != null)
|
{
|
onStateUpdate(19);
|
}
|
}
|
}
|
|
private void EnvelopeUpdateEvent()
|
{
|
bool rewardable = receiveRedpoint.state == RedPointState.GetReward;
|
|
UpdateRedpoint();
|
if (taskRedpackRefresh != null)
|
{
|
taskRedpackRefresh();
|
}
|
|
if (!rewardable && receiveRedpoint.state == RedPointState.GetReward
|
&& serverInited && !ExistSelfTaskRedpack())
|
{
|
PlayRedpackVoice();
|
}
|
}
|
|
public bool ExistSelfTaskRedpack()
|
{
|
List<int> list;
|
if (envelopeModel.TryGetEnvelopes(FESTIVALTASKREDPACKTYPE, out list))
|
{
|
foreach (var id in list)
|
{
|
RedEnvelopeModel.RedEnvelope envelope;
|
if (envelopeModel.TryGetEnvelope(id, out envelope))
|
{
|
if (envelope.player == PlayerDatas.Instance.PlayerId
|
&& envelope.state == 1)
|
{
|
return true;
|
}
|
}
|
}
|
}
|
return false;
|
}
|
|
public void JudgePlayRedpackVoice(int type)
|
{
|
if (type == FESTIVALSYSTEMREDPACK1
|
|| type == FESTIVALSYSTEMREDPACK2)
|
{
|
PlayRedpackVoice();
|
}
|
}
|
|
void PlayRedpackVoice()
|
{
|
if ((DateTime.Now - voicePlayTime).TotalSeconds < redpackVoiceInterval)
|
{
|
return;
|
}
|
SoundPlayer.Instance.PlayUIAudio(632);
|
voicePlayTime = DateTime.Now;
|
}
|
|
private void EnvelopeDelEvent()
|
{
|
UpdateRedpoint();
|
if (taskRedpackRefresh != null)
|
{
|
taskRedpackRefresh();
|
}
|
}
|
|
private void EnvelopeGetEvent(int _id)
|
{
|
if (!serverInited)
|
{
|
return;
|
}
|
RedEnvelopeModel.RedEnvelope _envelope;
|
if (envelopeModel.TryGetEnvelope(_id, out _envelope))
|
{
|
if (_envelope.player == PlayerDatas.Instance.PlayerId &&
|
_envelope.type == FESTIVALTASKREDPACKTYPE
|
&& _envelope.state == 1)
|
{
|
envelopeModel.cacheEnvelopeId = _envelope.id;
|
envelopeModel.envelopeSfx = _envelope.id;
|
CAB12_tagCMGrabFamilyRedPacket _pak = new CAB12_tagCMGrabFamilyRedPacket();
|
_pak.RedPaketID = (uint)_envelope.id;
|
_pak.GetWay = FESTIVALTASKREDPACKTYPE;
|
GameNetSystem.Instance.SendInfo(_pak);
|
}
|
}
|
}
|
|
private void AchievementCompletedEvent(int _achieve)
|
{
|
List<FestivalRedpackAchievement> list;
|
if (TryGetAchievements(operationDay + 1, out list) && IsContainsAchievement(list, _achieve))
|
{
|
if (achievementRefresh != null)
|
{
|
achievementRefresh(_achieve);
|
}
|
UpdateRedpoint();
|
}
|
}
|
|
private void AchievementProgressUpdateEvent(int _achieve)
|
{
|
List<FestivalRedpackAchievement> list;
|
if (TryGetAchievements(operationDay + 1, out list) && IsContainsAchievement(list, _achieve))
|
{
|
if (achievementRefresh != null)
|
{
|
achievementRefresh(_achieve);
|
}
|
UpdateRedpoint();
|
}
|
}
|
|
public bool ExistRewardableRedpack()
|
{
|
UpdateRedpoint();
|
return redpoint.state == RedPointState.GetReward;
|
}
|
|
public void SetDayRemind()
|
{
|
DayRemind.Instance.SetDayRemind(DayRemind.FESTIVALREDPACKREMIND, true);
|
UpdateRedpoint();
|
}
|
|
private void UpdateRedpoint()
|
{
|
var existSystemRedpack = false;
|
var existFinishTask = false;
|
var existUnGetRedpack = false;
|
var dailyRemind = false;
|
if (IsOpen)
|
{
|
OperationFestivalRedpack operation;
|
if (OperationTimeHepler.Instance.TryGetOperation(Operation.FestivalRedpack, out operation))
|
{
|
var index = festivalDay;
|
var systemRedpacks = index < operation.redpacks.Count && index >= 0 ?
|
operation.redpacks[index].redpacks : operation.redpacks[0].redpacks;
|
foreach (var redpackId in systemRedpacks)
|
{
|
if (IsSystemRedpackOverdue(redpackId))
|
{
|
continue;
|
}
|
var redpackServerId = 0;
|
if (IsExistSystemRedpack(redpackId, out redpackServerId))
|
{
|
RedEnvelopeModel.RedEnvelope envelope;
|
if (envelopeModel.TryGetEnvelope(redpackServerId, out envelope))
|
{
|
if (envelope.state == 1)
|
{
|
existSystemRedpack = true;
|
break;
|
}
|
}
|
}
|
}
|
}
|
|
List<FestivalRedpackAchievement> list;
|
if (TryGetAchievements(operationDay + 1, out list))
|
{
|
foreach (var festivalRedpackAchievement in list)
|
{
|
Achievement achievement;
|
if (achievementModel.TryGetAchievement(festivalRedpackAchievement.CurrentAchieve, out achievement))
|
{
|
if (Achievement.IsReach(festivalRedpackAchievement.CurrentAchieve, achievement.progress) && !achievement.completed)
|
{
|
existFinishTask = true;
|
break;
|
}
|
}
|
}
|
}
|
|
envelopeModel.GetEnvelopes(FESTIVALTASKREDPACKTYPE, ref taskRedpacks);
|
foreach (var id in taskRedpacks)
|
{
|
RedEnvelopeModel.RedEnvelope envelope;
|
if (envelopeModel.TryGetEnvelope(id, out envelope))
|
{
|
if (envelope.player == PlayerDatas.Instance.baseData.PlayerID)
|
{
|
if (envelope.state == 1)
|
{
|
existUnGetRedpack = true;
|
break;
|
}
|
}
|
else
|
{
|
if (envelope.state == 1 && grabRedpackTimes > 0)
|
{
|
existUnGetRedpack = true;
|
break;
|
}
|
}
|
}
|
}
|
|
if (!DayRemind.Instance.GetDayRemind(DayRemind.FESTIVALREDPACKREMIND))
|
{
|
dailyRemind = true;
|
}
|
}
|
systemRedpoint.state = existSystemRedpack ? RedPointState.GetReward : RedPointState.None;
|
taskRedpoint.state = existFinishTask ? RedPointState.Simple : RedPointState.None;
|
receiveRedpoint.state = existUnGetRedpack ? RedPointState.GetReward : RedPointState.None;
|
dailyRemindRedpoint.state = dailyRemind ? RedPointState.Simple : RedPointState.None;
|
}
|
}
|
|
public class FestivalRedpackAchievement
|
{
|
public int id;
|
public int[] achievements;
|
|
public AchievementModel model { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }
|
|
public int CurrentAchieve
|
{
|
get
|
{
|
for (int i = 0; i < achievements.Length; i++)
|
{
|
Achievement achievement;
|
if (model.TryGetAchievement(achievements[i], out achievement))
|
{
|
if (!achievement.completed)
|
{
|
return achievements[i];
|
}
|
}
|
}
|
return achievements[achievements.Length - 1];
|
}
|
}
|
|
public bool Contains(int _achieve)
|
{
|
for (int i = 0; i < achievements.Length; i++)
|
{
|
if (achievements[i] == _achieve)
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
}
|
|
public struct FestivalRedpack
|
{
|
public int id;
|
public int type;
|
public DateTime openTime;
|
public DateTime endTime;
|
}
|
|
public enum FestivalRedpackTaskState
|
{
|
Doing,
|
ReceiveReward,
|
Completed,
|
}
|
}
|
|
