/////////////////////////////////////////////// //////////////////PROPERTIES/////////////////// /////////////////////////////////////////////// /*********************************************/ /////////////////////////////////////////////// ////////////////////METHODS//////////////////// /////////////////////////////////////////////// //////////////TRANSFORM_METHODS//////////////// public void moveTo(GlPointR2 newBelongsPoint) { if (newBelongsPoint == null || newBelongsPoint.isNullPoint()) { return; } if (OnMoveStart != null) { if (!OnMoveStart.Invoke(this, this.pointOfLine.X, this.pointOfLine.Y)) { return; } } if (OnMoving != null) { OnMoving.Invoke(this, this.pointOfLine.X, this.pointOfLine.Y); } GlPointR2 OP = new GlPointR2(this.PointOfLine); this.pointOfLine = newBelongsPoint; if (OnMoved != null) { OnMoved.Invoke(this, OP.X, OP.Y); } }
/////////////////////////////////////////////// //////////////////PROPERTIES/////////////////// /////////////////////////////////////////////// /*********************************************/ /////////////////////////////////////////////// ////////////////////METHODS//////////////////// /////////////////////////////////////////////// //////////////TRANSFORM_METHODS//////////////// public override void moveTo(float x, float y) { float oldX = this.Center.X; float oldY = this.Center.Y; if (OnMoveStart != null) { if (!OnMoveStart.Invoke(this, oldX, oldY)) { return; } } if (OnMoving != null) { OnMoving.Invoke(this, oldX, oldY); } this.systemCenter = new GlPointR2(x, y); updatePointsPosition(); if (OnMoved != null) { OnMoved.Invoke(this, oldX, oldY); } }
protected override void OnMouseMove(MouseEventArgs e) { base.OnMouseMove(e); if (isDown) { if (Dir == Direction.Horizontal) { if (e.X - downPoint.X > this.Height) { OnMoving?.Invoke(this, new BlockMoveArgs(MoveDir.Right)); } else if (downPoint.X - e.X > this.Height) { OnMoving?.Invoke(this, new BlockMoveArgs(MoveDir.Left)); } } else { if (e.Y - downPoint.Y > this.Width) { OnMoving?.Invoke(this, new BlockMoveArgs(MoveDir.Down)); } else if (downPoint.Y - e.Y > this.Width) { OnMoving?.Invoke(this, new BlockMoveArgs(MoveDir.Up)); } } } }
/////////////////////////////////////////////// //////////////////PROPERTIES/////////////////// /////////////////////////////////////////////// /*********************************************/ /////////////////////////////////////////////// ////////////////////METHODS//////////////////// /////////////////////////////////////////////// //////////////TRANSFORM_METHODS//////////////// public override void moveTo(float x, float y) { if (OnMoveStart != null) { if (!OnMoveStart.Invoke(this, this.polyCenter.X, this.polyCenter.Y)) { return; } } if (OnMoving != null) { OnMoving.Invoke(this, this.polyCenter.X, this.polyCenter.Y); } GlVectorR2 delta = new GlVectorR2(x - polyCenter.X, y - polyCenter.Y); for (int i = 0; i < vertexes.Length; i++) { vertexes[i] = delta.fromPointToPoint(vertexes[i]); } GlPointR2 OP = new GlPointR2(this.polyCenter); this.polyCenter = new GlPointR2(x, y); if (OnMoved != null) { OnMoved.Invoke(this, OP.X, OP.Y); } }
/// <summary> /// Updates a move operation based of the provided position. <see cref="OnMoving"/> /// </summary> /// <returns>True if a move operation is running.</returns> public bool Drag(float x, float y) { if (!IsMoving) { return(false); } float dx = x - originX; float dy = y - originY; float nx = originalSelection.X + dx; float ny = originalSelection.Y + dy; Selection = new RectangleF(nx, ny, Selection.Width, Selection.Height); foreach (TransformerItem item in items) { item.Item.X = item.OriginX + dx; item.Item.Y = item.OriginY + dy; } OnMoving?.Invoke(this, EventArgs.Empty); return(true); }
/////////////////////////////////////////////// //////////////////PROPERTIES/////////////////// /////////////////////////////////////////////// /*********************************************/ /////////////////////////////////////////////// ////////////////////METHODS//////////////////// /////////////////////////////////////////////// //////////////TRANSFORM_METHODS//////////////// public override void moveTo(float x, float y) { float oldX = systemCenter.X, oldY = systemCenter.Y; if (OnMoveStart != null) { if (!OnMoveStart.Invoke(this, oldX, oldY)) { return; } } if (OnMoving != null) { OnMoving.Invoke(this, oldX, oldY); } GlVectorR2 moveVector = new GlVectorR2(x - this.systemCenter.X, y - this.systemCenter.Y); this.systemCenter = new GlPointR2(x, y); foreach (GlFigure F in this.figuresAmount) { GlPointR2 newCenter = moveVector.fromPointToPoint(F.Center); F.moveTo(newCenter.X, newCenter.Y); } if (OnMoved != null) { OnMoving.Invoke(this, oldX, oldY); } }
/////////////////////////////////////////////// //////////////////PROPERTIES/////////////////// /////////////////////////////////////////////// /*********************************************/ /////////////////////////////////////////////// ////////////////////METHODS//////////////////// /////////////////////////////////////////////// //////////////TRANSFORM_METHODS//////////////// public override void moveTo(float x, float y) { if (OnMoveStart != null) { if (!OnMoveStart.Invoke(this, this.x, this.y)) { return; } } if (OnMoving != null) { OnMoving.Invoke(this, this.x, this.y); } float oldX = this.x, oldy = this.y; this.X = x; this.Y = y; if (OnMoved != null) { OnMoved.Invoke(this, oldX, oldy); } }
private void Deploy() { if (deployed) { return; } OnMoving.Fire(0f, 1f); if (UIPartActionController.Instance is UIPartActionController partActionController && partActionController.GetItem(part, false) is UIPartActionWindow window) { window.displayDirty = true; } foreach (FairingSlice slice in slices) { GameObject gameObject = slice.SliceRootObject; physicalObject physObj = physicalObject.ConvertToPhysicalObject(part, gameObject); Rigidbody rigidBody = physObj.rb; rigidBody.useGravity = true; rigidBody.mass = slice.Mass; rigidBody.centerOfMass = slice.CalculateCoM(); rigidBody.drag = part.Rigidbody.drag / numSlices; rigidBody.angularDrag = part.Rigidbody.angularDrag; rigidBody.angularVelocity = part.Rigidbody.angularVelocity; rigidBody.maxAngularVelocity = PhysicsGlobals.MaxAngularVelocity; rigidBody.velocity = part.Rigidbody.velocity + Vector3.Cross(part.Rigidbody.worldCenterOfMass - vessel.CurrentCoM, vessel.angularVelocity); Vector3 planeNormal = part.partTransform.TransformDirection(axis); Vector3 centerOfMassDirection = (rigidBody.worldCenterOfMass - part.Rigidbody.worldCenterOfMass).normalized; Vector3 outDirection = Vector3.ProjectOnPlane(centerOfMassDirection, planeNormal).normalized; Vector3 forceDirection = (planeNormal * 0.5f + outDirection).normalized; Vector3 torqueDirection = Vector3.Cross(planeNormal, outDirection); rigidBody.AddForce(forceDirection * deploySpeed, ForceMode.VelocityChange); rigidBody.AddTorque(torqueDirection * deployAngularSpeed, ForceMode.VelocityChange); } slices.Clear(); part.ModifyCoM(); needsNotifyFARToRevoxelize = true; NotifyFARToRevoxelize(); part.DragCubes.SetCubeWeight(DRAG_CUBE_NAME_CLOSED, 0); part.DragCubes.SetCubeWeight(DRAG_CUBE_NAME_DEPLOYED, 1); part.DragCubes.ForceUpdate(weights: true, occlusion: true); OnStop.Fire(1f); HideDeployEvent(); deployed = true; GameEvents.onVesselWasModified.Fire(vessel); }
public virtual void MoveTo(PositionInGrid direction) { Board.ElementMoveTo(this, direction.x, direction.y); if (AudioSource && MoveSound) { AudioSource.clip = MoveSound; AudioSource.Play(); } OnMoving?.Invoke(this); transform.position += new Vector3(direction.x, direction.y); }
private void OnVesselWasModified(Vessel v) { bool wasDecoupled = decoupled; CheckDecoupled(); if (!wasDecoupled && decoupled) { OnMoving.Fire(0, 1); OnStop.Fire(1); } }
public new void Decouple() { if (waitForAnimation && (object)anim != null) { anim.Play(animationName); isDecoupling = true; OnMoving.Fire(0f, 1f); StartCoroutine(DelayedDecouple()); } else { OnDecouple(); } }
private void OnVesselWasModified(Vessel v) { if ((object)v != null && v == vessel) { if (!(isDecoupling || isDecoupled)) { if ((object)part.FindAttachNode(this.explosiveNodeID).attachedPart == null) { isDecoupling = true; OnMoving.Fire(0f, 1f); OnStop.Fire(1f); } } } }
private void FixedUpdate() { OnMovingArgs args = new OnMovingArgs(movement + (AddGravity ? Physics.gravity : Vector3.zero)); if (OnMoving != null) { OnMoving.Invoke(this, args); } if (!args.Cancel) { physics.velocity = (args.Velocity * MovementMultiplicator); movement = Vector3.zero; } }
public void Decouple() { OnMoving.Fire(0, 1); if (decoupler != null && !decoupler.isDecoupled) { decoupler.Decouple(); } foreach (ModuleDecouple d in panels) { if (!d.isDecoupled) { d.Decouple(); } } OnStop.Fire(1); }
// TODO Consider deprecating checkForDecoupling; it should no longer be necessary private void checkForDecoupling(EventReport separationData) { if (separationData.eventType == FlightEvents.STAGESEPARATION && separationData.origin == this.part) { // PROBABLY got called because we decoupled, but no way to know because ModuleAnchoredDecoupler doesn't SET isDecoupled until after the event fires. OnMoving.Fire(0f, 1f); if (animationName != "" && (object)anim != null && (!this.animationComplete || !this.anim.IsPlaying(animationName))) { this.anim.Play(animationName); this.animationComplete = true; Debug.Log("ModuleAnimatedAnchoredDecoupler.onStageSeparation() triggered animation " + this.animationName); } this.isDecoupling = true; this.OnStop.Fire(1f); } }
private void OnEditorToggleJettisoned(BaseField field, object oldValue) { if (!HighLogic.LoadedSceneIsEditor) { return; } OnMoving.Fire(isJettisoned ? 0 : 1, isJettisoned ? 1 : 0); if (jettisons.Length > 0) { SetJettisoned(isJettisoned); } OnStop.Fire(isJettisoned ? 1 : 0); }
public void Jettison() { if (isJettisoned) { return; } if (jettisons.Length == 0) { return; } OnMoving.Fire(0, 1); for (int i = 0; i < jettisons.Length; i++) { Rigidbody rb = physicalObject.ConvertToPhysicalObject(part, jettisons[i].gameObject).rb; rb.useGravity = true; rb.mass = jettisonedObjectMass / jettisons.Length; rb.maxAngularVelocity = PhysicsGlobals.MaxAngularVelocity; rb.angularVelocity = part.Rigidbody.angularVelocity; rb.velocity = part.Rigidbody.velocity + Vector3.Cross(part.Rigidbody.worldCenterOfMass - vessel.CurrentCoM, vessel.angularVelocity); Vector3 d = jettisonDirection; if (d == Vector3.zero) { d = Vector3.Normalize(rb.transform.position - part.transform.position); } else { d = part.transform.TransformDirection(d); } //rb.AddForce(part.transform.TransformDirection(jettisonDirection) * (jettisonForce * 0.5f), ForceMode.Force); rb.AddForceAtPosition(d * (jettisonForce * 0.5f), part.transform.position, ForceMode.Force); rb.AddTorque(d * jettisonTorque, ForceMode.VelocityChange); //part.Rigidbody.AddForce(d * (-jettisonForce * 0.5f), ForceMode.Force); } jettisons = new Transform[0]; isJettisoned = true; SetJettisoned(isJettisoned); OnStop.Fire(1); }
private void OnVesselWasModified(Vessel v) { if ((object)v != null && v == vessel) { if (!(isDecoupling || isDecoupled)) { Part p; p = this.ExplosiveNode.attachedPart; if (p = null) { isDecoupling = true; OnMoving.Fire(0f, 1f); OnStop.Fire(1f); } } } }
public void SetDeployed(bool newState) { if (deployed != newState) { if (newState) { OnMoving.Fire(stowedAnchor, deployedAnchor); } else { OnMoving.Fire(deployedAnchor, stowedAnchor); } OnStop.Fire(SpringAnchor()); } deployed = newState; Events["Deploy"].guiActive = !deployed; Actions["DeployAction"].active = !deployed; }
public void PlayAnimation(float speed) { float moveTo = animPosition; if (speed < 0) { moveTo = 0f; } else if (speed > 0) { moveTo = 1f; } OnMoving.Fire(animPosition, moveTo); foreach (var anim in animationStates) { anim.speed = speed; } playing = speed != 0f; }
public override void OnActive() { if (staged) { if ((object)anim != null) { anim.Play(animationName); isDecoupling = true; OnMoving.Fire(0f, 1f); if (waitForAnimation) { StartCoroutine(DelayedDecouple()); } else { OnDecouple(); } } else { OnDecouple(); } } }
private void fireEvents(AnimState newState) { switch (newState) { case AnimState.STOPPED_START: OnStop.Fire(0f); break; case AnimState.STOPPED_END: OnStop.Fire(1f); break; case AnimState.PLAYING_FORWARD: OnMoving.Fire(0, 1); break; case AnimState.PLAYING_BACKWARD: OnMoving.Fire(1, 0); break; default: break; } }
private void OnMove(InputValue inputValue) { OnMoving?.Invoke(inputValue.Get <float>()); }
public virtual void OnMouseMove(MouseEventArgs e) { if (!_enabled) { return; } if (Moving) { Point tempPoint = CMain.MPoint.Subtract(_movePoint); if (Parent == null) { if (tempPoint.Y + TrueSize.Height > Settings.ScreenHeight) { tempPoint.Y = Settings.ScreenHeight - TrueSize.Height - 1; } if (tempPoint.X + TrueSize.Width > Settings.ScreenWidth) { tempPoint.X = Settings.ScreenWidth - TrueSize.Width - 1; } } else { if (tempPoint.Y + TrueSize.Height > Parent.TrueSize.Height) { tempPoint.Y = Parent.TrueSize.Height - TrueSize.Height; } if (tempPoint.X + TrueSize.Width > Parent.TrueSize.Width) { tempPoint.X = Parent.TrueSize.Width - TrueSize.Width; } } if (tempPoint.X < 0) { tempPoint.X = 0; } if (tempPoint.Y < 0) { tempPoint.Y = 0; } Location = tempPoint; if (OnMoving != null) { OnMoving.Invoke(this, e); } return; } if (Controls != null) { for (int i = Controls.Count - 1; i >= 0; i--) { if (Controls[i].IsMouseOver(CMain.MPoint)) { Controls[i].OnMouseMove(e); return; } } } Highlight(); if (MouseMove != null) { MouseMove.Invoke(this, e); } }
private void Moving(float inputAxis) { // TODO: Moving Implement Here OnMoving?.Invoke(); }
public void OnDestroy() { OnMoving.Remove(DoOnMovingEffect); OnStop.Remove(StopEffect); }
public void Start() { OnMoving.Add(DoOnMovingEffect); OnStop.Add(StopEffect); }
private void DoStartAnimation(float pos, float moveto) { OnMoving.Fire(animPosition, moveto); part.Effect("deploy"); }
public void Jettison() { if (isJettisoned) { return; } if (jettisons.Length == 0) { return; } OnMoving.Fire(0, 1); for (int i = 0; i < jettisons.Length; i++) { Rigidbody rb = physicalObject.ConvertToPhysicalObject(part, jettisons[i].gameObject).rb; rb.useGravity = true; rb.mass = jettisonedObjectMass / jettisons.Length; rb.maxAngularVelocity = PhysicsGlobals.MaxAngularVelocity; rb.angularVelocity = part.Rigidbody.angularVelocity; rb.velocity = part.Rigidbody.velocity + Vector3.Cross(part.Rigidbody.worldCenterOfMass - vessel.CurrentCoM, vessel.angularVelocity); Vector3 d = jettisonDirection; if (d == Vector3.zero) { d = Vector3.Normalize(rb.transform.position - part.transform.position); } else { d = part.transform.TransformDirection(d); } //rb.AddForce(part.transform.TransformDirection(jettisonDirection) * (jettisonForce * 0.5f), ForceMode.Force); rb.AddForceAtPosition(d * (jettisonForce * 0.5f), part.transform.position, ForceMode.Force); part.Rigidbody.AddForce(d * (-jettisonForce * 0.5f), ForceMode.Force); } jettisons = new Transform[0]; if (part.temperature < part.skinMaxTemp) { part.skinTemperature = part.temperature; } isJettisoned = true; SetJettisoned(isJettisoned); OnStop.Fire(1); EnableOtherModules(); FXGroup effect = part.findFxGroup(fxGroupName); if (effect != null) { effect.Burst(); } GameEvents.onVesselWasModified.Fire(vessel); }