update 1.1.2 and add new block

added block CCRedstone and CCRednet
and CCTurtle is finished

blocks/CCRednet/block_design.json

@@ -0,0 +1,177 @@
+{
+    "rednet_open": {
+        "message0": "Open modem at %1 of computer",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["All", "all"],
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 20,
+        "tooltip": "Opens a modem with the given peripheral name, allowing it to send and receive messages over rednet."
+    },
+    "rednet_close": {
+        "message0": "Close modem at %1 of computer",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["All", "all"],
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 20,
+        "tooltip": "Opens a modem with the given peripheral name, allowing it to send and receive messages over rednet."
+    },
+    "rednet_isopen": {
+        "message0": "Is modem at %1 of computer",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["All", "all"],
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": "Boolean",
+        "colour": 20,
+        "tooltip": "Determine if rednet is currently open."
+    },
+    "rednet_send": {
+        "message0": "Send %1 to computer id %2 with protocol %3",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DATA"
+            },
+            {
+                "type": "input_value",
+                "name": "ID",
+                "check": "Number"
+            },
+            {
+                "type": "input_value",
+                "name": "PROTO",
+                "check": "String"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 20,
+        "tooltip": "Allows a computer or turtle with an attached modem to send a message intended for a computer with a specific ID."
+    },
+    "rednet_broadcast": {
+        "message0": "Broadcast %1 with protocol %2",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DATA"
+            },
+            {
+                "type": "input_value",
+                "name": "PROTO",
+                "check": "String"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 20,
+        "tooltip": "Broadcasts a string message over the predefined CHANNEL_BROADCAST channel."
+    },
+    "rednet_receive": {
+        "message0": "Receive data with protocol %1 and timeout waiting for %2",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "PROTO",
+                "check": "String"
+            },
+            {
+                "type": "input_value",
+                "name": "TIMEOUT",
+                "check": "Number"
+            }
+        ],
+        "output": "Multiple",
+        "colour": 20,
+        "tooltip": "Wait for a rednet message to be received, or until nTimeout seconds have elapsed."
+    },
+    "rednet_host": {
+        "message0": "Start Host protocol %1 with hostname %2",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "PROTO",
+                "check": "String"
+            },
+            {
+                "type": "input_value",
+                "name": "NAME",
+                "check": "String"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 20,
+        "tooltip": "Register the system as 'hosting' the desired protocol under the specified name."
+    },
+    "rednet_unhost": {
+        "message0": "Stop Host protocol %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "PROTO",
+                "check": "String"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 20,
+        "tooltip": "Stop hosting a specific protocol, meaning it will no longer respond to rednet.lookup requests."
+    },
+    "rednet_lookup": {
+        "message0": "Find Hostname %1 with protocol %2",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "NAME",
+                "check": "String"
+            },
+            {
+                "type": "input_value",
+                "name": "PROTO",
+                "check": "String"
+            }
+        ],
+        "output": "Number",
+        "colour": 20,
+        "tooltip": "Search the local rednet network for systems hosting the desired protocol and returns any computer IDs that respond as 'registered' against it."
+    }
+}

blocks/CCRednet/generator.js

