build in script load from resources, added 2 more events, added event test

src/main/java/carpet/mixins/ServerPlayNetworkHandler_scarpetEventsMixin.java

@@ -22,6 +22,8 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import static carpet.script.CarpetEventServer.Event.PLAYER_ATTACKS_ENTITY;
 import static carpet.script.CarpetEventServer.Event.PLAYER_CLICKS_BLOCK;
 import static carpet.script.CarpetEventServer.Event.PLAYER_DEPLOYS_ELYTRA;
+import static carpet.script.CarpetEventServer.Event.PLAYER_DROPS_ITEM;
+import static carpet.script.CarpetEventServer.Event.PLAYER_DROPS_STACK;
 import static carpet.script.CarpetEventServer.Event.PLAYER_INERACTSW_WITH_ENTITY;
 import static carpet.script.CarpetEventServer.Event.PLAYER_RELEASED_ITEM;
 import static carpet.script.CarpetEventServer.Event.PLAYER_RIDES;
@@ -49,6 +51,30 @@ public class ServerPlayNetworkHandler_scarpetEventsMixin
         }
     }
 
+    @Inject(method = "onPlayerAction", at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/server/network/ServerPlayerEntity;dropSelectedItem(Z)Lnet/minecraft/entity/ItemEntity;",
+            ordinal = 0,
+            shift = At.Shift.BEFORE
+    ))
+    private void onQItem(PlayerActionC2SPacket playerActionC2SPacket_1, CallbackInfo ci)
+    {
+        PLAYER_DROPS_ITEM.onPlayerEvent(player);
+    }
+
+    @Inject(method = "onPlayerAction", at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/server/network/ServerPlayerEntity;dropSelectedItem(Z)Lnet/minecraft/entity/ItemEntity;",
+            ordinal = 1,
+            shift = At.Shift.BEFORE
+    ))
+    private void onCtrlQItem(PlayerActionC2SPacket playerActionC2SPacket_1, CallbackInfo ci)
+    {
+        PLAYER_DROPS_STACK.onPlayerEvent(player);
+    }
+
+
+
     @Inject(method = "onPlayerMove", at = @At(
             value = "INVOKE",
             target = "Lnet/minecraft/server/network/ServerPlayerEntity;jump()V"

src/main/java/carpet/script/CarpetEventServer.java

@@ -301,7 +301,7 @@ public class CarpetEventServer
             @Override
             public void onPlayerEvent(ServerPlayerEntity player)
             {
-                handler.call( () -> Arrays.asList(((c, t) -> new EntityValue(player))), player::getCommandSource);
+                handler.call( () -> Collections.singletonList(((c, t) -> new EntityValue(player))), player::getCommandSource);
             }
         },
         PLAYER_STOPS_SNEAKING("player_stops_sneaking",new CallbackList(1))
@@ -309,7 +309,7 @@ public class CarpetEventServer
             @Override
             public void onPlayerEvent(ServerPlayerEntity player)
             {
-                handler.call( () -> Arrays.asList(((c, t) -> new EntityValue(player))), player::getCommandSource);
+                handler.call( () -> Collections.singletonList(((c, t) -> new EntityValue(player))), player::getCommandSource);
             }
         },
         PLAYER_STARTS_SPRINTING("player_starts_sprinting",new CallbackList(1))
@@ -317,7 +317,7 @@ public class CarpetEventServer
             @Override
             public void onPlayerEvent(ServerPlayerEntity player)
             {
-                handler.call( () -> Arrays.asList(((c, t) -> new EntityValue(player))), player::getCommandSource);
+                handler.call( () -> Collections.singletonList(((c, t) -> new EntityValue(player))), player::getCommandSource);
             }
         },
         PLAYER_STOPS_SPRINTING("player_stops_sprinting",new CallbackList(1))
@@ -325,7 +325,7 @@ public class CarpetEventServer
             @Override
             public void onPlayerEvent(ServerPlayerEntity player)
             {
-                handler.call( () -> Arrays.asList(((c, t) -> new EntityValue(player))), player::getCommandSource);
+                handler.call( () -> Collections.singletonList(((c, t) -> new EntityValue(player))), player::getCommandSource);
             }
         },
 
@@ -360,7 +360,24 @@ public class CarpetEventServer
                     );
                 }, player::getCommandSource);
             }
+        },
+        PLAYER_DROPS_ITEM("player_drops_item", new CallbackList(1))
+        {
+            @Override
+            public void onPlayerEvent(ServerPlayerEntity player)
+            {
+                handler.call( () -> Collections.singletonList(((c, t) -> new EntityValue(player))), player::getCommandSource);
+            }
+        },
+        PLAYER_DROPS_STACK("player_drops_stack", new CallbackList(1))
+        {
+            @Override
+            public void onPlayerEvent(ServerPlayerEntity player)
+            {
+                handler.call( () -> Collections.singletonList(((c, t) -> new EntityValue(player))), player::getCommandSource);
+            }
         };
+
         // on projectile thrown (arrow from bows, crossbows, tridents, snoballs, e-pearls
 
         public String name;

src/main/java/carpet/script/CarpetExpression.java

