### Myau Configuration File Format

Source: https://context7.com/60124808866/openmyau/llms.txt

Presents the JSON format used by the Myau configuration system. It shows example configurations for different modules, including toggled states, keybinds, and specific module settings like 'Attack Range' and 'Speed'.

```json
{
  "KillAura": {
    "toggled": true,
    "key": 19,
    "hidden": false,
    "Attack Range": 4.2,
    "Min CPS": 10,
    "Max CPS": 14,
    "Rotations": 1,
    "Auto Block": true,
    "Players": true,
    "Mobs": false
  },
  "Fly": {
    "toggled": false,
    "key": 33,
    "hidden": false,
    "Speed": 2.5,
    "Mode": 0
  }
}
```

--------------------------------

### Manage Module Properties in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Demonstrates how to get, set, and parse property values for modules within the Myau framework. It also shows how to retrieve all properties for a module and how to create properties with visibility conditions.

```java
// Get property from module
Module module = Myau.moduleManager.getModule("KillAura");
Property<?> property = Myau.propertyManager.getProperty(module, "Attack Range");

// Set property value from string
property.parseString("4.5");

// Get all properties for a module
ArrayList<Property<?>> properties = Myau.propertyManager.properties.get(module.getClass());
for (Property<?> prop : properties) {
    System.out.println(prop.getName() + ": " + prop.formatValue());
}

// Properties with visibility conditions
BooleanProperty autoBlockEnabled = new BooleanProperty("Auto Block", false);
FloatProperty autoBlockRange = new FloatProperty("AB Range", 3.0f, 2.0f, 6.0f,
    () -> autoBlockEnabled.getValue()  // Only visible when auto block is enabled
);
```

--------------------------------

### Module Management in Open Myau (Java)

Source: https://context7.com/60124808866/openmyau/llms.txt

Demonstrates how to get, toggle, set state, bind keys, hide, and format module information using the Myau module manager. Assumes Myau and Module classes are available.

```java
// Get a module instance by name or class
Module killAura = Myau.moduleManager.getModule("KillAura");
Module killAura = Myau.moduleManager.getModule(KillAura.class);

// Toggle a module on/off
killAura.toggle();  // Returns true if toggle was successful
killAura.setEnabled(true);
killAura.setEnabled(false);

// Check module state
if (killAura.isEnabled()) {
    System.out.println("KillAura is active");
}

// Bind module to a key (using LWJGL key codes)
killAura.setKey(org.lwjgl.input.Keyboard.KEY_R);

// Hide module from HUD display
killAura.setHidden(true);

// Get formatted module name with status
String formatted = killAura.formatModule();  // "[R] KillAura (ON)"
```

--------------------------------

### Register and Handle Events in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Shows how to register and handle various game events using the Myau EventManager. Includes examples for Tick, Packet, Render (3D and 2D), Attack, and MoveInput events, with different priority levels.

```java
import myau.event.EventManager;
import myau.event.EventTarget;
import myau.event.types.EventType;
import myau.event.types.Priority;
import myau.events.*;

public class ExampleModule extends Module {
    public ExampleModule() {
        super("Example", false);
        // Module is automatically registered to EventManager in Myau.init()
    }

    // Tick event - fires every game tick (20 times per second)
    @EventTarget(Priority.MEDIUM)
    public void onTick(TickEvent event) {
        if (event.getType() == EventType.PRE) {
            // Pre-tick logic
        } else {
            // Post-tick logic
        }
    }

    // Packet interception with highest priority
    @EventTarget(Priority.HIGHEST)
    public void onPacket(PacketEvent event) {
        if (event.getType() == EventType.SEND) {
            Packet<?> packet = event.getPacket();
            if (packet instanceof C03PacketPlayer) {
                // Modify or cancel outgoing packets
                event.setCancelled(true);
            }
        } else if (event.getType() == EventType.RECEIVE) {
            // Handle incoming server packets
        }
    }

    // 3D world rendering
    @EventTarget
    public void onRender3D(Render3DEvent event) {
        float partialTicks = event.getPartialTicks();
        // Render ESP boxes, lines, etc.
    }

    // 2D screen rendering (overlays)
    @EventTarget
    public void onRender2D(Render2DEvent event) {
        // Draw HUD elements
    }

    // Attack event - fires when player attacks entity
    @EventTarget
    public void onAttack(AttackEvent event) {
        EntityLivingBase target = event.getTarget();
        // Process attack logic
    }

    // Movement input modification
    @EventTarget
    public void onMoveInput(MoveInputEvent event) {
        // Modify player movement input
        event.setForward(1.0f);
        event.setStrafe(0.5f);
    }
}

// Manual event dispatch
CustomEvent event = new CustomEvent();
EventManager.call(event);
```

