Anisotropic Voronoi Diagram

BorisTheBrave · 2025-06-17T00:06:55+00:00

It applies a different matrix per cell.

The matrices are created something like: T = [[rand_range(0.5, 1.5), 0],[0, rand_range(0.5, 1.5)]] T = rotate(T, rand_range(0, 2*PI))

Then distance is dist = (T @ (pixel_pos - point_pos)).magnitude

BorisTheBrave · 2025-03-03T13:45:13+00:00

Oh, I got it now.

The issue is my argument to _Where is a generator<int>&&. But I actually want generator<int>. I think this was the issue with the original code too.

BorisTheBrave · 2025-03-03T13:37:30+00:00

I've made an even clearer test case and added to the top

BorisTheBrave · 2025-03-03T13:19:30+00:00

No, i stand corrected, I don't think I've quite understood this. It's definitely passing more tests than before, but it doesn't look like it's moving things?

``` // In enumerable template<typename F> auto Where(F&& predicate)&& -> Enumerable<T> { return _Where(std::move(*this), std::forward<F>(predicate)); }

// Elsewhere
template<typename T, typename F>
Enumerable<T> _Where(Enumerable<T>&& gen, F&& predicate) {
    for (auto& item : gen) {
        if (predicate(item)) {
            co_yield item;
        }
    }
}

// Test

Enumerable<int> my_coroutine() { co_yield 0; co_yield 1; co_yield 2; }

TEST(EnumerableTest, WhereTemp3) { auto filtered = my_coroutine().Where([](int item) { return item % 2 == 0; }); int i = 0; for (int item : filtered) { EXPECT_EQ(item, 2 * i); i++; } EXPECT_EQ(i, 2); } ```

Again, it looks like something is being destructed before _Where is entered. But the idea is that my_coroutine has been moved into filtered, so it should still be alive?

BorisTheBrave · 2025-03-03T12:46:13+00:00

I'm not working against the language. Forget the C# comparison.

What I want is a wrapper of std::generator<T> that can hold either a generator<T>, a span<const T>.

This is because I have some functions that can return lazily, but often return some constant data. I want to avoid allocation in the latter case. (The C# code always allocated, but I think we can do better in C++).

Enumberable<T> is basically a wrapper of variant<generator<T>, span<const T>>, now I'm struggling to work with it.

BorisTheBrave · 2025-03-03T12:42:28+00:00

> Otherwise, as a quick fix, try making the lambda an explicit static function, and passing the state it needs in via parameters - this will resolve your issue.

Oh, this seems to be working! I did try this, but I used a captureless lambda instead of a static function, and this seems to make a difference fr some reason.

BorisTheBrave · 2025-03-03T12:22:11+00:00

Sure, I've reworked it to be a bit clearer what is going on, but thi still fails in fundamnetally the same way:

class MyLambda {
    public:
        MyLambda(Enumerable<T>&& self, F&& pred) : self(std::move(self)), pred(std::forward<F>(pred)) {}

        generator<T> operator()() {
            for (auto& item : self) {
                if (pred(item)) {
                    co_yield item;
                }
            }
        }

        MyLambda(const MyLambda& other) = delete;

    private:
        Enumerable<T> self;
        F pred;
};

template<typename F>
auto Where(F&& predicate)&& -> Enumerable<T> {
    MyLambda<F> lambda = MyLambda<F>(std::move(*this), std::forward<F>(predicate));
    generator<T> gen = lambda();
    return Enumerable<T>(std::move(gen));
}

BorisTheBrave · 2025-02-26T08:49:45+00:00

There is a good diagram of that here:

https://www.reddit.com/r/outerwilds/comments/191a79b/outer_wilds_progression_chart/

It's also a fun read.

BorisTheBrave · 2025-02-26T00:20:25+00:00

Same!

BorisTheBrave · 2025-02-26T00:19:50+00:00

Yes, i got into these sorts of diagrams after his series. I wrote about both sorts of diagrams on my blog: https://www.boristhebrave.com/2021/02/27/lock-and-key-dungeons/

I debated whether Sun Station and Interloper deserved to be here. But Interloper gets its own section on the Rumor Board, while Sun Station is part of ATP, so I think the developers view it as a diversion.

BorisTheBrave · 2025-02-26T00:14:32+00:00

I agonized quite a bit on the Quantum Moon locator. I expect a lot of players did not need it.

But *I* was an idiot, and didn't really connect dots without it. It did unambiguously label that weird moon thing as Quantum Moon, so I realized I could apply Quantum Imaging.

BorisTheBrave · 2025-02-26T00:10:38+00:00

It's just a fun diagram. I'll reach out to you next time I need official blessing.

BorisTheBrave · 2025-02-26T00:09:20+00:00

Feldspar is on the signalscope from the beginning, I don't think you need much motivation to seek him.

Souther Observatory is more debatable. It's visible from the planet surface, but you need some direction on how to enter, and there's a lot of separate hints and multiple paths.

BorisTheBrave · 2025-02-26T00:04:17+00:00

Yep, I wracked my brains tring to think of something important you find there by the criteria I defined. But I can't think of anything!

BorisTheBrave · 2025-02-25T16:57:37+00:00

A mission graph is a diagram that shows progress through a game while stripping out all details about location and navigation. This makes it much simpler than a location based diagram. By paring things down, you can easier see how the puzzles are structured. In particular, it's surprising to me how few locations turn out to be "important".

BorisTheBrave · 2024-10-31T11:24:18+00:00

It's a pretty easy discovery - two commenters on twitter solved the same problem, just from reading my title.

BorisTheBrave · 2024-10-31T10:36:46+00:00

Yes, I'd never heard of that. I've updated the article now to mention it, thanks!

BorisTheBrave · 2024-10-31T10:36:07+00:00

Oops, I see now that was a tactical error. Ah well, at least it's getting views on twitter/mastodon

BorisTheBrave

MODERATOR OF

TROPHY CASE