You are currently not logged in! Enter your authentication credentials below to log in. You need to have cookies enabled to log in.
This shows you the differences between two versions of the page.
|
language:state [2018-10-11 05:36 SLT] sei Add info on multiple state switches |
language:state [2020-06-15 12:58 SLT] (current) sei more wording |
||
|---|---|---|---|
| Line 17: | Line 17: | ||
| </code> | </code> | ||
| - | where `<state_name`> is the identifier that will be used in $kw[switch] statements. As an exception, when declaring state $kw[default] we don't add the keyword $kw[state] in front of it. Additionally, the $kw[default] state must always appear before any other state declaration. | + | where `<state_name`> is the identifier that will be used in $kw[state] statements. As an exception, when declaring state $kw[default] we don't add the keyword $kw[state] in front of it. Additionally, the $kw[default] state must always appear before any other state declaration. |
| States can't be empty; each state must contain at least one event declaration. There can be as many event declarations as necessary, but there can't be two declarations of the same event within the same state. | States can't be empty; each state must contain at least one event declaration. There can be as many event declarations as necessary, but there can't be two declarations of the same event within the same state. | ||
| Line 33: | Line 33: | ||
| where `<state_name`> can be $kw[default] or the name of any existing state. This statement causes a state switch, interrupting execution of the current function or event. | where `<state_name`> can be $kw[default] or the name of any existing state. This statement causes a state switch, interrupting execution of the current function or event. | ||
| - | When a state switch statement is found, a $kw[return] statement is automatically inserted at that point in the code, and when the currently executed event finalizes, if the state is NOT the current state, the state switch happens. This triggers two events: first, the $lev[state_exit] event for this state; then, the $lev[state_entry] event for the state changed to. | + | When a state switch statement is found, a $kw[return] statement is automatically inserted at that point in the code, and when the current event finalizes, if the state is NOT the current state, the state switch happens. This triggers two events: first, the $lev[state_exit] event for this state; then, the $lev[state_entry] event for the state changed to. |
| A state switch statement that specifies the same state where it is executed, causes the interruption of the current event or function, but does not cause any other effects: neither the $ev[state_exit] nor the $ev[state_entry] events of the current state are executed. | A state switch statement that specifies the same state where it is executed, causes the interruption of the current event or function, but does not cause any other effects: neither the $ev[state_exit] nor the $ev[state_entry] events of the current state are executed. | ||
| Line 43: | Line 43: | ||
| ===== Notes ===== | ===== Notes ===== | ||
| - | * TODO: Talk about interaction of touch_start and switching states. | + | * When the left mouse button is pressed in a state that has a $lev[touch/] event ($lev[touch_start], $lev[touch] or $lev[touch_end]), and released in a state does not have a touch event, no other $ev[touch_start] event will be generated until the mouse is released in a state that has one of the touch events. This situation persists even after the script is reset. |
| - | * TODO: Talk about the event queue flush. | + | * This happens most often when using $ev[touch_start] to change state, and the destination state does not have any touch events. The symptom is that a click is lost. For this reason, it's preferable to use $ev[touch_end] to change state instead of $ev[touch_start]. |
| + | * When changing state, most pending events are cleared from the event queue. This does not include pending responses for $ev[dataserver], $ev[http_response], $ev[object_rez], $ev[transaction_result], etc. events that haven't been enqueued yet: those may still be processed by the new state when they arrive. Additionally, on state change all listeners ($lfn[llListen]) are closed and all repeated sensors ($lfn[llSensorRepeat]) are stopped. $lev[Target/] detectors ($lfn[llTarget], $lfn[llRotTarget]) are kept running. | ||
| + | * The case of $ev[timer] is special. If there's a running timer ($lfn[llSetTimerEvent]), it's not stopped by a state change. If there's a pending timer event (because of expiry of the timer period), and the current state does not have a $ev[timer] event itself, then that pending timer event won't be cleared by the state change, and will be executed in the new state. If the current state has a $ev[timer] event, however, the state change //will// clear it, without prejudice of the timer events that will be generated in the new state. | ||
| * Executing a state change to a state other than the current one within $ev[state_exit], causes the previous state switch to be cancelled, and the new state switch will generate another $ev[state_exit] event. This will cause an infinite loop unless the script is prepared to handle the situation. If the $ev[state_exit] event executes a switch to the current state, the previous state switch will still happen. | * Executing a state change to a state other than the current one within $ev[state_exit], causes the previous state switch to be cancelled, and the new state switch will generate another $ev[state_exit] event. This will cause an infinite loop unless the script is prepared to handle the situation. If the $ev[state_exit] event executes a switch to the current state, the previous state switch will still happen. | ||
| Line 87: | Line 89: | ||
| ===== Hacks ===== | ===== Hacks ===== | ||
| - | State switches are designed to be used only within event declarations. They work by flagging the state change and adding a $lkw[return] statement at the point where the switch statement is. The flag is checked when the currently executed event terminates. That creates the illusion that the state switch acts as an immediate jump to another state, stopping execution of the current code. | + | State switches are designed to be used only within event declarations. They work by signalling the state change and adding a $lkw[return] statement at the point where the state switch statement is. The signal is checked when the current event terminates. That creates the illusion that the state switch acts as an immediate jump to another state, stopping execution of the current code. |
| - | The compiler checks that there is no state switch statement within a user function; however, due to a bug, the check fails when the statement is somewhere within the block associated to: | + | This $kw[return] trick, however, does not work in user-defined functions, because it would return to the caller, rather that completely interrupting the currently running event. Since it doesn't work in these circumstances, it can't be properly supported in UDFs easily, and rather than adding the necessary complexity for adding proper support for it, LL chose to not support it in UDFs at all, and implemented a check in the compiler to ensure that there is no state switch statement within a user function. |
| + | |||
| + | However, due to a bug, the check fails when the statement is somewhere within the block associated to: | ||
| * an $lkw[if] statement that has no $lkw[else] part, | * an $lkw[if] statement that has no $lkw[else] part, | ||
| Line 96: | Line 100: | ||
| * a $lkw[do] statement. | * a $lkw[do] statement. | ||
| - | allowing us to use state statements even within user functions | + | thus allowing us to exploit that bug and use state statements even within user functions. |
| For example: | For example: | ||
| Line 113: | Line 117: | ||
| </code> | </code> | ||
| - | Note however that, against normal expectations, this will //not// jump to the specified state directly. Keep in mind that it works by flagging the state switch and inserting a return statement; this means that it will return to the caller of the function, which may be another function or an event. Only when the event within which these functions are executed terminates, will the actual state switch happen. | + | But note that, against normal expectations, this will //not// jump to the specified state directly. Keep in mind that it works by flagging the state switch and inserting a $kw[return] statement; this means that it will return to the caller of the function, which may be another function or an event. Only when the event within which these functions are executed terminates, will the $ev[state_exit] event execute, if it exists, and then the actual state switch will happen. |
| To illustrate this, consider the following example: | To illustrate this, consider the following example: | ||
| Line 145: | Line 149: | ||
| </code> | </code> | ||
| - | The output of that script will be "Oops, this is visible!" followed by "Yep, it changed state alright". The line that displays "You can't see me" isn't executed, because the state statement causes a return before reaching it. The line that displays "Oops, this is visible!", however, is executed when the function returns, therefore it will still be executed //after// the switch statement. When the $ev[state_entry] event finishes, the system will notice that there's a state switch pending, and change to ''state another''. | + | The output of that script will be "Oops, this is visible!" followed by "Yep, it changed state alright". The line that displays "You can't see me" isn't executed, because the state statement causes a return before reaching it. The line that displays "Oops, this is visible!", however, is executed when the function returns, therefore it will still be executed //after// the state switch statement. When the $ev[state_entry] event finishes, the system will notice that there's a state switch pending, and change to ''state another''. |
| When using this hack, it's best to use it within a function that does not return any values. If the function returns a value, the outcome depends on the virtual machine used and on the type returned. | When using this hack, it's best to use it within a function that does not return any values. If the function returns a value, the outcome depends on the virtual machine used and on the type returned. | ||