backups/neoLegacy
2
0
Fork 0
mirror of https://github.com/neoStudiosLCE/neoLegacy.git synced 2026-06-09 02:32:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Biome Update!

Browse source
This commit is contained in:
Lord Cambion 2026-03-26 20:37:51 +01:00
parent 74c197cc15
commit 10b7fc36d3
31 changed files with 602 additions and 92 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Minecraft.Client/Common/UI/IUIScene_CreativeMenu.cpp
View file

@ -82,7 +82,7 @@ void IUIScene_CreativeMenu::staticCtor()
ITEM(Tile::obsidian_Id)
ITEM(Tile::clay)
ITEM(Tile::ice_Id)
ITEM(Tile::packed_ice_Id)
ITEM(Tile::packedIce_Id)
ITEM(Tile::snow_Id)
ITEM(Tile::netherRack_Id)
ITEM(Tile::soulsand_Id)

28
Minecraft.World/Biome.cpp
View file

@ -47,35 +47,39 @@ Biome *Biome::birchForestHillsM = nullptr;
Biome *Biome::birchForestM = nullptr;
Biome *Biome::deepOcean = nullptr;
Biome *Biome::roofedForestM = nullptr;
Biome *Biome::sunflowersPlains = nullptr;
Biome *Biome::iceSpikes = nullptr;
void Biome::staticCtor()
{
Biome::ocean = (new OceanBiome(0))->setColor(0x000070)->setName(L"Ocean")->setDepthAndScale(-1, 0.4f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Ocean, eMinecraftColour_Foliage_Ocean, eMinecraftColour_Water_Ocean,eMinecraftColour_Sky_Ocean);
Biome::plains = (new PlainsBiome(1))->setColor(0x8db360)->setName(L"Plains")->setTemperatureAndDownfall(0.8f, 0.4f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Plains, eMinecraftColour_Foliage_Plains, eMinecraftColour_Water_Plains,eMinecraftColour_Sky_Plains);
Biome::plains = (new PlainsBiome(1,false))->setColor(0x8db360)->setName(L"Plains")->setTemperatureAndDownfall(0.8f, 0.4f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Plains, eMinecraftColour_Foliage_Plains, eMinecraftColour_Water_Plains,eMinecraftColour_Sky_Plains);
Biome::sunflowersPlains = (new PlainsBiome(129,true))->setColor(0x8db360)->setName(L"Sunflowers Plains")->setTemperatureAndDownfall(0.8f, 0.4f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Plains, eMinecraftColour_Foliage_Plains, eMinecraftColour_Water_Plains,eMinecraftColour_Sky_Plains);
Biome::desert = (new DesertBiome(2))->setColor(0xFA9418)->setName(L"Desert")->setNoRain()->setTemperatureAndDownfall(2, 0)->setDepthAndScale(0.1f, 0.2f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Desert, eMinecraftColour_Foliage_Desert, eMinecraftColour_Water_Desert,eMinecraftColour_Sky_Desert);
Biome::extremeHills = (new ExtremeHillsBiome(3))->setColor(0x606060)->setName(L"Extreme Hills")->setDepthAndScale(0.3f, 1.5f)->setTemperatureAndDownfall(0.2f, 0.3f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_ExtremeHills, eMinecraftColour_Foliage_ExtremeHills, eMinecraftColour_Water_ExtremeHills,eMinecraftColour_Sky_ExtremeHills);
// Foreste Base
Biome::forest = (new ForestBiome(4,0))->setColor(0x056621)->setName(L"Forest")->setLeafColor(0x4EBA31)->setTemperatureAndDownfall(0.7f, 0.8f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Forest, eMinecraftColour_Foliage_Forest, eMinecraftColour_Water_Forest,eMinecraftColour_Sky_Forest);
Biome::forestHills = (new ForestBiome(18,0))->setColor(0x22551c)->setName(L"ForestHills")->setLeafColor(0x4EBA31)->setTemperatureAndDownfall(0.7f, 0.8f)->setDepthAndScale(0.3f, 0.7f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_ForestHills, eMinecraftColour_Foliage_ForestHills, eMinecraftColour_Water_ForestHills,eMinecraftColour_Sky_ForestHills);
Biome::forestHills = (new ForestBiome(18,0))->setColor(0x22551c)->setName(L"Forest Hills")->setLeafColor(0x4EBA31)->setTemperatureAndDownfall(0.7f, 0.8f)->setDepthAndScale(0.3f, 0.7f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_ForestHills, eMinecraftColour_Foliage_ForestHills, eMinecraftColour_Water_ForestHills,eMinecraftColour_Sky_ForestHills);
Biome::taiga = (new TaigaBiome(5))->setColor(0x0b6659)->setName(L"Taiga")->setLeafColor(0x4EBA31)->setSnowCovered()->setTemperatureAndDownfall(0.05f, 0.8f)->setDepthAndScale(0.1f, 0.4f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Taiga, eMinecraftColour_Foliage_Taiga, eMinecraftColour_Water_Taiga,eMinecraftColour_Sky_Taiga);
Biome::swampland = (new SwampBiome(6))->setColor(0x07F9B2)->setName(L"Swampland")->setLeafColor(0x8BAF48)->setDepthAndScale(-0.2f, 0.1f)->setTemperatureAndDownfall(0.8f, 0.9f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Swampland, eMinecraftColour_Foliage_Swampland, eMinecraftColour_Water_Swampland,eMinecraftColour_Sky_Swampland);
Biome::river = (new RiverBiome(7))->setColor(0x0000ff)->setName(L"River")->setDepthAndScale(-0.5f, 0)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_River, eMinecraftColour_Foliage_River, eMinecraftColour_Water_River,eMinecraftColour_Sky_River);
Biome::hell = (new HellBiome(8))->setColor(0xff0000)->setName(L"Hell")->setNoRain()->setTemperatureAndDownfall(2, 0)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Hell, eMinecraftColour_Foliage_Hell, eMinecraftColour_Water_Hell,eMinecraftColour_Sky_Hell);
Biome::sky = (new TheEndBiome(9))->setColor(0x8080ff)->setName(L"Sky")->setNoRain()->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Sky, eMinecraftColour_Foliage_Sky, eMinecraftColour_Water_Sky,eMinecraftColour_Sky_Sky);
Biome::frozenOcean = (new OceanBiome(10))->setColor(0x9090a0)->setName(L"FrozenOcean")->setSnowCovered()->setDepthAndScale(-1, 0.5f)->setTemperatureAndDownfall(0, 0.5f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_FrozenOcean, eMinecraftColour_Foliage_FrozenOcean, eMinecraftColour_Water_FrozenOcean,eMinecraftColour_Sky_FrozenOcean);
Biome::frozenRiver = (new RiverBiome(11))->setColor(0xa0a0ff)->setName(L"FrozenRiver")->setSnowCovered()->setDepthAndScale(-0.5f, 0)->setTemperatureAndDownfall(0, 0.5f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_FrozenRiver, eMinecraftColour_Foliage_FrozenRiver, eMinecraftColour_Water_FrozenRiver,eMinecraftColour_Sky_FrozenRiver);
Biome::frozenOcean = (new OceanBiome(10))->setColor(0x9090a0)->setName(L"Frozen Ocean")->setSnowCovered()->setDepthAndScale(-1, 0.5f)->setTemperatureAndDownfall(0, 0.5f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_FrozenOcean, eMinecraftColour_Foliage_FrozenOcean, eMinecraftColour_Water_FrozenOcean,eMinecraftColour_Sky_FrozenOcean);
Biome::frozenRiver = (new RiverBiome(11))->setColor(0xa0a0ff)->setName(L"Frozen River")->setSnowCovered()->setDepthAndScale(-0.5f, 0)->setTemperatureAndDownfall(0, 0.5f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_FrozenRiver, eMinecraftColour_Foliage_FrozenRiver, eMinecraftColour_Water_FrozenRiver,eMinecraftColour_Sky_FrozenRiver);
Biome::iceFlats = (new IceBiome(12))->setColor(0xffffff)->setName(L"Ice Plains")->setSnowCovered()->setTemperatureAndDownfall(0, 0.5f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_IcePlains, eMinecraftColour_Foliage_IcePlains, eMinecraftColour_Water_IcePlains,eMinecraftColour_Sky_IcePlains);
Biome::iceSpikes = (new IceBiome(12,true))->setColor(0xffffff)->setName(L"Ice Spikes")->setSnowCovered()->setTemperatureAndDownfall(0, 0.5f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_IcePlains, eMinecraftColour_Foliage_IcePlains, eMinecraftColour_Water_IcePlains,eMinecraftColour_Sky_IcePlains);
Biome::iceMountains = (new IceBiome(13))->setColor(0xa0a0a0)->setName(L"Ice Mountains")->setSnowCovered()->setDepthAndScale(0.3f, 1.3f)->setTemperatureAndDownfall(0, 0.5f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_IceMountains, eMinecraftColour_Foliage_IceMountains, eMinecraftColour_Water_IceMountains,eMinecraftColour_Sky_IceMountains);
Biome::mushroomIsland = (new MushroomIslandBiome(14))->setColor(0xff00ff)->setName(L"MushroomIsland")->setTemperatureAndDownfall(0.9f, 1.0f)->setDepthAndScale(0.2f, 1.0f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_MushroomIsland, eMinecraftColour_Foliage_MushroomIsland, eMinecraftColour_Water_MushroomIsland,eMinecraftColour_Sky_MushroomIsland);
Biome::mushroomIslandShore = (new MushroomIslandBiome(15))->setColor(0xa000ff)->setName(L"MushroomIslandShore")->setTemperatureAndDownfall(0.9f, 1.0f)->setDepthAndScale(-1, 0.1f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_MushroomIslandShore, eMinecraftColour_Foliage_MushroomIslandShore, eMinecraftColour_Water_MushroomIslandShore,eMinecraftColour_Sky_MushroomIslandShore);
Biome::mushroomIsland = (new MushroomIslandBiome(14))->setColor(0xff00ff)->setName(L"Mushroom Island")->setTemperatureAndDownfall(0.9f, 1.0f)->setDepthAndScale(0.2f, 1.0f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_MushroomIsland, eMinecraftColour_Foliage_MushroomIsland, eMinecraftColour_Water_MushroomIsland,eMinecraftColour_Sky_MushroomIsland);
Biome::mushroomIslandShore = (new MushroomIslandBiome(15))->setColor(0xa000ff)->setName(L"Mushroom Island Shore")->setTemperatureAndDownfall(0.9f, 1.0f)->setDepthAndScale(-1, 0.1f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_MushroomIslandShore, eMinecraftColour_Foliage_MushroomIslandShore, eMinecraftColour_Water_MushroomIslandShore,eMinecraftColour_Sky_MushroomIslandShore);
Biome::beaches = (new BeachBiome(16))->setColor(0xfade55)->setName(L"Beach")->setTemperatureAndDownfall(0.8f, 0.4f)->setDepthAndScale(0.0f, 0.1f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Beach, eMinecraftColour_Foliage_Beach, eMinecraftColour_Water_Beach,eMinecraftColour_Sky_Beach);
Biome::desertHills = (new DesertBiome(17))->setColor(0xd25f12)->setName(L"DesertHills")->setNoRain()->setTemperatureAndDownfall(2, 0)->setDepthAndScale(0.3f, 0.8f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_DesertHills, eMinecraftColour_Foliage_DesertHills, eMinecraftColour_Water_DesertHills,eMinecraftColour_Sky_DesertHills);
Biome::taigaHills = (new TaigaBiome(19))->setColor(0x163933)->setName(L"TaigaHills")->setSnowCovered()->setLeafColor(0x4EBA31)->setTemperatureAndDownfall(0.05f, 0.8f)->setDepthAndScale(0.3f, 0.8f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_TaigaHills, eMinecraftColour_Foliage_TaigaHills, eMinecraftColour_Water_TaigaHills,eMinecraftColour_Sky_TaigaHills);
Biome::desertHills = (new DesertBiome(17))->setColor(0xd25f12)->setName(L"Desert Hills")->setNoRain()->setTemperatureAndDownfall(2, 0)->setDepthAndScale(0.3f, 0.8f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_DesertHills, eMinecraftColour_Foliage_DesertHills, eMinecraftColour_Water_DesertHills,eMinecraftColour_Sky_DesertHills);
Biome::taigaHills = (new TaigaBiome(19))->setColor(0x163933)->setName(L"Taiga Hills")->setSnowCovered()->setLeafColor(0x4EBA31)->setTemperatureAndDownfall(0.05f, 0.8f)->setDepthAndScale(0.3f, 0.8f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_TaigaHills, eMinecraftColour_Foliage_TaigaHills, eMinecraftColour_Water_TaigaHills,eMinecraftColour_Sky_TaigaHills);
Biome::smallerExtremeHills = (new ExtremeHillsBiome(20))->setColor(0x72789a)->setName(L"Extreme Hills Edge")->setDepthAndScale(0.2f, 0.8f)->setTemperatureAndDownfall(0.2f, 0.3f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_ExtremeHillsEdge, eMinecraftColour_Foliage_ExtremeHillsEdge, eMinecraftColour_Water_ExtremeHillsEdge,eMinecraftColour_Sky_ExtremeHillsEdge);
Biome::jungle = (new JungleBiome(21))->setColor(0x537b09)->setName(L"Jungle")->setLeafColor(0x537b09)->setTemperatureAndDownfall(1.2f, 0.9f)->setDepthAndScale(0.2f, 0.4f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Jungle, eMinecraftColour_Foliage_Jungle, eMinecraftColour_Water_Jungle,eMinecraftColour_Sky_Jungle);
Biome::jungleHills = (new JungleBiome(22))->setColor(0x2c4205)->setName(L"JungleHills")->setLeafColor(0x537b09)->setTemperatureAndDownfall(1.2f, 0.9f)->setDepthAndScale(1.8f, 0.5f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_JungleHills, eMinecraftColour_Foliage_JungleHills, eMinecraftColour_Water_JungleHills,eMinecraftColour_Sky_JungleHills);
Biome::jungle = (new JungleBiome(21, false))->setColor(0x537b09)->setName(L"Jungle")->setLeafColor(0x537b09)->setTemperatureAndDownfall(1.2f, 0.9f)->setDepthAndScale(0.2f, 0.4f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Jungle, eMinecraftColour_Foliage_Jungle, eMinecraftColour_Water_Jungle,eMinecraftColour_Sky_Jungle);
Biome::jungleHills = (new JungleBiome(22, false))->setColor(0x2c4205)->setName(L"Jungle Hills")->setLeafColor(0x537b09)->setTemperatureAndDownfall(1.2f, 0.9f)->setDepthAndScale(1.8f, 0.5f)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_JungleHills, eMinecraftColour_Foliage_JungleHills, eMinecraftColour_Water_JungleHills,eMinecraftColour_Sky_JungleHills);
Biome::savanna = (new SavannaBiome(35))->setColor(0xbda235)->setName(L"Savanna")->setNoRain()->setTemperatureAndDownfall(1.2f, 0.0f) ->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Savanna, eMinecraftColour_Foliage_Savanna, eMinecraftColour_Sky_Desert, eMinecraftColour_Sky_Desert);
Biome::deepOcean= (new OceanBiome(24))->setName(L"Deep Ocean")->setDepthAndScale(-1.8,0.1f)->setColor(0x000070)->setLeafFoliageWaterSkyColor(eMinecraftColour_Grass_Ocean, eMinecraftColour_Foliage_Ocean, eMinecraftColour_Water_Ocean,eMinecraftColour_Sky_Ocean);;
// Foreste Avanzate e Speciali
@ -104,7 +108,8 @@ Biome::Biome(int id) : id(id)
downfall = 0.5f;
decorator = nullptr;
m_temperatureNoise = nullptr;
GRASS_COLOR_NOISE = new PerlinNoise(new Random(2345L), 1);
DOUBLE_PLANT_GENERATOR = new DoublePlantFeature(false);
m_grassColor = eMinecraftColour_NOT_SET;
m_foliageColor = eMinecraftColour_NOT_SET;
m_waterColor = eMinecraftColour_NOT_SET;
@ -136,6 +141,7 @@ Biome::Biome(int id) : id(id)
Biome::~Biome()
{
if(decorator != nullptr) delete decorator;
if(DOUBLE_PLANT_GENERATOR != nullptr) delete DOUBLE_PLANT_GENERATOR;
}
BiomeDecorator *Biome::createDecorator()

