Example #1
0
        //  Add new explosion to the list, but caller needs to start it using Start() method
        public static void AddExplosion(ref MyExplosionInfo explosionInfo, bool updateSync = true)
        {
            System.Diagnostics.Debug.Assert(explosionInfo.ExplosionSphere.Radius > 0);

            if (updateSync)
            {
                SyncObject.RequestExplosion(
                    explosionInfo.ExplosionSphere.Center, 
                    (float)explosionInfo.ExplosionSphere.Radius, 
                    explosionInfo.ExplosionType,
                    explosionInfo.VoxelExplosionCenter,
                    explosionInfo.ParticleScale
                    );
            }            
            
            m_explosionsWrite.Add(explosionInfo);            
        }
        //  Add new explosion to the list, but caller needs to start it using Start() method
        public static void AddExplosion(ref MyExplosionInfo explosionInfo, bool updateSync = true)
        {
            System.Diagnostics.Debug.Assert(explosionInfo.ExplosionSphere.Radius > 0);

            if (updateSync)
            {
                MyMultiplayer.RaiseStaticEvent(s => MyExplosions.ProxyExplosionRequest,
                    explosionInfo.ExplosionSphere.Center, 
                    (float)explosionInfo.ExplosionSphere.Radius, 
                    explosionInfo.ExplosionType,
                    explosionInfo.VoxelExplosionCenter,
                    explosionInfo.ParticleScale
                );
            }            
            
            m_explosionsWrite.Add(explosionInfo);            
        }
 private static void ProxyExplosionRequest(Vector3D center, float radius, MyExplosionTypeEnum type, Vector3D voxelCenter, float particleScale)
 {
     //Dont create explosion particles if message is bufferred, it is useless to create hundred explosion after scene load
     if (MySession.Static.Ready)
     {
         //  Create explosion
         MyExplosionInfo info = new MyExplosionInfo()
         {
             PlayerDamage = 0,
             //Damage = m_ammoProperties.Damage,
             Damage = 200,
             ExplosionType = type,
             ExplosionSphere = new BoundingSphere(center, radius),
             LifespanMiliseconds = MyExplosionsConstants.EXPLOSION_LIFESPAN,
             CascadeLevel = 0,
             HitEntity = null,
             ParticleScale = particleScale,
             OwnerEntity = null,
             Direction = Vector3.Forward,
             VoxelExplosionCenter = voxelCenter,
             ExplosionFlags = MyExplosionFlags.CREATE_DEBRIS | MyExplosionFlags.CREATE_DECALS | MyExplosionFlags.CREATE_PARTICLE_EFFECT | MyExplosionFlags.CREATE_SHRAPNELS,
             VoxelCutoutScale = 1.0f,
             PlaySound = true,
             ObjectsRemoveDelayInMiliseconds = 40
         };
         MyExplosions.AddExplosion(ref info, false);
     }
 }
        public override void Update()
        {
            base.Update();

            if (m_selfDestruct && MySandboxGame.TotalGamePlayTimeInMilliseconds >= m_selfDestructStartedInTime + SELF_DESTRUCT_TIME_MS)
            {
                MyAIComponent.Static.RemoveBot(AgentBot.Player.Id.SerialId, removeCharacter: true);

                var explosionSphere = new BoundingSphere(AgentBot.Player.GetPosition(), EXPLOSION_RADIUS);
                MyExplosionInfo info = new MyExplosionInfo()
                {
                    PlayerDamage = EXPLOSION_PLAYER_DAMAGE,
                    Damage = EXPLOSION_DAMAGE,
                    ExplosionType = MyExplosionTypeEnum.BOMB_EXPLOSION,
                    ExplosionSphere = explosionSphere,
                    LifespanMiliseconds = MyExplosionsConstants.EXPLOSION_LIFESPAN,
                    CascadeLevel = 0,
                    HitEntity = AgentBot.Player.Character,
                    ParticleScale = 0.5f,
                    OwnerEntity = AgentBot.Player.Character,
                    Direction = Vector3.Zero,
                    VoxelExplosionCenter = AgentBot.Player.Character.PositionComp.GetPosition(),// + 2 * WorldMatrix.Forward * 0.5f,
                    ExplosionFlags = MyExplosionFlags.AFFECT_VOXELS | MyExplosionFlags.APPLY_FORCE_AND_DAMAGE | MyExplosionFlags.CREATE_DEBRIS | MyExplosionFlags.CREATE_DECALS | MyExplosionFlags.CREATE_PARTICLE_EFFECT | MyExplosionFlags.CREATE_SHRAPNELS | MyExplosionFlags.APPLY_DEFORMATION,
                    VoxelCutoutScale = 0.6f,
                    PlaySound = true,
                    ApplyForceAndDamage = true,
                    ObjectsRemoveDelayInMiliseconds = 40
                };
                MyExplosions.AddExplosion(ref info);
            }

            var target = (AiTarget as MyCyberhoundTarget);
            Debug.Assert(target != null);
            if (AgentBot.Player.Character.UseNewAnimationSystem == false) // obsolete in new animation system
            {
                if ((!target.IsAttacking && !m_lastWasAttacking) && target.HasTarget()
                    && !target.PositionIsNearTarget(AgentBot.Player.Character.PositionComp.GetPosition(), 1.5f))
                {
                    if (AgentBot.Navigation.Stuck)
                    {
                        // correct aiming (aim in front of dog)
                        Vector3D houndPosition = AgentBot.Player.Character.PositionComp.GetPosition();
                        Vector3D gravity = MyGravityProviderSystem.CalculateNaturalGravityInPoint(houndPosition);
                        Vector3D aimingDirection = AgentBot.Player.Character.AimedPoint - houndPosition;
                        Vector3D newAimVector = aimingDirection -
                                                gravity*Vector3D.Dot(aimingDirection, gravity)/gravity.LengthSquared();
                        newAimVector.Normalize();
                        AgentBot.Navigation.AimAt(null, houndPosition + 100.0f*newAimVector);
                        // play idle animation
                        AgentBot.Player.Character.PlayCharacterAnimation("CyberhoundIdle1", MyBlendOption.Immediate,
                            MyFrameOption.Loop, 0);
                        AgentBot.Player.Character.DisableAnimationCommands();
                    }
                    else
                    {
                        AgentBot.Player.Character.EnableAnimationCommands();
                    }
                }
            }
            m_lastWasAttacking = target.IsAttacking;
        }
        public static void CreateExplosion(Vector3D position, float radius, int damage = 5000)
        {
            var explosionType = MyExplosionTypeEnum.WARHEAD_EXPLOSION_50;
            if (radius < 2)
                explosionType = MyExplosionTypeEnum.WARHEAD_EXPLOSION_02;
            else if (radius < 15)
                explosionType = MyExplosionTypeEnum.WARHEAD_EXPLOSION_15;
            else if (radius < 30)
                explosionType = MyExplosionTypeEnum.WARHEAD_EXPLOSION_30;

            //  Create explosion
            MyExplosionInfo info = new MyExplosionInfo
            {
                PlayerDamage = 0,
                Damage = damage,
                ExplosionType = explosionType,
                ExplosionSphere = new BoundingSphereD(position, radius),
                LifespanMiliseconds = MyExplosionsConstants.EXPLOSION_LIFESPAN,
                CascadeLevel = 0,
                ParticleScale = 1,
                Direction = Vector3.Down,
                VoxelExplosionCenter = position,
                ExplosionFlags = MyExplosionFlags.AFFECT_VOXELS |
                                    MyExplosionFlags.APPLY_FORCE_AND_DAMAGE |
                                    MyExplosionFlags.CREATE_DEBRIS |
                                    MyExplosionFlags.CREATE_DECALS |
                                    MyExplosionFlags.CREATE_PARTICLE_EFFECT |
                                    MyExplosionFlags.CREATE_SHRAPNELS |
                                    MyExplosionFlags.APPLY_DEFORMATION,
                VoxelCutoutScale = 1.0f,
                PlaySound = true,
                ApplyForceAndDamage = true,
                ObjectsRemoveDelayInMiliseconds = 40
            };
            MyExplosions.AddExplosion(ref info);
        }
        MyDamageInfo ApplyVolumetricExplosionOnGrid(ref MyExplosionInfo explosionInfo, ref BoundingSphereD sphere, List<MyEntity> entities)
        {
            Debug.Assert(Sandbox.Game.Multiplayer.Sync.IsServer, "This is supposed to be only server method");
            VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("ApplyExplosionOnGrid");

            bool gridWasHit = false;

            HashSet<MySlimBlock> explodedBlocks = new HashSet<MySlimBlock>();
            Dictionary<MySlimBlock, float> damagedBlocks = new Dictionary<MySlimBlock, float>();
            HashSet<MyCubeGrid> explodedGrids = new HashSet<MyCubeGrid>();

            foreach (var entity in entities)
            {
                MyCubeGrid grid = entity as MyCubeGrid;
                if (grid != null && grid.CreatePhysics)
                {
                    explodedGrids.Add(grid);

                    var detectionHalfSize = grid.GridSize / 2 / 1.25f;
                    var invWorldGrid = MatrixD.Invert(grid.WorldMatrix);

                    VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("GetBlocksInsideSpheres");
                    BoundingSphereD innerSphere = new BoundingSphereD(sphere.Center, (float)Math.Max(0.1f, sphere.Radius - grid.GridSize));
                    BoundingSphereD exactSphere = new BoundingSphereD(sphere.Center, sphere.Radius);
                    BoundingSphereD outerSphere = new BoundingSphereD(sphere.Center, sphere.Radius + grid.GridSize * 0.5f * (float)Math.Sqrt(3));
                    grid.GetBlocksInsideSpheres(
                        ref innerSphere,
                        ref exactSphere,
                        ref outerSphere,
                        m_explodedBlocksInner,
                        m_explodedBlocksExact,
                        m_explodedBlocksOuter,
                        false, detectionHalfSize, ref invWorldGrid);
                    VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();

                    m_explodedBlocksInner.UnionWith(m_explodedBlocksExact);

                    explodedBlocks.UnionWith(m_explodedBlocksInner);

                    VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("outerSphere2");

                    foreach (var cubeBlock in m_explodedBlocksOuter)
                    {
                        grid.Physics.AddDirtyBlock(cubeBlock);
                    }

                    VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();

                    m_explodedBlocksInner.Clear();
                    m_explodedBlocksExact.Clear();
                    m_explodedBlocksOuter.Clear();

                    gridWasHit = true;
                }
            }
            VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();

            var damage = new MyExplosionDamage(explodedBlocks, sphere, explosionInfo.Damage);
            

            var damageInfo = new MyDamageInfo
            {
                GridWasHit = gridWasHit,
                ExplosionDamage = damage,
                AffectedCubeBlocks = explodedBlocks,
                AffectedCubeGrids = explodedGrids,
                Sphere = sphere
            };

            return damageInfo;
        }
        void ApplyExplosionOnVoxel(ref MyExplosionInfo explosionInfo)   
        {
            if (MySession.Static.EnableVoxelDestruction == false)
            {
                return;
            }

            VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("ApplyExplosionOnVoxel");

            if (explosionInfo.Damage > 0)
            {
                VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Voxel or collision");

                bool first = true;

                //  If explosion sphere intersects a voxel map, we need to cut out a sphere, spawn debrises, etc
                List<MyVoxelBase> voxelMaps = MySession.Static.VoxelMaps.GetAllOverlappingWithSphere(ref m_explosionSphere);
                voxelMaps.Sort(delegate(MyVoxelBase x, MyVoxelBase y) {
                    return y.GetOrePriority() - x.GetOrePriority();
                });

                foreach(var voxelMap in voxelMaps)
                {
                    // If the voxel is to be ignored.
                    if (voxelMap.GetOrePriority() == MyVoxelConstants.PRIORITY_IGNORE_EXTRACTION) continue;

                    bool createDebris = first; // We want to create debris

                    if (explosionInfo.HitEntity != null) // but not when we hit prefab
                    {
                        createDebris &= explosionInfo.HitEntity is MyVoxelBase;
                    }

                    createDebris &= explosionInfo.CreateDebris && (createDebris || explosionInfo.ForceDebris);

                    CutOutVoxelMap((float)m_explosionSphere.Radius * explosionInfo.VoxelCutoutScale, explosionInfo.VoxelExplosionCenter, voxelMap, createDebris);

                    //Sync
                    voxelMap.RequestVoxelCutoutSphere(explosionInfo.VoxelExplosionCenter, (float)m_explosionSphere.Radius * explosionInfo.VoxelCutoutScale, createDebris, false);

                    first = false;
                }
                VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
            }

            VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
        }
        // Doesn't get called anymore?
        bool ApplyExplosionOnGrid(ref MyExplosionInfo explosionInfo, ref BoundingSphereD sphere, List<MyEntity> entities)
        {
            Debug.Assert(Sandbox.Game.Multiplayer.Sync.IsServer, "This is supposed to be only server method");
            VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("ApplyExplosionOnGrid");

            bool gridWasHit = false;
            foreach (var entity in entities)
            {
                MyCubeGrid grid = entity as MyCubeGrid;
                if (grid != null && grid.BlocksDestructionEnabled)
                {
                    var detectionHalfSize = grid.GridSize / 2 / 1.25f;
                    var invWorldGrid = MatrixD.Invert(grid.WorldMatrix);

                    VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("GetBlocksInsideSpheres");
                    BoundingSphereD innerSphere = new BoundingSphereD(sphere.Center, (float)Math.Max(0.1f, sphere.Radius - grid.GridSize));
                    BoundingSphereD exactSphere = new BoundingSphereD(sphere.Center, sphere.Radius);
                    BoundingSphereD outerSphere = new BoundingSphereD(sphere.Center, sphere.Radius + grid.GridSize * 0.5f * (float)Math.Sqrt(3));
                    grid.GetBlocksInsideSpheres(
                        ref innerSphere,
                        ref exactSphere,
                        ref outerSphere,
                        m_explodedBlocksInner,
                        m_explodedBlocksExact,
                        m_explodedBlocksOuter, 
                        true, detectionHalfSize, ref invWorldGrid);
                    VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();

                    VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("foreach (var cubeBlock in m_explodedBlocks)");
                    foreach (var cubeBlock in m_explodedBlocksInner)
                    {
                        if (cubeBlock.FatBlock != null && cubeBlock.FatBlock.MarkedForClose)
                                continue;

                        if (cubeBlock.FatBlock != null)
                        {
                            grid.RemoveBlock(cubeBlock, updatePhysics: true);
                        }
                        else
                        {
                            grid.RemoveDestroyedBlock(cubeBlock);
                            grid.Physics.AddDirtyBlock(cubeBlock);
                        }
                    }
                    VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();

                    VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("GetBlocksInsideSphere outerSphere");
                    
                    foreach (var cubeBlock in m_explodedBlocksExact)
                    {
                        if ((cubeBlock.FatBlock != null) && cubeBlock.FatBlock.MarkedForClose)
                            continue;

                        if ((cubeBlock.FatBlock != null) && cubeBlock.FatBlock.MarkedToExplode)
                        {
                            grid.RemoveBlock(cubeBlock, updatePhysics: true);
                        }
                        else// if (MyVRageUtils.GetRandomFloat(0, 2) > 1)
                        {
                            grid.ApplyDestructionDeformation(cubeBlock);
                            grid.Physics.AddDirtyBlock(cubeBlock);
                        }
                        //else if (cubeBlock.FatBlock is IMyExplosiveObject)
                        //{
                        //    cubeBlock.OnDestroy();
                        //}
                    }
                    VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();

                    VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("outerSphere2");

                    foreach (var cubeBlock in m_explodedBlocksOuter)
                    {
                        grid.Physics.AddDirtyBlock(cubeBlock);
                    }

                    VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();

                    m_explodedBlocksInner.Clear();
                    m_explodedBlocksExact.Clear();
                    m_explodedBlocksOuter.Clear();

                    VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("AddDirtyArea");
                    
                    //Vector3 cornerVec = new Vector3(sphere.Radius + grid.GridSize / (float)grid.Skeleton.BoneDensity);
                    //BoundingBox box = new BoundingBox(sphere.Center - cornerVec, sphere.Center + cornerVec);

                    //var invee = Matrix.Invert(grid.WorldMatrix);
                    //box = box.Transform(ref invee);
                    //Vector3 min = box.Min;
                    //Vector3 max = box.Max;
                    //Vector3I start = new Vector3I((int)Math.Round(min.X / grid.GridSize), (int)Math.Round(min.Y / grid.GridSize), (int)Math.Round(min.Z / grid.GridSize));
                    //Vector3I end = new Vector3I((int)Math.Round(max.X / grid.GridSize), (int)Math.Round(max.Y / grid.GridSize), (int)Math.Round(max.Z / grid.GridSize));

                    //grid.Physics.AddDirtyArea(start, end);
                    VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();

                    VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("UpdateDirty");
                    grid.UpdateDirty();
                    VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();

                    VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("CreateExplosionDebris");
                    if (m_explosionInfo.HitEntity == grid)
                    {
                        BoundingBoxD aabb = BoundingBoxD.CreateFromSphere(new BoundingSphereD(sphere.Center, sphere.Radius * 1.5f));
                        MyDebris.Static.CreateExplosionDebris(ref sphere, grid, ref aabb, 0.5f, false);
                    }

                    VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();

                    gridWasHit = true;
                }
            }

            VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
            return gridWasHit;
        }
 // Doesn't get called anymore?
 private void ApplyExplosionOnEntities(ref MyExplosionInfo m_explosionInfo,List<MyEntity> entities)
 {
     Debug.Assert(Sync.IsServer);
     foreach (var entity in entities)
     {
         if (!(entity is IMyDestroyableObject))
             continue;
         float damage;
         if (entity is MyCharacter)
             damage = m_explosionInfo.PlayerDamage;
         else
             damage = m_explosionInfo.Damage;
         if (damage == 0)
             continue;
         var destroyableObj = entity as IMyDestroyableObject;
         destroyableObj.DoDamage(damage, MyDamageType.Explosion, true, attackerId: m_explosionInfo.OwnerEntity != null ? m_explosionInfo.OwnerEntity.EntityId : 0);
     }
 }
        private void ApplyVolumetricExplosionOnEntities(ref MyExplosionInfo m_explosionInfo, List<MyEntity> entities, MyDamageInfo explosionDamageInfo)
        {
            Debug.Assert(Sync.IsServer);
            foreach (var entity in entities)
            {
                //Special case for characters in cockpits
                var character = entity as MyCharacter;
                if (character != null)
                {
                    var cockpit = character.IsUsing as MyCockpit;
                    if (cockpit != null)
                    {
                        if (explosionDamageInfo.ExplosionDamage.DamagedBlocks.ContainsKey(cockpit.SlimBlock))
                        {
                            float damageRemaining = explosionDamageInfo.ExplosionDamage.DamageRemaining[cockpit.SlimBlock].DamageRemaining;
                            character.DoDamage(damageRemaining, MyDamageType.Explosion, true, attackerId: m_explosionInfo.OwnerEntity != null ? m_explosionInfo.OwnerEntity.EntityId : 0);
                        }
                        continue;
                    }
                }

                var raycastDamageInfo = explosionDamageInfo.ExplosionDamage.ComputeDamageForEntity(entity.PositionComp.WorldAABB.Center);
                float damage = raycastDamageInfo.DamageRemaining;

                float entityDistanceToExplosion = (float)(entity.PositionComp.WorldAABB.Center - explosionDamageInfo.Sphere.Center).Length();
                damage *= (float)(1 - (entityDistanceToExplosion - raycastDamageInfo.DistanceToExplosion) / (explosionDamageInfo.Sphere.Radius - raycastDamageInfo.DistanceToExplosion));

                if (damage <= 0f)
                    continue;

                if (entity.Physics != null && entity.Physics.Enabled)
                {
                    var ammoBase = entity as MyAmmoBase;
                    if (ammoBase != null)
                    {
                        if (Vector3.DistanceSquared(m_explosionSphere.Center, ammoBase.PositionComp.GetPosition()) < 4 * m_explosionSphere.Radius * m_explosionSphere.Radius)
                        {
                            ammoBase.MarkedToDestroy = true;
                        }
                        ammoBase.Explode();
                    }

                    float forceMultiplier = damage / 50000f;

                    //  Throws surrounding objects away from centre of the explosion.
                    if (m_explosionInfo.ApplyForceAndDamage)
                    {
                        m_explosionInfo.StrengthImpulse = MyExplosionsConstants.EXPLOSION_STRENGTH_IMPULSE * (float)m_explosionSphere.Radius;
                        m_explosionInfo.StrengthAngularImpulse = MyExplosionsConstants.EXPLOSION_STRENGTH_ANGULAR_IMPULSE;
                        m_explosionInfo.HitEntity = m_explosionInfo.HitEntity != null ? m_explosionInfo.HitEntity.GetBaseEntity() : null;

                        VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("ApplyExplosionForceAndDamage");

                        if (entity.PositionComp.WorldAABB.Center != m_explosionSphere.Center)
                        {
                            entity.Physics.AddForce(
                                MyPhysicsForceType.APPLY_WORLD_IMPULSE_AND_WORLD_ANGULAR_IMPULSE,
                                forceMultiplier * m_explosionInfo.StrengthImpulse * Vector3.Normalize(entity.PositionComp.WorldAABB.Center - m_explosionSphere.Center),
                                entity.PositionComp.WorldAABB.Center,
                                null);
                        }

                        VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
                    }
                }

                if (!(entity is IMyDestroyableObject))
                    continue;
                
                var destroyableObj = entity as IMyDestroyableObject;
                destroyableObj.DoDamage(damage, MyDamageType.Explosion, true, attackerId: m_explosionInfo.OwnerEntity != null ? m_explosionInfo.OwnerEntity.EntityId : 0);
            }
        }
        private bool ApplyVolumetricExplosion(ref MyExplosionInfo m_explosionInfo, ref BoundingSphereD influenceExplosionSphere, List<MyEntity> entities)
        {
            bool gridWasHit = false;

            ApplyExplosionOnVoxel(ref m_explosionInfo);

            var damageInfo = ApplyVolumetricExplosionOnGrid(ref m_explosionInfo, ref influenceExplosionSphere, entities);
            if ((m_explosionInfo.ExplosionFlags & MyExplosionFlags.APPLY_DEFORMATION) == MyExplosionFlags.APPLY_DEFORMATION)
            {
                damageInfo.ExplosionDamage.ComputeDamagedBlocks();
                gridWasHit = damageInfo.GridWasHit;
                ApplyVolumetriDamageToGrid(damageInfo, m_explosionInfo.OwnerEntity != null ? m_explosionInfo.OwnerEntity.EntityId : 0);
            }

            if (m_explosionInfo.HitEntity is MyWarhead)
            {
                var warhead = (m_explosionInfo.HitEntity as MyWarhead).SlimBlock;
                if (!warhead.CubeGrid.BlocksDestructionEnabled)
                {
                    warhead.CubeGrid.RemoveDestroyedBlock(warhead);
                    foreach (var neighbour in warhead.Neighbours)
                    {
                        neighbour.CubeGrid.Physics.AddDirtyBlock(neighbour);
                    }
                    warhead.CubeGrid.Physics.AddDirtyBlock(warhead);
                }
            }
            ApplyVolumetricExplosionOnEntities(ref m_explosionInfo, entities, damageInfo);

            entities.Clear();
            return gridWasHit;
        }
        // Doesn't get called anymore?
        private bool ApplyExplosion(ref MyExplosionInfo m_explosionInfo, ref BoundingSphereD influenceExplosionSphere, List<MyEntity> entities)
        {
            bool gridWasHit = false;

            ApplyExplosionOnVoxel(ref m_explosionInfo);

            ApplyExplosionOnEntities(ref m_explosionInfo, entities);

            if (((m_explosionInfo.ExplosionFlags & MyExplosionFlags.APPLY_DEFORMATION) == MyExplosionFlags.APPLY_DEFORMATION))
            {
                gridWasHit = ApplyExplosionOnGrid(ref m_explosionInfo, ref influenceExplosionSphere, entities);
            }

            entities.Clear();


            //  Throws surrounding objects away from centre of the explosion.
            if (m_explosionInfo.ApplyForceAndDamage)
            {
                m_explosionInfo.StrengthImpulse = MyExplosionsConstants.EXPLOSION_STRENGTH_IMPULSE * (float)m_explosionSphere.Radius;
                m_explosionInfo.StrengthAngularImpulse = MyExplosionsConstants.EXPLOSION_STRENGTH_ANGULAR_IMPULSE;
                m_explosionInfo.HitEntity = m_explosionInfo.HitEntity != null ? m_explosionInfo.HitEntity.GetBaseEntity() : null;

                VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("ApplyExplosionForceAndDamage");
                //MyEntities.ApplyExplosionForceAndDamage(ref explosionInfo);


                for (int s = 0; s < m_explosionForceSlices.Length; s++)
                {
                    BoundingSphereD forceImpactSphere = m_explosionSphere;
                    forceImpactSphere.Radius *= m_explosionForceSlices[s].X;
                    entities = MyEntities.GetEntitiesInSphere(ref forceImpactSphere);

                    foreach (var entity in entities)
                    {
                        if (!m_pushedEntities.Contains(entity))
                        {
                            if (entity.PositionComp.WorldAABB.Center != m_explosionSphere.Center)
                            {
                                if (entity.Physics != null && entity.Physics.Enabled)
                                {
                                    entity.Physics.AddForce(
                                        MyPhysicsForceType.APPLY_WORLD_IMPULSE_AND_WORLD_ANGULAR_IMPULSE,
                                        m_explosionForceSlices[s].Y * m_explosionInfo.StrengthImpulse * Vector3.Normalize(entity.PositionComp.WorldAABB.Center - m_explosionSphere.Center),
                                        entity.PositionComp.WorldAABB.Center,
                                        null);
                                }
                            }
                            m_pushedEntities.Add(entity);

                            if (entity.Physics != null && entity.Physics.Enabled)
                            {
                                var character = entity as Sandbox.Game.Entities.Character.MyCharacter;
                                if (character != null && !(character.IsUsing is MyCockpit))
                                {
                                    character.DoDamage(m_explosionInfo.Damage * m_explosionForceSlices[s].Y, MyDamageType.Explosion, true, m_explosionInfo.OwnerEntity != null ? m_explosionInfo.OwnerEntity.EntityId : 0);
                                }

                                var ammoBase = entity as MyAmmoBase;
                                if (ammoBase != null)
                                {
                                    if (Vector3.DistanceSquared(m_explosionSphere.Center, ammoBase.PositionComp.GetPosition()) < 4 * m_explosionSphere.Radius * m_explosionSphere.Radius)
                                    {
                                        ammoBase.MarkedToDestroy = true;
                                    }
                                    ammoBase.Explode();
                                }
                            }
                        }
                    }

                    entities.Clear();
                }

                m_pushedEntities.Clear();
                VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
            }
            return gridWasHit;
        }
        public void Start(MyExplosionInfo explosionInfo)
        {
            MyDebug.AssertDebug(explosionInfo.ExplosionSphere.Radius > 0);

            VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyExplosion.Start");

            m_explosionInfo = explosionInfo;
            ElapsedMiliseconds = 0;

            VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
        }
