MaulingMonkey

There is non-axiom FTL, it's just slower (≈700c?) and experimental.

“Our main ship, The Dauntless, was able to work properly in Cruel Space, including crossing a distance of about a quarter of a percent of the galaxy wide in just four months. Now that’s a very long time compared to Axiom assisted travel but...”

https://www.reddit.com/r/HFY/comments/10svg9j/out_of_cruel_space_part_584/

...and a little spicy:

First problem was that trying to get anything with the engines needed for crude FTL through the Ozone Layer made a really, really big bang.

We’d been warned about this from the program so that first flight had been unmanned just to see how big a bang it would be. Most of the people that looked at it directly needed experimental optical surgery to see again. People like me that saw it through a recording were blinking spots out of their eyes for hours to come. Still it was really neat to see a double-sided mushroom cloud.

https://www.reddit.com/r/HFY/comments/nfsakq/out_of_cruel_space_part_1/

JOD 148 makes a passing mention of plans to build a ringworld as "a healthy nudge toward Type II efficiencies"... but it's unclear how concrete or speculative said plan is, and on what kind of timeline, and even a single ringworld is a far cry from a full dyson sphere made out of 100% efficient unobtainium solar panels.

Now, if we're hoping to make up for that by bulk of worlds, each power only controls a thousand or so (previous discussion)... and that number presumably includes agricultural and primitive worlds that haven't been given the full Type I treatment... hell, have any SSB worlds been given the full Type I treatment? And you'd need millions of full Type I worlds to reach Type II, considering the tiny fraction of Sol's output is captured by Earth? (EDIT: or tens of billions if going by Sagan's extended model where Type II is ten orders of magnitude - 10,000,000,000 times - more watts?)

...I'd buy "above 1.0", but I'd also buy "approaching 1.0".

> The real solution is to allocate everything up-front, and have no memory allocations once your game has begun.

Hot take: there's no such thing as "allocating everything up-front".

You can pre-create an array of 10,000 entities, but then you still need to keep track of which ones are alive or dead and reusable. This is custom allocation in everything but name, and so I prefer to fix the name and explicitly call it allocation. It's just a pre-sized, contiguous, type-specific pool allocator, with allocated objects possibly accessed by id, handle, index, or generational index instead of by raw pointer.

By virtue of all the strict limitations imposed by this allocator, it's extremely simple to write. If you're feeling particularly crazy you can write a macro that overloads new/delete for a type and forwards them to such an allocator - this won't give you the full cache-friendly performance advantages of iterating over the contiguous array in it's natural order - you'll instead probably still iterate over arrays of pointers into said contiguous array - but it can still nail some of the allocation performance and fragmentation issues pretty quickly. The default C++ new/delete interface isn't very friendly for falliable allocation (catching std::bad_alloc or null-checking after using std::nothrow) but can also be done.

I've had my share of bugs where manager.instance.a was used in the middle of deconstructing the audio manager, resulting in crashes and worse when exiting the game. When a bunch of code all reference it directly, it can turn into a tangled mess.

Dependency injection is one possible "fix" that usually ensures sane construction/deconstruction order - in a more complicated engine, you might use this, and have some kind of entity factory responsible for constructing fish and dogs from data, including delaying their creation until textures/models/sounds are all loaded, and the factory would be the one holding a reference/pointer to Audio.

Going the other way, another "fix" would be to hide the fact that you have an Audio manager at all:

void dog::animate(...) {
    ...
    event("dog-footstep", position, velocity, intensity);
    ...
}

This could trigger 3D audio events (footstep sounds), spawn particle effects (dust particles from walking in the dirt), contribute to "Mush! Mush!" achievement progress in your sled dog race simulator, etc. which can all be driven by system specific data files.

In this example, dog doesn't need to be fixed to handle the case where Audio isn't initialized yet. Or has been unloaded during game exit. It's possible that "event" could have bugs, but they tend to be simple and easily fixed:

• If using a list of event listeners, adding Audio to the list before it's fully initialized - or not removing Audio from the list before it starts to be cleaned up - could lead to crashes.

• If hardcoding which systems you use under the hood inside the event function, not checking if audio is initialized / cleaned up before using it.

Having a list of event listeners is extremely flexible:

• If I haven't implemented the audio system for a new platform yet, I can simply not register it and the code will run without crashing.

• If I have a crash bug in the audio system and want to provide a workaround for our designers until I can fix it, I can provide them a config option or flag to simply skip registering the audio system.

• If I have multiple audio systems (because I'm replacing DirectSound with XAudio2 in preparation for a console port) I can easily swap around which audio systems are registered at runtime without a mess of conditional logic all over the place. I can just have AudioSystem_DirectSound and AudioSysten_XAudio2 and register/unregister them in one place.

• If I'm doing fancy 3D audio where multiple console players each have their own headset connected to their gamepads, I can register multiple listeners that calculate the left/right balance and volume separately for each headset depending on which way they're facing, and how far from the event they are.

To avoid double-frees, those move ctors/assignment operators need to null out other.managedData (turning ~abc into a noop for the 'moved from' object)

    abc(abc&& other) { //move constructor
        managedData = other.managedData;
        other.managedData = nullptr;
    }
    abc& operator=(abc&& other) { //move assignment operator
        managedData = other.managedData;
        other.managedData = nullptr;
        return *this;
    }

Depending on what your own destructors do, you may need to add null checks - I'm (ab)using the fact that free(nullptr) is a noop.