Assault Transport Oversight?

[Captain Jack]

This sort of invalidates my wins to date.  Which may be a good thing, because I was starting to feel like difficulty 8 was really easy.

Then there's only one solution: win a game of 10/10 and force Chris to rebalance these.

[Red.Queen]

On the other, other hand

How many have you?

As many as I need, I just program more like T-1000.

<Carrier stuff>

That's a good point, the Carrier is pretty much a symbolic stand-in for the fleet, with slightly-tweaked stats to make the representation more concrete and not abstract like a traditional "unit stack."

Vote to leave Carriers as is noted.  This is my preference too, unless someone can present some cases where Carriers do something ridiculously OP due to their straight damage (surprise dropping Plasma Siege V or 500 Eyebots at the FF line are another story).

<Barracks stuff>

They're definitely not doing the exact same damage as their contents, I'm not sure yet what the value is that's getting multiplied against the total number of shots that are derived from the stuff inside.  I'll find it at some point.  Given how Barracks are noticeably less scary than what comes out, whatever is getting used there might be a good place to start for curbing the per-shot AT damage, in combination with curbing the number of total shots that comes from the strength/total number carried calcs.

Wow I didn't realize just how broken these things are.  I just crammed all my ships into them, then used them to kill all the things, sometimes unloading at the edge of the gravity well, then using the transports to tie up the enemies while my snipers & zombards blew them up.

This sort of invalidates my wins to date.  Which may be a good thing, because I was starting to feel like difficulty 8 was really easy.

