hopfog

Thanks!

It has been amazing. I had no intention of signing with a publisher initially but when my demo blew up a lot of cool publishers started reaching out. In retrospect I'm really glad I didn't self-publish considering how much that goes into releasing a game. I was very naive, so wouldn't have done it without their support.

Thank you!

It's funny because I really wanted to introduce more things like that, but the very simple things I've added so far have received a bit of pushback ("I want to play a factory game, not solve puzzles!"). So now I'm reconsidering it, but I think there's a lot of room for really interesting Noita-style secrets when combined with the automation and processing tools.

Overall it's a much simpler and more controlled experience than Noita though, so don't expect anything like it.

By the way, this talk by the Noita devs has been instrumental when building my engine: https://www.youtube.com/watch?v=prXuyMCgbTc

Highly recommended!

Thank you! The demo is very old by now and the full game is almost a complete rewrite, but I hope people will like it.

It's my publisher (Hooded Horse) handling it so not sure about the exact process. I don't think it's easy to get a day 1 deal though so I'm very grateful for it.

The final stretch of getting my game ready for release next week: https://store.steampowered.com/app/2764460/Sandustry/

It's an automation game and factory builder with "falling sand" physics. Think Noita meets Factorio.

I used to run a small MMORPG. I only had to ban a player once but when I did they made it their life's mission to get around it and spam profanities. They went through every proxy in existence and I had to resort to banning whole IP ranges to keep them out.

CrossCode is a marvel in that they had to build their own runtime: https://news.ycombinator.com/item?id=41155807

I think the most famous Electron game is Vampire Suvivors, but it has since been ported to Unity.

What Discord server are you referring to? Would love to join.

Actually even higher level than that: it's all JavaScript, but it relies heavily on multithreading (see the linked Noita talk, which uses the same model). But basically:

The world is divided into chunks and the threads are processing them simultaneously in an even-odd checker pattern to avoid race conditions. When all pixels settle in a chunk it falls asleep and can be skipped altogether until an active pixel enters and wakes it up again.

Yes, that talk has been instrumental for my game. Highly recommended!

Awesome. I wasn't planning on signing with a publisher but now I'm really happy that I did.

As a fan of both Neal and R74n this was an unexpected collaboration!

I can highly recommend building your own falling sand simulator. It's really fun to see how such simple rules create emergent behaviors. Sand pixels try to move down, then diagonally down. Water does the same, then tries sideways.

Me messing around with it eventually resulted in a game I'm now working on full time (think Noita meets Factorio): https://store.steampowered.com/app/2764460/Sandustry/

Beautiful blog post!

I've built something similar and have yet to find a compelling use case for it. In my mind it seemed like such an obvious idea that I thought I'd start using it instead of Wikipedia. However, in practice I seldom care about the broader or more specific topics for the thing I'm looking into. It's strange though because I'm a compulsive rabbit holer but it just doesn't trigger the same urge to explore related nodes as Wikipedia does.

With that said, this UI is much slicker so maybe that is the missing piece.

I built a multiplayer chatroom where all messages are transformed by an LLM (e.g. into pirate speak or corporate jargon):

https://impersona.chat/

I also built this incremental clicker game where you split words ad infinitum (like Infinite Craft but in reverse):

https://lantto.github.io/hypersplit/

This seems really cool and I'm excited to play around with it once it's up and running properly again. These type of things are my favorite applications of LLMs.

A while back I made something similar in the form of an incremental "clicker" game where you split things ad infinitum: https://lantto.github.io/hypersplit/

Thanks for reporting! May I ask what browser and system you are on?

When going underground it starts raycasting shadows, which is heavier on the GPU, but the difference shouldn't be that big.

Working on my game Sandustry, a mining and automation sandbox with pixel-based physics (think Noita meets Factorio).

I released the first playtest of the alpha a few days ago, which you can try directly in your browser:

https://lanttogames.itch.io/sandustry

Great article and very relevant for me since I'm building a game in JavaScript based on "falling sand" physics, which is all about simulating massive amount of particles (think Noita meets Factorio - feel free to wishlist if you think it sounds interesting).

My custom engine is built on a very similar solution using SharedArrayBuffers but there are still many things in this article that I'm eager to try, so thanks!

