예제 #1
0
        public static ulong GetBattlePoints(MyObjectBuilder_CubeGrid[] grids)
        {
            ulong pts = 0;
            foreach (var grid in grids)
                pts += GetBattlePoints(grid);

            return pts;
        }
예제 #2
0
 public void ProcessCubeGrid(MyObjectBuilder_CubeGrid gridBuilder)
 {
     gridBuilder.IsStatic = false;
     // To prevent exploits
     gridBuilder.DestructibleBlocks = false;
     foreach (var block in gridBuilder.CubeBlocks)
     {
         var functionalBlock = block as MyObjectBuilder_FunctionalBlock;
         if (functionalBlock != null)
         {
             functionalBlock.Enabled = false;
         }
     }
 }
예제 #3
0
        public CubeGridEntity( MyObjectBuilder_CubeGrid definition )
            : base(definition)
        {
            _cubeBlockManager = new CubeBlockManager( this );
            List<CubeBlockEntity> cubeBlockList = new List<CubeBlockEntity>( );
            foreach ( MyObjectBuilder_CubeBlock cubeBlock in definition.CubeBlocks )
            {
                cubeBlock.EntityId = 0;
                cubeBlockList.Add( new CubeBlockEntity( this, cubeBlock ) );
            }
            _cubeBlockManager.Load( cubeBlockList );

            _lastNameRefresh = DateTime.Now;
            _name = "Cube Grid";
        }
예제 #4
0
        public static ulong GetBattlePoints(MyObjectBuilder_CubeGrid grid)
        {
            ulong pts = 0;
            foreach (var block in grid.CubeBlocks)
            {
                MyObjectBuilder_CompoundCubeBlock compoundBlock = block as MyObjectBuilder_CompoundCubeBlock;
                if (compoundBlock != null)
                {
                    foreach (var blockInCompound in compoundBlock.Blocks)
                        pts += GetBattlePoints(blockInCompound);
                }
                else
                {
                    pts += GetBattlePoints(block);
                }
            }

            return pts;
        }
        public virtual void Init(MyObjectBuilder_CubeGrid builder)
        {
	        var thrustComp = CubeGrid.Components.Get<MyEntityThrustComponent>();
			if(thrustComp != null)
				thrustComp.DampenersEnabled = builder.DampenersEnabled;

            if (WheelSystem != null)
                m_cubeGrid.SetHandbrakeRequest(builder.Handbrake);

            if (MySession.Static.Settings.EnableOxygen)
            {
                GasSystem.Init(builder.OxygenAmount);
            }

            if (MyPerGameSettings.EnableJumpDrive)
            {
                JumpSystem.Init(builder.JumpDriveDirection, builder.JumpRemainingTime);
            }

            var thrustComponent = CubeGrid.Components.Get<MyEntityThrustComponent>();
            if (thrustComponent != null)
                thrustComponent.MergeAllGroupsDirty();
        }
예제 #6
0
        public override void UpdateOnceBeforeFrame()
        {
            base.UpdateOnceBeforeFrame();

            //Only create projections from real projectors
            if (CubeGrid.Physics != null && m_savedProjection != null)
            {
                var clone = (MyObjectBuilder_CubeGrid)m_savedProjection.Clone();
                MyEntities.RemapObjectBuilder(clone);
                m_clipboard.ProcessCubeGrid(clone);

                m_clipboard.SetGridFromBuilder(clone, Vector3.Zero, 0f);
                m_originalGridBuilder = m_savedProjection;
                m_savedProjection = null;
                InitializeClipboard();
                
                //This will just issue the request
                //It will only remove it only if conditions are not met a few frames later
                RequestRemoveProjection();
            }
            UpdateEmissivity();
        }
예제 #7
0
        void OnBlueprintScreen_Closed(MyGuiScreenBase source)
        {
            ResourceSink.Update();
            UpdateIsWorking();
            if (m_clipboard.CopiedGrids.Count == 0 || !IsWorking)
            {
                RemoveProjection(false);
                return;
            }
            if (m_clipboard.GridSize != CubeGrid.GridSize)
            {
                RemoveProjection(false);
                ShowNotification(MySpaceTexts.NotificationProjectorGridSize);
                return;
            }
            if (m_clipboard.CopiedGrids.Count > 1)
            {
                ShowNotification(MySpaceTexts.NotificationProjectorMultipleGrids);
            }

            int largestGridIndex = -1;
            int largestGridBlockCount = -1;
            for (int i = 0; i < m_clipboard.CopiedGrids.Count; i++)
            {
                int currentGridBlockCount = m_clipboard.CopiedGrids[i].CubeBlocks.Count;
                if (currentGridBlockCount > largestGridBlockCount)
                {
                    largestGridBlockCount = currentGridBlockCount;
                    largestGridIndex = i;
                }
            }

            ParallelTasks.Parallel.Start(delegate()
            {
                m_originalGridBuilder = (MyObjectBuilder_CubeGrid)m_clipboard.CopiedGrids[largestGridIndex].Clone();
                m_clipboard.ProcessCubeGrid(m_clipboard.CopiedGrids[largestGridIndex]);
                MyEntities.RemapObjectBuilder(m_originalGridBuilder);
            }, 
            delegate()
            {
                SendNewBlueprint(m_originalGridBuilder);
            });
        }
 public static BoundingSphere CalculateBoundingSphere(this MyObjectBuilder_CubeGrid grid)
 {
     return(BoundingSphere.CreateFromBoundingBox(grid.CalculateBoundingBox()));
 }
예제 #9
0
        private void SetGridFromBuilderInternal(MyObjectBuilder_CubeGrid grid, Vector3 offset)
        {
            BeforeCreateGrid(grid);

            m_copiedGrids.Add(grid);
            m_copiedGridOffsets.Add(offset);
            RemovePilots(grid);
        }
