private void HandleInjection(EntityUid uid, SolutionInjectOnCollideComponent component, StartCollideEvent args)
        {
            var target = args.OtherFixture.Body.Owner;

            if (!args.OtherFixture.Body.Hard ||
                !EntityManager.TryGetComponent <BloodstreamComponent>(target, out var bloodstream) ||
                !_solutionsSystem.TryGetInjectableSolution(component.Owner, out var solution))
            {
                return;
            }

            if (component.BlockSlots != 0x0 && TryComp <InventoryComponent>(target, out var inventory))
            {
                var containerEnumerator = new InventorySystem.ContainerSlotEnumerator(target, inventory.TemplateId, _protoManager, _inventorySystem, component.BlockSlots);

                while (containerEnumerator.MoveNext(out var container))
                {
                    if (!container.ContainedEntity.HasValue)
                    {
                        continue;
                    }
                    return;
                }
            }

            var solRemoved    = solution.SplitSolution(component.TransferAmount);
            var solRemovedVol = solRemoved.TotalVolume;

            var solToInject = solRemoved.SplitSolution(solRemovedVol * component.TransferEfficiency);

            _bloodstreamSystem.TryAddToChemicals(target, solToInject, bloodstream);
        }
Example #2
0
    public GasTankComponent?FindBestGasTank(InternalsComponent component)
    {
        // Prioritise
        // 1. exo-slot tanks
        // 2. in-hand tanks
        // 3. pocket tanks
        InventoryComponent?       inventory        = null;
        ContainerManagerComponent?containerManager = null;

        if (_inventory.TryGetSlotEntity(component.Owner, "suitstorage", out var entity, inventory, containerManager) &&
            TryComp <GasTankComponent>(entity, out var gasTank) &&
            _gasTank.CanConnectToInternals(gasTank))
        {
            return(gasTank);
        }

        var tanks = new List <GasTankComponent>();

        foreach (var hand in _hands.EnumerateHands(component.Owner))
        {
            if (TryComp(hand.HeldEntity, out gasTank) && _gasTank.CanConnectToInternals(gasTank))
            {
                tanks.Add(gasTank);
            }
        }

        if (tanks.Count > 0)
        {
            tanks.Sort((x, y) => y.Air.TotalMoles.CompareTo(x.Air.TotalMoles));
            return(tanks[0]);
        }

        if (Resolve(component.Owner, ref inventory, false))
        {
            var enumerator = new InventorySystem.ContainerSlotEnumerator(component.Owner, inventory.TemplateId, _protoManager, _inventory, SlotFlags.POCKET);

            while (enumerator.MoveNext(out var container))
            {
                if (TryComp(container.ContainedEntity, out gasTank) && _gasTank.CanConnectToInternals(gasTank))
                {
                    tanks.Add(gasTank);
                }
            }

            if (tanks.Count > 0)
            {
                tanks.Sort((x, y) => y.Air.TotalMoles.CompareTo(x.Air.TotalMoles));
                return(tanks[0]);
            }
        }

        return(null);
    }
        private float GetZombieInfectionChance(EntityUid uid, ZombieComponent component)
        {
            float baseChance = component.MaxZombieInfectionChance;

            if (!TryComp <InventoryComponent>(uid, out var inventoryComponent))
            {
                return(baseChance);
            }

            var enumerator =
                new InventorySystem.ContainerSlotEnumerator(uid, inventoryComponent.TemplateId, _protoManager, _inv,
                                                            SlotFlags.FEET |
                                                            SlotFlags.HEAD |
                                                            SlotFlags.EYES |
                                                            SlotFlags.GLOVES |
                                                            SlotFlags.MASK |
                                                            SlotFlags.NECK |
                                                            SlotFlags.INNERCLOTHING |
                                                            SlotFlags.OUTERCLOTHING);

            var items = 0f;
            var total = 0f;

            while (enumerator.MoveNext(out var con))
            {
                total++;

                if (con.ContainedEntity != null)
                {
                    items++;
                }
            }

            var max = component.MaxZombieInfectionChance;
            var min = component.MinZombieInfectionChance;
            //gets a value between the max and min based on how many items the entity is wearing
            float chance = (max - min) * ((total - items) / total) + min;

            return(chance);
        }