experimental mojang mappings

build.xml

@@ -73,7 +73,7 @@
                     <include name="oshi-core-5.8.2.jar"/>
                     <include name="paper-api-1.18.1-R0.1-SNAPSHOT.jar"/>
                     <include name="paper-mojangapi-1.18.1-R0.1-SNAPSHOT.jar"/>
-                    <include name="paper-server-1.18.1-R0.1-SNAPSHOT-reobf.jar"/>
+                    <include name="paper-server-1.18.1-R0.1-SNAPSHOT-reobf"/>
                     <include name="plexus-interpolation-1.25.jar"/>
                     <include name="plexus-utils-3.2.1.jar"/>
                     <include name="protobuf-java-3.11.4.jar"/>

src/me/hammerle/kp/NMS.java

@@ -23,67 +23,75 @@ import org.bukkit.craftbukkit.v1_18_R1.inventory.CraftItemStack;
 import org.bukkit.entity.*;
 import org.bukkit.inventory.ItemStack;
 import me.hammerle.kp.snuviscript.ScriptEvents;
-import net.minecraft.core.BlockPosition;
-import net.minecraft.core.IRegistry;
-import net.minecraft.nbt.MojangsonParser;
-import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Registry;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.TagParser;
 import net.minecraft.network.protocol.Packet;
-import net.minecraft.network.protocol.game.*;
-import net.minecraft.server.level.EntityPlayer;
-import net.minecraft.server.level.WorldServer;
-import net.minecraft.server.network.PlayerConnection;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.network.ServerGamePacketListenerImpl;
 import net.minecraft.world.damagesource.DamageSource;