--------------------------------

### Player Utilities in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Provides examples for using the PlayerUtil class to get player speed, set player motion, check if the player is moving or on the ground, and retrieve the block beneath the player. These utilities are useful for movement-related game mechanics.

```java
import myau.util.PlayerUtil;
import net.minecraft.client.Minecraft;

Minecraft mc = Minecraft.getMinecraft();

// Get player's current speed
double speed = PlayerUtil.getSpeed();

// Set player motion
PlayerUtil.setSpeed(0.4);  // Set horizontal speed

// Check if player is moving
if (PlayerUtil.isMoving()) {
    System.out.println("Player is moving");
}

// Check if player is on ground (better than mc.thePlayer.onGround)
if (PlayerUtil.isOnGround()) {
    System.out.println("Grounded");
}

// Get block player is standing on
Block block = PlayerUtil.getBlockUnder();
```

--------------------------------

### Direct Packet Sending in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Illustrates sending packets directly using PacketUtil. It covers sending packets with and without event dispatch, and includes an example of a silent slot switch. Dependencies include myau.util.PacketUtil and net.minecraft.network.play.client.*.

```java
import myau.util.PacketUtil;
import net.minecraft.network.play.client.*;

// Send packet with event dispatch (can be intercepted)
PacketUtil.sendPacket(new C03PacketPlayer.C04PacketPlayerPosition(x, y, z, onGround));

// Send packet without triggering PacketEvent
PacketUtil.sendPacketNoEvent(new C08PacketPlayerBlockPlacement(itemStack));

// Example: Silent slot switch
int currentSlot = mc.thePlayer.inventory.currentItem;
PacketUtil.sendPacketNoEvent(new C09PacketHeldItemChange(newSlot));
// Perform action
PacketUtil.sendPacketNoEvent(new C09PacketHeldItemChange(currentSlot));

```

--------------------------------

### Timer Utilities in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Provides examples for using TimerUtil to manage time intervals. It covers resetting the timer, checking if a specific duration has passed, and getting the elapsed time. Dependency: myau.util.TimerUtil.

```java
import myau.util.TimerUtil;

TimerUtil timer = new TimerUtil();

// Reset timer
timer.reset();

// Check if time has passed
if (timer.hasReached(1000)) {  // 1000 milliseconds
    System.out.println("1 second elapsed");
    timer.reset();
}

// Get elapsed time
long elapsed = timer.getElapsedTime();

// Check without resetting
if (timer.hasReached(500) && !timer.hasReached(1000)) {
    System.out.println("Between 500ms and 1000ms");
}

```

--------------------------------

### Friend List Operations in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Provides examples for managing the friend list, including adding, removing, checking, and clearing friends. Friends are persisted to a file. Dependency: myau.Myau.

```java
import myau.Myau;

// Add friend
Myau.friendManager.add("PlayerName");

// Remove friend
Myau.friendManager.remove("PlayerName");

// Check if player is friend
if (Myau.friendManager.isFriend("PlayerName")) {
    System.out.println("Friend detected");
}

// Clear all friends
Myau.friendManager.clear();

// Friends are persisted to ./config/Myau/friends.txt
// Format: one name per line
// Auto-loaded on startup

```

