User:SuzannaLinn Resident/LuaMovingTo - Revision history

SuzannaLinn Resident: /* Concatenation */

2025-03-23T16:06:02Z

Concatenation

← Older revision		Revision as of 09:06, 23 March 2025
Line 624:		Line 624:
	==== Concatenation ====		==== Concatenation ====

			The concatenation operator is .. instead of +.
			{\| {{KBtable}}
			\|
			<syntaxhighlight lang="lsl2" line>
			// concatenation (LSL)

			string greet1 = "hello";
			string greet2 = "world";

			llOwnerSay(greet1 + " " + greet2); // --> hello world
			</syntaxhighlight>
			\|
			<syntaxhighlight lang="lua" line>
			-- concatenation (SLua)

			local greet1 = "hello"
			local greet2 = "world"

			ll.OwnerSay(greet1.." "..greet2) -- > hello world
			</syntaxhighlight>
			\|}

	==== And / Or / Not ====		==== And / Or / Not ====

2025-03-23T16:00:00Z

Operators

2025-03-23T15:58:20Z

Increment/ decrement

@@ Line 594: / Line 594: @@
 |}
-==== Increment/ decrement ====
+==== Increment / decrement ====
 ==== And / Or / Not ====

2025-03-23T15:53:18Z

Not equal

← Older revision		Revision as of 08:53, 23 March 2025
Line 574:		Line 574:
	==== Not equal ====		==== Not equal ====

			The unequality operator is ~= instead of !=.
			{\| {{KBtable}}
			\|
			<syntaxhighlight lang="lsl2" line>
			// not equal (LSL)

			if (llGetColor(ALL_SIDES) != <1,1,1>) {
			llOwnerSay("it isn't white");
			}
			</syntaxhighlight>
			\|
			<syntaxhighlight lang="lua" line>
			-- not equal (SLua)

			if ll.GetColor(ALL_SIDES) ~= vector(1,1,1) then
			ll.OwnerSay("it isn't white")
			end
			</syntaxhighlight>
			\|}

	==== Increment/ decrement ====		==== Increment/ decrement ====

2025-03-23T15:42:50Z

Operators