6
Minecraft.World/Biome.h
View file

@ -6,6 +6,7 @@ using namespace std;
#include "WeighedRandom.h"
#include "BlockPos.h"
#include "ChunkPrimer.h"
#include "DoublePlantFeature.h"
class Feature;
@ -65,6 +66,8 @@ public:
static Biome *Biome::roofedForestM;
static Biome *Biome::deepOcean;
static Biome *Biome::sunflowersPlains;
static Biome *Biome::iceSpikes;
static const int BIOME_COUNT = 256 ;
@ -79,8 +82,11 @@ public:
float temperature;
float downfall;
BiomeDecorator *decorator;
PerlinNoise *m_temperatureNoise;
PerlinNoise *GRASS_COLOR_NOISE;
DoublePlantFeature *DOUBLE_PLANT_GENERATOR;
const int id;

37
Minecraft.World/BiomeDecorator.cpp
View file

@ -76,6 +76,7 @@ void BiomeDecorator::_init()
doublePlantFeature = new DoublePlantFeature(false);
doublePlantCount = 0;
waterlilyCount = 0;
treeCount = 0;
flowerCount = 2;
@ -213,24 +214,24 @@ void BiomeDecorator::decorate()
}
}
// 2blockstall
int doublePlantsToGen = (grassCount + flowerCount) / 2;
if (doublePlantsToGen > 0 && random->nextInt(3) == 0)
{
for (int i = 0; i < doublePlantsToGen; i++)
{
int x = xo + random->nextInt(16) + 8;
int y = random->nextInt(Level::genDepth);
int z = zo + random->nextInt(16) + 8;
int plantType = biome->getRandomDoublePlantType(random);
DoublePlantFeature* dpf = static_cast<DoublePlantFeature*>(doublePlantFeature);
dpf->setPlantType(plantType);
dpf->place(level, random, x, y, z);
}
}
//int doublePlantsToGen = doublePlantCount; // <-- Usa una variabile specifica per bioma!
//for (int i = 0; i < doublePlantsToGen; i++)
//{
// // Genera il punto centrale del cluster
// int x = xo + random->nextInt(16) + 8;
// int z = zo + random->nextInt(16) + 8;
// int y = random->nextInt(Level::genDepth);
//
// int plantType = biome->getRandomDoublePlantType(random);
//
// DoublePlantFeature* dpf = static_cast<DoublePlantFeature*>(doublePlantFeature);
// dpf->setPlantType(plantType);
//
// // La chiamata place() ora genererà il grappolo grazie al ciclo da 64 inserito nel Passo 1
// dpf->place(level, random, x, y, z);
//}
PIXEndNamedEvent();
PIXBeginNamedEvent(0,"Decorate bush/waterlily/mushroom/reeds/pumpkins/cactuses");

