void OnItemPick()
{
if (_player == null)
{
_player = UnityEngine.GameObject.FindGameObjectWithTag("Player");
}
if (_inventory == null && _player != null)
{
_inventory = _player.GetComponent <PlayerInventory>().inventory.GetComponent <Inventory>();
}
if (_inventory != null)
{
float distance = Vector3.Distance(this.gameObject.transform.position, _player.transform.position);
if (distance <= 3)
{
//bool check = _inventory.checkIfItemAllreadyExist(item.itemID, item.itemValue);
//if (check)
// Destroy(this.gameObject);
if (_inventory.ItemsInInventory.Count < (_inventory.width * _inventory.height))
{
DroppedItem item = (DroppedItem)KBEngineApp.app.findEntity(Utility.getPostInt(gameObject.name));
if (item != null)
{
item.pickUpRequest();
}
//_inventory.addItemToInventory(item.itemID, item.itemValue);
//_inventory.updateItemList();
//_inventory.stackableSettings();
//Destroy(this.gameObject);
}
}
}
}
public void Pickup()
{
DroppedItem itemForPickup = null;
int minDistance = Range;
foreach (var droppedItem in _data.DroppedItems)
{
if (_data.MainHero.RangeTo(droppedItem.Value) < minDistance &&
(!PickupMine || _data.MonstersToLoot.Contains(droppedItem.Value.SourceMobObjectId)) &&
(!_blockedDrop.ContainsKey(droppedItem.Key) || DateTime.Now.Subtract(_blockedDrop[droppedItem.Key]).TotalSeconds > 30) &&
(PickupAll ||
(PickupInclusive && RulesInUse.Any(rule => rule.Enable && rule.ItemId == droppedItem.Value.ItemId && rule.ConditionsAreMet(_data, droppedItem.Value))) ||
(PickupExclusive && !RulesInUse.Any(rule => rule.Enable && rule.ItemId == droppedItem.Value.ItemId && rule.ConditionsAreMet(_data, droppedItem.Value))))
)
{
itemForPickup = droppedItem.Value;
minDistance = (int)_data.MainHero.RangeTo(itemForPickup);
}
}
if (itemForPickup == null)
{
return;
}
if (minDistance > 150)
{
if (DateTime.Now.Subtract(_moveToStamp).TotalMilliseconds > 500)
{
_actionsController.MoveToRaw(itemForPickup.X, itemForPickup.Y, itemForPickup.Z);
_moveToStamp = DateTime.Now;
}
}
else
{
_actionsController.Pickup(itemForPickup.ObjectId);
int timeout = 0;
while (timeout < 30 && _data.DroppedItems.ContainsKey(itemForPickup.ObjectId))
{
Thread.Sleep(100);
if (timeout % 10 == 0)
{
_actionsController.Pickup(itemForPickup.ObjectId);
}
}
if (timeout == 30)
{
if (_blockedDrop.ContainsKey(itemForPickup.ObjectId))
{
_blockedDrop[itemForPickup.ObjectId] = DateTime.Now;
}
else
{
_blockedDrop.Add(itemForPickup.ObjectId, DateTime.Now);
}
}
}
}
public DroppedItem CreateItem(Vector2 pos, int lifeStoneAmount, int goldRate)
{
float droppedLifeStoneOffset = 0.33f;
DroppedItem temp = Instantiate(droppedItem, pos, Quaternion.identity);
LifeStoneInfo lifeStoneInfo = LifeStoneManager.Instance.CreateLifeStoneShape(lifeStoneAmount, goldRate);
temp.lifeStoneInfo = lifeStoneInfo;
for (int y = 0; y < lifeStoneInfo.size.y; y++)
{
for (int x = 0; x < lifeStoneInfo.size.x; x++)
{
if ((LifeStoneType)int.Parse(lifeStoneInfo.lifeStonePos[y * lifeStoneInfo.size.x + x].ToString()) != LifeStoneType.NULL)
{
Instantiate(droppedLifeStone, new Vector2(x, y) * droppedLifeStoneOffset, Quaternion.identity, temp.transform);
}
}
}
temp.GetComponent <BoxCollider2D>().size = (Vector2)lifeStoneInfo.size * droppedLifeStoneOffset;
temp.GetComponent <BoxCollider2D>().offset = (lifeStoneInfo.size - new Vector2(1, 1)) / 2 * droppedLifeStoneOffset;
temp.transform.Find("GroundCollider").GetComponent <BoxCollider2D>().size = (Vector2)lifeStoneInfo.size * droppedLifeStoneOffset;
temp.transform.Find("GroundCollider").GetComponent <BoxCollider2D>().offset = (lifeStoneInfo.size - new Vector2(1, 1)) / 2 * droppedLifeStoneOffset;
temp.isWeapon = false;
return(temp);
}
void OnEntityKill(BaseNetworkable entity)
{
if (entity == null)
{
return;
}
DroppedItem item = entity as DroppedItem;
if (item?.item?.info?.worldModelPrefab == null)
{
return;
}
if (!item.item.info.worldModelPrefab.isValid)
{
return;
}
RotatePickupComponent component;
if (rotatingItems.TryGetValue(entity, out component))
{
if (component)
{
UnityEngine.Object.Destroy(component);
}
rotatingItems.Remove(entity);
}
}
private void PickupItem(Player player, DroppedItem droppedItem)
{
// Check the Distance Player <> Item
double dist = player.GetDistanceTo(droppedItem);
if (dist > 3)
{
return;
}
// Check Inv Space
int slot = player.Inventory.CheckInvSpace(droppedItem.Item);
if (slot < 12)
{
return;
}
var success = droppedItem.TryPickUpBy(player);
if (success)
{
player.PlayerView.InventoryView.ItemAppear(droppedItem.Item);
}
// todo: "Obtained message" ?? guess not
}
void OnTriggerStay2D(Collider2D col)
{
DroppedItem di = col.GetComponent <DroppedItem>();
Entity e = col.GetComponent <Entity>();
Block b = col.GetComponent <Block>();
if (di != null)
{
di.GetComponent <Rigidbody2D>().velocity = (Vector2)transform.right * transportSpeed;
s.color = effect;
}
else if (e != null)
{
e.GetComponent <Rigidbody2D>().position += (Vector2)transform.right * transportSpeed * Time.deltaTime;
e.GetComponent <Rigidbody2D>().velocity *= 0.9f;
//e.GetComponent<Rigidbody2D>().position = Vector3.Lerp(e.GetComponent<Rigidbody2D>().position, transform.position, pullToCenterSpeed * Time.deltaTime);
}
else if ((b != null && b.fluid && moveLiquids) || (b != null && b.blockGravity && moveGravityBlocks))
{
if (liquidTransportCooldown <= 0)
{
liquidTransportCooldown = 1 / liquidTransportRate;
b.transform.position += transform.right;
}
}
}
public void PickupItem(DroppedItem other)
{
CheckCurrentBaseWeapon();
Debug.Log("Picked up " + other.name);
if (parts[other.itemID].isBaseWeapon && hasBaseWeapon)
{
foreach (Item i in parts)
{
if (i.isEnabled)
{
i.DropWeapon();
}
}
}
if (parts[other.itemID].isEnabled) // if the player already has the item
{
other.DestroyItem();
}
else
{
parts[other.itemID].isEnabled = true;
parts[other.itemID].GetComponent <SpriteRenderer>().enabled = true;
other.DestroyItem();
}
RenderItems();
}
/*
* Performs the items functionality for pickups on the player. Does not handle removing the item from the world
*/
public void PickUpItem(DroppedItem item)
{
switch (item.dropType)
{
case DroppedItem.EDropType.Points:
points += POINTS_COIN;
if (player_ui != null)
{
player_ui.AddKickerNumber(transform, POINTS_COIN);
}
break;
case DroppedItem.EDropType.Life:
timesHit = Mathf.Max(0, timesHit - 1);
break;
case DroppedItem.EDropType.Speed:
AddEffector(new Effector_Speed(), 5.0f);
break;
case DroppedItem.EDropType.AttackRadius:
// TODO:
break;
}
PlaySound(item.pickupSoundClip, 1.0f, 1.0f);
gameMode.OnItemPickup(item);
}
public virtual void PickupItem(GameObject itemObject)
{
DroppedItem itemComponent = itemObject.GetComponent <DroppedItem>();
inventory.AddItem(itemComponent.item, 1);
Destroy(itemObject);
}
private IEnumerator CreateAndPopulateSpears()
{
for (int i = 0; i < storedData.spearData.Count; i++)
{
StoredData.SpearData spearData = storedData.spearData[i];
BaseEntity spear = CreateWorldObject(spearData.itemId, string.Empty, spearData.Position, true);
spear.GetComponent <Rigidbody>().isKinematic = true;
spear.transform.rotation = Quaternion.Euler(spearData.Rotation);
List <DroppedItem> skulls = Pool.GetList <DroppedItem>();
for (int y = 0; y < spearData.trophyData.Count; y++)
{
StoredData.TrophyData data = spearData.trophyData[y];
DroppedItem skullItem = CreateSkullItem(data.displayName, spear, data.Position, data.Rotation);
skulls.Add(skullItem);
}
spearRegisteredSkulls.Add(spear as DroppedItem, skulls);
yield return(new WaitForSeconds(UnityEngine.Random.Range(0.1f, 0.2f)));
}
}
public void DropItem()
{
if (inventory.selectedItem == null)
{
return;
}
GameObject mesh = inventory.selectedItem.Mesh;
if (mesh != null)
{
GameObject spawnedMesh = Instantiate(mesh, null);
spawnedMesh.transform.position = dropPoint.position;
DroppedItem droppedItem = mesh.GetComponent <DroppedItem>();
if (droppedItem == null)
{
droppedItem = spawnedMesh.AddComponent <DroppedItem>();
}
if (droppedItem != null)
{
droppedItem.item = new Item(inventory.selectedItem, 1);
}
}
inventory.selectedItem.Amount--;
if (inventory.selectedItem.Amount <= 0)
{
inventory.RemoveItem(inventory.selectedItem);
inventory.selectedItem = null;
}
}
public void DropItem()
{
if (inventory.selectedItem == null)
{
return;
}
//spawn item and drop it
GameObject mesh = inventory.selectedItem.Mesh;
if (mesh != null)
{
GameObject spawnedMesh = Instantiate(mesh, null);
spawnedMesh.transform.position = dropPoint.position;
DroppedItem droppedItem = mesh.GetComponent <DroppedItem>();
droppedItem.item = new Item(inventory.selectedItem, 1);
}
// remove from inventory if none left
inventory.selectedItem.Amount--;
if (inventory.selectedItem.Amount <= 0)
{
//inventory.inventory.Remove(inventory.selectedItem);
inventory.RemoveItemFromInventory(inventory.selectedItem);
inventory.selectedItem = null;
}
}
public void DropOrUpdateItem(Items.ID Type, Vector3 Position, float Rotation, Vector3 BaseMomentum, string Name) //Performs the actual drop
{
if (EntitiesRoot.HasNode(Name))
{
DroppedItem Instance = EntitiesRoot.GetNode <DroppedItem>(Name);
Instance.Translation = Position;
Instance.RotationDegrees = new Vector3(0, Rotation, 0);
Instance.Momentum = BaseMomentum;
Instance.PhysicsEnabled = true;
}
else
{
Game.PossessedPlayer.MatchSome(
(Plr) =>
{
var PositionChunk = GetChunkTuple(Position);
if (ChunkWithinDistanceFrom(PositionChunk, Game.ChunkRenderDistance, Plr.Translation))
{
var ToDrop = (DroppedItem)DroppedItemScene.Instance();
ToDrop.Translation = Position;
ToDrop.RotationDegrees = new Vector3(0, Rotation, 0);
ToDrop.Momentum = BaseMomentum;
ToDrop.Type = Type;
ToDrop.Name = Name;
ToDrop.GetNode <MeshInstance>("MeshInstance").Mesh = Items.Meshes[Type];
AddItemToChunk(ToDrop);
ItemList.Add(ToDrop);
EntitiesRoot.AddChild(ToDrop);
}
}
);
}
}
public void DropItem(Item itemToDrop)
{
GameObject dropObj = world.SpawnObject("P_DroppedItem", transform.position);
if (dropObj == null || itemToDrop == null)
{
return;
}
DroppedItem itemContainer = dropObj.GetComponent <DroppedItem>();
if (itemContainer == null)
{
return;
}
if (itemToDrop.GetType() == typeof(CraftingItem))
{
itemContainer.DropCraftingItem(this, (CraftingItem)itemToDrop);
}
else
{
itemContainer.Drop(this, itemToDrop.GetType());
}
}
private void ClearSceneRoom04()
{
DroppedItem tubeDroppedItem = FindObjectOfType <DroppedItem>();
if (tubeDroppedItem)
{
tubeDroppedItem.Interact(null);
Inventory.RemoveItem(tubeDroppedItem.Item);
}
DeliveryTube deliveryTube = FindObjectOfType <DeliveryTube>();
if (deliveryTube)
{
deliveryTube.Interact(deliveryTube.ItemNeeded);
Inventory.RemoveItem(deliveryTube.ItemNeeded);
}
if (deliveryTubeReceived)
{
deliveryTubeReceived.HasCollided = true;
}
if (Room05TubePopupGameObject)
{
Room05TubePopupGameObject.SetActive(true);
}
}
public DroppedItem GetCloseItem()
{
if (_DroppedItems.Count == 0)
{
return(null);
}
Vector2 pos = transform.position;
float closeLength = float.MaxValue;
DroppedItem cloes = null;
for (var i = _DroppedItems.First; i != null;)
{
if (!i.Value.gameObject.activeSelf)
{
var next = i.Next;
_DroppedItems.Remove(i);
i = next;
continue;
}
float length = Vector2.Distance(i.Value.transform.position, pos);
if (length < closeLength)
{
closeLength = length;
cloes = i.Value;
}
i = i.Next;
}
return(cloes);
}
/// <inheritdoc />
public void HandleCommand(Player player, string command)
{
using var logScope = player.Logger.BeginScope(this.GetType());
if (player.CurrentMap is not {
} currentMap)
{
return;
}
var dropCoordinates = currentMap.Terrain.GetRandomCoordinate(player.Position, 1);
try
{
var arguments = command.ParseArguments <Arguments>();
var item = CreateItem(player, arguments);
var droppedItem = new DroppedItem(item, dropCoordinates, currentMap, player);
currentMap.Add(droppedItem);
player.ShowMessage($"[GM][/item] {item} created");
}
catch (ArgumentException ex)
{
player.ShowMessage(ex.Message);
}
catch (Exception ex)
{
player.Logger.LogError(ex, "Unexpected error handling the chat command '{command}'.", command);
}
}
void CanCombineDroppedItem(DroppedItem item1, DroppedItem item2)
{
NextFrame(() =>
{
SetDespawnTime(item1);
});
}
public void RequestDroppedItem(int Id, string Guid)
{
if (Self.GetTree().GetNetworkPeer() != null)
{
if (Self.GetTree().IsNetworkServer())
{
//On server
DroppedItem Item = EntitiesRoot.GetNodeOrNull(Guid) as DroppedItem;
if (Item != null) //Only lookup node once instead of using HasNode
{
if (Id == Net.Work.GetNetworkUniqueId())
{
Game.PossessedPlayer.PickupItem(Item.Type);
}
else
{
Net.Players[Id].RpcId(Id, nameof(Player.PickupItem), Item.Type);
}
Net.SteelRpc(this, nameof(RemoveDroppedItem), Item.GetName());
RemoveDroppedItem(Item.GetName());
}
}
else
{
//Not on server, call on server
Self.RpcId(Net.ServerId, nameof(RequestDroppedItem), Id, Guid);
}
}
}
public static void Clear()
{
List <Tile> Branches = new List <Tile>();
foreach (KeyValuePair <Tuple <int, int>, ChunkClass> Chunk in Chunks)
{
foreach (Tile Branch in Chunk.Value.Tiles)
{
Branches.Add(Branch);
}
}
foreach (Tile Branch in Branches)
{
Branch.Remove(Force: true);
}
DroppedItem[] RemovingItems = new DroppedItem[ItemList.Count];
ItemList.CopyTo(RemovingItems);
foreach (DroppedItem Item in RemovingItems)
{
Item.Remove();
}
Chunks.Clear();
Grid.Clear();
foreach (KeyValuePair <int, List <Tuple <int, int> > > Pair in RemoteLoadedChunks)
{
RemoteLoadedChunks[Pair.Key].Clear();
}
}
protected virtual DroppedItem SpawnDroppedItem(Vector2 pos)
{
DroppedItem droppedItem = Instantiate(DroppedItemPrefab, pos, Quaternion.identity).GetComponent <DroppedItem>();
droppedItem.SetRef_Item(this);
return(droppedItem);
}
public void DropOrUpdateItem(Items.ID Type, Vector3 Position, float Rotation, Vector3 BaseMomentum, string Name) //Performs the actual drop
{
if (EntitiesRoot.HasNode(Name))
{
DroppedItem Instance = EntitiesRoot.GetNode <DroppedItem>(Name);
Instance.Translation = Position;
Instance.RotationDegrees = new Vector3(0, Rotation, 0);
Instance.Momentum = BaseMomentum;
Instance.PhysicsEnabled = true;
}
else
{
Vector3 LevelPlayerPos = new Vector3(Game.PossessedPlayer.Translation.x, 0, Game.PossessedPlayer.Translation.z);
if (GetChunkPos(Position).DistanceTo(LevelPlayerPos) <= Game.ChunkRenderDistance * (PlatformSize * 9))
{
var ToDrop = (DroppedItem)DroppedItemScene.Instance();
ToDrop.Translation = Position;
ToDrop.RotationDegrees = new Vector3(0, Rotation, 0);
ToDrop.Momentum = BaseMomentum;
ToDrop.Type = Type;
ToDrop.Name = Name;
ToDrop.GetNode <MeshInstance>("MeshInstance").Mesh = Items.Meshes[Type];
AddItemToChunk(ToDrop);
ItemList.Add(ToDrop);
EntitiesRoot.AddChild(ToDrop);
}
}
}
private void UpdateVoxel(int x, int y, int z)
{
if (CurrentVoxels[x, y, z] != VoxelIndex[x, y, z])
{
if (GetVoxel(x, y, z))
{
GameObject oldVoxel = GetVoxel(x, y, z);
GameObject droppedItem = Instantiate(DroppedItemContainerPrefab, oldVoxel.transform.position, Quaternion.identity);
DroppedItem droppedItemScript = droppedItem.GetComponent <DroppedItem>();
droppedItemScript.DroppedItemPrefab = VoxelPrefabs[(int)CurrentVoxels[x, y, z] - 1];
droppedItemScript.BlockType = CurrentVoxels[x, y, z];
Destroy(oldVoxel);
}
if (VoxelIndex[x, y, z] == BlockTypes.BLOCK_AIR)
{
VoxelInstances[x, y, z] = null;
CurrentVoxels[x, y, z] = BlockTypes.BLOCK_AIR;
}
else
{
VoxelInstances[x, y, z] = CreateVoxel(x, y, z, VoxelIndex[x, y, z]);
CurrentVoxels[x, y, z] = VoxelIndex[x, y, z];
UpdateVoxelFaces(x, y, z);
}
if (!IsInitialising)
{
UpdateSurroundingVoxelFaces(x, y, z);
}
}
}
void OnCollisionEnter2D(Collision2D col)
{
if (col.gameObject.tag != "Player")
{
return;
}
InventoryController invControl = InventoryController.Instance;
DroppedItem i = this.GetComponent <DroppedItem>();
Debug.Log(invControl);
int numleft = invControl.AutoStackItem(i.Item, i.Qauntity);
if (numleft == 0)
{
//Destroy the collided object
Destroy(gameObject);
}
else
{
i.Qauntity = numleft;
}
}
public static void RemoveDroppedItem(DroppedItem item)
{
int randomId = item.Instance.RandomId;
Database.RemoveDroppedItem(randomId);
droppedItemsList.Remove(item);
}
public void OnDroppedOn(DroppedItem di)
{
if (item == null || di.item == null || Interface.CallHook("CanCombineDroppedItem", this, di) != null || item.info.stackable <= 1 || di.item.info != item.info || (di.item.IsBlueprint() && di.item.blueprintTarget != item.blueprintTarget) || (di.item.hasCondition && di.item.condition != di.item.maxCondition) || (item.hasCondition && item.condition != item.maxCondition))
{
return;
}
if (di.item.info != null && di.item.info.amountType == ItemDefinition.AmountType.Genetics)
{
int num = ((di.item.instanceData != null) ? di.item.instanceData.dataInt : (-1));
int num2 = ((item.instanceData != null) ? item.instanceData.dataInt : (-1));
if (num != num2)
{
return;
}
}
int num3 = di.item.amount + item.amount;
if (num3 <= item.info.stackable && num3 != 0)
{
di.DestroyItem();
di.Kill();
item.amount = num3;
item.MarkDirty();
if (GetDespawnDuration() < float.PositiveInfinity)
{
Invoke(IdleDestroy, GetDespawnDuration());
}
Effect.server.Run("assets/bundled/prefabs/fx/notice/stack.world.fx.prefab", this, 0u, Vector3.zero, Vector3.zero);
}
}
public void SendSyncDropWeaponRequest(DroppedWeapon droppedWeapon, Vector3 pos)
{
print(PureXmlTool.Serializer <BaseWeapon>(droppedWeapon.bw));
DroppedItem d = new DroppedItem();
d.UniqueName = droppedWeapon.uniqueName;
d.Bw.BackBulletQuantity = droppedWeapon.bw.BackBulletQuantity;
d.Bw.CurBulletQuantity = droppedWeapon.bw.CurBulletQuantity;
d.Bw.IsHaveSpecial = droppedWeapon.bw.IsHaveSpecial;
d.Bw.MaxBulletQuantity = droppedWeapon.bw.MaxBulletQuantity;
d.Bw.Price = droppedWeapon.bw.Price;
d.Bw.WeaponClass = droppedWeapon.bw.WeaponClass;
d.Bw.WeaponName = droppedWeapon.bw.WeaponName;
d.Trans.PosX = pos.x;
d.Trans.PosY = pos.y;
d.Trans.PosZ = pos.z;
string droppedItemXml = PureXmlTool.Serializer <DroppedItem>(d);
OperationRequest opRequest = new OperationRequest()
{
Parameters = new Dictionary <byte, object>(), OperationCode = (byte)OperationCode.SyncDropWeapon
};
opRequest.Parameters.Add(opRequest.OperationCode, droppedItemXml);
syncDropWeaponRequest.OnOperationRequest(opRequest);
}
public void FindItems()
{
//var playerEq = GameManager.Instance.SavablePlayerData.PlayerProgress.Equipment;
hitCount = Physics2D.CircleCast(Squad.playerSquadInstance.CenterSquad, radiusToFind, Vector2.zero, rHitFilter, rhits);
inventory.Clear();
for (int i = 0; i < hitCount; i++)
{
DroppedItem di = rhits[i].transform.GetComponent <DroppedItem>();
FillInventory(di.Stack);
}
inventory.RemoveAll((st) => { return(st.Count <= 0); });
inventory.Sort((a, b) => { return(a.EquipmentStats.Type.CompareTo(b.EquipmentStats.Type)); });
//foreach (var i in inventory)открытие новых предметов теперь не когда увидел, а то что вынес с уровня.
//{
// //"открываем" увиденную экипировку - но тлько в временное хранилище
// if (!playerEq.IsThisEquipmantAllowed(i.EquipmentStats) && !playerEq.IsThisEquipmantInTempValues(i.EquipmentStats))
// {
// playerEq.AddTempValue(i.EquipmentStats);
// AllowedEquipmantPanel.MainInstance.AddEq(i);
// }
//}
}
public void PickUpEquipment(EquipmentStack stack)
{
int q = 0;
for (int i = 0; i < hitCount; i++)
{
DroppedItem di = rhits[i].transform.GetComponent <DroppedItem>();
if (di.Stack.EquipmentStats.Type == stack.EquipmentStats.Type &&
di.Stack.EquipmentStats.Id == stack.EquipmentStats.Id &&
di.Stack.EquipmentStats.ItemDurability == stack.EquipmentStats.ItemDurability)
{
q += di.Stack.Count;
if (q > stack.Count)
{
di.Stack.PopItems(di.Stack.Count - (q - stack.Count));
q = stack.Count;
}
else
{
Destroy(di.gameObject);
}
}
if (q == stack.Count)
{
break;
}
}
}
private void DropItem(Player player, Item item, byte x, byte y)
{
var droppedItem = new DroppedItem(item, x, y, player.CurrentMap, player);
player.CurrentMap.Add(droppedItem);
player.Inventory.RemoveItem(item);
player.PlayerView.InventoryView.ItemDropResult(item.ItemSlot, true);
}
// Called by DroppedItem when this pawn is in range of it: Pawn maintains a list of all items in range
public void DropIsNearby(DroppedItem drop)
{
if(!bCanPickupItems) {
return;
}
if(!nearbyDrops.Contains(drop)) {
nearbyDrops.Add(drop);
}
}
// Called by DroppedItem when this pawn leaves its range
public void DopIsOutOfRange(DroppedItem drop)
{
if(!bCanPickupItems) {
return;
}
if(nearbyDrops.Contains(drop)) {
nearbyDrops.Remove(drop);
}
}
/*
* Performs the items functionality for pickups on the player. Does not handle removing the item from the world
*/
public void PickUpItem(DroppedItem item) {
switch(item.dropType) {
case DroppedItem.EDropType.Points:
points += POINTS_COIN;
if(player_ui != null) {
player_ui.AddKickerNumber(transform, POINTS_COIN);
}
break;
case DroppedItem.EDropType.Life:
timesHit = Mathf.Max(0, timesHit - 1);
break;
case DroppedItem.EDropType.Speed:
AddEffector(new Effector_Speed(), 5.0f);
break;
case DroppedItem.EDropType.AttackRadius:
// TODO:
break;
}
PlaySound(item.pickupSoundClip, 1.0f, 1.0f);
gameMode.OnItemPickup(item);
}
/*
* Called by player when they pickup an item to notify the game mode
*/
public void OnItemPickup(DroppedItem item)
{
droppedItems.Remove(item.gameObject);
}
