public bool StoreItem(Item item, int amount = 1)
{
if (itemUI == null)
{
itemUI = new ItemUI(slotGo, item, amount);
return(true);
}
else
{//序号一致则可以增加数量
if (itemUI.item.Equals(item))
{
if (!IsFilled())
{
itemUI.AddAmount(amount);
return(true);
}
else
{
Debug.LogWarning("背包已满" + item.Name);
}
}
else
{
if (!IsFilled())
{
itemUI.InitItem(item, amount);
}
else
{
Debug.LogWarning("背包已满" + item.Name);
}
}
}
return(false);
}
/// <summary>
/// 设置物品的父对象
/// </summary>
/// <param name="item"></param>
public void SetItemParent(ItemUI item)
{
item.transform.SetParent(this.CurrentSlot);
item.transform.position = this.currentSlot.position;
item.transform.localScale = new Vector3(1, 1, 1);
item.AddAmount(0);//只为了添加一个动画
}
public void Store(Item item)
{
if (transform.childCount == 0)
{
GameObject goItem = Instantiate(prefabItem);
goItem.transform.SetParent(transform);
goItem.transform.localPosition = Vector3.zero;
goItem.transform.localScale = Vector3.one;
itemUI = goItem.GetComponent <ItemUI>();
itemUI.Set(item);
}
else
{
itemUI.AddAmount();
}
}
public void ForgeItem()
{
// 得到当前有哪些材料
// 判断满足哪一个秘籍的要求
List <int> haveMaterialIDList = new List <int>();//存储当前拥有的材料的id
foreach (Slot slot in slots)
{
if (slot.transform.childCount > 0)
{
ItemUI currentItemUI = slot.transform.GetChild(0).GetComponent <ItemUI>();
for (int i = 0; i < currentItemUI.Amount; i++)
{
haveMaterialIDList.Add(currentItemUI.Item.ID);//这个格子里面有多少个物品 就存储多少个id
}
}
}
Formula matchedFormula = null;
foreach (Formula formula in formulaList)
{
bool isMatch = formula.Match(haveMaterialIDList);
if (isMatch)
{
matchedFormula = formula; break;
}
}
if (matchedFormula != null)
{
Knapsack.Instance.StoreItem(matchedFormula.ResID);
//去掉消耗的材料
foreach (int id in matchedFormula.NeedIdList)
{
foreach (Slot slot in slots)
{
if (slot.transform.childCount > 0)
{
ItemUI itemUI = slot.transform.GetChild(0).GetComponent <ItemUI>();
if (itemUI.Item.ID == id && itemUI.Amount > 0)
{
itemUI.AddAmount(-1);
if (itemUI.Amount <= 0)
{
DestroyImmediate(itemUI.gameObject);
}
break;
}
}
}
}
}
}
private bool hasItem = false; // 辅助、补充
public void StoreItem(Item item, int amount = 1)
{
if (transform.childCount == 0)
{
GameObject go = Instantiate(ItemUIPrefab, transform);
ItemUI = go.GetComponent <ItemUI>();
ItemUI.SetItem(item, amount);
hasItem = true; // hasItem
}
else if (ItemUI.Item.ID == item.ID)
{
ItemUI.AddAmount(amount); /// 未检查容量 默认不写参数 amount
}
}
/// <summary>
/// 把item放在自身下面
/// 如果自身下面有item了，amountPicked++
/// 如果没有，根据itemPrefab去实例化一个item，放在下面
/// </summary>
/// <param name="item"></param>
public void StoreItem(Item item, int amount = 1)
{
if (transform.childCount == 0)
{
GameObject itemObj = GameObject.Instantiate(m_itemPerfab) as GameObject;
itemObj.transform.parent = this.transform;
itemObj.transform.localPosition = Vector3.zero;
itemObj.transform.localScale = Vector3.one;
itemObj.GetComponent <ItemUI>().SetItem(item, amount);
}
else
{
ItemUI itemObj = transform.GetChild(0).GetComponent <ItemUI>();
itemObj.AddAmount(amount);
}
}
/// <summary>
/// 把item放在自身下面
/// 如果自身下面已经有item了，amount++
/// 如果没有 根据itemPrefab去实例化一个item，放在下面
/// </summary>
/// <param name="item"></param>
public void StoreItem(Item item)
{
if ((int)transform.childCount > 0)
{
ItemUI itemUI = transform.GetChild(0).GetComponent <ItemUI>();
itemUI.AddAmount();
}
else
{
GameObject go = Resources.Load <GameObject>("Prefabs/Item");
GameObject itemGameObject = Instantiate(go);
itemGameObject.transform.SetParent(this.transform);
itemGameObject.transform.localPosition = Vector3.one;
itemGameObject.GetComponent <ItemUI>().SetItem(item);
ItemUI = itemGameObject.GetComponent <ItemUI>();
}
}
/// <summary>
/// 手里有东西的情况下按左键且物品栏内物品和手上物品相同
/// </summary>
public virtual void OnButtonLeftAndPickedItemIsSame()
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
if (InventoryManager.Instance.IsControl) //一个个放
{
if (currentItem.Amount < currentItem.Item.MaxStark) //还有容量
{
currentItem.AddAmount();
InventoryManager.Instance.RemoveItem();
}
else
{
return;
}
}
else
{
if (currentItem.Item.MaxStark > currentItem.Amount) //还有容量
{
int amounntRemained = currentItem.Item.MaxStark - currentItem.Amount;
if (amounntRemained >= InventoryManager.Instance.PickedItem.Amount) //完全放下
{
currentItem.SetAmount(currentItem.Amount + InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
else
{
currentItem.SetAmount(currentItem.Item.MaxStark);
InventoryManager.Instance.RemoveItem(amounntRemained);
}
}
else
{
return;
}
}
}
/// <summary>
/// 处理鼠标点击事件;
/// </summary>
/// <param name="eventData"></param>
public void OnPointerDown(PointerEventData eventData)
{
if (transform.childCount > 0) //格子下面的物体数量大于0
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>(); //当前格子下物体的数量
if (InventoryManager.Instance.isPickedItem == false) //鼠标上面没有物体
{
if (Input.GetKey(KeyCode.LeftControl)) //按下Control键的情况
{
int amountPicked = (currentItem.Amount + 1) >> 1;
InventoryManager.Instance.PickedupItem(currentItem.Item, amountPicked);
int amountRemained = currentItem.Amount - amountPicked;
if (amountRemained <= 0)//抽取箱子物体后,箱子物体数量<=0
{
Destroy(currentItem.gameObject);
}
else//抽取箱子物体后,箱子物体大于0
{
currentItem.SetAmount(amountRemained);//设置被拿走宝箱的剩余数量的物品
}
}
else//没按下control键
{
InventoryManager.Instance.PickedupItem(currentItem.Item, currentItem.Amount);//相当于将物品槽的信息复制给鼠标
Destroy(currentItem.gameObject);
}
}
else//鼠标上面有物体(currentItem 是ItemUI)
{
//箱子里的物品与鼠标上的物品是一样的类型
if (currentItem.Item.ID == InventoryManager.Instance.PickedItem.Item.ID)
{
if (Input.GetKey(KeyCode.LeftControl)) //按下control键
{
if (currentItem.Item.Capacity > currentItem.Amount) //当前格子的数量 > 目前存在的装备的数量,没装满
{
currentItem.AddAmount(); //增加装备数量;
InventoryManager.Instance.RemoveItem(); //鼠标上的物品的数量减一;
}
else//盒子装满了
{
return;
}
}
else //没有按下Control键
{
if (currentItem.Item.Capacity > currentItem.Amount)//当前物品槽还有容量
{
int amountReamin = currentItem.Item.Capacity - currentItem.Amount; //当前物品槽剩余的空间;
if (amountReamin >= InventoryManager.Instance.PickedItem.Amount) //空余容量>鼠标上个数
{
//设置当前物品槽的数量=当前槽数量 + 鼠标上的数量
currentItem.SetAmount(currentItem.Amount + InventoryManager.Instance.PickedItem.Amount);
//移出鼠标上的
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}//空余容量小于鼠标上的容量
else
{
currentItem.SetAmount(currentItem.Amount + amountReamin);
InventoryManager.Instance.RemoveItem(amountReamin);
}
}
else//当前物品槽没容量
{
Debug.Log("放不下了");
}
}
}
else//鼠标上的物体与当前物品槽的物品不同
{
Item item = currentItem.Item;
int amount = currentItem.Amount;
//将鼠标上的物品设置到物品槽中
currentItem.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);//物品槽设置
//将物品槽上的物品设置到鼠标中
InventoryManager.Instance.PickedItem.SetItem(item, amount);
}
}
}
else//当前储物格子为空的情况
{
if (InventoryManager.Instance.isPickedItem)//当前鼠标有东西
{
if (Input.GetKey(KeyCode.LeftControl))//按下control,个空格存东子 GetKey是持续监测,
{
StoreItem(InventoryManager.Instance.PickedItem.Item);
InventoryManager.Instance.RemoveItem();//鼠标上的数量-1;
}
else//没按空格键
{
//王物品槽一个一个存东西
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
StoreItem(InventoryManager.Instance.PickedItem.Item);
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
}
}
}
public virtual void OnPointerDown(PointerEventData eventData)
{
if (eventData.button == PointerEventData.InputButton.Right) //点击鼠标右键
{
if (InventoryManager.Instance.IsPickedItem == true)
{
return; //手上有东西时返回
}
if (transform.childCount > 0)
{
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (currentItemUI.item is Equipment || currentItemUI.item is Weapon) //如果当前物品为武器装备类型
{
CharacterPanel.Instance.PutOn(currentItemUI); //将物品放入装备槽中
InventoryManager.Instance.HideToolTipContent(); //隐藏信息提示框
CharacterPanel.Instance.UpdatePropertyText(); //更新人物属性
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
// 1.自身是空的
//1.1 鼠标上有物体(即 IsPickedItem = true)
//1.11 按下Ctrl 放置当前鼠标上物品的一个
//1.12 没有按下Ctrl 放置当前鼠标上物品的全部
//1.2 鼠标上没有有物体(即 IsPickedItem = false)
//1.21 返回，不处理
//2.自身不是空的
//2.1 鼠标上有物体(即 IsPickedItem = true)
//2.11 自身ID 等于 鼠标物品ID
//按下Ctrl 物品一个一个放入物品槽中
//没有按下Ctrl 物品全部放入物品槽中（判断Capacity是否够放 只能放一部分和全部都能你放下
//2.12 自身ID 不等于 鼠标物品ID
//PickedItem和当前物品交换
//2.2 鼠标上没有物体 (即 IsPickedItem = false)
//2.21 按下Ctrl 取得当前物品槽中物品的一半
//2.22 没有按下Ctrl 把当前物品槽里面的物品全部放到鼠标上
if (transform.childCount > 0) //自身不为空(有ItemUI)
{
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI>(); //当前物品的ItemUI
if (InventoryManager.Instance.IsPickedItem == false) //鼠标上没有物品时
{
if (Input.GetKey(KeyCode.LeftControl))
{
int tempAmount = (currentItemUI.Amount + 1) / 2; //当前物品一半的数量
InventoryManager.Instance.PickedItemUI(currentItemUI.item, tempAmount); //复制物品信息给PickedItem
int remainedAmount = currentItemUI.Amount - tempAmount; //当前物品剩余的数量
if (remainedAmount <= 0)
{
Destroy(currentItemUI.gameObject); //删除物品
}
else
{
currentItemUI.SetAmount(remainedAmount); //更新当前物品剩余的数量
}
}
else
{
InventoryManager.Instance.PickedItemUI(currentItemUI.item, currentItemUI.Amount);
Destroy(currentItemUI.gameObject); //删除物品
}
}
else //鼠标上有物品时
{
if (currentItemUI.item.Name == InventoryManager.Instance.PickedItem.item.Name)//自身ID 等于 鼠标物品ID
{
if (Input.GetKey(KeyCode.LeftControl))
{
if (currentItemUI.item.Capacity > currentItemUI.Amount) //当前物品容量大于当前物品已存在的个数
{
currentItemUI.AddAmount(); //数量加一
InventoryManager.Instance.ReducePickedItem(); //PickedItem减一
}
else
{
return;
}
}
else
{
if (currentItemUI.item.Capacity >= InventoryManager.Instance.PickedItem.Amount + currentItemUI.Amount)
{ // ↑ 当 当前物品容量大于鼠标上PickedItem个数 + 已储存个数 时，可全部存放下去
currentItemUI.AddAmount(InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.ReduceAllPickedItem();
}
else // 存放到满就无法存放
{
int tempAmount = currentItemUI.item.Capacity - currentItemUI.Amount;
currentItemUI.AddAmount(tempAmount);
InventoryManager.Instance.ReducePickedItem(tempAmount);
}
}
}
else // 交换鼠标上和物品槽中的物品
{
Item tempItem = currentItemUI.item;
int tempAmount = currentItemUI.Amount;
currentItemUI.SetItem(InventoryManager.Instance.PickedItem.item, InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.PickedItem.SetItem(tempItem, tempAmount);
}
}
}
// 1.自身是空的
//1.1 鼠标上有物体(即 IsPickedItem = true)
//1.11 按下Ctrl 放置当前鼠标上物品的一个
//1.12 没有按下Ctrl 放置当前鼠标上物品的全部
//1.2 鼠标上没有有物体(即 IsPickedItem = false)
//1.21 返回，不处理
else // 自身Slot物品槽为空
{
if (InventoryManager.Instance.IsPickedItem == true)
{
if (Input.GetKey(KeyCode.LeftControl))
{
CreateItem(InventoryManager.Instance.PickedItem.item);
InventoryManager.Instance.ReducePickedItem();
}
else
{
CreateItem(InventoryManager.Instance.PickedItem.item, InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.ReduceAllPickedItem();
}
}
else
{
return;
}
}
}
public override void OnPointerDown(PointerEventData eventData)
{
//鼠标右键 角色穿戴物品
if (eventData.button == PointerEventData.InputButton.Right)
{
if ((transform.childCount > 0) && !InventoryManager.Instance.IsPickedItem)
{
ItemUI itemUI = transform.GetChild(0).GetComponent <ItemUI>();
Character.Instance.PutOff(itemUI);
}
}
ItemUI pickedItem = InventoryManager.Instance.PickedItem;
//left 鼠标左键
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
//点击卡槽不为空
if (transform.childCount > 0)
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
//手上物品为空 捡起
if (!InventoryManager.Instance.IsPickedItem)
{
InventoryManager.Instance.PickupItem(currentItem.m_item, currentItem.m_amount);
InventoryManager.Instance.m_changeSlot = this;
DestroyImmediate(currentItem.gameObject);
}
//手上物品不为空 存放/替换
else
{
if (!IsRightItem(pickedItem.m_item))
{
return;
}
//手上的物品与卡槽内的物品id相同 存放
if (currentItem.m_item.m_ID == InventoryManager.Instance.PickedItem.m_item.m_ID)
{
if (currentItem.m_item.m_capacity > currentItem.m_amount)
{
//当前物品槽剩余的空间
int amountRemain = currentItem.m_item.m_capacity - currentItem.m_amount;
//可以完全放下
if (amountRemain > pickedItem.m_amount)
{
InventoryManager.Instance.PutDownItem();
currentItem.AddAmount(pickedItem.m_amount);
}
else
{
currentItem.AddAmount(amountRemain);
InventoryManager.Instance.RemoveItemByAmount(amountRemain);
}
}
}
//id不同 交换
else
{
//点击的物品和捡起的物品id不一致
Item item = currentItem.m_item;
int amount = currentItem.m_amount;
currentItem.SetItem(pickedItem.m_item, pickedItem.m_amount);
pickedItem.SetItem(item, amount);
}
}
}
else
{
//卡槽为空 手上有物品 存放
if (InventoryManager.Instance.IsPickedItem)
{
if (!IsRightItem(pickedItem.m_item))
{
return;
}
StoreItem(pickedItem.m_item, InventoryManager.Instance.PickedItem.m_amount);
InventoryManager.Instance.PutDownItem();
}
}
Character.Instance.UpdateProperty();
}
public virtual void OnPointerDown(PointerEventData eventData)
{
if (eventData.button == PointerEventData.InputButton.Right)
{
if (InventoryManager.Instance.IsPickedItem == false && transform.childCount > 0)
{
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (currentItemUI.Item is Equipment || currentItemUI.Item is Weapon)
{
Item currentItem = currentItemUI.Item;
currentItemUI.ReduceAmount(1);
if (currentItemUI.Amount <= 0)
{
DestroyImmediate(currentItemUI.gameObject);
InventoryManager.Instance.HideToolTip();
}
CharacterPanel.Instance.PutOn(currentItem);
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
if (transform.childCount > 0)
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
if (InventoryManager.Instance.IsPickedItem == false)
{
if (Input.GetKey(KeyCode.LeftControl))
{
int amountPicked = (currentItem.Amount + 1) / 2;
InventoryManager.Instance.PickupItem(currentItem.Item, amountPicked);
int amountRemined = currentItem.Amount - amountPicked;
if (amountRemined <= 0)
{
Destroy(currentItem.gameObject);
}
else
{
currentItem.SetAmount(amountRemined);
}
}
else
{
InventoryManager.Instance.PickupItem(currentItem.Item, currentItem.Amount);
Destroy(currentItem.gameObject);
}
}
else
{
if (currentItem.Item.Id == InventoryManager.Instance.PickedItem.Item.Id)
{
if (Input.GetKey(KeyCode.LeftControl))
{
if (currentItem.Item.Capacity > currentItem.Amount)
{
currentItem.AddAmount();
InventoryManager.Instance.RemoveItem();
}
else
{
return;
}
}
else
{
if (currentItem.Item.Capacity > currentItem.Amount)
{
int amountRemined = currentItem.Item.Capacity - currentItem.Amount;
if (amountRemined >= InventoryManager.Instance.PickedItem.Amount)
{
currentItem.SetAmount(currentItem.Amount + InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
else
{
currentItem.SetAmount(currentItem.Amount + amountRemined);
InventoryManager.Instance.RemoveItem(amountRemined);
}
}
else
{
return;
}
}
}
else
{
Item item = currentItem.Item;
int amount = currentItem.Amount;
currentItem.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.PickedItem.SetItem(item, amount);
}
}
}
else
{
if (InventoryManager.Instance.IsPickedItem)
{
if (Input.GetKey(KeyCode.LeftControl))
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
InventoryManager.Instance.RemoveItem();
}
else
{
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
}
else
{
return;
}
}
}
/// <summary>
/// 鼠标按下
/// </summary>
/// <param name="eventData"></param>
public virtual void OnPointerDown(PointerEventData eventData)
{
if (eventData.button == PointerEventData.InputButton.Right)
{
if (InventoryManager.Instance.IsPickedItem == false && transform.childCount > 0)
{
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (currentItemUI.Item is Equipment || currentItemUI.Item is Weapon)
{
currentItemUI.AddAmount(-1);
Item currentItem = currentItemUI.Item;
if (currentItemUI.Amount <= 0)
{
DestroyImmediate(currentItemUI.gameObject);
InventoryManager.Instance.HideToolTip();
}
CharacterPanel.Instance.PutOn(currentItem);
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
if (transform.childCount > 0)//点击的物品槽不为空
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
if (InventoryManager.Instance.IsPickedItem == false) //没有已选中的物品
{
if (Input.GetKey(KeyCode.LeftControl)) //按下ctrl,选中一半物品
{
int amountPicked = (currentItem.Amount + 1) / 2;
InventoryManager.Instance.PickupItem(currentItem.Item, amountPicked);
if (currentItem.Amount <= amountPicked)
{
Destroy(currentItem.gameObject);
}
else
{
currentItem.AddAmount(-amountPicked);
}
}
else//没有按下ctrl,选中所有物品
{
InventoryManager.Instance.PickupItem(currentItem.Item, currentItem.Amount);
Destroy(currentItem.gameObject);
}
}
else//有已经选中物品
{
if (currentItem.Item.ID == InventoryManager.Instance.PickedItem.Item.ID)//已选中物品id与格子中物品id相同
{
if (currentItem.Item.Capacity > currentItem.Amount) //有空余
{
if (Input.GetKey(KeyCode.LeftControl)) //按下ctrl,放置一个
{
currentItem.AddAmount();
InventoryManager.Instance.RemoveItem();
}
else//没有按下ctrl,尽量放下所有
{
int amountRemain = currentItem.Item.Capacity - currentItem.Amount;
if (amountRemain >= InventoryManager.Instance.PickedItem.Amount)//剩余容量大于等于已选中,放下所有
{
currentItem.AddAmount(InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
else//剩余容量不足已选中,放下相当于剩余容量的数量
{
currentItem.AddAmount(amountRemain);
InventoryManager.Instance.RemoveItem(amountRemain);
}
}
}
else//没有空余
{
return;
}
}
else//已选中物品id与格子中的物品id不同
{
//Item item = currentItem.Item;
//int amount = currentItem.Amount;
//currentItem.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);
//InventoryManager.Instance.PickedItem.SetItem(item, amount);
InventoryManager.Instance.PickedItem.Exchange(currentItem);
}
}
}
else//点击的物品槽为空
{
if (InventoryManager.Instance.IsPickedItem == true)//有已选中物品
{
if (Input.GetKey(KeyCode.LeftControl))//按下ctrl,放下一个
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
InventoryManager.Instance.RemoveItem();
}
else//没有按下ctrl,放下所有
{
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
}
else//没有已选中物品
{
return;
}
}
}
public virtual void OnPointerDown(PointerEventData eventData)
{
if (eventData.button == PointerEventData.InputButton.Right)
{ //如果点击了鼠标右键 则执行穿戴操作
if (transform.childCount > 0 && InventoryManager.Instance.IspickedItem == false)
{ //大于0 说明物品槽上有物品
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
if (currentItem.item is Equipment || currentItem.item is Weapon)
{
CharacterPanel.Instance.PutOn(currentItem);
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
if (transform.childCount > 0)
{ //此时说明物品槽上有物品
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>(); //获取此时物品槽上物品的引用
if (InventoryManager.Instance.IspickedItem == false)
{ //即鼠标上没有被选中物品 此时将物品槽上的物品加到鼠标上
if (Input.GetKey(KeyCode.LeftControl))
{ //如果持续按下左Ctrl键则将一般物品放到鼠标上
//此处执行物品信息到鼠标上pickedItem的信息传递
int amountPicked = (currentItem.amount + 1) / 2;
int currentRemain = currentItem.amount - amountPicked;//当前物品槽上物品还剩余多少
InventoryManager.Instance.SetPickedItem(currentItem.item, amountPicked, this.transform);
if (currentRemain <= 0)
{
Destroy(currentItem.gameObject);
InventoryManager.Instance.SetCurrenSlot(true);
}
else
{
currentItem.SetAmount(currentRemain);
InventoryManager.Instance.SetCurrenSlot(false);
}
}
else//否则即将所有物品都放到鼠标上
{
InventoryManager.Instance.SetPickedItem(currentItem.item, currentItem.amount, this.transform);
Destroy(currentItem.gameObject);
InventoryManager.Instance.SetCurrenSlot(true);
}
}
else
{ //即是说鼠标上已经有物品了
if (currentItem.item.id == InventoryManager.Instance.PickedItem.item.id)
{ //判断当前槽上的物品是否与鼠标上的物品一样，如果一样的话执行如下操作
if (Input.GetKey(KeyCode.LeftControl))
{ //如果此时按下了ctrl键，那么将鼠标上的物品放到槽上一个，否则全部放上去
if (currentItem.item.capacity > currentItem.amount)
{ //判断物品槽上物品是否已经装满，若没装满则还可以继续装，若装满，则不执行放入操作，直接返回即可
InventoryManager.Instance.RemoveItem(); //默认减少一个
currentItem.AddAmount(); //物品槽上的物品数量默认增加一个
}
else
{
return;
}
}
else
{ //没有按ctrl的时候，如果槽上有足够的空间，那么就将所有的物品都放到槽上去，如果空间不足，就将槽装满即可
if (currentItem.item.capacity > currentItem.amount)
{ //判断物品槽上物品是否已经装满，若没装满则还可以继续装，若装满，则不执行放入操作，直接返回即可
int remainCapacity = currentItem.item.capacity - currentItem.amount;
if (remainCapacity >= InventoryManager.Instance.GetPickedAmount())
{ //即预留的空间大于鼠标上的物品数量 那么将鼠标上所有物品都放到槽上去
//因为两次都使用了，pickedItem上的数量值所以下面这两句的顺序不能改变，
currentItem.AddAmount(InventoryManager.Instance.GetPickedAmount()); //物品槽上的物品数量增加为鼠标上的物品数量
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.GetPickedAmount()); //将鼠标上的信息减少到0
}
else
{//否则即说明，物品槽上的空间不足那么只将物品槽装满即可
InventoryManager.Instance.RemoveItem(remainCapacity);
currentItem.AddAmount(remainCapacity);
}
}
else
{
return;
}
}
}
else
{//物品槽上的物品与鼠标上的物品不相同，此时交换这两个物品槽上的物品
print(InventoryManager.Instance.IsItemSlot);
if (InventoryManager.Instance.IsItemSlot == true)
{ //即 当被取得物品槽上所有物品都被选取的情况下，才可以执行交换方法，像那种只拾取了一部分的，不允许执行交换操作
InventoryManager.Instance.SetItemParent(currentItem); //设置当前物品槽上物品的父对象
//将鼠标上的物品放到当前物品槽上，此时需要另外创建新对象
for (int i = 0; i < InventoryManager.Instance.GetPickedAmount(); i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.item);
if (InventoryManager.Instance.PickedItem.amount == i + 1)
{
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.amount);
}
}
}
}
}
}
else
{ //否则说明物品槽上没有物品
if (InventoryManager.Instance.IspickedItem == true)
{ //如果鼠标上有物品，那么要将物品放到空槽上
if (Input.GetKey(KeyCode.LeftControl))
{ //若果按下ctrl键 那么将鼠标上的物品一个放入空格子，不用考虑第二次在这个语句中的操作，因为第二次，槽上就有物品了，点击鼠标执行的事件，将是上面的操作
this.StoreItem(InventoryManager.Instance.PickedItem.item);
InventoryManager.Instance.RemoveItem();
}
else
{//不按下ctrl时将所有物品都放入到槽上
for (int i = 0; i < InventoryManager.Instance.PickedItem.amount; i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.item);
if (InventoryManager.Instance.PickedItem.amount == i + 1)
{
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.amount);
}
}
}
}
}
}
/// <summary>
/// 物品槽内，鼠标按下
/// </summary>
/// <param name="eventData"></param>
public virtual void OnPointerDown(PointerEventData eventData)
{
// 右键直接穿上装备
if (eventData.button == PointerEventData.InputButton.Right)
{
if (!InventoryManager.Instance.IsPickedItem && transform.childCount > 0)
{
ItemUI currentitemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (currentitemUI.Item is Equipment || currentitemUI.Item is Weapon)
{
// 装备从背包移动到装备槽中
Item tempItem = currentitemUI.Item;
currentitemUI.ReduceAmount(1);
if (currentitemUI.Amount <= 0)
{
DestroyImmediate(currentitemUI.gameObject);
InventoryManager.Instance.HideToolTip();
}
Character.Instance.PutOn(tempItem);
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
/*
* 格子是空的：
* 1、IsPickedItem == true，则把拖拽的物品放入格子里
* 1.1、按下Ctrl键，一次只放入一个物品
* 1.2、没按Ctrl键，一次放完全部物品
* 2、IsPickedItem == false，不做任何处理
* 格子不是空的：
* 1、IsPickedItem == true
* 1.1、pickedItem.id == 格子里的物品id
* 1.1.1、按下Ctrl键，一次只放入一个物品
* 1.1.1.1、当前格子的剩余容量足够，可以放入物品
* 1.1.1.2、当前格子的剩余容量不够，直接返回
* 1.1.2、没按Ctrl键，一次放完全部物品
* 1.1.2.1、当前格子的剩余容量足够，可以完全放下所有物品
* 1.1.2.2、当前格子的剩余容量不够，只能放下部分物品
* 1.2、pickedItem.id ！= 格子里的物品id，则将pickedItem与格子里的物品交换
* 2、IsPickedItem != true，拾取格子里的物品，变为选中的物品pickedItem
* 2.1、按下Ctrl键，取出一半物品（向上取整）放到pickedItem上
* 2.2、没按Ctrl键，取出所有物品放到pickedItem上
*/
if (transform.childCount > 0) // 格子不是空的
{
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (!InventoryManager.Instance.IsPickedItem) // pickedItem为空，拾取格子里的物品，变为选中的物品pickedItem
{
if (Input.GetKey(KeyCode.LeftControl)) // 按下Ctrl键，取出一半物品（向上取整）放到pickedItem上
{
int amountPicked = (currentItemUI.Amount + 1) / 2;
InventoryManager.Instance.PickUpItem(currentItemUI.Item, amountPicked);
int amountRemained = currentItemUI.Amount - amountPicked;
if (amountRemained <= 0) // 格子里是否还有剩余个数
{
Destroy(currentItemUI.gameObject); // 销毁格子里的物品
}
else
{
currentItemUI.SetAmount(amountRemained);
}
}
else // 没按Ctrl键，取出所有物品放到pickedItem上
{
InventoryManager.Instance.PickUpItem(currentItemUI.Item, currentItemUI.Amount);
Destroy(currentItemUI.gameObject); // 销毁格子里的物品
}
}
else // 格子里有物品，且PickedItem不为空
{
if (currentItemUI.Item.ID == InventoryManager.Instance.PickedItem.Item.ID) // 格子里的物品ID == PickedItem.ID
{
if (Input.GetKey(KeyCode.LeftControl)) // 按下Ctrl键，一次只放入一个物品
{
if (currentItemUI.Item.Capacity > currentItemUI.Amount) // 格子剩余容量足够
{
currentItemUI.AddAmount(); // 格子里的物品数量+1
InventoryManager.Instance.RemoveItem(); // 手上的物品数量-1
}
else
{
return; // 格子剩余容量不够
}
}
else // 没按Ctrl键，一次放完全部物品
{
if (currentItemUI.Item.Capacity > currentItemUI.Amount) // 格子还有剩余容量
{
// 当前物品槽剩余的容量
int amountRemain = currentItemUI.Item.Capacity - currentItemUI.Amount;
if (amountRemain >= InventoryManager.Instance.PickedItem.Amount) // 可以完全放得下
{
currentItemUI.AddAmount(InventoryManager.Instance.PickedItem.Amount); // 格子里的物品数量+N
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount); // 手上的物品数量-N
}
else // 只能放下部分数量
{
currentItemUI.AddAmount(amountRemain); // 格子里的物品数量+N
InventoryManager.Instance.RemoveItem(amountRemain); // 手上的物品数量-N
}
}
else
{
return; // 格子剩余容量不够
}
}
}
else // pickedItem.id ！= 格子里的物品id，将pickedItem与格子里的物品交换
{
// 交换前格子里的物品及数量
Item item = currentItemUI.Item;
int amount = currentItemUI.Amount;
// 手上的物品 --放到--> 格子里
currentItemUI.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);
// 格子里的物品 --放到--> 手上
InventoryManager.Instance.PickedItem.SetItem(item, amount);
}
}
}
else // 格子是空的
{
/*
* 1、IsPickedItem == true，则把拖拽的物品放入格子里
* 1.1、按下Ctrl键，一次只放入一个物品
* 1.2、没按Ctrl键，一次放完全部物品
* 2、IsPickedItem == false，不做任何处理
*/
if (InventoryManager.Instance.IsPickedItem) // 格子为空，且手上有东西，则东西放入格子里
{
if (Input.GetKey(KeyCode.LeftControl)) // 按下Ctrl键，放入一个物品
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item); // 格子里新建一个物品子物体，个数为1
InventoryManager.Instance.RemoveItem(); // 手上物品个数-1
}
else // 没按Ctrl键，一次放完全部物品
{
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item); // 格子里的物品数量+1
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount); // 手上物品个数-N
}
}
else
{
return; // 不做任何处理
}
}
}
virtual public void OnPointerDown(PointerEventData eventData)
{
//鼠标右键 角色穿戴物品
if (eventData.button == PointerEventData.InputButton.Right)
{
if ((transform.childCount > 0) && !InventoryManager.Instance.IsPickedItem)
{
ItemUI itemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (itemUI.m_item is Weapon || itemUI.m_item is Equipment)
{
//当前物品数量减一 数量为0则销毁
itemUI.ReduceAmount(1);
if (itemUI.m_amount <= 0)
{
InventoryManager.Instance.HideToolTip();
DestroyImmediate(itemUI.gameObject);
}
//穿戴物品
Character.Instance.PutOn(itemUI.m_item);
}
}
}
//left 鼠标左键
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
ItemUI pickedItem = InventoryManager.Instance.PickedItem;
//自身不为空
if (transform.childCount > 0)
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
//当前捡起任何物品
if (!InventoryManager.Instance.IsPickedItem)
{
if (Input.GetKey(KeyCode.LeftControl))
{
int amountPicked = (currentItem.m_amount + 1) / 2;
InventoryManager.Instance.PickupItem(currentItem.m_item, amountPicked);
InventoryManager.Instance.m_changeSlot = this;
if (currentItem.m_amount - amountPicked == 0)
{
Destroy(currentItem.gameObject);
}
else
{
currentItem.ReduceAmount(amountPicked);
}
}
else
{
InventoryManager.Instance.PickupItem(currentItem.m_item, currentItem.m_amount);
InventoryManager.Instance.m_changeSlot = this;
Destroy(currentItem.gameObject);
}
}
else
{
//捡起的物品与点击的武器id判断
if (currentItem.m_item.m_ID == InventoryManager.Instance.PickedItem.m_item.m_ID)
{
if (Input.GetKey(KeyCode.LeftControl))
{
if (currentItem.m_item.m_capacity > currentItem.m_amount)
{
currentItem.AddAmount();
InventoryManager.Instance.RemoveItemByAmount(1);
}
}
else
{
if (currentItem.m_item.m_capacity > currentItem.m_amount)
{
//当前物品槽剩余的空间
int amountRemain = currentItem.m_item.m_capacity - currentItem.m_amount;
//可以完全放下
if (amountRemain > pickedItem.m_amount)
{
InventoryManager.Instance.PutDownItem();
currentItem.AddAmount(pickedItem.m_amount);
}
else
{
currentItem.AddAmount(amountRemain);
InventoryManager.Instance.RemoveItemByAmount(amountRemain);
}
}
}
}
else
{
//点击的物品和捡起的物品id不一致
InventoryManager.Instance.ExchangeItem(currentItem);
}
}
}
else
{
if (InventoryManager.Instance.IsPickedItem)
{
if (Input.GetKey(KeyCode.LeftControl))
{
StoreItem(pickedItem.m_item);
InventoryManager.Instance.RemoveItemByAmount(1);
}
else
{
StoreItem(pickedItem.m_item, InventoryManager.Instance.PickedItem.m_amount);
InventoryManager.Instance.PutDownItem();
}
}
}
}
public virtual void OnPointerDown(PointerEventData eventData)
{
#region
//自身为空
//1、IsPickedItem==true
//摁下ctrl 放置当前鼠标上的物品的一个
//没有摁下ctrl 放置当前鼠标上的物品的所有
//2、IsPickedItem==false 不做任何处理
//自身不为空
//1、IsPickedItem==false
//摁下ctrl 取得当前物品槽中物品的一半
//没有摁下ctrl 取得当前物品槽中所有的物品
//2、IsPickedItem==true
//自身ID!=pickedItem.id pickedItem跟当前物品交换
//自身id==pickedItem.id
//摁下ctrl 放置当前鼠标上的物品的一个
//没有摁下ctrl
//可以完全放下鼠标上的物品
//只能放下鼠标上物品的一部分
#endregion
if (eventData.button == PointerEventData.InputButton.Right)
{
if (InventoryManager.Instance.M_IsPickedItem == false && transform.childCount > 0)
{
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (currentItemUI.M_Item is Equipment || currentItemUI.M_Item is Weapon)
{
currentItemUI.ReduceAmount(1);
Item currentItem = currentItemUI.M_Item;
if (currentItemUI.M_Amount <= 0)
{
Destroy(currentItemUI.gameObject);
InventoryManager.Instance.HideToolTip();
}
CharacterPanel.M_Instance.PutOn(currentItem);
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
if (transform.childCount > 0)//点击的物品槽不为空
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
if (InventoryManager.Instance.M_IsPickedItem == false)//点击的物品槽不为空 并且当前鼠标上没有任何物品
{
if (Input.GetKey(KeyCode.LeftControl))
{
int amountPicked = (currentItem.M_Amount + 1) / 2;
InventoryManager.Instance.PickUpItem(currentItem.M_Item, amountPicked);
int amountRemained = currentItem.M_Amount - amountPicked;
if (amountRemained <= 0)
{
Destroy(currentItem.gameObject);
}
else
{
currentItem.SetAmount(amountRemained);
}
}
else
{
InventoryManager.Instance.PickUpItem(currentItem.M_Item, currentItem.M_Amount);
Destroy(currentItem.gameObject);
}
}
else//点击的物品槽不为空 并且当前鼠标上有物品
{
if (currentItem.M_Item.M_ID == InventoryManager.Instance.M_PickedItem.M_Item.M_ID)//点击的物品槽不为空 当前鼠标上有物品 并且当前鼠标上的物品和点击的物品ID相同
{
if (Input.GetKey(KeyCode.LeftControl))
{
if (currentItem.M_Item.M_Capacity > currentItem.M_Amount)//如果当前物品槽还有容量
{
currentItem.AddAmount();
InventoryManager.Instance.RemoveItem();
}
else
{
return;
}
}
else
{
if (currentItem.M_Item.M_Capacity > currentItem.M_Amount)
{
int amountRemain = currentItem.M_Item.M_Capacity - currentItem.M_Amount;
if (amountRemain >= InventoryManager.Instance.M_PickedItem.M_Amount)
{
currentItem.SetAmount(currentItem.M_Amount + InventoryManager.Instance.M_PickedItem.M_Amount);
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.M_PickedItem.M_Amount);
}
else
{
currentItem.SetAmount(currentItem.M_Amount + amountRemain);
InventoryManager.Instance.RemoveItem(amountRemain);
}
}
else
{
return;
}
}
}
else//点击的物品槽不为空 当前鼠标上有物品 并且当前鼠标上的物品和点击的物品ID不同
{
Item item = currentItem.M_Item;
int amount = currentItem.M_Amount;
currentItem.SetItem(InventoryManager.Instance.M_PickedItem.M_Item, InventoryManager.Instance.M_PickedItem.M_Amount);
InventoryManager.Instance.M_PickedItem.SetItem(item, amount);
}
}
}
else//当前点击的物品槽为空
{
if (InventoryManager.Instance.M_IsPickedItem == true)
{
if (Input.GetKey(KeyCode.LeftControl))
{
this.StoreItem(InventoryManager.Instance.M_PickedItem.M_Item);
InventoryManager.Instance.RemoveItem();
}
else
{
for (int i = 0; i < InventoryManager.Instance.M_PickedItem.M_Amount; i++)
{
this.StoreItem(InventoryManager.Instance.M_PickedItem.M_Item);
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.M_PickedItem.M_Amount);
}
}
else
{
return;
}
}
}
public void OnEndDrag(PointerEventData eventData)
{
GameObject go = eventData.pointerCurrentRaycast.gameObject; //获取到鼠标终点位置下 可能的物体
if (go == null) //如果放置点没有检测到格子
{
//这个条件是避免从这里脱出的时候 加出上限
if (transform.childCount == 0)
{
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
//else if (transform.GetComponentInChildren<ItemUI>().Amount < transform.GetComponentInChildren<ItemUI>().Item.Capacity)
//{
// for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
// {
// this.StoreItem(InventoryManager.Instance.PickedItem.Item);
// }
// InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
//}
}
else if (go.transform.childCount == 0) //当前物品槽自身为空的情况下
{
if (InventoryManager.Instance.IsPickedItem == true) //手上有东西
{
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
go.GetComponent <Slot>().StoreItem(InventoryManager.Instance.PickedItem.Item);
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
else//手上没东西
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
}
}
else if (go.transform.childCount == 1)//当前物品槽有物品
{
ItemUI currentItem = go.transform.GetChild(0).GetComponent <ItemUI>();
if (InventoryManager.Instance.IsPickedItem == true) //当前的鼠标上有物品
{
if (currentItem.Item.ID == InventoryManager.Instance.PickedItem.Item.ID) //同id的物品
{
if (currentItem.Item.Capacity > currentItem.Amount) //当前的物品槽还有容量
{
int amountRemain = currentItem.Item.Capacity - currentItem.Amount; //当前物品槽剩余空间
if (InventoryManager.Instance.PickedItem.Amount > amountRemain) //手上大于 剩余量
{
currentItem.SetAmount(currentItem.Amount + amountRemain);
InventoryManager.Instance.RemoveItem(amountRemain);
}
else//手上小于剩余量
{
currentItem.AddAmount(InventoryManager.Instance.PickedItem.Amount);//槽内加上手上的数量
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
}
else
{
return;
}
}
else//id不同的物品
{
Item item = currentItem.Item;
int amount = currentItem.Amount;
currentItem.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.PickedItem.SetItem(item, amount);
}
}
}
}
public virtual void OnPointerDown(PointerEventData eventData)
{
if (eventData.button == PointerEventData.InputButton.Right)
{
if (InventoryManager.Instance.IsPickedItem == false && transform.childCount > 0)
{
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (currentItemUI.Item is Equipment || currentItemUI.Item is Weapon)
{
currentItemUI.ReduceAmount(1);
Item currentItem = currentItemUI.Item;
if (currentItemUI.Amount <= 0)
{
DestroyImmediate(currentItemUI.gameObject);
InventoryManager.Instance.HideToolTip();
}
CharacterPanel.Instance.PutOn(currentItem);
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
//自身是空的1.IsPickedItem == true PickedItem放在这个位置
//按下ctrol放置当前鼠标上的物品的一个
//没有按下ctrol 放置当前鼠标上的物品的所有
//2IsPickedItem == flase 不做任何处理
//自身不是
//IsPickedItem == true PickedItem与当前物品交换进行交换
//自身的id==pickedItem.id//
// //按下ctrol放置当前鼠标上的物品的一个
//没有按下ctrol 放置当前鼠标上的物品的所有
//可以完全放下
//只能放下其中一部分
//自身的id!=pickedItem.id 跟当前物体交换
//2IsPickedItem == false把当前物品槽里的物品放在鼠标
//ctrl按下，取得当前物品槽中物品的一半，
//没有按下ctrl，把当前物品槽的物品放到鼠标上
if (transform.childCount > 0)
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
if (InventoryManager.Instance.IsPickedItem == false) //当前没有选中任何物品（当前受伤没有任何物品，火者鼠标山没有任何物品）
{
if (Input.GetKey(KeyCode.LeftControl))
{
///TODO
int amountPicked = (currentItem.Amount + 1) / 2;
InventoryManager.Instance.PickupItem(currentItem.Item, amountPicked);
int amountRemained = currentItem.Amount - amountPicked;
if (amountRemained <= 0)
{
Destroy(currentItem.gameObject);
}
else
{
currentItem.SetAmount(amountRemained);
}
}
else
{
//把当前物品槽的信息，赋值geiPickedItem(跟随鼠标移动)
InventoryManager.Instance.PickupItem(currentItem.Item, currentItem.Amount);
Destroy(currentItem.gameObject); //销毁当前物品
}
}
else
{
//自身的id!=pickedItem.id 跟当前物体交换
//2IsPickedItem == false把当前物品槽里的物品放在鼠标
//ctrl按下，取得当前物品槽中物品的一半，
//没有按下ctrl，把当前物品槽的物品放到鼠标上
if (currentItem.Item.ID == InventoryManager.Instance.PickedItem.Item.ID)
{
if (Input.GetKey(KeyCode.LeftControl))
{
if (currentItem.Item.Capacity > currentItem.Amount)
{
//当前物品槽还有容量
currentItem.AddAmount();
InventoryManager.Instance.RemoveItem();
}
else
{
return;
}
}
else
{
if (currentItem.Item.Capacity > currentItem.Amount)
{
//当前物品槽还有容量
//当前物品槽剩余的空间
int amountReamin = currentItem.Item.Capacity - currentItem.Amount;
if (amountReamin >= InventoryManager.Instance.PickedItem.Amount)
{
currentItem.SetAmount(currentItem.Amount + InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
else
{
currentItem.SetAmount(amountReamin + currentItem.Amount);
InventoryManager.Instance.RemoveItem(amountReamin);
}
}
else
{
return;
}
}
}
else
{
Item item = currentItem.Item;
int amount = currentItem.Amount;
currentItem.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.PickedItem.SetItem(item, amount);
}
}
}
else
{
//自身是空的1.IsPickedItem == true PickedItem放在这个位置
//按下ctrol放置当前鼠标上的物品的一个
//没有按下ctrol 放置当前鼠标上的物品的所有数量
//2IsPickedItem == flase 不做任何处理
if (InventoryManager.Instance.IsPickedItem == true)
{
if (Input.GetKey((KeyCode.LeftControl)))
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
InventoryManager.Instance.RemoveItem();
}
else
{
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
}
else
{
return;
}
}
}
public virtual void OnPointerDown(PointerEventData eventData)
{
// 鼠标右键穿上装备
if (eventData.button == PointerEventData.InputButton.Right)
{
if (InventoryManager.Instance.IsPickedItem == false && transform.childCount > 0)
{
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI> ();
if (currentItemUI.Item is Equipment || currentItemUI.Item is Weapon)
{
currentItemUI.SubAmount(1);
Item currentItem = currentItemUI.Item;
if (currentItemUI.Amount <= 0)
{
DestroyImmediate(currentItemUI.gameObject);
InventoryManager.Instance.HideToolTip();
}
CharacterPanel.Instance.PutOn(currentItem);
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
// 当前格子有物品
if (transform.childCount > 0)
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI> ();
//当前没有选中任何物品( 当前手上没有任何物品)当前鼠标上没有任何物品
if (InventoryManager.Instance.IsPickedItem == false)
{
// 按住 control 拾取一半
if (Input.GetKey(KeyCode.LeftControl))
{
int amountPicked = (currentItem.Amount + 1) / 2;
InventoryManager.Instance.PickupItem(currentItem.Item, amountPicked);
int amountRemained = currentItem.Amount - amountPicked;
if (amountRemained <= 0)
{
Destroy(currentItem.gameObject); //销毁当前物品
}
else
{
currentItem.SetAmount(amountRemained);
}
} //拾取全部
else
{
InventoryManager.Instance.PickupItem(currentItem.Item, currentItem.Amount);
Destroy(currentItem.gameObject); //销毁当前物品
}
} // 当前手上已有物品
else
{
//如果是同一个物品
if (currentItem.Item.ID == InventoryManager.Instance.PickedItem.Item.ID)
{
// 一个一个的添加
if (Input.GetKey(KeyCode.LeftControl))
{
if (currentItem.Item.Capacity > currentItem.Amount) //当前物品槽还有容量
{
currentItem.AddAmount();
InventoryManager.Instance.PutBackItem();
}
else
{
return;
}
} // 添加全部
else
{
if (currentItem.Item.Capacity > currentItem.Amount)
{
int amountRemain = currentItem.Item.Capacity - currentItem.Amount; //当前物品槽剩余的空间
if (amountRemain >= InventoryManager.Instance.PickedItem.Amount)
{
currentItem.SetAmount(currentItem.Amount + InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.PutBackItem(InventoryManager.Instance.PickedItem.Amount);
}
else
{
currentItem.SetAmount(currentItem.Amount + amountRemain);
InventoryManager.Instance.PutBackItem(amountRemain);
}
}
else
{
return;
}
}
} //不是同一个物品,则交换选中的物品和格子中的物品
else
{
Item item = currentItem.Item;
int amount = currentItem.Amount;
currentItem.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.PickedItem.SetItem(item, amount);
}
}
} // 当前格子为空
else
{
if (InventoryManager.Instance.IsPickedItem == true)
{
if (Input.GetKey(KeyCode.LeftControl))
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
InventoryManager.Instance.PutBackItem();
}
else
{
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
}
InventoryManager.Instance.PutBackItem(InventoryManager.Instance.PickedItem.Amount);
}
}
else
{
return;
}
}
}
public virtual void OnPointerDown(PointerEventData eventData)
{
// 右键点击，穿戴装备
if (eventData.button == PointerEventData.InputButton.Right)
{
if (InventoryManager.Instance.IsPickedItem == false && transform.childCount > 0)
{
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (currentItemUI.Item is Equipment || currentItemUI.Item is Weapon)
{
currentItemUI.ReduceAmount(1);
Item currentItem = currentItemUI.Item;
if (currentItemUI.Amount <= 0)
{
DestroyImmediate(currentItemUI.gameObject);
InventoryManager.Instance.HideToolTip();
}
CharacterPanel.Instance.PutOn(currentItem);
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
// 自身不是空
if (transform.childCount > 0)
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
// 当前鼠标没有选中任何物品
if (InventoryManager.Instance.IsPickedItem == false)
{
// ctrl 按下，取得当前物品槽中物品的一半
if (Input.GetKey(KeyCode.LeftControl))
{
int amountPicked = (currentItem.Amount + 1) / 2; // 捡起的数量
InventoryManager.Instance.PickupItem(currentItem.Item, amountPicked);
int amountRemained = currentItem.Amount - amountPicked; // 余下的数量
if (amountRemained <= 0)
{
Destroy(currentItem.gameObject); // 销毁当前物品
}
else
{
currentItem.SetAmount(amountRemained); // 更新数量
}
}
// ctrl 没有按下，把当前物品槽里面的物品放到鼠标上
else
{
InventoryManager.Instance.PickupItem(currentItem.Item, currentItem.Amount);
Destroy(currentItem.gameObject); // 销毁当前物品
}
}
// 当前鼠标有选中物品
else
{
// 自身的 id == pickedItem.id，整合物品
if (currentItem.Item.ID == InventoryManager.Instance.PickedItem.Item.ID)
{
// 按下 ctrl，放置当前鼠标上的物品的一个，一个一个放置物品
if (Input.GetKey(KeyCode.LeftControl))
{
// 当前物品槽还有容量
if (currentItem.Item.Capacity > currentItem.Amount)
{
currentItem.AddAmount();
InventoryManager.Instance.RemoveItem();
}
else
{
return;
}
}
// 没有按下 ctrl，放置当前鼠标上的物品的所有
else
{
if (currentItem.Item.Capacity > currentItem.Amount)
{
int amountRemain = currentItem.Item.Capacity - currentItem.Amount; // 当前物品槽剩余的空间
// 容量够，可以完全放下
if (amountRemain >= InventoryManager.Instance.PickedItem.Amount)
{
currentItem.SetAmount(currentItem.Amount + InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
// 容量不够，只能放下其中一部分
else
{
currentItem.SetAmount(currentItem.Amount + amountRemain);
InventoryManager.Instance.RemoveItem(amountRemain);
}
}
else
{
return;
}
}
}
// 自身的 id != pickedItem.id，pickedItem 跟当前物品交换
else
{
Item item = currentItem.Item;
int amount = currentItem.Amount;
currentItem.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.PickedItem.SetItem(item, amount);
}
}
}
// 自身是空
else
{
// IsPickedItem == true，pickedItem 放在这个位置
if (InventoryManager.Instance.IsPickedItem == true)
{
// 按下 ctrl，放置当前鼠标上的物品的一个，一个一个放
if (Input.GetKey(KeyCode.LeftControl))
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
InventoryManager.Instance.RemoveItem();
}
// 没有按下 ctrl ，放置当前鼠标上所有的物品
else
{
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount); // 把手上的清空
}
}
// IsPickedItem == false，不做任何处理
else
{
return;
}
}
}
public void OnPointerDown(PointerEventData eventData)
{
//自身是空的
//（pickitem!=null）已选中格子，
//按下ctrl 放置当前鼠标上物品的一个
//不按下ctrl 放下当前鼠标物品的所有个数
//未选中格子 不作处理
//自身不为空
//已选中格子 物品交换
//如果自身id与选中格子上的物品的id相同
//可以全部放入
//只能放入一部分，剩下的仍在鼠标上
//id不同时，进行交换
//未选中格子 把当前格子的物品放到鼠标上
//按下ctrl 取出当前各自内物品的一半
//没有按下 全部取出
if (transform.childCount > 0)//点击的格子有物体
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
if (!InventoryManager.Instance().isPickItem)//当前拖拽框为空
{
if (Input.GetKey(KeyCode.LeftControl))
{
//按下ctrl,可取格子内一半的数量
int amountPicked = (currentItem.amount + 1) / 2;//一半的数值
InventoryManager.Instance().PickItem(currentItem.item, amountPicked);
int amountLast = currentItem.amount - amountPicked;
if (amountLast <= 0)//如果取完后格子内数量为0，则直接销毁
{
Destroy(currentItem.gameObject);
}
else
{
currentItem.SetAmount(amountLast);//设置数量
}
}
else
{
InventoryManager.Instance().PickItem(currentItem.item, currentItem.amount);//直接取出格子中所有数量
Destroy(currentItem.gameObject);
//把当前物品的信息赋值给拖拽框
}
}
else//当拖拽框不为空
{
//已选中格子 则物品交换
//如果自身id与选中格子上的物品的id相同
//可以全部放入
//只能放入一部分，剩下的仍在鼠标上
//id不同时，进行交换
if (currentItem.item.ID == InventoryManager.Instance().pickItem.item.ID)
//当前拖拽框物体与物品槽中物体相同，则可进行合并
{
if (Input.GetKey(KeyCode.LeftControl)) //按下ctrl时，每次从拖拽框放下一个物体
{
if (currentItem.item.Capacity > currentItem.amount) //当前格子物品还有容量
{
currentItem.AddAmount(); //每次增加一个数量
InventoryManager.Instance().RemoveItem(1);
}
else
{
return;
} //无容量时不作处理
}
else//没按下ctrl，直接进行合并
{
if (currentItem.item.Capacity > currentItem.amount) //当前格子还有容量时
{
int amountmain = currentItem.item.Capacity - currentItem.amount; //当前格子的剩余容量
if (amountmain >= InventoryManager.Instance().pickItem.amount) //如果剩余容量大于拖拽框内物体的容量
{
currentItem.AddAmount(InventoryManager.Instance().pickItem.amount); //当前格子数量增加
InventoryManager.Instance().RemoveItem(InventoryManager.Instance().pickItem.amount); //拖拽框数量减少
}
else//若剩余容量小于拖拽框物体的容量
{
currentItem.AddAmount(amountmain);
InventoryManager.Instance().RemoveItem(InventoryManager.Instance().pickItem.amount - amountmain);
}
}
else
{
return;
}
}
}
else//拖拽物体和格子物品不同 ,交换两者物品
{
Item item = currentItem.item;
int amount = currentItem.amount;
currentItem.SetItem(InventoryManager.Instance().pickItem.item, InventoryManager.Instance().pickItem.amount);
InventoryManager.Instance().pickItem.SetItem(item, amount);
}
}
}
else//点击的格子无物体时
{
if (InventoryManager.Instance().isPickItem)//当拖拽框不为空时
{
if (Input.GetKey(KeyCode.LeftControl)) //按下ctrl时，每次从拖拽框放下一个物体
{
storeItem(InventoryManager.Instance().pickItem.item); //存入一个物体
InventoryManager.Instance().RemoveItem(1);
}
else//把拖拽框所有物体放到格子中
{
for (int i = 0; i < InventoryManager.Instance().pickItem.amount; i++)//多次调用存入多个
{
storeItem(InventoryManager.Instance().pickItem.item);
}
InventoryManager.Instance().RemoveItem(InventoryManager.Instance().pickItem.amount);//拖拽框物体清空
}
}
else
{
return;
}
}
}
public void OnPointerDown(PointerEventData eventData)
{
if (transform.childCount > 0)//当前物品槽不为空时
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
if (InventoryManager.Instance.IsPickedItem == false)//当前手上没有任何物品
{
Debug.Log("使用");
}
else//手上有物品
{
if (currentItem.Item.ID == InventoryManager.Instance.PickedItem.Item.ID)//同id的物品
{
if (currentItem.Item.Capacity > currentItem.Amount) //当前的物品槽还有容量
{
int amountRemain = currentItem.Item.Capacity - currentItem.Amount; //当前物品槽剩余空间
if (InventoryManager.Instance.PickedItem.Amount > amountRemain) //手上大于 剩余量
{
currentItem.SetAmount(currentItem.Amount + amountRemain);
InventoryManager.Instance.RemoveItem(amountRemain);
}
else//手上小于剩余量
{
currentItem.AddAmount(InventoryManager.Instance.PickedItem.Amount);//槽内加上手上的数量
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
}
else
{
return;
}
}
else//id不同的物品
{
Item item = currentItem.Item;
int amount = currentItem.Amount;
currentItem.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.PickedItem.SetItem(item, amount);
}
}
}
else//点击的物品槽是空的时候
{
if (InventoryManager.Instance.IsPickedItem == true)//手上有东西
{
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
}
//自身是空的 1，pickedItem!=null 放置item到这个槽位
//按下ctrl
//没有按下ctrl //物品比较少一次取一个就不做ctrl了
//2 pickedItem==null 不做任何处理
//自身不是空 1，pickedItem!=null item与槽位上的物品交换
//槽位物品上的id==pickedItem//可以放的下和只能放下一部分
//是否按下了ctrl
//槽位物品上的id!=pickedItem 交换
//2 pickedItem==null 槽位上的物品和pickeditem交换
//是否按下ctrl
//if (transform.childCount > 0)//当前物品槽不为空时
//{
// ItemUI currentItem = transform.GetChild(0).GetComponent<ItemUI>();
// if (InventoryManager.Instance.IsPickedItem == false)//当前手上没有任何物品
// {
// //if (Input.GetKey(KeyCode.LeftControl))
// //{
// // int amountPicked = (currentItem.Amount + 1) / 2;
// // InventoryManager.Instance.PickupItem(currentItem.Item, amountPicked);
// // int amountRemained = currentItem.Amount - amountPicked;
// // if (amountRemained <= 0)
// // {
// // Destroy(currentItem.gameObject);
// // }
// // else
// // {
// // currentItem.SetAmount(amountRemained);
// // }
// //}
// InventoryManager.Instance.PickupItem(currentItem.Item, currentItem.Amount);
// Destroy(currentItem.gameObject);//销毁当前物品
// }
// else//当前的鼠标上有物品
// {
// if (currentItem.Item.ID == InventoryManager.Instance.PickedItem.Item.ID)//同id的物品
// {
// if (currentItem.Item.Capacity > currentItem.Amount)//当前的物品槽还有容量
// {
// int amountRemain = currentItem.Item.Capacity = currentItem.Item.Capacity - currentItem.Amount;//当前物品槽剩余空间
// if (InventoryManager.Instance.PickedItem.Amount > amountRemain)//手上大于 剩余量
// {
// currentItem.SetAmount(currentItem.Amount + amountRemain);
// InventoryManager.Instance.RemoveItem(amountRemain);
// }
// else//手上小于剩余量
// {
// currentItem.AddAmount(InventoryManager.Instance.PickedItem.Amount);//槽内加上手上的数量
// InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
// }
// }
// else
// {
// return;
// }
// }
// else//id不同的物品
// {
// }
// }
//}
//else//当前物品槽自身为空的情况下
//{
// if (InventoryManager.Instance.IsPickedItem == true)//手上有东西
// {
// for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
// {
// this.StoreItem(InventoryManager.Instance.PickedItem.Item);
// }
// InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
// }
// else//手上没东西
// {
// return;
// }
//}
}
public virtual void OnPointerDown(PointerEventData eventData)
{
if (eventData.button == PointerEventData.InputButton.Right)
{
if (InventoryManager.Instance.IsPickedItem == false && transform.childCount > 0)
{
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (currentItemUI.Item is Equipment || currentItemUI.Item is Weapon)
{
currentItemUI.ReduceAmount(1);
Item currentItem = currentItemUI.Item;
if (currentItemUI.Amount <= 0)
{
DestroyImmediate(currentItemUI.gameObject);
InventoryManager.Instance.HideToolTip();
}
CharacterPanel.Instance.PutOn(currentItem);
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
// 自身是空 1,IsPickedItem ==true pickedItem放在这个位置
// 按下ctrl 放置当前鼠标上的物品的一个
// 没有按下ctrl 放置当前鼠标上的物品的所有
//2,IsPickedItem==false 不做任何处理
// 自身不是空
//1,IsPickedItem==true
//自身的id==pickedItem.id
// 按下ctrl 放置当前鼠标上的物品的一个
// 没有按下ctrl 放置当前鼠标上的物品的所有
//可以完全放下
//只能放下其中一部分
//自身的id!=pickedItem.id pickedItem跟当前物品交换
//2,IsPickedItem==false
//ctrl按下 取得当前物品槽中物品的一半
//ctrl没有按下 把当前物品槽里面的物品放到鼠标上
if (transform.childCount > 0)
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
if (InventoryManager.Instance.IsPickedItem == false)//当前没有选中任何物品( 当前手上没有任何物品)当前鼠标上没有任何物品
{
if (Input.GetKey(KeyCode.LeftControl))
{
int amountPicked = (currentItem.Amount + 1) / 2;
InventoryManager.Instance.PickupItem(currentItem.Item, amountPicked);
int amountRemained = currentItem.Amount - amountPicked;
if (amountRemained <= 0)
{
Destroy(currentItem.gameObject);//销毁当前物品
}
else
{
currentItem.SetAmount(amountRemained);
}
}
else
{
InventoryManager.Instance.PickupItem(currentItem.Item, currentItem.Amount);
Destroy(currentItem.gameObject);//销毁当前物品
}
}
else
{
//1,IsPickedItem==true
//自身的id==pickedItem.id
// 按下ctrl 放置当前鼠标上的物品的一个
// 没有按下ctrl 放置当前鼠标上的物品的所有
//可以完全放下
//只能放下其中一部分
//自身的id!=pickedItem.id pickedItem跟当前物品交换
if (currentItem.Item.ID == InventoryManager.Instance.PickedItem.Item.ID)
{
if (Input.GetKey(KeyCode.LeftControl))
{
if (currentItem.Item.Capacity > currentItem.Amount)//当前物品槽还有容量
{
currentItem.AddAmount();
InventoryManager.Instance.RemoveItem();
}
else
{
return;
}
}
else
{
if (currentItem.Item.Capacity > currentItem.Amount)
{
int amountRemain = currentItem.Item.Capacity - currentItem.Amount;//当前物品槽剩余的空间
if (amountRemain >= InventoryManager.Instance.PickedItem.Amount)
{
currentItem.SetAmount(currentItem.Amount + InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
else
{
currentItem.SetAmount(currentItem.Amount + amountRemain);
InventoryManager.Instance.RemoveItem(amountRemain);
}
}
else
{
return;
}
}
}
else
{
Item item = currentItem.Item;
int amount = currentItem.Amount;
currentItem.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.PickedItem.SetItem(item, amount);
}
}
}
else
{
// 自身是空
//1,IsPickedItem ==true pickedItem放在这个位置
// 按下ctrl 放置当前鼠标上的物品的一个
// 没有按下ctrl 放置当前鼠标上的物品所有数量
//2,IsPickedItem==false 不做任何处理
if (InventoryManager.Instance.IsPickedItem == true)
{
if (Input.GetKey(KeyCode.LeftControl))
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
InventoryManager.Instance.RemoveItem();
}
else
{
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
}
else
{
return;
}
}
}
public override void OnPointerDown(PointerEventData eventData)
{
if (eventData.button == PointerEventData.InputButton.Right && InventoryManager.Instance.IsPickedItem == false)
{
if (transform.childCount > 0 && InventoryManager.Instance.IsPickedItem == false)
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
currentItem.ReduceAmount(1);
if (currentItem.Amount <= 0)
{
DestroyImmediate(currentItem.gameObject);
InventoryManager.Instance.HideToolTip();
}
VendorPanel.Instance.SellItem(currentItem.Item, true);
}
}
if (eventData.button == PointerEventData.InputButton.Left)
{
if (transform.childCount > 0) //物品槽不为空
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
if (InventoryManager.Instance.IsPickedItem == false)
{
if (InventoryManager.Instance.IsControl)
{
int amountPicked = (currentItem.Amount + 1) / 2;
InventoryManager.Instance.PickUpItem(currentItem.Item, amountPicked);
InventoryManager.Instance.PickedUpSlot(transform.GetComponent <Slot>());
int amounntRemained = currentItem.Amount - amountPicked;
if (amounntRemained <= 0)
{
Destroy(currentItem.gameObject);
}
else
{
currentItem.SetAmount(amounntRemained);
}
}
else
{
InventoryManager.Instance.PickUpItem(currentItem.Item, currentItem.Amount);
InventoryManager.Instance.PickedUpSlot(transform.GetComponent <Slot>());
Destroy(currentItem.gameObject);
}
}
else
{
if (currentItem.Item == InventoryManager.Instance.PickedItem.Item)
{
if (InventoryManager.Instance.IsControl) //一个个放
{
if (currentItem.Amount < currentItem.Item.MaxStark) //还有容量
{
if (VendorPanel.Instance.CanBuyItem(currentItem.Item))
{
VendorPanel.Instance.BuyItem(currentItem.Item, false);
}
currentItem.AddAmount();
InventoryManager.Instance.RemoveItem();
}
else
{
return;
}
}
else
{
if (currentItem.Item.MaxStark > currentItem.Amount) //还有容量
{
int amounntRemained = currentItem.Item.MaxStark - currentItem.Amount;
if (amounntRemained >= InventoryManager.Instance.PickedItem.Amount) //完全放下
{
if (VendorPanel.Instance.CanBuyItem(currentItem.Item, InventoryManager.Instance.PickedItem.Amount))
{
VendorPanel.Instance.BuyItem(currentItem.Item, false, InventoryManager.Instance.PickedItem.Amount);
currentItem.SetAmount(currentItem.Amount + InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
}
else
{
if (VendorPanel.Instance.CanBuyItem(currentItem.Item, amounntRemained))
{
VendorPanel.Instance.BuyItem(currentItem.Item, false, amounntRemained);
currentItem.SetAmount(currentItem.Item.MaxStark);
InventoryManager.Instance.RemoveItem(amounntRemained);
}
}
}
else
{
return;
}
}
}
//else //互换
//{
// InventoryManager.Instance.PickedItem.ExchangeItem(currentItem);
//}
}
}
else //物品槽为空
{
if (InventoryManager.Instance.IsPickedItem == true)
{
if (InventoryManager.Instance.IsControl) //一个个放
{
if (VendorPanel.Instance.CanBuyItem(InventoryManager.Instance.PickedItem.Item))
{
VendorPanel.Instance.BuyItem(InventoryManager.Instance.PickedItem.Item, false);
this.SetItem(InventoryManager.Instance.PickedItem.Item);
InventoryManager.Instance.RemoveItem();
}
}
else //全放
{
if (VendorPanel.Instance.CanBuyItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount))
{
VendorPanel.Instance.BuyItem(InventoryManager.Instance.PickedItem.Item, false, InventoryManager.Instance.PickedItem.Amount);
this.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
}
}
else
{
return;
}
}
}
}
public virtual void OnPointerDown(PointerEventData eventData)
{
if (eventData.button == PointerEventData.InputButton.Right)
{
if (BeibaoManager.Instance.IsPickedItem == false && transform.childCount > 0)
{
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (currentItemUI.Item is Zhuangbei || currentItemUI.Item is Wuqi)
{
currentItemUI.ReduceAmount(1);
Item currentItem = currentItemUI.Item;
if (currentItemUI.Amount <= 0)
{
DestroyImmediate(currentItemUI.gameObject);
BeibaoManager.Instance.HideToolTip();
}
Character_Panel.Instance.PutOn(currentItem);
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
//自身为空，第一种情况IsPickedItem == true pickedItem放在这个位置
//按下CTRL 放置当前鼠标上的物品的一个
//没有按下CTRL 放置当前鼠标上的物品的所有个数
//第二种情况 IsPickedItem == false 不做任何处理
//自身不为空，第一种情况IsPickedItem == true pickedItem跟当前物品交换
//自身的id==pickedItem.id
//按下CTRL 放置当前鼠标上的物品的一个
//没有按下CTRL 放置当前鼠标上的物品的所有个数
//可以完全放下（因为容量限制，物品的占格）
//只能放下一部分
//自身的id !=pickedItem.id pickedItem跟当前物品交换
// 第二种情况 IsPickedItem==false 把当前物品槽里面的物品放到鼠标上
//CTRL按下 取得当前物品槽的一半
//CTRL没有按下 把当前物品槽里面的物品放到鼠标上
if (transform.childCount > 0)
{
ItemUI currentItem = transform.GetChild(0).GetComponent <ItemUI>();
if (BeibaoManager.Instance.IsPickedItem == false)//当前没有选中任何物品（当前手上没有任何物品）（当前鼠标上没有任何物品）
{
if (Input.GetKey(KeyCode.LeftControl))
{
int amountPicked = (currentItem.Amount + 1) / 2;
BeibaoManager.Instance.PickupItem(currentItem.Item, amountPicked);
int amountRemained = currentItem.Amount - amountPicked;
if (amountRemained <= 0)
{
Destroy(currentItem.gameObject);//销毁当前物品
}
else
{
currentItem.SetAmount(amountRemained);
}
}
else
{
BeibaoManager.Instance.PickupItem(currentItem.Item, currentItem.Amount);
Destroy(currentItem.gameObject);//销毁当前物品
}
}
else
{
//自身不为空，第一种情况IsPickedItem == true pickedItem跟当前物品交换
//自身的id==pickedItem.id
//按下CTRL 放置当前鼠标上的物品的一个
//没有按下CTRL 放置当前鼠标上的物品的所有个数
//可以完全放下（因为容量限制，物品的占格）
//只能放下一部分
//自身的id !=pickedItem.id pickedItem跟当前物品交换
if (currentItem.Item.ID == BeibaoManager.Instance.PickedItem.Item.ID)
{
if (Input.GetKey(KeyCode.LeftControl))
{
if (currentItem.Item.Capacity > currentItem.Amount)//当前物品槽还有容量
{
currentItem.AddAmount();
BeibaoManager.Instance.RemoveItem();
}
else
{
return;
}
}
else
{
if (currentItem.Item.Capacity > currentItem.Amount)
{
int amountRemain = currentItem.Item.Capacity - currentItem.Amount;//当前物品槽剩余的空间
if (amountRemain >= BeibaoManager.Instance.PickedItem.Amount)
{
currentItem.SetAmount(currentItem.Amount + BeibaoManager.Instance.PickedItem.Amount);
BeibaoManager.Instance.RemoveItem(BeibaoManager.Instance.PickedItem.Amount);
}
else
{
currentItem.SetAmount(currentItem.Amount + amountRemain);
BeibaoManager.Instance.RemoveItem(amountRemain);
}
}
else
{
return;
}
}
}
else
{
Item item = currentItem.Item;
int amount = currentItem.Amount;
currentItem.SetItem(BeibaoManager.Instance.PickedItem.Item, BeibaoManager.Instance.PickedItem.Amount);
BeibaoManager.Instance.PickedItem.SetItem(item, amount);
}
}
}
else
{
//自身为空，第一种情况IsPickedItem == true pickedItem放在这个位置
//按下CTRL 放置当前鼠标上的物品的一个
//没有按下CTRL 放置当前鼠标上的物品的所有个数
//第二种情况 IsPickedItem == false 不做任何处理
if (BeibaoManager.Instance.IsPickedItem == true)
{
if (Input.GetKey(KeyCode.LeftControl))
{
this.StoreItem(BeibaoManager.Instance.PickedItem.Item);
BeibaoManager.Instance.RemoveItem();
}
else
{
for (int i = 0; i < BeibaoManager.Instance.PickedItem.Amount; i++)
{
this.StoreItem(BeibaoManager.Instance.PickedItem.Item);
}
BeibaoManager.Instance.RemoveItem(BeibaoManager.Instance.PickedItem.Amount);
}
}
else
{
return;
}
}
}
public virtual void OnPointerDown(PointerEventData eventData)
{
if (eventData.button == PointerEventData.InputButton.Right)
{
if (InventoryManager.Instance.IsPickedItem == false && transform.childCount > 0)
{
//Debug.Log("111111111=" + transform.GetChild(0).GetComponent<ItemUI>());
//Debug.Log("222222222=" + transform.GetComponent<ItemUI>());
ItemUI currentItemUI = transform.GetChild(0).GetComponent <ItemUI>();
if (currentItemUI.Item is Equipment || currentItemUI.Item is Weapon)
{
Item currentItem = currentItemUI.Item;
currentItemUI.ReducAmount(1);
if (currentItemUI.Amount <= 0)
{
DestroyImmediate(currentItemUI.gameObject);
InventoryManager.Instance.HideToolTip();
}
CharacterPanel.Instance.PutOn(currentItem);
}
}
}
if (eventData.button != PointerEventData.InputButton.Left)
{
return;
}
//自身是空
//1. IsPickedItem = true pickedItem放在这个位置
// 按下ctrl 放置当前鼠标上的物品的一个
// 没有按下ctrl 放置当前鼠标上的所有物品
//2. IsPickedItem == false 不做任何处理
//自身不为空
//1. IsPickedItem == true
//自身的id == pickedItem.id
// 按下ctrl 放置当前鼠标的物品的一个
// 没有按下ctrl 放置当前鼠标上的物品的所有
//完全可以放下
//只能放下其中的一部分
//自身的id != pickedItem.id pickedItem跟当前物品交换
//2.IsPickedItem == false
//ctrl按下 取得当前物品槽中物品的一半
//ctrl没有按下 把当前物品里面的物品放到鼠标上
if (transform.childCount > 0)
{
ItemUI currenItemui = transform.GetChild(0).GetComponent <ItemUI>();
if (InventoryManager.Instance.IsPickedItem == false) // 当前鼠标上没有任何物品
{
if (Input.GetKey(KeyCode.LeftControl))
{
int pickedAmount = (currenItemui.Amount + 1) / 2;
InventoryManager.Instance.PickUpItem(currenItemui.Item, pickedAmount);
int pickedAmoumtSurplus = currenItemui.Amount - pickedAmount;
if (pickedAmoumtSurplus <= 0)
{
Destroy(currenItemui.gameObject); //销毁当前物品
}
else
{
currenItemui.SetItemAmount(pickedAmoumtSurplus);
}
}
else
{
InventoryManager.Instance.PickUpItem(currenItemui.Item, currenItemui.Amount); //把当前物品的信息，复制费pickediem（跟随鼠标)
Destroy(currenItemui.gameObject); // 销毁当前物品
}
}
else
{
//TODO鼠标上存在物品
if (currenItemui.Item.ID == InventoryManager.Instance.PickedItem.Item.ID)
{
if (Input.GetKey(KeyCode.LeftControl))
{
if (currenItemui.Item.Capacity > currenItemui.Amount) //当前物品还有容量可以增加
{
currenItemui.AddAmount();
InventoryManager.Instance.RemoveItem();
}
else
{
return;
}
}
else
{
if (currenItemui.Item.Capacity > currenItemui.Amount)
{
int amountRemain = currenItemui.Item.Capacity - currenItemui.Amount; //当前物品剩余的空间
if (amountRemain >= InventoryManager.Instance.PickedItem.Amount)
{
currenItemui.SetItemAmount(currenItemui.Amount + InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
else
{
currenItemui.SetItemAmount(currenItemui.Amount + amountRemain);
InventoryManager.Instance.RemoveItem(amountRemain);
}
}
else
{
return;
}
}
}
else
{
//鼠标上的物品和格子中的物品交换
Item item = currenItemui.Item;
int amount = currenItemui.Amount;
currenItemui.SetItem(InventoryManager.Instance.PickedItem.Item, InventoryManager.Instance.PickedItem.Amount);
InventoryManager.Instance.PickedItem.SetItem(item, amount);
}
}
}
else
{
//自身是空 1. IsPickedItem = true pickedItem放在这个位置
// 按下ctrl 放置当前鼠标上的物品的一个
// 没有按下ctrl 放置当前鼠标上的所有物品
// 2. IsPickedItem == false 不做任何处理
if (InventoryManager.Instance.IsPickedItem == true)
{
if (Input.GetKey(KeyCode.LeftControl))
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
InventoryManager.Instance.RemoveItem();
}
else
{
for (int i = 0; i < InventoryManager.Instance.PickedItem.Amount; i++)
{
this.StoreItem(InventoryManager.Instance.PickedItem.Item);
}
InventoryManager.Instance.RemoveItem(InventoryManager.Instance.PickedItem.Amount);
}
}
else
{
return;
}
}
}