--------------------------------

### KillAura Module Configuration in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Shows a comprehensive example of configuring the KillAura module for automated combat. It covers settings for attack range, CPS, rotations, auto-blocking, and target selection, demonstrating how to enable and customize the module's behavior.

```java
// KillAura module with full combat automation
Module killAura = Myau.moduleManager.getModule(KillAura.class);
KillAura ka = (KillAura) killAura;

// Configure attack properties
ka.attackRange.setValue(4.2f);  // Attack range in blocks
ka.minCPS.setValue(10);         // Minimum clicks per second
ka.maxCPS.setValue(14);         // Maximum clicks per second
ka.fov.setValue(180);           // Field of view (degrees)

// Configure rotation behavior
ka.rotations.setValue(1);       // 0=None, 1=Normal, 2=Smooth
ka.smoothing.setValue(70);      // Rotation smoothing percentage
ka.moveFix.setValue(1);         // 0=None, 1=Silent, 2=Strict

// Configure auto-block
ka.autoBlock.setValue(1);       // 0=None, 1=Vanilla, 2=Fake, 3=AAC
ka.autoBlockRequirePress.setValue(true);
ka.autoBlockRange.setValue(3.0f);

// Configure targeting
ka.players.setValue(true);      // Target players
ka.mobs.setValue(false);        // Target hostile mobs
ka.animals.setValue(false);     // Target passive mobs
ka.teams.setValue(true);        // Respect team colors
ka.botCheck.setValue(true);     // Ignore bots

// Advanced settings
ka.throughWalls.setValue(false); // Attack through walls
ka.weaponsOnly.setValue(true);   // Only attack with weapons
ka.allowMining.setValue(false);  // Don't attack while mining

// Enable module
killAura.setEnabled(true);

// Module automatically handles:
// - Target selection based on distance, angle, and settings
// - Smooth rotation to targets
// - Attack timing with randomized CPS
// - Auto-blocking with sword
// - Packet management for anti-cheat bypass
```

--------------------------------

### Block Utilities in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Illustrates the usage of the BlockUtil class for interacting with blocks in the game world. It covers getting blocks at specific positions, checking block properties like air or solid, and retrieving adjacent blocks (above, below).

```java
import myau.util.BlockUtil;
import net.minecraft.util.BlockPos;

BlockPos pos = new BlockPos(x, y, z);

// Get block at position
Block block = BlockUtil.getBlock(pos);

// Check block properties
if (BlockUtil.isAir(pos)) {
    System.out.println("Air block");
}

if (BlockUtil.isSolid(pos)) {
    System.out.println("Solid block");
}

// Get block relative to position
Block below = BlockUtil.getBlockBelow(pos);
Block above = BlockUtil.getBlockAbove(pos);

// Check if block is replaceable (can place block here)
if (BlockUtil.isReplaceable(pos)) {
    // Safe to place block
}
```

--------------------------------

### Java Rotation Utilities for Myau

Source: https://context7.com/60124808866/openmyau/llms.txt

Presents utility functions for calculating and manipulating rotations within the Myau client. Includes methods for getting rotations to an entity, calculating angle differences between two yaw/pitch values, and obtaining randomized rotations for a more legitimate appearance. Depends on `myau.util.RotationUtil` and `net.minecraft.entity.EntityLivingBase`.

```java
import myau.util.RotationUtil;
import net.minecraft.entity.EntityLivingBase;

EntityLivingBase target = ...; // Assume target is obtained elsewhere

// Calculate rotations to entity
float[] rotations = RotationUtil.getRotations(target);
float yaw = rotations[0];
float pitch = rotations[1];

// Calculate angle difference
// float angleDiff = RotationUtil.getAngleDifference(yaw1, yaw2);

// Get rotation with randomization for legit look
float[] legitRotations = RotationUtil.getRotationsWithRandomization(
    target,
    0.5f  // randomization amount
);
```