예제 #10
0
        public void SetGridFromBuilder(MyObjectBuilder_CubeGrid grid, Vector3 dragPointDelta, float dragVectorLength)
        {

            m_copiedGrids.Clear();
            m_copiedGridOffsets.Clear();

            m_dragPointToPositionLocal = dragPointDelta;
            m_dragDistance = dragVectorLength;
            var transform = grid.PositionAndOrientation ?? MyPositionAndOrientation.Default;
            m_pasteDirUp = transform.Up;
            m_pasteDirForward = transform.Forward;

            SetGridFromBuilderInternal(grid, Vector3.Zero);
        }
예제 #11
0
 private void RemovePilots(MyObjectBuilder_CubeGrid grid)
 {
     foreach (var block in grid.CubeBlocks)
     {
         MyObjectBuilder_Cockpit cockpit = block as MyObjectBuilder_Cockpit;
         if (cockpit != null)
         {
             cockpit.ClearPilotAndAutopilot();
         }
         else
         {
             MyObjectBuilder_LandingGear landingGear = block as MyObjectBuilder_LandingGear;
             if (landingGear != null)
             {
                 landingGear.IsLocked = false;
                 landingGear.MasterToSlave = null;
                 landingGear.AttachedEntityId = null;
                 landingGear.LockMode = LandingGearMode.Unlocked;
             }
         }
     }
 }
        public override void GetGridSpawnMaterials(MyObjectBuilder_CubeGrid grid)
        {
            ClearRequiredMaterials();

            foreach (var block in grid.CubeBlocks)
            {
                MyComponentStack.GetMountedComponents(m_materialList, block);
                if (block.ConstructionStockpile != null)
                {
                    foreach (var item in block.ConstructionStockpile.Items)
                    {
                        if (item.PhysicalContent != null)
                        {
                            var itemId = item.PhysicalContent.GetId();
                            m_materialList.AddMaterial(itemId, item.Amount, item.Amount, addToDisplayList: false);
                        }
                    }
                }
            }
        }
예제 #13
0
 public static void BiggestGrid(this IEnumerable <MyObjectBuilder_CubeGrid> Grids, out MyObjectBuilder_CubeGrid BiggestGrid)
 {
     BiggestGrid = Grids.Aggregate((i1, i2) => i1.CubeBlocks.Count > i2.CubeBlocks.Count ? i1 : i2);
 }
예제 #14
0
        public void Update()
        {
            if (Entity == null || Entity.Closed || Entity.MarkedForClose)
            {
                return;
            }
            if (CoreMagRails.instance == null)
            {
                return;
            }
            if (!valid)
            {
                return;
            }
            if (initDirty)
            {
                initBlockSettings();
            }
            if (CoreMagRails.instance.debug != DebugLevel.Verbose)
            {
                if (updateHook)
                {
                    CoreMagRails.UpdateHook -= Update;
                    updateHook = false;
                }

                return;
            }


            if (ents.Count == 0)
            {
                int n = 30;
                while (n-- > 0)
                {
                    var prefab = MyDefinitionManager.Static.GetPrefabDefinition("HoloProjectionPrefab");
                    MyObjectBuilder_CubeGrid p_grid = prefab.CubeGrids[0];
                    MyAPIGateway.Entities.RemapObjectBuilder(p_grid);
                    p_grid.CreatePhysics = false;
                    IMyEntity grid = MyAPIGateway.Entities.CreateFromObjectBuilder(p_grid);
                    grid.Flags &= ~EntityFlags.Save;                    //do not save
                    grid.Flags &= ~EntityFlags.Sync;                    //do not sync
                    MyAPIGateway.Entities.AddEntity(grid);
                    ents.Add(grid);
                }
            }
            Vector3D home = WorldtoGrid(Entity.WorldMatrix.Translation, Entity.WorldMatrixNormalizedInv);

            home.X -= def.X;
            home.Y -= def.Y;
            home.Z -= def.Z;

            if (def.type == RailType.curve)
            {
                Vector3D baseangle = new Vector3D(0, 0, 1);

                foreach (var ent in ents)
                {
                    int index = ents.IndexOf(ent);

                    //MyAPIGateway.Utilities.ShowMessage("Test", Entity.WorldMatrix.Translation.ToString());
                    //MyAPIGateway.Utilities.ShowMessage("TestD", (Entity.WorldMatrix.Translation + Vector3D.Multiply(Entity.WorldMatrix.Down, 3)).ToString());
                    //going to use X and Z
                    double d_angle = ((double)index / 30) / 2;
                    d_angle += 0.5d;
                    if (def.X > 0)
                    {
                        d_angle += 0.5d;
                    }
                    d_angle *= Math.PI;
                    double s            = Math.Sin(d_angle);
                    double c            = Math.Cos(d_angle);
                    var    angle        = new Vector3D(-baseangle.Z * s, 0, baseangle.Z * c);          //note that for the rail part this will be easier...
                    var    radianvector = angle * def.radius;
                    radianvector += home;
                    ent.SetPosition(GridToWorld(radianvector, Entity.WorldMatrix));
                }
            }
            else if (def.type == RailType.straight)
            {
                home.Z -= def.size.Z * 0.5d * def.sizeenum;
                foreach (var ent in ents)
                {
                    double index = ents.IndexOf(ent);
                    var    lerp  = Vector3.Lerp(home, new Vector3(home.X, home.Y, def.size.Z * 0.5d * def.sizeenum), (float)(index / 30.0d));
                    //var newpos = home + new Vector3D(0,  0, (index - 15d) / 5);
                    ent.SetPosition(GridToWorld(lerp, Entity.WorldMatrix));
                }
            }
            else if (def.type == RailType.slant)
            {
                home.Z -= def.size.Z * 0.5d * def.sizeenum;
                //Log.DebugWrite( DebugLevel.Info, "Drawing line");
                //Log.DebugWrite(DebugLevel.Info, home);
                foreach (var ent in ents)
                {
                    double index = ents.IndexOf(ent);
                    var    lerp  = Vector3.Lerp(home, new Vector3(home.X, -def.min.Y, def.size.Z * 0.5d * def.sizeenum), (float)(index / 30.0d));
                    //var newpos = new Vector3D(home.X, ( home.Y + (def.min.Y - home.Y) * (((index - 15d) / 5) / def.size.Z)), home.Z + ((index - 15d) / 5));

                    //Log.DebugWrite(DebugLevel.Info, lerp);
                    ent.SetPosition(GridToWorld(lerp, Entity.WorldMatrix));
                }
            }
            else if (def.type == RailType.cross)
            {
                var ftb = new Vector3D(home);
                ftb.Z -= def.size.Z * 0.5d * def.sizeenum;
                var ltr = new Vector3D(home);
                ltr.X -= def.size.X * 0.5d * def.sizeenum;
                foreach (var ent in ents)
                {
                    double   index = ents.IndexOf(ent);
                    Vector3D lerp;
                    if (index % 2 == 0)
                    {
                        lerp = Vector3D.Lerp(ftb, new Vector3D(ftb.X, ftb.Y, def.size.Z * 0.5d * def.sizeenum), (float)(index / 30.0d));
                    }
                    else
                    {
                        lerp = Vector3D.Lerp(ltr, new Vector3D(def.size.X * 0.5d * def.sizeenum, ltr.Y, ltr.Z), (float)(index / 30.0d));
                    }
                    ent.SetPosition(GridToWorld(lerp, Entity.WorldMatrix));
                }
            }



            //DOSTUFF
        }
