RTS divided attention too many ways, and the so called “MOBA’s” aren’t, tehy are just real time strategy games without the base management. AKA RTS didn’t die it collapsed into League of legends and Dota 2. Instead of an army you controlled it became just RTS hero deathmatch.

The real problem is the rise of drm and the internet allowing companies to take control of the game from the end users. Microtransactions and mobile means talent went somewhere else for the money. Building AAA games for nerds is hard, making mobile games for whales is a lot easier.

]]>FAF is short for “Forged Alliance Forever”.

Take Gas Powered Games Supreme Commander+Forged Alliance expansion, then add a modding community that has expanded on it since.

More players in multiplayer,

more variations of gameplay,

far far FAR more maps.

New and different units.

new AI.

remade campaign playable in CO-OP! (Kinda just shoves the other people in there, but still!)

competition and associated leaderboard and rankings.

Opinion, as people on the internet are wont to do unsolicited:

The original SupCom engine was streets ahead better than anything of it’s time. Mainly BECAUSE it wasn’t about “the micro”.

Command linking, from factories, and inclusive of ferrying!

Factories – Infinite build queues.

Build templates(you want a resource building and 4 turrets, built in a particular order? One click done!)

Moveable patrol points, insert and delete patrol points? Of course.

You have two monitors? Supported that out of the box.

You want to zoom ALL the way in or ALL the way out without stupid “game designer says no” limits? Did that since the start.

I used to play a bunch of different RTS. There has only been one for over a decade.

]]>(test done with u64 only)

(serial sort = American Flag Sort)

I think I am done with my implementation improvement, I have reached same results as it is described in this post. I will move on the Regions Sort implementation.

array size: 30_000

— Std Rust sort 30000 integers: 2145298ns (2ms)

— Serial sort 30000 integers: 1512037ns (1ms)

— Ska sort 30000 integers: 1224484ns (1ms)

— LSD sort 30000 integers: 1120236ns (1ms)

array size: 40_000

— Std Rust sort 40000 integers: 2765500ns (2ms)

— Serial sort 40000 integers: 1742091ns (1ms)

— Ska sort 40000 integers: 1524766ns (1ms)

— LSD sort 40000 integers: 1997054ns (1ms)

array size: 100_000

— Std Rust sort 100000 integers: 7566436ns (7ms)

— Serial sort 100000 integers: 3153187ns (3ms)

— Ska sort 100000 integers: 2720144ns (2ms)

— LSD sort 100000 integers: 3932777ns (3ms)

array size: 1_000_000

— Std Rust sort 1000000 integers: 95101984ns (95ms)

— Serial sort 1000000 integers: 37807693ns (37ms)

— Ska sort 1000000 integers: 36735019ns (36ms)

— LSD sort 1000000 integers: 50231452ns (50ms)

array size: 5_000_000

— Std Rust sort 5000000 integers: 534031528ns (534ms)

— Serial sort 5000000 integers: 270564097ns (270ms)

— Ska sort 5000000 integers: 233946734ns (233ms)

— LSD sort 5000000 integers: 197715625ns (197ms)

array size: 10_000_000

— Std Rust sort 10000000 integers: 1121218428ns (1121ms)

— Serial sort 10000000 integers: 512437329ns (512ms)

— Ska sort 10000000 integers: 430279664ns (430ms)

— LSD sort 10000000 integers: 403955964ns (403ms)

array size: 100_000_000

— Std Rust sort 100000000 integers: 12619754751ns (12619ms)

— Serial sort 100000000 integers: 4706682830ns (4706ms)

— Ska sort 100000000 integers: 3435150209ns (3435ms)

— LSD sort 100000000 integers: 3786564746ns (3786ms)

Ska sort 20_000 integers: 789490ns

LSD sort 20_000 integers: 741793ns

Std Rust sort 20_000 integers: 1297973ns

Ska sort 100_000 integers: 5970815ns

LSD sort 100_000 integers: 5135667ns

Std Rust sort 100_000 integers: 8338032ns

Ska sort 1_000_000 integers: 34286443ns

LSD sort 1_000_000 integers: 40480471ns

Std Rust sort 1_000_000 integers: 92996585ns

Ska sort 10_000_000 integers: 501603635ns

LSD sort 10_000_000 integers: 349601204ns

Std Rust sort 10_000_000 integers: 1104897418ns

Ska sort 100_000_000 integers: 7059328711ns

LSD sort 100_000_000 integers: 3496587923ns

Std Rust sort 100_000_000 integers: 12635864161ns