--------------------------------

### Load and Save Configuration in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Explains how to manage application configurations using the Myau Config system. This includes creating, loading from a file, and saving configuration settings. Default configurations are auto-loaded and saved.

```java
import myau.config.Config;

// Create and load a configuration
Config config = new Config("pvp_settings", true);
if (config.file.exists()) {
    config.load();  // Loads from ./config/Myau/pvp_settings.json
}

// Save current module states
config.save();

// Default config is auto-loaded on startup
// Auto-saved on shutdown via shutdown hook in Myau.init()
```

--------------------------------

### Command System Overview

Source: https://context7.com/60124808866/openmyau/llms.txt

Explains how commands are executed in the Myau client, typically prefixed with '.' in chat. It outlines the command handling flow from player input to command execution and response. This section does not contain executable code but describes the system's logic.

```plaintext
// Commands are executed by typing in chat with '.' prefix
// .toggle killaura
// .bind killaura R
// .config save mypvpconfig

// Command handling flow:
// 1. Player types ".toggle killaura" in chat
// 2. CommandManager intercepts C01PacketChatMessage at HIGHEST priority
// 3. Packet is cancelled to prevent server message
// 4. Command is parsed and routed to ToggleCommand
// 5. Response sent via ChatUtil.sendFormatted()
```

--------------------------------

### Java Custom Command Creation for Myau

Source: https://context7.com/60124808866/openmyau/llms.txt

Provides a template for creating custom commands in the Myau client using Java. It shows how to extend the base `Command` class, define aliases, and implement the `runCommand` method to handle arguments. Commands are registered within `Myau.init()`.

```java
package myau.command.commands;

import myau.Myau;
import myau.command.Command;
import myau.util.ChatUtil;
import java.util.ArrayList;
import java.util.Arrays;

public class CustomCommand extends Command {
    public CustomCommand() {
        super(new ArrayList<>(Arrays.asList("custom", "c")));  // Command aliases
    }

    @Override
    public void runCommand(ArrayList<String> args) {
        // args[0] = command name used
        // args[1+] = command arguments

        if (args.size() < 2) {
            ChatUtil.sendFormatted(
                String.format("%sUsage: .custom <argument>", Myau.clientName)
            );
            return;
        }

        String arg = args.get(1);
        // Process command logic
        ChatUtil.sendFormatted(
            String.format("%sProcessed: %s", Myau.clientName, arg)
        );
    }
}

// Register command in Myau.init()
// commandManager.commands.add(new CustomCommand());
```

--------------------------------

### Java Config Operations for Myau

Source: https://context7.com/60124808866/openmyau/llms.txt

Demonstrates how to list, open, and load configuration files (JSON) for modules within the Myau project. It also shows how to automatically load properties using the PropertyManager. Dependencies include standard Java IO and Myau's module and property management classes.

```java
import java.io.File;
import org.json.JSONObject;
import myau.module.Module;
import myau.management.ModuleManager;
import myau.management.PropertyManager;
import myau.property.Property;
import java.util.ArrayList;

// List all configs
File configDir = new File("./config/Myau/");
File[] configs = configDir.listFiles((dir, name) -> name.endsWith(".json"));

// Open config folder
// Requires Desktop API access
// Desktop.getDesktop().open(configDir);

// Load specific module config from JSON
Module module = Myau.moduleManager.getModule("KillAura");
JsonObject moduleJson = jsonObject.getAsJsonObject("KillAura");
module.setEnabled(moduleJson.get("toggled").getAsBoolean());
module.setKey(moduleJson.get("key").getAsInt());

// Properties are automatically loaded via PropertyManager
ArrayList<Property<?>> properties = Myau.propertyManager.properties.get(module.getClass());
for (Property<?> property : properties) {
    property.read(moduleJson);  // Reads from JSON and sets value
}
```

