public async Task <Result <BackpackItemModel> > Handle(AddBackpackItem request, CancellationToken cancellationToken)
{
var isValid = await _validator.IsValidAsync(request);
if (!isValid)
{
return(Result.Failure <BackpackItemModel>("Validation failed"));
}
var backpack = await _context.Backpacks.FirstAsync(x => x.Id == request.BackpackId, cancellationToken);
var backpackItem = new BackpackItem
{
Name = request.BackpackItem.Name,
BackpackCategory = (BackpackCategoryType)request.BackpackItem.CategoryType,
Amount = request.BackpackItem.Amount,
ExpirationDate = request.BackpackItem.ExpirationDate,
Backpack = backpack
};
await _context.AddAsync(backpackItem, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(new BackpackItemModel
{
Id = backpackItem.Id,
Name = backpackItem.Name,
Amount = backpackItem.Amount,
CategoryType = backpackItem.BackpackCategory,
ExpirationDate = backpackItem.ExpirationDate
});
}
public bool Equip(BackpackItem.Type type, bool forceUpdate = false)
{
if (type == equipedItem.type && !forceUpdate)
{
return(true);
}
if (type != BackpackItem.Type.None)
{
BackpackItem newItem = Arsenal.Instance.Get(type);
if (newItem)
{
MeshFilter mf = newItem.GetComponent <MeshFilter>();
if (mf)
{
equipedMesh.mesh = mf.mesh;
BackpackItem.Copy(newItem, equipedItem);
return(true);
}
}
}
else
{
equipedItem.Clear();
equipedMesh.mesh = null;
return(true);
}
return(false);
}
public bool ReturnToBackpack(bool cancelDrag, bool dragTheItem)
{
Backpack bp = BackpackManager.Instance.GetBackPack(DragAreaDefines.BattleInventory.DragAreaName);
bp.BackpackPanel.BackpackDragArea.GetMousePosOnThisArea(out Vector3 _, out Vector3 pos_local, out Vector3 pos_matrix, out GridPos gp_matrix);
InventoryItem ii = new InventoryItem(MechaComponentInfo, bp, gp_matrix);
ii.ItemContentInfo = MechaComponentInfo;
bool suc = bp.TryAddItem(ii);
if (suc)
{
if (cancelDrag)
{
isReturningToBackpack = true;
DragManager.Instance.CurrentDrag = null;
}
if (dragTheItem)
{
bp.ResetGrids(ii.OccupiedGridPositions_Matrix);
BackpackItem backpackItem = bp.BackpackPanel.GetBackpackItem(ii.GUID);
DragManager.Instance.CurrentDrag = backpackItem.gameObject.GetComponent <Draggable>();
backpackItem.RectTransform.anchoredPosition = pos_local;
ii.SetGridPosition(gp_matrix);
DragManager.Instance.CurrentDrag.SetOnDrag(true, null, DragManager.Instance.GetDragProcessor <BackpackItem>());
}
MechaComponentInfo.RemoveMechaComponentInfo();
PoolRecycle();
}
return(suc);
}
void CloseBackpack(BasePlayer player)
{
string uid = player.UserIDString;
if (activeBackpacks.ContainsKey(uid))
{
BaseEntity box = activeBackpacks[uid] as BaseEntity;
StorageContainer loot = box.GetComponent <StorageContainer>();
Backpack backpack = new Backpack();
foreach (Item item in loot.inventory.itemList)
{
BackpackItem backpackItem = new BackpackItem();
backpackItem.amount = item.amount;
backpackItem.blueprint = item.IsBlueprint();
backpackItem.itemid = item.info.itemid;
backpackItem.skinid = item.skin;
backpackItem.slot = item.position;
backpack.items.Add(backpackItem);
}
backpacks[uid] = backpack;
SaveData();
loot.inventory.itemList.Clear();
box.Kill();
activeBackpacks.Remove(uid);
SendChatMessage(player, "Backpack", "Backpack closed.");
ui.Draw(player);
}
}
public void PickUpItem(ItemPickupMsg msg)
{
ItemData itemData = itemTable.GetItem <ItemData>(msg.itemType, msg.table_id);
if (currentAmount + itemData.BackpackAmount > limitAmount)
{
Debug.Log("가방 공간이 부족함");
return;
}
items.Add(itemData);
switch (itemData.ItemType)
{
case CONST.eItemType.Backpack:
BackpackItem backpackItem = itemData as BackpackItem;
ChangeBackpack(backpackItem.BackpackCapacity);
break;
case CONST.eItemType.Weapon:
break;
case CONST.eItemType.Medicine:
break;
default:
Debug.LogErrorFormat("{0} is not supported yet", itemData.ItemType);
break;
}
currentAmount += itemData.BackpackAmount;
transform.root.BroadcastMessage(eMessage.CompletePickup.ToString(), msg);
}
// Devuelve falso si no fue posible reducir la cantidad de item porque no esta en la mochila o no hay suficiente
public bool reduceItem(BackpackItem item, int amount = 1)
{
bool canReduce = false;
for (int i = 0; i < items.Count; ++i)
{
if (items[i].name == item.name)
{
if (amount < quantities[i])
{
// Hay una mayor cantidad del item de la que se quiere reducir
canReduce = true;
quantities[i] -= amount;
}
else if (amount == quantities[i])
{
// Se reduce la cantidad total del item, item se borra del inventario
canReduce = true;
items.RemoveAt(i);
quantities.RemoveAt(i);
}
break;
}
}
return(canReduce);
}
public void addItem(BackpackItem item, int amount = 1)
{
bool inBackpack = false;
if (item.stackable)
{
for (int i = 0; i < items.Count; ++i)
{
if (items [i].name == item.name)
{
inBackpack = true;
quantities [i] += amount;
break;
}
}
if (!inBackpack)
{
items.Add(item);
quantities.Add(amount);
}
}
else
{
for (int i = 0; i < amount; ++i)
{
items.Add(item);
quantities.Add(1);
}
}
}
public void Add(BackpackItem item)
{
var ui = Instantiate(item.uiPrefab, transform, false);
ui.item = item;
// place below title
ui.transform.SetSiblingIndex(titles[item.type].GetSiblingIndex() + 1);
}
public static void Copy(BackpackItem source, BackpackItem destination)
{
Item.Copy(source, destination);
destination.type = source.type;
destination.load = source.load;
destination.toolFamily = source.toolFamily;
destination.capacity = source.capacity;
}
public void Pull(BackpackItem item)
{
// enabling user interaction
item.enabled = true;
item.Push(transform.rotation * (pullImpulse + UnityEngine.Random.insideUnitSphere * pullRandomMagnitude));
onItemPull?.Invoke(item);
}
public BackpackItemViewModel(BackpackItem item)
: base(item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
this._Item = item;
}
public void DoNewItem(int assetLibrarySetId)
{
var item = new BackpackItem()
{
UniqueId = new Random().Next(int.MinValue, int.MaxValue),
// TODO: check other item unique IDs to prevent rare collisions
AssetLibrarySetId = assetLibrarySetId,
};
var viewModel = new BackpackItemViewModel(item);
this.Slots.Add(viewModel);
this.SelectedSlot = viewModel;
}
public bool itemInBackpack(BackpackItem item)
{
bool result = false;
for (int i = 0; i < items.Count; ++i)
{
if (items[i].name == item.name)
{
result = true;
}
}
return(result);
}
public static Item AttachItemCopy(Item original, GameObject destination)
{
switch (original.itemType)
{
case Item.ItemType.Backpack:
BackpackItem backpack = destination.AddComponent <BackpackItem>();
BackpackItem.Copy(original as BackpackItem, backpack);
return(backpack);
case Item.ItemType.Body:
BodyItem body = destination.AddComponent <BodyItem>();
BodyItem.Copy(original as BodyItem, body);
return(body);
case Item.ItemType.Head:
HeadItem head = destination.AddComponent <HeadItem>();
HeadItem.Copy(original as HeadItem, head);
return(head);
case Item.ItemType.Horse:
HorseItem horse = destination.AddComponent <HorseItem>();
HorseItem.Copy(original as HorseItem, horse);
return(horse);
case Item.ItemType.Second:
SecondItem second = destination.AddComponent <SecondItem>();
SecondItem.Copy(original as SecondItem, second);
return(second);
case Item.ItemType.Shield:
ShieldItem shield = destination.AddComponent <ShieldItem>();
ShieldItem.Copy(original as ShieldItem, shield);
return(shield);
case Item.ItemType.Weapon:
WeaponItem weapon = destination.AddComponent <WeaponItem>();
WeaponItem.Copy(original as WeaponItem, weapon);
return(weapon);
case Item.ItemType.Resource:
ResourceItem resource = destination.AddComponent <ResourceItem>();
ResourceItem.Copy(original as ResourceItem, resource);
return(resource);
default:
Debug.LogError("Unsuported Item type");
return(null);
}
}
public void setBackpack(BackpackItem equipment)
{
ItemInventorySlot slot = new ItemInventorySlot();
if (equipment == null)
{
slot.setSlot(null, 0);
}
else
{
slot.setSlot(equipment, 1);
}
this.backpack.setSlotBackingInfo(slot);
}
public override PacketDistributed MergeFrom(pb::CodedInputStream input, PacketDistributed _base)
{
GCFateResult _inst = (GCFateResult)_base;
while (true)
{
uint tag = input.ReadTag();
switch (tag)
{
case 0:
{
return(_inst);
}
case 8: {
_inst.Operate = input.ReadInt32();
break;
}
case 18: {
SymInfo subBuilder = new SymInfo();
input.ReadMessage(subBuilder);
_inst.AddSymInfos(subBuilder);
break;
}
case 26: {
FateInfo subBuilder = new FateInfo();
input.ReadMessage(subBuilder);
_inst.AddFateInfos(subBuilder);
break;
}
case 34: {
BackpackItem subBuilder = new BackpackItem();
input.ReadMessage(subBuilder);
_inst.AddMarkItems(subBuilder);
break;
}
case 40: {
_inst.TranstType = input.ReadInt32();
break;
}
}
}
return(_inst);
}
public override void Deserialize(NetworkReader reader)
{
belt = new BeltInventory(0);
belt.Deserialize(reader);
backpack = Item.ReadItem(reader) as BackpackItem;
helmet = Item.ReadItem(reader) as HelmetItem;
upperBody = Item.ReadItem(reader) as UpperBodyItem;
lowerBody = Item.ReadItem(reader) as LowerBodyItem;
boots = Item.ReadItem(reader) as BootsItem;
leftClaw = Item.ReadItem(reader) as ClawItem;
rightClaw = Item.ReadItem(reader) as ClawItem;
cursorSlot = new ItemInventorySlot();
cursorSlot.Deserialize(reader);
}
private void DecodeJson()
{
for (int i = 0; i < this.ItemConfig.Count; i++)
{
int itemID = (int)this.ItemConfig[i]["ItemID"];
string itemName = ItemConfig[i]["ItemName"].ToString();
string itemDesc = ItemConfig[i]["ItemDesc"].ToString();
int itemType = (int)ItemConfig[i]["ItemType"];
string itemIcon = ItemConfig[i]["ItemIcon"].ToString();
string itemBgIcon = ItemConfig[i]["ItemBgIcon"].ToString();
int itemCount = (int)ItemConfig[i]["ItemCount"];
int itemQuality = (int)ItemConfig[i]["ItemQuality"];
int itemOperation = (int)ItemConfig[i]["ItemOperation"];
Debug.Log(itemID + " " + itemName + " " + itemDesc + " " + itemType + " " + itemIcon + " " + itemBgIcon + " " +
itemCount + " " + itemQuality + " " + itemOperation);
BackpackItem item = new BackpackItem(itemID, itemName, itemDesc, itemType, itemIcon, itemBgIcon, itemCount, itemQuality, itemOperation);
BackpackItemList.Add(item);
}
}
// Get pickable item
public GameObject GetPickable(BackpackItem.Type type, bool showName = false, bool destroyOnPick = true)
{
BackpackItem item = Get(type);
if (!item)
{
return(null);
}
GameObject go = Instantiate(pickablePrefab.gameObject);
go.name = type.ToString();
go.transform.parent = null;
go.transform.position = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
go.transform.localScale = Vector3.one;
go.AddComponent <InteractionType>().type = InteractionType.Type.pickableBackpack;
BackpackItem.Copy(item, go.AddComponent <BackpackItem>());
go.SetActive(true);
MeshFilter mf = item.gameObject.GetComponent <MeshFilter>();
SpecialPickableShopArsenal pickable = go.GetComponent <SpecialPickableShopArsenal>();
pickable.textmesh.text = go.name;
if (go.name.Length >= 8)
{
pickable.textmesh.characterSize *= 0.5f;
}
if (mf)
{
pickable.itemMesh.mesh = mf.mesh;
}
else
{
pickable.itemMesh.gameObject.SetActive(false);
}
pickable.body.gameObject.SetActive(false);
pickable.textmesh.gameObject.SetActive(showName);
go.GetComponent <Item>().destroyOnPick = destroyOnPick;
return(go);
}
public void Put(BackpackItem item)
{
// disabling user interaction
item.enabled = false;
// placing item
var transform = item.transform;
var rotation = transform.rotation;
TweenFactory.Tween(item, transform.position, slots[item.type].position, putDuration, TweenScaleFunctions.QuadraticEaseInOut, (t) =>
{
transform.position = t.CurrentValue;
transform.rotation = Quaternion.Lerp(rotation, slots[item.type].rotation, t.CurrentProgress);
}, null);
// adding item's ui
ui.Add(item);
onItemPut?.Invoke(item);
}
public static Backpack_SearchReturnProto GetProto(byte[] buffer)
{
Backpack_SearchReturnProto proto = new Backpack_SearchReturnProto();
using (MMO_MemoryStream ms = new MMO_MemoryStream(buffer))
{
proto.BackpackItemCount = ms.ReadInt();
proto.ItemList = new List <BackpackItem>();
for (int i = 0; i < proto.BackpackItemCount; i++)
{
BackpackItem _Item = new BackpackItem();
_Item.BackpackItemId = ms.ReadInt();
_Item.GoodsType = (byte)ms.ReadByte();
_Item.GoodsId = ms.ReadInt();
_Item.GoodsServerId = ms.ReadInt();
_Item.GoodsOverlayCount = ms.ReadInt();
proto.ItemList.Add(_Item);
}
}
return(proto);
}
public static Backpack_SearchReturnProto GetProto(MMO_MemoryStream ms, byte[] buffer)
{
Backpack_SearchReturnProto proto = new Backpack_SearchReturnProto();
ms.SetLength(0);
ms.Write(buffer, 0, buffer.Length);
ms.Position = 0;
proto.BackpackItemCount = ms.ReadInt();
proto.ItemList = new List <BackpackItem>();
for (int i = 0; i < proto.BackpackItemCount; i++)
{
BackpackItem _Item = new BackpackItem();
_Item.BackpackItemId = ms.ReadInt();
_Item.GoodsType = (byte)ms.ReadByte();
_Item.GoodsId = ms.ReadInt();
_Item.GoodsServerId = ms.ReadInt();
_Item.GoodsOverlayCount = ms.ReadInt();
proto.ItemList.Add(_Item);
}
return(proto);
}
public void CompletePickup(ItemPickupMsg msg)
{
switch (msg.itemType)
{
case CONST.eItemType.Weapon:
WeaponItem weapon = itemTable.GetItem <WeaponItem>(msg.itemType, msg.table_id);
currentWeapon.SetMember(weapon.IconPath, weapon.ItemName);
break;
case CONST.eItemType.Backpack:
BackpackItem backpackData = itemTable.GetItem <BackpackItem>(msg.itemType, msg.table_id);
backpack.SetMember(backpackData.IconPath, backpackData.ItemName);
break;
case CONST.eItemType.Helmet:
HelmetItem helmetData = itemTable.GetItem <HelmetItem>(msg.itemType, msg.table_id);
backpack.SetMember(helmetData.IconPath, helmetData.ItemName);
break;
case CONST.eItemType.Amour:
AmourItem amourData = itemTable.GetItem <AmourItem>(msg.itemType, msg.table_id);
backpack.SetMember(amourData.IconPath, amourData.ItemName);
break;
case CONST.eItemType.Bullet:
break;
case CONST.eItemType.Bandage:
break;
case CONST.eItemType.Medicine:
break;
default:
break;
}
}
public static Backpack_SearchReturnProto GetProto(byte[] buffer, bool isChild = false)
{
Backpack_SearchReturnProto proto = new Backpack_SearchReturnProto();
MMO_MemoryStream ms = null;
if (!isChild)
{
ms = GameEntry.Socket.SocketSendMS;
}
else
{
ms = GameEntry.Pool.DequeueClassObject <MMO_MemoryStream>();
}
ms.SetLength(0);
ms.Write(buffer, 0, buffer.Length);
ms.Position = 0;
proto.BackpackItemCount = ms.ReadInt();
proto.ItemList = new List <BackpackItem>();
for (int i = 0; i < proto.BackpackItemCount; i++)
{
BackpackItem _Item = new BackpackItem();
_Item.BackpackItemId = ms.ReadInt();
_Item.GoodsType = (byte)ms.ReadByte();
_Item.GoodsId = ms.ReadInt();
_Item.GoodsServerId = ms.ReadInt();
_Item.GoodsOverlayCount = ms.ReadInt();
proto.ItemList.Add(_Item);
}
if (isChild)
{
GameEntry.Pool.EnqueueClassObject(ms);
}
return(proto);
}
public void UpdateUI()
{
PlayerItems items = playerController.getCurrentPlayerItems();
RectTransform rectTrans = GetComponent <RectTransform> ();
int numberOfButtons = transform.childCount;
int numberOfItems = items.count();
// Se agregan botones si no hay suficientes
if (numberOfButtons < numberOfItems)
{
for (int i = numberOfButtons; i < numberOfItems; ++i)
{
int row = i / 6;
int column = i % 6;
GameObject newButton = Instantiate(button, new Vector2(65 * column + 5, -65 * row - 5), Quaternion.Euler(Vector3.zero)) as GameObject;
newButton.transform.SetParent(transform, false);
}
}
// Se colocan los items en los botones
int butt = 0;
foreach (Transform child in transform)
{
// Se modifica cada boton para que tenga la info de un item
GameObject theButton = child.gameObject;
if (butt < numberOfItems)
{
BackpackItem item = items.getItemByPosition(butt);
int amount = items.getAmountByPosition(butt);
theButton.SetActive(true);
// Se setea la imagen del boton
Image image = theButton.GetComponentsInChildren <Image>()[1];
image.sprite = item.image;
// Se setea la cantidad del item
Text text = theButton.GetComponentsInChildren <Text>()[0];
if (item.stackable)
{
text.text = amount.ToString();
}
else
{
text.text = "";
}
}
else
{
// Se deshabilita el boton
theButton.SetActive(false);
}
++butt;
}
// Se modifica la altura del panel segun la cantidad de items que hay
Vector2 sizeDelta = rectTrans.sizeDelta;
int rows = numberOfItems / 6;
if (numberOfItems % 6 != 0)
{
++rows;
}
if (rows <= 2)
{
int height = 65 * 2 + 5;
rectTrans.sizeDelta = new Vector2(sizeDelta.x, height);
}
else
{
int height = 65 * rows + 5;
rectTrans.sizeDelta = new Vector2(sizeDelta.x, height);
}
}
public BackpackItemViewModel(BackpackItem item)
: base(item)
{
this._BackpackItem = item ?? throw new ArgumentNullException(nameof(item));
}
public bool EquipInteraction(InteractionType.Type type, GameObject interactor)
{
bool success = false;
if (type == InteractionType.Type.pickableWeapon)
{
WeaponItem item = interactor.GetComponent <WeaponItem>();
if (item && playerController.weapon.Equip(item.type))
{
if (item.forbidSecond || playerController.secondHand.equipedItem.forbidWeapon)
{
if (playerController.secondHand.equipedItem.type != SecondItem.Type.None)
{
inventory.AddItem(playerController.secondHand.equipedItem.Summarize(), 1);
}
playerController.secondHand.Equip(SecondItem.Type.None);
}
if (item.forbidShield)
{
if (playerController.shield.equipedItem.type != ShieldItem.Type.None)
{
inventory.AddItem(playerController.shield.equipedItem.Summarize(), 1);
}
playerController.shield.Equip(ShieldItem.Type.None);
}
success = true;
playerController.needEquipementAnimationUpdate = true;
if (ToolDictionary.instance.tools.ContainsKey(playerController.weapon.equipedItem.toolFamily))
{
List <AudioClip> sounds = ToolDictionary.instance.tools[playerController.weapon.equipedItem.toolFamily].collectionSound;
audiosource.clip = sounds[Random.Range(0, sounds.Count)];
audiosource.Play();
}
}
}
else if (type == InteractionType.Type.pickableBackpack)
{
BackpackItem item = interactor.GetComponent <BackpackItem>();
if (item && playerController.backpack.Equip(item.type))
{
success = true;
}
playerController.needEquipementAnimationUpdate = true;
if (success)
{
inventory.capacity = item.capacity;
}
if (ToolDictionary.instance.tools.ContainsKey(playerController.backpack.equipedItem.toolFamily))
{
List <AudioClip> sounds = ToolDictionary.instance.tools[playerController.backpack.equipedItem.toolFamily].collectionSound;
audiosource.clip = sounds[Random.Range(0, sounds.Count)];
audiosource.Play();
}
}
else if (type == InteractionType.Type.pickableHead)
{
HeadItem item = interactor.GetComponent <HeadItem>();
if (item && playerController.head.Equip(item.type))
{
success = true;
playerController.needEquipementAnimationUpdate = true;
int index = Mathf.Clamp((int)HeadItem.getCategory(playerController.head.equipedItem.type), 0, wearHead.Count - 1);
audiosource.clip = wearHead[index];
audiosource.Play();
}
}
else if (type == InteractionType.Type.pickableSecond)
{
SecondItem item = interactor.GetComponent <SecondItem>();
if (item && playerController.secondHand.Equip(item.type))
{
if (item.forbidWeapon || playerController.weapon.equipedItem.forbidSecond)
{
if (playerController.weapon.equipedItem.type != WeaponItem.Type.None)
{
inventory.AddItem(playerController.weapon.equipedItem.Summarize(), 1);
}
playerController.weapon.Equip(WeaponItem.Type.None);
}
if (item.forbidShield)
{
if (playerController.shield.equipedItem.type != ShieldItem.Type.None)
{
inventory.AddItem(playerController.shield.equipedItem.Summarize(), 1);
}
playerController.shield.Equip(ShieldItem.Type.None);
}
success = true;
playerController.needEquipementAnimationUpdate = true;
}
}
else if (type == InteractionType.Type.pickableShield)
{
ShieldItem item = interactor.GetComponent <ShieldItem>();
if (item && playerController.shield.Equip(item.type))
{
if (playerController.weapon.equipedItem.forbidShield)
{
if (playerController.weapon.equipedItem.type != WeaponItem.Type.None)
{
inventory.AddItem(playerController.weapon.equipedItem.Summarize(), 1);
}
playerController.weapon.Equip(WeaponItem.Type.None);
}
if (playerController.secondHand.equipedItem.forbidShield)
{
if (playerController.secondHand.equipedItem.type != SecondItem.Type.None)
{
inventory.AddItem(playerController.secondHand.equipedItem.Summarize(), 1);
}
playerController.secondHand.Equip(SecondItem.Type.None);
}
success = true;
playerController.needEquipementAnimationUpdate = true;
}
}
else if (type == InteractionType.Type.pickableBody)
{
BodyItem item = interactor.GetComponent <BodyItem>();
bool mounted = playerController.horse ? playerController.horse.equipedItem.type != HorseItem.Type.None : false;
if (item && playerController.body.Equip(item.type, mounted))
{
success = true;
playerController.needEquipementAnimationUpdate = true;
int index = Mathf.Clamp((int)BodyItem.getCategory(playerController.body.equipedItem.type), 0, wearBody.Count - 1);
audiosource.clip = wearBody[index];
audiosource.Play();
}
}
else if (type == InteractionType.Type.pickableHorse)
{
HorseItem item = interactor.GetComponent <HorseItem>();
if ((playerController.horse && item.type == HorseItem.Type.None) || (!playerController.horse && item.type != HorseItem.Type.None))
{
// change player template
PlayerController playerTemplate;
if (item.type == HorseItem.Type.None)
{
playerTemplate = Arsenal.Instance.playerTemplate;
}
else
{
playerTemplate = Arsenal.Instance.mountedPlayerTemplate;
}
PlayerController destination = Instantiate <PlayerController>(playerTemplate);
destination.gameObject.name = playerTemplate.gameObject.name;
// copy
PlayerController.MainInstance = destination;
PlayerController.Copy(playerController, destination);
MapStreaming.instance.focusAgent = destination.transform;
ConstructionSystem.instance.tpsController.target = destination.transform.Find("CameraTarget");
InteractionUI.instance.juicer = destination.interactionController.interactionJuicer;
destination.interactionController.PickableInteraction(type, interactor);
interactionJuicer.OnDelete();
Destroy(gameObject);
}
else
{
if (playerController.horse && item && playerController.horse.Equip(item.type))
{
success = true;
playerController.needEquipementAnimationUpdate = true;
int index = Mathf.Clamp((int)BodyItem.getCategory(playerController.body.equipedItem.type), 0, wearBody.Count - 1);
audiosource.clip = wearBody[index];
audiosource.Play();
bool mounted = playerController.horse ? playerController.horse.equipedItem.type != HorseItem.Type.None : false;
playerController.body.Equip(playerController.body.equipedItem.type, mounted, true);
inventory.onUpdateContent.Invoke();
}
}
}
if (success)
{
playerController.RecomputeLoadFactor();
}
return(success);
}
private void InitBoostData()
{
currentBackpackItem = User.Instance.getBackpackItem(ItemId);
currentBoostProduct = User.Instance.BoostProducts.Find(i => i.id == ItemId);
}
public void AddItem(string name, bool inheritOB)
{
GameObject itemObj = new GameObject(name); //Create the GameObject
imageObjects.Add(itemObj);
length++;
Image image = itemObj.AddComponent <Image>(); //Add the Image Component script
BackpackItem handler = itemObj.AddComponent <BackpackItem>(); //Add item-drag component
handler.itemScale = scaleAmount;
//物品判定
handler.canSpell = canSpellDictionary[name];
handler.canEquip = canEquipDictionary[name];
handler.canInteract = canInteractDictionary[name];
image.sprite = textureDictionary[name]; //Set the Sprite of the Image Component on the new GameObject
itemObj.tag = "BackpackItem";
RectTransform item_transform = itemObj.GetComponent <RectTransform>();
item_transform.SetParent(go.itemHolder.transform); //Assign the newly created Image GameObject as a Child of the Parent Panel, Canvas/Main UI.
item_transform.SetAsFirstSibling();
//更改物品的位置于背包UI内
if (length <= (currPageNumber + 1) * countPerPage && length > currPageNumber * countPerPage)
{
GameObject locationObj = go.itemPositionHolder.transform.GetChild(length - 1).gameObject;
item_transform.anchoredPosition = locationObj.GetComponent <RectTransform>().anchoredPosition;
}
else
{
GameObject locationObj = go.extraItemHolder;
item_transform.anchoredPosition = locationObj.GetComponent <RectTransform>().anchoredPosition;
}
//物品类型角标设置
GameObject itemIcon = new GameObject("ItemCanSpell");
Image itemIconImg = itemIcon.AddComponent <Image>();
itemIconImg.raycastTarget = false;
if (handler.canSpell)
{
itemIconImg.sprite = spellIcon;
}
else
{
itemIconImg.sprite = collectIcon;
}
RectTransform itemIconTransform = itemIcon.GetComponent <RectTransform>();
itemIconTransform.SetParent(itemObj.transform);
itemIconTransform.sizeDelta = new Vector2(20, 20);
itemIconTransform.anchoredPosition = new Vector2(20, -20);
// if (name.CompareTo("Heavenly Water") == 0) {
// item_transform.sizeDelta = new Vector2(60, 35);
// } else if (name.CompareTo("Changable Soil") == 0) {
// item_transform.anchoredPosition = item_transform.anchoredPosition + new Vector2(0, 5);
// item_transform.sizeDelta = new Vector2(45, 40);
// }
//check if Crutch is found
if (name == "OilLight")
{
oilLightFound = true;
}
//继承Ob相关属性
if (inheritOB)
{
ObItem backpackItemOb = itemObj.AddComponent <ObItem>();
backpackItemOb.correspondingOB = go.ob.GetComponent <ObManagement>().transferToBackpackItemOB;
backpackItemOb.correspondingOB.GetComponent <ObDisplay>().isPicked = true;
itemObj.SetActive(this.gameObject.activeSelf);
}
}
public bool EquipItem(EquipmentItem equip, bool rightSide)
{
if (equip is BackpackItem)
{
BackpackItem backpack = equip as BackpackItem;
info.backpack = backpack;
if (isLocalPlayer)
{
backpackUI.loadInventory(backpack.inventory);
equipUI.setBackpack(equip as BackpackItem);
}
return(true);
}
else if (equip is HelmetItem)
{
info.helmet = equip as HelmetItem;
if (isLocalPlayer)
{
equipUI.setHelmet(equip as HelmetItem);
}
return(true);
}
else if (equip is UpperBodyItem)
{
info.upperBody = equip as UpperBodyItem;
if (isLocalPlayer)
{
equipUI.setUpperBody(equip as UpperBodyItem);
}
return(true);
}
else if (equip is LowerBodyItem)
{
info.lowerBody = equip as LowerBodyItem;
if (isLocalPlayer)
{
equipUI.setLowerBody(equip as LowerBodyItem);
}
return(true);
}
else if (equip is BootsItem)
{
info.boots = equip as BootsItem;
if (isLocalPlayer)
{
equipUI.setBoots(equip as BootsItem);
}
return(true);
}
else if (equip is ClawItem)
{
if (rightSide)
{
info.rightClaw = equip as ClawItem;
if (isLocalPlayer)
{
equipUI.setRightClaw(equip as ClawItem);
}
}
else
{
info.leftClaw = equip as ClawItem;
if (isLocalPlayer)
{
equipUI.setLeftClaw(equip as ClawItem);
}
}
return(true);
}
return(false);
}
