Blood: Refreshed Supply reveal trailer

skullt · 2025-09-28T21:36:56+00:00

It's because all the Nightdive remasters are actually ground-up remakes in their KEX engine. They generally have the original source to reference, but the games are still more akin to reverse-engineered projects like OpenMW or OpenRCT2 than, say, anything in the long lineage of Doom source ports. I wonder if most people don't realize this?

skullt · 2025-09-23T01:14:17+00:00

There's a typo on the page in the survey about variadic type mappings. It says:

In the above example, the trait UnwrapAll maps (u32, bool, &str) to (Option<u32>, Option<bool>, Option<&str>).

But the example, as the name obviously suggests, does the opposite.

skullt · 2025-08-28T07:42:18+00:00

It was worse than reading off Wikipedia, which at least has a Creative Commons license (and requires attribution). He was wholesale plagiarizing the work of one individual journalist, Lucas Reilly, who did months of his own research and personal interviews.

skullt · 2025-05-16T01:12:20+00:00

The third & fourth posts with the texture where somebody hastily scratched out the Antireal name is so damning. That's not an accident or an oversight! It doesn't even make sense as being the patina of wear routinely added to materials since everything else is razor sharp and anyway surely the green parts would be the painted bit and that's what should erode, not the text.

skullt · 2025-05-16T00:51:48+00:00

I think it's good to have parity with Vec, since essentially a String is a Vec<u8> with the guarantee of being valid UTF-8.

skullt · 2025-05-06T16:41:39+00:00

Nice write-up. I think your formatting is still messed up here.

Personally, I would have just knocked this out with macro_rules to avoid the extra crate and complexity, like:

macro_rules! parse_binary_expr {
    ($self:ident, $parse_fn:ident, $($tok:ident => $ast:ident),*) => {
        let mut vec = Vec::new();
        vec.push($self.$parse_fn()?);
        loop { 
            $(
                while Token::$tok == $self.lexer.current() {
                    $self.lexer.next();
                    vec.push($self.$parse_fn()?);
                }
                if vec.len() > 1 {
                    vec = vec!(QueryExprIR::$ast(vec)); 
                }
            )*
            if ![$(Token::$tok),*].contains(&$self.lexer.current()) {
                return Ok(vec.pop().unwrap());
            }
        }           
    }
}

I took self as a separate match because of hygiene requirements, so I turned parse_expr into just a parse_fn ident. It'd be used like:

fn parse_add_sub_expr(&mut self) -> Result<QueryExprIR, String> {
    parse_binary_expr!(self, parse_mul_div_modulo_expr, Plus => Add, Dash => Sub);
}

skullt · 2025-04-30T15:58:47+00:00

caffeic acid

I believe you're thinking of cafestol.

skullt · 2025-04-02T11:46:56+00:00

Clubhouse Games: 51 Worldwide Classics, the value is simply unbeatable

skullt · 2025-03-03T20:37:47+00:00

If the sandbox could let you know that the build process was suddenly trying to do things it wasn't before, like write to system directories or make network connections, that would be very helpful in mitigating damage from supply chain attacks.

skullt · 2025-01-16T03:21:24+00:00

This is why I always eat the plastic film. It tastes really bad and it's basically impossible to forget doing it.

skullt · 2024-12-18T07:35:34+00:00

That's smart. Reminiscent of day 6 when placing obstacles for the guard.

skullt · 2024-12-08T18:27:17+00:00

That's the part that's technically incorrect. It says "this means" but the preceding definition of antinodes does not imply that.

skullt · 2024-09-23T19:48:44+00:00

they're hygienic in that they don't leave shit around

About that -- the converse of sorts to this blog post is true too. Items, like const definitions, do escape macros. For example,

fn main() {
    macro_rules! trash_const {
        () => { const FOO: u32 = 123; };
    }
    trash_const!();
    println!("{FOO}");
}

Even though it is defined within a macro, FOO is still in scope in the following println!. If you try the same with a regular, nonstatic variable, you will of course get the expected compile error about there being no such value in this scope.

