11/11/2022 0 Comments Minecraft dwarf fortressEventually this time can accumulate to represent large-scale works (building dams), or going to war over water rights, etc. Very-Low-fidelity: A faction has a population that loses X% of its time to resolving thirst.Low-fidelity: There's a population of NPCs in an area with a mix of jobs, quenching thirst occupies X% of their available time.Use those costs to reduce the NPCs' available time. Mid-fidelity: The NPCs live near water and have jobs with thirst 'costs'.High-fidelity: Vaguely assert that NPCs in an area can reach the water, taking X units of time to do so, so any time that "high-level action" is taken, they lose some units of time and lose thirst.Highest-fidelity: Path-plan how each NPC gets from their current location to the water, and have that NPC execute this at a time appropriate for their thirst level, which is affected by their other activities. In general, the idea is to aggressively relax constraints as you reduce fidelity, thereby reducing the time it takes to simulate.Į.g., say you have an NPC with 'thirst', and it lives in an house near-ish to a body of fresh water. This answer, broad as it is, relies on the idea that you can adjust your AI/world simulation's fidelity fairly easily, which I think is beyond what I can explain here. If you want a huge world, you'll need to reduce fidelity.Īlways ask: Can the player tell the difference? Variable Fidelity Simulations have an inverse correlation between fidelity and size/scope, so given fixed hardware you'll have to compromise. Furthermore, when a player leaves a chunk, he has made some changes to it, but the function cannot take those changes into account when computing the state of the block the next time the player enters it, in other words all changes that the player made to the block are lost as soon as he leaves. The problem with this is that this assumes a truly predeterministic world evolution, in which players have control over only their local chunk and no others. That is, a function f(time,coordinates), such that given the time and and coordinates of a block, will tell you what state that block should be in. The "solution" that I thought of is to come up with a closed form formula that simulates autoplay somehow. Moreover, this does not solve the general problem of faction simulation - factions can expand or contract through many chunks, whereas keeping one chunk loaded in memory would not affect its neighboring chunks, so that doesn't quite achieve the same effect as autoplay. The most straightforward approach to this, which is to just to make chunks remain loaded in memory even after the player is no longer in them, has the same performance issues as mentioned earlier - as the player moves across thousands of blocks, you will sooner or later run into computation limits. When a player comes back from a trip, the chunk is exactly as he left it. The minecraft world is a static, never-changing place. Minecraft gets around this problem by simply storing the inactive chunk in memory as-is as soon as the player leaves the area. With a bigger map and more factions, the performance requirements become exorbitant. On the other hand, simulating all the factions simultaneously is surely going to become a bottleneck as the map grows. One of the interesting things about Dwarf Fortress (and other procedurally generated games like Civilization) is that the game simulates multiple AI factions interacting with each other over time (what might be termed "autoplay") to generate an evolving world which changes over time, even whilst the player is playing the game.
0 Comments
Leave a Reply. |
AuthorWrite something about yourself. No need to be fancy, just an overview. ArchivesCategories |