feat: block execution actually works now

src/main/java/leap/s3me/App.java

···
 package leap.s3me;
 
-import gnu.classpath.java.util.zip.ZipInputStream;
-import java.io.ByteArrayInputStream;
-import gnu.classpath.java.util.zip.ZipEntry;
+import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
-import java.io.ByteArrayOutputStream;
+
 import javax.microedition.io.Connector;
 import javax.microedition.io.file.FileConnection;
+import javax.microedition.lcdui.Command;
+import javax.microedition.lcdui.CommandListener;
 import javax.microedition.lcdui.Display;
-import javax.microedition.lcdui.Form;
-import javax.microedition.lcdui.StringItem;
+import javax.microedition.lcdui.Displayable;
+import javax.microedition.lcdui.TextBox;
+import javax.microedition.lcdui.TextField;
 import javax.microedition.midlet.MIDlet;
 
 import cc.nnproject.json.JSON;
···
             byte[] buffer = null;
             if ((buffer = Unzip.extractFileToBytes("project.json")) != null) {
                 JSONObject obj = JSON.getObject(new String(buffer));
-                Interpret.executor.registerHandlers();
                 Interpret.loadSprites(obj);
                 System.out.println("Project width: " + String.valueOf(Scratch.projectWidth));
                 System.out.println("Project height: " + String.valueOf(Scratch.projectHeight));
                 System.out.println("Project FPS: " + String.valueOf(Scratch.FPS));
             }
             mainLoop.start();
+            App.display.setCurrent(App.render);
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
···
         synchronized (this) {
             Scratch.paused = true;
         }
+    }
+
+    public void showAskAndWaitInput() {
+        final TextBox inputField = new TextBox(Scratch.inputQuestion, "", -1, TextField.ANY);
+        Command okCommand = new Command("OK", Command.OK, 1);
+
+        inputField.addCommand(okCommand);
+        inputField.setCommandListener(new CommandListener() {
+            public void commandAction(Command c, Displayable d) {
+                synchronized(App.context) {
+                    Interpret.answer = inputField.getString();
+                    Scratch.awaitingUserInput = false;
+                    display.setCurrent(render);
+                    App.context.notifyAll();
+                }
+            }
+        });
+
+        display.setCurrent(inputField);
     }
 }

src/main/java/leap/s3me/Image.java

···
 package leap.s3me;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
 import java.util.Enumeration;
 import java.util.Hashtable;
 
