- Joined
- Sep 14, 2017
- Messages
- 666
- Reaction score
- 928
Okay, so here is an idea to try to keep integrity working in spirit how it works now, but without all the major problems. I suggested something similar to this before, but this is about system specific integrity.
I will begin by outlining the major issues with current integrity:
// Blockcount is how many blocks you have in a system.
// FaceCount is how many exposed faces a system has.
/* ##### Configs ##### */
IntegritySensitivity = 5; // This config value means that the ideal integrity is set to the surface area of a 5:1:1 box. The following formula will work exactly the same for a 5 x 1 x 1 reactor as it would for a 50 x 10 x 10 reactor, even though they have different relative surface areas to volume. Adjusting this up or down allows for more or less creative freedom.
IntegrityIntensity = 2.0; // This config value determines how much integrity penalizes you once you breach the threshold. Adjusting this up or down exponentially inflicts more or less bonus damage against unstable ships.
/* ##### The Function ##### */
X=(Blockcount/IntegritySensitivity)^(-3); // X is the length of the short leg on a 5:1:1 box based on your Blockcount
TargetFaces =((X*X)+(X*X*IntegritySensitivity )+(X*X*IntegritySensitivity ))*2; // TargetFaces is the maximum surface area of an integrity stable reactor.
Integrity = TargetFaces/FaceCount;
If (Integrity > 1) { // a structure that is less than 1.0 integrity is stable. No need for further math
Penalty = Integrity^IntegrityIntensity; // Applies intensity as an exponential penalty. This means slightly unstable builds will have negligible penalties, but highly unstable builds will take massive bonus damage.
}
Here is an example of what this looks like against a spaghetti ship with a 10k system.
10,000 block system = 3,492 target faces
10,000 block spaghetti = 40,002 actual faces
10,000 block integrity = 11.46
10,000 block Penalty = 131.22
The block penalty in this case is a 131.22 x damage multiplier to this system's HP so instead of needing to destroy 7,500 of the blocks to disable it, you only need to take out 58. (unstable shield systems will also suffer this penalty to shieldHP).
I will begin by outlining the major issues with current integrity:
- It enforces a singular meta shape, a cube, to maximize integrity.
- Basing integrity on a spreadsheet of exposed faces on a block by block basis is bad for performance, and lacks certain configuration options for server admins who want to experiment with more or less permissive systems without totally breaking the curve.
- It also harshly penalises smaller ships, and is difficult to visualise at various scales.
- Constantly recalculating surface area and penalties takes a lot of extra processing. This alone is bad on performance, and further enforces the cubic system meta.
- Secondary explosions as an effect are VERY bad on performance. Damage lag seems about 10 times as bad as it used to be when systems are "burning".
- Secondary explosions do not kill Spaghetti ships fast enough. Since each explosion destroys so few blocks on a spaghetti ship, they can afford to burn much longer than other designs allowing them to kill other ships before any noticeable effect can be felt. This means integrity fails its primary purpose of preventing spaghetti ships.
- Secondary explosions overflow the damage buffer which leads to invulnerability.
- Only calculate changes in integrity during construction and rebooting, not from damage to systems.
- This will encourage creativity with system shapes by letting people build to the integrity threshold, and only punish them when they design their ship past that. This means, systems can be built in more shapes than cubes (so nice looking cylinders and spheres could work too), This will lead to more depth for PvP builds and more creativity for RP builds.
- It will also alleviate the combat lag from recalculating damage to a system.
- Instead of Secondary explosions, give each system an HP pool that determines how much damage it needs to take before becoming disabled. You can then replace integrity penalties as a damage multiplier, so that fragile systems become disabled after losing fewer blocks.
- This means way less math, and therefore, less lag, to achieve effectively the same outcome.
- It keeps your damage queue free for calculating actual weapon strikes
- The the effects of breaking a spaghetti ship are instantaneous instead of something you have to wait until after you are already dead to see pay off.
- Use an integrity calculation that allows a reactor of the same proportions regardless of the size of your ship. Ugh... but that sounds hard... but that's okay, I figured that part out for you. (see below):
// Blockcount is how many blocks you have in a system.
// FaceCount is how many exposed faces a system has.
/* ##### Configs ##### */
IntegritySensitivity = 5; // This config value means that the ideal integrity is set to the surface area of a 5:1:1 box. The following formula will work exactly the same for a 5 x 1 x 1 reactor as it would for a 50 x 10 x 10 reactor, even though they have different relative surface areas to volume. Adjusting this up or down allows for more or less creative freedom.
IntegrityIntensity = 2.0; // This config value determines how much integrity penalizes you once you breach the threshold. Adjusting this up or down exponentially inflicts more or less bonus damage against unstable ships.
/* ##### The Function ##### */
X=(Blockcount/IntegritySensitivity)^(-3); // X is the length of the short leg on a 5:1:1 box based on your Blockcount
TargetFaces =((X*X)+(X*X*IntegritySensitivity )+(X*X*IntegritySensitivity ))*2; // TargetFaces is the maximum surface area of an integrity stable reactor.
Integrity = TargetFaces/FaceCount;
If (Integrity > 1) { // a structure that is less than 1.0 integrity is stable. No need for further math
Penalty = Integrity^IntegrityIntensity; // Applies intensity as an exponential penalty. This means slightly unstable builds will have negligible penalties, but highly unstable builds will take massive bonus damage.
}
Here is an example of what this looks like against a spaghetti ship with a 10k system.
10,000 block system = 3,492 target faces
10,000 block spaghetti = 40,002 actual faces
10,000 block integrity = 11.46
10,000 block Penalty = 131.22
The block penalty in this case is a 131.22 x damage multiplier to this system's HP so instead of needing to destroy 7,500 of the blocks to disable it, you only need to take out 58. (unstable shield systems will also suffer this penalty to shieldHP).
Last edited:
......