Heavy armour and warheads

Cpt_Mechu ●

It is due to difference in how explosions work in both games, in SE2 its just AOE (damage bypasses armor, only distance is concidered)

In SE 1 it was (as per wiki:) "The explosion is volumetric for these and loses damage as it destroys blocks to get past until it runs out of damage."

Explained it more in here: https://support.keenswh.com/spaceengineers2/pc/topic/54951-warheads-too-powerful

IF possible, like the linked feedback as this one is kind of misleading.

(And by any means i do not mean to offend, its important to consolidate our feedback in one place so the message reaches devs)

Reply URL

2

Wilhelm ●

Heavy armor should be very resistant to surface explosions like warheads honestly since it's largely a matter of the material and thickness of said material that determines whether the pressure wave from the explosion is enough to cause the armor to buckle or transfer enough of said energy through the armor for micro fracturing. Without shaped charges and the like, armor would act as a reflector of sorts and direct the blast away from it.

In this case, it might be 'simplified' to measure the explosive effect on armor based on a minimum thickness of said material,. distance from the blast and how wide the unsupported surface is. A 2.5 meter thick block of heavy armor would shrug of a non shaped charge explosion out into the range of 10,000 kilograms of TNT. For perspective, that's 10 standard US mk-84 heavy aircraft bombs all hitting at the same time. At that level, you'd start to see some spalling on the back side (damage to the opposite side due to the shockwave passing through the material) and the surface might show some pitting and damage.

Thinner sheets of the same material would obviously take more damage from that blast, as would (oddly enough) a number of 2.5m blocks stacked together into a continuous wall. The reason is that a lot of that energy that passes into that 'wall' would cause it to buckle under the pressure, where a single 2.5m block has less ability to flex.

I'd like it if the damage calculations for explosions would not consider each block independently (like the SE1 model where it just damaged each block and then passed the rest of the damage through)

Also, the behavior of said explosives also depends on the atmospheric pressure. A warhead going boom in space is vastly different than one going boom at sea level in how it affects armor.