@@ -31,6 +31,7 @@ import net.minecraft.block.CommandBlock;
 import net.minecraft.block.JigsawBlock;
 import net.minecraft.block.StructureBlock;
 import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.client.network.packet.GuiSlotUpdateS2CPacket;
 import net.minecraft.client.network.packet.PlaySoundIdS2CPacket;
 import net.minecraft.command.arguments.ItemStackArgument;
 import net.minecraft.command.arguments.ParticleArgumentType;
@@ -1051,6 +1052,13 @@ public class CarpetExpression
      *     stack_limit('ender_pearl') => 16
      *     stack_limit('stone') => 64
      * </pre>
+     * <h3><code>item_category(item)</code></h3>
+     * <p>Returns the string representing the category of a given item, like `building_blocks`, `combat`, or `tools`.</p>
+     * <pre>
+     *     item_category('wooden_axe') =&gt; tools
+     *     item_category('ender_pearl') =&gt; misc
+     *     item_category('stone') =&gt; building_blocks
+     * </pre>
      * <h3><code>inventory_size(inventory)</code></h3>
      * <p>Returns the size of the inventory for the entity or block in question. Returns null if the block or entity
      * don't have an inventory</p>
@@ -1120,6 +1128,13 @@ public class CarpetExpression
             return (_c, _t) -> res;
         });
 
+        this.expr.addLazyFunction("item_category", 1, (c, t, lv) ->
+        {
+            ItemStackArgument item = NBTSerializableValue.parseItem(lv.get(0).evalValue(c).getString());
+            Value res = new StringValue(item.getItem().getGroup().getName());
+            return (_c, _t) -> res;
+        });
+
         this.expr.addLazyFunction("inventory_size", -1, (c, t, lv) ->
         {
             CarpetContext cc = (CarpetContext) c;
@@ -1173,6 +1188,7 @@ public class CarpetExpression
             {
                 // clear slot
                 ItemStack removedStack = inventoryLocator.inventory.removeInvStack(slot);
+                syncPlayerInventory(inventoryLocator, slot);
                 //Value res = ListValue.fromItemStack(removedStack); // that tuple will be read only but cheaper if noone cares
                 return (_c, _t) -> ListValue.fromItemStack(removedStack);
             }
@@ -1182,6 +1198,7 @@ public class CarpetExpression
                 ItemStack newStack = previousStack.copy();
                 newStack.setCount(count);
                 inventoryLocator.inventory.setInvStack(slot, newStack);
+                syncPlayerInventory(inventoryLocator, slot);
                 return (_c, _t) -> ListValue.fromItemStack(previousStack);
             }
             CompoundTag nbt = null; // skipping one argument
@@ -1204,6 +1221,7 @@ public class CarpetExpression
             try
             {
                 inventoryLocator.inventory.setInvStack(slot, newitem.createStack(count, false));
+                syncPlayerInventory(inventoryLocator, slot);
             }
             catch (CommandSyntaxException e)
             {
@@ -1279,11 +1297,13 @@ public class CarpetExpression
                 {
                     stack.setCount(left);
                     inventoryLocator.inventory.setInvStack(i, stack);
+                    syncPlayerInventory(inventoryLocator, i);
                     return (_c, _t) -> Value.TRUE;
                 }
                 else
                 {
                     inventoryLocator.inventory.removeInvStack(i);
+                    syncPlayerInventory(inventoryLocator, i);
                     amount -= stack.getCount();
                 }
             }
@@ -1344,11 +1364,22 @@ public class CarpetExpression
                 item.setToDefaultPickupDelay();
                 cc.s.getWorld().spawnEntity(item);
             }
-            inventoryLocator.inventory.markDirty();
             Value res = new NumericValue(item.getStack().getCount());
             return (_c, _t) -> res;
         });
     }