예제 #15
0
        public override bool HandleCommand(ulong userId, string[] words)
        {
            bool force = false;

            if (words.FirstOrDefault(x => x.ToLower() == "force") != null)
            {
                force = true;
            }

            HashSet <IMyEntity> entities = new HashSet <IMyEntity>();

            Wrapper.GameAction(() =>
            {
                MyAPIGateway.Entities.GetEntities(entities);
            });

            List <MyObjectBuilder_EntityBase> addList = new List <MyObjectBuilder_EntityBase>();
            int count = 0;

            Wrapper.GameAction(() =>
            {
                foreach (IMyEntity entity in entities)
                {
                    if (entity.InScene)
                    {
                        continue;
                    }

                    if (!(entity is IMyCubeGrid))
                    {
                        continue;
                    }

                    MyObjectBuilder_CubeGrid builder = CubeGrids.SafeGetObjectBuilder((IMyCubeGrid)entity);
                    if (builder == null)
                    {
                        continue;
                    }

                    count++;
                    if (!force)
                    {
                        continue;
                    }

                    IMyCubeGrid grid = (IMyCubeGrid)entity;
                    long ownerId     = 0;
                    string ownerName = "";
                    if (grid.BigOwners.Count > 0)
                    {
                        ownerId   = grid.BigOwners.First();
                        ownerName = PlayerMap.Instance.GetPlayerItemFromPlayerId(ownerId).Name;
                    }

                    grid.PersistentFlags    = (MyPersistentEntityFlags2.InScene | MyPersistentEntityFlags2.CastShadows);
                    grid.InScene            = true;
                    grid.CastShadows        = true;
                    builder.PersistentFlags = (MyPersistentEntityFlags2.InScene | MyPersistentEntityFlags2.CastShadows);
                    MyAPIGateway.Entities.RemapObjectBuilder(builder);
                    Logging.WriteLineAndConsole("Conceal", string.Format("Force Revealing - Id: {0} -> {4} Display: {1} OwnerId: {2} OwnerName: {3}", entity.EntityId, entity.DisplayName.Replace("\r", "").Replace("\n", ""), ownerId, ownerName, builder.EntityId));

                    /*
                     * entity.InScene = true;
                     * entity.CastShadows = true;
                     * entity.Visible = true;
                     */

                    //CubeGridEntity newEntity = new CubeGridEntity(builder);
                    //SectorObjectManager.Instance.AddEntity(newEntity);

                    BaseEntityNetworkManager.BroadcastRemoveEntity(entity);
                    MyAPIGateway.Entities.CreateFromObjectBuilderAndAdd(builder);
                    addList.Add(builder);
                    MyAPIGateway.Multiplayer.SendEntitiesCreated(addList);
                    addList.Clear();
                }
            });

            if (!force)
            {
                Logging.WriteLineAndConsole(string.Format("Command would Reveal {0} grids.  Type /admin reveal force to reveal them.", count));
            }
            else
            {
                Logging.WriteLineAndConsole(string.Format("Command Revealed {0} grids", count));
            }

            return(true);
        }
예제 #16
0
 public virtual void BeforeBlockDeserialization(MyObjectBuilder_CubeGrid builder)
 {
     ConveyorSystem.BeforeBlockDeserialization(builder.ConveyorLines);
 }
예제 #17
0
        private void MergeData(MyObjectBuilder_CubeGrid cubeGridObject, ref Dictionary <Int64, Int64> idReplacementTable)
        {
            if (cubeGridObject == null)
            {
                return;
            }

            cubeGridObject.EntityId = MergeId(cubeGridObject.EntityId, ref idReplacementTable);

            foreach (var cubeGrid in cubeGridObject.CubeBlocks)
            {
                cubeGrid.EntityId = MergeId(cubeGrid.EntityId, ref idReplacementTable);
                //cubeGrid.MultiBlockId // ???

                var cockpit = cubeGrid as MyObjectBuilder_Cockpit;
                if (cockpit != null)
                {
                    cockpit.RemoveHierarchyCharacter(cockpit.Pilot);
                    cockpit.Pilot = null;  // remove any pilots.
                }

                var motorBase = cubeGrid as MyObjectBuilder_MotorBase;
                if (motorBase != null && motorBase.RotorEntityId.HasValue)
                {
                    // reattach motor/rotor to correct entity.
                    motorBase.RotorEntityId = MergeId(motorBase.RotorEntityId.Value, ref idReplacementTable);
                }

                var pistonBase = cubeGrid as MyObjectBuilder_PistonBase;
                if (pistonBase != null && pistonBase.TopBlockId.HasValue)
                {
                    // reattach PistonBase (and ExtendedPistonBase) to correct entity.
                    pistonBase.TopBlockId = MergeId(pistonBase.TopBlockId.Value, ref idReplacementTable);
                }

                var shipConnector = cubeGrid as MyObjectBuilder_ShipConnector;
                if (shipConnector != null)
                {
                    // reattach ShipConnector to correct entity.
                    shipConnector.ConnectedEntityId = MergeId(shipConnector.ConnectedEntityId, ref idReplacementTable);
                }

                var buttonPanel = cubeGrid as MyObjectBuilder_ButtonPanel;
                if (buttonPanel != null)
                {
                    // reattach Button Panels to correct entity.
                    RenumberToolbar(buttonPanel.Toolbar, ref idReplacementTable);
                }

                var timerBlock = cubeGrid as MyObjectBuilder_TimerBlock;
                if (timerBlock != null)
                {
                    // reattach Timer actions to correct entity.
                    RenumberToolbar(timerBlock.Toolbar, ref idReplacementTable);
                }

                var sensorBlock = cubeGrid as MyObjectBuilder_SensorBlock;
                if (sensorBlock != null)
                {
                    // reattach Sensor actions to correct entity.
                    RenumberToolbar(sensorBlock.Toolbar, ref idReplacementTable);
                }

                var shipController = cubeGrid as MyObjectBuilder_ShipController;
                if (shipController != null)
                {
                    // reattach Ship Controller actions to correct entity.
                    RenumberToolbar(shipController.Toolbar, ref idReplacementTable);
                }
            }

            AddEntity(cubeGridObject);
        }
