Merge branch 'master' into 1.17

src/main/java/carpet/script/ScriptHost.java

@@ -18,13 +18,10 @@ import java.util.Locale;
 import java.util.Map;
 import java.util.Random;
 import java.util.Set;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.function.Predicate;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public abstract class ScriptHost
@@ -189,7 +186,13 @@ public abstract class ScriptHost
     public FunctionValue getAssertFunction(Module module, String name)
     {
         FunctionValue ret = getFunction(module, name);
-        if (ret == null) throw new InternalExpressionException("Function "+name+" is not defined yet");
+        if (ret == null)
+        {
+            if (module == main)
+                throw new InternalExpressionException("Function '"+name+"' is not defined yet");
+            else
+                throw new InternalExpressionException("Function '"+name+"' is not defined nor visible by its name in the imported module '"+module.getName()+"'");
+        }
         return ret;
     }
     private FunctionValue getFunction(Module module, String name)

src/main/java/carpet/script/api/Auxiliary.java

@@ -18,6 +18,7 @@ import carpet.script.argument.FunctionArgument;
 import carpet.script.argument.Vector3Argument;
 import carpet.script.exception.ExitStatement;
 import carpet.script.exception.InternalExpressionException;
+import carpet.script.utils.FixedCommandSource;
 import carpet.script.utils.ShapeDispatcher;
 import carpet.script.utils.WorldTools;
 import carpet.script.value.EntityValue;
@@ -34,7 +35,6 @@ import carpet.script.value.ValueConversions;
 import carpet.utils.Messenger;
 import com.google.common.collect.ImmutableMap;
 import net.minecraft.block.BlockState;
-import net.minecraft.command.argument.EntityAnchorArgumentType;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityType;
 import net.minecraft.entity.EquipmentSlot;
@@ -49,7 +49,6 @@ import net.minecraft.network.packet.s2c.play.TitleS2CPacket;
 import net.minecraft.network.packet.s2c.play.TitleS2CPacket.Action;
 import net.minecraft.particle.ParticleEffect;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.command.CommandOutput;
 import net.minecraft.server.command.ServerCommandSource;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
@@ -63,7 +62,6 @@ import net.minecraft.util.InvalidIdentifierException;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.ChunkPos;
 import net.minecraft.util.math.EulerAngle;
-import net.minecraft.util.math.Vec2f;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.registry.DynamicRegistryManager;
 import net.minecraft.util.registry.Registry;
