ergor / mcworld Goto Github PK

Now we get random biomes in generated map

The current SOSI format implementation is thrown together to get testing quickly.

It should follow the specification:
https://www.kartverket.no/globalassets/standard/sosi-standarden-del-1-og-2/sosi-standarden/del1_2_realiseringsosigml-4.0.pdf

The Block class and its subclasses can be statically initialized. There is no need to create new objects each time we want to add a block to a world; the NBT lib doesn't seem to care.

I believe Java suffers from not having value-type structs. We cannot pass a coordinate, nor return one, without allocating it on the heap. There are millions of allocations being done while rendering, which must unnecessarily slow down the process.

Consider the following options:

• Keep using Java only. Try to profile the program and find out whether it is possible to optimize.
• Re-write the rendering logic in Rust. The Java part of the program shall deal with input and preprocessing, and delegate the heavy lifting to the Rust program.
• Re-write the complete program in Rust.

Im not happy with how it turned out. See if it can be done in a better way

Detect hills and mountains in order to render the slopes as pure stone.

Currently they just look like heaps of dirt.

Now it is "mcworld-$VERSION". Remember to update README.

Add support for OpenStreetMap (.osm) exports.
Can extract lots of surface data like roads, streets, forests, beach etc.

Add support for additional data:

• Roads/streets
• Landscapes: forests, beaches, etc
• Lakes

In WorldMapper#toChunkBuilders, it is currently assumed that the distance unit per pixel is in meters per pixel.

Need to account for other units as well.

Currently the rendering works on a per source height map basis.
But it should be working on a per chunk basis.

I.e. now it takes a height map and figures out which chunks they will become. But it should be the reverse; it should take a chunk coordinate, and figure out what source height map it needs to read from as well as which points it needs to read.

The rendering should be able to render any 1 chunk, fully independently from other chunks.

It should work as follows:

• The program shall take as input what real-world coordinate should be defined as in-game block coordinate (0, 0).
• Given a chunk coordinate, the renderer should select the appropriate source height map, or height maps if the chunk overlaps multiple source height maps.

The chunk first approach is better suited for streaming live data, e.g. for use in a server plugin with live data loading.

If the input heightmap has heights greater than 255, it can't fit in the game. There should be several options for how to deal with this:

• No scaling (clipping)
• Linear scaling
• Logarithmic scaling

Ties in with #5

At first we can test with generating the trees and place them randomly.

Then eventually we can use the generator with the input layers of #5 to place trees accoring to rela data.