C# Entity.MyEntity类代码示例

 protected void SerializeActive(BitStream stream, MyEntity entity)
 {
     if (stream.Writing)
     {
         if (entity.Physics.RigidBody != null && entity.Physics.RigidBody.IsActive)
             stream.WriteBool(true);
         else
             stream.WriteBool(false);
     }
     else
     {
         // reading
         bool isActive = stream.ReadBool();
         if (entity != null && entity.Physics != null)
         {
             HkRigidBody rb = entity.Physics.RigidBody;
             if (rb != null)
             {
                 if (isActive)
                     rb.Activate();
                 else
                     rb.Deactivate();
             }
         }
     }
 }

        public static MyEntity Spawn(this MyPhysicalInventoryItem thisItem, MyFixedPoint amount, BoundingBoxD box, MyEntity owner = null)
        {
            if(amount < 0)
            {
                return null;
            }

            MatrixD spawnMatrix = MatrixD.Identity;
            spawnMatrix.Translation = box.Center;
            var entity = Spawn(thisItem, amount, spawnMatrix, owner);
            if (entity == null)
                return null;
            var size = entity.PositionComp.LocalVolume.Radius;
            var halfSize = box.Size / 2 - new Vector3(size);
            halfSize = Vector3.Max(halfSize, Vector3.Zero);
            box = new BoundingBoxD(box.Center - halfSize, box.Center + halfSize);
            var pos = MyUtils.GetRandomPosition(ref box);

            Vector3 forward = MyUtils.GetRandomVector3Normalized();
            Vector3 up = MyUtils.GetRandomVector3Normalized();
            while (forward == up)
                up = MyUtils.GetRandomVector3Normalized();

            Vector3 right = Vector3.Cross(forward, up);
            up = Vector3.Cross(right, forward);
            entity.WorldMatrix = MatrixD.CreateWorld(pos, forward, up);
            return entity;
        }

 public void RemoveTrigger(MyEntity entity, MyTriggerComponent trigger)
 {
     if (m_updateLock)
         m_removeCacheTrigger.Add(new MyTuple<MyEntity, MyTriggerComponent>(entity, trigger));
     else
         RemoveTriggerCached(entity, trigger);
 }

 void m_entity_OnClose(MyEntity obj)
 {
     if (m_shotSmoke != null)
     {
         MyParticlesManager.RemoveParticleEffect(m_shotSmoke);
         m_shotSmoke = null;
     }
 }

 public MyGridContactInfo(ref HkContactPointEvent evnt, MyCubeGrid grid)
 {
     Event = evnt;
     ContactPosition = grid.Physics.ClusterToWorld(evnt.ContactPoint.Position); 
     m_currentEntity = grid;
     m_collidingEntity = Event.GetOtherEntity(grid) as MyEntity;
     m_currentBlock = null;
     m_otherBlock = null;
     ImpulseMultiplier = 1;
 }

        public override void Init(MyEntity entity, MyLargeTurretBase turretBase)
        {
            base.Init(entity, turretBase);

            // backward compatibility with old mods/models
            if (!m_gunBase.HasDummies)
            {
                Vector3 muzzleVec = -Entity.PositionComp.WorldMatrix.Forward * 0.8f;
                m_gunBase.AddMuzzleMatrix(MyAmmoType.HighSpeed, Matrix.CreateTranslation(muzzleVec));
            }
        }

        static bool ValidatePosition(MyEntity entity, Vector3D position)
        {
            float positionTolerancy = Math.Max(entity.PositionComp.MaximalSize * 0.1f, 0.1f);
            float smallSpeed = 0.1f;
            if (entity.m_serverLinearVelocity == Vector3.Zero || entity.m_serverLinearVelocity.Length() < smallSpeed)
                // some tolerancy of position for not moving objects
                positionTolerancy = Math.Max(entity.PositionComp.MaximalSize * 0.5f, 1.0f);

            if ((position - entity.PositionComp.GetPosition()).Length() < positionTolerancy)
                return false;
            return true;
        }

 private void RemoveTriggerCached(MyEntity entity, MyTriggerComponent trigger)
 {
     if (m_triggers.ContainsKey(entity) && m_triggers[entity].Contains(trigger))
     {
         if (m_triggers[entity].Count == 1)
         {
             m_triggers[entity].Clear();
             m_triggers.Remove(entity);
         }
         else
             m_triggers[entity].Remove(trigger);
     }
 }

        public void QueueEntity(MyEntity entity)
        {
            long time = Time();
            time += EntityPreserveTime;

            m_entities.Insert(new EntityReference
            {
                Entity = entity
            }, time);

            m_index.Add(entity.EntityId);

            if (UpdateOrder == MyUpdateOrder.NoUpdate)
            {
                SetUpdateOrder(MyUpdateOrder.AfterSimulation);
            }
        }

        public virtual void Init(MyEntity entity, MyLargeTurretBase turretBase)
        {
            m_entity = entity;
            m_turretBase = turretBase;
            m_gunBase = turretBase.GunBase as MyGunBase;

            // Check for the dummy cubes for the muzzle flash positions:
            if (m_entity.Model != null)
            {
                if (m_entity.Model.Dummies.ContainsKey("camera"))
                {
                    CameraDummy = m_entity.Model.Dummies["camera"];
                }

                m_gunBase.LoadDummies(m_entity.Model.Dummies);
            }

            m_entity.OnClose += m_entity_OnClose;

        }

        public static void TakeMaterialsFromBuilder(List<MyObjectBuilder_CubeGrid> blocksToBuild, MyEntity builder)
        {
            Debug.Assert(blocksToBuild.Count == 1);
            if (blocksToBuild.Count == 0)
                return;

            // Search for multiblock definition.
            var firstBlock = blocksToBuild[0].CubeBlocks.FirstOrDefault();
            Debug.Assert(firstBlock != null);
            if (firstBlock == null )
                return;

            MyDefinitionId multiBlockDefId;
            var compound = firstBlock as MyObjectBuilder_CompoundCubeBlock;
            if (compound != null)
            {
                Debug.Assert(compound.Blocks != null && compound.Blocks.Length > 0 && compound.Blocks[0].MultiBlockDefinition != null);
                if (compound.Blocks == null || compound.Blocks.Length == 0 || compound.Blocks[0].MultiBlockDefinition == null)
                    return;

                multiBlockDefId = compound.Blocks[0].MultiBlockDefinition.Value;
            }
            else
            {
                Debug.Assert(firstBlock.MultiBlockDefinition != null);
                if (firstBlock.MultiBlockDefinition == null)
                    return;

                multiBlockDefId = firstBlock.MultiBlockDefinition.Value;
            }

            MyMultiBlockDefinition multiBlockDefinition = MyDefinitionManager.Static.TryGetMultiBlockDefinition(multiBlockDefId);
            Debug.Assert(multiBlockDefinition != null);
            if (multiBlockDefinition == null)
                return;

            MyCubeBuilder.BuildComponent.GetMultiBlockPlacementMaterials(multiBlockDefinition);
            MyCubeBuilder.BuildComponent.AfterSuccessfulBuild(builder, instantBuild: false);
        }

 void previewGrid_OnClose(MyEntity obj)
 {
     m_previewGrids.Remove(obj as MyCubeGrid);
     if (m_previewGrids.Count == 0)
     {
         //TODO: show some notification that the paste failed
         // Deactivation commented out because during clipboard moving grid can be hidden (it is closed, see Hide) and deactivation is not wanted.
         //Deactivate();
     }
 }

        private void DisablePhysicsRecursively(MyEntity entity)
        {
            if (entity.Physics != null && entity.Physics.Enabled)
                entity.Physics.Enabled = false;

            var block = entity as MyCubeBlock;
            if (block != null && block.UseObjectsComponent.DetectorPhysics != null && block.UseObjectsComponent.DetectorPhysics.Enabled)
                block.UseObjectsComponent.DetectorPhysics.Enabled = false;

            if (block != null)
                block.NeedsUpdate = MyEntityUpdateEnum.NONE;

            foreach (var child in entity.Hierarchy.Children)
                DisablePhysicsRecursively(child.Container.Entity as MyEntity);
        }

 void gunEntity_OnClose(MyEntity obj)
 {
     if (m_currentWeapon == obj)
         m_currentWeapon = null;
 }

        private bool ShouldDetect(MyEntity entity)
        {
            if (entity == null)
                return false;

            if (entity == CubeGrid)
                return false;

            if (DetectPlayers)
            {
                if (entity is Character.MyCharacter)
                    return ShouldDetectRelation((entity as Character.MyCharacter).GetRelationTo(OwnerId));
                if (entity is MyGhostCharacter)
                    return ShouldDetectRelation((entity as IMyControllableEntity).ControllerInfo.Controller.Player.GetRelationTo(OwnerId));
            }
            if (DetectFloatingObjects)
                if (entity is MyFloatingObject)
                    return true;
            
            var grid = entity as MyCubeGrid;
            
            //GR: if grids are logically connected(not physically causes issues with detecting ships with landing gears) return false (mostly for not detecting Piston and Rotor top parts)
            if ( grid != null && MyCubeGridGroups.Static.Logical.HasSameGroup(grid, CubeGrid) )
                return false;

            if (DetectSmallShips)
                if (grid != null && grid.GridSizeEnum == MyCubeSize.Small)
                    return ShouldDetectGrid(grid);
            if (DetectLargeShips)
                if (grid != null && grid.GridSizeEnum == MyCubeSize.Large && !grid.IsStatic)
                    return ShouldDetectGrid(grid);
            if (DetectStations)
                if (grid != null && grid.GridSizeEnum == MyCubeSize.Large && grid.IsStatic)
                    return ShouldDetectGrid(grid);
            if (DetectAsteroids)
                if (entity is MyVoxelBase)
                    return true;

            return false;
        }