BetterView

Description

BetterView is a high-performance Paper plugin and Fabric mod for Minecraft servers. It extends the normal view distance
without sacrificing server performance using asynchronous player processing, direct chunk reading from disk, and
caching of chunk data.

Features

• Asynchronous fast player ticking on networking threads
• Reads chunks directly from disk without loading them
• Optimized chunk state tracking and chunk iteration
• Configurable chunk data caching for fast access
• Configurable limitations for chunk sending and chunk generation
• Per-dimension configuration options
• Support for integrated or dedicated fabric servers
• Lightweight anti-xray support for extended chunks

Example: Loading speed for a view distance of 127 chunks

The screenshot below was taken at 0 2250 0 in the end dimension with a view distance of 127 chunks
(with fog disabled). On an AMD Ryzen 7 5800X, all visible chunks were transmitted to the client in about
12 seconds after having joined the server with a cold cache and in about 9 seconds with a warm cache.

Supported Software

On fabric, this mod depends on Moonrise and
adventure-platform-mod to work.

Usage

On Paper servers, place the jar file in your plugins directory and restart your server. On Fabric servers/clients,
place the jar file in your mods directory and restart your server or client. By default, BetterView will configure a
view distance of 32 chunks for each dimension.

Configuration

On the first start, this plugin will automatically create a configuration file. If using Paper it will be created at
plugins/BetterView/config.yml, if using Fabric it will be created as betterview.yml inside your world directory
(e.g. world for dedicated servers). In there, you are able to configure the following options:

• config-version: Don't touch this
• integrated-server-render-distance: Only relevant for singleplayer worlds, this allows replacing the render distance
  of the integrated server as BetterView would otherwise have no effect (default: -1, disabled)
• global:
  • enabled: Whether to enable or disable the entire plugin/mod (default: true)
  • chunk-generation-limit: How many new chunks can be generated globally in one tick (default: 3)
  • chunk-send-limit: The maximum amount of chunks sent to a player in a tick (default: 3)
• dimensions:
  • <dimension> (e.g. minecraft:overworld):
    • enabled: Whether to enable or disable the plugin/mod for this dimension (default: true)
    • chunk-generation-limit: How many new chunks can be generated for this level in one tick (default: 2)
    • chunk-queue-size: How many chunks can be queued per player at once (default: 16)
    • view-distance: The maximum extended view distance for this dimension (default: 32)
    • cache-duration: The cache duration for how long extended chunks should be kept in memory (default: PT5M,
      5 minutes)
      • Make sure to adjust the cache duration based on what you use your server for;
        for e.g. static lobby servers, you can use a longer cache duration than for dynamic SMP servers.
        If the cache duration is too high, chunks will display outdated content after e.g. a rejoin.
    • anti-xray:
      • Be aware that this plugin implements a lightweight version of anti-xray, which
        doesn't check if a block is exposed to air or not. This means that every engine-mode other than HIDE
        will probably not look very good.
      • enabled: Whether anti-xray will be enabled or disabled in this world (default: false)
      • engine-mode: Engine modes of anti-xray, either HIDE, OBFUSCATE, or OBFUSCATE_LAYER
        (default: HIDE)
      • hidden-blocks: The list of blocks to hide/obfuscate (default: all ores and
        all base blocks of dimensions)
    • chunk-batches:
      • Chunk batches are used to ensure the client/internet of players doesn't get overwhelmed by
        too many chunks being sent at once. If enabled, BetterView sends a chunk batch and waits
        for the player to acknowledge they received the full chunk batch. Only then the next batch of chunks
        will be sent.
        A side effect of this will be that players with good connectivity but high latency
        will receive chunks at a much slower rate than possible.
        Note: chunk batches may be sent across multiple ticks.
      • enabled: Whether chunk batches are enabled or disabled in this dimension (default: true)
      • chunks-per-batch: The amount of chunks in a single batch (default: 12)
      • prepare-chunks-while-waiting: Whether BetterView should continue preparing chunks while waiting for acknowledgement of previous batch (default: true)
      • batch-timeout: The amount of time without a chunk being sent after which a batch expires (default: PT5S)
      • batch-wait-timeout: The timeout after which BetterView automatically marks the batch as done, even without a player response (default: PT30S)

Feel free to play around with the chunk generations and chunk sending limits for
an optimal experience on your server setup.

API Usage

Maven Repository: https://repo.minceraft.dev/releases/
Maven Artifact: dev.booky.betterview:betterview-api:2.2.0
Javadoc: https://repo.minceraft.dev/javadoc/releases/dev/booky/betterview/betterview-api/2.2.0

// get the BetterView API instance using Bukkit's ServicesManager
// this is the only difference between using the API on paper and fabric
BvManager bvManager = Bukkit.getServicesManager().load(BvManager.class);
if (bvManager == null) {
    throw new IllegalStateException("Failed to load BetterView API");
}
// invalidate chunk cache at 0 0 in the overworld
BvLevel overworld = bvManager.getLevel(Key.key(Key.MINECRAFT_NAMESPACE, "overworld"));
overworld.invalidateChunkCache(0, 0);
// refresh the chunk for all players in the overworld
for (BvPlayer player : overworld.getPlayers()) {
    // (switch to proper thread for thread-safety)
    player.getExecutor().execute(() -> {
        if (!player.isActive() || player.getLevel() != overworld) {
            // player isn't active or isn't in overworld - maybe they have switched
            // dimensions in the short time it took for this code to run?
            return;
        }
        // ensure BetterView actually "owns" the chunk at 0 0
        if (player.getChunkLifecycle(0, 0).isOwned()) {
            // finally, queue the chunk to be refreshed!
            player.refreshChunk(0, 0);
        }
    });
}

// get the BetterView API instance using fabric's object share
// this is the only difference between using the API on paper and fabric
BvManager bvManager = (BvManager) FabricLoader.getInstance().getObjectShare().get("betterview:api");
if (bvManager == null) {
    throw new IllegalStateException("Failed to load BetterView API");
}
// invalidate chunk cache at 0 0 in the overworld
BvLevel overworld = bvManager.getLevel(Key.key(Key.MINECRAFT_NAMESPACE, "overworld"));
overworld.invalidateChunkCache(0, 0);
// refresh the chunk for all players in the overworld
for (BvPlayer player : overworld.getPlayers()) {
    // (switch to proper thread for thread-safety)
    player.getExecutor().execute(() -> {
        if (!player.isActive() || player.getLevel() != overworld) {
            // player isn't active or isn't in overworld - maybe they have switched
            // dimensions in the short time it took for this code to run?
            return;
        }
        // ensure BetterView actually "owns" the chunk at 0 0
        if (player.getChunkLifecycle(0, 0).isOwned()) {
            // finally, queue the chunk to be refreshed!
            player.refreshChunk(0, 0);
        }
    });
}

Please note that the API is still work in progress. Please be sure to post suggestions, enhancements or any other ideas
on our Discord or in the issue tracker.

Building

1. Clone the project (git clone https://github.com/MinceraftMC/BetterView.git)
2. Go to the cloned directory (cd BetterView)
3. Build the jar files (./gradlew build on Linux/MacOS, just gradlew build on Windows)

The jar files can be found in the build → libs directory.

Contributing

If you want to contribute to BetterView, feel free to fork the repository and create a pull request. Please make sure to
follow the code style and conventions used in the project. If you have any questions or need help, feel free to ask in
our Discord.

You can test your changes by running ./gradlew :paper:runServer or
./gradlew :fabric:prodServer/./gradlew :fabric:prodClient respectively. This will start a local server with the
compiled plugin or mod automatically installed, ready for debugging in your IDE.