Example #14
0
        void ApplyExplosionOnVoxel(ref MyExplosionInfo explosionInfo)
        {
            VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("ApplyExplosionOnVoxel");

            if (explosionInfo.Damage > 0)
            {
                VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Voxel or collision");

                //  If explosion sphere intersects a voxel map, we need to cut out a sphere, spawn debrises, etc
                MyVoxelBase voxelMap = explosionInfo.AffectVoxels ? MySession.Static.VoxelMaps.GetOverlappingWithSphere(ref m_explosionSphere) : null;
                if (voxelMap != null)
                {
                    bool createDebris = true; // We want to create debris

                    if (explosionInfo.HitEntity != null) // but not when we hit prefab
                    {
                        createDebris &= explosionInfo.HitEntity is MyVoxelMap;
                    }

                    createDebris &= explosionInfo.CreateDebris && (createDebris || explosionInfo.ForceDebris);

                    CutOutVoxelMap((float)m_explosionSphere.Radius * explosionInfo.VoxelCutoutScale, explosionInfo.VoxelExplosionCenter, voxelMap, createDebris);

                    //Sync
                    voxelMap.SyncObject.RequestVoxelCutoutSphere(explosionInfo.VoxelExplosionCenter, (float)m_explosionSphere.Radius * explosionInfo.VoxelCutoutScale, createDebris);
                }
                VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
            }

            VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
        }
