User Tools

Site Tools


crpl:crpltutorial

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
crpl:crpltutorial [2020/05/26 18:25] – Added a chapter for Attributes, also fixed a mistake I made earlier Saniancrpl:crpltutorial [2020/05/27 07:59] (current) – All referenced functions are now links to their respective wiki pages. Also added a paragraph about ELSE and changed up some code examples to be more consise. Sanian
Line 49: Line 49:
 </note> </note>
  
-First of all, if you have programmed before, try to forget that while reading. CRPL is (unlike many others) a stack based language, that means you put (push) all numbers on a big stack of numbers and functions (like SetCreeper or QueueMove) get (pop) the last number(s) from the stack and do something with it (create a spore, emit creeper). Think of a stack of plates in the cafeteria. People take the top plate. Then someone brings more plates, those go on top and people start taking from the top again. The whole script will be executed once per frame. In scripts, you can use '#' to skip the rest of the line. Think of it as a comment in your script.+First of all, if you have programmed before, try to forget that while reading. CRPL is (unlike many others) a stack based language, that means you put (push) all numbers on a big stack of numbers and functions (like //[[crpl:docs:setcreeper|SetCreeper]]// or //[[crpl:docs:queuemove|QueueMove]]//) get (pop) the last number(s) from the stack and do something with it (create a spore, emit creeper). Think of a stack of plates in the cafeteria, you can only take the top plate. Then someone brings more plates, those go on top and people start taking from the top again. The whole script will be executed once per frame. In scripts, you can use '#' to skip the rest of the line. Think of it as a comment in your script. 
 <code> <code>
 #this is a comment and will not be executed</code> #this is a comment and will not be executed</code>
-Time to create your first CRPL script! Try to use the functions GetCoords and SetCreeper. CurrentCoords puts two numbers on the stack (the X and Y coordinates of the CRPL tower) and SetCreeper pops 3 numbers from the stack (X and Y coords the creeper will be set on and the amount of creeper). The following code sets the creeper height to 5 every frame (there are 30 frames in an in-game second):+Time to create your first CRPL script! Try to use the functions //[[crpl:docs:currentcoords|CurrentCoords]]// and //[[crpl:docs:setcreeper|SetCreeper]]////CurrentCoords// puts two numbers on the stack (the X and Y coordinates of the CRPL tower) and //SetCreeper// pops 3 numbers from the stack (X and Y coords the creeper will be set on and the amount of creeper). The following code sets the creeper height to 5 every frame (there are 30 frames in an in-game second):
 <code> <code>
 #Set the creeper to height 5 on the current position #Set the creeper to height 5 on the current position
-CurrentCoords 5 SetCreeper</code> +CurrentCoords 5 SetCreeper 
-Instead of '5' you could pick another number or a variable (explained later) and instead of CurrentCoords you could pick two number to indicate the cell where the creeper has to be set. +</code> 
 + 
 +Instead of '5' you could pick another number or a variable (explained later) and instead of //CurrentCoords// you could pick two number to indicate the cell where the creeper has to be set. 
  
 Here are 2 more examples of what you could write: Here are 2 more examples of what you could write:
  
-  * AddCreeper: instead of setting the creeper to a specific height, this adds creeper.<code>+  * //[[crpl:docs:addcreeper|AddCreeper]]//: instead of setting the creeper to a specific height, this adds creeper.<code>
 0 0 1 AddCreeper</code> 0 0 1 AddCreeper</code>
-  * RandCoords: This picks a random X and Y coordinate somewhere on the map. <code>#Set the creeper to 1 on a random position+  * //[[crpl:docs:randcoords|RandCoords]]//: This picks a random X and Y coordinate somewhere on the map. <code>#Set the creeper to 1 on a random position
 RandCoords 1 SetCreeper</code> RandCoords 1 SetCreeper</code>
  
-One more useful functions before I move on to the next section, you can use TIME Delay to stop the execution of the script for the set amount of time. So if you want to add 20 creeper every 3 seconds, you could write:+One more useful functions before I move on to the next section, you can use TIME //[[crpl:docs:delay|Delay]]// to stop the execution of the script for the set amount of time. So if you want to add 20 creeper every 3 seconds, you could write:
  
 <note warning> <note warning>
Line 89: Line 92:
 ==== Using the tracelog and further introduction of a stack language ==== ==== Using the tracelog and further introduction of a stack language ====
  
-There's a built-in function to show numbers that are currently on the stack. To enable the trace log, you must call the function ShowTraceLog. After that you can use the function Trace to pop an item from the stack and show it on the trace log (removes the item from the stack!). Use Trace2, Trace3, Trace4, Trace5 and TraceStack to pop and show 2, 3, 4, 5 or the whole stack on the trace log (TraceStack doesn't pop anything from the list).+There's a built-in function to show numbers that are currently on the stack. To enable the trace log, you must call the function //[[crpl:docs:showtracelog|ShowTraceLog]]//. After that you can use the function //[[crpl:docs:trace|Trace]]// to pop an item from the stack and show it on the trace log (removes the item from the stack!). Use //[[crpl:docs:trace2|Trace2]]////[[crpl:docs:trace3|Trace3]]////[[crpl:docs:trace4|Trace4]]////[[crpl:docs:trace5|Trace5]]// and //[[crpl:docs:tracestack|TraceStack]]// to pop and show 2, 3, 4, 5 or the whole stack on the trace log (//TraceStack// doesn't pop anything from the list).
 In the examples below we use the following notation to show how an operation affects the stack: OPERATION (BEFORE -- AFTER).  In the examples below we use the following notation to show how an operation affects the stack: OPERATION (BEFORE -- AFTER). 
  
 <hidden Show/Hide Examples> <hidden Show/Hide Examples>
