public static void AnnounceConnect(MyShipConnector masterConnector, MyShipConnector slaveConnector, ref Matrix masterMatrix, ref Matrix slaveMatrix)
{
var msg = new ConnectMsg();
msg.MasterEntityId = masterConnector.EntityId;
msg.SlaveEntityId = slaveConnector.EntityId;
msg.MasterForward = masterMatrix.Forward;
msg.MasterUp = masterMatrix.Up;
msg.MasterTranslation = masterMatrix.Translation;
msg.SlaveForward = slaveMatrix.Forward;
msg.SlaveUp = slaveMatrix.Up;
msg.SlaveTranslation = slaveMatrix.Translation;
Sync.Layer.SendMessageToAll(ref msg);
}
private void ConnectInternal(ref Matrix thisMatrix, ref Matrix otherMatrix, MyShipConnector otherConnector, bool constructor)
{
Debug.Assert(!m_attachableConveyorEndpoint.AlreadyAttached());
if (m_attachableConveyorEndpoint.AlreadyAttached()) m_attachableConveyorEndpoint.DetachAll();
m_attachableConveyorEndpoint.Attach(otherConnector.m_attachableConveyorEndpoint);
var data = new HkFixedConstraintData();
data.SetInWorldSpace(ref thisMatrix, ref otherMatrix, ref thisMatrix);
var newConstraint = new HkConstraint(CubeGrid.Physics.RigidBody, otherConnector.CubeGrid.Physics.RigidBody, data);
this.Connected = true;
this.Master = true;
otherConnector.Connected = true;
otherConnector.Master = false;
if (!constructor)
{
this.ChangeConstraint(otherConnector, newConstraint);
otherConnector.ChangeConstraint(this, newConstraint);
}
else
{
this.SetConstraint(otherConnector, newConstraint);
otherConnector.SetConstraint(this, newConstraint);
}
AddConstraint(newConstraint);
if (CubeGrid != otherConnector.CubeGrid)
{
this.OnConstraintAdded(GridLinkTypeEnum.Logical, otherConnector.CubeGrid);
this.OnConstraintAdded(GridLinkTypeEnum.Physical, otherConnector.CubeGrid);
}
}
private void ConnectNosync(ref Matrix localSpaceA, ref Matrix localSpaceB, MyShipConnector otherConnector)
{
Debug.Assert(!Connected);
if (m_constraint != null)
{
RemoveConstraint(otherConnector, m_constraint);
}
ConnectInternal(ref localSpaceA, ref localSpaceB, otherConnector);
}
private void UnsetConstraint()
{
Debug.Assert(InConstraint);
m_other = null;
m_constraint = null;
UpdateEmissivity();
}
private void ConnectOnInit(MyShipConnector otherConnector)
{
// This can happen if the other grid failed deserializaing during load, but only after the connector was deserialized
if (otherConnector.CubeGrid.Physics == null) return;
Matrix thisMatrix = this.CubeGrid.Physics.RigidBody.GetRigidBodyMatrix();
Matrix otherMatrix = otherConnector.CubeGrid.Physics.RigidBody.GetRigidBodyMatrix();
ConnectInternal(ref thisMatrix, ref otherMatrix, otherConnector, constructor: true);
}
private static MyShipConnector TryFindConnectorInGrid(ref BoundingSphereD sphere, MyCubeGrid grid, MyShipConnector thisConnector = null)
{
m_tmpBlockSet.Clear();
grid.GetBlocksInsideSphere(ref sphere, m_tmpBlockSet);
foreach (var block in m_tmpBlockSet)
{
if (block.FatBlock == null || !(block.FatBlock is MyShipConnector)) continue;
var connector = block.FatBlock as MyShipConnector;
if (connector.InConstraint) continue;
if (connector == thisConnector) continue;
if (!connector.IsWorking) continue;
if (!connector.FriendlyWithBlock(thisConnector)) continue;
m_tmpBlockSet.Clear();
return connector;
}
m_tmpBlockSet.Clear();
return null;
}
private void CreateConstraintInit(MyShipConnector otherConnector)
{
var posA = ConstraintPositionInGridSpace();
var posB = otherConnector.ConstraintPositionInGridSpace();
var axisA = ConstraintAxisGridSpace();
var axisB = -otherConnector.ConstraintAxisGridSpace();
CreateConstraintNosync(otherConnector, ref posA, ref posB, ref axisA, ref axisB);
}
protected float GetEffectiveStrength(MyShipConnector otherConnector)
{
float strength = 0.0f;
if (!IsReleasing)
{
strength = Math.Min(Strength, otherConnector.Strength);
if (strength <= MinStrength)
strength = 0.0000001f; // Must be > 0
}
return strength;
}
private void UpdateConnectionState()
{
if (!IsMaster)
return;
var state = m_connectionState.Value;
// Make sure constraints correctly represents ConnectionState.
if (state.OtherEntityId == 0) // Detached
{
if (InConstraint)
{
Detach(false);
}
}
else if (state.MasterToSlave == null) // Aproaching
{
if (Connected || (InConstraint && m_other.EntityId != state.OtherEntityId))
{
// Detach when connected or aproaching something else
Detach(false);
}
MyShipConnector connector;
if (!InConstraint && MyEntities.TryGetEntityById<MyShipConnector>(state.OtherEntityId, out connector) && connector.FriendlyWithBlock(this) && connector.Closed == false && connector.MarkedForClose == false)
{
if (Physics != null && connector.Physics != null)
{
if (Sync.IsServer == false && state.MasterToSlaveGrid.HasValue)
{
CubeGrid.WorldMatrix = MatrixD.Multiply(state.MasterToSlaveGrid.Value, connector.WorldMatrix);
}
CreateConstraintNosync(connector);
UpdateEmissivity();
m_other.UpdateEmissivity();
}
}
}
else // Connected
{
if (Connected && m_other.EntityId != state.OtherEntityId)
{
Detach(false);
}
MyShipConnector connector;
if (!Connected && MyEntities.TryGetEntityById<MyShipConnector>(state.OtherEntityId, out connector) && connector.FriendlyWithBlock(this))
{
m_other = connector;
var masterToSlave = state.MasterToSlave;
if (masterToSlave.HasValue && masterToSlave.Value.IsZero)
{
// Special case when deserializing old saves with connected connector (old saves does not have MasterToSlave transform...it's zero)
masterToSlave = null;
}
if (Sync.IsServer == false && state.MasterToSlaveGrid.HasValue)
{
this.CubeGrid.WorldMatrix = MatrixD.Multiply(state.MasterToSlaveGrid.Value, connector.WorldMatrix);
}
Weld(masterToSlave);
}
}
}
private void RemoveConstraint(MyShipConnector otherConnector, HkConstraint constraint)
{
if (this.m_hasConstraint)
{
if (CubeGrid.Physics != null)
CubeGrid.Physics.RemoveConstraint(constraint);
m_hasConstraint = false;
}
else
{
if (otherConnector.CubeGrid.Physics != null)
otherConnector.CubeGrid.Physics.RemoveConstraint(constraint);
otherConnector.m_hasConstraint = false;
}
constraint.Dispose();
}
//connectors priority : static grid is always slave to dynamic
// large grid is always slave to small grid
// if grid size or physical state is same than higher entityId will be master
// this is computed only first time when approaching and set only by server
MyShipConnector GetMaster(MyShipConnector first, MyShipConnector second)
{
MyCubeGrid firstGrid = first.CubeGrid;
MyCubeGrid secondGrid = second.CubeGrid;
//static grids are always slaves
if (firstGrid.IsStatic != secondGrid.IsStatic)
{
if (firstGrid.IsStatic)
{
return second;
}
if (secondGrid.IsStatic)
{
return first;
}
}
else if (firstGrid.GridSize != secondGrid.GridSize)
{
if (firstGrid.GridSizeEnum == MyCubeSize.Large)
{
return second;
}
if (secondGrid.GridSizeEnum == MyCubeSize.Large)
{
return first;
}
}
return first.EntityId < second.EntityId ? second : first;
}
public MyDebugRenderCompoonentShipConnector(MyShipConnector shipConnector)
: base(shipConnector)
{
m_shipConnector = shipConnector;
}
public ConnectorWrapper( MySlimBlock block )
: base(block)
{
Block = (MyShipConnector)block.FatBlock;
}
private void ConnectInternal(ref Matrix localSpaceA, ref Matrix localSpaceB, MyShipConnector otherConnector)
{
Debug.Assert(EntityId > otherConnector.EntityId, "Constraints should be created only master (entity with higher EntityId)");
Debug.Assert(!m_attachableConveyorEndpoint.AlreadyAttached());
if (m_attachableConveyorEndpoint.AlreadyAttached()) m_attachableConveyorEndpoint.DetachAll();
m_attachableConveyorEndpoint.Attach(otherConnector.m_attachableConveyorEndpoint);
var data = new HkFixedConstraintData();
data.SetInBodySpace(localSpaceA, localSpaceB, CubeGrid.Physics, otherConnector.CubeGrid.Physics);
var newConstraint = new HkConstraint(CubeGrid.Physics.RigidBody, otherConnector.CubeGrid.Physics.RigidBody, data);
this.Connected = true;
otherConnector.Connected = true;
this.SetConstraint(otherConnector, newConstraint);
otherConnector.SetConstraint(this, newConstraint);
AddConstraint(newConstraint);
if (CubeGrid != otherConnector.CubeGrid)
{
this.OnConstraintAdded(GridLinkTypeEnum.Logical, otherConnector.CubeGrid);
this.OnConstraintAdded(GridLinkTypeEnum.Physical, otherConnector.CubeGrid);
}
CubeGrid.OnPhysicsChanged += CubeGrid_OnPhysicsChanged;
}
public static void RequestDetach(MyShipConnector connector)
{
var msg = new DetachMsg();
msg.MasterEntityId = connector.EntityId;
Sync.Layer.SendMessageToServer(ref msg, MyTransportMessageEnum.Request);
}
private void CreateConstraint(MyShipConnector otherConnector)
{
CreateConstraintNosync(otherConnector);
if (Sync.IsServer)
{
MatrixD masterToSlave = CubeGrid.WorldMatrix * MatrixD.Invert(m_other.WorldMatrix);
m_connectionState.Value = new State() {IsMaster = true, OtherEntityId = otherConnector.EntityId, MasterToSlave = null,MasterToSlaveGrid = masterToSlave};
otherConnector.m_connectionState.Value = new State() { IsMaster = false, OtherEntityId = EntityId, MasterToSlave = null};
}
}
public static void AnnounceDetach(MyShipConnector connector)
{
var msg = new DetachMsg();
msg.MasterEntityId = connector.EntityId;
Sync.Layer.SendMessageToAll(ref msg, MyTransportMessageEnum.Success);
}
private void CreateConstraintNosync(MyShipConnector otherConnector)
{
Debug.Assert(IsMaster, "Constraints should be created only master (entity with higher EntityId)");
var posA = ConstraintPositionInGridSpace();
var posB = otherConnector.ConstraintPositionInGridSpace();
var axisA = ConstraintAxisGridSpace();
var axisB = -otherConnector.ConstraintAxisGridSpace();
var data = new HkHingeConstraintData();
data.SetInBodySpace(posA, posB, axisA, axisB, CubeGrid.Physics, otherConnector.CubeGrid.Physics);
var data2 = new HkMalleableConstraintData();
data2.SetData(data);
data.ClearHandle();
data = null;
data2.Strength = GetEffectiveStrength(otherConnector);
var newConstraint = new HkConstraint(CubeGrid.Physics.RigidBody, otherConnector.CubeGrid.Physics.RigidBody, data2);
SetConstraint(otherConnector, newConstraint);
otherConnector.SetConstraint(this, newConstraint);
AddConstraint(newConstraint);
}
private void CreateConstraint(MyShipConnector otherConnector)
{
var posA = ConstraintPositionInGridSpace();
var posB = otherConnector.ConstraintPositionInGridSpace();
var axisA = ConstraintAxisGridSpace();
var axisB = -otherConnector.ConstraintAxisGridSpace();
CreateConstraintNosync(otherConnector, ref posA, ref posB, ref axisA, ref axisB);
MySyncShipConnector.AnnounceApproach(this, otherConnector);
}
private void SetConstraint(MyShipConnector other, HkConstraint newConstraint)
{
m_other = other;
m_constraint = newConstraint;
UpdateEmissivity();
}
private void CreateConstraintNosync(MyShipConnector otherConnector, ref Vector3 posA, ref Vector3 posB, ref Vector3 axisA, ref Vector3 axisB)
{
var data = new HkHingeConstraintData();
data.SetInBodySpace(ref posA, ref posB, ref axisA, ref axisB);
var data2 = new HkMalleableConstraintData();
data2.SetData(data);
data.ClearHandle();
data = null;
data2.Strength = 0.0003f;
var newConstraint = new HkConstraint(CubeGrid.Physics.RigidBody, otherConnector.CubeGrid.Physics.RigidBody, data2);
this.Master = true;
otherConnector.Master = false;
SetConstraint(otherConnector, newConstraint);
otherConnector.SetConstraint(this, newConstraint);
AddConstraint(newConstraint);
}
public static void SendChangePropertyMessage(bool newValue, MyShipConnector block, Properties property)
{
var msg = new ChangePropertyMsg();
msg.EntityId = block.EntityId;
msg.Value = newValue;
msg.Property = property;
if (Sync.IsServer)
{
Sync.Layer.SendMessageToAllAndSelf(ref msg, MyTransportMessageEnum.Success);
}
else
{
Sync.Layer.SendMessageToServer(ref msg, MyTransportMessageEnum.Request);
}
}
private void ChangeConstraint(MyShipConnector other, HkConstraint newConstraint)
{
Debug.Assert(InConstraint);
m_other = other;
m_constraint = newConstraint;
UpdateEmissivity();
}
public static void AnnounceApproach(MyShipConnector thisConnector, MyShipConnector otherConnector)
{
var msg = new ApproachMsg();
msg.EntityId = thisConnector.EntityId;
msg.OtherEntityId = otherConnector.EntityId;
Sync.Layer.SendMessageToAll(msg);
}
private void ConnectNosync(ref Matrix thisMatrix, ref Matrix otherMatrix, MyShipConnector otherConnector)
{
Debug.Assert(m_other == otherConnector);
Debug.Assert(InConstraint);
Debug.Assert(!Connected);
Debug.Assert(m_other != null);
if (m_other != null)
{
Debug.Assert(this.m_constraint == m_other.m_constraint);
Debug.Assert(this == m_other.m_other);
}
if (m_constraint != null)
{
RemoveConstraint(otherConnector, m_constraint);
}
ConnectInternal(ref thisMatrix, ref otherMatrix, otherConnector, constructor: false);
}
public static void RequestConnect(MyShipConnector masterConnector)
{
var msg = new RequestConnectMsg();
msg.MasterEntityId = masterConnector.EntityId;
Sync.Layer.SendMessageToServer(ref msg);
}
private void RemoveConstraint(MyShipConnector otherConnector, HkConstraint constraint)
{
if (this.HasConstraint)
{
CubeGrid.Physics.RemoveConstraint(constraint);
HasConstraint = false;
}
else
{
otherConnector.CubeGrid.Physics.RemoveConstraint(constraint);
otherConnector.HasConstraint = false;
}
constraint.Dispose();
}
private void CreateConstraint(MyShipConnector otherConnector)
{
CreateConstraintNosync(otherConnector);
if (Sync.IsServer)
{
m_connectionState.Value = new State() { OtherEntityId = otherConnector.EntityId, MasterToSlave = null };
otherConnector.m_connectionState.Value = new State() { OtherEntityId = EntityId, MasterToSlave = null };
}
}