Scratch

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class ScriptExecuter {

    private static String HAT_MOUSE_CLICK_EVENT = "Scratch-MouseClickEvent";

    private ScriptExecuter() {
    }

    public static void stopAllHats(ScratchPlayer p) {
        for (Thread t : p.hats) {
            t.stop();
        }
    }

    public static boolean isNumber(Object o) {
        try {
            Integer.valueOf(toStr(o));
            return true;
        } catch (NumberFormatException ex1) {
            try {
                Double.valueOf(toStr(o));
                return true;
            } catch (NumberFormatException ex2) {
                return false;
            }
        }
    }

    public static boolean toBoolean(Object o) {
        if (o == null) {
            return false;
        }
        return o.toString().equalsIgnoreCase("true");
    }

    public static String toStr(Object o) {
        if (o == null) {
            return "";
        }
        return o.toString();
    }

    public static int toInt(Object o) {
        if (o == null) {
            return 0;
        }
        try {
            return Double.valueOf(o.toString()).intValue();
        } catch (NumberFormatException ex) {
            return 0;
        }
    }

    public static double toDouble(Object o) {
        if (o == null) {
            return 0;
        }
        try {
            return Double.valueOf(o.toString());
        } catch (NumberFormatException ex) {
            return 0;
        }
    }

    public static Color toColor(Object o) {
        if (o == null) {
            return new Color(0, 0, 0, 255);
        }
        if (o instanceof Color) {
            return (Color) o;
        }
        return new Color(toInt(o));
    }

    /**
     * May return null
     */
    public static Sound toSound(Sprite sprt, Object o) {
        if (o == null) {
            return null;
        }
        if (o instanceof Sound) {
            return (Sound) o;
        }
        String n = toStr(o);
        for (Sound s : sprt.sounds) {
            if (s.getName().equals(n)) {
                return s;
            }
        }
        return null;
    }

    public static int toJavaX(Object o) {
        return toInt(o) + 240;
    }

    public static int toJavaY(Object o) {
        return -toInt(o) + 180;
    }

    public static void startOnClickHats(ScratchPlayer p, Sprite s) {
        for (EventHatThread t : p.hats) {
            if (t.msg.equals(HAT_MOUSE_CLICK_EVENT) && t.owner == s) {
                t.interrupt();
            }
        }
        hat(p, HAT_MOUSE_CLICK_EVENT, s);
    }

    private static ArrayList<Thread> hat(final ScratchPlayer p, String msg) {
        ArrayList<Thread> started = new ArrayList<Thread>();
        started.addAll(hat(p, msg, p.stage));
        for (Drawable d : p.drawables) {
            if (d instanceof Sprite) {
                started.addAll(hat(p, msg, (Sprite) d));
            }
        }
        return started;
    }

    private static ArrayList<Thread> hat(final ScratchPlayer p, String msg, Sprite s) {
        ArrayList<Thread> started = new ArrayList<Thread>();
        final Object[] script = s.scripts;
        for (int i = 0; i < script.length; i++) {
            final String[] hat = getHat(script, i);
            final int hpos = i;
            if ((hat[0].equals("EventHatMorph") && hat[1].equals(msg))
                    || (hat[0].equals("MouseClickEventHatMorph") && msg.equals(HAT_MOUSE_CLICK_EVENT))) {
                EventHatThread t = new EventHatThread(hat[1], s, p) {

                    public void run() {
                        try {
                            execHat(p, (Object[]) ((Object[]) ((Object[]) script[hpos]))[1]);
                        } catch (Throwable e) {
                            if (e instanceof ThreadDeath) {
                                return;
                            }
                            e.printStackTrace();
                        } finally {
                            p.hats.remove(this);
                        }
                    }
                };
                t.setPriority(Thread.MIN_PRIORITY);
                p.hats.add(t);
                t.start();
                started.add(t);
            }


        }
        return started;
    }

    public static void broadcast(ScratchPlayer p, String msg) {
        hat(p, msg);
    }

    public static void broadcastAndWait(ScratchPlayer p, String msg) throws InterruptedException {
        ArrayList<Thread> thrds = hat(p, msg);
        for (Thread t : thrds) {
            t.join();
        }
    }

    public static void execHat(ScratchPlayer p, Object[] hat) {
        for (int i = 1; i < hat.length; i++) {
            execCmd(p, (Object[]) hat[i]);
        }
    }

    public static Object execFunction(ScratchPlayer p, String f, Object... param) {
        slow();
        Function func = p.functions.get(f);
        if (func == null) {
            System.err.println("Error: Can't find function \"" + f + "\"!");
            return null;
//            throw new RuntimeException("Can't find function \"" + f + "\"!");
        }
        if (func.preExecute()) {
            for (int i = 0; i < param.length; i++) {
                if (param[i] instanceof Object[]) {
                    param[i] = execCmd(p, (Object[]) param[i]);
                }
            }
        }
        try {
            return func.exec(param);
        } catch (java.lang.IllegalArgumentException e) {
            throw new RuntimeException("Error! False inputs for function \"" + f + "\"!");
        } catch (java.lang.IllegalAccessException e) {
            throw new RuntimeException("Error! Isn't allowed to access function \"" + f + "\"!");
        } catch (java.lang.reflect.InvocationTargetException e) {
            if (e.getTargetException() instanceof ThreadDeath) {
                throw new ThreadDeath();
            }
            throw new RuntimeException("Error in function \"" + f + "\"!", e.getTargetException());
        }
    }

    public static void slow() {
        try {
            if (Math.random() > 0.5F) {
                Thread.sleep(1);
            }
        } catch (Exception xe) {
        }
    }

    public static Sprite toSprite(ScratchPlayer p, Object obj) {
        if (obj instanceof Sprite) {
            return (Sprite) obj;
        }
        for (Drawable d : p.drawables) {
            if (d instanceof Sprite) {
                Sprite s = (Sprite) d;
                if (s.getName().equals(toStr(obj))) {
                    return s;
                }
            }
        }
        return null;
    }

    public static int toScratchX(int javax) {
        return javax - 240;
    }

    public static int toScratchY(int javay) {
        return 180 - javay;
    }

    public static Object execCmd(ScratchPlayer p, Object[] arr) {
        if (arr == null || arr.length == 0) {
            return null;
        }
        if (arr[0] instanceof String) {
            Object[] param = new Object[arr.length - 1];
            System.arraycopy(arr, 1, param, 0, param.length);
            return execFunction(p, (String) arr[0], param);
        } else if (arr[0] instanceof Object[]) {
            return arr;
        } else {
            throw new java.lang.UnsupportedOperationException(arr[0].getClass().getName());
        }
    }

    public static void execList(ScratchPlayer p, Object[] cmds) {
        if (cmds == null || cmds.length == 0) {
            return;
        }
        if (cmds[0] instanceof Object[]) {
            for (int i = 0; i < cmds.length; i++) {
                execCmd(p, (Object[]) cmds[i]);
            }
        } else {
            throw new java.lang.IllegalArgumentException(cmds[0].getClass().getName());
        }
    }

    private static String[] getHat(Object[] script, int i) {
        Object[] hat = (Object[]) ((Object[]) ((Object[]) ((Object[]) script[i])[1]))[0];
        if (hat.length == 2) {
            return new String[]{
                        hat[0].toString(),
                        hat[1].toString()
                    };
        } else {
            return new String[]{
                        hat[0].toString()
                    };
        } 
    }

    public static class EventHatThread extends Thread {

        private Sprite owner;
        private String msg;
        private ScratchPlayer player;

        public EventHatThread(String message, Sprite s, ScratchPlayer p) {
            owner = s;
            msg = message;
            player = p;
        }

        public String msg() {
            return msg;
        }

        public Sprite owner() {
            return owner;
        }

        private ScratchPlayer player() {
            return player;
        }
    }

    public static abstract class Commands {

        public abstract String[] getCommands();

        public final Function[] getFunctions() {
            String[] cmds = getCommands();
            Function[] f = new Function[cmds.length / 2];
            Method[] methods = getClass().getDeclaredMethods();

            for (int i = 0; i < f.length; i++) {
                for (Method m : methods) {
                    if (m.getName().equals(cmds[i * 2 + 1].replace("[raw]", ""))) {
                        f[i] = new Function(cmds[i * 2], m, this, !cmds[i * 2 + 1].endsWith("[raw]"));
                        break;
                    }
                }
                if (f[i] == null) {
                    throw new ScratchPlayer.PlayerException("Can't load Method \"" + cmds[i * 2 + 1] + "\" for name \"" + cmds[i * 2] + "\"");
                }
            }
            return f;
        }

        public Sprite owner() {
            return ((EventHatThread) Thread.currentThread()).owner();
        }

        public ScratchPlayer player() {
            return ((EventHatThread) Thread.currentThread()).player();
        }
    }

    public static class Function {

        private final Method m;
        final String name;
        private final Commands c;
        private final boolean preExecute;

        public Function(String name, Method m, Commands c, boolean pexec) {
            this.m = m;
            this.name = name;
            this.c = c;
            this.preExecute = pexec;
        }

        public boolean preExecute() {
            return preExecute;
        }

        public Object exec(Object... param) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
            return m.invoke(c, param);
        }
    }
}

import static org.me.scratchplayer.ScriptExecuter.*;

public class CmdsControl extends Commands {

    // here are the names of the blocks in Scratch and their names of the block's  function
    // in Java
    @Override
    public String[] getCommands() {
        return new String[]{
                    "broadcast:", "broadcast", "doRepeat", "doRepeat", "doBroadcastAndWait", "broadcastWait", "wait:elapsed:from:", "sleep",
                    "doForever", "doForever", "doIf", "doIf", "doIfElse", "doIfElse", "doReturn", "returnHat", "stopAll", "stopAll",
                    "doWaitUntil", "waitUntil[raw]", "doUntil", "doUntil[raw]", "doForeverIf", "doForeverIf", "say:", "debug"
                };
    }
    // this method gets the return values of the parameters from the broadcast block,
    // the player() method returns the ScratchPlayer instance.
    public void broadcast(String msg) {
        ScriptExecuter.broadcast(player(), msg);
    }
   [... the other command blocks]
}