-  * Add (99 33 -- 132)<code>+  * //[[crpl:docs:add|Add]]// (99 33 -- 132)<code>
 once  once 
     ShowTraceLog      ShowTraceLog 
Line 100: Line 103:
 </code> </code>
  
-  * Sub (12 7 -- 5)<code>+  * //[[crpl:docs:sub|Sub]]// (12 7 -- 5)<code>
 once  once 
     ShowTraceLog      ShowTraceLog 
Line 107: Line 110:
 </code> </code>
  
-  * Mod (15 6 -- 3)<code>+  * //[[crpl:docs:mod|Mod]]// (15 6 -- 3)<code>
 once  once 
     ShowTraceLog      ShowTraceLog 
Line 120: Line 123:
 <code>1 2 add 3 4 add mul</code> <code>1 2 add 3 4 add mul</code>
  
-The most important thing here is that you keep in mind that what you've put on the stack last, will be the first you take off (Last In First Out). So+The most important thing here is that you keep in mind that what you've put on the stack last, will be the first you take off (Last In First Out). So:
  
-''8 5 4 add'' +<code> 
- +8 5 4 add  
-will result in +will result in 8 9 
- +# because 5+4=9. 
-''8 9''+</code>
  
-because 5+4=9. If you add another 'add' the sum of 9 and 8 will be calculated since that are the last two items on the stack.+If you add another 'add' the sum of 9 and 8 will be calculated since that are the last two items on the stack.
  
 If you want a challenge, read the following piece of code:  If you want a challenge, read the following piece of code: 
Line 193: Line 196:
 ==== Comparing numbers and conditions ==== ==== Comparing numbers and conditions ====
  
-Sometimes you want a condition to check if code must be executed or not. Like in many other languages, this is possible with the 'iffunction. Since we can't use brackets to show what piece of code must be skipped if the condition is not true, we must use 'endif'. 'true' is indicated by the number 1, and 'false' is indicated by the number 0. The 'iffunction pops one number from the stack and if it is not equal to 0, the code will be executed. If that number is 0, the program skips the code until the next endif. The words 'true' and 'falsesimply push a 1 (true) or (false) on the stack. There are a lot of functions to compare numbers. Most these functions pop two items from the stack and push 0 (false) or 1 (true) back on the stack. You can find the full list in other wiki pages. I'll highlight some:+Sometimes you want a condition to check if code should be executed or not. Like in many other languages, this is possible with the **//[[crpl:docs:if|if]]//** function. Since we can't use brackets to show what piece of code must be skipped if the condition is not true, we must use **//[[crpl:docs:endif|endif]]//**. The **//if//** function pops one number from the stack and if it is not equal to 0, the code will be executed. If that number //is// 0, the program skips the code until the next **//endif//** 
 + 
 +**//if//** may also be used in combination with **//[[crpl:docs:else|else]]//**. This function always has to be in between the **//if//** and **//endif//** functions (''if ... else ... endif''), and works as you'd expect from the name. When an **//if//** function evaluates to //true// the code in between **//else//** and **//endif//** will be skipped and the code will continue from **//endif//**. When an **//if//** function evaluates to //false// the code in between **//if//** and **//else//** will be skipped and the code will continue from **//else//**.  
 + 
 +Typing the words **//[[crpl:docs:true|true]]//** and **//[[crpl:docs:false|false]]//** simply push a 1 and 0 on the stack respectively. There are a lot of functions to compare numbers, most of these functions pop two items from the stack and push 0 (false) or 1 (true) back on the stack. You can find the full list in other wiki pages. I'll highlight some:
  
 ^ Function ^ Description ^ ^ Function ^ Description ^
