private void OnItemEndDragItem(object param)
{
dragItem.gameObject.SetActive(false);
ItemData item = (ItemData)param;
ShowMask(item, false);
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
if (static_data.sub_ype == ItemSubType.Ring && equip_items[0].onItem)
{
RoleData.mainRole.EquipItem(item.id);
}
else if (static_data.sub_ype == ItemSubType.Ride && equip_items[1].onItem)
{
RoleData.mainRole.EquipItem(item.id);
}
else if (static_data.sub_ype == ItemSubType.recoverRemedy || static_data.sub_ype == ItemSubType.buffRemedy)
{
for (int idx = 0; idx < battle_items.Length; idx++)
{
if (battle_items[idx].onItem)
{
RoleData.mainRole.EquipItem(item.id, idx);
break;
}
}
}
}
/// <summary>
/// 创建新物品
/// </summary>
public int NewItem(int static_id, ref int count)
{
bool old_id = remove_items.Count > 0; // 是否复用丢弃的物品id
int item_id;
if (old_id)
{
item_id = remove_items.Dequeue();
}
else
{
item_id = all_item.Count;
}
ItemData item = new ItemData()
{
static_id = static_id, count = 1, id = item_id
};
if (old_id)
{
all_item[item_id] = item;
}
else
{
all_item.Add(item);
}
ItemStaticData static_data = item_static_data[static_id];
int item_count = Mathf.Min(count, static_data.maxcount);
item.count = item_count;
count -= item_count;
return(item_id);
}
/// <summary>
/// 物品是否装备着
/// </summary>
/// <returns></returns>
public bool ItemIsEquip(int item_id)
{
var item = GameData.instance.all_item[item_id];
bool isWear = false; // 是否穿戴者
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
if (static_data.sub_ype == ItemSubType.Ring)
{
return(equip_items[0] == item.id); // 戒指位置
}
else if (static_data.sub_ype == ItemSubType.Ride)
{
return(equip_items[1] == item.id); // 坐骑位置
}
else if (static_data.sub_ype == ItemSubType.recoverRemedy || static_data.sub_ype == ItemSubType.buffRemedy)
{
foreach (var id in remedy_items) // 丹药
{
if (id == item.id)
{
isWear = true;
break;
}
}
}
return(isWear);
}
private void UpdateItem(ItemData item)
{
ItemStaticData staticData = GameData.instance.item_static_data[item.static_id];
item_name.text = staticData.name;
item_type.text = GameConst.itemTypeName[staticData.type];
item_sub_type.text = GameConst.itemSubTypeName[staticData.sub_ype];
item_need_lv.text = LevelConfigData.GetBigName(staticData.level);
string[] array = staticData.des.Split('\n');
for (int i = 1; i < transform.childCount; i++)
{
if (i > array.Length)
{
transform.GetChild(i).gameObject.SetActive(false);
}
else
{
GameObject obj = transform.GetChild(i).gameObject;
obj.SetActive(true);
obj.GetComponent <Text>().text = array[i - 1];
}
}
//item_attr.text = GetItemAttrDes(staticData);
item_bg.sprite = UIAssets.instance.bgColor[staticData.color];
item_color.sprite = UIAssets.instance.itemColor[staticData.color];
item_icon.sprite = UIAssets.instance.itemIcon[staticData.icon];
item_use.SetActive(RoleData.mainRole.ItemIsEquip(item.id));
}
private void ShowMask(ItemStaticData static_data, bool show)
{
switch (static_data.sub_ype)
{
case ItemSubType.Heart:
yuan.SetActive(show);
break;
case ItemSubType.Attack:
yuan1.SetActive(show);
break;
case ItemSubType.Skill:
yuan2.SetActive(show);
break;
case ItemSubType.Body:
yuan3.SetActive(show);
break;
case ItemSubType.Magic:
yuan4.SetActive(show);
break;
}
}
public static GongfaStaticData GetStaticGongfaFromItem(int item_id)
{
ItemData item = instance.all_item[item_id];
ItemStaticData static_data = instance.item_static_data[item.static_id];
GongfaStaticData gongfa = instance.gongfa_static_data[static_data.param[0]];
return(gongfa);
}
/// <summary>
/// 卸下功法
/// </summary>
public void UnfixGongfa(GongfaData gongfa)
{
int item_id = gongfa.item_id;
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
GongfaStaticData static_gongfa = GetGongfaStaticData(gongfa);
UnfixGongfa(static_data.sub_ype, GetHeartType(static_gongfa.type));
}
/// <summary>
/// 获取功法静态数据
/// </summary>
public GongfaStaticData GetGongfaStaticData(GongfaData gongfa)
{
int item_id = gongfa.item_id;
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
int gongfa_static_id = static_data.param[0]; // 根据物品获取功法静态数据id
GongfaStaticData static_gongfa = GameData.instance.gongfa_static_data[gongfa_static_id];
return(static_gongfa);
}
private void OnItemEndDragItem(object param)
{
dragItem.gameObject.SetActive(false);
GongfaData gongfa = (GongfaData)param;
int item_id = gongfa.item_id;
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
ShowMask(static_data, false);
switch (static_data.sub_ype)
{
case ItemSubType.Heart:
for (int i = 0; i < heart_items.Length; i++)
{
if (heart_items[i].onItem)
{
RoleData.mainRole.EquipGongfa(gongfa, i);
break;
}
}
break;
case ItemSubType.Attack:
if (atk_items[0].onItem)
{
RoleData.mainRole.EquipGongfa(gongfa);
}
break;
case ItemSubType.Skill:
if (atk_items[1].onItem)
{
RoleData.mainRole.EquipGongfa(gongfa);
}
break;
case ItemSubType.Body:
if (atk_items[2].onItem)
{
RoleData.mainRole.EquipGongfa(gongfa);
}
break;
case ItemSubType.Magic:
if (atk_items[3].onItem)
{
RoleData.mainRole.EquipGongfa(gongfa);
}
break;
}
}
private void OnItemBeginDragItem(object param)
{
GongfaData gongfa = (GongfaData)param;
dragItem.GetComponent <GongfaItem>().SetItem(gongfa);
dragItem.gameObject.SetActive(true);
int item_id = gongfa.item_id;
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
ShowMask(static_data, true);
}
public int GetItemAttrbuite(int item_id, RoleAttribute attribute)
{
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
for (int i = 0; i < static_data.attributes.Length; i++)
{
if (static_data.attributes[i] == RoleAttribute.max_item)
{
return(static_data.attr_values[i]);
}
}
return(0);
}
public void RemoveItem(int item_id, int count = 1, bool removeDepot = true)
{
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
if (count == 0)
{
count = item.count;
}
// 移除背包的
item.count -= count;
if (item.count <= 0)
{
bag_items.Remove(item_id);
}
if (item.count <= 0)
{
// 移除穿在身上的
if (static_data.type == ItemType.Equip)
{
for (int i = 0; i < equip_items.Length; i++)
{
if (equip_items[i] == item.id)
{
equip_items[i] = -1;
break;
}
}
}
else if (static_data.sub_ype == ItemSubType.recoverRemedy || static_data.sub_ype == ItemSubType.buffRemedy)
{
for (int i = 0; i < remedy_items.Length; i++)
{
if (remedy_items[i] == item.id)
{
remedy_items[i] = -1;
break;
}
}
}
if (removeDepot)
{
// 移除物品库
GameData.instance.RemoveItem(item_id);
}
}
EventManager.SendEvent(EventTyp.ItemChange, null);
}
/*
* <color=#E28225FF>装备后可获得以下属性属性</color>
* 背包上限：<color=#20C123FF>+12</color>
*
*/
private string GetItemAttrDes(ItemStaticData staticData)
{
if (staticData.attributes == null || staticData.attributes.Length < 1)
{
return(null);
}
RoleAttrConfig[] attribute_config = RoleAttrConfigData.GetAttrConfig();
StringBuilder myString = new StringBuilder("<color=#E28225FF>装备后可获得以下属性</color>");
for (int i = 0; i < staticData.attributes.Length; i++)
{
myString.AppendLine();
myString.Append(attribute_config[(int)staticData.attributes[i]].name);
myString.AppendFormat("<color=#20C123FF>+{0}</color>", staticData.attr_values[i]);
}
return(myString.ToString());
}
/// <summary>
/// 添加或新建道具
/// </summary>
/// <param name="static_id">添加的物品静态配置id</param>
/// <param name="count">添加的数量，返回时大于0则是无法添加的数量</param>
/// <returns>是否成功添加 无法添加的数量在count</returns>
public bool AddOrCreateItem(int static_id, ref int count)
{
ItemStaticData static_data = GameData.instance.item_static_data[static_id];
// 判断是否可以叠加
for (int i = 0; i < bag_items.Count; i++)
{
ItemData item = GameData.instance.all_item[bag_items[i]];
if (item.static_id == static_id && item.count < static_data.maxcount)
{
// 背包有物品 并且堆叠数量未满
int can_count = static_data.maxcount - item.count;
if (can_count >= count)
{
item.count += count;
EventManager.SendEvent(EventTyp.ItemChange, null);
return(true);
}
else
{
count -= can_count;
item.count += can_count;
}
}
}
if (bag_items.Count >= GetAttr(RoleAttribute.max_item))
{
MessageTips.Message(21); // 提示背包已满
return(false);
}
do
{
int item_id = GameData.instance.NewItem(static_id, ref count);
if (!AddItem(item_id, ref count))
{
GameData.instance.RemoveItem(item_id);
return(false);
}
} while (count > 0);
return(true);
}
private void ShowMask(ItemData item, bool show)
{
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
switch (static_data.sub_ype)
{
case ItemSubType.Ring:
yuan1.SetActive(show);
break;
case ItemSubType.Ride:
yuan2.SetActive(show);
break;
case ItemSubType.recoverRemedy:
case ItemSubType.buffRemedy:
fang.SetActive(show);
break;
}
}
public void EquipItem(int item_id, int idx)
{
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
if (!LevelConfigData.CheckLevel(GetAttr(RoleAttribute.level), static_data.level))
{
MessageTips.Message(43, LevelConfigData.GetBigName(static_data.level));
return;
}
if (static_data.sub_ype == ItemSubType.recoverRemedy || static_data.sub_ype == ItemSubType.buffRemedy)
{
remedy_items[idx] = item_id;
EventManager.SendEvent(EventTyp.ItemChange, null);
}
else
{
EquipItem(item_id);
}
}
/// <summary>
/// 物品是否装备着
/// </summary>
/// <returns></returns>
public bool GonfaIsEquip(GongfaData gongfa)
{
bool isWear = false; // 是否穿戴着
int item_id = gongfa.item_id;
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
switch (static_data.sub_ype)
{
case ItemSubType.Heart:
for (int i = 0; i < heart_gongfa.Length; i++)
{
if (gongfa == heart_gongfa[i])
{
isWear = true;
}
}
break;
case ItemSubType.Body:
isWear = body_gongfa == gongfa;
break;
case ItemSubType.Attack:
isWear = attack_gongfa == gongfa;
break;
case ItemSubType.Skill:
isWear = skill_gongfa == gongfa;
break;
case ItemSubType.Magic:
isWear = magic_gongfa == gongfa;
break;
}
return(isWear);
}
/// <summary>
/// 添加道具
/// </summary>
/// <param name="static_id">添加的物品id</param>
/// <param name="count">添加的数量，返回时大于0则是无法添加的数量</param>
/// <returns>是否成功添加 无法添加的数量在count</returns>
public bool AddItem(int item_id, ref int count)
{
ItemData add_item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[add_item.static_id];
// 判断是否可以叠加
for (int i = 0; i < bag_items.Count; i++)
{
ItemData item = GameData.instance.all_item[bag_items[i]];
if (item.static_id == add_item.static_id && item.count < static_data.maxcount)
{
// 背包有物品 并且堆叠数量未满
int can_count = static_data.maxcount - item.count;
if (can_count >= count)
{
item.count += count;
GameData.instance.RemoveItem(add_item.id); // 物品堆叠到一起，删除旧的物品
EventManager.SendEvent(EventTyp.ItemChange, null);
return(true);
}
else
{
count -= can_count;
item.count += can_count;
}
}
}
if (bag_items.Count >= GetAttr(RoleAttribute.max_item))
{
MessageTips.Message(21); // 提示背包已满
return(false);
}
// 增加物品
bag_items.Add(item_id);
EventManager.SendEvent(EventTyp.ItemChange, null);
return(true);
}
/// <summary>
/// 是否可以穿戴物品
/// </summary>
/// <param name="item_id">返回可穿在的索引</param>
/// <returns></returns>
public int CanEquipItem(int item_id)
{
if (ItemIsEquip(item_id))
{
return(-1);
}
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
// 移除穿在身上的
if (static_data.sub_ype == ItemSubType.Ring)
{
if (equip_items[0] == -1) // 戒指
{
return(0);
}
}
else if (static_data.sub_ype == ItemSubType.Ride)
{
if (equip_items[1] == -1) // 坐骑
{
return(1);
}
}
else if (static_data.sub_ype == ItemSubType.recoverRemedy || static_data.sub_ype == ItemSubType.buffRemedy)
{
for (int i = 0; i < remedy_items.Length; i++) // 丹药
{
if (remedy_items[i] == -1)
{
return(i);
}
}
}
return(-1);
}
private ItemTipsBtn[] GetItemBtns()
{
if (item == null || roleData == null || !isBag)
{
return(new ItemTipsBtn[0]);
}
bool item_is_equip = roleData.ItemIsEquip(item.id);
List <ItemTipsBtn> btns = new List <ItemTipsBtn>();
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
if (static_data.sub_ype == ItemSubType.recoverRemedy || static_data.sub_ype == ItemSubType.buffRemedy ||
static_data.sub_ype == ItemSubType.Ring || static_data.sub_ype == ItemSubType.Ride)
{
if (item_is_equip)
{
// 卸载按钮
btns.Add(new ItemTipsBtn()
{
btn_name = 28, btn_func = BtnEquip
});
}
else
{
if (static_data.sub_ype == ItemSubType.Ride)
{
// 乘骑按钮
btns.Add(new ItemTipsBtn()
{
btn_name = 31, btn_func = BtnEquip
});
}
else
{
// 装备按钮
btns.Add(new ItemTipsBtn()
{
btn_name = 22, btn_func = BtnEquip
});
}
}
}
if (static_data.sub_ype == ItemSubType.recoverRemedy || static_data.sub_ype == ItemSubType.aptitudesRemedy)
{
// 食用按钮
btns.Add(new ItemTipsBtn()
{
btn_name = 23, btn_func = BtnUse
});
}
if (static_data.type == ItemType.Gongfa)
{
// 学习按钮
btns.Add(new ItemTipsBtn()
{
btn_name = 25, btn_func = BtnUse
});
}
if (!item_is_equip)
{
// 丢弃按钮
btns.Add(new ItemTipsBtn()
{
btn_name = 24, btn_func = BtnDiscard
});
}
return(btns.ToArray());
}
public void SetItem(ItemData item, RoleData role = null, bool isBag = false, bool isRound = false, string show_count = null, System.Action clickFunc = null)
{
roleData = role;
this.item = item;
this.isBag = isBag;
this.clickFunc = clickFunc;
if (item == null)
{
if (isRound)
{
color.sprite = UIAssets.instance.gongfaColor[0];
}
else
{
color.sprite = UIAssets.instance.itemColor[0];
}
icon.enabled = false;
if (show_count != null)
{
count.enabled = true;
count.text = show_count;
}
else
{
count.enabled = false;
}
Tools.SetActive(useing, false);
can_drag = false;
return;
}
icon.enabled = true;
count.enabled = true;
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
icon.sprite = UIAssets.instance.itemIcon[static_data.icon];
if (isRound)
{
color.sprite = UIAssets.instance.gongfaColor[static_data.color];
}
else
{
color.sprite = UIAssets.instance.itemColor[static_data.color];
}
if (show_count != null)
{
count.text = show_count;
}
else if (static_data.maxcount > 1)
{
count.text = item.count.ToString();
}
else
{
count.text = "";
}
if (roleData == null || !isBag)
{
can_drag = false;
Tools.SetActive(useing, false);
return;
}
bool isWear = roleData.ItemIsEquip(item.id); // 是否穿戴者
Tools.SetActive(useing, isWear);
can_drag = roleData == RoleData.mainRole && !isWear &&
(static_data.type == ItemType.Equip || // 装备
static_data.sub_ype == ItemSubType.recoverRemedy || static_data.sub_ype == ItemSubType.buffRemedy); // 恢复丹药或增益丹药
}
/// <summary>
/// 装备物品
/// 戒指或坐骑：如果是已穿戴就卸下，否则就穿戴
/// 药物：是已装备的药物则卸下，否则装备到最后一个空格子，没有的话提示装备已满
/// </summary>
public void EquipItem(int item_id)
{
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
if (!LevelConfigData.CheckLevel(GetAttr(RoleAttribute.level), static_data.level))
{
MessageTips.Message(43, LevelConfigData.GetBigName(static_data.level));
return;
}
// 移除穿在身上的
if (static_data.sub_ype == ItemSubType.Ring)
{
if (equip_items[0] != -1)
{
int empty_count = GetAttr(RoleAttribute.max_item) - bag_items.Count;
if (equip_items[0] == item_id)
{
// 脱下
empty_count -= GetItemAttrbuite(item_id, RoleAttribute.max_item);
}
else
{
// 更换
if (equip_items[0] != -1)
{
empty_count -= GetItemAttrbuite(equip_items[0], RoleAttribute.max_item);
}
empty_count += GetItemAttrbuite(item_id, RoleAttribute.max_item);
}
if (empty_count < 0)
{
// 无法更换或脱下戒指
MessageTips.Message(44);
return;
}
}
if (equip_items[0] == item_id) // 戒指
{
equip_items[0] = -1;
}
else
{
equip_items[0] = item_id;
}
UpdateAttr();
EventManager.SendEvent(EventTyp.ItemChange, null);
}
else if (static_data.sub_ype == ItemSubType.Ride)
{
if (equip_items[1] == item_id) // 坐骑
{
equip_items[1] = -1;
}
else
{
equip_items[1] = item_id;
}
UpdateAttr();
EventManager.SendEvent(EventTyp.ItemChange, null);
}
else if (static_data.sub_ype == ItemSubType.recoverRemedy || static_data.sub_ype == ItemSubType.buffRemedy)
{
for (int i = 0; i < remedy_items.Length; i++) // 判断卸下丹药
{
if (remedy_items[i] == item_id)
{
remedy_items[i] = -1;
EventManager.SendEvent(EventTyp.ItemChange, null);
return;
}
}
for (int i = 0; i < remedy_items.Length; i++) // 判断穿戴丹药
{
if (remedy_items[i] == -1)
{
remedy_items[i] = item_id;
EventManager.SendEvent(EventTyp.ItemChange, null);
return;
}
}
MessageTips.Message(27);
}
}
public void UseItem(int item_id, int count = 1)
{
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
if (!LevelConfigData.CheckLevel(GetAttr(RoleAttribute.level), static_data.level))
{
MessageTips.Message(43, LevelConfigData.GetBigName(static_data.level));
return;
}
switch (static_data.type)
{
case ItemType.Remedy: // 丹药类
switch (static_data.sub_ype)
{
case ItemSubType.recoverRemedy: // 恢复类丹药
// 扣除道具
RemoveItem(item_id, count);
// 恢复
for (int i = 0; i < static_data.attributes.Length; i++)
{
ChangeAttrebuteValue(static_data.attributes[i], static_data.attr_values[i] * count);
}
break;
case ItemSubType.aptitudesRemedy: // 资质丹药
// 扣除道具
RemoveItem(item_id, count);
// 增加属性
for (int i = 0; i < static_data.attributes.Length; i++)
{
int multiple = (GetAttr(static_data.attributes[i]) >= static_data.param[0]) ? 0 : 1;
ChangeAttrebuteMaxValue(static_data.attributes[i], static_data.attr_values[i] * count * multiple);
if (multiple < 1)
{
MessageTips.Message(46);
}
}
break;
case ItemSubType.buffRemedy:
break;
case ItemSubType.otherRemedy:
break;
}
break;
case ItemType.Gongfa: // 功法类
GongfaStaticData gongfa = GameData.GetStaticGongfaFromItem(item_id);
RoleAttribute[][] need_attr = gongfa.attr_condition;
var need_value = gongfa.value_condition;
int condition_count = need_value.Length;
for (int i = 0; i < condition_count; i++)
{
RoleAttribute[] need = need_attr[i];
int value = need_value[i];
bool can = false;
foreach (RoleAttribute attr in need)
{
if (GetAttr(attr) >= value)
{
can = true;
break;
}
}
if (!can)
{
// 修炼资质不足
MessageTips.Message(45);
return;
}
}
RemoveItem(item_id, count, false);
GongfaData new_gongfa = new GongfaData()
{
item_id = item.id, attr_value = gongfa.attr_value, ex_values = gongfa.ex_values, ex_color = gongfa.ex_color
};
all_gongfa.Add(new_gongfa);
int mood = 10;
ChangeAttrebuteValue(RoleAttribute.mood, -mood);
GameData.instance.SetGameData(GlobalAttribute.time, GameData.instance.GetGameData(GlobalAttribute.time) + GameConst.oneDayTicks * 15);
MessageWindow.Message(49, 50, null, 0, mood.ToString(), gongfa.name);
break;
}
}
/// <summary>
/// 装配功法
/// </summary>
public void EquipGongfa(GongfaData gongfa, int idx = -1)
{
int item_id = gongfa.item_id;
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
switch (static_data.sub_ype)
{
case ItemSubType.Heart:
GongfaStaticData static_gongfa = GetGongfaStaticData(gongfa);
GongfaType sub_type = GetHeartType(static_gongfa.type);
// 先判断是否有装备相同类型的功法
int same = -1;
for (int i = 0; i < heart_gongfa.Length; i++)
{
if (heart_gongfa[i] == null)
{
if (idx == -1)
{
idx = i;
}
continue;
}
GongfaStaticData equip_gongfa = GetGongfaStaticData(heart_gongfa[i]);
if ((equip_gongfa.type & sub_type) == sub_type)
{
same = i;
if (idx == -1)
{
idx = i;
}
}
}
if (CheckDaodian(gongfa, same == -1 ? 0 : ((HeartGongfaStaticData)GetGongfaStaticData(gongfa)).need_daodian))
{
if (same != -1)
{
heart_gongfa[same] = null;
}
heart_gongfa[idx] = gongfa;
}
else
{
MessageTips.Message(47);
}
break;
case ItemSubType.Body:
body_gongfa = gongfa;
break;
case ItemSubType.Attack:
attack_gongfa = gongfa;
break;
case ItemSubType.Skill:
skill_gongfa = gongfa;
break;
case ItemSubType.Magic:
magic_gongfa = gongfa;
break;
}
EventManager.SendEvent(EventTyp.GongfaChange, null);
UpdateAttr();
}
/// <summary>
/// 更新属性 重新计算装备增加的属性
/// </summary>
public void UpdateAttr()
{
int count = attribute.Length;
if (definitive_attribute == null || definitive_max_attribute == null)
{
definitive_attribute = new int[count];
definitive_max_attribute = new int[count];
for (int i = 0; i < count; i++)
{
definitive_attribute[i] = attribute[i];
definitive_max_attribute[i] = max_attribute[i];
}
}
int old_ride = GetAttr(RoleAttribute.ride_id);
int new_ride = -1;
// 记录更新属性
int[] max_value = new int[count];
for (int i = 0; i < count; i++)
{
max_value[i] = max_attribute[i];
}
// 计算装备增加的属性
for (int i = 0; i < equip_items.Length; i++)
{
int item_id = equip_items[i];
if (item_id == -1)
{
continue;
}
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
for (int j = 0; j < static_data.attributes.Length; j++)
{
int attr = (int)static_data.attributes[j];
max_value[attr] += static_data.attr_values[j];
}
if (static_data.sub_ype == ItemSubType.Ride)
{
new_ride = static_data.param[0];
}
}
// 计算功法加的属性
int daodian = 0; // 记录功法使用的道点
List <GongfaData> gongfas = new List <GongfaData>(heart_gongfa);
gongfas.Add(attack_gongfa);
gongfas.Add(skill_gongfa);
gongfas.Add(body_gongfa);
gongfas.Add(magic_gongfa);
for (int i = 0; i < gongfas.Count; i++)
{
GongfaData gongfa = gongfas[i];
if (gongfa != null)
{
GongfaStaticData static_gongfa = GetGongfaStaticData(gongfa);
for (int j = 0; j < static_gongfa.attr_id.Length; j++)
{
GongfaAttrData attr_data = GongfaAttrConfig.GetAttrConfig(static_gongfa.attr_id[j]);
if (!attr_data.isSkill)
{
int value = gongfa.attr_value[j][0];
max_value[(int)attr_data.attr] += value;
}
}
for (int j = 0; j < static_gongfa.ex_id.Length; j++)
{
GongfaAttrData attr_data = GongfaAttrConfig.GetAttrConfig(static_gongfa.ex_id[j]);
if (!attr_data.isSkill)
{
int value = gongfa.ex_values[j][0];
max_value[(int)attr_data.attr] += value;
}
}
if (static_gongfa is HeartGongfaStaticData)
{
daodian += ((HeartGongfaStaticData)static_gongfa).need_daodian;
}
}
}
RoleAttrConfig[] attribute_config = RoleAttrConfigData.GetAttrConfig();
for (int i = 0; i < count; i++)
{
float rate = definitive_attribute[i] == definitive_attribute[i] ? 1 : definitive_attribute[i] * 1f / definitive_max_attribute[i];
if (attribute_config[i].type == RoleAttrShowType.FixedMinMax)
{
definitive_max_attribute[i] = max_value[i];
continue;
}
else if (attribute_config[i].type != RoleAttrShowType.MinMax)
{
rate = 1;
}
definitive_max_attribute[i] = max_value[i];
definitive_attribute[i] = (int)(max_value[i] * rate);
}
definitive_attribute[(int)RoleAttribute.daodian] = daodian; // 修改当前使用的道点
EventManager.SendEvent(EventTyp.AttrChange, this); // 通知属性变更
if (old_ride != new_ride)
{
SetAttrebuteValue(RoleAttribute.ride_id, new_ride);
EventManager.SendEvent(EventTyp.ChangeRide, this); // 通知坐骑变更
}
}
public static void CreateGongfaItem(GongfaStaticData gongfa, List <ItemStaticData> item_list, ItemSubType sub_type)
{
StringBuilder des = new StringBuilder();
if (gongfa is HeartGongfaStaticData)
{
HeartGongfaStaticData gf = (HeartGongfaStaticData)gongfa;
des.AppendFormat("道点消耗：{0}", gf.need_daodian);
}
else if (gongfa is SkillGongfaStaticData)
{
SkillGongfaStaticData gf = (SkillGongfaStaticData)gongfa;
des.AppendFormat("技能冷却：{0}", gf.cool);
des.AppendLine();
des.AppendFormat("施法消耗：{0}", gf.cost);
}
des.AppendLine();
des.AppendLine("——————————————————");
bool isSkill = true;
for (int i = 0; i < gongfa.attr_id.Length; i++)
{
var attr_id = gongfa.attr_id[i];
GongfaAttrData main_attr_data = GongfaAttrConfig.GetAttrConfig(attr_id);
if (!main_attr_data.isSkill && isSkill)
{
isSkill = false;
des.AppendLine("<color=#E28225FF>装备后可获得以下属性</color>");
}
if (isSkill)
{
des.AppendLine(DesFormat(main_attr_data.des, gongfa.attr_value[i]));
}
else
{
des.AppendLine(" " + DesFormat(main_attr_data.des, gongfa.attr_value[i]));
}
}
des.AppendLine("——————————————————");
for (int i = 0; i < gongfa.ex_id.Length; i++)
{
GongfaAttrData congfa_attr_data = GongfaAttrConfig.GetAttrConfig(gongfa.ex_id[i]);
des.AppendFormat(" <size=10>{1}</size>：<color=#{0}>", GameConst.item_color_str[gongfa.ex_color[i]], GameConst.attr_level_name[i]);
des.Append(DesFormat(congfa_attr_data.des, gongfa.ex_values[i]));
des.AppendLine("</color>");
}
des.AppendLine("——————————————————");
if (gongfa.attr_condition[0].Length == 1)
{
RoleAttrConfig[] attribute_config = RoleAttrConfigData.GetAttrConfig();
des.AppendFormat("学习条件：{0}达到{1}", attribute_config[(int)gongfa.attr_condition[0][0]].name, gongfa.value_condition[0]);
}
else
{
des.AppendFormat("任意一项战斗资质达到{0}", gongfa.value_condition[0]);
}
int item_static_id = item_list.Count;
var item = new ItemStaticData()
{
id = item_static_id,
type = ItemType.Gongfa,
sub_ype = sub_type,
price = gongfa.price,
maxcount = 1,
param = new int[] { gongfa.id },
name = gongfa.name,
icon = ItemSubType.Magic - sub_type,
color = gongfa.color,
level = gongfa.level,
des = des.ToString(),
attributes = null,
attr_values = null,
};
item_list.Add(item);
}
public void SetItem(GongfaData gongfa, RoleData role = null, bool isBag = false, System.Action clickFunc = null)
{
roleData = role;
this.gongfa = gongfa;
this.isBag = isBag;
this.clickFunc = clickFunc;
if (gongfa == null)
{
icon.enabled = false;
color.sprite = UIAssets.instance.gongfaColor[0];;
if (bg)
{
bg.sprite = UIAssets.instance.bgColor[0];
}
if (t_name)
{
t_name.text = null;
}
if (t_type)
{
t_type.text = null;
}
if (t_level)
{
t_level.text = null;
}
Tools.SetActive(useing, false);
return;
}
int item_id = gongfa.item_id;
ItemData item = GameData.instance.all_item[item_id];
ItemStaticData static_data = GameData.instance.item_static_data[item.static_id];
icon.enabled = true;
icon.sprite = UIAssets.instance.itemIcon[static_data.icon];
color.sprite = UIAssets.instance.gongfaColor[static_data.color];
if (bg)
{
bg.sprite = UIAssets.instance.bgColor[static_data.color];
}
if (t_name)
{
t_name.text = static_data.name;
}
if (t_type)
{
t_type.text = GameConst.itemSubTypeName[static_data.sub_ype];
}
if (t_level)
{
t_level.text = LevelConfigData.GetBigName(static_data.level);
}
if (roleData == null || !isBag)
{
can_drag = false;
Tools.SetActive(useing, false);
return;
}
bool isWear = roleData.GonfaIsEquip(gongfa); // 是否穿戴着
Tools.SetActive(useing, isWear);
can_drag = roleData == RoleData.mainRole && !isWear;
}
