What are /r/howdidtheycodeit's favorite Products & Services?

From 3.5 billion Reddit comments

Without knowing exactly the data you're storing, it's hard to say if it goes over the limit. Like /u/Questjon said, generally you can either change where you're storing it or store less of it.

That said: Are you actually hitting the Firebase free storage limit? You should calculate how much data you would use then compare that to the Firebase pricing. You're given 1 GB in the free tier, so what you should do is run the script for a day or so and see how much data it uses in the Firebase DB, then extrapolate that for a whole year.

There are also other data storage options you can use. Take a look here: https://auth0.com/blog/the-complete-guide-to-deploying-javascript-applications-part-1/#Database-Deployment While some aren't free, the paid tiers tend to start very cheap.

A couple thoughts:

1. Often we send commands back and forth instead state.
2. If your simulations are synced (and packets are guaranteed in order by TCP or at the application-level over UDP), then the computers can send delta packets that indicate relative change to game state. This can reduce congestion.
3. Also, checkout this excerpt from chapter 1 of Multiplayer Game Programming:

>As with Tribes , the real-time strategy (RTS) game Age of Empires was released in the late 1990s. This means that Age of Empires faced many of the same bandwidth and latency constraints of dial-up Internet access. Age of Empires uses a deterministic lockstep networking model. In this model, all the computers are connected to each other, meaning it is peer-to-peer. A guaranteed deterministic simulation of the game is concurrently performed by each of the peers. It is lockstep because peers use communication to ensure that they remain synchronized throughout the game. As with Tribes , even though the deterministic lockstep model has existed for many years, it is still commonly used in modern RTS games.

...

> One of the largest differences between implementing networked multiplayer for an RTS instead of an FPS is the number of relevant units. In Tribes , even though there are up to 128 players, at any particular point in time only a fraction of these players is going to be relevant to a particular client. This means that the ghost manager in Tribes rarely has to send information about more than 20 to 30 ghosts at a time.

Having a bunch of coordinate alone isn't helping much (and that's the easiest part of the question).

Some database can efficiently index geopoints and find nearby points quickly, eg: https://www.elastic.co/guide/en/elasticsearch/reference/current/geo-point.html

I remember reading an explanation on how the actual indexing is implemented but my Google-fu too weak to pull it up now.

Usually you build task queue system to poll services for new data with settings configured by user or setup event subscription system to get data when it changes.

Study code in Huginn (https://github.com/huginn/huginn) or n8n (https://github.com/n8n-io/n8n). There are other systems too.

You're not very clear about what you're trying to achieve, I'll assume the death sequence that is happening here.

• Using a mocap suit you record yourself getting "hit" (not the fall, just the inital hit and response).
• Export the data and import it into an animation tool.
• Clean up the animation.
• Import animation into game engine.
• Inside the animation, add a text key for when we should change from animation to ragdoll.
• Inside the animation graph, listen for the text key and blend from animation to ragdoll.

If you want an example, check out Advanced Locomotion System on the UE4 marketplace (it should still be free). It doesn't have hit animations, but they do have a toggle key for blending from an animation to ragdoll.

For simple maps, you can use Wang Tiles! No, i'm not kidding

Then for "dusty" edges, it's probably something like decals on top. I'm always down to recommend the Factorio Blog (214) for fast and fun implementation overviews

Pacman version comparison is here https://github.com/gtmanfred/pacman/blob/d5acf7a44a41c0ac8224895a9f15f3d04e80811d/lib/libalpm/version.c#L232

Debian version format is documented here https://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-version

It dictates how to format an packages' version so dpkg can properly compare versions.

Speaking how to more generally determine version order: If there isn't a documented format and there are at least two releases and the format didn't change wildly, that should be enough to be reasonably confident to compare the versions.

I wrote something years ago that sorted versions of different types. It essentially split the string by common delimiters such as periods and hyphens and create a numerical value. There are some edge cases but unless the author is masochistic, they shouldn't show up often.

1.5 > 1.2-3 > 1.1c > 1.0.0 becomes 1.5 > 1.23 > 1.13 > 1.0

Yeah I'd assume that they create the assets synced already, and then use combination of lerps and snaps to align them in space, and delays to align the start of the animations.

You can also blend different animations (not the best example, but hopefully you get the idea, post from here). Using that, you can blend from whatever idle animation was being used, and you don't need to make a new transition animation for everything.

They used the procedural tools in Houdini, and in fact SideFx (the makers of Houdini) went on to hire one of the JC3 devs to work on their game tools.

I'm sure I saw a video on how the levels were built in JC3, how they carefully crafted rules for how a town should be structured such as how many churches there should be and the spacing between them, and how they should be oriented. A few hundred such rules written by technical artists and they ended up with a tool where you selected a point on a map and chose how large a town you wanted and a seed and it went and built it. Can't find the video now but watch the Spiderman one that /r/KingOfSpein linked to and it's the same basic thing.

For the random events, you can use Markov Chains throughout the lifetime of a person, with the probabilities depending on their traits. For example, you can have a state transition from healthy->sick be a low probability, but a higher probability if the person was born sickly or got engaged in some high-risk profession.

What you need to do is define a continuous function which can calculate the height of your map at a certain point .

This function must be defined in a way that your seed makes signifcant changes to the output.

​

Example (try it here)!

This will generate a map like waves when you drop something in a water:

z = sin ( sqrt( x^2 + y^2 ))

​

If you change your function by multiplying your result by your seed, now your map will have bigger or smaller waves based on your seed:

z = sin ( sqrt( x^2 + y^2 )) * [your_seed_value]

​

Obviously, your terrain generator will be much more complex, but hopefully this will help you understand.