--------------------------------

### Chat Utilities in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Demonstrates the use of ChatUtil for sending formatted, raw, and player messages. It also shows how to prefix messages with the client name. Dependencies: myau.util.ChatUtil and myau.Myau.

```java
import myau.util.ChatUtil;
import myau.Myau;

// Send formatted message (with color codes)
ChatUtil.sendFormatted("&aSuccess! &7Module enabled");

// Send raw message (no formatting)
ChatUtil.sendRaw("Plain text message");

// Send message as player (to server)
ChatUtil.sendMessage("/lobby");

// Client name prefix
String message = String.format("%sModule toggled", Myau.clientName);
// Result: "[Myau] Module toggled" (with colors)

```

--------------------------------

### Creating a Custom Module in Open Myau (Java)

Source: https://context7.com/60124808866/openmyau/llms.txt

Provides a template for creating a custom module, including defining properties, handling module enable/disable events, and implementing tick event logic. Requires Myau event and property system classes.

```java
package myau.module.modules;

import myau.event.EventTarget;
import myau.events.TickEvent;
import myau.module.Module;
import myau.property.properties.BooleanProperty;
import myau.property.properties.IntProperty;

public class CustomModule extends Module {
    // Define module properties using reflection-scanned fields
    public final BooleanProperty enableFeature = new BooleanProperty("Enable Feature", true);
    public final IntProperty tickDelay = new IntProperty("Tick Delay", 10, 1, 100);

    public CustomModule() {
        super("CustomModule", false);  // name, defaultEnabled
    }

    @Override
    public void onEnabled() {
        // Called when module is enabled
        System.out.println("CustomModule enabled!");
    }

    @Override
    public void onDisabled() {
        // Called when module is disabled
        System.out.println("CustomModule disabled!");
    }

    @EventTarget
    public void onTick(TickEvent event) {
        // Only executes when module is enabled
        if (enableFeature.getValue()) {
            // Module logic here
        }
    }

    @Override
    public String[] getSuffix() {
        // Display module configuration in HUD
        return new String[]{"Delay" + tickDelay.getValue()};
    }
}

// Register module in Myau.init()
moduleManager.modules.put(CustomModule.class, new CustomModule());
```

--------------------------------

### Render Utilities in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Demonstrates how to use the RenderUtil class to draw 3D boxes around entities, lines between points, check entity visibility, and render nametags in the game world. These functions are essential for visual feedback and debugging.

```java
import myau.util.RenderUtil;
import net.minecraft.entity.Entity;
import java.awt.Color;

// Draw 3D box around entity
Entity entity = ...;
Color color = new Color(255, 0, 0, 100);
RenderUtil.drawEntityBox(entity, color, true, partialTicks);

// Draw line from player to entity
RenderUtil.drawLine(
    startX, startY, startZ,
    endX, endY, endZ,
    color, lineWidth
);

// Check if entity is in view frustum
if (RenderUtil.isInViewFrustrum(entity)) {
    // Entity is visible on screen
}

// Draw text in world
RenderUtil.drawNameTag(
    "Name",
    x, y, z,
    partialTicks
);
```

--------------------------------

### Myau Available Commands

Source: https://context7.com/60124808866/openmyau/llms.txt

Lists the various commands available in the Myau client, categorized by function including module toggling, key binding, configuration management, property modification, friend/enemy lists, module listing, HUD display, and vertical teleportation (vclip).

