Пример #1
0
 private void ComputeReservedSpace(MyObjectBuilder_CubeGrid primaryGrid, IEnumerable <MyObjectBuilder_CubeGrid> allGrids, BlockSetInfo info)
 {
     m_reservedSpaces.Clear();
     ReservedSpace = new BoundingBox();
     foreach (var block in primaryGrid.CubeBlocks)
     {
         foreach (var name in block.ConfigNames())
         {
             if (!name.StartsWithICase(ReservedSpacePrefix))
             {
                 continue;
             }
             var args = name.Substring(ReservedSpacePrefix.Length).Trim().Split(' ').Select(x => x.Trim()).Where(x => x.Length > 0).ToArray();
             var box  = PartDummyUtils.ParseReservedSpace(MyDefinitionManager.Static.GetCubeSize(primaryGrid.GridSizeEnum), block, args,
                                                          Logger.Warning);
             box.Box.Max += (Vector3I)block.Min;
             box.Box.Min += (Vector3I)block.Min;
             if (m_reservedSpaces.Count == 0)
             {
                 ReservedSpace = new BoundingBox(box.Box.Min, box.Box.Max);
             }
             ReservedSpace = ReservedSpace.Include(box.Box.Min);
             ReservedSpace = ReservedSpace.Include(box.Box.Max);
             m_reservedSpaces.Add(box);
         }
     }
 }
Пример #2
0
        private void ComputeMountPoints(MyObjectBuilder_CubeGrid primaryGrid, IEnumerable <MyObjectBuilder_CubeGrid> allGrids, BlockSetInfo info)
        {
            m_mountPoints.Clear();
            foreach (var block in primaryGrid.CubeBlocks)
            {
                foreach (var name in block.ConfigNames())
                {
                    if (!name.StartsWithICase(MountPrefix))
                    {
                        continue;
                    }
                    var parts = PartDummyUtils.ConfigArguments(name.Substring(MountPrefix.Length)).ToArray();
                    if (parts.Length < 3)
                    {
                        continue;
                    }
                    var spec = parts[0].Split(':');
                    if (spec.Length != 2)
                    {
                        continue;
                    }

                    var mountType  = spec[0];
                    var mountPiece = spec[1];
                    var mountName  = parts[1];

                    Dictionary <string, PartMount> partsOfType;
                    if (!m_mountPoints.TryGetValue(mountType, out partsOfType))
                    {
                        partsOfType = m_mountPoints[mountType] = new Dictionary <string, PartMount>();
                    }
                    PartMount mount;
                    if (!partsOfType.TryGetValue(mountName, out mount))
                    {
                        mount = partsOfType[mountName] = new PartMount(this, mountType, mountName);
                    }

                    var args = new string[parts.Length - 2];
                    for (var i = 2; i < parts.Length; i++)
                    {
                        args[i - 2] = parts[i];
                    }

                    var pmpb = new PartMountPointBlock(mount);
                    pmpb.Init(block, mountPiece, args);
                    mount.Add(pmpb);
                }
            }

            m_mountPointBlocks.Clear();
            foreach (var mount in MountPoints)
            {
                foreach (var block in mount.Blocks)
                {
                    m_mountPointBlocks[block.AnchorLocation] = block;
                }
            }
        }
        public void Init(MyObjectBuilder_CubeBlock block, string piece, IEnumerable <string> args)
        {
            Piece                = piece;
            MountDirection6      = Base6Directions.GetOppositeDirection(Base6Directions.GetCross(block.BlockOrientation.Up, block.BlockOrientation.Forward));
            AnchorLocation       = block.Min;
            AdjacencyRule        = AdjacencyRule.Any;
            BiasDirection6       = null;
            SecondBiasDirection6 = null;

            var blockOrientation = new MatrixI(block.BlockOrientation);

            foreach (var arg in args)
            {
                if (arg.StartsWithICase(PartDummyUtils.ArgumentMountDirection))
                {
                    Base6Directions.Direction tmpMountDirection;
                    if (Enum.TryParse(arg.Substring(PartDummyUtils.ArgumentMountDirection.Length), out tmpMountDirection))
                    {
                        MountDirection6 = blockOrientation.GetDirection(tmpMountDirection);
                    }
                    else
                    {
                        Logging.Error("Failed to parse mount point direction argument \"{0}\"", arg);
                    }
                }
                else if (arg.StartsWithICase(PartDummyUtils.ArgumentBiasDirection))
                {
                    Base6Directions.Direction tmpBiasDirection;
                    if (Enum.TryParse(arg.Substring(PartDummyUtils.ArgumentBiasDirection.Length), out tmpBiasDirection))
                    {
                        BiasDirection6 = blockOrientation.GetDirection(tmpBiasDirection);
                    }
                    else
                    {
                        Logging.Error("Failed to parse bias direction argument \"{0}\"", arg);
                    }
                }
                else if (arg.StartsWithICase(PartDummyUtils.ArgumentSecondBiasDirection))
                {
                    Base6Directions.Direction tmpBiasDirection;
                    if (Enum.TryParse(arg.Substring(PartDummyUtils.ArgumentSecondBiasDirection.Length), out tmpBiasDirection))
                    {
                        SecondBiasDirection6 = blockOrientation.GetDirection(tmpBiasDirection);
                    }
                    else
                    {
                        Logging.Error("Failed to parse second bias direction argument \"{0}\"", arg);
                    }
                }
                else if (arg.StartsWithICase(PartDummyUtils.ArgumentAnchorPoint))
                {
                    Vector3I anchor;
                    if (PartDummyUtils.TryParseVector(arg.Substring(PartDummyUtils.ArgumentAnchorPoint.Length), out anchor))
                    {
                        AnchorLocation = block.Min + anchor;
                        continue;
                    }
                    Logging.Error("Failed to parse anchor location argument \"{0}\"", arg);
                }
                else if (arg.StartsWithICase(PartDummyUtils.ArgumentAdjacencyRule)) // Adjacency Rule
                {
                    AdjacencyRule rule;
                    if (Enum.TryParse(arg.Substring(PartDummyUtils.ArgumentAdjacencyRule.Length), out rule))
                    {
                        AdjacencyRule = rule;
                    }
                    else
                    {
                        Logging.Error("Failed to parse adjacency rule argument \"{0}\"", arg);
                    }
                }
                else
                {
                    Logging.Error("Failed to parse mount point argument \"{0}\"", arg);
                }
            }
            // ReSharper disable once InvertIf
            if (SecondBiasDirection6.HasValue && !BiasDirection6.HasValue)
            {
                BiasDirection6       = SecondBiasDirection6;
                SecondBiasDirection6 = null;
            }
        }
