/// <summary>
        /// Writes all surrounding blocks around the given one with the given size.
        /// </summary>
        private void GetSurroundingBlocksFromStaticGrids(MySlimBlock block, MyCubeSize cubeSizeEnum, HashSet <MyCubeBlock> outBlocks)
        {
            outBlocks.Clear();

            BoundingBoxD aabb = new BoundingBoxD(block.Min * block.CubeGrid.GridSize - block.CubeGrid.GridSize / 2, block.Max * block.CubeGrid.GridSize + block.CubeGrid.GridSize / 2);

            if (block.FatBlock != null)
            {
                aabb = (BoundingBoxD)block.FatBlock.Model.BoundingBox;
                aabb.Translate(block.Position * block.CubeGrid.GridSize);
            }

            aabb = aabb.Transform(block.CubeGrid.WorldMatrix);
            aabb.Inflate(0.125);

            List <MyEntity> boxOverlapList = new List <MyEntity>();

            MyEntities.GetElementsInBox(ref aabb, boxOverlapList);

            for (int i = 0; i < boxOverlapList.Count; i++)
            {
                var otherBlock = boxOverlapList[i] as MyCubeBlock;
                if (otherBlock != null && otherBlock.CubeGrid.IsStatic && otherBlock.CubeGrid.EnableSmallToLargeConnections && otherBlock.SlimBlock != block && otherBlock.CubeGrid != block.CubeGrid &&
                    otherBlock.CubeGrid.GridSizeEnum == cubeSizeEnum && !(otherBlock is MyCompoundCubeBlock) && !(otherBlock is MyFracturedBlock))
                {
                    outBlocks.Add(otherBlock);
                }
            }

            boxOverlapList.Clear();
        }
Example #2
0
        public void Load(MyCubeSize cubeSize, MyObjectBuilderType typeId, string subTypeId)
        {
            CubeList.Clear();
            var list = new SortedList<string, ComponentItemModel>();
            var contentPath = ToolboxUpdater.GetApplicationContentPath();
            var cubeDefinitions = SpaceEngineersCore.Resources.CubeBlockDefinitions.Where(c => c.CubeSize == cubeSize);

            foreach (var cubeDefinition in cubeDefinitions)
            {
                var c = new ComponentItemModel
                {
                    Name = cubeDefinition.DisplayNameText,
                    TypeId = cubeDefinition.Id.TypeId,
                    TypeIdString = cubeDefinition.Id.TypeId.ToString(),
                    SubtypeId = cubeDefinition.Id.SubtypeName,
                    TextureFile = (cubeDefinition.Icons == null || cubeDefinition.Icons.First() == null) ? null : SpaceEngineersCore.GetDataPathOrDefault(cubeDefinition.Icons.First(), Path.Combine(contentPath, cubeDefinition.Icons.First())),
                    Time = TimeSpan.FromSeconds(cubeDefinition.MaxIntegrity / cubeDefinition.IntegrityPointsPerSec),
                    Accessible = cubeDefinition.Public,
                    Mass = SpaceEngineersApi.FetchCubeBlockMass(cubeDefinition.Id.TypeId, cubeDefinition.CubeSize, cubeDefinition.Id.SubtypeName),
                    CubeSize = cubeDefinition.CubeSize,
                    Size = new BindableSize3DIModel(cubeDefinition.Size),
                };

                list.Add(c.FriendlyName + c.TypeIdString + c.SubtypeId, c);
            }

            foreach (var kvp in list)
            {
                CubeList.Add(kvp.Value);
            }

            CubeItem = CubeList.FirstOrDefault(c => c.TypeId == typeId && c.SubtypeId == subTypeId);
        }
Example #3
0
        public void Reset(WaypointTask holdTask, WaypointTask approachTask, WaypointTask enterTask, WaypointTask closeTask, DockTask dockTask, MyTuple <IntelItemType, long> intelKey, MyGridProgram program, MyCubeSize dockSize, IMyTerminalBlock connector, IMyTerminalBlock indicator = null)
        {
            Reset();
            if (indicator != null)
            {
                Indicator = indicator;
                Connector = connector;
            }
            EnterHoldingPattern = holdTask;
            WaitForClearance    = new WaitTask();
            ApproachEntrance    = approachTask;
            ApproachDock        = enterTask;
            FinalAdjustToDock   = closeTask;
            DockTask            = dockTask;
            IntelKey            = intelKey;
            DockSize            = dockSize;
            Program             = program;

            closeTask.Destination.MaxSpeed = 0.5f;
            enterTask.Destination.MaxSpeed = 5;

            TaskQueue.Enqueue(EnterHoldingPattern);
            TaskQueue.Enqueue(WaitForClearance);
            TaskQueue.Enqueue(ApproachEntrance);
            TaskQueue.Enqueue(ApproachDock);
            TaskQueue.Enqueue(FinalAdjustToDock);
            TaskQueue.Enqueue(DockTask);
        }
Example #4
0
        // Create additional model generators from plugins using reflection.
        public void CreateAdditionalModelGenerators(MyCubeSize gridSizeEnum)
        {
            Assembly[] assemblies = new Assembly[] {
                Assembly.GetExecutingAssembly(),
                       MyPlugins.GameAssembly,
                       MyPlugins.UserAssembly,
            };

            foreach (var assembly in assemblies)
            {
                if (assembly == null)
                {
                    continue;
                }

                // Lookup
                Type lookupType = typeof(IMyBlockAdditionalModelGenerator);
                IEnumerable <Type> lookupTypes = assembly.GetTypes().Where(
                    t => lookupType.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract);

                // Create instances
                foreach (var type in lookupTypes)
                {
                    IMyBlockAdditionalModelGenerator generator = Activator.CreateInstance(type) as IMyBlockAdditionalModelGenerator;
                    if (generator.Initialize(m_grid, gridSizeEnum))
                    {
                        AdditionalModelGenerators.Add(generator);
                    }
                    else
                    {
                        generator.Close();
                    }
                }
            }
        }
        // Create additional model generators from plugins using reflection.
        public void CreateAdditionalModelGenerators(MyCubeSize gridSizeEnum)
        {
            Assembly[] assemblies = new Assembly[] {
                Assembly.GetExecutingAssembly(),
                MyPlugins.GameAssembly,
                MyPlugins.SandboxAssembly,
                MyPlugins.UserAssembly,
            };

            foreach (var assembly in assemblies)
            {
                if (assembly == null)
                    continue;

                // Lookup
                Type lookupType = typeof(IMyBlockAdditionalModelGenerator);
                IEnumerable<Type> lookupTypes = assembly.GetTypes().Where(
                        t => lookupType.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract);

                // Create instances
                foreach (var type in lookupTypes)
                {
                    IMyBlockAdditionalModelGenerator generator = Activator.CreateInstance(type) as IMyBlockAdditionalModelGenerator;
                    if (generator.Initialize(m_grid, gridSizeEnum))
                        AdditionalModelGenerators.Add(generator);
                    else
                        generator.Close();
                }
            }
        }
        private static MyCubeBlockDefinition GetTopDef(IMyPistonBase block, MyCubeSize size)
        {
            MyPistonBaseDefinition     myDef    = (MyPistonBaseDefinition)((MyCubeBlock)block).BlockDefinition;
            MyCubeBlockDefinitionGroup defGroup = MyDefinitionManager.Static.TryGetDefinitionGroup(myDef.TopPart);

            return(defGroup[size]);
        }
Example #7
0
 public void CreateAdditionalModelGenerators(MyCubeSize gridSizeEnum)
 {
     Assembly[] first = new Assembly[] { Assembly.GetExecutingAssembly(), MyPlugins.GameAssembly, MyPlugins.SandboxAssembly };
     if (MyPlugins.UserAssemblies != null)
     {
         first = first.Union <Assembly>(MyPlugins.UserAssemblies).ToArray <Assembly>();
     }
     foreach (Assembly assembly in first)
     {
         if (assembly != null)
         {
             Type lookupType = typeof(IMyBlockAdditionalModelGenerator);
             using (IEnumerator <Type> enumerator = (from t in assembly.GetTypes()
                                                     where lookupType.IsAssignableFrom(t) && (t.IsClass && !t.IsAbstract)
                                                     select t).GetEnumerator())
             {
                 while (enumerator.MoveNext())
                 {
                     IMyBlockAdditionalModelGenerator item = Activator.CreateInstance(enumerator.Current) as IMyBlockAdditionalModelGenerator;
                     if (item.Initialize(this.m_grid, gridSizeEnum))
                     {
                         this.AdditionalModelGenerators.Add(item);
                         continue;
                     }
                     item.Close();
                 }
             }
         }
     }
 }
