A lot of events

README.md

@@ -19,6 +19,27 @@ A plugin for [PumpkinMC](https://pumpkinmc.org/) that adds support for [PaperMC]
 4. **Initialize**: Restart PumpkinMC. This creates a new `patchbukkit/` directory in your server root.
 5. **Add Plugins**: Drop your .jar plugin files (Paper/Spigot/Bukkit) into the newly created `patchbukkit/patchbukkit-plugins/` folder and restart.
 
+## GraalVM (Ecosystem Compatibility)
+
+PatchBukkit is a **native Rust plugin** that embeds a JVM for Bukkit/Paper/Spigot plugins. For
+maximum ecosystem compatibility, the recommended GraalVM usage is **JVM mode**, not native-image.
+
+**Recommended approach**
+- Use GraalVM JDK as a drop-in replacement for a standard JDK.
+- Keep plugins running on the JVM (dynamic classloading, reflection, JNI/FFM).
+
+**Why not native-image yet**
+- Bukkit/Paper plugins rely heavily on dynamic classloading, reflection, and Java agents.
+- PatchBukkit embeds a JVM and uses JNI/FFM; native-image would require extensive config
+  and compatibility work across the plugin ecosystem.
+
+**Suggested JVM flags (starting point)**
+- `-XX:+UseG1GC`
+- `-XX:+UseStringDeduplication`
+- `-Dpolyglot.engine.WarnInterpreterOnly=false`
+
+These are general JVM tuning hints; validate against your workload.
+
 ## Development
 
 If you wish to contribute to PatchBukkit, follow the following steps:

java/patchbukkit/src/main/java/org/patchbukkit/PatchBukkitServer.java

@@ -1238,10 +1238,7 @@ public void setMotd(@NotNull String motd) {
 
     @Override
     public @NotNull WarningState getWarningState() {
-        // TODO Auto-generated method stub
-        throw new UnsupportedOperationException(
-            "Unimplemented method 'getWarningState'"
-        );
+        return WarningState.DEFAULT;
     }
 
     @Override

java/patchbukkit/src/main/java/org/patchbukkit/bridge/BridgeUtils.java

@@ -1,5 +1,8 @@
 package org.patchbukkit.bridge;
 
+import org.bukkit.Location;
+import org.patchbukkit.world.PatchBukkitWorld;
+
 import java.util.UUID;
 
 public class BridgeUtils {
@@ -10,4 +13,60 @@ public static UUID convertUuid(patchbukkit.common.UUID uuid) {
     public static patchbukkit.common.UUID convertUuid(UUID uuid) {
         return patchbukkit.common.UUID.newBuilder().setValue(uuid.toString()).build();
     }
+
+    public static Location convertLocation(patchbukkit.common.Location location) {
+        if (location == null || location.getWorld() == null || location.getWorld().getUuid() == null) {
+            return null;
+        }
+
+        var world = PatchBukkitWorld.getOrCreate(convertUuid(location.getWorld().getUuid()));
+        var position = location.getPosition();
+        if (position == null) {
+            return null;
+        }
+
+        return new Location(
+            world,
+            position.getX(),
+            position.getY(),
+            position.getZ(),
+            location.getYaw(),
+            location.getPitch()
+        );
+    }
+
+    public static patchbukkit.common.Location convertLocation(Location location) {
+        if (location == null || location.getWorld() == null) {
+            return null;
+        }
+
+        return patchbukkit.common.Location.newBuilder()
+            .setWorld(patchbukkit.common.World.newBuilder()
+                .setUuid(convertUuid(location.getWorld().getUID()))
+                .build())
+            .setPosition(patchbukkit.common.Vec3.newBuilder()
+                .setX(location.getX())
+                .setY(location.getY())
+                .setZ(location.getZ())
+                .build())
+            .setYaw(location.getYaw())
+            .setPitch(location.getPitch())
+            .build();
+    }
+
+    public static PatchBukkitWorld convertWorld(patchbukkit.common.World world) {
+        if (world == null || world.getUuid() == null) {
+            return null;
+        }
+        return PatchBukkitWorld.getOrCreate(convertUuid(world.getUuid()));
+    }
+
+    public static patchbukkit.common.World convertWorld(org.bukkit.World world) {
+        if (world == null) {
+            return null;
+        }
+        return patchbukkit.common.World.newBuilder()
+            .setUuid(convertUuid(world.getUID()))
+            .build();
+    }
 }

java/patchbukkit/src/main/java/org/patchbukkit/entity/PatchBukkitAbstractArrow.java

@@ -0,0 +1,158 @@
+package org.patchbukkit.entity;
+
+import java.util.UUID;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.block.Block;
+import org.bukkit.entity.AbstractArrow;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import java.util.Collections;
+import java.util.List;
+
+public class PatchBukkitAbstractArrow extends PatchBukkitProjectile implements AbstractArrow {
+    private PickupStatus pickupStatus = PickupStatus.ALLOWED;
+    private double damage = 2.0;
+    private int knockbackStrength = 0;
+    private int pierceLevel = 0;
+    private boolean critical = false;
+    private boolean inBlock = false;
+    private boolean shotFromCrossbow = false;
+    private boolean noPhysics = false;
+    private int lifetimeTicks = 0;
+    private ItemStack item = new ItemStack(Material.ARROW, 1);
+    private ItemStack weapon = null;
+    private Sound hitSound = Sound.ENTITY_ARROW_HIT;
+
+    public PatchBukkitAbstractArrow(UUID uuid, String name) {
+        super(uuid, name);
+        warnSnapshotLimitation(
+            "entity:abstract_arrow_snapshot",
+            "PatchBukkitAbstractArrow uses fallback local values; Pumpkin does not fully expose arrow/bow runtime state yet."
+        );
+    }
+
+    public Block getAttachedBlock() {
+        return null;
+    }
+
+    @Override
+    public @NotNull List<Block> getAttachedBlocks() {
+        return Collections.emptyList();
+    }
+
+    public double getDamage() {
+        return damage;
+    }
+
+    public void setDamage(double damage) {
+        this.damage = damage;
+    }
+
+    public int getKnockbackStrength() {
+        return knockbackStrength;
+    }
+
+    public void setKnockbackStrength(int knockbackStrength) {
+        this.knockbackStrength = knockbackStrength;
+    }
+
+    public PickupStatus getPickupStatus() {
+        return pickupStatus;
+    }
+
+    public void setPickupStatus(PickupStatus status) {
+        this.pickupStatus = status;
+    }
+
+    public int getPierceLevel() {
+        return pierceLevel;
+    }
+
+    public void setPierceLevel(int pierceLevel) {
+        this.pierceLevel = pierceLevel;
+    }
+
+    public boolean isCritical() {
+        return critical;
+    }
+
+    public void setCritical(boolean critical) {
+        this.critical = critical;
+    }
+
+    public boolean isInBlock() {
+        return inBlock;
+    }
+
+    public boolean isShotFromCrossbow() {
+        return shotFromCrossbow;
+    }
+
+    public void setShotFromCrossbow(boolean shotFromCrossbow) {
+        this.shotFromCrossbow = shotFromCrossbow;
+    }
+
+    public ItemStack getItem() {
+        return item;
+    }
+
+    public void setItem(ItemStack item) {
+        if (item != null) {
+            this.item = item;
+        }
+    }
+
+    @Override
+    public @NotNull ItemStack getItemStack() {
+        return getItem();
+    }
+
+    @Override
+    public void setItemStack(@NotNull ItemStack stack) {
+        setItem(stack);
+    }
+
+    public ItemStack getWeapon() {
+        return weapon != null ? weapon : item;
+    }
+
+    public void setWeapon(ItemStack weapon) {
+        this.weapon = weapon;
+    }
+
+    public Sound getHitSound() {
+        return hitSound;
+    }
+
+    public void setHitSound(Sound sound) {
+        if (sound != null) {
+            this.hitSound = sound;
+        }
+    }
+
+    public boolean hasNoPhysics() {
+        return noPhysics;
+    }
+
+    public void setNoPhysics(boolean noPhysics) {
+        this.noPhysics = noPhysics;
+    }
+
+    public int getLifetimeTicks() {
+        return lifetimeTicks;
+    }
+
+    public void setLifetimeTicks(int ticks) {
+        this.lifetimeTicks = ticks;
+    }
+
+    @Override
+    public void setShooter(org.bukkit.projectiles.ProjectileSource shooter, boolean update) {
+        setShooter(shooter);
+        if (update) {
+            setHasBeenShot(true);
+        }
+    }
+}