Yeah, it's especially a problem when the ZOMGWTFBBQ damage combos with the damage not resetting on load/unload bug.  You can exploit the ever-loving crap out of things with that if you dump the fleet and then use the erroneously-still-juiced ATs *plus* the loose fleet.  It's at least easy to not take advantage of, by just standing down and parking off to the side the ATs when you drop the fleet (what I do, assuming I didn't work the ATs to the point they fell apart, which I commonly do).

Doesn't fix the issue with ATs being capable of doing insane damage though, sadly.  But it helps.  One step at a time.

This sort of invalidates my wins to date.  Which may be a good thing, because I was starting to feel like difficulty 8 was really easy.

Then there's only one solution: win a game of 10/10 and force Chris to rebalance these.

<chuckle>  Yeah that would probably bring the nerfhammer down hard.

***
Not aimed at anyone in particular -- I'm going to rephrase my makeshift poll request in a purely outcome-based manner that might work better for drawing out what I ultimately want to know.

You have a fleet.  You pack the ATs.  At what fleetstrength roughly does it feel like the ATs get stupid-OP? (I'd also be curious to know what raw difficulty setting you tend to use when you experience this as well, in case it reveals trends that might be useful to me.)  I can work from that to issue an experimental balance patch that the adventurous can try.

[Chris_Stalis]

Is the formula for ship strength published anywhere? I ask because, it's my observation that the ATs should cap out damage if they're filled with a mix of Mk I & Mk II fleet ships. This gives them definite utility even towards the late game, as I frequently find my Mk Is & IIs are far too easily crushed to bother wasting in a homeworld assault. This could give them a little extra lease on life.

[Red.Queen]

A first pass turns up two main formulas governing ship strength calcs.  They are rather complex.  I'm sticking them in spoiler foldouts at the bottom of this post to keep this readable.

The first thing the game does, is to determine how many ships of the current type of interest count as "one unit of Strength".  There are some special cases, but most of the time it divides 192 by the cap of the ship in question, then multiplies that result by the Mark of the ship.  So a Mark I Fighter is worth .5 of a basic unit of Strength at this stage in the calcs ((192/96)*1), while a Mark II Bomber would be 1.0 unit ((192/96)*2), and a Mark I Raidstar would be 64 units (((192/3)*1).  Not too complicated.

If a ship is marked as using the Unscaled formula, I think it pretty much stops here.  I doubt there are many of these -- it's probably mostly for special ships with caps of 1, where the game has a fixed strength value it forces.  I imagine that's things like Motherships, the Imperial Spire fleetships from FS, etc.

If a ship is marked as using the Scaled formula, it also uses a second function to get the final result of "what's this *really* worth, per unit?"  This is when it gets complicated as hell.  It proceeds to account for what it costs, how hard does it hit, what abilities does it have, etc.  Pretty cool.  Incidentally, this second formula also handles adjusting costs and other stats when you pick Low Caps, High Caps, etc in the lobby.

Compute Strength

Spoiler for Hiden:

    private FInt ComputeStrength(bool MultiplyByMarkLevel, out ForegroundUnitTypeImmutable.RelativeStrengthComputationType ComputationType)
    {
        FInt one;
        if (!(this.OverrideRelativeStrengthInCaps != (FInt)-1))
        {
            if (!this.UsesShipCap)
            {
                one = Mat.One;
                ComputationType = ForegroundUnitTypeImmutable.RelativeStrengthComputationType.UsesShipCap;
            }
            else if (this.IsAlwaysTreatedAsStrengthOneForReinforcementPurposes)
            {
                one = Mat.One;
                ComputationType = ForegroundUnitTypeImmutable.RelativeStrengthComputationType.IsAlwaysTreatedAsStrengthOneForReinforcementPurposes;
            }
            else if (this.BaseShipCap == 0)
            {
                one = Mat.One;
                ComputationType = ForegroundUnitTypeImmutable.RelativeStrengthComputationType.Default;
            }
            else if (!this.UsesScaledShipCaps)
            {
                one = (FInt)192 / (FInt)this.BaseShipCap;
                ComputationType = ForegroundUnitTypeImmutable.RelativeStrengthComputationType.BaseShipCapUnscaled;
            }
            else
            {
                one = (FInt)192 / (FInt)this.BaseShipCap;
                ComputationType = ForegroundUnitTypeImmutable.RelativeStrengthComputationType.BaseShipCapScaled;
            }
            if (this.IsTurret)
            {
                one = one * 3;
            }
        }
        else
        {
            one = this.OverrideRelativeStrengthInCaps * Configuration.RelativeStrengthPerStandardMarkICap;
            ComputationType = ForegroundUnitTypeImmutable.RelativeStrengthComputationType.OverrideRelativeStrengthInCaps;
        }
        if (this.RelativeStrengthSpecialMultiplier != Mat.One)
        {
            one = one * this.RelativeStrengthSpecialMultiplier;
        }
        if ((!MultiplyByMarkLevel ? false : this.ShipLevel > 0))
        {
            one = one * this.ShipLevel;
        }
        return one;
    }

Compute Scaled

Spoiler for Hiden:

    private void ComputeUnitScaleAlternates()
    {
        int num;
        bool usesScaledShipCaps = this.UsesScaledShipCaps;
        bool flag = (this.BaseAutoCreateAtBuildPointCount > 0 ? true : this.BaseAbstractedAutoFactoryBuildPointsPerShip > 0);
        bool instaKillsLowerShips = this.InstaKillsLowerShips;
        if ((usesScaledShipCaps || flag ? true : instaKillsLowerShips))
        {
            this.scaleAlternatives = new UnitDataScaledStatisticsSet[(int)UnitCapScaleData.LargestOrdinal + (int)UnitCapScaleType.Normal];
            for (int i = 0; i < (int)this.scaleAlternatives.Length; i++)
            {
                UnitCapScaleType unitCapScaleType = (UnitCapScaleType)i;
                UnitDataScaledStatisticsSet baseMetalCost = new UnitDataScaledStatisticsSet();
                switch (unitCapScaleType)
                {
                    case UnitCapScaleType.Low:
                    {
                        num = 2;
                        break;
                    }
                    case UnitCapScaleType.Normal:
                    {
                        num = 1;
                        break;
                    }
                    case UnitCapScaleType.High:
                    {
                        num = 0;
                        break;
                    }
                    case UnitCapScaleType.UltraLow:
                    {
                        num = 3;
                        break;
                    }
                    default:
                    {
                        num = 0;
                        break;
                    }
                }
                bool flag1 = num < 0;
                if (flag1)
                {
                    num = -num;
                }
                baseMetalCost.ScaledMetalCost = this.BaseMetalCost + this.BaseOtherMetalCost;
                baseMetalCost.ScaledEnergyUse = this.BaseEnergyUse;
                baseMetalCost.ScaledMaxHealth = this.BaseMaxHealth;
                baseMetalCost.ScaledRegenPerSecond = this.BaseRegenPerSecond;
                baseMetalCost.ScaledGetsEatenPerSecond = this.BaseGetsEatenPerSecond;
                baseMetalCost.ScaledAttackPower = this.BaseAttackPower;
                baseMetalCost.ScaledArmorRating = this.BaseArmorRating;
                baseMetalCost.ScaledArmorPiercing = this.BaseArmorPiercing;
                baseMetalCost.ScaledLoneUnitCircularAreaForPurposesOfBoostCapacityCalculation = this.BaseLoneUnitCircularAreaForPurposesOfBoostCapacityCalculation;
                baseMetalCost.ScaledMunitionsBoostCircularArea = this.BaseMunitionsBoostCircularArea;
                baseMetalCost.ScaledShieldBoostCircularArea = this.BaseShieldBoostCircularArea;
                baseMetalCost.ShipCapScaleRawValue = Mat.One.RawValue;
                baseMetalCost.ScaledAutoCreateAtBuildPointCount = this.BaseAutoCreateAtBuildPointCount;
                baseMetalCost.ScaledAbstractedAutoFactoryBuildPointsPerShip = this.BaseAbstractedAutoFactoryBuildPointsPerShip;
                baseMetalCost.ScaledAbstractedAutoFactoryMaxShipsQuasiStored = this.BaseAbstractedAutoFactoryMaxShipsQuasiStored;
                baseMetalCost.ScaledAbstractedAutoFactoryMinimumShipsForSpawn = this.BaseAbstractedAutoFactoryMinimumShipsForSpawn;
                baseMetalCost.ScaledAttackRechargeSeconds = this.BaseAttackRechargeSeconds;
                baseMetalCost.ScaledStrength = this.BaseStrength;
                baseMetalCost.ScaledStrengthIgnoringMark = this.BaseStrengthIgnoringMark;
                baseMetalCost.ScaledNumberThatFitIntoOneStrengthIgnoringMark = this.BaseNumberThatFitInOneStrengthIgnoringMark;
                if (num != 0)
                {
                    if (!flag1)
                    {
                        if (usesScaledShipCaps)
                        {
                            baseMetalCost.ScaledMetalCost = (this.BaseMetalCost << (num & 31)) + (this.BaseOtherMetalCost << (num & 31));
                            baseMetalCost.ScaledEnergyUse = this.BaseEnergyUse << (num & 31);
                            baseMetalCost.ScaledMaxHealth = this.BaseMaxHealth << (num & 31);
                            baseMetalCost.ScaledRegenPerSecond = this.BaseRegenPerSecond << (num & 31);
                            baseMetalCost.ScaledGetsEatenPerSecond = this.BaseGetsEatenPerSecond << (num & 31);
                            baseMetalCost.ScaledAttackPower = this.BaseAttackPower << (num & 31);
                            baseMetalCost.ScaledArmorRating = this.BaseArmorRating << (num & 31);
                            baseMetalCost.ScaledArmorPiercing = this.BaseArmorPiercing << (num & 31);
                            baseMetalCost.ScaledLoneUnitCircularAreaForPurposesOfBoostCapacityCalculation = this.BaseLoneUnitCircularAreaForPurposesOfBoostCapacityCalculation << (num & 31);
                            baseMetalCost.ScaledMunitionsBoostCircularArea = this.BaseMunitionsBoostCircularArea << (num & 31);
                            baseMetalCost.ScaledShieldBoostCircularArea = this.BaseShieldBoostCircularArea << (num & 31);
                            baseMetalCost.ShipCapScaleRawValue = Mat.One.RawValue >> (num & 63);
                            baseMetalCost.ScaledStrength = this.BaseStrength << num;
                            baseMetalCost.ScaledStrengthIgnoringMark = this.BaseStrengthIgnoringMark << num;
                            baseMetalCost.ScaledNumberThatFitIntoOneStrengthIgnoringMark = this.BaseNumberThatFitInOneStrengthIgnoringMark >> num;
                        }
                        if (flag)
                        {
                            baseMetalCost.ScaledAutoCreateAtBuildPointCount = this.BaseAutoCreateAtBuildPointCount << (num & 31);
                            baseMetalCost.ScaledAbstractedAutoFactoryBuildPointsPerShip = this.BaseAbstractedAutoFactoryBuildPointsPerShip << (num & 31);
                            baseMetalCost.ScaledAbstractedAutoFactoryMaxShipsQuasiStored = this.BaseAbstractedAutoFactoryMaxShipsQuasiStored >> (num & 31);
                            baseMetalCost.ScaledAbstractedAutoFactoryMinimumShipsForSpawn = this.BaseAbstractedAutoFactoryMinimumShipsForSpawn >> (num & 31);
                        }
                        if (instaKillsLowerShips)
                        {
                            baseMetalCost.ScaledAttackRechargeSeconds = this.BaseAttackRechargeSeconds << (num & 31);
                            baseMetalCost.ScaledAttackPower = this.BaseAttackPower << (num & 31);
                        }
                    }
                    else
                    {
                        if (usesScaledShipCaps)
                        {
                            baseMetalCost.ScaledMetalCost = (this.BaseMetalCost >> (num & 31)) + (this.BaseOtherMetalCost >> (num & 31));
                            baseMetalCost.ScaledEnergyUse = this.BaseEnergyUse >> (num & 31);
                            baseMetalCost.ScaledMaxHealth = this.BaseMaxHealth >> (num & 31);
                            baseMetalCost.ScaledRegenPerSecond = this.BaseRegenPerSecond >> (num & 31);
                            baseMetalCost.ScaledGetsEatenPerSecond = this.BaseGetsEatenPerSecond >> (num & 31);
                            baseMetalCost.ScaledAttackPower = this.BaseAttackPower >> (num & 31);
                            baseMetalCost.ScaledArmorRating = this.BaseArmorRating >> (num & 31);
                            baseMetalCost.ScaledArmorPiercing = this.BaseArmorPiercing >> (num & 31);
                            baseMetalCost.ScaledLoneUnitCircularAreaForPurposesOfBoostCapacityCalculation = this.BaseLoneUnitCircularAreaForPurposesOfBoostCapacityCalculation >> (num & 31);
                            baseMetalCost.ScaledMunitionsBoostCircularArea = this.BaseMunitionsBoostCircularArea >> (num & 31);
                            baseMetalCost.ScaledShieldBoostCircularArea = this.BaseShieldBoostCircularArea >> (num & 31);
                            baseMetalCost.ShipCapScaleRawValue = Mat.One.RawValue << (num & 63);
                            baseMetalCost.ScaledStrength = this.BaseStrength >> num;
                            baseMetalCost.ScaledStrengthIgnoringMark = this.BaseStrengthIgnoringMark >> num;
                            baseMetalCost.ScaledNumberThatFitIntoOneStrengthIgnoringMark = this.BaseNumberThatFitInOneStrengthIgnoringMark << num;
                        }
                        if (flag)
                        {
                            baseMetalCost.ScaledAutoCreateAtBuildPointCount = this.BaseAutoCreateAtBuildPointCount >> (num & 31);
                            baseMetalCost.ScaledAbstractedAutoFactoryBuildPointsPerShip = this.BaseAbstractedAutoFactoryBuildPointsPerShip >> (num & 31);
                            baseMetalCost.ScaledAbstractedAutoFactoryMaxShipsQuasiStored = this.BaseAbstractedAutoFactoryMaxShipsQuasiStored << (num & 31);
                            baseMetalCost.ScaledAbstractedAutoFactoryMinimumShipsForSpawn = this.BaseAbstractedAutoFactoryMinimumShipsForSpawn << (num & 31);
                        }
                        if (instaKillsLowerShips)
                        {
                            baseMetalCost.ScaledAttackRechargeSeconds = this.BaseAttackRechargeSeconds >> (num & 31);
                            baseMetalCost.ScaledAttackPower = this.BaseAttackPower >> (num & 31);
                        }
                    }
                    if (baseMetalCost.ScaledMaxHealth < 1)
                    {
                        baseMetalCost.ScaledMaxHealth = 1;
                    }
                    if ((this.BaseRegenPerSecond < 1 ? false : baseMetalCost.ScaledRegenPerSecond < 1))
                    {
                        baseMetalCost.ScaledRegenPerSecond = 1;
                    }
                    if (baseMetalCost.ScaledGetsEatenPerSecond < 1)
                    {
                        baseMetalCost.ScaledGetsEatenPerSecond = 1;
                    }
                    if ((this.BaseAttackPower < 1 ? false : baseMetalCost.ScaledAttackPower < 1))
                    {
                        baseMetalCost.ScaledAttackPower = 1;
                    }
                    if ((this.BaseArmorRating < 1 ? false : baseMetalCost.ScaledArmorRating < 1))
                    {
                        baseMetalCost.ScaledArmorRating = 1;
                    }
                    if ((this.BaseArmorPiercing < 1 ? false : baseMetalCost.ScaledArmorPiercing < 1))
                    {
                        baseMetalCost.ScaledArmorPiercing = 1;
                    }
                    if (baseMetalCost.ShipCapScaleRawValue < (long)1)
                    {
                        baseMetalCost.ShipCapScaleRawValue = (long)1;
                    }
                    if ((this.BaseAttackRechargeSeconds < 1 ? false : baseMetalCost.ScaledAttackRechargeSeconds < 1))
                    {
                        baseMetalCost.ScaledAttackRechargeSeconds = 1;
                    }
                    if ((this.BaseStrength <= 0 ? false : baseMetalCost.ScaledStrength.RawValue < (long)1))
                    {
                        baseMetalCost.ScaledStrength.RawValue = (long)1;
                    }
                    if ((this.BaseStrengthIgnoringMark <= 0 ? false : baseMetalCost.ScaledStrengthIgnoringMark.RawValue < (long)1))
                    {
                        baseMetalCost.ScaledStrengthIgnoringMark.RawValue = (long)1;
                    }
                    if ((this.BaseNumberThatFitInOneStrengthIgnoringMark <= 0 ? false : baseMetalCost.ScaledNumberThatFitIntoOneStrengthIgnoringMark.RawValue < (long)1))
                    {
                        baseMetalCost.ScaledNumberThatFitIntoOneStrengthIgnoringMark.RawValue = (long)1;
                    }
                }
                this.scaleAlternatives = baseMetalCost;
            }
        }
    }

[Pumpkin]

Quick question from the guy that isn't interesting in the topic ()

How are suicide ships (ZAutoBombs, SMRams, etc) handled by the DPS formula?

[Red.Queen]

Pumpkin -- You don't want to read the code? :p  Looking at the Compute Scaled function, I don't see any special consideration of suicide.  I assume Arcen took that into account themselves when they were choosing how much damage to let the suicide ships do/speed/etc, making there be no need for a special rule in the strength calcs.

[Pumpkin]

Pumpkin -- You don't want to read the code? :p

I write code. I don't like reading code. That's why I like perl. (Nicknamed "read-only script language")
:p yourself


OK for the "Arcen may have done it right". Like I said, it matters few to me. I prefer balancing the (Dire) Guardian capture rather than the AT's DPS.
++

[Red.Queen]

I write code. I don't like reading code. That's why I like perl. (Nicknamed "read-only script language")
:p yourself

Ah Perl, my hated foe.  "Write once, read never."  I'll stick to Lua and MSIL, thank you very much. 

****

Letting balance thoughts stew on these things, had an incident the other night where the ATs carrying a moderate strength fleet weren't out of line, partially because the AI ended up focus-firing them down one after the other rather than scattering their shots around, which brought down their lifespan boost to something sensible.  Slippery problem.

Wonder if the best combo may end up being capping their max possible damage, combined with a hull type change to something more frequently countered to trim their durability in toe to toe slugging matches so you end up forced to unload the fleet faster.  Definitely not Polycrystal though, don't want them becoming the sudden best choice for Fortress killing...

Had an idea for a way to figure out potentially good max damage numbers -- looking at whichever starship has otherwise similar stats at the 3000K mark.  There should be a certain sense of balance that has driven the assignment of K values to stuff, it's not logical to believe that Arcen assigned K values haphazardly, so why reinvent the wheel when I can use that to get a ballpark idea of what levels of DPS and utility are intended at K cost XYZ.

I'll probably end up kicking out a few variants so people can test and argue about which flavor they think is closest to the mark -- that'll give Keith and Chris an easy shortcut to tweaking these things if everyone ultimately agrees that they need work and can settle on a loose consensus of what feels right.

Thinking about ATs makes me also think about Cloaker starships and how they're kind of pointless IMO outside of cloaking warheads and golems at this stage in the game, but that hasn't gelled into anything that warrants posting about yet.

[Chris_Stalis]

I've been mulling this over a fair bit, and I've settled on wanting the current strength of ATs when filled with Mk Is & IIs to be the default ballpark for "max damage". Currently, you can nearly fill 3 ATs with a healthy mix of Mk I & II fighters, bombers & frigates. While the current oddness does allow a certain degree of min-maxing, this would indicate to me that people might find a good compromise if they play around with ATs carrying a strength of about 576 [192 (cap Mk I str) + 384 (cap Mk II str)]. Need to keep remembering to write down what the actual damage that is right now, but it keeps it at a decent "either/or" level for me.

[Red.Queen]

Thanks Chris, this is definitely helpful.  It's also not too far off from some of the patch note stuff about the base, unloaded damage of a cap of ATs being roughly equivalent to half a cap or a cap of Mk.I fighters, so there's a logical connection between the suggested max and the given min.  Sounds pretty reasonable and like a nice place to start testing.

[Chris_Stalis]

Oh, one other thing: allow empty transports (both normal and ATs) to be given the self-destruct command when not on friendly planets. Alternatively, cause the self destruct to kill any ships inside it if you want. There is nothing more infuriating than accidentally flying my ATs into a system with a blackhole, only to be told that I'm not allowed to recover them the same way I can my main fleet.

[Red.Queen]

I'd noticed that flag on them, I assume it probably is because it'll wipe out the contents as well (haven't stripped the flag and tried it).  I bet it also cheats the AI out of the correct amount of scrap if you wipe one out with stuff inside.  Those two points are probably the reasoning for the flag, especially as destroying the BHM to escape is always an option.

[Chris_Stalis]

Yeah, but I often encounter the BHM like this when I'm exploring and don't actually intend to destroy it yet. If the BHM prevented me from self-destructing any other ships, I'd be more ok with it, but it's only the 3K in research that I tied up in the ATs that gets affected this way. It's... irritating to feel like my hand is being forced to take an action this arbitrarily.

Maybe others will disagree, but it has become a pet peeve of mine.

[Captain Jack]

Just build Mk. IV scouts. They're undetectable by passive tachyon coverage, can explore the entire map in ten minutes and ignore black hole machines.

[Draco18s]

I'm a fan of non-linear calculations when something like this is involved.  Mathf.log(n) is probably too expensive (and I doubt Chris has a fast version), but you can get something similar using...

G = growth (probably 1 in this case, but acts as a scalar, the "20%" mentioned upthread would be this number)
P = modifier (less than 1)
B = base value (how much you get for no strength, if I am remembering correctly)
S = ContainedStrength
(The "+1" is also modifiable)

=(POWER((G*S),P)+1)*B

For example, (WolframAlpha graph)
G = 0.2
P = 0.5
B = 20
S = 500,000 strength
You get a output value of 6344 (which you would then substitute into the original calculation where it currently uses total strength)

But I'll admit I don't know if Chris has a fastPow function or not.
But it lets continued addition of strength add to the firepower, but with pretty harsh diminishing returns.