1
Minecraft.World/BiomeDecorator.h
View file

@ -59,6 +59,7 @@ public:
Feature *tulipPinkFeature;
Feature *doublePlantFeature;
int doublePlantCount;
int waterlilyCount;
int treeCount;
int flowerCount;

4
Minecraft.World/BiomeInitLayer.cpp
View file

@ -21,7 +21,7 @@ BiomeInitLayer::BiomeInitLayer(int64_t seed, shared_ptr<Layer>parent, LevelType
}
else
{
startBiomes = BiomeArray(16);
startBiomes = BiomeArray(18);
startBiomes[0] = Biome::desert;
startBiomes[1] = Biome::forest;
startBiomes[2] = Biome::extremeHills;
@ -38,6 +38,8 @@ BiomeInitLayer::BiomeInitLayer(int64_t seed, shared_ptr<Layer>parent, LevelType
startBiomes[13] = Biome::birchForestHillsM;
startBiomes[14] = Biome::roofedForestM;
startBiomes[15] = Biome::deepOcean;
startBiomes[16] = Biome::sunflowersPlains;
startBiomes[17] = Biome::iceSpikes;
}
}

2
Minecraft.World/BiomeSource.cpp
View file

@ -27,6 +27,8 @@ void BiomeSource::_init()
playerSpawnBiomes.push_back(Biome::savanna);
playerSpawnBiomes.push_back(Biome::roofedForest);
playerSpawnBiomes.push_back(Biome::flowerForest);
playerSpawnBiomes.push_back(Biome::sunflowersPlains);
playerSpawnBiomes.push_back(Biome::iceSpikes);
}
void BiomeSource::_init(int64_t seed, LevelType *generator)

2
Minecraft.World/CMakeLists.txt
View file