@@ -331,7 +329,7 @@ public class Auxiliary {
             {
                 Value nameValue = lv.get(0).evalValue(c);
                 name = nameValue instanceof NullValue ? "" : nameValue.getString();
-                pointLocator = Vector3Argument.findIn(cc, lv, 1, true);
+                pointLocator = Vector3Argument.findIn(cc, lv, 1, true, false);
                 if (lv.size()>pointLocator.offset)
                 {
                     BlockArgument blockLocator = BlockArgument.findIn(cc, lv, pointLocator.offset, true, true, false);
@@ -467,28 +465,29 @@ public class Auxiliary {
         {
             if (lv.size() == 0 || lv.size() > 2) throw new InternalExpressionException("'print' takes one or two arguments");
             ServerCommandSource s = ((CarpetContext)c).s;
+            MinecraftServer server = s.getMinecraftServer();
             Value res = lv.get(0).evalValue(c);
+            List<ServerPlayerEntity> targets = null;
             if (lv.size() == 2)
             {
-                ServerPlayerEntity player = EntityValue.getPlayerByValue(s.getMinecraftServer(), res);
-                if (player == null) return LazyValue.NULL;
-                s = player.getCommandSource();
+                List<Value> playerValues = (res instanceof ListValue)?((ListValue) res).getItems():Collections.singletonList(res);
+                List<ServerPlayerEntity> playerTargets = new ArrayList<>();
+                playerValues.forEach(pv -> {
+                    ServerPlayerEntity player = EntityValue.getPlayerByValue(server, pv);
+                    if (player == null) throw new InternalExpressionException("Cannot target player "+pv.getString()+" in print");
+                    playerTargets.add(player);
+                });
+                targets = playerTargets;
                 res = lv.get(1).evalValue(c);
             }
-            if (res instanceof FormattedTextValue)
+            Text message = (res instanceof FormattedTextValue)?((FormattedTextValue) res).getText():new LiteralText(res.getString());
+            if (targets == null)
             {
-                s.sendFeedback(((FormattedTextValue) res).getText(), false);
+                s.sendFeedback(message, false);
             }
             else
             {
-                if (s.getEntity() instanceof PlayerEntity)
-                {
-                    Messenger.m((PlayerEntity) s.getEntity(), "w " + res.getString());
-                }
-                else
-                {
-                    Messenger.m(s, "w " + res.getString());
-                }
+                targets.forEach(p -> p.getCommandSource().sendFeedback(message, false));
             }
             Value finalRes = res;
             return (_c, _t) -> finalRes; // pass through for variables
@@ -565,29 +564,14 @@ public class Auxiliary {
 
         expression.addLazyFunction("run", 1, (c, t, lv) -> {
             BlockPos target = ((CarpetContext)c).origin;
-            Vec3d posf = new Vec3d((double)target.getX()+0.5D,(double)target.getY(),(double)target.getZ()+0.5D);
+            Vec3d posf = new Vec3d((double)target.getX()+0.5D, target.getY(),(double)target.getZ()+0.5D);
             ServerCommandSource s = ((CarpetContext)c).s;
             try
             {
                 Value[] error = {Value.NULL};
                 List<Value> output = new ArrayList<>();
                 Value retval = new NumericValue(s.getMinecraftServer().getCommandManager().execute(
-                        new ServerCommandSource(
-                                CommandOutput.DUMMY, posf, Vec2f.ZERO, s.getWorld(), CarpetSettings.runPermissionLevel,
-                                s.getName(), s.getDisplayName(), s.getMinecraftServer(), s.getEntity(), true,
-                                (ctx, succ, res) -> { }, EntityAnchorArgumentType.EntityAnchor.FEET)
-                        {
-                            @Override
-                            public void sendError(Text message)
-                            {
-                                error[0] = new FormattedTextValue(message);
-                            }
-                            @Override
-                            public void sendFeedback(Text message, boolean broadcastToOps)
-                            {
-                                output.add(new FormattedTextValue(message));
-                            }
-                        },
+                        new FixedCommandSource(s, posf, error, output),
                         lv.get(0).evalValue(c).getString())
                 );
                 Value ret = ListValue.of(retval, ListValue.wrap(output), error[0]);

src/main/java/carpet/script/api/Entities.java

@@ -194,14 +194,24 @@ public class Entities {
             if (lv.size()<3) throw new InternalExpressionException("'entity_area' requires entity type, center and range arguments");
             String who = lv.get(0).evalValue(c).getString();
             CarpetContext cc = (CarpetContext)c;
-            Vector3Argument centerLocator = Vector3Argument.findIn(cc, lv, 1);
-            Vec3d center = centerLocator.vec;
-            if (centerLocator.fromBlock) center.add(0.5, 0.5, 0.5);
+            Vector3Argument centerLocator = Vector3Argument.findIn(cc, lv, 1, false, true);
+
+            Box centerBox;
+            if (centerLocator.entity != null)
+            {
+                centerBox = centerLocator.entity.getBoundingBox();
+            }
+            else
+            {
+                Vec3d center = centerLocator.vec;
+                if (centerLocator.fromBlock) center.add(0.5, 0.5, 0.5);
+                centerBox = new Box(center, center);
+            }
             Vector3Argument rangeLocator = Vector3Argument.findIn(cc, lv, centerLocator.offset);
             if (rangeLocator.fromBlock)
                 throw new InternalExpressionException("Range of 'entity_area' cannot come from a block argument");
             Vec3d range = rangeLocator.vec;
-            Box area = new Box(center, center).expand(range.x, range.y, range.z);
+            Box area = centerBox.expand(range.x, range.y, range.z);
             EntityValue.EntityClassDescriptor eDesc = EntityValue.getEntityDescriptor(who);
             List<? extends Entity> entityList = ((CarpetContext)c).s.getWorld().getEntitiesByType(eDesc.directType, area,eDesc.filteringPredicate);
             Value retval = ListValue.wrap(entityList.stream().map(EntityValue::new).collect(Collectors.toList()));

src/main/java/carpet/script/api/WorldAccess.java

@@ -6,6 +6,7 @@ import carpet.fakes.BiomeArrayInterface;
 import carpet.fakes.ChunkGeneratorInterface;
 import carpet.fakes.ChunkTicketManagerInterface;
 import carpet.fakes.ServerChunkManagerInterface;
+import carpet.fakes.ServerWorldInterface;
 import carpet.fakes.SpawnHelperInnerInterface;
 import carpet.fakes.ThreadedAnvilChunkStorageInterface;
 import carpet.helpers.FeatureGenerator;
@@ -58,6 +59,7 @@ import net.minecraft.item.SwordItem;
 import net.minecraft.item.TridentItem;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.Tag;
+import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ChunkTicket;
 import net.minecraft.server.world.ChunkTicketType;
@@ -89,6 +91,7 @@ import net.minecraft.world.gen.ChunkRandom;
 import net.minecraft.world.gen.chunk.ChunkGenerator;
 import net.minecraft.world.gen.feature.ConfiguredStructureFeature;
 import net.minecraft.world.gen.feature.StructureFeature;
+import net.minecraft.world.level.ServerWorldProperties;
 import net.minecraft.world.poi.PointOfInterest;
 import net.minecraft.world.poi.PointOfInterestStorage;
 import net.minecraft.world.poi.PointOfInterestType;
@@ -413,6 +416,67 @@ public class WorldAccess {
         });
 
 
+        expression.addLazyFunction("weather",-1,(c, t, lv) -> {
+            ServerWorld world = ((CarpetContext) c).s.getWorld();
+
+            if(lv.size()==0)//cos it can thunder when raining or when clear.
+            {
+                Value ret = new StringValue(world.isThundering() ? "thunder" : (world.isRaining() ? "rain" : "clear"));
+                return (_c, _t) -> ret;
+            }
+
+            Value weather = lv.get(0).evalValue(c);
+            ServerWorldProperties worldProperties = ((ServerWorldInterface) world).getWorldPropertiesCM();
+            if(lv.size()==1)
+            {
+                int ticks;
+                switch (weather.getString().toLowerCase(Locale.ROOT)) {
+                    case "clear":
+                        ticks = worldProperties.getClearWeatherTime();
+                        break;
+                    case "rain":
+                        ticks = world.isRaining()? worldProperties.getRainTime():0;//cos if not it gives 1 for some reason
+                        break;
+                    case "thunder":
+                        ticks = world.isThundering()? worldProperties.getThunderTime():0;//same dealio here
+                        break;
+                    default:
+                        throw new InternalExpressionException("Weather can only be 'clear', 'rain' or 'thunder'");
+                }
+                Value ret = new NumericValue(ticks);
+                return (_c,_t) -> ret;
+            }
+            if(lv.size()==2)
+            {
+                int ticks = NumericValue.asNumber(lv.get(1).evalValue(c), "tick_time in 'weather'").getInt();
+                switch (weather.getString().toLowerCase(Locale.ROOT))
+                {
+                    case "clear":
+                        world.setWeather(ticks,0,false,false);
+                        break;
+
+                    case "rain":
+                        world.setWeather(0,ticks,true,false);
+                        break;
+
+                    case "thunder":
+                        world.setWeather(
+                                0,
+                                ticks,//this is used to set thunder time, idk why...
+                                true,
+                                true
+                        );
+                        break;
+
+                    default:
+                        throw new InternalExpressionException("Weather can only be 'clear', 'rain' or 'thunder'");
+                }
+                Value ret = NumericValue.of(ticks);
+                return (_c, _t) -> ret;
+            }
+            throw new InternalExpressionException("'weather' requires 0, 1 or 2 arguments");
+        });
+
         expression.addLazyFunction("pos", 1, (c, t, lv) ->
         {
             Value arg = lv.get(0).evalValue(c);

src/main/java/carpet/script/argument/Vector3Argument.java

@@ -4,9 +4,11 @@ import carpet.script.CarpetContext;
 import carpet.script.LazyValue;
 import carpet.script.exception.InternalExpressionException;
 import carpet.script.value.BlockValue;
+import carpet.script.value.EntityValue;
 import carpet.script.value.ListValue;
 import carpet.script.value.NumericValue;
 import carpet.script.value.Value;
+import net.minecraft.entity.Entity;
 import net.minecraft.util.math.Vec3d;
 
 import java.util.List;
@@ -16,7 +18,8 @@ public class Vector3Argument extends Argument
     public Vec3d vec;
     public final double yaw;
     public final double pitch;
-    public boolean fromBlock;
+    public boolean fromBlock = false;
+    public Entity entity = null;
     private Vector3Argument(Vec3d v, int o)
     {
         super(o);
@@ -38,13 +41,19 @@ public class Vector3Argument extends Argument
         return this;
     }
 
+    private Vector3Argument withEntity(Entity e)
+    {
+        entity = e;
+        return this;
+    }
+
 
     public static Vector3Argument findIn(CarpetContext c, List<LazyValue> params, int offset)
     {
-        return findIn(c,params, offset, false);
+        return findIn(c,params, offset, false, false);
     }
 
-    public static Vector3Argument findIn(CarpetContext c, List<LazyValue> params, int offset, boolean optionalDirection)
+    public static Vector3Argument findIn(CarpetContext c, List<LazyValue> params, int offset, boolean optionalDirection, boolean optionalEntity)
     {
         try
         {
@@ -54,6 +63,11 @@ public class Vector3Argument extends Argument
                 // pos + 0.5v
                 return (new Vector3Argument(Vec3d.ofCenter(((BlockValue) v1).getPos()), 1+offset)).fromBlock();
             }
+            if (optionalEntity && v1 instanceof EntityValue)
+            {
+                Entity e = ((EntityValue) v1).getEntity();
+                return new Vector3Argument(e.getPos(), 1+offset).withEntity(e);
+            }
             if (v1 instanceof ListValue)
             {
                 List<Value> args = ((ListValue) v1).getItems();

src/main/java/carpet/script/utils/FixedCommandSource.java

@@ -0,0 +1,206 @@
+package carpet.script.utils;
+
+import carpet.CarpetSettings;
+import carpet.script.value.FormattedTextValue;
+import carpet.script.value.Value;
+import com.mojang.brigadier.ResultConsumer;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import net.minecraft.command.argument.EntityAnchorArgumentType;
+import net.minecraft.entity.Entity;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.command.CommandOutput;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.text.Text;
+import net.minecraft.util.math.Vec2f;
+import net.minecraft.util.math.Vec3d;
+
+import java.util.List;
+import java.util.function.BinaryOperator;
+
+public class FixedCommandSource extends ServerCommandSource
+{
+    private Vec3d position;
+    private ServerWorld world;
+    private final String simpleName;
+    private final Text name;
+    private final MinecraftServer server;
+    private Entity entity;
+    private ResultConsumer<ServerCommandSource> resultConsumer;
+    private EntityAnchorArgumentType.EntityAnchor entityAnchor;
+    private Vec2f rotation;
+    private final Value[] error;
+    private final List<Value> chatOutput;
+
+    public FixedCommandSource(ServerCommandSource original, Vec3d pos, Value[] error, List<Value> chatOutput)
+    {
+        super(CommandOutput.DUMMY, pos, Vec2f.ZERO, original.getWorld(), CarpetSettings.runPermissionLevel,
+                original.getName(), original.getDisplayName(), original.getMinecraftServer(), original.getEntity(), true,
+                (ctx, succ, res) -> { }, EntityAnchorArgumentType.EntityAnchor.FEET);
+        position = pos;
+        world = original.getWorld();
+        simpleName = original.getName();
+        name = original.getDisplayName();
+        server = original.getMinecraftServer();
+        entity = original.getEntity();
+        resultConsumer = (ctx, succ, res) -> { };
+        entityAnchor = original.getEntityAnchor();
+        rotation = Vec2f.ZERO;
+        this.error = error;
+        this.chatOutput = chatOutput;
+    }
+
+    @Override
+    public ServerCommandSource withEntity(Entity entity)
+    {
+        this.entity = entity;
+        return this;
+    }
+
+    @Override
+    public ServerCommandSource withPosition(Vec3d position)
+    {
+        this.position = position;
+        return this;
+    }
+
+    @Override
+    public ServerCommandSource withRotation(Vec2f rotation)
+    {
+        this.rotation = rotation;
+        return this;
+    }
+
+    @Override
+    public ServerCommandSource withConsumer(ResultConsumer<ServerCommandSource> consumer)
+    {
+        this.resultConsumer = consumer;
+        return this;
+    }
+
+    @Override
+    public ServerCommandSource mergeConsumers(ResultConsumer<ServerCommandSource> consumer, BinaryOperator<ResultConsumer<ServerCommandSource>> binaryOperator)
+    {
+        return this.withConsumer(binaryOperator.apply(this.resultConsumer, consumer));
+    }
+
+    @Override
+    public ServerCommandSource withSilent()
+    {
+        return this;
+    }
+
+    @Override
+    public ServerCommandSource withLevel(int level)
+    {
+        return this;
+    }
+
+    @Override
+    public ServerCommandSource withMaxLevel(int level)
+    {
+        return this;
+    }
+
+    @Override
+    public ServerCommandSource withEntityAnchor(EntityAnchorArgumentType.EntityAnchor anchor)
+    {
+        entityAnchor = anchor;
+        return this;
+    }
+
+    @Override
+    public ServerCommandSource withWorld(ServerWorld world)
+    {
+        this.world = world;
+        return this;
+    }
+
+    @Override
+    public Text getDisplayName()
+    {
+        return name;
+    }
+
+    @Override
+    public String getName()
+    {
+        return simpleName;
+    }
+
+    @Override
+    public Vec3d getPosition()
+    {
+        return position;
+    }
+
+    @Override
+    public ServerWorld getWorld()
+    {
+        return world;
+    }
+
+    @Override
+    public Entity getEntity()
+    {
+        return entity;
+    }
+
+    @Override
+    public Entity getEntityOrThrow() throws CommandSyntaxException
+    {
+        if (entity == null) {
+            throw REQUIRES_ENTITY_EXCEPTION.create();
+        } else {
+            return entity;
+        }
+    }
+
+    @Override
+    public ServerPlayerEntity getPlayer() throws CommandSyntaxException
+    {
+        if (!(this.entity instanceof ServerPlayerEntity)) {
+            throw REQUIRES_PLAYER_EXCEPTION.create();
+        } else {
+            return (ServerPlayerEntity)this.entity;
+        }
+    }
+
+    @Override
+    public Vec2f getRotation()
+    {
+        return rotation;
+    }
+
+    @Override
+    public MinecraftServer getMinecraftServer()
+    {
+        return server;
+    }
+
+    @Override
+    public EntityAnchorArgumentType.EntityAnchor getEntityAnchor()
+    {
+        return entityAnchor;
+    }
+
+
+    @Override
+    public void onCommandComplete(CommandContext<ServerCommandSource> context, boolean success, int result)
+    {
+    }
+
+    @Override
+    public void sendError(Text message)
+    {
+        error[0] = new FormattedTextValue(message);
+    }
+    @Override
+    public void sendFeedback(Text message, boolean broadcastToOps)
+    {
+        chatOutput.add(new FormattedTextValue(message));
+    }
+
+}

src/main/java/carpet/script/utils/SystemInfo.java

@@ -13,6 +13,7 @@ import carpet.settings.ParsedRule;
 import carpet.settings.SettingsManager;
 import com.sun.management.OperatingSystemMXBean;
 import net.minecraft.util.WorldSavePath;
+import net.minecraft.world.GameRules;
 
 import java.lang.management.ManagementFactory;
 import java.nio.file.Path;
@@ -124,6 +125,17 @@ public class SystemInfo {
             });
             return carpetRules;
         });
+        put("world_gamerules", c->{
+            Map<Value, Value> rules = new HashMap<>();
+            final GameRules gameRules = c.s.getWorld().getGameRules();
+            GameRules.accept(new GameRules.Visitor() {
+                @Override
+                public <T extends GameRules.Rule<T>> void visit(GameRules.Key<T> key, GameRules.Type<T> type) {
+                    rules.put(StringValue.of(key.getName()), StringValue.of(gameRules.get(key).toString()));
+                }
+            });
+            return MapValue.wrap(rules);
+        });
         put("scarpet_version", c -> StringValue.of(CarpetSettings.carpetVersion));
 
     }};

src/main/java/carpet/script/value/EntityValue.java

@@ -31,6 +31,7 @@ import net.minecraft.nbt.StringTag;
 import net.minecraft.nbt.Tag;
 import net.minecraft.network.packet.s2c.play.EntityPassengersSetS2CPacket;
 import net.minecraft.network.packet.s2c.play.EntityPositionS2CPacket;
+import net.minecraft.network.packet.s2c.play.ExperienceBarUpdateS2CPacket;
 import net.minecraft.network.packet.s2c.play.PlayerPositionLookS2CPacket;
 import net.minecraft.command.EntitySelector;
 import net.minecraft.command.EntitySelectorReader;
@@ -514,6 +515,31 @@ public class EntityValue extends Value
             return Value.NULL;
         });
 
+        put("absorption",(e, a)->{
+            if(e instanceof PlayerEntity) return new NumericValue(((PlayerEntity) e).getAbsorptionAmount());
+            return Value.NULL;
+        });
+
+        put("xp",(e, a)->{
+            if(e instanceof PlayerEntity) return new NumericValue(((PlayerEntity) e).totalExperience);
+            return Value.NULL;
+        });
+
+        put("xp_level", (e, a)->{
+            if(e instanceof PlayerEntity) return new NumericValue(((PlayerEntity) e).experienceLevel);
+            return Value.NULL;
+        });
+
+        put("xp_progress", (e, a)->{
+            if(e instanceof PlayerEntity) return new NumericValue(((PlayerEntity) e).experienceProgress);
+            return Value.NULL;
+        });
+
+        put("score", (e, a)->{
+            if(e instanceof PlayerEntity) return new NumericValue(((PlayerEntity) e).getScore());
+            return Value.NULL;
+        });
+
         put("jumping", (e, a) -> {
             if (e instanceof LivingEntity)
             {
@@ -1343,11 +1369,36 @@ public class EntityValue extends Value
             if(e instanceof PlayerEntity) ((PlayerEntity) e).getHungerManager().addExhaustion((int) NumericValue.asNumber(v).getLong());
         });
 
-        put("saturation", (e, v)-> {
-            if(e instanceof PlayerEntity) ((PlayerEntity) e).getHungerManager().setSaturationLevelClient((float)NumericValue.asNumber(v).getLong());
+        put("absorption", (e, v) -> {
+            if (e instanceof PlayerEntity) ((PlayerEntity) e).setAbsorptionAmount((float) NumericValue.asNumber(v, "absorbtion").getLong());
         });
 
-        put("air", (e, v) -> e.setAir(NumericValue.asNumber(v).getInt()));
+        put("add_xp", (e, v) -> {
+            if (e instanceof PlayerEntity) ((PlayerEntity) e).addExperience(NumericValue.asNumber(v, "add_xp").getInt());
+        });
+
+        put("xp_level", (e, v) -> {
+            if (e instanceof PlayerEntity) ((PlayerEntity) e).addExperienceLevels(NumericValue.asNumber(v, "xp_level").getInt()-((PlayerEntity) e).experienceLevel);
+        });
+
+        put("xp_progress", (e, v) -> {
+            if (e instanceof ServerPlayerEntity)
+            {
+                ServerPlayerEntity p = (ServerPlayerEntity) e;
+                p.experienceProgress = NumericValue.asNumber(v, "xp_progress").getFloat();
+                p.networkHandler.sendPacket(new ExperienceBarUpdateS2CPacket(p.experienceProgress, p.totalExperience, p.experienceLevel));
+            }
+        });
+
+        put("xp_score", (e, v) -> {
+            if (e instanceof PlayerEntity) ((PlayerEntity) e).setScore(NumericValue.asNumber(v, "xp_score").getInt());
+        });
+
+        put("saturation", (e, v)-> {
+            if(e instanceof PlayerEntity) ((HungerManagerInterface) ((PlayerEntity) e).getHungerManager()).setSaturationCM(NumericValue.asNumber(v, "saturation").getFloat());
+        });
+
+        put("air", (e, v) -> e.setAir(NumericValue.asNumber(v, "air").getInt()));
 
         put("breaking_progress", (e, a) -> {
             if (e instanceof ServerPlayerEntity)