public GridComponents(IMyProjector p)
{
if (p.ProjectedGrid != null)
{
Dictionary <MyDefinitionId, int> ids = new Dictionary <MyDefinitionId, int>();
MyObjectBuilder_Projector ob = (MyObjectBuilder_Projector)p.GetObjectBuilderCubeBlock(true);
foreach (MyObjectBuilder_CubeGrid grid in ob.ProjectedGrids)
{
foreach (MyObjectBuilder_CubeBlock block in grid.CubeBlocks)
{
int num;
MyDefinitionId id = block.GetId();
if (ids.TryGetValue(id, out num))
{
ids[id] = num + 1;
}
else
{
ids[id] = 1;
}
}
}
foreach (KeyValuePair <MyDefinitionId, int> kv in ids)
{
MyCubeBlockDefinition def = MyDefinitionManager.Static.GetCubeBlockDefinition(kv.Key);
if (def != null)
{
IncludeCount(def, kv.Value);
}
}
}
}
public StructureProjectorModel(MyObjectBuilder_CubeGrid grid, MyObjectBuilder_Projector proj)
: base(null)
{
var identity = SpaceEngineersCore.WorldResource.Checkpoint.Identities.FirstOrDefault(p => p.PlayerId == proj.Owner);
if (identity != null)
{
_ownerName = identity.DisplayName;
}
else
{
_ownerName = "Nobody";
}
_gridName = grid.DisplayName;
identity = SpaceEngineersCore.WorldResource.Checkpoint.Identities.FirstOrDefault(p => p.PlayerId == proj.BuiltBy);
if (identity != null)
{
_builderName = identity.DisplayName;
}
else
{
_builderName = "Nobody";
}
_builderName = $"(by {_builderName})";
identity = SpaceEngineersCore.WorldResource.Checkpoint.Identities.FirstOrDefault(p => p.PlayerId == grid.GetTopBuilderId());
if (identity != null)
{
_gridBuilderName = identity.DisplayName;
}
else
{
_gridBuilderName = "Nobody";
}
_gridBuilderName = $"(by {_gridBuilderName})";
DisplayName = proj.GetBlockName(grid);
_enabled = proj.Enabled && proj.ProjectedGrid != null;
if (proj.ProjectedGrid == null)
{
return;
}
_blockStatistics = new BlockStatistics(proj.ProjectedGrid.CubeBlocks);
BlockCount = proj.ProjectedGrid.CubeBlocks.Count;
_blockCountStr = $"{proj.ProjectedGrid.CubeBlocks.Count} ({((decimal)proj.ProjectedGrid.CubeBlocks.Count / grid.CubeBlocks.Count * 100):F1}% of self)";
}
public static bool TryCreate(ulong activator, IMyProjector p, bool shiftBuildArea, out ProjectedGrid projectedGrid)
{
projectedGrid = null;
// Ensure the projector is valid and has a projection
if (p.CubeGrid?.Physics == null)
{
Utilities.Notify(Constants.msgError + "bad_physics", activator);
return(false);
}
if (p.ProjectedGrid == null)
{
Utilities.Notify(Constants.msgNoGrid, activator);
return(false);
}
MyObjectBuilder_Projector pBuilder = (MyObjectBuilder_Projector)p.GetObjectBuilderCubeBlock(true);
if (pBuilder.ProjectedGrids == null || pBuilder.ProjectedGrids.Count == 0)
{
Utilities.Notify(Constants.msgNoGrid, activator);
return(false);
}
// Prepare list of grids
List <MyObjectBuilder_CubeGrid> grids = pBuilder.ProjectedGrids;
int largestIndex = FindLargest(grids);
MyObjectBuilder_CubeGrid largestGrid = grids[largestIndex];
if (Utilities.SupportsSubgrids(p))
{
if (largestIndex != 0)
{
MyObjectBuilder_CubeGrid temp = grids[0];
grids[0] = largestGrid;
grids[largestIndex] = temp;
}
}
else
{
grids.Clear();
grids.Add(largestGrid);
}
MatrixD largestMatrixInvert = MatrixD.Invert(largestGrid.PositionAndOrientation.Value.GetMatrix());
MatrixD targetMatrix = p.ProjectedGrid.WorldMatrix;
float scale = GetScale(p);
GridOrientation orientation = new GridOrientation(p);
GridComponents comps = null;
if (!MyAPIGateway.Session.CreativeMode)
{
comps = new GridComponents();
}
int totalBlocks = 0;
MyIDModule owner = ((MyCubeBlock)p).IDModule;
if (activator != 0)
{
long temp = MyAPIGateway.Players.TryGetIdentityId(activator);
if (temp != 0)
{
if (owner.ShareMode == MyOwnershipShareModeEnum.All)
{
owner = new MyIDModule(temp, MyOwnershipShareModeEnum.Faction);
}
else
{
owner = new MyIDModule(temp, owner.ShareMode);
}
}
}
Random rand = new Random();
foreach (MyObjectBuilder_CubeGrid grid in grids)
{
totalBlocks += grid.CubeBlocks.Count;
if (totalBlocks > IPSession.Instance.MapSettings.MaxBlocks)
{
Utilities.Notify(Constants.msgGridLarge, activator);
return(false);
}
PrepBlocks(rand, owner, grid, comps);
if (grid.CubeBlocks.Count == 0)
{
Utilities.Notify(Constants.msgGridSmall, activator);
return(false);
}
grid.IsStatic = false;
grid.CreatePhysics = true;
grid.Immune = false;
grid.DestructibleBlocks = true;
MatrixD current = grid.PositionAndOrientation.Value.GetMatrix();
if (scale != 1)
{
current.Translation /= scale;
}
MatrixD newWorldMatrix = (current * largestMatrixInvert) * targetMatrix;
grid.PositionAndOrientation = new MyPositionAndOrientation(ref newWorldMatrix);
orientation.Include(newWorldMatrix);
}
if (totalBlocks < IPSession.Instance.MapSettings.MinBlocks)
{
Utilities.Notify(Constants.msgGridSmall, activator);
return(false);
}
if (comps == null)
{
comps = new GridComponents();
}
else
{
comps.ApplySettings(IPSession.Instance.MapSettings);
int needed;
MyDefinitionId neededId;
if (!comps.HasComponents(Utilities.GetInventories(p), out needed, out neededId))
{
Utilities.Notify(Utilities.GetCompsString(needed, neededId), activator);
return(false);
}
}
GridBounds bounds = new GridBounds(p, grids);
IMyEntity e = bounds.GetOverlappingEntity();
if (e != null && (!shiftBuildArea || !bounds.HasClearArea()))
{
Utilities.Notify(Utilities.GetOverlapString(true, e), activator);
return(false);
}
projectedGrid = new ProjectedGrid(activator, p, grids, bounds, comps, orientation, shiftBuildArea, totalBlocks);
return(true);
}