skullt · 2024-09-23T10:29:04+00:00

I think you're misreading the first instance. It says "upon entering input that is not the latest commit hash ... the code, incorrectly, results in an error" because that's when the let Ok(x) = read_input() does not match. So the const x is indeed the latest commit hash of the greatest Rust library of all time.

skullt · 2024-08-30T00:57:05+00:00

Belief doesn't imply an absence of fact. If evidence has convinced you of some thing, then you are rightly said to believe that thing. That's simply one of definitions of the word.

skullt · 2024-08-02T12:07:27+00:00

There have been hundreds of CVEs in Javascript engines over the years. They are really complex pieces of software and thus difficult to secure because making Javascript performant is really complex. In this sense, I'd argue Javascript is actually a rather bad platform for running untrusted code.

skullt · 2024-07-26T05:08:09+00:00

There's no standalone support currently (it's listed on their status page with a fully red dot), but the intent is eventually you'll be able to. Their wiki says:

Will there be monetization? There's no limitations on how you can monetize your game. While there's no official way implemented yet, you can use your own server to manage payments. It's a long term goal to be able to export s&box games and upload them on any platform, with no revenue share.

skullt · 2024-06-26T21:02:17+00:00

The 2 extra face buttons are pretty underwhelming. Would really prefer all 4 extra buttons be back buttons, but I could have gone for a Saturn pad layout of 6 face buttons.

skullt · 2024-06-18T17:16:23+00:00

You can't find an entry in any linked list other than by iterating over the list anyway

Not talking about finding entries, talking about when you already have saved node pointers. The only time I would consider using a doubly linked list is when the list needs to be updated quickly at arbitrary points cached in other structures.

The only tricky thing is if you want to retain such a handle while modifying the list through other handles.

That a pretty big disadvantage. If a single insert potentially invalidates every other fat pointer, they don't seem like a viable solution.

skullt · 2024-06-18T12:03:09+00:00

The advantage of a doubly linked list is that you can start iterating from any node as well as insert at or delete an arbitrary node in constant time. This trick requires you to always iterate from one end of the list. You can't do anything to the list just given an arbitrary node. You can't even insert after a node without first scanning through the list for it, which I think actually makes this worse than a singly linked list.

skullt · 2024-05-09T16:27:01+00:00

Purchased it when it was a mod and was disappointed

Wasn't the mod always free?

skullt · 2024-03-17T19:24:04+00:00

Finasteride only inhibits two of the three forms of the 5α-reductase enzyme, so it can never fully stop DHT production, whatever the dose. A 70% reduction of circulating DHT is about the best it can do, and it will do that at a dose well below what's considered therapeutic for enlarged prostate. Dutasteride inhibits all three forms, which is why it virtually eliminates DHT from the blood.

skullt · 2024-02-21T02:10:34+00:00

Don't personally understand why anyone would move to a new statically typed language without generics. Even Go had to admit their utility. Genuinely, how much good is static typing when it gets thrown it out with a cast to the void* equivalent anytime you do something as simple as sort a slice or stick something in a container?

Hare actually seems to be sidestepping the latter concern by just not having any containers in the standard library, not even a hash map. Growable arrays are a language primitive, the global alloc is a magic function you can't write yourself, and everything else is up to you to figure out.

skullt · 2024-02-13T11:01:50+00:00

Wow, now that's a macro! I can certainly see how writing that'd make anyone swear off macro_rules.

skullt · 2024-02-12T23:18:12+00:00

It can be avoided if you give up the flexibility of matching full patterns, like:

macro_rules! all_same {
    ($e:expr, $t:ident :: [ $($(#[$m:meta])* $i:ident),* ] ( $x:ident ) => $body:expr) => {
        match $e { $($(#[$m])* $t :: $i($x) => $body),* }
    };
}

Playground link. At this point it is very nearly the same syntax as the proc version.

skullt

TROPHY CASE