예제 #18
0
 static void OnThrowMessageSuccess(MyObjectBuilder_CubeGrid grid, Vector3D position, Vector3D linearVelocity, float mass, MyCueId throwSound)
 {
     MySessionComponentThrower.Static.Throw(grid, position, linearVelocity, mass, throwSound);
 }
예제 #19
0
 public virtual void BeforeBlockDeserialization(MyObjectBuilder_CubeGrid builder)
 {
     ConveyorSystem.BeforeBlockDeserialization(builder.ConveyorLines);
 }
        public void SpawnCargoShipGroup(Vector3 startPosition, Vector3 stopPosition, ulong remoteUserId = 0)
        {
            try
            {
                //Calculate lowest and highest frequencies
                float lowestFrequency  = 999999;
                float highestFrequency = 0;
                foreach (MySpawnGroupDefinition entry in MyDefinitionManager.Static.GetSpawnGroupDefinitions())
                {
                    if (entry.Frequency < lowestFrequency)
                    {
                        lowestFrequency = entry.Frequency;
                    }
                    if (entry.Frequency > highestFrequency)
                    {
                        highestFrequency = entry.Frequency;
                    }
                }
                if (lowestFrequency <= 0)
                {
                    lowestFrequency = 1;
                }

                //Get a list of which groups *could* spawn
                Random random       = new Random((int)DateTime.Now.ToBinary());
                double randomChance = random.NextDouble();
                randomChance = randomChance * (highestFrequency / lowestFrequency);
                List <MySpawnGroupDefinition> possibleGroups = new List <MySpawnGroupDefinition>();
                foreach (MySpawnGroupDefinition entry in MyDefinitionManager.Static.GetSpawnGroupDefinitions())
                {
                    if (entry.Frequency >= randomChance)
                    {
                        possibleGroups.Add(entry);
                    }
                }

                //Determine which group *will* spawn
                randomChance = random.NextDouble();
                int randomShipIndex = Math.Max(0, Math.Min((int)Math.Round(randomChance * possibleGroups.Count, 0), possibleGroups.Count - 1));
                MySpawnGroupDefinition randomSpawnGroup = possibleGroups[randomShipIndex];

                ChatManager.Instance.SendPrivateChatMessage(remoteUserId, "Spawning cargo group '" + randomSpawnGroup.DisplayNameText.ToString() + "' ...");

                //Spawn the ships in the group
                Matrix orientation = Matrix.CreateLookAt(startPosition, stopPosition, new Vector3(0, 1, 0));
                foreach (MySpawnGroupDefinition.SpawnGroupPrefab entry in randomSpawnGroup.Prefabs)
                {
                    MyPrefabDefinition matchedPrefab = null;
                    foreach (var prefabEntry in MyDefinitionManager.Static.GetPrefabDefinitions())
                    {
                        MyPrefabDefinition prefabDefinition = prefabEntry.Value;
                        if (prefabDefinition.Id.SubtypeId.ToString() == entry.SubtypeId)
                        {
                            matchedPrefab = prefabDefinition;
                            break;
                        }
                    }
                    if (matchedPrefab == null)
                    {
                        continue;
                    }

                    //TODO - Build this to iterate through all cube grids in the prefab
                    MyObjectBuilder_CubeGrid objectBuilder = matchedPrefab.CubeGrids[0];

                    //Create the ship
                    CubeGridEntity cubeGrid = new CubeGridEntity(objectBuilder);

                    //Set the ship position and orientation
                    Vector3 shipPosition = Vector3.Transform(entry.Position, orientation) + startPosition;
                    orientation.Translation = shipPosition;
                    MyPositionAndOrientation newPositionOrientation = new MyPositionAndOrientation(orientation);
                    cubeGrid.PositionAndOrientation = newPositionOrientation;

                    //Set the ship velocity
                    //Speed is clamped between 1.0f and the max cube grid speed
                    Vector3 travelVector = stopPosition - startPosition;
                    travelVector.Normalize();
                    Vector3 shipVelocity = travelVector * (float)Math.Min(cubeGrid.MaxLinearVelocity, Math.Max(1.0f, entry.Speed));
                    cubeGrid.LinearVelocity = shipVelocity;

                    cubeGrid.IsDampenersEnabled = false;

                    foreach (MyObjectBuilder_CubeBlock cubeBlock in cubeGrid.BaseCubeBlocks)
                    {
                        //Set the beacon names
                        if (cubeBlock.TypeId == typeof(MyObjectBuilder_Beacon))
                        {
                            MyObjectBuilder_Beacon beacon = (MyObjectBuilder_Beacon)cubeBlock;
                            beacon.CustomName = entry.BeaconText;
                        }

                        //Set the owner of every block
                        //TODO - Find out if setting to an arbitrary non-zero works for this
                        // TODO Fix the rest of the player manager methods
                        //cubeBlock.Owner = PlayerMap.Instance.GetServerVirtualPlayerId();
                        cubeBlock.ShareMode = MyOwnershipShareModeEnum.Faction;
                    }

                    //And add the ship to the world
                    SectorObjectManager.Instance.AddEntity(cubeGrid);
                }

                ChatManager.Instance.SendPrivateChatMessage(remoteUserId, "Cargo group '" + randomSpawnGroup.DisplayNameText.ToString() + "' spawned with " + randomSpawnGroup.Prefabs.Count.ToString() + " ships at " + startPosition.ToString());
            }
            catch (Exception ex)
            {
                LogManager.ErrorLog.WriteLine(ex);
            }
        }