+    private void syncPlayerInventory(NBTSerializableValue.InventoryLocator inventory, int int_1)
+    {
+        if (inventory.owner instanceof ServerPlayerEntity)
+        {
+            ServerPlayerEntity player = (ServerPlayerEntity) inventory.owner;
+            player.networkHandler.sendPacket(new GuiSlotUpdateS2CPacket(
+                    -2,
+                    int_1,
+                    inventory.inventory.getInvStack(int_1)
+            ));
+        }
+    }
 
 
     /**
@@ -3105,6 +3136,8 @@ public class CarpetExpression
      * __on_player_stops_sneaking(player)
      * __on_player_starts_sprinting(player)
      * __on_player_stops_sprinting(player)
+     * __on_player_drops_item(player)
+     * __on_player_drops_stack(player)
      * </pre>
      * <h3><code>/script event</code> command</h3>
      * <p>used to display current events and bounded functions. use <code>add_to</code> ro register new event, or <code>remove_from</code>

src/main/java/carpet/script/CarpetScriptServer.java

@@ -1,8 +1,8 @@
 package carpet.script;
 
+import carpet.script.bundled.BundledModule;
 import carpet.settings.CarpetSettings;
 import carpet.CarpetServer;
-import carpet.script.bundled.CameraPathModule;
 import carpet.script.bundled.FileModule;
 import carpet.script.bundled.ModuleInterface;
 import carpet.script.exception.CarpetExpressionException;
@@ -40,7 +40,8 @@ public class CarpetScriptServer
     public CarpetEventServer events;
 
     public static List<ModuleInterface> bundledModuleData = new ArrayList<ModuleInterface>(){{
-        add(new CameraPathModule());
+        add(new BundledModule("camera"));
+        add(new BundledModule("event_test"));
     }};
 
     public CarpetScriptServer()

src/main/java/carpet/script/bundled/BundledModule.java

@@ -0,0 +1,39 @@
+package carpet.script.bundled;
+
+import org.apache.commons.io.IOUtils;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+public class BundledModule implements ModuleInterface
+{
+    private String name;
+    private String code;
+    public BundledModule(String scriptName)
+    {
+        try
+        {
+            name = scriptName;
+            code = IOUtils.toString(
+                    getClass().getClassLoader().getResourceAsStream("assets/carpet/scripts/"+scriptName+".sc"),
+                    StandardCharsets.UTF_8
+            );
+        }
+        catch ( NullPointerException | IOException e)
+        {
+            name = null;
+            code = null;
+        }
+    }
+    @Override
+    public String getName()
+    {
+        return name;
+    }
+
+    @Override
+    public String getCode()
+    {
+        return code;
+    }
+}

src/main/java/carpet/script/bundled/CameraPathModule.java

@@ -1,334 +0,0 @@
-package carpet.script.bundled;
-
-public class CameraPathModule implements ModuleInterface
-{
-    @Override
-    public String getName()
-    {
-        return "camera";
-    }
-
-    @Override
-    public String getCode()
-    {
-        return  " __command() ->\n" +
-                " (\n" +
-                "   print('Camera path module.');\n" +
-                "   print('-------------------');\n" +
-                "   print(' \"/camera start\" - set the starting point');\n" +
-                "   print('');\n" +
-                "   print(' \"/camera add <N>\" - add another point <N> frames later');\n" +
-                "   print('');\n" +
-                "   print(' \"/camera select_interpolation < linear | gauss_? >\"');\n" +
-                "   print('    Select interpolation between points:');\n" +
-                "   print('    - linear: straight paths between points.');\n" +
-                "   print('    - gauss_auto: automatic smooth transitions.');\n" +
-                "   print('    - gauss_<number>: custom fixed variance ');\n" +
-                "   print('            (in points) for special effects.');\n" +
-                "   print('');\n" +
-                "   print(' \"/camera repeat <N> <last_delay>\" - ');\n" +
-                "   print('    Repeat existing points configuration n-times');\n" +
-                "   print('      using <last_delay> points to link path ends');\n" +
-                "   print('');\n" +
-                "   print(' \"/camera speed <factor> - ');\n" +
-                "   print('    Change number of frames between points');\n" +
-                "   print('      from 25 -> 4 times faster (less points),');\n" +
-                "   print('      to 400 -> 4 times slower (more points)');\n" +
-                "   print('');\n" +
-                "   print(' \"/camera play <fps>: run a path with a player');\n" +
-                "   print('    <fps> needs to be multiples of 20, (20 tps)');\n" +
-                "   print('');\n" +
-                "   print(' \"/camera show\": shows current path for a moment');\n" +
-                "   print('');\n" +
-                "   print(' \"/script in camera invoke _show_path_tick <particle> <ppt>\":');\n" +
-                "   print('    place this in a repeating commandblock');\n" +
-                "   print('      to display path continuously');\n" +
-                "   print('      with set particle and number of particles per tick');\n" +
-                "   print('      example: \\'dust 0.9 0.1 0.1 1\\' 100 ');\n" +
-                "   ''\n" +
-                " );\n" +
-                " start() -> \n" +
-                "(\n" +
-                "   p = player();\n" +
-                "   global_points = l(l(l(p~'x',p~'y',p~'z',p~'yaw',p~'pitch'),0,'sharp'));\n" +
-                "   undef('global_path_precalculated');\n" +
-                "   str('Started path at %.1f %.1f %.1f', p~'x', p~'y', p~'z')\n" +
-                ");\n" +
-                "\n" +
-                " add(delay) -> \n" +
-                "( \n" +
-                "   p = player(); \n" +
-                "   mode = 'sharp';\n" +
-                "   'mode is currently unused, run_path does always sharp, gauss interpolator is always smooth';\n" +
-                "   ' but this option could be used could be used at some point by more robust interpolators';\n" +
-                "   vector = l(p~'x',p~'y',p~'z', p~'yaw', p~'pitch');\n" +
-                "   __add_path_segment(vector, delay, mode);\n" +
-                "   str('Added point %d: %.1f %.1f %.1f', length(global_points), p~'x', p~'y', p~'z')\n" +
-                ");\n" +
-                "\n" +
-                " __add_path_segment(vector, duration, mode) -> \n" +
-                "(\n" +
-                "   undef('global_path_precalculated');\n" +
-                "   if ( (l('sharp','smooth') ~ mode) == null, exit('use smooth or sharp point'));  \n" +
-                "   if(!global_points, exit('Cannot add point to path that didn\\'t started yet!'));\n" +
-                "   l(v, end_time, m) = element(global_points, -1);\n" +
-                "   put(vector,-2, __adjusted_rot(element(v, -2), element(vector, -2)));\n" +
-                "   global_points += l(vector, end_time+duration, mode)\n" +
-                ");\n" +
-                "\n" +
-                "'adjusts current rotation so we don\\'t spin around like crazy';\n" +
-                " __adjusted_rot(previous_rot, current_rot) -> \n" +
-                "(\n" +
-                "   while( abs(previous_rot-current_rot) > 180, 1000,\n" +
-                "       current_rot += if(previous_rot < current_rot, -360, 360)\n" +
-                "   );\n" +
-                "   current_rot\n" +
-                ");\n" +
-                "\n" +
-                "\n" +
-                " repeat(times, last_section_duration) -> \n" +
-                "(\n" +
-                "   undef('global_path_precalculated');\n" +
-                "   positions = map(global_points, k = element(_, 0));\n" +
-                "   modes = map(global_points, element(_, -1));\n" +
-                "   durations = map(global_points, element(element(global_points, _i+1), 1)-element(_, 1));\n" +
-                "   put(durations, -1, last_section_duration);\n" +
-                "   loop(times,\n" +
-                "       loop( length(positions),\n" +
-                "           __add_path_segment(element(positions, _), element(durations, _), element(modes, _))\n" +
-                "       )\n" +
-                "   );\n" +
-                "   str('Add %d points %d times', length(positions), times)\n" +
-                ");\n" +
-                "\n" +
-                " speed(percentage) ->\n" +
-                "(\n" +
-                "   undef('global_path_precalculated');\n" +
-                "   if (percentage < 25 || percentage > 400, \n" +
-                "       exit('path speed can only be speed, or slowed down 4 times. Recall command for larger changes')\n" +
-                "   );\n" +
-                "   ratio = percentage/100;\n" +
-                "   previous_path_length = element(element(global_points, -1),1);\n" +
-                "   for(global_points, put(_, 1, element(_, 1)*ratio ) );\n" +
-                "   undef('global_path_precalculated');\n" +
-                "   str('path %s from %d to %d ticks',\n" +
-                "       if(ratio<1,'shortened','extended'),\n" +
-                "       previous_path_length,\n" +
-                "       element(element(global_points, -1),1)\n" +
-                "   )\n" +
-                ");\n" +
-                "\n" +
-                " select_interpolation(method) ->\n" +
-                "(\n" +
-                "   undef('global_path_precalculated');\n" +
-                "   __prepare_path_if_needed() -> __prepare_path_if_needed_generic();\n" +
-                "   'each supported method needs to specify its __find_position_for_point to trace the path';\n" +
-                "   'accepting segment number, and position in the segment';\n" +
-                "   'or optionally __prepare_path_if_needed, if path is inefficient to compute point by point';\n" +
-                "   if (\n" +
-                "       method == 'linear',\n" +
-                "       (\n" +
-                "           __find_position_for_point(s, p) -> __find_position_for_linear(s, p)\n" +
-                "       ),\n" +
-                "       method ~ '^gauss_',\n" +
-                "       (\n" +
-                "           type = method - 'gauss_';\n" +
-                "           global_interpol_option = if(type=='auto',0,number(type));\n" +
-                "           __find_position_for_point(s, p) -> __find_position_for_gauss(s, p)\n" +
-                "       ),\n" +
-                "       method ~ '^bungee_',\n" +
-                "       (\n" +
-                "           exit('unsupported / planned');\n" +
-                "           type = method - 'bungee_';\n" +
-                "           global_interpol_option = if(type=='auto',80,number(type));\n" +
-                "           __prepare_path_if_needed() -> __prepare_path_if_needed_bungee()\n" +
-                "       ),\n" +
-                "       \n" +
-                "       exit('Choose one of the following methods: linear, gauss:auto, gauss:<deviation>')\n" +
-                "   );\n" +
-                "   'Ok'\n" +
-                ");\n" +
-                "\n" +
-                " select_interpolation('linear');\n" +
-                "\n" +
-                " __assert_valid_for_motion() ->\n" +
-                "(\n" +
-                "   if(!global_points, exit('Path not defined yet'));\n" +
-                "   if(length(global_points)<2, exit('Path not complete - add more points'));\n" +
-                "   null    \n" +
-                ");\n" +
-                "\n" +
-                " __get_path_at(segment, start, index) ->\n" +
-                "(\n" +
-                "   v = element(global_path_precalculated, start+index);\n" +
-                "   if(v == null,\n" +
-                "       v = __find_position_for_point(segment, index);\n" +
-                "       put(global_path_precalculated, start+index, v)\n" +
-                "    );\n" +
-                "    v\n" +
-                ");\n" +
-                "\n" +
-                " __invalidate_points_cache() -> global_path_precalculated = map(range(element(element(global_points, -1),1)), null);\n" +
-                "\n" +
-                " show() -> \n" +
-                "(\n" +
-                "   loop(100,\n" +
-                "       _show_path_tick('dust 0.9 0.1 0.1 1', 100);\n" +
-                "       game_tick(50)\n" +
-                "   );\n" +
-                "   'Done!'\n" +
-                ");\n" +
-                "\n" +
-                " __play(fps) -> \n" +
-                "(\n" +
-                "   p = player();\n" +
-                "   __assert_valid_for_motion();\n" +
-                "   __prepare_path_if_needed();\n" +
-                "   loop( length(global_points)-1,\n" +
-                "       segment = _;\n" +
-                "       start = element(element(global_points, segment),1);\n" +
-                "       end = element(element(global_points, segment+1),1);\n" +
-                "       loop(end-start,\n" +
-                "           v = __get_path_at(segment, start, _);\n" +
-                "           modify(p, 'location', v);\n" +
-                "           game_tick(1000/fps)\n" +
-                "       )\n" +
-                "   );\n" +
-                "   game_tick(1000);\n" +
-                "   'Done!'\n" +
-                ");\n" +
-                "\n" +
-                " play(fps) -> \n" +
-                "(\n" +
-                "   p = player();\n" +
-                "   __assert_valid_for_motion();\n" +
-                "   __prepare_path_if_needed();\n" +
-                "   if ((fps % 20 != 0) || fps < 20, exit('FPS needs to be multiples of 20') );\n" +
-                "\ttpt = round(fps / 20);\n" +
-                "   mspt = 50 / tpt; \n" +
-                "   start_time = time();\n" +
-                "   point = 0;\n" +
-                "   loop( length(global_points)-1,\n" +
-                "       segment = _;\n" +
-                "       start = element(element(global_points, segment),1);\n" +
-                "       end = element(element(global_points, segment+1),1);\n" +
-                "       loop(end-start,\n" +
-                "           v = __get_path_at(segment, start, _);\n" +
-                "           modify(p, 'location', v);\n" +
-                "           point += 1;\n" +
-                "           if ((point % tpt == 0), game_tick());\n" +
-                "           end_time = time();\n" +
-                "           took = end_time - start_time;\n" +
-                "           if (took < mspt, sleep(mspt-took));\n" +
-                "           start_time = time()\n" +
-                "       )\n" +
-                "   );\n" +
-                "   game_tick(1000);\n" +
-                "   'Done!'\n" +
-                ");\n" +
-                "\n" +
-                " _show_path_tick(particle_type, total) -> (\n" +
-                "   __assert_valid_for_motion();\n" +
-                "   __prepare_path_if_needed();\n" +
-                "   loop(total,\n" +
-                "       segment = floor(rand(length(global_points)-1));\n" +
-                "       start = element(element(global_points, segment),1);\n" +
-                "       end = element(element(global_points, segment+1),1);\n" +
-                "       index = floor(rand(end-start));\n" +
-                "       l(x, y, z) = slice(__get_path_at(segment, start, index), 0, 3);\n" +
-                "       particle(particle_type, x, y, z, 1, 0, 0)\n" +
-                "   );\n" +
-                "   null\n" +
-                ");\n" +
-                "\n" +
-                " __prepare_path_if_needed_generic() ->\n" +
-                "(\n" +
-                "   if(!global_path_precalculated, __invalidate_points_cache())\n" +
-                ");\n" +
-                "\n" +
-                "__find_position_for_linear(segment, point) ->\n" +
-                "(\n" +
-                "   l(va, start, mode_a) = element(global_points,segment);\n" +
-                "   l(vb, end, mode_b)   = element(global_points,segment+1);\n" +
-                "   section = end-start;\n" +
-                "   dt = point/section;\n" +
-                "   dt*vb+(1-dt)*va\n" +
-                ");\n" +
-                "\n" +
-                "\n" +
-                "'(1/sqrt(2*pi*d*d))*euler^(-((x-miu)^2)/(2*d*d)) ';\n" +
-                " 'but we will be normalizing anyways, so who cares';\n" +
-                " __norm_prob(x, miu, d) -> euler^(-((x-miu)^2)/(2*d*d));\n" +
-                "\n" +
-                " __find_position_for_gauss(from_index, point) -> \n" +
-                "(\n" +
-                "   dev = global_interpol_option;\n" +
-                "   components = l();\n" +
-                "   path_point = element(element(global_points, from_index),1);\n" +
-                "   \n" +
-                "   try(\n" +
-                "       for(range(from_index+1, length(global_points)),\n" +
-                "           l(v,ptime,mode) = element(global_points, _);\n" +
-                "           dev = if (global_interpol_option > 0, global_interpol_option, \n" +
-                "               devs = l();\n" +
-                "               if (_+1 < length(global_points), devs += element(element(global_points, _+1),1)-ptime);\n" +
-                "               if (_-1 >= 0, devs += ptime-element(element(global_points, _-1),1));\n" +
-                "               0.6*reduce(devs, _a+_, 0)/length(devs)\n" +
-                "           );\n" +
-                "           impact = __norm_prob(path_point+point, ptime, dev);\n" +
-                "           if(rtotal && impact < 0.000001*rtotal, throw(null));\n" +
-                "           components += l(v, impact);\n" +
-                "           rtotal += impact\n" +
-                "       )\n" +
-                "       ,null\n" +
-                "   );\n" +
-                "   try(\n" +
-                "       for(range(from_index, -1, -1),\n" +
-                "           l(v,ptime,mode) = element(global_points, _);\n" +
-                "           dev = if (global_interpol_option > 0, global_interpol_option, \n" +
-                "               devs = l();\n" +
-                "               if (_+1 < length(global_points), devs += element(element(global_points, _+1),1)-ptime);\n" +
-                "               if (_-1 >= 0, devs += ptime-element(element(global_points, _-1),1));\n" +
-                "               0.6*reduce(devs, _a+_, 0)/length(devs)\n" +
-                "           );\n" +
-                "           impact = __norm_prob(path_point+point, ptime, dev);\n" +
-                "           if(ltotal && impact < 0.000001*ltotal, throw(null));\n" +
-                "           components += l(v, impact);\n" +
-                "           ltotal += impact\n" +
-                "       )\n" +
-                "       ,null\n" +
-                "   );\n" +
-                "   total = rtotal+ltotal;\n" +
-                "   reduce(components, _a+element(_,0)*(element(_,1)/total), l(0,0,0,0,0))\n" +
-                ");\n" +
-                " __prepare_path_if_needed_bungee(fps) ->\n" +
-                "(\n" +
-                "   exit('not ready!');\n" +
-                "   if(!global_points, exit('Cannot show path that doesn\\'t exist'));\n" +
-                "   if(length(global_points)<2, exit('Path not complete - add more points'));\n" +
-                "   v = element(element(global_points, 0),0);\n" +
-                "   modify(p, 'pos', slice(v,0,3));\n" +
-                "   modify(p, 'yaw', element(v,3));\n" +
-                "   modify(p, 'pitch', element(v,4));\n" +
-                "   current_target = element(element(global_points, 1),0);\n" +
-                "   current_hook = 1;\n" +
-                "   loop(length(global_points)-1, \n" +
-                "       current_base = _;\n" +
-                "       l(va, start, mode_a) = element(global_points,_);\n" +
-                "       l(vb, end, mode_b)   = element(global_points,_+1);\n" +
-                "       section = end-start;\n" +
-                "       loop(section,\n" +
-                "           dt = _/section;\n" +
-                "\n" +
-                "           v = dt*vb+(1-dt)*va;\n" +
-                "           modify(p, 'pos', slice(v,0,3));\n" +
-                "           modify(p, 'yaw', element(v,3));\n" +
-                "           modify(p, 'pitch', element(v,4));\n" +
-                "           game_tick(1000/fps)\n" +
-                "       )\n" +
-                "   );\n" +
-                "   game_tick(1000);\n" +
-                "   'Done!'\n" +
-                ")\n";
-    }
-}

src/main/resources/assets/carpet/scripts/camera.sc

@@ -0,0 +1,248 @@
+__command() ->
+(
+   print('camera_path module.');
+   print('-------------------');
+   print(' "/camera_path start" - set the starting point');
+   print('');
+   print(' "/camera_path add <N>" - add another point <N> frames later');
+   print('');
+   print(' "/camera_path select_interpolation < linear | gauss_? >"');
+   print('    Select interpolation between points:');
+   print('    - linear: straight paths between points.');
+   print('    - gauss_auto: automatic smooth transitions.');
+   print('    - gauss_<number>: custom fixed variance ');
+   print('            (in points) for special effects.');
+   print('');
+   print(' "/camera_path repeat <N> <last_delay>" - ');
+   print('    Repeat existing points configuration n-times');
+   print('      using <last_delay> points to link path ends');
+   print('');
+   print(' "/camera_path speed <factor> - ');
+   print('    Change number of frames between points');
+   print('      from 25 -> 4 times faster (less points),');
+   print('      to 400 -> 4 times slower (more points)');
+   print('');
+   print(' "/camera_path play <fps>: run a path with a player');
+   print('    <fps> needs to be multiples of 20, (20 tps)');
+   print('');
+   print(' "/camera_path show": shows current path for a moment');
+   print('');
+   print(' "/script in camera_path invoke _show_path_tick <particle> <ppt>":');
+   print('    place this in a repeating commandblock');
+   print('      to display path continuously');
+   print('      with set particle and number of particles per tick');
+   print('      example: \'dust 0.9 0.1 0.1 1\' 100 ');
+   ''
+);
+
+start() ->
+(
+   p = player();
+   global_points = l(l(p ~ 'location', 0,'sharp'));
+   undef('global_path_precalculated');
+   str('Started path at %.1f %.1f %.1f', p~'x', p~'y', p~'z')
+);
+add(delay) ->
+(
+   p = player();
+   mode = 'sharp';
+   //mode is currently unused, run_path does always sharp, gauss interpolator is always smooth
+   // but this option could be used could be used at some point by more robust interpolators
+   __add_path_segment(p ~ 'location', delay, mode);
+   str('Added point %d: %.1f %.1f %.1f', length(global_points), p~'x', p~'y', p~'z')
+);
+__add_path_segment(vector, duration, mode) ->
+(
+   undef('global_path_precalculated');
+   if ( (l('sharp','smooth') ~ mode) == null, exit('use smooth or sharp point'));
+   if(!global_points, exit('Cannot add point to path that didn\'t started yet!'));
+   l(v, end_time, m) = get(global_points, -1);
+   put(vector,-2, __adjusted_rot(get(v, -2), get(vector, -2)));
+   global_points += l(vector, end_time+duration, mode)
+);
+// adjusts current rotation so we don\'t spin around like crazy
+__adjusted_rot(previous_rot, current_rot) ->
+(
+   while( abs(previous_rot-current_rot) > 180, 1000,
+       current_rot += if(previous_rot < current_rot, -360, 360)
+   );
+   current_rot
+);
+
+
+repeat(times, last_section_duration) ->
+(
+   undef('global_path_precalculated');
+   positions = map(global_points, k = get(_, 0));
+   modes = map(global_points, get(_, -1));
+   durations = map(global_points, get(get(global_points, _i+1), 1)-get(_, 1));
+   put(durations, -1, last_section_duration);
+   loop(times,
+       loop( length(positions),
+           __add_path_segment(get(positions, _), get(durations, _), get(modes, _))
+       )
+   );
+   str('Add %d points %d times', length(positions), times)
+);
+speed(percentage) ->
+(
+   undef('global_path_precalculated');
+   if (percentage < 25 || percentage > 400,
+       exit('path speed can only be speed, or slowed down 4 times. Recall command for larger changes')
+   );
+   ratio = percentage/100;
+   previous_path_length = get(get(global_points, -1),1);
+   for(global_points, put(_, 1, get(_, 1)*ratio ) );
+   undef('global_path_precalculated');
+   str('path %s from %d to %d ticks',
+       if(ratio<1,'shortened','extended'),
+       previous_path_length,
+       get(get(global_points, -1),1)
+   )
+);
+select_interpolation(method) ->
+(
+   undef('global_path_precalculated');
+   __prepare_path_if_needed() -> __prepare_path_if_needed_generic();
+   // each supported method needs to specify its __find_position_for_point to trace the path
+   // accepting segment number, and position in the segment
+   // or optionally __prepare_path_if_needed, if path is inefficient to compute point by point
+   if (
+       method == 'linear',
+       (
+           __find_position_for_point(s, p) -> __find_position_for_linear(s, p)
+       ),
+       method ~ '^gauss_',
+       (
+           type = method - 'gauss_';
+           global_interpol_option = if(type=='auto',0,number(type));
+           __find_position_for_point(s, p) -> __find_position_for_gauss(s, p)
+       ),
+
+       exit('Choose one of the following methods: linear, gauss:auto, gauss:<deviation>')
+   );
+   'Ok'
+);
+select_interpolation('gauss_auto');
+__assert_valid_for_motion() ->
+(
+   if(!global_points, exit('Path not defined yet'));
+   if(length(global_points)<2, exit('Path not complete - add more points'));
+   null
+);
+__get_path_at(segment, start, index) ->
+(
+   v = get(global_path_precalculated, start+index);
+   if(v == null,
+       v = __find_position_for_point(segment, index);
+       put(global_path_precalculated, start+index, v)
+    );
+    v
+);
+__invalidate_points_cache() -> global_path_precalculated = map(range(get(get(global_points, -1),1)), null);
+show() ->
+(
+   loop(100,
+       _show_path_tick('dust 0.9 0.1 0.1 1', 100);
+       game_tick(50)
+   );
+   'Done!'
+);
+play(fps) ->
+(
+   p = player();
+   __assert_valid_for_motion();
+   __prepare_path_if_needed();
+   if ((fps % 20 != 0) || fps < 20, exit('FPS needs to be multiples of 20') );
+	tpt = round(fps / 20);
+   mspt = 50 / tpt;
+   start_time = time();
+   point = 0;
+   loop( length(global_points)-1,
+       segment = _;
+       start = get(get(global_points, segment),1);
+       end = get(get(global_points, segment+1),1);
+       loop(end-start,
+           v = __get_path_at(segment, start, _);
+           modify(p, 'location', v);
+           point += 1;
+           if ((point % tpt == 0), game_tick());
+           end_time = time();
+           took = end_time - start_time;
+           if (took < mspt, sleep(mspt-took));
+           start_time = time()
+       )
+   );
+   game_tick(1000);
+   'Done!'
+);
+_show_path_tick(particle_type, total) ->
+(
+   __assert_valid_for_motion();
+   __prepare_path_if_needed();
+   loop(total,
+       segment = floor(rand(length(global_points)-1));
+       start = get(get(global_points, segment),1);
+       end = get(get(global_points, segment+1),1);
+       index = floor(rand(end-start));
+       l(x, y, z) = slice(__get_path_at(segment, start, index), 0, 3);
+       particle(particle_type, x, y, z, 1, 0, 0)
+   );
+   null
+);
+__prepare_path_if_needed_generic() ->
+(
+   if(!global_path_precalculated, __invalidate_points_cache())
+);
+__find_position_for_linear(segment, point) ->
+(
+   l(va, start, mode_a) = get(global_points,segment);
+   l(vb, end, mode_b)   = get(global_points,segment+1);
+   section = end-start;
+   dt = point/section;
+   dt*vb+(1-dt)*va
+);
+//(1/sqrt(2*pi*d*d))*euler^(-((x-miu)^2)/(2*d*d))
+// but we will be normalizing anyways, so who cares
+__norm_prob(x, miu, d) -> euler^(-((x-miu)^2)/(2*d*d));
+__find_position_for_gauss(from_index, point) ->
+(
+   dev = global_interpol_option;
+   components = l();
+   path_point = get(get(global_points, from_index),1);
+
+   try(
+       for(range(from_index+1, length(global_points)),
+           l(v,ptime,mode) = get(global_points, _);
+           dev = if (global_interpol_option > 0, global_interpol_option,
+               devs = l();
+               if (_+1 < length(global_points), devs += get(get(global_points, _+1),1)-ptime);
+               if (_-1 >= 0, devs += ptime-get(get(global_points, _-1),1));
+               0.6*reduce(devs, _a+_, 0)/length(devs)
+           );
+           impact = __norm_prob(path_point+point, ptime, dev);
+           if(rtotal && impact < 0.000001*rtotal, throw(null));
+           components += l(v, impact);
+           rtotal += impact
+       )
+       ,null
+   );
+   try(
+       for(range(from_index, -1, -1),
+           l(v,ptime,mode) = get(global_points, _);
+           dev = if (global_interpol_option > 0, global_interpol_option,
+               devs = l();
+               if (_+1 < length(global_points), devs += get(get(global_points, _+1),1)-ptime);
+               if (_-1 >= 0, devs += ptime-get(get(global_points, _-1),1));
+               0.6*reduce(devs, _a+_, 0)/length(devs)
+           );
+           impact = __norm_prob(path_point+point, ptime, dev);
+           if(ltotal && impact < 0.000001*ltotal, throw(null));
+           components += l(v, impact);
+           ltotal += impact
+       )
+       ,null
+   );
+   total = rtotal+ltotal;
+   reduce(components, _a+get(_,0)*(get(_,1)/total), l(0,0,0,0,0))
+)

src/main/resources/assets/carpet/scripts/event_test.sc

@@ -0,0 +1,116 @@
+
+__on_player_jumps(player) -> print('Player '+player+' jumps.');
+
+__on_player_deploys_elytra(player) -> print('Player '+player+' deploys elytra.');
+
+__on_player_wakes_up(player) -> print('Player '+player+' wakes up. Lemme know when this starts working');
+
+__on_player_rides(player, forward, strafe, jumping, sneaking) ->
+(
+	print('');
+	print('player rides a vehicle:');
+	print('  - player: '+player);
+	print('  - forward/backward: '+forward);
+	print('  - strafing: '+strafe);
+	print('  - jumping: '+jumping);
+	print('  - sneaking: '+sneaking)
+);
+
+__on_player_uses_item(player, item_tuple, hand) ->
+(
+	l(item, count, nbt) = item_tuple || l('None', 0, null);
+	print('');
+	print('player uses an item:');
+	print('  - player: '+player);
+	print('  - item:');
+	print('    > name: '+item);
+	print('    > count: '+count);
+	print('    > nbt: '+nbt);
+	print('  - hand: '+hand)
+);
+
+__on_player_clicks_block(player, block, face) ->
+(
+	print('');
+	print('player clicks an item:');
+	print('  - player: '+player);
+	print('  - block: '+block+' at '+map(pos(block), str('%.2f',_)));
+	print('  - face: '+face)
+);
+
+
+__on_player_right_clicks_block(player, item_tuple, hand, block, face, hitvec) ->
+(
+	l(item, count, nbt) = item_tuple || l('None', 0, null);
+	print('');
+	print('block right clicked by player:');
+	print('  - player: '+player);
+	print('  - item: '+item);
+	print('  - hand: '+hand);
+	print('  - block: '+block+' at '+map(pos(block), str('%.2f',_)));
+	print('  - face: '+face);
+	print('  - hitvec: '+map(hitvec, str('%.2f',_)))
+);
+
+__on_player_breaks_block(player, block) ->
+(
+	print('');
+	print('player breaks block:');
+	print('  - player: '+player);
+	print('  - block: '+block+' at '+map(pos(block), str('%.2f',_)))
+);
+
+__on_player_interacts_with_entity(player, entity, hand) ->
+(
+	print('');
+	print('player interacts with entity:');
+	print('  - player: '+player);
+	print('  - entity: '+entity+' at '+map(pos(entity), str('%.2f',_)));
+	print('  - hand: '+hand)
+);
+
+__on_player_attacks_entity(player, entity) ->
+(
+	print('');
+	print('player attacks entity:');
+	print('  - player: '+player);
+	print('  - entity: '+entity+' at '+map(pos(entity), str('%.2f',_)))
+);
+
+__on_player_starts_sneaking(player) -> print('Player '+player+' starts sneaking.');
+
+__on_player_stops_sneaking(player) -> print('Player '+player+' stops sneaking.');
+
+__on_player_starts_sprinting(player) -> print('Player '+player+' starts sprinting.');
+
+__on_player_stops_sprinting(player) -> print('Player '+player+' stops sprinting.');
+
+__on_player_releases_item(player, item_tuple, hand) ->
+(
+	l(item, count, nbt) = item_tuple || l('None', 0, null);
+	print('');
+	print('player releases an item:');
+	print('  - player: '+player);
+	print('  - item:');
+	print('    > name: '+item);
+	print('    > count: '+count);
+	print('    > nbt: '+nbt);
+	print('  - hand: '+hand)
+);
+
+__on_player_finishes_using_item(player, item_tuple, hand) ->
+(
+	l(item, count, nbt) = item_tuple || l('None', 0, null);
+	print('');
+	print('player finishes using an item:');
+	print('  - player: '+player);
+	print('  - item:');
+	print('    > name: '+item);
+	print('    > count: '+count);
+	print('    > nbt: '+nbt);
+	print('  - hand: '+hand)
+);
+
+__on_player_drops_item(player) -> print('Player '+player+' drops current item.');
+
+__on_player_drops_stack(player) -> print('Player '+player+' drops current stack.');