1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
package org.bukkit.craftbukkit.generator;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
import it.unimi.dsi.fastutil.longs.Long2ObjectMaps;
import it.unimi.dsi.fastutil.longs.LongSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import net.minecraft.server.*;
import org.bukkit.block.Biome;
import org.bukkit.generator.BlockPopulator;
import org.bukkit.generator.ChunkGenerator;
import org.bukkit.craftbukkit.block.CraftBlock;
public class CustomChunkGenerator extends InternalChunkGenerator<GeneratorSettingsDefault> {
private final ChunkGenerator generator;
private final WorldServer world;
private final long seed;
private final Random random;
private final WorldChunkManager chunkManager;
private final WorldGenStronghold strongholdGen = new WorldGenStronghold();
private final GeneratorSettingsDefault settings = new GeneratorSettingsDefault();
private static class CustomBiomeGrid implements BiomeGrid {
BiomeBase[] biome;
@Override
public Biome getBiome(int x, int z) {
return CraftBlock.biomeBaseToBiome(biome[(z << 4) | x]);
}
@Override
public void setBiome(int x, int z, Biome bio) {
biome[(z << 4) | x] = CraftBlock.biomeToBiomeBase(bio);
}
}
public CustomChunkGenerator(World world, long seed, ChunkGenerator generator) {
this.world = (WorldServer) world;
this.generator = generator;
this.seed = seed;
this.random = new Random(seed);
this.chunkManager = world.worldProvider.getChunkGenerator().getWorldChunkManager();
}
@Override
public void createChunk(IChunkAccess ichunkaccess) {
int x = ichunkaccess.getPos().x;
int z = ichunkaccess.getPos().z;
random.setSeed((long) x * 341873128712L + (long) z * 132897987541L);
// Get default biome data for chunk
CustomBiomeGrid biomegrid = new CustomBiomeGrid();
biomegrid.biome = chunkManager.getBiomeBlock(x << 4, z << 4, 16, 16);
ChunkData data = generator.generateChunkData(this.world.getWorld(), random, x, z, biomegrid);
Preconditions.checkArgument(data instanceof CraftChunkData, "Plugins must use createChunkData(World) rather than implementing ChunkData: %s", data);
ChunkSection[] sections = ((CraftChunkData) data).getRawChunkData();
ChunkSection[] csect = ichunkaccess.getSections();
int scnt = Math.min(csect.length, sections.length);
// Loop through returned sections
for (int sec = 0; sec < scnt; sec++) {
if (sections[sec] == null) {
continue;
}
ChunkSection section = sections[sec];
csect[sec] = section;
}
// Set biome grid
ichunkaccess.a(biomegrid.biome);
}
@Override
public ChunkData generateChunkData(org.bukkit.World world, Random random, int x, int z, BiomeGrid biome) {
return generator.generateChunkData(world, random, x, z, biome);
}
@Override
public boolean canSpawn(org.bukkit.World world, int x, int z) {
return generator.canSpawn(world, x, z);
}
@Override
public List<BlockPopulator> getDefaultPopulators(org.bukkit.World world) {
return generator.getDefaultPopulators(world);
}
@Override
public List<BiomeBase.BiomeMeta> getMobsFor(EnumCreatureType type, BlockPosition position) {
BiomeBase biomebase = world.getBiome(position);
return biomebase == null ? null : biomebase.getMobs(type);
}
@Override
public void addFeatures(RegionLimitedWorldAccess regionlimitedworldaccess, WorldGenStage.Features worldgenstage_features) {
}
@Override
public void addDecorations(RegionLimitedWorldAccess regionlimitedworldaccess) {
}
@Override
public void addMobs(RegionLimitedWorldAccess regionlimitedworldaccess) {
}
@Override
public BlockPosition findNearestMapFeature(World world, String type, BlockPosition position, int i, boolean flag) {
return "Stronghold".equals(type) && this.strongholdGen != null ? this.strongholdGen.getNearestGeneratedFeature(world, this, position, i, flag) : null;
}
@Override
public GeneratorSettingsDefault getSettings() {
return settings;
}
@Override
public int a(World world, boolean flag, boolean flag1) {
return 0;
}
@Override
public boolean canSpawnStructure(BiomeBase biomebase, StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator) {
return biomebase.a(structuregenerator);
}
@Override
public WorldGenFeatureConfiguration getFeatureConfiguration(BiomeBase biomebase, StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator) {
return biomebase.b(structuregenerator);
}
// Taken from ChunkGeneratorAbstract
private final Map<StructureGenerator<? extends WorldGenFeatureConfiguration>, Long2ObjectMap<StructureStart>> structureStartCache = Maps.newHashMap();
@Override
public Long2ObjectMap<StructureStart> getStructureStartCache(StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator) {
return (Long2ObjectMap) this.structureStartCache.computeIfAbsent(structuregenerator, (s) -> {
return Long2ObjectMaps.synchronize(new ExpiringMap(8192, 10000));
});
}
// Taken from ChunkGeneratorAbstract
private final Map<StructureGenerator<? extends WorldGenFeatureConfiguration>, Long2ObjectMap<LongSet>> structureCache = Maps.newHashMap();
@Override
public Long2ObjectMap<LongSet> getStructureCache(StructureGenerator<? extends WorldGenFeatureConfiguration> structuregenerator) {
return (Long2ObjectMap) this.structureCache.computeIfAbsent(structuregenerator, (s) -> {
return Long2ObjectMaps.synchronize(new ExpiringMap(8192, 10000));
});
}
@Override
public WorldChunkManager getWorldChunkManager() {
return chunkManager;
}
@Override
public long getSeed() {
return seed;
}
@Override
public int getSpawnHeight() {
return world.getSeaLevel() + 1;
}
@Override
public int getGenerationDepth() {
return world.getHeight();
}
}
|