-|and|true if last 2 items are true| +|[[crpl:docs:and|and]]|true if last 2 items are true| 
-|or|true if at least one of the last 2 items are true| +|[[crpl:docs:or|or]]|true if at least one of the last 2 items are true| 
-|xor|true if exactly one of the last 2 items are true| +|[[crpl:docs:xor|xor]]|true if exactly one of the last 2 items are true| 
-|not|true if the last item is false| +|[[crpl:docs:not|not]]|true if the last item is false| 
-|gt|'greater than', pops 2 items from the stack, if the first is greater than the second, it results in true| +|[[crpl:docs:gt|gt]]|'greater than', pops 2 items from the stack, if the first is greater than the second, it results in true| 
-|gte|'greater than or equal'+|[[crpl:docs:gte|gte]]|'greater than or equal'
-|lt|'lower than'+|[[crpl:docs:lt|lt]]|'lower than'
-|lte|'lower than or equal'+|[[crpl:docs:lte|lte]]|'lower than or equal'
-|eq|'equal' true if the last 2 item have the same value| +|[[crpl:docs:eq|eq]]|'equal' true if the last 2 item have the same value| 
-|neq|'not equal', true if the last 2 items are not the same| +|[[crpl:docs:neq|neq]]|'not equal', true if the last 2 items are not the same| 
-|eq0|true if the last item on the stack is equal to 0| +|[[crpl:docs:eq0|eq0]]|true if the last item on the stack is equal to 0| 
-|neq0|true if the last item is not equal to 0|+|[[crpl:docs:neq0|neq0]]|true if the last item is not equal to 0|
  
  
Line 243: Line 250:
 ==== More functions ==== ==== More functions ====
  
-Time to learn some more useful commands, I'll take the pre-made towers as example. A function is shown by the function name followed by bracket with the arguments in the order they must be put on the stack, seperated by a ','. Empty brackets mean that you don't need to give any arguments.+Time to learn some more useful commands, I'll take the pre-made towers as example. A function is shown by the function name followed by brackets with the arguments in the order in which they must be put on the stack, seperated by a ','. Empty brackets mean that you don't need to give any arguments.
  
 <hidden Emitters> <hidden Emitters>
 ^ Command (args) ^ Description ^ ^ Command (args) ^ Description ^
-|AddCreeper (x, y, amount)| adds [amount] creeper to the cell on [x, y]. | +|[[crpl:docs:addcreeper|AddCreeper]] (x, y, amount)| adds [amount] creeper to the cell on [x, y]. | 
-|SetCreeper (x, y, amount)| sets creeper to [amount] height on cell [x, y].| +|[[crpl:docs:setcreeper|SetCreeper]] (x, y, amount)| sets creeper to [amount] height on cell [x, y].| 
-|SetCreeperNoLower (x, y, amount)| sets creeper to [amount] height on cell [x, y], but it won't remove creeper if there is more creeper than [amount].| +|[[crpl:docs:setcreepernolower|SetCreeperNoLower]] (x, y, amount)| sets creeper to [amount] height on cell [x, y], but it won't remove creeper if there is more creeper than [amount].| 
-|GetCreeper (x, y)| gets the creeper of cell [x, y] and puts it on the stack.|+|[[crpl:docs:getcreeper|GetCreeper]] (x, y)| gets the creeper of cell [x, y] and puts it on the stack.| 
 <code> <code>
 # this: # this:
Line 265: Line 273:
 <hidden  Spore Towers> <hidden  Spore Towers>
 ^ Command (args) ^ Description ^ ^ Command (args) ^ Description ^
