private void UpdateUI(
            GravityGeneratorComponent component,
            ApcPowerReceiverComponent powerReceiver,
            float chargeRate)
        {
            if (!_uiSystem.IsUiOpen(component.Owner, SharedGravityGeneratorComponent.GravityGeneratorUiKey.Key))
            {
                return;
            }

            var   chargeTarget = chargeRate < 0 ? 0 : 1;
            short chargeEta;
            var   atTarget = false;

            if (MathHelper.CloseTo(component.Charge, chargeTarget))
            {
                chargeEta = short.MinValue; // N/A
                atTarget  = true;
            }
            else
            {
                var diff = chargeTarget - component.Charge;
                chargeEta = (short)Math.Abs(diff / chargeRate);
            }

            var status = chargeRate switch
            {
        private void OnParentChanged(EntityUid uid, GravityGeneratorComponent component, ref EntParentChangedMessage args)
        {
            // TODO consider stations with more than one generator.
            if (component.GravityActive && TryComp(args.OldParent, out GravityComponent? gravity))
            {
                _gravitySystem.DisableGravity(gravity);
            }

            UpdateGravityActive(component, false);
        }
        private void SetSwitchedOn(EntityUid uid, GravityGeneratorComponent component, bool on, ApcPowerReceiverComponent?powerReceiver = null)
        {
            if (!Resolve(uid, ref powerReceiver))
            {
                return;
            }

            component.SwitchedOn = on;
            UpdatePowerState(component, powerReceiver);
            component.NeedUIUpdate = true;
        }
Example #4
0
        public async Task WeightlessStatusTest()
        {
            var server = StartServer();

            await server.WaitIdleAsync();

            var mapManager            = server.ResolveDependency <IMapManager>();
            var entityManager         = server.ResolveDependency <IEntityManager>();
            var pauseManager          = server.ResolveDependency <IPauseManager>();
            var tileDefinitionManager = server.ResolveDependency <ITileDefinitionManager>();

            IEntity human = null;
            SharedStatusEffectsComponent statusEffects = null;

            await server.WaitAssertion(() =>
            {
                var mapId = mapManager.CreateMap();

                pauseManager.AddUninitializedMap(mapId);

                var gridId = new GridId(1);

                if (!mapManager.TryGetGrid(gridId, out var grid))
                {
                    grid = mapManager.CreateGrid(mapId, gridId);
                }

                var tileDefinition = tileDefinitionManager["underplating"];
                var tile           = new Tile(tileDefinition.TileId);
                var coordinates    = grid.ToCoordinates();

                grid.SetTile(coordinates, tile);

                pauseManager.DoMapInitialize(mapId);

                human = entityManager.SpawnEntity("HumanMob_Content", coordinates);

                Assert.True(human.TryGetComponent(out statusEffects));
            });

            // Let WeightlessSystem and GravitySystem tick
            await server.WaitRunTicks(1);

            GravityGeneratorComponent gravityGenerator = null;

            await server.WaitAssertion(() =>
            {
                // No gravity without a gravity generator
                Assert.True(statusEffects.Statuses.ContainsKey(StatusEffect.Weightless));

                gravityGenerator = human.EnsureComponent <GravityGeneratorComponent>();
            });

            // Let WeightlessSystem and GravitySystem tick
            await server.WaitRunTicks(1);

            await server.WaitAssertion(() =>
            {
                Assert.False(statusEffects.Statuses.ContainsKey(StatusEffect.Weightless));

                // Disable the gravity generator
                var args = new BreakageEventArgs {
                    Owner = human
                };
                gravityGenerator.OnBreak(args);
            });

            await server.WaitRunTicks(1);

            await server.WaitAssertion(() =>
            {
                Assert.False(statusEffects.Statuses.ContainsKey(StatusEffect.Weightless));
            });
        }
        public async Task WeightlessStatusTest()
        {
            var options = new ServerContentIntegrationOption {
                ExtraPrototypes = Prototypes
            };
            var server = StartServer(options);

            await server.WaitIdleAsync();

            var mapManager    = server.ResolveDependency <IMapManager>();
            var entityManager = server.ResolveDependency <IEntityManager>();

            IEntity human = null;
            SharedAlertsComponent alerts = null;

            await server.WaitAssertion(() =>
            {
                var mapId  = new MapId(1);
                var gridId = new GridId(1);

                if (!mapManager.TryGetGrid(gridId, out var grid))
                {
                    grid = mapManager.CreateGrid(mapId, gridId);
                }

                var coordinates = grid.ToCoordinates();
                human           = entityManager.SpawnEntity("HumanDummy", coordinates);

                Assert.True(human.TryGetComponent(out alerts));
            });

            // Let WeightlessSystem and GravitySystem tick
            await server.WaitRunTicks(1);

            GravityGeneratorComponent gravityGenerator = null;

            await server.WaitAssertion(() =>
            {
                // No gravity without a gravity generator
                Assert.True(alerts.IsShowingAlert(AlertType.Weightless));

                gravityGenerator = human.EnsureComponent <GravityGeneratorComponent>();
            });

            // Let WeightlessSystem and GravitySystem tick
            await server.WaitRunTicks(1);

            await server.WaitAssertion(() =>
            {
                Assert.False(alerts.IsShowingAlert(AlertType.Weightless));

                // Disable the gravity generator
                var args = new BreakageEventArgs {
                    Owner = human
                };
                gravityGenerator.OnBreak(args);
            });

            await server.WaitRunTicks(1);

            await server.WaitAssertion(() =>
            {
                Assert.True(alerts.IsShowingAlert(AlertType.Weightless));
            });
        }
 private void OnComponentShutdown(EntityUid uid, GravityGeneratorComponent component, ComponentShutdown args)
 {
     component.GravityActive = false;
     UpdateGravityActive(component, true);
 }
 private static void UpdatePowerState(
     GravityGeneratorComponent component,
     ApcPowerReceiverComponent powerReceiver)
 {
     powerReceiver.Load = component.SwitchedOn ? component.ActivePowerUse : component.IdlePowerUse;
 }