Example #8
0
            /// <summary>Creates a new power wheel</summary>
            /// <param name="wheel">The actual wheel it wraps</param>
            /// <param name="wb">The wheel base, to which the power wheel will be added</param>
            /// <param name="tform">Coordinates transformer, should be one that makes the Z axis parallel the wheel direction and Y axis the up axis</param>
            public PowerWheel(IMyMotorSuspension wheel, WheelBase wb, CoordinatesTransformer tform)
            {
                this.wheelBase   = wb;
                this.CubeSize    = wheel.CubeGrid.GridSizeEnum;
                this.Position    = tform.Pos(wheel.GetPosition());
                this.IsRight     = RIGHT.Dot(tform.Dir(wheel.WorldMatrix.Up)) > 0;
                this.reverseY    = UP.Dot(tform.Dir(wheel.WorldMatrix.Backward)) > 0;
                this.transformer = tform;
                this.wheel       = wheel;

                wheel.Height = 10;
                this.maxY    = wheel.Height;
                wheel.Height = -10;
                this.minY    = wheel.Height;
                if (this.reverseY)
                {
                    float tmp = this.minY;
                    this.minY = -this.maxY;
                    this.maxY = -tmp;
                }
                this.WheelSize = (wheel.Top.Max - wheel.Top.Min).X + 1;
                this.Mass      = this.CubeSize == MyCubeSize.Small
          ? this.WheelSize == 1 ? 105 : (this.WheelSize == 3 ? 205 : 310)
          : this.WheelSize == 1 ? 420 : (this.WheelSize == 3 ? 590 : 760);
                // real center of rotation of the wheel
                this.Position += tform.Dir(wheel.WorldMatrix.Up) * wheel.CubeGrid.GridSize;
                this.wheelBase.AddWheel(this);
            }
        /// <summary>
        /// Used in order to get material requirements from prefabs of the new station/ship and draw them to the hud
        /// </summary>
        void CreateToolTipForNewGrid(MyCubeSize size, bool isStatic)
        {
            bool isLarge = (size == MyCubeSize.Large);
            MyGuiControlBlockInfo usedInfo   = isLarge ? m_blockInfoLarge : m_blockInfoSmall;
            MyGuiControlBlockInfo unusedInfo = !isLarge ? m_blockInfoLarge : m_blockInfoSmall;
            string prefabName;

            MyDefinitionManager.Static.GetBaseBlockPrefabName(size, isStatic, MySession.Static.CreativeMode, out prefabName);
            if (prefabName == null)
            {
                return;
            }
            var gridBuilders = MyPrefabManager.Static.GetGridPrefab(prefabName);

            Debug.Assert(gridBuilders != null && gridBuilders.Length > 0);
            if (gridBuilders == null || gridBuilders.Length == 0)
            {
                return;
            }

            MyCubeBlockDefinition blockDefinition = MyDefinitionManager.Static.GetCubeBlockDefinition(gridBuilders[0].CubeBlocks[0].GetId());

            if (blockDefinition != null)
            {
                usedInfo.BlockInfo.LoadDefinition(blockDefinition);
                usedInfo.Visible = true;
            }
            else
            {
                usedInfo.Visible = false;
            }
            unusedInfo.Visible = false;
        }
        public void Load(MyCubeSize cubeSize, MyObjectBuilderType typeId, string subTypeId)
        {
            CubeList.Clear();
            var list            = new SortedList <string, ComponentItemModel>();
            var contentPath     = ToolboxUpdater.GetApplicationContentPath();
            var cubeDefinitions = SpaceEngineersCore.Resources.CubeBlockDefinitions.Where(c => c.CubeSize == cubeSize);

            foreach (var cubeDefinition in cubeDefinitions)
            {
                var c = new ComponentItemModel
                {
                    Name         = cubeDefinition.DisplayNameText,
                    TypeId       = cubeDefinition.Id.TypeId,
                    TypeIdString = cubeDefinition.Id.TypeId.ToString(),
                    SubtypeId    = cubeDefinition.Id.SubtypeName,
                    TextureFile  = (cubeDefinition.Icons == null || cubeDefinition.Icons.First() == null) ? null : SpaceEngineersCore.GetDataPathOrDefault(cubeDefinition.Icons.First(), Path.Combine(contentPath, cubeDefinition.Icons.First())),
                    Time         = TimeSpan.FromSeconds(cubeDefinition.MaxIntegrity / cubeDefinition.IntegrityPointsPerSec),
                    Accessible   = cubeDefinition.Public,
                    Mass         = SpaceEngineersApi.FetchCubeBlockMass(cubeDefinition.Id.TypeId, cubeDefinition.CubeSize, cubeDefinition.Id.SubtypeName),
                    CubeSize     = cubeDefinition.CubeSize,
                    Size         = new BindableSize3DIModel(cubeDefinition.Size),
                };

                list.Add(c.FriendlyName + c.TypeIdString + c.SubtypeId, c);
            }

            foreach (var kvp in list)
            {
                CubeList.Add(kvp.Value);
            }

            CubeItem = CubeList.FirstOrDefault(c => c.TypeId == typeId && c.SubtypeId == subTypeId);
        }
Example #11
0
            /// <summary>Requests the autoconnector to connect</summary>
            /// <param name="size">Size of the requesting connector</param>
            /// <param name="position">Position of the requesting connector</param>
            /// <param name="orientation">Orientation of the requesting connector</param>
            public void Connect(MyCubeSize size, Vector3D position, Vector3D orientation)
            {
                double offset = this.getOffset(size) + this.getOffset((this.frontConnector ?? this.downConnector).CubeGrid.GridSizeEnum);

                Vector3D finalTarget = position + (offset * orientation);

                this.queueConnectionRoute(finalTarget, orientation);
            }
 public MyCubeBlockDefinition this[MyCubeSize size]
 {
     get { return m_definitions[(int)size]; }
     set
     {
         Debug.Assert(m_definitions[(int)size] == null, "You're overwriting an existing definition in the group. Is this what you want?");
         m_definitions[(int)size] = value;
     }
 }
Example #13
0
 public MyCubeBlockDefinition this[MyCubeSize size]
 {
     get { return(m_definitions[(int)size]); }
     set
     {
         Debug.Assert(m_definitions[(int)size] == null, "You're overwriting an existing definition in the group. Is this what you want?");
         m_definitions[(int)size] = value;
     }
 }
        /// <summary>
        /// Returns block size.
        /// </summary>
        /// <remarks>see: http://spaceengineerswiki.com/index.php?title=FAQs
        /// Why are the blocks 0.5 and 2.5 meter blocks?
        /// </remarks>
        /// <param name="cubeSize"></param>
        /// <returns></returns>
        public static float ToLength(this MyCubeSize cubeSize)
        {
            switch (cubeSize)
            {
            case MyCubeSize.Large: return(SpaceEngineersCore.Resources.Definitions.Configuration.CubeSizes.Large);

            case MyCubeSize.Small: return(SpaceEngineersCore.Resources.Definitions.Configuration.CubeSizes.Small);
            }
            return(0f);
        }
Example #15
0
        private void GetSurroundingBlocksFromStaticGrids(MySlimBlock block, MyCubeSize cubeSizeEnum, HashSet <MyCubeBlock> outBlocks)
        {
            outBlocks.Clear();
            BoundingBoxD boundingBox = new BoundingBoxD((Vector3D)((block.Min * block.CubeGrid.GridSize) - (block.CubeGrid.GridSize / 2f)), (block.Max * block.CubeGrid.GridSize) + (block.CubeGrid.GridSize / 2f));

            if (block.FatBlock != null)
            {
                Matrix matrix;
                boundingBox = block.FatBlock.Model.BoundingBox;
                block.FatBlock.Orientation.GetMatrix(out matrix);
                boundingBox = boundingBox.TransformFast(matrix);
                boundingBox.Translate(boundingBox.Center);
            }
            boundingBox = boundingBox.TransformFast(block.CubeGrid.WorldMatrix);
            boundingBox.Inflate((double)0.125);
            List <VRage.Game.Entity.MyEntity> foundElements = new List <VRage.Game.Entity.MyEntity>();

            Sandbox.Game.Entities.MyEntities.GetElementsInBox(ref boundingBox, foundElements);
            int num = 0;

            while (true)
            {
                while (true)
                {
                    if (num >= foundElements.Count)
                    {
                        foundElements.Clear();
                        return;
                    }
                    MyCubeBlock item = foundElements[num] as MyCubeBlock;
                    if (((item != null) && (!ReferenceEquals(item.SlimBlock, block) && (item.CubeGrid.IsStatic && (item.CubeGrid.EnableSmallToLargeConnections && (item.CubeGrid.SmallToLargeConnectionsInitialized && (!ReferenceEquals(item.CubeGrid, block.CubeGrid) && ((item.CubeGrid.GridSizeEnum == cubeSizeEnum) && !(item is MyFracturedBlock)))))))) && !item.Components.Has <MyFractureComponentBase>())
                    {
                        MyCompoundCubeBlock block3 = item as MyCompoundCubeBlock;
                        if (block3 != null)
                        {
                            foreach (MySlimBlock block4 in block3.GetBlocks())
                            {
                                if (ReferenceEquals(block4, block))
                                {
                                    continue;
                                }
                                if (!block4.FatBlock.Components.Has <MyFractureComponentBase>())
                                {
                                    outBlocks.Add(block4.FatBlock);
                                }
                            }
                            break;
                        }
                        outBlocks.Add(item);
                    }
                    break;
                }
                num++;
            }
        }