Example #15
0
        void ApplyExplosionOnVoxel(ref MyExplosionInfo explosionInfo)
        {
            if (MySession.Static.EnableVoxelDestruction == false)
            {
                return;
            }

            VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("ApplyExplosionOnVoxel");

            if (explosionInfo.Damage > 0)
            {
                VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Voxel or collision");

                bool first = true;

                //  If explosion sphere intersects a voxel map, we need to cut out a sphere, spawn debrises, etc
                List<MyVoxelBase> voxelMaps = MySession.Static.VoxelMaps.GetAllOverlappingWithSphere(ref m_explosionSphere);

                for (int i = voxelMaps.Count - 1; i > 0; --i)
                {
                    m_VoxelsToCutTmp.Add(voxelMaps[i].RootVoxel);
                }

                foreach (var voxelMap in m_VoxelsToCutTmp)
                {
                    bool createDebris = first; // We want to create debris
                    /*
                    if (explosionInfo.HitEntity != null) // but not when we hit prefab
                    {
                        createDebris &= explosionInfo.HitEntity is MyVoxelBase;
                    }*/

                    createDebris &= explosionInfo.CreateDebris && (createDebris || explosionInfo.ForceDebris);

                    CutOutVoxelMap((float)m_explosionSphere.Radius * explosionInfo.VoxelCutoutScale, explosionInfo.VoxelExplosionCenter, voxelMap, createDebris);

                    //Sync
                    voxelMap.RequestVoxelCutoutSphere(explosionInfo.VoxelExplosionCenter, (float)m_explosionSphere.Radius * explosionInfo.VoxelCutoutScale, createDebris, false);

                    first = false;
                }

                m_VoxelsToCutTmp.Clear();
                VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
            }

            VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
        }