public Biome(string id, BiomeTemperature temperature, int minHeight, int maxHeight, Rgba32I grassColor, World world,
int seed)
{
_id = id;
_temperature = temperature;
_minHeight = minHeight;
_maxHeight = maxHeight;
_grassColor = grassColor;
_world = world;
_seed = seed;
}
public bool Load()
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var regionsFolder = _world.Folder + Path.DirectorySeparatorChar + World2dRegionFolder;
FolderUtils.CreateRegionFolderIfNotExist(regionsFolder);
var file = regionsFolder + Path.DirectorySeparatorChar + _position.X + "-" + _position.Y + ".reg";
if (!File.Exists(file))
{
return(false);
}
var stream = new DeflateStream(File.Open(file, FileMode.Open, FileAccess.Read), CompressionMode.Decompress);
var formatter = new BinaryFormatter();
var version = (uint)formatter.Deserialize(stream);
var grid = _world.WorldGenerator.BiomeGrid;
for (var x = 0; x < RegionLength; x++)
{
for (var z = 0; z < RegionLength; z++)
{
_biomes[x, z] = grid.GetBiomeOrDefault((string)formatter.Deserialize(stream));
_heights[x, z] = (int)formatter.Deserialize(stream);
_interpolatedHeights[x, z] = (int)formatter.Deserialize(stream);
_interpolatedGrassColors[x, z] = new Rgba32I(
(byte)formatter.Deserialize(stream),
(byte)formatter.Deserialize(stream),
(byte)formatter.Deserialize(stream),
(byte)formatter.Deserialize(stream));
var light = new SunlightData(this, new Vector2i(x, z));
light.Load(stream, formatter);
_sunlightData[x, z] = light;
}
}
stream.Close();
stopwatch.Stop();
_world.DelayViewer.AddRegion2dLoad(stopwatch.ElapsedTicks);
return(true);
}
public Block(BlockStaticData staticData, Chunk chunk, Vector3i position, Rgba32I textureFilter)
{
_weakReference = new WeakReference <Block>(this);
_staticData = staticData;
_chunk = chunk;
_position = position;
_collidableFaces = new bool[6];
_textureFilter = textureFilter;
_neighbours = new WeakReference <Block> [6];
_blockLight = new BlockLight();
var lightSource = staticData.LightSource;
_blockLightSource = lightSource ? new BlockLightSource(this, staticData.LightSourceLight) : null;
if (!lightSource)
{
return;
}
_blockLight.Light = _blockLightSource.SourceLight;
_blockLight.Source = _blockLightSource;
}
public override void AddData(int mapperIndex, Block block, int blockLight, int sunlight)
{
if (!(block is BlockWater water))
{
return;
}
var mapper = _mappers[mapperIndex];
var pos = BitUtils.IntBitsToFloat(block.Position);
var filter = block.TextureFilter;
var index = BlockWater.TextureIndex;
var levels = water.VertexWaterLevel;
var t = water.HasWaterOnTop;
var waterLevel = new Rgba32I((byte)(t ? 8 : levels[0]), (byte)(t ? 8 : levels[1]),
(byte)(t ? 8 : levels[2]),
(byte)(t ? 8 : levels[3]));
mapper.AddTask(new VboMapperTask <Block>(VboMapperTaskType.Add, block,
new[] {
pos.X, pos.Y, pos.Z, index,
filter.ValueF, blockLight / Block.MaxBlockLightF,
sunlight / Block.MaxBlockLightF, waterLevel.ValueF
}, 0));
}
public CrossBlock(BlockStaticDataCross staticData, Chunk chunk, Vector3i position, Rgba32I textureFilter)
: base(staticData, chunk, position, textureFilter)
{
}
public override BlockSnapshot GetBlockSnapshot(Vector3i position, int columnHeight, Rgba32I grassColor)
{
var y = position.Y;
if (y > columnHeight)
{
return(y > 60 ? BlockSnapshotAir.Instance : (BlockSnapshot) new BlockSnapshotWater(8));
}
if (y == columnHeight)
{
if (y > 59)
{
return(new BlockSnapshotGrass(grassColor));
}
return(BlockSnapshotDirt.Instance);
}
if (y > columnHeight - 4)
{
return(BlockSnapshotDirt.Instance);
}
return(BlockSnapshotStone.Instance);
}
public abstract BlockSnapshot GetBlockSnapshot(Vector3i position, int columnHeight, Rgba32I grassColor);
public SlabBlock(BlockStaticDataSlab staticData, Chunk chunk, Vector3i position, Rgba32I textureFilter,
bool upside)
: base(staticData, chunk, position, textureFilter)
{
_upside = upside;
_visibleFaces = 0;
}
public CubicBlock(BlockStaticDataCubic staticData, Chunk chunk, Vector3i position, Rgba32I textureFilter)
: base(staticData, chunk, position, textureFilter)
{
_visibleFaces = 0;
}
public BlockSnapshotOakLeaves(Rgba32I grassColor) : base("default:oak_leaves", BlockStaticDataOakLeaves.Instance)
{
_grassColor = grassColor;
}
public MultiTexturedSlabBlock(BlockStaticDataMultiTexturedSlab staticData, Chunk chunk, Vector3i position,
Rgba32I textureFilter, bool upside)
: base(staticData, chunk, position, textureFilter, upside)
{
}
public override BlockSnapshot GetBlockSnapshot(Vector3i position, int columnHeight, Rgba32I grassColor)
{
var y = position.Y;
var cave = _caveGenerator.Noise(1, 10, true, position.X, position.Y, position.Z) > 0.5;
if (cave)
{
return(BlockSnapshotAir.Instance);
}
if (y > columnHeight)
{
return(y > 60 ? BlockSnapshotAir.Instance : (BlockSnapshot) new BlockSnapshotWater(8));
}
if (y == columnHeight)
{
if (y > 59)
{
if (_random.NextDouble() > 0.9995)
{
_treeGenerator.TryToGenerate(position + new Vector3i(0, 1, 0), _world);
}
else if (_random.NextDouble() > 0.96)
{
_world.UnloadedChunkGenerationManager.AddBlock(position + new Vector3i(0, 1, 0),
new BlockSnapshotTallGrass(grassColor), false);
}
return(new BlockSnapshotGrass(grassColor));
}
return(BlockSnapshotDirt.Instance);
}
if (y > columnHeight - 4)
{
return(BlockSnapshotDirt.Instance);
}
return(BlockSnapshotStone.Instance);
}
public MultiTexturedCubicBlock(BlockStaticDataMultiTexturedCubic staticData, Chunk chunk, Vector3i position,
Rgba32I textureFilter)
: base(staticData, chunk, position, textureFilter)
{
}
public override BlockSnapshot GetBlockSnapshot(Vector3i position, int columnHeight, Rgba32I grassColor)
{
var y = position.Y;
if (y > columnHeight)
{
return(y > 60 ? BlockSnapshotAir.Instance : (BlockSnapshot) new BlockSnapshotWater(8));
}
if (y == columnHeight)
{
if (y > 59)
{
var generateTreeGrass = _treeOctaveGenerator.Noise(100, 100, true,
position.X, y, position.Z);
if (generateTreeGrass > 0.99)
{
_treeGenerator.TryToGenerate(position + new Vector3i(0, 1, 0), _world);
}
else if (generateTreeGrass > 0.5)
{
_world.UnloadedChunkGenerationManager.AddBlock(position + new Vector3i(0, 1, 0),
new BlockSnapshotTallGrass(grassColor), false);
}
return(new BlockSnapshotGrass(grassColor));
}
return(BlockSnapshotDirt.Instance);
}
if (y > columnHeight - 4)
{
return(BlockSnapshotDirt.Instance);
}
return(BlockSnapshotStone.Instance);
}
public BlockSnapshotTallGrass(Rgba32I grassColor) : base("default:tall_grass", BlockStaticDataTallGrass.Instance)
{
_grassColor = grassColor;
}
private void Interpolate(World2dRegion[,] regions, Vector2i position, Vector2i local, out int height,
out Rgba32I grassColor)
{
const int radius = 5;
height = 0;
var gColor = Vector3i.Zero;
for (var x = -radius; x <= radius; x++)
{
for (var z = -radius; z <= radius; z++)
{
var rx = 1;
var rz = 1;
var relative = position + new Vector2i(x, z);
var relativeLocal = local + new Vector2i(x, z);
if (relativeLocal.X < 0)
{
relativeLocal.X += RegionLength;
rx--;
}
else if (relativeLocal.X >= RegionLength)
{
relativeLocal.X -= RegionLength;
rx++;
}
if (relativeLocal.Y < 0)
{
relativeLocal.Y += RegionLength;
rz--;
}
else if (relativeLocal.Y >= RegionLength)
{
relativeLocal.Y -= RegionLength;
rz++;
}
var region = regions[rx, rz];
if (region == null)
{
var biome = _world.WorldGenerator.BiomeGrid.GetBiome(relative);
height += biome.GetColumnHeight(relative);
var bgColor = biome.GrassColor;
gColor += new Vector3i(bgColor.R, bgColor.G, bgColor.B);
}
else
{
height += region._heights[relativeLocal.X, relativeLocal.Y];
var bgColor = region._biomes[relativeLocal.X, relativeLocal.Y].GrassColor;
gColor += new Vector3i(bgColor.R, bgColor.G, bgColor.B);
}
}
}
const int d = radius * 2 + 1;
height /= d * d;
gColor /= d * d;
grassColor = new Rgba32I((byte)gColor.X, (byte)gColor.Y, (byte)gColor.Z, 255);
}
public override BlockSnapshot GetBlockSnapshot(Vector3i position, int columnHeight, Rgba32I grassColor)
{
var y = position.Y;
if (y > columnHeight)
{
return(y > 60 ? BlockSnapshotAir.Instance : (BlockSnapshot) new BlockSnapshotWater(8));
}
if (y == columnHeight)
{
if (y > 59)
{
var generateTree = _treeOctaveGenerator.Noise(100, 10, true,
position.X, y, position.Z) > 0.7;
if (generateTree)
{
_treeGenerator.TryToGenerate(position + new Vector3i(0, 1, 0), _world);
}
return(new BlockSnapshotGrass(grassColor));
}
return(BlockSnapshotDirt.Instance);
}
if (y > columnHeight - 4)
{
return(BlockSnapshotDirt.Instance);
}
return(BlockSnapshotStone.Instance);
}