@ -11,7 +11,7 @@ set(MINECRAFT_WORLD_SOURCES
${SOURCES_COMMON}
)
add_library(Minecraft.World STATIC ${MINECRAFT_WORLD_SOURCES})
add_library(Minecraft.World STATIC ${MINECRAFT_WORLD_SOURCES} "IceSpikeFeature.cpp" "IceSpikeFeature.h")
target_include_directories(Minecraft.World
PRIVATE

10
Minecraft.World/DoublePlantFeature.cpp
View file

@ -11,7 +11,7 @@ DoublePlantFeature::DoublePlantFeature(bool doUpdate)
void DoublePlantFeature::setPlantType(int plantType)
{
m_plantType = (plantType < 1) ? 1 : plantType;
m_plantType = plantType;
}
bool DoublePlantFeature::place(Level* level, Random* rand, int x, int y, int z)
@ -24,8 +24,7 @@ bool DoublePlantFeature::place(Level* level, Random* rand, int x, int y, int z)
int by = y + rand->nextInt(4) - rand->nextInt(4);
int bz = z + rand->nextInt(8) - rand->nextInt(8);
if (by >= Level::maxBuildHeight - 1) continue;
if (by < 1) continue;
if (by >= Level::maxBuildHeight - 1 || by < 1) continue;
if (level->getTile(bx, by, bz) != 0) continue;
if (level->getTile(bx, by + 1, bz) != 0) continue;
@ -33,8 +32,9 @@ bool DoublePlantFeature::place(Level* level, Random* rand, int x, int y, int z)
if (!static_cast<TallGrass2*>(Tile::tiles[Tile::tallgrass2_Id])->mayPlace(level, bx, by, bz)) continue;
level->setTileAndData(bx, by, bz, Tile::tallgrass2_Id, m_plantType, Tile::UPDATE_ALL);
level->setTileAndData(bx, by + 1, bz, Tile::tallgrass2_Id, m_plantType | TallGrass2::UPPER_BIT, Tile::UPDATE_ALL);
level->setTileAndData(bx, by, bz, Tile::tallgrass2_Id, m_plantType, 0);
level->setTileAndData(bx, by + 1, bz, Tile::tallgrass2_Id, TallGrass2::UPPER_BIT | m_plantType, 0);
placed = true;
}

54
Minecraft.World/ExtremeHillsBiome.cpp
View file

@ -3,16 +3,37 @@
#include "net.minecraft.world.level.tile.h"
#include "net.minecraft.world.level.levelgen.feature.h"
#include "ExtremeHillsBiome.h"
#include "BiomeDecorator.h"
ExtremeHillsBiome::ExtremeHillsBiome(int id) : Biome(id)
#include "SpruceFeature.h"
#include "TreeFeature.h"
ExtremeHillsBiome::ExtremeHillsBiome(int id, bool extraTrees) : Biome(id)
{
silverfishFeature = new OreFeature(Tile::monsterStoneEgg_Id, 8);
taigaFeature = new SpruceFeature(false);
friendlies.clear();
type = 0;
if (extraTrees)
{
decorator->treeCount = 3;
type = 1;
}
}
ExtremeHillsBiome::~ExtremeHillsBiome()
{
delete silverfishFeature;
delete taigaFeature;
}
Feature *ExtremeHillsBiome::getTreeFeature(Random *random)
{
if (random->nextInt(3) > 0)
{
return new SpruceFeature(false);
}
return Biome::getTreeFeature(random);
}
void ExtremeHillsBiome::decorate(Level *level, Random *random, int xo, int zo) {
@ -37,8 +58,37 @@ void ExtremeHillsBiome::decorate(Level *level, Random *random, int xo, int zo) {
for (int i = 0; i < 7; i++)
{
int x = xo + random->nextInt(16);
int y = random->nextInt(Level::genDepth / 2);
int y = random->nextInt(64);
int z = zo + random->nextInt(16);
silverfishFeature->place(level, random, x, y, z);
}
}
void ExtremeHillsBiome::buildSurfaceAtDefault(Level *level, Random *random, byte* chunkBlocks, int x, int z, double noiseVal)
{
topMaterial = static_cast<byte>(Tile::grass_Id);
material = static_cast<byte>(Tile::dirt_Id);
if ((noiseVal < -1.0 || noiseVal > 2.0) && type == 2)
{
topMaterial = static_cast<byte>(Tile::gravel_Id);
material = static_cast<byte>(Tile::gravel_Id);
}
else if (noiseVal > 1.0 && type != 1)
{
topMaterial = static_cast<byte>(Tile::stone_Id);
material = static_cast<byte>(Tile::stone_Id);
}
Biome::buildSurfaceAtDefault(level, random, chunkBlocks, x, z, noiseVal);
}
Biome* ExtremeHillsBiome::mutateHills(Biome* baseBiome)
{
this->type = 2; // Mutated type
this->setColor(baseBiome->color, true);
this->setName(baseBiome->m_name + L" M");
this->setDepthAndScale(baseBiome->depth, baseBiome->scale);
this->setTemperatureAndDownfall(baseBiome->temperature, baseBiome->downfall);
return this;
}

9
Minecraft.World/ExtremeHillsBiome.h
View file

@ -8,11 +8,16 @@ class ExtremeHillsBiome : public Biome
private:
static const bool GENERATE_EMERALD_ORE = true;
Feature *silverfishFeature;
int type;
Feature *taigaFeature;
protected:
ExtremeHillsBiome(int id);
ExtremeHillsBiome(int id, bool extraTrees = false);
~ExtremeHillsBiome();
public:
void decorate(Level *level, Random *random, int xo, int zo);
virtual void decorate(Level *level, Random *random, int xo, int zo) override;
virtual void buildSurfaceAtDefault(Level *level, Random *random, byte* chunkBlocks, int x, int z, double noiseVal) override;
virtual Feature *getTreeFeature(Random *random) override;
Biome* mutateHills(Biome* baseBiome);
};

24
Minecraft.World/FixedBiomeSource.cpp
View file