-|CreateSpore (x start, y start, x destination, y destination, health, payload) |Creates a spore at cell [x start, y start] that moves towards cell [x destination, y destination]. The spore has a health of [health] ('normal' spores have 1) and if it lands it will drop [payload] creeper.|+|[[crpl:docs:createspore|CreateSpore]] (x start, y start, x destination, y destination, health, payload) |Creates a spore at cell [x start, y start] that moves towards cell [x destination, y destination]. The spore has a health of [health] ('normal' spores have 1) and if it lands it will drop [payload] creeper.| 
 <code> <code>
 # Send a spore to a random unit # Send a spore to a random unit
Line 275: Line 284:
 <hidden  Timing> <hidden  Timing>
 ^ Command (args) ^ Description ^ ^ Command (args) ^ Description ^
-|SetTimer0 (time)| set the timer of timer 0 to [time], the timers decrease with 1 each game frame. SetTimer1, SetTimer2 and SetTimer3 work the same.| +|[[crpl:docs:settimer0|SetTimer0]] (time)| set the timer of timer 0 to [time], the timers decrease with 1 each game frame. //SetTimer1////SetTimer2// and //SetTimer3// work the same.| 
-|GetTimer0 ()| pushes the current value of timer 0 on the stack, same thing for GetTimer1, GetTimer2 and GetTimer3.|+|[[crpl:docs:gettimer0|GetTimer0]] ()| pushes the current value of timer 0 on the stack, same thing for //GetTimer1////GetTimer2// and //GetTimer3//.| 
 <code> <code>
 # Send a spore to a random unit every second # Send a spore to a random unit every second
Line 291: Line 301:
 <hidden Runner Nest> <hidden Runner Nest>
 ^ Command (args) ^ Description ^ ^ Command (args) ^ Description ^
-|GetDigitalis (x, y)| checks for Digitalis on cell [x, y] and pushes the health of the Digitalis back on the stack (0 - no Digitalis, 1 - full health).| +|[[crpl:docs:getdigitalis|GetDigitalis]] (x, y)| checks for Digitalis on cell [x, y] and pushes the health of the Digitalis back on the stack (0 - no Digitalis, 1 - full health).| 
-|CreateRunner (x, y, move, health, payload)| creates a runner on position [x, y], the runner has [health] health and moves [move] pixels per frame. Once the runner is killed [payload] creeper is deposited.| +|[[crpl:docs:createrunner|CreateRunner]] (x, y, move, health, payload)| creates a runner on position [x, y], the runner has [health] health and moves [move] pixels per frame. Once the runner is killed [payload] creeper is deposited.| 
-|GetRunnerCount ()| pushes the amount of runner currently on the map created by this CRPL-Core on the stack (exactly the same as GetGlobalRunnerCount, except this is only for runners created by this tower).| +|[[crpl:docs:getrunnercount|GetRunnerCount]] ()| pushes the amount of runner currently on the map created by this CRPL-Core on the stack (exactly the same as GetGlobalRunnerCount, except this is only for runners created by this tower).| 
-|GetGlobalRunnerCount ()| pushes the total amount of runners currently on the map on the stack.|+|[[crpl:docs:getglobalrunnercount|GetGlobalRunnerCount]] ()| pushes the total amount of runners currently on the map on the stack.| 
 <code> <code>
 # Create a weak runner every frame if Digitalis is present and less than 20 runners are on the map # Create a weak runner every frame if Digitalis is present and less than 20 runners are on the map
Line 304: Line 315:
  
 <hidden  More Digitalis stuff> <hidden  More Digitalis stuff>
-A CRPL-Core can 'activate' Digitalis, that means once the Digitalis is connected to a CRPLT, the will grow. You can change this in the settings for each core.+A CRPL-Core can 'activate' Digitalis, that means once the Digitalis is connected to a CRPLT, the Digitalis will grow. You can change this in the settings for each core.
 ^ Command (args) ^ Description ^ ^ Command (args) ^ Description ^
-|GetDigitalisGrowth (x, y)| checks for digitalis growth area at cell [x, y], if Digitalis can grow there, 1 is pushed back on the stack, if not, 0 is pushed back on the stack.| +|[[crpl:docs:getdigitalisgrowth|GetDigitalisGrowth]] (x, y)| checks for digitalis growth area at cell [x, y], if Digitalis can grow there, 1 is pushed back on the stack, if not, 0 is pushed back on the stack.| 
-|SetDigitalis (x, y, health)| sets the health of the digitalis on cell [x, y] to [health], 0 removes the Digitalis while 1 sets the D to full health.| +|[[crpl:docs:setdigitalis|SetDigitalis]] (x, y, health)| sets the health of the digitalis on cell [x, y] to [health], 0 removes the Digitalis while 1 sets the D to full health.| 
-|SetDigitalisGrowth (x, y, present)| sets if Digitalis can grow on cell [x, y]. Present must be 0 (no Digitalis growth area) or 1 (creates growth area).|+|[[crpl:docs:setdigitalisgrowth|SetDigitalisGrowth]] (x, y, present)| sets if Digitalis can grow on cell [x, y]. Present must be 0 (no Digitalis growth area) or 1 (creates growth area).| 
 <code> <code>
 # this code is mostly used in moving towers # this code is mostly used in moving towers
