コード例 #1
0
    public EntityUid?TakeAmmo(AmmoBoxComponent ammoBox, TransformComponent?xform = null)
    {
        if (!Resolve(ammoBox.Owner, ref xform))
        {
            return(null);
        }

        if (ammoBox.SpawnedAmmo.TryPop(out var ammo))
        {
            ammoBox.AmmoContainer.Remove(ammo);
            return(ammo);
        }

        if (ammoBox.UnspawnedCount > 0)
        {
            ammo = EntityManager.SpawnEntity(ammoBox.FillPrototype, xform.Coordinates);

            // when dumping from held ammo box, this detaches the spawned ammo from the player.
            EntityManager.GetComponent <TransformComponent>(ammo).AttachParentToContainerOrGrid();

            ammoBox.UnspawnedCount--;
        }

        return(ammo);
    }
コード例 #2
0
    private bool TryUse(EntityUid user, AmmoBoxComponent ammoBox)
    {
        if (!TryComp(user, out HandsComponent? handsComponent))
        {
            return(false);
        }

        if (TakeAmmo(ammoBox) is not {
        } ammo)
        {
            return(false);
        }

        if (TryComp(ammo, out ItemComponent? item))
        {
            if (!handsComponent.CanPutInHand(item))
            {
                TryInsertAmmo(user, ammo, ammoBox);
                return(false);
            }

            handsComponent.PutInHand(item);
        }

        UpdateAmmoBoxAppearance(ammoBox.Owner, ammoBox);
        return(true);
    }
コード例 #3
0
    private void OnAmmoBoxUse(EntityUid uid, AmmoBoxComponent component, UseInHandEvent args)
    {
        if (args.Handled)
        {
            return;
        }

        TryUse(args.User, component);
    }
コード例 #4
0
    private void UpdateAmmoBoxAppearance(EntityUid uid, AmmoBoxComponent ammoBox, AppearanceComponent?appearanceComponent = null)
    {
        if (!Resolve(uid, ref appearanceComponent, false))
        {
            return;
        }

        appearanceComponent.SetData(MagazineBarrelVisuals.MagLoaded, true);
        appearanceComponent.SetData(AmmoVisuals.AmmoCount, ammoBox.AmmoLeft);
        appearanceComponent.SetData(AmmoVisuals.AmmoMax, ammoBox.Capacity);
    }
コード例 #5
0
    private void OnAmmoBoxInit(EntityUid uid, AmmoBoxComponent component, ComponentInit args)
    {
        component.AmmoContainer = uid.EnsureContainer <Container>($"{component.Name}-container", out var existing);

        if (existing)
        {
            foreach (var entity in component.AmmoContainer.ContainedEntities)
            {
                component.UnspawnedCount--;
                component.SpawnedAmmo.Push(entity);
                component.AmmoContainer.Insert(entity);
            }
        }
    }
コード例 #6
0
    private void AmmoBoxEjectContents(AmmoBoxComponent ammoBox, int count)
    {
        var ejectCount = Math.Min(count, ammoBox.Capacity);
        var ejectAmmo  = new List <EntityUid>(ejectCount);

        for (var i = 0; i < Math.Min(count, ammoBox.Capacity); i++)
        {
            if (TakeAmmo(ammoBox) is not {
            } ammo)
            {
                break;
            }

            ejectAmmo.Add(ammo);
        }

        EjectCasings(ejectAmmo);
        UpdateAmmoBoxAppearance(ammoBox.Owner, ammoBox);
    }
コード例 #7
0
        private void AddDumpVerb(EntityUid uid, AmmoBoxComponent component, GetAlternativeVerbsEvent args)
        {
            if (args.Hands == null || !args.CanAccess || !args.CanInteract)
            {
                return;
            }

            if (component.AmmoLeft == 0)
            {
                return;
            }

            Verb verb = new();

            verb.Text        = Loc.GetString("dump-vert-get-data-text");
            verb.IconTexture = "/Textures/Interface/VerbIcons/eject.svg.192dpi.png";
            verb.Act         = () => component.EjectContents(10);
            args.Verbs.Add(verb);
        }
