Minecraft Forums

Quote from Aierou

"RedScript" Concept

I like to think of Vanilla Minecraft as a platform, and over time that platform has evolved with the addition of command blocks and various redstone features that allow people to create amazing games and various contraptions. As these redstone builds become more complex, it can be difficult to manage them. Now, I'm not sure how useful this would be in the grand scheme of things, but I quickly wrote down a few ideas about a scripting language that would compile into an MCEdit schematic to be imported into the gameworld. Let me know what you think!


--Handling functions:
+Each function would have an ID associated with it: Main=0, and so on
+Each function will also have a clock testing for its own ID, and if found, it will move a redstone block along the line
+The clocks should be able to operate very quickly, calling a command each tick
+Functions that return values will have a separate scoreboard value associated with the returned value
+Function calls would set current function to x
+On function clock tick, if the conditions are not met, remove the redstone block and/or reset function position

--Conversion to schematic:
+Handled as intelligently as possible
+Map function nodes to coordinates based on calculated physical size of line (table lookup)
+Lines of code would essentially convert to command blocks/etc. all lined up in a row.
+More complex lines would take up more space perpendicular to the command block for that line.

--Code blocks:
+If/else would have to offset the redstone block iterator based on result or something similar
+(code blocks could be handled as another function)

--Variables:
+Integers only for now
+Variables stored in scoreboards
+Full Arithmetic possible with scoreboards?
+Inequalities possible with scoreboard values?

--Misc:
+Function Clocks should check if a scoreboard for sleep delay is active, and stop iterating the redstone block.
+Sleep(ticks) would set a scoreboard value to the number of ticks. Each tick, the value would count down.
+Could use physical logic gates for specific tasks like AND conditions.
+Events could be handled as a clock that calls a function (Many different events are possible)

--Clocks thus far:
+Functions
+Sleep
+Events


--CODE SAMPLES (ECMAScript-formatted):

function foobar(){
    command("/tp @p x y z"); //Low-level command access.
}

if(player.position.equals({x:10,y:10,z:10})){
    foobar();
}

//foo would reference scoreboard id, bar would be the name of a player in the scoreboard
//Not too sure if this is how scoreboards work...
if(foo.bar>1){
    foobar();
}

--REDSTONE SAMPLES:

Function Node:
-------------------

    {C}

    [ ]
    [ ]
    [ ][x]
    [ ]
    [ ] > [x]

If-statement:
-------------------

    [ ] > [x][x][x]

Gated If-statment:
-------------------

    [ ]
     x x x {G}[ ]

Key:

{C}= Clock
{G}= Logic Gate
[ ]= Command Block
x = Redstone
> = Comparator



All concepts are subject to change.