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);
}
private void MarkExploredDirections(ref MyNavmeshComponents.ClosedCellInfo cellInfo)
{
foreach (var direction in Base6Directions.EnumDirections)
{
var dirFlag = Base6Directions.GetDirectionFlag(direction);
if (cellInfo.ExploredDirections.HasFlag(dirFlag))
{
continue;
}
Vector3I dirVec = Base6Directions.GetIntVector(direction);
MyCellCoord otherCoord = new MyCellCoord();
otherCoord.Lod = MyVoxelNavigationMesh.NAVMESH_LOD;
otherCoord.CoordInLod = m_currentCell + dirVec;
if (otherCoord.CoordInLod.X == -1 || otherCoord.CoordInLod.Y == -1 || otherCoord.CoordInLod.Z == -1)
{
continue;
}
ulong otherPackedCoord = otherCoord.PackId64();
if (m_triangleLists.ContainsKey(otherPackedCoord))
{
m_navmeshComponents.MarkExplored(otherPackedCoord, Base6Directions.GetFlippedDirection(direction));
cellInfo.ExploredDirections |= Base6Directions.GetDirectionFlag(direction);
}
}
m_navmeshComponents.SetExplored(m_packedCoord, cellInfo.ExploredDirections);
}
private unsafe void MarkExploredDirections(ref MyNavmeshComponents.ClosedCellInfo cellInfo)
{
foreach (Base6Directions.Direction direction in Base6Directions.EnumDirections)
{
Base6Directions.DirectionFlags directionFlag = Base6Directions.GetDirectionFlag(direction);
if (!cellInfo.ExploredDirections.HasFlag(directionFlag))
{
Vector3I intVector = Base6Directions.GetIntVector(direction);
MyCellCoord coord = new MyCellCoord {
Lod = 0,
CoordInLod = (Vector3I)(this.m_currentCell + intVector)
};
if (((coord.CoordInLod.X != -1) && (coord.CoordInLod.Y != -1)) && (coord.CoordInLod.Z != -1))
{
ulong key = coord.PackId64();
if (this.m_triangleLists.ContainsKey(key))
{
this.m_navmeshComponents.MarkExplored(key, Base6Directions.GetFlippedDirection(direction));
Base6Directions.DirectionFlags *flagsPtr1 = (Base6Directions.DirectionFlags *) ref cellInfo.ExploredDirections;
*((sbyte *)flagsPtr1) = *(((byte *)flagsPtr1)) | Base6Directions.GetDirectionFlag(direction);
}
}
}
}
this.m_navmeshComponents.SetExplored(this.m_packedCoord, cellInfo.ExploredDirections);
}
private void CheckEmissivity()
{
if (!InScene)
{
return;
}
EmissivityState state = EmissivityState.WORKING;
var otherBlock = GetOtherMergeBlock();
if (!IsWorking)
{
state = EmissivityState.NONE;
}
else if (otherBlock != null)
{
var dir1 = Base6Directions.GetFlippedDirection(otherBlock.Orientation.TransformDirection(otherBlock.m_forward));
var dir2 = this.Orientation.TransformDirection(this.m_forward);
if (dir1 == dir2)
{
state = EmissivityState.LOCKED;
}
}
else if (InConstraint)
{
state = EmissivityState.CONSTRAINED;
}
if (state != m_emissivityState)
{
UpdateEmissivity(state);
}
}
private void UP()
{
PX = 0; NX = 0; PY = 0; NY = 0; PZ = 0; NZ = 0; bool a = false; var b = .0; double d; if (SC.TryGetPlanetElevation(MyPlanetElevation.Sealevel, out d))
{
a = d < AA; if (a)
{
b = PA(d);
}
}
var c = SC.Orientation; foreach (var t in T)
{
var e = c.TransformDirectionInverse(Base6Directions.GetFlippedDirection(t.Orientation.Forward)); var f = TH.GetValueOrDefault(t.BlockDefinition.SubtypeId); if (f == null)
{
P.Echo("Unknown thruster type: " + t.BlockDefinition.SubtypeId); continue;
}
var g = f.GetPower(a, b); switch (e)
{
case Base6Directions.Direction.Right: PX += g; break;
case Base6Directions.Direction.Left: NX += g; break;
case Base6Directions.Direction.Up: PY += g; break;
case Base6Directions.Direction.Down: NY += g; break;
case Base6Directions.Direction.Backward: PZ += g; break;
case Base6Directions.Direction.Forward: NZ += g; break;
}
}
}
public void Init(ShipControlCommons shipControl,
Base6Directions.Direction localForward = Base6Directions.Direction.Forward)
{
LocalForward = localForward;
LocalBackward = Base6Directions.GetFlippedDirection(LocalForward);
thrustPID.Reset();
}
// Finds the grid direction for left (x) and down (y)
private void GetAxis(IMyTextPanel panel, out Vector3I xAxis, out Vector3I yAxis)
{
Base6Directions.Direction xAxisDir = Base6Directions.GetFlippedDirection(panel.Orientation.Left);
xAxis = Vector3I.Round(Base6Directions.GetVector(xAxisDir));
Base6Directions.Direction yAxisDir = Base6Directions.GetFlippedDirection(panel.Orientation.Up);
yAxis = Vector3I.Round(Base6Directions.GetVector(yAxisDir));
}
private float CalcForceInDirection(Base6Directions.Direction direction)
{
float force = 0;
using (lock_thrustersInDirection.AcquireSharedUsing())
foreach (MyThrust thruster in m_thrustersInDirection[(int)direction])
{
if (!thruster.Closed && thruster.IsWorking)
{
force += GetThrusterMaxForce(thruster);
}
}
m_totalThrustForce[(int)direction] = force;
if (direction == m_primaryForce.Direction)
{
//Log.DebugLog("updating primary force, direction: " + direction + ", force: " + force, "CalcForceInDirection()");
m_primaryForce.Force = force;
}
else if (force > m_primaryForce.Force * 1.1f)
{
Log.DebugLog("stronger than primary force, direction: " + direction + ", force: " + force + ", acceleration: " + force / myGrid.Physics.Mass + ", primary: " + m_primaryForce, Logger.severity.DEBUG);
m_secondaryForce = m_primaryForce;
m_primaryForce.Direction = direction;
m_primaryForce.Force = force;
if (m_secondaryForce.Direction == Base6Directions.GetFlippedDirection(m_primaryForce.Direction))
{
m_secondaryForce = new ForceInDirection()
{
Direction = Base6Directions.GetPerpendicular(m_primaryForce.Direction)
}
}
;
Log.DebugLog("secondary: " + m_secondaryForce);
Standard.SetMatrixOrientation(m_primaryForce.Direction, m_secondaryForce.Direction);
Gravity.SetMatrixOrientation(m_secondaryForce.Direction, m_primaryForce.Direction);
}
else if (direction == m_secondaryForce.Direction)
{
//Log.DebugLog("updating secondary force, direction: " + direction + ", force: " + force, "CalcForceInDirection()");
m_secondaryForce.Force = force;
}
else if (force > m_secondaryForce.Force * 1.1f && direction != Base6Directions.GetFlippedDirection(m_primaryForce.Direction))
{
Log.DebugLog("stronger than secondary force, direction: " + direction + ", force: " + force + ", acceleration: " + force / myGrid.Physics.Mass + ", secondary: " + m_secondaryForce, Logger.severity.DEBUG);
m_secondaryForce.Direction = direction;
m_secondaryForce.Force = force;
Standard.SetMatrixOrientation(m_primaryForce.Direction, m_secondaryForce.Direction);
Gravity.SetMatrixOrientation(m_secondaryForce.Direction, m_primaryForce.Direction);
}
//Log.DebugLog("direction: " + direction + "(" + (int)direction + ")" + ", force: " + force);
return(force);
}
public void Run(ZACommons commons, EventDriver eventDriver)
{
var shipControl = (ShipControlCommons)commons;
ResetIfNotLive(commons, eventDriver);
if (!Active)
{
return;
}
// Determine velocity
var velocity = shipControl.LinearVelocity;
// If we have no velocity, we have no ship controllers.
// In theory, ResetIfNotLive should have caught it above
if (velocity != null)
{
var cruiseDirectionFlipped = Base6Directions.GetFlippedDirection(CruiseDirection);
// Determine forward vector
var forward3I = shipControl.Reference.Position + Base6Directions.GetIntVector(shipControl.ShipBlockOrientation.TransformDirection(CruiseDirection));
var forward = Vector3D.Normalize(shipControl.Reference.CubeGrid.GridIntegerToWorld(forward3I) - shipControl.ReferencePoint);
CurrentSpeed = Vector3D.Dot((Vector3D)velocity, forward);
var error = TargetSpeed - CurrentSpeed;
var force = thrustPID.Compute(error);
//commons.Echo("Force: " + force);
var thrustControl = shipControl.ThrustControl;
var collect = ParseCruiseFlags();
if (Math.Abs(error) < CRUISE_CONTROL_DEAD_ZONE * TargetSpeed)
{
// Close enough, just disable both sets of thrusters
thrustControl.Enable(CruiseDirection, false, collect);
thrustControl.Enable(cruiseDirectionFlipped, false, collect);
}
else if (force > 0.0)
{
// Thrust forward
thrustControl.Enable(CruiseDirection, true, collect);
thrustControl.SetOverride(CruiseDirection, force, collect);
thrustControl.Enable(cruiseDirectionFlipped, false, collect);
}
else
{
thrustControl.Enable(CruiseDirection, false, collect);
thrustControl.Enable(cruiseDirectionFlipped, true, collect);
thrustControl.SetOverride(cruiseDirectionFlipped, -force, collect);
}
}
eventDriver.Schedule(FramesPerRun, Run);
}
void SetupThrusters()
{
//add all backward facing thrusters to backwardThruster list.
thrusters = new List <IMyThrust>();
GridTerminalSystem.GetBlocksOfType(thrusters);
foreach (IMyThrust thruster in thrusters)
{
if (Base6Directions.GetFlippedDirection(rc.Orientation.Forward) == Base6Directions.GetFlippedDirection(thruster.Orientation.Forward))
{
backwardThrusters.Add(thruster);
}
}
}
/// <summary>
/// Creates properties for a thruster and adds it to allMyThrusters. If the thruster is working, calls enableDisableThruster(true).
/// </summary>
/// <param name="thruster">The new thruster</param>
private void newThruster(IMySlimBlock thruster)
{
float dampingForce = 10 * (MyDefinitionManager.Static.GetCubeBlockDefinition(thruster.GetObjectBuilder()) as MyThrustDefinition).ForceMagnitude;
ThrusterProperties properties = new ThrusterProperties(dampingForce, Base6Directions.GetFlippedDirection(thruster.FatBlock.Orientation.Forward));
allMyThrusters.Add(thruster.FatBlock, properties);
thruster.FatBlock.IsWorkingChanged += block_IsWorkingChanged;
if (thruster.FatBlock.IsWorking)
{
enableDisableThruster(properties, true);
}
return;
}
public void Burn(ZACommons commons, EventDriver eventDriver)
{
if (ShouldAbort(commons, eventDriver, Modes.Burning, false))
{
return;
}
var shipControl = (ShipControlCommons)commons;
var controller = GetShipController(shipControl);
if (controller == null)
{
return;
}
var gravity = controller.GetNaturalGravity();
if (gravity.LengthSquared() > 0.0)
{
// Override gyro, disable "bottom" thrusters
shipControl.Reset(gyroOverride: true, thrusterEnable: true,
thrusterCondition: ThrusterCondition);
shipControl.ThrustControl.Enable(Base6Directions.GetFlippedDirection(BrakeDirection), false);
var down = shipControl.ShipBlockOrientation.TransformDirection(BrakeDirection);
seeker.Init(shipControl,
shipUp: Base6Directions.GetPerpendicular(down),
shipForward: down);
if (Autodrop)
{
// "forward" & "right"
var forward = Base6Directions.GetPerpendicular(BrakeDirection);
var right = Base6Directions.GetCross(forward, BrakeDirection);
// Actual orientations don't matter
// Just as long as they're planar & perpendicular to down
LongCruiser.Init(shipControl, localForward: forward);
LatCruiser.Init(shipControl, localForward: right);
}
Mode = Modes.Gliding;
eventDriver.Schedule(FramesPerRun, Glide);
}
else
{
cruiser.Cruise(shipControl, VTVLHELPER_BURN_SPEED,
condition: ThrusterCondition);
eventDriver.Schedule(FramesPerRun, Burn);
}
}
private void calcOrientationFromBlockDirection(IMyCubeBlock block)
{
if (CNS.match_direction != null)
{
log("already have an orientation: " + CNS.match_direction + ":" + CNS.match_roll, "calcOrientationFromBlockDirection()", Logger.severity.TRACE);
return;
}
Base6Directions.Direction?landDirLocal;
if (!landingDirectionLocal(block, out landDirLocal))
{
log("could not get landing direction from block: " + block.DefinitionDisplayNameText, "calcOrientationFromBlockDirection()", Logger.severity.INFO);
return;
}
Base6Directions.Direction?blockDirection;
direction_RCfromGrid(landDirLocal, out blockDirection);
switch (blockDirection)
{
case Base6Directions.Direction.Forward:
CNS.match_direction = Base6Directions.GetFlippedDirection((Base6Directions.Direction)CNS.landDirection); //CNS.match_direction = Base6Directions.Direction.Backward;
// roll is irrelevant
break;
case Base6Directions.Direction.Backward:
CNS.match_direction = CNS.landDirection; //CNS.match_direction = Base6Directions.Direction.Forward;
// roll is irrelevant
break;
case Base6Directions.Direction.Up:
CNS.match_direction = Base6Directions.GetPerpendicular((Base6Directions.Direction)CNS.landDirection); //CNS.match_direction = Base6Directions.Direction.Up;
CNS.match_roll = Base6Directions.GetFlippedDirection((Base6Directions.Direction)CNS.landDirection); //CNS.match_roll = Base6Directions.Direction.Backward;
break;
case Base6Directions.Direction.Down:
CNS.match_direction = Base6Directions.GetPerpendicular((Base6Directions.Direction)CNS.landDirection); //CNS.match_direction = Base6Directions.Direction.Down;
CNS.match_roll = CNS.landDirection; //CNS.match_direction = Base6Directions.Direction.Forward;
break;
case Base6Directions.Direction.Left:
CNS.match_direction = Base6Directions.GetPerpendicular((Base6Directions.Direction)CNS.landDirection); //CNS.match_roll = Base6Directions.Direction.Up;
CNS.match_roll = Base6Directions.GetFlippedDirection(Base6Directions.GetCross((Base6Directions.Direction)CNS.match_direction, (Base6Directions.Direction)CNS.landDirection)); //CNS.match_direction = Base6Directions.Direction.Left;
break;
case Base6Directions.Direction.Right:
CNS.match_direction = Base6Directions.GetPerpendicular((Base6Directions.Direction)CNS.landDirection); //CNS.match_roll = Base6Directions.Direction.Up;
CNS.match_roll = Base6Directions.GetCross((Base6Directions.Direction)CNS.match_direction, (Base6Directions.Direction)CNS.landDirection); //CNS.match_direction = Base6Directions.Direction.Right;
break;
}
log("landDirection = " + landDirLocal + ", blockDirection = " + blockDirection + ", match_direction = " + CNS.match_direction + ", match_roll = " + CNS.match_roll, "calcOrientationFromBlockDirection()", Logger.severity.DEBUG);
}
public void update(IMyGridTerminalSystem terminal, IMyShipController cockpit)
{
_cockpit = cockpit;
Base6Directions.Direction cockpitForward = _cockpit.Orientation.TransformDirection(Base6Directions.Direction.Forward);
for (int i = 0; i < 6; ++i)
{
_thrust[i].Clear();
terminal.GetBlocksOfType(_thrust[i], b =>
// The desired direction, transformed by the cockpit, is equal to the direction of thrust
_cockpit.Orientation.TransformDirection(GRID_THRUST_DIRECTIONS[i])
== Base6Directions.GetFlippedDirection(b.Orientation.Forward));
_effectiveThrust[i] = computeTotalEffectiveThrust(_thrust[i]);
}
}
public void SetMatrixOrientation(Base6Directions.Direction forward, Base6Directions.Direction up)
{
if (forward == up || forward == Base6Directions.GetFlippedDirection(up))
{
Log.AlwaysLog("incompatible directions, for2: " + forward + ", up2: " + up, Logger.severity.FATAL);
throw new ArgumentException("forward is not perpendicular to up");
}
Matrix localMatrix = LocalMatrix;
localMatrix.Forward = Base6Directions.GetVector(forward);
localMatrix.Up = Base6Directions.GetVector(up);
localMatrix.Right = Base6Directions.GetVector(Base6Directions.GetCross(forward, up));
this.LocalMatrix = localMatrix;
}
/// <summary>
/// Adds thruster to thrustersInDirection
/// </summary>
/// <param name="thruster">The new thruster</param>
private void newThruster(MyThrust thruster)
{
Log.DebugLog("thruster == null", Logger.severity.ERROR, condition: thruster == null);
if (TP_ThrustOverride == null)
{
TP_ThrustOverride = thruster.GetProperty("Override") as ITerminalProperty <float>;
}
using (lock_thrustersInDirection.AcquireExclusiveUsing())
m_thrustersInDirection[(int)Base6Directions.GetFlippedDirection(thruster.Orientation.Forward)].Add(thruster);
if (TP_ThrustOverride.GetValue(thruster) != 0f)
{
TP_ThrustOverride.SetValue(thruster, 0f);
}
}
private bool direction_RCfromGrid(Base6Directions.Direction?gridDirection, out Base6Directions.Direction?result)
{
if (gridDirection == null)
{
result = null;
return(false);
}
IMyCubeBlock myRC = myNav.currentRCblock;
if (myRC.Orientation.Left == gridDirection)
{
result = Base6Directions.Direction.Left;
return(true);
}
if (Base6Directions.GetFlippedDirection(myRC.Orientation.Left) == gridDirection)
{
result = Base6Directions.Direction.Right;
return(true);
}
if (myRC.Orientation.Up == gridDirection)
{
result = Base6Directions.Direction.Up;
return(true);
}
if (Base6Directions.GetFlippedDirection(myRC.Orientation.Up) == gridDirection)
{
result = Base6Directions.Direction.Down;
return(true);
}
if (myRC.Orientation.Forward == gridDirection)
{
result = Base6Directions.Direction.Forward;
return(true);
}
if (Base6Directions.GetFlippedDirection(myRC.Orientation.Forward) == gridDirection)
{
result = Base6Directions.Direction.Backward;
return(true);
}
myLogger.log(Logger.severity.ERROR, "direction_RCfromGrid", "failed to match direction: " + gridDirection);
result = null;
return(false);
}
private void StartReverse(ShipControlCommons shipControl, EventDriver eventDriver)
{
shipControl.Reset(gyroOverride: true);
var shipBackward = Base6Directions.GetFlippedDirection(shipControl.ShipForward);
seeker.Init(shipControl,
shipUp: shipControl.ShipUp,
shipForward: shipBackward);
cruiser.Init(shipControl,
localForward: Base6Directions.Direction.Backward);
if (Mode != REVERSING)
{
Mode = REVERSING;
eventDriver.Schedule(0, Reverse);
}
}
private Vector3I CalculateOtherGridOffset()
{
Debug.Assert(m_other != null);
Vector3 myConstraint = ConstraintPositionInGridSpace() / this.CubeGrid.GridSize;
Vector3 otherConstraint = -m_other.ConstraintPositionInGridSpace() / m_other.CubeGrid.GridSize;
Base6Directions.Direction thisRight = Orientation.TransformDirection(m_right); // Where does this block's right point to
Base6Directions.Direction thisForward = Orientation.TransformDirection(m_forward); // Where does this block's forward point to
Base6Directions.Direction otherBackward = Base6Directions.GetFlippedDirection(m_other.Orientation.TransformDirection(m_other.m_forward));
Base6Directions.Direction otherRight = m_other.CubeGrid.WorldMatrix.GetClosestDirection(CubeGrid.WorldMatrix.GetDirectionVector(thisRight));
Vector3 toOtherOrigin;
MatrixI rotation = MatrixI.CreateRotation(otherRight, otherBackward, thisRight, thisForward);
Vector3.Transform(ref otherConstraint, ref rotation, out toOtherOrigin);
return(Vector3I.Round(myConstraint + toOtherOrigin));
}
private void TO(Vector3D o)
{
TS = false; var a = SC.Orientation; foreach (var t in T)
{
var d = a.TransformDirectionInverse(Base6Directions.GetFlippedDirection(t.Orientation.Forward)); switch (d)
{
case Base6Directions.Direction.Right: t.SetValueFloat("Override", Math.Max(0, (float)o.X)); break;
case Base6Directions.Direction.Left: t.SetValueFloat("Override", Math.Max(0, (float)-o.X)); break;
case Base6Directions.Direction.Up: t.SetValueFloat("Override", Math.Max(0, (float)o.Y)); break;
case Base6Directions.Direction.Down: t.SetValueFloat("Override", Math.Max(0, (float)-o.Y)); break;
case Base6Directions.Direction.Backward: t.SetValueFloat("Override", Math.Max(0, (float)o.Z)); break;
case Base6Directions.Direction.Forward: t.SetValueFloat("Override", Math.Max(0, (float)-o.Z)); break;
}
}
}
internal Light(IMyLightingBlock b, Base6Directions.Direction dir)
{
light = b;
isSpotlight = b.BlockDefinition.SubtypeName.ToLowerInvariant().Contains("frontlight");
isExitLight = isSpotlight && b.Orientation.Forward == Base6Directions.GetFlippedDirection(dir);
b.Intensity = 20;
b.Radius = 200;
b.Falloff = 4;
maxIntensity = b.Intensity;
maxRadius = b.Radius;
switch (dir)
{
case Base6Directions.Direction.Backward: //+Z
positionValue = b.Position.Z;
break;
case Base6Directions.Direction.Forward:
positionValue = -b.Position.Z;
break;
case Base6Directions.Direction.Right: //+X
positionValue = b.Position.X;
break;
case Base6Directions.Direction.Left:
positionValue = -b.Position.X;
break;
case Base6Directions.Direction.Down:
positionValue = -b.Position.Y;
break;
case Base6Directions.Direction.Up: //+Y
positionValue = b.Position.Y;
break;
}
}
private void setArtificialGravity(float gnat, float g)
{
float eff = getAGravEfficacy(gnat);
float f = eff <= 0 ? 0 : 1F / eff;
if (SPLIT_GRAVITY)
{
f /= gravGens.Count;
}
if (gravDriveOn())
{
Echo("Gravity Drive is working, all other gravity disabled.");
f = 0;
}
else
{
Echo("Setting gravity generator level to " + f * 100 + "% in direction " + upDirection.ToString());
}
foreach (IMyGravityGenerator gen in gravGens)
{
if (f <= 0 || g <= 0)
{
gen.Enabled = false;
}
else
{
float sign = 0;
if (gen.Orientation.Up == upDirection)
{
sign = 1;
}
else if (gen.Orientation.Up == Base6Directions.GetFlippedDirection(upDirection))
{
sign = -1;
}
float amt = g * 9.81F * f * sign;
gen.Enabled = Math.Abs(amt) > 0;
gen.GravityAcceleration = amt;
}
}
}
public void Init(IEnumerable <IMyTerminalBlock> blocks,
Func <IMyThrust, bool> collect = null,
Base6Directions.Direction shipUp = Base6Directions.Direction.Up,
Base6Directions.Direction shipForward = Base6Directions.Direction.Forward)
{
MyBlockOrientation shipOrientation = new MyBlockOrientation(shipForward, shipUp);
thrusters.Clear();
foreach (var block in blocks)
{
var thruster = block as IMyThrust;
if (thruster != null && thruster.IsFunctional &&
(collect == null || collect(thruster)))
{
var facing = thruster.Orientation.TransformDirection(Base6Directions.Direction.Forward); // Exhaust goes this way
var thrustDirection = Base6Directions.GetFlippedDirection(facing);
var shipDirection = shipOrientation.TransformDirectionInverse(thrustDirection);
AddThruster(shipDirection, thruster);
}
}
}
public static Vector3I CalculateOffset(IMyCubeBlock pad1, IMyCubeBlock pad2)
{
Vector3 pad1local = pad1.Position; // ConstraintPositionInGridSpace(pad1) / pad1.CubeGrid.GridSize;
Vector3 pad2local = -pad2.Position; // -ConstraintPositionInGridSpace(pad2) / pad2.CubeGrid.GridSize;
// I dunno why it works but it seems to do in the tests I made xD
pad1local += Base6Directions.GetVector(pad1.Orientation.TransformDirection(Base6Directions.GetOppositeDirection(WeldPad.DirForward)));
//pad2local += Base6Directions.GetVector(pad2.Orientation.TransformDirection(Base6Directions.GetOppositeDirection(WeldPad.DIR_FORWARD)));
Base6Directions.Direction direction = pad1.Orientation.TransformDirection(WeldPad.DirRight);
MatrixI matrix = MatrixI.CreateRotation(
newB: pad1.Orientation.TransformDirection(WeldPad.DirForward),
oldB: Base6Directions.GetFlippedDirection(pad2.Orientation.TransformDirection(WeldPad.DirForward)),
oldA: pad2.CubeGrid.WorldMatrix.GetClosestDirection(pad1.CubeGrid.WorldMatrix.GetDirectionVector(direction)),
newA: direction);
Vector3 offset;
Vector3.Transform(ref pad2local, ref matrix, out offset);
return(Vector3I.Round(pad1local + offset));
}
/// <summary>
/// if removed is a thruster, remove it from thrustersInDirection
/// </summary>
/// <remarks>
/// if a working block is destroyed, block_IsWorkingChange() is called first
/// </remarks>
/// <param name="removed">block that was removed</param>
private void grid_OnBlockRemoved(IMySlimBlock removed)
{
try
{
if (removed.FatBlock == null)
{
return;
}
MyThrust asThrust = removed.FatBlock as MyThrust;
if (asThrust == null)
{
return;
}
using (lock_thrustersInDirection.AcquireExclusiveUsing())
m_thrustersInDirection[(int)Base6Directions.GetFlippedDirection(asThrust.Orientation.Forward)].Remove(asThrust);
Log.DebugLog("removed thruster = " + removed.FatBlock.DefinitionDisplayNameText + "/" + asThrust.DisplayNameText, Logger.severity.DEBUG);
return;
}
catch (Exception e)
{ Log.AlwaysLog("Exception: " + e, Logger.severity.ERROR); }
}
private void SetThrustersOverride(Vector3D overrides)
{
thrustersStopped = false;
MyBlockOrientation orientation = shipController.Orientation;
foreach (IMyThrust thruster in thrusters)
{
Base6Directions.Direction direction = Base6Directions.GetFlippedDirection(thruster.Orientation.Forward);
switch (direction)
{
case Base6Directions.Direction.Right:
thruster.SetValueFloat("Override", Math.Max(0, (float)overrides.X));
break;
case Base6Directions.Direction.Left:
thruster.SetValueFloat("Override", Math.Max(0, (float)-overrides.X));
break;
case Base6Directions.Direction.Up:
thruster.SetValueFloat("Override", Math.Max(0, (float)overrides.Y));
break;
case Base6Directions.Direction.Down:
thruster.SetValueFloat("Override", Math.Max(0, (float)-overrides.Y));
break;
case Base6Directions.Direction.Backward:
thruster.SetValueFloat("Override", Math.Max(0, (float)overrides.Z));
break;
case Base6Directions.Direction.Forward:
thruster.SetValueFloat("Override", Math.Max(0, (float)-overrides.Z));
break;
}
}
}
/// <summary>
/// Creates a PseudoBlock from a block and an orientation.
/// </summary>
/// <param name="block">The block to calculate the local matrix from.</param>
/// <param name="forward">The direction the block should face towards the target.</param>
/// <param name="up">A direction perpendicular to forward.</param>
public PseudoBlock(IMyCubeBlock block, Base6Directions.Direction?forward, Base6Directions.Direction?up)
: this(block)
{
Base6Directions.Direction for2 = forward ?? block.FirstFaceDirection();
Base6Directions.Direction up2 = up ??
(for2 == Base6Directions.Direction.Forward ? Base6Directions.Direction.Up : Base6Directions.GetPerpendicular(for2));
if (for2 == up2 || for2 == Base6Directions.GetFlippedDirection(up2))
{
Log.DebugLog("incompatible directions, for2: " + for2 + ", up2: " + up2);
up2 = Base6Directions.GetPerpendicular(for2);
}
this.LocalMatrix = new Matrix()
{
Forward = block.LocalMatrix.GetDirectionVector(for2),
Up = block.LocalMatrix.GetDirectionVector(up2),
Right = block.LocalMatrix.GetDirectionVector(Base6Directions.GetCross(for2, up2)),
M41 = block.LocalMatrix.M41,
M42 = block.LocalMatrix.M42,
M43 = block.LocalMatrix.M43,
M44 = block.LocalMatrix.M44
};
}
public void Main(string argument, UpdateType updateSource)
{
string[] argInfo = argument.Split(new string[] { "," }, StringSplitOptions.None);
if (argument == "RUN")
{
//Check if can scan, and scan if can.
if (cam.CanScan(rayCastDistance))
{
detectedInfo = cam.Raycast(rayCastDistance);
}
else
{
Echo("Can't scan yet!");
}
Echo("INITIATING");
coordinate = Vector3D.Zero; //initating to zero value.
Boolean found = false;
if (detectedInfo.HitPosition != null)
{
coordinate = detectedInfo.HitPosition.Value;
found = true;
}
if (found)
{
Vector3D currentCoords = rc.GetPosition();
//creating unit vector
double denominator = Math.Sqrt(Math.Pow(coordinate.X - currentCoords.X, 2)
+ Math.Pow(coordinate.Y - currentCoords.Y, 2)
+ Math.Pow(coordinate.Z - currentCoords.Z, 2));
double xMultiplier = (coordinate.X - currentCoords.X) / denominator;
double yMultiplier = (coordinate.Y - currentCoords.Y) / denominator;
double zMultiplier = (coordinate.Z - currentCoords.Z) / denominator;
//manipulating target coordinate with unit vector
coordinate.X -= finalDistFromTarget * xMultiplier;
coordinate.Y -= finalDistFromTarget * yMultiplier;
coordinate.Z -= finalDistFromTarget * zMultiplier;
//Setting up backward thrusters list
backwardThrusters = new List <IMyThrust>();
//Obtaining each thruster pointing backward
foreach (IMyThrust thruster in thrusters)
{
if (Base6Directions.GetFlippedDirection(rc.Orientation.Forward) == Base6Directions.GetFlippedDirection(thruster.Orientation.Forward))
{
backwardThrusters.Add(thruster);
}
}
//Obtaining max backward acceleration
MyShipMass myShipMass = rc.CalculateShipMass();
backwardsAcceleration = CalculateAcceleration(myShipMass.TotalMass, backwardThrusters);
//autopilot settings
rc.ClearWaypoints();
rc.AddWaypoint(coordinate, "AUTO DYNAMIC BRAKING SCRIPT COORDINATE");
rc.SetAutoPilotEnabled(true);
rc.SetCollisionAvoidance(false);
rc.SetDockingMode(false); //CHANGE??? or dont?
rc.FlightMode = FlightMode.OneWay;
rc.Direction = Base6Directions.Direction.Forward;
blindMode = false;
}
}
else if (argInfo[0] == "blind".ToLower())
{
int dist = 0;
Boolean passed = Int32.TryParse(argInfo[1], out dist);
if (passed)
{
Vector3D dir = rc.WorldMatrix.Forward;
coordinate = rc.GetPosition();
coordinate.X += dir.X * dist;
coordinate.Y += dir.Y * dist;
coordinate.Z += dir.Z * dist;
Vector3D currentCoords = rc.GetPosition();
//Setting up backward thrusters list
backwardThrusters = new List <IMyThrust>();
//Obtaining each thruster pointing backward
foreach (IMyThrust thruster in thrusters)
{
if (Base6Directions.GetFlippedDirection(rc.Orientation.Forward) == Base6Directions.GetFlippedDirection(thruster.Orientation.Forward))
{
backwardThrusters.Add(thruster);
}
}
//Obtaining max backward acceleration
MyShipMass myShipMass = rc.CalculateShipMass();
backwardsAcceleration = CalculateAcceleration(myShipMass.TotalMass, backwardThrusters);
//autopilot settings
rc.ClearWaypoints();
rc.AddWaypoint(coordinate, "CAPTXAN'S SCRIPT COORDINATE");
rc.SetAutoPilotEnabled(true);
rc.SetCollisionAvoidance(false);
rc.SetDockingMode(false); //CHANGE??? or dont?
rc.FlightMode = FlightMode.OneWay;
rc.Direction = Base6Directions.Direction.Forward;
blindMode = true;
blindCounter = 0;
}
else
{
Echo("2nd parameter is not a number!");
}
}
else
{
//User Feedback
if (!cam.CanScan(rayCastDistance))
{
float percentage = ((cam.TimeUntilScan(rayCastDistance) / 1000) / (rayCastDistance / 2000));
percentage = (1 - percentage) * 100;
Echo("Raycast is recharging " + percentage + "%");
if (!cam.EnableRaycast)
{
cam.EnableRaycast = true;
}
}
else
{
Echo("Ready to Scan");
cam.EnableRaycast = false;
}
//Travelling CHANGE HERE FOR ENABLE / DISABLE AUTOPILOT
if (rc.IsAutoPilotEnabled)
{
travelling = true;
double currentDistanceFromTarget = Vector3D.Distance(coordinate, rc.GetPosition());
Echo("Travelling, ETA: " + (int)(currentDistanceFromTarget / rc.GetShipSpeed()) + "s");
//Calculating stopping distance to determine if thrusters need to be enabled.
Echo("Current Speed: " + (int)rc.GetShipSpeed() + "m/s");
Echo("Ship Speed Limit: " + rc.SpeedLimit + "m/s");
if (rc.GetShipSpeed() > rc.SpeedLimit - 1) //If ship at max speed
{
Vector3D currentTrajectory = Vector3D.Normalize(rc.GetPosition() - prevPosition);
prevPosition = rc.GetPosition();
Vector3D calculatedTrajectory = Vector3D.Normalize(rc.GetPosition() - coordinate);
double accuracyAmount;
if (currentDistanceFromTarget > 15000)
{
accuracyAmount = .99999;
}
else if (currentDistanceFromTarget > 5000)
{
accuracyAmount = .9999;
}
else
{
accuracyAmount = .999;
}
if (currentDistanceFromTarget * .90 > (Math.Pow(rc.GetShipSpeed(), 2) / (2 * backwardsAcceleration)) &&
Math.Abs(currentTrajectory.Dot(calculatedTrajectory)) > accuracyAmount)
{
foreach (IMyThrust thruster in thrusters)
{
thruster.ApplyAction("OnOff_Off");
}
}
else //Curr < stopp
{
foreach (IMyThrust thruster in thrusters)
{
thruster.ApplyAction("OnOff_On");
}
}
}
Echo("Blind Mode: " + blindMode);
if (blindMode)
{
Echo("Blind Counter: " + blindCounter);
Echo("Coll Avoid: " + rc.);
if (cam.CanScan(((Math.Pow(rc.GetShipSpeed(), 2) / (2 * backwardsAcceleration)) * 2)))
{
detectedInfo = cam.Raycast((Math.Pow(maxSpeed, 2) / (2 * backwardsAcceleration)) * 2);
if (detectedInfo.HitPosition != null)
{
rc.SpeedLimit = 3;
rc.SetCollisionAvoidance(true);
blindCounter = 0;
}
else
{
if (blindCounter > 500)
{
rc.SpeedLimit = maxSpeed;
rc.SetCollisionAvoidance(false);
blindCounter = 0;
}
else
{
blindCounter++;
}
}
}
}
}
else if (travelling)
{
foreach (IMyThrust thruster in thrusters)
{
thruster.ApplyAction("OnOff_On");
}
travelling = false;
blindMode = false;
}
}
//Additional Arugment Commands
if (argument == "ABORT")
{
rc.SetAutoPilotEnabled(false);
rc.DampenersOverride = true;
}
}
private void MergeFromAnotherMesh(MyGridNavigationMesh otherMesh, ref MatrixI transform)
{
ProfilerShort.Begin("MergeFromAnotherMesh");
m_mergeHelper.Clear();
// Save the cubes from the other mesh that are touching cubes of this mesh into a helper set.
// Also put the touched cubes from this mesh into the set.
foreach (var position in otherMesh.m_smallTriangleRegistry.Keys)
{
bool add = false;
foreach (var direction in Base6Directions.IntDirections)
{
// CH: TODO: We query the grid so far, but in the future, we should make sure that the access is thread-safe
Vector3I pos = Vector3I.Transform(position + direction, transform);
if (m_cubeSet.Contains(ref pos)) // Test the transformed position...
{
m_mergeHelper.Add(position + direction); // ... but add the original one
add = true;
}
}
if (add)
{
m_mergeHelper.Add(position);
}
}
foreach (var entry in otherMesh.m_smallTriangleRegistry)
{
Vector3I originalCube = entry.Key;
Vector3I tformedCube; Vector3I.Transform(ref originalCube, ref transform, out tformedCube);
// If the cube is one of the touching cubes, we have to intersect the touching triangles
if (m_mergeHelper.Contains(originalCube))
{
// Take the touching pairs one by one and calculate triangulation of the disjoint union of the opposing faces
// Remove the opposing faces from the old block
// Add the triangulation to the mesh
// Add the rest of the navmesh from this block to the mesh
m_tmpTriangleList.Clear();
// CH: TODO. Just remove the triangles now
foreach (var direction in Base6Directions.EnumDirections)
{
Vector3I directionVec = Base6Directions.GetIntVector((int)direction);
Base6Directions.Direction tformedDirection = transform.GetDirection(direction);
Vector3I tformedFlippedVec = Base6Directions.GetIntVector((int)Base6Directions.GetFlippedDirection(tformedDirection));
// Remove face triangles from this mesh
if (m_mergeHelper.Contains(originalCube + directionVec))
{
List <int> triList = null;
if (m_smallTriangleRegistry.TryGetValue(tformedCube - tformedFlippedVec, out triList))
{
foreach (var index in triList)
{
var triangle = GetTriangle(index);
// CH: TODO: This will probably be expensive. Could we precalculate it?
if (IsFaceTriangle(triangle, tformedCube - tformedFlippedVec, tformedFlippedVec))
{
m_tmpTriangleList.Add(new KeyValuePair <MyNavigationTriangle, Vector3I>(triangle, tformedCube - tformedFlippedVec));
}
}
}
}
}
foreach (var triangle in m_tmpTriangleList)
{
RemoveTriangle(triangle.Key, triangle.Value);
}
m_tmpTriangleList.Clear();
int debugCounter = 0;
// CH: TODO: optimize this (actually whole this method)
foreach (var triangleIndex in entry.Value)
{
var triangle = otherMesh.GetTriangle(triangleIndex);
Vector3I pos = entry.Key;
bool addTriangle = true;
foreach (var direction in Base6Directions.EnumDirections)
{
Vector3I dirvec = Base6Directions.GetIntVector((int)direction);
if (m_mergeHelper.Contains(pos + dirvec) && IsFaceTriangle(triangle, pos, dirvec))
{
addTriangle = false;
break;
}
}
if (addTriangle)
{
if (debugCounter == 5)
{
}
CopyTriangle(triangle, pos, ref transform);
debugCounter++;
}
}
}
// Otherwise, we just transform the triangles from the other mesh and add them to this mesh
else
{
foreach (var triangleIndex in entry.Value)
{
var triangle = otherMesh.GetTriangle(triangleIndex);
CopyTriangle(triangle, entry.Key, ref transform);
//if (triangleIndex > 1) break;
}
}
}
m_mergeHelper.Clear();
ProfilerShort.End();
}
// Returns a position with the same position and with a flipped direction
// .-------. .-------.
// | | | |
// | o-->| ~> |<--o |
// | | | |
// '-------* .-------.
public ConveyorLinePosition GetFlippedPosition()
{
return(new ConveyorLinePosition(LocalGridPosition, Base6Directions.GetFlippedDirection(Direction)));
}