예제 #21
0
        public MyObjectBuilder_CubeGrid BuildTestEntity()
        {
            var entity = new MyObjectBuilder_CubeGrid
            {
                EntityId        = SpaceEngineersApi.GenerateEntityId(IDType.ENTITY),
                PersistentFlags = MyPersistentEntityFlags2.CastShadows | MyPersistentEntityFlags2.InScene,
                Skeleton        = new System.Collections.Generic.List <BoneInfo>(),
                LinearVelocity  = new VRageMath.Vector3(0, 0, 0),
                AngularVelocity = new VRageMath.Vector3(0, 0, 0),
                GridSizeEnum    = MyCubeSize.Large
            };

            var blockPrefix       = entity.GridSizeEnum.ToString();
            var cornerBlockPrefix = entity.GridSizeEnum.ToString();

            entity.IsStatic    = false;
            blockPrefix       += "BlockArmor"; // HeavyBlockArmor|BlockArmor;
            cornerBlockPrefix += "BlockArmor"; // HeavyBlockArmor|BlockArmor|RoundArmor_;

            // Figure out where the Character is facing, and plant the new constrcut right in front, by "10" units, facing the Character.
            var vector = new BindableVector3DModel(_dataModel.CharacterPosition.Forward).Vector3D;

            vector.Normalize();
            vector   = Vector3D.Multiply(vector, 6);
            Position = new BindablePoint3DModel(Point3D.Add(new BindablePoint3DModel(_dataModel.CharacterPosition.Position).Point3D, vector));
            Forward  = new BindableVector3DModel(_dataModel.CharacterPosition.Forward);
            Up       = new BindableVector3DModel(_dataModel.CharacterPosition.Up);

            entity.PositionAndOrientation = new MyPositionAndOrientation
            {
                Position = Position.ToVector3D(),
                Forward  = Forward.ToVector3(),
                Up       = Up.ToVector3()
            };

            // Large|BlockArmor|Corner
            // Large|RoundArmor_|Corner
            // Large|HeavyBlockArmor|Block,
            // Small|BlockArmor|Slope,
            // Small|HeavyBlockArmor|Corner,

            var blockType              = (SubtypeId)Enum.Parse(typeof(SubtypeId), blockPrefix + "Block");
            var slopeBlockType         = (SubtypeId)Enum.Parse(typeof(SubtypeId), cornerBlockPrefix + "Slope");
            var cornerBlockType        = (SubtypeId)Enum.Parse(typeof(SubtypeId), cornerBlockPrefix + "Corner");
            var inverseCornerBlockType = (SubtypeId)Enum.Parse(typeof(SubtypeId), cornerBlockPrefix + "CornerInv");

            entity.CubeBlocks = new System.Collections.Generic.List <MyObjectBuilder_CubeBlock>();

            //var smoothObject = true;

            // Read in voxel and set main cube space.
            //var ccubic = TestCreateSplayedDiagonalPlane();
            //var ccubic = TestCreateSlopedDiagonalPlane();
            //var ccubic = TestCreateStaggeredStar();
            var ccubic = Modelling.TestCreateTrayShape();
            //var ccubic = ReadModelVolmetic(@"..\..\..\..\..\..\building 3D\models\Rhino_corrected.obj", 10, null, ModelTraceVoxel.ThickSmoothedDown);

            var fillObject = false;

            //if (smoothObject)
            //{
            //    CalculateAddedInverseCorners(ccubic);
            //    CalculateAddedSlopes(ccubic);
            //    CalculateAddedCorners(ccubic);
            //}

            Modelling.BuildStructureFromCubic(entity, ccubic, fillObject, blockType, slopeBlockType, cornerBlockType, inverseCornerBlockType);

            return(entity);
        }
예제 #22
0
 public static void CalculateItemRequirements(MyObjectBuilder_CubeGrid[] blocksToBuild, MyComponentList buildComponents)
 {
     buildComponents.Clear();
     foreach (var grid in blocksToBuild)
     {
         foreach (var block in grid.CubeBlocks)
         {
             var compound = block as MyObjectBuilder_CompoundCubeBlock;
             if (compound != null)
             {
                 foreach (var subblock in compound.Blocks)
                 {
                     AddSingleBlockRequirements(subblock, buildComponents);
                 }
             }
             else
             {
                 AddSingleBlockRequirements(block, buildComponents);
             }
         }
     }
 }
        public static void PlacePrefabToWorld(MyObjectBuilder_CubeGrid[] currentPrefab, Vector3D position, List<MyCubeGrid> createdGrids = null)
        {        
            Vector3D newPosition = Vector3D.Zero;
            Vector3D positionOffset = Vector3D.Zero;
            bool firstIteration = true;
            MyEntities.RemapObjectBuilderCollection(currentPrefab);
            foreach (var gridBuilder in currentPrefab)
            {
                if (gridBuilder.PositionAndOrientation.HasValue)
                {
                    if (firstIteration)
                    {
                        positionOffset = position - gridBuilder.PositionAndOrientation.Value.Position;
                        firstIteration = false;
                        newPosition = position;
                    }
                    else
                    {
                        newPosition = gridBuilder.PositionAndOrientation.Value.Position + positionOffset;
                    }
                }

                MyPositionAndOrientation originalPos = gridBuilder.PositionAndOrientation.Value;
                originalPos.Position = newPosition;
                gridBuilder.PositionAndOrientation = originalPos; 

                MyCubeGrid currentGrid = MyEntities.CreateFromObjectBuilder(gridBuilder) as MyCubeGrid;

                if (currentGrid != null)
                {                
                    currentGrid.ClearSymmetries();
                    currentGrid.Physics.LinearVelocity = Vector3D.Zero;
                    currentGrid.Physics.AngularVelocity = Vector3D.Zero;
                    if (createdGrids != null)
                    {
                        createdGrids.Add(currentGrid);
                    }
                    MyEntities.Add(currentGrid, true);
                }
            }  
        }