Line 321: Line 333:
  
 A variable: a way to store numbers without using the stack once stored. A variable: a way to store numbers without using the stack once stored.
-You can use ->VARNAME to pop the last item from the stack and store it as variable and you can use <-VARNAME to push the value of the variable on the stack (doesn't remove the variable). Please not that instead of VARNAME you can use any word. Examples:+You can use **->VARNAME** to pop the last item from the stack and store it as variable and you can use **<-VARNAME** to push the value of the variable on the stack (doesn't remove the variable). Please note that instead of **VARNAME** you can use any word. Examples:
  
 <code> <code>
Line 331: Line 343:
 </code> </code>
  
-As you may have noticed, I used 'while''repeatand 'endwhile'. These functions form a 'loop'. There are different loops you can create in CRPL.  +As you may have noticed, I used **//[[crpl:docs:while|while]]//****//[[crpl:docs:repeat|repeat]]//** and **//[[crpl:docs:endwhile|endwhile]]//**. These functions form a loop. There are different loops you can create in CRPL. 
- +
-Lets start with a 'do' loop. A do loop has 2 functions and has the following form: +
- +
-''do (limit, index) ... loop'' +
- +
-'do' pops 2 items from the stack, if the index is bigger or equal to the limit, the execution skips to 'loop', else the loop runs with 'index'. When 'loop' is read, the execution returns to 'do', the index is raised with 1 and everything starts again. Simply put: the code between 'do' and 'loop' will repeat as many times as (limit-index), it is skipped if that value is 0 or lower. +
- +
-<code> +
-# Add 5 creeper to 5 random locations every 5 seconds +
-5 ->times +
-5 ->creeper +
-150 ->wait +
-<-times 0 do +
-  RandCoords <-creeper AddCreeper +
-loop +
-<-wait Delay +
-</code>+
  
-There'also a while loop. A while loop has 3 functions and has the following form:+Let'start with **//while//** loop, like in the example. A while loop has 3 functions and has the following form:
  
 ''while repeat (condition) ... endwhile'' ''while repeat (condition) ... endwhile''
  
-When while is read, the code between while and repeat is executed (and should push true or false on the stack). If true is read, the code will be executed until endwhile and execution return to while. If false is read, the code between repeat and endwhile is skipped and the execution continues at endwhile.+When **//[[crpl:docs:while|while]]//** is read, the code between **//while//** and **//repeat//** is executed (and should push //true// or //false// on the stack). If //true// is read, the code will be executed until **//endwhile//** and execution return to **//while//**. If //false// is read, the code between repeat and **//endwhile//** is skipped and the execution continues at **//endwhile//**.
  
 <code> <code>
Line 369: Line 364:
 </code> </code>
  
-In a do or while loop, you can use 'break' to stop the loop immediatly and continue at loop or endwhile+There's also 'doloop. A do loop has 2 functions and has the following form: 
 + 
 +''do (limitindex) ... loop'' 
 + 
 +**//[[crpl:docs:do|do]]//** pops 2 items from the stack, if the //index// is bigger or equal to the //limit//, the execution skips to **//loop//**, else the loop will run. When **//loop//** is read, the execution returns to **//do//**, the index is raised with 1 and everything starts again. Simply put: the code between **//do//** and **//loop//** will repeat as many times as (''limit-index''), it is skipped if that value is 0 or lower. 
 + 
 +Within a **//do//** loop the value of //index// can be accessed by typing **//[[crpl:docs:i|I]]//**. This will push the value of //index// onto the stack. 
  
 <code> <code>
