mirror of
https://gitea.sffempire.ru/Kolyah35/minecraft-pe-0.6.1.git
synced 2026-04-02 05:23:31 +00:00
446 lines
11 KiB
C++
446 lines
11 KiB
C++
#ifndef NET_MINECRAFT_WORLD_LEVEL_LEVELGEN_FEATURE__BasicTree_H__
|
|
#define NET_MINECRAFT_WORLD_LEVEL_LEVELGEN_FEATURE__BasicTree_H__
|
|
|
|
//package net.minecraft.world.level.levelgen.feature;
|
|
|
|
#include "Feature.h"
|
|
|
|
#include "../../../../util/Random.h"
|
|
#include "../../Level.h"
|
|
|
|
#include "../../tile/TreeTile.h"
|
|
|
|
class Level;
|
|
|
|
class BasicTree : public Feature
|
|
{
|
|
typedef Feature super;
|
|
private:
|
|
|
|
|
|
|
|
unsigned char axisConversionArray[6];
|
|
Random *rnd;
|
|
Level *thisLevel;
|
|
int origin[3];
|
|
int height;
|
|
int trunkHeight;
|
|
double trunkHeightScale;
|
|
double branchDensity;
|
|
double branchSlope;
|
|
double widthScale;
|
|
double foliageDensity;
|
|
int trunkWidth;
|
|
int heightVariance;
|
|
int foliageHeight;
|
|
int **foliageCoords;
|
|
int foliageCoordsLength;
|
|
void prepare(){
|
|
trunkHeight = (int) (height * trunkHeightScale);
|
|
if (trunkHeight >= height) trunkHeight = height - 1;
|
|
int clustersPerY = (int) (1.382 + pow(foliageDensity * height / 13.0, 2));
|
|
if (clustersPerY < 1) clustersPerY = 1;
|
|
int **tempFoliageCoords = new int *[clustersPerY * height];
|
|
for( int i = 0; i < clustersPerY * height; i++ )
|
|
{
|
|
tempFoliageCoords[i] = new int[4];
|
|
}
|
|
int y = origin[1] + height - foliageHeight;
|
|
int clusterCount = 1;
|
|
int trunkTop = origin[1] + trunkHeight;
|
|
int relativeY = y - origin[1];
|
|
|
|
tempFoliageCoords[0][0] = origin[0];
|
|
tempFoliageCoords[0][1] = y;
|
|
tempFoliageCoords[0][2] = origin[2];
|
|
tempFoliageCoords[0][3] = trunkTop;
|
|
y--;
|
|
|
|
while (relativeY >= 0)
|
|
{
|
|
int num = 0;
|
|
|
|
float shapefac = treeShape(relativeY);
|
|
if (shapefac < 0)
|
|
{
|
|
y--;
|
|
relativeY--;
|
|
continue;
|
|
}
|
|
|
|
double originOffset = 0.5;
|
|
while (num < clustersPerY)
|
|
{
|
|
double radius = widthScale * (shapefac * (rnd->nextFloat() + 0.328));
|
|
double angle = rnd->nextFloat() * 2.0 * 3.14159;
|
|
int x = Mth::floor(radius * sin(angle) + origin[0] + originOffset);
|
|
int z = Mth::floor(radius * cos(angle) + origin[2] + originOffset);
|
|
int checkStart[] = { x, y, z };
|
|
int checkEnd[] = { x, y + foliageHeight, z };
|
|
if (checkLine(checkStart, checkEnd) == -1) {
|
|
int checkBranchBase[] = { origin[0], origin[1], origin[2] };
|
|
double distance = sqrt(pow(abs(origin[0] - checkStart[0]), 2.0) + pow(abs(origin[2] - checkStart[2]), 2.0));
|
|
double branchHeight = distance * branchSlope;
|
|
if ((checkStart[1] - branchHeight) > trunkTop)
|
|
{
|
|
checkBranchBase[1] = trunkTop;
|
|
}
|
|
else
|
|
{
|
|
checkBranchBase[1] = (int) (checkStart[1] - branchHeight);
|
|
}
|
|
if (checkLine(checkBranchBase, checkStart) == -1)
|
|
{
|
|
tempFoliageCoords[clusterCount][0] = x;
|
|
tempFoliageCoords[clusterCount][1] = y;
|
|
tempFoliageCoords[clusterCount][2] = z;
|
|
tempFoliageCoords[clusterCount][3] = checkBranchBase[1];
|
|
clusterCount++;
|
|
}
|
|
}
|
|
num++;
|
|
}
|
|
y--;
|
|
relativeY--;
|
|
}
|
|
|
|
foliageCoordsLength = clusterCount;
|
|
foliageCoords = tempFoliageCoords;
|
|
|
|
for( int i = clusterCount; i < clustersPerY * height; i++ )
|
|
{
|
|
delete [] tempFoliageCoords[i];
|
|
tempFoliageCoords[i] = NULL;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void crossection(int x, int y, int z, float radius, unsigned char direction, int material)
|
|
{
|
|
|
|
int rad = (int) (radius + 0.618);
|
|
unsigned char secidx1 = axisConversionArray[direction];
|
|
unsigned char secidx2 = axisConversionArray[direction + 3];
|
|
int center[] = { x, y, z };
|
|
int position[] = { 0, 0, 0 };
|
|
int offset1 = -rad;
|
|
int offset2 = -rad;
|
|
int thismat;
|
|
position[direction] = center[direction];
|
|
while (offset1 <= rad)
|
|
{
|
|
position[secidx1] = center[secidx1] + offset1;
|
|
offset2 = -rad;
|
|
while (offset2 <= rad)
|
|
{
|
|
double thisdistance = pow(abs(offset1) + 0.5, 2) + pow(abs(offset2) + 0.5, 2);
|
|
if (thisdistance > radius * radius)
|
|
{
|
|
offset2++;
|
|
continue;
|
|
}
|
|
position[secidx2] = center[secidx2] + offset2;
|
|
|
|
thismat = thisLevel->getTile(position[0], position[1], position[2]);
|
|
|
|
if (!((thismat == 0) || (thismat == Tile::leaves->id)))
|
|
{
|
|
offset2++;
|
|
continue;
|
|
}
|
|
|
|
placeBlock(thisLevel, position[0], position[1], position[2], material, 0);
|
|
|
|
offset2++;
|
|
}
|
|
offset1++;
|
|
}
|
|
|
|
}
|
|
float treeShape(int y){
|
|
if (y < (((float) height) * 0.3)) return (float) -1.618;
|
|
float radius = ((float) height) / ((float) 2.0);
|
|
float adjacent = (((float) height) / ((float) 2.0)) - y;
|
|
float distance;
|
|
if (adjacent == 0) distance = radius;
|
|
else if (abs(adjacent) >= radius) distance = (float) 0.0;
|
|
else distance = (float) sqrt(pow(abs(radius), 2) - pow(abs(adjacent), 2));
|
|
distance *= (float) 0.5;
|
|
return distance;
|
|
}
|
|
float foliageShape(int y){
|
|
if ((y < 0) || (y >= foliageHeight)) return (float) -1;
|
|
else if ((y == 0) || (y == (foliageHeight - 1))) return (float) 2;
|
|
else return (float) 3;
|
|
}
|
|
void foliageCluster(int x, int y, int z){
|
|
|
|
int topy = y + foliageHeight;
|
|
int cury = topy - 1;
|
|
float radius;
|
|
while (cury >= y)
|
|
{
|
|
radius = foliageShape(cury - y);
|
|
crossection(x, cury, z, radius, (unsigned char) 1, Tile::leaves->id);
|
|
cury--;
|
|
}
|
|
|
|
}
|
|
void limb(int *start, int *end, int material)
|
|
{
|
|
int delta[] = { 0, 0, 0 };
|
|
unsigned char idx = 0;
|
|
unsigned char primidx = 0;
|
|
while (idx < 3)
|
|
{
|
|
delta[idx] = end[idx] - start[idx];
|
|
if (abs(delta[idx]) > abs(delta[primidx]))
|
|
{
|
|
primidx = idx;
|
|
}
|
|
idx++;
|
|
}
|
|
if (delta[primidx] == 0) return;
|
|
unsigned char secidx1 = axisConversionArray[primidx];
|
|
unsigned char secidx2 = axisConversionArray[primidx + 3];
|
|
char primsign;
|
|
if (delta[primidx] > 0) primsign = 1;
|
|
else primsign = -1;
|
|
double secfac1 = ((double) delta[secidx1]) / ((double) delta[primidx]);
|
|
double secfac2 = ((double) delta[secidx2]) / ((double) delta[primidx]);
|
|
int coordinate[] = { 0, 0, 0 };
|
|
int primoffset = 0;
|
|
int endoffset = delta[primidx] + primsign;
|
|
while (primoffset != endoffset)
|
|
{
|
|
coordinate[primidx] = Mth::floor(start[primidx] + primoffset + 0.5);
|
|
coordinate[secidx1] = Mth::floor(start[secidx1] + (primoffset * secfac1) + 0.5);
|
|
coordinate[secidx2] = Mth::floor(start[secidx2] + (primoffset * secfac2) + 0.5);
|
|
|
|
int dir = 0;
|
|
int xdiff = abs(coordinate[0] - start[0]);
|
|
int zdiff = abs(coordinate[2] - start[2]);
|
|
int maxdiff = (std::max)(xdiff, zdiff);
|
|
|
|
if (maxdiff > 0)
|
|
{
|
|
if (xdiff == maxdiff)
|
|
{
|
|
dir = 0;
|
|
}
|
|
else if (zdiff == maxdiff)
|
|
{
|
|
dir = 0;
|
|
}
|
|
}
|
|
placeBlock(thisLevel, coordinate[0], coordinate[1], coordinate[2], material, dir);
|
|
primoffset += primsign;
|
|
}
|
|
}
|
|
void makeFoliage(){
|
|
int idx = 0;
|
|
int finish = foliageCoordsLength;
|
|
while (idx < finish)
|
|
{
|
|
int x = foliageCoords[idx][0];
|
|
int y = foliageCoords[idx][1];
|
|
int z = foliageCoords[idx][2];
|
|
foliageCluster(x, y, z);
|
|
idx++;
|
|
}
|
|
}
|
|
bool trimBranches(int localY){
|
|
if (localY < (height * 0.2)) return false;
|
|
else return true;
|
|
}
|
|
void makeTrunk(){
|
|
int x = origin[0];
|
|
int startY = origin[1];
|
|
int topY = origin[1] + trunkHeight;
|
|
int z = origin[2];
|
|
int startCoord[] = { x, startY, z };
|
|
int endCoord[] = { x, topY, z };
|
|
limb(startCoord, endCoord, Tile::treeTrunk->id);
|
|
if (trunkWidth == 2)
|
|
{
|
|
startCoord[0] += 1;
|
|
endCoord[0] += 1;
|
|
limb(startCoord, endCoord, Tile::treeTrunk->id);
|
|
startCoord[2] += 1;
|
|
endCoord[2] += 1;
|
|
limb(startCoord, endCoord, Tile::treeTrunk->id);
|
|
startCoord[0] += -1;
|
|
endCoord[0] += -1;
|
|
limb(startCoord, endCoord, Tile::treeTrunk->id);
|
|
}
|
|
}
|
|
void makeBranches(){
|
|
int idx = 0;
|
|
int finish = foliageCoordsLength;
|
|
int baseCoord[] = { origin[0], origin[1], origin[2] };
|
|
while (idx < finish)
|
|
{
|
|
int *coordValues = foliageCoords[idx];
|
|
int endCoord[] = { coordValues[0], coordValues[1], coordValues[2] };
|
|
baseCoord[1] = coordValues[3];
|
|
int localY = baseCoord[1] - origin[1];
|
|
if (trimBranches(localY))
|
|
{
|
|
limb(baseCoord, endCoord, Tile::treeTrunk->id);
|
|
}
|
|
idx++;
|
|
}
|
|
}
|
|
int checkLine(int *start, int *end){
|
|
|
|
int delta[] = { 0, 0, 0 };
|
|
unsigned char idx = 0;
|
|
unsigned char primidx = 0;
|
|
while (idx < 3)
|
|
{
|
|
delta[idx] = end[idx] - start[idx];
|
|
if (abs(delta[idx]) > abs(delta[primidx]))
|
|
{
|
|
primidx = idx;
|
|
}
|
|
idx++;
|
|
}
|
|
if (delta[primidx] == 0) return -1;
|
|
unsigned char secidx1 = axisConversionArray[primidx];
|
|
unsigned char secidx2 = axisConversionArray[primidx + 3];
|
|
char primsign;
|
|
if (delta[primidx] > 0) primsign = 1;
|
|
else primsign = -1;
|
|
double secfac1 = ((double) delta[secidx1]) / ((double) delta[primidx]);
|
|
double secfac2 = ((double) delta[secidx2]) / ((double) delta[primidx]);
|
|
int coordinate[] = { 0, 0, 0 };
|
|
int primoffset = 0;
|
|
int endoffset = delta[primidx] + primsign;
|
|
int thismat;
|
|
while (primoffset != endoffset)
|
|
{
|
|
coordinate[primidx] = start[primidx] + primoffset;
|
|
coordinate[secidx1] = Mth::floor(start[secidx1] + (primoffset * secfac1));
|
|
coordinate[secidx2] = Mth::floor(start[secidx2] + (primoffset * secfac2));
|
|
thismat = thisLevel->getTile(coordinate[0], coordinate[1], coordinate[2]);
|
|
if (!((thismat == 0) || (thismat == Tile::leaves->id)))
|
|
{
|
|
|
|
break;
|
|
}
|
|
primoffset += primsign;
|
|
}
|
|
|
|
if (primoffset == endoffset)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
else
|
|
{
|
|
return abs(primoffset);
|
|
}
|
|
}
|
|
bool checkLocation(){
|
|
|
|
int startPosition[] = { origin[0], origin[1], origin[2] };
|
|
int endPosition[] = { origin[0], origin[1] + height - 1, origin[2] };
|
|
|
|
|
|
int baseMaterial = thisLevel->getTile(origin[0], origin[1] - 1, origin[2]);
|
|
if (!((baseMaterial == 2) || (baseMaterial == 3)))
|
|
{
|
|
return false;
|
|
}
|
|
int allowedHeight = checkLine(startPosition, endPosition);
|
|
if (allowedHeight == -1)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
else if (allowedHeight < 6)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
height = allowedHeight;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public:
|
|
BasicTree(bool doUpdate){
|
|
axisConversionArray[0] = 2;
|
|
axisConversionArray[1] = 0;
|
|
axisConversionArray[2] = 0;
|
|
axisConversionArray[3] = 1;
|
|
axisConversionArray[4] = 2;
|
|
axisConversionArray[5] = 1;
|
|
rnd = new Random();
|
|
origin[0] = 0;
|
|
origin[1] = 0;
|
|
origin[2] = 0;
|
|
height = 0;
|
|
trunkHeight = 0;
|
|
trunkHeightScale = 0.618;
|
|
branchDensity = 1.0;
|
|
branchSlope = 0.381;
|
|
widthScale = 1.0;
|
|
foliageDensity = 1.0;
|
|
trunkWidth = 1;
|
|
heightVariance = 12;
|
|
foliageHeight = 4;
|
|
foliageCoords = NULL;
|
|
foliageCoordsLength = 0;
|
|
}
|
|
virtual ~BasicTree(){
|
|
delete rnd;
|
|
|
|
for( int i = 0; i < foliageCoordsLength; i++ )
|
|
{
|
|
delete [] foliageCoords[i];
|
|
}
|
|
delete [] foliageCoords;
|
|
}
|
|
|
|
virtual void init(double heightInit, double widthInit, double foliageDensityInit){
|
|
|
|
heightVariance = (int) (heightInit * 12);
|
|
if (heightInit > 0.5) foliageHeight = 5;
|
|
widthScale = widthInit;
|
|
foliageDensity = foliageDensityInit;
|
|
}
|
|
virtual bool place(Level *level, Random *random, int x, int y, int z){
|
|
|
|
thisLevel = level;
|
|
int seed = random->nextLong();
|
|
rnd->setSeed(seed);
|
|
origin[0] = x;
|
|
origin[1] = y;
|
|
origin[2] = z;
|
|
if (height == 0)
|
|
{
|
|
height = 5 + rnd->nextInt(heightVariance);
|
|
}
|
|
if (!(checkLocation()))
|
|
{
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
prepare();
|
|
|
|
makeFoliage();
|
|
|
|
makeTrunk();
|
|
|
|
makeBranches();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
#endif /*NET_MINECRAFT_WORLD_LEVEL_LEVELGEN_FEATURE__BasicTree_H__*/ |