Documentation:CommandsNew commandsOverview:Download Links Hello everyone. Now it 1.8 we have a lot of new possibilities with command blocks, but sometimes it’s just too hard to use them. When you are working with command blocks you can’t see all your commands at once and sometimes it’s tricky to edit them, not to mention a very long
Hello everyone. Now it 1.8 we've plenty of new opportunities with order blocks, but sometimes its just too much to use them. If you are dealing with control blocks you cant notice all your commands simultaneously and sometimes its difficult to edit them, not forgetting a very longer and unclear syntax. It could be ok if you have a dozen of order blocks in assembling your project, but that means you're most likely not using on 100% all of the cool stuff that arrived.
Redstone PROGRAM WRITING LANGUAGE is a solution to generate any level of command blocks predicated on program code in a text document. You write your program code in a file, head to MCEdit, make use of RPL filter and it'll build all of the command blocks. This way you will have a code of one's project, it is simple to edit it and much more importantly its designed to have a brief and intuitive syntax. You'll reveal 2-5 times much less code than you'll do working with control blocks ingame. And you may write this code quicker because youre dealing with it in a textual content document where you dont need to fly around and right-click every order block.
RPL is supposed to convert the program code from the text file to create of control blocks in Minecraft entire world. So the majority of the outlines in RPL system transform into one or many (as well as hundreds) command blocks. Additionally, there are ranges which affect RPLs habits and dont come in the resulted blocks. You can even write comments following a dual slash (//) at any stage in RPL plan.
Specific RPL directives inform the interpreter how exactly to process the outlines arriving after them. Every directive constantly begins with # symbol and requires a separate collection (except #coords ). You can find 7 directives in RPL now. Lets proceed through every one of them.
This one shows the interpreter that the next lines contain a group of substitute pairs. RPL will memorize these pairs and later on apply the replacements on all of the ranges that are designed to turn into order blocks. In each range pairs should be divided by two adhering to symbols: ; , a semicolon and an area. Each pair must have this format: discover = replace . So = must have an area on each aspect. No quotations needed. Multi-line replacements aren't supported. Heres a good example:
%1000% = thousand Constant; %100% = hundred Regular; my_coords = 239 123 -45
no_ai = NoAI:1,Silent:1; mob_kind = Creeper
NEW MOB = summon mob_type my_coords zero_ai
Replacements are applied inside the reverse order, thus after this instance all occurences of NEW MOB will undoubtedly be converted into summon Creeper 239 123 -45 NoAI:1,Silent:1
This directive implies that the following outlines ought to be transformed into control blocks which is put into a straight collection in the Minecraft globe. The path and coordinates of this range`s starting block are usually set via directive`s features which go immediately after the directive itself like therefore:
#new_series x 12 57 -34
So the very first attribute is direction and contains 3 possible values: x , y and z . Negative instructions are not supported since they make small sence because of the fact that in Minecraft generaly blocks are usually up-to-date and executed in the region of positive instructions along each axis.
The next, third and 4th arguments listed below are x, y and z of the initial block in the collection. You may use standart Minecraft tilde notation right here to specify the positioning in accordance with the corner of one's choice with lowest coordinates along each axis.
This directive will be used in combination with 20Hz clocks. It generates a fill-based clock, making a type of redstone blocks which are increasingly being replaced with rock and vice-versa 20 instances per second (each video game tick). So every order block touching that range gets driven and updated 20 moments per 2nd and executes its control with the same regularity. RPL places all of the command blocks third , directive around that series in a similar order they'll be triggered ingame each tick. There's an optional attribute that enables you to specify the sides of the clockline you wish to use to put command blocks close to:
#fresh_clockline z ~ ~1 ~ bottom level,left
#new_clockline x ~ ~2 ~ all
Which means this directive has 5 parameters. Unlike #new_collection , the first you can just end up being x or z . The final attribute could be either all or perhaps a fixed of comma-separated available choices: correct,left,top,bottom part . Default value is definitely all .
And both in #brand-new_range and in #fresh_clockline settings a blank line may cause a one-block gap between resulting order blocks.
This one is strictly exactly like #fresh_clockline except it doesnt develop a 20Hz clock, nevertheless, you can location a redstone block at the start of the series and the complete line will undoubtedly be triggered and the redstone block will undoubtedly be replaced with rock, so you can stick it there again afterwards. In this manner its kinda such as a function that you could call.
Identical to #fresh_functionline , however the collection gets removed following the initial execution. RPL areas a block by the end of the range that fills the whole lot with air. That is useful for things such as creating objectives and establishing some initial ideals.
RPL will create a set of control blocks that generates all goals found in the script above. It just counts goals from selectors (like in rating_obj_min=0 and obj gong7deng sign rather than gong18deng execute *** ~ ~ ~ gong7deng . Illustration: gong21deng gong22deng @Sheep => @a => playsound dig.wooden @p gong23deng gong21deng means: gong21deng gong22deng execute @electronic ~ ~ ~ carry out @a ~ ~ ~ playsound dig.wood @p gong23deng gong21deng Therefore gong18deng @selector => command becomes execute @selector ~ ~ ~ control
And today to essentially the most handy function of RPL: intuitive procedures. You dont need to write those loooong scoreboard gamers operation or scoreboard gamers set or include or remove, it is possible to just write several intuitive terms and RPL can do the relaxation for you personally:
@Sheep vx = vy
This command will set the score of every sheep in vx objective to its score in vy objective. In case you are serious, it corresponds to the Minecraft order:
execute @electronic ~ ~ ~ scoreboard players operation @electronic vx = @electronic vy
In cases like this the RPL command is 6 times shorter and possibly 10 times more very clear!
So there always ought to be two phrases on the left part of the procedure: selector and goal. On the proper side you may use either selector and goal or simply an objective, RPL use @me selector automagically.
Numbers may also be allowed on the proper side, but limited to =, -= and += functions. If you are using numbers, you can include a dataTag on the proper exactly like in scoreboard gamers set/add/remove instructions:
@Creepers driven = 1 powered:1b
So this is quite cool, but theres even more ???? It is possible to cascade the procedures with exactly the same left aspect:
@Sheep temp = deltav /= dirScale configurations *= temp
@Sheep temp = deltav
@Sheep temp /= dirScale configurations
@Sheep temp *= temp
The important thing here's that operation`s priorities aren't considered. The functions are executed in exactly the same purchase as they come in the string. For instance:
@Sheep a = 2 += 3 *= d
@Sheep a = 2
@Sheep the += 3
@Sheep the *= d
So a will undoubtedly be 5 * d, however, not 2 + (3 * d) as you'll expect if priorities were considered.
The other important things will be that as of this moment you are not permitted to utilize the scoreboard gamers operation control in RPL, since it will confuse the procedure signs with its very own format. The only method to use this order in RPL is to apply $ indication explained above. But RPL implements all of the top features of this command, which means you probably wont have to utilize it anyway.
gong7deng New instructions gong16deng gong7deng gong17deng
gong11deng RPL introduces some new instructions. In first version you can find two of these: gong18deng tpsmart gong7deng and gong18deng sqrt gong7deng . gong13deng
gong19deng tpsmart gong20deng
gong11deng This command enables you to teleport entities predicated on its score within an objective. You could have an objective which has velocity values for every entity and teleport them appropriately. I will utilize the expression velocity below since it is the almost all probable usecase of the command. This control creates a couple of control blocks and each one of these covers certain variety in possible velocity ideals. It requires 8 parameters: gong21deng
gong22deng tpsmart @Sheep x vx 20 400 10 0.02 0.4 gong23deng gong21deng
1. Selector who do you wish to telepot gong21deng
2. Axis of teleportation. You may use only 1 axis per one tpsmart control gong21deng
3. Objective to utilize. RPL with utilize the selector from the initial parameter to look for the velocity value gong21deng
4 and 5. Selection of possible velocity ideals. gong21deng
6. Step. This affects just how many blocks will be produced and how precise the correspondence between velocity and tp range will be. In the aforementioned example step is 10, therefore the command will generate a control block for velocity ideals from 20 to 30, after that from 30 to 40 and so forth. gong21deng
7 and 8. The number of distances corresponding to specified selection of velocity ideals. This is the range the entity will undoubtedly be teleported by. If you work with a 20Hz time clock the reasonable ideals for these parameters are usually between -1 and 1, 1 means 20 blocks per 2nd. gong13deng
gong11deng The aforementioned example will create these commands: gong21deng
gong22deng tp @e ~0.02 ~ ~ gong21deng
tp @e ~0.03 ~ ~ gong21deng
tp @e ~0.041 ~ ~ gong21deng
... and so forth untill: gong21deng
tp @e ~0.39 ~ ~ gong21deng
tp @e ~0.4 ~ ~ gong23deng gong13deng
gong19deng sqrt gong20deng
gong11deng Square root calculation. As of this moment theres no method to actually calculate the main in Minecraft, which means this command uses exactly the same method as tpsmart. It generates a control block for every feasible resulting square root and each one of these blocks checks if the foundation number is just about this block`s quantity squared, if which makes sense. Example: gong21deng
gong22deng sqrt 1 5 @p src dest gong23deng gong21deng
converts into (inside RPL syntax): gong21deng
gong22deng @p dest = 1 gong21deng
@p dest = 2 gong21deng
@p dest = 3 gong21deng
@p dest = 4 gong21deng
@p dest = 5 gong23deng gong21deng
So the very first two parameters set the number of resulting sq . roots you would like to obtain, 3rd and 4th parameters specify the foundation number and final two parameters specify where you can place the square root. In the illustration above theres only 1 parameter for this because RPL use @me selector automagically. Full syntax appears like this: gong21deng
gong22deng sqrt 1 6 @srcSelector srcObj @destSelector destObj gong23deng gong21deng
and it'll be changed into (in RPL syntax again): gong21deng
gong22deng @srcSelector => destSelector destObj = 1 gong21deng
@srcSelector => destSelector destObj = 2 gong21deng
@srcSelector => destSelector destObj = 3 gong21deng
@srcSelector => destSelector destObj = 4 gong21deng
@srcSelector => destSelector destObj = 5 gong21deng
@srcSelector => destSelector destObj = 6
For Minecraft 1.8