-import gnu.classpath.java.util.zip.ZipInputStream;
 import leap.s3me.scratch.Costume;
 
 /**

src/main/java/leap/s3me/Interpret.java

···
 package leap.s3me;
 
-import java.util.Vector;
 import java.util.Enumeration;
 import java.util.Hashtable;
+import java.util.Vector;
 
-import cc.nnproject.json.AbstractJSON;
 import cc.nnproject.json.JSON;
 import cc.nnproject.json.JSONArray;
 import cc.nnproject.json.JSONObject;
···
 import leap.s3me.scratch.Monitor;
 import leap.s3me.scratch.ParsedField;
 import leap.s3me.scratch.ParsedInput;
-import leap.s3me.scratch.Sprite;
 import leap.s3me.scratch.Sound;
+import leap.s3me.scratch.Sprite;
 import leap.s3me.scratch.Value;
 import leap.s3me.scratch.Variable;
 
···
                 Block block = new Block();
                 block.id = id;
                 if (data.has("opcode")) {
-                    block.opcode = data.getString("opcode", "");
+                    block.opcode = data.getString("opcode");
                     if (block.opcode.equals("event_whenthisspriteclicked"))
                         sprite.shouldDoSpriteClick = true;
                 }
-                block.next = data.getString("next", null);
+                if (data.has("next") && !data.isNull("next")) {
+                    block.next = data.getString("next");
+                }
                 block.parent = data.getString("parent", "null");
                 if (data.has("fields")) {
                     JSONObject fields = data.getObject("fields");
···
                 block.topLevel = data.getBoolean("topLevel", false);
                 block.shadow = data.getBoolean("shadow", false);
                 if (data.has("mutation")) {
-                    if (data.getObject("mutation").has("proccode"))
-                        block.customBlockId = data.getObject("mutation").getString("proccode");
-                    else
-                        block.customBlockId = "";
+                    block.customBlockId = data.getObject("mutation").getString("proccode", "");
                 }
 
                 sprite.blocks.put(id, block);
···
     }
 
     public static Block findBlock(String blockID) {
-        if (blockLookup.contains(blockID))
+        if (blockLookup.containsKey(blockID))
             return (Block)blockLookup.get(blockID);
         return null;
     }
···
                 }
             }
 
-            currentBlock = findBlock(currentBlock.next);
+            if (currentBlock.next != null)
+                currentBlock = findBlock(currentBlock.next);
+            else
+                currentBlock = null;
         }
-                System.out.println(outID == null);
-                System.out.println(outID.toString() == null);
-                System.out.println(outID.toString().equals(""));
-                System.out.println(outID.toString().length() > 0);
-                System.out.println(outID.toString());
         return blockChain;
     }
 

src/main/java/leap/s3me/Render.java

···
 package leap.s3me;
 
-import java.io.IOException;
 import java.util.Hashtable;
 import java.util.Vector;
 
 import javax.microedition.lcdui.Canvas;
-import javax.microedition.lcdui.Font;
 import javax.microedition.lcdui.Graphics;
 import javax.microedition.lcdui.Image;
 import javax.microedition.lcdui.game.Sprite;
 
 import leap.s3me.scratch.BlockExecutor;
 import leap.s3me.scratch.Costume;
-import leap.s3me.scratch.Monitor;
 import leap.s3me.scratch.Input;
+import leap.s3me.scratch.Monitor;
 
 public class Render extends Canvas {
     public int windowWidth;
     public int windowHeight;
 
     public Vector visibleVariables;
-    private Hashtable images = new Hashtable();
+    public Hashtable images = new Hashtable();
     private Image penLayer;
 
     public Render() {
···
             currentSprite.rotationCenterX = (int)costume.rotationCenterX;
             currentSprite.rotationCenterY = (int)costume.rotationCenterY;
 
-            // First, get the base image to determine its original dimensions
             leap.s3me.Image baseImageWrapper = leap.s3me.Image.getImage(costume);
             if (baseImageWrapper != null && baseImageWrapper.image != null) {
                 int imgWidth = baseImageWrapper.image.getWidth();
···
                 sprite.setTransform(transform);
                 sprite.setPosition(renderX, renderY);
                 sprite.paint(g);
-
             } else {
                 g.setColor(0, 0, 0);
                 int x = (int)((currentSprite.xPosition * scale) + (windowWidth / 2));

src/main/java/leap/s3me/Scratch.java

···
     public static boolean miscellaneousLimits = true;
     public static boolean paused = false;
     public static boolean shouldStop = false;
+    public static boolean awaitingUserInput = false;
+    public static String inputQuestion = "";
 
     public static double counter = 0;
 
···
                     while (paused) {
                         App.context.wait();
                     }
+                    if (awaitingUserInput) {
+                        App.context.showAskAndWaitInput();
+                        App.context.wait();
+                    }
                 }
 
                 Input.update();
                 BlockExecutor.runRepeatBlocks();
                 BlockExecutor.runBroadcasts();
                 App.render.repaint();
-                App.display.setCurrent(App.render);
 
-                //Thread.sleep(1000 / FPS);
+                Thread.sleep(1000 / FPS);
             } catch (Exception e) {
                 e.printStackTrace();
             }

src/main/java/leap/s3me/scratch/BlockExecutor.java

···
 import leap.s3me.scratch.blocks.ControlBlocks;
 import leap.s3me.scratch.blocks.DataBlocks;
 import leap.s3me.scratch.blocks.OperatorBlocks;
+import leap.s3me.scratch.blocks.SensingBlocks;
 import leap.s3me.scratch.blocks.ProcedureBlocks;
 
 public class BlockExecutor {
···
         registerHandlers();
     }
 
-    public void registerHandlers() {
+    private void registerHandlers() {
         // motion
         handlers.put("motion_movesteps", new MotionBlocks.MoveSteps());
         handlers.put("motion_gotoxy", new MotionBlocks.GoToXY());
···
         valueHandlers.put("data_lengthoflist", new DataBlocks.LengthOfList());
         valueHandlers.put("data_listcontainsitem", new DataBlocks.ListContainsItem());
 
+        // sensing
+        handlers.put("sensing_resettimer", new SensingBlocks.ResetTimer());
+        handlers.put("sensing_askandwait", new SensingBlocks.AskAndWait());
+        handlers.put("sensing_setdragmode", new SensingBlocks.SetDragMode());
+        valueHandlers.put("sensing_timer", new SensingBlocks.SensingTimer());
+        valueHandlers.put("sensing_of", new SensingBlocks.Of());
+        valueHandlers.put("sensing_mousex", new SensingBlocks.MouseX());
+        valueHandlers.put("sensing_mousey", new SensingBlocks.MouseY());
+        valueHandlers.put("sensing_distanceto", new SensingBlocks.DistanceTo());
+        valueHandlers.put("sensing_dayssince2000", new SensingBlocks.DaysSince2000());
+        valueHandlers.put("sensing_current", new SensingBlocks.Current());
+        valueHandlers.put("sensing_answer", new SensingBlocks.SensingAnswer());
+        valueHandlers.put("sensing_keypressed", new SensingBlocks.KeyPressed());
+        valueHandlers.put("sensing_touchingobject", new SensingBlocks.TouchingObject());
+        valueHandlers.put("sensing_mousedown", new SensingBlocks.MouseDown());
+        valueHandlers.put("sensing_username", new SensingBlocks.Username());
+    
         // procedures / arguments
         handlers.put("procedures_call", new ProcedureBlocks.Call());
         handlers.put("procedures_definition", new ProcedureBlocks.Definition());
         valueHandlers.put("argument_reporter_string_number", new ProcedureBlocks.StringNumber());
         valueHandlers.put("argument_reporter_boolean", new ProcedureBlocks.BooleanArgument());
+
+        // Other (Don't know where else to put these)
+        valueHandlers.put("matrix", new ValueBlockHandler() {
+            public Value run(Block block, Sprite sprite) {
+                return new Value(Scratch.getFieldValue(block, "MATRIX"));
+            }
+        });
     }
 
     public Vector runBlock(Block block, Sprite sprite, boolean[] withoutScreenRefresh, boolean fromRepeat) {
···
 
     private int executeBlock(Block block, Sprite sprite, boolean[] withoutScreenRefresh, boolean fromRepeat) {
         BlockHandler handler = (BlockHandler)handlers.get(block.opcode);
-        System.out.println("Handler: " + block.opcode);
+        //System.out.println("Handler: " + block.opcode);
         if (handler != null) {
             return handler.run(block, sprite, withoutScreenRefresh, fromRepeat);
         }
···
     public Value getBlockValue(Block block, Sprite sprite) {
         if (block == null) return new Value();
         ValueBlockHandler handler = (ValueBlockHandler)valueHandlers.get(block.opcode);
-        System.out.println("Value handler: " + block.opcode);
+        //System.out.println("Value handler: " + block.opcode);
         if (handler != null) {
             return handler.run(block, sprite);
         }
···
     }
 
     public static Vector runAllBlocksByOpcode(String opcodeToFind) {
-        System.out.println("Running all " + opcodeToFind + " blocks");
+        //System.out.println("Running all " + opcodeToFind + " blocks");
         Vector blocksRun = new Vector();
         for (int i = 0; i < Interpret.sprites.size(); i++) {
             Sprite currentSprite = (Sprite)Interpret.sprites.elementAt(i);
···
     }
 
     public static boolean hasActiveRepeats(Sprite sprite, String blockChainID) {
-        if (sprite.blockChains.contains(blockChainID)) {
+        if (sprite.blockChains.containsKey(blockChainID)) {
             if (!((BlockChain)sprite.blockChains.get(blockChainID)).blocksToRepeat.isEmpty()) return true;
         }
         return false;

src/main/java/leap/s3me/scratch/Sprite.java

···
 import java.util.Hashtable;
 import java.util.Map;
 
+import leap.s3me.Image;
+
 public class Sprite {
     public String name;
     public String id;
···
     public Hashtable customBlocks = new Hashtable();
     public Hashtable blockChains = new Hashtable();
 
+    public Sprite() {}
+
+    public Sprite(Sprite other) {}
+
     public void clearAll() {
         variables.clear();
         blocks.clear();
···
 
     public void copyFrom(Sprite other) {
         this.name = other.name;
-        // Don't copy ID, clones get a new one
         this.isStage = other.isStage;
         this.draggable = other.draggable;
         this.visible = other.visible;
···
         this.brightnessEffect = other.brightnessEffect;
         this.colorEffect = other.colorEffect;
 
-        // Deep copy collections to avoid shared state issues
         this.variables = new Hashtable();
         for (java.util.Enumeration e = other.variables.keys(); e.hasMoreElements();) {
-            String key = (String) e.nextElement();
-            // This assumes Variable has a copy constructor or similar method
-            // For now, we'll just share them, but this can be risky for non-global vars
-            this.variables.put(key, other.variables.get(key));
+            String key = (String)e.nextElement();
+            Variable originalVar = (Variable)other.variables.get(key);
+            this.variables.put(key, new Variable(originalVar));
         }
 
         this.blocks = other.blocks;
···
         this.broadcasts = other.broadcasts;
         this.customBlocks = other.customBlocks;
         this.blockChains = other.blockChains;
+    }
+
+    public void loadCurrentCostume() {
+        if (costumes.isEmpty() || currentCostume >= costumes.size()) {
+            return;
+        }
+
+        Costume costume = (Costume)costumes.elementAt(currentCostume);
+        if (costume.id.equals(lastCostumeId)) {
+            return;
+        }
+
+        Image baseImageWrapper = Image.getImage(costume);
+        if (baseImageWrapper != null && baseImageWrapper.image != null) {
+            this.spriteWidth = baseImageWrapper.image.getWidth();
+            this.spriteHeight = baseImageWrapper.image.getHeight();
+            this.lastCostumeId = costume.id;
+        }
     }
 }

src/main/java/leap/s3me/scratch/Value.java

···
         this.value = val;
     }
 
+    /**
+     * Copy constructor for creating a deep copy of a Value object.
+     * This is crucial for cloning sprites to ensure variables are not shared.
+     * @param other The Value object to copy.
+     */
+    public Value(Value other) {
+        if (other.value == null) {
+            this.value = null;
+        } else if (other.isColor()) {
+            this.value = new Color(((Color)other.value).hue, ((Color)other.value).saturation, ((Color)other.value).brightness);
+        } else {
+            this.value = other.value; // Immutable types (String, Integer, etc.) can be assigned directly.
+        }
+    }
+
     public boolean isInteger() {
         return value instanceof Integer;
     }

