Matt Downey @SciFiGameDev@mastodon.gamedev.place

Finished my 6-second game trailer for my Asteroids (1979)-clone in virtual reality:

https://youtu.be/tGoc2T6ABUc

Hmmm, actually I think I'm very close to done with this version of the "proof".

It weirds me out that there are only reals in the infinite summation, but since there are only reals you could do proof by contradiction I think.

I still have to verify the math, but I know what to do.

I found a cool lecture series on math relevant to the Riemann hypothesis that I like:

https://youtu.be/lkU3oT353Mw

It reminded me of some of the strategies I tried, and also makes me wonder why I didn't watch tutorial videos back in the day or try to understand what the Riemann hypothesis is (to be fair, I'm still not fully aware of the scope of the question).

Also, because you don't get the gravity-strafing boots until later, you have to use x-momentum to make the bounce jump. This is particularly cool because it could pair well with the hexagonal corridor design.

To add to the fun of it, the bounce jumping route should be significantly slower than the alternative route unless you make the jump.

One nice thing: if this technique is difficult (it probably won't be for normal people (read: it would be near-impossible for me)) then it will be within the first 30 seconds of gameplay (easy to reset).

I also don't think I mentioned that the start screen fades in from black (input is accepted during this time but historically held inputs are ignored). This adds something to do as the game starts.

Oh wait, I remember now that I was interally debating about corridor z-velocities based on grounded movement (something I previously only needed to implement in midair). It turns out that adding that would make this feature possible XD

I also just figured out how to add a speedrun technique: bounce jumping off ceilings for extra vertical momentum.

The idea is you use the ceiling off the corridor (essentially "level 0.5") to jump towards the floor, then you transition to "level 1" then you jump off the floor with an extra bounce for making an otherwise impossible jump to shortcut some of the level.

Based on how I set up corridor gravity and gravity-strafing boots this is currently impossible, but I'll make it work.

To be fair, spherical levels are difficult to chart out on paper. A lot of it ends up being a 2D square with matching discontinuity lines on the left and right.

It took me what felt like 2-3 years to develop the "0th level" and >4 years to develop the first (abstract) part of the "1st level", so if I extrapolate maybe I'll have the level design figured out in 20 years XD

Finally decided on the first (or second depending on how you count it) level for my game, probably thanks in part to this great article I just skimmed: https://www.gamasutra.com/blogs/AhmedKhalifa/20190610/344344/Level_Design_Patterns_in_2D_Games.php

Basically the character can fall down (can't immediately backtrack) to the left or right, so you have a degree of branching, guidance, and foreshadowing.

I also informally called the achievement for the 0th level "Around the World in Eighty Degrees".

I really don't like this new version (even if it works) because 1) it lacks elegance so far 2) it is cache-unfriendly.

If you're concerned about performance on nearly-sorted data you can Lazy-Insertion-Sort (max_distance=64) and regions should be relatively sorted.

The only thing I'm baffled by is how to solve the 1 + 1 + 2 + 2 + 4 + 4 + 8 + 8 != 32 problem.

The data structure always needs a concept of 1 1 1 1 2 2 4 4 8 8... for the VList (which is fulfilling to the perfectionist in me).

This includes cases like 64 64 64 64 128 128 256 256... (when you do insertion sort for small chunks).

I think this is doable.

You can consider sorting after getting a chunk of size 64.

Naive implementation: 64 1 1 2 2 4 4 8 8 16 16

Smart implementation: 64 (16 16 8 8 4 4 2 2)? 1 1 -- parsing region right-to-left

Notably if you get random-ish data you can combine the regions (e.g. 16s in this example) and put them in the rightmost bytes.

Smartly-implemented, there would be a lot of zig-zagging left and right to sort the data.

Extra random access.

It's possible getting the memory to end up in contiguous regions is difficult, so this might be a logical fallacy.

I really like this version of hierarchysort, it should be able to work either in-place or out-of-place (adaptive memory performance).

If two items are combined via this memory trick you get memory that is laid out in a complementary way.

Simplest Example:

2 1 1 2 4 4 8 8... (first 2 region populated)

In this case, if the 1 1 regions aren't combined into the neighboring spot, then you can't use the memory trick.

With respect to out-of-place hierarchysort, I might have found an optimization that makes it better with nearly-sorted data. (Specifically, strong Omega(n) not weak Omega(n) best case, according to my prior definitions.)

You basically invalidate the 1 1 2 2 4 4 8 8 16 16 VList structure occasionally when you can quickly combine neighboring regions.

Extra invariants and checks are needed.

The reason for this decision would be these sexual harassment allegations (there seem to be 10 Jane Does).

If there's any coverup involved, I'm gonna want to switch to Godot if it's not gonna bankrupt me, because when you state:

"Unity intends to vigorously defend against the false allegations asserted by Anne Evans."

And then it turns out that is part of a coverup, I don't want to give you any business.

https://gamasutra.com/view/news/344336/Lawsuit_alleges_Unity_CEO_sexually_harassed_former_VP.php

Today is the first day (to my recollection) I've seriously considered switching to Godot.

I know some incredibly important features would be missing in the short-term, but on the plus side I could treat my previous code as a throwaway prototype for the 7-9th time (it's more useful for refactoring / architecture than you'd think).

I'll probably decide quickly after I finish my two major non-game development projects.

I feel like this article describes some of my bad behavior well and gives me a means to fix it.

https://insight.kellogg.northwestern.edu/article/unethical-behavior-and-authenticity-at-work

Because of this, the algorithm should detect this at the beginning of the O(lgn) combine step and do one median of 4 (with the smallest chunks).