예제 #24
0
        public MyCubeBlockDefinition GetFirstBlockDefinition(MyObjectBuilder_CubeGrid grid = null)
        {
            if (grid == null)
                if (m_copiedGrids.Count > 0)
                    grid = m_copiedGrids[0];
                else
                    return null;

            if (grid.CubeBlocks.Count > 0)
            {
                MyDefinitionId firstBlock = grid.CubeBlocks[0].GetId();
                return MyDefinitionManager.Static.GetCubeBlockDefinition(firstBlock);
            }
            return null;
        }
예제 #25
0
        internal void SetNewBlueprint(MyObjectBuilder_CubeGrid gridBuilder)
        {
            m_originalGridBuilder = gridBuilder;

            var clone = m_originalGridBuilder;//(MyObjectBuilder_CubeGrid)gridBuilder.Clone();

            //MyEntities.RemapObjectBuilder(clone);
            //m_clipboard.ProcessCubeGrid(clone);

            m_clipboard.SetGridFromBuilder(clone, Vector3.Zero, 0f);

            if (m_instantBuildingEnabled)
            {
                ResetRotation();
                var boundingBox = clone.CalculateBoundingBox();
                // Add 1 to get the center out of the bounds and another 1 for a gap
                m_projectionOffset.Y = Math.Abs((int)(boundingBox.Min.Y / MyDefinitionManager.Static.GetCubeSize(clone.GridSizeEnum))) + 2;
            }

            InitializeClipboard();
        }
예제 #26
0
        public void SetGridFromBuilders(MyObjectBuilder_CubeGrid[] grids, Vector3 dragPointDelta, float dragVectorLength)
        {
            ShowModdedBlocksWarning = true;
            if (IsActive)
            {
                Deactivate();
            }

            m_copiedGrids.Clear();
            m_copiedGridOffsets.Clear();

            if (grids.Length == 0) return;

            MatrixD pasteMatrix = GetPasteMatrix();
            m_dragPointToPositionLocal = dragPointDelta;
            m_dragDistance = dragVectorLength;
            var transform = grids[0].PositionAndOrientation ?? MyPositionAndOrientation.Default;
            m_pasteDirUp = transform.Up;
            m_pasteDirForward = transform.Forward;

            SetGridFromBuilderInternal(grids[0], Vector3.Zero);

            MatrixD invMatrix = grids[0].PositionAndOrientation.HasValue ? grids[0].PositionAndOrientation.Value.GetMatrix() : MatrixD.Identity;
            invMatrix = MatrixD.Invert(invMatrix);
            for (int i = 1; i < grids.Length; ++i)
            {
                Vector3D offset = grids[i].PositionAndOrientation.HasValue ? (Vector3D)grids[i].PositionAndOrientation.Value.Position : Vector3D.Zero;
                offset = Vector3D.Transform(offset, invMatrix);
                SetGridFromBuilderInternal(grids[i], offset);
            }

            //Activate();
        }
예제 #27
0
 private void OnNewBlueprintSuccess(MyObjectBuilder_CubeGrid projectedGrid)
 {
     if (MyEventContext.Current.IsLocallyInvoked == false)
     {
         SetNewBlueprint(projectedGrid);
     }
 }
예제 #28
0
        protected void BeforeCreateGrid(MyObjectBuilder_CubeGrid grid)
        {
            Debug.Assert(grid.CubeBlocks.Count > 0, "The grid does not contain any blocks");

            foreach (var block in grid.CubeBlocks)
            {
                var defId = block.GetId();
                MyCubeBlockDefinition blockDef = null;
                MyDefinitionManager.Static.TryGetCubeBlockDefinition(defId, out blockDef);
                if (blockDef == null) continue;

                MyCubeBuilder.BuildComponent.BeforeCreateBlock(blockDef, GetClipboardBuilder(), block, buildAsAdmin: MySession.Static.IsAdminModeEnabled(Sync.MyId));
            }
        }
