Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
package com.marginallyclever.makelangelo.makeart.io;
import com.marginallyclever.makelangelo.Translator;
import com.marginallyclever.makelangelo.turtle.Turtle;
import org.json.JSONArray;
import org.json.JSONObject;
import org.json.JSONTokener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.swing.filechooser.FileNameExtensionFilter;
import java.awt.*;
import java.io.*;
import java.util.List;
import java.util.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
/**
* {@link LoadScratch3} loads a limited set of Scratch 3.0 commands into memory.
* We ignore monitors, which are visual displays of variables, booleans, and lists
* They don't contain any real information we need.
*
* See https://en.scratch-wiki.info/wiki/Scratch_File_Format
* See https://github.com/LLK/scratch-blocks/tree/develop/blocks_vertical
*
* @author Dan Royer
* @since 7.31.0
*/
public class LoadScratch3 implements TurtleLoader {
private static final Logger logger = LoggerFactory.getLogger(LoadScratch3.class);
private final String PROJECT_JSON = "project.json";
private static int seed=0;
private static final Random random = new Random();
private static class Scratch3Variable {
public String name;
public String uniqueID;
public Object value;
public Scratch3Variable(String name,String uniqueID,Object defaultValue) {
this.name=name;
this.uniqueID=uniqueID;
this.value=defaultValue;
}
@Override
public String toString() {
return //uniqueID+" "+
name+"="+value;
}
};
private static class Scratch3List {
public String name;
public ArrayList<Double> contents;
public Scratch3List(String _name) {
name=_name;
contents=new ArrayList<Double>();
}
};
private static class Scratch3Variables extends ArrayList<Scratch3Variable> {
public Scratch3Variables deepCopy() {
Scratch3Variables copy = new Scratch3Variables();
for(Scratch3Variable v : this) {
copy.add(new Scratch3Variable(v.name,v.uniqueID,null));
}
return copy;
}
}
private static class Scratch3Procedure {
public String proccode; // name of procedure
public String uniqueID;
public Scratch3Variables parameters = new Scratch3Variables();
public Scratch3Procedure(String uniqueID,String proccode) {
this.uniqueID = uniqueID;
this.proccode = proccode;
}
public String toString() {
return //uniqueID+" "+
proccode+parameters.toString();
}
}
private FileNameExtensionFilter filter = new FileNameExtensionFilter("Scratch 3","SB3");
private Scratch3Variables scratchGlobalVariables;
private final Stack<Scratch3Variables> myStack = new Stack<>();
private final List<Scratch3List> scratchLists = new ArrayList<>();
private final List<Scratch3Procedure> scratchProcedures = new ArrayList<>();
private JSONObject blocks;
private Set<String> blockKeys;
private Turtle myTurtle;
// used in doRepeatForever
private final int loopNbCountInsteadOfForever = 1;// resilient : we can draw something, but it may be incomplete ...
// used in doRepeatForever
private final boolean foreverThrowAnException = false;// To be resilient and user-friendly this is not an error...
@Override
public FileNameExtensionFilter getFileNameFilter() {
return filter;
}
@Override
public boolean canLoad(String filename) {
String ext = filename.substring(filename.lastIndexOf('.')+1);
return Arrays.stream(filter.getExtensions()).anyMatch(ext::equalsIgnoreCase);
}
@Override
public Turtle load(InputStream in) throws Exception {
if (in == null) {
throw new NullPointerException("Input stream is null");
}
logger.debug("Loading...");
JSONObject tree = getTreeFromInputStream(in);
random.setSeed(0);
if(!confirmAtLeastVersion3(tree)) throw new Exception("File must be at least version 3.0.0.");
if(!confirmHasPenExtension(tree)) throw new Exception("File must include pen extension.");
readScratchVariables(tree);
readScratchLists(tree);
findBlocks(tree);
readScratchProcedures();
readScratchInstructions();
return myTurtle;
}
private JSONObject getTreeFromInputStream(InputStream in) throws IOException {
File tempZipFile = extractProjectJSON(in);
logger.trace("Parsing JSON file...");
JSONTokener tokener = new JSONTokener(tempZipFile.toURI().toURL().openStream());
JSONObject tree = new JSONObject(tokener);
tempZipFile.delete();
return tree;
}
private File extractProjectJSON(InputStream in) throws IOException {
logger.trace("Searching for project.json...");
try (ZipInputStream zipInputStream = new ZipInputStream(in)) {
ZipEntry entry;
File tempZipFile = null;
while ((entry = zipInputStream.getNextEntry()) != null) {
if (entry.getName().equals(PROJECT_JSON)) {
logger.trace("Found project.json...");
// read buffered stream into temp file.
tempZipFile = File.createTempFile("project", "json");
tempZipFile.setReadable(true);
tempZipFile.setWritable(true);
tempZipFile.deleteOnExit();
try (FileOutputStream fos = new FileOutputStream(tempZipFile)) {
byte[] buffer = new byte[2048];
int len;
while ((len = zipInputStream.read(buffer)) > 0) {
fos.write(buffer, 0, len);
}
return tempZipFile;
}
}
}
}
throw new FileNotFoundException("SB3 missing project.json");
}
private void findBlocks(JSONObject tree) throws Exception {
JSONArray targets = (JSONArray)tree.get("targets");
for (Object target : targets) {
JSONObject targetN = (JSONObject) target;
if ((Boolean) targetN.get("isStage") ) continue;
blocks = targetN.getJSONObject("blocks");
// we found the blocks.
logger.debug("found {} blocks", blocks.length());
// get the keys, too.
blockKeys = blocks.keySet();
return;
}
throw new Exception("targets > blocks missing");
}
private final int nbClicOnTheGreenFlag = 1; // Let's be basic - one click for now.
/**
* parse blocks in scratch3 format
* @throws Exception if no program was run because no green flag was found.
*/
private void readScratchInstructions() throws Exception {
logger.trace("readScratchInstructions ( and do a flagclicked {} times ) ",nbClicOnTheGreenFlag);
myTurtle = new Turtle();// needed to be init here in case multiple "event_whenflagclicked"
// TODO some myTurtle init to be like Scratch initial state. ( like initial color... )
int flagsClickedTotal = 0;
for (int i = 0; i < nbClicOnTheGreenFlag; i++) {
// find the first block with opcode=event_whenflagclicked.
int flagsClickedInThisBlock = 0;
for (String k : blockKeys) {
Object getTmp = blocks.get(k);
if (getTmp instanceof JSONObject) {
JSONObject block = (JSONObject) getTmp;
final String key_scratch_block_opcode = "opcode";
if (block.has(key_scratch_block_opcode)) {
String opcode = block.getString(key_scratch_block_opcode);
if (opcode.equals("event_whenflagclicked")) {
parseScratchCode(k);// TODO a stack (LIFO) with k to parseScratchCode(k) later (if multiple event_whenflagclicked this is in the Scratch3 interpretor reverse order ... and for scratch timing (wait, ...) if we want to implement it.)
flagsClickedInThisBlock++;
}
} else {
// starge no opcode ... but to be resilient no exception .
logger.debug("no {} for block {} : {} // instanceof {}",key_scratch_block_opcode, k, getTmp, getTmp.getClass().toString());
}
} else {
if ( getTmp != null ){
// somethinge is not what expected ... maybe a lost variable in the scratch projet ...
logger.debug("not expected for block {} : {} // instanceof {}", k, getTmp, getTmp.getClass().toString());
}else{
// normaly should not happend but juste to be sure ...
logger.debug("not expected for block {} : {} // null", k, getTmp);
}
}
}
flagsClickedTotal += flagsClickedInThisBlock;
}
if (flagsClickedTotal == 0) {
throw new Exception("WhenFlagClicked block not found.");
}
}
private JSONObject getBlock(String key) {
return blocks.getJSONObject(key);
}
private String findNextBlockKey(JSONObject currentBlock) {
Object key = currentBlock.opt("next");
if(key==null || key == JSONObject.NULL) return null;
return (String)key;
}
private void parseScratchCode(String currentKey) throws Exception {
logger.trace("parseScratchCode {}",currentKey);
JSONObject currentBlock = getBlock(currentKey);
while(currentBlock!=null) {
String opcode = (String)currentBlock.get("opcode");
switch(opcode) {
// control blocks start
case "event_whenflagclicked": doStart(currentBlock); break;
case "control_repeat": doRepeat(currentBlock); break;
case "control_repeat_until": doRepeatUntil(currentBlock); break;
case "control_forever": doRepeatForever(currentBlock); break;
case "control_if": doIf(currentBlock); break;
case "control_if_else": doIfElse(currentBlock); break;
case "control_stop":
//throw new Exception("control_stop not supported.");
return;
case "procedures_call": doCall(currentBlock); break;
// control blocks end
case "data_setvariableto": setVariableTo(currentBlock); break;
case "data_changevariableby": changeVariableBy(currentBlock); break;
/* case "data_variable": break;
case "data_hidevariable": break;
case "data_showvariable": break;
case "data_listcontents": break;
case "data_addtolist": break;
case "data_deleteoflist": break;
case "data_deletealloflist": break;
case "data_insertatlist": break;
case "data_replaceitemoflist": break;
case "data_itemoflist": break;
case "data_itemnumoflist": break;
case "data_lengthoflist": break;
case "data_listcontainsitem": break;
*/
case "motion_gotoxy": doMotionGotoXY(currentBlock); break;
case "motion_pointindirection": doMotionPointInDirection(currentBlock); break;
case "motion_turnleft": doMotionTurnLeft(currentBlock); break;
case "motion_turnright": doMotionTurnRight(currentBlock); break;
case "motion_movesteps": doMotionMoveSteps(currentBlock); break;
//case "motion_pointtowards": doMotionPointTowards(currentBlock); break;
case "motion_changexby": doMotionChangeX(currentBlock); break;
case "motion_changeyby": doMotionChangeY(currentBlock); break;
case "motion_setx": doMotionSetX(currentBlock); break;
case "motion_sety": doMotionSetY(currentBlock); break;
case "pen_penDown": myTurtle.penDown(); break;
case "pen_penUp": myTurtle.penUp(); break;
case "pen_setPenColorToColor": doSetPenColor(currentBlock); break;
default: logger.debug("Ignored {}", opcode);
}
currentKey = findNextBlockKey(currentBlock);
if(currentKey==null) break;
logger.trace("next block {}",currentKey);
currentBlock = getBlock(currentKey);
}
}
private void doStart(JSONObject currentBlock) {
logger.trace("START a block opcode event_whenflagclicked ...");
}
private void doIfElse(JSONObject currentBlock) throws Exception {
logger.trace("IF ELSE");
String condition = (String)findInputInBlock(currentBlock,"CONDITION");
String substack = (String)findInputInBlock(currentBlock,"SUBSTACK");
String substack2 = (String)findInputInBlock(currentBlock,"SUBSTACK2");
if(resolveBoolean(getBlock(condition))) {
parseScratchCode(substack);
} else {
parseScratchCode(substack2);
}
}
private void doCall(JSONObject currentBlock) throws Exception {
String proccode = (String)findMutationInBlock(currentBlock,"proccode");
ArrayList<Object> args = resolveArgumentsForProcedure(currentBlock);
logger.trace("CALL {}({})",proccode,args.toString());
Scratch3Procedure p = findProcedureWithProccode(proccode);
pushStack(p,args);
parseScratchCode(getBlock(p.uniqueID).getString("next"));
myStack.pop();
}
private ArrayList<Object> resolveArgumentsForProcedure(JSONObject currentBlock) throws Exception {
ArrayList<Object> args = new ArrayList<>();
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray argumentids = new JSONArray((String)findMutationInBlock(currentBlock,"argumentids"));
for (Object argumentid : argumentids) {
JSONArray key = (JSONArray) inputs.get((String) argumentid);
args.add(resolveValue(key.get(1)));
}
return args;
}
// copy the parameters, set the values based on what was passed into the procedure, and then push that onto the stack.
private void pushStack(Scratch3Procedure p, ArrayList<Object> args) {
Scratch3Variables list = p.parameters.deepCopy();
for(int i=0;i<list.size();++i) {
list.get(i).value = args.get(i);
}
myStack.push(list);
}
private Scratch3Procedure findProcedureWithProccode(String proccode) {
for (Scratch3Procedure p : scratchProcedures) {
if (p.proccode.equals(proccode)) return p;
}
return null;
}
private void doIf(JSONObject currentBlock) throws Exception {
logger.trace("IF");
String condition = (String)findInputInBlock(currentBlock,"CONDITION");
String substack = (String)findInputInBlock(currentBlock,"SUBSTACK");
if(resolveBoolean(getBlock(condition))) {
parseScratchCode(substack);
}
}
/**
* dummy doReapeatForever. N.B. : For the current Makelangelo implementation
* we need to assert the Scratch program has an end. (is not infinite ...
* This is the easy case.) RepeatForever has to be altered (loop only n
* time) or seen as an error.
* @param currentBlock the block to parse
* @throws Exception if the block tries to repeat forever
*/
private void doRepeatForever(JSONObject currentBlock) throws Exception {
if( foreverThrowAnException ) {
throw new Exception(Translator.get("LoadScratch3.foreverNotAllowed"));
}
logger.trace("REPEAT FOREVER ( will only repeat {} times. )", loopNbCountInsteadOfForever);
String substack = (String)findInputInBlock(currentBlock,"SUBSTACK");
for (int i = 0; i < loopNbCountInsteadOfForever; i++){
//while(true) { // technically this would work and the program would never end. It is here for reference.
parseScratchCode(substack);
//}
}
}
private void doRepeatUntil(JSONObject currentBlock) throws Exception {
logger.trace("REPEAT UNTIL");
String condition = (String)findInputInBlock(currentBlock,"CONDITION");
String substack = (String)findInputInBlock(currentBlock,"SUBSTACK");
while(!resolveBoolean(getBlock(condition))) {
parseScratchCode(substack);
}
}
private void doRepeat(JSONObject currentBlock) throws Exception {
int count = (int)resolveValue(findInputInBlock(currentBlock,"TIMES"));
String substack = (String)findInputInBlock(currentBlock,"SUBSTACK");
logger.trace("REPEAT {}",count);
for(int i=0;i<count;++i) {
parseScratchCode(substack);
}
}
// relative change
private void changeVariableBy(JSONObject currentBlock) throws Exception {
Scratch3Variable v = getScratchVariable((String)findFieldsInBlock(currentBlock));
double newValue = resolveValue(findInputInBlock(currentBlock,"VALUE"));
// set and report
v.value = (double)v.value + newValue;
logger.trace("Set {} to {}", v.name, v.value);
}
// absolute change
private void setVariableTo(JSONObject currentBlock) throws Exception {
Scratch3Variable v = getScratchVariable((String)findFieldsInBlock(currentBlock));
// set and report
v.value = resolveValue(findInputInBlock(currentBlock,"VALUE"));
logger.trace("Set {} to {}", v.name, v.value);
}
private void doMotionGotoXY(JSONObject currentBlock) throws Exception {
double px = resolveValue(findInputInBlock(currentBlock,"X"));
double py = resolveValue(findInputInBlock(currentBlock,"Y"));
logger.trace("GOTO {} {}",px,py);
myTurtle.moveTo(px, py);
}
private void doMotionPointInDirection(JSONObject currentBlock) throws Exception {
double v = resolveValue(findInputInBlock(currentBlock,"DIRECTION"));
logger.trace("POINT AT {}",v);
myTurtle.setAngle(90.0-v);// axial symmetry of an axis having an angle of 45° see https://github.com/MarginallyClever/Makelangelo-software/issues/564#issuecomment-1046217070
}
private void doMotionTurnLeft(JSONObject currentBlock) throws Exception {
double v = resolveValue(findInputInBlock(currentBlock,"DEGREES"));
logger.trace("LEFT {}",v);
myTurtle.setAngle(myTurtle.getAngle()+v);//myTurtle.turn(v);
}
private void doMotionTurnRight(JSONObject currentBlock) throws Exception {
double v = resolveValue(findInputInBlock(currentBlock,"DEGREES"));
logger.trace("RIGHT {}",v);
myTurtle.setAngle(myTurtle.getAngle()-v);//myTurtle.turn(-v);
}
private void doMotionMoveSteps(JSONObject currentBlock) throws Exception {
double v = resolveValue(findInputInBlock(currentBlock,"STEPS"));
logger.trace("MOVE {}",v);
myTurtle.forward(v);
}
private void doMotionChangeX(JSONObject currentBlock) throws Exception {
double v = resolveValue(findInputInBlock(currentBlock,"DX"));
logger.trace("MOVE X {}",v);
myTurtle.moveTo(myTurtle.getX()+v,myTurtle.getY());
}
private void doMotionChangeY(JSONObject currentBlock) throws Exception {
double v = resolveValue(findInputInBlock(currentBlock,"DY"));
logger.trace("MOVE Y {}",v);
myTurtle.moveTo(myTurtle.getX(),myTurtle.getY()+v);
}
private void doMotionSetX(JSONObject currentBlock) throws Exception {
double v = resolveValue(findInputInBlock(currentBlock,"X"));
logger.trace("SET X {}",v);
myTurtle.moveTo(v,myTurtle.getY());
}
private void doMotionSetY(JSONObject currentBlock) throws Exception {
double v = resolveValue(findInputInBlock(currentBlock,"Y"));
logger.trace("SET Y {}",v);
myTurtle.moveTo(myTurtle.getX(),v);
}
boolean ignoreDoSetPenColor = false; // As setColor can bug the Makelangelo Render a quick/bad hack to enable/disable this implementation.
private void doSetPenColor(JSONObject currentBlock) throws Exception {
Color c = new Color((int)resolveValue(findInputInBlock(currentBlock,"COLOR")));
if ( !ignoreDoSetPenColor ){
logger.trace("SET COLOR {}",c);
myTurtle.setStroke(c);
}else{
logger.trace("SET COLOR {} ignored",c);
}
}
/**
* Find and return currentBlock/fields/subKey/(first element).
*
* @param currentBlock the block to search.
* @return the first element of currentBlock/inputs/subKey
*/
private Object findFieldsInBlock(JSONObject currentBlock) {
JSONObject inputs = currentBlock.getJSONObject("fields");
JSONArray subKeyArray = (JSONArray)inputs.get("VARIABLE");
return subKeyArray.get(1);
}
/**
* Find and return currentBlock/inputs/subKey/(first element).
* @param currentBlock the block to search.
* @param subKey the key name inside currentBlock.
* @return the first element of currentBlock/inputs/subKey
*/
private Object findInputInBlock(JSONObject currentBlock,String subKey) {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray subKeyArray = (JSONArray)inputs.get(subKey);
return subKeyArray.get(1);
}
/**
* Find and return currentBlock/mutation/subKey.
* @param currentBlock the block to search.
* @param subKey the key name inside currentBlock.
* @return the element currentBlock/mutation/subKey
* @throws Exception if any part of the operation fails, usually because of non-existent key.
*/
private Object findMutationInBlock(JSONObject currentBlock,String subKey) throws Exception {
JSONObject mutation = currentBlock.getJSONObject("mutation");
return mutation.get(subKey);
}
/**
* Find and return the variable with uniqueID. Search the top of myStack first, then the globals.
* @param uniqueID the id to match.
* @return the variable found.
* @throws Exception if variable not found.
*/
private Scratch3Variable getScratchVariable(String uniqueID) throws Exception {
if(!myStack.isEmpty()) {
for(Scratch3Variable sv : myStack.peek()) {
if(sv.uniqueID.equals(uniqueID)) return sv;
}
}
for(Scratch3Variable sv : scratchGlobalVariables) {
if(sv.uniqueID.equals(uniqueID)) return sv;
}
throw new Exception("Variable '"+uniqueID+"' not found.");
}
/**
* Confirm this is version 3
* @param tree the JSONObject tree read from the project.json/zip file.
*/
private boolean confirmAtLeastVersion3(JSONObject tree) {
JSONObject meta = (JSONObject)tree.get("meta"); // this cannot be getJSONObject because it changes the exception response.
if(meta==null) return false;
String semver = (String)meta.get("semver"); // this cannot be getJSONObject because it changes the exception response.
if(semver==null) return false;
return ( semver.compareTo("3.0.0") <= 0 );
}
private boolean confirmHasPenExtension(JSONObject tree) {
JSONArray extensions = (JSONArray)tree.get("extensions"); // this cannot be getJSONObject because it changes the exception response.
if(extensions==null) return false;
for (Object o : extensions) {
if (o instanceof String && o.equals("pen")) return true;
}
return false;
}
/**
* read the list of Scratch variables
* @param tree the JSONObject tree read from the project.json/zip file.
* @throws Exception
*/
private void readScratchVariables(JSONObject tree) throws Exception {
logger.trace("readScratchVariables");
scratchGlobalVariables = new Scratch3Variables();
JSONArray targets = tree.getJSONArray("targets");
for (Object target : targets) {
JSONObject targetN = (JSONObject) target;
if (!((Boolean) targetN.get("isStage"))) continue;
JSONObject variables = targetN.getJSONObject("variables");
for (String k : variables.keySet()) {
JSONArray details = variables.getJSONArray(k);
String name = details.getString(0);
Object valueUnknown = details.get(1);
Number value;
if (valueUnknown instanceof String) value = Double.parseDouble((String) valueUnknown);
else value = (Number) valueUnknown;
try {
double d = value.doubleValue();
logger.debug("Variable {} {}", name, d);
scratchGlobalVariables.add(new Scratch3Variable(name, k, d));
} catch (Exception e) {
throw new Exception("Variables must be numbers.", e);
}
}
}
}
/**
* read the list of Scratch lists
* @param tree the JSONObject tree read from the project.json/zip file.
* @throws Exception
*/
private void readScratchLists(JSONObject tree) throws Exception {
logger.trace("readScratchLists");
JSONArray targets = tree.getJSONArray("targets");
for (Object target : targets) {
JSONObject targetN = (JSONObject) target;
if (!((Boolean) targetN.get("isStage"))) continue;
JSONObject listOfLists = targetN.getJSONObject("lists");
if (listOfLists == null) return;
Set<?> keys = listOfLists.keySet();
for (Object o : keys) {
String key = (String) o;
logger.trace("list key:{}", key);
JSONArray elem = listOfLists.getJSONArray(key);
String listName = elem.getString(0);
logger.trace(" list name:{}", listName);
Object contents = elem.get(1);
Scratch3List list = new Scratch3List(listName);
// fill the list with any given contents
if ( contents instanceof JSONArray) {
JSONArray arr = (JSONArray) contents;
for (Object varValue : arr) {
double value;
if (varValue instanceof Number) {
Number num = (Number) varValue;
value = (float) num.doubleValue();
logger.trace(" list float:{}", value);
list.contents.add(value);
} else if (varValue instanceof String) {
try {
value = Double.parseDouble((String) varValue);
logger.trace(" list string:{}", value);
list.contents.add(value);
} catch (Exception e) {
throw new Exception("List variables must be numbers.", e);
}
} else
throw new Exception("List variable " + listName + "(" + list.contents.size() + ") is " + varValue.toString());
}
}
// add the list to the list-of-lists.
scratchLists.add(list);
}
}
}
/**
* Read in and store the description of procedures (methods)
* @throws Exception
*/
private void readScratchProcedures() throws Exception {
logger.trace("readScratchProcedures");
// find the blocks with opcode=procedures_definition.
for( String k : blockKeys ) {
String uniqueID = k.toString();
Object obj = blocks.get(uniqueID);
if(!(obj instanceof JSONObject)) continue;
JSONObject currentBlock = blocks.getJSONObject(uniqueID);
String opcode = currentBlock.getString("opcode");
if(opcode.equals("procedures_definition")) {
// the procedures_definition block points to the procedures_prototype block
JSONObject prototypeBlock = getBlock((String)findInputInBlock(currentBlock,"custom_block"));
// which contains the human-readable name of the procedure
String proccode = (String)findMutationInBlock(prototypeBlock,"proccode");
Scratch3Procedure p = new Scratch3Procedure(uniqueID, proccode);
scratchProcedures.add(p);
buildParameterListForProcedure(prototypeBlock,p);
logger.trace("procedure found: {}",p.toString());
}
}
}
private void buildParameterListForProcedure(JSONObject prototypeBlock, Scratch3Procedure p) throws Exception {
JSONArray argumentIDs = new JSONArray((String)findMutationInBlock(prototypeBlock,"argumentids"));
JSONArray argumentNames = new JSONArray((String)findMutationInBlock(prototypeBlock,"argumentnames"));
//JSONArray argumentDefaults = new JSONArray((String)findMutationInBlock(prototypeBlock,"argumentdefaults"));
for(int i=0;i<argumentIDs.length();++i) {
String uniqueID = argumentIDs.getString(i);
//String defaultValue = argumentDefaults.getString(i);
String name = argumentNames.getString(i);
p.parameters.add(new Scratch3Variable(name,uniqueID,0/*defaultValue*/));
// TODO set defaults?
}
}
/**
* Scratch block contains a boolean or boolean operator
* @param currentBlock a String, Number, or JSONArray of elements to be calculated.
* @return the calculated final value.
* @throws Exception when an upsupported opcode is found.
*/
private boolean resolveBoolean(JSONObject currentBlock) throws Exception {
if(currentBlock.has("opcode")) {
// is equation
String opcode = currentBlock.getString("opcode");
return switch (opcode) {
case "operator_lt" -> doLessThan(currentBlock);
case "operator_gt" -> doGreaterThan(currentBlock);
case "operator_equals" -> doEquals(currentBlock);
case "operator_and" -> doAnd(currentBlock);
case "operator_or" -> doOr(currentBlock);
case "operator_not" -> doNot(currentBlock);
default -> throw new Exception("resolveBoolean unsupported opcode " + opcode);
};
}
throw new Exception("Parse error (resolveBoolean missing opcode)");
}
private boolean doNot(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray OPERAND = inputs.getJSONArray("OPERAND");
boolean a = resolveBoolean(getBlock(OPERAND.getString(1)));
return !a;
}
private boolean doOr(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray OPERAND1 = inputs.getJSONArray("OPERAND1");
JSONArray OPERAND2 = inputs.getJSONArray("OPERAND2");
boolean a = resolveBoolean(getBlock(OPERAND1.getString(1)));
boolean b = resolveBoolean(getBlock(OPERAND2.getString(1)));
return a || b;
}
private boolean doAnd(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray OPERAND1 = inputs.getJSONArray("OPERAND1");
JSONArray OPERAND2 = inputs.getJSONArray("OPERAND2");
boolean a = resolveBoolean(getBlock(OPERAND1.getString(1)));
boolean b = resolveBoolean(getBlock(OPERAND2.getString(1)));
return a && b;
}
private boolean doEquals(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray OPERAND1 = inputs.getJSONArray("OPERAND1");
JSONArray OPERAND2 = inputs.getJSONArray("OPERAND2");
double a = resolveValue(OPERAND1.get(1));
double b = resolveValue(OPERAND2.get(1));
return a == b;
}
private boolean doGreaterThan(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray OPERAND1 = inputs.getJSONArray("OPERAND1");
JSONArray OPERAND2 = inputs.getJSONArray("OPERAND2");
double a = resolveValue(OPERAND1.get(1));
double b = resolveValue(OPERAND2.get(1));
return a > b;
}
private boolean doLessThan(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray OPERAND1 = inputs.getJSONArray("OPERAND1");
JSONArray OPERAND2 = inputs.getJSONArray("OPERAND2");
double a = resolveValue(OPERAND1.get(1));
double b = resolveValue(OPERAND2.get(1));
return a < b;
}
/**
* Scratch block contains an Operator (variable, constant, or math combination of the two).
* @param currentObject a String, Number, or JSONArray of elements to be calculated.
* @return the calculated final value.
* @throws Exception when an unknown value type is found.
*/
private double resolveValue(Object currentObject) throws Exception {
if(currentObject instanceof JSONArray) {
JSONArray currentArray = (JSONArray)currentObject;
return switch (currentArray.getInt(0)) {
case 4, 5, 6, 7, 8, 9, 10 ->
// 4 number
// 5 positive number
// 6 positive integer
// 7 integer
// 8 angle
// 9 color (#rrggbbaa)
// 10 string, try to parse as number
parseNumber(currentArray.get(1));
case 12 -> // 12 variable
(double) getScratchVariable(currentArray.getString(2)).value;
// 13 is list [name,id,x,y]
default -> throw new Exception("resolveValue unknown value type " + currentArray.getInt(0));
};
} else if(currentObject instanceof String) {
JSONObject currentBlock = getBlock((String)currentObject);
// is equation
String opcode = currentBlock.getString("opcode");
return switch (opcode) {
case "operator_add" -> doAdd(currentBlock);
case "operator_subtract" -> doSubstract(currentBlock);
case "operator_multiply" -> doMultiply(currentBlock);
case "operator_divide" -> doDivide(currentBlock);
case "operator_mod" -> doModulus(currentBlock);
case "operator_random" -> doRandom(currentBlock);
case "operator_mathop" -> doMathOp(currentBlock);
case "operator_round" -> doRound(currentBlock);
case "motion_direction" -> doMotionDirection();
case "motion_xposition" -> doMotionXPosition();
case "motion_yposition" -> doMotionYPosition();
case "argument_reporter_string_number", "argument_reporter_boolean" -> (double) doReporterStringValue(currentBlock);
default -> throw new Exception("resolveValue unsupported opcode " + opcode);
};
}
throw new Exception("resolveValue unknown object type "+currentObject.getClass().getSimpleName());
}
private double parseNumber(Object object) {
if(object instanceof String) {
String str = (String)object;
if(str.startsWith("#")) return (double)Integer.parseInt(str.substring(1),16);
return Double.parseDouble(str);
} else if(object instanceof Double)
return (double)object;
else //if(object instanceof Integer)
return (double)(int)object;
}
private double doAdd(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray NUM1 = inputs.getJSONArray("NUM1");
JSONArray NUM2 = inputs.getJSONArray("NUM2");
double a = resolveValue(NUM1.get(1));
double b = resolveValue(NUM2.get(1));
return a + b;
}
private double doSubstract(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray NUM1 = inputs.getJSONArray("NUM1");
JSONArray NUM2 = inputs.getJSONArray("NUM2");
double a = resolveValue(NUM1.get(1));
double b = resolveValue(NUM2.get(1));
return a - b;
}
private double doMultiply(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray NUM1 = inputs.getJSONArray("NUM1");
JSONArray NUM2 = inputs.getJSONArray("NUM2");
double a = resolveValue(NUM1.get(1));
double b = resolveValue(NUM2.get(1));
return a * b;
}
private double doDivide(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray NUM1 = inputs.getJSONArray("NUM1");
JSONArray NUM2 = inputs.getJSONArray("NUM2");
double a = resolveValue(NUM1.get(1));
double b = resolveValue(NUM2.get(1));
return a / b;
}
private double doModulus(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray NUM1 = inputs.getJSONArray("NUM1");
JSONArray NUM2 = inputs.getJSONArray("NUM2");
double a = resolveValue(NUM1.get(1));
double b = resolveValue(NUM2.get(1));
return a % b;
}
private double doRandom(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray FROM = inputs.getJSONArray("FROM");
JSONArray TO = inputs.getJSONArray("TO");
double a = resolveValue(FROM.get(1));
double b = resolveValue(TO.get(1));
return random.nextDouble() * (b-a) + a;
}
private double doRound(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray NUM = inputs.getJSONArray("NUM");
double a = resolveValue(NUM.get(1));
return Math.round(a);
}
private double doMathOp(JSONObject currentBlock) throws Exception {
JSONObject inputs = currentBlock.getJSONObject("inputs");
JSONArray NUM = inputs.getJSONArray("NUM");
double v = resolveValue(NUM.get(1));
JSONObject fields = currentBlock.getJSONObject("fields");
JSONArray OPERATOR = fields.getJSONArray("OPERATOR");
return switch (OPERATOR.getString(0)) {
case "abs" -> Math.abs(v);
case "floor" -> Math.floor(v);
case "ceiling" -> Math.ceil(v);
case "sqrt" -> Math.sqrt(v);
case "sin" -> Math.sin(Math.toRadians(v));
case "cos" -> Math.cos(Math.toRadians(v));
case "tan" -> Math.tan(Math.toRadians(v));
case "asin" -> Math.asin(Math.toRadians(v));
case "acos" -> Math.acos(Math.toRadians(v));
case "atan" -> Math.atan(Math.toRadians(v));
case "ln" -> Math.log(v);
case "log" -> Math.log10(v);
case "e ^" -> Math.exp(v);
case "10 ^" -> Math.pow(10, v);
default -> throw new Exception("doMathOp unknown operator " + OPERATOR.getString(1));
};
}
private double doMotionDirection() {
return myTurtle.getAngle();
}
private double doMotionXPosition() {
return myTurtle.getX();
}
private double doMotionYPosition() {
return myTurtle.getY();
}
private Object doReporterStringValue(JSONObject currentBlock) throws Exception {
String name = currentBlock.getJSONObject("fields").getJSONArray("VALUE").getString(0);
if(!myStack.isEmpty()) {
for(Scratch3Variable sv : myStack.peek()) {
if(sv.name.equals(name)) return sv.value;
}
}
throw new Exception("Variable '"+name+"' not found.");
}
private int getListID(Object obj) throws Exception {
if(!(obj instanceof String)) throw new Exception("List name not a string.");
String listName = obj.toString();
int index=0;
for (Scratch3List i : scratchLists) {
if (i.name.equals(listName)) return index;
++index;
}
throw new Exception("List '"+listName+"' not found.");
}
/**
* Find the requested index in a list.
* @param o2 the index value. could be "random", "last", or an index number
* @param o3 the list name.
* @return the resolved value as an integer.
* @throws Exception
*/
@SuppressWarnings("unused")
private int resolveListIndex(Object o2,Object o3) throws Exception {
String index = (String)o2;
String listName = (String)o3;
Scratch3List list = scratchLists.get(getListID(listName));
int listIndex;
if(index.equals("last")) {
listIndex = list.contents.size()-1;
} else if(index.equals("random")) {
listIndex = (int) (random.nextDouble() * list.contents.size());
} else {
listIndex = Integer.parseInt(index);
}
return listIndex;
}
}
3a472ecb4This file is pinned to the selected release. Download the original to open it in your design tool.