Example #16
0
        private void GetSurroundingBlocksFromStaticGrids(MySlimBlock block, MyCubeSize cubeSizeEnum, HashSet <MySlimBlock> outBlocks)
        {
            outBlocks.Clear();
            BoundingBoxD aabbForNeighbors = new BoundingBoxD((Vector3D)(block.Min * block.CubeGrid.GridSize), (Vector3D)(block.Max * block.CubeGrid.GridSize));
            BoundingBoxD box = new BoundingBoxD((Vector3D)((block.Min * block.CubeGrid.GridSize) - (block.CubeGrid.GridSize / 2f)), (block.Max * block.CubeGrid.GridSize) + (block.CubeGrid.GridSize / 2f));

            if (block.FatBlock != null)
            {
                Matrix matrix;
                box = block.FatBlock.Model.BoundingBox;
                block.FatBlock.Orientation.GetMatrix(out matrix);
                box = box.TransformFast(matrix);
                box.Translate(box.Center);
            }
            box.Inflate((double)0.125);
            BoundingBoxD boundingBox = box.TransformFast(block.CubeGrid.WorldMatrix);
            List <VRage.Game.Entity.MyEntity> foundElements = new List <VRage.Game.Entity.MyEntity>();

            Sandbox.Game.Entities.MyEntities.GetElementsInBox(ref boundingBox, foundElements);
            for (int i = 0; i < foundElements.Count; i++)
            {
                MyCubeGrid objA = foundElements[i] as MyCubeGrid;
                if (((objA != null) && (objA.IsStatic && (!ReferenceEquals(objA, block.CubeGrid) && (objA.EnableSmallToLargeConnections && objA.SmallToLargeConnectionsInitialized)))) && (objA.GridSizeEnum == cubeSizeEnum))
                {
                    m_tmpSlimBlocksList.Clear();
                    objA.GetBlocksIntersectingOBB(box, block.CubeGrid.WorldMatrix, m_tmpSlimBlocksList);
                    CheckNeighborBlocks(block, aabbForNeighbors, objA, m_tmpSlimBlocksList);
                    foreach (MySlimBlock block2 in m_tmpSlimBlocksList)
                    {
                        if (block2.FatBlock == null)
                        {
                            outBlocks.Add(block2);
                            continue;
                        }
                        if (!(block2.FatBlock is MyFracturedBlock) && !block2.FatBlock.Components.Has <MyFractureComponentBase>())
                        {
                            if (block2.FatBlock is MyCompoundCubeBlock)
                            {
                                foreach (MySlimBlock block3 in (block2.FatBlock as MyCompoundCubeBlock).GetBlocks())
                                {
                                    if (!block3.FatBlock.Components.Has <MyFractureComponentBase>())
                                    {
                                        outBlocks.Add(block3);
                                    }
                                }
                                continue;
                            }
                            outBlocks.Add(block2);
                        }
                    }
                    m_tmpSlimBlocksList.Clear();
                }
            }
            foundElements.Clear();
        }
Example #17
0
        private void CreateTool(MyCubeSize size, string toolBuilderText)
        {
            var toolObject = toolBuilderText;

            if (size == MyCubeSize.Large)
            {
                toolObject = string.Format(toolObject, "Small");
            }
            else
            {
                toolObject = string.Format(toolObject, "Tiny");
            }

            MyObjectBuilder_CubeGrid cubeGrid = MyAPIGateway.Utilities.SerializeFromXML <MyObjectBuilder_CubeGrid>(toolObject);

            foreach (var item in cubeGrid.CubeBlocks)
            {
                item.Owner = m_constructionBlock.ConstructionBlock.OwnerId;
            }

            m_toolEntity = MyAPIGateway.Entities.CreateFromObjectBuilder(cubeGrid);
            m_toolEntity.PositionComp.Scale = 0.001f;
            m_toolEntity.PositionComp.SetPosition(GetTargetPosition());
            m_toolEntity.Physics.Enabled = false;
            m_toolEntity.Save            = false;

            var toolGrid = (MyCubeGrid)m_toolEntity;

            toolGrid.IsSplit   = true;
            toolGrid.IsPreview = true;

            List <IMySlimBlock> blocks = new List <IMySlimBlock>();

            ((IMyCubeGrid)m_toolEntity).GetBlocks(blocks);
            foreach (var slimBlock in blocks)
            {
                if (slimBlock.FatBlock == null)
                {
                    continue;
                }

                var block = slimBlock.FatBlock;
                if (block is Sandbox.ModAPI.Ingame.IMyShipWelder || block is Sandbox.ModAPI.Ingame.IMyShipGrinder)
                {
                    MyCubeBlock toolBlock = (MyCubeBlock)block;
                    toolBlock.IDModule.ShareMode = MyOwnershipShareModeEnum.Faction;
                    IMyFunctionalBlock tool = (IMyFunctionalBlock)block;
                    m_tool = tool;
                    break;
                }
            }

            MyAPIGateway.Entities.AddEntity(m_toolEntity);
            //m_toolEntity.RemoveFromGamePruningStructure();
        }
Example #18
0
        private static double GetMaxVolume(MyObjectBuilder_Base block, MyCubeSize size)
        {
            Func <MyCubeSize, MyStringHash, double> volumeFunc;

            Definitions.MaxInventoryVolume.TryGetValue(block.TypeId, out volumeFunc);
            if (volumeFunc == null)
            {
                return(0);
            }
            return(volumeFunc.Invoke(size, block.SubtypeId));
        }
 public void IGCUnpackInto(MyTuple <MyTuple <Vector3D, Vector3D, double, double>, MyTuple <string, long, float, int> > unpacked)
 {
     CurrentPosition            = unpacked.Item1.Item1;
     CurrentVelocity            = unpacked.Item1.Item2;
     CurrentCanonicalTime       = TimeSpan.FromMilliseconds(unpacked.Item1.Item3);
     LastValidatedCanonicalTime = TimeSpan.FromMilliseconds(unpacked.Item1.Item4);
     DisplayName = unpacked.Item2.Item1;
     ID          = unpacked.Item2.Item2;
     Radius      = unpacked.Item2.Item3;
     CubeSize    = (MyCubeSize)unpacked.Item2.Item4;
 }
        public MyGridPlacementSettings GetGridPlacementSettings(MyCubeSize cubeSize, bool isStatic)
        {
            switch (cubeSize)
            {
                case MyCubeSize.Large: return (isStatic) ? LargeStaticGrid : LargeGrid;
                case MyCubeSize.Small: return (isStatic) ? SmallStaticGrid : SmallGrid;

                default:
                    Debug.Fail("Invalid branch.");
                    return LargeGrid;
            }
        }
        public MyGridPlacementSettings GetGridPlacementSettings(MyCubeSize cubeSize)
        {
            switch (cubeSize)
            {
                case MyCubeSize.Large: return LargeGrid;
                case MyCubeSize.Small: return SmallGrid;

                default:
                    Debug.Fail("Invalid branch.");
                    return LargeGrid;
            }
        }
        protected void RefreshTextField()
        {
            if (m_textField == null)
            {
                return;
            }
            var displayName = m_blueprintName;

            if (displayName.Length > 25)
            {
                displayName = displayName.Substring(0, 25) + "...";
            }
            m_textField.Clear();
            m_textField.AppendText("Name: " + displayName);//zxc translate
            m_textField.AppendLine();

            MyCubeSize type = m_loadedPrefab.ShipBlueprints[0].CubeGrids[0].GridSizeEnum;

            m_textField.AppendText(MyTexts.GetString(MyCommonTexts.BlockPropertiesText_Type));
            if (m_loadedPrefab.ShipBlueprints[0].CubeGrids[0].IsStatic && type == MyCubeSize.Large)
            {
                m_textField.AppendText(MyTexts.GetString(MyCommonTexts.DetailStaticGrid));
            }
            else
            {
                if (type == MyCubeSize.Small)
                {
                    m_textField.AppendText(MyTexts.GetString(MyCommonTexts.DetailSmallGrid));
                }
                else
                {
                    m_textField.AppendText(MyTexts.GetString(MyCommonTexts.DetailLargeGrid));
                }
            }

            m_textField.AppendLine();
            m_textField.AppendText("Number of blocks: " + GetNumberOfBlocks());//zxc translate
            m_textField.AppendLine();

            if (MyFakes.ENABLE_BATTLE_SYSTEM)
            {
                int battlePoints = GetNumberOfBattlePoints();
                if (battlePoints != 0)
                {
                    m_textField.AppendText("Castle siege points: " + battlePoints);//zxc translate
                    m_textField.AppendLine();
                }
            }

            m_textField.AppendText("Author: " + m_loadedPrefab.ShipBlueprints[0].DisplayName);//zxc translate
            m_textField.AppendLine();
        }