```plaintext
// Toggle module on/off
// .toggle <module> [true|false|on|off]
// .toggle KillAura
// .toggle Sprint true

// Bind module to key
// .bind <module> <key>
// .bind list  (shows all bindings)
// .bind KillAura R
// .bind Fly NONE  (unbind)

// Config management
// .config save <name>
// .config load <name>
// .config list
// .config folder

// Module property modification
// .<module> <property> <value>
// .killaura attackrange 4.5
// .killaura autoblock true
// .speed mode bhop

// Friend/enemy list management
// .friend add Notch
// .friend remove Steve
// .friend list
// .target add Herobrine

// List all modules
// .list
// .modules

// Hide/show modules from HUD
// .hide KillAura
// .show KillAura

// Vertical teleport
// .vclip <blocks>
// .vclip 5    (teleport 5 blocks up)
// .vclip -3   (teleport 3 blocks down)
```

--------------------------------

### Blink Module Implementation in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Demonstrates how to enable, disable, and manually buffer packets using the Blink Module. Packets are buffered in a ConcurrentLinkedDeque and can be automatically handled or manually offered. Dependencies include myau.Myau and myau.enums.BlinkModules.

```java
import myau.Myau;
import myau.enums.BlinkModules;

// Enable blink (packet buffering)
Myau.blinkManager.setBlinkState(true, BlinkModules.BLINK_MODULE);

// Packets are automatically buffered in ConcurrentLinkedDeque
// Check if blink is active
if (Myau.blinkManager.isBlinking()) {
    int packetCount = Myau.blinkManager.getMovementPacketCount();
    System.out.println("Buffered packets: " + packetCount);
}

// Disable blink (releases all buffered packets)
Myau.blinkManager.setBlinkState(false, BlinkModules.BLINK_MODULE);

// Manual packet buffering
@EventTarget(Priority.HIGH)
public void onPacket(PacketEvent event) {
    if (event.getType() == EventType.SEND) {
        if (Myau.blinkManager.offerPacket(event.getPacket())) {
            event.setCancelled(true);  // Packet buffered, cancel send
        }
    }
}
```

--------------------------------

### Property System Usage in Open Myau (Java)

Source: https://context7.com/60124808866/openmyau/llms.txt

Illustrates the usage of various property types (Boolean, Int, Float, Mode, Percent, Color, Text) for configuring modules within the Open Myau client. Requires specific property classes from the Myau project.

```java
// Boolean property - toggle values
BooleanProperty autoBlock = new BooleanProperty("Auto Block", true);
autoBlock.setValue(false);
boolean value = autoBlock.getValue();

// Integer property with range validation
IntProperty minCPS = new IntProperty("Min CPS", 10, 1, 20);  // name, default, min, max
minCPS.setValue(15);
int cps = minCPS.getValue();

// Float property with decimal precision
FloatProperty attackRange = new FloatProperty("Attack Range", 3.5f, 3.0f, 6.0f);
attackRange.setValue(4.2f);
float range = attackRange.getValue();

// Mode property - cycle through options
ModeProperty mode = new ModeProperty("Mode", new String[]{"Single", "Multi", "Switch"}, 0);
mode.cycle();  // Switch to next mode
String currentMode = mode.getModes()[mode.getValue()];

// Percent property - 0-100 range
PercentProperty smoothing = new PercentProperty("Smoothing", 50);
smoothing.setValue(75);
int percent = smoothing.getValue();

// Color property - RGB values
ColorProperty color = new ColorProperty("Color", new Color(255, 0, 0).getRGB());
color.setValue(new Color(0, 255, 0).getRGB());

// Text property - string values
TextProperty name = new TextProperty("Name", "DefaultName");
name.setValue("NewName");
```

--------------------------------

### Target/Enemy List Operations in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Demonstrates operations for managing the target or enemy list, including adding, removing, and checking targets. Targets are persisted to a file and can be loaded/saved. Dependency: myau.Myau.

```java
import myau.Myau;

// Add target
Myau.targetManager.add("EnemyName");

// Remove target
Myau.targetManager.remove("EnemyName");

// Check if player is target
if (Myau.targetManager.isTarget("EnemyName")) {
    System.out.println("Enemy detected");
}

// Targets are persisted to ./config/Myau/enemies.txt
Myau.targetManager.save();
Myau.targetManager.load();

```

