update ui and webpack

support multiple upload to machine and make remote script to one file and support to run on startup

.gitignore

@@ -1,4 +1,6 @@
 node_modules/
 .mcattributes
 package-lock.json
-dist/
+dist/
+dist_debug/
+ccIDE.wheel

TestProject/advperipherals energy detector (example 2).ccp

@@ -0,0 +1 @@
+{"usedlibrary":["Advanced_Peripherals","CCPeripheral"],"content":{"blocks":{"languageVersion":0,"blocks":[{"type":"ide_start","id":"ricNE5%Z`fhO08w3_ys?","x":101,"y":245,"inputs":{"DO":{"block":{"type":"variables_set","id":"eI39:+.u@(!5%kvtO;:%","fields":{"VAR":{"id":"*{7i9]pPQ]SdxwKC$?3g"}},"inputs":{"VALUE":{"block":{"type":"peripheral_wrap","id":"I@})D:bWyuA*FB8JA._Q","inputs":{"NAME":{"block":{"type":"text","id":"$.|TXypr(p,O?j+AyxG}","fields":{"TEXT":"back"}}}}}}},"next":{"block":{"type":"text_print","id":"`pV-P7(5sAFfu.Rw#?*0","inputs":{"TEXT":{"shadow":{"type":"text","id":"LWM*Dzq9*nJOE2aHlE!:","fields":{"TEXT":"Hello World!"}},"block":{"type":"advanced_peripherals_energy_detector_get_transfer_rate","id":",t1ePaKNhwgjj8*NxTv4","inputs":{"DETECTOR":{"block":{"type":"variables_get","id":"*CXv^ZN2(,0/M{AAYCqd","fields":{"VAR":{"id":"*{7i9]pPQ]SdxwKC$?3g"}}}}}}}},"next":{"block":{"type":"controls_for","id":"4!(mnA6g%G=~D3O|::Vm","fields":{"VAR":{"id":"RxOxb]Cq?^Fl%TPEReQg"}},"inputs":{"FROM":{"shadow":{"type":"math_number","id":"Dd_i)gS(=_5Z^A+WFwlC","fields":{"NUM":1}}},"TO":{"shadow":{"type":"math_number","id":"-C7.z0)cwU2m=Nkai:?t","fields":{"NUM":5500000}}},"BY":{"shadow":{"type":"math_number","id":"0XKg00ZWP)J21Ml;r3zY","fields":{"NUM":10000}}},"DO":{"block":{"type":"advanced_peripherals_energy_detector_set_transfer_rate_limit","id":"LUW1R-c8QnslP9ZkHe^i","inputs":{"TFRLIMIT":{"shadow":{"type":"math_number","id":"ihxhw[%G_?YGmGNHhNn~","fields":{"NUM":512}},"block":{"type":"variables_get","id":"zdca/5P:G=R-/1Jn7~6i","fields":{"VAR":{"id":"RxOxb]Cq?^Fl%TPEReQg"}}}},"DETECTOR":{"block":{"type":"variables_get","id":"R+t`O{nwP2m`h;00zn$S","fields":{"VAR":{"id":"*{7i9]pPQ]SdxwKC$?3g"}}}}},"next":{"block":{"type":"text_print","id":"y:t@#1T=P?#7On+oP!vk","inputs":{"TEXT":{"shadow":{"type":"text","id":"LWM*Dzq9*nJOE2aHlE!:","fields":{"TEXT":"Hello World!"}},"block":{"type":"advanced_peripherals_energy_detector_get_transfer_rate","id":"%#cm|_bk@Z?K2dcZ%yG8","inputs":{"DETECTOR":{"block":{"type":"variables_get","id":"Q3,TJ``WBVTZC|iAm:WI","fields":{"VAR":{"id":"*{7i9]pPQ]SdxwKC$?3g"}}}}}}}}}}}}}}}}}}}}}]},"variables":[{"name":"i","id":"RxOxb]Cq?^Fl%TPEReQg"},{"name":"detector","id":"*{7i9]pPQ]SdxwKC$?3g"}]}}

TestProject/geoscanner (example 4).ccp

@@ -0,0 +1 @@
+{"usedlibrary":["Advanced_Peripherals","CCPeripheral","CCTextutils","NativeIO"],"content":{"blocks":{"languageVersion":0,"blocks":[{"type":"ide_start","id":"_s{i,SzdnGk`iz}V{Ef,","x":30,"y":150,"inputs":{"DO":{"block":{"type":"variables_set","id":"4`t0A~mi9udqazuPFltl","fields":{"VAR":{"id":"b!G3HI*3Su-;s=l@m`{C"}},"inputs":{"VALUE":{"block":{"type":"io_open","id":"{s9Q{?YzVj[IT}u~g52k","fields":{"MODE":"w"},"inputs":{"FILENAME":{"block":{"type":"text","id":"}r@r{xS9G6@i@C{jDAOG","fields":{"TEXT":"test.json"}}}}}}},"next":{"block":{"type":"variables_set","id":"la(`]]2fjOy@W3|#H+j5","fields":{"VAR":{"id":"!60`+fJsl+LMzF5L;((_"}},"inputs":{"VALUE":{"block":{"type":"peripheral_wrap","id":"#gIy8pYRI5r;|Gpt((6D","inputs":{"NAME":{"shadow":{"type":"text","id":"s1SZ;+Ll-[Dn*[yCTh4^","fields":{"TEXT":"geoScanner_1"}}}}}}},"next":{"block":{"type":"io_write","id":"cXQ`rD/MHKTs*S:asoq`","inputs":{"DATA":{"shadow":{"type":"text","id":"j_Am~Q@Lu.p2e[cVK%_+","fields":{"TEXT":"Hello, world!"}},"block":{"type":"textutils_serialize_json","id":"7D;X/4FI7*aP+^+JG]w~","fields":{"NBT":false,"UNICODE":false,"ALLOWREPETI":false},"inputs":{"OBJECT":{"block":{"type":"advanced_peripherals_geo_scanner_scan","id":"=uxVRL!ZaUB=t@-]@;`4","inputs":{"RADIUS":{"shadow":{"type":"math_number","id":"e5oF_eP.dd+gJ@3YxYYJ","fields":{"NUM":2}}},"SCANNER":{"block":{"type":"variables_get","id":"Y`peao|kXro)ax|@x8v*","fields":{"VAR":{"id":"!60`+fJsl+LMzF5L;((_"}}}}}}}}}},"FILE":{"block":{"type":"variables_get","id":"-iS.RqK;e21F_P4Psbm+","fields":{"VAR":{"id":"b!G3HI*3Su-;s=l@m`{C"}}}}}}}}}}}}}]},"variables":[{"name":"scanner","id":"!60`+fJsl+LMzF5L;((_"},{"name":"file","id":"b!G3HI*3Su-;s=l@m`{C"}]}}

advremote.lua

@@ -1,50 +0,0 @@
-local ws = assert(http.websocket("ws://127.0.0.1:5133"))
-print("connected to server")
-
-local id
-local isrunning = true
-
-function exitcheck()
-    while true do
-        local event = os.pullEventRaw("terminate")
-        if event == "terminate" then
-            print("Exiting...")
-            isrunning = false
-            ws.close()
-            break
-        end
-    end
-end
-
-function main()
-    while isrunning do
-        print("ready")
-        local message, error = ws.receive()
-        if message then
-            print("Received message:", message)
-            if message == "ping" then
-                ws.send("pong")
-            elseif message == "sendcode" then
-                local file = io.open("main.lua", "w")
-                print("waiting for code")
-                local filedata, error = ws.receive()
-                file:write(filedata)
-                file:close()
-            elseif message == "runcode" then
-                id = multishell.launch({}, "main.lua")
-                multishell.setTitle(id, "Code")
-                multishell.setFocus(id)
-            elseif message == "exit" then
-                print("Exiting...")
-                break
-            end
-
-        else
-            print("WebSocket error:", error)
-            break
-        end
-    end
-end
-
-parallel.waitForAny(exitcheck, main)
-print("Exited")

blocks/Advanced_Peripherals/generator.js