예제 #29
0
        private MyObjectBuilder_CubeGrid BuildShipEntity()
        {
            var entity = new MyObjectBuilder_CubeGrid
            {
                EntityId        = SpaceEngineersApi.GenerateEntityId(IDType.ENTITY),
                PersistentFlags = MyPersistentEntityFlags2.CastShadows | MyPersistentEntityFlags2.InScene,
                Skeleton        = new System.Collections.Generic.List <BoneInfo>(),
                LinearVelocity  = new VRageMath.Vector3(0, 0, 0),
                AngularVelocity = new VRageMath.Vector3(0, 0, 0)
            };

            var blockPrefix = "";

            switch (ClassType)
            {
            case ImportModelClassType.SmallShip:
                entity.GridSizeEnum = MyCubeSize.Small;
                blockPrefix        += "Small";
                entity.IsStatic     = false;
                break;

            case ImportModelClassType.LargeShip:
                entity.GridSizeEnum = MyCubeSize.Large;
                blockPrefix        += "Large";
                entity.IsStatic     = false;
                break;

            case ImportModelClassType.Station:
                entity.GridSizeEnum = MyCubeSize.Large;
                blockPrefix        += "Large";
                entity.IsStatic     = true;
                Position            = Position.RoundOff(MyCubeSize.Large.ToLength());
                Forward             = Forward.RoundToAxis();
                Up = Up.RoundToAxis();
                break;
            }

            switch (ArmorType)
            {
            case ImportArmorType.Heavy: blockPrefix += "HeavyBlockArmor"; break;

            case ImportArmorType.Light: blockPrefix += "BlockArmor"; break;

                // TODO: Rounded Armor.
                // Currently in development, and only specified as 'Light' on the 'Large' structures.
                //case ImportArmorType.Round: blockPrefix += "RoundArmor_"; break;
            }

            // Large|BlockArmor|Corner
            // Large|RoundArmor_|Corner
            // Large|HeavyBlockArmor|Block,
            // Small|BlockArmor|Slope,
            // Small|HeavyBlockArmor|Corner,

            var blockType              = (SubtypeId)Enum.Parse(typeof(SubtypeId), blockPrefix + "Block");
            var slopeBlockType         = (SubtypeId)Enum.Parse(typeof(SubtypeId), blockPrefix + "Slope");
            var cornerBlockType        = (SubtypeId)Enum.Parse(typeof(SubtypeId), blockPrefix + "Corner");
            var inverseCornerBlockType = (SubtypeId)Enum.Parse(typeof(SubtypeId), blockPrefix + "CornerInv");

            entity.CubeBlocks = new System.Collections.Generic.List <MyObjectBuilder_CubeBlock>();

            double multiplier;

            if (IsMultipleScale)
            {
                multiplier = MultipleScale;
            }
            else
            {
                multiplier = MaxLengthScale / Math.Max(Math.Max(OriginalModelSize.Height, OriginalModelSize.Width), OriginalModelSize.Depth);
            }

            var ccubic = Modelling.ReadModelVolmetic(Filename, multiplier, null, TraceType, MainViewModel.ResetProgress, MainViewModel.IncrementProgress);

            Modelling.BuildStructureFromCubic(entity, ccubic, FillObject, blockType, slopeBlockType, cornerBlockType, inverseCornerBlockType);

            MainViewModel.ClearProgress();

            entity.PositionAndOrientation = new MyPositionAndOrientation
            {
                // TODO: reposition based scale.
                Position = Position.ToVector3D(),
                Forward  = Forward.ToVector3(),
                Up       = Up.ToVector3()
            };

            IsValidModel = entity.CubeBlocks.Count > 0;

            return(entity);
        }
 private static BoundingSphere GetBoundingSphereForGrids(MyObjectBuilder_CubeGrid[] currentPrefab)
 {
     BoundingSphere boundingSphere = new BoundingSphere(Vector3.Zero, float.MinValue);
     foreach (var gridBuilder in currentPrefab)
     {
         BoundingSphere localSphere = gridBuilder.CalculateBoundingSphere();
         MatrixD gridTransform = gridBuilder.PositionAndOrientation.HasValue ? gridBuilder.PositionAndOrientation.Value.GetMatrix() : MatrixD.Identity;
         boundingSphere.Include(localSphere.Transform(gridTransform));
     }
     return boundingSphere;
 }
예제 #31
0
		// might not work? -- updated, needs testing
		public static List<long> GetBigOwners( MyObjectBuilder_CubeGrid grid )
		{
			Dictionary<long, int> ownerList = new Dictionary<long, int>( );
			foreach ( MyObjectBuilder_CubeBlock block in grid.CubeBlocks )
			{
				if ( block.Owner == 0 )
					continue;

				if ( ownerList.ContainsKey( block.Owner ) )
					ownerList[ block.Owner ] = ownerList[ block.Owner ] + 1;
				else
					ownerList.Add( block.Owner, 1 );
			}

			int count = ownerList.OrderBy( x => x.Value ).Select( x => x.Value ).FirstOrDefault( );
			return ownerList.OrderBy( x => x.Value ).Where( x => x.Value == count ).Select( x => x.Key ).ToList( );
		}
예제 #32
0
 private void SendNewBlueprint(MyObjectBuilder_CubeGrid projectedGrid)
 {
     SetNewBlueprint(projectedGrid);
     MyMultiplayer.RaiseEvent(this, x => x.OnNewBlueprintSuccess, projectedGrid);
 }
예제 #33
0
		public static List<long> GetAllOwners( MyObjectBuilder_CubeGrid grid )
		{
			Dictionary<long, int> ownerList = new Dictionary<long, int>( );
			foreach ( MyObjectBuilder_CubeBlock block in grid.CubeBlocks )
			{
				if ( block.Owner == 0 )
					continue;

				if ( ownerList.ContainsKey( block.Owner ) )
					ownerList[ block.Owner ] = ownerList[ block.Owner ] + 1;
				else
					ownerList.Add( block.Owner, 1 );
			}

			return ownerList.Select( x => x.Key ).ToList( );
		}
예제 #34
0
        private void RemoveProjection(bool keepProjection)
        {
            m_hiddenBlock = null;
            m_clipboard.Deactivate();
            if (!keepProjection)
            {
                m_clipboard.Clear();
                m_originalGridBuilder = null;
            }

            UpdateEmissivity();
            m_statsDirty = true;
            UpdateText();

            //We call this to disable the controls
            RaisePropertiesChanged();
        }
예제 #35
0
		public static bool HasCustomName( MyObjectBuilder_CubeGrid grid, string name, bool exact )
		{
			foreach ( MyObjectBuilder_CubeBlock block in grid.CubeBlocks )
			{
				MyObjectBuilder_TerminalBlock termBlock = block as MyObjectBuilder_TerminalBlock;
				if ( termBlock != null )
				{
					if ( exact )
					{
						if ( termBlock.CustomName != null && termBlock.CustomName == name )
						{
							return true;
						}
					}
					else
					{
						if ( termBlock.CustomName != null && termBlock.CustomName.Contains( name ) )
						{
							return true;
						}
					}
				}
			}

			return false;
		}
