PlayerCulling

PlayerCulling

Description

PlayerCulling is an anti-cheat plugin and mod for Minecraft servers. It prevents players from seeing other players through walls using cheats. It utilizes a unique allocationless asynchronous voxel stepping-faced-ray-casting algorithm.

Features

• Asynchronous, multithreaded culling
• Allocationsless voxel raycasting algorithm
• Advanced scheduler system
• Support for nametag visibility, potions, glowing and spectating
• 2x2x2-scale voxel occlusion for non-full blocks
• Efficient storage of occlusion block data
• Nearly instant block updates
• Easily enable/disable culling globally/per-player

Supported Software

Dependencies on Fabric:

• Fabric API

Usage

PlayerCulling can be installed like any other bukkit plugin. Place the jar file in your plugins directory. On Fabric as well, just place the jar file and the dependencies listed above in your mods directory and restart your server.

Configuration

After the first start, PlayerCulling will automatically create a configuration file. On paper under plugins/PlayerCulling/config.yml or on Fabric config/playerculling.yml. In there, you are able to configure the following options:

• config-version: Don't touch this
• scheduler:
  • max-threads: The maximum amount of threads allowed to use (default: cpu threads / 3)
  • cleanup-interval: The interval to check for cleanup of threads in seconds (default: 30)
  • container-ttl: The time-to-live of unused threads (default: 30)
  • max-cull-time: The maximum time a thread is allowed to have in milliseconds (default: 45)
  • max-transfer-factor: If the load percentage of a thread is below this factor, it is allowed to accept more tasks from other overloaded threads (default: 0.7)
  • max-merge-factor: If the combined load percentage of two threads is below this factor, the two threads are allowed to merge together (default: 0.5)
• updater:
  • enabled: Enables/disables the update checker (default: true)
  • notify-admins: Whether to notify admins about new PlayerCulling releases (default: true)
  • interval-hours: The update check interval in hours (default: 24)

Note: If you're not sure what a configuration option does, it's best to leave it at its default value.

Permissions

See the table below for command permissions.

Commands

Note: [...] is an optional argument, <...> is a required argument

PlayerCulling uses brigadier for commands which means command blocks and datapacks are also able to use these commands. Additionally, this also means /execute can recognize these commands and you are able to change the executor/location of the executed command. For example:

• /execute as Notch run playerculling hidden will show you the hidden players of the player Notch, if online
• /execute as @a run playerculling hidden will show you the hidden players of everyone online

API setup

PlayerCulling has to be added as a dependency to the plugin.yml regardless of the build system used. On Fabric add playerculling to the fabric.mod.json file.

<repositories>
    <repository>
        <id>tjcserver</id>
        <url>https://repo.minceraft.dev/releases/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>de.pianoman911</groupId>
        <artifactId>playerculling-api</artifactId>
        <version>2.0.2-SNAPSHOT</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

repositories {
    maven {
        url = 'https://repo.minceraft.dev/releases/'
        name = 'tjcserver'
    }
}

dependencies {
    compileOnly 'de.pianoman911:playerculling-api:2.0.2-SNAPSHOT'
}

repositories {
    maven("https://repo.minceraft.dev/releases/") {
        name = "tjcserver"
    }
}

dependencies {
    compileOnly("de.pianoman911:playerculling-api:2.0.2-SNAPSHOT")
}

API usage

Basic paper plugin example:

public class ExamplePlugin extends JavaPlugin {

    @Override
    public void onEnable() {
        // this loads the player culling api from bukkit's services manager
        PlayerCullingApi api = Bukkit.getServicesManager().load(PlayerCullingApi.class);

        // example: disable culling for the player "Notch", if online
        Player player = Bukkit.getPlayer("Notch");
        if (player != null) {
            api.setCullingEnabled(player.getUniqueId(), false);
        }
    }
}

Basic fabric mod example:

public class ExampleMod implements ModInitializer {

    @Override
    public void onInitialize() {
        FabricLoader.getInstance().getObjectShare().whenAvailable("playerculling:api", (__, obj) -> {
            if (!(obj instanceof PlayerCullingApi api)) {
                return;
            }
            // Toggle global culling
            api.setCullingEnabled(false);
        });
    }
}

Building

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

The PlayerCulling jars can be found in the build → libs directory.

Contributing

If you want to contribute to PlayerCulling, 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 plugin-paper:runServer or ./gradlew platform-fabric:runServer. This will start a local development server with the compiled plugin or mod automatically installed. This can be combined with the debugger of your IDE.
Please note that the update checker will be automatically disabled when running in a development environment.