@@ -0,0 +1,94 @@
+const { luaGenerator } = require('blockly/lua');
+
+// Check if luaGenerator.forBlock is defined and initialize if necessary
+if (!luaGenerator.forBlock) {
+    luaGenerator.forBlock = {};
+}
+
+luaGenerator.forBlock['rednet_open'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+
+    var code = '';
+    if (side == "all") {
+        code = `peripheral.find("modem", rednet.open)`;
+    } else {
+        code = `rednet.open("${side}")`
+    }
+
+    return code + "\n";
+};
+
+luaGenerator.forBlock['rednet_close'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+
+    var code = '';
+    if (side == "all") {
+        code = `peripheral.find("modem", rednet.close)`;
+    } else {
+        code = `rednet.close("${side}")`
+    }
+
+    return code + "\n";
+};
+
+luaGenerator.forBlock['rednet_isopen'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+
+    var code = '';
+    if (side == "all") {
+        code = `rednet.isOpen()`;
+    } else {
+        code = `rednet.isOpen("${side}")`
+    }
+
+    return [code, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['rednet_send'] = function(block, generator) {
+    var data = generator.valueToCode(block, 'DATA', generator.ORDER_NONE);
+    var id = generator.valueToCode(block, 'ID', generator.ORDER_NONE);
+    var protocol = generator.valueToCode(block, 'PROTO', generator.ORDER_NONE);
+
+    return `rednet.send(${id}, ${data}, ${protocol})\n`;
+};
+
+luaGenerator.forBlock['rednet_broadcast'] = function(block, generator) {
+    var data = generator.valueToCode(block, 'DATA', generator.ORDER_NONE);
+    var protocol = generator.valueToCode(block, 'PROTO', generator.ORDER_NONE);
+
+    return `rednet.broadcast(${data}, ${protocol})\n`;
+};
+
+luaGenerator.forBlock['rednet_receive'] = function(block, generator) {
+    var protocol = generator.valueToCode(block, 'PROTO', generator.ORDER_NONE);
+    var timeout = generator.valueToCode(block, 'TIMEOUT', generator.ORDER_NONE);
+
+    var code = '';
+    if (timeout == 0) {
+        code = `rednet.receive(${protocol})`
+    } else {
+        code = `rednet.receive(${protocol}, ${timeout})`
+    }
+
+    return [code, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['rednet_host'] = function(block, generator) {
+    var protocol = generator.valueToCode(block, 'PROTO', generator.ORDER_NONE);
+    var hostname = generator.valueToCode(block, 'NAME', generator.ORDER_NONE);
+
+    return `rednet.host(${protocol}, ${hostname})\n`;
+};
+
+luaGenerator.forBlock['rednet_unhost'] = function(block, generator) {
+    var protocol = generator.valueToCode(block, 'PROTO', generator.ORDER_NONE);
+
+    return `rednet.unhost(${protocol})\n`;
+};
+
+luaGenerator.forBlock['rednet_lookup'] = function(block, generator) {
+    var protocol = generator.valueToCode(block, 'PROTO', generator.ORDER_NONE);
+    var hostname = generator.valueToCode(block, 'NAME', generator.ORDER_NONE);
+
+    return [`rednet.lookup(${protocol}, ${hostname})`, luaGenerator.ORDER_NONE];
+};

blocks/CCRednet/index.json

@@ -0,0 +1,22 @@
+{
+    "name": "Rednet",
+    "author": "DPSoftware Foundation",
+    "description": "Library for rednet",
+    "version": "1.0.0",
+    "category": "Network",
+    "keyword": "Rednet",
+    "license": "GPL-3.0-or-later",
+    "peripherals": true,
+    "library": true,
+    "require_network": false,
+    "dependencies": {},
+    "design_for_computer": {
+        "basic": true,
+        "adv": true, 
+        "command": true,
+        "pocket": true,
+        "advpocket": true,
+        "turtle": true,
+        "advturtle": true
+    }
+}

blocks/CCRednet/toolbox.xml

@@ -0,0 +1,64 @@
+<xml id="toolbox" style="display: none;">
+    <category name="Rednet" colour="20">
+        <block type="rednet_open"></block>
+        <block type="rednet_close"></block>
+        <block type="rednet_isopen"></block>
+        <block type="rednet_send">
+            <value name="PROTO">
+                <shadow type="text">
+                    <field name="TEXT">default</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="rednet_broadcast">
+            <value name="PROTO">
+                <shadow type="text">
+                    <field name="TEXT">default</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="rednet_receive">
+            <value name="PROTO">
+                <shadow type="text">
+                    <field name="TEXT">default</field>
+                </shadow>
+            </value>
+            <value name="TIMEOUT">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="rednet_host">
+            <value name="PROTO">
+                <shadow type="text">
+                    <field name="TEXT">default</field>
+                </shadow>
+            </value>
+            <value name="NAME">
+                <shadow type="text">
+                    <field name="TEXT">SomeName</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="rednet_unhost">
+            <value name="PROTO">
+                <shadow type="text">
+                    <field name="TEXT">default</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="rednet_lookup">
+            <value name="NAME">
+                <shadow type="text">
+                    <field name="TEXT">SomeName</field>
+                </shadow>
+            </value>
+            <value name="PROTO">
+                <shadow type="text">
+                    <field name="TEXT">default</field>
+                </shadow>
+            </value>
+        </block>
+    </category>
+</xml>

blocks/CCRedstone/block_design.json

@@ -0,0 +1,137 @@
+{
+    "redstone_set_output": {
+        "message0": "Set redstone %1 at %2 of computer",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "STATE",
+                "options": [
+                    ["On", "OFF"],
+                    ["Off", "ON"]
+                ]
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 10,
+        "tooltip": "Turn the redstone signal of a specific side on or off."
+    },
+    "redstone_get_output": {
+        "message0": "Get redstone output at %1 of computer",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": "Boolean",
+        "colour": 10,
+        "tooltip": "Get the current redstone output of a specific side."
+    },
+    "redstone_read_input": {
+        "message0": "Read redstone input at %1 of computer",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": "Boolean",
+        "colour": 10,
+        "tooltip": "Get the current redstone input of a specific side."
+    },
+    "redstone_set_analog_output": {
+        "message0": "Set redstone analog with power %1 at %2 of computer",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "POWER",
+                "check": "Number"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 10,
+        "tooltip": "Set the redstone signal strength for a specific side."
+    },
+    "redstone_get_analog_output": {
+        "message0": "Get redstone analog output at %1 of computer",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 10,
+        "tooltip": "Get the redstone output signal strength for a specific side."
+    },
+    "redstone_read_analog_input": {
+        "message0": "Read redstone analog output at %1 of computer",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 10,
+        "tooltip": "Get the redstone input signal strength for a specific side."
+    }
+}

blocks/CCRedstone/generator.js

@@ -0,0 +1,50 @@
+const { luaGenerator } = require('blockly/lua');
+
+// Check if luaGenerator.forBlock is defined and initialize if necessary
+if (!luaGenerator.forBlock) {
+    luaGenerator.forBlock = {};
+}
+
+luaGenerator.forBlock['redstone_set_output'] = function(block, generator) {
+    var state = block.getFieldValue('STATE');
+    var side = block.getFieldValue('SIDE');
+    
+    if (state == "OFF") {
+        var code = `rs.setOutput("${side}", true)`;
+    } else {
+        var code = `rs.setOutput("${side}", false)`;
+    }
+
+    return code + "\n";
+};
+
+luaGenerator.forBlock['redstone_get_output'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return [`rs.getOutput("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['redstone_read_input'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return [`rs.getInput("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['redstone_set_analog_output'] = function(block, generator) {
+    var power = generator.valueToCode(block, 'POWER', generator.ORDER_NONE);
+    var side = block.getFieldValue('SIDE');
+    
+    return `rs.setAnalogOutput("${side}", ${power})\n`;
+};
+
+luaGenerator.forBlock['redstone_get_analog_output'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return `rs.getAnalogOutput("${side}")\n`;
+};
+
+luaGenerator.forBlock['redstone_read_analog_input'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return `rs.getAnalogInput("${side}")\n`;
+};

blocks/CCRedstone/index.json

@@ -0,0 +1,22 @@
+{
+    "name": "CC: Redstone",
+    "author": "DPSoftware Foundation",
+    "description": "Library for control redstone",
+    "version": "1.0.0",
+    "category": "Power",
+    "keyword": "Redstone",
+    "license": "GPL-3.0-or-later",
+    "peripherals": false,
+    "library": true,
+    "require_network": false,
+    "dependencies": {},
+    "design_for_computer": {
+        "basic": true,
+        "adv": true, 
+        "command": true,
+        "pocket": false,
+        "advpocket": false,
+        "turtle": false,
+        "advturtle": false
+    }
+}

blocks/CCRedstone/toolbox.xml

@@ -0,0 +1,16 @@
+<xml id="toolbox" style="display: none;">
+    <category name="Redstone" colour="10">
+        <block type="redstone_set_output"></block>
+        <block type="redstone_get_output"></block>
+        <block type="redstone_read_input"></block>
+        <block type="redstone_set_analog_output">
+            <value name="POWER">
+                <shadow type="math_number">
+                    <field name="NUM">15</field> 
+                </shadow>
+            </value>
+        </block>
+        <block type="redstone_get_analog_output"></block>
+        <block type="redstone_read_analog_input"></block>
+    </category>
+</xml>

blocks/CCTurtle/block_design.json

@@ -63,8 +63,8 @@
                 "type": "field_dropdown",
                 "name": "SIDE",
                 "options": [
-                    ["Left", "LEFT"],
-                    ["Right", "RIGHT"]
+                    ["Left", "left"],
+                    ["Right", "right"]
                 ]
             }
         ],
@@ -90,8 +90,8 @@
                 "type": "field_dropdown",
                 "name": "SIDE",
                 "options": [
-                    ["Left", "LEFT"],
-                    ["Right", "RIGHT"]
+                    ["Left", "left"],
+                    ["Right", "right"]
                 ]
             }
         ],
@@ -376,7 +376,8 @@
             }
         ],
         "inputsInline": true,