예제 #36
0
        public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
        {
            var sinkComp = new MyResourceSinkComponent();
            sinkComp.Init(
                BlockDefinition.ResourceSinkGroup,
                BlockDefinition.RequiredPowerInput,
                CalculateRequiredPowerInput);
           
            ResourceSink = sinkComp;

            base.Init(objectBuilder, cubeGrid);
            if (!MyFakes.ENABLE_PROJECTOR_BLOCK)
            {
                return;
            }

            var projectorBuilder = (MyObjectBuilder_ProjectorBase)objectBuilder;
            if (projectorBuilder.ProjectedGrid != null)
            {
                m_projectionOffset = projectorBuilder.ProjectionOffset;
                m_projectionRotation = projectorBuilder.ProjectionRotation;

                m_savedProjection = projectorBuilder.ProjectedGrid;
                KeepProjection = projectorBuilder.KeepProjection;
            }

            m_showOnlyBuildable = projectorBuilder.ShowOnlyBuildable;
            InstantBuildingEnabled = projectorBuilder.InstantBuildingEnabled;
            MaxNumberOfProjections = projectorBuilder.MaxNumberOfProjections;
            MaxNumberOfBlocksPerProjection = projectorBuilder.MaxNumberOfBlocks;
            GetOwnershipFromProjector = projectorBuilder.GetOwnershipFromProjector;

            m_projectionsRemaining = MathHelper.Clamp(projectorBuilder.ProjectionsRemaining, 0, m_maxNumberOfProjections);

			
            IsWorkingChanged += MyProjector_IsWorkingChanged;
            sinkComp.IsPoweredChanged += PowerReceiver_IsPoweredChanged;
			ResourceSink.Update();
            m_statsDirty = true;
            UpdateText();

            NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME | MyEntityUpdateEnum.EACH_100TH_FRAME;

            SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;

            CubeGrid.OnBlockAdded += previewGrid_OnBlockAdded;
            CubeGrid.OnBlockRemoved += previewGrid_OnBlockRemoved;
        
            CubeGrid.OnGridSplit += CubeGrid_OnGridSplit;
        }
예제 #37
0
		public static bool HasOwner( MyObjectBuilder_CubeGrid grid )
		{
			foreach ( MyObjectBuilder_CubeBlock block in grid.CubeBlocks )
			{
				if ( !( block is MyObjectBuilder_TerminalBlock ) )
					continue;

				MyObjectBuilder_TerminalBlock functional = (MyObjectBuilder_TerminalBlock)block;
				if ( functional.Owner != 0 )
					return true;
			}

			return false;
		}
예제 #38
0
 public abstract void GetGridSpawnMaterials(MyObjectBuilder_CubeGrid grid);
예제 #39
0
		public static bool DoesGridHavePowerSupply( MyObjectBuilder_CubeGrid grid )
		{
			return grid.CubeBlocks.Any( DoesBlockSupplyPower );
		}
예제 #40
0
        public virtual void GetObjectBuilder(MyObjectBuilder_CubeGrid ob)
        {
	        var thrustComp = CubeGrid.Components.Get<MyEntityThrustComponent>();
	        ob.DampenersEnabled = thrustComp == null || thrustComp.DampenersEnabled;

            ConveyorSystem.SerializeLines(ob.ConveyorLines);
            if (ob.ConveyorLines.Count == 0)
                ob.ConveyorLines = null;

            if (WheelSystem != null)
                ob.Handbrake = WheelSystem.HandBrake;

            if (MySession.Static.Settings.EnableOxygen)
            {
                ob.OxygenAmount = GasSystem.GetOxygenAmount();
            }

            if (MyPerGameSettings.EnableJumpDrive)
            {
                ob.JumpDriveDirection = JumpSystem.GetJumpDriveDirection();
                ob.JumpRemainingTime = JumpSystem.GetRemainingJumpTime();
            }
        }
예제 #41
0
        public override void Remap(MyObjectBuilder_CubeGrid grid)
        {
            var transformCopy = LocalTransform;

            var minToMin = new Dictionary <Vector3I, Vector3I>(grid.CubeBlocks.Count * 3 / 2);

            foreach (var x in grid.CubeBlocks)
            {
                var      orig = (Vector3I)x.Min;
                var      cMin = orig;
                Vector3I cMax;
                BlockTransformations.ComputeBlockMax(x, out cMax);
                x.BlockOrientation.Forward = LocalTransform.GetDirection(x.BlockOrientation.Forward);
                x.BlockOrientation.Up      = LocalTransform.GetDirection(x.BlockOrientation.Up);
                Vector3I.Transform(ref cMin, ref transformCopy, out cMin);
                Vector3I.Transform(ref cMax, ref transformCopy, out cMax);
                minToMin[orig] = x.Min = Vector3I.Min(cMin, cMax);

                var proj = x as MyObjectBuilder_ProjectorBase;
                // Don't have to update the rotation; it is bound to the world matrix of the projector.
                if (proj != null)
                {
                    Vector3I.TransformNormal(ref proj.ProjectionOffset, ref transformCopy, out proj.ProjectionOffset);
                }
            }

            if (grid.BlockGroups != null)
            {
                foreach (var g in grid.BlockGroups)
                {
                    for (var i = 0; i < g.Blocks.Count; i++)
                    {
                        Vector3I tmpOut;
                        if (minToMin.TryGetValue(g.Blocks[i], out tmpOut))
                        {
                            g.Blocks[i] = tmpOut;
                        }
                        else
                        {
                            g.Blocks[i] = Vector3I.MaxValue; // sorta discards it?
                        }
                    }
                }
            }

            if (grid.ConveyorLines != null)
            {
                foreach (var l in grid.ConveyorLines)
                {
                    l.StartDirection = LocalTransform.GetDirection(l.StartDirection);
                    l.StartPosition  = Vector3I.Transform(l.StartPosition, ref transformCopy);

                    l.EndDirection = LocalTransform.GetDirection(l.EndDirection);
                    l.EndPosition  = Vector3I.Transform(l.EndPosition, ref transformCopy);

                    if (l.Sections == null)
                    {
                        continue;
                    }
                    for (var s = 0; s < l.Sections.Count; s++)
                    {
                        l.Sections[s] = new SerializableLineSectionInformation()
                        {
                            Direction = LocalTransform.GetDirection(l.Sections[s].Direction), Length = l.Sections[s].Length
                        }
                    }
                    ;
                }
            }
        }