Example #23
0
        public static float GetBuoyancyMultiplier(Vector3D Position, MyCubeSize GridSize, long?ID = 0)
        {
            Water Water = (ID == null) ? WaterMod.Static.GetClosestWater(Position) : WaterMod.Static.Waters[ID.Value];

            if (GridSize == MyCubeSize.Large)
            {
                return((1 + (-Water.GetDepth(ref Position) / 5000f)) / 50f * Water.buoyancy);
            }
            else
            {
                return((1 + (-Water.GetDepth(ref Position) / 5000f)) / 20f * Water.buoyancy);
            }
        }
Example #24
0
 public virtual bool Initialize(MyCubeGrid grid, MyCubeSize gridSizeEnum)
 {
     this.m_grid    = grid;
     this.m_enabled = true;
     if (!this.IsValid(gridSizeEnum))
     {
         return(false);
     }
     this.m_grid.OnBlockAdded   += new Action <MySlimBlock>(this.Grid_OnBlockAdded);
     this.m_grid.OnBlockRemoved += new Action <MySlimBlock>(this.Grid_OnBlockRemoved);
     this.m_grid.OnGridSplit    += new Action <MyCubeGrid, MyCubeGrid>(this.Grid_OnGridSplit);
     return(true);
 }
        public MyGridPlacementSettings GetGridPlacementSettings(MyCubeSize cubeSize)
        {
            switch (cubeSize)
            {
            case MyCubeSize.Large: return(LargeGrid);

            case MyCubeSize.Small: return(SmallGrid);

            default:
                Debug.Fail("Invalid branch.");
                return(LargeGrid);
            }
        }
        public MyGridPlacementSettings GetGridPlacementSettings(MyCubeSize cubeSize, bool isStatic)
        {
            switch (cubeSize)
            {
            case MyCubeSize.Large: return((isStatic) ? LargeStaticGrid : LargeGrid);

            case MyCubeSize.Small: return((isStatic) ? SmallStaticGrid : SmallGrid);

            default:
                Debug.Fail("Invalid branch.");
                return(LargeGrid);
            }
        }
Example #27
0
        //public static long GenerateEntityId()
        //{
        //    // Not the offical SE way of generating IDs, but its fast and we don't have to worry about a random seed.
        //    var buffer = Guid.NewGuid().ToByteArray();
        //    return BitConverter.ToInt64(buffer, 0);
        //}

        #endregion

        #region FetchCubeBlockMass

        public static float FetchCubeBlockMass(MyObjectBuilderType typeId, MyCubeSize cubeSize, string subTypeid)
        {
            float mass = 0;

            var cubeBlockDefinition = GetCubeDefinition(typeId, cubeSize, subTypeid);

            if (cubeBlockDefinition != null)
            {
                return(cubeBlockDefinition.Mass);
            }

            return(mass);
        }
        /// <summary>
        /// Writes all surrounding blocks around the given one with the given size.
        /// </summary>
        private void GetSurroundingBlocksFromStaticGrids(MySlimBlock block, MyCubeSize cubeSizeEnum, HashSet <MyCubeBlock> outBlocks)
        {
            outBlocks.Clear();

            BoundingBoxD aabb = new BoundingBoxD(block.Min * block.CubeGrid.GridSize - block.CubeGrid.GridSize / 2, block.Max * block.CubeGrid.GridSize + block.CubeGrid.GridSize / 2);

            if (block.FatBlock != null)
            {
                var aabbCenter = aabb.Center;
                aabb = (BoundingBoxD)block.FatBlock.Model.BoundingBox;
                Matrix m;
                block.FatBlock.Orientation.GetMatrix(out m);
                aabb = aabb.TransformFast(m);
                aabb.Translate(aabbCenter);
            }

            aabb = aabb.TransformFast(block.CubeGrid.WorldMatrix);
            aabb.Inflate(0.125);

            List <MyEntity> boxOverlapList = new List <MyEntity>();

            MyEntities.GetElementsInBox(ref aabb, boxOverlapList);

            for (int i = 0; i < boxOverlapList.Count; i++)
            {
                var otherBlock = boxOverlapList[i] as MyCubeBlock;
                if (otherBlock != null && otherBlock.SlimBlock != block &&
                    otherBlock.CubeGrid.IsStatic && otherBlock.CubeGrid.EnableSmallToLargeConnections && otherBlock.CubeGrid.SmallToLargeConnectionsInitialized &&
                    otherBlock.CubeGrid != block.CubeGrid && otherBlock.CubeGrid.GridSizeEnum == cubeSizeEnum && !(otherBlock is MyFracturedBlock) &&
                    !(otherBlock.Components.Has <MyFractureComponentBase>()))
                {
                    var compound = otherBlock as MyCompoundCubeBlock;
                    if (compound != null)
                    {
                        foreach (var blockInCompound in compound.GetBlocks())
                        {
                            if (blockInCompound != block && !(blockInCompound.FatBlock.Components.Has <MyFractureComponentBase>()))
                            {
                                outBlocks.Add(blockInCompound.FatBlock);
                            }
                        }
                    }
                    else
                    {
                        outBlocks.Add(otherBlock);
                    }
                }
            }

            boxOverlapList.Clear();
        }
 void connect(List <string> args)
 {
     this.log("received a connection request");
     try {
         MyCubeSize size = MyCubeSize.Small;
         Enum.TryParse(args[0], out size);
         var  wPos         = new Vector3D(double.Parse(args[1]), double.Parse(args[2]), double.Parse(args[3]));
         var  wOrientation = new Vector3D(double.Parse(args[4]), double.Parse(args[5]), double.Parse(args[6]));
         long address      = long.Parse(args[7]);
         this.connect(size, wPos, wOrientation, address);
     } catch (Exception e) {
         this.log($"could not parse value received: {e.Message}");
     }
 }
Example #30
0
        public static float GetSizeM(this MyCubeSize size)
        {
            switch (size)
            {
            case MyCubeSize.Large:
                return(2.5f);

            case MyCubeSize.Small:
                return(0.5f);

            default:
                return(float.NaN);
            }
        }
        /// <summary>
        /// Writes all surrounding blocks around the given one with the given size.
        /// </summary>
        private void GetSurroundingBlocksFromStaticGrids(MySlimBlock block, MyCubeSize cubeSizeEnum, HashSet <MyCubeBlock> outBlocks)
        {
            outBlocks.Clear();

            BoundingBoxD aabb = new BoundingBoxD(block.Min * block.CubeGrid.GridSize - block.CubeGrid.GridSize / 2, block.Max * block.CubeGrid.GridSize + block.CubeGrid.GridSize / 2);

            if (block.FatBlock != null)
            {
                aabb = (BoundingBoxD)block.FatBlock.Model.BoundingBox;
                aabb.Translate(block.Position * block.CubeGrid.GridSize);
            }

            aabb = aabb.Transform(block.CubeGrid.WorldMatrix);
            aabb.Inflate(0.125);

            List <MyEntity> boxOverlapList = new List <MyEntity>();

            MyEntities.GetElementsInBox(ref aabb, boxOverlapList);

            for (int i = 0; i < boxOverlapList.Count; i++)
            {
                var otherGrid = boxOverlapList[i] as MyCubeGrid;
                if (otherGrid != null)
                {
                    foreach (var gridBlock in otherGrid.CubeBlocks)
                    {
                        if (IsValidForConnection(gridBlock.FatBlock, block, cubeSizeEnum))
                        {
                            if (!IsCompoundAndProcessed(gridBlock.FatBlock, block, outBlocks))
                            {
                                outBlocks.Add(gridBlock.FatBlock);
                            }
                        }
                    }
                }
                else
                {
                    var otherBlock = boxOverlapList[i] as MyCubeBlock;
                    if (IsValidForConnection(otherBlock, block, cubeSizeEnum))
                    {
                        if (!IsCompoundAndProcessed(otherBlock, block, outBlocks))
                        {
                            outBlocks.Add(otherBlock);
                        }
                    }
                }
            }

            boxOverlapList.Clear();
        }
        public virtual bool Initialize(MyCubeGrid grid, MyCubeSize gridSizeEnum)
        {
            m_grid    = grid;
            m_enabled = true;

            if (IsValid(gridSizeEnum))
            {
                m_grid.OnBlockAdded   += Grid_OnBlockAdded;
                m_grid.OnBlockRemoved += Grid_OnBlockRemoved;
                m_grid.OnGridSplit    += Grid_OnGridSplit;

                return(true);
            }

            return(false);
        }