Пример #4
0
        public static ReservedSpace ParseReservedSpace(float gridSize, MyObjectBuilder_CubeBlock src, string[] args, Utilities.LoggingCallback log = null)
        {
            var optional = false;
            var shared   = false;
            var nSet     = false;
            var pSet     = false;
            var nExt     = Vector3.Zero;
            var pExt     = Vector3.Zero;

            foreach (var arg in args)
            {
                if (arg.StartsWithICase("NE:"))
                {
                    Vector3 tmp;
                    if (PartDummyUtils.TryParseVector(arg.Substring(3), out tmp))
                    {
                        nSet = true;
                        nExt = tmp;
                    }
                    else
                    {
                        log?.Invoke("Failed to decode negative extent argument \"{0}\"", arg);
                    }
                }
                else if (arg.StartsWithICase("PE:"))
                {
                    Vector3 tmp;
                    if (PartDummyUtils.TryParseVector(arg.Substring(3), out tmp))
                    {
                        pSet = true;
                        pExt = tmp;
                    }
                    else
                    {
                        log?.Invoke("Failed to decode positive extent argument \"{0}\"", arg);
                    }
                }
                else if (arg.Equals("share", StringComparison.CurrentCultureIgnoreCase) || arg.Equals("shared", StringComparison.CurrentCultureIgnoreCase))
                {
                    shared = true;
                }
                else if (arg.Equals("opt", StringComparison.CurrentCultureIgnoreCase) || arg.Equals("optional", StringComparison.CurrentCultureIgnoreCase) || arg.Equals("hint", StringComparison.CurrentCultureIgnoreCase))
                {
                    optional = true;
                }
                else
                {
                    log?.Invoke("Failed to decode argument \"{0}\"", arg);
                }
            }
            if (!nSet || !pSet)
            {
                var sense = src as MyObjectBuilder_SensorBlock;
                if (sense != null)
                {
                    if (!nSet)
                    {
                        nExt = (Vector3)sense.FieldMin / gridSize;
                    }
                    if (!pSet)
                    {
                        pExt = (Vector3)sense.FieldMax / gridSize;
                    }
                }
                else
                {
                    log?.Invoke("Isn't a sensor block and isn't fully specified");
                }
            }
            var srcTra = new MatrixI(src.BlockOrientation).GetFloatMatrix();

            nExt = Vector3.TransformNormal(nExt, srcTra);
            pExt = Vector3.TransformNormal(pExt, srcTra);
            return(new ReservedSpace()
            {
                Box = new BoundingBox(nExt, pExt), IsOptional = optional, IsShared = shared
            });
        }