using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
|
using UnityEngine;
|
using LitJson;
|
using System.Collections;
|
|
public class BuyShopItemLimit
|
{
|
public uint ItemIndex;
|
public int BuyCnt; // 今日已购买次数
|
public int isReset; //是否属于每月重置 0 不重置 1重置
|
}
|
|
public struct ShopItemInfo
|
{
|
public int itemId;
|
public int count;
|
|
public ShopItemInfo(int id, int count)
|
{
|
this.itemId = id;
|
this.count = count;
|
}
|
}
|
|
public class StoreModel : GameSystemManager<StoreModel>
|
{
|
|
public string UNIONSTORESAVE_KEY { get; private set; }
|
public string MUSTBUYSAVE_KEY { get; private set; }
|
public string StoreEffectRecord_Key { get; private set; }
|
public Dictionary<int, Dictionary<int, int>> JobReplaceIdDict = new Dictionary<int, Dictionary<int, int>>();
|
public Dictionary<int, int> showCoinUIDict { get; private set; }
|
public int storeTrailerLv { get; private set; }
|
|
|
public int fairyStoreJumpShopId = 0;
|
|
int m_SelectClassifyId = 0;
|
public int selectSecondType
|
{
|
get { return m_SelectClassifyId; }
|
set
|
{
|
if (m_SelectClassifyId != value)
|
{
|
m_SelectClassifyId = value;
|
if (selectClassifyRefresh != null)
|
{
|
selectClassifyRefresh();
|
}
|
}
|
}
|
}
|
|
public event Action selectClassifyRefresh;
|
|
|
private bool isUpdatePlayerLv;
|
|
//排行榜活动的商店
|
public int rankActStore_MoneyType;
|
public int rankActStore_StoreType;
|
public Operation rankActStore_ActType;
|
|
public override void Init()
|
{
|
ParseFuncConfig();
|
ParseStoreConfig();
|
SetShopRedpoint();
|
}
|
|
public void OnBeforePlayerDataInitialize()
|
{
|
isUpdatePlayerLv = false;
|
IsMustBuyDay = false;
|
sortStoreSecondType = true;
|
ClearJump();
|
FuncOpen.Instance.OnFuncStateChangeEvent -= FuncStateChange;
|
PlayerDatas.Instance.fairyData.OnRefreshFairyMine -= RefreshServerHour;
|
PlayerDatas.Instance.fairyData.OnRefreshFairyInfo -= RefreshFamilyLv;
|
PlayerDatas.Instance.playerDataRefreshEvent -= RefreshPlayerData;
|
TimeMgr.Instance.OnHourEvent -= RefreshServerHour;
|
GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
|
shopItemlimitDict.Clear();
|
storeFuncType = StoreFunc.DayStore;
|
}
|
|
public void OnAfterPlayerDataInitialize()
|
{
|
UNIONSTORESAVE_KEY = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, LocalSaveStoreType.UnionStore);
|
StoreEffectRecord_Key = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "StoreEffectRecord");
|
MUSTBUYSAVE_KEY = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "MustBuy");
|
buyItemCheckDict.Clear();
|
}
|
|
public void OnPlayerLoginOk()
|
{
|
PlayerDatas.Instance.fairyData.OnRefreshFairyInfo += RefreshFamilyLv;
|
PlayerDatas.Instance.fairyData.OnRefreshFairyMine += RefreshServerHour;
|
FuncOpen.Instance.OnFuncStateChangeEvent += FuncStateChange;
|
PlayerDatas.Instance.playerDataRefreshEvent += RefreshPlayerData;
|
TimeMgr.Instance.OnHourEvent += RefreshServerHour;
|
GlobalTimeEvent.Instance.secondEvent += UpdateSecond;
|
|
UpdateShowStore();
|
SetIsMustBuyDay();
|
ControllerRedPoint();
|
UpdateFreeShopRedpoint();
|
UpdateCanBuyRedpoint();
|
UpdateMustBuyRedpoint();
|
UpdateDailyRedpoinit();
|
}
|
|
|
|
|
|
#region 解析本地数据
|
public Dictionary<int, List<int>> storeRedRuleDict { get; private set; } //红点类型 1,免费商品 2,必买商品 3,坐骑灵宠 4,可购买物品（积分兑换）
|
private void ParseFuncConfig()
|
{
|
storeRedRuleDict = new Dictionary<int, List<int>>();
|
FuncConfigConfig storeRedRules = FuncConfigConfig.Get("StoreRedRules");
|
if (storeRedRules != null)
|
{
|
JsonData redRules = JsonMapper.ToObject(storeRedRules.Numerical1);
|
foreach (var type in redRules.Keys)
|
{
|
int redType = 0;
|
int.TryParse(type, out redType);
|
JsonData shops = redRules[type];
|
if (!storeRedRuleDict.ContainsKey(redType))
|
{
|
List<int> shopIdlist = new List<int>();
|
if (shops.IsArray)
|
{
|
for (int i = 0; i < shops.Count; i++)
|
{
|
int shopId = 0;
|
int.TryParse(shops[i].ToString(), out shopId);
|
shopIdlist.Add(shopId);
|
}
|
}
|
storeRedRuleDict.Add(redType, shopIdlist);
|
}
|
}
|
|
|
}
|
}
|
|
public Dictionary<int, List<StoreData>> storeTypeDict { get; private set; }
|
public Dictionary<int, List<StoreData>> theOnlyShopDict { get; private set; } //key 物品id
|
public Dictionary<string, List<StoreData>> limitValueShopDict { get; private set; } //key 商品类型和限制条件
|
private void ParseStoreConfig()
|
{
|
storeTypeDict = new Dictionary<int, List<StoreData>>();
|
theOnlyShopDict = new Dictionary<int, List<StoreData>>();
|
limitValueShopDict = new Dictionary<string, List<StoreData>>();
|
List<StoreConfig> storeConfigs = StoreConfig.GetValues();
|
for (int i = 0; i < storeConfigs.Count; i++)
|
{
|
var config = storeConfigs[i];
|
if (config.ShopType != 0)
|
{
|
StoreData storeData = new StoreData();
|
storeData.shopId = config.ID;
|
storeData.storeConfig = config;
|
storeData.jobReplaceDict = AnalysisJobReplace(config);
|
if (!storeTypeDict.ContainsKey(config.ShopType))
|
{
|
List<StoreData> storeDatas = new List<StoreData>();
|
storeDatas.Add(storeData);
|
storeTypeDict.Add(config.ShopType, storeDatas);
|
}
|
else
|
{
|
storeTypeDict[config.ShopType].Add(storeData);
|
}
|
|
if (config.TheOnlyShop == 1)
|
{
|
if (!theOnlyShopDict.ContainsKey(config.ItemID))
|
{
|
List<StoreData> storeDatas = new List<StoreData>();
|
storeDatas.Add(storeData);
|
theOnlyShopDict.Add(config.ItemID, storeDatas);
|
}
|
else
|
{
|
theOnlyShopDict[config.ItemID].Add(storeData);
|
}
|
}
|
|
string key = StringUtility.Contact(config.ShopType, config.LimitValue);
|
if (!limitValueShopDict.ContainsKey(key))
|
{
|
List<StoreData> storeDatas = new List<StoreData>();
|
storeDatas.Add(storeData);
|
limitValueShopDict.Add(key, storeDatas);
|
}
|
else
|
{
|
limitValueShopDict[key].Add(storeData);
|
}
|
}
|
}
|
|
foreach (var type in storeTypeDict.Keys)
|
{
|
var configs = storeTypeDict[type];
|
configs.Sort(CompareByShopSort);
|
}
|
}
|
|
private Dictionary<int, List<int>> AnalysisJobReplace(StoreConfig storeConfig)
|
{
|
if (storeConfig == null || string.IsNullOrEmpty(storeConfig.JobItem)) return null;
|
|
Dictionary<int, List<int>> replaceDict = new Dictionary<int, List<int>>();
|
JsonData jsonData = JsonMapper.ToObject(storeConfig.JobItem);
|
if (jsonData.IsArray)
|
{
|
for (int i = 0; i < jsonData.Count; i++)
|
{
|
List<int> idlist = new List<int>();
|
replaceDict.Add(i, idlist);
|
if (jsonData[i].IsArray)
|
{
|
for (int j = 0; j < jsonData[i].Count; j++)
|
{
|
int itemId = int.Parse(jsonData[i][j].ToString());
|
idlist.Add(itemId);
|
}
|
}
|
}
|
}
|
return replaceDict;
|
}
|
|
public int CompareByShopSort(StoreData start, StoreData end)
|
{
|
int sort1 = start.storeConfig.ShopSort;
|
int sort2 = end.storeConfig.ShopSort;
|
|
return sort1.CompareTo(sort2);
|
}
|
|
public class StoreData
|
{
|
public int shopId;
|
public StoreConfig storeConfig;
|
public Dictionary<int, List<int>> jobReplaceDict;
|
}
|
#endregion
|
|
#region 获取数据
|
|
private Dictionary<int, List<StoreData>> showStoreTypeDict = new Dictionary<int, List<StoreData>>();
|
|
private Dictionary<int, Dictionary<int, List<StoreData>>> showStoreSecondTypeDict = new Dictionary<int, Dictionary<int, List<StoreData>>>();
|
|
|
// 新规则分二级标签，此函数保留，另增加UpdateShowStoreEx函数
|
public void UpdateShowStore()
|
{
|
showStoreTypeDict.Clear();
|
int playeLv = PlayerDatas.Instance.baseData.LV;
|
//int vipLevel = PlayerDatas.Instance.baseData.VIPLv;
|
foreach (var type in storeTypeDict.Keys)
|
{
|
var storeDatas = storeTypeDict[type];
|
List<StoreData> showStoreDatas = new List<StoreData>();
|
if (!showStoreTypeDict.ContainsKey(type))
|
{
|
for (int i = 0; i < storeDatas.Count; i++)
|
{
|
var storeData = storeDatas[i];
|
bool isReachLv = playeLv >= storeData.storeConfig.LVSee ? true : false;
|
|
bool isReach = isReachLv;
|
if (isReach)
|
{
|
int remainNum = 0;
|
bool isSellOut = TryGetIsSellOut(storeData.storeConfig, out remainNum);
|
if (storeData.storeConfig.IsHideSellOut != 1)
|
{
|
showStoreDatas.Add(storeData);
|
}
|
else
|
{
|
if (storeData.storeConfig.TheOnlyShop == 1)
|
{
|
if (!CheckTheOnlyShopSellOut(storeData.shopId))
|
{
|
showStoreDatas.Add(storeData);
|
}
|
}
|
else
|
{
|
if (!isSellOut)
|
{
|
showStoreDatas.Add(storeData);
|
}
|
}
|
}
|
}
|
|
}
|
showStoreTypeDict.Add(type, showStoreDatas);
|
}
|
}
|
UpdateShowStoreEx();
|
}
|
|
// 商城分二级标签
|
public void UpdateShowStoreEx()
|
{
|
sortStoreSecondType = true;
|
showStoreSecondTypeDict.Clear();
|
foreach (var type in showStoreTypeDict.Keys)
|
{
|
if (!showStoreSecondTypeDict.ContainsKey(type))
|
showStoreSecondTypeDict[type] = new Dictionary<int, List<StoreData>>();
|
|
foreach (var storeData in showStoreTypeDict[type])
|
{
|
|
foreach (var secondType in storeData.storeConfig.SecondType)
|
{
|
if (!showStoreSecondTypeDict[type].ContainsKey(secondType))
|
showStoreSecondTypeDict[type][secondType] = new List<StoreData>();
|
|
showStoreSecondTypeDict[type][secondType].Add(storeData);
|
}
|
|
}
|
}
|
|
}
|
|
bool sortStoreSecondType = true;
|
|
public void SortStoreSecondType()
|
{
|
//ArrayList lst = new ArrayList(showStoreSecondTypeDict.Keys);
|
if (!sortStoreSecondType)
|
return;
|
|
foreach (var type in showStoreSecondTypeDict.Keys)
|
{
|
foreach (var secondType in showStoreSecondTypeDict[type].Keys)
|
{
|
var storeList = showStoreSecondTypeDict[type][secondType];
|
storeList.Sort(CompareSecondShop);
|
}
|
}
|
|
sortStoreSecondType = false;
|
}
|
|
private bool IsSellOut(StoreData storeData)
|
{
|
int remainNum = 0;
|
if (TryGetIsSellOut(storeData.storeConfig, out remainNum))
|
return true;
|
|
if (storeData.storeConfig.TheOnlyShop == 1 && CheckTheOnlyShopSellOut(storeData.shopId))
|
return true;
|
|
return false;
|
}
|
|
private int CompareSecondShop(StoreData start, StoreData end)
|
{
|
bool isSellOut1 = IsSellOut(start);
|
bool isSellOut2 = IsSellOut(end);
|
|
if (isSellOut1 != isSellOut2)
|
return isSellOut1.CompareTo(isSellOut2);
|
int sort1 = start.storeConfig.ShopSort;
|
int sort2 = end.storeConfig.ShopSort;
|
|
return sort1.CompareTo(sort2);
|
}
|
|
/// <summary>
|
/// 检测唯一商品是否已售罄
|
/// </summary>
|
/// <param name="shopIndex"></param>
|
/// <param name="isTheOnlyShop"></param>
|
/// <returns></returns>
|
public bool CheckTheOnlyShopSellOut(int shopIndex)
|
{
|
StoreConfig storeConfig = StoreConfig.Get(shopIndex);
|
if (storeConfig == null || storeConfig.TheOnlyShop != 1) return false;
|
|
if (theOnlyShopDict.ContainsKey(storeConfig.ItemID))
|
{
|
List<StoreData> datas = theOnlyShopDict[storeConfig.ItemID];
|
for (int i = 0; i < datas.Count; i++)
|
{
|
var data = datas[i];
|
int remainNum = 0;
|
if (TryGetIsSellOut(data.storeConfig, out remainNum))
|
{
|
return true;
|
}
|
}
|
}
|
|
return false;
|
}
|
|
public List<StoreData> TryGetStoreDatas(StoreFunc type)
|
{
|
var results = new List<StoreData>();
|
List<StoreData> datas = null;
|
if (showStoreTypeDict.TryGetValue((int)type, out datas))
|
{
|
results.AddRange(datas);
|
//switch (type)
|
//{
|
// case StoreFunc.MysteryStore:
|
// foreach (var item in datas)
|
// {
|
// if (mysteryCommondities.Contains(item.storeConfig.ID))
|
// {
|
// results.Add(item);
|
// }
|
// }
|
|
// results.Sort((StoreData x, StoreData y) => { return x.storeConfig.MoneyType < y.storeConfig.MoneyType ? -1 : 1; });
|
// break;
|
// default:
|
// results.AddRange(datas);
|
// break;
|
//}
|
}
|
|
return results;
|
}
|
|
// 获取二级标签商品
|
public List<StoreData> TryGetStoreDatasBySecondType(int type, int secondType)
|
{
|
if (!showStoreSecondTypeDict.ContainsKey(type))
|
return null;
|
|
if (!showStoreSecondTypeDict[type].ContainsKey(secondType))
|
return null;
|
|
SortStoreSecondType();
|
return showStoreSecondTypeDict[type][secondType];
|
}
|
|
// 获得二级标签的第一个标签类型
|
public int GetFirstStoreSecondType(int type, bool jump = true)
|
{
|
if (jump && jumpToItemId != 0)
|
{
|
if (selectSecondType == 0) selectSecondType = 1;
|
return selectSecondType;
|
}
|
if (!showStoreSecondTypeDict.ContainsKey(type))
|
return 1;
|
|
ArrayList sortList = new ArrayList(showStoreSecondTypeDict[type].Keys);
|
sortList.Sort();
|
return (int)sortList[0];
|
}
|
|
// 获得二级标签的第一个标签类型
|
public ArrayList GetStoreSecondTypeList(int type)
|
{
|
if (!showStoreSecondTypeDict.ContainsKey(type))
|
return null;
|
|
ArrayList sortList = new ArrayList(showStoreSecondTypeDict[type].Keys);
|
sortList.Sort();
|
return sortList;
|
}
|
|
public StoreData GetStoreData(int shopId)
|
{
|
StoreConfig storeConfig = StoreConfig.Get(shopId);
|
if (storeConfig == null) return null;
|
|
List<StoreData> storeDatas = null;
|
storeTypeDict.TryGetValue(storeConfig.ShopType, out storeDatas);
|
if (storeDatas != null)
|
{
|
for (int i = 0; i < storeDatas.Count; i++)
|
{
|
var storeData = storeDatas[i];
|
if (storeData.shopId == shopId)
|
{
|
return storeData;
|
}
|
}
|
}
|
return null;
|
}
|
|
// 不同职业显示不同物品的情况
|
public int GetReplaceId(int shopId, int itemId)
|
{
|
var storeData = GetStoreData(shopId);
|
if (storeData == null) return 0;
|
|
int job = PlayerDatas.Instance.baseData.Job;
|
var replaceDict = storeData.jobReplaceDict;
|
if (replaceDict != null)
|
{
|
foreach (var index in replaceDict.Keys)
|
{
|
var idlist = replaceDict[index];
|
if (idlist.Contains(itemId))
|
{
|
int replaceIndex = job - 1;
|
return idlist[replaceIndex];
|
}
|
}
|
}
|
|
return itemId;
|
}
|
|
public bool TryGetRedTypeByShopId(int shopId, out int type)
|
{
|
type = 0;
|
foreach (var key in storeRedRuleDict.Keys)
|
{
|
List<int> idlist = storeRedRuleDict[key];
|
if (idlist.Contains(shopId))
|
{
|
type = key;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
|
|
public bool TryGetIsSellOut(StoreConfig storeConfig, out int remainCnt)
|
{
|
int canBuyCnt = 0;
|
int addBuyCnt = 0;
|
remainCnt = 0;
|
bool isLimitBuy = TryGetLimitBuy(storeConfig, out canBuyCnt, out addBuyCnt);
|
if (!isLimitBuy) return false;
|
|
remainCnt = canBuyCnt;
|
BuyShopItemLimit shopItemLimit = GetBuyShopLimit((uint)storeConfig.ID);
|
if (shopItemLimit != null)
|
{
|
remainCnt -= shopItemLimit.BuyCnt;
|
}
|
|
if (remainCnt <= 0)
|
{
|
return true;
|
}
|
return false;
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
/// <param name="config"></param>
|
/// <param name="canBuyCnt"> 可购买上限</param>
|
/// <param name="addBuyCnt"> 下一级VIP增加的可购买次数</param>
|
/// <returns></returns>
|
public bool TryGetLimitBuy(StoreConfig config, out int canBuyCnt, out int addBuyCnt)
|
{
|
canBuyCnt = 0;
|
addBuyCnt = 0;
|
if (config == null) return false;
|
|
int[] canBuyNums = config.GoumaiNumber;
|
if (canBuyNums == null || canBuyNums.Length < 1) return false;
|
|
int curVipIndex = -1;
|
int nexVipIndex = -1;
|
bool isVipBuy = TryGetVipBuy(config, out curVipIndex, out nexVipIndex);
|
if (isVipBuy)
|
{
|
if (curVipIndex != -1)
|
{
|
canBuyCnt = canBuyNums[curVipIndex];
|
}
|
|
if (nexVipIndex != -1)
|
{
|
addBuyCnt = canBuyNums[nexVipIndex] - canBuyCnt;
|
}
|
return true;
|
}
|
else
|
{
|
if (canBuyNums[0] != 0)
|
{
|
canBuyCnt = canBuyNums[0];
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
}
|
|
public bool TryGetVipBuy(StoreConfig config, out int curVipIndex, out int nextVipIndex)
|
{
|
curVipIndex = -1;
|
nextVipIndex = -1;
|
bool isVipBuy = false;
|
if (config == null) return false;
|
|
var vipLvs = config.VIPLV;
|
if (vipLvs == null || vipLvs.Length < 1) return false;
|
|
for (int i = 0; i < vipLvs.Length; i++)
|
{
|
var vipLv = vipLvs[i];
|
if (vipLv != 0)
|
{
|
isVipBuy = true;
|
}
|
}
|
|
if (isVipBuy)
|
{
|
int playerVip = PlayerDatas.Instance.baseData.VIPLv;
|
for (int i = vipLvs.Length - 1; i > -1; i--)
|
{
|
var vipLv = vipLvs[i];
|
if (vipLv > playerVip)
|
{
|
nextVipIndex = i;
|
}
|
else if (vipLv <= playerVip)
|
{
|
curVipIndex = i;
|
break;
|
}
|
}
|
|
}
|
|
return isVipBuy;
|
}
|
|
|
|
public List<StoreData> TryGetStoreDatasByLimit(int type, int limitValue)
|
{
|
string key = StringUtility.Contact(type, limitValue);
|
List<StoreData> datas = null;
|
limitValueShopDict.TryGetValue(key, out datas);
|
return datas;
|
}
|
#endregion
|
|
|
|
public string GetMysteryStoreRefreshTime()
|
{
|
if (GeneralDefine.mysteryShopRefreshInterval == 0)
|
{
|
return "";
|
}
|
var seconds = GeneralDefine.mysteryShopRefreshInterval -
|
(int)((TimeUtility.ServerNow - TimeUtility.createRoleTime).TotalSeconds) % GeneralDefine.mysteryShopRefreshInterval;
|
return Language.Get("StoreWin200", TimeUtility.SecondsToHMS(seconds));
|
}
|
|
private int GetWillRefreshTime()
|
{
|
int willRefresh = (3 - TimeUtility.OpenDay % 3);
|
if (willRefresh == 3)
|
{
|
if (TimeUtility.ServerNow.Hour < 5)
|
{
|
willRefresh = 0;
|
}
|
}
|
int remainHour = 5 - TimeUtility.ServerNow.Hour;
|
int remainMinute = 0 - TimeUtility.ServerNow.Minute;
|
int remainSecond = willRefresh * 24 * 60 * 60 + remainHour * 60 * 60 + remainMinute * 60 - TimeUtility.ServerNow.Second;
|
return remainSecond;
|
}
|
|
int refreshTime = 0;
|
private void UpdateSecond()
|
{
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return;
|
if (isUpdatePlayerLv)
|
{
|
UpdatePlayerLv();
|
isUpdatePlayerLv = false;
|
}
|
}
|
|
private void UpdatePlayerLv()
|
{
|
UpdateShowStore();
|
UpdateFreeShopRedpoint();
|
UpdateCanBuyRedpoint();
|
UpdateMustBuyRedpoint();
|
}
|
|
private void RefreshPlayerData(PlayerDataType type)
|
{
|
if (type == PlayerDataType.VIPLv)
|
{
|
UpdateShowStore();
|
}
|
|
switch (type)
|
{
|
case PlayerDataType.LV:
|
isUpdatePlayerLv = true;
|
break;
|
case PlayerDataType.VIPLv:
|
case PlayerDataType.Gold:
|
case PlayerDataType.GoldPaper:
|
UpdateFreeShopRedpoint();
|
UpdateCanBuyRedpoint();
|
UpdateDailyRedpoinit();
|
break;
|
case PlayerDataType.UnionLiven:
|
UpdateDailyRedpoinit();
|
break;
|
case PlayerDataType.FBHelpPoint:
|
UpdateFreeShopRedpoint();
|
UpdateCanBuyRedpoint();
|
break;
|
}
|
}
|
|
private void RefreshFamilyLv()
|
{
|
int familyLv = PlayerDatas.Instance.fairyData.fairy.FamilyLV;
|
if (familyLv > GetSaveFairyLV())
|
{
|
ControllerRedPoint();
|
}
|
UpdateDailyRedpoinit();
|
}
|
|
private void RefreshServerHour()
|
{
|
ControllerRedPoint();
|
if (PlayerPrefs.HasKey(MUSTBUYSAVE_KEY))
|
{
|
int[] records = LocalSave.GetIntArray(MUSTBUYSAVE_KEY);
|
if (TimeUtility.ServerNow.Hour >= 5
|
&& ((TimeUtility.ServerNow.Day == records[0] && records[1] < 5)
|
|| TimeUtility.ServerNow.Day != records[0]))
|
{
|
saveTimes[0] = TimeUtility.ServerNow.Day;
|
saveTimes[1] = TimeUtility.ServerNow.Hour;
|
IsMustBuyDay = true;
|
LocalSave.SetIntArray(MUSTBUYSAVE_KEY, saveTimes);
|
UpdateMustBuyRedpoint();
|
}
|
}
|
if (!PlayerDatas.Instance.fairyData.HasFairy)
|
{
|
PlayerPrefs.DeleteKey(UNIONSTORESAVE_KEY);
|
}
|
|
UpdateDailyRedpoinit();
|
}
|
|
public event Action RefreshBuyShopLimitEvent;
|
|
public StoreFunc storeFuncType = StoreFunc.DayStore;
|
public int jumpStoreFuncType { get; set; }
|
private Dictionary<uint, BuyShopItemLimit> shopItemlimitDict = new Dictionary<uint, BuyShopItemLimit>();
|
|
/// <summary>
|
/// 得到物品购买次数
|
/// </summary>
|
/// <param name="buylimit"></param>
|
public void RefreshBuyShopLimitModel(HA802_tagMCShopItemDayBuyCntInfo buylimit)
|
{
|
Debug.Log("RefreshBuyShopLimitModel" + buylimit.Count);
|
if (buylimit.Count > 0)
|
{
|
int i = 0;
|
for (i = 0; i < buylimit.Count; i++)
|
{
|
if (!shopItemlimitDict.ContainsKey(buylimit.DayBuyCntList[i].ItemIndex))
|
{
|
BuyShopItemLimit shopItemLimit = new BuyShopItemLimit();
|
shopItemLimit.ItemIndex = buylimit.DayBuyCntList[i].ItemIndex;
|
shopItemLimit.BuyCnt = (int)buylimit.DayBuyCntList[i].BuyCnt;
|
shopItemLimit.isReset = buylimit.DayBuyCntList[i].IsReset;
|
shopItemlimitDict.Add(shopItemLimit.ItemIndex, shopItemLimit);
|
}
|
else
|
{
|
shopItemlimitDict[buylimit.DayBuyCntList[i].ItemIndex].BuyCnt = (int)buylimit.DayBuyCntList[i].BuyCnt;
|
shopItemlimitDict[buylimit.DayBuyCntList[i].ItemIndex].isReset = buylimit.DayBuyCntList[i].IsReset;
|
}
|
}
|
|
}
|
|
sortStoreSecondType = true;
|
UpdateShowStore();
|
UpdateFreeShopRedpoint();
|
UpdateCanBuyRedpoint();
|
UpdateMustBuyRedpoint();
|
UpdateDailyRedpoinit();
|
if (RefreshBuyShopLimitEvent != null)
|
RefreshBuyShopLimitEvent();
|
}
|
|
public BuyShopItemLimit GetBuyShopLimit(uint itemIndex)
|
{
|
if (shopItemlimitDict.ContainsKey(itemIndex))
|
{
|
return shopItemlimitDict[itemIndex];
|
}
|
return null;
|
}
|
|
|
|
//和GetShopItemlistEx 一样 获取商店物品列表，只是返回类型不同
|
List<ShopItemInfo> shopItemlist = new List<ShopItemInfo>();
|
public List<ShopItemInfo> GetShopItemlistByIndex(StoreConfig storeConfig)
|
{
|
if (storeConfig == null) return null;
|
|
shopItemlist.Clear();
|
if (storeConfig.ItemID != 0)
|
{
|
int replaceId = GetReplaceId(storeConfig.ID, storeConfig.ItemID);
|
ShopItemInfo shopItem = new ShopItemInfo(replaceId, storeConfig.ItemCnt);
|
shopItemlist.Add(shopItem);
|
}
|
JsonData extraItem = JsonMapper.ToObject(storeConfig.ItemListEx);
|
if (extraItem.IsArray)
|
{
|
for (int i = 0; i < extraItem.Count; i++)
|
{
|
if (extraItem[i].IsArray)
|
{
|
if (extraItem[i].Count > 0)
|
{
|
int itemId = int.Parse(extraItem[i][0].ToString());
|
int itemCount = int.Parse(extraItem[i][1].ToString());
|
if (itemId != 0)
|
{
|
int extraReplaceId = GetReplaceId(storeConfig.ID, itemId);
|
ShopItemInfo shop = new ShopItemInfo(extraReplaceId, itemCount);
|
shopItemlist.Add(shop);
|
}
|
}
|
}
|
}
|
}
|
return shopItemlist;
|
}
|
|
//和GetShopItemlistByIndex 一样 获取商店物品列表，只是返回类型不同
|
public List<int[]> GetShopItemlistEx(StoreConfig storeConfig)
|
{
|
if (storeConfig == null) return null;
|
|
List<int[]> shopItemlist = new List<int[]>();
|
if (storeConfig.ItemID != 0)
|
{
|
int replaceId = GetReplaceId(storeConfig.ID, storeConfig.ItemID);
|
shopItemlist.Add(new int[] { replaceId, storeConfig.ItemCnt, 0 });
|
}
|
var extraItem = JsonMapper.ToObject<int[][]>(storeConfig.ItemListEx);
|
for (int i = 0; i < extraItem.Length; i++)
|
{
|
shopItemlist.Add(extraItem[i]);
|
}
|
return shopItemlist;
|
}
|
|
public bool TryGetShopItemInfo(StoreFunc _type, int _id, out List<ShopItemInfo> _shopItems)
|
{
|
_shopItems = null;
|
var _list = TryGetStoreDatas(_type);
|
var _index = _list.FindIndex((x) =>
|
{
|
return x.shopId == _id;
|
});
|
if (_index == -1)
|
{
|
return false;
|
}
|
_shopItems = GetShopItemlistByIndex(_list[_index].storeConfig);
|
return _shopItems != null;
|
}
|
|
|
#region 点击商店物品逻辑
|
public void OnClickShopCell(StoreConfig shopInfo)
|
{
|
int itemId = GetReplaceId(shopInfo.ID, shopInfo.ItemID);
|
ItemTipUtility.ShowGood(shopInfo.ID, itemId);
|
}
|
|
public int BuyCnt { get; private set; }
|
public void SetBuyCnt(int buyCnt)
|
{
|
BuyCnt = buyCnt;
|
}
|
|
#endregion
|
|
private ulong _price;
|
public void SendBuyShopItem(StoreConfig model, int count)
|
{
|
|
_price = (ulong)(model.MoneyNumber * count);
|
|
if (MoneyIsEnough(model.MoneyType, _price))
|
{
|
var vipLv = PlayerDatas.Instance.baseData.VIPLv;
|
var itemMinLv = model.VIPLV[0];
|
if (vipLv < itemMinLv)
|
{
|
SysNotifyMgr.Instance.ShowTip("VIPNotEnough", itemMinLv);
|
}
|
else
|
{
|
CA310_tagCMBuyItem buyShop = new CA310_tagCMBuyItem();
|
buyShop.BuyItemIndex = (ushort)model.ID;
|
buyShop.BuyCount = (uint)count;
|
GameNetSystem.Instance.SendInfo(buyShop);
|
}
|
}
|
else
|
{
|
switch (model.MoneyType)
|
{
|
case 1:
|
if (VersionConfig.Get().isBanShu)
|
{
|
SysNotifyMgr.Instance.ShowTip("GoldErr");
|
return;
|
}
|
// WindowCenter.Instance.Open<RechargeTipWin>();
|
break;
|
case 25:
|
SysNotifyMgr.Instance.ShowTip("LackXBMoney", model.MoneyType);
|
break;
|
default:
|
SysNotifyMgr.Instance.ShowTip("LackMoney", model.MoneyType);
|
break;
|
}
|
}
|
|
}
|
|
//仙玉购买物品的二次确认框，一级货币只有仙玉 默认为仙玉即可
|
Dictionary<int, bool> buyItemCheckDict = new Dictionary<int, bool>();
|
//type 对应枚举 BuyStoreItemCheckType 方便记忆
|
public void SendBuyShopItemWithPopCheck(StoreConfig model, int count, int type = 0)
|
{
|
if (model.MoneyNumber == 0)
|
{
|
//免费的
|
SendBuyShopItem(model, count);
|
return;
|
}
|
|
if (buyItemCheckDict.ContainsKey(type) && buyItemCheckDict[type])
|
{
|
SendBuyShopItem(model, count);
|
return;
|
}
|
|
ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), Language.Get("OSTimeLimitGiftConfirm", model.MoneyNumber),
|
Language.Get("ConfirmCancel102"), (Action<bool, bool>)((bool isOk, bool isToggle) =>
|
{
|
if (isOk)
|
{
|
SendBuyShopItem(model, count);
|
buyItemCheckDict[type] = isToggle;
|
}
|
|
}));
|
}
|
|
//花仙玉购买的二次确认框(本次登录) 默认提示 MysticalQG104 是否花费<color=#109d06>{0}</color>仙玉进行购买？
|
//type 对应枚举 BuyStoreItemCheckType 方便记忆
|
public void UseMoneyCheck(int money, Action func, int type = 0, string tip = "MysticalQG104", string fullTip = "")
|
{
|
if (money == 0)
|
{
|
//免费的
|
func?.Invoke();
|
return;
|
}
|
|
if (buyItemCheckDict.ContainsKey(type) && buyItemCheckDict[type])
|
{
|
func?.Invoke();
|
return;
|
}
|
|
ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), fullTip == "" ? Language.Get(tip, money) : fullTip,
|
Language.Get("ConfirmCancel102"), (bool isOk, bool isToggle) =>
|
{
|
if (isOk)
|
{
|
func?.Invoke();
|
buyItemCheckDict[type] = isToggle;
|
}
|
|
});
|
}
|
|
|
|
public event Action<int> RefreshBuyResultEvent;
|
|
public void GetBuyResult(HA811_tagMCShoppingResult result)
|
{
|
|
//Debug.Log("GetBuyResult");
|
StoreConfig tagStore = StoreConfig.Get((int)result.ItemIndex);
|
|
if (tagStore != null)
|
{
|
ItemConfig chinModel = ItemConfig.Get(GetReplaceId(tagStore.ID, tagStore.ItemID));
|
if (tagStore.RemindSuccess == 0)
|
{
|
return;
|
}
|
|
if (RefreshBuyResultEvent != null)
|
{
|
RefreshBuyResultEvent(chinModel.ID);
|
}
|
}
|
}
|
|
|
public bool MoneyIsEnough(int moneyType, ulong money)
|
{
|
if (UIHelper.GetMoneyCnt(moneyType) < money)
|
{
|
return false;
|
}
|
else
|
{
|
return true;
|
}
|
}
|
|
public int funcOrder { get; private set; }
|
public int jumpToItemId { get; set; }
|
|
/// <summary>
|
/// 会先清之前的跳转，调用者要注意 ClearJump
|
/// </summary>
|
/// <param name="itemId"></param>
|
public void SetJumpToModel(int itemId)
|
{
|
ClearJump();
|
jumpToItemId = itemId;
|
}
|
|
public void ClearJump()
|
{
|
funcOrder = -1;
|
jumpToItemId = 0;
|
}
|
|
public void SetWinOrder(int order)
|
{
|
funcOrder = order;
|
}
|
|
public void OpenStoreWin(bool forceSync = false, int functionOrder = 0, bool useJump = false)
|
{
|
if (useJump && funcOrder != -1)
|
{
|
// WindowCenter.Instance.Open<StoreWin>(forceSync, funcOrder);
|
}
|
else
|
{
|
ClearJump();
|
// WindowCenter.Instance.Open<StoreWin>(forceSync, functionOrder);
|
}
|
}
|
|
public event Action StoreFuncOpenAct;
|
|
private void FuncStateChange(int funcId)
|
{
|
switch ((FuncOpenEnum)funcId)
|
{
|
case FuncOpenEnum.Store:
|
if (StoreFuncOpenAct != null)
|
{
|
StoreFuncOpenAct();
|
}
|
UpdateFreeShopRedpoint();
|
UpdateCanBuyRedpoint();
|
UpdateMustBuyRedpoint();
|
UpdateDailyRedpoinit();
|
break;
|
case FuncOpenEnum.BlastFurnace:
|
ControllerRedPoint();
|
break;
|
}
|
}
|
|
public bool IsNewDay(string recordKey)
|
{
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return false;
|
|
if (PlayerPrefs.HasKey(recordKey))
|
{
|
int day = LocalSave.GetInt(recordKey);
|
if (day != TimeUtility.ServerNow.Day)
|
{
|
LocalSave.SetInt(recordKey, TimeUtility.ServerNow.Day);
|
return true;
|
}
|
else
|
{
|
return false;
|
}
|
}
|
else
|
{
|
LocalSave.SetInt(recordKey, TimeUtility.ServerNow.Day);
|
return true;
|
}
|
}
|
|
public bool IsRequireDailyRedRemind(int shopId)
|
{
|
var config = StoreConfig.Get(shopId);
|
if (config == null)
|
{
|
return false;
|
}
|
var key = StringUtility.Contact("Store_", config.ShopType, "_", "Daily", shopId);
|
var array = LocalSave.GetIntArray(key);
|
if (array != null && array.Length == 2)
|
{
|
if (array[0] < TimeUtility.Day - 1)
|
{
|
return true;
|
}
|
else if (array[0] == TimeUtility.Day - 1)
|
{
|
return array[1] < 5 || TimeUtility.Hour >= 5;
|
}
|
else if (array[0] == TimeUtility.Day)
|
{
|
return array[1] < 5 && TimeUtility.Hour >= 5;
|
}
|
}
|
return true;
|
}
|
|
public void SetDailyRedRedmind(int shopId)
|
{
|
var config = StoreConfig.Get(shopId);
|
if (config == null)
|
{
|
return;
|
}
|
var key = StringUtility.Contact("Store_", config.ShopType, "_", "Daily", shopId);
|
LocalSave.SetIntArray(key, new int[2] { TimeUtility.Day, TimeUtility.Hour });
|
UpdateDailyRedpoinit();
|
}
|
#region 商城红点
|
|
#region 仙盟红点逻辑处理
|
|
private bool CheckIsBuyNewItem(int fairyLv)
|
{
|
if (fairyLv > GetSaveFairyLV())
|
{
|
var toolStoreDatas = TryGetStoreDatasByLimit((int)StoreFunc.ToolStore, fairyLv);
|
var mountStoreDatas = TryGetStoreDatasByLimit((int)StoreFunc.MountStoneStore, fairyLv);
|
var skillBookStoreData = TryGetStoreDatasByLimit((int)StoreFunc.MountSkillBookStore, fairyLv);
|
if ((toolStoreDatas != null && toolStoreDatas.Count > 0)
|
|| (mountStoreDatas != null && mountStoreDatas.Count > 0)
|
|| (skillBookStoreData != null && skillBookStoreData.Count > 0))
|
{
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private bool CheckIsNewMonth()
|
{
|
GetSaveDateTime();
|
if (datelist.Count > 0)
|
{
|
if (TimeUtility.ServerNow.Month == datelist[0])
|
{
|
if (TimeUtility.ServerNow.Day >= 1
|
&& TimeUtility.ServerNow.Hour >= 5
|
&& datelist[1] <= 1 && datelist[2] < 5)
|
{
|
return true;
|
}
|
}
|
else
|
{
|
if (TimeUtility.ServerNow.Day >= 1
|
&& TimeUtility.ServerNow.Hour >= 5)
|
{
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
List<int> datelist = new List<int>();
|
public List<int> GetSaveDateTime()
|
{
|
datelist.Clear();
|
int[] unionArray = LocalSave.GetIntArray(UNIONSTORESAVE_KEY);
|
if (unionArray != null && unionArray.Length >= 4)
|
{
|
datelist.Add(unionArray[1]);
|
datelist.Add(unionArray[2]);
|
datelist.Add(unionArray[3]);
|
}
|
return datelist;
|
}
|
|
public int GetSaveFairyLV()
|
{
|
int[] unionArray = LocalSave.GetIntArray(UNIONSTORESAVE_KEY);
|
int fairyLv = 0;
|
if (unionArray != null)
|
{
|
return unionArray[0];
|
}
|
return fairyLv;
|
}
|
|
|
//1仙盟等级 2 月份 3 号 4 几点
|
public void SetStoreLocalSave(LocalSaveStoreType saveStoreType, params int[] infos)
|
{
|
string key = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, saveStoreType);
|
LocalSave.SetIntArray(key, infos);
|
}
|
|
public void ControllerRedPoint(bool isLook = false)
|
{
|
fairyStoreRemindRedpoint.state = RedPointState.None;
|
if (!FairyModel.Instance.fairyStoreOpen
|
|| !FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.BlastFurnace))
|
{
|
return;
|
}
|
|
int familyLv = PlayerDatas.Instance.fairyData.fairy.FamilyLV;
|
if (!isLook)
|
{
|
if (CheckIsBuyNewItem(familyLv))
|
{
|
fairyStoreRemindRedpoint.state = RedPointState.Simple;
|
return;
|
}
|
|
if (CheckIsNewMonth())
|
{
|
fairyStoreRemindRedpoint.state = RedPointState.Simple;
|
return;
|
}
|
}
|
|
SetStoreLocalSave(LocalSaveStoreType.UnionStore, familyLv, TimeUtility.ServerNow.Month,
|
TimeUtility.ServerNow.Day, TimeUtility.ServerNow.Hour);
|
}
|
|
#endregion
|
|
public const int StoreFunc_RedKey = 22;
|
public const int StoreFunc1_RedKey = 2201;
|
public const int StoreFunc2_RedKey = 2202;
|
public const int StoreFunc3_RedKey = 2203;
|
public const int StoreFunc4_RedKey = 2204;
|
public const int StoreFunc5_RedKey = 2205;
|
public const int StoreFunc8_RedKey = 2208;
|
public const int FairyStoreRemind_RedKey = 107010601;
|
public Redpoint storeFuncPoint = new Redpoint(StoreFunc_RedKey);
|
public Redpoint storeFunc1Point = new Redpoint(StoreFunc_RedKey, StoreFunc1_RedKey);
|
public Redpoint storeFunc2Point = new Redpoint(StoreFunc_RedKey, StoreFunc2_RedKey);
|
public Redpoint storeFunc3Point = new Redpoint(StoreFunc_RedKey, StoreFunc3_RedKey);
|
public Redpoint storeFunc4Point = new Redpoint(StoreFunc_RedKey, StoreFunc4_RedKey);
|
public Redpoint storeFunc5Point = new Redpoint(StoreFunc_RedKey, StoreFunc5_RedKey);
|
public Redpoint storeFunc8Point = new Redpoint(MainRedDot.FAIRYStore_REDPOINT_KEY3, StoreFunc8_RedKey);
|
public Redpoint fairyStoreRemindRedpoint = new Redpoint(MainRedDot.FAIRYStore_REDPOINT_KEY3, FairyStoreRemind_RedKey);
|
public Dictionary<int, Redpoint> shopRedDict = new Dictionary<int, Redpoint>();
|
public void SetShopRedpoint()
|
{
|
shopRedDict.Clear();
|
List<StoreConfig> storelist = StoreConfig.GetValues();
|
for (int i = 0; i < storelist.Count; i++)
|
{
|
StoreConfig storeConfig = storelist[i];
|
int redKey = 0;
|
Redpoint redpoint = null;
|
switch (storeConfig.ShopType)
|
{
|
//case 1:
|
// redKey = StoreFunc1_RedKey * 10000 + storeConfig.ID;
|
// redpoint = new Redpoint(StoreFunc1_RedKey, redKey);
|
// shopRedDict.Add(storeConfig.ID, redpoint);
|
// break;
|
//case 2:
|
// redKey = StoreFunc2_RedKey * 10000 + storeConfig.ID;
|
// redpoint = new Redpoint(StoreFunc2_RedKey, redKey);
|
// shopRedDict.Add(storeConfig.ID, redpoint);
|
// break;
|
//case 3:
|
// redKey = StoreFunc3_RedKey * 10000 + storeConfig.ID;
|
// redpoint = new Redpoint(StoreFunc3_RedKey, redKey);
|
// shopRedDict.Add(storeConfig.ID, redpoint);
|
// break;
|
//case 4:
|
// redKey = StoreFunc4_RedKey * 10000 + storeConfig.ID;
|
// redpoint = new Redpoint(StoreFunc4_RedKey, redKey);
|
// shopRedDict.Add(storeConfig.ID, redpoint);
|
// break;
|
//case 5:
|
// redKey = StoreFunc5_RedKey * 10000 + storeConfig.ID;
|
// redpoint = new Redpoint(StoreFunc5_RedKey, redKey);
|
// shopRedDict.Add(storeConfig.ID, redpoint);
|
// break;
|
case 8:
|
redKey = StoreFunc8_RedKey * 10000 + storeConfig.ID;
|
redpoint = new Redpoint(StoreFunc8_RedKey, redKey);
|
shopRedDict.Add(storeConfig.ID, redpoint);
|
break;
|
}
|
}
|
}
|
|
public void UpdateFreeShopRedpoint()
|
{
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return;
|
|
foreach (var key in showStoreTypeDict.Keys)
|
{
|
var storeDatas = showStoreTypeDict[key];
|
for (int i = 0; i < storeDatas.Count; i++)
|
{
|
var storeConfig = storeDatas[i].storeConfig;
|
int type = 0;
|
TryGetRedTypeByShopId(storeConfig.ID, out type);
|
if (type == 1)
|
{
|
int remainNum = 0;
|
if (shopRedDict.ContainsKey(storeConfig.ID))
|
{
|
if (!TryGetIsSellOut(storeConfig, out remainNum))
|
{
|
shopRedDict[storeConfig.ID].state = RedPointState.Simple;
|
}
|
else
|
{
|
shopRedDict[storeConfig.ID].state = RedPointState.None;
|
}
|
}
|
}
|
}
|
|
}
|
}
|
|
public void UpdateCanBuyRedpoint()
|
{
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return;
|
|
foreach (var key in showStoreTypeDict.Keys)
|
{
|
var storeDatas = showStoreTypeDict[key];
|
for (int i = 0; i < storeDatas.Count; i++)
|
{
|
var storeConfig = storeDatas[i].storeConfig;
|
int type = 0;
|
TryGetRedTypeByShopId(storeConfig.ID, out type);
|
if (type == 4)
|
{
|
int remainNum = 0;
|
if (shopRedDict.ContainsKey(storeConfig.ID))
|
{
|
if (!TryGetIsSellOut(storeConfig, out remainNum))
|
{
|
if (UIHelper.GetMoneyCnt(storeConfig.MoneyType) >= (ulong)storeConfig.MoneyNumber)
|
{
|
shopRedDict[storeConfig.ID].state = RedPointState.Simple;
|
}
|
else
|
{
|
shopRedDict[storeConfig.ID].state = RedPointState.None;
|
}
|
}
|
else
|
{
|
shopRedDict[storeConfig.ID].state = RedPointState.None;
|
}
|
|
}
|
}
|
}
|
|
}
|
}
|
|
public void UpdateMustBuyRedpoint()
|
{
|
if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return;
|
|
foreach (var key in showStoreTypeDict.Keys)
|
{
|
var storeDatas = showStoreTypeDict[key];
|
for (int i = 0; i < storeDatas.Count; i++)
|
{
|
var storeConfig = storeDatas[i].storeConfig;
|
int type = 0;
|
TryGetRedTypeByShopId(storeConfig.ID, out type);
|
if (type == 2)
|
{
|
if (shopRedDict.ContainsKey(storeConfig.ID))
|
{
|
if (CheckIsMustBuy(storeConfig))
|
{
|
shopRedDict[storeConfig.ID].state = RedPointState.Simple;
|
}
|
else
|
{
|
shopRedDict[storeConfig.ID].state = RedPointState.None;
|
}
|
}
|
}
|
}
|
|
}
|
}
|
|
public void UpdateDailyRedpoinit()
|
{
|
if (storeRedRuleDict.ContainsKey(6))
|
{
|
var shopIds = storeRedRuleDict[6];
|
var count = 0;
|
foreach (var shopId in shopIds)
|
{
|
var redable = false;
|
var config = StoreConfig.Get(shopId);
|
switch (config.ShopType)
|
{
|
case 8:
|
if (TryGetIsSellOut(config, out count))
|
{
|
break;
|
}
|
if (PlayerDatas.Instance.fairyData.fairy == null)
|
{
|
break;
|
}
|
if (config.VIPLV.Length > 0
|
&& PlayerDatas.Instance.baseData.VIPLv < config.VIPLV[0])
|
{
|
break;
|
}
|
if (PlayerDatas.Instance.fairyData.fairy.FamilyLV < config.LimitValue)
|
{
|
break;
|
}
|
if (!MoneyIsEnough(config.MoneyType, (ulong)config.MoneyNumber))
|
{
|
break;
|
}
|
redable = IsRequireDailyRedRemind(shopId);
|
break;
|
}
|
|
if (shopRedDict.ContainsKey(shopId))
|
{
|
shopRedDict[shopId].state = redable ? RedPointState.Simple : RedPointState.None;
|
}
|
}
|
}
|
}
|
|
|
|
|
public void ClearMustBuyRedpoint(StoreConfig storeConfig)
|
{
|
if (!shopRedDict.ContainsKey(storeConfig.ID))
|
return;
|
int type = 0;
|
TryGetRedTypeByShopId(storeConfig.ID, out type);
|
if (type == 2)
|
{
|
shopRedDict[storeConfig.ID].state = RedPointState.None;
|
IsMustBuyDay = false;
|
}
|
else if (type == 1)
|
{
|
shopRedDict[storeConfig.ID].state = RedPointState.None;
|
}
|
}
|
|
public bool IsMustBuyDay { get; private set; }
|
int[] saveTimes = new int[2];
|
public void SetIsMustBuyDay()
|
{
|
if (IsMustBuyDay) return;
|
|
saveTimes[0] = TimeUtility.ServerNow.Day;
|
saveTimes[1] = TimeUtility.ServerNow.Hour;
|
if (PlayerPrefs.HasKey(MUSTBUYSAVE_KEY))
|
{
|
int[] records = LocalSave.GetIntArray(MUSTBUYSAVE_KEY);
|
if (TimeUtility.ServerNow.Hour >= 5
|
&& ((TimeUtility.ServerNow.Day == records[0] && records[1] < 5)
|
|| TimeUtility.ServerNow.Day != records[0]))
|
{
|
IsMustBuyDay = true;
|
LocalSave.SetIntArray(MUSTBUYSAVE_KEY, saveTimes);
|
}
|
else
|
{
|
IsMustBuyDay = false;
|
}
|
}
|
else
|
{
|
IsMustBuyDay = true;
|
LocalSave.SetIntArray(MUSTBUYSAVE_KEY, saveTimes);
|
}
|
}
|
|
public bool CheckIsMustBuy(StoreConfig config)
|
{
|
int remainNum = 0;
|
if (!TryGetIsSellOut(config, out remainNum) && IsMustBuyDay)
|
{
|
return true;
|
}
|
return false;
|
}
|
|
|
public void ClearPetAndMountRedpoint(StoreConfig storeConfig)
|
{
|
ItemConfig itemConfig = ItemConfig.Get(storeConfig.ItemID);
|
switch (itemConfig.Type)
|
{
|
case 26:
|
case 41:
|
string key = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", storeConfig.ID);
|
if (shopRedDict.ContainsKey(storeConfig.ID) && shopRedDict[storeConfig.ID].state == RedPointState.Simple)
|
{
|
shopRedDict[storeConfig.ID].state = RedPointState.None;
|
LocalSave.SetBool(key, false);
|
}
|
break;
|
}
|
}
|
|
public void ClearAllPetAndMountRedpoint(StoreFunc storeFunc)
|
{
|
if (storeFuncType == StoreFunc.BindStore && storeFunc != StoreFunc.BindStore)
|
{
|
foreach (var key in shopRedDict.Keys)
|
{
|
StoreConfig storeConfig = StoreConfig.Get(key);
|
ItemConfig itemConfig = ItemConfig.Get(storeConfig.ItemID);
|
switch (itemConfig.Type)
|
{
|
case 26:
|
case 41:
|
if (shopRedDict.ContainsKey(key) && shopRedDict[key].state != RedPointState.None)
|
{
|
string record = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", key);
|
shopRedDict[key].state = RedPointState.None;
|
LocalSave.SetBool(record, false);
|
}
|
break;
|
}
|
|
}
|
}
|
|
}
|
|
public void CloseRedPoint(StoreConfig storeConfig)
|
{
|
ClearMustBuyRedpoint(storeConfig);
|
ClearPetAndMountRedpoint(storeConfig);
|
}
|
|
public void CloseAllRedpoint(StoreFunc storeFunc)
|
{
|
ClearAllPetAndMountRedpoint(storeFunc);
|
}
|
#endregion
|
|
|
|
|
}
|
|
public enum StoreFunc
|
{
|
DayStore = 1, //1：每天限购
|
CommonStore = 2, //2：幻境阁商店
|
GrowStrongerStore = 3, //3：成长变强
|
BindStore = 4, //4：绑玉商城
|
IntegralStore = 5, //5：积分商城
|
BagStore = 6, //6:随身商店
|
RuneStore = 7, //7：符印商店
|
ToolStore = 8, // 道具商店
|
MountStoneStore = 9, //坐骑魂石商店
|
MountSkillBookStore = 10,//坐骑技能书商店
|
XBEquipStore = 11, //寻宝装备商店
|
XBRuneStore = 12, //寻宝符印商店
|
XBToolStore = 13, //寻宝道具商店
|
OSGift = 14,//开服礼包
|
OSTimeLimitGift = 15,//限时特惠
|
CrossOneVsOneHonor = 17,//荣誉商店
|
MysteryStore = 18, //1：神秘商店
|
default1,
|
default2, //时间类活动 - 如boss凭证的商店 20
|
default3,
|
QCTrainActStore = 306, //骑宠养成活动商店
|
CelestialPalaceStore = 308, //仙宫商店（天道阁）
|
}
|
|
public enum LocalSaveStoreType
|
{
|
UnionStore, //仙盟商店
|
|
}
|
|