コード例 #8
0
    private void OnAmmoBoxInteractUsing(EntityUid uid, AmmoBoxComponent component, InteractUsingEvent args)
    {
        if (args.Handled)
        {
            return;
        }

        if (TryComp(args.Used, out AmmoComponent? ammoComponent))
        {
            if (TryInsertAmmo(args.User, args.Used, component, ammoComponent))
            {
                args.Handled = true;
            }

            return;
        }

        if (!TryComp(args.Used, out RangedMagazineComponent? rangedMagazine))
        {
            return;
        }

        for (var i = 0; i < Math.Max(10, rangedMagazine.ShotsLeft); i++)
        {
            if (TakeAmmo(rangedMagazine) is not {
                Valid: true
            } ammo)
            {
                continue;
            }

            if (!TryInsertAmmo(args.User, ammo, component))
            {
                TryInsertAmmo(args.User, ammo, rangedMagazine);
                args.Handled = true;
                return;
            }
        }

        args.Handled = true;
    }
コード例 #9
0
    // Probably needs combining with magazines in future given the common functionality.

    private void OnAmmoBoxAltVerbs(EntityUid uid, AmmoBoxComponent component, GetVerbsEvent <AlternativeVerb> args)
    {
        if (args.Hands == null || !args.CanAccess || !args.CanInteract)
        {
            return;
        }

        if (component.AmmoLeft == 0)
        {
            return;
        }

        AlternativeVerb verb = new()
        {
            Text        = Loc.GetString("dump-vert-get-data-text"),
            IconTexture = "/Textures/Interface/VerbIcons/eject.svg.192dpi.png",
            Act         = () => AmmoBoxEjectContents(component, 10)
        };

        args.Verbs.Add(verb);
    }
コード例 #10
0
    private bool TryUse(EntityUid user, AmmoBoxComponent ammoBox)
    {
        if (!TryComp(user, out HandsComponent? handsComponent))
        {
            return(false);
        }

        if (TakeAmmo(ammoBox) is not {
        } ammo)
        {
            return(false);
        }

        if (!_handsSystem.TryPickup(user, ammo, handsComp: handsComponent))
        {
            TryInsertAmmo(user, ammo, ammoBox);
            return(false);
        }

        UpdateAmmoBoxAppearance(ammoBox.Owner, ammoBox);
        return(true);
    }
コード例 #11
0
    public bool TryInsertAmmo(EntityUid user, EntityUid ammo, AmmoBoxComponent ammoBox, AmmoComponent?ammoComponent = null)
    {
        if (!Resolve(ammo, ref ammoComponent, false))
        {
            return(false);
        }

        if (ammoComponent.Caliber != ammoBox.Caliber)
        {
            _popup.PopupEntity(Loc.GetString("ammo-box-component-try-insert-ammo-wrong-caliber"), ammo, Filter.Entities(user));
            return(false);
        }

        if (ammoBox.AmmoLeft >= ammoBox.Capacity)
        {
            _popup.PopupEntity(Loc.GetString("ammo-box-component-try-insert-ammo-no-room"), ammo, Filter.Entities(user));
            return(false);
        }

        ammoBox.SpawnedAmmo.Push(ammo);
        ammoBox.AmmoContainer.Insert(ammo);
        UpdateAmmoBoxAppearance(ammoBox.Owner, ammoBox);
        return(true);
    }
コード例 #12
0
 private void OnAmmoBoxMapInit(EntityUid uid, AmmoBoxComponent component, MapInitEvent args)
 {
     component.UnspawnedCount += component.Capacity;
     UpdateAmmoBoxAppearance(uid, component);
 }
コード例 #13
0
 private void OnAmmoBoxExamine(EntityUid uid, AmmoBoxComponent component, ExaminedEvent args)
 {
     args.PushMarkup(Loc.GetString("ammo-box-component-on-examine-caliber-description", ("caliber", component.Caliber)));
     args.PushMarkup(Loc.GetString("ammo-box-component-on-examine-remaining-ammo-description", ("ammoLeft", component.AmmoLeft), ("capacity", component.Capacity)));
 }