private Matrix GetGridOrientation(MyObjectBuilder_ProjectorBase projectorBuilder)
{
m_dirForward = Vector3.Forward;
m_dirUp = Vector3.Up;
m_orientationAngle = 0f;
RotateAroundAxis(0, Math.Sign(projectorBuilder.ProjectionRotation.X), Math.Abs(projectorBuilder.ProjectionRotation.X * MathHelper.PiOver2));
RotateAroundAxis(1, Math.Sign(projectorBuilder.ProjectionRotation.Y), Math.Abs(projectorBuilder.ProjectionRotation.Y * MathHelper.PiOver2));
RotateAroundAxis(2, Math.Sign(projectorBuilder.ProjectionRotation.Z), Math.Abs(projectorBuilder.ProjectionRotation.Z * MathHelper.PiOver2));
return(Matrix.CreateWorld(Vector3.Zero, m_dirForward, m_dirUp) * Matrix.CreateFromAxisAngle(m_dirUp, m_orientationAngle));
}
public override MyObjectBuilder_CubeBlock GetObjectBuilderCubeBlock(bool copy = false)
{
MyObjectBuilder_ProjectorBase objectBuilder = (MyObjectBuilder_ProjectorBase)base.GetObjectBuilderCubeBlock(copy);
if (m_clipboard != null && m_clipboard.CopiedGrids != null && m_clipboard.CopiedGrids.Count > 0 && m_originalGridBuilder != null)
{
if (copy)
{
var clone = (MyObjectBuilder_CubeGrid)m_originalGridBuilder.Clone();
MyEntities.RemapObjectBuilder(clone);
objectBuilder.ProjectedGrid = clone;
}
else
{
objectBuilder.ProjectedGrid = m_originalGridBuilder;
}
objectBuilder.ProjectionOffset = m_projectionOffset;
objectBuilder.ProjectionRotation = m_projectionRotation;
objectBuilder.KeepProjection = m_keepProjection;
}
else
{
if (objectBuilder.ProjectedGrid == null && m_savedProjection != null && CubeGrid.Projector == null)
{
objectBuilder.ProjectedGrid = m_savedProjection;
objectBuilder.ProjectionOffset = m_projectionOffset;
objectBuilder.ProjectionRotation = m_projectionRotation;
objectBuilder.KeepProjection = m_keepProjection;
}
else
{
objectBuilder.ProjectedGrid = null;
}
}
objectBuilder.ShowOnlyBuildable = m_showOnlyBuildable;
objectBuilder.InstantBuildingEnabled = m_instantBuildingEnabled;
objectBuilder.MaxNumberOfProjections = m_maxNumberOfProjections;
objectBuilder.MaxNumberOfBlocks = m_maxNumberOfBlocksPerProjection;
objectBuilder.ProjectionsRemaining = m_projectionsRemaining;
objectBuilder.GetOwnershipFromProjector = m_getOwnershipFromProjector;
return(objectBuilder);
}
private void BuildBlock(IMySlimBlock block, MyCubeBlock constructionBlock)
{
MyObjectBuilder_CubeBlock cubeBlock = block.GetObjectBuilder();
MyObjectBuilder_ProjectorBase projectorBuilder = null;// = (MyObjectBuilder_ProjectorBase)constructionBlock.GetObjectBuilderCubeBlock();
MyCubeGrid projectorGrid = null;
MyCubeGrid blockGrid = (MyCubeGrid)block.CubeGrid;
MyCubeBlock projector = null;
foreach (var item in NaniteConstructionManager.ProjectorBlocks)
{
var projectorTest = item.Value as IMyProjector;
if (projectorTest == null)
{
continue;
}
if (projectorTest.ProjectedGrid == null)
{
continue;
}
if (projectorTest.ProjectedGrid == block.CubeGrid)
{
projector = (MyCubeBlock)projectorTest;
projectorGrid = projector.CubeGrid;
projectorBuilder = (MyObjectBuilder_ProjectorBase)projector.GetObjectBuilderCubeBlock();
break;
}
}
/*
* Ingame.IMyGridTerminalSystem system = MyAPIGateway.TerminalActionsHelper.GetTerminalSystemForGrid((IMyCubeGrid)m_constructionBlock.ConstructionBlock.CubeGrid);
* List<Ingame.IMyTerminalBlock> terminalBlocks = new List<Ingame.IMyTerminalBlock>();
* system.GetBlocks(terminalBlocks);
* foreach(var item in terminalBlocks)
* {
* if (!(item is IMyFunctionalBlock) || !((IMyFunctionalBlock)item).Enabled)
* continue;
*
* if (!(item is Ingame.IMyProjector))
* continue;
*
* var cube = (MyCubeBlock)item;
* MyObjectBuilder_ProjectorBase testBuilder = (MyObjectBuilder_ProjectorBase)cube.GetObjectBuilderCubeBlock();
* if (testBuilder.ProjectedGrid == null)
* continue;
*
* if(testBuilder.ProjectedGrid.DisplayName == blockGrid.DisplayName)
* {
* projector = cube;
* projectorGrid = cube.CubeGrid;
* projectorBuilder = testBuilder;
* break;
* }
* }
*/
if (projectorBuilder == null)
{
Logging.Instance.WriteLine("PROBLEM Can not locate projector that is projecting target!");
return;
}
Quaternion quat = Quaternion.Identity;
var orientation = block.Orientation;
Matrix local;
orientation.GetMatrix(out local);
var gridOrientation = GetGridOrientation(projectorBuilder);
if (gridOrientation != Matrix.Identity)
{
var afterRotation = Matrix.Multiply(local, gridOrientation);
orientation = new MyBlockOrientation(ref afterRotation);
}
Quaternion projQuat = Quaternion.Identity;
projector.Orientation.GetQuaternion(out projQuat);
orientation.GetQuaternion(out quat);
quat = Quaternion.Multiply(projQuat, quat);
// Get real block max
MyCubeBlockDefinition blockDefinition = (MyCubeBlockDefinition)block.BlockDefinition;
Vector3I blockMax = block.Max;
Vector3I blockMin = cubeBlock.Min;
Vector3I position = block.Position;
Vector3I min = projectorGrid.WorldToGridInteger(blockGrid.GridIntegerToWorld(blockMin));
Vector3I max = projectorGrid.WorldToGridInteger(blockGrid.GridIntegerToWorld(blockMax));
Vector3I pos = projectorGrid.WorldToGridInteger(blockGrid.GridIntegerToWorld(block.Position));
Vector3I projectedMin = new Vector3I(Math.Min(min.X, max.X), Math.Min(min.Y, max.Y), Math.Min(min.Z, max.Z));
Vector3I projectedMax = new Vector3I(Math.Max(min.X, max.X), Math.Max(min.Y, max.Y), Math.Max(min.Z, max.Z));
MyCubeGrid.MyBlockLocation location = new MyCubeGrid.MyBlockLocation(blockDefinition.Id, projectedMin, projectedMax, pos,
quat, 0, constructionBlock.OwnerId);
/*
* MyObjectBuilder_CubeGrid originalGridBuilder = (MyObjectBuilder_CubeGrid)blockGrid.GetObjectBuilder();
* MyObjectBuilder_CubeBlock objectBuilder = null;
* //Find original grid builder
* foreach (var blockBuilder in originalGridBuilder.CubeBlocks)
* {
* if (blockBuilder.GetId() == blockDefinition.Id)
* {
* if ((Vector3I)blockBuilder.Min == blockMin)
* {
* objectBuilder = (MyObjectBuilder_CubeBlock)blockBuilder.Clone();
* objectBuilder.SetupForProjector();
* }
* }
* }
*/
MyObjectBuilder_CubeBlock objectBuilder = cubeBlock;
objectBuilder.SetupForProjector();
var functionalBuilder = objectBuilder as MyObjectBuilder_FunctionalBlock;
if (functionalBuilder != null && !functionalBuilder.Enabled)
{
functionalBuilder.Enabled = true;
}
var terminalBuilder = objectBuilder as MyObjectBuilder_TerminalBlock;
if (terminalBuilder != null)
{
terminalBuilder.Owner = constructionBlock.OwnerId;
}
var shipConnector = objectBuilder as MyObjectBuilder_ShipConnector;
if (shipConnector != null)
{
shipConnector.Connected = false;
shipConnector.ConnectedEntityId = 0;
shipConnector.MasterToSlaveGrid = null;
shipConnector.MasterToSlaveTransform = null;
}
//if (objectBuilder == null)
// objectBuilder = cubeBlock;
location.EntityId = 0; // MyEntityIdentifier.AllocateId();
objectBuilder.EntityId = 0;
objectBuilder.ConstructionInventory = null;
projector.CubeGrid.BuildBlockRequest(block.GetColorMask().PackHSVToUint(), location, objectBuilder, constructionBlock.EntityId, false, constructionBlock.OwnerId);
}
private bool CanBuildBlock(MyObjectBuilder_CubeBlock block, MyCubeGrid blockGrid, MyCubeBlock projector, MyCubeGrid projectorGrid, MyObjectBuilder_ProjectorBase projectorBuilder)
{
MyBlockOrientation blockOrientation = block.BlockOrientation;
Matrix local;
blockOrientation.GetMatrix(out local);
var gridOrientation = GetGridOrientation(projectorBuilder);
if (gridOrientation != Matrix.Identity)
{
var afterRotation = Matrix.Multiply(local, gridOrientation);
blockOrientation = new MyBlockOrientation(ref afterRotation);
}
Quaternion blockOrientationQuat;
blockOrientation.GetQuaternion(out blockOrientationQuat);
Quaternion projQuat = Quaternion.Identity;
projector.Orientation.GetQuaternion(out projQuat);
blockOrientationQuat = Quaternion.Multiply(projQuat, blockOrientationQuat);
MyCubeBlockDefinition blockDefinition;
MyDefinitionManager.Static.TryGetCubeBlockDefinition(block.GetId(), out blockDefinition);
// Get real block max
Vector3I blockMax = Vector3I.Zero;
Vector3I blockMin = block.Min;
ComputeMax(blockDefinition, block.BlockOrientation, ref blockMin, out blockMax);
var position = ComputePositionInGrid(new MatrixI(block.BlockOrientation), blockDefinition, blockMin);
Vector3I projectedMin = projectorGrid.WorldToGridInteger(blockGrid.GridIntegerToWorld(block.Min));
Vector3I projectedMax = projectorGrid.WorldToGridInteger(blockGrid.GridIntegerToWorld(blockMax));
Vector3I blockPos = projectorGrid.WorldToGridInteger(blockGrid.GridIntegerToWorld(position));
Vector3I min = new Vector3I(Math.Min(projectedMin.X, projectedMax.X), Math.Min(projectedMin.Y, projectedMax.Y), Math.Min(projectedMin.Z, projectedMax.Z));
Vector3I max = new Vector3I(Math.Max(projectedMin.X, projectedMax.X), Math.Max(projectedMin.Y, projectedMax.Y), Math.Max(projectedMin.Z, projectedMax.Z));
projectedMin = min;
projectedMax = max;
if (!projectorGrid.CanAddCubes(projectedMin, projectedMax))
{
IMySlimBlock slimBlock = (IMySlimBlock)blockGrid.GetCubeBlock(block.Min);
if (slimBlock == null || slimBlock.FatBlock == null)
{
return(false);
}
Logging.Instance.WriteLine(string.Format("Can not add block: {0}: {1} - {2} {3} {4} {5}", slimBlock.FatBlock.EntityId, blockDefinition.Id, projectedMin, projectedMax, blockMin, blockMax)); //, slimBlock.FatBlock.EntityId));
return(false);
}
var mountPoints = blockDefinition.GetBuildProgressModelMountPoints(1.0f);
bool isConnected = MyCubeGrid.CheckConnectivity(projectorGrid, blockDefinition, mountPoints, ref blockOrientationQuat, ref blockPos);
if (isConnected)
{
if (projectorGrid.GetCubeBlock(blockPos) == null)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
private bool UpdateProjection(MyCubeBlock projector, MyCubeGrid projectedGrid, MyObjectBuilder_ProjectorBase projectorBuilder)
{
// god f*****g damnit object builders
MyCubeGrid cubeGrid = projector.CubeGrid;
MyObjectBuilder_CubeGrid gridBuilder = (MyObjectBuilder_CubeGrid)projectedGrid.GetObjectBuilder();
bool found = false;
foreach (MyObjectBuilder_CubeBlock blockBuilder in gridBuilder.CubeBlocks)
{
Vector3 worldPosition = projectedGrid.GridIntegerToWorld(blockBuilder.Min);
Vector3I realPosition = cubeGrid.WorldToGridInteger(worldPosition);
var realBlock = (IMySlimBlock)cubeGrid.GetCubeBlock(realPosition);
MyCubeBlockDefinition blockDefinition;
MyDefinitionManager.Static.TryGetCubeBlockDefinition(blockBuilder.GetId(), out blockDefinition);
if (realBlock != null) // && blockDefinition.Id == new MyDefinitionId(realBlock.GetType()))
{
//Logging.Instance.WriteLine(string.Format("Found overlap - {0} {1}", blockBuilder.GetId(), realBlock.GetObjectBuilder().GetId()));
}
else
{
//Logging.Instance.WriteLine(string.Format("No block at position: {0}", blockBuilder.GetId()));
if (CanBuildBlock(blockBuilder, projectedGrid, projector, cubeGrid, projectorBuilder))
{
//Logging.Instance.WriteLine(string.Format("No block at position: {0}", blockBuilder.GetId()));
var slimBlock = (IMySlimBlock)projectedGrid.GetCubeBlock(blockBuilder.Min);
if (slimBlock != null && slimBlock.CubeGrid.GetPosition() != Vector3D.Zero)
{
//Logging.Instance.WriteLine(string.Format("Adding block: {0}", blockBuilder.GetId()));
PotentialTargetList.Add(slimBlock);
found = true;
}
}
else
{
using (m_lock.AcquireExclusiveUsing())
{
foreach (var item in blockDefinition.Components)
{
if (!ComponentsRequired.ContainsKey(item.Definition.Id.SubtypeName))
{
ComponentsRequired.Add(item.Definition.Id.SubtypeName, item.Count);
}
else
{
ComponentsRequired[item.Definition.Id.SubtypeName] += item.Count;
}
}
}
}
}
}
return(found);
}