Example #33
0
 public WeaponInformation(List <BlockSideEnum> mountPoints, MyCubeSize myCubeSize, int sizeX, int sizeY, int sizeZ,
                          MyStringHash subtypeId, string subtypeName, MyObjectBuilderType typeId, string modName, string id, MyWeaponBlockDefinition myWeaponBlock = null, MyLargeTurretBaseDefinition myLargeTurret = null)
 {
     MountPoints   = mountPoints;
     MyCubeSize    = myCubeSize;
     SizeX         = sizeX;
     SizeY         = sizeY;
     SizeZ         = sizeZ;
     SubtypeId     = subtypeId;
     SubtypeName   = subtypeName;
     TypeId        = typeId;
     ModName       = modName;
     Id            = id;
     MyWeaponBlock = myWeaponBlock;
     MyLargeTurret = myLargeTurret;
 }
Example #34
0
        //public static long GenerateEntityId()
        //{
        //    // Not the offical SE way of generating IDs, but its fast and we don't have to worry about a random seed.
        //    var buffer = Guid.NewGuid().ToByteArray();
        //    return BitConverter.ToInt64(buffer, 0);
        //}

        #endregion

        #region FetchCubeBlockMass

        public static float FetchCubeBlockMass(MyObjectBuilderType typeId, MyCubeSize cubeSize, string subTypeid)
        {
            float mass = 0;

            var cubeBlockDefinition = GetCubeDefinition(typeId, cubeSize, subTypeid);

            if (cubeBlockDefinition != null)
            {
                foreach (var component in cubeBlockDefinition.Components)
                {
                    mass += SpaceEngineersCore.Resources.Definitions.Components.Where(c => c.Id.SubtypeId == component.Subtype).Sum(c => c.Mass) * component.Count;
                }
            }

            return(mass);
        }
        void CreateGrid(MyCubeSize cubeSize, bool isStatic)
        {
            if (!MyEntities.MemoryLimitReachedReport && !MySandboxGame.IsPaused)
            {
                MySessionComponentVoxelHand.Static.Enabled = false;
                MyCubeBuilder.Static.StartNewGridPlacement(cubeSize, isStatic);
                var character = MySession.Static.LocalCharacter;

                Debug.Assert(character != null);
                if (character != null)
                {
                    MyDefinitionId weaponDefinition = new MyDefinitionId(typeof(MyObjectBuilder_CubePlacer));
                    character.SwitchToWeapon(weaponDefinition);
                }
            }
        }
        void CreateGrid(MyCubeSize cubeSize, bool isStatic)
        {
            if (!MyEntities.MemoryLimitReachedReport && !MySandboxGame.IsPaused)
            {
                MySessionComponentVoxelHand.Static.Enabled = false;
                MyCubeBuilder.Static.StartNewGridPlacement(cubeSize, isStatic);
                var character = MySession.Static.LocalCharacter;

                Debug.Assert(character != null);
                if (character != null)
                {
                    MyDefinitionId weaponDefinition = new MyDefinitionId(typeof(MyObjectBuilder_CubePlacer));
                    character.SwitchToWeapon(weaponDefinition);
                }
            }
        }
Example #37
0
        public void StartNewGridPlacement(MyCubeSize cubeSize, bool isStatic)
        {
            var character = MySession.LocalCharacter;
            if (character != null)
            {
                character.SwitchToWeapon(null);
            }

            string prefabName;
            MyDefinitionManager.Static.GetBaseBlockPrefabName(cubeSize, isStatic, MySession.Static.CreativeMode, out prefabName);
            if (prefabName == null)
                return;
            var gridBuilders = MyPrefabManager.Static.GetGridPrefab(prefabName);
            Debug.Assert(gridBuilders != null && gridBuilders.Count() > 0);
            if (gridBuilders == null || gridBuilders.Count() == 0)
                return;

            var blockDefinition = MyDefinitionManager.Static.GetCubeBlockDefinition(gridBuilders[0].CubeBlocks.First().GetId());
            var sizeInMeters = MyDefinitionManager.Static.GetCubeSize(cubeSize);
            Vector3 blockDiagonal = new Vector3(blockDefinition.Size) * sizeInMeters;

            Vector3 centerDisplacement;
            if (isStatic)
                centerDisplacement = Vector3.Zero;
            else
                centerDisplacement = new Vector3(0.0f, 0.55f, -1.0f) * sizeInMeters;

            foreach (var gridBuilder in gridBuilders)
            {
                foreach (var blockBuilder in gridBuilder.CubeBlocks)
                {
                    blockBuilder.ColorMaskHSV = MyToolbar.ColorMaskHSV;
                }
            }

            MyCubeBuilder.Static.ActivateShipCreationClipboard(gridBuilders, centerDisplacement, 5.0f + blockDiagonal.Length() * 0.5f);
        }
        public void StartNewGridPlacement(MyCubeSize cubeSize, bool isStatic)
        {
            var character = MySession.Static.LocalCharacter;
            if (character != null)
            {
                character.SwitchToWeapon(null);
            }

            string prefabName;
            MyDefinitionManager.Static.GetBaseBlockPrefabName(cubeSize, isStatic, MySession.Static.CreativeMode, out prefabName);
            if (prefabName == null)
                return;
            var gridBuilders = MyPrefabManager.Static.GetGridPrefab(prefabName);
            Debug.Assert(gridBuilders != null && gridBuilders.Length > 0);
            if (gridBuilders == null || gridBuilders.Length == 0)
                return;

            var blockDefinition = MyDefinitionManager.Static.GetCubeBlockDefinition(gridBuilders[0].CubeBlocks.First().GetId());
            var sizeInMeters = MyDefinitionManager.Static.GetCubeSize(cubeSize);
            Vector3 blockDiagonal = new Vector3(blockDefinition.Size) * sizeInMeters;

            Vector3 centerDisplacement;
            if (isStatic)
                centerDisplacement = Vector3.Zero;
            else
                centerDisplacement = new Vector3(0.0f, 0.55f, -1.0f) * sizeInMeters;

            foreach (var gridBuilder in gridBuilders)
            {
                if (gridBuilder.IsStatic && gridBuilder.PositionAndOrientation.HasValue)
                {
                    gridBuilder.PositionAndOrientation = MyPositionAndOrientation.Default;
                }
                foreach (var blockBuilder in gridBuilder.CubeBlocks)
                {
					blockBuilder.ColorMaskHSV = MyPlayer.SelectedColor;
                }
            }
            
            ActivateShipCreationClipboard(gridBuilders, centerDisplacement, (character.IsUsing is MyCockpit?10f:5.0f) + blockDiagonal.Length() * 0.5f,true,cubeSize,isStatic);

            if (MySector.MainCamera != null)
            {
                Vector3 gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(MySector.MainCamera.Position);
                if (gravity.LengthSquared() > 0.01f)
                {
                    m_shipCreationClipboard.EnableStationRotation = true;
                    m_shipCreationClipboard.AlignClipboardToGravity(gravity);
                    ShowStationRotationNotification();
                }
            }

            if (isStatic)
            {
                ShowStationRotationNotification();
            }
            else
            {
                HideStationRotationNotification();
            }
        }
