C# MyCubeGrid.GetBlocks方法代码示例

        public MyStructuralIntegrity(MyCubeGrid cubeGrid)
        {
            m_cubeGrid = cubeGrid;
            m_cubeGrid.OnBlockAdded += cubeGrid_OnBlockAdded;

            switch (1)
            {
                case 0: m_simulator = new MyJacobianConstraintSimulator(m_cubeGrid.GetBlocks().Count); break;
                case 1: m_simulator = new MyAdvancedStaticSimulator(m_cubeGrid); break;
				case 2: m_simulator = new MyOndraSimulator(m_cubeGrid); break;
                case 3: m_simulator = new MyOndraSimulator2(m_cubeGrid); break;
                case 4: m_simulator = new MyOndraSimulator3(m_cubeGrid); break;
            }

            foreach (var block in m_cubeGrid.GetBlocks())
            {
                cubeGrid_OnBlockAdded(block);
            }
        }

        public static ulong GetBattlePoints(MyCubeGrid grid)
        {
            ulong points = 0;

            foreach (var block in grid.GetBlocks())
            {
                MyCompoundCubeBlock compoundBlock = block.FatBlock as MyCompoundCubeBlock;
                if (compoundBlock != null)
                {
                    foreach (var blockInCompound in compoundBlock.GetBlocks())
                        points += GetBattlePoints(blockInCompound);
                }
                else
                {
                    points += GetBattlePoints(block);
                }
            }

            return points;
        }

        public static bool CheckMergeConnectivity(MyCubeGrid hitGrid, MyCubeGrid gridToMerge, Vector3I gridOffset)
        {
            // CH: Beware, this funtion seems horribly inefficient! Think twice before using it (e.g. don't use it in a 10000x loop) or optimize it :-)
            MatrixI mergeTransform = hitGrid.CalculateMergeTransform(gridToMerge, gridOffset);
            Quaternion mergeOri;
            mergeTransform.GetBlockOrientation().GetQuaternion(out mergeOri);

            foreach (var block in gridToMerge.GetBlocks())
            {
                Quaternion ori;
                Vector3I pos = Vector3I.Transform(block.Position, mergeTransform);
                block.Orientation.GetQuaternion(out ori);
                //Matrix mergeGridMatrix = Matrix.CreateFromQuaternion(mergeOri);
                //Matrix oriMatrix = Matrix.CreateFromQuaternion(ori);
                //Matrix result = oriMatrix * mergeGridMatrix;
                //Quaternion quatFromMatrix = Quaternion.CreateFromRotationMatrix(result);
                // Seems that quaternion multiplication is reversed to matrix multiplication!
                ori = mergeOri * ori;
				var mountPoints = block.BlockDefinition.GetBuildProgressModelMountPoints(block.BuildLevelRatio);
                if (MyCubeGrid.CheckConnectivity(hitGrid, block.BlockDefinition, mountPoints, ref ori, ref pos))
                    return true;
            }

            return false;
        }

        public static bool ShouldBeStatic(MyCubeGrid grid)
        {
            if (grid.GridSizeEnum == MyCubeSize.Small && MyCubeGridSmallToLargeConnection.Static != null &&
                MyCubeGridSmallToLargeConnection.Static.TestGridSmallToLargeConnection(grid))
                return true;

            foreach (var block in grid.GetBlocks())
            {
                if (IsInVoxels(block))
                    return true;
            }
            return false;
        }

        public bool AddGrid(MyCubeGrid grid)
        {
            //TODO: create static list
            List<Vector3I> lst = new List<Vector3I>();

            foreach (var block in grid.GetBlocks())
            {
                if (block.FatBlock is MyCompoundCubeBlock)
                {
                    bool added = false;
                    foreach (var subb in (block.FatBlock as MyCompoundCubeBlock).GetBlocks())
                    {
                        if (AddBlock(subb))
                        {
                            if (!added)
                                lst.Add(block.Position);

                            added = true;
                        }
                    }
                }
                else
                {
                    if (AddBlock(block))
                    {
                        lst.Add(block.Position);
                    }
                }
            }

            if (lst.Count > 0)
            {
                grid.RazeBlocks(lst);
                return true;
            }

            return false;
        }

        static MyTrashRemovalFlags GetTrashState(MyCubeGrid grid, MyTrashRemovalSettings settings, out float metric,bool checkGroup = false)
        {
            metric = -1;

            HashSet<MySlimBlock> blocks = grid.GetBlocks();

            if (blocks != null  && blocks.Count > settings.BlockCountThreshold)
            {
                metric = settings.BlockCountThreshold;
                return MyTrashRemovalFlags.WithBlockCount;
            }

            if (!settings.HasFlag(MyTrashRemovalFlags.Fixed) && grid.IsStatic)
                return MyTrashRemovalFlags.Fixed;

            bool isAccelerating = false;
            bool isLinearMoving = false;
            bool isStationary = true;

            if (grid.Physics != null)
            {
                isAccelerating = grid.Physics.AngularAcceleration.AbsMax() > 0.05f || grid.Physics.LinearAcceleration.AbsMax() > 0.05f;
                isStationary = grid.Physics.AngularVelocity.AbsMax() < 0.05f && grid.Physics.LinearVelocity.AbsMax() < 0.05f;
                isLinearMoving = !isAccelerating && !isStationary;
            }

            if (!settings.HasFlag(MyTrashRemovalFlags.Stationary) && isStationary)
                return MyTrashRemovalFlags.Stationary;

            if (!settings.HasFlag(MyTrashRemovalFlags.Linear) && isLinearMoving)
                return MyTrashRemovalFlags.Linear;

            if (!settings.HasFlag(MyTrashRemovalFlags.Accelerating) && isAccelerating)
                return MyTrashRemovalFlags.Accelerating;


            if (grid.GridSystems != null)
            {
                bool isPowered = grid.GridSystems.ResourceDistributor.ResourceStateByType(MyResourceDistributorComponent.ElectricityId) != MyResourceStateEnum.NoPower;
                if (!settings.HasFlag(MyTrashRemovalFlags.Powered) && isPowered)
                    return MyTrashRemovalFlags.Powered;

                if (!settings.HasFlag(MyTrashRemovalFlags.Controlled) && grid.GridSystems.ControlSystem.IsControlled)
                    return MyTrashRemovalFlags.Controlled;

                if (!settings.HasFlag(MyTrashRemovalFlags.WithProduction) && grid.GridSystems.ControlSystem.IsControlled)
                    return MyTrashRemovalFlags.WithProduction;
            }

            if (!settings.HasFlag(MyTrashRemovalFlags.WithMedBay) && grid.BlocksCounters.GetValueOrDefault(typeof(MyObjectBuilder_MedicalRoom)) > 0)
                return MyTrashRemovalFlags.WithMedBay;

            if (IsCloseToPlayerOrCamera(grid, settings.PlayerDistanceThreshold))
            {
                metric = settings.PlayerDistanceThreshold;
                return MyTrashRemovalFlags.DistanceFromPlayer;
            }

            if (checkGroup && MyCubeGridGroups.Static.Physical != null)
            {
                var physicalGroup = MyCubeGridGroups.Static.Physical.GetGroup(grid);
                if (physicalGroup != null)
                {
                    foreach (var cubeGrid in physicalGroup.Nodes)
                    {
                        if (cubeGrid.NodeData == null || cubeGrid.NodeData.Physics == null || cubeGrid.NodeData.Physics.Shape == null || cubeGrid.NodeData == grid)
                            continue;


                        var subGridReason = GetTrashState(cubeGrid.NodeData, settings, out metric, false);
                        if (subGridReason != MyTrashRemovalFlags.None)
                        {
                            return subGridReason;
                        }
                    }
                }
            }

            return MyTrashRemovalFlags.None;
        }

 public MyOndraSimulator3(MyCubeGrid grid)
 {
     m_grid = grid;
     m_selectedGrid = m_grid;
     SelectedCube = m_grid.GetBlocks().First().Position;
 }

 public MyAdvancedStaticSimulator(MyCubeGrid grid)
 {
     m_grid = grid;
     m_selectedGrid = m_grid;
     if (m_grid.BlocksCount > 0)
         SelectedCube = m_grid.GetBlocks().First().Position;
 }

 public bool AddGrid(MyCubeGrid grid)
 {
     HashSet<Sandbox.Game.Entities.Cube.MySlimBlock> lst = new HashSet<Sandbox.Game.Entities.Cube.MySlimBlock>();
     foreach(var b in grid.GetBlocks())
     {
         if(b.FatBlock is MyCompoundCubeBlock)
         {
             foreach(var subb in (b.FatBlock as MyCompoundCubeBlock).GetBlocks())
             {
                 if (AddBlock(subb))
                     lst.Add(b);
             }
         }
         else
         {
             if (AddBlock(b))
                 lst.Add(b);
         }
     }
     foreach(var b in lst)
     {
         grid.RemoveBlock(b);
     }
     return lst.Count > 0;
     //grid.Close();
 }

        public bool AddGrid(MyCubeGrid grid)
        {
            HashSet<Sandbox.Game.Entities.Cube.MySlimBlock> lst = new HashSet<Sandbox.Game.Entities.Cube.MySlimBlock>();

            foreach (var block in grid.GetBlocks())
            {
                if (block.FatBlock is MyCompoundCubeBlock)
                {
                    bool added = false;
                    foreach (var subb in (block.FatBlock as MyCompoundCubeBlock).GetBlocks())
                    {
                        if (AddBlock(subb))
                        {
                            added = true;
                        }
                    }
                    if (added)
                    {
                        lst.Add(block);
                    }
                }
                else
                {
                    if (AddBlock(block))
                    {
                        lst.Add(block);
                    }
                }
            }


            foreach (var b in lst)
            {
                Vector3I pos = b.Position;
                Vector3UByte size = new Vector3UByte(1, 1, 1);
                grid.RazeBlocks(ref pos, ref size);
                //   grid.RemoveBlock(b, true); not synced
            }

            return lst.Count > 0;
        }

        static bool ShouldBeStatic(MyCubeGrid grid, MyCubeGrid.MyTestDynamicReason testReason)
        {
            if (grid.GridSizeEnum == MyCubeSize.Small && MyCubeGridSmallToLargeConnection.Static != null &&
                MyCubeGridSmallToLargeConnection.Static.TestGridSmallToLargeConnection(grid))
                return true;

            if (testReason == MyTestDynamicReason.GridSplit)
            {
                foreach (var block in grid.GetBlocks())
                {
                    if (IsInVoxels(block))
                        return true;
                }
                return false;
            }

            return grid.IsStatic;
        }

        public static bool CheckValidBlocksRotation(Matrix gridLocalMatrix, MyCubeGrid grid)
        {
            Matrix blockLocalMatrix;
            bool retval = true;

            foreach (var block in grid.GetBlocks())
            {
                MyCompoundCubeBlock compoundBlock = block.FatBlock as MyCompoundCubeBlock;
                if (compoundBlock != null) 
                {
                    foreach (var blockInCompound in compoundBlock.GetBlocks())
                    {
                        blockInCompound.Orientation.GetMatrix(out blockLocalMatrix);
                        blockLocalMatrix = blockLocalMatrix * gridLocalMatrix;

                        retval = retval && CheckValidBlockRotation(blockLocalMatrix, blockInCompound.BlockDefinition.Direction, blockInCompound.BlockDefinition.Rotation);
                        if (!retval)
                            break;
                    }
                }
                else 
                {
                    block.Orientation.GetMatrix(out blockLocalMatrix);
                    blockLocalMatrix = blockLocalMatrix * gridLocalMatrix;

                    retval = retval && CheckValidBlockRotation(blockLocalMatrix, block.BlockDefinition.Direction, block.BlockDefinition.Rotation);
                }

                if (!retval)
                    break;
            }

            return retval;
        }