--------------------------------

### Understand Event Priority Levels in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Illustrates the different priority levels available for event handlers in the Myau Event System. Priorities range from HIGHEST (called first) to LOWEST (called last), allowing fine-grained control over event processing order.

```java
// Priority values (from highest to lowest)
@EventTarget(Priority.HIGHEST)  // 0 - Called first, useful for early cancellation
public void handler1(TickEvent event) { }

@EventTarget(Priority.HIGH)     // 1 - Early processing
public void handler2(TickEvent event) { }

@EventTarget(Priority.MEDIUM)   // 2 - Default priority (can be omitted)
public void handler3(TickEvent event) { }

@EventTarget(Priority.LOW)      // 3 - Late processing
public void handler4(TickEvent event) { }

@EventTarget(Priority.LOWEST)   // 4 - Called last, useful for cleanup
public void handler5(TickEvent event) { }
```

--------------------------------

### Packet Delay System in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Shows how to enable and disable the packet delay system, and how to check if a packet should be delayed. Incoming packets are buffered and can be intercepted. Dependencies include myau.Myau and myau.enums.DelayModules.

```java
import myau.Myau;
import myau.enums.DelayModules;

// Enable packet delay
Myau.delayManager.setDelayState(true, DelayModules.SOME_MODULE);

// Incoming packets are automatically buffered
@EventTarget(Priority.HIGH)
public void onPacket(PacketEvent event) {
    if (event.getType() == EventType.RECEIVE) {
        if (Myau.delayManager.shouldDelay(event.getPacket())) {
            event.setCancelled(true);  // Packet delayed
        }
    }
}

// Disable delay (processes all buffered packets)
Myau.delayManager.setDelayState(false, DelayModules.SOME_MODULE);

// Keep-alive and respawn packets are never delayed

```

--------------------------------

### Team Detection Utilities in Java

Source: https://context7.com/60124808866/openmyau/llms.txt

Shows how to use TeamUtil to check entity relationships, including whether they are on the same team, a friend, a target, or a bot. Dependencies: myau.util.TeamUtil and net.minecraft.entity.EntityLivingBase.

```java
import myau.util.TeamUtil;
import net.minecraft.entity.EntityLivingBase;

EntityLivingBase entity = ...;

// Check if entity is on same team (scoreboard-based)
if (TeamUtil.isOnSameTeam(entity)) {
    // Don't attack teammates
}

// Check if entity is a friend
if (TeamUtil.isFriend(entity)) {
    // Friend protection
}

// Check if entity is target/enemy
if (TeamUtil.isTarget(entity)) {
    // Priority targeting
}

// Check if entity is a bot (heuristic detection)
if (TeamUtil.isBot(entity)) {
    // Ignore bots
}

```

--------------------------------

### Java Smooth Rotation Control for Myau

Source: https://context7.com/60124808866/openmyau/llms.txt

Details how to control player rotations in Myau using a priority system. It allows setting target yaw and pitch with a specified priority, and optionally forcing the rotation. Rotations are smoothly interpolated and automatically reset when priorities are removed. Requires Myau's rotation management classes.

```java
import myau.Myau;
import myau.management.RotationState;

// Set target rotation with priority system
// Higher priority values override lower priorities
float targetYaw = 45.0f;
float targetPitch = 15.0f;
int priority = 100;  // Higher = more important
boolean force = false;

Myau.rotationManager.setRotation(targetYaw, targetPitch, priority, force);

// Check if rotations are active
if (Myau.rotationManager.isRotated()) {
    RotationState state = Myau.rotationManager.getState();
    float currentYaw = state.getYaw();
    float currentPitch = state.getPitch();
}

// Rotations are smoothly interpolated across ticks
// Automatic reset when priority modules disable
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.