I dunno why, but I had Google AI crank out a sample algorithm and pseudocode (I'll call it that until I know it actually would work) for a rough concept. Apologies for the AI 'stuff' but it was just a lot easier this way.

Complete Code Implementation Template for Dynamic Armor Damage vs. Explosions in C#/VRAGE3

csharp

using System;
using System.Collections.Generic;

public class BlastDamageSystem
{
    public struct BlockMaterialProfile
    {
        public bool IsArmor;              // Identifies structural armor plating
        public float BaseYieldStrength;   // Initial material strength limit in Megapascals (MPa)
        public float MaterialDensity;     // Dense alloy rating (Heavy Armor >> Light Armor)
        public float AttenuationFactor;   // Internal shockwave scattering coefficient (0.0 to 1.0)
        public float SizeInMeters;        // Physical thickness of the block grid space
        public float Integrity;           // Active block health pool
        
        public void Destroy() { /* Triggers block fracture debris meshes */ }
        public void ApplyVisualDeformation(float shockwaveIntensity) { /* Morphs the block geometry */ }
    }

    public interface IGridHitResult
    {
        IEnumerable<BlockMaterialProfile> GetBlocksAlongRayPath(Vector3 direction);
    }

    public struct Vector3 { public float X, Y, Z; }

    public void ProcessExplosionVector(Vector3 rayDirection, float distanceToGrid, IGridHitResult hitResult, float baseExplosionForce, float localAtmosphere)
    {
        // ---------------------------------------------------------------------
        // 1. ENVIRONMENTAL ATMOSPHERIC LAW
        // ---------------------------------------------------------------------
        float shockwaveMultiplier = Math.Clamp(localAtmosphere, 0.0f, 2.0f);
        float fragmentDamageMultiplier = 1.0f + (1.0f - Math.Clamp(localAtmosphere, 0.0f, 1.0f)) * 0.75f;

        // ---------------------------------------------------------------------
        // 2. VECTOR OVERPRESSURE AND SHRAPNEL INITIALIZATION
        // ---------------------------------------------------------------------
        float airShockPressure = (baseExplosionForce * shockwaveMultiplier) / (distanceToGrid * distanceToGrid);
        float shrapnelPressure = (baseExplosionForce * (1.0f - Math.Clamp(localAtmosphere, 0.0f, 1.0f)) * fragmentDamageMultiplier) / distanceToGrid;
        
        float currentVectorPressure = airShockPressure + shrapnelPressure;
        float cumulativeArmorThickness = 0.0f;

        // ---------------------------------------------------------------------
        // 3. CONTIGUOUS MATERIAL CONTINUITY LOOP
        // ---------------------------------------------------------------------
        foreach (BlockMaterialProfile targetBlock in hitResult.GetBlocksAlongRayPath(rayDirection))
        {
            if (!targetBlock.IsArmor)
            {
                cumulativeArmorThickness = 0.0f; // Reset if the ray hits an air gap or machinery
            }
            else
            {
                cumulativeArmorThickness += targetBlock.SizeInMeters; // Accumulate thick slab depth
            }

            // ---------------------------------------------------------------------
            // 4. EXPONENTIAL BACKING LAW (MONOLITHIC THICKNESS CALCULATOR)
            // ---------------------------------------------------------------------
            float thicknessScalingFactor = 1.0f + (float)Math.Pow(cumulativeArmorThickness, 1.5);
            float effectiveYieldStrength = targetBlock.BaseYieldStrength * thicknessScalingFactor;

            // ---------------------------------------------------------------------
            // 5. MATERIAL DAMAGE REGIME EVALUATION
            // ---------------------------------------------------------------------
            if (currentVectorPressure < effectiveYieldStrength)
            {
                // REGIME A: SURFACE EROSION / TOTAL DEFLECTION
                targetBlock.Integrity -= (currentVectorPressure * 0.05f);
                currentVectorPressure = 0.0f; 
                break; 
            }
            else if (currentVectorPressure >= effectiveYieldStrength && currentVectorPressure < (effectiveYieldStrength * 3.0f))
            {
                // REGIME B: MECHANICAL DEFORMATION & INTERNAL SPALLING
                targetBlock.Integrity -= currentVectorPressure;
                targetBlock.ApplyVisualDeformation(shockwaveMultiplier);
                
                // SHOCK ATTENUATION AND MASS DAMPENING
                currentVectorPressure *= (0.50f / (targetBlock.MaterialDensity * cumulativeArmorThickness));
            }
            else
            {
                // REGIME C: PLUGGING / HYDRODYNAMIC PUNCH-THROUGH
                targetBlock.Destroy();
                currentVectorPressure -= effectiveYieldStrength;
            }

            if (currentVectorPressure <= 0.01f)
            {
                break;
            }
        }
    }
}

Detailed Mathematical & Physics Logic Breakdown

1. Environmental Atmospheric Law

csharp

float shockwaveMultiplier = Math.Clamp(localAtmosphere, 0.0f, 2.0f); float fragmentDamageMultiplier = 1.0f + (1.0f - Math.Clamp(localAtmosphere, 0.0f, 1.0f)) * 0.75f;

The Physics: Conventional explosives require an ambient gas medium to form a fluid shockwave. In the vacuum of space (localAtmosphere = 0), the absence of air molecules means an overpressure air-blast cannot manifest. Instead, the blast's energy transitions entirely into fast-moving chemical gas expansion and high-velocity casing fragmentation. Without atmospheric drag to slow it down, this shrapnel retains maximum kinetic energy over distance.
The Code: When localAtmosphere is 0, shockwaveMultiplier forces fluid air-shock damage to zero, while fragmentDamageMultiplier scales up the fragmentation damage to its maximum threshold. On high-pressure planets or inside pressurized base rooms (localAtmosphere >= 1.0), the ratio automatically flips, dampening shrapnel while simulating a crushing overpressure environment.

2. Vector Pressure Initialization

csharp

float airShockPressure = (baseExplosionForce * shockwaveMultiplier) / (distanceToGrid * distanceToGrid); float shrapnelPressure = (baseExplosionForce * (1.0f - Math.Clamp(localAtmosphere, 0.0f, 1.0f)) * fragmentDamageMultiplier) / distanceToGrid;

The Physics: Fluid overpressure waves follow the inverse-square law (1/d²) because their volumetric energy dissipates rapidly as a expanding three-dimensional sphere. Shrapnel fragmentation, however, spreads linearly over distance (1/d) because individual physical projectiles maintain their specific mass and speed until hitting a surface.
The Code: By dividing airShockPressure by the distance squared and shrapnelPressure by the single distance value, the game engine naturally simulates real combat profiles. Space battles feature sharp, pinpoint hull punctures, whereas atmospheric base raids result in wide, catastrophic structural crumpling.

3. Contiguous Material Continuity Loop

csharp

if (!targetBlock.IsArmor) { cumulativeArmorThickness = 0.0f; } else { cumulativeArmorThickness += targetBlock.SizeInMeters; }

The Physics: When a shockwave transitions between two materials of wildly different densities (such as steel-to-air, or armor-to-machinery), it encounters an impedance mismatch. The stress wave reflects backward or scatters. If the metal is continuous and unbroken, it behaves as a single monolithic block, distributing the structural load throughout its collective mass.
The Code: This loop walks step-by-step through the voxel grid along the ray's path. If three small 0.5-meter blocks are welded side-by-side without gaps, cumulativeArmorThickness continuously sums up to 1.5 meters. If an interior air gap or a soft reactor block is hit, the counter instantly resets to 0.0. This gives players the engineering freedom to design solid heavy hulls or multi-layered spaced armor.

4. Exponential Backing Law

csharp

float thicknessScalingFactor = 1.0f + (float)Math.Pow(cumulativeArmorThickness, 1.5); float effectiveYieldStrength = targetBlock.BaseYieldStrength * thicknessScalingFactor;

Physics: A massive block of metal resists damage exponentially better than several thin sheets of the same cumulative thickness. This is because the internal structural layers act as an physical "backing support," distributing the crushing stress across a vast crystalline network and preventing the front face from easily bowing or shearing inward.
The Code: Instead of checking each block with an unvarying static health bar (the flaw of SE1), the code uses an exponential power scaling factor (Math.Pow(..., 1.5)). An individual outer block has standard resistance, but a block buried deep inside a 2.5-meter thick composite stack calculates an immensely elevated effectiveYieldStrength. This mimics the resilience of real-world heavy naval or tank armor.

5. Material Damage Regime Evaluation

Regime A: Surface Erosion / Total Deflection

csharp

if (currentVectorPressure < effectiveYieldStrength) { ... }

The Physics: If the blast energy striking the plate is lower than the armor's yield point, the metal will not undergo permanent plastic deformation. Hardened composite alloys absorb the shockwaves cleanly, resulting only in minor surface melting, shallow ablation, or surface scratches.
The Code: The block subtracts a minor fraction of superficial integrity, sets the remaining ray energy to zero, and triggers a code break. This completely stops the ray, guaranteeing that absolutely no "phantom damage" leaks through to sensitive interior components hidden behind an intact wall.

Regime B: Mechanical Deformation & Internal Spalling

csharp

else if (currentVectorPressure >= effectiveYieldStrength && currentVectorPressure < (effectiveYieldStrength * 3.0f)) { targetBlock.Integrity -= currentVectorPressure; // ... SHOCK ATTENUATION AND MASS DAMPENING currentVectorPressure *= (0.50f / (targetBlock.MaterialDensity * cumulativeArmorThickness)); }

The Physics: When the incoming blast wave exceeds the material's yield strength but stays below its ultimate structural failure point, the metal bends and warps. The compression wave travels through the armor, hitting the backside boundary. It reflects back as a violent tensile wave, tearing the back of the armor plate apart from the inside out via spalling. However, a solid block's massive inertia (mass dampening) and internal composite layers scatter and flatten the wave's peak intensity before it can escape.
The Code: The block takes significant structural damage and morphs its visual mesh. Crucially, the remaining pressure vector is divided by targetBlock.MaterialDensity * cumulativeArmorThickness. High-density heavy armor stacks will instantly choke out the remaining pressure wave to zero, whereas thin, low-density light armor blocks let a massive portion of the blast energy bleed through to the next layer.

Regime C: Plugging / Hydrodynamic Punch-Through

csharp

else { targetBlock.Destroy(); currentVectorPressure -= effectiveYieldStrength; }

The Physics: When blast pressures are extraordinarily high, material strength becomes entirely irrelevant. The interaction enters the hydrodynamic regime, where solid steel is pressurized so severely that it behaves precisely like a fluid. The blast wave physically shears a broad, ragged cylinder of metal (a "plug") straight out of the wall, or vaporizes the mass entirely.
The Code: The block is instantly deleted from the grid and spawns fractured debris particles. The remaining vector pressure is reduced by the block's effectiveYieldStrength (representing the energy spent to punch through that layer) and continues traveling forward along the ray path to challenge the next block in line.

Heavy armor should be very resistant to surface explosions like warheads honestly since it's largely a matter of the material and thickness of said material that determines whether the pressure wave from the explosion is enough to cause the armor to buckle or transfer enough of said energy through the armor for micro fracturing. Without shaped charges and the like, armor would act as a reflector of sorts and direct the blast away from it.

In this case, it might be 'simplified' to measure the explosive effect on armor based on a minimum thickness of said material,. distance from the blast and how wide the unsupported surface is. A 2.5 meter thick block of heavy armor would shrug of a non shaped charge explosion out into the range of 10,000 kilograms of TNT. For perspective, that's 10 standard US mk-84 heavy aircraft bombs all hitting at the same time. At that level, you'd start to see some spalling on the back side (damage to the opposite side due to the shockwave passing through the material) and the surface might show some pitting and damage.

Thinner sheets of the same material would obviously take more damage from that blast, as would (oddly enough) a number of 2.5m blocks stacked together into a continuous wall. The reason is that a lot of that energy that passes into that 'wall' would cause it to buckle under the pressure, where a single 2.5m block has less ability to flex.

I'd like it if the damage calculations for explosions would not consider each block independently (like the SE1 model where it just damaged each block and then passed the rest of the damage through)

Also, the behavior of said explosives also depends on the atmospheric pressure. A warhead going boom in space is vastly different than one going boom at sea level in how it affects armor.

I dunno why, but I had Google AI crank out a sample algorithm and pseudocode (I'll call it that until I know it actually would work) for a rough concept. Apologies for the AI 'stuff' but it was just a lot easier this way.

Complete Code Implementation Template for Dynamic Armor Damage vs. Explosions in C#/VRAGE3

csharp

using System;
using System.Collections.Generic;

public class BlastDamageSystem
{
    public struct BlockMaterialProfile
    {
        public bool IsArmor;              // Identifies structural armor plating
        public float BaseYieldStrength;   // Initial material strength limit in Megapascals (MPa)
        public float MaterialDensity;     // Dense alloy rating (Heavy Armor >> Light Armor)
        public float AttenuationFactor;   // Internal shockwave scattering coefficient (0.0 to 1.0)
        public float SizeInMeters;        // Physical thickness of the block grid space
        public float Integrity;           // Active block health pool
        
        public void Destroy() { /* Triggers block fracture debris meshes */ }
        public void ApplyVisualDeformation(float shockwaveIntensity) { /* Morphs the block geometry */ }
    }

    public interface IGridHitResult
    {
        IEnumerable<BlockMaterialProfile> GetBlocksAlongRayPath(Vector3 direction);
    }

    public struct Vector3 { public float X, Y, Z; }

    public void ProcessExplosionVector(Vector3 rayDirection, float distanceToGrid, IGridHitResult hitResult, float baseExplosionForce, float localAtmosphere)
    {
        // ---------------------------------------------------------------------
        // 1. ENVIRONMENTAL ATMOSPHERIC LAW
        // ---------------------------------------------------------------------
        float shockwaveMultiplier = Math.Clamp(localAtmosphere, 0.0f, 2.0f);
        float fragmentDamageMultiplier = 1.0f + (1.0f - Math.Clamp(localAtmosphere, 0.0f, 1.0f)) * 0.75f;

        // ---------------------------------------------------------------------
        // 2. VECTOR OVERPRESSURE AND SHRAPNEL INITIALIZATION
        // ---------------------------------------------------------------------
        float airShockPressure = (baseExplosionForce * shockwaveMultiplier) / (distanceToGrid * distanceToGrid);
        float shrapnelPressure = (baseExplosionForce * (1.0f - Math.Clamp(localAtmosphere, 0.0f, 1.0f)) * fragmentDamageMultiplier) / distanceToGrid;
        
        float currentVectorPressure = airShockPressure + shrapnelPressure;
        float cumulativeArmorThickness = 0.0f;

        // ---------------------------------------------------------------------
        // 3. CONTIGUOUS MATERIAL CONTINUITY LOOP
        // ---------------------------------------------------------------------
        foreach (BlockMaterialProfile targetBlock in hitResult.GetBlocksAlongRayPath(rayDirection))
        {
            if (!targetBlock.IsArmor)
            {
                cumulativeArmorThickness = 0.0f; // Reset if the ray hits an air gap or machinery
            }
            else
            {
                cumulativeArmorThickness += targetBlock.SizeInMeters; // Accumulate thick slab depth
            }

            // ---------------------------------------------------------------------
            // 4. EXPONENTIAL BACKING LAW (MONOLITHIC THICKNESS CALCULATOR)
            // ---------------------------------------------------------------------
            float thicknessScalingFactor = 1.0f + (float)Math.Pow(cumulativeArmorThickness, 1.5);
            float effectiveYieldStrength = targetBlock.BaseYieldStrength * thicknessScalingFactor;

            // ---------------------------------------------------------------------
            // 5. MATERIAL DAMAGE REGIME EVALUATION
            // ---------------------------------------------------------------------
            if (currentVectorPressure < effectiveYieldStrength)
            {
                // REGIME A: SURFACE EROSION / TOTAL DEFLECTION
                targetBlock.Integrity -= (currentVectorPressure * 0.05f);
                currentVectorPressure = 0.0f; 
                break; 
            }
            else if (currentVectorPressure >= effectiveYieldStrength && currentVectorPressure < (effectiveYieldStrength * 3.0f))
            {
                // REGIME B: MECHANICAL DEFORMATION & INTERNAL SPALLING
                targetBlock.Integrity -= currentVectorPressure;
                targetBlock.ApplyVisualDeformation(shockwaveMultiplier);
                
                // SHOCK ATTENUATION AND MASS DAMPENING
                currentVectorPressure *= (0.50f / (targetBlock.MaterialDensity * cumulativeArmorThickness));
            }
            else
            {
                // REGIME C: PLUGGING / HYDRODYNAMIC PUNCH-THROUGH
                targetBlock.Destroy();
                currentVectorPressure -= effectiveYieldStrength;
            }

            if (currentVectorPressure <= 0.01f)
            {
                break;
            }
        }
    }
}

Detailed Mathematical & Physics Logic Breakdown

1. Environmental Atmospheric Law

csharp

float shockwaveMultiplier = Math.Clamp(localAtmosphere, 0.0f, 2.0f); float fragmentDamageMultiplier = 1.0f + (1.0f - Math.Clamp(localAtmosphere, 0.0f, 1.0f)) * 0.75f;

The Physics: Conventional explosives require an ambient gas medium to form a fluid shockwave. In the vacuum of space (localAtmosphere = 0), the absence of air molecules means an overpressure air-blast cannot manifest. Instead, the blast's energy transitions entirely into fast-moving chemical gas expansion and high-velocity casing fragmentation. Without atmospheric drag to slow it down, this shrapnel retains maximum kinetic energy over distance.
The Code: When localAtmosphere is 0, shockwaveMultiplier forces fluid air-shock damage to zero, while fragmentDamageMultiplier scales up the fragmentation damage to its maximum threshold. On high-pressure planets or inside pressurized base rooms (localAtmosphere >= 1.0), the ratio automatically flips, dampening shrapnel while simulating a crushing overpressure environment.

2. Vector Pressure Initialization

csharp

float airShockPressure = (baseExplosionForce * shockwaveMultiplier) / (distanceToGrid * distanceToGrid); float shrapnelPressure = (baseExplosionForce * (1.0f - Math.Clamp(localAtmosphere, 0.0f, 1.0f)) * fragmentDamageMultiplier) / distanceToGrid;

The Physics: Fluid overpressure waves follow the inverse-square law (1/d²) because their volumetric energy dissipates rapidly as a expanding three-dimensional sphere. Shrapnel fragmentation, however, spreads linearly over distance (1/d) because individual physical projectiles maintain their specific mass and speed until hitting a surface.
The Code: By dividing airShockPressure by the distance squared and shrapnelPressure by the single distance value, the game engine naturally simulates real combat profiles. Space battles feature sharp, pinpoint hull punctures, whereas atmospheric base raids result in wide, catastrophic structural crumpling.

3. Contiguous Material Continuity Loop

csharp

if (!targetBlock.IsArmor) { cumulativeArmorThickness = 0.0f; } else { cumulativeArmorThickness += targetBlock.SizeInMeters; }

The Physics: When a shockwave transitions between two materials of wildly different densities (such as steel-to-air, or armor-to-machinery), it encounters an impedance mismatch. The stress wave reflects backward or scatters. If the metal is continuous and unbroken, it behaves as a single monolithic block, distributing the structural load throughout its collective mass.
The Code: This loop walks step-by-step through the voxel grid along the ray's path. If three small 0.5-meter blocks are welded side-by-side without gaps, cumulativeArmorThickness continuously sums up to 1.5 meters. If an interior air gap or a soft reactor block is hit, the counter instantly resets to 0.0. This gives players the engineering freedom to design solid heavy hulls or multi-layered spaced armor.

4. Exponential Backing Law

csharp

float thicknessScalingFactor = 1.0f + (float)Math.Pow(cumulativeArmorThickness, 1.5); float effectiveYieldStrength = targetBlock.BaseYieldStrength * thicknessScalingFactor;

Physics: A massive block of metal resists damage exponentially better than several thin sheets of the same cumulative thickness. This is because the internal structural layers act as an physical "backing support," distributing the crushing stress across a vast crystalline network and preventing the front face from easily bowing or shearing inward.
The Code: Instead of checking each block with an unvarying static health bar (the flaw of SE1), the code uses an exponential power scaling factor (Math.Pow(..., 1.5)). An individual outer block has standard resistance, but a block buried deep inside a 2.5-meter thick composite stack calculates an immensely elevated effectiveYieldStrength. This mimics the resilience of real-world heavy naval or tank armor.

5. Material Damage Regime Evaluation

Regime A: Surface Erosion / Total Deflection

csharp

if (currentVectorPressure < effectiveYieldStrength) { ... }

The Physics: If the blast energy striking the plate is lower than the armor's yield point, the metal will not undergo permanent plastic deformation. Hardened composite alloys absorb the shockwaves cleanly, resulting only in minor surface melting, shallow ablation, or surface scratches.
The Code: The block subtracts a minor fraction of superficial integrity, sets the remaining ray energy to zero, and triggers a code break. This completely stops the ray, guaranteeing that absolutely no "phantom damage" leaks through to sensitive interior components hidden behind an intact wall.

Regime B: Mechanical Deformation & Internal Spalling

csharp

else if (currentVectorPressure >= effectiveYieldStrength && currentVectorPressure < (effectiveYieldStrength * 3.0f)) { targetBlock.Integrity -= currentVectorPressure; // ... SHOCK ATTENUATION AND MASS DAMPENING currentVectorPressure *= (0.50f / (targetBlock.MaterialDensity * cumulativeArmorThickness)); }

The Physics: When the incoming blast wave exceeds the material's yield strength but stays below its ultimate structural failure point, the metal bends and warps. The compression wave travels through the armor, hitting the backside boundary. It reflects back as a violent tensile wave, tearing the back of the armor plate apart from the inside out via spalling. However, a solid block's massive inertia (mass dampening) and internal composite layers scatter and flatten the wave's peak intensity before it can escape.
The Code: The block takes significant structural damage and morphs its visual mesh. Crucially, the remaining pressure vector is divided by targetBlock.MaterialDensity * cumulativeArmorThickness. High-density heavy armor stacks will instantly choke out the remaining pressure wave to zero, whereas thin, low-density light armor blocks let a massive portion of the blast energy bleed through to the next layer.

Regime C: Plugging / Hydrodynamic Punch-Through

csharp

else { targetBlock.Destroy(); currentVectorPressure -= effectiveYieldStrength; }

The Physics: When blast pressures are extraordinarily high, material strength becomes entirely irrelevant. The interaction enters the hydrodynamic regime, where solid steel is pressurized so severely that it behaves precisely like a fluid. The blast wave physically shears a broad, ragged cylinder of metal (a "plug") straight out of the wall, or vaporizes the mass entirely.
The Code: The block is instantly deleted from the grid and spawns fractured debris particles. The remaining vector pressure is reduced by the block's effectiveYieldStrength (representing the energy spent to punch through that layer) and continues traveling forward along the ray path to challenge the next block in line.

Reply URL

2

Wilhelm ●

Some of this applies to my feedback of 'armor should have a minimum threshold for damage as some things you do to armor just shouldn't be enough to even scratch it. I should be abl eto shoot my pistol in game at a block of heavy armor all day and never do a point of damage, just coat the surface with splotches of lead and copper jacket.

Reply URL

2

Semtex ●

Possible solution:

Let’s imagine the explosive charge as a block. Upon detonation, it is surrounded by 26 other blocks in a 3x3x3 structure.

It is connected to 6 adjacent blocks by walls (neighborhood weight 1), to 12 blocks by edges (neighborhood weight 1/sqr 2 ~ 0.707), and to 8 blocks by corners (neighborhood weight 1/sqr 3 ~ 0.577).

According to this scheme, the explosion’s energy could be distributed to neighboring blocks.

A neighboring block absorbs the explosion’s energy and uses a certain portion (1/3 - 1/2 - 2/3 ???) is used to inflict damage on itself (if this energy exceeds the damage threshold—if not, it simply absorbs it), and the remaining energy is distributed to its own neighboring blocks, again in a 3x3x3 structure and according to the same scheme—this should simulate the transmission of a shock wave.

If a “neighboring block” is empty space, it distributes all the energy to the surrounding area.

If a block is destroyed while absorbing energy intended to damage it before the energy is fully consumed, the remaining portion is also distributed to the surrounding blocks.

In this model, a block can be struck by the explosion’s energy repeatedly.

In this model, a block can be damaged by a nearby explosion in open space.

The disadvantage is the computational complexity—the number of affected blocks increases very rapidly, roughly in the order of 27–125–343–729–1331.

I'm not a programmer, so I have no idea how this model could be translated into code.

Reply URL

2

Wilhelm ●

In the case of the suggestion above, to simplify, basically when a 'boom' happens, it determines the atmospheric pressure that the 'boom' happens in (which matters a lot to 'booms') and then shoots out invisible rays (vectors) from the point of 'boom'. When it encounters a material, it determines that material type and then continues through that material until it hits another material (or air/vacuum). This test ignores whether that material is one block or multiple blocks. Then it calculates the damage to the affected block(s) based on the distance from 'boom', material, thickness of said material (combined) and the atmospheric pressure the explosion happened at.

This would provide a fairly realistic explosion damage pattern, and if you threw in an added calculation (probably too resource intensive) for reflecting pressure waves, you could build your own shaped charges and the like, which would be awesome.

Reply URL

2

Vanguard ●

@Willhelm I commented on this in your other thread regarding minimum threshold, 2.5m armor in SE is not 2.5m "thick". Its a hollow box filled with trusses, with steel plates on the facades. A heavy is only 2x the mass of a light, as it uses twice the plates, so no, it wouldn't take 10 Mk84 bombs... The issue I have both here and in the other thread is this. a 2.5m block is:

Plate

Gap

Plate

5 deep of 0.5 blocks is

Plate

Gap

Plate

Gap

Plate

Gap

Plate

Where is Plate/Gap/Plate is 0.5m

And this is considered in the build cost, if you break it down and the "plates" per 0.5m2 as per the other thread. I'm not saying I disagree at all with the proposal or what you're suggesting should happen though, I'm just pointing out that armor and it's cost would need an overhaul to achieve what you're after. With the unified grid system I do think it's bonkers that, again as I said before, I need to break up a 5x5 large block into 125 little blocks just so I can paint a pinstripe down it.

1 2.5 Cube = 1070 hitpoints

125 0.5 Cubes (same volume) = 3,648.75 hitpoints

I've seen some other games that solved this issue by having a base set of blocks that you can stretch in the 3 axis's, so a 2.5m cube is a scaled up 0.5m cube, which scales the build cost for surface area, but the surface is the same thickness, so all light armor is X mm thick no matter how big it is. Want it thicker... layer it.

Reply URL

1

Wilhelm ●

I would argue that if it's a hollow box then it's not armor it's just a structural box. It would need to be solid plates of some type of high density metal or high tech ceramic. Armor, especially heavy like tank armor is measured in solid thickness of material. Having a hollow center with non-protective air gaps and structure is a waste of mass. It would be more effective if you got rid of the middle gap and mashed the ends together, less mass and stronger in a smaller space.

Absolutely get what you're saying and the above 'pseudocode' would handle what you're describing just fine also since it accounts for air gaps in the logic.

URL

1

Vanguard ●

Well it's definitely a hollow box, you can see it and the trusses as you're building it, and the mass of build materials works out accordingly, but hollow or not, it still has a thickness in the traditional sense, the "thickness" of the armor is still be measurable by the thickness of the plates. I.e. heavy armor is 2x light armor because it's 2x the number of plates. The only thing unique here is that by design, every block in SE is somewhat naturally "spaced armor".

Remember the ammo is SE is 24x184mm bullets, so it's not even A-10 level brrrrrrrrrt, so the plates should be around 35-50mm thick. Definitely 1 Mk84 worth, hence why rockets are blowing them to bits.

URL

1

Wilhelm ●

Right, and saving the space and internal structure would make it more 'armor-like' vs. structural blocks with some metal wrapped around it. i.e. this is the future and it's really crappy armor and bad space engineering if they went with hollow boxes (not in game but in lore) as some sort of 'heavy armor' against mostly ballistic weapons.

The videos that I've seen posted here about how the explosives just do damage in a radius is not how this should work once we get to the finished game. The logic I'm shooting for is something that takes into account things like air gaps and thickness of materials and the air pressure (or lack thereof) when the explosive goes boom. It all works with the current 'armor-like substance' and would reward better armor schemes and thickness of armor if they went to stacked plates vs. hollow box. One could argue that the inner structure could be all scaffolding and an inner air-sealed area(s) and then you slap light or heavy armor plates on the parts you want.

Anyway...I have to go update my license thread. Cheers.

URL

1

Vanguard ●

Right, just to re-iterate, I'm all for what you're suggesting, and I completely agree with the principle, even if they didn't change the underlying visuals or materials or change the math for the cost of the structure to align with your vision, I'd still welcome better accountability of damage propagation.

I suppose the heart of what I'm getting at here is, should a single large 5x5 (2.5m) block have the same "outer" durability/thickness of 125 small cubes making up the same volume? Again as I pointed out in the other thread, if I were to hypothetically convert my single 2.5m cube to little cubes simply to add some depth and decoration, on one hand it should be treated the same as a single 2.5m block, but on the other hand, I can use a gat and shoot through a single column of 5 0.5m cubes to start hitting components inside the ship, and I'm not really sure how you can account for that. Blast explosion using your math yes, single rounds punching a hole through the middle column, no, and I'm not sure what to suggest here either.

URL

1

Wilhelm ●

Oh yeah, I get it totally. The blast vector logic in the code above basically calculates a number of vectors (invisible) that simulate the damage wave expanding from the boom. Those vectors go through any blocks they encounter and calculate the thickness (contiguous) of each material, air gap, unarmored, light armor, heavy that each vector passes through. That's the thickness of each that the explosive is tested against, even if it's 125 small heavy armor cubes or one big one.

This is really just relating to how to calculate damage from non-shaped charge explosives. Not sure if rockets in game I'd consider shaped charge as they seem to be essentially 1940's unguided rockets that explode on contact with a surface (not fast enough to measurably penetrate the armor prior to explosion). Artillery I could see as delayed fuse (penetrate the armor and go boom inside) but they also seem to explode on the surface so they're probably just HE rounds.

Bullets I'd have to go to the 'armor minimum threshold for damage' thread. Non armor piercing ammo I'd have to say heavy armor should be pretty resistant to even if from an A-10 brrrp gun. You start talking about depleted uranium AP ammo and that's a different ballgame.

URL

1

Vanguard ●

I've tried I think 5 times now, and I'm sure it's me and not you, but I'm definitely not getting my point across. Your code (appropriately IMHO) treats a blob of 125 small cubes like a 2.5m cube, trying to effectively give the two volumes an equal amount of damage. What I'm trying to say is, we'd need to do the same for bullets, otherwise in the 125 (5x5x5 0.5m) case, I can needle straight through a column of 5 small blocks and start damaging underlying components well before I could ever do the same shooting at the same 2.5m block. No sense in having explosive damage and kinetic treating the surfaces different. And I'm saying I'm not sure how to do that, same way? Disperse the HP to neighboring blocks so you can't needle through the thin column.

URL

1

Wilhelm ●

No, you're getting it across, no issues. In a way you're absolutely correct and the physics actually lines up 'okay-ish' with that observation. Explosion energy vs. armor (non-shaped charge) is spread evenly along the entire surface of armor with a longer duration (relatively) of stress to the armor surface via pressure wave. A ballistic impact is a shorter duration, very localized impact that damages largely only the specific area (some spreading of the energy through the structure of the armor and spalling on thinner armors).

Using your 1 large block vs. 125 small blocks analogy, an explosion would be spread across the 25 blocks on the surface of the cube, the ones behind providing structural support to resist the pressure wave of the blast as the energy passes into the armor block (the 125). This might destroy the outer blocks and damage ones inside (maybe) A neat detail in this would be that some of the inner blocks on the opposite side of the block might also be damaged as the energy from the explosion hits the far side of the block of 125 as the pressure wave rebounds back into the block (vs. being transferred into the next 'material' inline). Essentially spalling.

Looking at the ballistic impact in the same manner, all the energy density of the projectile is transferred into the point of impact, which would be one block. That block would absorb that damage, possibly be close to being destroyed (if it's AP ammo). When that block fails, now you're applying the very localized ballistic impact to the next block in the chain until you have a hole through it. You have to remember that non-AP vs. heavy armor a lot of the energy of the impact is reflected back into the projectile and often they do more damage to the bullet than to the armor, lead-core you're just painting the surface with lead and not doing much else. Anyway, the point is that the boom damage is spread out (even though it's a bigger boom) across the surface of the armor and projectiles are very localized.

Reminds me of a very early, long archived feedback I provided requesting exactly this sort of thing where as an armor block gets damaged it (logically) breaks into an array of smaller blocks. i.e. my single large block of armor gets hit, the engine responds by turning it into smaller blocks. A boom goes off and the large block is split into eight smaller blocks and at the same time the explosion-facing side is turned into smaller and smaller blocks, some of which are damaged. Leaving a pitted but mostly intact armor block with a facing that has visible damage (think old timey asteroids game) in the form of smaller attached blocks that survived.

Without the above, the one large monolithic block would suffer damage by both equally (less satisfying) since you're applying damage across the entire armor face regardless of where the projectile actually hits. In a way this makes bullets against the larger blocks like mini explosions that apply to the entire surface. I could shoot it in the upper left corner or the lower right, both damage the block in the same way and eventually cause the whole block to fail (yuk).

No, you're getting it across, no issues. In a way you're absolutely correct and the physics actually lines up 'okay-ish' with that observation. Explosion energy vs. armor (non-shaped charge) is spread evenly along the entire surface of armor with a longer duration (relatively) of stress to the armor surface via pressure wave. A ballistic impact is a shorter duration, very localized impact that damages largely only the specific area (some spreading of the energy through the structure of the armor and spalling on thinner armors).

Using your 1 large block vs. 125 small blocks analogy, an explosion would be spread across the 25 blocks on the surface of the cube, the ones behind providing structural support to resist the pressure wave of the blast as the energy passes into the armor block (the 125). This might destroy the outer blocks and damage ones inside (maybe) A neat detail in this would be that some of the inner blocks on the opposite side of the block might also be damaged as the energy from the explosion hits the far side of the block of 125 as the pressure wave rebounds back into the block (vs. being transferred into the next 'material' inline). Essentially spalling.

Looking at the ballistic impact in the same manner, all the energy density of the projectile is transferred into the point of impact, which would be one block. That block would absorb that damage, possibly be close to being destroyed (if it's AP ammo). When that block fails, now you're applying the very localized ballistic impact to the next block in the chain until you have a hole through it. You have to remember that non-AP vs. heavy armor a lot of the energy of the impact is reflected back into the projectile and often they do more damage to the bullet than to the armor, lead-core you're just painting the surface with lead and not doing much else. Anyway, the point is that the boom damage is spread out (even though it's a bigger boom) across the surface of the armor and projectiles are very localized.

Reminds me of a very early, long archived feedback I provided requesting exactly this sort of thing where as an armor block gets damaged it (logically) breaks into an array of smaller blocks. i.e. my single large block of armor gets hit, the engine responds by turning it into smaller blocks. A boom goes off and the large block is split into eight smaller blocks and at the same time the explosion-facing side is turned into smaller and smaller blocks, some of which are damaged. Leaving a pitted but mostly intact armor block with a facing that has visible damage (think old timey asteroids game) in the form of smaller attached blocks that survived.

Without the above, the one large monolithic block would suffer damage by both equally (less satisfying) since you're applying damage across the entire armor face regardless of where the projectile actually hits. In a way this makes bullets against the larger blocks like mini explosions that apply to the entire surface. I could shoot it in the upper left corner or the lower right, both damage the block in the same way and eventually cause the whole block to fail (yuk).

URL

1

Vanguard ●

We're almost there, but I'm still not convinced my point is making it through 🙃.

"In a way you're absolutely correct and the physics actually lines up 'okay-ish' with that observation."

Yes, but that's the problem I have. Sure it's more physically accurate in the small block case, but then less accurate in the large block case. So it's still broken.

If I were to break up a 2.5m cube into 125 purely for decoration purposes (like I want to paint a cross on it, so I'm forced (currently) to break it up, I will end up with a completely different outcome when being shot at. In the explosive case, the whole chunk is treated effectively as a 2.5m cube, kinetically it's treated as a columns of 5 cubes. Shoot the big cube, as you say, the energy gets dispersed, shoot the small ones it'll drill through. So it's, as you say, more physically accurate in the small block case, but also as you say, less accurate in the large block case.

Bottom line: I'm saying if the math behind the explosive code is going to treat the 1 large and 125 small the same, the kinematic code should too. The game should ideally treat the aggregate blocks in an area as a single contiguous piece in both cases, otherwise we get two different outcomes based on design when choosing different weapon types, and IMHO it should be consistent, one way or the other. The big guy breaks up, or the small guy is treated as a big guy.

URL

1

Wilhelm ●

I'll get my noggin to work, they already archived my old suggestion to have damage start to 'fracture' the larger block into a grid of smaller blocks, essentially ending up at the 125 in both cases. That would be my preference since I think it would look more visually cool to have real pitting in damaged armor reflecting actual hits (vs the static fracture effects they use).

Since it's bedtime, the only first pass thought I'd have to think about is that attached armor blocks have their own 'hit points', but also share a pool of hit points with attached nearby blocks of the same type. Each block would have its own pool and a shared pool with those within 'range'.

I think (my sleepy brain tells me) this would work in a way where the total hit points of the 125 would share essentially the same pool of hit points as the one larger block. You hit the big block, you have to overcome its HP (since it has nothing attached), you hit the small block, some comes off the block that was hit, but most of it (unless AP ammo) comes out of the shared pool of hit points which combined adds up to the same as the single large block. In this case, some of the damage is spread (evenly but diminished by distance) among the other blocks. So you shoot the lower left small cube and every attached armor block in the vicinity takes a bit of that shared damage spread along all of them. The hit block takes the most, the one farthest away takes the least. This could still use the vector calculations I mentioned for explosives.

Essentially the two blocks have the same total hit points.

Even in the ballistic case I mentioned above, some of the kinetic energy from the projectile would spread through the armor, so as I mentioned above treating it like small explosions is actually relevant in a way, since the impact would still send small shockwaves through the adjoining blocks and some of the damage would go to them too. The shared hit point pool idea I guess helps make the two configurations react in a similar way. The same would then work if you took 3 or 4 larger blocks and stuck them together, the adjoining blocks would take some of the damage reducing the rate that the single block hit would fail.

I'll get my noggin to work, they already archived my old suggestion to have damage start to 'fracture' the larger block into a grid of smaller blocks, essentially ending up at the 125 in both cases. That would be my preference since I think it would look more visually cool to have real pitting in damaged armor reflecting actual hits (vs the static fracture effects they use).

Since it's bedtime, the only first pass thought I'd have to think about is that attached armor blocks have their own 'hit points', but also share a pool of hit points with attached nearby blocks of the same type. Each block would have its own pool and a shared pool with those within 'range'.

I think (my sleepy brain tells me) this would work in a way where the total hit points of the 125 would share essentially the same pool of hit points as the one larger block. You hit the big block, you have to overcome its HP (since it has nothing attached), you hit the small block, some comes off the block that was hit, but most of it (unless AP ammo) comes out of the shared pool of hit points which combined adds up to the same as the single large block. In this case, some of the damage is spread (evenly but diminished by distance) among the other blocks. So you shoot the lower left small cube and every attached armor block in the vicinity takes a bit of that shared damage spread along all of them. The hit block takes the most, the one farthest away takes the least. This could still use the vector calculations I mentioned for explosives.

Essentially the two blocks have the same total hit points.

Even in the ballistic case I mentioned above, some of the kinetic energy from the projectile would spread through the armor, so as I mentioned above treating it like small explosions is actually relevant in a way, since the impact would still send small shockwaves through the adjoining blocks and some of the damage would go to them too. The shared hit point pool idea I guess helps make the two configurations react in a similar way. The same would then work if you took 3 or 4 larger blocks and stuck them together, the adjoining blocks would take some of the damage reducing the rate that the single block hit would fail.

URL

1

Vanguard ●

Exactly so. Having the grid split itself up being the stretch goal, the middle ground woild be to treat the ammo effectively as HE rounds and using the same calculations as you've said. I think that would satisfy the issue gameplay and balance wise.

URL

Heavy armour and warheads

Replies (6)