Example #39
0
        public void StartNewGridPlacement(MyCubeSize cubeSize, bool isStatic)
        {
            var character = MySession.Static.LocalCharacter;
            if (character != null)
            {
                character.SwitchToWeapon(null);
            }

            string prefabName;
            MyDefinitionManager.Static.GetBaseBlockPrefabName(cubeSize, isStatic, MySession.Static.CreativeMode, out prefabName);
            if (prefabName == null)
                return;
            var gridBuilders = MyPrefabManager.Static.GetGridPrefab(prefabName);
            Debug.Assert(gridBuilders != null && gridBuilders.Length > 0);
            if (gridBuilders == null || gridBuilders.Length == 0)
                return;

            foreach (var gridBuilder in gridBuilders)
            {
                if (gridBuilder.IsStatic && gridBuilder.PositionAndOrientation.HasValue)
                {
                    gridBuilder.PositionAndOrientation = MyPositionAndOrientation.Default;
                }
                foreach (var blockBuilder in gridBuilder.CubeBlocks)
                {
					blockBuilder.ColorMaskHSV = MyPlayer.SelectedColor;
                }
            }
                }
        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var ob = builder as MyObjectBuilder_CubeBlockDefinition;
            MyDebug.AssertDebug(ob != null);

            this.Size                  = ob.Size;
            this.Model                 = ob.Model;
            this.UseModelIntersection  = ob.UseModelIntersection;
            this.CubeSize              = ob.CubeSize;
            this.ModelOffset           = ob.ModelOffset;
            this.BlockTopology         = ob.BlockTopology;
            this.PhysicsOption         = ob.PhysicsOption;
            this.BlockPairName         = ob.BlockPairName;
            this.m_center              = ob.Center ?? ((Size - 1) / 2);
            this.m_symmetryX           = ob.MirroringX;
            this.m_symmetryY           = ob.MirroringY;
            this.m_symmetryZ           = ob.MirroringZ;
            this.DeformationRatio      = ob.DeformationRatio;
            this.SilenceableByShipSoundSystem = ob.SilenceableByShipSoundSystem;
            this.EdgeType              = ob.EdgeType;
            this.AutorotateMode        = ob.AutorotateMode;
            this.m_mirroringBlock      = ob.MirroringBlock;
            this.MultiBlock            = ob.MultiBlock;
            this.GuiVisible            = ob.GuiVisible;
            this.Rotation              = ob.Rotation;
            this.Direction             = ob.Direction;
            this.Mirrored              = ob.Mirrored;
            this.RandomRotation        = ob.RandomRotation;
            this.BuildType             = MyStringId.GetOrCompute(ob.BuildType != null ? ob.BuildType.ToLower() : null);
            this.BuildMaterial         = ob.BuildMaterial != null ? ob.BuildMaterial.ToLower() : null;
            this.BuildProgressToPlaceGeneratedBlocks = ob.BuildProgressToPlaceGeneratedBlocks;
            this.GeneratedBlockType    = MyStringId.GetOrCompute(ob.GeneratedBlockType != null ? ob.GeneratedBlockType.ToLower() : null);
            this.CompoundEnabled       = ob.CompoundEnabled;
            this.CreateFracturedPieces = ob.CreateFracturedPieces;
            this.VoxelPlacement      = ob.VoxelPlacement;

            if (ob.PhysicalMaterial != null)
            {
                this.PhysicalMaterial = MyDefinitionManager.Static.GetPhysicalMaterialDefinition(ob.PhysicalMaterial);
            }
            if (ob.Effects != null)
            {
                this.Effects = new CubeBlockEffectBase[ob.Effects.Length];
                for (int i = 0; i < ob.Effects.Length; i++)
                {
                    this.Effects[i] = new CubeBlockEffectBase(ob.Effects[i].Name, ob.Effects[i].ParameterMin, ob.Effects[i].ParameterMax);
                    if (ob.Effects[i].ParticleEffects != null && ob.Effects[i].ParticleEffects.Length > 0)
                    {
                        this.Effects[i].ParticleEffects = new CubeBlockEffect[ob.Effects[i].ParticleEffects.Length];
                        for (int j = 0; j < ob.Effects[i].ParticleEffects.Length; j++)
                        {
                            this.Effects[i].ParticleEffects[j] = new CubeBlockEffect(ob.Effects[i].ParticleEffects[j]);
                        }
                    }
                    else
                        this.Effects[i].ParticleEffects = null;
                }
            }
            if (ob.DamageEffectId != 0)
                this.DamageEffectID = ob.DamageEffectId;

            this.Points = ob.Points;
            InitEntityComponents(ob.EntityComponents);

            this.CompoundTemplates = ob.CompoundTemplates;
            Debug.Assert(this.CompoundTemplates == null || this.CompoundTemplates.Length > 0, "Wrong compound templates, array is empty");

            if (ob.SubBlockDefinitions != null)
            {
                SubBlockDefinitions = new Dictionary<string, MyDefinitionId>();

                foreach (var definition in ob.SubBlockDefinitions)
                {
                    MyDefinitionId defId;
                    if (SubBlockDefinitions.TryGetValue(definition.SubBlock, out defId))
                    {
                        MyDebug.AssertDebug(false, "Subblock definition already defined!");
                        continue;
                    }

                    defId = definition.Id;
                    SubBlockDefinitions.Add(definition.SubBlock, defId);
                }
            }

            if (ob.BlockVariants != null)
            {
                BlockStages = new MyDefinitionId[ob.BlockVariants.Length];

                for (int i = 0; i < ob.BlockVariants.Length; ++i)
                {
                    BlockStages[i] = ob.BlockVariants[i];
                }
            }

            var cubeDef = ob.CubeDefinition;
            if (cubeDef != null)
            {
                MyCubeDefinition tmp = new MyCubeDefinition();
                tmp.CubeTopology = cubeDef.CubeTopology;
                tmp.ShowEdges = cubeDef.ShowEdges;

                var sides = cubeDef.Sides;
                tmp.Model = new string[sides.Length];
                tmp.PatternSize = new Vector2I[sides.Length];
                for (int j = 0; j < sides.Length; ++j)
                {
                    var side = sides[j];
                    tmp.Model[j] = side.Model;
                    tmp.PatternSize[j] = side.PatternSize;
                }
                this.CubeDefinition = tmp;
            }

            var components = ob.Components;
            MyDebug.AssertDebug(components != null);
            MyDebug.AssertDebug(components.Length != 0);
            float mass = 0.0f;
            float criticalIntegrity = 0f;
            float ownershipIntegrity = 0f;

            MaxIntegrityRatio = 1;

            if (components != null && components.Length != 0)
            {
                Components = new MyCubeBlockDefinition.Component[components.Length];

                float integrity = 0.0f;
                int criticalTypeCounter = 0;
                for (int j = 0; j < components.Length; ++j)
                {
                    var component = components[j];

                    var definition = MyDefinitionManager.Static.GetComponentDefinition(new MyDefinitionId(component.Type, component.Subtype));
                    MyPhysicalItemDefinition deconstructDefinition = null;
                    if (!component.DeconstructId.IsNull() && !MyDefinitionManager.Static.TryGetPhysicalItemDefinition(component.DeconstructId, out deconstructDefinition))
                        deconstructDefinition = definition;

                    if (deconstructDefinition == null)
                        deconstructDefinition = definition;

                    MyCubeBlockDefinition.Component tmp = new MyCubeBlockDefinition.Component()
                    {
                        Definition = definition,
                        Count = component.Count,
                        DeconstructItem = deconstructDefinition,
                    };

                    if (component.Type == typeof(MyObjectBuilder_Component) && component.Subtype == "Computer")
                    {
                        if (ownershipIntegrity == 0)
                            ownershipIntegrity = integrity + tmp.Definition.MaxIntegrity;
                    }

                    integrity += tmp.Count * tmp.Definition.MaxIntegrity;
                    if (component.Type == ob.CriticalComponent.Type &&
                        component.Subtype == ob.CriticalComponent.Subtype)
                    {
                        if (criticalTypeCounter == ob.CriticalComponent.Index)
                        {
                            CriticalGroup = (UInt16)j;
                            criticalIntegrity = integrity-1;
                        }
                        ++criticalTypeCounter;
                    }

                    mass += tmp.Count * tmp.Definition.Mass;

                    Components[j] = tmp;
                }

                MaxIntegrity = integrity;
                IntegrityPointsPerSec = MaxIntegrity / ob.BuildTimeSeconds;
                DisassembleRatio = ob.DisassembleRatio;

                if (ob.MaxIntegrity != 0)
                {
                    // If we specify MaxIntegrity for a block, it conflicts with the original integrity
                    // So instead of overriding the MaxIntegrity, we multiply DeformationRatio so that the block
                    // behaves as if it had the integrity that we want!
                    MaxIntegrityRatio = ob.MaxIntegrity / MaxIntegrity;
                    DeformationRatio = DeformationRatio / MaxIntegrityRatio;
                }

                if(!MyPerGameSettings.Destruction)
                    Mass = mass;
            }
            else
            {
                if (ob.MaxIntegrity != 0)
                    MaxIntegrity = ob.MaxIntegrity;
            }

            CriticalIntegrityRatio = criticalIntegrity / MaxIntegrity;
            OwnershipIntegrityRatio = ownershipIntegrity / MaxIntegrity;

            if (ob.BuildProgressModels != null)
            {
                ob.BuildProgressModels.Sort((a, b) => a.BuildPercentUpperBound.CompareTo(b.BuildPercentUpperBound));
                this.BuildProgressModels = new BuildProgressModel[ob.BuildProgressModels.Count];
                for (int i = 0; i < BuildProgressModels.Length; ++i)
                {
                    var builderModel = ob.BuildProgressModels[i];
                    if (!string.IsNullOrEmpty(builderModel.File))
                    {
                        this.BuildProgressModels[i] = new BuildProgressModel()
                        {
                            BuildRatioUpperBound = builderModel.BuildPercentUpperBound * CriticalIntegrityRatio,
                            File = builderModel.File,
                            RandomOrientation = builderModel.RandomOrientation
                        };
                    }
                }
            }

            if (ob.GeneratedBlocks != null)
            {
                this.GeneratedBlockDefinitions = new MyDefinitionId[ob.GeneratedBlocks.Length];

                for (int i = 0; i < ob.GeneratedBlocks.Length; ++i)
                {
                    var genBlockId = ob.GeneratedBlocks[i];
                    Debug.Assert(!string.IsNullOrEmpty(genBlockId.SubtypeName));
                    Debug.Assert(!string.IsNullOrEmpty(genBlockId.TypeIdString));

                    this.GeneratedBlockDefinitions[i] = genBlockId;
                }
            }

            Skeleton = ob.Skeleton;
            if (Skeleton != null)
            {
                Bones = new Dictionary<Vector3I,Vector3>(ob.Skeleton.Count);
                foreach (var bone in Skeleton)
                {
                    Bones[bone.BonePosition] = Vector3UByte.Denormalize(bone.BoneOffset, MyDefinitionManager.Static.GetCubeSize(ob.CubeSize));
                }
            }

            IsAirTight = ob.IsAirTight;

            InitMountPoints(ob);
            InitPressurization();

            InitNavigationInfo(ob, ob.NavigationDefinition);

            CheckBuildProgressModels();
            // Components and CriticalComponent will be initialized elsewhere

            PrimarySound = new MySoundPair(ob.PrimarySound);
            ActionSound = new MySoundPair(ob.ActionSound);
            if (ob.DamagedSound!=null)
                DamagedSound = new MySoundPair(ob.DamagedSound);

        }