-#Add 5 creeper to 5 random locations every 5 seconds +Show the trace log, clear it, then show the numbers 0 through 4 in the log  
-5 ->times +ShowTraceLog  
-->creeper +ClearTraceLog  
-150 ->wait +0 do  
-0 ->numb +   I Trace  
-while true repeat +loop 
-  RandCoords <-creeper AddCreeper <-numb add <-numb 4 gt if break endif ->numb+</code
 + 
 +In a **//do//** or **//while//** loop, you can use **//[[crpl:docs:break|break]]//** to stop the loop immediatly and continue at loop or endwhile 
 + 
 +<code
 +# deposit creeper in random spots in a range of 20 round the Core 
 +# 'while true' = repeat endlessly 
 +while true repeat  
 +    CurrentCoords 20 RandCoordsInRange 60 AddCreeper  
 +    30 Delay 
 +    CurrentCoords GetCreeper 1 gt if break endif  
 +    # the only way to break out of the while-loop 
 +    # is if the core has creeper under it that is 1 high or higher (1 gt = greater than 1)
 endwhile endwhile
-<-wait Delay 
-#'true' pushes 1 (true) on the stack, this means repeat allways reads true 
-#and the loop will keep going until break is read 
-#this can easily make your game crash if you don't add the break command! 
-#gt means greater than 
 </code> </code>
  
  
 ====Defining your own functions==== ====Defining your own functions====
-If you want to use the same piece of code multiple times or want a better overview, you can use functions. In the main code, use @FUNCTION to call the function. At the end of the code, use :FUNCTION to define the function. The function is the piece of code between :FUNCTION and the end of the script or another function. If you want to give arguments or return a value, use the stack. An example to help you:+If you want to use the same piece of code multiple times or want a better overview, you can use functions. In the main code, use **[[crpl:docs:call|@FUNCTION]]** to call the function. At the end of the code, use **[[crpl:docs:func|:FUNCTION]]** to define the function. The function is the piece of code between **:FUNCTION** and the end of the script or another function. If you want to give arguments or return a value, use the stack. An example to help you:
 <code> <code>
-@getnumb #pass the execution to :getnumb +@getnumb         # pass the execution to :getnumb 
-@emit #pass the execution to :emit +@emit            # pass the execution to :emit 
-#------------------ (end of main bodyusing a line helps visualizing it) + 
-:emit #once @emit is read, execution continues here +# -------------- end of main body (using a line helps to visualize it) 
-->numb #pop value from the stack and store it+ 
 +:emit            # once @emit is read, execution continues here 
 +->numb           store variable and do something with it
 CurrentCoords <-numb AddCreeper CurrentCoords <-numb AddCreeper
-:getnumb #start a new function here, the :emit function stops here + 
-5 #push 5 on the stack +:getnumb         define a new function, the :emit function stops here and execution returns to the main body 
-#end of the code, the :getnumb function stops here+               # push 5 on the stack 
 +                 # end of the code, the :getnumb function stops here and execution returns to the main body
 </code> </code>
  
Line 417: Line 428:
 CRPL allows you to modify the attributes of units, which is arguably the most powerful feature of CRPL. Unit attributes may look very complicated but they're actually pretty simple: You give the unit UID (unique identifier), the attribute you want to get/set and then call the GetUnitAttribute or SetUnitAttribute function. CRPL allows you to modify the attributes of units, which is arguably the most powerful feature of CRPL. Unit attributes may look very complicated but they're actually pretty simple: You give the unit UID (unique identifier), the attribute you want to get/set and then call the GetUnitAttribute or SetUnitAttribute function.
 ^ Function ^ Description ^  ^ Function ^ Description ^ 
-|Self () |Pushes the UID of the current unit on the stack| +|[[crpl:docs:self|Self]] () |Pushes the UID of the current unit on the stack| 
-|GetUnitAttribute (unit UID, attribute) |Finds the unit with the given UID, gets the given attribute and pushes  it onto the stack| +|[[crpl:docs:getunitattribute|GetUnitAttribute]] (unit UID, attribute) |Finds the unit with the given UID, gets the given attribute and pushes  it onto the stack| 
-|SetUnitAttribute (unit UID, attribute, value) |Finds the unit with the given UID and sets the given attribute to the given value|+|[[crpl:docs:setunitattribute|SetUnitAttribute]] (unit UID, attribute, value) |Finds the unit with the given UID and sets the given attribute to the given value|
  
