public void Enable(Base6Directions.Direction direction, bool enable, Func <IMyThrust, bool> collect = null) { var thrusterList = GetThrusters(direction, collect, true); thrusterList.ForEach(thruster => thruster.Enabled = enable); }
public static bool getDirFromOri(MyBlockOrientation orientation, Base6Directions.Direction direction, out Base6Directions.Direction?result) { switch (direction) { case Base6Directions.Direction.Left: result = orientation.Left; break; case Base6Directions.Direction.Up: result = orientation.Up; break; case Base6Directions.Direction.Forward: result = orientation.Forward; break; case Base6Directions.Direction.Right: result = Base6Directions.GetFlippedDirection(orientation.Left); break; case Base6Directions.Direction.Down: result = Base6Directions.GetFlippedDirection(orientation.Up); break; case Base6Directions.Direction.Backward: result = Base6Directions.GetFlippedDirection(orientation.Forward); break; default: result = null; return(false); } return(true); }
public void Start(float targetSpeed, Base6Directions.Direction forward, double targetAltDescending = 0, double targetAltAcending = double.MaxValue, bool useSealevel = false, bool disableOnNaturalGravityExit = true) { Enabled = true; TargetSpeed = targetSpeed; AdaptiveTargetSpeed = targetSpeed; if (forward == Base6Directions.Direction.Left) { Forward = autoForward; } else { Forward = forward; } //EnableThrusters(reverse, false); if (targetSpeed < 0) { descending = true; } else { descending = false; } if (useSealevel) { elevationType = MyPlanetElevation.Sealevel; } else { elevationType = MyPlanetElevation.Surface; } TargetAltAcending = targetAltAcending; TargetAltDescending = targetAltDescending; DisableOnNaturalGravityExit = disableOnNaturalGravityExit; startedInNaturalGravity = controller.GetNaturalGravity().Length() > 0; }
public void Init(ShipControlCommons shipControl, Base6Directions.Direction shipUp = Base6Directions.Direction.Up, Base6Directions.Direction shipForward = Base6Directions.Direction.Forward) { ShipForward = shipForward; ShipUp = shipUp; ShipLeft = Base6Directions.GetLeft(ShipUp, ShipForward); var small = shipControl.Reference.CubeGrid.GridSize == 0.5f; yawPID.Kp = small ? SmallGyroKp : LargeGyroKp; yawPID.Ti = small ? SmallGyroTi : LargeGyroTi; yawPID.Td = small ? SmallGyroTd : LargeGyroTd; pitchPID.Kp = small ? SmallGyroKp : LargeGyroKp; pitchPID.Ti = small ? SmallGyroTi : LargeGyroTi; pitchPID.Td = small ? SmallGyroTd : LargeGyroTd; rollPID.Kp = small ? SmallGyroKp : LargeGyroKp; rollPID.Ti = small ? SmallGyroTi : LargeGyroTi; rollPID.Td = small ? SmallGyroTd : LargeGyroTd; yawPID.Reset(); pitchPID.Reset(); rollPID.Reset(); }
/// <summary> /// Adds Gravity Generator to list of Generators /// </summary> /// <param name="generator"></param> public void AddGenerator(IMyGravityGenerator generator) { grav.Add(generator); Base6Directions.Direction direction = core.Orientation.TransformDirectionInverse(generator.Orientation.Up); //transforms the "Up" direction of the generator into the direction of the corridor coordinates gravDirections.Add(direction); numberOfGeneratorsInDirection[((int)Base6Directions.GetAxis(direction) + 2) % 3]++; }
internal Launcher(IMySmallMissileLauncher b, int timer, int offset) { tube = b; cooldown = timer; this.offset = offset; direction = b.Orientation.Forward; }
private Vector3D GetReferenceVector(ShipControlCommons shipControl, Base6Directions.Direction direction) { var offset = shipControl.Reference.Position + Base6Directions.GetIntVector(direction); return(Vector3D.Normalize(shipControl.Reference.CubeGrid.GridIntegerToWorld(offset) - shipControl.ReferencePoint)); }
/// <summary> /// Gets the closest face direction to worldDirection. /// </summary> public static Base6Directions.Direction ClosestFaceDirection(this IMyCubeBlock block, Vector3 worldDirection) { IEnumerable <Base6Directions.Direction> faceDirections = FaceDirections(block); worldDirection.Normalize(); Base6Directions.Direction bestDirection = (Base6Directions.Direction) 255; double bestDirectionAngle = double.MinValue; foreach (Base6Directions.Direction direction in faceDirections) { Vector3 directionVector = block.WorldMatrix.GetDirectionVector(direction); double cosAngle = directionVector.Dot(worldDirection); //Log.DebugLog(cosAngle < -1 || cosAngle > 1, "cosAngle out of bounds: " + cosAngle, "GetFaceDirection()", Logger.severity.ERROR); // sometimes values are slightly out of range Logger.DebugLog("cosAngle invalid", Logger.severity.ERROR, condition: double.IsNaN(cosAngle) || double.IsInfinity(cosAngle)); if (cosAngle > bestDirectionAngle) { //Log.DebugLog("angle: " + angle + ", bestDirectionAngle: " + bestDirectionAngle + ", direction: " + direction, "GetFaceDirection()"); bestDirection = direction; bestDirectionAngle = cosAngle; } } if (bestDirectionAngle == double.MinValue) { throw new NullReferenceException("bestDirection"); } return(bestDirection); }
public MatrixI(Vector3I position, Base6Directions.Direction forward, Base6Directions.Direction up) { Translation = position; Right = Base6Directions.GetFlippedDirection(Base6Directions.GetLeft(up, forward)); Up = up; Backward = Base6Directions.GetFlippedDirection(forward); }
bool sameThrusterDirection(Base6Directions.Direction orientation) => (orientation == Base6Directions.Direction.Up && ((thrusterDirection_ & ThrusterDirection.Lower) != 0)) || (orientation == Base6Directions.Direction.Down && ((thrusterDirection_ & ThrusterDirection.Lift) != 0)) || (orientation == Base6Directions.Direction.Left && ((thrusterDirection_ & ThrusterDirection.Right) != 0)) || (orientation == Base6Directions.Direction.Right && ((thrusterDirection_ & ThrusterDirection.Left) != 0)) || (orientation == Base6Directions.Direction.Forward && ((thrusterDirection_ & ThrusterDirection.Break) != 0)) || (orientation == Base6Directions.Direction.Backward && ((thrusterDirection_ & ThrusterDirection.Accelerate) != 0));
private void SetAxisDetails(IMyGyro gyro, int axis, Base6Directions.Direction axisDirection) { switch (gyro.Orientation.TransformDirectionInverse(axisDirection)) { case Base6Directions.Direction.Up: AxisDetails[axis] = new GyroAxisDetails(Yaw, -1); break; case Base6Directions.Direction.Down: AxisDetails[axis] = new GyroAxisDetails(Yaw, 1); break; case Base6Directions.Direction.Left: AxisDetails[axis] = new GyroAxisDetails(Pitch, -1); break; case Base6Directions.Direction.Right: AxisDetails[axis] = new GyroAxisDetails(Pitch, 1); break; case Base6Directions.Direction.Forward: AxisDetails[axis] = new GyroAxisDetails(Roll, 1); break; case Base6Directions.Direction.Backward: AxisDetails[axis] = new GyroAxisDetails(Roll, -1); break; } }
void GetAxisAndDir(Base6Directions.Direction RefDir, out string Axis, out float sign) { Axis = "Yaw"; sign = -1.0f; if (Base6Directions.GetAxis(YawAxisDir) == Base6Directions.GetAxis(RefDir)) { if (YawAxisDir == RefDir) { sign = 1.0f; } } if (Base6Directions.GetAxis(PitchAxisDir) == Base6Directions.GetAxis(RefDir)) { Axis = "Pitch"; if (PitchAxisDir == RefDir) { sign = 1.0f; } } if (Base6Directions.GetAxis(RollAxisDir) == Base6Directions.GetAxis(RefDir)) { Axis = "Roll"; if (RollAxisDir == RefDir) { } else { sign = 1.0f; } } }
private void LoadDummies() { var finalModel = VRage.Game.Models.MyModels.GetModelOnlyDummies(BlockDefinition.Model); foreach (var dummy in finalModel.Dummies) { if (dummy.Key.ToLower().Contains("merge")) { var matrix = dummy.Value.Matrix; Vector3 halfExtents = matrix.Scale / 2.0f; Vector3 projectedPosition = Vector3.DominantAxisProjection(matrix.Translation / halfExtents); projectedPosition.Normalize(); m_forward = Base6Directions.GetDirection(projectedPosition); m_right = Base6Directions.GetPerpendicular(m_forward); var world = MatrixD.Normalize(matrix) * this.WorldMatrix; var detectorShape = CreateFieldShape(halfExtents); Physics = new Sandbox.Engine.Physics.MyPhysicsBody(this, RigidBodyFlag.RBF_STATIC); Physics.IsPhantom = true; Physics.CreateFromCollisionObject(detectorShape, matrix.Translation, world, null, MyPhysics.CollisionLayers.ObjectDetectionCollisionLayer); Physics.Enabled = IsWorking; Physics.RigidBody.ContactPointCallbackEnabled = true; detectorShape.Base.RemoveReference(); break; } } }
/// <summary> /// gets the local position /// </summary> public Vector3 getLocal() { if (value__grid != null) { return((Vector3)value__grid); } if (value__world != null || value__worldAbsolute != null) { // create from world Vector3I gridInt = cubeGrid.WorldToGridInteger(getWorld() * precisionMultiplier + cubeGrid.GetPosition()); value__grid = (gridInt * cubeGrid.GridSize) / precisionMultiplier; return((Vector3)value__grid); } // create from block // create from block // orient according to block Vector3D resultant = Vector3D.Zero; Vector3D blockRelative = (Vector3D)value__block; Base6Directions.Direction RCdirection = cubeBlock.Orientation.Left; resultant -= (Vector3D)Base6Directions.GetVector(RCdirection) * blockRelative.X; RCdirection = cubeBlock.Orientation.Up; resultant += (Vector3D)Base6Directions.GetVector(RCdirection) * blockRelative.Y; RCdirection = cubeBlock.Orientation.Forward; resultant -= (Vector3D)Base6Directions.GetVector(RCdirection) * blockRelative.Z; // add block position value__grid = resultant + cubeBlock.Position * cubeGrid.GridSize; return((Vector3D)value__grid); }
public List <IMyThrust> GetThrusters(Base6Directions.Direction direction, Func <IMyThrust, bool> collect = null, bool disable = false) { List <IMyThrust> thrusterList; if (!thrusters.TryGetValue(direction, out thrusterList)) { thrusterList = new List <IMyThrust>(); thrusters.Add(direction, thrusterList); } if (collect == null) { return(thrusterList); } else { var result = new List <IMyThrust>(); foreach (var thruster in thrusterList) { if (collect(thruster)) { result.Add(thruster); } else if (disable) { thruster.Enabled = false; } } return(result); } }
public void SetDirection(Base6Directions.Direction dirToSet, Base6Directions.Direction newDirection) { switch (dirToSet) { case Base6Directions.Direction.Right: Right = newDirection; break; case Base6Directions.Direction.Left: Left = newDirection; break; case Base6Directions.Direction.Up: Up = newDirection; break; case Base6Directions.Direction.Down: Down = newDirection; break; case Base6Directions.Direction.Backward: Backward = newDirection; break; case Base6Directions.Direction.Forward: Forward = newDirection; break; } }
public void Init(ZACommons commons, EventDriver eventDriver, double maxError, Base6Directions.Direction thrusterDirection = Base6Directions.Direction.Forward) { MaxError = maxError; ThrusterDirection = thrusterDirection; var shipControl = (ShipControlCommons)commons; var forward = shipControl.ShipBlockOrientation.TransformDirection(ThrusterDirection); // Don't really care about "up," just pick a perpindicular direction seeker.Init(shipControl, shipUp: Base6Directions.GetPerpendicular(forward), shipForward: forward); var gyroControl = shipControl.GyroControl; gyroControl.Reset(); gyroControl.EnableOverride(true); LastPosition = shipControl.ReferencePoint; Enabled = true; shipControl.ThrustControl.Enable(false); eventDriver.Schedule(SampleDelay, DetermineVelocity); }
/// <summary> /// Converts the given block with the given matrix for static grid. /// </summary> private static void ConvertRotatedGridBlockToStatic(ref MatrixI transform, MyObjectBuilder_CubeBlock origBlock) { MyDefinitionId defId = new MyDefinitionId(origBlock.TypeId, origBlock.SubtypeName); MyCubeBlockDefinition blockDefinition; MyDefinitionManager.Static.TryGetCubeBlockDefinition(defId, out blockDefinition); if (blockDefinition == null) { return; } // Orientation quaternion is not setup in origblock MyBlockOrientation origOrientation = origBlock.BlockOrientation; Vector3I origMin = origBlock.Min; Vector3I origMax; MySlimBlock.ComputeMax(blockDefinition, origOrientation, ref origMin, out origMax); Vector3I tMin; Vector3I tMax; Vector3I.Transform(ref origMin, ref transform, out tMin); Vector3I.Transform(ref origMax, ref transform, out tMax); Base6Directions.Direction forward = transform.GetDirection(origOrientation.Forward); Base6Directions.Direction up = transform.GetDirection(origOrientation.Up); // Write data MyBlockOrientation newBlockOrientation = new MyBlockOrientation(forward, up); Quaternion rotationQuat; newBlockOrientation.GetQuaternion(out rotationQuat); origBlock.Orientation = rotationQuat; origBlock.Min = Vector3I.Min(tMin, tMax); }
/// <summary> /// Add or remove a thruster from thrustProfile, if appropriate. /// </summary> private void enableDisableThruster(ThrusterProperties properties, bool enable) { if (properties.isEnabled == enable) { if (enable) { log("already enabled. " + properties, "enableDisableThruster()", Logger.severity.DEBUG); } else { log("already disabled. " + properties, "enableDisableThruster()", Logger.severity.DEBUG); } return; } properties.isEnabled = enable; float change = properties.forceDamping; Base6Directions.Direction direction = properties.forceDirect; if (!enable) { change = -change; } thrustProfile[direction] += change; //log("thrust power change = " + change + ", total power = " + thrustProfile[direction] + ", direction = " + direction, "enableDisableThruster()", Logger.severity.TRACE); }
/// <summary> /// Converts the given grid to static with the world matrix. Instead of grid (which must have identity rotation for static grid) we transform blocks in the grid. /// </summary> /// <param name="originalGrid">grid to be transformed</param> /// <param name="worldMatrix">target world transform</param> private static void ConvertGridBuilderToStatic(MyObjectBuilder_CubeGrid originalGrid, MatrixD worldMatrix) { originalGrid.IsStatic = true; originalGrid.PositionAndOrientation = new MyPositionAndOrientation(originalGrid.PositionAndOrientation.Value.Position, Vector3.Forward, Vector3.Up); Vector3 fw = (Vector3)worldMatrix.Forward; Vector3 up = (Vector3)worldMatrix.Up; Base6Directions.Direction fwDir = Base6Directions.GetClosestDirection(fw); Base6Directions.Direction upDir = Base6Directions.GetClosestDirection(up); if (upDir == fwDir) { upDir = Base6Directions.GetPerpendicular(fwDir); } MatrixI transform = new MatrixI(Vector3I.Zero, fwDir, upDir); // Blocks in static grid - must be recreated for static grid with different orientation and position foreach (var origBlock in originalGrid.CubeBlocks) { if (origBlock is MyObjectBuilder_CompoundCubeBlock) { var origBlockCompound = origBlock as MyObjectBuilder_CompoundCubeBlock; ConvertRotatedGridCompoundBlockToStatic(ref transform, origBlockCompound); for (int i = 0; i < origBlockCompound.Blocks.Length; ++i) { var origBlockInCompound = origBlockCompound.Blocks[i]; ConvertRotatedGridBlockToStatic(ref transform, origBlockInCompound); } } else { ConvertRotatedGridBlockToStatic(ref transform, origBlock); } } }
public ThrusterGroup(Program _parent_program, Base6Directions.Direction direction, IMyTerminalBlock _directionReferenceBlock) { parent_program = _parent_program; directionReferenceBlock = _directionReferenceBlock; thrusters = new List <IMyThrust>(); MaxThrust = 0; LocalThrustDirection = direction; UpdateWorldDirection(); ANS = new double[3]; finalThrustForces = new Vector3D(); finalThrusterGroups = new ThrusterGroup[6]; matrixM = new double[3, 3]; if (LocalThrustDirection == Base6Directions.Direction.Down || LocalThrustDirection == Base6Directions.Direction.Right || LocalThrustDirection == Base6Directions.Direction.Backward) { directionSign = -1; } else { directionSign = 1; } }
public void SetDirectionVector(Base6Directions.Direction direction, Vector3 newValue) { switch (direction) { case Base6Directions.Direction.Forward: this.Forward = newValue; return; case Base6Directions.Direction.Backward: this.Backward = newValue; return; case Base6Directions.Direction.Left: this.Left = newValue; return; case Base6Directions.Direction.Right: this.Right = newValue; return; case Base6Directions.Direction.Up: this.Up = newValue; return; case Base6Directions.Direction.Down: this.Down = newValue; return; } }
public Base6Directions.Direction TransformDirectionInverse(Base6Directions.Direction baseDirection) { Base6Directions.Axis axis = Base6Directions.GetAxis(baseDirection); if (axis == Base6Directions.GetAxis(this.Forward)) { if (baseDirection != this.Forward) { return(Base6Directions.Direction.Backward); } return(Base6Directions.Direction.Forward); } if (axis == Base6Directions.GetAxis(this.Left)) { if (baseDirection != this.Left) { return(Base6Directions.Direction.Right); } return(Base6Directions.Direction.Left); } if (baseDirection != this.Up) { return(Base6Directions.Direction.Down); } return(Base6Directions.Direction.Up); }
public static Vector3D GetDirection(MatrixD m, string dirStr) { Base6Directions.Direction d = GetDirection(dirStr); string upperDir = dirStr == null ? "F" : dirStr.ToUpper(); Vector3D r; switch (d) { case Base6Directions.Direction.Backward: r = m.Backward; break; case Base6Directions.Direction.Up: r = m.Up; break; case Base6Directions.Direction.Down: r = m.Down; break; case Base6Directions.Direction.Left: r = m.Left; break; case Base6Directions.Direction.Right: r = m.Right; break; case Base6Directions.Direction.Forward: default: r = m.Forward; break; } return(r); }
public Base6Directions.Direction TransformDirection(Base6Directions.Direction baseDirection) { Base6Directions.Axis axis = Base6Directions.GetAxis(baseDirection); int num = (int)(baseDirection % Base6Directions.Direction.Left); switch (axis) { case Base6Directions.Axis.ForwardBackward: if (num != 1) { return(this.Forward); } return(Base6Directions.GetFlippedDirection(this.Forward)); case Base6Directions.Axis.LeftRight: if (num != 1) { return(this.Left); } return(Base6Directions.GetFlippedDirection(this.Left)); } if (num != 1) { return(this.Up); } return(Base6Directions.GetFlippedDirection(this.Up)); }
private void EraseFaceTriangles(Vector3I pos, Base6Directions.Direction direction) { m_tmpTriangleList.Clear(); Vector3I directionVec = Base6Directions.GetIntVector((int)direction); List <int> triList = null; if (m_smallTriangleRegistry.TryGetValue(pos, out triList)) { foreach (var index in triList) { var triangle = GetTriangle(index); if (IsFaceTriangle(triangle, pos, directionVec)) { m_tmpTriangleList.Add(new KeyValuePair <MyNavigationTriangle, Vector3I>(triangle, pos)); } } } foreach (var triangle in m_tmpTriangleList) { RemoveTriangle(triangle.Key, triangle.Value); } m_tmpTriangleList.Clear(); }
public List <IMyThrust> GetThrusters(Base6Directions.Direction direction, Func <IMyThrust, bool> collect = null, bool disable = false) { List <IMyThrust> thrusterList; if (!thrusters.TryGetValue(direction, out thrusterList)) { thrusterList = new List <IMyThrust>(); thrusters.Add(direction, thrusterList); } if (collect == null) { return(thrusterList); } else { var result = new List <IMyThrust>(); for (var e = thrusterList.GetEnumerator(); e.MoveNext();) { var thruster = (IMyThrust)e.Current; if (collect(thruster)) { result.Add(thruster); } else if (disable) { thruster.SetValue <bool>("OnOff", false); } } return(result); } }
public void SetYawPitchRoll(float yaw, float pitch, float roll) { for (int i = 0; i < Gyros.Count; i++) { string Axis; float sign; Vector3 RotatedVector = Base6Directions.GetVector(Forward); Vector3.TransformNormal(ref RotatedVector, Gyros[i].Orientation, out RotatedVector); RollAxisDir = Base6Directions.GetDirection(ref RotatedVector); RotatedVector = Base6Directions.GetVector(Left); Vector3.TransformNormal(ref RotatedVector, Gyros[i].Orientation, out RotatedVector); PitchAxisDir = Base6Directions.GetDirection(ref RotatedVector); RotatedVector = Base6Directions.GetVector(Up); Vector3.TransformNormal(ref RotatedVector, Gyros[i].Orientation, out RotatedVector); YawAxisDir = Base6Directions.GetDirection(ref RotatedVector); GetAxisAndDir(RefUp, out Axis, out sign); SetAxis(Gyros[i], Axis, sign * yaw); // Gyros[i].SetValueFloat(Axis, sign * yaw); GetAxisAndDir(RefLeft, out Axis, out sign); SetAxis(Gyros[i], Axis, sign * pitch); // Gyros[i].SetValueFloat(Axis, sign * pitch); GetAxisAndDir(RefForward, out Axis, out sign); SetAxis(Gyros[i], Axis, sign * roll); // Gyros[i].SetValueFloat(Axis, sign * roll); } }
private bool IsRotationValid(MyBlockOrientation refOrientation, MyBlockOrientation orientation, MyBlockOrientation[] validRotations) { Debug.Assert(validRotations != null); // Ref matrix MatrixI localMatrix = new MatrixI(Vector3I.Zero, refOrientation.Forward, refOrientation.Up); MatrixI inverseMatrix; MatrixI.Invert(ref localMatrix, out inverseMatrix); Matrix inverseMatrixF = inverseMatrix.GetFloatMatrix(); // Transform orientation to ref Base6Directions.Direction forward = Base6Directions.GetClosestDirection(Vector3.TransformNormal((Vector3)Base6Directions.GetIntVector(orientation.Forward), inverseMatrixF)); Base6Directions.Direction up = Base6Directions.GetClosestDirection(Vector3.TransformNormal((Vector3)Base6Directions.GetIntVector(orientation.Up), inverseMatrixF)); foreach (var validRotation in validRotations) { if (validRotation.Forward == forward && validRotation.Up == up) { return(true); } } return(false); }
private void CreateConstraint(MyCubeGrid other, MyShipMergeBlock block) { var data = new HkPrismaticConstraintData(); data.MaximumLinearLimit = 0; data.MinimumLinearLimit = 0; var posA = ConstraintPositionInGridSpace(); var posB = block.ConstraintPositionInGridSpace(); var axisA = PositionComp.LocalMatrix.GetDirectionVector(m_forward); var axisAPerp = PositionComp.LocalMatrix.GetDirectionVector(m_right); var axisB = -block.PositionComp.LocalMatrix.GetDirectionVector(m_forward); Base6Directions.Direction thisRightForOther = block.WorldMatrix.GetClosestDirection(WorldMatrix.GetDirectionVector(m_right)); Base6Directions.Direction otherRight = WorldMatrix.GetClosestDirection(block.WorldMatrix.GetDirectionVector(block.m_right)); var axisBPerp = block.PositionComp.LocalMatrix.GetDirectionVector(thisRightForOther); data.SetInBodySpace(posA, posB, axisA, axisB, axisAPerp, axisBPerp, CubeGrid.Physics, other.Physics); var data2 = new HkMalleableConstraintData(); data2.SetData(data); data.ClearHandle(); data = null; data2.Strength = 0.00001f; var constraint = new HkConstraint(CubeGrid.Physics.RigidBody, other.Physics.RigidBody, data2); AddConstraint(constraint); SetConstraint(block, constraint, otherRight); m_other.SetConstraint(this, constraint, thisRightForOther); }
public void Init(ShipControlCommons shipControl, Base6Directions.Direction localForward = Base6Directions.Direction.Forward) { LocalForward = localForward; LocalBackward = Base6Directions.GetFlippedDirection(LocalForward); thrustPID.Reset(); }
public void SetLocalPosition(Vector3I sectionStart, int sectionStartPosition, float cubeSize, Base6Directions.Direction forward, Base6Directions.Direction offset) { int segmentPosition = LinePosition - sectionStartPosition; Matrix localMatrix = PositionComp.LocalMatrix; Vector3 offsetVector = PositionComp.LocalMatrix.GetDirectionVector(forward) * segmentPosition + PositionComp.LocalMatrix.GetDirectionVector(offset) * 0.10f; localMatrix.Translation = (sectionStart + offsetVector / PositionComp.Scale.Value) * cubeSize; PositionComp.LocalMatrix = localMatrix; m_segmentDirection = forward; }
public void Init(ZACommons commons, EventDriver eventDriver, Vector3D target, double speed, double delay = 1.0, Action<ZACommons, EventDriver> doneAction = null, Base6Directions.Direction localForward = Base6Directions.Direction.Forward) { if (!AutopilotEngaged) { AutopilotTarget = target; AutopilotSpeed = speed; AutopilotEngaged = true; DoneAction = doneAction; LocalForward = localForward; eventDriver.Schedule(delay, Start); } }
private void OnPasteAutopilotSetup(MyObjectBuilder_AutopilotClipboard clipboard) { m_currentDirection = (Base6Directions.Direction)clipboard.Direction; m_currentFlightMode = (FlightMode)clipboard.FlightMode; m_dockingModeEnabled = clipboard.DockingModeEnabled; if (clipboard.Waypoints != null) { m_waypoints = new List<MyAutopilotWaypoint>(clipboard.Waypoints.Count); foreach (var waypoint in clipboard.Waypoints) { if (waypoint.Actions != null) { foreach (var action in waypoint.Actions) { var blockAction = action as MyObjectBuilder_ToolbarItemTerminalBlock; //Swith from old entity to the new one if (blockAction != null && blockAction.BlockEntityId == clipboard.RemoteEntityId) { blockAction.BlockEntityId = EntityId; } } } m_waypoints.Add(new MyAutopilotWaypoint(waypoint, this)); } } m_selectedWaypoints.Clear(); RaisePropertiesChangedRemote(); }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { SyncFlag = true; base.Init(objectBuilder, cubeGrid); NeedsUpdate = MyEntityUpdateEnum.BEFORE_NEXT_FRAME | MyEntityUpdateEnum.EACH_FRAME | MyEntityUpdateEnum.EACH_10TH_FRAME; var remoteOb = (MyObjectBuilder_RemoteControl)objectBuilder; m_savedPreviousControlledEntityId = remoteOb.PreviousControlledEntityId; PowerReceiver = new MyPowerReceiver( MyConsumerGroupEnum.Utility, false, m_powerNeeded, this.CalculateRequiredPowerInput); PowerReceiver.IsPoweredChanged += Receiver_IsPoweredChanged; PowerReceiver.RequiredInputChanged += Receiver_RequiredInputChanged; PowerReceiver.Update(); m_autoPilotEnabled = remoteOb.AutoPilotEnabled; m_dockingModeEnabled = remoteOb.DockingModeEnabled; m_currentFlightMode = (FlightMode)remoteOb.FlightMode; m_currentDirection = (Base6Directions.Direction)remoteOb.Direction; if (remoteOb.Coords == null || remoteOb.Coords.Count == 0) { if (remoteOb.Waypoints == null) { m_waypoints = new List<MyAutopilotWaypoint>(); CurrentWaypoint = null; } else { m_waypoints = new List<MyAutopilotWaypoint>(remoteOb.Waypoints.Count); for (int i = 0; i < remoteOb.Waypoints.Count; i++) { m_waypoints.Add(new MyAutopilotWaypoint(remoteOb.Waypoints[i], this)); } } } else { m_waypoints = new List<MyAutopilotWaypoint>(remoteOb.Coords.Count); for (int i = 0; i < remoteOb.Coords.Count; i++) { m_waypoints.Add(new MyAutopilotWaypoint(remoteOb.Coords[i], remoteOb.Names[i], this)); } if (remoteOb.AutoPilotToolbar != null && m_currentFlightMode == FlightMode.OneWay) { m_waypoints[m_waypoints.Count - 1].SetActions(remoteOb.AutoPilotToolbar.Slots); } } if (remoteOb.CurrentWaypointIndex == -1 || remoteOb.CurrentWaypointIndex >= m_waypoints.Count) { CurrentWaypoint = null; } else { CurrentWaypoint = m_waypoints[remoteOb.CurrentWaypointIndex]; } m_actionToolbar = new MyToolbar(MyToolbarType.ButtonPanel, pageCount: 1); m_actionToolbar.DrawNumbers = false; m_actionToolbar.Init(null, this); m_selectedGpsLocations = new List<IMyGps>(); m_selectedWaypoints = new List<MyAutopilotWaypoint>(); UpdateText(); }
protected void SetConstraint(MyShipMergeBlock otherBlock, HkConstraint constraint, Base6Directions.Direction otherRight) { Debug.Assert(m_constraint == null && m_other == null); if (m_constraint != null || m_other != null) return; m_constraint = constraint; m_other = otherBlock; m_otherRight = otherRight; CheckEmissivity(); NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME; }
private void OnChangeDirection(Base6Directions.Direction direction) { m_currentDirection = direction; RaisePropertiesChangedRemote(); }
public SerializableBlockOrientation(ref Quaternion q) { Forward = Base6Directions.GetForward(q); Up = Base6Directions.GetUp(q); }
public SerializableBlockOrientation(Base6Directions.Direction forward, Base6Directions.Direction up) { Forward = forward; Up = up; }
public MyBlockOrientation(Base6Directions.Direction forward, Base6Directions.Direction up) { Forward = forward; Up = up; Debug.Assert(IsValid); }
public MyBlockOrientation(ref Quaternion q) { Forward = Base6Directions.GetForward(q); Up = Base6Directions.GetUp(q); Debug.Assert(IsValid); }
public ThrusterProperties(IMyThrust thruster) { thruster.throwIfNull_argument("thruster"); this.thruster = thruster; this.force = (DefinitionCache.GetCubeBlockDefinition(thruster) as MyThrustDefinition).ForceMagnitude; //this.dampingForce = force * 10; this.forceDirect = Base6Directions.GetFlippedDirection(thruster.Orientation.Forward); }
public void ShipOrientation() { if (_shipControls != null) { var Origin = ((IMyCubeBlock) _shipControls).GetPosition(); var Up = Origin + (((IMyCubeBlock) _shipControls).LocalMatrix.Up); var Forward = Origin + (((IMyCubeBlock) _shipControls).LocalMatrix.Forward); var Left = Origin + (((IMyCubeBlock) _shipControls).LocalMatrix.Left); Vector3D forwardVector = Forward - Origin; Vector3D upVector = Up - Origin; Vector3D leftVector = Left - Origin; leftVector.Normalize(); forwardVector.Normalize(); upVector.Normalize(); _shipUp = Base6Directions.GetDirection(upVector); _shipLeft = Base6Directions.GetDirection(leftVector); } }
public void HandleCommand(ZACommons commons, EventDriver eventDriver, string argument) { argument = argument.Trim().ToLower(); var parts = argument.Split(new char[] { ' ' }, 4); if (parts.Length < 2) return; var command = parts[0]; var speed = parts[1]; if (command == "cruise") { if (speed == "reset") { CruiseFlags = null; if (parts.Length >= 3) CruiseFlags = parts[2]; Reset(commons); ThrusterStates.Clear(); Active = false; SaveLastCommand(commons, null); } else if (speed == "stop") { RestoreThrusterStates(commons); Active = false; SaveLastCommand(commons, null); } else { CruiseDirection = Base6Directions.Direction.Forward; if (parts.Length >= 3) { switch (parts[2]) { case "forward": case "forwards": default: break; case "backward": case "backwards": case "reverse": CruiseDirection = Base6Directions.Direction.Backward; break; case "left": CruiseDirection = Base6Directions.Direction.Left; break; case "right": CruiseDirection = Base6Directions.Direction.Right; break; case "up": CruiseDirection = Base6Directions.Direction.Up; break; case "down": CruiseDirection = Base6Directions.Direction.Down; break; } } CruiseFlags = null; if (parts.Length == 4) CruiseFlags = parts[3]; double desiredSpeed; if (double.TryParse(speed, out desiredSpeed)) { TargetSpeed = Math.Max(desiredSpeed, 0.0); thrustPID.Reset(); if (!Active) { SaveThrusterStates(commons); Active = true; eventDriver.Schedule(0, Run); } SaveLastCommand(commons, argument); } } } }
public MyBlockOrientation(ref Matrix m) { Forward = Base6Directions.GetForward(ref m); Up = Base6Directions.GetUp(ref m); //Debug.Assert(IsValid); }
public FlyToGrid(Mover mover, AllNavigationSettings navSet, string targetGrid, AttachedGrid.AttachmentKind allowedAttachment = AttachedGrid.AttachmentKind.Permanent) : base(mover, navSet) { this.m_logger = new Logger(GetType().Name, m_controlBlock.CubeBlock, () => m_landingState.ToString()); this.m_targetBlock = m_navSet.Settings_Current.DestinationBlock; string blockName = m_targetBlock == null ? null : m_targetBlock.BlockName; this.m_gridFinder = new GridFinder(m_navSet, m_mover.Block, targetGrid, blockName, allowedAttachment); this.m_contBlock = m_navSet.Settings_Commands.NavigationBlock; PseudoBlock landingBlock = m_navSet.Settings_Current.LandingBlock; m_navBlock = landingBlock ?? m_navSet.Settings_Current.NavigationBlock; if (landingBlock != null) { if (landingBlock.Block is IMyFunctionalBlock) m_landingState = LandingState.Approach; else { m_logger.debugLog("landingBlock is not functional, player error? : " + landingBlock.Block.DisplayNameText, "FlyToGrid()", Logger.severity.INFO); m_landingState = LandingState.None; } if (m_targetBlock == null) { if (!(landingBlock.Block is IMyLandingGear)) { m_logger.debugLog("cannot land block without a target", "FlyToGrid()", Logger.severity.INFO); m_landingState = LandingState.None; } else { m_logger.debugLog("golden retriever mode enabled", "FlyToGrid()", Logger.severity.INFO); m_landGearWithoutTargetBlock = true; } } else if (landingBlock.Block is Ingame.IMyShipConnector) { m_gridFinder.BlockCondition = block => { Ingame.IMyShipConnector connector = block as Ingame.IMyShipConnector; return connector != null && (!connector.IsConnected || connector.OtherConnector == m_navBlock.Block); }; m_landingDirection = m_targetBlock.Forward ?? Base6Directions.GetFlippedDirection(landingBlock.Block.GetFaceDirection()[0]); } else if (landingBlock.Block is IMyShipMergeBlock) { m_gridFinder.BlockCondition = block => block is IMyShipMergeBlock; m_landingDirection = m_targetBlock.Forward ?? Base6Directions.GetFlippedDirection(landingBlock.Block.GetFaceDirection()[0]); (landingBlock.Block as IMyShipMergeBlock).BeforeMerge += MergeBlock_BeforeMerge; } else if (m_targetBlock.Forward.HasValue) m_landingDirection = m_targetBlock.Forward.Value; else { m_logger.debugLog("Player failed to specify landing direction and it could not be determined.", "FlyToGrid()", Logger.severity.INFO); m_landingState = LandingState.None; } if (m_landingState != LandingState.None) { float minDestRadius = m_controlBlock.CubeGrid.GetLongestDim() * 5f; if (m_navSet.Settings_Current.DestinationRadius < minDestRadius) { m_logger.debugLog("Increasing DestinationRadius from " + m_navSet.Settings_Current.DestinationRadius + " to " + minDestRadius, "FlyToGrid()", Logger.severity.DEBUG); m_navSet.Settings_Task_NavRot.DestinationRadius = minDestRadius; } new UnLander(mover, navSet, landingBlock); m_landingHalfSize = landingBlock.Block.GetLengthInDirection(landingBlock.Block.LocalMatrix.GetClosestDirection(landingBlock.LocalMatrix.Forward)) * 0.5f; m_logger.debugLog("m_landing direction: " + m_landingDirection + ", m_landingBlockSize: " + m_landingHalfSize, "FlyToGrid()"); } } m_navSet.Settings_Task_NavMove.NavigatorMover = this; }