1012 lines
21 KiB
C#
1012 lines
21 KiB
C#
// ***********************************************************************
|
|
// Assembly : Game
|
|
// Author : Kimch
|
|
// Created : 2021-11-15
|
|
// Description :
|
|
// Last Modified By :
|
|
// Last Modified On :
|
|
// ***********************************************************************
|
|
// <copyright file= "SwordProxy" company="Kunpo"></copyright>
|
|
// <summary></summary>
|
|
// ***********************************************************************
|
|
|
|
using CodeStage.AntiCheat.ObscuredTypes;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
namespace G
|
|
{
|
|
/// <summary>
|
|
/// 剑阁
|
|
/// </summary>
|
|
public class SwordProxy : F.GameProxy
|
|
{
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public class SwordInfo
|
|
{
|
|
public readonly ItemSword item;
|
|
public int id => item.id;
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public readonly List<CombatAttribute> attributes = new List<CombatAttribute>(2);
|
|
|
|
private ObscuredInt _grade = 0;
|
|
/// <summary>
|
|
/// 等级
|
|
/// </summary>
|
|
public int grade
|
|
{
|
|
get { return _grade; }
|
|
private set
|
|
{
|
|
if (value <= gradeMax && value != grade)
|
|
{
|
|
_grade = value;
|
|
|
|
attributes.Clear();
|
|
var gradeItem = ItemProxy.Instance.GetStaticItem<ItemSwordGrade>(value);
|
|
if (gradeItem != null)
|
|
{
|
|
int[][] sources = null;
|
|
switch (id)
|
|
{
|
|
case 1:
|
|
sources = gradeItem.attributes1;
|
|
break;
|
|
case 2:
|
|
sources = gradeItem.attributes2;
|
|
break;
|
|
case 3:
|
|
sources = gradeItem.attributes3;
|
|
break;
|
|
case 4:
|
|
sources = gradeItem.attributes4;
|
|
break;
|
|
case 5:
|
|
sources = gradeItem.attributes5;
|
|
break;
|
|
}
|
|
if (sources != null)
|
|
for (int i = 0; i < sources.Length; i++)
|
|
{
|
|
attributes.Add(new CombatAttribute
|
|
{
|
|
id = (CombatAttributeId)sources[i][0],
|
|
value = sources[i][1],
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 等级上限
|
|
/// </summary>
|
|
public int gradeMax
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public bool isMaxGrade => grade >= gradeMax;
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public bool isUnlock
|
|
{
|
|
get
|
|
{
|
|
if (grade == 0 && item.unlock > 0)
|
|
{
|
|
var mission = MissionProxy.Instance.GetMission(item.unlock);
|
|
if (mission != null && mission.isCompleted)
|
|
{
|
|
grade = 1;
|
|
Instance.UpdateAttributes(true);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool CheckUnlock(bool updateAttributes)
|
|
{
|
|
if (grade == 0 && item.unlock > 0)
|
|
{
|
|
var mission = MissionProxy.Instance.GetMission(item.unlock);
|
|
if (mission != null && mission.isCompleted)
|
|
{
|
|
grade = 1;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public string unlockText
|
|
{
|
|
get
|
|
{
|
|
var mission = MissionProxy.Instance.GetMission(item.unlock);
|
|
return mission != null ? mission.description : default;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public int combatValue
|
|
{
|
|
get
|
|
{
|
|
return item.combatValue[0] + item.combatValue[1] * this.grade;
|
|
}
|
|
}
|
|
|
|
Item.ItemInfo _firstCostInfo;
|
|
ObscuredInt _costAddition;
|
|
|
|
public Item.ItemInfo upgradeCost
|
|
{
|
|
get
|
|
{
|
|
var result = _firstCostInfo;
|
|
if (this.grade > 0)
|
|
result.count += (this.grade - 1) * _costAddition;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public int status
|
|
{
|
|
get { return this.grade; }
|
|
set { this.grade = value; }
|
|
}
|
|
|
|
public SwordInfo(ItemSword swordItem)
|
|
{
|
|
this.item = swordItem;
|
|
this.gradeMax = swordItem.gradeMax;
|
|
if (swordItem.upgradeCost != null && swordItem.upgradeCost.Length > 2)
|
|
{
|
|
_firstCostInfo = Item.ItemInfo.Convert(swordItem.upgradeCost);
|
|
_costAddition = swordItem.upgradeCost[2];
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool CheckUpgrade()
|
|
{
|
|
return this.grade > 0 && grade < gradeMax;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int Upgrade()
|
|
{
|
|
if (grade > 0 && grade < gradeMax)
|
|
{
|
|
grade++;
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="results"></param>
|
|
/// <returns></returns>
|
|
public int GetAttributes(List<CombatAttribute> results)
|
|
{
|
|
if (grade > 0)
|
|
{
|
|
for (int i = 0; i < attributes.Count; i++)
|
|
{
|
|
var attr = attributes[i];
|
|
results.Add(attr);
|
|
}
|
|
}
|
|
return this.combatValue;
|
|
}
|
|
}
|
|
|
|
#region Field
|
|
|
|
private ItemSwordTitle _curTitle;
|
|
private ItemSwordTitle _studyTitle;
|
|
private readonly int[] _studyStars = new int[4];
|
|
private int _studyTitleCombatValue;
|
|
|
|
readonly Dictionary<int, SwordInfo> _swordInfos = new Dictionary<int, SwordInfo>(5);
|
|
|
|
ObscuredInt _swordLevel;
|
|
ObscuredInt _rewardTimestamp;
|
|
Item.ItemInfo _minuteReward;
|
|
|
|
#endregion
|
|
|
|
#region Property
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public int swordLevel
|
|
{
|
|
get { return _swordLevel; }
|
|
private set
|
|
{
|
|
_swordLevel = value;
|
|
var item = ItemProxy.Instance.GetStaticItem<ItemSwordLevel>(value);
|
|
if (item != null)
|
|
{
|
|
_minuteReward = item.stationRewardInfos;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public int swordLevelMax => 1000;
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public ItemSwordLevel swordLevelItem
|
|
{
|
|
get => ItemProxy.Instance.GetStaticItem<ItemSwordLevel>(swordLevel);
|
|
}
|
|
|
|
public Item.ItemInfo completedReward
|
|
{
|
|
get
|
|
{
|
|
var swordLevelItem = ItemProxy.Instance.GetStaticItem<ItemSwordLevel>(Mathf.Clamp(swordLevel, 1, swordLevelMax));
|
|
if (swordLevelItem != null)
|
|
{
|
|
return swordLevelItem.completedRewardInfos;
|
|
}
|
|
return default;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 累计分钟数
|
|
/// </summary>
|
|
public int accumMinute => Mathf.Clamp((Launch.Timestamp - rewardTimestamp) / 60, 0, totalMinute);
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public int totalMinute => 1440;
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public int intervalMinute => 1;
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public bool isFullReward => accumMinute >= totalMinute;
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public bool isHalfReward => accumMinute >= (totalMinute / 2);
|
|
|
|
public int rewardTimestamp
|
|
{
|
|
get { return _rewardTimestamp; }
|
|
set
|
|
{
|
|
_rewardTimestamp = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public Item.ItemInfo minuteRewards
|
|
{
|
|
get { return _minuteReward; }
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public Item.ItemInfo adRewards
|
|
{
|
|
get
|
|
{
|
|
var result = _minuteReward;
|
|
result.count *= 480;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Method
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public ItemSwordTitle GetTitle()
|
|
{
|
|
if (_curTitle == null)
|
|
{
|
|
SetTitle(1, true);
|
|
}
|
|
return _curTitle;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public ItemSwordTitle GetStudyTitle()
|
|
{
|
|
return _studyTitle;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public ItemSwordTitle SetStudyTitle()
|
|
{
|
|
var titles = ItemProxy.Instance.GetStaticItems<ItemSwordTitle>();
|
|
for (int i = 0; i < titles.Count; i++)
|
|
{
|
|
var title = titles[i];
|
|
if (title.studyAdd != null && title.studyAdd.Length > 0)
|
|
{
|
|
_studyTitle = title;
|
|
return _studyTitle;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <param name="save"></param>
|
|
public void SetTitle(int id, bool save = true)
|
|
{
|
|
if (id > 0 && (_curTitle == null || _curTitle.id < id))
|
|
{
|
|
_curTitle = ItemProxy.Instance.GetStaticItem<ItemSwordTitle>(id);
|
|
|
|
if (save)
|
|
{
|
|
UpdateAttributes(true);
|
|
SaveSword();
|
|
MissionProxy.Instance.OnEvent2(MissionProxy.境界达到X级, id);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 突破
|
|
/// </summary>
|
|
public void UpTitle()
|
|
{
|
|
var currTitle = GetTitle();
|
|
if (currTitle != null && currTitle.isCompleted && currTitle.nextTitle != null)
|
|
{
|
|
currTitle = currTitle.nextTitle;
|
|
}
|
|
SetTitle(currTitle.id, true);
|
|
}
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int[] GetStudyStar()
|
|
{
|
|
return _studyStars;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int StudyTitle()
|
|
{
|
|
int max = 0;
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (_studyStars[i] < 10)
|
|
{
|
|
max++;
|
|
}
|
|
}
|
|
|
|
if (max > 0)
|
|
{
|
|
int r = Random.Range(0, max);
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (_studyStars[i] < 10)
|
|
{
|
|
r -= 1;
|
|
if (r < 0)
|
|
{
|
|
_studyStars[i] += 1;
|
|
if (Random.value < GlobalVar.TitleStudyDouble)
|
|
{
|
|
SaveSword();
|
|
UpdateAttributes(true);
|
|
MissionProxy.Instance.OnEvent(MissionProxy.累计境界修炼X次);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SaveSword();
|
|
UpdateAttributes(true);
|
|
MissionProxy.Instance.OnEvent(MissionProxy.累计境界修炼X次);
|
|
return 2;
|
|
}
|
|
else
|
|
{
|
|
if (_studyTitle.id < _curTitle.id)
|
|
{
|
|
_studyTitle = _studyTitle.nextTitle;
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
_studyStars[i] = 0;
|
|
}
|
|
UpdateAttributes(true);
|
|
SaveSword();
|
|
return 3;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public int GetTitleCombatValue()
|
|
{
|
|
return PlayerProxy.Instance.GetCombatValue(PlayerProxy.ATTRIBUTES_INDEX_TITLE);
|
|
}
|
|
|
|
public int GetStudyCombatValue()
|
|
{
|
|
return _studyTitleCombatValue;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int GetTitleRedPoint()
|
|
{
|
|
var unlocked = FunctionProxy.Instance.GetFunctionUnlock(FunctionProxy.FunctionId.Jingjie);
|
|
if (unlocked)
|
|
{
|
|
var currTitle = GetTitle();
|
|
if (currTitle != null && currTitle.rewardMissionCount > 0)
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private void UpdateAttributes(bool sendNotification)
|
|
{
|
|
int combatValue = 0;
|
|
|
|
var results = F.ListPool<CombatAttribute>.Get();
|
|
if (_curTitle != null)
|
|
{
|
|
CombatAttribute.Convert(_curTitle.attributes, results);
|
|
combatValue += _curTitle.combatValue;
|
|
}
|
|
|
|
_studyTitleCombatValue = 0;
|
|
if (_studyTitle != null)
|
|
{
|
|
_studyTitleCombatValue = _studyTitle.studyCombatValue;
|
|
|
|
var studyAttributes = F.ListPool<CombatAttribute>.Get();
|
|
CombatAttribute.Convert(_studyTitle.attributes, studyAttributes);
|
|
for (int j = 0; j < studyAttributes.Count; j++)
|
|
{
|
|
var attr = studyAttributes[j];
|
|
attr.value = attr.value * _studyTitle.studyAdd[_studyStars[j]] / 100;
|
|
results.Add(attr);
|
|
_studyTitleCombatValue += _studyStars[j] * _studyTitle.starCombatValue;
|
|
}
|
|
|
|
combatValue += _studyTitleCombatValue;
|
|
F.ListPool<CombatAttribute>.Release(studyAttributes);
|
|
}
|
|
|
|
foreach (var item in _swordInfos.Values)
|
|
{
|
|
if (item.CheckUnlock(false))
|
|
{
|
|
item.GetAttributes(results);
|
|
combatValue += item.combatValue;
|
|
}
|
|
}
|
|
|
|
PlayerProxy.Instance.UpdateTitleCombatValue(results, combatValue, sendNotification);
|
|
F.ListPool<CombatAttribute>.Release(results);
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region Method
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
/// <param name="sendNotification"></param>
|
|
public void SetSwordLevel(int value, bool sendNotification)
|
|
{
|
|
if (swordLevel < value && value <= swordLevelMax)
|
|
{
|
|
if (swordLevel <= 0)
|
|
{
|
|
rewardTimestamp = Launch.Timestamp;
|
|
}
|
|
|
|
int count = 0;
|
|
for (int i = Mathf.Max(1, swordLevel); i < value; i++)
|
|
{
|
|
var item = ItemProxy.Instance.GetStaticItem<ItemSwordLevel>(i);
|
|
if (item != null)
|
|
{
|
|
count += item.completedRewardInfos.count;
|
|
if (_settleRewards.id == 0)
|
|
_settleRewards.id = item.completedRewardInfos.id;
|
|
}
|
|
}
|
|
|
|
if (count > 0)
|
|
{
|
|
_settleRewards.count += count;
|
|
MoneyProxy.Instance.AddMoney(_settleRewards.id, count);
|
|
}
|
|
|
|
swordLevel = value;
|
|
SaveSword();
|
|
|
|
//
|
|
var curTitle = GetTitle();
|
|
if (curTitle != null && curTitle.isCompleted)
|
|
{
|
|
UpTitle();
|
|
}
|
|
|
|
MissionProxy.Instance.OnEvent2(MissionProxy.剑阁达到层数, value);
|
|
}
|
|
}
|
|
|
|
Item.ItemInfo _settleRewards;
|
|
/// <summary>
|
|
/// 结算显示的奖励
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public Item.ItemInfo GetSettleRewards()
|
|
{
|
|
var result = _settleRewards;
|
|
if (result.count > 0)
|
|
RankingProxy.Instance.UploadSwordRanking(swordLevel);
|
|
_settleRewards.count = 0;
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
public SwordInfo GetSwordInfo(int id)
|
|
{
|
|
_swordInfos.TryGetValue(id, out var result);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获得累计收益
|
|
/// </summary>
|
|
/// <param name="callback"></param>
|
|
public void GetAccumulateGains(Callback2 callback)
|
|
{
|
|
int accum = this.accumMinute;
|
|
if (accum > 0)
|
|
{
|
|
var reward = minuteRewards;
|
|
float addition = 1f;
|
|
reward.count = (int)(reward.count * accum * addition);
|
|
rewardTimestamp = Launch.Timestamp;
|
|
|
|
SaveSword();
|
|
RewardProxy.Instance.GetRewardWithUI(reward, (error, message) =>
|
|
{
|
|
callback(error, "");
|
|
});
|
|
}
|
|
else
|
|
{
|
|
callback?.Invoke(1, "还没有收益");
|
|
}
|
|
|
|
//if (beauty != null)
|
|
//{
|
|
// addition += beauty.businessFactor * 0.01f;
|
|
//}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获得广告收益
|
|
/// </summary>
|
|
/// <param name="callback"></param>
|
|
public void GetAdGains(Callback2 callback)
|
|
{
|
|
if (TimeProxy.Instance.CheckTimes(TimeProxy.剑阁广告次数))
|
|
{
|
|
var timeInfo = TimeProxy.Instance.GetTimeInfo2(TimeProxy.剑阁广告次数);
|
|
if (timeInfo.remain == timeInfo.max)
|
|
{
|
|
TimeProxy.Instance.CostTimes(TimeProxy.剑阁广告次数);
|
|
|
|
var reward = minuteRewards;
|
|
float addition = 1f;
|
|
reward.count = (int)(reward.count * 480f * addition);
|
|
RewardProxy.Instance.GetRewardWithUI(reward, (err, msg) =>
|
|
{
|
|
callback(err, msg);
|
|
});
|
|
return;
|
|
}
|
|
|
|
AdProxy.Instance.PlayAd("sword", "ads_gains",
|
|
(error, message) =>
|
|
{
|
|
if (error == 0)
|
|
{
|
|
TimeProxy.Instance.CostTimes(TimeProxy.剑阁广告次数);
|
|
|
|
var reward = minuteRewards;
|
|
float addition = 1f;
|
|
reward.count = (int)(reward.count * 480f * addition);
|
|
RewardProxy.Instance.GetRewardWithUI(reward, (err, msg) =>
|
|
{
|
|
callback(err, msg);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
callback(error, message);
|
|
}
|
|
});
|
|
}
|
|
else
|
|
{
|
|
callback(1, "广告次数不足,请明日再来");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <param name="callback"></param>
|
|
public void UpgradeSword(int id, Callback2 callback)
|
|
{
|
|
if (_swordInfos.TryGetValue(id, out var swordInfo))
|
|
{
|
|
if (swordInfo.CheckUpgrade())
|
|
{
|
|
if (MoneyProxy.Instance.CheckAndCostMoney(swordInfo.upgradeCost))
|
|
{
|
|
swordInfo.Upgrade();
|
|
SaveSword();
|
|
|
|
UpdateAttributes(true);
|
|
callback(0, "");
|
|
}
|
|
else
|
|
{
|
|
callback(1, KLocalization.GetLocalString(87));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
callback(1, "已满级");
|
|
}
|
|
}
|
|
}
|
|
|
|
public int QuickBattle()
|
|
{
|
|
int battleForce = 0;
|
|
var currSwordLevelItem = this.swordLevelItem;
|
|
if (currSwordLevelItem != null)
|
|
battleForce = currSwordLevelItem.requirementCV;
|
|
|
|
int targetForce = PlayerProxy.Instance.combatValue - 200000;
|
|
int quickLevel = 0;
|
|
if (targetForce < 7000000)
|
|
quickLevel = targetForce / 10000;
|
|
else
|
|
{
|
|
var swordLevels = ItemProxy.Instance.GetStaticItems<ItemSwordLevel>();
|
|
for (int i = swordLevels.Count - 1; i >= 0; i--)
|
|
{
|
|
if (swordLevels[i].requirementCV < targetForce)
|
|
{
|
|
quickLevel = swordLevels[i].id;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
quickLevel = Mathf.Min(quickLevel, 1000);
|
|
|
|
int result = quickLevel - this.swordLevel;
|
|
if (result > 0)
|
|
{
|
|
SetSwordLevel(quickLevel, true);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 开始战斗
|
|
/// </summary>
|
|
/// <param name="callback"></param>
|
|
public void StartBattle(Callback2 callback)
|
|
{
|
|
LevelProxy.Instance.StartClimb(this.swordLevel);
|
|
callback?.Invoke(0, "");
|
|
}
|
|
|
|
void InitSword()
|
|
{
|
|
_curTitle = null;
|
|
_studyTitle = null;
|
|
for (int i = 0; i < _studyStars.Length; i++)
|
|
{
|
|
_studyStars[i] = 0;
|
|
}
|
|
_studyTitleCombatValue = 0;
|
|
|
|
_rewardTimestamp = Launch.Timestamp;
|
|
_swordLevel = 0;
|
|
_swordInfos.Clear();
|
|
var swordItems = ItemProxy.Instance.GetStaticItems<ItemSword>();
|
|
if (swordItems != null)
|
|
for (int i = 0; i < swordItems.Count; i++)
|
|
{
|
|
var swordItem = swordItems[i];
|
|
_swordInfos.Add(swordItem.id, new SwordInfo(swordItem));
|
|
}
|
|
}
|
|
|
|
const string ARCHIVE_KEY_V1 = "sword_v1";
|
|
const string ARCHIVE_KEY_V2 = "sword_v2";
|
|
|
|
void LoadSword()
|
|
{
|
|
var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V2);
|
|
if (dataList != null && dataList.Count > 0)
|
|
{
|
|
int index = 0;
|
|
int titleId = Mathf.Max(1, dataList.SafeGet(index++));
|
|
|
|
SetTitle(titleId, false);
|
|
|
|
titleId = dataList.SafeGet(index++);
|
|
_studyTitle = ItemProxy.Instance.GetStaticItem<ItemSwordTitle>(titleId);
|
|
for (int i = 0; i < _studyStars.Length; i++)
|
|
{
|
|
_studyStars[i] = dataList.SafeGet(index++);
|
|
}
|
|
|
|
swordLevel = dataList[index++];
|
|
if (swordLevel > 0)
|
|
{
|
|
//MissionProxy.Instance.OnEvent2(MissionProxy.剑阁达到层数, swordLevel);
|
|
}
|
|
_rewardTimestamp = dataList[index++];
|
|
if (_rewardTimestamp <= 0)
|
|
{
|
|
_rewardTimestamp = Launch.Timestamp;
|
|
}
|
|
|
|
int count = dataList[index++];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
int id = dataList[index++];
|
|
int status = dataList[index++];
|
|
if (_swordInfos.TryGetValue(id, out var swordInfo))
|
|
{
|
|
swordInfo.status = status;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V1);
|
|
if (dataList != null && dataList.Count > 0)
|
|
{
|
|
int index = 0;
|
|
int titleId = Mathf.Max(1, dataList.SafeGet(index++));
|
|
|
|
SetTitle(titleId, false);
|
|
|
|
titleId = dataList.SafeGet(index++);
|
|
_studyTitle = ItemProxy.Instance.GetStaticItem<ItemSwordTitle>(titleId);
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
_studyStars[i] = dataList.SafeGet(index++);
|
|
}
|
|
|
|
swordLevel = dataList[index++];
|
|
if (swordLevel > 0)
|
|
{
|
|
//MissionProxy.Instance.OnEvent2(MissionProxy.剑阁达到层数, swordLevel);
|
|
}
|
|
_rewardTimestamp = dataList[index++];
|
|
if (_rewardTimestamp <= 0)
|
|
{
|
|
_rewardTimestamp = Launch.Timestamp;
|
|
}
|
|
|
|
int count = dataList[index++];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
int id = dataList[index++];
|
|
int status = dataList[index++];
|
|
if (_swordInfos.TryGetValue(id, out var swordInfo))
|
|
{
|
|
swordInfo.status = status;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dataList = ArchiveProxy.Instance.GetIntList(TITLE_KEY_V1);
|
|
if (dataList != null && dataList.Count > 0)
|
|
{
|
|
int index = 0;
|
|
int titleId = Mathf.Max(1, dataList.SafeGet(index++));
|
|
|
|
SetTitle(titleId, false);
|
|
|
|
titleId = dataList.SafeGet(index++);
|
|
_studyTitle = ItemProxy.Instance.GetStaticItem<ItemSwordTitle>(titleId);
|
|
for (int i = 0; i < _studyStars.Length; i++)
|
|
{
|
|
_studyStars[i] = dataList.SafeGet(index++);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SaveSword()
|
|
{
|
|
var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V2);
|
|
if (dataList != null)
|
|
{
|
|
dataList.Clear();
|
|
|
|
dataList.Add(_curTitle != null ? _curTitle.id : 0);
|
|
dataList.Add(_studyTitle != null ? _studyTitle.id : 0);
|
|
for (int i = 0; i < _studyStars.Length; i++)
|
|
{
|
|
dataList.Add(_studyStars[i]);
|
|
}
|
|
|
|
dataList.Add(this.swordLevel);
|
|
dataList.Add(_rewardTimestamp);
|
|
|
|
dataList.Add(_swordInfos.Count);
|
|
foreach (var item in _swordInfos)
|
|
{
|
|
dataList.Add(item.Key);
|
|
dataList.Add(item.Value.status);
|
|
}
|
|
|
|
ArchiveProxy.Instance.SetIntList(ARCHIVE_KEY_V2, dataList);
|
|
}
|
|
|
|
ArchiveProxy.Instance.RemoveIntList(ARCHIVE_KEY_V1);
|
|
ArchiveProxy.Instance.RemoveIntList(TITLE_KEY_V1);
|
|
}
|
|
|
|
private const string TITLE_KEY_V1 = "title";
|
|
|
|
#endregion
|
|
|
|
#region Proxy && Unity
|
|
|
|
public static SwordProxy Instance => GetInstance<SwordProxy>();
|
|
|
|
public override void ReadArchive()
|
|
{
|
|
InitSword();
|
|
LoadSword();
|
|
|
|
UpdateAttributes(false);
|
|
}
|
|
|
|
//private void OnEnable()
|
|
//{
|
|
// RegisterCommand();
|
|
//}
|
|
|
|
//private void OnDisable()
|
|
//{
|
|
// UnregisterCommand();
|
|
//}
|
|
|
|
#endregion
|
|
|
|
#region COMMAND
|
|
|
|
//public void RegisterCommand()
|
|
//{
|
|
// GameCommand.Register(GlobalDefine.EVENT_MISSION_CHANGED, TitleMissionCommand.CreateCommand);
|
|
//}
|
|
|
|
//public void UnregisterCommand()
|
|
//{
|
|
// GameCommand.Unregister(GlobalDefine.EVENT_MISSION_CHANGED);
|
|
//}
|
|
|
|
//private class TitleMissionCommand : GameCommand
|
|
//{
|
|
// public override void Execute(INotification notification)
|
|
// {
|
|
// if (notification.Name == GlobalDefine.EVENT_MISSION_CHANGED)
|
|
// {
|
|
// var curTitle = Instance.GetTitle();
|
|
// if (curTitle != null)
|
|
// {
|
|
// //达到
|
|
// MissionProxy.Instance.OnEvent2(MissionProxy.境界系统任务完成X次, curTitle.completedMissionCount, curTitle.id);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// static readonly TitleMissionCommand _Default = new TitleMissionCommand();
|
|
// public static TitleMissionCommand CreateCommand()
|
|
// {
|
|
// return _Default;
|
|
// }
|
|
//}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|