-        "output": "Multiple",
+        "previousStatement": null,
+        "nextStatement": null,
         "colour": 215,
         "tooltip": "Craft a recipe based on the turtle's inventory."
     }

blocks/CCTurtle/generator.js

@@ -5,54 +5,350 @@ if (!luaGenerator.forBlock) {
     luaGenerator.forBlock = {};
 }
 
-// Math operation block
-luaGenerator.forBlock['math_operation'] = function(block, generator) {
-    var operator = block.getFieldValue('OPERATOR');
-    var num1 = generator.valueToCode(block, 'NUM1', generator.ORDER_ATOMIC);
-    var num2 = generator.valueToCode(block, 'NUM2', generator.ORDER_ATOMIC);
+luaGenerator.forBlock['turtle_move_operation'] = function(block, generator) {
+    var operator = block.getFieldValue('OPERATION');
+    var FOR = generator.valueToCode(block, 'FOR', generator.ORDER_ATOMIC);
 
-    var operatorSymbol = '';
+    var movecommand = '';
     switch (operator) {
-        case 'ADD':
-            operatorSymbol = '+';
+        case 'FORWARD':
+            movecommand = 'turtle.forward()';
             break;
-        case 'SUBTRACT':
-            operatorSymbol = '-';
+        case 'BACK':
+            movecommand = 'turtle.back()';
             break;
-        case 'MULTIPLY':
-            operatorSymbol = '*';
+        case 'UP':
+            movecommand = 'turtle.up()';
             break;
-        case 'DIVIDE':
-            operatorSymbol = '/';
+        case 'DOWN':
+            movecommand = 'turtle.down()';
             break;
         default:
-            operatorSymbol = '+';
+            movecommand = 'turtle.forward()';
+            break;
+    }
+    if (FOR == 1) {
+        var code = movecommand;
+    } else {
+        var code = `for i=${FOR},1,-1 do ${movecommand} end`;
+    };
+
+    return code + "\n";
+};
+
+luaGenerator.forBlock['turtle_turn_operation'] = function(block, generator) {
+    var operator = block.getFieldValue('OPERATION');
+    var FOR = generator.valueToCode(block, 'ROUND', generator.ORDER_ATOMIC);
+
+    var movecommand = '';
+    switch (operator) {
+        case 'LEFT':
+            movecommand = 'turtle.turnLeft()';
+            break;
+        case 'RIGHT':
+            movecommand = 'turtle.turnRight()';
+            break;
+        default:
+            movecommand = 'turtle.turnLeft()';
+            break;
+    }
+    if (FOR == 1) {
+        var code = movecommand;
+    } else {
+        var code = `for i=${FOR},1,-1 do ${movecommand} end`;
+    };
+    
+    return code + "\n";
+};
+
+luaGenerator.forBlock['turtle_turn_operation'] = function(block, generator) {
+    var operator = block.getFieldValue('OPERATION');
+    var FOR = generator.valueToCode(block, 'ROUND', generator.ORDER_ATOMIC);
+
+    var movecommand = '';
+    switch (operator) {
+        case 'LEFT':
+            movecommand = 'turtle.turnLeft()';
+            break;
+        case 'RIGHT':
+            movecommand = 'turtle.turnRight()';
+            break;
+        default:
+            movecommand = 'turtle.turnLeft()';
+            break;
+    }
+    if (FOR == 1) {
+        var code = movecommand;
+    } else {
+        var code = `for i=${FOR},1,-1 do ${movecommand} end`;
+    };
+    
+    return code + "\n";
+};
+
+luaGenerator.forBlock['turtle_dig_operation'] = function(block, generator) {
+    var operator = block.getFieldValue('OPERATION');
+    var side = block.getFieldValue('SIDE');
+
+    var code = '';
+    switch (operator) {
+        case 'FRONT':
+            code = `turtle.dig("${side}")`;
+            break;
+        case 'UP':
+            code = `turtle.digUp("${side}")`;
+            break;
+        case 'DOWN':
+            code = `turtle.digDown("${side}")`;
+            break;
+        default:
+            code = `turtle.dig("${side}")`;
             break;
     }
     
-    var code = `${num1} ${operatorSymbol} ${num2}`;
-    return [code, generator.ORDER_ATOMIC];
+    return code + "\n";
 };
 
-// Print text block
-luaGenerator.forBlock['text_print'] = function(block, generator) {
-    var text = generator.valueToCode(block, 'TEXT', generator.ORDER_NONE) || '\'\'';
-    var code = `print(${text})\n`;
-    return code;
+luaGenerator.forBlock['turtle_attack_operation'] = function(block, generator) {
+    var operator = block.getFieldValue('OPERATION');
+    var side = block.getFieldValue('SIDE');
+
+    var code = '';
+    switch (operator) {
+        case 'FRONT':
+            code = `turtle.attack("${side}")`;
+            break;
+        case 'UP':
+            code = `turtle.attackUp("${side}")`;
+            break;
+        case 'DOWN':
+            code = `turtle.attackDown("${side}")`;
+            break;
+        default:
+            code = `turtle.attack("${side}")`;
+            break;
+    }
+    
+    return code + "\n";
 };
 
-// If condition block
-luaGenerator.forBlock['controls_if'] = function(block, generator) {
-    var condition = generator.valueToCode(block, 'IF0', generator.ORDER_NONE) || 'false';
-    var branch = generator.statementToCode(block, 'DO0');
-    var code = `if ${condition} then\n${branch}\nend\n`;
-    return code;
+luaGenerator.forBlock['turtle_place_operation'] = function(block, generator) {
+    var operator = block.getFieldValue('OPERATION');
+
+    var code = '';
+    switch (operator) {
+        case 'FRONT':
+            code = `turtle.place()`;
+            break;
+        case 'UP':
+            code = `turtle.placeUp()`;
+            break;
+        case 'DOWN':
+            code = `turtle.placeDown()`;
+            break;
+        default:
+            code = `turtle.place()`;
+            break;
+    }
+    
+    return code + "\n";
 };
 
-// Set variable block
-luaGenerator.forBlock['variables_set'] = function(block, generator) {
-    var variable = generator.nameDB_.getName(block.getFieldValue('VAR'), Blockly.Variables.NAME_TYPE);
-    var value = generator.valueToCode(block, 'VALUE', generator.ORDER_NONE) || '0';
-    var code = `${variable} = ${value}\n`;
-    return code;
+luaGenerator.forBlock['turtle_drop_operation'] = function(block, generator) {
+    var operator = block.getFieldValue('OPERATION');
+    var count = generator.valueToCode(block, 'COUNT', generator.ORDER_ATOMIC);
+
+    var code = '';
+    switch (operator) {
+        case 'FRONT':
+            code = `turtle.drop(${count})`;
+            break;
+        case 'UP':
+            code = `turtle.dropUp(${count})`;
+            break;
+        case 'DOWN':
+            code = `turtle.dropDown(${count})`;
+            break;
+        default:
+            code = `turtle.drop(${count})`;
+            break;
+    }
+    
+    return code + "\n";
+};
+
+luaGenerator.forBlock['turtle_select_item'] = function(block, generator) {
+    var slot = generator.valueToCode(block, 'SLOT', generator.ORDER_ATOMIC);
+
+    return `turtle.select(${slot})\n`;
+};
+
+luaGenerator.forBlock['turtle_get_item_count'] = function(block, generator) {
+    var slot = generator.valueToCode(block, 'SLOT', generator.ORDER_ATOMIC);
+
+    return [`turtle.getItemCount(${slot})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['turtle_get_slot_free'] = function(block, generator) {
+    var slot = generator.valueToCode(block, 'SLOT', generator.ORDER_ATOMIC);
+
+    return [`turtle.getItemSpace(${slot})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['turtle_detect_block'] = function(block, generator) {
+    var operator = block.getFieldValue('OPERATION');
+
+    var code = '';
+    switch (operator) {
+        case 'FRONT':
+            code = `turtle.detect()`;
+            break;
+        case 'UP':
+            code = `turtle.detectUp()`;
+            break;
+        case 'DOWN':
+            code = `turtle.detectDown()`;
+            break;
+        default:
+            code = `turtle.detect()`;
+            break;
+    }
+    
+    return [code, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['turtle_compare_item'] = function(block, generator) {
+    var operator = block.getFieldValue('OPERATION');
+
+    var code = '';
+    switch (operator) {
+        case 'FRONT':
+            code = `turtle.compare()`;
+            break;
+        case 'UP':
+            code = `turtle.compareUp()`;
+            break;
+        case 'DOWN':
+            code = `turtle.compareDown()`;
+            break;
+        default:
+            code = `turtle.compare()`;
+            break;
+    }
+    
+    return [code, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['turtle_collect_item'] = function(block, generator) {
+    var count = generator.valueToCode(block, 'COUNT', generator.ORDER_ATOMIC);
+    var operator = block.getFieldValue('OPERATION');
+
+    var code = '';
+    switch (operator) {
+        case 'FRONT':
+            code = `turtle.suck(${count})`;
+            break;
+        case 'UP':
+            code = `turtle.suckUp(${count})`;
+            break;
+        case 'DOWN':
+            code = `turtle.suckDown(${count})`;
+            break;
+        default:
+            code = `turtle.suck(${count})`;
+            break;
+    }
+    
+    return code + "\n";
+};
+
+luaGenerator.forBlock['turtle_get_fuel_level'] = function(block) {
+    return ["turtle.getFuelLevel()", luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['turtle_refuel'] = function(block, generator) {
+    var count = generator.valueToCode(block, 'COUNT', generator.ORDER_ATOMIC);
+
+    if (count == 0) {
+        var code = "turtle.refuel()"
+    } else {
+        var code = `turtle.refuel(${count})`
+    }
+
+    return code + "\n";
+};
+
+luaGenerator.forBlock['turtle_compare_to'] = function(block, generator) {
+    var slot = generator.valueToCode(block, 'SLOT', generator.ORDER_ATOMIC);
+
+    return [`turtle.compareTo(${slot})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['turtle_transfer_to'] = function(block, generator) {
+    var slot = generator.valueToCode(block, 'SLOT', generator.ORDER_ATOMIC);
+    var count = generator.valueToCode(block, 'COUNT', generator.ORDER_ATOMIC);
+
+    return `turtle.transferTo(${slot}, ${count})\n`;
+};
+
+luaGenerator.forBlock['turtle_get_selected_slot'] = function(block) {
+    return [`turtle.getSelectedSlot()`, luaGenerator.ORDER_NONE];
+};
+
+
+luaGenerator.forBlock['turtle_get_fuel_limit'] = function(block) {
+    return [`turtle.getFuelLimit()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['turtle_equip'] = function(block) {
+    var side = block.getFieldValue('SIDE');
+
+    var code = '';
+    switch (side) {
+        case 'LEFT':
+            code = `turtle.equipLeft()`;
+            break;
+        case 'RIGHT':
+            code = `turtle.equipRight()	`;
+            break;
+        default:
+            code = `turtle.equipLeft()`;
+            break;
+    }
+
+    return [code, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['turtle_inspect'] = function(block) {
+    var operator = block.getFieldValue('OPERATION');
+
+    var code = '';
+    switch (operator) {
+        case 'FRONT':
+            code = `turtle.inspect()`;
+            break;
+        case 'UP':
+            code = `turtle.inspectUp()`;
+            break;
+        case 'DOWN':
+            code = `turtle.inspectDown()`;
+            break;
+        default:
+            code = `turtle.inspect()`;
+            break;
+    }
+    
+    return [code, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['turtle_get_item_detail'] = function(block, generator) {
+    var slot = generator.valueToCode(block, 'SLOT', generator.ORDER_ATOMIC);
+
+    return [`turtle.getItemDetail(${slot})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['turtle_craft'] = function(block, generator) {
+    var limit = generator.valueToCode(block, 'LIMIT', generator.ORDER_ATOMIC);
+
+    return `turtle.craft(${limit})\n`;
 };

blocks/CCTurtle/index.json

@@ -2,7 +2,7 @@
     "name": "CC: Turtle",
     "author": "DPSoftware Foundation",
     "description": "Library for control turtle",
-    "version": "0.1",
+    "version": "1.0",
     "category": "turtle",
     "keyword": "turtle",
     "license": "GPL-3.0-or-later",

blocks/CCTurtle/toolbox.xml

@@ -65,19 +65,19 @@
         <block type="turtle_compare_to">
             <value name="SLOT">
                 <shadow type="math_number">
-                    <field name="NUM">1</field> <!-- If 0 it refuel unlimit from current item-->
+                    <field name="NUM">1</field>
                 </shadow>
             </value>
         </block>
         <block type="turtle_transfer_to">
             <value name="SLOT">
                 <shadow type="math_number">
-                    <field name="NUM">1</field> <!-- If 0 it refuel unlimit from current item-->
+                    <field name="NUM">1</field> 
                 </shadow>
             </value>
             <value name="COUNT">
                 <shadow type="math_number">
-                    <field name="NUM">64</field> <!-- If 0 it refuel unlimit from current item-->
+                    <field name="NUM">64</field> 
                 </shadow>
             </value>
         </block>
@@ -85,7 +85,13 @@
         <block type="turtle_get_fuel_limit"></block>
         <block type="turtle_equip"></block>
         <block type="turtle_inspect"></block>
-        <block type="turtle_get_item_detail"></block>
+        <block type="turtle_get_item_detail">
+            <value name="SLOT">
+                <shadow type="math_number">
+                    <field name="NUM">1</field> 
+                </shadow>
+            </value>
+        </block>
         <block type="turtle_craft">
             <value name="LIMIT">
                 <shadow type="math_number">

readme.md

@@ -1,3 +1,5 @@
+[![wakatime](https://wakatime.com/badge/user/0e729f00-081a-41e0-ab17-b9ac6abfc334/project/e9e0d6a6-dfaf-46d0-bb77-e1f7127e7fb4.svg)](https://wakatime.com/badge/user/0e729f00-081a-41e0-ab17-b9ac6abfc334/project/e9e0d6a6-dfaf-46d0-bb77-e1f7127e7fb4)
+
 # ComputerCraft IDE (ccIDE)
 ccIDE is block based programming for ComputerCraft lua.
 

src/module_block_design.json

@@ -13,5 +13,45 @@
         "colour": 120,
         "tooltip": "Sleep command",
         "helpUrl": ""
+    },
+    "sys_utils_table_variable_pack": {
+        "message0": "Pack %1 to Table",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "RETURN_ARGS",
+                "check": "Multiple"
+            }
+        ],
+        "output": "Array",
+        "colour": 220
+    },
+    "sys_utils_get_value_from_table_with_index": {
+        "message0": "UnPack %1 to Value with index/key %2",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "TABLE",
+                "check": "Array"
+            },
+            {
+                "type": "input_value",
+                "name": "INDEX",
+                "check": ["Number", "String"]
+            }
+        ],
+        "output": null,
+        "colour": 220
+    },
+    "sys_utils_get_type": {
+        "message0": "Get type of %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "INPUT"
+            }
+        ],
+        "output": "String",
+        "colour": 220
     }
 }

src/module_generator.js

@@ -12,3 +12,22 @@ luaGenerator.forBlock['sys_sleep'] = function(block, generator) {
     var code = `sleep(${sleepfor})\n`;
     return code;
 };
+
+luaGenerator.forBlock['sys_utils_table_variable_pack'] = function(block, generator) {
+    var args = generator.valueToCode(block, 'RETURN_ARGS', generator.ORDER_NONE);
+
+    return [`{${args}}`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['sys_utils_get_value_from_table_with_index'] = function(block, generator) {
+    var table = generator.valueToCode(block, 'TABLE', generator.ORDER_NONE);
+    var index = generator.valueToCode(block, 'INDEX', generator.ORDER_NONE);
+
+    return [`${table}[${index}]`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['sys_utils_get_type'] = function(block, generator) {
+    var input = generator.valueToCode(block, 'INPUT', generator.ORDER_NONE);
+
+    return [`type(${input})`, luaGenerator.ORDER_NONE];
+};

src/toolbox.xml

@@ -1,4 +1,15 @@
 <xml id="toolbox" style="display: none;">
+    <category name="Utils" colour="220">
+        <block type="sys_utils_table_variable_pack"></block>
+        <block type="sys_utils_get_value_from_table_with_index">
+            <value name="INDEX">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="sys_utils_get_type"></block>
+    </category>
     <category name="Control" colour="38">
         <block type="sys_sleep">
             <value name="SLEEPSEC">

src/virtualcode.js

@@ -99,9 +99,11 @@ ipc.on('load-workspace', (event, json) => {
                     }
                 }
             }
+            setTimeout(() => {
                 Blockly.serialization.workspaces.load(data.content, workspace);
                 isprojectsaved = true
                 document.getElementById('statusMessage').textContent = `Project Loaded`;
+            }, 100);
         } 
     } catch (e) {
         document.getElementById('statusMessage').textContent = `Can't Load Project: ${e}`;