Example #41
0
 public static float GetShipMaxAngularVelocity(MyCubeSize size)
 {
     return size == MyCubeSize.Large ? GetLargeShipMaxAngularVelocity() : GetSmallShipMaxAngularVelocity();
 }
Example #42
0
        public void StartStaticGridPlacement(MyCubeSize cubeSize, bool isStatic)
        {
            var character = MySession.Static.LocalCharacter;
            if (character != null)
            {
                character.SwitchToWeapon(null);
            }

            MyDefinitionId id = new MyDefinitionId(typeof(MyObjectBuilder_CubeBlock), "LargeBlockArmorBlock");
            MyCubeBlockDefinition def;
            MyDefinitionManager.Static.TryGetCubeBlockDefinition(id, out def);
            Activate(def.Id);
            m_stationPlacement = true;

        }
        // TODO: deal with cubes that need to be rotated.
        // LargeBlockBeacon, SmallBlockBeacon, ConveyorTube, ConveyorTubeSmall
        public static bool ScaleShip(IMyCubeGrid shipEntity, MyCubeSize newScale)
        {
            if (shipEntity == null)
                return false;

            if (shipEntity.GridSizeEnum == newScale)
            {
                MyAPIGateway.Utilities.ShowMessage("scaledown", "Ship is already the right scale.");
                return true;
            }

            var grids = shipEntity.GetAttachedGrids();

            var newGrids = new MyObjectBuilder_CubeGrid[grids.Count];

            foreach (var cubeGrid in grids)
            {
                // ejects any player prior to deleting the grid.
                cubeGrid.EjectControllingPlayers();
                cubeGrid.Physics.Enabled = false;
            }

            var tempList = new List<MyObjectBuilder_EntityBase>();
            var gridIndex = 0;
            foreach (var cubeGrid in grids)
            {
                var blocks = new List<Sandbox.ModAPI.IMySlimBlock>();
                cubeGrid.GetBlocks(blocks);

                var gridObjectBuilder = cubeGrid.GetObjectBuilder(true) as MyObjectBuilder_CubeGrid;

                gridObjectBuilder.EntityId = 0;
                Regex rgx = new Regex(Regex.Escape(gridObjectBuilder.GridSizeEnum.ToString()));
                var rgxScale = Regex.Escape(newScale.ToString());
                gridObjectBuilder.GridSizeEnum = newScale;
                var removeList = new List<MyObjectBuilder_CubeBlock>();

                foreach (var block in gridObjectBuilder.CubeBlocks)
                {
                    MyCubeBlockDefinition defintion;
                    string newSubType = null;
                    if (newScale == MyCubeSize.Small && LargeToSmall.ContainsKey(block.SubtypeName))
                        newSubType = LargeToSmall[block.SubtypeName];
                    else if (newScale == MyCubeSize.Large && SmallToLarge.ContainsKey(block.SubtypeName))
                        newSubType = SmallToLarge[block.SubtypeName];
                    else
                    {
                        newSubType = rgx.Replace(block.SubtypeName, rgxScale, 1);

                        // Match using the BlockPairName if there is a matching cube.
                        if (MyDefinitionManager.Static.TryGetCubeBlockDefinition(new MyDefinitionId(block.GetType(), block.SubtypeName), out defintion))
                        {
                            var newDef = MyDefinitionManager.Static.GetAllDefinitions().Where(d => d is MyCubeBlockDefinition && ((MyCubeBlockDefinition)d).BlockPairName == defintion.BlockPairName && ((MyCubeBlockDefinition)d).CubeSize == newScale).FirstOrDefault();
                            if (newDef != null)
                                newSubType = newDef.Id.SubtypeName;
                        }
                    }
                    if (MyDefinitionManager.Static.TryGetCubeBlockDefinition(new MyDefinitionId(block.GetType(), newSubType), out defintion) && defintion.CubeSize == newScale)
                    {
                        block.SubtypeName = newSubType;
                        //block.EntityId = 0;
                    }
                    else
                    {
                        removeList.Add(block);
                    }
                }

                foreach (var block in removeList)
                {
                    gridObjectBuilder.CubeBlocks.Remove(block);
                }

                // This will Delete the entity and sync to all.
                // Using this, also works with player ejection in the same Tick.
                cubeGrid.SyncObject.SendCloseRequest();

                var name = cubeGrid.DisplayName;
                MyAPIGateway.Utilities.ShowMessage("ship", "'{0}' resized.", name);

                tempList.Add(gridObjectBuilder);

                gridIndex++;
            }

            // TODO: reposition multiple grids so rotors and pistons re-attach.

            tempList.CreateAndSyncEntities();
            return true;
        }
 void IMyCubeBuilder.StartNewGridPlacement(MyCubeSize cubeSize, bool isStatic)
 {
     StartNewGridPlacement(cubeSize, isStatic);
 }
        public virtual bool Initialize(MyCubeGrid grid, MyCubeSize gridSizeEnum)
        {
            m_grid = grid;
            m_enabled = true;

            if (IsValid(gridSizeEnum))
            {
                m_grid.OnBlockAdded += Grid_OnBlockAdded;
                m_grid.OnBlockRemoved += Grid_OnBlockRemoved;
                m_grid.OnGridSplit += Grid_OnGridSplit;

                return true;
            }

            return false;
        }
 protected abstract bool IsValid(MyCubeSize gridSizeEnum);
        public void ActivateShipCreationClipboard(MyObjectBuilder_CubeGrid[] grids, Vector3 centerDeltaDirection, float dragVectorLength, bool creation, MyCubeSize cubeSize, bool isStatic)
        {
            if (m_shipCreationClipboard.IsActive)
                return;

            MySessionComponentVoxelHand.Static.Enabled = false;
            DeactivateMultiBlockClipboard();
            if(creation)
            {
                m_shipCreationClipboard.CubeSize = cubeSize;
                m_shipCreationClipboard.IsStatic = isStatic;
                m_shipCreationClipboard.CreationMode = true;
            }
            m_shipCreationClipboard.SetGridFromBuilders(grids, centerDeltaDirection, dragVectorLength);
        }