The author is also working on a really impressive voxel physics engine: https://youtu.be/3259aycYcek

Yes, this is a really good article that I can highly recommend if you're interested in these type of "falling sand" simulations.

A big difference between a classic powder toy game like in the article and Noita is that Noita needs to run a much larger simulation that extends beyond the visible canvas. So while multithreading is probably not needed in the former it's most likely needed when the game is a scrolling platformer. I posted a GDC talk by the Noita devs as a reply to a sibling comment if you're interested in their tech.

Thank you!

If you haven't played Noita it's basically a "falling sand" or powder physics game where every pixel is simulated. You need a special cellular automata that is not your typical game physics engine, so I don't think Babylon.js would be a good choice but I may be wrong.

I've modeled my architecture after this fantastic GDC talk by the Noita devs: https://www.youtube.com/watch?v=prXuyMCgbTc ("Exploring the Tech and Design of Noita")

I'm building a JavaScript game in my own engine, which in retrospect was a big mistake considering the game utilizes a lot of multithreading (the game is "Noita meets Factorio" so it's required for the simulation). You can only share memory between threads using a SharedArrayBuffer with raw binary data and you need special headers from the web server to even enable it. This means that I've had to write a lot of convoluted code that simply wouldn't be necessary in a non-browser environment.

Other than that I really like that I can piggyback on the browser's devtools and that I can use the DOM for the UI.

Sorry about that! I realized too late that the game is really badly optimized once you hit higher levels and start getting chain reactions. Turning off Effects helps for some things.

I wonder how far you can push the DOM. It gets crazy with so many element updates after a while but there are probably many performance improvements that can be done.

Try pressing the wizard. I should probably make it clearer on mobile and highlight it once you can afford your first cat.

Getting the second resource (can't post emojis here) means you hit a quark, loop or a dead-end. I have a version where it continues splitting to up/down quarks and then fantasy matters but it quickly derails into chaos.

I've seen many reports of this on Pixel phones but I experienced something very similar on another Android phone (it was either Moto G5 or OnePlus One): https://news.ycombinator.com/item?id=29494820

I love Andreas Kling's "Browser hacking" series on YouTube where he fixes various issues Ladybird has with specific websites. E.g:

Fixing a CSS layout bug found by chessboard.js - https://www.youtube.com/watch?v=bMpLiEgKC_w

Let's make "Cookie Clicker" playable in Ladybird! - https://www.youtube.com/watch?v=W4SxKWwFhA0

He's very good at articulating his thought progress and it's always really interesting to see how he reduces the bug down into a minimal reproducible example.

> Ideally there would be a way to "sign" something that says you are a real citizen without revealing which citizen you are, but is durably unique (subsequent signings identify you as the same citizen).

This is a truly interesting and groundbreaking idea that would solve all my problems. Do you know if there are any initiatives like that or is it science-fiction?

Yeah, I thought I could pull that off but in the end I was naive thinking I could solve it with mechanics. The idea was that I would never need to ban anyone, ever. However, even with thousands of players playing the game as intended just one troll can wreck havoc by creating hundreds of accounts through proxies.

I have implemented measures where you can't chat until you've finished the tutorial, 5 minutes decay on stuff built/painted outside plots and upkeep on claimed plots but it's not enough. The trolls are extremely dedicated and devote their life to ruining my game.

I run a free browser game where you can start playing immediately, no registration required. The game has a big sandbox element where you can build and paint on the world map.

Naturally I've attracted trolls doing everything in their power to grief and ruin it for other players. This has lead me to reluctantly implement moderation tools such as IP bans and proxy detection.

I'm currently using a couple of services where I can supply an IP and get a risk score back but I'm worried about false positives. I'm afraid this initiative, while great for privacy, will make my defense measures futile.

What should I do? I just want to run a game with as few intrusive barriers as possible. I have no interest in collecting any private data from users whatsoever.

I implemented an AMM in my multiplayer game (nothing to do with cryptocurrencies) for players to trade one resource for another. They can always buy/sell into the AMM even at low activity as long as there's liquidity. It's also a fun mechanic for players where they can invest their surplus and get a cut of every trade.