-Each attribute has a number. The 'attribute' part you pass to the above functions has to contain the number of the desired attribute. Though you //could// type 17 in order to select a units Ammo-attribute, all attribute values are stored as constant variables that you can access at any point in your code. This means you don't have to learn which attribute has has which value, you can simply type CONST_AMMO and that will add 17 (the attribute number of Ammo) to the stack.+Each attribute has a number. The 'attribute' part you pass to the above functions has to contain the number of the desired attribute. Though you //could// type 17 in order to select a units Ammo-attribute, all attribute values are stored as constant variables that you can access them at any point in your code. This means you don't have to learn which attribute has has which value, you can simply type //CONST_AMMO// and that will add 17 (the attribute number of Ammo) to the stack.
  
-Here's a short list with //some// of the attributes you can use (more can be found on the [[crpl:docs:getunitattribute#unit_constants|GetUnitAttribute]] page):+Here's a short list with //some// of the attributes you can use (The full list can be found on the [[crpl:docs:getunitattribute#unit_constants|GetUnitAttribute]] page):
  
 ^ Attribute ^ Description ^ Value ^ ^ Attribute ^ Description ^ Value ^
Line 437: Line 448:
 | CONST_NULLIFIERDAMAGES | Whether the CrplTower can be targeted and damaged by Nullifiers. Only works for CRPLTowers. |18| | CONST_NULLIFIERDAMAGES | Whether the CrplTower can be targeted and damaged by Nullifiers. Only works for CRPLTowers. |18|
  
-Remember that simply typing an attributes name doesn't return the value of said attribute. In order to get or set the the attributes of a unit you have to use the GetUnitAttribute and SetUnitAttribute functions.+Remember that simply typing an attributes name doesn't return a unit'value of that attribute. In order to get or set the the attributes of a unit you have to use a their UID and the //GetUnitAttribute// and //SetUnitAttribute// functions.
  
 If this is still a bit hard to follow, here's an example: If this is still a bit hard to follow, here's an example:
  
 <code> <code>
-:randUnitBuildMode        # This function puts a random unit back into build mode+:randUnitBuildMode          # This function puts a random unit back into build mode
 # GetUnitsInRange first pushes the UIDs of all units in range, then the amount of units # GetUnitsInRange first pushes the UIDs of all units in range, then the amount of units
 # If there are no units in range it pushes 0 on the stack # If there are no units in range it pushes 0 on the stack
Line 450: Line 461:
  
 <-unitCount 0 do            # for each unit <-unitCount 0 do            # for each unit
- I <-unitNr eq if    # if unit is the chosen one +    I <-unitNr eq if        # if unit is the chosen one 
- CONST_ISBUILDING true SetUnitAttribute   +        CONST_ISBUILDING true SetUnitAttribute   
- else pop endif+    else pop endif
 loop loop
 </code> </code>
Line 459: Line 470:
 ====Making your script more useful==== ====Making your script more useful====
  
-If you use $VARNAME:DEFAULT at the start of your code you can define the variable when adding scripts to units in-game. In other words, you can set these variables in-game and that can be different for other cores.+If you use **[[crpl:docs:define|$VARNAME:DEFAULT]]** at the start of your code you can define the variable when adding scripts to units in-game. In other words, you can set these variables in-game so they are different for other cores running the same script.
  
 <code> <code>
Line 467: Line 478:
 <-interval Delay <-interval Delay
 </code> </code>
-Take a look at '$amtToEmit:10'. When you attach the script to a core in-game you can choose a value for the variable 'amtToEmit'. If you don't input a number in-game, 10 is used. + 
-This is a very powerful mechanism to use the same script over different cores or if you want to give the script to other map makers.+Take a look at ''$amtToEmit:10''. When you attach the script to a core in-game you can choose a value for the variable //amtToEmit//. If you don't input a number in-game, 10 is used. This is a very powerful mechanism to use the same script over different cores or if you want to give the script to other map makers.
 You should use it instead of You should use it instead of
-<code>10 ->amtToEmit</code> +''10 ->amtToEmit'' 
-where possible. Also try to use this instead of fixed values (10 AddCreeper), which should help you alot if you want to make small balance changes later. Ofcourse a good coder can change values directly from within the script, but that'll get harder as your scripts grow larger.+where possible. Also try to use this instead of fixed values (''10 AddCreeper''), which should help you alot if you want to make small balance changes later. Ofcourse a good coder can change values directly from within the script, but that'll get harder as your scripts grow larger.
  
  
crpl/crpltutorial.txt · Last modified: 2020/05/27 07:59 by Sanian