@@ -0,0 +1,690 @@
+// this file not for generator only
+
+const { luaGenerator } = require('blockly/lua');
+
+// Check if luaGenerator.forBlock is defined and initialize if necessary
+if (!luaGenerator.forBlock) {
+    luaGenerator.forBlock = {};
+}
+
+// Generator for chatbox
+
+luaGenerator.forBlock['advanced_peripherals_chatbox_send_message'] = function(block, generator) {
+    var chatbox = generator.valueToCode(block, 'CHATBOX', generator.ORDER_ATOMIC);
+    var text = generator.valueToCode(block, 'TEXT', generator.ORDER_ATOMIC);
+    var prefix = generator.valueToCode(block, 'PREFIX', generator.ORDER_ATOMIC);
+    var bracket = generator.valueToCode(block, 'BRACKET', generator.ORDER_ATOMIC);
+    var bracketcolor = generator.valueToCode(block, 'BRACKETCOLOR', generator.ORDER_ATOMIC);
+    var range = generator.valueToCode(block, 'RANGE', generator.ORDER_ATOMIC);
+
+    return `${chatbox}.sendMessage(${text}, ${prefix}, ${bracket}, ${bracketcolor}, ${range})\n`;
+};
+
+luaGenerator.forBlock['advanced_peripherals_chatbox_send_message_to_player'] = function(block, generator) {
+    var chatbox = generator.valueToCode(block, 'CHATBOX', generator.ORDER_ATOMIC);
+    var text = generator.valueToCode(block, 'TEXT', generator.ORDER_ATOMIC);
+    var player = generator.valueToCode(block, 'PLAYER', generator.ORDER_ATOMIC);
+    var prefix = generator.valueToCode(block, 'PREFIX', generator.ORDER_ATOMIC);
+    var bracket = generator.valueToCode(block, 'BRACKET', generator.ORDER_ATOMIC);
+    var bracketcolor = generator.valueToCode(block, 'BRACKETCOLOR', generator.ORDER_ATOMIC);
+    var range = generator.valueToCode(block, 'RANGE', generator.ORDER_ATOMIC);
+
+    return `${chatbox}.sendMessageToPlayer(${text}, ${player}, ${prefix}, ${bracket}, ${bracketcolor}, ${range})\n`;
+};
+
+luaGenerator.forBlock['advanced_peripherals_chatbox_send_toast_to_player'] = function(block, generator) {
+    var chatbox = generator.valueToCode(block, 'CHATBOX', generator.ORDER_ATOMIC);
+    var text = generator.valueToCode(block, 'TEXT', generator.ORDER_ATOMIC);
+    var title = generator.valueToCode(block, 'TITLE', generator.ORDER_ATOMIC);
+    var player = generator.valueToCode(block, 'PLAYER', generator.ORDER_ATOMIC);
+    var prefix = generator.valueToCode(block, 'PREFIX', generator.ORDER_ATOMIC);
+    var bracket = generator.valueToCode(block, 'BRACKET', generator.ORDER_ATOMIC);
+    var bracketcolor = generator.valueToCode(block, 'BRACKETCOLOR', generator.ORDER_ATOMIC);
+    var range = generator.valueToCode(block, 'RANGE', generator.ORDER_ATOMIC);
+
+    return `${chatbox}.sendToastToPlayer(${text}, ${title}, ${player}, ${prefix}, ${bracket}, ${bracketcolor}, ${range})\n`;
+};
+
+luaGenerator.forBlock['advanced_peripherals_chatbox_send_message_formatted'] = function(block, generator) {
+    var chatbox = generator.valueToCode(block, 'CHATBOX', generator.ORDER_ATOMIC);
+    var json = generator.valueToCode(block, 'JSON', generator.ORDER_ATOMIC);
+    var prefix = generator.valueToCode(block, 'PREFIX', generator.ORDER_ATOMIC);
+    var bracket = generator.valueToCode(block, 'BRACKET', generator.ORDER_ATOMIC);
+    var bracketcolor = generator.valueToCode(block, 'BRACKETCOLOR', generator.ORDER_ATOMIC);
+    var range = generator.valueToCode(block, 'RANGE', generator.ORDER_ATOMIC);
+
+    return `${chatbox}.sendFormattedMessage(${json}, ${prefix}, ${bracket}, ${bracketcolor}, ${range})\n`;
+};
+
+luaGenerator.forBlock['advanced_peripherals_chatbox_send_message_formatted_to_player'] = function(block, generator) {
+    var chatbox = generator.valueToCode(block, 'CHATBOX', generator.ORDER_ATOMIC);
+    var json = generator.valueToCode(block, 'JSON', generator.ORDER_ATOMIC);
+    var player = generator.valueToCode(block, 'PLAYER', generator.ORDER_ATOMIC);
+    var prefix = generator.valueToCode(block, 'PREFIX', generator.ORDER_ATOMIC);
+    var bracket = generator.valueToCode(block, 'BRACKET', generator.ORDER_ATOMIC);
+    var bracketcolor = generator.valueToCode(block, 'BRACKETCOLOR', generator.ORDER_ATOMIC);
+    var range = generator.valueToCode(block, 'RANGE', generator.ORDER_ATOMIC);
+
+    return `${chatbox}.sendFormattedMessageToPlayer(${json}, ${player}, ${prefix}, ${bracket}, ${bracketcolor}, ${range})\n`;
+};
+
+luaGenerator.forBlock['advanced_peripherals_chatbox_send_toast_formatted_to_player'] = function(block, generator) {
+    var chatbox = generator.valueToCode(block, 'CHATBOX', generator.ORDER_ATOMIC);
+    var json = generator.valueToCode(block, 'JSON', generator.ORDER_ATOMIC);
+    var title = generator.valueToCode(block, 'TITLE', generator.ORDER_ATOMIC);
+    var player = generator.valueToCode(block, 'PLAYER', generator.ORDER_ATOMIC);
+    var prefix = generator.valueToCode(block, 'PREFIX', generator.ORDER_ATOMIC);
+    var bracket = generator.valueToCode(block, 'BRACKET', generator.ORDER_ATOMIC);
+    var bracketcolor = generator.valueToCode(block, 'BRACKETCOLOR', generator.ORDER_ATOMIC);
+    var range = generator.valueToCode(block, 'RANGE', generator.ORDER_ATOMIC);
+
+    return `${chatbox}.sendFormattedToastToPlayer(${json}, ${title}, ${player}, ${prefix}, ${bracket}, ${bracketcolor}, ${range})\n`;
+};
+
+// Generator for Energy Detector
+
+luaGenerator.forBlock['advanced_peripherals_energy_detector_get_transfer_rate'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getTransferRate()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_energy_detector_get_transfer_rate_limit'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getTransferRateLimit()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_energy_detector_set_transfer_rate_limit'] = function(block, generator) {
+    var limit = generator.valueToCode(block, 'TFRLIMIT', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return `${detector}.setTransferRateLimit(${limit})\n`;
+};
+
+// Generator for Environment Detector
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_biome'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getBiome()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_block_light_level'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getBlockLightLevel()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_day_light_level'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getDayLightLevel()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_sky_light_level'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getSkyLightLevel()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_dimension_name'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getDimensionName()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_dimension_PaN'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getDimensionPaN()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_dimension_provider'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getDimensionProvider()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_moon_id'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getMoonId()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_moon_name'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getMoonName()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_time'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getTime()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_radiation'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getRadiation()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_get_radiation_raw'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getRadiationRaw()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_is_dimension'] = function(block, generator) {
+    var dimension = generator.valueToCode(block, 'DIMENSION', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isDimension(${dimension})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_is_moon'] = function(block, generator) {
+    var id = generator.valueToCode(block, 'MOONID', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isMoon(${id})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_is_raining'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isRaining()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_is_sunny'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isSunny()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_is_thunder'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isThunder()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_is_slime_chunk'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isSlimeChunk()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_list_dimensions'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.listDimensions()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_env_detector_scan_entities'] = function(block, generator) {
+    var blockrange = generator.valueToCode(block, "BLOCKSRANGE", generator.ORDER_ATOMIC)
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.scanEntities(${blockrange})`, luaGenerator.ORDER_NONE];
+};
+
+// Generator for Player Detector
+
+luaGenerator.forBlock['advanced_peripherals_player_detector_get_player_pos'] = function(block, generator) {
+    var player = generator.valueToCode(block, "PLAYER", generator.ORDER_ATOMIC)
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getPlayer(${player})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_player_detector_get_online_player'] = function(block, generator) {
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getOnlinePlayers()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_player_detector_get_player_in_range'] = function(block, generator) {
+    var range = generator.valueToCode(block, 'RANGE', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getPlayersInRange(${range})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_player_detector_get_players_in_coords'] = function(block, generator) {
+    var FX = generator.valueToCode(block, 'FX', generator.ORDER_ATOMIC);
+    var FY = generator.valueToCode(block, 'FY', generator.ORDER_ATOMIC);
+    var FZ = generator.valueToCode(block, 'FZ', generator.ORDER_ATOMIC);
+    var TX = generator.valueToCode(block, 'TX', generator.ORDER_ATOMIC);
+    var TY = generator.valueToCode(block, 'TY', generator.ORDER_ATOMIC);
+    var TZ = generator.valueToCode(block, 'TZ', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getPlayersInCoords({x=${FX}, y=${FY}, z=${FZ}}, {x=${TX}, y=${TY}, z=${TZ}})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_player_detector_get_players_in_cubic'] = function(block, generator) {
+    var width = generator.valueToCode(block, 'WIDTH', generator.ORDER_ATOMIC);
+    var height = generator.valueToCode(block, 'HEIGHT', generator.ORDER_ATOMIC);
+    var depth = generator.valueToCode(block, 'DEPTH', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.getPlayersInCubic(${width}, ${height}, ${depth})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_player_detector_is_player_in_range'] = function(block, generator) {
+    var player = generator.valueToCode(block, 'PLAYER', generator.ORDER_ATOMIC);
+    var range = generator.valueToCode(block, 'RANGE', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isPlayerInRange(${range}, ${player})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_player_detector_is_player_in_coords'] = function(block, generator) {
+    var player = generator.valueToCode(block, 'PLAYER', generator.ORDER_ATOMIC);
+    var FX = generator.valueToCode(block, 'FX', generator.ORDER_ATOMIC);
+    var FY = generator.valueToCode(block, 'FY', generator.ORDER_ATOMIC);
+    var FZ = generator.valueToCode(block, 'FZ', generator.ORDER_ATOMIC);
+    var TX = generator.valueToCode(block, 'TX', generator.ORDER_ATOMIC);
+    var TY = generator.valueToCode(block, 'TY', generator.ORDER_ATOMIC);
+    var TZ = generator.valueToCode(block, 'TZ', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isPlayerInCoords({x=${FX}, y=${FY}, z=${FZ}}, {x=${TX}, y=${TY}, z=${TZ}}, ${player})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_player_detector_is_player_in_cubic'] = function(block, generator) {
+    var player = generator.valueToCode(block, 'PLAYER', generator.ORDER_ATOMIC);
+    var width = generator.valueToCode(block, 'WIDTH', generator.ORDER_ATOMIC);
+    var height = generator.valueToCode(block, 'HEIGHT', generator.ORDER_ATOMIC);
+    var depth = generator.valueToCode(block, 'DEPTH', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isPlayerInCubic(${width}, ${height}, ${depth}, ${player})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_player_detector_is_players_in_range'] = function(block, generator) {
+    var range = generator.valueToCode(block, 'RANGE', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isPlayersInRange(${range})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_player_detector_is_players_in_coords'] = function(block, generator) {
+    var FX = generator.valueToCode(block, 'FX', generator.ORDER_ATOMIC);
+    var FY = generator.valueToCode(block, 'FY', generator.ORDER_ATOMIC);
+    var FZ = generator.valueToCode(block, 'FZ', generator.ORDER_ATOMIC);
+    var TX = generator.valueToCode(block, 'TX', generator.ORDER_ATOMIC);
+    var TY = generator.valueToCode(block, 'TY', generator.ORDER_ATOMIC);
+    var TZ = generator.valueToCode(block, 'TZ', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isPlayersInCoords({x=${FX}, y=${FY}, z=${FZ}}, {x=${TX}, y=${TY}, z=${TZ}})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_player_detector_is_players_in_cubic'] = function(block, generator) {
+    var width = generator.valueToCode(block, 'WIDTH', generator.ORDER_ATOMIC);
+    var height = generator.valueToCode(block, 'HEIGHT', generator.ORDER_ATOMIC);
+    var depth = generator.valueToCode(block, 'DEPTH', generator.ORDER_ATOMIC);
+    var detector = generator.valueToCode(block, 'DETECTOR', generator.ORDER_ATOMIC);
+
+    return [`${detector}.isPlayersInCubic(${width}, ${height}, ${depth})`, luaGenerator.ORDER_NONE];
+};
+
+// Generator for Inventory Manager
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_add_item_to_player'] = function(block, generator) {
+    var item = generator.valueToCode(block, 'ITEM', generator.ORDER_ATOMIC);
+    var toslot = generator.valueToCode(block, 'TOSLOT', generator.ORDER_ATOMIC);
+    var count = generator.valueToCode(block, 'COUNT', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return `${manager}.addItemToPlayer("${side}", {name=${item}, toSlot=${toslot}, count=${count}})\n`;
+};
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_remove_item_from_player'] = function(block, generator) {
+    var item = generator.valueToCode(block, 'ITEM', generator.ORDER_ATOMIC);
+    var fromslot = generator.valueToCode(block, 'FROMSLOT', generator.ORDER_ATOMIC);
+    var count = generator.valueToCode(block, 'COUNT', generator.ORDER_ATOMIC);
+    var toslot = generator.valueToCode(block, 'TOSLOT', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return `${manager}.removeItemFromPlayer("${side}", {name=${item}, toSlot=${toslot}, fromSlot=${fromslot}, count=${count}})\n`;
+};
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_get_armor'] = function(block, generator) {
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return [`${manager}.getArmor()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_get_items'] = function(block, generator) {
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return [`${manager}.getItems()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_get_owner'] = function(block, generator) {
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return [`${manager}.getOwner()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_is_player_equipped'] = function(block, generator) {
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return [`${manager}.isPlayerEquipped()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_is_wearing'] = function(block, generator) {
+    var slot = generator.valueToCode(block, 'SLOT', generator.ORDER_ATOMIC);
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return [`${manager}.isWearing(${slot})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_get_item_in_hand'] = function(block, generator) {
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return [`${manager}.getItemInHand()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_get_item_in_offhand'] = function(block, generator) {
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return [`${manager}.getItemInOffHand()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_get_free_slot'] = function(block, generator) {
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return [`${manager}.getFreeSlot()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_is_space_available'] = function(block, generator) {
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return [`${manager}.isSpaceAvailable()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_inv_manager_get_empty_space'] = function(block, generator) {
+    var manager = generator.valueToCode(block, 'MANAGER', generator.ORDER_ATOMIC);
+
+    return [`${manager}.getEmptySpace()`, luaGenerator.ORDER_NONE];
+};
+
+// Generator for NBT Storage
+
+luaGenerator.forBlock['advanced_peripherals_nbt_storage_read'] = function(block, generator) {
+    var nbtstorage = generator.valueToCode(block, 'NBTDEV', generator.ORDER_ATOMIC);
+
+    return [`${nbtstorage}.read()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_nbt_storage_write_json'] = function(block, generator) {
+    var nbtjson = generator.valueToCode(block, 'NBTJSON', generator.ORDER_ATOMIC);
+    var nbtstorage = generator.valueToCode(block, 'NBTDEV', generator.ORDER_ATOMIC);
+
+    return `${nbtstorage}.writeJson(${nbtjson})\n`;
+};
+
+luaGenerator.forBlock['advanced_peripherals_nbt_storage_write_table'] = function(block, generator) {
+    var nbt = generator.valueToCode(block, 'NBT', generator.ORDER_ATOMIC);
+    var nbtstorage = generator.valueToCode(block, 'NBTDEV', generator.ORDER_ATOMIC);
+
+    return `${nbtstorage}.writeTable(${nbt})\n`;
+};
+
+// Generator for Block Reader
+
+luaGenerator.forBlock['advanced_peripherals_block_reader_get_block_name'] = function(block, generator) {
+    var reader = generator.valueToCode(block, 'READER', generator.ORDER_ATOMIC);
+
+    return [`${reader}.getBlockName()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_block_reader_get_block_data'] = function(block, generator) {
+    var reader = generator.valueToCode(block, 'READER', generator.ORDER_ATOMIC);
+
+    return [`${reader}.getBlockData()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_block_reader_get_block_states'] = function(block, generator) {
+    var reader = generator.valueToCode(block, 'READER', generator.ORDER_ATOMIC);
+
+    return [`${reader}.getBlockStates()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_block_reader_is_tile_entity'] = function(block, generator) {
+    var reader = generator.valueToCode(block, 'READER', generator.ORDER_ATOMIC);
+
+    return [`${reader}.isTileEntity()`, luaGenerator.ORDER_NONE];
+};
+
+// Generator for Geo Scanner
+
+luaGenerator.forBlock['advanced_peripherals_geo_scanner_get_fuel_level'] = function(block, generator) {
+    var scanner = generator.valueToCode(block, 'SCANNER', generator.ORDER_ATOMIC);
+
+    return [`${scanner}.getFuelLevel()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_geo_scanner_get_max_fuel_level'] = function(block, generator) {
+    var scanner = generator.valueToCode(block, 'SCANNER', generator.ORDER_ATOMIC);
+
+    return [`${scanner}.getMaxFuelLevel()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_geo_scanner_cost'] = function(block, generator) {
+    var radius = generator.valueToCode(block, 'RADIUS', generator.ORDER_ATOMIC);
+    var scanner = generator.valueToCode(block, 'SCANNER', generator.ORDER_ATOMIC);
+
+    return [`${scanner}.cost(${radius})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_geo_scanner_scan'] = function(block, generator) {
+    var radius = generator.valueToCode(block, 'RADIUS', generator.ORDER_ATOMIC);
+    var scanner = generator.valueToCode(block, 'SCANNER', generator.ORDER_ATOMIC);
+
+    return [`${scanner}.scan(${radius})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_geo_get_scan_cooldown'] = function(block, generator) {
+    var scanner = generator.valueToCode(block, 'SCANNER', generator.ORDER_ATOMIC);
+
+    return [`${scanner}.getScanCooldown()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_geo_chunk_analyze'] = function(block, generator) {
+    var scanner = generator.valueToCode(block, 'SCANNER', generator.ORDER_ATOMIC);
+
+    return [`${scanner}.chunkAnalyze()`, luaGenerator.ORDER_NONE];
+};
+
+// Generator for Redstone Integrator
+
+luaGenerator.forBlock['advanced_peripherals_redstone_integrator_get_input'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    var integrator = generator.valueToCode(block, 'INTEGRATOR', generator.ORDER_ATOMIC);
+
+    return [`${integrator}.getInput("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_redstone_integrator_get_output'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    var integrator = generator.valueToCode(block, 'INTEGRATOR', generator.ORDER_ATOMIC);
+
+    return [`${integrator}.getOutput("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_redstone_integrator_get_analog_input'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    var integrator = generator.valueToCode(block, 'INTEGRATOR', generator.ORDER_ATOMIC);
+
+    return [`${integrator}.getAnalogInput("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_redstone_integrator_get_analog_output'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    var integrator = generator.valueToCode(block, 'INTEGRATOR', generator.ORDER_ATOMIC);
+
+    return [`${integrator}.getAnalogOutput("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_redstone_integrator_set_output'] = function(block, generator) {
+    var powered = block.getFieldValue('POWERED');
+    var side = block.getFieldValue('SIDE');
+    var integrator = generator.valueToCode(block, 'INTEGRATOR', generator.ORDER_ATOMIC);
+
+    var ispowerd;
+    if (powered == "ON") {
+        ispowerd = "true";
+    } else {
+        ispowerd = "false";
+    }
+
+    return `${integrator}.setOutput("${side}", ${ispowerd})\n`;
+};
+
+luaGenerator.forBlock['advanced_peripherals_redstone_integrator_set_analog_output'] = function(block, generator) {
+    var power = generator.valueToCode(block, 'POWER', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+    var integrator = generator.valueToCode(block, 'INTEGRATOR', generator.ORDER_ATOMIC);
+
+    return `${integrator}.setOutput("${side}", ${power})\n`;
+};
+
+// Generator for Minecraft: Beacon
+
+luaGenerator.forBlock['advanced_peripherals_mc_beacon_get_level'] = function(block, generator) {
+    var beacon = generator.valueToCode(block, 'BEACON', generator.ORDER_ATOMIC);
+
+    return [`${beacon}.getLevel()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_mc_beacon_get_primary_effect'] = function(block, generator) {
+    var beacon = generator.valueToCode(block, 'BEACON', generator.ORDER_ATOMIC);
+
+    return [`${beacon}.getPrimaryEffect()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_mc_beacon_get_secondary_effect'] = function(block, generator) {
+    var beacon = generator.valueToCode(block, 'BEACON', generator.ORDER_ATOMIC);
+
+    return [`${beacon}.getSecondaryEffect()`, luaGenerator.ORDER_NONE];
+};
+
+// Generator for Minecraft: Note Block
+
+luaGenerator.forBlock['advanced_peripherals_mc_note_block_play_note'] = function(block, generator) {
+    var noteblock = generator.valueToCode(block, 'NOTEBLOCK', generator.ORDER_ATOMIC);
+
+    return `${noteblock}.playNote()\n`;
+};
+
+luaGenerator.forBlock['advanced_peripherals_mc_note_block_get_note'] = function(block, generator) {
+    var noteblock = generator.valueToCode(block, 'NOTEBLOCK', generator.ORDER_ATOMIC);
+
+    return [`${beacon}.getNote()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_mc_note_block_change_note_by'] = function(block, generator) {
+    var to = generator.valueToCode(block, 'TO', generator.ORDER_ATOMIC); 
+    var noteblock = generator.valueToCode(block, 'NOTEBLOCK', generator.ORDER_ATOMIC);
+
+    return `${noteblock}.changeNoteBy(${to})\n`;
+};
+
+luaGenerator.forBlock['advanced_peripherals_mc_note_block_change_note'] = function(block, generator) {
+    var noteblock = generator.valueToCode(block, 'NOTEBLOCK', generator.ORDER_ATOMIC);
+
+    return `${noteblock}.changeNote()\n`;
+};
+
+// Generator for Botania: Flowers
+
+luaGenerator.forBlock['advanced_peripherals_botania_flowers_get_mana'] = function(block, generator) {
+    var flower = generator.valueToCode(block, 'FLOWER', generator.ORDER_ATOMIC);
+
+    return [`${flower}.getMana()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_flowers_get_max_mana'] = function(block, generator) {
+    var flower = generator.valueToCode(block, 'FLOWER', generator.ORDER_ATOMIC);
+
+    return [`${flower}.getMaxMana()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_flowers_is_floating'] = function(block, generator) {
+    var flower = generator.valueToCode(block, 'FLOWER', generator.ORDER_ATOMIC);
+
+    return [`${flower}.isFloating()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_flowers_is_on_enchanted_soil'] = function(block, generator) {
+    var flower = generator.valueToCode(block, 'FLOWER', generator.ORDER_ATOMIC);
+
+    return [`${flower}.isOnEnchantedSoil()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_flowers_is_empty'] = function(block, generator) {
+    var flower = generator.valueToCode(block, 'FLOWER', generator.ORDER_ATOMIC);
+
+    return [`${flower}.isEmpty()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_flowers_is_full'] = function(block, generator) {
+    var flower = generator.valueToCode(block, 'FLOWER', generator.ORDER_ATOMIC);
+
+    return [`${flower}.isFull()`, luaGenerator.ORDER_NONE];
+};
+
+// Generator for Botania: Mana Pool
+
+luaGenerator.forBlock['advanced_peripherals_botania_mana_pool_get_mana'] = function(block, generator) {
+    var pool = generator.valueToCode(block, 'POOL', generator.ORDER_ATOMIC);
+
+    return [`${pool}.getMana()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_mana_pool_get_max_mana'] = function(block, generator) {
+    var pool = generator.valueToCode(block, 'POOL', generator.ORDER_ATOMIC);
+
+    return [`${pool}.getMaxMana()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_mana_pool_get_mana_needed'] = function(block, generator) {
+    var pool = generator.valueToCode(block, 'POOL', generator.ORDER_ATOMIC);
+
+    return [`${pool}.getManaNeeded()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_mana_pool_is_empty'] = function(block, generator) {
+    var pool = generator.valueToCode(block, 'POOL', generator.ORDER_ATOMIC);
+
+    return [`${pool}.isEmpty()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_mana_pool_is_full'] = function(block, generator) {
+    var pool = generator.valueToCode(block, 'POOL', generator.ORDER_ATOMIC);
+
+    return [`${pool}.isFull()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_mana_pool_can_charge_item'] = function(block, generator) {
+    var pool = generator.valueToCode(block, 'POOL', generator.ORDER_ATOMIC);
+
+    return [`${pool}.canChargeItem()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_mana_pool_has_items'] = function(block, generator) {
+    var pool = generator.valueToCode(block, 'POOL', generator.ORDER_ATOMIC);
+
+    return [`${pool}.hasItems()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['advanced_peripherals_botania_mana_pool_get_items'] = function(block, generator) {
+    var pool = generator.valueToCode(block, 'POOL', generator.ORDER_ATOMIC);
+
+    return [`${pool}.getItems()`, luaGenerator.ORDER_NONE];
+};

blocks/Advanced_Peripherals/index.json

@@ -0,0 +1,24 @@
+{
+    "name": "Advanced Peripherals",
+    "author": "DPSoftware Foundation",
+    "description": "Advanced Peripherals is a mod that adds many useful extensions for CC:Tweaked.",
+    "version": "1.2",
+    "category": "Mod",
+    "keyword": "mod",
+    "license": "GPL-3.0-or-later",
+    "peripherals": true,
+    "library": false,
+    "require_network": false,
+    "dependencies": [
+        "CCPeripheral"
+    ],
+    "design_for_computer": {
+        "basic": true,
+        "adv": true, 
+        "command": true,
+        "pocket": true,
+        "advpocket": true,
+        "turtle": true,
+        "advturtle": true
+    }
+}

blocks/Advanced_Peripherals/toolbox.xml

@@ -0,0 +1,526 @@
+<xml id="toolbox" style="display: none;">
+    <category name="Advanced Peripherals" colour="200">
+        <label text="ChatBox"></label>
+        <label text="Event: chat"></label>
+        <block type="advanced_peripherals_chatbox_send_message">
+            <value name="TEXT">
+                <shadow type="text">
+                    <field name="TEXT">Hello, world!</field>
+                </shadow>
+            </value>
+            <value name="PREFIX">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKET">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKETCOLOR">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="RANGE">
+                <shadow type="logic_null"></shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_chatbox_send_message_to_player">
+            <value name="TEXT">
+                <shadow type="text">
+                    <field name="TEXT">Hello, world!</field>
+                </shadow>
+            </value>
+            <value name="PLAYER">
+                <shadow type="text">
+                    <field name="TEXT">Player</field>
+                </shadow>
+            </value>
+            <value name="PREFIX">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKET">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKETCOLOR">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="RANGE">
+                <shadow type="logic_null"></shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_chatbox_send_toast_to_player">
+            <value name="TEXT">
+                <shadow type="text">
+                    <field name="TEXT">Hello, world!</field>
+                </shadow>
+            </value>
+            <value name="TITLE">
+                <shadow type="text">
+                    <field name="TEXT">Hi</field>
+                </shadow>
+            </value>
+            <value name="PLAYER">
+                <shadow type="text">
+                    <field name="TEXT">Player</field>
+                </shadow>
+            </value>
+            <value name="PREFIX">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKET">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKETCOLOR">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="RANGE">
+                <shadow type="logic_null"></shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_chatbox_send_message_formatted">
+            <value name="PREFIX">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKET">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKETCOLOR">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="RANGE">
+                <shadow type="logic_null"></shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_chatbox_send_message_formatted_to_player">
+            <value name="PLAYER">
+                <shadow type="text">
+                    <field name="TEXT">Player</field>
+                </shadow>
+            </value>
+            <value name="PREFIX">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKET">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKETCOLOR">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="RANGE">
+                <shadow type="logic_null"></shadow>
+            </value>
+        </block>
+		<block type="advanced_peripherals_chatbox_send_toast_formatted_to_player">
+			<value name="TITLE">
+                <shadow type="text">
+                    <field name="TEXT">Hi</field>
+                </shadow>
+            </value>
+            <value name="PLAYER">
+                <shadow type="text">
+                    <field name="TEXT">Player</field>
+                </shadow>
+            </value>
+            <value name="PREFIX">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKET">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="BRACKETCOLOR">
+                <shadow type="logic_null"></shadow>
+            </value>
+            <value name="RANGE">
+                <shadow type="logic_null"></shadow>
+            </value>
+        </block>
+
+        <label text="Energy Detector"></label>
+        <block type="advanced_peripherals_energy_detector_get_transfer_rate"></block>
+        <block type="advanced_peripherals_energy_detector_get_transfer_rate_limit"></block>
+        <block type="advanced_peripherals_energy_detector_set_transfer_rate_limit">
+            <value name="TFRLIMIT">
+                <shadow type="math_number">
+                    <field name="NUM">512</field>
+                </shadow>
+            </value>
+        </block>
+
+        <label text="Environment Detector"></label>
+        <block type="advanced_peripherals_env_detector_get_biome"></block>
+        <block type="advanced_peripherals_env_detector_get_block_light_level"></block>
+        <block type="advanced_peripherals_env_detector_get_day_light_level"></block>
+        <block type="advanced_peripherals_env_detector_get_sky_light_level"></block>
+        <block type="advanced_peripherals_env_detector_get_dimension_name"></block>
+        <block type="advanced_peripherals_env_detector_get_dimension_PaN"></block>
+        <block type="advanced_peripherals_env_detector_get_dimension_provider"></block>
+        <block type="advanced_peripherals_env_detector_get_moon_id"></block>
+        <block type="advanced_peripherals_env_detector_get_moon_name"></block>
+        <block type="advanced_peripherals_env_detector_get_time"></block>
+        <block type="advanced_peripherals_env_detector_get_radiation"></block>
+        <block type="advanced_peripherals_env_detector_get_radiation_raw"></block>
+        <block type="advanced_peripherals_env_detector_is_dimension">
+            <value name="DIMENSION">
+                <shadow type="text">
+                    <field name="TEXT">minecraft:overworld</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_env_detector_is_moon">
+            <value name="MOONID">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_env_detector_is_raining"></block>
+        <block type="advanced_peripherals_env_detector_is_sunny"></block>
+        <block type="advanced_peripherals_env_detector_is_thunder"></block>
+        <block type="advanced_peripherals_env_detector_is_slime_chunk"></block>
+        <block type="advanced_peripherals_env_detector_list_dimensions"></block>
+        <block type="advanced_peripherals_env_detector_scan_entities">
+            <value name="BLOCKSRANGE">
+                <shadow type="math_number">
+                    <field name="NUM">32</field>
+                </shadow>
+            </value>
+        </block>
+
+        <label text="Player Detector"></label>
+        <label text="Event: playerClick, playerJoin, playerLeave, playerChangedDimension"></label>
+        <block type="advanced_peripherals_player_detector_get_player_pos">
+            <value name="PLAYER">
+                <shadow type="text">
+                    <field name="TEXT">Player</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_player_detector_get_online_player"></block>
+        <block type="advanced_peripherals_player_detector_get_player_in_range">
+            <value name="RANGE">
+                <shadow type="math_number">
+                    <field name="NUM">10</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_player_detector_get_players_in_coords">
+            <value name="FX">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="FY">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="FZ">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="TX">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="TY">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="TZ">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_player_detector_get_players_in_cubic">
+            <value name="WIDTH">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="HEIGHT">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="DEPTH">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_player_detector_is_player_in_range">
+            <value name="PLAYER">
+                <shadow type="text">
+                    <field name="TEXT">Player</field>
+                </shadow>
+            </value>
+            <value name="RANGE">
+                <shadow type="math_number">
+                    <field name="NUM">10</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_player_detector_is_player_in_coords">
+            <value name="PLAYER">
+                <shadow type="text">
+                    <field name="TEXT">Player</field>
+                </shadow>
+            </value>
+            <value name="FX">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="FY">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="FZ">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="TX">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="TY">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="TZ">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_player_detector_is_player_in_cubic">
+            <value name="PLAYER">
+                <shadow type="text">
+                    <field name="TEXT">Player</field>
+                </shadow>
+            </value>
+            <value name="WIDTH">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="HEIGHT">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="DEPTH">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_player_detector_is_players_in_range">
+            <value name="RANGE">
+                <shadow type="math_number">
+                    <field name="NUM">10</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_player_detector_is_players_in_coords">
+            <value name="FX">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="FY">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="FZ">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="TX">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="TY">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="TZ">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_player_detector_is_players_in_cubic">
+            <value name="WIDTH">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="HEIGHT">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+            <value name="DEPTH">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+        </block>
+
+        <label text="Inventory Manager"></label>
+        <block type="advanced_peripherals_inv_manager_add_item_to_player">
+            <value name="ITEM">
+                <shadow type="text">
+                    <field name="TEXT">minecraft:grass_block</field>
+                </shadow>
+            </value>
+            <value name="TOSLOT">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+            <value name="COUNT">
+                <shadow type="math_number">
+                    <field name="NUM">64</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_inv_manager_remove_item_from_player">
+            <value name="ITEM">
+                <shadow type="text">
+                    <field name="TEXT">minecraft:grass_block</field>
+                </shadow>
+            </value>
+            <value name="FROMSLOT">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+            <value name="COUNT">
+                <shadow type="math_number">
+                    <field name="NUM">64</field>
+                </shadow>
+            </value>
+            <value name="TOSLOT">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_inv_manager_get_armor"></block>
+        <block type="advanced_peripherals_inv_manager_get_items"></block>
+        <block type="advanced_peripherals_inv_manager_get_owner"></block>
+        <block type="advanced_peripherals_inv_manager_is_player_equipped"></block>
+        <block type="advanced_peripherals_inv_manager_is_wearing">
+            <value name="SLOT">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_inv_manager_get_item_in_hand"></block>
+        <block type="advanced_peripherals_inv_manager_get_item_in_offhand"></block>
+        <block type="advanced_peripherals_inv_manager_get_free_slot"></block>
+        <block type="advanced_peripherals_inv_manager_is_space_available"></block>
+        <block type="advanced_peripherals_inv_manager_get_empty_space"></block>
+
+        <label text="NBT Storage"></label>
+        <block type="advanced_peripherals_nbt_storage_read"></block>
+        <block type="advanced_peripherals_nbt_storage_write_json"></block>
+        <block type="advanced_peripherals_nbt_storage_write_table"></block>
+
+        <label text="Block Reader"></label>
+        <block type="advanced_peripherals_block_reader_get_block_name"></block>
+        <block type="advanced_peripherals_block_reader_get_block_data"></block>
+        <block type="advanced_peripherals_block_reader_get_block_states"></block>
+        <block type="advanced_peripherals_block_reader_is_tile_entity"></block>
+
+        <label text="Geo Scanner"></label>
+        <block type="advanced_peripherals_geo_scanner_get_fuel_level"></block>
+        <block type="advanced_peripherals_geo_scanner_get_max_fuel_level"></block>
+        <block type="advanced_peripherals_geo_scanner_cost">
+            <value name="RADIUS">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_geo_scanner_scan">
+            <value name="RADIUS">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_geo_get_scan_cooldown"></block>
+        <block type="advanced_peripherals_geo_chunk_analyze"></block>
+
+        <label text="Redstone Integrator"></label>
+        <block type="advanced_peripherals_redstone_integrator_get_input"></block>
+        <block type="advanced_peripherals_redstone_integrator_get_output"></block>
+        <block type="advanced_peripherals_redstone_integrator_get_analog_input"></block>
+        <block type="advanced_peripherals_redstone_integrator_get_analog_output"></block>
+        <block type="advanced_peripherals_redstone_integrator_set_output"></block>
+        <block type="advanced_peripherals_redstone_integrator_set_analog_output">
+            <value name="POWER">
+                <shadow type="math_number">
+                    <field name="NUM">15</field>
+                </shadow>
+            </value>
+        </block>
+
+        <label text="AR Controller"></label>
+
+        <label text="ME Bridge"></label>
+
+        <label text="RS Bridge"></label>
+
+        <label text="Colony Integrator"></label>
+
+        <label text="Minecraft: Beacon"></label>
+        <block type="advanced_peripherals_mc_beacon_get_level"></block>
+        <block type="advanced_peripherals_mc_beacon_get_primary_effect"></block>
+        <block type="advanced_peripherals_mc_beacon_get_secondary_effect"></block>
+
+        <label text="Minecraft: Note Block"></label>
+        <block type="advanced_peripherals_mc_note_block_play_note"></block>
+        <block type="advanced_peripherals_mc_note_block_get_note"></block>
+        <block type="advanced_peripherals_mc_note_block_change_note_by">
+            <value name="TO">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="advanced_peripherals_mc_note_block_change_note"></block>
+
+        <label text="Botania: Flowers"></label>
+        <block type="advanced_peripherals_botania_flowers_get_mana"></block>
+        <block type="advanced_peripherals_botania_flowers_get_max_mana"></block>
+        <block type="advanced_peripherals_botania_flowers_is_floating"></block>
+        <block type="advanced_peripherals_botania_flowers_is_on_enchanted_soil"></block>
+        <block type="advanced_peripherals_botania_flowers_is_empty"></block>
+        <block type="advanced_peripherals_botania_flowers_is_full"></block>
+
+        <label text="Botania: Mana Pool"></label>
+        <block type="advanced_peripherals_botania_mana_pool_get_mana"></block>
+        <block type="advanced_peripherals_botania_mana_pool_get_max_mana"></block>
+        <block type="advanced_peripherals_botania_mana_pool_get_mana_needed"></block>
+        <block type="advanced_peripherals_botania_mana_pool_is_empty"></block>
+        <block type="advanced_peripherals_botania_mana_pool_is_full"></block>
+        <block type="advanced_peripherals_botania_mana_pool_can_charge_item"></block>
+        <block type="advanced_peripherals_botania_mana_pool_has_items"></block>
+        <block type="advanced_peripherals_botania_mana_pool_get_items"></block>
+
+    </category>
+</xml>

blocks/CCColors/index.json

@@ -7,9 +7,9 @@
     "keyword": "Colors",
     "license": "GPL-3.0-or-later",
     "peripherals": false,
-    "library": true,
+    "library": false,
     "require_network": false,
-    "dependencies": {},
+    "dependencies": [],
     "design_for_computer": {
         "basic": false,
         "adv": true, 

blocks/CCDisk/block_design.json

@@ -0,0 +1,232 @@
+{
+    "disk_is_present": {
+        "message0": "Is disk %1 present?",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": "Boolean",
+        "colour": 160,
+        "tooltip": "Check if any item is present in the disk drive"
+    },
+    "disk_get_label": {
+        "message0": "get label disk %1",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": "String",
+        "colour": 160,
+        "tooltip": "Get the label of the disk in the drive"
+    },
+    "disk_set_label": {
+        "message0": "set label disk %1 to %2",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            },
+            {
+                "type": "input_value",
+                "name": "LABEL",
+                "check": "String"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 160,
+        "tooltip": "Set the label of the disk in the drive"
+    },
+    "disk_has_data": {
+        "message0": "Is disk %1 have data?",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": "Boolean",
+        "colour": 160,
+        "tooltip": "Check if the disk has data"
+    },
+    "disk_get_mount_path": {
+        "message0": "get mount path of disk %1",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": "String",
+        "colour": 160,
+        "tooltip": "Get the mount path of the disk"
+    },
+    "disk_has_audio": {
+        "message0": "Is disk %1 have audio?",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": "Boolean",
+        "colour": 160,
+        "tooltip": "Check if the disk has audio"
+    },
+    "disk_get_audio_title": {
+        "message0": "get audio title of disk %1",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": ["String", "Boolean"],
+        "colour": 160,
+        "tooltip": "Get the title of the audio track"
+    },
+    "disk_play_audio": {
+        "message0": "play audio disk %1",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 160,
+        "tooltip": "Play the audio track on the disk"
+    },
+    "disk_stop_audio": {
+        "message0": "stop audio on %1",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 160,
+        "tooltip": "Stop the audio track on the disk"
+    },
+    "disk_eject": {
+        "message0": "eject disk %1",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 160,
+        "tooltip": "Eject the disk from the drive",
+        "helpUrl": ""
+    },
+    "disk_get_id": {
+        "message0": "get ID of disk %1",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["Left", "left"],
+                    ["Right", "right"],
+                    ["Front", "front"],
+                    ["Back", "back"]
+                ]
+            }
+        ],
+        "output": "String",
+        "colour": 160,
+        "tooltip": "Get the unique ID of the disk"
+    }
+}

blocks/CCDisk/generator.js

@@ -0,0 +1,75 @@
+// this file not for generator only
+
+const { luaGenerator } = require('blockly/lua');
+
+// Check if luaGenerator.forBlock is defined and initialize if necessary
+if (!luaGenerator.forBlock) {
+    luaGenerator.forBlock = {};
+}
+
+luaGenerator.forBlock['disk_is_present'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return [`disk.isPresent("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['disk_get_label'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return [`disk.getLabel("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['disk_set_label'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    var label = generator.valueToCode(block, 'LABEL', generator.ORDER_ATOMIC);
+    
+    return `disk.setLabel("${side}", ${label})\n`;
+};
+
+luaGenerator.forBlock['disk_has_data'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return [`disk.hasData("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['disk_get_mount_path'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return [`disk.getMountPath("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['disk_has_audio'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return [`disk.hasAudio("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['disk_get_audio_title'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return [`disk.getAudioTitle("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['disk_play_audio'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return `disk.playAudio("${side}")\n`;
+};
+
+luaGenerator.forBlock['disk_stop_audio'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return `disk.stopAudio("${side}")\n`;
+};
+
+luaGenerator.forBlock['disk_eject'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return `disk.eject("${side}")\n`;
+};
+
+luaGenerator.forBlock['disk_get_id'] = function(block, generator) {
+    var side = block.getFieldValue('SIDE');
+    
+    return [`disk.getID("${side}")`, luaGenerator.ORDER_NONE];
+};

blocks/CCDisk/index.json

@@ -0,0 +1,22 @@
+{
+    "name": "CC: Disk",
+    "author": "DPSoftware Foundation",
+    "description": "Blocks for performing operations on disk drives in ccIDE",
+    "version": "1.0.0",
+    "category": "",
+    "keyword": "disk, operations, ccIDE",
+    "license": "GPL-3.0-or-later",
+    "peripherals": true,
+    "library": false,
+    "require_network": false,
+    "dependencies": [],
+    "design_for_computer": {
+        "basic": true,
+        "adv": true,
+        "command": true,
+        "pocket": false,
+        "advpocket": false,
+        "turtle": true,
+        "advturtle": true
+    }
+}

blocks/CCDisk/toolbox.xml

@@ -0,0 +1,15 @@
+<xml id="toolbox" style="display: none;">
+    <category name="Disk" colour="160">
+        <block type="disk_is_present"></block>
+        <block type="disk_get_label"></block>
+        <block type="disk_set_label"></block>
+        <block type="disk_has_data"></block>
+        <block type="disk_get_mount_path"></block>
+        <block type="disk_has_audio"></block>
+        <block type="disk_get_audio_title"></block>
+        <block type="disk_play_audio"></block>
+        <block type="disk_stop_audio"></block>
+        <block type="disk_eject"></block>
+        <block type="disk_get_id"></block>
+    </category>
+</xml>

blocks/CCKeys/block_design.json

@@ -0,0 +1,136 @@
+{
+    "keys_get_key_number": {
+        "message0": "Keys %1",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "KEY",
+                "options": [
+                    ["A", "30"],
+                    ["Apostrophe", "40"],
+                    ["At", "145"],
+                    ["Ax", "150"],
+                    ["B", "48"],
+                    ["Backspace", "14"],
+                    ["Backslash", "43"],
+                    ["CapsLock", "58"],
+                    ["C", "46"],
+                    ["Cimcumflex", "144"],
+                    ["Colon", "146"],
+                    ["Convert", "121"],
+                    ["Delete", "211"],
+                    ["D", "32"],
+                    ["Down", "208"],
+                    ["E", "18"],
+                    ["Eight", "9"],
+                    ["End", "207"],
+                    ["Equals", "13"],
+                    ["F", "33"],
+                    ["F1", "59"],
+                    ["F2", "60"],
+                    ["F3", "61"],
+                    ["F4", "62"],
+                    ["F5", "63"],
+                    ["F6", "64"],
+                    ["F7", "65"],
+                    ["F8", "66"],
+                    ["F9", "67"],
+                    ["F10", "68"],
+                    ["F11", "87"],
+                    ["F12", "88"],
+                    ["F13", "100"],
+                    ["F14", "101"],
+                    ["F15", "102"],
+                    ["Five", "6"],
+                    ["Four", "5"],
+                    ["G", "34"],
+                    ["H", "35"],
+                    ["Home", "199"],
+                    ["I", "23"],
+                    ["Insert", "210"],
+                    ["J", "36"],
+                    ["Kana", "112"],
+                    ["Kanji", "148"],
+                    ["K", "37"],
+                    ["L", "38"],
+                    ["Left", "203"],
+                    ["LeftAlt", "56"],
+                    ["LeftCtrl", "29"],
+                    ["LeftShift", "42"],
+                    ["M", "50"],
+                    ["Minus", "12"],
+                    ["NumPad0", "82"],
+                    ["NumPad1", "79"],
+                    ["NumPad2", "80"],
+                    ["NumPad3", "81"],
+                    ["NumPad4", "75"],
+                    ["NumPad5", "76"],
+                    ["NumPad6", "77"],
+                    ["NumPad7", "71"],
+                    ["NumPad8", "72"],
+                    ["NumPad9", "73"],
+                    ["NumPadAdd", "78"],
+                    ["NumPadComma", "179"],
+                    ["NumPadDecimal", "83"],
+                    ["NumPadDivide", "181"],
+                    ["NumPadEnter", "156"],
+                    ["NumPadEquals", "141"],
+                    ["NumPadSubtract", "74"],
+                    ["NumLock", "69"],
+                    ["O", "24"],
+                    ["P", "25"],
+                    ["PageDown", "209"],
+                    ["PageUp", "201"],
+                    ["Period", "52"],
+                    ["Q", "16"],
+                    ["R", "19"],
+                    ["Right", "205"],
+                    ["RightAlt", "184"],
+                    ["RightCtrl", "157"],
+                    ["RightShift", "54"],
+                    ["Return", "28"],
+                    ["S", "31"],
+                    ["ScrollLock", "70"],
+                    ["SemiColon", "39"],
+                    ["Seven", "8"],
+                    ["Slash", "53"],
+                    ["Space", "57"],
+                    ["Stop", "149"],
+                    ["Tab", "15"],
+                    ["T", "20"],
+                    ["Three", "4"],
+                    ["Two", "3"],
+                    ["U", "22"],
+                    ["Up", "200"],
+                    ["V", "47"],
+                    ["W", "17"],
+                    ["X", "45"],
+                    ["Y", "21"],
+                    ["Yen", "125"],
+                    ["Z", "44"],
+                    ["Zero", "11"],
+                    ["N", "49"],
+                    ["Noconvert", "123"],
+                    ["ScollLock", "70"]
+                ]
+            }
+        ],
+        "inputsInline": true,
+        "output": "Number",
+        "colour": 190,
+        "tooltip": "Get key number"
+    },
+    "keys_get_key_name": {
+        "message0": "Get key %1 name",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "KEY",
+                "check": "Number"
+            }
+        ],
+        "output": "String",
+        "colour": 190,
+        "tooltip": "Translates a numerical key code to a human-readable name."
+    }
+}

blocks/CCKeys/generator.js

@@ -0,0 +1,18 @@
+// this file not for generator only
+
+const { luaGenerator } = require('blockly/lua');
+
+// Check if luaGenerator.forBlock is defined and initialize if necessary
+if (!luaGenerator.forBlock) {
+    luaGenerator.forBlock = {};
+}
+
+luaGenerator.forBlock['keys_get_key_number'] = function(block, generator) {
+    return [block.getFieldValue('KEY'), generator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['text_print'] = function(block, generator) {
+    var key = generator.valueToCode(block, 'KEY', generator.ORDER_NONE);
+    return [`keys.getName(${key})`, luaGenerator.ORDER_NONE];
+};
+

blocks/CCKeys/index.json

@@ -0,0 +1,22 @@
+{
+    "name": "CC: Keys",
+    "author": "DPSoftware Foundation",
+    "description": "Constants for all keyboard 'key codes', as queued by the key event.",
+    "version": "1.0.0",
+    "category": "Input",
+    "keyword": "Keyboard",
+    "license": "GPL-3.0-or-later",
+    "peripherals": false,
+    "library": false,
+    "require_network": false,
+    "dependencies": [],
+    "design_for_computer": {
+        "basic": true,
+        "adv": true, 
+        "command": true,
+        "pocket": true,
+        "advpocket": true,
+        "turtle": true,
+        "advturtle": true
+    }
+}

blocks/CCKeys/toolbox.xml

@@ -0,0 +1,10 @@
+<xml id="toolbox" style="display: none;">
+    <category name="Keys" colour="190">
+        <block type="keys_get_key_number"></block>
+        <block type="keys_get_key_name">
+            <value name="KEY">
+                <shadow type="keys_get_key_number"></shadow>
+            </value>
+        </block>
+    </category>
+</xml>

blocks/CCPeripheral/block_design.json

@@ -0,0 +1,130 @@
+{
+    "peripheral_get_names": {
+        "message0": "Get all peripheral",
+        "output": "Array",
+        "colour": 240,
+        "tooltip": "Provides a list of all peripherals available."
+    },
+    "peripheral_is_present": {
+        "message0": "Peripheral %1 is present",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "NAME",
+                "check": "String"
+            }
+        ],
+        "output": "Boolean",
+        "colour": 240,
+        "tooltip": "Determines if a peripheral is present with the given name."
+    },
+    "peripheral_get_type": {
+        "message0": "Get type of peripheral %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DEVICE",
+                "check": ["Peripheral", "String"]
+            }
+        ],
+        "output": "String",
+        "colour": 240,
+        "tooltip": "Get the types of a named or wrapped peripheral."
+    },
+    "peripheral_has_type": {
+        "message0": "Peripheral %1 has type %2",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DEVICE",
+                "check": ["Peripheral", "String"]
+            },
+            {
+                "type": "input_value",
+                "name": "TYPE",
+                "check": "String"
+            }
+        ],
+        "output": "Boolean",
+        "colour": 240,
+        "tooltip": "Check if a peripheral is of a particular type."
+    },
+    "peripheral_get_methods": {
+        "message0": "Get methods of peripheral %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "NAME",
+                "check": "String"
+            }
+        ],
+        "output": "Array",
+        "colour": 240,
+        "tooltip": "Get all available methods for the peripheral with the given name."
+    },
+    "peripheral_get_name": {
+        "message0": "Get name of peripheral %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DEVICE",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "String",
+        "colour": 240,
+        "tooltip": "Get the name of a peripheral wrapped with peripheral.wrap."
+    },
+    "peripheral_call": {
+        "message0": "Call peripheral %1 with method %2\nand args %3",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "NAME",
+                "check": "String"
+            },
+            {
+                "type": "input_value",
+                "name": "METHOD",
+                "check": "String"
+            },
+            {
+                "type": "input_value",
+                "name": "ARGS",
+                "check": "Multiple"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "output": null,
+        "colour": 240,
+        "tooltip": "Call a method on the peripheral with the given name."
+    },
+    "peripheral_wrap": {
+        "message0": "Open peripheral %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "NAME",
+                "check": "String"
+            }
+        ],
+        "output": "Peripheral",
+        "colour": 240,
+        "tooltip": "Get a table containing all functions available on a peripheral. These can then be called instead of using peripheral.call every time."
+    },
+    "peripheral_find": {
+        "message0": "Find peripheral %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "NAME",
+                "check": "String"
+            }
+        ],
+        "output": "Peripheral",
+        "colour": 240,
+        "tooltip": "Find all peripherals of a specific type, and return the wrapped peripherals."
+    }
+}
+

blocks/CCPeripheral/generator.js

@@ -0,0 +1,67 @@
+// this file not for generator only
+
+const { luaGenerator } = require('blockly/lua');
+
+// Check if luaGenerator.forBlock is defined and initialize if necessary
+if (!luaGenerator.forBlock) {
+    luaGenerator.forBlock = {};
+}
+
+luaGenerator.forBlock['peripheral_get_names'] = function(block, generator) {
+    return ["peripheral.getNames()", luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['peripheral_is_present'] = function(block, generator) {
+    var name = generator.valueToCode(block, 'NAME', generator.ORDER_ATOMIC);
+
+    return [`peripheral.isPresent(${name})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['peripheral_get_type'] = function(block, generator) {
+    var device = generator.valueToCode(block, 'DEVICE', generator.ORDER_ATOMIC);
+
+    return [`peripheral.getType(${device})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['peripheral_has_type'] = function(block, generator) {
+    var device = generator.valueToCode(block, 'DEVICE', generator.ORDER_ATOMIC);
+    var type = generator.valueToCode(block, 'TYPE', generator.ORDER_ATOMIC);
+
+    return [`peripheral.hasType(${device}, ${type})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['peripheral_get_methods'] = function(block, generator) {
+    var name = generator.valueToCode(block, 'NAME', generator.ORDER_ATOMIC);
+
+    return [`peripheral.getMethods(${name})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['peripheral_get_name'] = function(block, generator) {
+    var device = generator.valueToCode(block, 'DEVICE', generator.ORDER_ATOMIC);
+
+    return [`peripheral.getName(${device})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['peripheral_call'] = function(block, generator) {
+    var name = generator.valueToCode(block, 'NAME', generator.ORDER_ATOMIC);
+    var method = generator.valueToCode(block, 'METHOD', generator.ORDER_ATOMIC);
+    var args = generator.valueToCode(block, 'ARGS', generator.ORDER_ATOMIC);
+
+    if (block.outputConnection && block.outputConnection.targetConnection) {
+        return [`peripheral.call(${name}, ${method}, ${args})`, luaGenerator.ORDER_NONE];
+    } else {
+        return `peripheral.call(${name}, ${method}, ${args})\n`
+    }    
+};
+
+luaGenerator.forBlock['peripheral_wrap'] = function(block, generator) {
+    var name = generator.valueToCode(block, 'NAME', generator.ORDER_ATOMIC);
+
+    return [`peripheral.wrap(${name})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['peripheral_find'] = function(block, generator) {
+    var name = generator.valueToCode(block, 'NAME', generator.ORDER_ATOMIC);
+
+    return [`peripheral.find(${name})`, luaGenerator.ORDER_NONE];
+};

blocks/CCPeripheral/index.json

@@ -0,0 +1,22 @@
+{
+    "name": "CC: Peripheral",
+    "author": "DPSoftware Foundation",
+    "description": "Peripherals are blocks (or turtle and pocket computer upgrades) which can be controlled by a computer.",
+    "version": "1.0.0",
+    "category": "Peripheral",
+    "keyword": "peripheral",
+    "license": "GPL-3.0-or-later",
+    "peripherals": true,
+    "library": false,
+    "require_network": false,
+    "dependencies": [],
+    "design_for_computer": {
+        "basic": true,
+        "adv": true, 
+        "command": true,
+        "pocket": false,
+        "advpocket": false,
+        "turtle": true,
+        "advturtle": true
+    }
+}

blocks/CCPeripheral/toolbox.xml

@@ -0,0 +1,47 @@
+<xml id="toolbox" style="display: none;">
+    <category name="Peripheral" colour="240">
+        <block type="peripheral_get_names"></block>
+        <block type="peripheral_is_present">
+            <value name="NAME">
+                <shadow type="text"></shadow>
+            </value>
+        </block>
+        <block type="peripheral_get_type">
+            <value name="DEVICE">
+                <shadow type="text"></shadow>
+            </value>
+        </block>
+        <block type="peripheral_has_type">
+            <value name="DEVICE">
+                <shadow type="text"></shadow>
+            </value>
+            <value name="TYPE">
+                <shadow type="text"></shadow>
+            </value>
+        </block>
+        <block type="peripheral_get_methods">
+            <value name="NAME">
+                <shadow type="text"></shadow>
+            </value>
+        </block>
+        <block type="peripheral_get_name"></block>
+        <block type="peripheral_call">
+            <value name="NAME">
+                <shadow type="text"></shadow>
+            </value>
+            <value name="METHOD">
+                <shadow type="text"></shadow>
+            </value>
+        </block>
+        <block type="peripheral_wrap">
+            <value name="NAME">
+                <shadow type="text"></shadow>
+            </value>
+        </block>
+        <block type="peripheral_find">
+            <value name="NAME">
+                <shadow type="text"></shadow>
+            </value>
+        </block>
+    </category>
+</xml>

blocks/CCPeripheral_generic_energy_storage/block_design.json

@@ -0,0 +1,28 @@
+{
+    "periph_gen_energy_get": {
+        "message0": "Get current energy from %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "ENERGY",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 25,
+        "tooltip": "Get the energy of this block."
+    },
+    "periph_gen_energy_get_capacity": {
+        "message0": "Get max energy capacity from %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "ENERGY",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 25,
+        "tooltip": "Get the maximum amount of energy this block can store."
+    }
+}

blocks/CCPeripheral_generic_energy_storage/generator.js

@@ -0,0 +1,20 @@
+// this file not for generator only
+
+const { luaGenerator } = require('blockly/lua');
+
+// Check if luaGenerator.forBlock is defined and initialize if necessary
+if (!luaGenerator.forBlock) {
+    luaGenerator.forBlock = {};
+}
+
+luaGenerator.forBlock['periph_gen_energy_get'] = function(block, generator) {
+    var energy = generator.valueToCode(block, 'ENERGY', generator.ORDER_NONE);
+
+    return [`${energy}.getEnergy()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['periph_gen_energy_get_capacity'] = function(block, generator) {
+    var energy = generator.valueToCode(block, 'ENERGY', generator.ORDER_NONE);
+
+    return [`${energy}.getEnergyCapacity()`, luaGenerator.ORDER_NONE];
+};

blocks/CCPeripheral_generic_energy_storage/index.json

@@ -0,0 +1,24 @@
+{
+    "name": "CC: Generic Energy Storage",
+    "author": "DPSoftware Foundation",
+    "description": "Methods for interacting with blocks which store energy.",
+    "version": "1.0.0",
+    "category": "Peripheral",
+    "keyword": "generic peripheral storage power",
+    "license": "GPL-3.0-or-later",
+    "peripherals": true,
+    "library": false,
+    "require_network": false,
+    "dependencies": [
+        "CCPeripheral"
+    ],
+    "design_for_computer": {
+        "basic": true,
+        "adv": true, 
+        "command": true,
+        "pocket": false,
+        "advpocket": false,
+        "turtle": true,
+        "advturtle": true
+    }
+}

blocks/CCPeripheral_generic_energy_storage/toolbox.xml

@@ -0,0 +1,6 @@
+<xml id="toolbox" style="display: none;">
+    <category name="Energy" colour="25">
+        <block type="periph_gen_energy_get"></block>
+        <block type="periph_gen_energy_get_capacity"></block>
+    </category>
+</xml>

blocks/CCPeripheral_generic_fluid_storage/block_design.json

@@ -0,0 +1,52 @@
+{
+    "periph_gen_fluid_tanks": {
+        "message0": "Get fluid in tanks %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "TANKS",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Array",
+        "colour": 240,
+        "tooltip": "Get all \"tanks\" in this fluid storage."
+    },
+    "periph_gen_fluid_transfer": {
+        "message0": "Fluid name %1 in tanks %2 %3 tanks %4\nWith limit %5 mb",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "FLUIDNAME",
+                "check": "String"
+            },
+            {
+                "type": "input_value",
+                "name": "TANKS1",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "MODE",
+                "options": [
+                    ["Push to", "PUSH"],
+                    ["Pull from", "PULL"]
+                ]
+            },
+            {
+                "type": "input_value",
+                "name": "TANKS2",
+                "check": "Peripheral"
+            },
+            {
+                "type": "input_value",
+                "name": "LIMIT",
+                "check": "Number"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 240,
+        "tooltip": "Transfer a fluid from one fluid container to another connected one."
+    }
+}

blocks/CCPeripheral_generic_fluid_storage/generator.js

@@ -0,0 +1,28 @@
+// this file not for generator only
+
+const { luaGenerator } = require('blockly/lua');
+
+// Check if luaGenerator.forBlock is defined and initialize if necessary
+if (!luaGenerator.forBlock) {
+    luaGenerator.forBlock = {};
+}
+
+luaGenerator.forBlock['periph_gen_fluid_tanks'] = function(block, generator) {
+    var tanks = generator.valueToCode(block, 'TANKS', generator.ORDER_NONE);
+
+    return [`${tanks}.tanks()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['periph_gen_fluid_transfer'] = function(block, generator) {
+    var fluidname = generator.valueToCode(block, 'FLUIDNAME', generator.ORDER_ATOMIC);
+    var tanks1 = generator.valueToCode(block, 'TANKS1', generator.ORDER_ATOMIC);
+    var mode = block.getFieldValue('MODE');
+    var tanks2 = generator.valueToCode(block, 'TANKS2', generator.ORDER_ATOMIC);
+    var limit = generator.valueToCode(block, 'LIMIT', generator.ORDER_ATOMIC);
+
+    if (mode == "PUSH") {
+        return `${tanks1}.pushFluid(peripheral.getName(${tanks2}), ${limit}, ${fluidname})\n`
+    } else {
+        return `${tanks1}.pullFluid(peripheral.getName(${tanks2}), ${limit}, ${fluidname})\n`
+    }
+};

blocks/CCPeripheral_generic_fluid_storage/index.json

@@ -0,0 +1,24 @@
+{
+    "name": "CC: Generic Fluid Storage",
+    "author": "DPSoftware Foundation",
+    "description": "Methods for interacting with tanks and other fluid storage blocks.",
+    "version": "1.0.0",
+    "category": "Peripheral",
+    "keyword": "generic peripheral storage",
+    "license": "GPL-3.0-or-later",
+    "peripherals": true,
+    "library": false,
+    "require_network": false,
+    "dependencies": [
+        "CCPeripheral"
+    ],
+    "design_for_computer": {
+        "basic": true,
+        "adv": true, 
+        "command": true,
+        "pocket": false,
+        "advpocket": false,
+        "turtle": true,
+        "advturtle": true
+    }
+}

blocks/CCPeripheral_generic_fluid_storage/toolbox.xml

@@ -0,0 +1,12 @@
+<xml id="toolbox" style="display: none;">
+    <category name="FluidTanks" colour="240">
+        <block type="periph_gen_fluid_tanks"></block>
+        <block type="periph_gen_fluid_transfer">
+            <value name="LIMIT">
+                <shadow type="math_number">
+                    <field name="NUM">1000</field>
+                </shadow>
+            </value>
+        </block>
+    </category>
+</xml>

blocks/CCPeripheral_generic_inventory/block_design.json

@@ -0,0 +1,107 @@
+{
+    "periph_gen_inv_size": {
+        "message0": "Size of Inventory %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "INV",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 130,
+        "tooltip": "Get the size of this inventory."
+    },
+    "periph_gen_inv_list": {
+        "message0": "List all item in Inventory %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "INV",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Array",
+        "colour": 130,
+        "tooltip": "List all items in this inventory. This returns a table, with an entry for each slot."
+    },
+    "periph_gen_inv_get_item_detail": {
+        "message0": "Get item detail from inventory %1 in slot %2",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "INV",
+                "check": "Peripheral"
+            },
+            {
+                "type": "input_value",
+                "name": "SLOT",
+                "check": "Number"
+            }
+        ],
+        "output": "Array",
+        "colour": 130,
+        "tooltip": "Get detailed information about an item.",
+        "helpUrl": "https://tweaked.cc/generic_peripheral/inventory.html#v:getItemDetail"
+    },
+    "periph_gen_inv_get_item_limit": {
+        "message0": "Get item limit from inventory %1 in slot %2",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "INV",
+                "check": "Peripheral"
+            },
+            {
+                "type": "input_value",
+                "name": "SLOT",
+                "check": "Number"
+            }
+        ],
+        "output": "Number",
+        "colour": 130,
+        "tooltip": "Get the maximum number of items which can be stored in this slot."
+    },
+    "periph_gen_inv_transfer_items": {
+        "message0": "Inventory %1 in slot %2 %3 inventory %4 in slot %5\nWith limit %6 items",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "INV1",
+                "check": "Peripheral"
+            },
+            {
+                "type": "input_value",
+                "name": "INV1SLOT",
+                "check": "Number"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "MODE",
+                "options": [
+                    ["Push to", "PUSH"],
+                    ["Pull from", "PULL"]
+                ]
+            },
+            {
+                "type": "input_value",
+                "name": "INV2",
+                "check": "Peripheral"
+            },
+            {
+                "type": "input_value",
+                "name": "INV2SLOT",
+                "check": "Number"
+            },
+            {
+                "type": "input_value",
+                "name": "LIMIT",
+                "check": "Number"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 130,
+        "tooltip": "Transfer items from one inventory to another connected one."
+    }
+}

blocks/CCPeripheral_generic_inventory/generator.js

@@ -0,0 +1,49 @@
+// this file not for generator only
+
+const { luaGenerator } = require('blockly/lua');
+
+// Check if luaGenerator.forBlock is defined and initialize if necessary
+if (!luaGenerator.forBlock) {
+    luaGenerator.forBlock = {};
+}
+
+luaGenerator.forBlock['periph_gen_inv_size'] = function(block, generator) {
+    var inv = generator.valueToCode(block, 'INV', generator.ORDER_NONE);
+
+    return [`${inv}.size()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['periph_gen_inv_list'] = function(block, generator) {
+    var inv = generator.valueToCode(block, 'INV', generator.ORDER_NONE);
+
+    return [`${inv}.list()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['periph_gen_inv_get_item_detail'] = function(block, generator) {
+    var inv = generator.valueToCode(block, 'INV', generator.ORDER_NONE);
+    var slot = generator.valueToCode(block, 'SLOT', generator.ORDER_NONE);
+
+    return [`${inv}.getItemDetail(${slot})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['periph_gen_inv_get_item_limit'] = function(block, generator) {
+    var inv = generator.valueToCode(block, 'INV', generator.ORDER_NONE);
+    var slot = generator.valueToCode(block, 'SLOT', generator.ORDER_NONE);
+
+    return [`${inv}.getItemLimit(${slot})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['periph_gen_inv_transfer_items'] = function(block, generator) {
+    var inv1 = generator.valueToCode(block, 'INV1', generator.ORDER_ATOMIC);
+    var inv1slot = generator.valueToCode(block, 'INV1SLOT', generator.ORDER_ATOMIC);
+    var mode = block.getFieldValue('MODE');
+    var inv2 = generator.valueToCode(block, 'INV2', generator.ORDER_ATOMIC);
+    var inv2slot = generator.valueToCode(block, 'INV2SLOT', generator.ORDER_ATOMIC);
+    var limit = generator.valueToCode(block, 'LIMIT', generator.ORDER_ATOMIC);
+
+    if (mode == "PUSH") {
+        return `${inv1}.pushItems(peripheral.getName(${inv2}), ${inv1slot}, ${limit}, ${inv2slot})\n`
+    } else {
+        return `${inv1}.pullItems(peripheral.getName(${inv2}), ${inv2slot}, ${limit}, ${inv1slot})\n`
+    }
+};

blocks/CCPeripheral_generic_inventory/index.json

@@ -0,0 +1,24 @@
+{
+    "name": "CC: Generic Inventory",
+    "author": "DPSoftware Foundation",
+    "description": "Methods for interacting with inventories.",
+    "version": "1.0.0",
+    "category": "Peripheral",
+    "keyword": "generic peripheral",
+    "license": "GPL-3.0-or-later",
+    "peripherals": true,
+    "library": false,
+    "require_network": false,
+    "dependencies": [
+        "CCPeripheral"
+    ],
+    "design_for_computer": {
+        "basic": true,
+        "adv": true, 
+        "command": true,
+        "pocket": false,
+        "advpocket": false,
+        "turtle": true,
+        "advturtle": true
+    }
+}

blocks/CCPeripheral_generic_inventory/toolbox.xml

@@ -0,0 +1,37 @@
+<xml id="toolbox" style="display: none;">
+    <category name="Inventory" colour="130">
+        <block type="periph_gen_inv_size"></block>
+        <block type="periph_gen_inv_list"></block>
+        <block type="periph_gen_inv_get_item_detail">
+            <value name="NUM1">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="periph_gen_inv_get_item_limit">
+            <value name="SLOT">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="periph_gen_inv_transfer_items">
+            <value name="INV1SLOT">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+            <value name="INV2SLOT">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+            <value name="LIMIT">
+                <shadow type="math_number">
+                    <field name="NUM">64</field>
+                </shadow>
+            </value>
+        </block>
+    </category>
+</xml>

blocks/CCRednet/index.json

@@ -7,9 +7,9 @@
     "keyword": "Rednet",
     "license": "GPL-3.0-or-later",
     "peripherals": true,
-    "library": true,
+    "library": false,
     "require_network": false,
-    "dependencies": {},
+    "dependencies": [],
     "design_for_computer": {
         "basic": true,
         "adv": true, 

blocks/CCRedstone/block_design.json

@@ -6,8 +6,8 @@
                 "type": "field_dropdown",
                 "name": "STATE",
                 "options": [
-                    ["On", "OFF"],
-                    ["Off", "ON"]
+                    ["On", "ON"],
+                    ["Off", "OFF"]
                 ]
             },
             {

blocks/CCRedstone/index.json

@@ -7,16 +7,16 @@
     "keyword": "Redstone",
     "license": "GPL-3.0-or-later",
     "peripherals": false,
-    "library": true,
+    "library": false,
     "require_network": false,
-    "dependencies": {},
+    "dependencies": [],
     "design_for_computer": {
         "basic": true,
         "adv": true, 
         "command": true,
         "pocket": false,
         "advpocket": false,
-        "turtle": false,
-        "advturtle": false
+        "turtle": true,
+        "advturtle": true
     }
 }

blocks/CCSettings/index.json

@@ -7,9 +7,9 @@
     "keyword": "Env",
     "license": "GPL-3.0-or-later",
     "peripherals": false,
-    "library": true,
+    "library": false,
     "require_network": false,
-    "dependencies": {},
+    "dependencies": [],
     "design_for_computer": {
         "basic": true,
         "adv": true, 

blocks/CCSystem/block_design.json

@@ -172,7 +172,7 @@
     },
     "sysos_clock": {
         "message0": "Get Uptime",
-        "output": "String",
+        "output": "Number",
         "colour": 0,
         "tooltip": "Returns the number of seconds that the computer has been running."
     },

blocks/CCSystem/generator.js

@@ -10,17 +10,17 @@ if (!luaGenerator.forBlock) {
 luaGenerator.forBlock['sysos_pullevent'] = function(block, generator) {
     var event = generator.valueToCode(block, 'EVENT', generator.ORDER_ATOMIC);
 
-    if (event == "") {
-        return [`os.pullevent()`, luaGenerator.ORDER_NONE];
+    if (event == "'All'") {
+        return [`os.pullEvent()`, luaGenerator.ORDER_NONE];
     } else {
-        return [`os.pullevent(${event})`, luaGenerator.ORDER_NONE];
+        return [`os.pullEvent(${event})`, luaGenerator.ORDER_NONE];
     }
 };
 
 luaGenerator.forBlock['sysos_pullrawevent'] = function(block, generator) {
     var event = generator.valueToCode(block, 'EVENT', generator.ORDER_ATOMIC);
 
-    if (event == "") {
+    if (event == "'All'") {
         return [`os.pullEventRaw()`, luaGenerator.ORDER_NONE];
     } else {
         return [`os.pullEventRaw(${event})`, luaGenerator.ORDER_NONE];

blocks/CCSystem/index.json

@@ -7,9 +7,9 @@
     "keyword": "System, OS",
     "license": "GPL-3.0-or-later",
     "peripherals": false,
-    "library": true,
+    "library": false,
     "require_network": false,
-    "dependencies": {},
+    "dependencies": [],
     "design_for_computer": {
         "basic": true,
         "adv": true, 

blocks/CCTextutils/index.json

@@ -7,9 +7,9 @@
     "keyword": "utils",
     "license": "GPL-3.0-or-later",
     "peripherals": false,
-    "library": true,
+    "library": false,
     "require_network": false,
-    "dependencies": {},
+    "dependencies": [],
     "design_for_computer": {
         "basic": true,
         "adv": true, 

blocks/CCTurtle/index.json

@@ -7,9 +7,9 @@
     "keyword": "turtle",
     "license": "GPL-3.0-or-later",
     "peripherals": false,
-    "library": true,
+    "library": false,
     "require_network": false,
-    "dependencies": {},
+    "dependencies": [],
     "design_for_computer": {
         "basic": false,
         "adv": false, 

blocks/Create_Additions/block_design.json

@@ -0,0 +1,787 @@
+{
+    "create_addition_electric_motor_set_speed": {
+        "message0": "Set motor %1 speed to %2 RPM",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "MOTOR",
+                "check": "Peripheral"
+            },
+            {
+                "type": "input_value",
+                "name": "RPM",
+                "check": "Number"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 70,
+        "tooltip": "To set the speed of the Electric Motor, call setSpeed(rpm) where the argument rpm is a number between -256 and 256. The function will throw an exception if it is called too many times per second."
+    },
+    "create_addition_electric_motor_stop": {
+        "message0": "Stop motor %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "MOTOR",
+                "check": "Peripheral"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 70,
+        "tooltip": "This is a shorthand for setSpeed(0)."
+    },
+    "create_addition_electric_motor_rotate": {
+        "message0": "Calculate rotation for motor %1 to rotate %2 degrees with speed %3 RPM",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "MOTOR",
+                "check": "Peripheral"
+            },
+            {
+                "type": "input_value",
+                "name": "DEGREES",
+                "check": "Number"
+            },
+            {
+                "type": "input_value",
+                "name": "RPM",
+                "check": "Number"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the time it will take to rotate the shaft by the argument degrees at the current speed. If the optional argument rpm is given it will set the speed of the motor and return the rotation time at the new speed."
+    },
+    "create_addition_electric_motor_translate": {
+        "message0": "Translate motor %1 by %2 blocks with speed %3 RPM",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "MOTOR",
+                "check": "Peripheral"
+            },
+            {
+                "type": "input_value",
+                "name": "BLOCKS",
+                "check": "Number"
+            },
+            {
+                "type": "input_value",
+                "name": "RPM",
+                "check": "Number"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the time it will take to rotate the shaft to push a piston or gantry shaft by distance given by the argument blocks at the current speed. "
+    },
+    "create_addition_electric_motor_get_speed": {
+        "message0": "Get current speed from motor %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "MOTOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the current motor speed."
+    },
+    "create_addition_electric_motor_get_stress_capacity": {
+        "message0": "Get stress capacity from motor %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "MOTOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the produced stress capacity (output su)."
+    },
+    "create_addition_electric_motor_get_energy_consumption": {
+        "message0": "Get energy consumption from motor %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "MOTOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the motor energy consumption in FE/t."
+    },
+    "create_addition_electric_motor_get_max_input": {
+        "message0": "Get max input from motor %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "MOTOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the Motor max input in fe."
+    },
+    "create_addition_electric_motor_get_max_output": {
+        "message0": "Get max output from motor %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "MOTOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the Motor max output in fe (Always 0)."
+    },
+
+    "create_addition_accumulator_get_energy": {
+        "message0": "Get current energy is store in accumulator %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "ACCUMULATOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the accumulator total stored charge in fe."
+    },
+    "create_addition_accumulator_get_capacity": {
+        "message0": "Get total capacity in accumulator %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "ACCUMULATOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the accumulator total capacity in fe."
+    },
+    "create_addition_accumulator_get_percent": {
+        "message0": "Get percent energy is store in accumulator %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "ACCUMULATOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the accumulator total charge in relation to the total capacity in percent."
+    },
+    "create_addition_accumulator_get_max_input": {
+        "message0": "Get max input from accumulator %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "ACCUMULATOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the accumulator max input per block face in fe."
+    },
+    "create_addition_accumulator_get_max_output": {
+        "message0": "Get max output from accumulator %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "ACCUMULATOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the accumulator max output per block face in fe."
+    },
+    "create_addition_accumulator_get_height": {
+        "message0": "Get current height from accumulator %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "ACCUMULATOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the accumulator height in block."
+    },
+    "create_addition_accumulator_get_width": {
+        "message0": "Get current width from accumulator %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "ACCUMULATOR",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the accumulator width in block."
+    },
+
+    "create_addition_pei_get_energy": {
+        "message0": "Get current energy is store in source from PEI %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "PEI",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the connected contraption total stored charge in fe, (-1 if not connected)."
+    },
+    "create_addition_pei_get_capacity": {
+        "message0": "Get total capacity in source from PEI %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "PEI",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the connected contraption total capacity in fe, (-1 if not connected)."
+    },
+    "create_addition_pei_is_connected": {
+        "message0": "Is PEI %1 connected",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "PEI",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Boolean",
+        "colour": 70,
+        "tooltip": "This will return true if a contraption is connected."
+    },
+    "create_addition_pei_get_max_input": {
+        "message0": "Get max input from PEI %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "PEI",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the PEI max input in fe."
+    },
+    "create_addition_pei_get_max_output": {
+        "message0": "Get max output from PEI %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "PEI",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the PEI max output in fe."
+    },
+
+    "create_addition_relay_get_max_input": {
+        "message0": "Get max input from relay %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "RELAY",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the Relay max input in fe."
+    },
+    "create_addition_relay_get_max_output": {
+        "message0": "Get max output from relay %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "RELAY",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the Relay max output in fe."
+    },
+    "create_addition_relay_get_throughput": {
+        "message0": "Get current throughput relay %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "RELAY",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the current throughput in fe."
+    },
+    "create_addition_relay_is_powered": {
+        "message0": "Is relay %1 powered",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "RELAY",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Boolean",
+        "colour": 70,
+        "tooltip": "This will return the redstone state of the Relay."
+    },
+
+    "create_addition_da_rotational_speed_control_set_target_speed": {
+        "message0": "Set target speed to %1 rpm to controller %2 at %3 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "RPM"
+            },
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 70,
+        "tooltip": "This will set the target speed of a Rotation Speed Controller attached to the side of a Digital Adapter."
+    },
+    "create_addition_da_rotational_speed_control_get_target_speed": {
+        "message0": "Get target speed from controller %1 at %2 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will get the target speed of a Rotation Speed Controller attached to the side of a Digital Adapter."
+    },
+
+    "create_addition_da_stressometer_get_kinetic_stress": {
+        "message0": "Get current stress from stressometer %1 at %2 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will get the stress of a Stressometer attached to the side of a Digital Adapter."
+    },
+    "create_addition_da_stressometer_get_kinetic_capacity": {
+        "message0": "Get capacity stress from stressometer %1 at %2 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will get the stress capacity of a Stressometer attached to the side of a Digital Adapter."
+    },
+
+    "create_addition_da_speedometer_get_kinetic_speed": {
+        "message0": "Get current speed from speedometer %1 at %2 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will get the speed of a Speedometer attached to the side of a Digital Adapter."
+    },
+    "create_addition_da_speedometer_get_kinetic_max_speed": {
+        "message0": "Get max speed from speedometer %1 of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will get the top speed as set by Create."
+    },
+
+    "create_addition_da_pulleys_get_pulleys_distance": {
+        "message0": "Get current distance from pulleys %1 at %2 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will get the extended distance of a Rope, Hose, or Elevator -Pulley attached to the side of a Digital Adapter."
+    },
+
+    "create_addition_da_elevator_pulley_get_elevator_floor": {
+        "message0": "Get current floor from elevator %1 at %2 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will get the current floor index of an Elevator Pulley attached to the side of a Digital Adapter."
+    },
+    "create_addition_da_elevator_pulley_get_elevator_floors": {
+        "message0": "Get total floors from elevator %1 at %2 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will get the number of floors of an Elevator Pulley attached to the side of a Digital Adapter."
+    },
+    "create_addition_da_elevator_pulley_get_elevator_floor_name": {
+        "message0": "Get floor %1 name from elevator %2 at %3 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "INDEX",
+                "check": "Number"
+            },
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will get floor name at floor index of a Elevator Pulley attached to the side of a Digital Adapter."
+    },
+    "create_addition_da_elevator_pulley_goto_elevator_floor_name": {
+        "message0": "Goto floor %1 with elevator %2 at %3 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "INDEX",
+                "check": "Number"
+            },
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will trigger a Elevator Pulley attached to the side of a Digital Adapter to move to the given floor index and returns the delta-y to move."
+    },
+
+    "create_addition_da_mechanical_piston_get_piston_distance": {
+        "message0": "Get current extended distance from piston %1 at %2 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will get the extended distance of a Mechanical Piston attached to the side of a Digital Adapter."
+    },
+
+    "create_addition_da_mechanical_bearing_get_bearing_angle": {
+        "message0": "Get current angle from Bearing %1 at %2 side of adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "SIDE",
+                "options": [
+                    ["Top", "top"],
+                    ["Bottom", "bottom"],
+                    ["North", "north"],
+                    ["East", "east"],
+                    ["West", "west"],
+                    ["South", "south"]
+                ]
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will get the angle of a Mechanical Bearing attached to the side of a Digital Adapter."
+    },
+
+    "create_addition_da_dp_link_print": {
+        "message0": "Print %1 to display %2 with adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "TEXT",
+                "check": "String"
+            },
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 70,
+        "tooltip": "This will print a string on the currently selected line to an internal buffer which can be read by a Display Link and put on a Display Board, print will increment the currently selected line."
+    },
+    "create_addition_da_dp_link_clear_line": {
+        "message0": "Clear current line in display %1 with adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 70,
+        "tooltip": "This will clear the text on the currently selected line."
+    },
+    "create_addition_da_dp_link_clear": {
+        "message0": "Clear display %1 with adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 70,
+        "tooltip": "This will clear all the text on all lines."
+    },
+    "create_addition_da_dp_link_get_line": {
+        "message0": "Get current line from display %1 with adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the currently selected line (starts at 1)."
+    },
+    "create_addition_da_dp_link_set_line": {
+        "message0": "Goto line %1 in display %2 with adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "LINE",
+                "check": "Number"
+            },
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 70,
+        "tooltip": "This will set the currently selected line to line (starts at 1)."
+    },
+    "create_addition_da_dp_link_get_max_line": {
+        "message0": "Get max line in display %1 with adapter",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DA",
+                "check": "Peripheral"
+            }
+        ],
+        "output": "Number",
+        "colour": 70,
+        "tooltip": "This will return the max number of lines that can be displayable using the Digital Adapter (will always return 16)."
+    }
+}

blocks/Create_Additions/generator.js

@@ -0,0 +1,330 @@
+// this file not for generator only
+
+const { luaGenerator } = require('blockly/lua');
+
+// Check if luaGenerator.forBlock is defined and initialize if necessary
+if (!luaGenerator.forBlock) {
+    luaGenerator.forBlock = {};
+}
+
+// generator for Electric Motor
+
+luaGenerator.forBlock['create_addition_electric_motor_set_speed'] = function(block, generator) {
+    var motor = generator.valueToCode(block, 'MOTOR', generator.ORDER_ATOMIC);
+    var speed = generator.valueToCode(block, 'RPM', generator.ORDER_ATOMIC);
+
+    return `${motor}.setSpeed(${speed})\n`;
+};
+
+luaGenerator.forBlock['create_addition_electric_motor_stop'] = function(block, generator) {
+    var motor = generator.valueToCode(block, 'MOTOR', generator.ORDER_ATOMIC);
+
+    return `${motor}.stop()\n`;
+};
+
+luaGenerator.forBlock['create_addition_electric_motor_rotate'] = function(block, generator) {
+    var motor = generator.valueToCode(block, 'MOTOR', generator.ORDER_ATOMIC);
+    var degrees = generator.valueToCode(block, 'DEGREES', generator.ORDER_ATOMIC);
+    var speed = generator.valueToCode(block, 'RPM', generator.ORDER_ATOMIC);
+
+    if (speed == "nil") {
+        return [`${motor}.rotate(${degrees})`, luaGenerator.ORDER_NONE];
+    } else {
+        return [`${motor}.rotate(${degrees}, ${speed})`, luaGenerator.ORDER_NONE];
+    }
+};
+
+luaGenerator.forBlock['create_addition_electric_motor_translate'] = function(block, generator) {
+    var motor = generator.valueToCode(block, 'MOTOR', generator.ORDER_ATOMIC);
+    var tblock = generator.valueToCode(block, 'BLOCKS', generator.ORDER_ATOMIC);
+    var speed = generator.valueToCode(block, 'RPM', generator.ORDER_ATOMIC);
+
+    if (speed == "nil") {
+        return [`${motor}.translate(${tblock})`, luaGenerator.ORDER_NONE];
+    } else {
+        return [`${motor}.translate(${tblock}, ${speed})`, luaGenerator.ORDER_NONE];
+    }
+};
+
+luaGenerator.forBlock['create_addition_electric_motor_get_speed'] = function(block, generator) {
+    var motor = generator.valueToCode(block, 'MOTOR', generator.ORDER_ATOMIC);
+
+    return [`${motor}.getSpeed()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_electric_motor_get_stress_capacity'] = function(block, generator) {
+    var motor = generator.valueToCode(block, 'MOTOR', generator.ORDER_ATOMIC);
+
+    return [`${motor}.getStressCapacity()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_electric_motor_get_energy_consumption'] = function(block, generator) {
+    var motor = generator.valueToCode(block, 'MOTOR', generator.ORDER_ATOMIC);
+
+    return [`${motor}.getEnergyConsumption()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_electric_motor_get_max_input'] = function(block, generator) {
+    var motor = generator.valueToCode(block, 'MOTOR', generator.ORDER_ATOMIC);
+
+    return [`${motor}.getMaxInsert()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_electric_motor_get_max_output'] = function(block, generator) {
+    var motor = generator.valueToCode(block, 'MOTOR', generator.ORDER_ATOMIC);
+
+    return [`${motor}.getMaxExtract()`, luaGenerator.ORDER_NONE];
+};
+
+// generator for Accumulator
+
+luaGenerator.forBlock['create_addition_accumulator_get_energy'] = function(block, generator) {
+    var accumulator = generator.valueToCode(block, 'ACCUMULATOR', generator.ORDER_ATOMIC);
+
+    return [`${accumulator}.getEnergy()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_accumulator_get_capacity'] = function(block, generator) {
+    var accumulator = generator.valueToCode(block, 'ACCUMULATOR', generator.ORDER_ATOMIC);
+
+    return [`${accumulator}.getCapacity()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_accumulator_get_percent'] = function(block, generator) {
+    var accumulator = generator.valueToCode(block, 'ACCUMULATOR', generator.ORDER_ATOMIC);
+
+    return [`${accumulator}.getPercent()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_accumulator_get_max_input'] = function(block, generator) {
+    var accumulator = generator.valueToCode(block, 'ACCUMULATOR', generator.ORDER_ATOMIC);
+
+    return [`${accumulator}.getMaxInsert()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_accumulator_get_max_output'] = function(block, generator) {
+    var accumulator = generator.valueToCode(block, 'ACCUMULATOR', generator.ORDER_ATOMIC);
+
+    return [`${accumulator}.getMaxExtract()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_accumulator_get_height'] = function(block, generator) {
+    var accumulator = generator.valueToCode(block, 'ACCUMULATOR', generator.ORDER_ATOMIC);
+
+    return [`${accumulator}.getHeight()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_accumulator_get_width'] = function(block, generator) {
+    var accumulator = generator.valueToCode(block, 'ACCUMULATOR', generator.ORDER_ATOMIC);
+
+    return [`${accumulator}.getWidth()`, luaGenerator.ORDER_NONE];
+};
+
+// generator for Portable Energy Interface (PEI)
+
+luaGenerator.forBlock['create_addition_pei_get_energy'] = function(block, generator) {
+    var pei = generator.valueToCode(block, 'PEI', generator.ORDER_ATOMIC);
+
+    return [`${pei}.getEnergy()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_pei_get_capacity'] = function(block, generator) {
+    var pei = generator.valueToCode(block, 'PEI', generator.ORDER_ATOMIC);
+
+    return [`${pei}.getCapacity()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_pei_is_connected'] = function(block, generator) {
+    var pei = generator.valueToCode(block, 'PEI', generator.ORDER_ATOMIC);
+
+    return [`${pei}.isConnected()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_pei_get_max_input'] = function(block, generator) {
+    var pei = generator.valueToCode(block, 'PEI', generator.ORDER_ATOMIC);
+
+    return [`${pei}.getMaxInsert()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_pei_get_max_output'] = function(block, generator) {
+    var pei = generator.valueToCode(block, 'PEI', generator.ORDER_ATOMIC);
+
+    return [`${pei}.getMaxExtract()`, luaGenerator.ORDER_NONE];
+};
+
+// generator for Redstone Relay
+
+luaGenerator.forBlock['create_addition_relay_get_max_input'] = function(block, generator) {
+    var relay = generator.valueToCode(block, 'RELAY', generator.ORDER_ATOMIC);
+
+    return [`${relay}.getMaxInsert()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_relay_get_max_output'] = function(block, generator) {
+    var relay = generator.valueToCode(block, 'RELAY', generator.ORDER_ATOMIC);
+
+    return [`${relay}.getMaxExtract()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_relay_get_throughput'] = function(block, generator) {
+    var relay = generator.valueToCode(block, 'RELAY', generator.ORDER_ATOMIC);
+
+    return [`${relay}.getThroughput()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_relay_is_powered'] = function(block, generator) {
+    var relay = generator.valueToCode(block, 'RELAY', generator.ORDER_ATOMIC);
+
+    return [`${relay}.isPowered()`, luaGenerator.ORDER_NONE];
+};
+
+// Digital Adapter | Rotational Speed Controller
+
+luaGenerator.forBlock['create_addition_da_rotational_speed_control_set_target_speed'] = function(block, generator) {
+    var speed = generator.valueToCode(block, 'RPM', generator.ORDER_ATOMIC);
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    return `${adapter}.setTargetSpeed("${side}", ${speed})\n`;
+};
+
+luaGenerator.forBlock['create_addition_da_rotational_speed_control_get_target_speed'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    return [`${adapter}.getTargetSpeed("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+// Digital Adapter | Stressometer
+
+luaGenerator.forBlock['create_addition_da_stressometer_get_kinetic_stress'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    return [`${adapter}.getKineticStress("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_da_stressometer_get_kinetic_capacity'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    return [`${adapter}.getKineticSpeed("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+// Digital Adapter | Speedometer
+
+luaGenerator.forBlock['create_addition_da_speedometer_get_kinetic_speed'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    return [`${adapter}.getKineticSpeed("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_da_speedometer_get_kinetic_max_speed'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+
+    return [`${adapter}.getKineticTopSpeed()`, luaGenerator.ORDER_NONE];
+};
+
+// Digital Adapter | Pulleys
+
+luaGenerator.forBlock['create_addition_da_pulleys_get_pulleys_distance'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    return [`${adapter}.getPulleyDistance("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+// Digital Adapter | Elevator Pulley
+
+luaGenerator.forBlock['create_addition_da_elevator_pulley_get_elevator_floor'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    return [`${adapter}.getElevatorFloor("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_da_elevator_pulley_get_elevator_floors'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    return [`${adapter}.getElevatorFloors("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_da_elevator_pulley_get_elevator_floor_name'] = function(block, generator) {
+    var floorindex = generator.valueToCode(block, 'INDEX', generator.ORDER_ATOMIC);
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    return [`${adapter}.getElevatorFloorName("${side}", ${floorindex})`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_da_elevator_pulley_goto_elevator_floor_name'] = function(block, generator) {
+    var floorindex = generator.valueToCode(block, 'INDEX', generator.ORDER_ATOMIC);
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    if (block.outputConnection && block.outputConnection.targetConnection) {
+        return [`${adapter}.gotoElevatorFloor("${side}", ${floorindex})`, luaGenerator.ORDER_NONE];
+    } else {
+        return `${adapter}.gotoElevatorFloor("${side}", ${floorindex})\n`;
+    }
+};
+
+// Digital Adapter | Mechanical Piston
+
+luaGenerator.forBlock['create_addition_da_mechanical_piston_get_piston_distance'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    return [`${adapter}.getPistonDistance("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+// Digital Adapter | Mechanical Bearing
+
+luaGenerator.forBlock['create_addition_da_mechanical_bearing_get_bearing_angle'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+    var side = block.getFieldValue('SIDE');
+
+    return [`${adapter}.getBearingAngle("${side}")`, luaGenerator.ORDER_NONE];
+};
+
+// Digital Adapter | Display Link
+
+luaGenerator.forBlock['create_addition_da_dp_link_print'] = function(block, generator) {
+    var text = generator.valueToCode(block, 'TEXT', generator.ORDER_ATOMIC);
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+
+    return `${adapter}.print("${text}")\n`;
+};
+
+luaGenerator.forBlock['create_addition_da_dp_link_clear_line'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+
+    return `${adapter}.clearLine()\n`;
+};
+
+luaGenerator.forBlock['create_addition_da_dp_link_clear'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+
+    return `${adapter}.clear()\n`;
+};
+
+luaGenerator.forBlock['create_addition_da_dp_link_get_line'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+
+    return [`${adapter}.getLine()`, luaGenerator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['create_addition_da_dp_link_set_line'] = function(block, generator) {
+    var line = generator.valueToCode(block, 'LINE', generator.ORDER_ATOMIC);
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+
+    return `${adapter}.setLine()\n`;
+};
+
+luaGenerator.forBlock['create_addition_da_dp_link_get_max_line'] = function(block, generator) {
+    var adapter = generator.valueToCode(block, 'DA', generator.ORDER_ATOMIC);
+
+    return [`${adapter}.getMaxLines()`, luaGenerator.ORDER_NONE];
+};

blocks/Create_Additions/index.json

@@ -0,0 +1,24 @@
+{
+    "name": "Create Crafts & Additions",
+    "author": "DPSoftware Foundation",
+    "description": "https://www.curseforge.com/minecraft/mc-mods/createaddition",
+    "version": "1.0",
+    "category": "Create",
+    "keyword": "create mod",
+    "license": "GPL-3.0-or-later",
+    "peripherals": true,
+    "library": false,
+    "require_network": false,
+    "dependencies": [
+        "CCPeripheral"
+    ],
+    "design_for_computer": {
+        "basic": true,
+        "adv": true, 
+        "command": true,
+        "pocket": false,
+        "advpocket": false,
+        "turtle": true,
+        "advturtle": true
+    }
+}

blocks/Create_Additions/toolbox.xml

@@ -0,0 +1,125 @@
+<xml id="toolbox" style="display: none;">
+    <category name="Create Additions" colour="70">
+        <label text="Electric Motor"></label>
+        <block type="create_addition_electric_motor_set_speed">
+            <value name="RPM">
+                <shadow type="math_number">
+                    <field name="NUM">32</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="create_addition_electric_motor_stop"></block>
+        <block type="create_addition_electric_motor_rotate">
+            <value name="DEGREES">
+                <shadow type="math_number">
+                    <field name="NUM">90</field>
+                </shadow>
+            </value>
+            <value name="RPM">
+                <shadow type="logic_null"></shadow>
+            </value>
+        </block>
+        <block type="create_addition_electric_motor_translate">
+            <value name="BLOCKS">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+            <value name="RPM">
+                <shadow type="logic_null"></shadow>
+            </value>
+        </block>
+        <block type="create_addition_electric_motor_get_speed"></block>
+        <block type="create_addition_electric_motor_get_stress_capacity"></block>
+        <block type="create_addition_electric_motor_get_energy_consumption"></block>
+        <block type="create_addition_electric_motor_get_max_input"></block>
+        <block type="create_addition_electric_motor_get_max_output"></block>
+
+        <label text="Accumulator"></label>
+        <block type="create_addition_accumulator_get_energy"></block>
+        <block type="create_addition_accumulator_get_capacity"></block>
+        <block type="create_addition_accumulator_get_percent"></block>
+        <block type="create_addition_accumulator_get_max_input"></block>
+        <block type="create_addition_accumulator_get_max_output"></block>
+        <block type="create_addition_accumulator_get_height"></block>
+        <block type="create_addition_accumulator_get_width"></block>
+
+        <label text="Portable Energy Interface (PEI)"></label>
+        <block type="create_addition_pei_get_energy"></block>
+        <block type="create_addition_pei_get_capacity"></block>
+        <block type="create_addition_pei_is_connected"></block>
+        <block type="create_addition_pei_get_max_input"></block>
+        <block type="create_addition_pei_get_max_output"></block>
+
+        <label text="Redstone Relay"></label>
+        <block type="create_addition_relay_get_max_input"></block>
+        <block type="create_addition_relay_get_max_output"></block>
+        <block type="create_addition_relay_get_throughput"></block>
+        <block type="create_addition_relay_is_powered"></block>
+
+        <label text="Digital Adapter | Rotational Speed Controller"></label>
+        <block type="create_addition_da_rotational_speed_control_set_target_speed">
+            <value name="RPM">
+                <shadow type="math_number">
+                    <field name="NUM">32</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="create_addition_da_rotational_speed_control_get_target_speed"></block>
+
+        <label text="Digital Adapter | Stressometer"></label>
+        <block type="create_addition_da_stressometer_get_kinetic_stress"></block>
+        <block type="create_addition_da_stressometer_get_kinetic_capacity"></block>
+    
+        <label text="Digital Adapter | Speedometer"></label>
+        <block type="create_addition_da_speedometer_get_kinetic_speed"></block>
+        <block type="create_addition_da_speedometer_get_kinetic_max_speed"></block>
+
+        <label text="Digital Adapter | Pulleys"></label>
+        <block type="create_addition_da_pulleys_get_pulleys_distance"></block>
+        
+        <label text="Digital Adapter | Elevator Pulley"></label>
+        <block type="create_addition_da_elevator_pulley_get_elevator_floor"></block>
+        <block type="create_addition_da_elevator_pulley_get_elevator_floors"></block>
+        <block type="create_addition_da_elevator_pulley_get_elevator_floor_name">
+            <value name="INDEX">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="create_addition_da_elevator_pulley_goto_elevator_floor_name">
+            <value name="INDEX">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+        </block>
+
+        <label text="Digital Adapter | Mechanical Piston"></label>
+        <block type="create_addition_da_mechanical_piston_get_piston_distance"></block>
+
+        <label text="Digital Adapter | Mechanical Bearing"></label>
+        <block type="create_addition_da_mechanical_bearing_get_bearing_angle"></block>
+
+        <label text="Digital Adapter | Display Link"></label>
+        <block type="create_addition_da_dp_link_print">
+            <value name="TEXT">
+                <shadow type="text">
+                    <field name="TEXT">Hello, world!</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="create_addition_da_dp_link_clear_line"></block>
+        <block type="create_addition_da_dp_link_clear"></block>
+        <block type="create_addition_da_dp_link_get_line"></block>
+        <block type="create_addition_da_dp_link_set_line">
+            <value name="LINE">
+                <shadow type="math_number">
+                    <field name="NUM">1</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="create_addition_da_dp_link_get_max_line"></block>
+    </category>
+</xml>

blocks/NativeIO/block_design.json

@@ -0,0 +1,134 @@
+{
+    "io_open": {
+        "message0": "Open file %1 with mode %2",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "FILENAME",
+                "check": "String"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "MODE",
+                "options": [
+                    ["read", "r"],
+                    ["write", "w"],
+                    ["append", "a"],
+                    ["read/write", "r+"],
+                    ["write/read", "w+"]
+                ]
+            }
+        ],
+        "output": "File",
+        "colour": 260,
+        "tooltip": "Open a file with the given mode"
+    },
+    "io_close": {
+        "message0": "Close file %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "FILE",
+                "check": "File"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 260,
+        "tooltip": "Close the specified file"
+    },
+    "io_flush": {
+        "message0": "Flush file %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "FILE",
+                "check": "File"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 260,
+        "tooltip": "Flush any buffered output, forcing it to be written to the file"
+    },
+    "io_read": {
+        "message0": "Read from file %1 with format %2",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "FILE",
+                "check": "File"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "FORMAT",
+                "options": [
+                    ["line", "l"],
+                    ["line ln", "L"],
+                    ["All", "a"]
+                ]
+            }
+        ],
+        "output": "String",
+        "colour": 260,
+        "tooltip": "Read data from the file"
+    },
+    "io_write": {
+        "message0": "Write %1 to file %2",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "DATA"
+            },
+            {
+                "type": "input_value",
+                "name": "FILE",
+                "check": "File"
+            }
+        ],
+        "previousStatement": null,
+        "nextStatement": null,
+        "colour": 260,
+        "tooltip": "Write data to the file"
+    },
+    "io_lines": {
+        "message0": "Read line %1",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "FILE",
+                "check": "File"
+            }
+        ],
+        "output": "Array",
+        "colour": 260,
+        "tooltip": "Returns an iterator that, each time it is called, returns a new line from the file."
+    },
+    "io_seek": {
+        "message0": "Seek in file %1 to position %2 with offset %3",
+        "args0": [
+            {
+                "type": "input_value",
+                "name": "FILE",
+                "check": "File"
+            },
+            {
+                "type": "field_dropdown",
+                "name": "POSITION",
+                "options": [
+                    ["Set", "set"],
+                    ["Current", "cur"],
+                    ["End", "end"]
+                ]
+            },
+            {
+                "type": "input_value",
+                "name": "OFFSET",
+                "check": "Number"
+            }
+        ],
+        "output": "Number",
+        "colour": 260,
+        "tooltip": "Seek to a specific position in the file"
+    }
+}

blocks/NativeIO/generator.js

@@ -0,0 +1,52 @@
+const { luaGenerator } = require('blockly/lua');
+
+if (!luaGenerator.forBlock) {
+    luaGenerator.forBlock = {};
+}
+
+luaGenerator.forBlock['io_open'] = function(block, generator) {
+    const filename = generator.valueToCode(block, 'FILENAME', generator.ORDER_ATOMIC);
+    const mode = block.getFieldValue('MODE');
+    const code = `io.open(${filename}, "${mode}")`;
+    return [code, generator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['io_close'] = function(block, generator) {
+    const file = generator.valueToCode(block, 'FILE', generator.ORDER_ATOMIC);
+    const code = `${file}:close()\n`;
+    return code;
+};
+
+luaGenerator.forBlock['io_read'] = function(block, generator) {
+    const file = generator.valueToCode(block, 'FILE', generator.ORDER_ATOMIC);
+    const format = block.getFieldValue('FORMAT');
+    const code = `${file}:read("${format}")`;
+    return [code, generator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['io_write'] = function(block, generator) {
+    const data = generator.valueToCode(block, 'DATA', generator.ORDER_NONE) || '""';
+    const file = generator.valueToCode(block, 'FILE', generator.ORDER_ATOMIC);
+    const code = `${file}:write(${data})\n`;
+    return code;
+};
+
+luaGenerator.forBlock['io_seek'] = function(block, generator) {
+    const file = generator.valueToCode(block, 'FILE', generator.ORDER_ATOMIC);
+    const position = generator.valueToCode(block, 'POSITION', generator.ORDER_ATOMIC);
+    const offset = generator.valueToCode(block, 'OFFSET', generator.ORDER_ATOMIC);
+    const code = `${file}:seek("${position}", ${offset})`;
+    return [code, generator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['io_lines'] = function(block, generator) {
+    const file = generator.valueToCode(block, 'FILE', generator.ORDER_ATOMIC);
+    const code = `${file}:lines()`;
+    return [code, generator.ORDER_NONE];
+};
+
+luaGenerator.forBlock['io_flush'] = function(block, generator) {
+    const file = generator.valueToCode(block, 'FILE', generator.ORDER_ATOMIC);
+    const code = `${file}:flush()\n`;
+    return code;
+};

blocks/NativeIO/index.json

@@ -0,0 +1,22 @@
+{
+    "name": "IO",
+    "author": "DPSoftware Foundation",
+    "description": "Lua Native: Input/Output file",
+    "version": "1.0.0",
+    "category": "Native",
+    "keyword": "Native, Lua, IO",
+    "license": "GPL-3.0-or-later",
+    "peripherals": false,
+    "library": false,
+    "require_network": false,
+    "dependencies": [],
+    "design_for_computer": {
+        "basic": true,
+        "adv": true, 
+        "command": true,
+        "pocket": true,
+        "advpocket": true,
+        "turtle": true,
+        "advturtle": true
+    }
+}

blocks/NativeIO/toolbox.xml

@@ -0,0 +1,36 @@
+<xml id="toolbox" style="display: none;">
+    <category name="IO" colour="260">
+        <!-- Open file block -->
+        <block type="io_open">
+            <value name="MODE">
+                <shadow type="field_dropdown">
+                    <field name="MODE">r</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="io_read">
+            <value name="FORMAT">
+                <shadow type="field_dropdown">
+                    <field name="FORMAT">a</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="io_write">
+            <value name="DATA">
+                <shadow type="text">
+                    <field name="TEXT">Hello, world!</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="io_seek">
+            <value name="OFFSET">
+                <shadow type="math_number">
+                    <field name="NUM">0</field>
+                </shadow>
+            </value>
+        </block>
+        <block type="io_lines"></block>
+        <block type="io_flush"></block>
+        <block type="io_close"></block>    
+    </category>
+</xml>

blocks/_Template/index.json

@@ -9,7 +9,7 @@
     "peripherals": false,
     "library": false,
     "require_network": false,
-    "dependencies": {},
+    "dependencies": [],
     "design_for_computer": {
         "basic": false,
         "adv": false, 

ccIDE.wheel

@@ -0,0 +1 @@
+{"title":"ccIDE","description":"","entries":[{"text":"fs","id":"bpjk25nz5u"},{"text":"gps","id":"4ycx32t6zv"},{"text":"http","id":"sy5e4jg9te"},{"text":"multishell","id":"zmpdq862sr"},{"text":"paintutils","id":"2kcgbw3r5k"},{"text":"peripheral","id":"jzj9g9s4q9"},{"text":"shell","id":"aekamm3pn6"},{"text":"term","id":"phtvswrv6v"},{"text":"vector","id":"6c6uz56m77"},{"text":"window","id":"5dk6dkpz9b"},{"text":"cc.audio.dfpwm","id":"dkbm2ftkcr"},{"text":"cc.completion","id":"95vdrwx3rf"},{"text":"cc.expect","id":"g6agen6yej"},{"text":"cc.image.nft","id":"rwb9d7eru7"},{"text":"cc.pretty","id":"twkxbcsgh8"},{"text":"cc.require","id":"b3n7k2xnny"},{"text":"cc.shell.completion","id":"9x98gv9hba"},{"text":"cc.strings","id":"jcru68rr39"},{"text":"computer (turtle)","id":"cdrvm4equh"},{"text":"monitor (peripheral)","id":"hmtaqyh5rf"},{"text":"printer (peripheral)","id":"kcwfe8suy5"},{"text":"speaker (peripheral)","id":"92p9tv9wbz"},{"text":"energy_storage (peripheral)","id":"3td8u4cua3"},{"text":"fluid_storage (peripheral)","id":"gt2ndb9pj4"},{"text":"inventory (peripheral)","id":"zx9c8aqakq"}],"colorSettings":[{"color":"#3369E8","enabled":true},{"color":"#D50F25","enabled":true},{"color":"#EEB211","enabled":true},{"color":"#009925","enabled":true},{"color":"#000000","enabled":false},{"color":"#000000","enabled":false}],"pageBackgroundColor":"#FFFFFF","type":"color","pictureType":"none","coverImageType":"gallery","coverImageName":"/images/chocolate-chip-cookie.jpg","galleryPicture":"/images/none.png","customPictureName":"","customPictureDataUri":"","customCoverImageDataUri":"","centerText":"","allowDuplicates":true,"duringSpinSound":"ticking-sound","duringSpinSoundVolume":50,"afterSpinSound":"no-sound","afterSpinSoundVolume":50,"maxNames":1000,"spinTime":10,"launchConfetti":true,"animateWinner":false,"autoRemoveWinner":true,"displayWinnerDialog":true,"displayRemoveButton":true,"displayHideButton":true,"winnerMessage":"เรามีผู้ชนะ!","playClickWhenWinnerRemoved":false,"hubSize":"S","drawOutlines":false,"slowSpin":false,"showTitle":true,"isAdvanced":false}

index.js

@@ -1,24 +1,90 @@
+console.log("Initializing...")
 const { app, BrowserWindow, ipcMain, Menu, dialog } = require('electron')
 const fs = require('fs');
 const prompt = require('electron-prompt');
 const path = require('path');
+const pino = require('pino')
+const pretty = require('pino-pretty');
+const https = require('node:https');
+
 const ipc = ipcMain
 
+const logger = pino(pretty())
+
 process.env['ELECTRON_DISABLE_SECURITY_WARNINGS'] = 'true';
 
-let currentprojectpath = null;
-let currentprojectname = null;
-let currentprojectopen = false;
-let appexiting = false;
-let appreloading = false;
-let currentworkspacechange = false;
-let isopennewproject = false;
+var ena_splash = process.env['CCIDE_ENABLE_MAIN_SPLASH'] == 'true';
 
-app.whenReady().then(() => {
+var currentprojectpath = null;
+var currentprojectname = null;
+var currentprojectopen = false;
+var appexiting = false;
+var appreloading = false;
+var currentworkspacechange = false;
+var isopennewproject = false;
+
+var appstarted = false;
+var version;
+var gitver;
+
+try {
+    // Read package.json synchronously
+    const data = fs.readFileSync('package.json', 'utf8');
+
+    // Parse JSON
+    const packageJson = JSON.parse(data);
+
+    // Get project version
+    version = packageJson.version;
+} catch (err) {
+    console.error("Error reading package.json:", err);
+}
+
+function checkupdate() {
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+                hostname: 'api.github.com',
+                port: 443,
+                path: '/repos/DPSoftware-Foundation/ccIDE/releases/latest',
+                method: 'GET',
+                headers: {
+                'User-Agent': 'ccIDE-Check-Update-Service', // GitHub API requires a User-Agent header
+            }
+        }, (res) => {
+            let data = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.tag_name); // Return the tag_name or other relevant data
+                } catch (e) {
+                    reject('Error parsing JSON: ' + e.message);
+                }
+            });
+        });
+    
+        req.on('error', (e) => {
+            reject('Error fetching release: ' + e.message);
+        });
+    
+        req.end();
+    });
+}
+
+function normalizeVersion(version, length = 4) {
+    // Split the version string into parts and pad with zeros if necessary
+    return version.split('.').map(part => part.padStart(2, '0')).concat(Array(length).fill('00')).slice(0, length).join('.');
+}
+
+app.whenReady().then(async () => {
+    logger.info("Initializing splash window...")
     reloadall(false);
     var splash = new BrowserWindow({
-        width: 600, 
-        height: 300, 
+        width: 720, 
+        height: 400, 
         icon: path.join(__dirname, 'assets', 'ccIDEIcon.ico'),
         transparent: true, 
         frame: false, 
@@ -26,11 +92,77 @@ app.whenReady().then(() => {
         webPreferences: {
             nodeIntegration: true,
             contextIsolation: false,
-        }
+        },
+        resizable: false
     });
 
     splash.loadFile('src/splash.html');
-    splash.webContents.send("change-status", "Initializing...")
+
+    while (!splash.isVisible()) {}
+
+    // checkupdate
+    logger.info("Checking for new update...")
+    splash.webContents.send("change-status", "Checking for new update...")
+    
+    try {
+        const latestRelease = await checkupdate();
+        // Store the version or use it as needed
+        gitver = latestRelease;
+    } catch (error) {
+        logger.error('Error in update check:', error);
+    }
+
+    logger.info("Current version: " + version)
+    logger.info("Version in github: " + gitver)
+    
+
+    const normalizedAppVersion = normalizeVersion(version);
+
+    if (!gitver) {
+        logger.error("Can't check update")
+    } else {
+        const normalizedReleaseVersion = normalizeVersion(gitver);
+        if (normalizedAppVersion >= normalizedReleaseVersion) {
+            logger.info("Software is up-to-date.");
+        } else {
+            logger.info("A new update is available: " + gitver)
+            var is_not_skip_update = localStorage.getItem('skip_update_version') != normalizedAppVersion;
+            var is_ignore = localStorage.getItem('ignore_update');
+            if (is_ignore || is_not_skip_update) {
+                const result = dialog.showMessageBoxSync({
+                    type: 'question',
+                    buttons: ['Update', 'Ignore', 'Skip'],
+                    defaultId: 0,
+                    title: 'Update Available',
+                    message: `A new version (${gitver}) is available. Do you want to update now?`,
+                    detail: 'Click "Update" to go to the release page, "Ignore" to ignore this update, or "Skip" to skip this version.'
+                });
+                switch (result.response) {
+                    case 0: // 'Update'
+                        (async () => {
+                            try {
+                                const { default: open } = await import('open');
+                            
+                                await open('https://github.com/DPSoftware-Foundation/ccIDE/releases/latest');
+                                console.log('URL opened in default browser');
+                            } catch (err) {
+                                console.error('Error opening URL:', err);
+                            }
+                        })();
+                        break;
+                    case 1: // 'Ignore'
+                        localStorage.setItem('ignore_update', true);
+                        break;
+                    case 2: // 'Skip'
+                        localStorage.setItem('skip_update_version', normalizedReleaseVersion);
+                        break;
+                }
+            }
+        }
+    }
+
+    logger.info("Initializing main windows...")
+    splash.webContents.send("change-status", "Initializing main windows...")
 
     const win = new BrowserWindow({
         width: 1280,
@@ -42,10 +174,10 @@ app.whenReady().then(() => {
             enableRemoteModule: true,
             contextIsolation: false,
         },
-        show: false,
+        show: ena_splash,
         center: true,
     })
-
+    
     try {
         win.loadFile('src/index.html');
     } catch {
@@ -55,24 +187,50 @@ app.whenReady().then(() => {
             dialog.showErrorBox("Error on startup", "Can't find index.html");
         }
     }
-    win.setTitle(`ccIDE`)
+    win.setTitle(`ccIDE v${version}`)
 
     ipc.once('ready', () => {
-        console.log("ready")
+        splash.webContents.send("isloaded")
+        splash.webContents.send("change-status", "Thanks for using software from DPSoftware.")
+        splash.webContents.send("change-title", `ccIDE v${version}`)
+        logger.info("Ready!")
         if (splash) {
-            splash.close();
+            splash.hide();
         }
         win.show();
-        win.maximize();
+        //win.maximize();
+        appstarted = true;
     });
 
+    ipc.on("splash-close", (event) => {
+        if (appstarted) {
+            splash.hide();
+        } else {
+            splash.close();
+            win.close();
+        }
+    })
+
     ipc.on('erroronstart', (event, errormessage) => {
+        logger.error(errormessage)
         dialog.showErrorBox("Error on startup", errormessage);
         //win.openDevTools();
     });
 
-    ipc.on('update-startup-status', (event, status) => {
-        splash.webContents.send("change-status", status)
+    ipc.on('error', (event, errormessage) => {
+        logger.error(errormessage)
+        dialog.showErrorBox("Error", errormessage);
+        //win.openDevTools();
+    });
+
+    ipc.on('update-log-status', (event, status) => {
+        logger.info(status);
+        if (!appstarted) {
+            splash.webContents.send("change-status", status);
+        }
+        if (status == "Downloading blocks...") {
+            win.show();
+        }
     });
     
     //app.on('activate', () => {
@@ -90,11 +248,12 @@ app.whenReady().then(() => {
         appreloading = false;
         isopennewproject = false;
         if (isloaded) {
-            win.setTitle(`ccIDE`)
+            win.setTitle(`ccIDE v${version}`)
             win.reload();
         }
     }
 
+    logger.info("Settings up menu bar...")
     // Define a custom menu template
     const menuTemplate = [
         {
@@ -161,7 +320,7 @@ app.whenReady().then(() => {
                                             currentprojectname = path.basename(result.filePaths[0]);
                                             currentprojectopen = true;
     
-                                            win.setTitle(`${currentprojectname} | ccIDE`)
+                                            win.setTitle(`${currentprojectname} | ccIDE v${version}`)
                                         });
     
                                     }
@@ -196,7 +355,7 @@ app.whenReady().then(() => {
                                         currentprojectname = path.basename(result.filePaths[0]);
                                         currentprojectopen = true;
 
-                                        win.setTitle(`${currentprojectname} | ccIDE`)
+                                        win.setTitle(`${currentprojectname} | ccIDE v${version}`)
                                     });
 
                                 }
@@ -266,6 +425,16 @@ app.whenReady().then(() => {
                     click: () => {
                         win.webContents.send("open-about")
                     }
+                },
+                {
+                    label: 'Splash Screen',
+                    click: () => {
+                        if (!splash.isVisible()) {
+                            splash.show();
+                        } else {
+                            splash.hide();
+                        }
+                    }
                 }
             ]
         }
@@ -274,6 +443,8 @@ app.whenReady().then(() => {
     // Set the custom menu
     const menu = Menu.buildFromTemplate(menuTemplate);
     Menu.setApplicationMenu(menu);
+
+    logger.info("Settings up event...")
     
     ipc.on('prompt', (event, promptText, defaultValue) => {
         try {
@@ -324,7 +495,7 @@ app.whenReady().then(() => {
 
                             win.webContents.send('workspace-saved', true);
 
-                            win.setTitle(`${currentprojectname} | ccIDE`)
+                            win.setTitle(`${currentprojectname} | ccIDE v${version}`)
                             if (currentworkspacechange) {
                                 currentworkspacechange = false;
                             }
@@ -349,7 +520,7 @@ app.whenReady().then(() => {
 
                     win.webContents.send('workspace-saved', true);
 
-                    win.setTitle(`${currentprojectname} | ccIDE`)
+                    win.setTitle(`${currentprojectname} | ccIDE v${version}`)
 
                     if (currentworkspacechange) {
                         currentworkspacechange = false;
@@ -384,7 +555,7 @@ app.whenReady().then(() => {
                                     currentprojectname = path.basename(result.filePaths[0]);
                                     currentprojectopen = true;
 
-                                    win.setTitle(`${currentprojectname} | ccIDE`)
+                                    win.setTitle(`${currentprojectname} | ccIDE v${version}`)
                                 });
 
                             }
@@ -420,44 +591,51 @@ app.whenReady().then(() => {
     });
 
     ipc.on('workspace-notsave', (event) => {
-        win.setTitle(`${currentprojectname}* | ccIDE`)
+        win.setTitle(`${currentprojectname}* | ccIDE v${version}`)
         currentworkspacechange = true;
     })
     ipc.on('workspace-unsave', (event) => {
         currentworkspacechange = true;
     })
-})
 
-
-app.on("close", function(e) {
-    console.log("Close event triggered");
-    if (currentprojectopen) {
-        const result = dialog.showMessageBoxSync({
-            type: 'question',
-            buttons: ['Save', 'Don\'t Save', 'Cancel'],
-            defaultId: 2,
-            title: 'Save Changes',
-            message: "Your project is not saved",
-        });
-        if (result === 1) {
-            // Don't save, continue closing
-            win = null;
-        } else if (result === 0) {
-            // Save and then quit
-            appexiting = true;
-            win.webContents.send('save-workspace-request');
+    // Listen for the close event of the main window
+    /*
+    win.on('close', (event) => {
+        event.preventDefault()
+        if (currentprojectopen && !currentworkspacechange) {
+            const result = dialog.showMessageBoxSync({
+                type: 'question',
+                buttons: ['Save', 'Don\'t Save', 'Cancel'],
+                defaultId: 2,
+                title: 'Save Changes',
+                message: "Your project is not saved",
+            });
+            if (result === 1) {
+                // Don't save, continue closing
+                win.close();
+            } else if (result === 0) {
+                // Save and then quit
+                appexiting = true;
+                win.webContents.send('save-workspace-request');
+            }
         } else {
-            // Cancel the close operation
-            e.preventDefault();
+            win.destroy();
         }
-    } else {
-        // No unsaved changes, continue closing
-        win = null;
-    }
-});
+    });
+    */
+
+    win.on("closed", () => {
+        logger.info("Exiting...")
+        if (!splash.isDestroyed()) {
+            splash.close()
+        }
+    })
+    
+})
 
 app.on('window-all-closed', () => {
     if (process.platform !== 'darwin') {
         app.quit();
     }
+    logger.info("Exited")
 });

package.json

@@ -1,23 +1,52 @@
 {
   "name": "ccide",
-  "version": "1.1",
+  "version": "1.6.0",
   "description": "ComputerCraft mod virtual lua IDE",
-  "main": "index.js",
+  "main": "dist/main.js",
   "scripts": {
-    "dev": "electron .",
-    "build": "electron-packager . ccIDE --platform=win32 --arch=x64 --icon=assets/ccIDEIcon.ico --out=dist --overwrite"
+    "dev": "title ccIDE && electron .",
+    "build": "title building ccIDE && electron-packager . ccIDE --platform=win32 --arch=x64 --icon=assets/ccIDEIcon.ico --out=dist --overwrite && for /d %i in (dist\\ccIDE-*) do copy package.json %i\\",
+    "build_debug": "title building ccIDE (Debug) && electron-packager . ccIDE --platform=win32 --arch=x64 --icon=assets/ccIDEIcon.ico --out=dist_debug --overwrite --debug && for /d %i in (dist_debug\\ccIDE-*) do copy package.json %i\\",
+    "new_build": "webpack --config webpack.main.config.js && webpack --config webpack.renderer.config.js",
+    "dist": "electron-builder"
   },
   "author": "DPSoftware Foundation",
   "license": "GPL-3.0-or-later",
   "devDependencies": {
-    "electron": "^31.1.0"
+    "copy-webpack-plugin": "^12.0.2",
+    "electron": "^31.7.7",
+    "electron-builder": "^25.1.8",
+    "html-webpack-plugin": "^5.6.3",
+    "terser-webpack-plugin": "^5.3.11",
+    "webpack": "^5.97.1",
+    "webpack-cli": "^6.0.1",
+    "webpack-merge": "^6.0.1",
+    "webpack-node-externals": "^3.0.0"
   },
   "dependencies": {
     "@blockly/plugin-workspace-search": "^9.0.5",
+    "@blockly/theme-dark": "^7.0.7",
     "@electron/remote": "^2.1.2",
     "blockly": "^11.1.1",
     "bootstrap": "^5.3.3",
     "electron-prompt": "^1.7.0",
+    "node-localstorage": "^3.0.5",
+    "open": "^10.1.0",
+    "pino": "^9.3.2",
+    "pino-pretty": "^11.2.2",
+    "toastify-js": "^1.12.0",
+    "unzipper": "^0.12.3",
     "xmldom": "^0.6.0"
+  },
+  "build": {
+    "appId": "dev.dpsoftware.ccide",
+    "productName": "ccIDE",
+    "files": [
+      "dist/**/*",
+      "node_modules/**/*"
+    ],
+    "directories": {
+      "output": "release"
+    }
   }
 }

readme.md

@@ -1,46 +1,84 @@
 # ComputerCraft IDE (ccIDE)
 ccIDE is block based programming for ComputerCraft lua.
 
-special thank for [this repo](https://github.com/Mirka1405/ccblockly)
+special thank for [ccblockly](https://github.com/Mirka1405/ccblockly) for idea
 
-![image](https://github.com/user-attachments/assets/57c3f2b4-793b-4136-b503-6569bb577eae)
+![Screenshot 2024-08-20 202018](https://github.com/user-attachments/assets/ba6c1ca6-ce91-41c9-b412-b1f3a8f2e735)
 
 # Quick Start
-1. install nodejs and git
-2. git clone cd to this project 
-3. Install dependency use `npm install .`
-4. To run this IDE use `npm run dev`
-5. Done!
+1. install nodejs and git.
+2. git clone and cd to this project .
+3. Install dependency use `npm install .`.
+4. To run this IDE use `npm run dev` or if you using windows you can use `run.bat` to run it.
 
 ## Install Remote code into computercraft
 it very simple! to install Remote code.
-### Run from URL
-for advanced computer/pocket/turtle
 ```
-wget run https://raw.githubusercontent.com/DPSoftware-Foundation/ccIDE/main/advremote.lua
-```
-for non advance computer/pocket/turtle
-```
-wget run https://raw.githubusercontent.com/DPSoftware-Foundation/ccIDE/main/remote.lua
-```
-### Download and Run
-for advanced computer/pocket/turtle
-```
-wget https://raw.githubusercontent.com/DPSoftware-Foundation/ccIDE/main/advremote.lua advremote.lua
-advremote
-```
-for non advanced computer/pocket/turtle
-```
-wget https://raw.githubusercontent.com/DPSoftware-Foundation/ccIDE/main/remote.lua remote.lua
-remote
+wget https://raw.githubusercontent.com/DPSoftware-Foundation/ccIDE/main/startup.lua
 ```
+And restart the computer.
+
 If error "Domain not permitted" try [this solution](https://github.com/cc-tweaked/CC-Tweaked/discussions/626#discussioncomment-241924).
 
-## official support peripherals
-| Peripheral | Status 
+## official support library, peripheral and module function
+
+### Module (CC) (15/42)
+| Module | Status 
 |------------|--------
-|[Advanced Peripherals](https://www.curseforge.com/minecraft/mc-mods/advanced-peripherals) | 🟨 First support
+| [_G](https://tweaked.cc/module/_G.html) | 🟩 Supported all
+| [Disk](https://tweaked.cc/module/disk.html) | 🟩 Supported all
+| [IO](https://tweaked.cc/module/io.html) (NativeIO) | 🟩 Supported all
+| [Keys](https://tweaked.cc/module/keys.html) | 🟩 Supported all
+| [OS](https://tweaked.cc/module/os.html) (System) | 🟩 Supported all
+| [RedNet](https://tweaked.cc/module/rednet.html) | 🟩 Supported all
+| [Settings](https://tweaked.cc/module/settings.html) | 🟩 Supported all
+| [TextUtils](https://tweaked.cc/module/textutils.html) | 🟩 Supported all
+| [Peripheral](https://tweaked.cc/module/peripheral.html) | 🟩 Supported all
+| [Turtle](https://tweaked.cc/module/turtle.html) | 🟩 Supported all
+| [Energy Storage Peripheral](https://tweaked.cc/generic_peripheral/energy_storage.html) | 🟩 Supported all
+| [Fluid Storage Peripheral](https://tweaked.cc/generic_peripheral/fluid_storage.html) | 🟩 Supported all
+| [Inventory](https://tweaked.cc/generic_peripheral/inventory.html) | 🟩 Supported all
+| [Redstone](https://tweaked.cc/module/redstone.html) | 🟨 Partially Supported
+| [Colors](https://tweaked.cc/module/colors.html) | 🟨 Partially Supported
+| [Commands](https://tweaked.cc/module/commands.html) | 🟥 Unsupport
+| [FS](https://tweaked.cc/module/fs.html) | 🟥 Unsupport
+| [GPS](https://tweaked.cc/module/gps.html) | 🟥 Unsupport
+| [Help](https://tweaked.cc/module/help.html) | 🟥 Unsupport
+| [HTTP](https://tweaked.cc/module/http.html) (Network) | 🟥 Unsupport
+| [Multishell](https://tweaked.cc/module/multishell.html) | 🟥 Unsupport
+| [PaintUtils](https://tweaked.cc/module/paintutils.html) | 🟥 Unsupport
+| [Parallel](https://tweaked.cc/module/parallel.html) | 🟥 Unsupport
+| [Pocket](https://tweaked.cc/module/pocket.html) | 🟥 Unsupport
+| [Shell](https://tweaked.cc/module/shell.html) | 🟥 Unsupport
+| [Term](https://tweaked.cc/module/term.html) | 🟥 Unsupport
+| [Vector](https://tweaked.cc/module/vector.html) | 🟥 Unsupport
+| [Window](https://tweaked.cc/module/window.html) | 🟥 Unsupport
+| [DFPWM Audio](https://tweaked.cc/library/cc.audio.dfpwm.html) | 🟥 Unsupport
+| [Completion](https://tweaked.cc/library/cc.completion.html) | 🟥 Unsupport
+| [Expect](https://tweaked.cc/library/cc.expect.html) | 🟥 Unsupport
+| [NFT Image](https://tweaked.cc/library/cc.image.nft.html) | 🟥 Unsupport
+| [Pretty](https://tweaked.cc/library/cc.pretty.html) | 🟥 Unsupport
+| [Require](https://tweaked.cc/library/cc.require.html) | 🟥 Unsupport
+| [Shell Completion](https://tweaked.cc/library/cc.shell.completion.html) | 🟥 Unsupport
+| [Strings](https://tweaked.cc/library/cc.strings.html) | 🟥 Unsupport
+| [Command Peripheral](https://tweaked.cc/peripheral/command.html) | 🟥 Unsupport
+| [Computer Peripheral](https://tweaked.cc/peripheral/computer.html) | 🟥 Unsupport
+| [Drive Peripheral](https://tweaked.cc/peripheral/drive.html) | 🟥 Unsupport
+| [Modem Peripheral](https://tweaked.cc/peripheral/modem.html) | 🟥 Unsupport
+| [Monitor Peripheral](https://tweaked.cc/peripheral/monitor.html) | 🟥 Unsupport
+| [Printer Peripheral](https://tweaked.cc/peripheral/printer.html) | 🟥 Unsupport
+| [Speaker Peripheral](https://tweaked.cc/peripheral/speaker.html) | 🟥 Unsupport
+
+Event: https://tweaked.cc/event/alarm.html
+
+### Peripheral mods (2/20)
+| Mod | Status 
+|------------|--------
+|[Create Additions](https://www.curseforge.com/minecraft/mc-mods/createaddition) | 🟩 Supported all
+|[Advanced Peripherals](https://www.curseforge.com/minecraft/mc-mods/advanced-peripherals) | 🟨 Partially Supported (9/13 Peripheral)
+|[Create](https://www.curseforge.com/minecraft/mc-mods/create) | 🟨 Third support
 |[CC:C Bridge](https://www.curseforge.com/minecraft/mc-mods/cccbridge) | 🟥 Unsupport
+|[Extreme Reactors](https://www.curseforge.com/minecraft/mc-mods/extreme-reactors) ([Command](https://ftbwiki.org/Reactor_Computer_Port)) | 🟥 Unsupport
 |[CC:Destroy Bridge](https://www.curseforge.com/minecraft/mc-mods/ccdbridge) | 🟥 Unsupport
 |[More Red x CC:Tweaked Compat](https://www.curseforge.com/minecraft/mc-mods/more-red-x-cc-tweaked-compat) | 🟥 Unsupport
 |[More Peripherals](https://www.curseforge.com/minecraft/mc-mods/more-peripherals) | 🟥 Unsupport
@@ -53,9 +91,38 @@ If error "Domain not permitted" try [this solution](https://github.com/cc-tweake
 |[SirEdvin's Cloud Solutions](https://modrinth.com/mod/cloud-solutions) | 🟥 Unsupport
 |[CC: VS](https://modrinth.com/mod/cc-vs) | 🟥 Unsupport
 |[CC Shops](https://modrinth.com/mod/cc-shops) | 🟥 Unsupport
-|[SwitchCraft Peripherals](https://www.curseforge.com/minecraft/mc-mods/sc-peripherals) | 🟥 Unsupport
-|[Plethora Peripherals](https://www.curseforge.com/minecraft/mc-mods/plethora-peripherals) | 🟥 Unsupport
-|[Some Peripherals](https://modrinth.com/mod/some-peripherals) | 🟥 Unsupport
+|[SwitchCraft Peripherals](https://www.curseforge.com/minecraft/mc-mods/sc-peripherals) | 🟥 Unsupport (Old version)
+|[Plethora Peripherals](https://www.curseforge.com/minecraft/mc-mods/plethora-peripherals) | 🟥 Unsupport (Fabric only)
+|[Some Peripherals](https://modrinth.com/mod/some-peripherals) | 🟥 Unsupport (Fabric only)
+
+### Library (0/24)
+| Library | Status |
+|------------|--------|
+| [Acidity](https://github.com/9551-Dev/acidity) | 🟥 Unsupport |
+| [Anavrins' ChaCha20](https://web.archive.org/web/20200924232302/http://www.computercraft.info/forums2/index.php?/topic/25474-chacha20-encryption-in-computercraft/) ([pastebin](https://pastebin.com/GPzf9JSa)) | 🟥 Unsupport |
+| [Anavrins' MD5](https://pastebin.com/6PVSRckQ) | 🟥 Unsupport |
+| [Anavrins' SHA-1](https://pastebin.com/SfL7vxP3) | 🟥 Unsupport |
+| [Anavrins' SHA-256](https://web.archive.org/web/20230211193054/http://www.computercraft.info/forums2/index.php?/topic/8169-sha-256-in-pure-lua/) ([pastebin](https://pastebin.com/gsFrNjbt)) | 🟥 Unsupport |
+| [AUKit](https://mcjack123.github.io/AUKit/) | 🟥 Unsupport |
+| [Basalt](https://basalt.madefor.cc/) | 🟥 Unsupport |
+| [Bigfont](https://pastebin.com/3LfWxRWh) | 🟥 Unsupport |
+| [C3D](https://c3d.madefor.cc/) | 🟥 Unsupport |
+| [CC-Archive](https://github.com/MCJack123/CC-Archive) | 🟥 Unsupport |
+| [dbprotect](https://gist.github.com/MCJack123/4cf6fc941a2d412b4195caafb9636363) | 🟥 Unsupport |
+| [ecc.lua](https://web.archive.org/web/20190808224502/http://www.computercraft.info/forums2/index.php?/topic/29803-elliptic-curve-cryptography/) ([pastebin](https://pastebin.com/ZGJGBJdg)) | 🟥 Unsupport |
+| [ecnet](https://github.com/migeyel/ecnet) | 🟥 Unsupport |
+| [GuiH](https://guih.madefor.cc) | 🟥 Unsupport |
+| [IsometriH](https://github.com/9551-Dev/IsometriH) | 🟥 Unsupport |
+| [Luz](https://github.com/MCJack123/Luz) | 🟥 Unsupport |
+| [Milo](https://github.com/kepler155c/opus-apps/wiki/Milo-(crafting---storage-system)) | 🟥 Unsupport |
+| [Pine3D](https://github.com/Xella37/Pine3D) | 🟥 Unsupport |
+| [PngLua](https://github.com/9551-Dev/pngLua) | 🟥 Unsupport |
+| [Pixelbox Lite](https://github.com/9551-Dev/pixelbox_lite) | 🟥 Unsupport |
+| [RedRun](https://gist.github.com/MCJack123/473475f07b980d57dd2bd818026c97e8) | 🟥 Unsupport |
+| [Tamperer](https://github.com/Fatboychummy-CC/Tamperer) | 🟥 Unsupport |
+| [Tampl](https://github.com/9551-Dev/tampl) | 🟥 Unsupport |
+| [Telem](https://telem.cc) | 🟥 Unsupport |
+| [VeriCode](https://gist.github.com/MCJack123/7752c85918bcf23ada028abd615e8750) | 🟥 Unsupport |
 
 # Some small developer media
 [![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)
@@ -66,12 +133,8 @@ https://github.com/user-attachments/assets/195231d4-8fd8-4101-8068-70bc038a5c4f
 
 https://github.com/user-attachments/assets/8f114cfa-d87c-47d0-a670-a13dc975ab06
 
-This is my time for this project in one week
-![image](https://github.com/user-attachments/assets/d2c8ec6e-25b4-45e4-9f72-a7fb4b8906d1)
-
-
 # For adapting in other project
-This project is based for every block based IDE from DPSoftware Foundation
+This project is for every block based IDE from DPSoftware Foundation.
 
 # License 
 This project is licensed under the [GPL v3 License](https://github.com/DPSoftware-Foundation/ccIDE/blob/main/LICENSE).

remote.lua

@@ -1,48 +0,0 @@
-local ws = assert(http.websocket("ws://127.0.0.1:5133"))
-print("connected to server")
-
-local id
-local isrunning = true
-
-function exitcheck()
-    while true do
-        local event = os.pullEventRaw("terminate")
-        if event == "terminate" then
-            print("Exiting...")
-            isrunning = false
-            ws.close()
-            break
-        end
-    end
-end
-
-function main()
-    while isrunning do
-        print("ready")
-        local message, error = ws.receive()
-        if message then
-            print("Received message:", message)
-            if message == "ping" then
-                ws.send("pong")
-            elseif message == "sendcode" then
-                local file = io.open("main.lua", "w")
-                print("waiting for code")
-                local filedata, error = ws.receive()
-                file:write(filedata)
-                file:close()
-            elseif message == "runcode" then
-                shell.run("main")
-            elseif message == "exit" then
-                print("Exiting...")
-                break
-            end
-
-        else
-            print("WebSocket error:", error)
-            break
-        end
-    end
-end
-
-parallel.waitForAny(exitcheck, main)
-print("Exited")

run.bat

@@ -1,3 +1,5 @@
 @echo off
 title Starting ccIDE
+start "" cmd /c "npm cache clean --force"
+timeout 2
 npm run dev

src/blocksmanager.js

@@ -1,17 +1,116 @@
 const fs = require('fs');
 const path = require('path');
+const https = require('https');
+const unzipper = require('unzipper');
 const { DOMParser, XMLSerializer } = require('xmldom');
 
+
 const peripheralsfolder = path.join(__dirname, "../blocks"); 
 
 const fallbackImagePath = path.join(__dirname, '..', 'assets', 'noimagefallback.png'); // Path to fallback image
 
+if (!fs.existsSync(peripheralsfolder)) {
+    // If it doesn't exist, create it
+    fs.mkdirSync(peripheralsfolder, { recursive: true });
+    console.log('Block Folder created');
+}
+
+let progressBar = document.getElementById('progressBarloading');
+let blocks_url = "https://cdn.damp11113.xyz/file/zip/ccide/blockslastest.zip?dl=1"
+
+function isBlocksFolderEmpty() {
+    try {
+        const files = fs.readdirSync(peripheralsfolder);
+        return files.length === 0; // Returns true if the folder is empty
+    } catch (err) {
+        console.error('Error reading folder:', err);
+        return false; // Return false or handle error as needed
+    }
+}
+
+async function downloadBlocks() {
+    try {
+        progressBar.style.display = 'inline-block';
+        // Create the output directory if it doesn't exist
+        if (!fs.existsSync(peripheralsfolder)) {
+            fs.mkdirSync(peripheralsfolder, { recursive: true });
+        }
+
+        console.log('Downloading blocks...');
+
+        const zipFilePath = path.join(peripheralsfolder, 'blocks.zip');
+
+        // Download the file as a Promise
+        await new Promise((resolve, reject) => {
+            https.get(blocks_url, (response) => {
+                if (response.statusCode !== 200) {
+                    reject(new Error(`Download failed with status code ${response.statusCode}`));
+                    return;
+                }
+
+                const totalBytes = parseInt(response.headers['content-length'], 10);
+                let downloadedBytes = 0;
+
+                const file = fs.createWriteStream(zipFilePath);
+
+                response.on('data', (chunk) => {
+                    downloadedBytes += chunk.length;
+                    const percentCompleted = Math.round((downloadedBytes / totalBytes) * 100);
+                    progressBar.value = percentCompleted;
+                    progressBar.innerText = percentCompleted + '%'; // Fallback text
+                    process.stdout.write(`Download progress: ${percentCompleted}%\r`);
+                });
+
+                response.pipe(file);
+
+                file.on('finish', () => {
+                    file.close();
+                    console.log('\nFile downloaded successfully.');
+                    resolve();
+                });
+
+                file.on('error', (error) => {
+                    fs.unlinkSync(zipFilePath);
+                    reject(error);
+                });
+            }).on('error', (error) => {
+                reject(error);
+            });
+        });
+
+        console.log('Unzipping file...');
+        
+        // Unzip the file as a Promise
+        await new Promise((resolve, reject) => {
+            fs.createReadStream(zipFilePath)
+                .pipe(unzipper.Extract({ path: peripheralsfolder }))
+                .on('close', () => {
+                    console.log('File unzipped successfully.');
+                    fs.unlinkSync(zipFilePath); // Delete the zip file after extraction
+                    console.log('Zip file deleted.');
+
+                    console.log('Downloaded blocks');
+                    progressBar.style.display = 'none';
+                    resolve();
+                })
+                .on('error', (error) => {
+                    reject(error);
+                });
+        });
+
+
+
+    } catch (error) {
+        console.error('Error downloading or unzipping file:', error);
+    }
+}
+
 
 const defineicon = {
     computer: {
         basic: path.join(__dirname, '..', 'assets', 'basic_computer.png'),
         adv: path.join(__dirname, '..', 'assets', 'adv_computer.png'),
-        //command: path.join(__dirname, '..', 'assets', 'command_computer.png'), // new version not use it
+        command: path.join(__dirname, '..', 'assets', 'command_computer.png'),
         pocket: path.join(__dirname, '..', 'assets', 'pocket_computer.png'),
         advpocket: path.join(__dirname, '..', 'assets', 'adv_pocket_computer.png'),
         turtle: path.join(__dirname, '..', 'assets', 'turtle.png'),
@@ -41,21 +140,26 @@ function mergeXml(xml1, xml2) {
     return mergedXml;
 }
 
-function loadperipheral(workspace, currenttoolbar, peripherals) {
-    const filePath = path.join(peripheralsfolder, peripherals);
-    const jsonfilePath = path.join(filePath, "block_design.json");
-    const xmlfilePath = path.join(filePath, "toolbox.xml");
-    const generatorfilePath = path.join(filePath, "generator.js"); // Path to generator.js
-
-    // Load generator.js
-    // Load blocks from block_design.json
-    fs.readFile(jsonfilePath, 'utf-8', (err, data) => {
-        if (err) {
-            console.error('Error loading JSON file:', err);
-            return;
-        }
+function loadperipheral(workspace, currenttoolbar, peripherals, usedlibinproject) {
+    if (!usedlibinproject.includes(peripherals)) {
         try {
-            const blocksJson = JSON.parse(data);
+            console.log(`Importing ${peripherals} blocks`);
+
+            const filePath = path.join(peripheralsfolder, peripherals);
+            const jsonfilePath = path.join(filePath, "block_design.json");
+            const xmlfilePath = path.join(filePath, "toolbox.xml");
+            const generatorfilePath = path.join(filePath, "generator.js");
+            const indexfilePath = path.join(filePath, "index.json");
+
+            // Synchronously read and parse the index.json file
+            const indexcontent = JSON.parse(fs.readFileSync(indexfilePath, 'utf8'));
+            const dependencies = indexcontent.dependencies;
+            dependencies.forEach((dependency) => {
+                currenttoolbar = loadperipheral(workspace, currenttoolbar, dependency, usedlibinproject);
+            });
+
+            // Synchronously load and parse block_design.json
+            const blocksJson = JSON.parse(fs.readFileSync(jsonfilePath, 'utf8'));
             for (const blockId in blocksJson) {
                 if (blocksJson.hasOwnProperty(blockId)) {
                     Blockly.Blocks[blockId] = {
@@ -65,27 +169,28 @@ function loadperipheral(workspace, currenttoolbar, peripherals) {
                     };
                 }
             }
+
+            // Synchronously load and merge new toolbox XML
+            const toolbar = fs.readFileSync(xmlfilePath, 'utf8');
+            const newxml = mergeXml(currenttoolbar, toolbar);
+            workspace.updateToolbox(newxml);
+
+            fireNotify(`Loaded ${peripherals}`, "success")
+
+            // Synchronously require generator.js
+            require(generatorfilePath); // This will execute generator.js if it's a Node.js module
+
+            console.log(`Loaded ${peripherals} blocks`);
+            usedlibinproject.push(peripherals);
+
+            return newxml;
         } catch (e) {
-            document.getElementById('statusMessage').textContent = 'Error parsing JSON file: ' + e;
-            return;
+            fireNotify(`Can't Import ${peripherals}: ${e}`, "error")
+            ipc.send("error", `Can't Import ${peripherals}: ${e}`);
         }
-    });
-
-    // Load and merge new toolbox XML
-    const toolbar = fs.readFileSync(xmlfilePath, 'utf8');
-    const newxml = mergeXml(currenttoolbar, toolbar);
-    
-    workspace.updateToolbox(newxml);
-
-    document.getElementById('statusMessage').textContent = `Loaded ${peripherals}`;
-
-    try {
-        require(generatorfilePath); // This will execute generator.js if it's a Node.js module
-    } catch (error) {
-        console.error('Error loading generator.js:', error);
+    } else {
+        return currenttoolbar;
     }
-
-    return newxml;
 }
 
 function extractFolderName(path) {
@@ -114,12 +219,11 @@ function addimageiconinfo(div, src, tiptool) {
     img.setAttribute('data-bs-placement', "bottom");
     img.setAttribute('data-bs-title', tiptool);
     div.appendChild(img);
-    console.log(`added image ${img}`);
+    console.log(`added image ${src}`);
 }
 
 function scanindex() {
     let foundedpackages = 0;
-    document.getElementById('statusMessage').textContent = "Scanning Packages...";
     // clear all item in libcontainer
     document.getElementById('libcontainer').innerHTML = "";
 
@@ -167,24 +271,29 @@ function scanindex() {
                         
                         // Create the title element
                         const title = document.createElement('h3');
-                        title.textContent = jsonData.name + ` [v${jsonData.version} by ${jsonData.author}]`;
+                        title.textContent = jsonData.name;
                         libraryDetails.appendChild(title);
 
+                        // Create the credit and version element
+                        const cv = document.createElement('p');
+                        cv.classList.add('library-details-cv');
+                        cv.textContent = `v${jsonData.version} by ${jsonData.author}`;
+                        libraryDetails.appendChild(cv);
+
                         // Create the description element
                         const description = document.createElement('p');
                         description.innerHTML = jsonData.description;
                         libraryDetails.appendChild(description);
 
-                        console.log(jsonData)
                         if (jsonData.design_for_computer.basic) {
                             addimageiconinfo(libraryDetails, defineicon.computer.basic, "Basic Computer Supported");
                         }
                         if (jsonData.design_for_computer.adv) {
                             addimageiconinfo(libraryDetails, defineicon.computer.adv, "Advanced Computer Supported");
                         }
-                        //if (jsonData.design_for_computer.command) {
-                        //    addimageiconinfo(libraryDetails, defineicon.computer.command, "Command Computer Supported");
-                        //}
+                        if (jsonData.design_for_computer.command) {
+                            addimageiconinfo(libraryDetails, defineicon.computer.command, "Command Computer Supported");
+                        }
                         if (jsonData.design_for_computer.pocket) {
                             addimageiconinfo(libraryDetails, defineicon.computer.pocket, "Pocket Computer Supported");
                         }
@@ -211,7 +320,7 @@ function scanindex() {
 
                         libraryItem.appendChild(libraryDetails);
                         document.getElementById('libcontainer').appendChild(libraryItem);
-                        console.log(`registered ${blockfoldername} blocks and added to packages managers`)
+                        console.log(`Registered ${blockfoldername} blocks and added to packages managers`)
                     }
                 }
 
@@ -225,14 +334,12 @@ function scanindex() {
         });
     });
 
-    document.getElementById('statusMessage').textContent = `Founded ${foundedpackages} Packages`;
-    setTimeout(() => {
-        document.getElementById('statusMessage').textContent = `Ready`;
-    }, 1000);
+    fireNotify(`Founded ${foundedpackages} Packages`, "success")
 }
 
-
 module.exports = {
     loadperipheral,
-    scanindex
+    scanindex,
+    isBlocksFolderEmpty,
+    downloadBlocks
 }

src/ccRemote.js

@@ -7,109 +7,258 @@ class CCRemote {
             host: ip
         });
 
-        console.log("Server is started");
+        this.clients = new Map(); // Map to track client data (numeric IDs)
+        this.clientIdCounter = 0; // Counter for numeric client IDs
+
+        console.log("Remote server is started");
+        fireNotify(
+            "Remote server started, waiting for clients to connect...",
+            "info"
+        );
 
         this.socket.on('connection', (ws) => {
-            document.getElementById("navbar-button-computer-disconnect").disabled = false;
-            document.getElementById("navbar-button-computer-run").disabled = false;
+            const clientId = this.clientIdCounter++;
+            this.clients.set(clientId, { ws, isAlive: true, name: `Client-${clientId}`, clientInfo: null });
 
-            document.getElementById('statusMessage').textContent = "Computer connected";
-            setTimeout(() => {
-                document.getElementById('statusMessage').textContent = `Ready`;
-            }, 1000);
+            if (this.clients.size >= 0) {
+                document.getElementById("navbar-button-computer-disconnect").disabled = false;
+                document.getElementById("navbar-button-computer-run").disabled = false;
+            }
 
-            console.log('WebSocket connection established.');
+            console.log(`Client ${clientId} connected.`);
+            fireNotify(`Client ${clientId} connected`, "success");
+
+            // Send "info" command to the client immediately upon connection
+            this.sendCommandToClient(clientId, 'info', true);
 
-            // Set up heartbeat
-            ws.isAlive = true;
             ws.on('pong', () => {
-                ws.isAlive = true;
+                this.clients.get(clientId).isAlive = true;
             });
 
             ws.on('message', (message) => {
-                console.log(`Received message => ${message}`);
+                console.log(`Message from Client ${clientId}: ${message}`);
+                // Handle info response
+                try {
+                    const data = JSON.parse(message);
+
+                    if (data.OSVersion && typeof data.OSVersion === 'string' &&
+                        data.Name && typeof data.Name === 'string' &&
+                        typeof data.ID === 'number' &&
+                        typeof data.uptime === 'number' &&
+                        typeof data.Type === 'number') {
+                        
+                        // Update clientInfo with the received data
+                        this.clients.get(clientId).clientInfo = data;
+                        console.log(`Client ${clientId} info updated:`, data);
+                    } else {
+                        console.log(`Invalid data format from Client ${clientId}:`, data);
+                    }
+                } catch (error) {
+                    console.error(`Error parsing message from Client ${clientId}:`, error);
+                }
             });
 
             ws.on('close', () => {
-                document.getElementById("navbar-button-computer-disconnect").disabled = true;
-                document.getElementById("navbar-button-computer-run").disabled = true;
+                console.log(`Client ${clientId} disconnected.`);
+                this.clients.delete(clientId);
+                fireNotify(`Client ${clientId} disconnected`, "warning");
 
-                document.getElementById('statusMessage').textContent = "Computer disconnected";
-                setTimeout(() => {
-                    document.getElementById('statusMessage').textContent = `Ready`;
-                }, 1000);
+                if (this.clients.size === 0) {
+                    document.getElementById("navbar-button-computer-disconnect").disabled = true;
+                    document.getElementById("navbar-button-computer-run").disabled = true;
+                }
             });
 
             ws.on('error', (error) => {
-                console.error('Client error:', error);
+                console.error(`Client ${clientId} error:`, error);
+                fireNotify(`Error with Client ${clientId}: ${error.message}`, "error");
             });
         });
 
         // Ping clients every 30 seconds to check if they are alive
         const interval = setInterval(() => {
-            this.socket.clients.forEach((ws) => {
-                if (ws.isAlive === false) {
-                    console.log('Client did not respond to ping, terminating connection.');
-                    return ws.terminate();
+            for (const [clientId, clientData] of this.clients.entries()) {
+                if (clientData.isAlive === false) {
+                    console.log(`Client ${clientId} did not respond to ping, terminating connection.`);
+                    fireNotify(`Client ${clientId} did not respond to ping, disconnected`, "warning");
+                    clientData.ws.terminate();
+                    this.clients.delete(clientId);
+                    continue;
                 }
 
-                ws.isAlive = false;
-                ws.ping();
-            });
-        }, 1000);
+                clientData.isAlive = false;
+                clientData.ws.ping();
+            }
+        }, 30000);
 
         this.socket.on('close', () => {
             clearInterval(interval);
             console.log('WebSocket server closed.');
+            fireNotify("WebSocket server closed.", "info");
         });
 
         this.socket.on('error', (error) => {
             console.error('WebSocket server error:', error);
+            fireNotify(`WebSocket server error: ${error.message}`, "error");
         });
     }
 
-    isClientConnect() {
-        for (const client of this.socket.clients) {
-            if (client.readyState === WebSocket.OPEN) {
-                return true;
+    // List all connected clients with their IDs, names, and clientInfo
+    // List all connected clients with their IDs, names, and clientInfo
+    async listClients() {
+        const clientList = [];
+        
+        // Create an array of promises for fetching client info
+        const infoPromises = [];
+        
+        // Loop over each client and trigger 'info' command to get the latest information
+        for (const [clientId, clientData] of this.clients.entries()) {
+            if (clientData.ws.readyState === WebSocket.OPEN) {
+                const infoPromise = new Promise((resolve) => {
+                    // Set a timeout to handle cases where no response is received
+                    const timeout = setTimeout(() => {
+                        resolve({ id: clientId, name: clientData.name, info: null });
+                    }, 5000); // Wait 5 seconds for a response
+
+                    // Listen for the response from the client
+                    const messageHandler = (message) => {
+                        try {
+                            const data = JSON.parse(message);
+                            if (data.OSVersion && typeof data.OSVersion === 'string' &&
+                                data.Name && typeof data.Name === 'string' &&
+                                typeof data.ID === 'number' &&
+                                typeof data.uptime === 'number' &&
+                                typeof data.Type === 'number') {
+                                
+                                // Resolve with the valid data
+                                resolve({ id: clientId, name: clientData.name, info: data });
+                            } else {
+                                resolve({ id: clientId, name: clientData.name, info: null });
+                            }
+                        } catch (error) {
+                            resolve({ id: clientId, name: clientData.name, info: null });
+                        }
+                    };
+
+                    // Send the "info" command to the client
+                    this.sendCommandToClient(clientId, 'info', true);
+                    
+                    // Attach the handler for this specific client
+                    clientData.ws.on('message', messageHandler);
+                });
+
+                // Add the promise to the array
+                infoPromises.push(infoPromise);
             }
         }
-        return false;
+
+        // Wait for all promises to resolve (all client info to be updated)
+        const resolvedClientInfo = await Promise.all(infoPromises);
+
+        // Construct the final list of clients with updated information
+        for (const clientInfo of resolvedClientInfo) {
+            clientList.push(clientInfo);
+        }
+
+        return clientList;
     }
 
-    sendCommand(command) {
-        this.socket.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send(command);
-            }
-        });
+    // Check if any client is connected
+    isClientConnect() {
+        return this.clients.size > 0;
     }
 
-    sendCode(Code) {
-        this.socket.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send("sendcode");
+    // Send code to all clients
+    sendCode(code) {
+        this.clients.forEach((clientData, clientId) => {
+            if (clientData.ws.readyState === WebSocket.OPEN) {
+                clientData.ws.send("sendcode");
                 setTimeout(() => {
-                    client.send(Code);
+                    clientData.ws.send(code);
                 }, 500);
             }
         });
     }
 
+    // Send code to a specific client
+    sendCodeToClient(clientId, code) {
+        const client = this.clients.get(clientId);
+        if (!client || client.ws.readyState !== WebSocket.OPEN) {
+            console.error(`Client ${clientId} is not available or not connected.`);
+            fireNotify(`Client ${clientId} is not connected.`, "error");
+            return;
+        }
+
+        client.ws.send("sendcode");
+        setTimeout(() => {
+            client.ws.send(code);
+        }, 500);
+    }
+
+    // Run code on all clients
     runCode() {
-        this.socket.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.send("runcode");
+        this.clients.forEach((clientData, clientId) => {
+            if (clientData.ws.readyState === WebSocket.OPEN) {
+                clientData.ws.send("runcode");
             }
         });
     }
 
+    // Run code on a specific client
+    runCodeOnClient(clientId) {
+        const client = this.clients.get(clientId);
+        if (!client || client.ws.readyState !== WebSocket.OPEN) {
+            console.error(`Client ${clientId} is not available or not connected.`);
+            fireNotify(`Client ${clientId} is not connected.`, "error");
+            return;
+        }
+
+        client.ws.send("runcode");
+    }
+
+    // Disconnect all clients
     disconnectAllClients() {
-        this.socket.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                client.close();
+        this.clients.forEach((clientData, clientId) => {
+            if (clientData.ws.readyState === WebSocket.OPEN) {
+                clientData.ws.send("exit");
+                clientData.ws.close();
+                fireNotify(`Client ${clientId} disconnected`, "warning");
             }
         });
+        this.clients.clear();
+    }
+
+    // Send a command to a specific client
+    sendCommandToClient(clientId, command, expectResponse = false) {
+        const client = this.clients.get(clientId);
+        if (!client || client.ws.readyState !== WebSocket.OPEN) {
+            console.error(`Client ${clientId} is not available or not connected.`);
+            fireNotify(`Client ${clientId} is not connected.`, "error");
+            return;
+        }
+
+        client.ws.send(command);
+
+        if (expectResponse) {
+            client.ws.on('message', (response) => {
+                console.log(`Response from Client ${clientId}: ${response}`);
+            });
+        }
+    }
+
+    // Send a command to all clients
+    sendCommandToAll(command, expectResponse = false) {
+        for (const [clientId, clientData] of this.clients.entries()) {
+            if (clientData.ws.readyState === WebSocket.OPEN) {
+                clientData.ws.send(command);
+
+                if (expectResponse) {
+                    clientData.ws.on('message', (response) => {
+                        console.log(`Response from Client ${clientId}: ${response}`);
+                    });
+                }
+            }
+        }
     }
 }
 

src/codegen.js

@@ -1,10 +1,7 @@
-function delay(time) {
-    return new Promise(resolve => setTimeout(resolve, time));
-}
-
 const { luaGenerator } = require('blockly/lua');  // Use require syntax for Blockly module
 const { CCRemote } = require("./ccRemote")
 
+console.log("Starting remote server...")
 const ccInstance = new CCRemote('127.0.0.1', 5133);
 
 const progress = document.getElementById("progress");
@@ -12,6 +9,16 @@ const circles = document.querySelectorAll(".circle");
 let upcurrentActive = 1;
 let uploadError = false; // Flag to track if there's an error
 
+const defineicon = {
+    5: path.join(__dirname, '..', 'assets', 'basic_computer.png'),
+    6: path.join(__dirname, '..', 'assets', 'adv_computer.png'),
+    7: path.join(__dirname, '..', 'assets', 'command_computer.png'),
+    2: path.join(__dirname, '..', 'assets', 'pocket_computer.png'),
+    4: path.join(__dirname, '..', 'assets', 'adv_pocket_computer.png'),
+    1: path.join(__dirname, '..', 'assets', 'turtle.png'),
+    3: path.join(__dirname, '..', 'assets', 'adv_turtle.png')
+}
+
 const uploadUpdateProgress = () => {
     circles.forEach((circle, index) => {
         if (index < upcurrentActive) {
@@ -37,7 +44,6 @@ const uploadUpdateProgress = () => {
 };
 
 function clientexit() {
-    ccInstance.sendCommand("exit")
     ccInstance.disconnectAllClients();
 }
 
@@ -45,51 +51,129 @@ function gencodeonly() {
     return luaGenerator.workspaceToCode(workspace);
 }
 
+let selectedClientId = null;
+
 async function gencode() {
+    console.log("Starting generate code")
     document.getElementById('upload-popup').style.display = 'block';
     upcurrentActive = 1;
     uploadError = false;
     uploadUpdateProgress();
-    // compile/convert code
-
+    
+    // Compile/convert code
+    console.log("Generating code...");
     upcurrentActive++;
     uploadUpdateProgress();
     document.getElementById('upload-status').textContent = "Generating code";
     let code = null;
     try {
         code = luaGenerator.workspaceToCode(workspace);
-        console.log(code);
     } catch (e) {
         uploadError = true;
         uploadUpdateProgress();
         document.getElementById('upload-status').textContent = e;
-        return
+        return;
     }
 
     upcurrentActive++;
     uploadUpdateProgress();
+    
     if (ccInstance.isClientConnect()) {
-        // upload to computercraft with remote
-        document.getElementById('upload-status').textContent = "Uploading code to machine";
-        ccInstance.sendCode(code);
-        await delay(500)
+        const clients = await ccInstance.listClients();
+        document.getElementById('upload-status').innerHTML = "";
 
-        // execute with remote
-        document.getElementById('upload-status').textContent = "Executing code";
-        upcurrentActive++;
-        uploadUpdateProgress();
-        ccInstance.runCode();
+        const ClientLists = document.createElement('div');
+        ClientLists.classList.add("library-content");
+
+        clients.forEach(client => {
+            console.log(`Info:`, client.info);
+            
+            const ClientItem = document.createElement('div');
+            ClientItem.classList.add('library-item', 'overflow-auto', 'library-container');
+            ClientItem.setAttribute('data-clientid', client.id);
+        
+            const img = document.createElement('img');
+            img.classList.add('libimage');
+            img.src = defineicon[client.info.Type];
+            ClientItem.appendChild(img);
+        
+            const ClientDetails = document.createElement('div');
+            ClientDetails.classList.add('library-details');
+        
+            const title = document.createElement('h3');
+            title.textContent = client.info.Name;
+            ClientDetails.appendChild(title);
+        
+            const description = document.createElement('p');
+            description.innerHTML = `OS: ${client.info.OSVersion} | ID: ${client.info.ID} | Uptime: ${client.info.uptime}s`;
+            ClientDetails.appendChild(description);
+        
+            ClientItem.appendChild(ClientDetails);
+        
+            // Add event listener for user selection
+            ClientItem.addEventListener('click', () => {
+                selectedClientId = client.id; // Correctly store the client ID
+                ClientItem.classList.add('selected'); // Optional: Style selected item
+            });
+        
+            ClientLists.appendChild(ClientItem);
+        });
+        
+        const title = document.createElement("h3");
+        title.textContent = "Upload to machine";
+        document.getElementById('upload-status').appendChild(title);
+
+        document.getElementById('upload-status').appendChild(ClientLists);
+
+        // Wait for user selection
+        const waitForSelection = () => new Promise((resolve, reject) => {
+            const checkSelection = setInterval(() => {
+                if (selectedClientId !== null) {
+                    clearInterval(checkSelection);
+                    resolve(selectedClientId);
+                }
+            }, 100); // Check every 100ms if a client is selected
+        });
+
+        // Wait until the user selects a client
+        try {
+            const selectedClientId = await waitForSelection();
+            console.log(`Selected client: ${selectedClientId}`);
+            
+            document.getElementById('upload-status').innerHTML = "";
+
+            // Now proceed with uploading code to the selected client
+            console.log("Uploading code to machine...");
+            document.getElementById('upload-status').textContent = "Uploading code to machine";
+            ccInstance.sendCodeToClient(selectedClientId, code);
+            await delay(500);
+
+            // Execute with remote
+            console.log("Executing code in machine...");
+            document.getElementById('upload-status').textContent = "Executing code";
+            upcurrentActive++;
+            uploadUpdateProgress();
+            ccInstance.runCodeOnClient(selectedClientId);
+        } catch (error) {
+            console.error("Error waiting for selection:", error);
+            uploadError = true;
+            uploadUpdateProgress();
+            document.getElementById('upload-status').innerHTML = `Error selecting client.`;
+        }
     } else {
+        console.log("Machine is not connected");
         uploadError = true;
         uploadUpdateProgress();
-        document.getElementById('upload-status').innerHTML = `Please Connect Computer to IDE.\nInstruction: <a href="https://github.com/DPSoftware-Foundation/ccIDE#install-remote-code-into-computercraft">Install Remote code into computercraft</a> in github. (Please press SHIFT or CTRL and click)`;
-        return
+        document.getElementById('upload-status').innerHTML = `Please Connect Computer to IDE.\nInstruction: <a href="https://github.com/DPSoftware-Foundation/ccIDE#install-remote-code-into-computercraft">Install Remote code into computercraft</a> in github.`;
+        return;
     }
 
-    // done!
+    // Done!
+    console.log("Run code done!");
     document.getElementById('upload-status').textContent = "Done!";
-    await delay(1000)
+    await delay(1000);
     document.getElementById('upload-popup').style.animation = 'fadeOut 0.3s ease'; // Apply fade-out animation
+    selectedClientId = null;
     setTimeout(function() {
         document.getElementById('upload-popup').style.display = 'none'; // Hide popup after animation completes
         document.getElementById('upload-popup').style.animation = ''; // Reset animation property

src/index.html

@@ -3,136 +3,152 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>ccIDE</title>
-    <link href="https://fonts.googleapis.com/css2?family=Noto+Sans:wght@400;700&display=swap" rel="stylesheet">
-    <script>
-        const bootstrap = require('bootstrap')
-        const {shell} = require('electron');
-    </script>
-    <link rel="stylesheet" href="../node_modules/bootstrap/dist/css/bootstrap.min.css">
-    <link rel="stylesheet" type="text/css" href="styles.css" />
-</head>
-<body>
-    <!-- Navigation bar -->
-    <nav id="navbar">
-        <button class="navbar-button" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Computer Types" style="background-color: #0087bd;">
-            <svg viewBox="0 0 24 24"><path d="M6 4h12v1h3v2h-3v2h3v2h-3v2h3v2h-3v2h3v2h-3v1H6v-1H3v-2h3v-2H3v-2h3v-2H3V9h3V7H3V5h3V4m5 11v3h1v-3h-1m2 0v3h1v-3h-1m2 0v3h1v-3h-1z" /></svg>
-        </button>
-        <button class="navbar-button" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Packages Managers" style="background-color: #0087bd;" onclick="openlibraryselect()">
-            <svg viewBox="0 0 24 24"><path d="M21 16.5c0 .38-.21.71-.53.88l-7.9 4.44c-.16.12-.36.18-.57.18-.21 0-.41-.06-.57-.18l-7.9-4.44A.991.991 0 0 1 3 16.5v-9c0-.38.21-.71.53-.88l7.9-4.44c.16-.12.36-.18.57-.18.21 0 .41.06.57.18l7.9 4.44c.32.17.53.5.53.88v9M12 4.15l-1.89 1.07L16 8.61l1.96-1.11L12 4.15M6.04 7.5 12 10.85l1.96-1.1-5.88-3.4L6.04 7.5M5 15.91l6 3.38v-6.71L5 9.21v6.7m14 0v-6.7l-6 3.37v6.71l6-3.38z" /></svg>
-        </button>
-        <!-- 
-        <button class="navbar-button" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Preview code" style="background-color: #0087bd; margin-left: auto; position: absolute; right: 115px;">
-            <svg viewBox="0 0 24 24"><path d="M12 9a3 3 0 0 0-3 3 3 3 0 0 0 3 3 3 3 0 0 0 3-3 3 3 0 0 0-3-3m0 8a5 5 0 0 1-5-5 5 5 0 0 1 5-5 5 5 0 0 1 5 5 5 5 0 0 1-5 5m0-12.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5z" /></svg>
-        </button>
-        -->
-        <button class="navbar-button" id="navbar-button-computer-disconnect" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Disconnect Client" style="background-color: #bd0000; margin-left: auto; position: absolute; right: 65px;" onclick="clientexit()" disabled>
-            <svg viewBox="0 0 24 24"><path d="M19 3H5c-1.11 0-2 .89-2 2v4h2V5h14v14H5v-4H3v4a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2m-8.92 12.58L11.5 17l5-5-5-5-1.42 1.41L12.67 11H3v2h9.67l-2.59 2.58z" /></svg>
-        </button>
-        <button class="navbar-button" id="navbar-button-computer-run" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Run" style="background-color: #10bd00; margin-left: auto;" onclick="gencode()" disabled>
-            <svg viewBox="0 0 24 24"><path d="M8 5.14v14l11-7-11-7z" /></svg>
-        </button>
-    </nav>
+    <!-- <meta charset="utf-8" http-equiv="Content-Security-Policy" content="script-src 'self' 'sha256-m0mwdxEgv9nMDDw3gHrhX/xCs/OAiZg5/bQ/6X5SIcA='"/> -->
+    <div class="loading-area">
+        <div id="loadingContent">
+            <div class="loader"></div>
+            <br>
+            <h3>Please wait...</h3>
+            <h5 id="loadingstatus"></h5>
+            <progress id="progressBarloading" value="0" max="100"></progress>
 
-    <!-- Blockly workspace container -->
-    <section id="blocklyContainer">
-        <div id="blocklyDiv"></div>
-    </section>
 
-    <!-- Status bar -->
-    <div id="statusBar">
-        <p id="statusMessage">Initializing...</p>
-    </div>
-
-    <div class="popup" id="upload-popup">
-        <div class="popup-content">
-            <button type="button" class="btn-close float-end" aria-label="Close" id="uploadCloseBtn"></button>
-            <div class="upload-progress-container" style="text-align: center;">
-                <div class="progress-container">
-                    <div class="progress" id="progress"></div>
-                    <div class="circle active">
-                        <svg viewBox="0 0 24 24"><path d="M8 3a2 2 0 0 0-2 2v4a2 2 0 0 1-2 2H3v2h1a2 2 0 0 1 2 2v4a2 2 0 0 0 2 2h2v-2H8v-5a2 2 0 0 0-2-2 2 2 0 0 0 2-2V5h2V3m6 0a2 2 0 0 1 2 2v4a2 2 0 0 0 2 2h1v2h-1a2 2 0 0 0-2 2v4a2 2 0 0 1-2 2h-2v-2h2v-5a2 2 0 0 1 2-2 2 2 0 0 1-2-2V5h-2V3h2z" /></svg>
-                    </div>
-                    <div class="circle">
-                        <svg viewBox="0 0 24 24"><path d="m5.5 4.14-1 1.72L15 12 4.5 18.14l1 1.72L19 12 5.5 4.14z" /></svg>
-                    </div>
-                    <div class="circle">
-                        <svg viewBox="0 0 24 24"><path d="M9 16v-6H5l7-7 7 7h-4v6H9m-4 4v-2h14v2H5z" /></svg>
-                    </div>
-                    <div class="circle">
-                        <svg viewBox="0 0 24 24"><path d="m20 22-3.86-1.55c.7-1.53 1.2-3.11 1.51-4.72L20 22M7.86 20.45 4 22l2.35-6.27c.31 1.61.81 3.19 1.51 4.72M12 2s5 2 5 10c0 3.1-.75 5.75-1.67 7.83A2 2 0 0 1 13.5 21h-3a2 2 0 0 1-1.83-1.17C7.76 17.75 7 15.1 7 12c0-8 5-10 5-10m0 10c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2z" /></svg>
-                    </div>
-                </div>
-                <p id="upload-status"></p>
-            </div>
-        </div>
-    </div>
-
-    <div class="popup" id="about-popup">
-        <div class="popup-content">
-            <button type="button" class="btn-close float-end" aria-label="Close" id="aboutCloseBtn"></button>
-            <h2>ccIDE</h2>
-            <p>
-                ccIDE is an integrated development environment designed for coding Lua scripts
-                for ComputerCraft. It provides a user-friendly interface for creating and managing
-                projects, designing custom blocks, and debugging scripts efficiently.
-            </p>
-            <p>
-                Developed by DPSoftware Foundation, ccIDE aims to streamline the development
-                process for ComputerCraft programmers, offering features like block-based coding,
-                real-time collaboration, and seamless integration with ComputerCraft environments.
-            </p>
-            <p>
-                Visit <a href="https://damp11113.xyz/dpsoftware/ccide">ccIDE Website</a> for more information and updates.
-            </p>
-            <div class="license">
-                &copy; 2024 DPSoftware Foundation. Licensed under GPL v3.
-            </div>
-            <style>
-                .license {
-                    font-size: 14px;
-                    color: #888;
-                    text-align: center;
-                    margin-top: 20px;
-                }
-            </style>
-        </div>
-    </div>
-
-    <div class="popup" id="library-popup" style="overflow-y:hidden;">
-        <div class="popup-content p-3" style="max-width: 1280px; position: relative; margin-top: 100px;">
-            <button type="button" class="btn-close" aria-label="Close" id="libraryCloseBtn" style="position: absolute; top: 10px; right: 10px;"></button>
-            <h3>Packages Managers</h3>
-            <div class="library-content">
-                <div id="libcontainer">
-                    <div class="library-item overflow-auto library-container" data-libraryfolder="name">
-                        <img src="image.jpg" class="libimage" onerror="this.onerror=null;this.src='../assets/noimagefallback.png'; this.alt='No Image Available';">
-                        <div class="library-details">
-                            <h3>Title [v1.0 by Author]</h3>
-                            <p>Library description goes here.</p>
-                            <img src="../assets/basic_computer.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Basic Computer">
-                            <img src="../assets/adv_computer.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Advanced Computer">
-                            <img src="../assets/command_computer.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Command Computer">
-                            <img src="../assets/pocket_computer.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Pocket Computer">
-                            <img src="../assets/adv_pocket_computer.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Advanced Pocket Computer">
-                            <img src="../assets/turtle.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Basic Turtle">
-                            <img src="../assets/adv_turtle.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Advanced Turtle">
-                            <img src="../assets/peripheral.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Peripheral">
-                            <img src="../assets/library.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Library">
-                            <img src="../assets/network-require.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Network Require">
-                        </div>
-                    </div>
-                    
-                </div>
-            </div>
-            <div class="button-container">
-                <button type="button" class="btn btn-success btn-sm" id="packageman-import-btn">Import Packages</button>
-                <button type="button" class="btn btn-warning btn-sm" onclick='scanindex()'>Refetch Packages</button>
-                <button type="button" class="btn btn-primary btn-sm" onclick='shell.openExternal("https://damp11113.xyz/dpsoftware/ccide/library")'>Download Packages</button>
+            <div class="dpclogoload">
+                <img src="../assets/DPSoftware2.png" style="width: 25%;"/>
             </div>
         </div>
     </div>
     
+    <link rel="stylesheet" href="../node_modules/bootstrap/dist/css/bootstrap.min.css">
+    <link rel="stylesheet" href="../node_modules/toastify-js/src/toastify.css">
+    <link rel="stylesheet" type="text/css" href="styles.css" />
+</head>
+<body>
+    
+    <div class="content-area">
+        <!-- Navigation bar -->
+        <nav id="navbar">
+            <!--
+            <button class="navbar-button" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Computer Types" style="background-color: #0087bd;">
+                <svg viewBox="0 0 24 24"><path d="M6 4h12v1h3v2h-3v2h3v2h-3v2h3v2h-3v2h3v2h-3v1H6v-1H3v-2h3v-2H3v-2h3v-2H3V9h3V7H3V5h3V4m5 11v3h1v-3h-1m2 0v3h1v-3h-1m2 0v3h1v-3h-1z" /></svg>
+            </button>
+            -->
+            <button class="navbar-button" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Packages Managers" style="background-color: #0087bd;" onclick="openlibraryselect()">
+                <svg viewBox="0 0 24 24"><path d="M21 16.5c0 .38-.21.71-.53.88l-7.9 4.44c-.16.12-.36.18-.57.18-.21 0-.41-.06-.57-.18l-7.9-4.44A.991.991 0 0 1 3 16.5v-9c0-.38.21-.71.53-.88l7.9-4.44c.16-.12.36-.18.57-.18.21 0 .41.06.57.18l7.9 4.44c.32.17.53.5.53.88v9M12 4.15l-1.89 1.07L16 8.61l1.96-1.11L12 4.15M6.04 7.5 12 10.85l1.96-1.1-5.88-3.4L6.04 7.5M5 15.91l6 3.38v-6.71L5 9.21v6.7m14 0v-6.7l-6 3.37v6.71l6-3.38z" /></svg>
+            </button>
+            <!-- 
+            <button class="navbar-button" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Preview code" style="background-color: #0087bd; margin-left: auto; position: absolute; right: 115px;">
+                <svg viewBox="0 0 24 24"><path d="M12 9a3 3 0 0 0-3 3 3 3 0 0 0 3 3 3 3 0 0 0 3-3 3 3 0 0 0-3-3m0 8a5 5 0 0 1-5-5 5 5 0 0 1 5-5 5 5 0 0 1 5 5 5 5 0 0 1-5 5m0-12.5C7 4.5 2.73 7.61 1 12c1.73 4.39 6 7.5 11 7.5s9.27-3.11 11-7.5c-1.73-4.39-6-7.5-11-7.5z" /></svg>
+            </button>
+            -->
+            <button class="navbar-button" id="navbar-button-computer-disconnect" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Disconnect Client" style="background-color: #bd0000; margin-left: auto; position: absolute; right: 65px;" onclick="clientexit()" disabled>
+                <svg viewBox="0 0 24 24"><path d="M19 3H5c-1.11 0-2 .89-2 2v4h2V5h14v14H5v-4H3v4a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2m-8.92 12.58L11.5 17l5-5-5-5-1.42 1.41L12.67 11H3v2h9.67l-2.59 2.58z" /></svg>
+            </button>
+            <button class="navbar-button" id="navbar-button-computer-run" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Run" style="background-color: #10bd00; margin-left: auto;" onclick="gencode()" disabled>
+                <svg viewBox="0 0 24 24"><path d="M8 5.14v14l11-7-11-7z" /></svg>
+            </button>
+        </nav>
+
+        <!-- Blockly workspace container -->
+        <section id="blocklyContainer">
+            <div id="blocklyDiv"></div>
+        </section>
+
+        <div class="popup" id="upload-popup" style="overflow-y:hidden;">
+            <div class="popup-content p-3" style="max-width: 720px; position: relative; margin-top: 100px;">
+                <button type="button" class="btn-close float-end" aria-label="Close" id="uploadCloseBtn"></button>
+                <div class="upload-progress-container" style="text-align: center;">
+                    <div class="progress-container">
+                        <div class="progress" id="progress"></div>
+                        <div class="circle active">
+                            <svg viewBox="0 0 24 24"><path d="M8 3a2 2 0 0 0-2 2v4a2 2 0 0 1-2 2H3v2h1a2 2 0 0 1 2 2v4a2 2 0 0 0 2 2h2v-2H8v-5a2 2 0 0 0-2-2 2 2 0 0 0 2-2V5h2V3m6 0a2 2 0 0 1 2 2v4a2 2 0 0 0 2 2h1v2h-1a2 2 0 0 0-2 2v4a2 2 0 0 1-2 2h-2v-2h2v-5a2 2 0 0 1 2-2 2 2 0 0 1-2-2V5h-2V3h2z" /></svg>
+                        </div>
+                        <div class="circle">
+                            <svg viewBox="0 0 24 24"><path d="m5.5 4.14-1 1.72L15 12 4.5 18.14l1 1.72L19 12 5.5 4.14z" /></svg>
+                        </div>
+                        <div class="circle">
+                            <svg viewBox="0 0 24 24"><path d="M9 16v-6H5l7-7 7 7h-4v6H9m-4 4v-2h14v2H5z" /></svg>
+                        </div>
+                        <div class="circle">
+                            <svg viewBox="0 0 24 24"><path d="m20 22-3.86-1.55c.7-1.53 1.2-3.11 1.51-4.72L20 22M7.86 20.45 4 22l2.35-6.27c.31 1.61.81 3.19 1.51 4.72M12 2s5 2 5 10c0 3.1-.75 5.75-1.67 7.83A2 2 0 0 1 13.5 21h-3a2 2 0 0 1-1.83-1.17C7.76 17.75 7 15.1 7 12c0-8 5-10 5-10m0 10c1.1 0 2-.9 2-2s-.9-2-2-2-2 .9-2 2 .9 2 2 2z" /></svg>
+                        </div>
+                    </div>
+                    <div id="upload-status"></div>
+                </div>
+            </div>
+        </div>
+
+        <div class="popup" id="about-popup">
+            <div class="popup-content">
+                <button type="button" class="btn-close float-end" aria-label="Close" id="aboutCloseBtn"></button>
+                <h2>ccIDE</h2>
+                <p>
+                    ccIDE is an integrated development environment designed for coding Lua scripts
+                    for ComputerCraft. It provides a user-friendly interface for creating and managing
+                    projects, designing custom blocks, and debugging scripts efficiently.
+                </p>
+                <p>
+                    Developed by DPSoftware Foundation, ccIDE aims to streamline the development
+                    process for ComputerCraft programmers, offering features like block-based coding,
+                    real-time collaboration, and seamless integration with ComputerCraft environments.
+                </p>
+                <p>
+                    Visit <a href="https://damp11113.xyz/dpsoftware/ccide">ccIDE Website</a> for more information and updates.
+                </p>
+                <div class="license">
+                    &copy; 2024 DPSoftware Foundation. Licensed under GPL v3.
+                </div>
+                <style>
+                    .license {
+                        font-size: 14px;
+                        color: #888;
+                        text-align: center;
+                        margin-top: 20px;
+                    }
+                </style>
+            </div>
+        </div>
+
+        <div class="popup" id="library-popup" style="overflow-y:hidden;">
+            <div class="popup-content p-3" style="max-width: 1280px; position: relative; margin-top: 100px;">
+                <button type="button" class="btn-close" aria-label="Close" id="libraryCloseBtn" style="position: absolute; top: 10px; right: 10px;"></button>
+                <h3>Packages Managers</h3>
+                <div class="library-content">
+                    <div id="libcontainer">
+                        <div class="library-item overflow-auto library-container" data-libraryfolder="name">
+                            <img src="image.jpg" class="libimage" onerror="this.onerror=null;this.src='../assets/noimagefallback.png'; this.alt='No Image Available';">
+                            <div class="library-details">
+                                <h3>Title</h3>
+                                <!--Add Author credit-->
+                                <h6>v1.0 by Author</h6>
+                                <p>Library description goes here.</p>
+                                <img src="../assets/basic_computer.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Basic Computer">
+                                <img src="../assets/adv_computer.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Advanced Computer">
+                                <img src="../assets/command_computer.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Command Computer">
+                                <img src="../assets/pocket_computer.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Pocket Computer">
+                                <img src="../assets/adv_pocket_computer.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Advanced Pocket Computer">
+                                <img src="../assets/turtle.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Basic Turtle">
+                                <img src="../assets/adv_turtle.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Advanced Turtle">
+                                <img src="../assets/peripheral.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Peripheral">
+                                <img src="../assets/library.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Library">
+                                <img src="../assets/network-require.png" class="libimageicon" data-bs-toggle="tooltip" data-bs-placement="bottom" data-bs-title="Network Require">
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                <div class="button-container">
+                    <button type="button" class="btn btn-success btn-sm" id="packageman-import-btn">Import Packages</button>
+                    <button type="button" class="btn btn-warning btn-sm" onclick='scanindex()'>Refetch Packages</button>
+                    <button type="button" class="btn btn-primary btn-sm" onclick='downloadBlocks()'>Download Packages</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const {shell} = require('electron');
+    </script>
+    <script src="../node_modules/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
     <script src="frontend.js"></script>
     <script src="index.js"></script>
     <script src="codegen.js"></script>

src/index.js

@@ -6,23 +6,86 @@ window.prompt = function(promptText, defaultValue) {
     return ipc.sendSync("prompt", promptText, defaultValue);
 };
 
-ipc.send("update-startup-status", "Importing module...")
+window.onerror = function (message, source, lineno, colno, error) {
+    ipc.send("error", message)
+    return true; // Prevents the default browser error handling
+};
+
+function delay(time) {
+    return new Promise(resolve => setTimeout(resolve, time));
+}
+
+console.originalLog = console.log;
+
+console.log = function (...args) {
+    ipc.send("update-log-status", ...args)
+    console.originalLog(...args)
+    document.getElementById("loadingstatus").textContent = args.join(' ');
+};
+
+console.log("Importing module...")
 const fs = require('fs');
 const path = require('path');
-const { loadperipheral, scanindex } = require("./blocksmanager");
+const { loadperipheral, scanindex, isBlocksFolderEmpty, downloadBlocks } = require("./blocksmanager");
 const Blockly = require('blockly');
 const { WorkspaceSearch } = require("@blockly/plugin-workspace-search")
+const Toastify = require('toastify-js');
+
+function fireNotify(text, status, destination, duration=3000) {
+    let color;
+    if (status == "success") {
+        color = "#a5dc86"
+    } else if (status == "warning") {
+        color = "#f8bb86"
+    } else if (status == "error") {
+        color = "#f27474"
+    } else if (status == "info") {
+        color = "#3fc3ee"
+    } 
+
+    Toastify({
+        text: text,
+        duration: duration,
+        destination: destination,
+        newWindow: true,
+        close: true,
+        gravity: "top", // `top` or `bottom`
+        position: "right", // `left`, `center` or `right`
+        stopOnFocus: true, // Prevents dismissing of toast on hover
+        style: {
+            background: color,
+        }
+    }).showToast();
+}
 
 let isprojectsaved = false;
 let isprojectopened = false;
 let usedlibinproject = []
 
-ipc.send("update-startup-status", "Initializing blockly workspace...")
+console.log("Initializing blockly workspace...")
 Blockly.utils.colour.setHsvSaturation(0.9)
 
 let originaltoolbar = fs.readFileSync(path.join(__dirname, "toolbox.xml"), 'utf8');
 
 try {
+    const theme = Blockly.Theme.defineTheme('themeName', {
+        base: Blockly.Themes.Classic,
+        componentStyles: {
+            workspaceBackgroundColour: "#1e1e1e",
+            toolboxBackgroundColour: "blackBackground",
+            toolboxForegroundColour: "#fff",
+            flyoutBackgroundColour: "#252526",
+            flyoutForegroundColour: "#ccc",
+            flyoutOpacity: 1,
+            scrollbarColour: "#797979",
+            insertionMarkerColour: "#fff",
+            insertionMarkerOpacity: .3,
+            scrollbarOpacity: .4,
+            cursorColour: "#d0d0d0",
+            blackBackground: "#333"
+        }
+    });
+
     var workspace = Blockly.inject('blocklyDiv', {
         toolbox: originaltoolbar,
         trashcan: true,
@@ -40,7 +103,8 @@ try {
             minScale: 0.1,
             scaleSpeed: 1.1,
             pinch: true
-        }
+        },
+        theme: theme
     });
 
     const workspaceSearch = new WorkspaceSearch(workspace);
@@ -51,28 +115,7 @@ try {
     ipc.send("erroronstart", `Error on initializing workspace: ${e}`)
 }
 
-try {
-    ipc.send("update-startup-status", "Importing system library...")
-    const sysmodulejson = fs.readFileSync(path.join(__dirname, "module_block_design.json"), 'utf8');
-    const blocksJson = JSON.parse(sysmodulejson);
-    for (const blockId in blocksJson) {
-        if (blocksJson.hasOwnProperty(blockId)) {
-            Blockly.Blocks[blockId] = {
-                init: function() {
-                    this.jsonInit(blocksJson[blockId]);
-                }
-            };
-        }
-    }
-    require("./module_generator")
-
-    ipc.send("update-startup-status", "Scanning library...")
-    scanindex();
-} catch (e) {
-    ipc.send("erroronstart", `Error on loading block: ${e}`)
-}
-
-ipc.send("update-startup-status", "Initializing event...")
+console.log("Initializing event...")
 
 ipc.on('export-lua-request', (event) => {    
     console.log("exporting lua")
@@ -81,7 +124,8 @@ ipc.on('export-lua-request', (event) => {
 
 // Save workspace
 ipc.on('save-workspace-request', (event) => {
-    document.getElementById('statusMessage').textContent = `Saving...`;
+    console.log("Saving project...")
+    fireNotify(`Saving...`, "warning")
     const state = Blockly.serialization.workspaces.save(workspace);
     const data = {
         "usedlibrary": usedlibinproject,
@@ -93,6 +137,7 @@ ipc.on('save-workspace-request', (event) => {
 
 // Load workspace
 ipc.on('load-workspace', (event, json) => {
+    console.log("Loading project...")
     try {
         if (json) {
             data = JSON.parse(json)
@@ -102,28 +147,21 @@ ipc.on('load-workspace', (event, json) => {
                 const packagefolder = libinproject[i]
                 if (!usedlibinproject.includes(packagefolder)) {
                     try {
-                        originaltoolbar = loadperipheral(workspace, originaltoolbar, packagefolder);
+                        originaltoolbar = loadperipheral(workspace, originaltoolbar, packagefolder, usedlibinproject);
                         usedlibinproject.push(packagefolder);
                     } catch (e) {
-                        document.getElementById('statusMessage').textContent = `Can't Import ${usedlibinproject[i]}: ${e}`;
-                        setTimeout(() => {
-                            document.getElementById('statusMessage').textContent = `Ready`;
-                        }, 1000);
+                        fireNotify(`Can't Import ${usedlibinproject[i]}: ${e}`, "error")
                     }
+                    
                 }
             }
-            setTimeout(() => {
-                Blockly.serialization.workspaces.load(data.content, workspace);
-                isprojectsaved = true
-                document.getElementById('statusMessage').textContent = `Project Loaded`;
-            }, 100);
+            Blockly.serialization.workspaces.load(data.content, workspace);
+            isprojectsaved = true
+            fireNotify(`Project Loaded`, "success")
         } 
     } catch (e) {
-        document.getElementById('statusMessage').textContent = `Can't Load Project: ${e}`;
+        fireNotify(`Can't Load Project: ${e}`, "error")
     }
-    setTimeout(() => {
-        document.getElementById('statusMessage').textContent = `Ready`;
-    }, 1000);
 })
 
 ipc.on('workspace-saved', (event, success) => {
@@ -131,10 +169,7 @@ ipc.on('workspace-saved', (event, success) => {
     if (!isprojectopened) {
         isprojectopened = true;
     }
-    document.getElementById('statusMessage').textContent = `Project Saved`;
-    setTimeout(() => {
-        document.getElementById('statusMessage').textContent = `Ready`;
-    }, 1000);
+    fireNotify(`Project Saved`, "success")
 });
 
 ipc.on("open-about", () => {
@@ -167,27 +202,54 @@ document.getElementById("packageman-import-btn").addEventListener('click', () =>
     const selectedItems = document.querySelectorAll('.library-item.selected');
     selectedItems.forEach(item => {
         const packagefolder = item.getAttribute('data-libraryfolder');
-        if (!usedlibinproject.includes(packagefolder)) {
-            try {
-                originaltoolbar = loadperipheral(workspace, originaltoolbar, packagefolder);
-                usedlibinproject.push(packagefolder);
-            } catch (e) {
-                document.getElementById('statusMessage').textContent = `Can't Import ${packagefolder}: ${e}`;
-            }
-        }
-        setTimeout(() => {
-            document.getElementById('statusMessage').textContent = `Ready`;
-        }, 1000);
+        originaltoolbar = loadperipheral(workspace, originaltoolbar, packagefolder, usedlibinproject);
+        fireNotify(`Loaded ${packagefolder}`, "success")
     });
 });
 
-// Ensure Blockly container is shown after the workspace is injected
-ipc.send("update-startup-status", "Finished")
-setTimeout(() => {
-    ipc.send("ready")
-}, 500);
+async function InitializingBlock() {
+    try {
+        console.log("Importing system library...");
+        const sysmodulejson = fs.readFileSync(path.join(__dirname, "module_block_design.json"), 'utf8');
+        const blocksJson = JSON.parse(sysmodulejson);
 
-document.getElementById('statusMessage').textContent = "Computer isn't connect";
-setTimeout(() => {
-    document.getElementById('statusMessage').textContent = `Ready`;
-}, 10000);
+        for (const blockId in blocksJson) {
+            if (blocksJson.hasOwnProperty(blockId)) {
+                Blockly.Blocks[blockId] = {
+                    init: function() {
+                        this.jsonInit(blocksJson[blockId]);
+                    }
+                };
+            }
+        }
+        require("./module_generator");
+
+        console.log("Check library folder...");
+        if (isBlocksFolderEmpty()) {
+            await downloadBlocks(); 
+        } 
+        scanindex();
+
+
+    } catch (e) {
+        ipc.send("erroronstart", `Error on loading block: ${e}`);
+    }
+
+    // Ensure Blockly container is shown after the workspace is injected
+    console.log("Finished")
+    setTimeout(() => {
+        ipc.send("ready")
+        // Hide loading area
+        const loadingArea = document.querySelector('.loading-area');
+        loadingArea.style.opacity = '0';
+        loadingArea.style.visibility = 'hidden';
+        loadingArea.style.display = 'none';
+        
+        // Show content area
+        const contentArea = document.querySelector('.content-area');
+        contentArea.style.opacity = '1';
+        contentArea.style.visibility = 'visible';
+    }, 500);
+}
+
+InitializingBlock();

src/module_block_design.json

@@ -158,5 +158,34 @@
         "nextStatement": null,
         "colour": 110,
         "tooltip": "Prints the specified values to the screen in red, separated by spaces, wrapping if necessary. After printing, the cursor is moved to the next line."
+    },
+    "sys_mc_std_color": {
+        "message0": "Standard chat color %1",
+        "args0": [
+            {
+                "type": "field_dropdown",
+                "name": "COLOR",
+                "options": [
+                    ["White", "&f"],
+                    ["Gray", "&7"],
+                    ["Dark Gray", "&8"],
+                    ["Black", "&0"],
+                    ["Dark Red", "&4"],
+                    ["Red", "&c"],
+                    ["Gold", "&6"],
+                    ["Yellow", "&e"],
+                    ["Dark Green", "&2"],
+                    ["Green", "&a"],
+                    ["Dark Aqua", "&b"],
+                    ["Dark Blue", "&1"],
+                    ["Blue", "&9"],
+                    ["Light Purple", "&d"],
+                    ["Dark Purple", "&5"]
+                ]
+            }
+        ],
+        "output": "String",
+        "colour": 220,
+        "tooltip": "Standard chat color picker"
     }
 }

src/module_generator.js

@@ -16,7 +16,7 @@ luaGenerator.forBlock['sys_sleep'] = function(block, generator) {
 luaGenerator.forBlock['sys_utils_table_variable_pack'] = function(block, generator) {
     var args = generator.valueToCode(block, 'RETURN_ARGS', generator.ORDER_NONE);
 
-    return [`table.pack(${arg})`, luaGenerator.ORDER_NONE];
+    return [`table.pack(${args})`, luaGenerator.ORDER_NONE];
 };
 
 luaGenerator.forBlock['sys_utils_get_value_from_table_with_index'] = function(block, generator) {
@@ -101,4 +101,10 @@ luaGenerator.forBlock['sys_print_error'] = function(block, generator) {
     var error = generator.valueToCode(block, 'ERROR', generator.ORDER_NONE);
 
     return `printError(${error})\n`;
+};
+
+luaGenerator.forBlock['sys_mc_std_color'] = function(block, generator) {
+    var color = block.getFieldValue('COLOR');
+
+    return [`"${color}"`, luaGenerator.ORDER_NONE];
 };

src/splash.html

@@ -2,80 +2,197 @@
 <html lang="en">
 <head>
     <meta charset="UTF-8">
-    <title>Splash Screen</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Product Page</title>
     <style>
-    body {
-        display: flex;
-        justify-content: center;
-        align-items: center;
-        height: 100vh;
-        margin: 0;
-        background-color: #2c3e50;
-        color: white;
-        font-family: Arial, sans-serif;
-        position: relative;
-    }
-    #splash-content {
-        text-align: center;
-    }
-    #splash-content img {
-        width: 100px;
-        height: 100px;
-        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3); /* Added drop shadow */
-    }
-    .progress-bar {
-        height: 4px;
-        background-color: rgba(5, 114, 206, 0.2);
-        width: 100%;
-        overflow: hidden;
-        margin-top: 20px;
-    }
-    .progress-bar-value {
-        width: 100%;
-        height: 100%;
-        background-color: rgb(5, 114, 206);
-        animation: indeterminateAnimation 1s infinite linear;
-        transform-origin: 0% 50%;
-    }
-    @keyframes indeterminateAnimation {
-        0% {
-            transform:  translateX(0) scaleX(0);
+        body, html {
+            margin: 0;
+            overflow: hidden;
         }
-        40% {
-            transform:  translateX(0) scaleX(0.4);
+
+        #box {
+            position: absolute;
+            user-select: none;
+            width: 100%;
+            height: 100%;
+            overflow: hidden;
+            margin: auto;
         }
-        100% {
-            transform:  translateX(100%) scaleX(0.5);
+
+        #logo {
+            height: 16px;
+            position: absolute;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            top: 25px;
+            left: 25px;
+        }
+
+        #logo img {
+            width: 18px;
+        }
+
+        #logo h6 {
+            color: white;
+            font-size: 16px;
+            font-weight: 200;
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+            letter-spacing: 0px;
+            margin-left: 5px;
+        }
+
+        #box h1 {
+            color: white;
+            display: inline-block;
+            font-size: 65px;
+            position: absolute;
+            left: 50%;
+            top: 60%;
+            transform: translateX(-50%) translateY(-120%);
+        }
+
+        #box .text {
+            color: white;
+            font-weight: 400;
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+        }
+
+        #box h4 {
+            font-size: 12px;
+            font-weight: 400;
+            opacity: 50%;
+        }
+
+        #starting-txt {
+            position: absolute;
+            left: 25px;
+            bottom: 13px;
+        }
+
+        #author-txt {
+            position: absolute;
+            right: 25px;
+            bottom: 13px;
+        }
+
+        #author-txt a {
+            color: inherit;
+            text-decoration: none;
+        }
+
+        .text img {
+            width: 15px;
+        }
+
+        .dot {
+            width: 4px;
+            height: 4px;
+            top: 60%;
+            left: -20%;
+            transform: translateY(40px);
+            position: absolute;
+            margin: auto;
+            border-radius: 5px;
+            background: white;
+        }
+
+        #dot1 {
+            animation: dotslide 2.8s infinite cubic-bezier(0.2, .8, .8, 0.2);
+        }
+
+        #dot2 {
+            animation: dotslide 2.8s .2s infinite cubic-bezier(0.2, .8, .8, 0.2);
+        }
+
+        #dot3 {
+            animation: dotslide 2.8s .4s infinite cubic-bezier(0.2, .8, .8, 0.2);
+        }
+
+        #dot4 {
+            animation: dotslide 2.8s .6s infinite cubic-bezier(0.2, .8, .8, 0.2);
+        }
+
+        #dot5 {
+            animation: dotslide 2.8s .8s infinite cubic-bezier(0.2, .8, .8, 0.2);
+        }
+
+        @keyframes dotslide {
+            0% {
+                left: -20%;
+            }
+
+            100% {
+                left: 120%;
+            }
+        }
+
+        #product-icon {
+            position: absolute;
+            top: 20%;
+            left: 50%;
+            transform: translateX(-50%);
+            width: 100px; /* Adjust size as needed */
+            height: 100px; /* Adjust size as needed */
+            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3); /* Added drop shadow */
+        }
+
+        #close-btn {
+            position: absolute;
+            top: 15px;
+            right: 25px;
+            background: transparent;
+            border: none;
+            color: white;
+            font-size: 24px;
+            cursor: pointer;
+            outline: none;
+            opacity: 50%;
         }
-    }
-    #copyright {
-        position: absolute;
-        bottom: 10px;
-        left: 10px;
-        font-size: 12px;
-        color: #bdc3c7;
-    }
     </style>
 </head>
 <body>
-    <div id="splash-content">
-        <img src="../assets/ccIDEIcon.ico" alt="ccIDE Icon">
-        <h1>Loading ccIDE...</h1>
-        <div class="progress-bar">
-            <div class="progress-bar-value"></div>
+    <div id="box" style="background-color:#2c3e50">
+        <button id="close-btn">&#10006;</button>
+        <span id="logo">
+            <img id="logo-img" src="../assets/dpsoftware.png"/>
+            <h6 id="logo-text">DPSoftware Foundation</h6>
+        </span>
+        
+        <div id="product-review">
+            <img id="product-icon" src="../assets/ccIDEIcon.ico" alt="ccIDE Icon"/>
+            <h1 id="product" class="text">ccIDE</h1>
         </div>
-        <h6 id="status">Initializing...</h6>
-    </div>
-    <div id="copyright">
-        &copy; 2024 DPSoftware Foundation. Licensed under GPL v3.
+        <div id="loading-dots">
+            <div class="dot" id="dot1"></div>
+            <div class="dot" id="dot2"></div>
+            <div class="dot" id="dot3"></div>
+            <div class="dot" id="dot4"></div>
+            <div class="dot" id="dot5"></div>
+        </div>
+        <h4 class="text" id="starting-txt">Loading ...</h4>
+        <h4 class="text" id="author-txt">damp11113.xyz</h4>
     </div>
     <script>
         const { ipcRenderer } = require("electron");
         const ipc = ipcRenderer;
 
         ipc.on('change-status', (event, status) => {
-            document.getElementById('status').textContent = status;
+            document.getElementById('starting-txt').textContent = status;
         });
+
+        ipc.on('change-title', (event, title) => {
+            document.getElementById('product').textContent = title;
+        });
+
+        ipc.on('isloaded', (event) => {
+            document.getElementById('loading-dots').remove();
+        });
+
+        document.getElementById('close-btn').addEventListener('click', () => {
+            ipc.send('splash-close');
+        });
+        
     </script>
 </body>
 </html>

src/splash_old.html

@@ -0,0 +1,90 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Splash Screen</title>
+    <style>
+    body {
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        height: 100vh;
+        margin: 0;
+        background-color: #2c3e50;
+        color: white;
+        font-family: Arial, sans-serif;
+        position: relative;
+    }
+    #splash-content {
+        text-align: center;
+    }
+    #splash-content img {
+        width: 100px;
+        height: 100px;
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3); /* Added drop shadow */
+    }
+    .progress-bar {
+        height: 4px;
+        background-color: rgba(5, 114, 206, 0.2);
+        width: 100%;
+        overflow: hidden;
+        margin-top: 20px;
+    }
+    .progress-bar-value {
+        width: 100%;
+        height: 100%;
+        background-color: rgb(5, 114, 206);
+        animation: indeterminateAnimation 1s infinite linear;
+        transform-origin: 0% 50%;
+    }
+    @keyframes indeterminateAnimation {
+        0% {
+            transform:  translateX(0) scaleX(0);
+        }
+        40% {
+            transform:  translateX(0) scaleX(0.4);
+        }
+        100% {
+            transform:  translateX(100%) scaleX(0.5);
+        }
+    }
+    #copyright {
+        position: absolute;
+        bottom: 10px;
+        left: 10px;
+        font-size: 12px;
+        color: #bdc3c7;
+    }
+    </style>
+</head>
+<body>
+    <div id="splash-content">
+        <img src="../assets/ccIDEIcon.ico" alt="ccIDE Icon">
+        <h1 id="title">Loading ccIDE...</h1>
+        <div class="progress-bar" id="progressbar">
+            <div class="progress-bar-value"></div>
+        </div>
+        <h6 id="status">Initializing...</h6>
+    </div>
+    <div id="copyright">
+        &copy; 2024 DPSoftware Foundation. Licensed under GPL v3.
+    </div>
+    <script>
+        const { ipcRenderer } = require("electron");
+        const ipc = ipcRenderer;
+
+        ipc.on('change-status', (event, status) => {
+            document.getElementById('status').textContent = status;
+        });
+
+        ipc.on('change-title', (event, title) => {
+            document.getElementById('title').textContent = title;
+        });
+
+        ipc.on('isloaded', (event) => {
+            document.getElementById('progressbar').remove();
+        });
+        
+    </script>
+</body>
+</html>

src/styles.css

@@ -1,16 +1,90 @@
 :root {
     --line-border-fill: #3498db;
-    --line-border-empty: #e0e0e0;
+    --line-border-empty: #7f8c8d; /* Lighter gray for dark mode */
+    --background-color: #121212; /* Dark background for body */
+    --text-color: #e0e0e0; /* Lighter text color */
+    --button-bg: #333; /* Dark button background */
+    --button-hover-bg: #0066cc; /* Button hover color */
+    --progress-bg: #3498db; /* Progress bar fill color */
+    --error-color: #e74c3c; /* Error state color */
 }
 
 body {
-    background-color: #212121;
-    margin: 0;
+    background-color: var(--background-color);
+    color: var(--text-color);
+    font-family: 'Arial', sans-serif;
+    overflow: hidden; /* Hide scrollbars */
+}
+
+.content-area {
+    opacity: 0;
+    visibility: hidden;
+}
+
+.loading-area {
+    color: #cacaca;
+    position: absolute;
+    z-index: 400;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 100%;
+    height: calc(100% - 22px);
+}
+
+#progressBarloading {
+    display: none; /* Initially hidden */
+}
+
+#loadingContent {
+    position: relative;
     display: flex;
     flex-direction: column;
-    height: 100vh;
-    font-family: 'Noto Sans', sans-serif;
-    overflow: hidden; /* Hide scrollbars */
+    align-items: center;
+    justify-content: center;
+}
+
+.loader {
+    width: 90px;
+    height: 14px;
+    box-shadow: 0 3px 0 #fff;
+    position: relative;
+    clip-path: inset(-40px 0 -5px)
+}
+
+.loader:before {
+    content: "";
+    position: absolute;
+    inset: auto calc(50% - 17px) 0;
+    height: 50px;
+    --g:no-repeat linear-gradient(#ccc 0 0);
+    background: var(--g),var(--g),var(--g),var(--g);
+    background-size: 16px 14px;
+    animation:
+    l7-1 2s infinite linear,
+    l7-2 2s infinite linear;
+}
+@keyframes l7-1 {
+    0%,
+    100%  {background-position: 0 -50px,100% -50px}
+    17.5% {background-position: 0 100%,100% -50px,0 -50px,100% -50px}
+    35%   {background-position: 0 100%,100% 100% ,0 -50px,100% -50px}
+    52.5% {background-position: 0 100%,100% 100% ,0 calc(100% - 16px),100% -50px}
+    70%,
+    98%  {background-position: 0 100%,100% 100% ,0 calc(100% - 16px),100% calc(100% - 16px)}
+}
+@keyframes l7-2 {
+    0%,70% {transform:translate(0)}
+    100%  {transform:translate(200%)}
+}
+
+.dpclogoload {
+    display: flex; /* Enable flexbox */
+    justify-content: center; /* Center horizontally */
+    position: fixed; /* Fixed position */
+    bottom: 30px; /* Adjust as necessary */
+    z-index: 20; /* Ensure it appears above other content */
+    width: 100%; /* Ensure the div takes full width */
 }
 
 #navbar {
@@ -22,7 +96,7 @@ body {
 }
 
 .navbar-button {
-    background-color: #2c3e50;
+    background-color: var(--button-bg);
     color: white;
     border: none;
     border-radius: 50%; /* Make the button circular */
@@ -48,7 +122,7 @@ body {
 }
 
 .navbar-button:hover {
-    background-color: #0066cc; /* Darken color on hover */
+    background-color: var(--button-hover-bg); /* Darken color on hover */
     z-index: 99; 
 }
 
@@ -66,20 +140,6 @@ body {
     bottom: 0;
 }
 
-#statusBar {
-    height: 3vh; /* Set the height of the status bar */
-    background-color: #333;
-    color: #ffffff;
-    display: flex;
-    align-items: center;
-    padding: 0 10px;
-    box-sizing: border-box;
-}
-
-#statusMessage {
-    margin: 0;
-}
-
 /* Styles for the upload-popup container */
 .popup {
     display: none; /* Hide initially */
@@ -97,7 +157,8 @@ body {
 
 /* Styles for the upload-popup content */
 .popup-content {
-    background-color: #fefefe;
+    background-color: #333;
+    color: #fefefe;
     margin: 15% auto; /* Center the upload-popup vertically and horizontally */
     padding: 20px;
     border: 1px solid #888;
@@ -151,7 +212,7 @@ body {
 }
 
 .progress {
-    background-color: var(--line-border-fill);
+    background-color: var(--progress-bg);
     position: absolute;
     top: 50%;
     left: 0;
@@ -163,10 +224,9 @@ body {
 }
 
 .progress.error {
-    background-color: red; /* Set to red color for error state */
+    background-color: var(--error-color); /* Set to red color for error state */
 }
 
-
 .circle {
     background-color: #fff;
     color: #999;
@@ -186,7 +246,7 @@ body {
 }
 
 .circle.error {
-    border-color: red; /* Optionally, change border color to red */
+    border-color: var(--error-color); /* Optionally, change border color to red */
     color: white; /* Optionally, adjust text color for visibility */
 }
 
@@ -211,15 +271,20 @@ body {
 }
 .library-details {
     flex: 1;
-    line-height: 10px;
+    line-height: 5px;
 }
+.library-details-cv {
+    color: #7a7a7a;
+    font-size: 15px;
+}
+
 .library-item {
     cursor: pointer;
     padding: 10px;
-    border-bottom: 1px solid #e9ecef;
+    border-bottom: 1px solid #7f8c8d; /* Lighter border */
 }
 .library-item.selected {
-    background-color: #e9ecef;
+    background-color: #34495e; /* Darker background for selected items */
 }
 .library-content {
     flex: 1;
@@ -228,11 +293,27 @@ body {
     max-height: 720px; /* Ensure a max height for scrolling */
 }
 .library-item:hover {
-    background-color: #cacaca;
+    background-color: #7f8c8d; /* Hover effect for items */
 }
 
 .button-container {
     display: flex;
-    justify-content: flex-end;
-    gap: 10px;
-}
+    justify-content: center;
+    align-items: center;
+    margin-top: 10px;
+}
+.btn-invisible {
+    background: transparent;
+    border: none;
+    padding: 5px;
+    cursor: pointer;
+}
+
+.swipe-text {
+    font-size: 14px;
+    color: #ccc;
+}
+
+.pointer-pointer {
+    cursor: pointer;
+}

src/toolbox.xml

@@ -332,6 +332,7 @@
         <block type="sys_utils_get_type"></block>
         <block type="ide_addcode"></block>
         <block type="ide_start"></block>
+        <block type="sys_mc_std_color"></block>
     </category>
     <sep></sep>
     <category name="Variables" custom="VARIABLE" colour="330">

startup.lua

@@ -0,0 +1,117 @@
+print("checking computer type...")
+local machineType = 0
+local isAdvanced = false
+local isPocket = false
+local isTurtle = false
+local isCommand = false
+
+-- Check if advanced (multishell exists in advanced computers and advanced pocket computers)
+if multishell then
+    isAdvanced = true
+end
+
+-- Check if Pocket Computer (API specific to Pocket Computers)
+if pocket then
+    isPocket = true
+end
+
+-- Check if Turtle (turtle API is available for turtles)
+if turtle then
+    isTurtle = true
+end
+
+if commands then
+    isCommand = true
+end
+
+-- Determine machine type
+if isTurtle then
+    if isAdvanced then
+        machineType = 3 -- Advanced Turtle
+    else
+        machineType = 1 -- Standard Turtle
+    end
+elseif isPocket then
+    if isAdvanced then
+        machineType = 4 -- Advanced Pocket Computer
+    else
+        machineType = 2 -- Standard Pocket Computer
+    end
+else
+    if isAdvanced then
+        if isCommand then
+            machineType = 7 -- Command Computer
+        else
+            machineType = 6 -- Advanced Computer
+        end
+        
+    else
+        machineType = 5 -- Standard Computer
+    end
+end
+
+print("Machine Type: " .. machineType)
+print("connecting to IDE...")
+local ws = assert(http.websocket("ws://127.0.0.1:5133"))
+print("connected to server")
+
+local id
+local isrunning = true
+
+function exitcheck()
+    while true do
+        local event = os.pullEventRaw("terminate")
+        if event == "terminate" then
+            print("Exiting...")
+            isrunning = false
+            ws.close()
+            break
+        end
+    end
+end
+
+function main()
+    while isrunning do
+        print("ready")
+        local message, error = ws.receive()
+        if message then
+            print("Received message:", message)
+            if message == "ping" then
+                ws.send("pong")
+            elseif message == "info" then
+                info = {
+                    OSVersion = os.version(),
+                    ID = os.getComputerID(),
+                    Name = os.getComputerLabel() or "No Name",
+                    Type = machineType,
+                    uptime = os.clock()
+                }
+                ws.send(textutils.serialiseJSON(info))
+            elseif message == "sendcode" then
+                local file = io.open("main.lua", "w")
+                print("waiting for code")
+                local filedata, error = ws.receive()
+                file:write(filedata)
+                file:close()
+            elseif message == "runcode" then
+                if isAdvanced then
+                    id = multishell.launch({}, "main.lua")
+                    multishell.setTitle(id, "Code")
+                    multishell.setFocus(id)
+                else
+                    shell.run("main")
+                end
+            elseif message == "exit" then
+                print("Exiting...")
+                break
+            end
+
+        else
+            print("WebSocket error:", error)
+            break
+        end
+    end
+end
+
+parallel.waitForAny(exitcheck, main)
+print("Exited")

webpack.main.config.js

@@ -0,0 +1,23 @@
+const path = require("path");
+const CopyWebpackPlugin = require("copy-webpack-plugin");
+const nodeExternals = require("webpack-node-externals");
+
+module.exports = {
+    mode: "production",
+    target: "electron-main", // For Electron main process
+    entry: "./src/index.js", // Adjust based on your main entry file
+    output: {
+        filename: "main.js",
+        path: path.resolve(__dirname, "dist"),
+    },
+    externals: [nodeExternals()], // Exclude node_modules
+    plugins: [
+        new CopyWebpackPlugin({
+            patterns: [
+                { from: "assets", to: "assets" },
+                { from: "blocks", to: "blocks" },
+                { from: "src/styles.css", to: "styles.css" },
+            ],
+        }),
+    ],
+};

webpack.renderer.config.js

@@ -0,0 +1,18 @@
+const path = require("path");
+const HtmlWebpackPlugin = require("html-webpack-plugin");
+
+module.exports = {
+    mode: "production",
+    target: "web",  // This should target the web environment for the renderer process
+    entry: "./src/frontend.js", // Ensure this points to the correct renderer entry
+    output: {
+        filename: "renderer.js",
+        path: path.resolve(__dirname, "dist"),
+    },
+    plugins: [
+        new HtmlWebpackPlugin({
+            template: "src/index.html", // Ensure this injects the renderer script
+        }),
+    ],
+};
+