1762 lines
55 KiB
C#
1762 lines
55 KiB
C#
// ***********************************************************************
|
|
// Assembly : Unity
|
|
// Author : Kimch
|
|
// Created : 2019-06-05
|
|
// Description :
|
|
// Last Modified By :
|
|
// Last Modified On :
|
|
// ***********************************************************************
|
|
// <copyright file= "PlayerProxy" company="Kunpo"></copyright>
|
|
// <summary></summary>
|
|
// ***********************************************************************
|
|
using CodeStage.AntiCheat.ObscuredTypes;
|
|
using F;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
namespace G
|
|
{
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
partial class PlayerProxy
|
|
{
|
|
#region 角色装备
|
|
|
|
/// <summary>
|
|
/// 装备槽
|
|
/// </summary>
|
|
public class EquipmentSlotInfo
|
|
{
|
|
public readonly int id;
|
|
|
|
#region Grade
|
|
|
|
|
|
private ObscuredInt _grade;
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public int grade
|
|
{
|
|
get { return _grade; }
|
|
set { _grade = value; }
|
|
}
|
|
|
|
public int maxGrade
|
|
{
|
|
get { return curEquipment != null ? curEquipment.level + 9 : 0; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// 强化战力
|
|
/// </summary>
|
|
public int gradeCombatValue
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
public void SetGrade(int value)
|
|
{
|
|
grade = value;
|
|
if (curEquipment != null)
|
|
{
|
|
gradeCombatValue = curEquipment.SetGrade(this.grade, upgradeAttributes);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Suit
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
private ObscuredInt _slotSuitGrade;
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public int slotSuitGrade
|
|
{
|
|
get { return _slotSuitGrade; }
|
|
set { _slotSuitGrade = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="value"></param>
|
|
public void SetSlotSuitGrade(int value)
|
|
{
|
|
slotSuitGrade = value;
|
|
}
|
|
|
|
public ItemSuit slotSuitItem
|
|
{
|
|
get { return ItemProxy.Instance.GetStaticItem<ItemSuit>(1); }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Gem
|
|
|
|
public const int MAX_GEM_COUNT = 3;
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public readonly EntityItemGem[] gems = new EntityItemGem[MAX_GEM_COUNT];
|
|
|
|
/// <summary>
|
|
/// 宝石开启
|
|
/// </summary>
|
|
public bool gemEnabled
|
|
{
|
|
get { return this.equipment != null; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// 最大可镶嵌宝石数量
|
|
/// </summary>
|
|
public int setGemCountMax
|
|
{
|
|
get
|
|
{
|
|
int tmpGrade = this.grade;
|
|
if (tmpGrade >= 80)
|
|
{
|
|
return 3;
|
|
}
|
|
else if (tmpGrade >= 60)
|
|
{
|
|
return 2;
|
|
}
|
|
else if (tmpGrade >= 40)
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
public int GetGemUnlockGrade(int index)
|
|
{
|
|
if (index == 1)
|
|
{
|
|
return 40;
|
|
}
|
|
else if (index == 2)
|
|
{
|
|
return 60;
|
|
}
|
|
else if (index == 3)
|
|
{
|
|
return 80;
|
|
}
|
|
else
|
|
{
|
|
return 40;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <returns></returns>
|
|
public EntityItemGem GetGem(int index)
|
|
{
|
|
if (index >= 0 & index < MAX_GEM_COUNT)
|
|
{
|
|
return gems[index];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="gemId"></param>
|
|
/// <returns></returns>
|
|
public bool SetGem(int index, int gemId)
|
|
{
|
|
if (gemId > 0 && index < MAX_GEM_COUNT)
|
|
{
|
|
gems[index] = ItemProxy.Instance.NewTemporaryGem(gemId);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public EntityItemEquipment curEquipment;
|
|
/// <summary>
|
|
/// 试用装备
|
|
/// </summary>
|
|
public EntityItemEquipment tryEquipment;
|
|
|
|
/// <summary>
|
|
/// 升级属性
|
|
/// </summary>
|
|
public readonly List<CombatAttribute> upgradeAttributes = new List<CombatAttribute>(1);
|
|
|
|
public int equipmentId
|
|
{
|
|
get { return curEquipment != null ? curEquipment.id : 0; }
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public EntityItemEquipment equipment
|
|
{
|
|
get { return tryEquipment ?? curEquipment; }
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="equipment"></param>
|
|
/// <returns></returns>
|
|
public bool IsSetEquipment(EntityItemEquipment equipment)
|
|
{
|
|
return equipmentId == equipment.id;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="equipment"></param>
|
|
/// <returns></returns>
|
|
public bool SetEquipment(EntityItemEquipment equipment)
|
|
{
|
|
if (equipment.id == this.equipmentId)
|
|
{
|
|
return false;
|
|
}
|
|
curEquipment = equipment;
|
|
if (curEquipment != null)
|
|
{
|
|
curEquipment.SetGrade(this.grade, upgradeAttributes);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="equipmentId"></param>
|
|
/// <returns></returns>
|
|
public bool SetEquipment(int equipmentId)
|
|
{
|
|
if (this.equipmentId == equipmentId)
|
|
{
|
|
return false;
|
|
}
|
|
curEquipment = ItemProxy.Instance.GetEquipment(equipmentId);
|
|
if (curEquipment != null)
|
|
{
|
|
gradeCombatValue = curEquipment.SetGrade(this.grade, upgradeAttributes);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public EquipmentSlotInfo(int id)
|
|
{
|
|
this.id = id;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="results"></param>
|
|
/// <returns></returns>
|
|
public int GetAttributes(List<CombatAttribute> results)
|
|
{
|
|
int resultCombatValue = 0;
|
|
var tmp = this.equipment;
|
|
if (tmp != null)
|
|
{
|
|
results.Add(tmp.basicAttribute);
|
|
results.AddRange(tmp.extraAttributes);
|
|
results.AddRange(tmp.specialAttributes);
|
|
results.AddRange(upgradeAttributes);
|
|
resultCombatValue = tmp.combatValue + gradeCombatValue;
|
|
}
|
|
|
|
for (int i = 0; i < gems.Length; i++)
|
|
{
|
|
if (gems[i] != null)
|
|
{
|
|
results.Add(gems[i].attribute);
|
|
resultCombatValue += gems[i].combatValue;
|
|
}
|
|
}
|
|
return resultCombatValue;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
private readonly EquipmentSlotInfo[] _equipmentSlots = new EquipmentSlotInfo[(int)Item.EquipmentType.kMax];
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
private void InitEquipmentSlots()
|
|
{
|
|
for (int i = 0; i < _equipmentSlots.Length; i++)
|
|
{
|
|
_equipmentSlots[i] = new EquipmentSlotInfo(i);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int GetValidEquipmentSlotCount()
|
|
{
|
|
int result = 0;
|
|
for (int i = 0; i < _equipmentSlots.Length; i++)
|
|
{
|
|
if (_equipmentSlots[i].curEquipment != null)
|
|
result++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="equipment"></param>
|
|
/// <returns></returns>
|
|
public EquipmentSlotInfo GetEquipmentSlot(EntityItemEquipment equipment)
|
|
{
|
|
if (equipment != null)
|
|
{
|
|
var result = _equipmentSlots[equipment.equipmentType];
|
|
if (result.IsSetEquipment(equipment))
|
|
return result;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <returns></returns>
|
|
public EquipmentSlotInfo GetEquipmentSlot(int index)
|
|
{
|
|
if (index < _equipmentSlots.Length)
|
|
{
|
|
return _equipmentSlots[index];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public EquipmentSlotInfo[] GetEquipmentSlots()
|
|
{
|
|
return _equipmentSlots;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <param name="onekey"></param>
|
|
/// <returns></returns>
|
|
public bool UpgradeEquipmentSlot(int index, bool onekey, bool sendNotification)
|
|
{
|
|
var equipment = _equipmentSlots[index].curEquipment;
|
|
if (equipment == null)
|
|
{
|
|
return false;
|
|
}
|
|
int maxGrade = equipment.level + 9;
|
|
int tmpGrade = _equipmentSlots[index].grade;
|
|
if (tmpGrade >= maxGrade)
|
|
{
|
|
PostNotification(GlobalDefine.EVENT_SHOW_TOAST, KLocalization.GetLocalString(16));
|
|
return false;
|
|
}
|
|
|
|
int costId = Item.Id.kChip;
|
|
|
|
bool result = false;
|
|
var costReduce = Mathf.Clamp01(GetAttributeValue(CombatAttributeId.CoinUpgradeCostReduce) * 0.01f);
|
|
|
|
int lastCost = 0;
|
|
if (tmpGrade > 0)
|
|
{
|
|
lastCost = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(tmpGrade).equipmentUpgradeCostCount;
|
|
}
|
|
|
|
int gradeAdd = 0;
|
|
if (!onekey)
|
|
{
|
|
var chaLevelItem = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(tmpGrade + 1);
|
|
costId = chaLevelItem.equipmentUpgradeCostId;
|
|
int currCost = chaLevelItem.equipmentUpgradeCostCount;
|
|
|
|
int cost = currCost - lastCost;
|
|
|
|
cost -= (int)(cost * costReduce);
|
|
if (MoneyProxy.Instance.CheckMoney(costId, cost))
|
|
{
|
|
tmpGrade += 1;
|
|
gradeAdd += 1;
|
|
MoneyProxy.Instance.CostMoney(costId, cost);
|
|
result = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int cost = 0;
|
|
while (tmpGrade < maxGrade)
|
|
{
|
|
var chaLevelItem = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(tmpGrade + 1);
|
|
costId = chaLevelItem.equipmentUpgradeCostId;
|
|
int currCost = chaLevelItem.equipmentUpgradeCostCount;
|
|
|
|
int tmpCost = currCost - lastCost;
|
|
tmpCost -= (int)(tmpCost * costReduce);
|
|
if (MoneyProxy.Instance.CheckMoney(costId, tmpCost))
|
|
{
|
|
tmpGrade += 1;
|
|
gradeAdd += 1;
|
|
cost = tmpCost;
|
|
result = true;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
MoneyProxy.Instance.CostMoney(costId, cost);
|
|
}
|
|
|
|
if (result)
|
|
{
|
|
_equipmentSlots[index].SetGrade(tmpGrade);
|
|
|
|
SaveSlots();
|
|
UpdateAttributes();
|
|
int totalGrade = 0;
|
|
for (int i = 0; i < _equipmentSlots.Length; i++)
|
|
{
|
|
totalGrade += _equipmentSlots[i].grade;
|
|
}
|
|
MissionProxy.Instance.OnEvent2(MissionProxy.累计强化次数, totalGrade);
|
|
if (sendNotification)
|
|
PostNotification(GlobalDefine.EVENT_PLAYER_EQUIPMENT_CHANGED, onekey.ToString(), "upgrade");
|
|
PostNotification(GlobalDefine.EVENT_MONEY_CHANGED);
|
|
UI.ToastBox.ShowText("强化成功", 5);
|
|
}
|
|
else
|
|
{
|
|
UI.AdMoneyBox.ShowAdMoney(costId, true);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 代码有bug
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <param name="onekey"></param>
|
|
/// <param name="costId"></param>
|
|
/// <param name="costCount"></param>
|
|
/// <returns></returns>
|
|
public bool GetUpgradeEquipmentSlotCost(int index, bool onekey, out int costId, out int costCount)
|
|
{
|
|
costId = Item.Id.kChip;
|
|
costCount = 0;
|
|
|
|
var slot = _equipmentSlots[index];
|
|
if (slot.curEquipment == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int playerGrade = _equipmentSlots[index].maxGrade;
|
|
int slotGrade = slot.grade;
|
|
if (slotGrade >= playerGrade)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool result = false;
|
|
var costReduce = Mathf.Clamp01(GetAttribute(CombatAttributeId.CoinUpgradeCostReduce).value * 0.01f);
|
|
|
|
int gradeAdd = 0;
|
|
int lastCost = 0;
|
|
if (slotGrade > 0)
|
|
{
|
|
lastCost = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(slotGrade).equipmentUpgradeCostCount;
|
|
}
|
|
|
|
if (!onekey)
|
|
{
|
|
var chaLevelItem = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(slotGrade + 1);
|
|
costId = chaLevelItem.equipmentUpgradeCostId;
|
|
int currCost = chaLevelItem.equipmentUpgradeCostCount;
|
|
|
|
costCount = currCost - lastCost;
|
|
costCount -= (int)(costCount * costReduce);
|
|
if (MoneyProxy.Instance.CheckMoney(costId, costCount))
|
|
{
|
|
slotGrade += 1;
|
|
gradeAdd += 1;
|
|
result = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
costCount = 0;
|
|
while (slotGrade < playerGrade)
|
|
{
|
|
int currCost = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(slotGrade + 1).equipmentUpgradeCostCount;
|
|
int tmpCost = currCost - lastCost;
|
|
tmpCost -= (int)(tmpCost * costReduce);
|
|
if (MoneyProxy.Instance.CheckMoney(costId, tmpCost))
|
|
{
|
|
slotGrade += 1;
|
|
gradeAdd += 1;
|
|
costCount = tmpCost;
|
|
result = true;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="equipment"></param>
|
|
/// <returns></returns>
|
|
public bool IsSetEquipment(EntityItemEquipment equipment)
|
|
{
|
|
if (equipment != null)
|
|
{
|
|
return _equipmentSlots[equipment.equipmentType].IsSetEquipment(equipment);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Item.EquipmentType
|
|
/// </summary>
|
|
/// <param name="id">部位</param>
|
|
/// <returns></returns>
|
|
public EntityItemEquipment GetCurEquipment(int id)
|
|
{
|
|
return _equipmentSlots[id].curEquipment;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取武器 包括试用
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public EntityItemEquipment GetCurWeapon()
|
|
{
|
|
return _equipmentSlots[0].equipment;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="itemId"></param>
|
|
public void SetDefaultEquipment(int itemId)
|
|
{
|
|
var equipment = BagProxy.Instance.NewEquipment(itemId);
|
|
if (equipment != null)
|
|
{
|
|
if (_equipmentSlots[equipment.equipmentType].SetEquipment(equipment))
|
|
{
|
|
SaveSlots();
|
|
UpdateAttributes(false);
|
|
this.PostNotification(GlobalDefine.EVENT_PLAYER_EQUIPMENT_CHANGED, equipment, "set");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 装装备
|
|
/// </summary>
|
|
/// <param name="equipment"></param>
|
|
/// <returns></returns>
|
|
public bool SetEquipment(EntityItemEquipment equipment)
|
|
{
|
|
if (equipment == null /*|| equipment.propLevel > grade*/)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (_equipmentSlots[equipment.equipmentType].SetEquipment(equipment))
|
|
{
|
|
UpdateAttributes();
|
|
SaveSlots();
|
|
|
|
if (_equipmentSlots[0].tryEquipment == null)
|
|
this.PostNotification(GlobalDefine.EVENT_PLAYER_EQUIPMENT_CHANGED, equipment, "set");
|
|
MissionProxy.Instance.OnOverEvent(MissionProxy.装备累计穿戴_等级_品质_数量, 1, equipment.propLevel, equipment.quality);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="equipments"></param>
|
|
public void SetEquipments(EntityItemEquipment[] equipments)
|
|
{
|
|
bool flag = false;
|
|
foreach (var equipment in equipments)
|
|
{
|
|
if (equipment != null)
|
|
{
|
|
if (_equipmentSlots[equipment.equipmentType].SetEquipment(equipment))
|
|
{
|
|
flag = true;
|
|
MissionProxy.Instance.OnOverEvent(MissionProxy.装备累计穿戴_等级_品质_数量, 1, equipment.propLevel, equipment.quality);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (flag)
|
|
{
|
|
SaveSlots();
|
|
UpdateAttributes();
|
|
this.PostNotification(GlobalDefine.EVENT_PLAYER_EQUIPMENT_CHANGED, equipments, "sets");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="equipment"></param>
|
|
/// <returns></returns>
|
|
public bool IsBetterEquipment(EntityItemEquipment equipment)
|
|
{
|
|
if (equipment == null /*|| equipment.propLevel > grade*/ || (equipment.isWeapon && _equipmentSlots[0].tryEquipment != null))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var setEquipment = GetCurEquipment(equipment.equipmentType);
|
|
if (setEquipment == null || setEquipment.combatValue < equipment.combatValue)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 试用
|
|
/// </summary>
|
|
/// <param name="equipment"></param>
|
|
/// <returns></returns>
|
|
public bool TryoutEquipment(int equipmentId)
|
|
{
|
|
var equipment = ItemProxy.Instance.NewTemporaryEquipment(equipmentId);
|
|
if (equipment == null)
|
|
{
|
|
return false;
|
|
}
|
|
_equipmentSlots[0].tryEquipment = equipment;
|
|
|
|
UpdateAttributes();
|
|
this.PostNotification(GlobalDefine.EVENT_PLAYER_EQUIPMENT_CHANGED, equipment, "set");
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 试用结束
|
|
/// </summary>
|
|
public void TryoutFinish()
|
|
{
|
|
bool flag = false;
|
|
for (int i = 0; i < _equipmentSlots.Length; i++)
|
|
{
|
|
if (_equipmentSlots[i].tryEquipment != null)
|
|
{
|
|
_equipmentSlots[i].tryEquipment = null;
|
|
flag = true;
|
|
}
|
|
}
|
|
|
|
if (flag)
|
|
{
|
|
UpdateAttributes(false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="gem"></param>
|
|
/// <returns></returns>
|
|
public bool SetGem(EntityItemGem gem)
|
|
{
|
|
if (gem.count <= 0)
|
|
return false;
|
|
|
|
var slot = GetEquipmentSlot(gem.item.slot);
|
|
if (slot != null)
|
|
{
|
|
int gemLevel = gem.level;
|
|
int lowGemIndex = -1;
|
|
for (int i = 0; i < slot.setGemCountMax; i++)
|
|
{
|
|
var slotGem = slot.gems[i];
|
|
if (slotGem == null)
|
|
{
|
|
slot.SetGem(i, gem.itemId);
|
|
gem.count -= 1;
|
|
return true;
|
|
}
|
|
else if (slotGem.level < gemLevel)
|
|
{
|
|
lowGemIndex = i;
|
|
gemLevel = slotGem.level;
|
|
}
|
|
}
|
|
|
|
if (lowGemIndex >= 0)
|
|
{
|
|
var slotGem = slot.GetGem(lowGemIndex);
|
|
slotGem.count += 1;
|
|
|
|
slot.SetGem(lowGemIndex, gem.itemId);
|
|
gem.count -= 1;
|
|
}
|
|
|
|
SaveSlots();
|
|
UpdateAttributes(true);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="gemKVs"></param>
|
|
/// <returns></returns>
|
|
public bool SetGems(Dictionary<int, List<EntityItemGem>> gemKVs)
|
|
{
|
|
bool result = false;
|
|
foreach (var gemKV in gemKVs)
|
|
{
|
|
var slot = GetEquipmentSlot(gemKV.Key);
|
|
if (slot != null && slot.gemEnabled)
|
|
{
|
|
int maxSetCount = slot.setGemCountMax;
|
|
int setCount = 0;
|
|
for (int j = gemKV.Value.Count - 1; j >= 0 && setCount < 3; j--)
|
|
{
|
|
var gem = gemKV.Value[j];
|
|
for (int i = 0; i < maxSetCount; i++)
|
|
{
|
|
if (gem.count > 0)
|
|
{
|
|
var slotGem = slot.GetGem(i);
|
|
if (slotGem == null)
|
|
{
|
|
slot.SetGem(i, gem.itemId);
|
|
gem.count -= 1;
|
|
setCount += 1;
|
|
}
|
|
else if (slotGem.level < gem.level)
|
|
{
|
|
slot.SetGem(i, gem.itemId);
|
|
gem.count -= 1;
|
|
slotGem.count += 1;
|
|
setCount += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (setCount > 0)
|
|
result = true;
|
|
}
|
|
}
|
|
|
|
if (result)
|
|
{
|
|
SaveSlots();
|
|
UpdateAttributes(true);
|
|
PostNotification(GlobalDefine.EVENT_GEM_CHANGED, null, "set");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="gem"></param>
|
|
/// <returns></returns>
|
|
public bool IsBetterGem(EntityItemGem gem)
|
|
{
|
|
var slot = GetEquipmentSlot(gem.item.slot);
|
|
if (slot != null)
|
|
{
|
|
for (int i = 0; i < slot.setGemCountMax; i++)
|
|
{
|
|
var slotGem = slot.gems[i];
|
|
if (slotGem == null || slotGem.level < gem.level)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="sendNotification"></param>
|
|
private void UpdateAttributes(bool sendNotification = true)
|
|
{
|
|
UpdateAttributes(_equipmentSlots, sendNotification);
|
|
}
|
|
|
|
private readonly Dictionary<int, int> _equipmentSuits = new Dictionary<int, int>();
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="equipmentSlots"></param>
|
|
/// <param name="sendNotification"></param>
|
|
private void UpdateAttributes(EquipmentSlotInfo[] equipmentSlots, bool sendNotification)
|
|
{
|
|
var results = F.ListPool<CombatAttribute>.Get();
|
|
|
|
_equipmentSuits.Clear();
|
|
int combatV = 0;
|
|
for (int i = 0; i < equipmentSlots.Length; i++)
|
|
{
|
|
combatV += equipmentSlots[i].GetAttributes(results);
|
|
if (equipmentSlots[i].curEquipment != null)
|
|
{
|
|
var equipmentSuitId = equipmentSlots[i].curEquipment.suitId;
|
|
if (equipmentSuitId > 0)
|
|
{
|
|
if (_equipmentSuits.ContainsKey(equipmentSuitId))
|
|
_equipmentSuits[equipmentSuitId] += 1;
|
|
else
|
|
_equipmentSuits.Add(equipmentSuitId, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_equipmentSuits.Count > 0)
|
|
{
|
|
foreach (var suitKV in _equipmentSuits)
|
|
{
|
|
var suitItem = ItemProxy.Instance.GetStaticItem<ItemSuit>(suitKV.Key);
|
|
if (suitKV.Value >= 2)
|
|
{
|
|
var attribute = suitItem.GetAttribute2();
|
|
combatV += attribute.combatValue;
|
|
results.Add(attribute);
|
|
}
|
|
if (suitKV.Value >= 4)
|
|
{
|
|
var attribute = suitItem.GetAttribute4();
|
|
combatV += attribute.combatValue;
|
|
results.Add(attribute);
|
|
}
|
|
if (suitKV.Value >= 6)
|
|
{
|
|
var attribute = suitItem.GetAttribute6();
|
|
combatV += attribute.combatValue;
|
|
results.Add(attribute);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < _suitInfos.Count; i++)
|
|
{
|
|
combatV += _suitInfos[i].GetAttributes(results);
|
|
}
|
|
|
|
UpdateEquipmentCombatValue(results, combatV, sendNotification);
|
|
|
|
F.ListPool<CombatAttribute>.Release(results);
|
|
}
|
|
|
|
private const string ARCHIVE_KEY_OB = "eq_slots";
|
|
private const string ARCHIVE_KEY_V1 = "slots_v1";
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
private void LoadEquipmentSlots()
|
|
{
|
|
var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V1);
|
|
if (dataList != null && dataList.Count > 0)
|
|
{
|
|
int index = 0;
|
|
for (int i = 0; i < _equipmentSlots.Length; i++)
|
|
{
|
|
_equipmentSlots[i].grade = dataList.SafeGet(index++);
|
|
_equipmentSlots[i].SetEquipment(dataList.SafeGet(index++));
|
|
|
|
var gemCount = dataList.SafeGet(index++);
|
|
for (int j = 0; j < gemCount; j++)
|
|
{
|
|
var gemId = dataList.SafeGet(index++);
|
|
_equipmentSlots[i].SetGem(j, gemId);
|
|
}
|
|
}
|
|
|
|
var suitCount = dataList.SafeGet(index++);
|
|
for (int i = 0; i < suitCount; i++)
|
|
{
|
|
int status = dataList.SafeGet(index++);
|
|
if (i < _suitInfos.Count)
|
|
_suitInfos[i].SetStatus(status);
|
|
}
|
|
|
|
//UpdateAttributes(false);
|
|
}
|
|
else
|
|
{
|
|
var saveList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_OB);
|
|
if (saveList != null && saveList.Count > 0)
|
|
{
|
|
bool flag = false;
|
|
|
|
int index = 0;
|
|
for (int i = 0; i < _equipmentSlots.Length; i++)
|
|
{
|
|
_equipmentSlots[i].grade = saveList.SafeGet(index++);
|
|
if (_equipmentSlots[i].SetEquipment(saveList.SafeGet(index++)))
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < _suitInfos.Count; i++)
|
|
{
|
|
_suitInfos[i].SetStatus(saveList.SafeGet(index++));
|
|
}
|
|
|
|
if (flag)
|
|
{
|
|
UpdateAttributes(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
private void SaveSlots()
|
|
{
|
|
var saveList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V1);
|
|
if (saveList != null)
|
|
{
|
|
saveList.Clear();
|
|
|
|
for (int i = 0; i < _equipmentSlots.Length; i++)
|
|
{
|
|
var slot = _equipmentSlots[i];
|
|
saveList.Add(slot.grade);
|
|
saveList.Add(slot.equipmentId);
|
|
|
|
saveList.Add(slot.gems.Length);
|
|
for (int j = 0; j < slot.gems.Length; j++)
|
|
{
|
|
var gem = slot.gems[j];
|
|
saveList.Add(gem != null ? gem.id : 0);
|
|
}
|
|
}
|
|
|
|
saveList.Add(_suitInfos.Count);
|
|
for (int i = 0; i < _suitInfos.Count; i++)
|
|
{
|
|
saveList.Add(_suitInfos[i].GetStatus());
|
|
}
|
|
|
|
ArchiveProxy.Instance.SetIntList(ARCHIVE_KEY_V1, saveList);
|
|
}
|
|
ArchiveProxy.Instance.RemoveIntList(ARCHIVE_KEY_OB);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 角色套装
|
|
|
|
/// <summary>
|
|
/// 套装
|
|
/// </summary>
|
|
public class EquipmentSlotSuit
|
|
{
|
|
public readonly ItemSuit item;
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public int id => item.id;
|
|
|
|
public string description
|
|
{
|
|
get { return $"<color=#{ColorUtility.ToHtmlStringRGB(Item.GetQualityColor(activeGrade + 1))}>{item.name}({activeCount}/6)"; }
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public string suitFxAsset
|
|
{
|
|
get
|
|
{
|
|
int tmp = stage;
|
|
if (tmp > 0)
|
|
{
|
|
return $"ef_suit_blue_{tmp}";
|
|
}
|
|
return "";
|
|
}
|
|
}
|
|
|
|
public int stageMax
|
|
{
|
|
get => 3;
|
|
}
|
|
|
|
public int stage
|
|
{
|
|
get
|
|
{
|
|
int ac = this.activeCount;
|
|
if (ac < 1)
|
|
{
|
|
return 0;
|
|
}
|
|
else if (ac < 3)
|
|
{
|
|
return 1;
|
|
}
|
|
else if (ac < 6)
|
|
{
|
|
return 2;
|
|
}
|
|
else
|
|
{
|
|
return 3;
|
|
}
|
|
}
|
|
}
|
|
|
|
public int stageCount1 => 1;
|
|
public int stageCount2 => 3;
|
|
public int stageCount3 => 6;
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="stageCount"></param>
|
|
/// <returns></returns>
|
|
public int GetStageGrade(int stageCount)
|
|
{
|
|
int result = -1;
|
|
int count = 0;
|
|
for (int i = (int)Item.EquipmentType.kMax - 1; i >= 0; i--)
|
|
{
|
|
int grade = _grades[i];
|
|
if (grade > result)
|
|
{
|
|
result = grade;
|
|
count = 1;
|
|
}
|
|
else if (grade == result)
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
|
|
return count >= stageCount ? result : result - 1;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="stageCount"></param>
|
|
/// <returns></returns>
|
|
public string GetStageGradeText(int stageCount)
|
|
{
|
|
if (activeCount < stageCount)
|
|
return $"<color=#7E8486>({stageCount})</color> ";
|
|
int stageGrade = GetStageGrade(stageCount);
|
|
return $"<color=#{ColorUtility.ToHtmlStringRGB(Item.GetQualityColor(stageGrade + 1))}>({Item.GetQualityText(stageGrade + 1) + stageCount})</color> ";
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public string suitAttributesText2
|
|
{
|
|
get
|
|
{
|
|
var attributes = item.GetAttribute2ByGrade(GetStageGrade(stageCount1));
|
|
return GetStageGradeText(stageCount1) + attributes.ToString();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public string suitAttributesText4
|
|
{
|
|
get
|
|
{
|
|
var attributes = item.GetAttribute4ByGrade(GetStageGrade(stageCount2));
|
|
return GetStageGradeText(stageCount2) + attributes.ToString();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public string suitAttributesText6
|
|
{
|
|
get
|
|
{
|
|
var attributes = item.GetAttribute6ByGrade(GetStageGrade(stageCount3));
|
|
return GetStageGradeText(stageCount3) + attributes.ToString();
|
|
}
|
|
}
|
|
|
|
private int _status;
|
|
/// <summary>
|
|
/// 激活数量
|
|
/// </summary>
|
|
public int activeCount
|
|
{
|
|
get
|
|
{
|
|
int result = 0;
|
|
for (int i = 0; i < (int)Item.EquipmentType.kMax; i++)
|
|
{
|
|
if (_grades[i] > 0)
|
|
//if ((_status & (1 << i)) != 0)
|
|
result++;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 激活等级
|
|
/// </summary>
|
|
public int activeGrade
|
|
{
|
|
get
|
|
{
|
|
int result = 0;
|
|
for (int i = (int)Item.EquipmentType.kMax - 1; i >= 0; i--)
|
|
{
|
|
if (_grades[i] > result)
|
|
result = _grades[i];
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public EquipmentSlotSuit(ItemSuit suitItem)
|
|
{
|
|
this.item = suitItem;
|
|
}
|
|
|
|
public bool IsActiveSlot(int slot)
|
|
{
|
|
return (_status & (1 << slot)) != 0;
|
|
}
|
|
|
|
public void ActiveSuit(int slot)
|
|
{
|
|
_status |= (1 << slot);
|
|
}
|
|
|
|
private readonly ObscuredInt[] _grades = new ObscuredInt[(int)Item.EquipmentType.kMax];
|
|
|
|
public int maxGrade
|
|
{
|
|
get => 5;
|
|
}
|
|
|
|
public int GetGrade(int slot)
|
|
{
|
|
return _grades[slot];
|
|
}
|
|
|
|
public void SetGrade(int slot, int value)
|
|
{
|
|
_grades[slot] = value;
|
|
}
|
|
|
|
public void Upgrade(int slot)
|
|
{
|
|
_grades[slot] += 1;
|
|
}
|
|
|
|
public bool CanUpgrade(int slot)
|
|
{
|
|
var slotGrade = (int)_grades[slot];
|
|
if (slotGrade >= maxGrade)
|
|
return false;
|
|
for (int i = 0; i < _grades.Length; i++)
|
|
{
|
|
if (slotGrade > _grades[i])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public Item.ItemInfo GetUpgradeCost(int slot)
|
|
{
|
|
return item.GetCostByGrade(_grades[slot]);
|
|
}
|
|
|
|
public void SetStatus(int status)
|
|
{
|
|
if (status > 0)
|
|
{
|
|
_status = status;
|
|
for (int i = 0; i < (int)Item.EquipmentType.kMax; i++)
|
|
{
|
|
bool active = (_status & (1 << i)) != 0;
|
|
if (active)
|
|
{
|
|
_grades[i] = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public int GetStatus()
|
|
{
|
|
return _status;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="results"></param>
|
|
/// <returns></returns>
|
|
public int GetAttributes(List<CombatAttribute> results)
|
|
{
|
|
int resutCV = 0;
|
|
int tmpCount = this.activeCount;
|
|
if (tmpCount >= stageCount1)
|
|
{
|
|
var attribute = item.GetAttribute2ByGrade(GetStageGrade(stageCount1));
|
|
resutCV += attribute.combatValue;
|
|
results.Add(attribute);
|
|
}
|
|
if (tmpCount >= stageCount2)
|
|
{
|
|
var attribute = item.GetAttribute4ByGrade(GetStageGrade(stageCount2));
|
|
resutCV += attribute.combatValue;
|
|
results.Add(attribute);
|
|
}
|
|
if (tmpCount >= stageCount3)
|
|
{
|
|
var attribute = item.GetAttribute6ByGrade(GetStageGrade(stageCount3));
|
|
resutCV += attribute.combatValue;
|
|
results.Add(attribute);
|
|
}
|
|
return resutCV;
|
|
}
|
|
}
|
|
|
|
private readonly List<EquipmentSlotSuit> _suitInfos = new List<EquipmentSlotSuit>();
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
private void InitEquipmentSlotSuits()
|
|
{
|
|
_suitInfos.Clear();
|
|
var suitItem = ItemProxy.Instance.GetStaticItem<ItemSuit>(1);
|
|
//if (suitItems != null)
|
|
// for (int i = 0; i < suitItems.Count; i++)
|
|
// {
|
|
_suitInfos.Add(new EquipmentSlotSuit(suitItem));
|
|
//}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public EquipmentSlotSuit GetCurrEquipmentSuit()
|
|
{
|
|
return _suitInfos[0];
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="slot"></param>
|
|
/// <returns></returns>
|
|
public bool UpgradeEquipmentSlotSuit(int slot)
|
|
{
|
|
var suit = GetCurrEquipmentSuit();
|
|
if (slot >= 0 && suit != null && suit.CanUpgrade(slot) && MoneyProxy.Instance.CheckAndCostMoney(suit.GetUpgradeCost(slot)))
|
|
{
|
|
suit.Upgrade(slot);
|
|
SaveEquipmentSuits();
|
|
UpdateAttributes();
|
|
PostNotification(GlobalDefine.EVENT_EQUIPMENT_SUIT, null, "upgrade");
|
|
PostNotification(GlobalDefine.EVENT_MONEY_CHANGED, null, "suit");
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public int GetEquipmentSuitActiveCount(int suitId)
|
|
{
|
|
int result = 0;
|
|
for (int i = 0; i < _equipmentSlots.Length; i++)
|
|
{
|
|
var equipment = _equipmentSlots[i].curEquipment;
|
|
if (equipment != null && equipment.suitId == suitId)
|
|
{
|
|
result++;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private const string SUIT_ARCHIVE_KEY_V1 = "suit_v1";
|
|
|
|
void LoadEquipmentSuits()
|
|
{
|
|
var dataList = ArchiveProxy.Instance.GetIntList(SUIT_ARCHIVE_KEY_V1);
|
|
if (dataList != null && dataList.Count > 0)
|
|
{
|
|
int index = 0;
|
|
int suitId = dataList[index++];
|
|
var suitInfo = _suitInfos[0];
|
|
for (int j = 0; j < 6; j++)
|
|
{
|
|
suitInfo.SetGrade(j, dataList[index++]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SaveEquipmentSuits()
|
|
{
|
|
var saveList = ArchiveProxy.Instance.GetIntList(SUIT_ARCHIVE_KEY_V1);
|
|
if (saveList != null)
|
|
{
|
|
saveList.Clear();
|
|
|
|
var suitInfo = _suitInfos[0];
|
|
saveList.Add(suitInfo.id);
|
|
for (int j = 0; j < 6; j++)
|
|
{
|
|
saveList.Add(suitInfo.GetGrade(j));
|
|
}
|
|
|
|
ArchiveProxy.Instance.SetIntList(SUIT_ARCHIVE_KEY_V1, saveList);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region 角色战斗属性
|
|
|
|
public const int ATTRIBUTES_INDEX_TOTAL = 0;
|
|
public const int ATTRIBUTES_INDEX_CHA = 1;
|
|
public const int ATTRIBUTES_INDEX_EQUIPMENT = 2;
|
|
public const int ATTRIBUTES_INDEX_KUNGFU = 3;
|
|
public const int ATTRIBUTES_INDEX_TITLE = 4;
|
|
public const int ATTRIBUTES_INDEX_BEAUTY = 5;
|
|
public const int ATTRIBUTES_INDEX_PET = 6;
|
|
public const int ATTRIBUTES_INDEX_BOOK = 7;
|
|
|
|
public const int ATTRIBUTES_INDEX_MAX = 6 + 1;
|
|
public const int COMBATVALUE_INDEX_MAX = 7 + 1;
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
private readonly int[] _combatValues = new int[COMBATVALUE_INDEX_MAX];
|
|
|
|
/// <summary>
|
|
/// 角色数值
|
|
/// </summary>
|
|
private readonly CombatAttribute[][] _allAttributes = new CombatAttribute[ATTRIBUTES_INDEX_MAX][];
|
|
|
|
/// <summary>
|
|
/// 总属性
|
|
/// </summary>
|
|
public CombatAttribute[] combatAttributes => _allAttributes[ATTRIBUTES_INDEX_TOTAL];
|
|
/// <summary>
|
|
/// 成长属性
|
|
/// </summary>
|
|
public CombatAttribute[] growthAttributes => _allAttributes[ATTRIBUTES_INDEX_CHA];
|
|
/// <summary>
|
|
/// 装备属性
|
|
/// </summary>
|
|
public CombatAttribute[] equipmentAttributes => _allAttributes[ATTRIBUTES_INDEX_EQUIPMENT];
|
|
/// <summary>
|
|
/// 武学属性
|
|
/// </summary>
|
|
public CombatAttribute[] kungfuAttributes => _allAttributes[ATTRIBUTES_INDEX_KUNGFU];
|
|
/// <summary>
|
|
/// 称号属性
|
|
/// </summary>
|
|
public CombatAttribute[] titleAttributes => _allAttributes[ATTRIBUTES_INDEX_TITLE];
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public CombatAttribute[] beautyAttributes => _allAttributes[ATTRIBUTES_INDEX_BEAUTY];
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public CombatAttribute[] petAttributes => _allAttributes[ATTRIBUTES_INDEX_PET];
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public void InitCombatAttributes()
|
|
{
|
|
for (int i = 0; i < ATTRIBUTES_INDEX_MAX; i++)
|
|
{
|
|
var attributes = _allAttributes[i];
|
|
if (attributes == null)
|
|
{
|
|
attributes = new CombatAttribute[(int)CombatAttributeId.kMax];
|
|
for (var j = CombatAttributeId.kMin; j < CombatAttributeId.kMax; j++)
|
|
{
|
|
attributes[(int)j].id = j;
|
|
}
|
|
_allAttributes[i] = attributes;
|
|
}
|
|
else
|
|
{
|
|
for (var j = CombatAttributeId.kMin; j < CombatAttributeId.kMax; j++)
|
|
{
|
|
attributes[(int)j].value = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="attributeId"></param>
|
|
/// <returns></returns>
|
|
public CombatAttribute GetAttribute(CombatAttributeId attributeId)
|
|
{
|
|
return _allAttributes[0][(int)attributeId];
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="attributeId"></param>
|
|
/// <returns></returns>
|
|
public int GetAttributeValue(CombatAttributeId attributeId)
|
|
{
|
|
return _allAttributes[0][(int)attributeId].value;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
/// <param name="attribute"></param>
|
|
private void AddAttribute(CombatAttribute[] source, CombatAttribute attribute)
|
|
{
|
|
source[(int)attribute.id].AddValue(attribute.value);
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
/// <param name="attributes"></param>
|
|
private void AddAttributes(CombatAttribute[] source, IList<CombatAttribute> attributes)
|
|
{
|
|
foreach (var attribute in attributes)
|
|
{
|
|
source[(int)attribute.id].AddValue(attribute.value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
private void ResetAttributes(CombatAttribute[] attributes)
|
|
{
|
|
for (int i = 1; i < (int)CombatAttributeId.kMax; i++)
|
|
{
|
|
attributes[i].ResetValue();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <returns></returns>
|
|
public int GetCombatValue(int index)
|
|
{
|
|
return _combatValues[index];
|
|
}
|
|
|
|
/// <summary>
|
|
/// 更新战力
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <param name="fixedCV"></param>
|
|
/// <param name="extraCV"></param>
|
|
/// <returns>返回战力差</returns>
|
|
public int UpdateCombatValue(int index, int fixedCV = 0, int extraCV = 0)
|
|
{
|
|
//
|
|
for (int i = 1; i < (int)CombatAttributeId.kMax; i++)
|
|
{
|
|
_allAttributes[0][i].ResetValue();
|
|
for (int j = 1; j < ATTRIBUTES_INDEX_MAX; j++)
|
|
{
|
|
_allAttributes[0][i].AddValue(_allAttributes[j][i].value);
|
|
}
|
|
}
|
|
//
|
|
if (fixedCV == 0)
|
|
{
|
|
var attributes = _allAttributes[index];
|
|
for (int i = 1; i < (int)CombatAttributeId.kMax; i++)
|
|
{
|
|
fixedCV += attributes[i].combatValue;
|
|
}
|
|
}
|
|
fixedCV += extraCV;
|
|
int result = fixedCV - _combatValues[index];
|
|
_combatValues[index] = fixedCV;
|
|
|
|
_combatValues[0] = 0;
|
|
for (int i = 1; i < COMBATVALUE_INDEX_MAX; i++)
|
|
{
|
|
_combatValues[0] += _combatValues[i];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="index"></param>
|
|
/// <param name="fixedCV"></param>
|
|
/// <returns></returns>
|
|
public int UpdateCombatValueWithoutAttributes(int index, int fixedCV = 0)
|
|
{
|
|
//
|
|
int result = fixedCV - _combatValues[index];
|
|
_combatValues[index] = fixedCV;
|
|
|
|
_combatValues[0] = 0;
|
|
for (int i = 1; i < COMBATVALUE_INDEX_MAX; i++)
|
|
{
|
|
_combatValues[0] += _combatValues[i];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 升级战力
|
|
/// </summary>
|
|
public void UpdateGrowthCombatValue(bool sendNotification)
|
|
{
|
|
var attributes = this.growthAttributes;
|
|
ResetAttributes(attributes);
|
|
|
|
var cha = GetCurrentCha();
|
|
if (cha != null)
|
|
{
|
|
var initAttributes = cha.initAttributes;
|
|
for (int i = 0; i < initAttributes.Length; i++)
|
|
{
|
|
AddAttribute(attributes, new CombatAttribute
|
|
{
|
|
id = (CombatAttributeId)initAttributes[i][0],
|
|
value = initAttributes[i][1],
|
|
});
|
|
}
|
|
}
|
|
|
|
//var chaLevel = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(this.grade);
|
|
//if (chaLevel != null)
|
|
//{
|
|
// for (int i = 0; i < chaLevel.attributes.Length; i++)
|
|
// {
|
|
// AddAttribute(attributes, new CombatAttribute
|
|
// {
|
|
// id = (CombatAttributeId)chaLevel.attributes[i][0],
|
|
// value = chaLevel.attributes[i][1],
|
|
// });
|
|
// }
|
|
//}
|
|
|
|
int skinCV = ChaSkinProxy.Instance.combatValue;
|
|
|
|
int result = UpdateCombatValue(ATTRIBUTES_INDEX_CHA, 0, skinCV);
|
|
if (sendNotification)
|
|
this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "growth");
|
|
}
|
|
|
|
/// <summary>
|
|
/// 装备战力
|
|
/// </summary>
|
|
public void UpdateEquipmentCombatValue(IList<CombatAttribute> results, int combatValue, bool sendNotification)
|
|
{
|
|
var attributes = this.equipmentAttributes;
|
|
if (sendNotification)
|
|
for (int i = 0; i < results.Count; i++)
|
|
{
|
|
var newAttr = results[i];
|
|
var oldAttr = attributes[(int)newAttr.id];
|
|
if (newAttr.value > oldAttr.value)
|
|
{
|
|
newAttr.value -= oldAttr.value;
|
|
UI.ToastBox.ShowText(newAttr.ToString2(), 4);
|
|
}
|
|
}
|
|
|
|
ResetAttributes(attributes);
|
|
AddAttributes(attributes, results);
|
|
|
|
int result = UpdateCombatValue(ATTRIBUTES_INDEX_EQUIPMENT, combatValue);
|
|
if (sendNotification)
|
|
this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "equipment");
|
|
}
|
|
|
|
/// <summary>
|
|
/// 武学战力
|
|
/// </summary>
|
|
public void UpdateKungfuCombatValue(IList<CombatAttribute> results, bool sendNotification)
|
|
{
|
|
var attributes = this.kungfuAttributes;
|
|
if (sendNotification)
|
|
for (int i = 0; i < results.Count; i++)
|
|
{
|
|
var newAttr = results[i];
|
|
var oldAttr = attributes[(int)newAttr.id];
|
|
if (newAttr.value > oldAttr.value)
|
|
{
|
|
newAttr.value -= oldAttr.value;
|
|
UI.ToastBox.ShowText(newAttr.ToString2(), 4);
|
|
}
|
|
}
|
|
|
|
ResetAttributes(attributes);
|
|
AddAttributes(attributes, results);
|
|
|
|
int result = UpdateCombatValue(ATTRIBUTES_INDEX_KUNGFU);
|
|
if (sendNotification)
|
|
this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "kungfu");
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public void UpdateTitleCombatValue(IList<CombatAttribute> results, int combatValue, bool sendNotification)
|
|
{
|
|
var attributes = this.titleAttributes;
|
|
ResetAttributes(attributes);
|
|
AddAttributes(attributes, results);
|
|
|
|
int result = UpdateCombatValue(ATTRIBUTES_INDEX_TITLE, combatValue);
|
|
if (sendNotification)
|
|
this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "title");
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="results"></param>
|
|
public void UpdateBeautyCombatValue(IList<CombatAttribute> results, bool sendNotification)
|
|
{
|
|
var attributes = this.beautyAttributes;
|
|
ResetAttributes(attributes);
|
|
AddAttributes(attributes, results);
|
|
|
|
int result = UpdateCombatValue(ATTRIBUTES_INDEX_BEAUTY);
|
|
if (sendNotification)
|
|
this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "beauty");
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="results"></param>
|
|
/// <param name="combatValue"></param>
|
|
/// <param name="sendNotification"></param>
|
|
public void UpdatePetCombatValue(IList<CombatAttribute> results, int combatValue, bool sendNotification)
|
|
{
|
|
var attributes = this.petAttributes;
|
|
ResetAttributes(attributes);
|
|
AddAttributes(attributes, results);
|
|
|
|
int result = UpdateCombatValue(ATTRIBUTES_INDEX_PET, combatValue);
|
|
if (sendNotification)
|
|
this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "pet");
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="combatValue"></param>
|
|
/// <param name="sendNotification"></param>
|
|
public void UpdateBookCombatValue(int combatValue, bool sendNotification)
|
|
{
|
|
int result = UpdateCombatValueWithoutAttributes(ATTRIBUTES_INDEX_BOOK, combatValue);
|
|
if (sendNotification)
|
|
this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "book");
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|