-import net.minecraft.world.entity.EntityCreature;
-import net.minecraft.world.entity.EntityLiving;
-import net.minecraft.world.entity.EntityTypes;
-import net.minecraft.world.entity.EnumCreatureType;
-import net.minecraft.world.entity.item.EntityItem;
-import net.minecraft.world.entity.monster.EntityMonster;
-import net.minecraft.world.entity.projectile.EntityArrow;
-import net.minecraft.world.entity.projectile.EntityFireballFireball;
-import net.minecraft.world.entity.projectile.EntityFireworks;
-import net.minecraft.world.entity.projectile.EntityWitherSkull;
-import net.minecraft.world.level.block.entity.TileEntity;
-import net.minecraft.world.level.block.state.IBlockData;
-import net.minecraft.world.entity.ai.attributes.AttributeDefaults;
-import net.minecraft.world.entity.ai.attributes.AttributeProvider;
-import net.minecraft.world.entity.ai.attributes.GenericAttributes;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.MobCategory;
+import net.minecraft.world.entity.PathfinderMob;
+import net.minecraft.world.entity.ai.attributes.AttributeSupplier;
+import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.entity.ai.attributes.DefaultAttributes;
+import net.minecraft.world.entity.ai.goal.FloatGoal;
+import net.minecraft.world.entity.ai.goal.LookAtPlayerGoal;
+import net.minecraft.world.entity.ai.goal.RandomLookAroundGoal;
+import net.minecraft.world.entity.item.ItemEntity;
+import net.minecraft.world.entity.monster.Monster;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.phys.Vec3;
+import net.minecraft.network.protocol.game.ClientboundAddMobPacket;
+import net.minecraft.network.protocol.game.ClientboundPlayerInfoPacket;
+import net.minecraft.network.protocol.game.ClientboundAddPlayerPacket;
+import net.minecraft.network.protocol.game.ClientboundSetEntityDataPacket;
+import net.minecraft.network.protocol.game.ClientboundRemoveEntitiesPacket;
 
 public class NMS {
     private final static HashMap<String, DamageSource> DAMAGE_SOURCES = new HashMap<>();
 
-    private static EntityTypes<RawHuman.WrapperHuman> HUMAN_TYPE;
+    private static EntityType<RawHuman.WrapperHuman> HUMAN_TYPE;
 
     @SuppressWarnings("unchecked")
     public static void init() {
         try {
-            Method m = EntityTypes.class.getDeclaredMethod("a", String.class,
-                    EntityTypes.Builder.class);
+            Method m = EntityType.class.getDeclaredMethod("a", String.class,
+                    EntityType.Builder.class);
             m.setAccessible(true);
+
             HUMAN_TYPE =
-                    (EntityTypes<RawHuman.WrapperHuman>) m.invoke(null, "human", EntityTypes.Builder
-                            .a(RawHuman.WrapperHuman::new, EnumCreatureType.a).a(0.6f, 1.95f));
+                    (EntityType<RawHuman.WrapperHuman>) m.invoke(null, "human", EntityType.Builder
+                            .of(RawHuman.WrapperHuman::new, MobCategory.CREATURE)
+                            .sized(0.6f, 1.95f));
 
             final Field unsafeField = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
             unsafeField.setAccessible(true);
             final sun.misc.Unsafe unsafe = (sun.misc.Unsafe) unsafeField.get(null);
 
-            Field attributesMapField = AttributeDefaults.class.getDeclaredField("b");
+            Field attributesMapField = DefaultAttributes.class.getDeclaredField("b");
             attributesMapField.setAccessible(true);
 
             Object base = unsafe.staticFieldBase(attributesMapField);
             long offset = unsafe.staticFieldOffset(attributesMapField);
 
-            Map<EntityTypes<? extends EntityLiving>, AttributeProvider> attributesMap =
-                    (Map<EntityTypes<? extends EntityLiving>, AttributeProvider>) attributesMapField
+            Map<EntityType<? extends net.minecraft.world.entity.LivingEntity>, AttributeSupplier> attributesMap =
+                    (Map<EntityType<? extends net.minecraft.world.entity.LivingEntity>, AttributeSupplier>) attributesMapField
                             .get(null);
             attributesMap = new HashMap<>(attributesMap);
             attributesMap.put(HUMAN_TYPE,
-                    EntityMonster.fD().a(GenericAttributes.a, 20.0).a(GenericAttributes.f, 1)
-                            .a(GenericAttributes.d, 0.1).a(GenericAttributes.h).a());
+                    Monster.createMonsterAttributes().add(Attributes.MAX_HEALTH, 20.0)
+                            .add(Attributes.ATTACK_DAMAGE, 1)
+                            .add(Attributes.MOVEMENT_SPEED, 0.1).add(Attributes.ATTACK_SPEED)
+                            .build());
+
             unsafe.putObject(base, offset, attributesMap);
 
-            AttributeDefaults.a();
+            DefaultAttributes.validate();
         } catch(Exception ex) {
             ex.printStackTrace();
             KajetansPlugin.warn(ex.getMessage());
@@ -104,28 +112,59 @@ public class NMS {
         public void setName(String name);
     }
 
+    private static void setId(net.minecraft.world.entity.Entity e, int id) {
+        e.setId(id);
+    }
+
+    private static int getId(net.minecraft.world.entity.Entity e) {
+        return e.getId();
+    }
+
+    private static UUID getUUID(net.minecraft.world.entity.Entity e) {
+        return e.getUUID();
+    }
+
+    private static void moveTo(net.minecraft.world.entity.Entity e, double x, double y, double z,
+            float yaw, float pitch) {
+        e.moveTo(x, y, z, yaw, pitch);
+    }
+
+    private static Level getWorld(net.minecraft.world.entity.Entity e) {
+        return e.getLevel();
+    }
+
+    private static GameProfile getGameProfile(net.minecraft.world.entity.player.Player e) {
+        return e.getGameProfile();
+    }
+
     private static class RawHuman extends CraftCreature implements Human {
-        private static class WrapperHuman extends EntityCreature {
-            private EntityPlayer player;
+        private static class WrapperHuman extends PathfinderMob {
+            private ServerPlayer player;
 
-            public WrapperHuman(EntityTypes<? extends WrapperHuman> type,
-                    net.minecraft.world.level.World world) {
+            public WrapperHuman(EntityType<? extends WrapperHuman> type,
+                    Level world) {
                 super(type, world);
                 setPlayer("Default", world);
             }
 
-            private void setPlayer(String name, net.minecraft.world.level.World world) {
-                player = new EntityPlayer(getCraftServer().getServer(), (WorldServer) world,
-                        new GameProfile(cm(), name));
-                player.e(getBukkitEntity().getEntityId());
+            private void setPlayer(String name, Level world) {
+                player = new ServerPlayer(getCraftServer().getServer(), (ServerLevel) world,
+                        new GameProfile(NMS.getUUID(this), name));
+                NMS.setId(player, NMS.getId(this));
             }
 
             @Override
-            public boolean a(DamageSource ds, float amount) {
+            public void tick() {
+                super.tick();
+                setYRot(getYHeadRot());
+            }
+
+            @Override
+            public boolean hurt(DamageSource ds, float amount) {
                 if(ScriptEvents.onHumanHurt(ds, getWrappedEntity(), amount)) {
                     return false;
                 }
-                return super.a(ds, amount);
+                return super.hurt(ds, amount);
             }
 
             public RawHuman getWrappedEntity() {
@@ -137,66 +176,68 @@ public class NMS {
                 return getWrappedEntity();
             }
 
-            public EntityPlayer update(PacketPlayOutSpawnEntityLiving p) {
-                player.e(p.b()); // set id, get id
-                player.a(p.e(), p.f(), p.g(), 0.0f, 0.0f);
+            public ServerPlayer update(ClientboundAddMobPacket p) {
+                NMS.setId(player, p.getId());
+                NMS.moveTo(player, p.getX(), p.getY(), p.getZ(), 0.0f, 0.0f);
                 return player;
             }
 
             @Override
-            public void b(NBTTagCompound nbt) {
-                super.b(nbt);
+            public void addAdditionalSaveData(CompoundTag nbt) {
+                super.addAdditionalSaveData(nbt);
 
-                GameProfile gp = player.fp();
-                nbt.a("HumanName", gp.getName());
+                GameProfile gp = NMS.getGameProfile(player);
+                nbt.putString("HumanName", gp.getName());
 
                 Collection<Property> c = gp.getProperties().get("textures");
                 for(Property p : c) {
                     if(p.getName().equals("textures")) {
-                        nbt.a("HumanTexture", p.getValue());
-                        nbt.a("HumanSignature", p.getSignature());
+                        nbt.putString("HumanTexture", p.getValue());
+                        nbt.putString("HumanSignature", p.getSignature());
                         break;
                     }
                 }
             }
 
             @Override
-            public void a(NBTTagCompound nbt) {
-                super.a(nbt);
-                if(nbt.b("HumanName", 8)) {
-                    String name = nbt.l("HumanName");
-                    setPlayer(name, player.t);
+            public void readAdditionalSaveData(CompoundTag nbt) {
+                super.readAdditionalSaveData(nbt);
+                if(nbt.contains("HumanName", CompoundTag.TAG_STRING)) {
+                    String name = nbt.getString("HumanName");
+                    setPlayer(name, NMS.getWorld(player));
                 }
-                if(nbt.b("HumanTexture", 8) && nbt.b("HumanSignature", 8)) {
-                    String texture = nbt.l("HumanTexture");
-                    String signature = nbt.l("HumanSignature");
+                if(nbt.contains("HumanTexture", CompoundTag.TAG_STRING)
+                        && nbt.contains("HumanSignature", CompoundTag.TAG_STRING)) {
+                    String texture = nbt.getString("HumanTexture");
+                    String signature = nbt.getString("HumanSignature");
                     setSkinWithoutPacket(texture, signature);
                 }
             }
 
             private void updatePosition() {
                 Location l = getBukkitEntity().getLocation();
-                player.a(l.getX(), l.getY(), l.getZ(), l.getYaw(), l.getPitch());
+                NMS.moveTo(player, l.getX(), l.getY(), l.getZ(), l.getYaw(), l.getPitch());
             }
 
             public void setSkinWithoutPacket(String texture, String signature) {
-                GameProfile gp = player.fp();
+                GameProfile gp = NMS.getGameProfile(player);
                 gp.getProperties().clear();
                 gp.getProperties().put("textures", new Property("textures", texture, signature));
             }
 
             private void sync() {
                 updatePosition();
-                PacketPlayOutPlayerInfo info = new PacketPlayOutPlayerInfo(
-                        PacketPlayOutPlayerInfo.EnumPlayerInfoAction.a, player);
-                PacketPlayOutNamedEntitySpawn spawn = new PacketPlayOutNamedEntitySpawn(player);
+                ClientboundPlayerInfoPacket info = new ClientboundPlayerInfoPacket(
+                        ClientboundPlayerInfoPacket.Action.ADD_PLAYER, player);
+                ClientboundAddPlayerPacket spawn = new ClientboundAddPlayerPacket(player);
 
                 Location center = getBukkitEntity().getLocation();
-                for(EntityPlayer p : ((WorldServer) this.W()).z()) {
+
+                for(ServerPlayer p : ((ServerLevel) NMS.getWorld(this)).players()) {
                     double distance = center.distanceSquared(p.getBukkitEntity().getLocation());
                     if(distance < 100.0) {
-                        p.b.a(info);
-                        p.b.a(spawn);
+                        p.connection.send(info);
+                        p.connection.send(spawn);
                     }
                 }
             }
@@ -207,9 +248,24 @@ public class NMS {
             }
 
             public void setName(String name) {
-                setPlayer(name, player.t);
+                setPlayer(name, NMS.getWorld(player));
                 sync();
             }
+
+            @Override
+            protected void registerGoals() {
+                this.goalSelector.addGoal(0, new FloatGoal(this));
+                this.goalSelector.addGoal(1,
+                        new LookAtPlayerGoal(this, net.minecraft.server.level.ServerPlayer.class,
+                                6.0f));
+                this.goalSelector.addGoal(2, new RandomLookAroundGoal(this));
+            }
+
+            @Override
+            public void setDeltaMovement(Vec3 velocity) {}
+
+            @Override
+            public void setDeltaMovement(double x, double y, double z) {}
         }
 
         public final WrapperHuman human;
@@ -222,12 +278,12 @@ public class NMS {
 
         private RawHuman(WrapperHuman human, Location l, PlayerProfile profile) {
             this(human);
-            human.a(l.getX(), l.getY(), l.getZ(), l.getYaw(), l.getPitch());
-            human.W().b(human);
+            NMS.moveTo(human, l.getX(), l.getY(), l.getZ(), l.getYaw(), l.getPitch());
+            ((net.minecraft.world.level.LevelWriter) NMS.getWorld(human)).addFreshEntity(human);
         }
 
         public RawHuman(Location l, PlayerProfile profile) {
-            this(HUMAN_TYPE.a(map(l.getWorld())), l, profile);
+            this(HUMAN_TYPE.create(map(l.getWorld())), l, profile);
         }
 
         public void setSkin(String texture, String signature) {
@@ -243,71 +299,71 @@ public class NMS {
         return new RawHuman(l, Bukkit.createProfile(UUID.randomUUID(), name));
     }
 
-    private static class PluginConnection extends PlayerConnection {
-        public PluginConnection(PlayerConnection c) {
-            super(getCraftServer().getServer(), c.a, c.b);
+    private static class PluginConnection extends ServerGamePacketListenerImpl {
+        public PluginConnection(ServerGamePacketListenerImpl c) {
+            super(getCraftServer().getServer(), c.connection, c.player);
         }
 
-        @SuppressWarnings("deprecation")
         private RawHuman.WrapperHuman getById(int id) {
-            net.minecraft.world.entity.Entity ent = b.x().b(id);
+            net.minecraft.world.entity.Entity ent = player.getLevel().getEntity(id);
             if(ent instanceof RawHuman.WrapperHuman) {
                 return (RawHuman.WrapperHuman) ent;
             }
             return null;
         }
 
-        private boolean handle(PacketPlayOutSpawnEntityLiving p) {
-            if(p.d() != IRegistry.Z.a(HUMAN_TYPE)) {
+        private boolean handle(ClientboundAddMobPacket p) {
+            if(p.getType() != Registry.ENTITY_TYPE.getId(HUMAN_TYPE)) {
                 return false;
             }
-            UUID uuid = p.c();
+            UUID uuid = p.getUUID();
             Entity ent = Bukkit.getEntity(uuid);
             if(!(ent instanceof RawHuman)) {
                 return false;
             }
             RawHuman raw = (RawHuman) ent;
-            EntityPlayer player = raw.human.update(p);
-            PacketPlayOutPlayerInfo info = new PacketPlayOutPlayerInfo(
-                    PacketPlayOutPlayerInfo.EnumPlayerInfoAction.a, player);
-            PacketPlayOutNamedEntitySpawn spawn = new PacketPlayOutNamedEntitySpawn(player);
-            super.a(info);
-            super.a(spawn);
+            ServerPlayer player = raw.human.update(p);
+            ClientboundPlayerInfoPacket info = new ClientboundPlayerInfoPacket(
+                    ClientboundPlayerInfoPacket.Action.ADD_PLAYER, player);
+            ClientboundAddPlayerPacket spawn = new ClientboundAddPlayerPacket(player);
+
+            super.send(info);
+            super.send(spawn);
             return true;
         }
 
-        private boolean handle(PacketPlayOutEntityMetadata p) {
-            return getById(p.c()) != null;
+        private boolean handle(ClientboundSetEntityDataPacket p) {
+            return getById(p.getId()) != null;
         }
 
-        private void handle(PacketPlayOutEntityDestroy p) {
-            for(int id : p.b()) {
+        private void handle(ClientboundRemoveEntitiesPacket p) {
+            for(int id : p.getEntityIds()) {
                 RawHuman.WrapperHuman human = getById(id);
                 if(human != null) {
-                    PacketPlayOutPlayerInfo remove = new PacketPlayOutPlayerInfo(
-                            PacketPlayOutPlayerInfo.EnumPlayerInfoAction.e, human.player);
-                    super.a(remove);
+                    ClientboundPlayerInfoPacket remove = new ClientboundPlayerInfoPacket(
+                            ClientboundPlayerInfoPacket.Action.REMOVE_PLAYER, human.player);
+                    super.send(remove);
                 }
             }
         }
 
         @Override
-        public void a(Packet<?> p) {
-            if(p instanceof PacketPlayOutSpawnEntityLiving
-                    && handle((PacketPlayOutSpawnEntityLiving) p)) {
+        public void send(Packet<?> p) {
+            if(p instanceof ClientboundAddMobPacket
+                    && handle((ClientboundAddMobPacket) p)) {
                 return;
-            } else if(p instanceof PacketPlayOutEntityMetadata
-                    && handle((PacketPlayOutEntityMetadata) p)) {
+            } else if(p instanceof ClientboundSetEntityDataPacket
+                    && handle((ClientboundSetEntityDataPacket) p)) {
                 return;
-            } else if(p instanceof PacketPlayOutEntityDestroy) {
-                handle((PacketPlayOutEntityDestroy) p);
+            } else if(p instanceof ClientboundRemoveEntitiesPacket) {
+                handle((ClientboundRemoveEntitiesPacket) p);
             }
-            super.a(p);
+            super.send(p);
         }
     }
 
     public static void patch(Player p) {
-        map(p).b = new PluginConnection(map(p).b);
+        map(p).connection = new PluginConnection(map(p).connection);
     }
 
     public static DamageSource getCurrentDamageSource() {
@@ -315,20 +371,20 @@ public class NMS {
     }
 
     public static Entity getImmediateSource(DamageSource ds) {
-        if(ds.k() == null) {
+        if(ds.getDirectEntity() == null) {
             return null;
         }
-        return map(ds.k());
+        return map(ds.getDirectEntity());
     }
 
     public static Entity getTrueSource(DamageSource ds) {
-        if(ds.l() == null) {
+        if(ds.getEntity() == null) {
             return null;
         }
-        return map(ds.l());
+        return map(ds.getEntity());
     }
 
-    public static EntityPlayer map(Player p) {
+    public static ServerPlayer map(Player p) {
         return ((CraftPlayer) p).getHandle();
     }
 
@@ -344,31 +400,31 @@ public class NMS {
         return e.getBukkitEntity();
     }
 
-    public static EntityLiving map(LivingEntity e) {
+    public static net.minecraft.world.entity.LivingEntity map(LivingEntity e) {
         return ((CraftLivingEntity) e).getHandle();
     }
 
-    public static EntityArrow map(Arrow e) {
+    public static net.minecraft.world.entity.projectile.AbstractArrow map(Arrow e) {
         return ((CraftArrow) e).getHandle();
     }
 
-    public static EntityFireworks map(Firework e) {
+    public static net.minecraft.world.entity.projectile.FireworkRocketEntity map(Firework e) {
         return ((CraftFirework) e).getHandle();
     }
 
-    public static EntityFireballFireball map(LargeFireball e) {
+    public static net.minecraft.world.entity.projectile.LargeFireball map(LargeFireball e) {
         return ((CraftLargeFireball) e).getHandle();
     }
 
-    public static EntityWitherSkull map(WitherSkull e) {
+    public static net.minecraft.world.entity.projectile.WitherSkull map(WitherSkull e) {
         return ((CraftWitherSkull) e).getHandle();
     }
 
-    public static EntityItem map(Item e) {
-        return (EntityItem) ((CraftItem) e).getHandle();
+    public static ItemEntity map(Item e) {
+        return (ItemEntity) ((CraftItem) e).getHandle();
     }
 
-    public static WorldServer map(World e) {
+    public static ServerLevel map(World e) {
         return ((CraftWorld) e).getHandle();
     }
 
@@ -376,7 +432,7 @@ public class NMS {
         return ((CraftPlayerProfile) profile).getGameProfile();
     }
 
-    public static IBlockData map(Block b) {
+    public static net.minecraft.world.level.block.state.BlockState map(Block b) {
         return ((CraftBlock) b).getNMS();
     }
 
@@ -390,7 +446,7 @@ public class NMS {
                 if(f.getType() == DamageSource.class) {
                     try {
                         DamageSource ds = (DamageSource) f.get(null);
-                        DAMAGE_SOURCES.put(ds.u(), ds);
+                        DAMAGE_SOURCES.put(ds.getMsgId(), ds);
                     } catch(Exception ex) {
                     }
                 }
@@ -400,145 +456,150 @@ public class NMS {
     }
 
     public static DamageSource sting(LivingEntity liv) {
-        return DamageSource.b(map(liv));
+        return DamageSource.sting(map(liv));
     }
 
     public static DamageSource mobAttack(LivingEntity liv) {
-        return DamageSource.c(map(liv));
+        return DamageSource.mobAttack(map(liv));
     }
 
     public static DamageSource mobIndirect(Entity ent, LivingEntity liv) {
-        return DamageSource.a(map(ent), map(liv));
+        return DamageSource.indirectMobAttack(map(ent), map(liv));
     }
 
     public static DamageSource playerAttack(Player p) {
-        return DamageSource.a(map(p));
+        return DamageSource.playerAttack(map(p));
     }
 
     public static DamageSource arrow(Arrow arrow, Entity ent) {
-        return DamageSource.a(map(arrow), map(ent));
+        return DamageSource.arrow(map(arrow), map(ent));
     }
 
     public static DamageSource trident(Entity ent, Entity ent2) {
-        return DamageSource.a(map(ent), map(ent2));
+        return DamageSource.trident(map(ent), map(ent2));
     }
 
     public static DamageSource firework(Firework firework, Entity ent) {
-        return DamageSource.a(map(firework), map(ent));
+        return DamageSource.fireworks(map(firework), map(ent));
     }
 
     public static DamageSource fireball(LargeFireball fireball, Entity ent) {
-        return DamageSource.a(map(fireball), map(ent));
+        return DamageSource.fireball(map(fireball), map(ent));
     }
 
     public static DamageSource witherSkull(WitherSkull witherSkull, Entity ent) {
-        return DamageSource.a(map(witherSkull), map(ent));
+        return DamageSource.witherSkull(map(witherSkull), map(ent));
     }
 
     public static DamageSource projectile(Entity ent, Entity ent2) {
-        return DamageSource.a(map(ent), map(ent2));
+        return DamageSource.thrown(map(ent), map(ent2));
     }
 
     public static DamageSource indirectMagic(Entity ent, Entity ent2) {
-        return DamageSource.c(map(ent), map(ent2));
+        return DamageSource.indirectMagic(map(ent), map(ent2));
     }
 
     public static DamageSource thorns(Entity ent) {
-        return DamageSource.a(map(ent));
+        return DamageSource.thorns(map(ent));
     }
 
     public static DamageSource explosion(LivingEntity liv) {
-        return DamageSource.d(map(liv));
+        return DamageSource.explosion(map(liv));
     }
 
     public static DamageSource explosionBed() {
-        return DamageSource.a();
+        return DamageSource.badRespawnPointExplosion();
     }
 
     public static void setMessageOfTheDay(String msg) {
-        ((CraftServer) Bukkit.getServer()).getServer().e(msg);
+        try {
+            var server = ((CraftServer) Bukkit.getServer()).getServer();
+            server.getClass().getMethod("e", String.class).invoke(server, msg);
+        } catch(Exception ex) {
+            KajetansPlugin.warn("cannot set motd");
+        }
     }
 
     public static String toString(ItemStack stack) {
-        NBTTagCompound c = new NBTTagCompound();
-        map(stack).b(c);
+        CompoundTag c = new CompoundTag();
+        map(stack).save(c);
         return c.toString();
     }
 
-    private static NBTTagCompound parse(String s) throws Exception {
-        return MojangsonParser.a(s);
+    private static CompoundTag parse(String s) throws Exception {
+        return TagParser.parseTag(s);
     }
 
     public static ItemStack parseItemStack(String stack) throws Exception {
-        return CraftItemStack.asCraftMirror(net.minecraft.world.item.ItemStack.a(parse(stack)));
+        return CraftItemStack.asCraftMirror(net.minecraft.world.item.ItemStack.of(parse(stack)));
     }
 
     public static String toString(Entity ent) {
-        NBTTagCompound c = new NBTTagCompound();
-        map(ent).d(c);
+        CompoundTag c = new CompoundTag();
+        map(ent).save(c);
         return c.toString();
     }
 
     public static Entity parseEntity(String stack, Location l) throws Exception {
-        NBTTagCompound c = parse(stack);
+        CompoundTag c = parse(stack);
         var nmsWorld = map(l.getWorld());
         net.minecraft.world.entity.Entity ent =
-                net.minecraft.world.entity.EntityTypes.a(c, nmsWorld, e -> {
-                    e.a_(UUID.randomUUID());
-                    e.a(l.getX(), l.getY(), l.getZ(), l.getYaw(), l.getPitch());
-                    return nmsWorld.b(e) ? e : null;
+                EntityType.loadEntityRecursive(c, nmsWorld, e -> {
+                    e.setUUID(UUID.randomUUID());
+                    NMS.moveTo(e, l.getX(), l.getY(), l.getZ(), l.getYaw(), l.getPitch());
+                    return nmsWorld.addFreshEntity(e) ? e : null;
                 });
         return map(ent);
     }
 
-    private static BlockPosition convert(Location l) {
-        return new BlockPosition(l.getBlockX(), l.getBlockY(), l.getBlockZ());
+    private static BlockPos convert(Location l) {
+        return new BlockPos(l.getBlockX(), l.getBlockY(), l.getBlockZ());
     }
 
     public static void copyTileEntity(Location from, Location to) {
         var nmsFromWorld = map(from.getWorld());
         var nmsToWorld = map(to.getWorld());
 
-        BlockPosition posTo = convert(to);
-        TileEntity fromEntity = nmsFromWorld.c_(convert(from));
-        TileEntity toEntity = nmsToWorld.c_(posTo);
+        BlockPos posTo = convert(to);
+        BlockEntity fromEntity = nmsFromWorld.getBlockEntity(convert(from));
+        BlockEntity toEntity = nmsToWorld.getBlockEntity(posTo);
         if(fromEntity != null && toEntity != null && fromEntity.getClass() == toEntity.getClass()) {
-            NBTTagCompound nbtTagCompound = fromEntity.m();
-            toEntity.a(nbtTagCompound);
+            CompoundTag nbtTagCompound = fromEntity.saveWithFullMetadata();
+            toEntity.load(nbtTagCompound);
             Block b = to.getBlock();
-            nmsToWorld.a(posTo, map(b), map(b), 3);
+            nmsToWorld.sendBlockUpdated(posTo, map(b), map(b), 3);
         }
     }
 
-    public static NBTTagCompound getBlockEntity(String s) throws Exception {
+    public static CompoundTag getBlockEntity(String s) throws Exception {
         return parse(s);
     }
 
-    public static NBTTagCompound getEntity(Block b) {
+    public static CompoundTag getEntity(Block b) {
         Location l = b.getLocation();
         var nmsWorld = map(l.getWorld());
-        TileEntity te = nmsWorld.c_(convert(l));
+        BlockEntity te = nmsWorld.getBlockEntity(convert(l));
         if(te == null) {
             return null;
         }
-        return te.o();
+        return te.saveWithoutMetadata();
     }
 
-    public static void setEntity(Block b, NBTTagCompound nbt) {
+    public static void setEntity(Block b, CompoundTag nbt) {
         if(nbt == null) {
             return;
         }
         Location l = b.getLocation();
         var nmsWorld = map(l.getWorld());
-        BlockPosition pos = convert(l);
-        TileEntity te = nmsWorld.c_(pos);
+        BlockPos pos = convert(l);
+        BlockEntity te = nmsWorld.getBlockEntity(pos);
         if(te != null) {
-            te.a(nbt);
-            nmsWorld.a(pos, map(b), map(b), 3);
+            te.load(nbt);
+            nmsWorld.sendBlockUpdated(pos, map(b), map(b), 3);
         }
     }
 
-    public static NBTTagCompound toNBT(Object o) {
-        return (NBTTagCompound) o;
+    public static CompoundTag toNBT(Object o) {
+        return (CompoundTag) o;
     }
 }

src/me/hammerle/kp/snuviscript/CommandManager.java

@@ -13,11 +13,11 @@ import org.bukkit.permissions.PermissionAttachment;
 import org.bukkit.permissions.PermissionAttachmentInfo;
 import me.hammerle.kp.KajetansPlugin;
 import me.hammerle.kp.NMS;
-import net.minecraft.commands.CommandListenerWrapper;
-import net.minecraft.commands.ICompletionProvider;
-import net.minecraft.commands.synchronization.CompletionProviders;
-import net.minecraft.network.protocol.game.PacketPlayOutCommands;
-import net.minecraft.server.level.EntityPlayer;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.SharedSuggestionProvider;
+import net.minecraft.commands.synchronization.SuggestionProviders;
+import net.minecraft.network.protocol.game.ClientboundCommandsPacket;
+import net.minecraft.server.level.ServerPlayer;
 import com.google.common.collect.Maps;
 import com.mojang.brigadier.builder.ArgumentBuilder;
 import com.mojang.brigadier.builder.RequiredArgumentBuilder;
@@ -30,7 +30,7 @@ public class CommandManager {
             UUID.fromString("51e240f9-ab10-4ea6-8a5d-779319f51257");
     private final static HashMap<String, KajetanCommand> COMMANDS = new HashMap<>();
     private final static HashSet<String> SNUVI_COMMANDS = new HashSet<>();
-    private final static ArrayList<CommandNode<?>> CUSTOM_NODES = new ArrayList<>();
+    private final static HashMap<String, CommandNode<?>> CUSTOM_NODES = new HashMap<>();
     private final static HashSet<String> IGNORED_COMMANDS = new HashSet<>();
 
     public static void clearCustomNodes() {
@@ -46,7 +46,7 @@ public class CommandManager {
     }
 
     public static void addCustomNode(CommandNode<?> node) {
-        CUSTOM_NODES.add(node);
+        CUSTOM_NODES.put(node.getName(), node);
     }
 
     public static void add(KajetanCommand command) {
@@ -143,34 +143,34 @@ public class CommandManager {
 
     @SuppressWarnings({"unchecked", "rawtypes"})
     public static void send(Player player) {
-        EntityPlayer p = NMS.map(player);
+        ServerPlayer p = NMS.map(player);
 
-        Map<CommandNode<CommandListenerWrapper>, CommandNode<ICompletionProvider>> map =
+        Map<CommandNode<CommandSourceStack>, CommandNode<SharedSuggestionProvider>> map =
                 Maps.newIdentityHashMap();
-        RootCommandNode<CommandListenerWrapper> vanilla =
-                p.c.vanillaCommandDispatcher.a().getRoot();
-        RootCommandNode<ICompletionProvider> rootNode = new RootCommandNode<>();
+        RootCommandNode<CommandSourceStack> vanilla =
+                p.server.vanillaCommandDispatcher.getDispatcher().getRoot();
+        RootCommandNode<SharedSuggestionProvider> rootNode = new RootCommandNode<>();
         map.put(vanilla, rootNode);
-        CommandListenerWrapper cs = p.cQ();
+        CommandSourceStack cs = ((net.minecraft.world.entity.Entity) p).createCommandSourceStack();
         commandSourceNodesToSuggestionNodes(true, vanilla, rootNode, cs, map);
-        for(CommandNode node : CUSTOM_NODES) {
+        for(CommandNode node : CUSTOM_NODES.values()) {
             commandSourceNodesToSuggestionNodes(node, rootNode, cs, map);
         }
-        p.b.a(new PacketPlayOutCommands(rootNode));
+        p.connection.send(new ClientboundCommandsPacket(rootNode));
     }
 
     @SuppressWarnings({"unchecked", "rawtypes"})
     private static void commandSourceNodesToSuggestionNodes(boolean first,
-            CommandNode<CommandListenerWrapper> node, CommandNode<ICompletionProvider> suggestion,
-            CommandListenerWrapper source,
-            Map<CommandNode<CommandListenerWrapper>, CommandNode<ICompletionProvider>> map) {
-        for(CommandNode<CommandListenerWrapper> childNode : node.getChildren()) {
+            CommandNode<CommandSourceStack> node, CommandNode<SharedSuggestionProvider> suggestion,
+            CommandSourceStack source,
+            Map<CommandNode<CommandSourceStack>, CommandNode<SharedSuggestionProvider>> map) {
+        for(CommandNode<CommandSourceStack> childNode : node.getChildren()) {
             if(first && IGNORED_COMMANDS.contains(childNode.getName())) {
                 continue;
             }
             if((first && source.getBukkitSender().hasPermission(childNode.getName())
                     || (!first && childNode.canUse(source)))) {
-                ArgumentBuilder<ICompletionProvider, ?> arg =
+                ArgumentBuilder<SharedSuggestionProvider, ?> arg =
                         (ArgumentBuilder) childNode.createBuilder();
                 arg.requires(a -> true);
                 if(arg.getCommand() != null) {
@@ -178,10 +178,11 @@ public class CommandManager {
                 }
 
                 if(arg instanceof RequiredArgumentBuilder) {
-                    RequiredArgumentBuilder<ICompletionProvider, ?> required =
+                    RequiredArgumentBuilder<SharedSuggestionProvider, ?> required =
                             (RequiredArgumentBuilder) arg;
                     if(required.getSuggestionsProvider() != null) {
-                        required.suggests(CompletionProviders.b(required.getSuggestionsProvider()));
+                        required.suggests(
+                                SuggestionProviders.safelySwap(required.getSuggestionsProvider()));
                     }
                 }
 
@@ -189,7 +190,7 @@ public class CommandManager {
                     arg.redirect(map.get(arg.getRedirect()));
                 }
 
-                CommandNode<ICompletionProvider> commandNode = arg.build();
+                CommandNode<SharedSuggestionProvider> commandNode = arg.build();
                 map.put(childNode, commandNode);
                 suggestion.addChild(commandNode);
                 if(!childNode.getChildren().isEmpty()) {
@@ -201,31 +202,32 @@ public class CommandManager {
 
     @SuppressWarnings({"unchecked", "rawtypes"})
     private static void commandSourceNodesToSuggestionNodes(
-            CommandNode<CommandListenerWrapper> node, CommandNode<ICompletionProvider> parentNode,
-            CommandListenerWrapper cs,
-            Map<CommandNode<CommandListenerWrapper>, CommandNode<ICompletionProvider>> map) {
+            CommandNode<CommandSourceStack> node, CommandNode<SharedSuggestionProvider> parentNode,
+            CommandSourceStack cs,
+            Map<CommandNode<CommandSourceStack>, CommandNode<SharedSuggestionProvider>> map) {
         if(!node.canUse(cs)) {
             return;
         }
-        ArgumentBuilder<ICompletionProvider, ?> arg = (ArgumentBuilder) node.createBuilder();
+        ArgumentBuilder<SharedSuggestionProvider, ?> arg = (ArgumentBuilder) node.createBuilder();
         arg.requires(a -> true);
         if(arg.getCommand() != null) {
             arg.executes(a -> 0);
         }
         if(arg instanceof RequiredArgumentBuilder) {
-            RequiredArgumentBuilder<ICompletionProvider, ?> required =
+            RequiredArgumentBuilder<SharedSuggestionProvider, ?> required =
                     (RequiredArgumentBuilder) arg;
             if(required.getSuggestionsProvider() != null) {
-                required.suggests(CompletionProviders.b(required.getSuggestionsProvider()));
+                required.suggests(
+                        SuggestionProviders.safelySwap(required.getSuggestionsProvider()));
             }
         }
         if(arg.getRedirect() != null) {
             arg.redirect(map.get(arg.getRedirect()));
         }
-        CommandNode<ICompletionProvider> commandNode = arg.build();
+        CommandNode<SharedSuggestionProvider> commandNode = arg.build();
         map.put(node, commandNode);
         parentNode.addChild(commandNode);
-        for(CommandNode<CommandListenerWrapper> childNode : node.getChildren()) {
+        for(CommandNode<CommandSourceStack> childNode : node.getChildren()) {
             commandSourceNodesToSuggestionNodes(childNode, commandNode, cs, map);
         }
     }

src/me/hammerle/kp/snuviscript/commands/CommandCommands.java

@@ -6,13 +6,13 @@ import com.mojang.brigadier.arguments.*;
 import com.mojang.brigadier.builder.*;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
-import net.minecraft.commands.CommandDispatcher;
-import net.minecraft.commands.CommandListenerWrapper;
-import net.minecraft.commands.arguments.ArgumentEnchantment;
-import net.minecraft.commands.arguments.ArgumentEntity;
-import net.minecraft.commands.arguments.ArgumentMobEffect;
-import net.minecraft.commands.arguments.blocks.ArgumentTile;
-import net.minecraft.commands.arguments.item.ArgumentItemStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.arguments.EntityArgument;
+import net.minecraft.commands.arguments.ItemEnchantmentArgument;
+import net.minecraft.commands.arguments.MobEffectArgument;
+import net.minecraft.commands.arguments.blocks.BlockStateArgument;
+import net.minecraft.commands.arguments.item.ItemArgument;
 
 public class CommandCommands {
     @SuppressWarnings({"unchecked", "rawtypes"})
@@ -23,12 +23,12 @@ public class CommandCommands {
                 (sc, in) -> CommandManager.clearIgnored());
         KajetansPlugin.scriptManager.registerFunction("command.newhelp", (sc, in) -> {
             final String perm = in[1].getString(sc);
-            return CommandDispatcher.a(in[0].getString(sc))
+            return Commands.literal(in[0].getString(sc))
                     .requires(p -> p.getBukkitSender().hasPermission(perm));
         });
         KajetansPlugin.scriptManager.registerFunction("command.newhelpliteral", (sc, in) -> {
-            LiteralArgumentBuilder<CommandListenerWrapper> arg =
-                    CommandDispatcher.a(in[0].getString(sc));
+            LiteralArgumentBuilder<CommandSourceStack> arg =
+                    Commands.literal(in[0].getString(sc));
             if(in.length >= 2) {
                 final String perm = in[1].getString(sc);
                 arg.requires(p -> p.getBukkitSender().hasPermission(perm));
@@ -36,8 +36,8 @@ public class CommandCommands {
             return arg;
         });
         KajetansPlugin.scriptManager.registerFunction("command.newhelpbool", (sc, in) -> {
-            RequiredArgumentBuilder<CommandListenerWrapper, Boolean> arg =
-                    CommandDispatcher.a(in[0].getString(sc), BoolArgumentType.bool());
+            RequiredArgumentBuilder<CommandSourceStack, Boolean> arg =
+                    Commands.argument(in[0].getString(sc), BoolArgumentType.bool());
             if(in.length >= 2) {
                 final String perm = in[1].getString(sc);
                 arg.requires(p -> p.getBukkitSender().hasPermission(perm));
@@ -47,8 +47,8 @@ public class CommandCommands {
         KajetansPlugin.scriptManager.registerFunction("command.newhelpdouble", (sc, in) -> {
             double min = in[1].getDouble(sc);
             double max = in[2].getDouble(sc);
-            RequiredArgumentBuilder<CommandListenerWrapper, Double> arg = CommandDispatcher
-                    .a(in[0].getString(sc), DoubleArgumentType.doubleArg(min, max));
+            RequiredArgumentBuilder<CommandSourceStack, Double> arg = Commands
+                    .argument(in[0].getString(sc), DoubleArgumentType.doubleArg(min, max));
             if(in.length >= 4) {
                 final String perm = in[3].getString(sc);
                 arg.requires(p -> p.getBukkitSender().hasPermission(perm));
@@ -58,8 +58,8 @@ public class CommandCommands {
         KajetansPlugin.scriptManager.registerFunction("command.newhelpfloat", (sc, in) -> {
             float min = in[1].getFloat(sc);
             float max = in[2].getFloat(sc);
-            RequiredArgumentBuilder<CommandListenerWrapper, Float> arg =
-                    CommandDispatcher.a(in[0].getString(sc), FloatArgumentType.floatArg(min, max));
+            RequiredArgumentBuilder<CommandSourceStack, Float> arg =
+                    Commands.argument(in[0].getString(sc), FloatArgumentType.floatArg(min, max));
             if(in.length >= 4) {
                 final String perm = in[3].getString(sc);
                 arg.requires(p -> p.getBukkitSender().hasPermission(perm));
@@ -69,8 +69,8 @@ public class CommandCommands {
         KajetansPlugin.scriptManager.registerFunction("command.newhelpint", (sc, in) -> {
             int min = in[1].getInt(sc);
             int max = in[2].getInt(sc);
-            RequiredArgumentBuilder<CommandListenerWrapper, Integer> arg =
-                    CommandDispatcher.a(in[0].getString(sc), IntegerArgumentType.integer(min, max));
+            RequiredArgumentBuilder<CommandSourceStack, Integer> arg =
+                    Commands.argument(in[0].getString(sc), IntegerArgumentType.integer(min, max));
             if(in.length >= 4) {
                 final String perm = in[3].getString(sc);
                 arg.requires(p -> p.getBukkitSender().hasPermission(perm));
@@ -80,8 +80,8 @@ public class CommandCommands {
         KajetansPlugin.scriptManager.registerFunction("command.newhelplong", (sc, in) -> {
             long min = in[1].getLong(sc);
             long max = in[2].getLong(sc);
-            RequiredArgumentBuilder<CommandListenerWrapper, Long> arg =
-                    CommandDispatcher.a(in[0].getString(sc), LongArgumentType.longArg(min, max));
+            RequiredArgumentBuilder<CommandSourceStack, Long> arg =
+                    Commands.argument(in[0].getString(sc), LongArgumentType.longArg(min, max));
             if(in.length >= 4) {
                 final String perm = in[3].getString(sc);
                 arg.requires(p -> p.getBukkitSender().hasPermission(perm));
@@ -89,11 +89,11 @@ public class CommandCommands {
             return arg;
         });
         KajetansPlugin.scriptManager.registerFunction("command.newhelpstring", (sc, in) -> {
-            RequiredArgumentBuilder<CommandListenerWrapper, String> arg;
+            RequiredArgumentBuilder<CommandSourceStack, String> arg;
             if(in[1].getBoolean(sc)) {
-                arg = CommandDispatcher.a(in[0].getString(sc), StringArgumentType.greedyString());
+                arg = Commands.argument(in[0].getString(sc), StringArgumentType.greedyString());
             } else {
-                arg = CommandDispatcher.a(in[0].getString(sc), StringArgumentType.string());
+                arg = Commands.argument(in[0].getString(sc), StringArgumentType.string());
             }
             if(in.length >= 3) {
                 final String perm = in[2].getString(sc);
@@ -102,27 +102,28 @@ public class CommandCommands {
             return arg;
         });
         KajetansPlugin.scriptManager.registerFunction("command.newhelpspecial", (sc, in) -> {
-            RequiredArgumentBuilder<CommandListenerWrapper, ArgumentType<?>> arg = null;
+            RequiredArgumentBuilder<CommandSourceStack, ArgumentType<?>> arg = null;
             String name = in[0].getString(sc);
             switch(name) {
                 case "Item":
-                    arg = CommandDispatcher.a(in[1].getString(sc),
-                            (ArgumentType) ArgumentItemStack.a());
+                    arg = Commands.argument(in[1].getString(sc),
+                            (ArgumentType) ItemArgument.item());
                     break;
                 case "Block":
-                    arg = CommandDispatcher.a(in[1].getString(sc), (ArgumentType) ArgumentTile.a());
+                    arg = Commands.argument(in[1].getString(sc),
+                            (ArgumentType) BlockStateArgument.block());
                     break;
                 case "Potion":
-                    arg = CommandDispatcher.a(in[1].getString(sc),
-                            (ArgumentType) ArgumentMobEffect.a());
+                    arg = Commands.argument(in[1].getString(sc),
+                            (ArgumentType) MobEffectArgument.effect());
                     break;
                 case "Enchantment":
-                    arg = CommandDispatcher.a(in[1].getString(sc),
-                            (ArgumentType) ArgumentEnchantment.a());
+                    arg = Commands.argument(in[1].getString(sc),
+                            (ArgumentType) ItemEnchantmentArgument.enchantment());
                     break;
                 case "Player":
-                    arg = CommandDispatcher.a(in[1].getString(sc),
-                            (ArgumentType) ArgumentEntity.c());
+                    arg = Commands.argument(in[1].getString(sc),
+                            (ArgumentType) EntityArgument.player());
                     break;
                 default:
                     throw new IllegalArgumentException(
@@ -149,7 +150,7 @@ public class CommandCommands {
         });
         KajetansPlugin.scriptManager.registerConsumer("command.addhelp", (sc, in) -> {
             CommandManager.addCustomNode(
-                    ((LiteralArgumentBuilder<CommandListenerWrapper>) in[0].get(sc)).build());
+                    ((LiteralArgumentBuilder<CommandSourceStack>) in[0].get(sc)).build());
         });
         KajetansPlugin.scriptManager.registerConsumer("command.clearhelp",
                 (sc, in) -> CommandManager.clearCustomNodes());

src/me/hammerle/kp/snuviscript/commands/DamageCommands.java

@@ -17,29 +17,29 @@ public class DamageCommands {
         KajetansPlugin.scriptManager.registerFunction("damage.gettruesource",
                 (sc, in) -> NMS.getTrueSource(NMS.toDamageSource(in[0].get(sc))));
         KajetansPlugin.scriptManager.registerFunction("damage.iscreativeplayer",
-                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).i());
+                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).isBypassInvul());
         KajetansPlugin.scriptManager.registerFunction("damage.isabsolute",
-                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).j());
+                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).isBypassArmor());
         KajetansPlugin.scriptManager.registerFunction("damage.isdifficultyscaled",
-                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).w());
+                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).scalesWithDifficulty());
         KajetansPlugin.scriptManager.registerFunction("damage.isexplosion",
-                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).d());
+                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).isExplosion());
         KajetansPlugin.scriptManager.registerFunction("damage.isfire",
-                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).s());
+                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).isFire());
         KajetansPlugin.scriptManager.registerFunction("damage.ismagic",
-                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).x());
+                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).isMagic());
         KajetansPlugin.scriptManager.registerFunction("damage.isprojectile",
-                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).b());
+                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).isProjectile());
         KajetansPlugin.scriptManager.registerFunction("damage.isunblockable",
-                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).f());
+                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).isBypassMagic());
         KajetansPlugin.scriptManager.registerFunction("damage.isfall",
-                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).z());
+                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).isFall());
         KajetansPlugin.scriptManager.registerFunction("damage.isdamaginghelmet",
-                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).g());
+                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).isDamageHelmet());
         KajetansPlugin.scriptManager.registerFunction("damage.issweep",
                 (sc, in) -> NMS.toDamageSource(in[0].get(sc)).isSweep());
         KajetansPlugin.scriptManager.registerFunction("damage.gettype",
-                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).u());
+                (sc, in) -> NMS.toDamageSource(in[0].get(sc)).getMsgId());
         KajetansPlugin.scriptManager.registerFunction("damage.get",
                 (sc, in) -> NMS.parseDamageSource(in[0].getString(sc)));
         KajetansPlugin.scriptManager.registerFunction("damage.sting",

src/me/hammerle/kp/snuviscript/commands/EntityCommands.java

@@ -148,7 +148,7 @@ public class EntityCommands {
             ((Ageable) in[0].get(sc)).setAge(in[1].getInt(sc));
         });
         KajetansPlugin.scriptManager.registerFunction("entity.gettype",
-                (sc, in) -> NMS.map(((Entity) in[0].get(sc))).ad());
+                (sc, in) -> NMS.map(((Entity) in[0].get(sc))).getType());
         KajetansPlugin.scriptManager.registerFunction("sheep.issheared",
                 (sc, in) -> ((Sheep) in[0].get(sc)).isSheared());
         KajetansPlugin.scriptManager.registerFunction("sheep.getcolor",

src/me/hammerle/kp/snuviscript/commands/LivingCommands.java

@@ -6,6 +6,7 @@ import org.bukkit.attribute.AttributeInstance;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Projectile;
 import org.bukkit.event.entity.EntityRegainHealthEvent;
+import org.bukkit.inventory.EquipmentSlot;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
@@ -78,7 +79,7 @@ public class LivingCommands {
             StackTrace trace = sc.getStackTrace();
             KajetansPlugin.scheduleTask(() -> {
                 try {
-                    NMS.map(liv).a(damageSource, damage);
+                    NMS.map(liv).hurt(damageSource, damage);
                 } catch(Exception ex) {
                     sc.getScriptManager().getLogger().print(null, ex, "living.damage", sc.getName(),
                             sc, trace);
@@ -105,45 +106,11 @@ public class LivingCommands {
         });
         KajetansPlugin.scriptManager.registerConsumer("living.setequip", (sc, in) -> {
             LivingEntity liv = (LivingEntity) in[0].get(sc);
-            ItemStack stack = ((ItemStack) in[2].get(sc));
-            switch(in[1].getString(sc)) {
-                case "hand":
-                    liv.getEquipment().setItemInMainHand(stack);
-                    return;
-                case "head":
-                    liv.getEquipment().setHelmet(stack);
-                    return;
-                case "chest":
-                    liv.getEquipment().setChestplate(stack);
-                    return;
-                case "legs":
-                    liv.getEquipment().setLeggings(stack);
-                    return;
-                case "feet":
-                    liv.getEquipment().setBoots(stack);
-                    return;
-                case "offhand":
-                    liv.getEquipment().setItemInOffHand(stack);
-                    return;
-            }
+            liv.getEquipment().setItem((EquipmentSlot) in[1].get(sc), (ItemStack) in[2].get(sc));
         });
         KajetansPlugin.scriptManager.registerFunction("living.getequip", (sc, in) -> {
             LivingEntity liv = (LivingEntity) in[0].get(sc);
-            switch(in[1].getString(sc)) {
-                case "hand":
-                    return liv.getEquipment().getItemInMainHand();
-                case "head":
-                    return liv.getEquipment().getHelmet();
-                case "chest":
-                    return liv.getEquipment().getChestplate();
-                case "legs":
-                    return liv.getEquipment().getLeggings();
-                case "feet":
-                    return liv.getEquipment().getBoots();
-                case "offhand":
-                    return liv.getEquipment().getItemInOffHand();
-            }
-            return null;
+            return liv.getEquipment().getItem((EquipmentSlot) in[1].get(sc));
         });
         KajetansPlugin.scriptManager.registerConsumer("living.setinvisible", (sc, in) -> {
             ((LivingEntity) in[0].get(sc)).setInvisible(in[1].getBoolean(sc));

src/me/hammerle/kp/snuviscript/commands/LocationCommands.java

@@ -92,6 +92,13 @@ public class LocationCommands {
             }
         });
         KajetansPlugin.scriptManager.registerFunction("loc.iterator", (sc, in) -> {
+            Object o = in[0].get(sc);
+            if(o instanceof Location) {
+                Location l1 = (Location) o;
+                Location l2 = (Location) in[1].get(sc);
+                return new LocationIterator(l1.getWorld(), l1.getBlockX(), l1.getBlockY(),
+                        l1.getBlockZ(), l2.getBlockX(), l2.getBlockY(), l2.getBlockZ());
+            }
             return new LocationIterator((World) in[0].get(sc), in[1].getInt(sc), in[2].getInt(sc),
                     in[3].getInt(sc), in[4].getInt(sc), in[5].getInt(sc), in[6].getInt(sc));
         });

src/me/hammerle/kp/snuviscript/commands/PlayerCommands.java

@@ -181,12 +181,13 @@ public class PlayerCommands {
         KajetansPlugin.scriptManager.registerConsumer("player.damageitem", (sc, in) -> {
             Player p = (Player) in[0].get(sc);
             ItemStack stack = p.getEquipment().getItemInMainHand();
-            NMS.map(stack).a(in[1].getInt(sc), NMS.map(p), c -> {
+            NMS.map(stack).hurtAndBreak(in[1].getInt(sc), NMS.map(p), c -> {
             });
         });
         KajetansPlugin.scriptManager.registerConsumer("player.damagearmor", (sc, in) -> {
             Player p = (Player) in[0].get(sc);
-            NMS.map(p).fq().a(NMS.toDamageSource(in[2].get(sc)), in[1].getFloat(sc),
+            NMS.map(p).getInventory().hurtArmor(NMS.toDamageSource(in[2].get(sc)),
+                    in[1].getFloat(sc),
                     new int[] {0, 1, 2, 3});
         });
         KajetansPlugin.scriptManager.registerConsumer("player.addtotalexp", (sc, in) -> {

src/me/hammerle/kp/snuviscript/commands/ReadCommands.java

@@ -28,8 +28,14 @@ public class ReadCommands {
                 (sc, in) -> UUID.fromString(in[0].getString(sc)));
         KajetansPlugin.scriptManager.registerFunction("read.slot",
                 (sc, in) -> EquipmentSlot.valueOf(in[0].getString(sc)));
-        KajetansPlugin.scriptManager.registerFunction("read.blockdata",
-                (sc, in) -> Bukkit.createBlockData(in[0].getString(sc)));
+        KajetansPlugin.scriptManager.registerFunction("read.blockdata", (sc, in) -> {
+            String s = in[0].getString(sc);
+            try {
+                return Bukkit.createBlockData(s);
+            } catch(Exception ex) {
+                return null;
+            }
+        });
         KajetansPlugin.scriptManager.registerFunction("read.blockentity",
                 (sc, in) -> NMS.getBlockEntity(in[0].getString(sc)));
     }

src/me/hammerle/kp/utils/LocationIterator.java

@@ -18,11 +18,12 @@ public class LocationIterator implements Iterator<Location> {
 
     public LocationIterator(World world, int minX, int minY, int minZ, int maxX, int maxY,
             int maxZ) {
-        this.minX = minX;
-        this.minY = minY;
-        this.maxX = maxX;
-        this.maxY = maxY;
-        this.maxZ = maxZ;
+        this.minX = Math.min(minX, maxX);
+        this.minY = Math.min(minY, maxY);
+        this.maxX = Math.max(minX, maxX);
+        this.maxY = Math.max(minY, maxY);
+        this.maxZ = Math.max(minZ, maxZ);
+        minZ = Math.min(minZ, maxZ);
 
         current = new Location(world, minX, minY, minZ, 0, 0);
         x = minX;