void PickupThrow()
{
if (pickupedObject != null)
{
pickupedObject.OnThrow();
pickupedObject = null;
}
else
{
Debug.Log("uh");
RaycastHit hit;
if (Physics.Raycast(raycastPoint.position, transform.TransformDirection(Vector3.forward), out hit, raycastLength))
{
Debug.Log(hit.transform.name);
pickupedObject = hit.transform.GetComponent <IPickupable>();
if (pickupedObject != null)
{
Debug.Log("Pickup");
hit.transform.GetComponent <IPickupable>().PickUp();
}
}
Debug.DrawRay(raycastPoint.transform.position, transform.TransformDirection(Vector3.forward) * hit.distance,
Color.yellow);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
IPickupable pickupable = collision.gameObject.GetComponent <IPickupable>();
//Debug.Log("Trigger: " + collision.gameObject.name);
Checkpoint c = collision.GetComponent <Checkpoint>();
if (collision.gameObject.GetComponent <Spike>() != null)
{
collision.gameObject.GetComponent <Spike>().MakeDamage(this);
}
if (pickupable != null)
{
pickupable.OnPickUp(this);
}
else if (collision.gameObject.GetComponent <IHazard>() != null)
{
collision.gameObject.GetComponent <IHazard>().MakeDamage(this);
}
else if (c != null)
{
if (!c.activated)
{
_checkpointPosition = collision.GetComponent <Checkpoint>().GetCheckpointPosition();
c.ActivateCheckpoint();
}
}
else if (collision.gameObject.GetComponent <IMovingPlatform>() != null)
{
Debug.Log("Parent");
collision.gameObject.GetComponent <IMovingPlatform>().ParentToPlatform(this.gameObject.transform);
}
}
private void InteractWithItemObject(ItemObject itemObject)
{
Debug.Assert(itemObject.Item != null);
IUsable usable = itemObject.Item as IUsable;
IPickupable pickupable = itemObject.Item as IPickupable;
IEquipable equipable = itemObject.Item as IEquipable;
IStackable stackable = itemObject.Item as IStackable;
if (usable != null)
{
usable.OnUse(_stats, itemObject);
}
else if (pickupable != null)
{
if (equipable != null && equipable.IsDurable && _equipment.EquipmentTable[equipable.EquipmentType].IsEmpty)
{
equipable.OnEquip(_equipment, _stats);
}
else if (stackable != null)
{
stackable.OnStack(_inventory);
}
else
{
pickupable.OnPutInInventory(_inventory);
}
pickupable.OnRemoveFromGround(itemObject);
}
}
public void PickUp(IPickupable item) // при поднятии предмета
{
switch (item.ItemType)
{
case PickUpItemType.Healthpack:
{
if (item is Healthpack healthPack)
{
_endurance += healthPack.HealingPower; // если подняли лечилку, то увеличиваем здоровье
EnduranceChanged.Invoke(_endurance);
}
break;
}
case PickUpItemType.Booster:
{
if (item is Boost booster)
{
StartCoroutine(BoostPickedUp(booster.BoostTime)); // на время включаем буст
}
break;
}
default:
break;
}
}
private void LeftClickItemIcon(object[] eventParams)
{
Debug.Assert(eventParams.Length == 1 && eventParams[0] is ItemIcon);
ItemIcon itemIcon = (ItemIcon)eventParams[0];
SlotPosition slotPosition = itemIcon.Position;
IPickupable pickupable = itemIcon.Item as IPickupable;
IEquipable equipable = itemIcon.Item as IEquipable;
if (_airItem.IsEmpty)
{
if (itemIcon.IsEquipmentIcon)
{
equipable.OnUnequip(_equipment, _stats);
}
else if (itemIcon.Item is IStackable)
{
EventManager.TriggerEvent(EventName.OPEN_SPLIT_SCREEN, eventParams);
return;
}
else
{
pickupable.OnRemoveFromInventory(_inventory, slotPosition);
}
pickupable.OnPutInAir(_airItem, slotPosition);
}
else
{
IPickupable pickupableAir = _airItem.Item as IPickupable;
if (slotPosition.RowIndex == EquipmentSlot.EQUIPMENT_SLOT_ROW_INDEX)
{
IEquipable equipableAir = _airItem.Item as IEquipable;
if (equipableAir == null)
{
Debug.Log("Not equipable");
return;
}
if ((Equipment.EquipmentType)slotPosition.SlotIndex != equipableAir.EquipmentType)
{
Debug.Log("Not the same equipment type");
return;
}
if (equipable.IsDurable == false)
{
Debug.Log("Not durable");
}
equipable.OnUnequip(_equipment, _stats);
pickupableAir.OnRemoveFromAir(_airItem);
equipableAir.OnEquip(_equipment, _stats);
pickupable.OnPutInAir(_airItem, slotPosition);
}
else
{
pickupable.OnRemoveFromInventory(_inventory, slotPosition);
pickupableAir.OnRemoveFromAir(_airItem);
pickupableAir.OnPutInInventory(_inventory, slotPosition);
pickupable.OnPutInAir(_airItem, slotPosition);
}
}
}
private void UnequipItemNoDurability(object[] eventParams)
{
Debug.Assert(eventParams.Length == 1 && eventParams[0] is Item);
IPickupable pickupable = eventParams[0] as IPickupable;
IEquipable equipable = eventParams[0] as IEquipable;
equipable.OnUnequip(_equipment, _stats);
pickupable.OnPutInInventory(_inventory);
}
private void OnTriggerEnter(Collider other)
{
IPickupable pickup = other.gameObject.GetInterface <IPickupable>();
if (pickup != null)
{
pickup.Pickup(Owner);
}
}
private void LeftClickWorld(object[] eventParams)
{
if (_airItem.IsEmpty)
{
return;
}
IPickupable pickupableAir = _airItem.Item as IPickupable;
pickupableAir.OnRemoveFromAir(_airItem);
pickupableAir.OnPutOnGround(transform.position);
}
public void InteractWith(PlayerController playerController)
{
if (playerController.CurrentPickup != null)
{
IPickupable garbage = playerController.CurrentPickup;
garbage.GetTransform().position = target.position;
PlayAnimation();
}
else
{
// Feedback nothing to throw away
}
}
private void Update()
{
bool justClicked = Input.GetMouseButtonDown(0);
bool clicked = Input.GetMouseButton(0);
var raycastTarget = Raycast();
if (pickup == null)
{
if (justClicked)
{
if (raycastTarget == null)
{
return;
}
var pickupable = raycastTarget.GetComponent <IPickupable>();
var clickable = raycastTarget.GetComponent <IClickable>();
if (pickupable != null)
{
pickup = pickupable;
pickup.PickUp();
}
else
{
clickable?.Click();
}
}
}
else
{
if (pickup.GetTransform() == null)
{
pickup = null;
return;
}
Vector3 force = (GetMousePos() - pickup.GetTransform().position) * holdForce * Time.deltaTime;
pickup.GetRigidbody().AddForce(force);
pickup.GetRigidbody().velocity = pickup.GetRigidbody().velocity * 0.9f;
if (!clicked)
{
pickup.Release();
pickup = null;
}
}
}
void Pickup(GameObject obj)
{
if (currentMode == PlayerMode.PLAYER)
{
Rigidbody2D picked = obj.GetComponent <Rigidbody2D> ();
pickedUp = obj.GetComponent <IPickupable>();
picked.transform.localRotation = Quaternion.identity;
picked.velocity = new Vector2(0f, 0f);
picked.bodyType = RigidbodyType2D.Kinematic;
picked.constraints = RigidbodyConstraints2D.FreezeAll;
obj.transform.parent = transform;
obj.transform.localPosition = new Vector3(0f, 0.52f, 0f);
currentMode = PlayerMode.PICKUP;
}
}
void OnTriggerStay2D(Collider2D coll)
{
if (coll.gameObject.GetComponent <IPickupable> () != null && Input.GetKeyDown(KeyCode.Joystick1Button17) && pickedUp == null)
{
coll.gameObject.GetComponent <IPickupable> ().Pickup(gameObject);
}
if (coll.gameObject.GetComponent <IStashTarget> () != null && Input.GetKeyDown(KeyCode.Joystick1Button17) && pickedUp != null)
{
if (pickedUp.GetGameObject().GetComponent <IStashable> () != null)
{
coll.gameObject.GetComponent <IStashTarget> ().StashInside(pickedUp.GetGameObject().GetComponent <IStashable>());
pickedUp.GetGameObject().transform.parent = null;
pickedUp.GetGameObject().SetActive(false);
pickedUp = null;
}
}
}
private void DropItem(object[] eventParams)
{
Debug.Assert(eventParams.Length == 1 && eventParams[0] is ItemIcon);
ItemIcon itemIcon = (ItemIcon)eventParams[0];
SlotPosition slotPosition = itemIcon.Position;
IPickupable pickupable = itemIcon.Item as IPickupable;
IEquipable equipable = itemIcon.Item as IEquipable;
if (slotPosition.RowIndex == EquipmentSlot.EQUIPMENT_SLOT_ROW_INDEX)
{
equipable.OnUnequip(_equipment, _stats);
}
else
{
pickupable.OnRemoveFromInventory(_inventory, itemIcon.Position);
}
pickupable.OnPutOnGround(transform.position);
}
private void ReturnAirItem(object[] eventParams)
{
if (_airItem.IsEmpty)
{
return;
}
SlotPosition originalPosition = _airItem.OriginalPosition;
Item itemAir = _airItem.Item;
IPickupable pickupableAir = itemAir as IPickupable;
IEquipable equipableAir = itemAir as IEquipable;
IStackable stackableAir = itemAir as IStackable;
pickupableAir.OnRemoveFromAir(_airItem);
if (originalPosition.RowIndex == EquipmentSlot.EQUIPMENT_SLOT_ROW_INDEX)
{
Equipment.EquipmentType equipmentType = (Equipment.EquipmentType)originalPosition.SlotIndex;
if (_equipment.EquipmentTable[equipmentType].IsEmpty)
{
equipableAir.OnEquip(_equipment, _stats);
}
else
{
pickupableAir.OnPutInInventory(_inventory);
}
}
else
{
if (stackableAir != null)
{
stackableAir.OnStack(_inventory, originalPosition);
}
else if (_inventory.IsItemEmpty(originalPosition))
{
pickupableAir.OnPutInInventory(_inventory, originalPosition);
}
else
{
pickupableAir.OnPutInInventory(_inventory);
}
}
}
public void ConsumeItem(SlotPosition slotPosition)
{
Item item = GetItem(slotPosition);
IPickupable pickupable = item as IPickupable;
IStackable stackable = item as IStackable;
if (stackable != null)
{
stackable.Count -= 1;
}
if (stackable == null || stackable.Count == 0)
{
pickupable.OnRemoveFromInventory(this, slotPosition);
}
UpdateCapacity();
EventManager.TriggerEvent(EventName.UPDATE_INVENTORY);
Debug.Log(this.ToString());
}
private void EquipItem(object[] eventParams)
{
Debug.Assert(eventParams.Length == 1 && eventParams[0] is ItemIcon);
if (_airItem.IsEmpty == false)
{
Debug.Log("Air Item is not null");
return;
}
ItemIcon itemIcon = (ItemIcon)eventParams[0];
IPickupable pickupable = itemIcon.Item as IPickupable;
IEquipable equipable = itemIcon.Item as IEquipable;
if (equipable == null)
{
Debug.Log("Not equipable");
return;
}
if (equipable.IsDurable == false)
{
Debug.Log("Not durable");
}
if (itemIcon.IsEquipmentIcon)
{
equipable.OnUnequip(_equipment, _stats);
pickupable.OnPutInInventory(_inventory);
}
else
{
Item equippedItem = _equipment.EquipmentTable[equipable.EquipmentType].Item;
pickupable.OnRemoveFromInventory(_inventory, itemIcon.Position);
if (equippedItem != null)
{
((IEquipable)equippedItem).OnUnequip(_equipment, _stats);
((IPickupable)equippedItem).OnPutInInventory(_inventory, itemIcon.Position);
}
equipable.OnEquip(_equipment, _stats);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (!collision.CompareTag("WeaponGround"))
{
IPickupable itemComponent = collision.GetComponent <IPickupable>();
if (itemComponent != null && loot == null)
{
Physics2D.IgnoreCollision(collider2D, collision);
loot = collision.gameObject;
GameObject newItem = Instantiate(collision.gameObject, EnemyTorso.transform);
newItem.GetComponent <Collider2D>().enabled = false;
newItem.GetComponent <MonoBehaviour>().enabled = false;
newItem.transform.localPosition = Vector3.left * .60f;
newItem.transform.right = newItem.transform.up;
newItem.transform.localScale /= 4;
collision.gameObject.SetActive(false);
}
}
}
void OnAction()
{
IPickupable target = targetRef.Get();
if (carrying)
{
target.OnDrop(this);
carrying = false;
}
else
{
if (target.CanPickup(this))
{
target.OnPickup(this);
carrying = true;
}
else
{
Debug.Log("Woops - can't pick up " + target.GetName() + " yet");
}
}
}
void OnTriggerStay2D(Collider2D collider)
{
if (collider.gameObject.CompareTag("Checkout"))
{
message = "Press E or Mouse 2 to Checkout";
if (Input.GetKeyDown(KeyCode.Mouse1) || Input.GetKeyDown(KeyCode.E))
{
UIManager.instance.EndGame(true, collider.gameObject.name);
message = "";
}
}
else
{
if (collider.CompareTag("WeaponGround"))
{
message = "Press E or Mouse 2 to Equip";
if (Input.GetKeyDown(KeyCode.Mouse1) || Input.GetKeyDown(KeyCode.E))
{
IPickupable itemComponent = collider.GetComponent <IPickupable>();
if (itemComponent != null)
{
DropWeapon();
itemComponent.pickUp();
defaultWeapon.gameObject.SetActive(false);
message = "";
}
}
}
else
{
IPickupable itemComponent = collider.GetComponent <IPickupable>();
if (itemComponent != null)
{
itemComponent.pickUp();
}
}
}
}
public void Pickup(IPickupable target)
{
// Drop carried thing so new thing can be picked up
if (Carrying)
{
Drop();
}
else
{
// If not carrying, hand will be disabled so need to enable it
Enable();
}
// Position will be the position of last Drop() so need to move to cursor again -> otherwise, won't move til next update
MoveToCursor();
held = target;
previousParent = target.gameObject.transform.parent; // Remember previous parent so hierarchy can be restored on Drop()
held.gameObject.transform.position = transform.position; // Set object as child and match position
held.gameObject.transform.parent = transform;
held.OnPickUp();
}
private void LeftClickItemSlot(object[] eventParams)
{
Debug.Assert(eventParams.Length == 1 && eventParams[0] is SlotPosition);
SlotPosition slotPosition = (SlotPosition)eventParams[0];
if (_airItem.IsEmpty)
{
return;
}
IPickupable pickupable = _airItem.Item as IPickupable;
if (slotPosition.RowIndex == EquipmentSlot.EQUIPMENT_SLOT_ROW_INDEX)
{
IEquipable equipable = _airItem.Item as IEquipable;
if (equipable == null)
{
Debug.Log("Not equipable");
return;
}
if ((Equipment.EquipmentType)slotPosition.SlotIndex != equipable.EquipmentType)
{
Debug.Log("Not the same equipment type");
return;
}
if (equipable.IsDurable == false)
{
Debug.Log("Not durable");
}
pickupable.OnRemoveFromAir(_airItem);
equipable.OnEquip(_equipment, _stats);
}
else
{
pickupable.OnRemoveFromAir(_airItem);
pickupable.OnPutInInventory(_inventory, slotPosition);
}
}
private void SplitStackableItem(object[] eventParams)
{
Debug.Assert(eventParams.Length == 2 && eventParams[0] is ItemIcon && eventParams[1] is int);
ItemIcon itemIcon = (ItemIcon)eventParams[0];
int splitCount = (int)eventParams[1];
Item item = itemIcon.Item;
SlotPosition slotPosition = itemIcon.Position;
IStackable stackable = (IStackable)item;
if (splitCount == stackable.Count)
{
IPickupable pickupable = (IPickupable)item;
pickupable.OnRemoveFromInventory(_inventory, slotPosition);
pickupable.OnPutInAir(_airItem, slotPosition);
}
else
{
Item splitItem = item.Copy();
((IStackable)splitItem).Count = splitCount;
((IPickupable)splitItem).OnPutInAir(_airItem, slotPosition);
stackable.OnSplit(_inventory, slotPosition, splitCount);
}
}
public IEnumerator TestPillCooldown()
{
GameObject pillGo = new GameObject();
pillGo.AddComponent <Pill>();
IPickupable pickup = pillGo.GetComponent <IPickupable>();
Assert.IsNotNull(pickup);
TestGrabber grabber = new TestGrabber();
Assert.IsTrue(pickup.CanPickup(grabber));
pickup.OnPickup(grabber);
Assert.IsFalse(pickup.CanPickup(grabber));
pickup.OnDrop(grabber);
// Should not be pickupable for 1 second of cooldown.
Assert.IsFalse(pickup.CanPickup(grabber));
// Wait for cooldown - then should be pickupable.
yield return(new WaitForSeconds(1.1f));
Assert.IsTrue(pickup.CanPickup(grabber));
}
private void Update()
{
RaycastHit hitInfo;
Ray ray = Camera.main.ScreenPointToRay(new Vector2(Screen.width * 0.5f, Screen.height * 0.5f));
if (Physics.Raycast(ray, out hitInfo, _maxPickupRange, _pickableItemLayers))
{
IPickupable pickableItem = hitInfo.collider.GetComponent <IPickupable>();
// Show text that tells the user to press a button to pickup.
_pickupText.gameObject.SetActive(true);
_pickupText.text = string.Format("Press 'LMB' to pickup <color=#EB6721>{0}</color>", pickableItem.DisplayName);
if (Input.GetMouseButtonDown(0))
{
// Pickup item
pickableItem.Pickup(gameObject);
}
}
else
{
_pickupText.gameObject.SetActive(false);
}
}
public override void HoldObject(IPickupable pickup)
{
throw new NotImplementedException();
}
public void Pickup(IPickupable held, Action OnDrop, Action OnCancel)
{
dropCallback = OnDrop;
cancelCallback = OnCancel;
Pickup(held);
}
public void SwapItem(IPickupable otherItem)
{
PickedUpObj.GetComponent <IPickupable>().Drop(this);
otherItem.Pickup(this);
}
void Clear()
{
held = null;
previousParent = null;
dropCallback = null;
cancelCallback = null;
}
public abstract void HoldObject(IPickupable pickup);
private void DoPickup(IPickupable pickupable, CookingPlayer pawn)
{
pickupable.HoldingPlayer = pawn;
CarriedProp = pickupable as ModelEntity;
}
private bool CanPickup(IPickupable pickupable)
{
Log.Info("Can Pickup called");
return(LastPickup.Relative >= 1 && !pickupable.HoldingPlayer.IsValid && !CarriedProp.IsValid);
}
public void Pickup(IPickupable held, Action OnDrop)
{
dropCallback = OnDrop;
Pickup(held);
}
public void Throw()
{
myAnim.SetBool("throwing", true);
pickedUp.Throw(facingRight, 10f);
pickedUp = null;
}
private void CheckPickup()
{
if (actionButtonDown)
{
//If we have an object...
if (currentItem != null)
{
//And we look at something...
IHolder holder = null;
RaycastHit hit;
if (UnityEngine.Physics.Raycast(cam.transform.position, cam.transform.forward, out hit, pickupRange))
{
//If it's a holder
holder = hit.collider.gameObject.GetComponent <IHolder>();
}
//If it isn't null..
if (holder != null && !holder.CheckHoldingObject())
{
//Make it hold our released object
IPickupable releasedObject = ReleaseObject();
releasedObject.GetGameObject().transform.position = hit.point + hit.normal * 0.1f;
holder.HoldObject(releasedObject);
audioSource.Play();
}
else
{
//Otherwise release our object
IPickupable releasedItem = ReleaseObject();
GameObject releasedGameObject = releasedItem.GetGameObject();
if (hit.collider != null)
{
releasedGameObject.transform.position = hit.point + hit.normal * 0.1f;
releasedGameObject.transform.rotation = Quaternion.LookRotation(hit.normal, Vector3.up);
}
}
}
else
{
//If we don't have an object and we are looking at something...
RaycastHit hit;
if (UnityEngine.Physics.Raycast(cam.transform.position, cam.transform.forward, out hit, pickupRange))
{
//If the item is a pickup...
IPickupable pickup = hit.collider.gameObject.GetComponent <IPickupable>();
if (pickup != null)
{
//Pick up the object
HoldObject(pickup);
}
else
{
//And we look at a holder...
IHolder holder = hit.collider.gameObject.GetComponent <IHolder>();
if (holder != null)
{
//And it holds an object...
if (holder.CheckHoldingObject())
{
//Get it from the holder
IPickupable releasedObject = holder.ReleaseObject();
releasedObject.GetGameObject().transform.position = hit.point + hit.normal * 0.1f;
HoldObject(releasedObject);
}
}
}
}
}
}
}