Example #48
0
 public static bool IsGroupGridSize( GridGroup group, MyCubeSize size, bool isStatic = false )
 {
     if( isStatic )
         return group.Grids.Any( x => x?.Physics !=null && x.Physics.IsStatic );
     else
         return group.Grids.All( x => x.GridSizeEnum == size );
 }
        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var ob = builder as MyObjectBuilder_CubeBlockDefinition;
            MyDebug.AssertDebug(ob != null);

            this.Size                  = ob.Size;
            this.Model                 = ob.Model;
            this.UseModelIntersection  = ob.UseModelIntersection;
            this.CubeSize              = ob.CubeSize;
            this.ModelOffset           = ob.ModelOffset;
            this.BlockTopology         = ob.BlockTopology;
            this.PhysicsOption         = ob.PhysicsOption;
            this.BlockPairName         = ob.BlockPairName;
            this.m_center              = ob.Center ?? ((Size - 1) / 2);
            this.m_symmetryX           = ob.MirroringX;
            this.m_symmetryY           = ob.MirroringY;
            this.m_symmetryZ           = ob.MirroringZ;
            this.DeformationRatio      = ob.DeformationRatio;
            this.EdgeType              = ob.EdgeType;
            this.AutorotateMode        = ob.AutorotateMode;
            this.m_mirroringBlock      = ob.MirroringBlock;
            this.MultiBlock            = ob.MultiBlock;
            this.GuiVisible            = ob.GuiVisible;
            this.Rotation              = ob.Rotation;
            this.Direction             = ob.Direction;
            this.Mirrored              = ob.Mirrored;
            this.RandomRotation        = ob.RandomRotation;
            this.BuildType             = ob.BuildType != null ? ob.BuildType.ToLower() : null;
            this.GeneratedBlockType    = MyStringId.GetOrCompute(ob.GeneratedBlockType != null ? ob.GeneratedBlockType.ToLower() : null);
            if (ob.DamageEffectId != 0)
                this.DamageEffectID = ob.DamageEffectId;

            this.CompoundTemplates = ob.CompoundTemplates;
            Debug.Assert(this.CompoundTemplates == null || this.CompoundTemplates.Length > 0, "Wrong compound templates, array is empty");

            if (ob.SubBlockDefinitions != null)
            {
                SubBlockDefinitions = new Dictionary<string, MyDefinitionId>();

                foreach (var definition in ob.SubBlockDefinitions)
                {
                    MyDefinitionId defId;
                    if (SubBlockDefinitions.TryGetValue(definition.SubBlock, out defId))
                    {
                        MyDebug.AssertDebug(false, "Subblock definition already defined!");
                        continue;
                    }

                    defId = definition.Id;
                    SubBlockDefinitions.Add(definition.SubBlock, defId);
                }
            }

            if (ob.BlockVariants != null)
            {
                BlockStages = new MyDefinitionId[ob.BlockVariants.Length];

                for (int i = 0; i < ob.BlockVariants.Length; ++i)
                {
                    BlockStages[i] = ob.BlockVariants[i];
                }
            }

            var cubeDef = ob.CubeDefinition;
            if (cubeDef != null)
            {
                MyCubeDefinition tmp = new MyCubeDefinition();
                tmp.CubeTopology = cubeDef.CubeTopology;
                tmp.ShowEdges = cubeDef.ShowEdges;

                var sides = cubeDef.Sides;
                tmp.Model = new string[sides.Length];
                tmp.PatternSize = new Vector2I[sides.Length];
                for (int j = 0; j < sides.Length; ++j)
                {
                    var side = sides[j];
                    tmp.Model[j] = side.Model;
                    tmp.PatternSize[j] = side.PatternSize;
                }
                this.CubeDefinition = tmp;
            }

            var components = ob.Components;
            MyDebug.AssertDebug(components != null);
            MyDebug.AssertDebug(components.Length != 0);
            float mass = 0.0f;
            float criticalIntegrity = 0f;
            float ownershipIntegrity = 0f;
            if (components != null && components.Length != 0)
            {
                Components = new MyCubeBlockDefinition.Component[components.Length];

                float integrity = 0.0f;
                int criticalTypeCounter = 0;
                for (int j = 0; j < components.Length; ++j)
                {
                    var component = components[j];

                    MyCubeBlockDefinition.Component tmp = new MyCubeBlockDefinition.Component()
                    {
                        Count = component.Count,
                        Definition = MyDefinitionManager.Static.GetComponentDefinition(new MyDefinitionId(component.Type, component.Subtype))
                    };

                    if (component.Type == typeof(MyObjectBuilder_Component) && component.Subtype == "Computer")
                    {
                        if (ownershipIntegrity == 0)
                            ownershipIntegrity = integrity + tmp.Definition.MaxIntegrity;
                    }

                    integrity += tmp.Count * tmp.Definition.MaxIntegrity;
                    if (component.Type == ob.CriticalComponent.Type &&
                        component.Subtype == ob.CriticalComponent.Subtype)
                    {
                        if (criticalTypeCounter == ob.CriticalComponent.Index)
                        {
                            CriticalGroup = (UInt16)j;
                            criticalIntegrity = integrity-1;
                        }
                        ++criticalTypeCounter;
                    }

                    mass += tmp.Count * tmp.Definition.Mass;

                    Components[j] = tmp;
                }
                MaxIntegrity = integrity;
                IntegrityPointsPerSec = integrity / ob.BuildTimeSeconds;
                DisassembleRatio = ob.DisassembleRatio;
                Mass = mass;
            }

            CriticalIntegrityRatio = criticalIntegrity / MaxIntegrity;
            OwnershipIntegrityRatio = ownershipIntegrity / MaxIntegrity;

            if (ob.BuildProgressModels != null)
            {
                ob.BuildProgressModels.Sort((a, b) => a.BuildPercentUpperBound.CompareTo(b.BuildPercentUpperBound));
                this.BuildProgressModels = new BuildProgressModel[ob.BuildProgressModels.Count];
                for (int i = 0; i < BuildProgressModels.Length; ++i)
                {
                    var builderModel = ob.BuildProgressModels[i];
                    if (!string.IsNullOrEmpty(builderModel.File))
                    {
                        this.BuildProgressModels[i] = new BuildProgressModel()
                        {
                            BuildRatioUpperBound = builderModel.BuildPercentUpperBound * CriticalIntegrityRatio,
                            File = builderModel.File,
                            RandomOrientation = builderModel.RandomOrientation
                        };
                    }
                }
            }

            if (ob.GeneratedBlocks != null)
            {
                this.GeneratedBlockDefinitions = new MyDefinitionId[ob.GeneratedBlocks.Length];

                for (int i = 0; i < ob.GeneratedBlocks.Length; ++i)
                {
                    var genBlockId = ob.GeneratedBlocks[i];
                    Debug.Assert(!string.IsNullOrEmpty(genBlockId.SubtypeName));
                    Debug.Assert(!string.IsNullOrEmpty(genBlockId.TypeIdString));

                    this.GeneratedBlockDefinitions[i] = genBlockId;
                }
            }

            Skeleton = ob.Skeleton;
            if (Skeleton != null)
            {
                Bones = new Dictionary<Vector3I,Vector3>(ob.Skeleton.Count);
                foreach (var bone in Skeleton)
                {
                    Bones[bone.BonePosition] = Vector3UByte.Denormalize(bone.BoneOffset, MyDefinitionManager.Static.GetCubeSize(ob.CubeSize));
                }
            }

            IsAirTight = ob.IsAirTight;

            InitMountPoints(ob);
            InitPressurization();

            InitNavigationInfo(ob, ob.NavigationDefinition);

            CheckBuildProgressModels();
            // Components and CriticalComponent will be initialized elsewhere

            this.PrimarySound = new MySoundPair(ob.PrimarySound);
        }
        public bool SpectatorToNextGrid(MyCubeSize size)
        {
            MyCubeGrid nextGrid = null;
            MyCubeGrid prevGrid = null;

            foreach (var entity in MyEntities.GetEntities())
            {
                MyCubeGrid grid = entity as MyCubeGrid;
                if (grid != null && grid.GridSizeEnum == size)
                {
                    if (m_previousSpectatorGridId == 0)
                    {
                        nextGrid = grid;
                        break;
                    }

                    if (prevGrid != null)
                    {
                        nextGrid = grid;
                        break;
                    }

                    if (grid.EntityId == m_previousSpectatorGridId)
                    {
                        prevGrid = grid;
                    }

                    if (nextGrid == null)
                    {
                        nextGrid = grid;
                    }
                }
            }

            if (nextGrid == null)
            {
                return false;
            }

            BoundingSphere bSphere = nextGrid.PositionComp.WorldVolume;
            Vector3D rotatedFW = Vector3D.Transform(Vector3D.Forward, MySpectator.Static.Orientation);
            MySpectator.Static.Position = nextGrid.PositionComp.GetPosition() - rotatedFW * bSphere.Radius * 2;
            m_previousSpectatorGridId = nextGrid.EntityId;
            return true;
        }
 /// <summary>
 /// Sets cube size mode.
 /// </summary>
 /// <param name="newCubeSize">New cube size mode.</param>
 public void SetCubeSize(MyCubeSize newCubeSize)
 {
     m_cubeSizeMode = newCubeSize;
     UpdateComplementBlock();
 }