树苗生长系统#

@Override
protected void randomTick(BlockState state, ServerWorld world, BlockPos pos, Random random) {
    if (world.getLightLevel(pos.up()) >= 9    // 头顶光照 ≥ 9
        && random.nextInt(7) == 0) {          // 1/7 概率（平均 ~476 秒一次）
        this.generate(world, pos, state, random);
    }
}

// Fertilizable 接口实现
public boolean isFertilizable(WorldView w, BlockPos p, BlockState s) { return true; }
public boolean canGrow(World w, Random r, BlockPos p, BlockState s) {
    return w.random.nextFloat() < 0.45;  // 45% 成功概率
}
public void grow(ServerWorld w, Random r, BlockPos p, BlockState s) {
    this.generate(w, p, s, r);
}

public void generate(ServerWorld world, BlockPos pos, BlockState state, Random random) {
    if (state.get(STAGE) == 0) {
        // 阶段 0 → 阶段 1：只是改 BlockState，不生成树
        // 这一步让"一次骨粉直接长出一棵树"变成了概率问题
        world.setBlockState(pos, state.cycle(STAGE), SKIP_REDRAW_AND_BLOCK_ENTITY_REPLACED_CALLBACK);
    } else {
        // 阶段 1 → 树：调用 SaplingGenerator.generate 生成世界结构
        this.generator.generate(world,
            world.getChunkManager().getChunkGenerator(),
            pos, state, random);
    }
}

SaplingGenerator OAK = new SaplingGenerator(
    "oak",
    0.1F,                              // 10% 概率选中稀有变种
    Optional.empty(),                  // 无巨型树（橡树没有 2x2 巨型）
    Optional.empty(),                  // 无稀有巨型
    Optional.of(TreeConfiguredFeatures.OAK),              // 普通橡树
    Optional.of(TreeConfiguredFeatures.FANCY_OAK),        // 稀有：大型（弯）橡树
    Optional.of(TreeConfiguredFeatures.OAK_BEES_005),     // 蜜蜂橡树（5%概率有蜂巢）
    Optional.of(TreeConfiguredFeatures.FANCY_OAK_BEES_005)
);

// 普通小树特征（用于 1x1 树苗）
private RegistryKey<ConfiguredFeature<?,?>> getSmallTreeFeature(Random r, boolean flowers) {
    if (r.nextFloat() < rareChance) {
        // 命中稀有概率
        if (flowers && rareBeesVariant.isPresent()) return rareBeesVariant;
        if (rareRegularVariant.isPresent())      return rareRegularVariant;
    }
    // 普通概率：有花 + 有蜜蜂变种 → 蜜蜂橡树；否则普通
    return flowers && beesVariant.isPresent() ? beesVariant : regularVariant;
}

// 附近有花吗？搜索 pos.down().north(2).west(2) 到 pos.up().south(2).east(2)
private boolean areFlowersNearby(WorldAccess w, BlockPos p) {
    for (BlockPos n : BlockPos.iterate(p.down().north(2).west(2), p.up().south(2).east(2)))
        if (w.getBlockState(n).isIn(BlockTags.FLOWERS)) return true;
    return false;
}

// 第一步：尝试 2x2 巨型树
if (megaVariant != null) {
    // 检查 4 种"左上角偏移"对齐方式（0,0）（0,-1）（-1,0）（-1,-1）
    for (int i = 0; i >= -1; i--) {
        for (int j = 0; j >= -1; j--) {
            if (canGenerateLargeTree(state, world, pos, i, j)) {
                // 2x2 树苗确认无误，开始生成
                // 1. 先把 4 个树苗全部设为 AIR
                setBlock(add(i,0,j), AIR, ...)
                setBlock(add(i+1,0,j), AIR, ...)
                setBlock(add(i,0,j+1), AIR, ...)
                setBlock(add(i+1,0,j+1), AIR, ...)

                // 2. 调用 ConfiguredFeature.generate(左上角)
                if (configuredFeature.generate(world, chunkGen, rand, pos.add(i,0,j)))
                    return true;  // 成功

                // 3. 失败回滚：恢复 4 棵树苗
                setBlock(..., state) × 4
                return false;
            }
        }
    }
}

// 第二步：尝试 1x1 普通树
feature = getSmallTreeFeature(rand, areFlowersNearby(world, pos));
if (feature == null) return false;

// 同样先把自己去掉，腾出位置
BlockState fluidState = world.getFluidState(pos).getBlockState();
world.setBlockState(pos, fluidState, SKIP_REDRAW_AND_BLOCK_ENTITY_REPLACED_CALLBACK);

if (configuredFeature.generate(world, chunkGen, rand, pos)) {
    // 生成成功后如果位置还没被树覆盖，通知邻居
    if (world.getBlockState(pos) == fluidState)
        world.updateListeners(pos, state, fluidState, NOTIFY_LISTENERS);
    return true;
} else {
    // 失败：恢复树苗
    world.setBlockState(pos, state, SKIP_REDRAW_AND_BLOCK_ENTITY_REPLACED_CALLBACK);
    return false;
}

@Override
protected void randomTick(BlockState state, ServerWorld world, BlockPos pos, Random random) {
    if (!isHanging(state)) {
        // 着地状态：1/7 概率长成树（同普通树苗）
        if (random.nextInt(7) == 0) generate(world, pos, state, random);
    } else {
        // 悬挂状态：每次都长一岁，到 AGE=4 就停
        if (!isFullyGrown(state)) {
            world.setBlockState(pos, state.cycle(AGE), NOTIFY_LISTENERS);
        }
    }
}

// PropaguleBlock.canPlaceAt
protected boolean canPlaceAt(BlockState state, WorldView world, BlockPos pos) {
    if (isHanging(state)) {
        // 悬挂：上方必须是红树叶
        return world.getBlockState(pos.up()).isOf(Blocks.MANGROVE_LEAVES);
    } else {
        return super.canPlaceAt(state, world, pos);  // 继承 SaplingBlock.canPlaceAt
    }
}

// 父类 PlantBlock.canPlaceAt 检查 canPlantOnTop：
// PropaguleBlock 重写为：泥土/耕地 或 粘土
protected boolean canPlantOnTop(BlockState floor, BlockView w, BlockPos p) {
    return super.canPlantOnTop(floor, w, p)  // 泥土类 / 耕地
        || floor.isOf(Blocks.CLAY);          // 红树特有：粘土
}

public void grow(ServerWorld world, Random r, BlockPos pos, BlockState state) {
    if (isHanging(state) && !isFullyGrown(state)) {
        world.setBlockState(pos, state.cycle(AGE), NOTIFY_LISTENERS);
    } else {
        super.grow(world, r, pos, state);
    }
}

// PlantBlock.getStateForNeighborUpdate
protected BlockState getStateForNeighborUpdate(...) {
    return !state.canPlaceAt(world, pos) ? Blocks.AIR : super....;
}