@ -45,7 +45,11 @@ floatArray FixedBiomeSource::getTemperatureBlock(int x, int z, int w, int h) con
// 4J - note that caller is responsible for deleting returned array. temperatures array is for output only.
void FixedBiomeSource::getTemperatureBlock(doubleArray& temperatures, int x, int z, int w, int h) const
{
temperatures = doubleArray(w * h);
if (temperatures.data == nullptr || temperatures.length < w * h)
{
if(temperatures.data != nullptr) delete [] temperatures.data;
temperatures = doubleArray(w * h);
}
Arrays::fill(temperatures, 0, w * h, (double)temperature);
}
@ -86,7 +90,11 @@ void FixedBiomeSource::getDownfallBlock(doubleArray downfalls, int x, int z, int
void FixedBiomeSource::getBiomeBlock(BiomeArray& biomes, int x, int z, int w, int h, bool useCache) const
{
MemSect(36);
biomes = BiomeArray(w * h);
if (biomes.data == nullptr || biomes.length < w * h)
{
if(biomes.data != nullptr) delete [] biomes.data;
biomes = BiomeArray(w * h);
}
MemSect(0);
Arrays::fill(biomes, 0, w * h, biome);
@ -96,7 +104,11 @@ void FixedBiomeSource::getBiomeBlock(BiomeArray& biomes, int x, int z, int w, in
void FixedBiomeSource::getBiomeIndexBlock(byteArray& biomeIndices, int x, int z, int w, int h, bool useCache) const
{
MemSect(36);
biomeIndices = byteArray(w * h);
if (biomeIndices.data == nullptr || biomeIndices.length < w * h)
{
if(biomeIndices.data != nullptr) delete [] biomeIndices.data;
biomeIndices = byteArray(w * h);
}
MemSect(0);
int biomeIndex = biome->id;
Arrays::fill(biomeIndices, 0, w * h, biomeIndex);
@ -107,7 +119,11 @@ void FixedBiomeSource::getBiomeIndexBlock(byteArray& biomeIndices, int x, int z,
void FixedBiomeSource::getRawBiomeBlock(BiomeArray& biomes,int x, int z, int w, int h) const
{
MemSect(36);
biomes = BiomeArray(w * h);
if (biomes.data == nullptr || biomes.length < w * h)
{
if(biomes.data != nullptr) delete [] biomes.data;
biomes = BiomeArray(w * h);
}
MemSect(0);
Arrays::fill(biomes, 0, w * h, biome);

8
Minecraft.World/ForestBiome.cpp
View file

@ -9,6 +9,7 @@
#include "Rose.h"
#include "HugeMushroomFeature.h"
#include "DoublePlantFeature.h"
#include "TallGrass2.h"
#include "../Minecraft.Client/Minecraft.h"
#include "../Minecraft.Client/Common/Colours/ColourTable.h"
#include "Level.h"
@ -175,10 +176,13 @@ void ForestBiome::decorate(Level* level, Random* rand, int xo, int zo)
{
do
{
int plantType = rand->nextInt(3);
int l1 = rand->nextInt(3);
DoublePlantFeature plantFeature;
if (l1 == 0) plantFeature.setPlantType(TallGrass2::LILAC);
else if (l1 == 1) plantFeature.setPlantType(TallGrass2::ROSE_BUSH);
else if (l1 == 2) plantFeature.setPlantType(TallGrass2::PEONY);
for (int attempts = 2; attempts >= 0; --attempts)
for (int attempts = 0; attempts < 5; ++attempts)
{
int dx = rand->nextInt(16) + 8;
int dz = rand->nextInt(16) + 8;

37
Minecraft.World/IceBiome.cpp
View file

@ -1,6 +1,39 @@
#include "stdafx.h"
#include "IceBiome.h"
#include "net.minecraft.world.level.tile.h"
#include "IceSpikeFeature.h"
#include "SpruceFeature.h"
#include "Level.h"
#include "Random.h"
IceBiome::IceBiome(int id) : Biome(id)
IceBiome::IceBiome(int id, bool isSpikes) : Biome(id)
{
};
this->isSpikes = isSpikes;
if (isSpikes)
{
topMaterial = static_cast<byte>(Tile::snow_Id);
}
friendlies.clear();
}
void IceBiome::decorate(Level *level, Random *random, int xo, int zo)
{
if (this->isSpikes)
{
IceSpikeFeature iceSpikeFeature;
for (int i = 0; i < 3; ++i)
{
int j = random->nextInt(16) + 8;
int k = random->nextInt(16) + 8;
int y = level->getHeightmap(xo + j, zo + k);
iceSpikeFeature.place(level, random, xo + j, y, zo + k);
}
}
Biome::decorate(level, random, xo, zo);
}
Feature* IceBiome::getTreeFeature(Random* random)
{
return new SpruceFeature(false);
}

6
Minecraft.World/IceBiome.h
View file

@ -3,6 +3,10 @@
class IceBiome : public Biome
{
private:
bool isSpikes;
public:
IceBiome(int id);
IceBiome(int id, bool isSpikes = false);
virtual void decorate(Level *level, Random *random, int xo, int zo) override;
virtual Feature* getTreeFeature(Random* random) override;
};

111
Minecraft.World/IceSpikeFeature.cpp Normal file
View file

@ -0,0 +1,111 @@
#include "IceSpikeFeature.h"
#include <cmath>
#include "Level.h"
#include "Tile.h"
#include <algorithm>
IceSpikeFeature::IceSpikeFeature() {}
bool IceSpikeFeature::place(Level *level, Random *random, int x, int y, int z)
{
while (level->isEmptyTile(x, y, z) && y > 2)
{
y--;
}
if (level->getTile(x, y, z) != Tile::snow_Id)
{
return false;
}
y += random->nextInt(4);
int height = random->nextInt(4) + 7;
int baseRadius = height / 4 + random->nextInt(2);
if (baseRadius > 1 && random->nextInt(60) == 0)
{
y += 10 + random->nextInt(30);
}
for (int k = 0; k < height; ++k)
{
float f = (1.0F - (float)k / (float)height) * (float)baseRadius;
int l = ceil(f);
for (int ix = -l; ix <= l; ++ix)
{
float f1 = (float)abs(ix) - 0.25F;
for (int iz = -l; iz <= l; ++iz)
{
float f2 = (float)abs(iz) - 0.25F;
if ((ix == 0 && iz == 0 || f1 * f1 + f2 * f2 <= f * f) &&
(ix != -l && ix != l && iz != -l && iz != l || random->nextFloat() <= 0.75F))
{
int currentTile = level->getTile(x + ix, y + k, z + iz);
if (level->isEmptyTile(x + ix, y + k, z + iz) || currentTile == Tile::dirt_Id ||
currentTile == Tile::snow_Id || currentTile == Tile::ice_Id)
{
level->setTileAndData(x + ix, y + k, z + iz, Tile::packedIce_Id, 0, 3);
}
if (k != 0 && l > 1)
{
currentTile = level->getTile(x + ix, y - k, z + iz);
if (level->isEmptyTile(x + ix, y - k, z + iz) || currentTile == Tile::dirt_Id ||
currentTile == Tile::snow_Id || currentTile == Tile::ice_Id)
{
level->setTileAndData(x + ix, y - k, z + iz, Tile::packedIce_Id, 0, 3);
}
}
}
}
}
}
int rootRadius = baseRadius - 1;
if (rootRadius < 0) rootRadius = 0;
else if (rootRadius > 1) rootRadius = 1;
for (int rx = -rootRadius; rx <= rootRadius; ++rx)
{
for (int rz = -rootRadius; rz <= rootRadius; ++rz)
{
int curY = y - 1;
int depthCounter = 50;
if (abs(rx) == 1 && abs(rz) == 1) depthCounter = random->nextInt(5);
while (curY > 50)
{
int t = level->getTile(x + rx, curY, z + rz);
if (!level->isEmptyTile(x + rx, curY, z + rz) && t != Tile::dirt_Id &&
t != Tile::snow_Id && t != Tile::ice_Id && t != Tile::packedIce_Id)
{
break;
}
level->setTileAndData(x + rx, curY, z + rz, Tile::packedIce_Id, 0, 3);
curY--;
depthCounter--;
if (depthCounter <= 0)
{
curY -= (random->nextInt(5) + 1);
depthCounter = random->nextInt(5);
}
}
}
}
return true;
}

10
Minecraft.World/IceSpikeFeature.h Normal file
View file

@ -0,0 +1,10 @@
#pragma once
#include "Feature.h"
class IceSpikeFeature : public Feature
{
public:
IceSpikeFeature();
virtual bool place(Level *level, Random *random, int x, int y, int z) override;
};

30
Minecraft.World/JungleBiome.cpp
View file

@ -6,14 +6,23 @@
#include "net.minecraft.world.entity.animal.h"
#include "JungleBiome.h"
JungleBiome::JungleBiome(int id) : Biome(id)
JungleBiome::JungleBiome(int id, bool isEdge) : Biome(id)
{
decorator->treeCount = 50;
this->isEdge = isEdge;
if (isEdge)
{
decorator->treeCount = 2;
}
else
{
decorator->treeCount = 50;
enemies.push_back(new MobSpawnerData(eTYPE_OCELOT, 2, 1, 1));
}
decorator->grassCount = 25;
decorator->flowerCount = 4;
enemies.push_back(new MobSpawnerData(eTYPE_OCELOT, 2, 1, 1));
// make chicken a lot more common in the jungle
friendlies.push_back(new MobSpawnerData(eTYPE_CHICKEN, 10, 4, 4));
}
@ -23,13 +32,13 @@
{
if (random->nextInt(10) == 0)
{
return new BasicTree(false); // 4J used to return member fancyTree, now returning newly created object so that caller can be consistently resposible for cleanup
return new BasicTree(false);
}
if (random->nextInt(2) == 0)
{
return new GroundBushFeature(TreeTile::JUNGLE_TRUNK, LeafTile::NORMAL_LEAF);
return new GroundBushFeature(TreeTile::JUNGLE_TRUNK, LeafTile::NORMAL_LEAF); // Shrub
}
if (random->nextInt(3) == 0)
if (!this->isEdge && random->nextInt(3) == 0)
{
return new MegaTreeFeature(false, 10 + random->nextInt(20), TreeTile::JUNGLE_TRUNK, LeafTile::JUNGLE_LEAF);
}
@ -52,12 +61,13 @@
PIXBeginNamedEvent(0, "Adding vines");
VinesFeature *vines = new VinesFeature();
for (int i = 0; i < 50; i++)
for (int j = 0; j < 50; j++)
{
int x = xo + random->nextInt(16) + 8;
int y = Level::genDepth / 2;
int y2 = 128;
int z = zo + random->nextInt(16) + 8;
vines->place(level, random, x, y, z);
vines->place(level, random, x, y2, z);
}
delete vines;
PIXEndNamedEvent();
}

12
Minecraft.World/JungleBiome.h
View file

@ -4,11 +4,13 @@
class JungleBiome : public Biome
{
private:
bool isEdge;
public:
JungleBiome(int id);
JungleBiome(int id, bool isEdge);
Feature *getTreeFeature(Random *random);
Feature *getGrassFeature(Random *random);
void decorate(Level *level, Random *random, int xo, int zo);
virtual Feature *getTreeFeature(Random *random) override;
virtual Feature *getGrassFeature(Random *random) override;
virtual void decorate(Level *level, Random *random, int xo, int zo) override;
};

8
Minecraft.World/MutatedBiome.cpp
View file

@ -76,6 +76,14 @@ int MutatedBiome::getTemperatureCategory() const {
return m_baseBiome ? m_baseBiome->getTemperatureCategory() : Biome::getTemperatureCategory();
}
Feature* MutatedBiome::getFlowerFeature(Random* random, int x, int y, int z) {
return m_baseBiome ? m_baseBiome->getFlowerFeature(random, x, y, z) : Biome::getFlowerFeature(random, x, y, z);
}
int MutatedBiome::getRandomDoublePlantType(Random* random) {
return m_baseBiome ? m_baseBiome->getRandomDoublePlantType(random) : Biome::getRandomDoublePlantType(random);
}
void MutatedBiome::buildSurfaceAt(Level* level, Random* random, ChunkPrimer* primer, int x, int z, double noiseVal) {
if (m_baseBiome)
m_baseBiome->buildSurfaceAt(level, random, primer, x, z, noiseVal);

2
Minecraft.World/MutatedBiome.h
View file

@ -15,6 +15,8 @@ public:
virtual float getCreatureProbability() const override;
virtual bool isSame(const Biome* other) const override;
virtual int getTemperatureCategory() const override;
virtual Feature* getFlowerFeature(Random* random, int x, int y, int z) override;
virtual int getRandomDoublePlantType(Random* random) override;
virtual void buildSurfaceAt(Level* level, Random* random, ChunkPrimer* primer, int x, int z, double noiseVal) override;
Biome* getBaseBiome() const { return m_baseBiome; } // Rimosso const

85
Minecraft.World/PlainsBiome.cpp
View file

@ -1,8 +1,12 @@
#include "stdafx.h"
#include "net.minecraft.world.level.biome.h"
#include "DoublePlantFeature.h"
#include "TallGrass2.h"
#include "Level.h"
PlainsBiome::PlainsBiome(int id) : Biome(id)
PlainsBiome::PlainsBiome(int id,bool plains) : Biome(id)
{
_plains = plains;
friendlies.push_back(new MobSpawnerData(eTYPE_HORSE, 5, 2, 6));
friendlies.push_back(new MobSpawnerData(eTYPE_RABBIT, 4, 2, 3));
@ -13,18 +17,73 @@ PlainsBiome::PlainsBiome(int id) : Biome(id)
Feature* PlainsBiome::getFlowerFeature(Random* random, int x, int y, int z)
{
int fType = random->nextInt(3);
if (fType == 0) return new FlowerFeature(Tile::rose_Id, Rose::OXEYE_DAISY);
if (fType == 1) return new FlowerFeature(Tile::rose_Id, Rose::AZURE_BLUET);
// Tulipani (qualsiasi colore)
int tulipColor = random->nextInt(4);
switch (tulipColor) {
case 0: return new FlowerFeature(Tile::rose_Id, Rose::RED_TULIP);
case 1: return new FlowerFeature(Tile::rose_Id, Rose::ORANGE_TULIP);
case 2: return new FlowerFeature(Tile::rose_Id, Rose::WHITE_TULIP);
case 3: return new FlowerFeature(Tile::rose_Id, Rose::PINK_TULIP);
}
double d0 = GRASS_COLOR_NOISE->getValue((double)(x + 8) / 200.0,(double)(z + 8) / 200.0);
if (d0 < -0.8)
{
int j = random->nextInt(4);
switch (j) {
case 0: return new FlowerFeature(Tile::rose_Id, Rose::ORANGE_TULIP);
case 1: return new FlowerFeature(Tile::rose_Id, Rose::RED_TULIP);
case 2: return new FlowerFeature(Tile::rose_Id, Rose::PINK_TULIP);
case 3: return new FlowerFeature(Tile::rose_Id, Rose::WHITE_TULIP);
}
}else if (random->nextInt(3) > 0)
{
int i = random->nextInt(3);
if (i == 1) {
return new FlowerFeature(Tile::rose_Id,Rose::AZURE_BLUET);
} else
return new FlowerFeature(Tile::rose_Id,Rose::OXEYE_DAISY);
}
else
{
return new FlowerFeature(Tile::flower_Id);
}
return Biome::getFlowerFeature(random, x, y, z);
}
void PlainsBiome::decorate(Level* level, Random* rand, int xo, int zo)
{
double d0 = GRASS_COLOR_NOISE->getValue((double)(xo + 8) / 200.0,(double)(zo + 8) / 200.0);
if (d0 < -0.8)
{
decorator->flowerCount = 15;
decorator->grassCount = 5;
}
else
{
decorator->flowerCount = 4;
decorator->grassCount = 10;
DOUBLE_PLANT_GENERATOR->setPlantType(TallGrass2::TALL_GRASS);
for (int i = 0; i < 7; ++i)
{
int x = xo + rand->nextInt(16) + 8;
int z = zo + rand->nextInt(16) + 8;
int y = rand->nextInt(level->getHeightmap(x, z) + 32);
DOUBLE_PLANT_GENERATOR->place(level, rand, x, y, z);
}
}
if (_plains)
{
DOUBLE_PLANT_GENERATOR->setPlantType(TallGrass2::SUNFLOWER);
for (int i1 = 0; i1 < 10; ++i1)
{
int j1 = rand->nextInt(16) + 8;
int k1 = rand->nextInt(16) + 8;
int l1 = rand->nextInt(level->getHeightmap(j1, k1) + 32);
DOUBLE_PLANT_GENERATOR->place(level, rand, j1, l1, k1);
}
}
Biome::decorate(level, rand, xo, zo);
}

7
Minecraft.World/PlainsBiome.h
View file

@ -6,6 +6,11 @@ class PlainsBiome : public Biome
{
friend class Biome;
protected:
PlainsBiome(int id);
bool _plains;
protected:
PlainsBiome(int id,bool plains);
virtual Feature* getFlowerFeature(Random* random, int x, int y, int z) override;
void decorate(Level* level, Random* rand, int xo, int zo)override;
bool isPlains() { return _plains; };
};

51
Minecraft.World/SavannaBiome.cpp
View file

@ -5,6 +5,10 @@
#include "net.minecraft.world.entity.h"
#include "SavannaBiome.h"
#include "SavannaTreeFeature.h"
#include "DoublePlantFeature.h"
#include "TallGrass2.h"
#include "Level.h"
#include "Random.h"
SavannaBiome::SavannaBiome(int id) : Biome(id)
{
@ -48,6 +52,51 @@ Feature *SavannaBiome::getFlowerFeature(Random *random, int x, int y, int z)
int SavannaBiome::getRandomDoublePlantType(Random *random)
{
return 0;
}
void SavannaBiome::decorate(Level *level, Random *random, int xo, int zo)
{
DOUBLE_PLANT_GENERATOR->setPlantType(TallGrass2::TALL_GRASS);
for (int i = 0; i < 7; ++i)
{
int x = xo + random->nextInt(16) + 8;
int z = zo + random->nextInt(16) + 8;
int y = random->nextInt(level->getHeightmap(x, z) + 32);
DOUBLE_PLANT_GENERATOR->place(level, random, x, y, z);
}
Biome::decorate(level, random, xo, zo);
}
MutatedSavannaBiome::MutatedSavannaBiome(int id, Biome* baseBiome) : MutatedBiome(id, baseBiome)
{
decorator->treeCount = 2;
decorator->flowerCount = 2;
decorator->grassCount = 5;
}
void MutatedSavannaBiome::buildSurfaceAtDefault(Level *level, Random *random, byte* chunkBlocks, int x, int z, double noiseVal)
{
topMaterial = static_cast<byte>(Tile::grass_Id);
material = static_cast<byte>(Tile::dirt_Id);
if (noiseVal > 1.75)
{
topMaterial = static_cast<byte>(Tile::stone_Id);
material = static_cast<byte>(Tile::stone_Id);
}
else if (noiseVal > -0.5)
{
topMaterial = static_cast<byte>(Tile::dirt_Id);
material = static_cast<byte>(Tile::dirt_Id);
}
Biome::buildSurfaceAtDefault(level, random, chunkBlocks, x, z, noiseVal);
}
void MutatedSavannaBiome::decorate(Level *level, Random *random, int xo, int zo)
{
MutatedBiome::decorate(level, random, xo, zo);
}

11
Minecraft.World/SavannaBiome.h
View file

@ -1,5 +1,6 @@
#pragma once
#include "Biome.h"
#include "MutatedBiome.h"
class SavannaBiome : public Biome
{
@ -12,4 +13,14 @@ public:
//virtual int getWaterColor() override;
virtual Feature *getFlowerFeature(Random *random, int x, int y, int z) override;
virtual int getRandomDoublePlantType(Random *random) override;
virtual void decorate(Level *level, Random *random, int xo, int zo) override;
};
class MutatedSavannaBiome : public MutatedBiome
{
public:
MutatedSavannaBiome(int id, Biome* baseBiome);
virtual void buildSurfaceAtDefault(Level *level, Random *random, byte* chunkBlocks, int x, int z, double noiseVal) override;
virtual void decorate(Level *level, Random *random, int xo, int zo) override;
};

40
Minecraft.World/SwampBiome.cpp
View file

@ -2,26 +2,58 @@
#include "net.minecraft.world.level.h"
#include "net.minecraft.world.level.biome.h"
#include "SwampTreeFeature.h"
#include "net.minecraft.world.level.tile.h"
#include "PerlinNoise.h"
SwampBiome::SwampBiome(int id) : Biome(id)
{
decorator->treeCount = 2;
decorator->flowerCount = -999;
decorator->flowerCount = 1;
decorator->deadBushCount = 1;
decorator->mushroomCount = 8;
decorator->reedsCount = 10;
decorator->clayCount = 1;
decorator->waterlilyCount = 4;
decorator->sandCount = 0;
decorator->grassCount = 5;
// waterColor = 0xe0ffae;
enemies.push_back(new MobSpawnerData(eTYPE_SLIME, 1, 1, 1));
}
Feature *SwampBiome::getTreeFeature(Random *random)
{
return new SwampTreeFeature(); // 4J used to return member swampTree, now returning newly created object so that caller can be consistently resposible for cleanup
return new SwampTreeFeature();
}
void SwampBiome::buildSurfaceAtDefault(Level *level, Random *random, byte* chunkBlocks, int x, int z, double noiseVal)
{
double d0 = GRASS_COLOR_NOISE->getValue(x * 0.25, z * 0.25);
if (d0 > 0.0)
{
int localX = x & 15;
int localZ = z & 15;
for (int y = 255; y >= 0; --y)
{
int index = (localX * 16 + localZ) * 256 + y;
if (chunkBlocks[index] != 0)
{
if (y == 62 && chunkBlocks[index] != static_cast<byte>(Tile::water_Id))
{
chunkBlocks[index] = static_cast<byte>(Tile::water_Id);
if (d0 < 0.12)
{
chunkBlocks[index + 1] = static_cast<byte>(Tile::waterLily_Id);
}
}
break;
}
}
}
Biome::buildSurfaceAtDefault(level, random, chunkBlocks, x, z, noiseVal);
}
// 4J Stu - Not using these any more

1
Minecraft.World/SwampBiome.h
View file

@ -14,6 +14,7 @@ public:
public:
virtual Feature *getTreeFeature(Random *random);
virtual void buildSurfaceAtDefault(Level *level, Random *random, byte* chunkBlocks, int x, int z, double noiseVal) override;
virtual Feature* getFlowerFeature(Random* random, int x, int y, int z) override{return new FlowerFeature(Tile::rose_Id, Rose::BLUE_ORCHID);}
// 4J Stu - Not using these any more
//virtual int getGrassColor();

80
Minecraft.World/TaigaBiome.cpp
View file

@ -4,20 +4,96 @@
#include "net.minecraft.world.level.levelgen.feature.h"
#include "net.minecraft.world.level.biome.h"
TaigaBiome::TaigaBiome(int id) : Biome(id)
#include "net.minecraft.world.level.tile.h"
#include "DoublePlantFeature.h"
#include "TallGrass2.h"
#include "Level.h"
#include "Random.h"
TaigaBiome::TaigaBiome(int id, int type) : Biome(id)
{
this->type = type;
friendlies_wolf.push_back(new MobSpawnerData(eTYPE_WOLF, 8, 4, 4)); // 4J - moved to their own category
friendlies.push_back(new MobSpawnerData(eTYPE_RABBIT, 4, 2, 3));
decorator->treeCount = 10;
decorator->grassCount = 1;
if (type != 1 && type != 2)
{
decorator->grassCount = 1;
decorator->mushroomCount = 1;
}
else
{
decorator->grassCount = 7;
decorator->deadBushCount = 1;
decorator->mushroomCount = 3;
}
}
Feature *TaigaBiome::getTreeFeature(Random *random)
{
if ((type == 1 || type == 2) && random->nextInt(3) == 0)
{
return new MegaTreeFeature(false, 10 + random->nextInt(20), TreeTile::SPRUCE_TRUNK, LeafTile::EVERGREEN_LEAF);
}
if (random->nextInt(3) == 0)
{
return new PineFeature();
}
return new SpruceFeature(false);
}
void TaigaBiome::decorate(Level *level, Random *random, int xo, int zo)
{
if (type == 1 || type == 2)
{
int count = random->nextInt(3);
for (int i = 0; i < count; ++i)
{
int x = xo + random->nextInt(16) + 8;
int z = zo + random->nextInt(16) + 8;
int y = level->getHeightmap(x, z);
for (int dx = -1; dx <= 1; ++dx) {
for (int dy = -1; dy <= 1; ++dy) {
for (int dz = -1; dz <= 1; ++dz) {
int tileAt = level->getTile(x + dx, y + dy, z + dz);
if (random->nextInt(4) != 0 && (tileAt == 0 || tileAt == Tile::grass_Id)) {
level->setTileAndData(x + dx, y + dy, z + dz, Tile::mossyCobblestone_Id, 0, Tile::UPDATE_CLIENTS);
}
}
}
}
}
}
DOUBLE_PLANT_GENERATOR->setPlantType(TallGrass2::LARGE_FERN);
for (int i = 0; i < 7; ++i)
{
int x = xo + random->nextInt(16) + 8;
int z = zo + random->nextInt(16) + 8;
int y = random->nextInt(level->getHeightmap(x, z) + 32);
DOUBLE_PLANT_GENERATOR->place(level, random, x, y, z);
}
Biome::decorate(level, random, xo, zo);
}
void TaigaBiome::buildSurfaceAtDefault(Level *level, Random *random, byte* chunkBlocks, int x, int z, double noiseVal)
{
if (type == 1 || type == 2)
{
topMaterial = static_cast<byte>(Tile::grass_Id);
material = static_cast<byte>(Tile::dirt_Id);
if (noiseVal > 1.75)
{
topMaterial = static_cast<byte>(Tile::dirt_Id);
}
else if (noiseVal > -0.95)
{
topMaterial = static_cast<byte>(Tile::dirt_Id);
}
}
Biome::buildSurfaceAtDefault(level, random, chunkBlocks, x, z, noiseVal);
}

8
Minecraft.World/TaigaBiome.h
View file

@ -3,8 +3,12 @@
class TaigaBiome : public Biome
{
private:
int type;
public:
TaigaBiome(int id);
TaigaBiome(int id, int type = 0);
virtual Feature *getTreeFeature(Random *random);
virtual Feature *getTreeFeature(Random *random) override;
virtual void decorate(Level *level, Random *random, int xo, int zo) override;
virtual void buildSurfaceAtDefault(Level *level, Random *random, byte* chunkBlocks, int x, int z, double noiseVal) override;
};

4
Minecraft.World/Tile.cpp
View file

@ -259,7 +259,7 @@ Tile* Tile::prismarine = nullptr;
Tile* Tile::tree2Trunk = nullptr;
Tile* Tile::packed_ice = nullptr;
Tile* Tile::packedIce = nullptr;
TallGrass2* Tile::tallgrass2 = nullptr;
@ -520,7 +520,7 @@ void Tile::staticCtor()
Tile::coalBlock = (new Tile(173, Material::stone)) ->setBaseItemTypeAndMaterial(Item::eBaseItemType_block, Item::eMaterial_coal)->setDestroyTime(5.0f)->setExplodeable(10)->setSoundType(SOUND_STONE)->setIconName(L"coal_block")->setDescriptionId(IDS_TILE_COAL)->setUseDescriptionId(IDS_DESC_COAL_BLOCK);
//
Tile::packed_ice = (new PackedIceTile(174))->setDestroyTime(0.5f)->setSoundType(SOUND_GLASS)->setIconName(L"packed_ice")->setDescriptionId(IDS_TILE_PACKED_ICE)->setUseDescriptionId(IDS_DESC_PACKED_ICE);
Tile::packedIce = (new PackedIceTile(174))->setDestroyTime(0.5f)->setSoundType(SOUND_GLASS)->setIconName(L"packed_ice")->setDescriptionId(IDS_TILE_PACKED_ICE)->setUseDescriptionId(IDS_DESC_PACKED_ICE);
Tile::invertedDaylightDetector = static_cast<DaylightDetectorTile*>((new DaylightDetectorTile(178, true))->setDestroyTime(0.2f)->setSoundType(SOUND_WOOD)->setIconName(L"daylight_detector")->setDescriptionId(IDS_TILE_DAYLIGHT_DETECTOR)->setUseDescriptionId(IDS_DESC_DAYLIGHT_DETECTOR));
Tile::red_sandstone = (new RedSandStoneTile(179))->setBaseItemTypeAndMaterial(Item::eBaseItemType_structblock, Item::eMaterial_sand)->setSoundType(Tile::SOUND_STONE)->setDestroyTime(0.8f)->sendTileData()->setIconName(L"red_sandstone")->setDescriptionId(IDS_TILE_RED_SANDSTONE)->setUseDescriptionId(IDS_DESC_RED_SANDSTONE)->sendTileData();

4
Minecraft.World/Tile.h
View file

@ -380,7 +380,7 @@ public:
static const int woolCarpet_Id = 171;
static const int clayHardened_Id = 172;
static const int coalBlock_Id = 173;
static const int packed_ice_Id = 174;
static const int packedIce_Id = 174;
static const int tallgrass2_Id = 175;
//176 standing_banner
//177 wall_banner
@ -629,7 +629,7 @@ public:
static Tile* red_sandstone;
static Tile* stairs_red_sandstone;
static Tile* tree2Trunk;
static Tile* packed_ice;
static Tile* packedIce;
static Tile* seaLantern;
static Tile* prismarine;