src/main/java/leap/s3me/scratch/Variable.java

···
     public String id;
     public String name;
     public Value value;
+
+    public Variable() {}
+
+    /**
+     * Copy constructor for creating a deep copy of a Variable.
+     */
+    public Variable(Variable other) {
+        this.id = other.id;
+        this.name = other.name;
+        this.value = new Value(other.value); // Use Value's copy constructor
+    }
 }

src/main/java/leap/s3me/scratch/blocks/DataBlocks.java

···
 
             Sprite targetSprite = null;
 
-            if (sprite.lists.contains(listID)) {
+            if (sprite.lists.containsKey(listID)) {
                 targetSprite = sprite;
             } else {
                 for (int i = 0; i < Interpret.sprites.size(); i++) {
                     Sprite currentSprite = (Sprite)Interpret.sprites.elementAt(i);
-                    if (currentSprite.isStage && sprite.lists.contains(listID)) {
+                    if (currentSprite.isStage && sprite.lists.containsKey(listID)) {
                         targetSprite = currentSprite;
                         break;
                     }
···
 
             Sprite targetSprite = null;
 
-            if (sprite.lists.contains(listID)) {
+            if (sprite.lists.containsKey(listID)) {
                 targetSprite = sprite;
             } else {
                 for (int i = 0; i < Interpret.sprites.size(); i++) {
                     Sprite currentSprite = (Sprite)Interpret.sprites.elementAt(i);
-                    if (currentSprite.isStage && sprite.lists.contains(listID)) {
+                    if (currentSprite.isStage && sprite.lists.containsKey(listID)) {
                         targetSprite = currentSprite;
                         break;
                     }
···
 
             Sprite targetSprite = null;
 
-            if (sprite.lists.contains(listID)) {
+            if (sprite.lists.containsKey(listID)) {
                 targetSprite = sprite;
             } else {
                 for (int i = 0; i < Interpret.sprites.size(); i++) {
                     Sprite currentSprite = (Sprite)Interpret.sprites.elementAt(i);
-                    if (currentSprite.isStage && sprite.lists.contains(listID)) {
+                    if (currentSprite.isStage && sprite.lists.containsKey(listID)) {
                         targetSprite = currentSprite;
                         break;
                     }
···
 
             Sprite targetSprite = null;
 
-            if (sprite.lists.contains(listID)) {
+            if (sprite.lists.containsKey(listID)) {
                 targetSprite = sprite;
             } else {
                 for (int i = 0; i < Interpret.sprites.size(); i++) {
                     Sprite currentSprite = (Sprite)Interpret.sprites.elementAt(i);
-                    if (currentSprite.isStage && sprite.lists.contains(listID)) {
+                    if (currentSprite.isStage && sprite.lists.containsKey(listID)) {
                         targetSprite = currentSprite;
                         break;
                     }
···
 
             Sprite targetSprite = null;
 
-            if (sprite.lists.contains(listID)) {
+            if (sprite.lists.containsKey(listID)) {
                 targetSprite = sprite;
             } else {
                 for (int i = 0; i < Interpret.sprites.size(); i++) {
                     Sprite currentSprite = (Sprite)Interpret.sprites.elementAt(i);
-                    if (currentSprite.isStage && sprite.lists.contains(listID)) {
+                    if (currentSprite.isStage && sprite.lists.containsKey(listID)) {
                         targetSprite = currentSprite;
                         break;
                     }
···
 
             Sprite targetSprite = null;
 
-            if (sprite.lists.contains(listID)) {
+            if (sprite.lists.containsKey(listID)) {
                 targetSprite = sprite;
             } else {
                 for (int i = 0; i < Interpret.sprites.size(); i++) {
                     Sprite currentSprite = (Sprite)Interpret.sprites.elementAt(i);
-                    if (currentSprite.isStage && sprite.lists.contains(listID)) {
+                    if (currentSprite.isStage && sprite.lists.containsKey(listID)) {
                         targetSprite = currentSprite;
                         break;
                     }
···
 
             Sprite targetSprite = null;
 
-            if (sprite.lists.contains(listID)) {
+            if (sprite.lists.containsKey(listID)) {
                 targetSprite = sprite;
             } else {
                 for (int i = 0; i < Interpret.sprites.size(); i++) {
                     Sprite currentSprite = (Sprite)Interpret.sprites.elementAt(i);
-                    if (currentSprite.isStage && sprite.lists.contains(listID)) {
+                    if (currentSprite.isStage && sprite.lists.containsKey(listID)) {
                         targetSprite = currentSprite;
                         break;
                     }
···
 
             Sprite targetSprite = null;
 
-            if (sprite.lists.contains(listID)) {
+            if (sprite.lists.containsKey(listID)) {
                 targetSprite = sprite;
             } else {
                 for (int i = 0; i < Interpret.sprites.size(); i++) {
                     Sprite currentSprite = (Sprite)Interpret.sprites.elementAt(i);
-                    if (currentSprite.isStage && sprite.lists.contains(listID)) {
+                    if (currentSprite.isStage && sprite.lists.containsKey(listID)) {
                         targetSprite = currentSprite;
                         break;
                     }
···
 
             Sprite targetSprite = null;
 
-            if (sprite.lists.contains(listID)) {
+            if (sprite.lists.containsKey(listID)) {
                 targetSprite = sprite;
             } else {
                 for (int i = 0; i < Interpret.sprites.size(); i++) {
                     Sprite currentSprite = (Sprite)Interpret.sprites.elementAt(i);
-                    if (currentSprite.isStage && sprite.lists.contains(listID)) {
+                    if (currentSprite.isStage && sprite.lists.containsKey(listID)) {
                         targetSprite = currentSprite;
                         break;
                     }

src/main/java/leap/s3me/scratch/blocks/LooksBlocks.java

···
     public static class Show implements BlockExecutor.BlockHandler {
         public int run(Block block, Sprite sprite, boolean[] withoutScreenRefresh, boolean fromRepeat) {
             sprite.visible = true;
-            //Image.getImage((Costume)sprite.costumes.get(sprite.currentCostume));
+            sprite.loadCurrentCostume();
             return BlockExecutor.RESULT_CONTINUE;
         }
     }
···
                 }
             }
 
-            //Image.getImage((Costume)sprite.costumes.get(sprite.currentCostume));
+            sprite.loadCurrentCostume();
 
             return BlockExecutor.RESULT_CONTINUE;
         }
···
             if (sprite.currentCostume >= sprite.costumes.size()) {
                 sprite.currentCostume = 0;
             }
-            //Image.getImage((Costume)sprite.costumes.get(sprite.currentCostume));
+            sprite.loadCurrentCostume();
             return BlockExecutor.RESULT_CONTINUE;
         }
     }
···
                     }
                 }
 
-                //Image.getImage((Costume)currentSprite.costumes.get(currentSprite.currentCostume));
+                currentSprite.loadCurrentCostume();
 
                 Enumeration e = currentSprite.blocks.keys();
                 while (e.hasMoreElements()) {
···
                 if (currentSprite.currentCostume >= currentSprite.costumes.size()) {
                     currentSprite.currentCostume = 0;
                 }
-                //Image.getImage((Costume)currentSprite.costumes.get(currentSprite.currentCostume));
+                currentSprite.loadCurrentCostume();
 
                 Enumeration e = currentSprite.blocks.keys();
                 while (e.hasMoreElements()) {

src/main/java/leap/s3me/scratch/blocks/SensingBlocks.java

···
+package leap.s3me.scratch.blocks;
+
+import java.util.Calendar;
+import java.util.Enumeration;
+import java.util.Vector;
+
+import leap.s3me.App;
+import leap.s3me.Interpret;
+import leap.s3me.MathUtils;
+import leap.s3me.Scratch;
+import leap.s3me.scratch.Block;
+import leap.s3me.scratch.BlockExecutor;
+import leap.s3me.scratch.Costume;
+import leap.s3me.scratch.Input;
+import leap.s3me.scratch.Sprite;
+import leap.s3me.scratch.Value;
+import leap.s3me.scratch.Variable;
+
+public class SensingBlocks {
+    public static class ProjectTimer {
+        private long startTime;
+
+        public ProjectTimer() {
+            startTime = System.currentTimeMillis();
+        }
+
+        public void start() {
+            startTime = System.currentTimeMillis();
+        }
+
+        public double getTimeMs() {
+            return System.currentTimeMillis() - startTime;
+        }
+    }
+    public static ProjectTimer projectTimer = new ProjectTimer();
+
+    public static class ResetTimer implements BlockExecutor.BlockHandler {
+        public int run(Block block, Sprite sprite, boolean[] withoutScreenRefresh, boolean fromRepeat) {
+            projectTimer.start();
+            return BlockExecutor.RESULT_CONTINUE;
+        }
+    }
+
+    public static class AskAndWait implements BlockExecutor.BlockHandler {
+        public int run(Block block, Sprite sprite, boolean[] withoutScreenRefresh, boolean fromRepeat) {
+            // This block is blocking, meaning script execution pauses until user input is received.
+            // We use Scratch.awaitingUserInput and Scratch.inputQuestion flags to signal the UI.
+            // The main loop in Scratch.startScratchProject() will wait until input is provided.
+
+            if (block.repeatTimes != -1 && !fromRepeat) {
+                block.repeatTimes = -1;
+            }
+
+            if (block.repeatTimes == -1) {
+                block.repeatTimes = -9; // Special code for ask and wait to indicate it's waiting for input
+                BlockExecutor.addToRepeatQueue(sprite, block);
+
+                Scratch.awaitingUserInput = true;
+                Scratch.inputQuestion = Scratch.getInputValue(block, "QUESTION", sprite).asString();
+
+                // Return RESULT_RETURN to pause this script's execution.
+                // The main loop will then handle displaying the input prompt and waiting.
+                return BlockExecutor.RESULT_RETURN;
+            }
+
+            // If we reach here, it means the user has provided input, and the block is resuming.
+            // Interpret.answer should have been set by the UI.
+            block.repeatTimes = -1; // Reset for next execution
+            BlockExecutor.removeFromRepeatQueue(sprite, block);
+            return BlockExecutor.RESULT_CONTINUE;
+        }
+    }
+
+    public static class SetDragMode implements BlockExecutor.BlockHandler {
+        public int run(Block block, Sprite sprite, boolean[] withoutScreenRefresh, boolean fromRepeat) {
+            String mode = Scratch.getFieldValue(block, "DRAG_MODE");
+            if (mode.equals("draggable")) {
+                sprite.draggable = true;
+            } else if (mode.equals("not draggable")) {
+                sprite.draggable = false;
+            }
+            return BlockExecutor.RESULT_CONTINUE;
+        }
+    }
+
+    public static class SensingTimer implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            return new Value(projectTimer.getTimeMs() / 1000.0);
+        }
+    }
+
+    public static class Of implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            String property = Scratch.getFieldValue(block, "PROPERTY");
+            String objectName;
+
+            // Get the target object name from the input. This can be "_stage_", "_myself_", or a sprite name.
+            Value objectValue = Scratch.getInputValue(block, "OBJECT", sprite);
+            objectName = objectValue.asString();
+
+            Sprite targetSprite = null;
+
+            if (objectName.equals("_stage_")) {
+                for (int i = 0; i < Interpret.sprites.size(); i++) {
+                    Sprite s = (Sprite) Interpret.sprites.elementAt(i);
+                    if (s.isStage) {
+                        targetSprite = s;
+                        break;
+                    }
+                }
+            } else if (objectName.equals("_myself_")) {
+                targetSprite = sprite;
+            } else {
+                // Find sprite by name (non-clone)
+                for (int i = 0; i < Interpret.sprites.size(); i++) {
+                    Sprite s = (Sprite) Interpret.sprites.elementAt(i);
+                    if (s.name.equals(objectName) && !s.isClone) {
+                        targetSprite = s;
+                        break;
+                    }
+                }
+            }
+
+            if (targetSprite == null) {
+                // If target sprite not found, return a default value (0 for numbers, empty string for names)
+                if (property.equals("costume name") || property.equals("backdrop name")) {
+                    return new Value("");
+                }
+                return new Value(0);
+            }
+
+            if (property.equals("x position")) {
+                return new Value(targetSprite.xPosition);
+            } else if (property.equals("y position")) {
+                return new Value(targetSprite.yPosition);
+            } else if (property.equals("direction")) {
+                return new Value(targetSprite.rotation);
+            } else if (property.equals("costume #") || property.equals("backdrop #")) {
+                return new Value(targetSprite.currentCostume + 1);
+            } else if (property.equals("costume name") || property.equals("backdrop name")) {
+                if (targetSprite.costumes.isEmpty()) return new Value("");
+                return new Value(((Costume)targetSprite.costumes.elementAt(targetSprite.currentCostume)).name);
+            } else if (property.equals("size")) {
+                return new Value(targetSprite.size);
+            } else if (property.equals("volume")) {
+                return new Value(targetSprite.volume);
+            } else if (property.equals("timer")) {
+                return new Value(projectTimer.getTimeMs() / 1000.0);
+            }
+
+            // Check for variables of the target sprite by name
+            Enumeration varEnum = targetSprite.variables.elements();
+            while(varEnum.hasMoreElements()) {
+                Variable var = (Variable)varEnum.nextElement();
+                if (var.name.equals(property)) {
+                    return var.value;
+                }
+            }
+
+            return new Value(0);
+        }
+    }
+
+    public static class MouseX implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            return new Value(Input.mousePointer.x);
+        }
+    }
+
+    public static class MouseY implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            return new Value(Input.mousePointer.y);
+        }
+    }
+
+    public static class DistanceTo implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            Value targetValue = Scratch.getInputValue(block, "DISTANCETOMENU", sprite);
+            String objectName = targetValue.asString();
+
+            if (objectName.equals("_mouse_")) {
+                double dx = Input.mousePointer.x - sprite.xPosition;
+                double dy = Input.mousePointer.y - sprite.yPosition;
+                return new Value(Math.sqrt(dx * dx + dy * dy));
+            }
+
+            Sprite targetSprite = null;
+            // Find sprite by name (non-clone)
+            for (int i = 0; i < Interpret.sprites.size(); i++) {
+                Sprite s = (Sprite) Interpret.sprites.elementAt(i);
+                if (s.name.equals(objectName) && !s.isClone) {
+                    targetSprite = s;
+                    break;
+                }
+            }
+
+            if (targetSprite != null) {
+                double dx = targetSprite.xPosition - sprite.xPosition;
+                double dy = targetSprite.yPosition - sprite.yPosition;
+                return new Value(Math.sqrt(dx * dx + dy * dy));
+            }
+
+            return new Value(10000);
+        }
+    }
+
+    public static class DaysSince2000 implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            Calendar cal = Calendar.getInstance();
+            //cal.set(2000, Calendar.JANUARY, 1, 0, 0, 0);
+            cal.set(Calendar.YEAR, 2000);
+            cal.set(Calendar.MONTH, Calendar.JANUARY);
+            cal.set(Calendar.DATE, 1);
+            cal.set(Calendar.HOUR_OF_DAY, 0);
+            cal.set(Calendar.MINUTE, 0);
+            cal.set(Calendar.SECOND, 0);
+            long millis2000 = cal.getTime().getTime();
+            long currentMillis = System.currentTimeMillis();
+            long diffMillis = currentMillis - millis2000;
+            double days = diffMillis / (1000.0 * 60 * 60 * 24);
+            return new Value(days);
+        }
+    }
+
+    public static class Current implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            String unit = Scratch.getFieldValue(block, "CURRENTMENU");
+            Calendar cal = Calendar.getInstance(); // Current time
+
+            if (unit.equals("YEAR")) return new Value(cal.get(Calendar.YEAR));
+            if (unit.equals("MONTH")) return new Value(cal.get(Calendar.MONTH) + 1); // Calendar.MONTH is 0-indexed
+            if (unit.equals("DATE")) return new Value(cal.get(Calendar.DAY_OF_MONTH));
+            if (unit.equals("DAYOFWEEK")) {
+                // Scratch's day of week: Sunday=7, Monday=1, ..., Saturday=6
+                // Java's Calendar.DAY_OF_WEEK: Sunday=1, Monday=2, ..., Saturday=7
+                return new Value((cal.get(Calendar.DAY_OF_WEEK) + 5) % 7 + 1);
+            }
+            if (unit.equals("HOUR")) return new Value(cal.get(Calendar.HOUR_OF_DAY)); // 24-hour format
+            if (unit.equals("MINUTE")) return new Value(cal.get(Calendar.MINUTE));
+            if (unit.equals("SECOND")) return new Value(cal.get(Calendar.SECOND));
+
+            return new Value();
+        }
+    }
+
+    public static class SensingAnswer implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            return new Value(Interpret.answer);
+        }
+    }
+
+    public static class KeyPressed implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            Value keyOptionValue = Scratch.getInputValue(block, "KEY_OPTION", sprite);
+            String keyToCheck = keyOptionValue.asString();
+            return new Value(Input.isKeyPressed(keyToCheck));
+        }
+    }
+
+    public static class TouchingObject implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            Value targetValue = Scratch.getInputValue(block, "TOUCHINGOBJECTMENU", sprite);
+            String objectName = targetValue.asString();
+
+            if (objectName.equals("_mouse_")) {
+                return new Value(Interpret.isColliding("mouse", sprite, null, null));
+            } else if (objectName.equals("_edge_")) {
+                return new Value(Interpret.isColliding("edge", sprite, null, null));
+            } else {
+                // Find sprite by name (non-clone)
+                for (int i = 0; i < Interpret.sprites.size(); i++) {
+                    Sprite currentSprite = (Sprite) Interpret.sprites.elementAt(i);
+                    if (currentSprite.name.equals(objectName) && !currentSprite.isClone) {
+                        return new Value(Interpret.isColliding("sprite", sprite, currentSprite, objectName));
+                    }
+                }
+            }
+            return new Value(false);
+        }
+    }
+
+    public static class MouseDown implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            return new Value(Input.mousePointer.isPressed);
+        }
+    }
+
+    public static class Username implements BlockExecutor.ValueBlockHandler {
+        public Value run(Block block, Sprite sprite) {
+            return new Value(Input.getUsername());
+        }
+    }
+}