private static void RotateEvent(RotateEvent ev) { if (ev.Sender.TryGetComponent(out ParticleAcceleratorPartComponent? part)) { part.Rotated(); } }
private void OnRotateEvent(EntityUid uid, NodeContainerComponent container, ref RotateEvent ev) { if (ev.NewRotation == ev.OldRotation) { return; } var xform = Transform(uid); foreach (var node in container.Nodes.Values) { if (node is not IRotatableNode rotatableNode) { continue; } // Don't bother updating nodes that can't even be connected to anything atm. if (!node.Connectable(EntityManager, xform)) { continue; } if (rotatableNode.RotateEvent(ref ev)) { _nodeGroupSystem.QueueReflood(node); } } }
private void RotateEvent(RotateEvent ev) { if (ev.Sender.TryGetComponent(out AirtightComponent? airtight)) { airtight.RotateEvent(ev); } }
private void RotateEvent(ref RotateEvent ev) { if (EntityManager.TryGetComponent(ev.Sender, out ParticleAcceleratorPartComponent? part)) { part.Rotated(); } }
private void OnAirtightRotated(EntityUid uid, AirtightComponent airtight, RotateEvent ev) { if (!airtight.RotateAirBlocked || airtight.InitialAirBlockedDirection == (int)AtmosDirection.Invalid) { return; } airtight.CurrentAirBlockedDirection = (int)Rotate((AtmosDirection)airtight.InitialAirBlockedDirection, ev.NewRotation); UpdatePosition(airtight); }
// TODO: Shitcode, needs to use sprites instead of actual offsets. private void OnVehicleRotate(EntityUid uid, VehicleComponent component, ref RotateEvent args) { // This first check is just for safety if (!HasComp <InputMoverComponent>(uid)) { UpdateAutoAnimate(uid, false); return; } UpdateBuckleOffset(args.Component, component); UpdateDrawDepth(uid, GetDrawDepth(args.Component, component.NorthOnly)); }
private void RotateEvent(RotateEvent ev) { if (ev.Sender != Owner || ev.NewRotation == ev.OldRotation) { return; } foreach (var rotatableNode in Nodes.OfType <IRotatableNode>()) { rotatableNode.RotateEvent(ev); } }
private void RotateEvent(EntityUid uid, StrapComponent strap, ref RotateEvent ev) { // On rotation of a strap, reattach all buckled entities. // This fixes buckle offsets and draw depths. foreach (var buckledEntity in strap.BuckledEntities) { if (!EntityManager.TryGetComponent(buckledEntity, out BuckleComponent? buckled)) { continue; } buckled.ReAttach(strap); buckled.Dirty(); } }
private void OnAirtightInit(EntityUid uid, AirtightComponent airtight, ComponentInit args) { if (airtight.FixAirBlockedDirectionInitialize) { var rotateEvent = new RotateEvent(airtight.Owner, Angle.Zero, airtight.Owner.Transform.WorldRotation); OnAirtightRotated(uid, airtight, ref rotateEvent); } // Adding this component will immediately anchor the entity, because the atmos system // requires airtight entities to be anchored for performance. airtight.Owner.Transform.Anchored = true; UpdatePosition(airtight); }
private void OnStrapRotate(EntityUid uid, SharedStrapComponent component, ref RotateEvent args) { // TODO: This looks dirty af. // On rotation of a strap, reattach all buckled entities. // This fixes buckle offsets and draw depths. foreach (var buckledEntity in component.BuckledEntities) { if (!EntityManager.TryGetComponent(buckledEntity, out SharedBuckleComponent? buckled)) { continue; } buckled.ReAttach(component); Dirty(buckled); } }
public void StoreTurnsEventTest() { //ARRANGE var @event = new RotateEvent(new Guid(), RotateDirection.Left); var command = new MoveCommand(store); //ACT command.Handle(@event); var storedEvents = store.GetEvents <MoveEvent>(); //ASSERT Assert.AreEqual(true, storedEvents.Contains(@event)); Assert.AreEqual(1, storedEvents.Count); }
private void OnRotateEvent(EntityUid uid, NodeContainerComponent container, RotateEvent ev) { if (ev.NewRotation == ev.OldRotation) { return; } foreach (var node in container.Nodes.Values) { if (node is not IRotatableNode rotatableNode) { continue; } rotatableNode.RotateEvent(ev); } }
public void Rotate(Vector3 v, float deltaTime, bool active = false) { var speed = acceleration.GetSpeed(deltaTime, rotationSpeed, active); movement.Rotate(v * speed); if (previousRotationSpeed < 0.1f && speed != previousRotationSpeed) { RotateEvent?.Invoke(); } else if (previousRotationSpeed > 0.1f && speed == 0) { StopEvent?.Invoke(); } previousRotationSpeed = speed; }
public void LookRotate(Vector3 v, float deltaTime, bool active = false) { var speed = acceleration.GetSpeed(deltaTime, rotationSpeed, active); currentLookRotation = Vector3.Lerp(currentLookRotation, v, speed); movement.LookRotate(currentLookRotation); if (previousLookRotationSpeed < 0.1f && speed != previousLookRotationSpeed) { RotateEvent?.Invoke(); } else if (previousLookRotationSpeed > 0.1f && speed == 0) { StopEvent?.Invoke(); } previousLookRotationSpeed = speed; }
private void RotateEvent(RotateEvent ev) { if (!ev.Sender.TryGetComponent(out NodeContainerComponent container)) { return; } if (ev.NewRotation == ev.OldRotation) { return; } foreach (var rotatableNode in container.Nodes.OfType <IRotatableNode>()) { rotatableNode.RotateEvent(ev); } }
// Start is called before the first frame update void Awake() { if (onRotateInput == null) { onRotateInput = new RotateEvent(); } if (onSpaceDown == null) { onSpaceDown = new UnityEvent(); } if (onSpaceUp == null) { onSpaceUp = new UnityEvent(); } spaceDown = false; }
private void OnRotateEvent(ITransformable transformable, Matrix delta, Matrix deleta2) { RotateEvent?.Invoke(transformable, new TransformationEventArgs(delta, ActivePivot)); }
private void OnRotate(RotateEvent data) { _targetRot.y += data.Axis.x * RotateSensitivity; _targetRot.x -= data.Axis.y * RotateSensitivity; _targetRot.x = ClampAngle(_targetRot.x, -80, 80); }
private void OnAirtightRotated(EntityUid uid, AirtightComponent airtight, RotateEvent ev) { airtight.RotateEvent(ev); }
public PinchHoldRotate(HandModel handModel, RotateEvent rotateEvent) : base(handModel) { _rotateEvent = rotateEvent; _pinch = new PinchCondition(handModel, false); }
public void HandleEvent(RotateEvent e) => board.GetUnit(e.From).transform.rotation = (e.To - e.From).ToQuaternion();
private static void OnRotateEvent(EntityUid uid, ParticleAcceleratorPartComponent component, ref RotateEvent args) { component.Rotated(); }
protected void OnRotate() { RotateEvent?.Invoke(RotateArgs); }