← Older revision		Revision as of 08:42, 23 March 2025
Line 513:		Line 513:
	== Operators ==		== Operators ==


			==== Division ====

			There are two division operators: / and //.

			The / is the decimal division. The // is the integer division.

			If in LSL we are dividing two integers, in Slua we use //, otherwise we use /.

			{\| {{KBtable}}
			\|
			<syntaxhighlight lang="lsl2" line>
			// division (LSL)

			integer total = 10;
			integer people = 7;

			llOwnerSay((string)(total / people)); // --> 1
			llOwnerSay((string)((float)total / people)); // --> 1.428571
			</syntaxhighlight>
			\|
			<syntaxhighlight lang="lua" line>
			-- division (SLua)

			local total = 10
			local people = 7

			ll.OwnerSay(tostring(total // people)) -- > 1
			ll.OwnerSay(tostring(total / people)) -- > 1.4285714285714286
			</syntaxhighlight>
			\|}

			==== Exponentiation ====

			In Lua, the ^ is the exponentiation operator.

			We can use ^ instead of the function ll.Pow()

			{\| {{KBtable}}
			\|
			<syntaxhighlight lang="lsl2" line>
			// exponentiation (LSL)

			integer base = 2;
			integer exp = 3;

			llOwnerSay((string)llPow(base,exp)); // --> 8.000000
			</syntaxhighlight>
			\|
			<syntaxhighlight lang="lua" line>
			-- exponentiation (SLua)

			local base = 2;
			local exp = 3;

			ll.OwnerSay(tostring(base ^ exp)) -- > 8
			</syntaxhighlight>
			\|}

			==== Not equal ====


			==== Increment/ decrement ====


			==== And / Or / Not ====


			==== Concatenation ====


			==== Bitwise operations ====


			==== The operator # ====

	== Functions ==		== Functions ==

2025-03-23T08:49:55Z

← Older revision		Revision as of 01:49, 23 March 2025
Line 341:		Line 341:

	We need to typecast from booleans and to booleans because the LL functions use numeric TRUE/FALSE as parameters and return value.		We need to typecast from booleans and to booleans because the LL functions use numeric TRUE/FALSE as parameters and return value.


	== Events ==		== Events ==
Line 514:		Line 515:

	== Functions ==		== Functions ==


			== Expressions ==

2025-03-22T19:26:19Z

The "New Script"

← Older revision		Revision as of 12:26, 22 March 2025
Line 506:		Line 506:
	SLua doesn't have states and there are no events <code>state_entry</code> or <code>state_exit</code>.		SLua doesn't have states and there are no events <code>state_entry</code> or <code>state_exit</code>.

	To keep the LSL structure, we can write a function with name <code>state_entry</code> (it's not an event, just a function) and call it from the top-level code (LSL-~~syle~~ script, line 16).		To keep the LSL structure, we can write a function with name <code>state_entry</code> (it's not an event, just a function) and call it from the top-level code (LSL-style script, line 16).

	Or move the code in the LSL <code>state_entry</code> to the top-level code (Lua-~~syle~~ script, line 16).		Or move the code in the LSL <code>state_entry</code> to the top-level code (Lua-style script, line 16).

	== Operators ==		== Operators ==

2025-03-22T19:25:20Z

The "New Script"

← Older revision		Revision as of 12:25, 22 March 2025
Line 504:		Line 504:
	\|}		\|}

			SLua doesn't have states and there are no events <code>state_entry</code> or <code>state_exit</code>.

			To keep the LSL structure, we can write a function with name <code>state_entry</code> (it's not an event, just a function) and call it from the top-level code (LSL-syle script, line 16).

			Or move the code in the LSL <code>state_entry</code> to the top-level code (Lua-syle script, line 16).

	== Operators ==		== Operators ==

2025-03-22T19:19:46Z

States

← Older revision		Revision as of 12:19, 22 March 2025
Line 383:		Line 383:
	There aren't states in Slua.		There aren't states in Slua.

	We can simulate ~~them~~ with functions with different names, one for each state, for each event. To change to another "state" we assign the function for this "state" to the name of the event.		The events <code>state_entry</code> and <code>state_exit</code> doesn't exist.

			The script executes the code that is at the top level, out of the functions.

			We can simulate states with functions with different names, one for each state, for each event. To change to another "state" we assign the function for this "state" to the name of the event.

	{\| {{KBtable}}		{\| {{KBtable}}

2025-03-22T19:11:29Z

States

← Older revision		Revision as of 12:11, 22 March 2025
Line 380:		Line 380:
	== States ==		== States ==


			There aren't states in Slua.

			We can simulate them with functions with different names, one for each state, for each event. To change to another "state" we assign the function for this "state" to the name of the event.

			{\| {{KBtable}}
			\|
			<syntaxhighlight lang="lsl2" line>
			// states (LSL)

			default
			{
			touch_end(integer num_detected)
			{
			llOwnerSay("Changing to state ready");
			state ready;
			}
			}

			state ready
			{
			touch_end(integer num_detected)
			{
			llOwnerSay("Changing to state default");
			state default;
			}
			}


			//
			</syntaxhighlight>
			\|
			<syntaxhighlight lang="lua" line>
			-- states (SLua)


			-- function for the event in the "state" default
			function touch_end_default(num_detected)
			ll.OwnerSay("Changing to state ready")
			touch_end = touch_end_ready -- we change the function that handles the event
			end




			-- function for the event in the "state" ready
			function touch_end_ready(num_detected)
			ll.OwnerSay("Changing to state default")
			touch_end = touch_end_default -- we change the function that handles the event
			end


			-- in Lua we can assign a function to a variable
			-- touch_end becomes a function, the same than touch_end_default
			touch_end = touch_end_default
			</syntaxhighlight>
			\|}

	== The "New Script" ==		== The "New Script" ==