Second Life Wiki - User contributions [en]

LlDetectedKey

2013-03-08T12:56:40Z

Myopic Mole: Added to Key category

{{LSL_Function
|inject-2={{LSL_Function/detected|number|key}}
|func_id=32|func_sleep=0.0|func_energy=10.0
|sort=DetectedKey|func=llDetectedKey
|return_type=key
|p1_type=integer|p1_name=number
|func_footnote=Returns an {{HoverText|empty key|{{String}}}} if '''number''' does not correspond to a valid sensed object or avatar.
|func_desc
|return_text=that is the [[UUID]] of the {{LSLGC|Detected|detected}} object or avatar '''number'''.
|spec
|caveats
|constants
|examples=
<lsl>
default
{
touch_start(integer num_detected)
{
llSay(0, "touch_start event: key of avatar touching: " + (string) llDetectedKey(0) );
}
}
</lsl>
|helpers
|also_functions
|also_events
|also_articles
|notes
|permission
|cat1=Key
|cat2
|cat3
|cat4
}}

Modular Pathfinding Kit

2012-12-30T21:46:06Z

Myopic Mole: cleared up unecessary embellishments that were not relevant, fixed math error in comment

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
// insert pathfinding functionality here
}

// called as necessary from events such as script reset or rezzing
startup()
{
// create the character
llCreateCharacter([ CHARACTER_MAX_SPEED, 25,
CHARACTER_DESIRED_SPEED, 15.0]);

doSomething();
}

default
{
on_rez(integer start_param)
{
llResetScript();
}

state_entry()
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([ CHARACTER_MAX_SPEED, 25,
CHARACTER_DESIRED_SPEED, 15.0,
CHARACTER_RADIUS, 0.25,
CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter([CHARACTER_LENGTH, 6.5]);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd(CHARACTER_CMD_STOP, []);

llSleep(15.0);

vector currentPosition = llGetPos();
// resume with any desired pathfinding function
llWanderWithin(currentPosition, <10.0, 10.0, 5.0>, []);
</lsl>

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

===hopping/jumping===

Use llExecCharacterCmd(CHARACTER_CMD_JUMP, [height, 1.0]) to make the character hop 1m into the air. If done with a timer event while using another pathfinding command such as [[llWanderWithin]] the hop will have an arc rather than just vertical movement.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
// insert a cunning grass eating animation here
}

animateTailWiggle()
{
// insert very cute tail wiggle animation here
}

startup()
{
llCreateCharacter([ CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]);
state wander;
}

default
{
on_rez(integer start_param)
{
llResetScript();
}

state_entry()
{
startup();
}
}

state wander
{
state_entry()
{
vector currentPosition = llGetPos();
llWanderWithin(currentPosition, <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();

llSetTimerEvent(15.0);
}

timer()
{
llSetTimerEvent((float)FALSE);
animateTailWiggle();
state wander;
}
}
</lsl>

===random timers===

In the example above the rabbit eat grass for 15 seconds then wanders again, for a random period defined by how long it takes to reach it's next random wander target. This 15 second wait will make it an easy target for hunting creatures or agents (hunting game? what if this was a zombie bunny with a taste for brains? hmm, brains).

To make things less predictable use:

<lsl>
// random period in between [0.0, 15.0)
// which means the random float returned could be 0.0 but not 15.0

llSetTimerEvent( llFrand(15.0) );
</lsl>

<lsl>
// random period in between (0.0, (30.0-random number up to 15)]
// which means the resulting float could be 0 but not (30 - random number up to but not including 15)

llSetTimerEvent( 30.0 - llFrand(15.0) );

</lsl>

===enabled check===

If you're giving other people your creations, you'd be wise to have your script check to see if pathfinding is enabled where they rez it. Pathfinding can be disabled on private regions.

<lsl>
// returns TRUE if patfinding is enabled, FALSE if not.
integer IsPFEnabled()
{
if ( llGetEnv("dynamic_pathfinding") == "enabled" )
return TRUE;
return FALSE;
}
</lsl>
----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-12-30T21:40:33Z

Myopic Mole: /* pathfinding character skeleton */

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
// insert pathfinding functionality here
}

// called as necessary from events such as script reset or rezzing
startup()
{
// create the character
llCreateCharacter([ CHARACTER_MAX_SPEED, 25,
CHARACTER_DESIRED_SPEED, 15.0]);

doSomething();
}

default
{
on_rez(integer start_param)
{
llResetScript();
}

state_entry()
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([ CHARACTER_MAX_SPEED, 25,
CHARACTER_DESIRED_SPEED, 15.0,
CHARACTER_RADIUS, 0.25,
CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter([CHARACTER_LENGTH, 6.5]);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd(CHARACTER_CMD_STOP, []);

llSleep(15.0);

vector currentPosition = llGetPos();
// resume with any desired pathfinding function
llWanderWithin(currentPosition, <10.0, 10.0, 5.0>, []);
</lsl>

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

===hopping/jumping===

Use llExecCharacterCmd(CHARACTER_CMD_JUMP, [height, 1.0]) to make the character hop 1m into the air. If done with a timer event while using another pathfinding command such as [[llWanderWithin]] the hop will have an arc rather than just vertical movement.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
// insert a cunning grass eating animation here
}

animateTailWiggle()
{
// insert very cute tail wiggle animation here
}

startup()
{
llCreateCharacter([ CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]);
state wander;
}

default
{
on_rez(integer start_param)
{
llResetScript();
}

state_entry()
{
startup();
}
}

state wander
{
state_entry()
{
vector currentPosition = llGetPos();
llWanderWithin(currentPosition, <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();

llSetTimerEvent(15.0);
}

timer()
{
llSetTimerEvent((float)FALSE);
animateTailWiggle();
state wander;
}
}
</lsl>

===random timers===

In the example above the rabbit eat grass for 15 seconds then wanders again, for a random period defined by how long it takes to reach it's next random wander target. This 15 second wait will make it an easy target for hunting creatures or agents (hunting game? what if this was a zombie bunny with a taste for brains? hmm, brains).

To make things less predictable use:

<lsl>
// random period in between [0.0, +15.0)
// which means the random float returned could be 0.0 but not 15.0
llSetTimerEvent( llFrand(15.0) );
</lsl>

<lsl>
// random period in between (+15.0, +30.0]
// which means the resulting float could be 30.0 but not 15.0

llSetTimerEvent( 30.0 - llFrand(15.0) );

// same results for:
// llSetTimerEvent( 30.0 + llFrand(-15.0) );
</lsl>

===enabled check===

If you're giving other people your creations, you'd be wise to have your script check to see if pathfinding is enabled where they rez it. Pathfinding can be disabled on private regions.

<lsl>
// returns TRUE if patfinding is enabled, FALSE if not.
integer IsPFEnabled()
{
if ( llGetEnv("dynamic_pathfinding") == "enabled" )
return TRUE;
return FALSE;
}
</lsl>
----
Return to [[Good_Building_Practices]]

Resetting Scripts in a Large Build

2012-11-04T16:24:18Z

Myopic Mole: /* Random Staggered Reset */

If you have a complex build, perhaps sim wide and you need to reset all of the scripts, there isn't an easy way to do this, say from from parcel properties or the region tools.

This presents a few startegies for providing this ability but it does require some forethought.

=Region Restart=

Detect region restart and restart script.

(or other event)

<lsl>
default
{
changed(integer change)
{
if (change & CHANGED_REGION_START)
{
llOwnerSay("The regions has just restarted, resetting the script.");
llResetScript();
}
}

state_entry()
{
// setup and do stuff
}
}
</lsl>

=Listener - restart on command=

Listen for instruction and restart script.

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function
string chatCommand = "reset";

default
{
// this script sends the command to reset the other scripts to reset.
// change to use any trigger event that is suitable.

touch(integer num_detected)
{
llRegionSay(chatChannel, chatCommand);// (3)
}
}
</lsl>

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function
string chatCommand = "reset";

default
{
// insert the listen into your scripts that need to reset on command

state_entry()
{
// setup and do stuff
llListen(chatChannel, "", NULL_KEY, chatCommand);
}

listen(integer channel, string name, key id, string message)
{
if (message == chatCommand)
llResetScript();
}
}
</lsl>

=Random Staggered Reset=

Script load on the sim may be a concern, if so you could use a random timer in the target script to stagger the reset as follows:

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function
string chatCommand = "reset";

default
{
// insert the listen into your scripts that need to reset on command

state_entry()
{
//setup and do stuff
llListen(chatChannel, "", NULL_KEY, chatCommand);
}

listen(integer channel, string name, key id, string message)
{
if (message == chatCommand)
{
//random timer within [0.0, 60.0)
llSetTimerEvent( llFrand(60.0) );
}
}

timer()
{
llResetScript();
}
}
</lsl>

If you need to stagger the resets, perhaps because the order the sxripts start is imortant, use different commands with appropriate pauses between start commands, such as:

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function. "reset3" will trigger after 15 seconds.
string chatCommand = "reset3";

default
{
state_entry()
{
// setup and do stuff
llListen(chatChannel, "", NULL_KEY, chatCommand);
}

listen(integer channel, string name, key id, string message)
{
if (message == chatCommand) llResetScript();
}
}
</lsl>

----
Return to [[Good_Building_Practices]]

Resetting Scripts in a Large Build

2012-11-04T16:23:55Z

Myopic Mole: /* Random Staggered Reset */

Resetting Scripts in a Large Build

2012-11-04T16:22:46Z

Myopic Mole: /* Random Staggered Reset */

If you have a complex build, perhaps sim wide and you need to reset all of the scripts, there isn't an easy way to do this, say from from parcel properties or the region tools.

This presents a few startegies for providing this ability but it does require some forethought.

=Region Restart=

Detect region restart and restart script.

(or other event)

<lsl>
default
{
changed(integer change)
{
if (change & CHANGED_REGION_START)
{
llOwnerSay("The regions has just restarted, resetting the script.");
llResetScript();
}
}

state_entry()
{
// setup and do stuff
}
}
</lsl>

=Listener - restart on command=

Listen for instruction and restart script.

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function
string chatCommand = "reset";

default
{
// this script sends the command to reset the other scripts to reset.
// change to use any trigger event that is suitable.

touch(integer num_detected)
{
llRegionSay(chatChannel, chatCommand);// (3)
}
}
</lsl>

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function
string chatCommand = "reset";

default
{
// insert the listen into your scripts that need to reset on command

state_entry()
{
// setup and do stuff
llListen(chatChannel, "", NULL_KEY, chatCommand);
}

listen(integer channel, string name, key id, string message)
{
if (message == chatCommand)
llResetScript();
}
}
</lsl>

=Random Staggered Reset=

Script load on the sim may be a concern, if so you could use a random timer in the target script to stagger the reset as follows:

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function
string chatCommand = "reset";

default
{
// insert the listen into your scripts that need to reset on command

state_entry()
{
// setup and do stuff
llListen(chatChannel, "", NULL_KEY, chatCommand);
}

listen(integer channel, string name, key id, string message)
{
if (message == chatCommand)
// {
// random timer within [0.0, 60.0)
llSetTimerEvent( llFrand(60.0) );
// }
}

timer()
{
llResetScript();
}
}
</lsl>

If you need to stagger the resets, perhaps because the order the sxripts start is imortant, use different commands with appropriate pauses between start commands, such as:

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function. "reset3" will trigger after 15 seconds.
string chatCommand = "reset3";

default
{
state_entry()
{
// setup and do stuff
llListen(chatChannel, "", NULL_KEY, chatCommand);
}

listen(integer channel, string name, key id, string message)
{
if (message == chatCommand) llResetScript();
}
}
</lsl>

----
Return to [[Good_Building_Practices]]

Resetting Scripts in a Large Build

2012-11-04T16:21:04Z

Myopic Mole: /* Region Restart */

If you have a complex build, perhaps sim wide and you need to reset all of the scripts, there isn't an easy way to do this, say from from parcel properties or the region tools.

This presents a few startegies for providing this ability but it does require some forethought.

=Region Restart=

Detect region restart and restart script.

(or other event)

<lsl>
default
{
changed(integer change)
{
if (change & CHANGED_REGION_START)
{
llOwnerSay("The regions has just restarted, resetting the script.");
llResetScript();
}
}

state_entry()
{
// setup and do stuff
}
}
</lsl>

=Listener - restart on command=

Listen for instruction and restart script.

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function
string chatCommand = "reset";

default
{
// this script sends the command to reset the other scripts to reset.
// change to use any trigger event that is suitable.

touch(integer num_detected)
{
llRegionSay(chatChannel, chatCommand);// (3)
}
}
</lsl>

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function
string chatCommand = "reset";

default
{
// insert the listen into your scripts that need to reset on command

state_entry()
{
// setup and do stuff
llListen(chatChannel, "", NULL_KEY, chatCommand);
}

listen(integer channel, string name, key id, string message)
{
if (message == chatCommand)
llResetScript();
}
}
</lsl>

=Random Staggered Reset=

Script load on the sim may be a concern, if so you could use a random timer in the target script to stagger the reset as follows:

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function
string chatCommand = "reset";

default
{
// insert the listen into your scripts that need to reset on command

state_entry()
{
// setup and do stuff
llListen(chatChannel, "", NULL_KEY, chatCommand);
}

listen(integer channel, string name, key id, string message)
{
if (message == chatCommand)
// {
// random timer within [0.0, 60.0)
llSetTimerEvent( llFrand(60.0) );
// }
}

timer()
{
llResetScript();
}
}
</lsl>

If you need to stagger the resets, perhaps because the order the sxripts start is imortant, use different commands with appropriate pauses between start commands, such as:

<lsl>
// some random negative number
integer chatChannel = -1324628;

// could consider using a random string for the command to obscure the function. "reset3" will trigger after 15 seconds.
string chatCommand = "reset3";

default
{
state_entry()
{
// setup and do stuff
llListen(chatChannel, "", NULL_KEY, chatCommand);
}

listen(integer channel, string name, key id, string message)
{
if (message == chatCommand)
llResetScript();
}
}
</lsl>

----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-11-04T16:10:55Z

Myopic Mole: /* more than one state */

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
// insert pathfinding functionality here
;
}

// called as necessary from events such as script reset or rezzing
startup()
{
// create the character
llCreateCharacter([ CHARACTER_MAX_SPEED, 25,
CHARACTER_DESIRED_SPEED, 15.0]);

doSomething();
}

default
{
on_rez(integer start_param)
{
llResetScript();
}

state_entry()
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([ CHARACTER_MAX_SPEED, 25,
CHARACTER_DESIRED_SPEED, 15.0,
CHARACTER_RADIUS, 0.25,
CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter([CHARACTER_LENGTH, 6.5]);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd(CHARACTER_CMD_STOP, []);

llSleep(15.0);

vector currentPosition = llGetPos();
// resume with any desired pathfinding function
llWanderWithin(currentPosition, <10.0, 10.0, 5.0>, []);
</lsl>

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

===hopping/jumping===

Use llExecCharacterCmd(CHARACTER_CMD_JUMP, [height, 1.0]) to make the character hop 1m into the air. If done with a timer event while using another pathfinding command such as [[llWanderWithin]] the hop will have an arc rather than just vertical movement.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
// insert a cunning grass eating animation here
}

animateTailWiggle()
{
// insert very cute tail wiggle animation here
}

startup()
{
llCreateCharacter([ CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]);
state wander;
}

default
{
on_rez(integer start_param)
{
llResetScript();
}

state_entry()
{
startup();
}
}

state wander
{
state_entry()
{
vector currentPosition = llGetPos();
llWanderWithin(currentPosition, <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();

llSetTimerEvent(15.0);
}

timer()
{
llSetTimerEvent((float)FALSE);
animateTailWiggle();
state wander;
}
}
</lsl>

===Random Timers===

In the example above the rabbit eat grass for 15 seconds then wanders again, for a random period defined by how long it takes to reach it's next random wander target. This 15 second wait will make it an easy target for hunting creatures or agents (hunting game? what if this was a zombie bunny with a taste for brains? hmm, brains).

To make things less predictable use:

<lsl>
// random period in between [0.0, +15.0)
// which means the random float returned could be 0.0 but not 15.0
llSetTimerEvent( llFrand(15.0) );
</lsl>

<lsl>
// random period in between (+15.0, +30.0]
// which means the resulting float could be 30.0 but not 15.0

llSetTimerEvent( 30.0 - llFrand(15.0) );

// same results for:
// llSetTimerEvent( 30.0 + llFrand(-15.0) );
</lsl>

----
Return to [[Good_Building_Practices]]

Resetting Scripts in a Large Build

2012-10-21T21:30:43Z

Myopic Mole: first draft

If you have a complex build, perhaps sim wide and you need to reset all of the scripts, there isn't an easy way to do this, say from from parcel properties or the region tools.

This presents a few startegies for providing this ability but it does require some forethought.

=Region Restart=

Detect region restart and restart script.

(or other event)

<lsl>

default
{
state_entry()
{
//setup and do stuff
}

changed(integer change)
{
if (change & CHANGED_REGION_START)
{
llOwnerSay("The regions has just restarted, resetting the script.");
llResetScript();
}
}
}

</lsl>

=Listener - restart on command=

Listen for instruction and restart script.

<lsl>

default
{

// this script sends the command to reset the other scripts to reset.
// change to use any trigger event that is suitable.

integer channel = -1324628; // some random negative number
string command = "reset"; // could consider using a random string for the command to obscure the function

touch(integer num_detected)
{
llRegionsSay(channel, command); // (3)
}

}

</lsl>

<lsl>

default
{

//insert the lisetn into your scripts that need to reset on command

integer channel = -1324628; //some random negative number
string command = "reset"; //could consider using a random string for the command to obscure the function

state_entry()
{
//setup and do stuff
llListen(channel, "", NULL_KEY, command);
}

listen(integer channel, string name, key id, string message)
{
if (message == command) llResetScript();
}

}

</lsl>

=Random Staggered Reset=

Script load on the sim may be a concern, if so you could use a random timer in the target script to stagger the reset as follows:

<lsl>

default
{

//insert the listen into your scripts that need to reset on command

integer channel = -1324628; //some random negative number
string command = "reset"; //could consider using a random string for the command to obscure the function

state_entry()
{
//setup and do stuff
llListen(channel, "", NULL_KEY, command);
}

listen(integer channel, string name, key id, string message)
{
if (message == command) llSetTimer(llFrand(60)); //random timer within 60 seconds
}

timer()
{
llResetScript();
}

}

</lsl>

If you need to stagger the resets, perhaps because the order the sxripts start is imortant, use different commands with appropriate pauses between start commands, such as:

<lsl>

default
{

integer channel = -1324628; //some random negative number
string command = "reset3"; //could consider using a random string for the command to obscure the function. "reset3" will trigger after 15 seconds.

state_entry()
{
//setup and do stuff
llListen(channel, "", NULL_KEY, command);
}

listen(integer channel, string name, key id, string message)
{
if (message == command) llResetScript();
}

}

</lsl>

----
Return to [[Good_Building_Practices]]

Good Building Practices

2012-10-21T20:03:31Z

Myopic Mole: /* Scripting */

== Good building practices verified by Linden Lab ==
This guide is a collection of officially verified building practices for moderate to advanced creators that result in efficient, high performance creations in Second Life. If you are new to building in Second Life, please check out the [http://community.secondlife.com/t5/English-Knowledge-Base/Build-Tools/ta-p/700039 Knowledge Base].

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Make your creations move without dragging Second Life to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
* '''[[Mesh and LOD]]''' - Mesh objects that don't crash your friends' old computer.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Tools_in_the_Second_Life_Viewer]]''' - The Pathfinding tools.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.
*'''[[Universal_Attribute_Changes_for_Pathfinding]]''' Configure objects for pathfinding in bulk
</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Debugging Tips]]''' - how to work out what your code is doing without a conventional development toolkit
* '''[[Resetting Scripts in a Large Build]]''' - strategies for resetting scripts in a large coordinated build

* '''Pathfinding'''
** '''[[Pathfinding LSL Functions]]''' - standard reference for all of the pathfinding functions.
** '''[[Modular Pathfinding Kit]]''' - code snippets designed to be plugged together to quickly build unique behaviors.
** '''[[Pathfinding Cookbook]]''' - ready made solutions for some critters.
** '''[[Holistic Pathfinding Management]]''' - Strategies for managing large numbers of pathfinding objects.

* '''Vehicles'''
** '''[[Linden Vehicle Tutorial]]''' - Vehicle scripting best practices.

</div>
</div>

<div id="box">

== Sound ==
<div style="padding: 0.5em">
Tips for adding sound effects to your builds.
* [[Environment_Sounds|Environment Sounds]]
* [[Event_Driven_Sounds|Event Driven Sounds]]
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__
= Coming Soon =
We'll be highlighting examples of great builds and answer the questions: "What next? What do I do with what I've built?" Keep checking back for more information!

;Other Topics to be added in the Near Future :
: SL Animation Tutorial Videos;
: How to retrofit an existing home to work with Pathfinding

= Resident contributions awaiting official approval =
If you'd like to contribute some of your own best practices for efficient content creation, please link to them in this section so that Linden Lab subject matter experts can verify them before they are added to the official guide.

Pathfinding Cookbook

2012-09-19T19:51:44Z

Myopic Mole:

UNDER DEVELOPMENT - INCOMPLETE

=Rezzer=

The code below is for a simple rezzer for the creatures. For a region scale rezzer system see [[Holistic_Pathfinding_Management]]

<lsl>

</lsl>

=Simple Creatures=

==Grazing Animal==
Wanders pauses and eat, wanders, repeat.

<lsl>

</lsl>

==Sentient Treasure Chest==
Treasure chest with legs. Sleeps, but runs and hides if anyone approaches.

<lsl>

</lsl>

==Fairy==
Wanders about (flying) looking for flowers, lingers by flowers, runs and hides from agents.

<lsl>

</lsl>

==Dragonfly==
Moves along designated path, lingers by designated waypoint and moves to next random waypoint.

<lsl>

</lsl>

==Snake==
Wanders about an area, includes special movement example.

<lsl>

</lsl>

==Treetop Birds==
Birds that move between treetops at random intervals.

<lsl>

</lsl>

==Vulture==
Birds that glide about on thermals

<lsl>

</lsl>

=Ecosystem Creatures=

==Hunting Animal==
Wanders looking for specific prey and pursues when prey is spotted.

<lsl>

</lsl>

==Grazing Prey Animal==
Wanders and pauses to eat, run a short distance when approached (skittish), runs further and hides from specific predator.

<lsl>

</lsl>

==Rat==
Wanders about a specified area, flees and hides if an agent approaches.

<lsl>

</lsl>

==Mount==
Build a character that can be ridden with race example.

<lsl>

</lsl>

==Dog==
Wanders about, chooses random agent, follows agent for a period, then wanders off, if no agents found sleeps.

<lsl>

</lsl>

==Cat==
Wanders about, chooses random agent, lingers by agent, then wanders again, if no agents found sleeps.

<lsl>

</lsl>

==Hopping Scarecrow==
Wanders about hopping and approaches random people, lingers and moves on.

<lsl>

</lsl>

----
Return to [[Good_Building_Practices]]

Pathfinding Cookbook

2012-08-02T21:21:36Z

Myopic Mole: restructure

UNDER DEVELOPMENT - INCOMPLETE

=Rezzer=

The code below is for a simple rezzer for the creatures. For a region scale rezzer system see...

<lsl>

</lsl>

=Simple Creatures=

==Grazing Animal==
Wanders pauses and eat, wanders, repeat.

<lsl>

</lsl>

==Sentient Treasure Chest==
Treasure chest with legs. Sleeps, but runs and hides if anyone approaches.

<lsl>

</lsl>

==Fairy==
Wanders about (flying) looking for flowers, lingers by flowers, runs and hides from agents.

<lsl>

</lsl>

==Dragonfly==
Moves along designated path, lingers by designated waypoint and moves to next random waypoint.

<lsl>

</lsl>

==Snake==
Wanders about an area, includes special movement example.

<lsl>

</lsl>

==Treetop Birds==
Birds that move between treetops at random intervals.

<lsl>

</lsl>

==Vulture==
Birds that glide about on thermals

<lsl>

</lsl>

=Ecosystem Creatures=

==Hunting Animal==
Wanders looking for specific prey and pursues when prey is spotted.

<lsl>

</lsl>

==Grazing Prey Animal==
Wanders and pauses to eat, run a short distance when approached (skittish), runs further and hides from specific predator.

<lsl>

</lsl>

==Rat==
Wanders about a specified area, flees and hides if an agent approaches.

<lsl>

</lsl>

==Mount==
Build a character that can be ridden with race example.

<lsl>

</lsl>

==Dog==
Wanders about, chooses random agent, follows agent for a period, then wanders off, if no agents found sleeps.

<lsl>

</lsl>

==Cat==
Wanders about, chooses random agent, lingers by agent, then wanders again, if no agents found sleeps.

<lsl>

</lsl>

==Hopping Scarecrow==
Wanders about hopping and approaches random people, lingers and moves on.

<lsl>

</lsl>

----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-08-02T21:04:18Z

Myopic Mole: I hadn't intended to describe brain eating, must cut back on zombie movies

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
//insert pathfinding functionality here
}

startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]); //create the character
doSomething();
}

default
{
state_entry() //standard event, called when the script resets
{
startup();
}

on_rez(integer start_param) //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0, CHARACTER_RADIUS, 0.25, CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter(CHARACTER_LENGTH, 6.5);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd([CHARACTER_CMD_STOP]);
llSleep(15.0);
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []); //resume with any desired pathfinding function
</lsl>

It's a personal preference but generally speaking state changes are easier to manage and debug.

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

===hopping/jumping===

Use llExecCharacterCmd(CHARACTER_CMD_JUMP, [height, 1.0]) to make the character hop 1m into the air. If done with a timer event while using another pathfinding command such as [[llWanderWithin]] the hop will have an arc rather than just vertical movement.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
//insert a cunning grass eating animation here
}

animateTailWiggle()
{
//insert very cute tail wiggle animation here
}

startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]); //create the character
state wander;
}

default
{
state_entry() //standard event, called when the script resets
{
startup();
}

on_rez(integer start_param) //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}

state wander
{
state_entry()
{
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
//we're near the goal, we need to switch behaviour
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();
llSetTimerEvent(15.0); //replace this with random timer, see next section
}

timer()
{
llSetTimerEvent(0);
animateTailWiggle();
state wander;
}
}
</lsl>

===Random Timers===

In the example above the rabbit eat grass for 15 seconds then wanders again, for a random period defined by how long it takes to reach it's next random wander target. This 15 second wait will make it an easy target for hunting creatures or agents (hunting game? what if this was a zombie bunny with a taste for brains? hmm, brains).

To make things less predictable use:

<lsl>
llSetTimerEvent(llFrand(15.0));
</lsl>

This generates a random grazing period of between 0s and 15s, each time it's called.

----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-07-26T23:25:45Z

Myopic Mole: /* more than one state */

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
//insert pathfinding functionality here
}

startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]); //create the character
doSomething();
}

default
{
state_entry() //standard event, called when the script resets
{
startup();
}

on_rez(integer start_param) //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0, CHARACTER_RADIUS, 0.25, CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter(CHARACTER_LENGTH, 6.5);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd([CHARACTER_CMD_STOP]);
llSleep(15.0);
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []); //resume with any desired pathfinding function
</lsl>

It's a personal preference but generally speaking state changes are easier to manage and debug.

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

===hopping/jumping===

Use llExecCharacterCmd(CHARACTER_CMD_JUMP, [height, 1.0]) to make the character hop 1m into the air. If done with a timer event while using another pathfinding command such as [[llWanderWithin]] the hop will have an arc rather than just vertical movement.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
//insert a cunning grass eating animation here
}

animateTailWiggle()
{
//insert very cute tail wiggle animation here
}

startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]); //create the character
state wander;
}

default
{
state_entry() //standard event, called when the script resets
{
startup();
}

on_rez(integer start_param) //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}

state wander
{
state_entry()
{
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
//we're near the goal, we need to switch behaviour
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();
llSetTimerEvent(15.0); //replace this with random timer, see next section
}

timer()
{
llSetTimerEvent(0);
animateTailWiggle();
state wander;
}
}
</lsl>

===Random Timers===

In the example above the rabbit eat grass for 15 seconds then wanders again, for a random period defined by how long it takes to reach it's next random wander target. This 15 second wait will make it an easy target for hunting creatures or agents (hunting game? what if this was a zombie bunny with a taste for brains? hmm, brains).

To make things less predictable use:

<lsl>
llSetTimerEvent(llFrand(15.0));
</lsl>

This generates a random graze/brain eating of between 0s and 15s, each time it's called.

----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-07-26T23:25:13Z

Myopic Mole: /* pathfinding character skeleton */

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
//insert pathfinding functionality here
}

startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]); //create the character
doSomething();
}

default
{
state_entry() //standard event, called when the script resets
{
startup();
}

on_rez(integer start_param) //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0, CHARACTER_RADIUS, 0.25, CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter(CHARACTER_LENGTH, 6.5);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd([CHARACTER_CMD_STOP]);
llSleep(15.0);
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []); //resume with any desired pathfinding function
</lsl>

It's a personal preference but generally speaking state changes are easier to manage and debug.

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

===hopping/jumping===

Use llExecCharacterCmd(CHARACTER_CMD_JUMP, [height, 1.0]) to make the character hop 1m into the air. If done with a timer event while using another pathfinding command such as [[llWanderWithin]] the hop will have an arc rather than just vertical movement.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
//insert a cunning grass eating animation here
}

animateTailWiggle()
{
//insert very cute tail wiggle animation here
}

startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]); //create the character
state wander;
}

default
{
state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}

state wander
{
state_entry()
{
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
//we're near the goal, we need to switch behaviour
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();
llSetTimerEvent(15.0); //replace this with random timer, see next section
}

timer()
{
llSetTimerEvent(0);
animateTailWiggle();
state wander;
}
}
</lsl>

===Random Timers===

In the example above the rabbit eat grass for 15 seconds then wanders again, for a random period defined by how long it takes to reach it's next random wander target. This 15 second wait will make it an easy target for hunting creatures or agents (hunting game? what if this was a zombie bunny with a taste for brains? hmm, brains).

To make things less predictable use:

<lsl>
llSetTimerEvent(llFrand(15.0));
</lsl>

This generates a random graze/brain eating of between 0s and 15s, each time it's called.

----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-07-26T21:47:10Z

Myopic Mole: fixed glaring scripting error before anyone noted ;-)

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
//insert pathfinding functionality here
}

startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]); //create the character
doSomething();
}

default
{
state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0, CHARACTER_RADIUS, 0.25, CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter(CHARACTER_LENGTH, 6.5);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd([CHARACTER_CMD_STOP]);
llSleep(15.0);
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []); //resume with any desired pathfinding function
</lsl>

It's a personal preference but generally speaking state changes are easier to manage and debug.

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

===hopping/jumping===

Use llExecCharacterCmd(CHARACTER_CMD_JUMP, [height, 1.0]) to make the character hop 1m into the air. If done with a timer event while using another pathfinding command such as [[llWanderWithin]] the hop will have an arc rather than just vertical movement.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
//insert a cunning grass eating animation here
}

animateTailWiggle()
{
//insert very cute tail wiggle animation here
}

startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]); //create the character
state wander;
}

default
{
state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}

state wander
{
state_entry()
{
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
//we're near the goal, we need to switch behaviour
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();
llSetTimerEvent(15.0); //replace this with random timer, see next section
}

timer()
{
llSetTimerEvent(0);
animateTailWiggle();
state wander;
}
}
</lsl>

===Random Timers===

In the example above the rabbit eat grass for 15 seconds then wanders again, for a random period defined by how long it takes to reach it's next random wander target. This 15 second wait will make it an easy target for hunting creatures or agents (hunting game? what if this was a zombie bunny with a taste for brains? hmm, brains).

To make things less predictable use:

<lsl>
llSetTimerEvent(llFrand(15.0));
</lsl>

This generates a random graze/brain eating of between 0s and 15s, each time it's called.

----
Return to [[Good_Building_Practices]]

Pathfinding Cookbook

2012-07-12T21:05:24Z

Myopic Mole:

UNDER DEVELOPMENT - INCOMPLETE

==Hunting Animal==
Wanders looking for specific prey and pursues when prey is spotted.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Grazing Animal==
Wanders pauses and eat, wanders, repeat.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Grazing Prey Animal==
Wanders and pauses to eat, run a short distance when approached (skittish), runs further and hides from specific predator.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Dragonfly==
Moves along designated path, lingers by designated waypoint and moves to next random waypoint.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Fairy==
Wanders about (flying) looking for flowers, lingers by flowers, runs and hides from agents.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Sentient Treasure Chest==
Treasure chest with legs. Sleeps, but runs and hides if anyone approaches.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Rat==
Wanders about a specified area, flees and hides if an agent approaches.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Snake==
Wanders about an area, includes special movement example.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Mount==
Build a character that can be ridden with race example.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Dog==
Wanders about, chooses random agent, follows agent for a period, then wanders off, if no agents found sleeps.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Cat==
Wanders about, chooses random agent, lingers by agent, then wanders again, if no agents found sleeps.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Hopping Scarecrow==
Wanders about hopping and approaches random people, lingers and moves on.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Treetop Birds==
Birds that move between treetops at random intervals.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Vulture==
Birds that glide about on thermals

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-07-09T14:27:20Z

Myopic Mole: /* Random Timers */

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
//insert pathfinding functionality here
}

default
{
startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]); //create the character
doSomething();
}

state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0, CHARACTER_RADIUS, 0.25, CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter(CHARACTER_LENGTH, 6.5);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd([CHARACTER_CMD_STOP]);
llSleep(15.0);
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []); //resume with any desired pathfinding function
</lsl>

It's a personal preference but generally speaking state changes are easier to manage and debug.

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

===hopping/jumping===

Use llExecCharacterCmd(CHARACTER_CMD_JUMP, [height, 1.0]) to make the character hop 1m into the air. If done with a timer event while using another pathfinding command such as [[llWanderWithin]] the hop will have an arc rather than just vertical movement.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
//insert a cunning grass eating animation here
}

animateTailWiggle()
{
//insert very cute tail wiggle animation here
}

default
{
startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]); //create the character
state wander;
}

state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}

state wander
{
state_entry()
{
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
//we're near the goal, we need to switch behaviour
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();
llSetTimerEvent(15.0); //replace this with random timer, see next section
}

timer()
{
llSetTimerEvent(0);
animateTailWiggle();
state wander;
}
}
</lsl>

===Random Timers===

In the example above the rabbit eat grass for 15 seconds then wanders again, for a random period defined by how long it takes to reach it's next random wander target. This 15 second wait will make it an easy target for hunting creatures or agents (hunting game? what if this was a zombie bunny with a taste for brains? hmm, brains).

To make things less predictable use:

<lsl>
llSetTimerEvent(llFrand(15.0));
</lsl>

This generates a random graze/brain eating of between 0s and 15s, each time it's called.

----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-07-09T14:25:06Z

Myopic Mole: added random timer section

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
//insert pathfinding functionality here
}

default
{
startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]); //create the character
doSomething();
}

state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0, CHARACTER_RADIUS, 0.25, CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter(CHARACTER_LENGTH, 6.5);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd([CHARACTER_CMD_STOP]);
llSleep(15.0);
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []); //resume with any desired pathfinding function
</lsl>

It's a personal preference but generally speaking state changes are easier to manage and debug.

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

===hopping/jumping===

Use llExecCharacterCmd(CHARACTER_CMD_JUMP, [height, 1.0]) to make the character hop 1m into the air. If done with a timer event while using another pathfinding command such as [[llWanderWithin]] the hop will have an arc rather than just vertical movement.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
//insert a cunning grass eating animation here
}

animateTailWiggle()
{
//insert very cute tail wiggle animation here
}

default
{
startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]); //create the character
state wander;
}

state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}

state wander
{
state_entry()
{
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
//we're near the goal, we need to switch behaviour
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();
llSetTimerEvent(15.0); //replace this with random timer, see next section
}

timer()
{
llSetTimerEvent(0);
animateTailWiggle();
state wander;
}
}
</lsl>

===Random Timers===

In the example above the rabbit eat grass for 15 seconds then wanders again, for a random period defined by how long it takes to reach it's next random wander target. This 15 second wait will make it an easy target for hunting creatures or agents (hunting game? what is it was a zombie bunny with a taste for brains?).

To make things less predictable use:

<lsl>
llSetTimerEvent(llFrand(15.0));
</lsl>

This generates a random graze/brain eating of between 0s and 15s, each time it's called.

----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-07-09T14:17:42Z

Myopic Mole: removed undesirable double line space

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
//insert pathfinding functionality here
}

default
{
startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]); //create the character
doSomething();
}

state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0, CHARACTER_RADIUS, 0.25, CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter(CHARACTER_LENGTH, 6.5);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd([CHARACTER_CMD_STOP]);
llSleep(15.0);
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []); //resume with any desired pathfinding function
</lsl>

It's a personal preference but generally speaking state changes are easier to manage and debug.

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

===hopping/jumping===

Use llExecCharacterCmd(CHARACTER_CMD_JUMP, [height, 1.0]) to make the character hop 1m into the air. If done with a timer event while using another pathfinding command such as [[llWanderWithin]] the hop will have an arc rather than just vertical movement.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
//insert a cunning grass eating animation here
}

animateTailWiggle()
{
//insert very cute tail wiggle animation here
}

default
{
startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]); //create the character
state wander;
}

state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}

state wander
{
state_entry()
{
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
//we're near the goal, we need to switch behaviour
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();
llSetTimerEvent(15.0);
}

timer()
{
llSetTimerEvent(0);
animateTailWiggle();
state wander;
}
}
</lsl>

----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-07-09T14:15:48Z

Myopic Mole: added hopping/jumping

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
//insert pathfinding functionality here
}

default
{
startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]); //create the character
doSomething();
}

state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0, CHARACTER_RADIUS, 0.25, CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter(CHARACTER_LENGTH, 6.5);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd([CHARACTER_CMD_STOP]);
llSleep(15.0);
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []); //resume with any desired pathfinding function
</lsl>

It's a personal preference but generally speaking state changes are easier to manage and debug.

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

===hopping/jumping===

Use llExecCharacterCmd(CHARACTER_CMD_JUMP, [height, 1.0]) to make the character hop 1m into the air. If done with a timer event while using another pathfinding command such as [[llWanderWithin]] the hop will have an arc rather than just vertical movement.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
//insert a cunning grass eating animation here
}

animateTailWiggle()
{
//insert very cute tail wiggle animation here
}

default
{
startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]); //create the character
state wander;
}

state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}

state wander
{
state_entry()
{
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
//we're near the goal, we need to switch behaviour
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();
llSetTimerEvent(15.0);
}

timer()
{
llSetTimerEvent(0);
animateTailWiggle();
state wander;
}
}
</lsl>

----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-07-09T05:59:39Z

Myopic Mole: major content addition

There is a lot of options for how to create pathfinding creatures. It’s best to start by having an idea of what you want to create, either a real world analogue like a horse or a dog, or something mythical such as a ghost or fairy.

'''things that don’t work (at present)''':
1. 3D spatial movement - for example underwater free movement or aerial free movement
2. mixing physics and pathfinding (for instance using llApplyImpulse with a pathfinding character)

=Quick Guide=

> object + pathfinding character skeleton + behavioural tropes = autonomous pathfinding creature

This guide gives quick guidance of how to create specific behavioural tropes (commonly found autonomous characteristics) and doesn't go into detail about individual functions - see [[Pathfinding LSL Functions]] for more details.

=Components=

==pathfinding character skeleton==

<lsl>
doSomething()
{
//insert pathfinding functionality here
}

default
{
startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]); //create the character
doSomething();
}

state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}
</lsl>

==Behavioural Tropes==

===flying/hovering===
3D spatial free flight is at present unavailable. We can however fake it but one of the following methods:

# create a small object with a tall root prim - not recommended, causes excessive collisions
# create a small object and create a large character envelope - recommended

The example below creates a character with a 1.5m tall and 0.25m wide envelope. If the object itself if 0.25 it will appear to be "flying", or, more accurately, hovering.

<lsl>
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0, CHARACTER_RADIUS, 0.25, CHARACTER_LENGTH, 1.5]);
</lsl>

In order to further the illusion of flying we can do a number of things. If the creature is something that works at near ground height, such as a hummingbird or dragonfly just use one of the movement tropes, such as wandering.

If you want the creature to fly higher than the 10.0m maximum character height (which will give a centre of mass height of 5.0m), we can use a platform. If you want a parrot to fly between trees place a prim or series of prims that stretch between them and use something like [[llPatrolPoints]] or [[llWanderWithin]]. Even if you use a series of narrow pathways the pathfinding will find a way to valid targets.

We can make a really nice effect by using a mesh surface with an undulating form - the creature will follow the dips and rises giving the appearance of varying flight.

For ground hugging creatures we can something similar that looks natural for hovering creatures by dynamically changing the envelope size of the creature by calling [[llUpdateCharacter]], as below. Call this function repeatedly with different values and the character will change the level it hovers at.

<lsl>
llUpdateCharacter(CHARACTER_LENGTH, 6.5);
</lsl>

===fleeing===

There are two distinct behaviours we can exploit. If we wanted a character to run from a specific point such as an explosion we can use [[llFleeFrom]]. If we want to run from a specific object or agent (avatar) use [[llEvade]]

===hiding===

Part of [[llEvade]] is hiding (blocked line of sight) from the agent/object the character is fleeing from. See [[llEvade]] for more details.

===move-wait-repeat===

By responding to path events we can create varying behaviour. All pathfinding functions are moving to specific targe coordinates, whether determined randomly by something like [[llWanderWithin]], specific as in [[llPatrolPoints]] or even [[llPursue]].

Have a look at [[Path update]] for guidance, and see the example script in the multiple states discussion at the end of this article.

===chase===

Use [[llPursue]] and specify a target object or avatar.

===hunt===

Use a sensor of some description, such as [[llSensorRepeat]] or some sort of collision detection such [[llVolumeDetect]]

===wait===

To make a character pause you can use a state change with a new event trigger making the character active again, or simply use something like:

<lsl>
llExecCharacterCmd([CHARACTER_CMD_STOP]);
llSleep(15.0);
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []); //resume with any desired pathfinding function
</lsl>

It's a personal preference but generally speaking state changes are easier to manage and debug.

===wandering===

Use [[llWanderWithin]] to specify an area to wander within.

==Optional Extras==

To add to immersion it's worth adding some extras. If desired add...

===animation===
see [[Animation Streamlined]] for tips

===sounds===
see [[Creature Sounds]] and [[Event Driven Sounds]]

===more than one state===

States are an excellent way of managing pathfinding creatures, but note however that pathfinding behaviour survives state changes - it's simple a simpler way of managing a status than using a variable. See the example below, which simulates a rabbit grazing.

<lsl>
animateGrassEating()
{
//insert a cunning grass eating animation here
}

animateTailWiggle()
{
//insert very cute tail wiggle animation here
}

default
{
startup() //called as necessary from events such as script reset or rezzing
{
llCreateCharacter([CHARACTER_MAX_SPEED, 2, CHARACTER_DESIRED_SPEED, 1.0]); //create the character
state wander;
}

state_entry() //standard event, called when the script resets
{
startup();
}

on_rez() //good to include so it scuttles off when rezzed from inventory or a rezzer
{
startup();
}
}

state wander
{
state_entry()
{
llWanderWithin(llGetPos(), <10.0, 10.0, 5.0>, []);
}

path_update(integer type, list reserved)
{
if (type == PU_SLOWDOWN_DISTANCE_REACHED)
{
//we're near the goal, we need to switch behaviour
llExecCharacterCmd([CHARACTER_CMD_SMOOTH_STOP]);
state graze;
}
}
}

state graze
{
state_entry()
{
animateGrassEating();
llSetTimerEvent(15.0);
}

timer()
{
llSetTimerEvent(0);
animateTailWiggle();
state wander;
}
}
</lsl>

----
Return to [[Good_Building_Practices]]

Good Building Practices

2012-07-09T02:28:19Z

Myopic Mole: added link to standard Pathfinding_LSL_Functions

== Welcome to Good Building Practices ==
This page is all about how to be creative and efficient at the same time!

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Let's make Second Life move, without dragging it to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Tools_in_the_Second_Life_Viewer]]''' - The Pathfinding tools.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.

</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Debugging Tips]]''' - how to work out what your code is doing without a conventional development toolkit

* '''Pathfinding'''
** '''[[Pathfinding LSL Functions]]''' - standard reference for all of the pathfinding functions.
** '''[[Modular Pathfinding Kit]]''' - code snippets designed to be plugged together to quickly build unique behaviors.
** '''[[Pathfinding Cookbook]]''' - ready made solutions for some critters.
** '''[[Holistic Pathfinding Management]]''' - Strategies for managing large numbers of pathfinding objects.

* '''Sounds''' - tips for adding efficient sound effects to your builds
** [[Environmental|Environment Sounds]]
** [[Creatures|Creature Sounds]]
** [[Event Driven|Event Driven Sounds]]
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__

Modular Pathfinding Kit

2012-07-09T01:42:00Z

Myopic Mole:

Modular Pathfinding Kit

2012-07-09T01:40:52Z

Myopic Mole:

Modular Pathfinding Kit

2012-07-09T01:36:11Z

Myopic Mole: added physics exception

Modular Pathfinding Kit

2012-07-09T01:26:49Z

Myopic Mole:

Category:LSL User-Defined Functions

2012-07-09T01:08:48Z

Myopic Mole:

{{LSL Header|ml=3}}{{LSLC|Keywords}}{{LSLC|Flow Control}}{{LSLC|}}
==User-Defined Functions==
This category contains custom pre-defined function contributions from the LSL community to extend the abilities of LSL.
To add a wiki page to this category, include a link to this page. You may use the [[:Template:LSL_Function/docs|Template:LSL_Function]] (with "mode" set to user) to create the page to be added here.

Go to the {{LSLGC|Functions}} page to view the built-in functions.

=== About User-Defined Functions ===
LSL allows user-defined functions. The syntax is very simple:

<lsl>

return_type variable_name(par1type par1name, par2type par2name,...)
{
function_statements;
.
.
.
return value_of_return_type;
}
</lsl>

There are no "function" or "def" keywords or function type/inheritance specifiers needed. I have not yet discovered what limits (if any) exist on the length or composition of the parameter list. Multiple types can be used, as shown in the example below. A list can be returned, so a single function can return a list with several values in it. User-defined functions will help keep scripts compact and readable, and allow rudimentary code reuse. The [[LSL_Style_Guide]] suggests that user-defined functions should be placed before the default state definition and after user-defined variables. Placing user-defined functions after the first state will result in a Syntax Error.

examples can be found linked below

Holistic Pathfinding Management

2012-07-09T00:57:48Z

Myopic Mole:

''coming soon''

----
Return to [[Good_Building_Practices]]

Good Building Practices

2012-07-09T00:55:52Z

Myopic Mole: /* Scripting */ minor fix to layout

== Welcome to Good Building Practices ==
This page is all about how to be creative and efficient at the same time!

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Let's make Second Life move, without dragging it to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Tools_in_the_Second_Life_Viewer]]''' - The Pathfinding tools.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.

</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Debugging Tips]]''' - how to work out what your code is doing without a conventional development toolkit

* '''Pathfinding'''
** '''[[Modular Pathfinding Kit]]''' - code snippets designed to be plugged together to quickly build unique behaviors.
** '''[[Pathfinding Cookbook]]''' - ready made solutions for some critters
** '''[[Holistic Pathfinding Management]]''' - Strategies for managing large numbers of pathfinding objects.

* '''Sounds''' - tips for adding efficient sound effects to your builds
** [[Environmental|Environment Sounds]]
** [[Creatures|Creature Sounds]]
** [[Event Driven|Event Driven Sounds]]
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__

Good Building Practices

2012-07-09T00:55:02Z

Myopic Mole: Added section for sounds scripting

== Welcome to Good Building Practices ==
This page is all about how to be creative and efficient at the same time!

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Let's make Second Life move, without dragging it to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Tools_in_the_Second_Life_Viewer]]''' - The Pathfinding tools.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.

</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Debugging Tips]]''' - how to work out what your code is doing without a conventional development toolkit

* '''Pathfinding'''
** '''[[Modular Pathfinding Kit]]''' - code snippets designed to be plugged together to quickly build unique behaviors.
** '''[[Pathfinding Cookbook]]''' - ready made solutions for some critters
** '''[[Holistic Pathfinding Management]]''' - Strategies for managing large numbers of pathfinding objects.

* '''Sounds'''
Tips for adding efficient sound effects to your builds
** [[Environmental|Environment Sounds]]
** [[Creatures|Creature Sounds]]
** [[Event Driven|Event Driven Sounds]]
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__

Holistic Pathfinding Management

2012-07-08T21:33:15Z

Myopic Mole: Created page with " ---- Return to Good_Building_Practices"

----
Return to [[Good_Building_Practices]]

Pathfinding Cookbook

2012-07-08T21:33:00Z

Myopic Mole:

==Hunting Animal==
Wanders looking for specific prey and pursues when prey is spotted.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Grazing Animal==
Wanders pauses and eat, wanders, repeat.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Grazing Prey Animal==
Wanders and pauses to eat, run a short distance when approached (skittish), runs further and hides from specific predator.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Dragonfly==
Moves along designated path, lingers by designated waypoint and moves to next random waypoint.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Fairy==
Wanders about (flying) looking for flowers, lingers by flowers, runs and hides from agents.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Sentient Treasure Chest==
Treasure chest with legs. Sleeps, but runs and hides if anyone approaches.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Rat==
Wanders about a specified area, flees and hides if an agent approaches.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Snake==
Wanders about an area, includes special movement example.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Mount==
Build a character that can be ridden with race example.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Dog==
Wanders about, chooses random agent, follows agent for a period, then wanders off, if no agents found sleeps.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Cat==
Wanders about, chooses random agent, lingers by agent, then wanders again, if no agents found sleeps.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Hopping Scarecrow==
Wanders about hopping and approaches random people, lingers and moves on.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Treetop Birds==
Birds that move between treetops at random intervals.

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

==Vulture==
Birds that glide about on thermals

<lsl>
default
{
state_entry()
{
llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACTER_DESIRED_SPEED, 15.0]);
//script being tested/refined, coming soon
}
}
</lsl>

----
Return to [[Good_Building_Practices]]

Modular Pathfinding Kit

2012-07-08T21:32:40Z

Myopic Mole:

Pathfinding Cookbook

2012-07-08T15:54:20Z

Myopic Mole: Created page with "==Hunting Animal== Wanders looking for specific prey and pursues when prey is spotted. <lsl> default { state_entry() { llCreateCharacter([CHARACTER_MAX_SPEED, 25, CHARACT…"

Modular Pathfinding Kit

2012-07-08T15:06:33Z

Myopic Mole:

Good Building Practices

2012-06-24T21:42:23Z

Myopic Mole: /* Scripting */

== Welcome to Good Building Practices ==
This page is all about how to be creative and efficient at the same time!

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Let's make Second Life move, without dragging it to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Tools_in_the_Second_Life_Viewer]]''' - The Pathfinding tools.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.

</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Debugging Tips]]''' - how to work out what your code is doing without a conventional development toolkit
* '''Pathfinding'''
** '''[[Modular Pathfinding Kit]]''' - code snippets designed to be plugged together to quickly build unique behaviours.
** '''[[Holistic Pathfinding Management]]''' - Strategies for managing large numbers of pathfinding objects.
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__

Good Building Practices

2012-06-24T14:56:26Z

Myopic Mole: /* Scripting */

== Welcome to Good Building Practices ==
This page is all about how to be creative and efficient at the same time!

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Let's make Second Life move, without dragging it to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.

</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Debugging Tips]]''' - how to work out what your code is doing without a conventional development toolkit
* '''[[Scripting for Pathfinding]]''' - Pathfinding scripting help.
** '''[[Modular Pathfinding Kit]]''' - code snippets designed to be plugged together to quickly build unique behaviours.
** '''[[Holistic Pathfinding Management]]''' - Strategies for managing large numbers of pathfinding objects.
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__

Debugging Tips

2012-06-23T18:55:45Z

Myopic Mole: corrected spelling of Mjölnir ;-)

One of the hardest things with scripting anything non trivial in LSL, especially if you come from an software development environment where you're used to combined editor and debugger, is the seeming inability to debug LSL code.

==Simple Example==

The solution is to define a simple debugging utility function as follows.

<lsl>
notify(string msg)
{
llOwnerSay(msg);
}
</lsl>

then whenever we need to check the value of a variable simple call

<lsl>
notify("your debug message here");
</lsl>

don't forget to typecast as necessary, for example:

<lsl>
integer a = 3;
integer b = 4;
integer result = a * b;
notify((string)result);
</lsl>

This allows us to reuse the same function for reporting anything to the owner of the object, rather than using public chat. The advantage to doing this is we can comment out a single line in the code function as follows to disable all debugging, or we can search and replace and instance of "notify" with "//notify".

<lsl>
notify(string msg)
{
//llOwnerSay(msg);
}
</lsl>

if you're working with list use something along the lines of:

notify(llList2String(listName, integerIndex)); // notification contains one list element
or
notify(llDumpList2String(listName, ",")); notification contains entire list as a string

==Error Reporting and Debugging==
We can use the same concept for tracking issues after the code is complete as follows

<lsl>
notify(string genus, string msg)
{
key creator = "a822ff2b-ff02-461d-b45d-dcd10a2de0c2";
//genus = "off" //uncoment this line to turn notifications off
if (genus == "dbg")
{
llInstantMessage(creator, "DEBUG: " + msg); //coment out this line to turn off debugging
}
else if (genus == "err")
{
llOwnerSay("ERROR: " + msg);
llInstantMessage(creator, "ERROR: " + msg + " in object " + llGetObjectName() + " that belongs to " + llKey2Name(llGetOwner()) + " in region " + llGetRegionName());
}
else if (genus == "info")
{
llOwnerSay(msg); //no prepend because it's a normal message
}
else
{
//do nothing, notifications were turned off
}
}
</lsl>

We're doing a number of things here: handling different kids of messages, informational for normal running, error reporting to the owner and creator and debug messages. To turn off debug simply comment out the debug line as shown in the code, and uncomment the genus="off" line to disable all notifications.

We're using llOwner for the current owner and llInstantMessage for contacting the script creator that will continue to work after ownership has passed - you just have insert your own key at the top.

Other mechanisms that could be used include llEmail or llHTTPRequest to post a message to an external logging system perhaps.

You define your own custome message types and communicate using the most appropriate method.

==More Reuse==
We can extend the reuse even further by making this a discreet script on it's own within the object as follows:

<lsl>
notify(string genus, string msg)
{
key creator = "a822ff2b-ff02-461d-b45d-dcd10a2de0c2";
//genus = "off" //uncoment this line to turn notifications off
if (genus == "dbg")
{
llInstantMessage(creator, "DEBUG: " + msg); //coment out this line to turn off debugging
}
else if (genus == "err")
{
llOwnerSay("ERROR: " + msg);
llInstantMessage(creator, "ERROR: " + msg + " in object " + llGetObjectName() + " that belongs to " + llKey2Name(llGetOwner()) + " in region " + llGetRegionName());
}
else if (genus == "info")
{
llOwnerSay(msg); //no prepend because it's a normal message
}
else
{
//do nothing, notifications were turned off
}
}

default
{
state_entry()
{
notify("info", "notification system ready");
}
link_message(integer source, integer num, string str, key id)
{
notify(str, key); //we're using the key as a second string parameter
}
}
</lsl>

To send a notification you simply use in your implementation:

<lsl>
default
{
touch_start(integer c)
{
string msg = llKey2Name(llDetectedKey(0)) + " attempted to steal Mjölnir!";
llMessageLinked(LINK_SET, 0, "info", msg);
//this may seem odd but it's valid to use the key paramter of llMessageLinked as a second string passing facility if not actually used for a key
}
}
</lsl>

Debugging Tips

2012-06-23T18:52:35Z

Myopic Mole: added instructions on how to use the discreet debug script that got chopped off the end

One of the hardest things with scripting anything non trivial in LSL, especially if you come from an software development environment where you're used to combined editor and debugger, is the seeming inability to debug LSL code.

==Simple Example==

The solution is to define a simple debugging utility function as follows.

<lsl>
notify(string msg)
{
llOwnerSay(msg);
}
</lsl>

then whenever we need to check the value of a variable simple call

<lsl>
notify("your debug message here");
</lsl>

don't forget to typecast as necessary, for example:

<lsl>
integer a = 3;
integer b = 4;
integer result = a * b;
notify((string)result);
</lsl>

This allows us to reuse the same function for reporting anything to the owner of the object, rather than using public chat. The advantage to doing this is we can comment out a single line in the code function as follows to disable all debugging, or we can search and replace and instance of "notify" with "//notify".

<lsl>
notify(string msg)
{
//llOwnerSay(msg);
}
</lsl>

if you're working with list use something along the lines of:

notify(llList2String(listName, integerIndex)); // notification contains one list element
or
notify(llDumpList2String(listName, ",")); notification contains entire list as a string

==Error Reporting and Debugging==
We can use the same concept for tracking issues after the code is complete as follows

<lsl>
notify(string genus, string msg)
{
key creator = "a822ff2b-ff02-461d-b45d-dcd10a2de0c2";
//genus = "off" //uncoment this line to turn notifications off
if (genus == "dbg")
{
llInstantMessage(creator, "DEBUG: " + msg); //coment out this line to turn off debugging
}
else if (genus == "err")
{
llOwnerSay("ERROR: " + msg);
llInstantMessage(creator, "ERROR: " + msg + " in object " + llGetObjectName() + " that belongs to " + llKey2Name(llGetOwner()) + " in region " + llGetRegionName());
}
else if (genus == "info")
{
llOwnerSay(msg); //no prepend because it's a normal message
}
else
{
//do nothing, notifications were turned off
}
}
</lsl>

We're doing a number of things here: handling different kids of messages, informational for normal running, error reporting to the owner and creator and debug messages. To turn off debug simply comment out the debug line as shown in the code, and uncomment the genus="off" line to disable all notifications.

We're using llOwner for the current owner and llInstantMessage for contacting the script creator that will continue to work after ownership has passed - you just have insert your own key at the top.

Other mechanisms that could be used include llEmail or llHTTPRequest to post a message to an external logging system perhaps.

You define your own custome message types and communicate using the most appropriate method.

==More Reuse==
We can extend the reuse even further by making this a discreet script on it's own within the object as follows:

<lsl>
notify(string genus, string msg)
{
key creator = "a822ff2b-ff02-461d-b45d-dcd10a2de0c2";
//genus = "off" //uncoment this line to turn notifications off
if (genus == "dbg")
{
llInstantMessage(creator, "DEBUG: " + msg); //coment out this line to turn off debugging
}
else if (genus == "err")
{
llOwnerSay("ERROR: " + msg);
llInstantMessage(creator, "ERROR: " + msg + " in object " + llGetObjectName() + " that belongs to " + llKey2Name(llGetOwner()) + " in region " + llGetRegionName());
}
else if (genus == "info")
{
llOwnerSay(msg); //no prepend because it's a normal message
}
else
{
//do nothing, notifications were turned off
}
}

default
{
state_entry()
{
notify("info", "notification system ready");
}
link_message(integer source, integer num, string str, key id)
{
notify(str, key); //we're using the key as a second string parameter
}
}
</lsl>

To send a notification you simply use in your implementation:

<lsl>
default
{
touch_start(integer c)
{
string msg = llKey2Name(llDetectedKey(0)) + " attempted to steal Mjolnir!";
llMessageLinked(LINK_SET, 0, "info", msg);
//this may seem odd but it's valid to use the key paramter of llMessageLinked as a second string passing facility if not actually used for a key
}
}
</lsl>

Debugging Tips

2012-06-23T18:34:12Z

Myopic Mole: added several line comments

One of the hardest things with scripting anything non trivial in LSL, especially if you come from an software development environment where you're used to combined editor and debugger, is the seeming inability to debug LSL code.

==Simple Example==

The solution is to define a simple debugging utility function as follows.

<lsl>
notify(string msg)
{
llOwnerSay(msg);
}
</lsl>

then whenever we need to check the value of a variable simple call

<lsl>
notify("your debug message here");
</lsl>

don't forget to typecast as necessary, for example:

<lsl>
integer a = 3;
integer b = 4;
integer result = a * b;
notify((string)result);
</lsl>

This allows us to reuse the same function for reporting anything to the owner of the object, rather than using public chat. The advantage to doing this is we can comment out a single line in the code function as follows to disable all debugging, or we can search and replace and instance of "notify" with "//notify".

<lsl>
notify(string msg)
{
//llOwnerSay(msg);
}
</lsl>

if you're working with list use something along the lines of:

notify(llList2String(listName, integerIndex)); // notification contains one list element
or
notify(llDumpList2String(listName, ",")); notification contains entire list as a string

==Error Reporting and Debugging==
We can use the same concept for tracking issues after the code is complete as follows

<lsl>
notify(string genus, string msg)
{
key creator = "a822ff2b-ff02-461d-b45d-dcd10a2de0c2";
//genus = "off" //uncoment this line to turn notifications off
if (genus == "dbg")
{
llInstantMessage(creator, "DEBUG: " + msg); //coment out this line to turn off debugging
}
else if (genus == "err")
{
llOwnerSay("ERROR: " + msg);
llInstantMessage(creator, "ERROR: " + msg + " in object " + llGetObjectName() + " that belongs to " + llKey2Name(llGetOwner()) + " in region " + llGetRegionName());
}
else if (genus == "info")
{
llOwnerSay(msg); //no prepend because it's a normal message
}
else
{
//do nothing, notifications were turned off
}
}
</lsl>

We're doing a number of things here: handling different kids of messages, informational for normal running, error reporting to the owner and creator and debug messages. To turn off debug simply comment out the debug line as shown in the code, and uncomment the genus="off" line to disable all notifications.

We're using llOwner for the current owner and llInstantMessage for contacting the script creator that will continue to work after ownership has passed - you just have insert your own key at the top.

Other mechanisms that could be used include llEmail or llHTTPRequest to post a message to an external logging system perhaps.

You define your own custome message types and communicate using the most appropriate method.

==More Reuse==
We can extend the reuse even further by making this a discreet script on it's own within the object as follows:

<lsl>
notify(string genus, string msg)
{
key creator = "a822ff2b-ff02-461d-b45d-dcd10a2de0c2";
//genus = "off" //uncoment this line to turn notifications off
if (genus == "dbg")
{
llInstantMessage(creator, "DEBUG: " + msg); //coment out this line to turn off debugging
}
else if (genus == "err")
{
llOwnerSay("ERROR: " + msg);
llInstantMessage(creator, "ERROR: " + msg + " in object " + llGetObjectName() + " that belongs to " + llKey2Name(llGetOwner()) + " in region " + llGetRegionName());
}
else if (genus == "info")
{
llOwnerSay(msg); //no prepend because it's a normal message
}
else
{
//do nothing, notifications were turned off
}
}

default
{
state_entry()
{
notify("info", "notification system ready");
}
link_message(integer source, integer num, string str, key id)
{
notify(llString2CSV(str, 0), llString2CSV(str, 1));
}
}
</lsl>

Debugging Tips

2012-06-23T18:29:38Z

Myopic Mole: Added discreet script dection

One of the hardest things with scripting anything non trivial in LSL, especially if you come from an software development environment where you're used to combined editor and debugger, is the seeming inability to debug LSL code.

==Simple Example==

The solution is to define a simple debugging utility function as follows.

<lsl>
notify(string msg)
{
llOwnerSay(msg);
}
</lsl>

then whenever we need to check the value of a variable simple call

<lsl>
notify("your debug message here");
</lsl>

don't forget to typecast as necessary, for example:

<lsl>
integer a = 3;
integer b = 4;
integer result = a * b;
notify((string)result);
</lsl>

This allows us to reuse the same function for reporting anything to the owner of the object, rather than using public chat. The advantage to doing this is we can comment out a single line in the code function as follows to disable all debugging, or we can search and replace and instance of "notify" with "//notify".

<lsl>
notify(string msg)
{
//llOwnerSay(msg);
}
</lsl>

if you're working with list use something along the lines of:

notify(llList2String(listName, integerIndex)); // notification contains one list element
or
notify(llDumpList2String(listName, ",")); notification contains entire list as a string

==Error Reporting and Debugging==
We can use the same concept for tracking issues after the code is complete as follows

<lsl>
notify(string genus, string msg)
{
key creator = "a822ff2b-ff02-461d-b45d-dcd10a2de0c2";
//genus = "off" //uncoment this line to turn notifications off
if (genus == "dbg")
{
llInstantMessage(creator, "DEBUG: " + msg);
}
else if (genus == "err")
{
llOwnerSay("ERROR: " + msg);
llInstantMessage(creator, "ERROR: " + msg + " in object " + llGetObjectName() + " that belongs to " + llKey2Name(llGetOwner()) + " in region " + llGetRegionName());
}
else if (genus == "info")
{
llOwnerSay(msg);
}
else
{
//do nothing, notifications were turned off
}
}
</lsl>

We're doing a number of things here: handling different kids of messages, informational for normal running, error reporting to the owner and creator and debug messages. To turn off debug simply comment out the debug line as shown in the code, and uncomment the genus="off" line to disable all notifications.

We're using llOwner for the current owner and llInstantMessage for contacting the script creator that will continue to work after ownership has passed - you just have insert your own key at the top.

Other mechanisms that could be used include llEmail or llHTTPRequest to post a message to an external logging system perhaps.

You define your own custome message types and communicate using the most appropriate method.

==More Reuse==
We can extend the reuse even further by making this a discreet script on it's own within the object as follows:

<lsl>
notify(string genus, string msg)
{
key creator = "a822ff2b-ff02-461d-b45d-dcd10a2de0c2";
//genus = "off" //uncoment this line to turn notifications off
if (genus == "dbg")
{
llInstantMessage(creator, "DEBUG: " + msg);
}
else if (genus == "err")
{
llOwnerSay("ERROR: " + msg);
llInstantMessage(creator, "ERROR: " + msg + " in object " + llGetObjectName() + " that belongs to " + llKey2Name(llGetOwner()) + " in region " + llGetRegionName());
}
else if (genus == "info")
{
llOwnerSay(msg);
}
else
{
//do nothing, notifications were turned off
}
}

default
{
state_entry()
{
notify("info", "notification system ready");
}
link_message(integer source, integer num, string str, key id)
{
notify(llString2CSV(str, 0), llString2CSV(str, 1));
}
}
</lsl>

Debugging Tips

2012-06-23T18:17:09Z

Myopic Mole: Created page with "One of the hardest things with scripting anything non trivial in LSL, especially if you come from an software development environment where you're used to combined editor and deb…"

Good Building Practices

2012-06-23T09:50:40Z

Myopic Mole: /* Scripting */

== Welcome to Good Building Practices ==
This page is all about how to be creative and efficient at the same time!

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Let's make Second Life move, without dragging it to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.

</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Smart Scripting]]''' - No lag scripting tips.
** '''[[Debugging Tips]]''' - how to work out what your code is doing without a conventional development toolkit
* '''[[Scripting for Pathfinding]]''' - Pathfinding scripting help.
** '''[[Modular Pathfinding Kit]]''' - code snippets designed to be plugged together to quickly build unique behaviours.
** '''[[Holistic Pathfinding Management]]''' - Strategies for managing large numbers of pathfinding objects.
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__

Good Building Practices

2012-06-23T09:50:22Z

Myopic Mole: /* Scripting */

== Welcome to Good Building Practices ==
This page is all about how to be creative and efficient at the same time!

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Let's make Second Life move, without dragging it to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.

</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Smart Scripting]]''' - No lag scripting tips.
** '''[[Debugging Tips]]''' - how to work out what your code is doing without a development toolkit
* '''[[Scripting for Pathfinding]]''' - Pathfinding scripting help.
** '''[[Modular Pathfinding Kit]]''' - code snippets designed to be plugged together to quickly build unique behaviours.
** '''[[Holistic Pathfinding Management]]''' - Strategies for managing large numbers of pathfinding objects.
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__

Good Building Practices

2012-06-23T09:46:06Z

Myopic Mole: /* Scripting */

== Welcome to Good Building Practices ==
This page is all about how to be creative and efficient at the same time!

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Let's make Second Life move, without dragging it to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.

</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Smart Scripting]]''' - No lag scripting tips.
** '''[[Debugging Tips]]''' - how to work out what your code is doing without a conventional IDE
* '''[[Scripting for Pathfinding]]''' - Pathfinding scripting help.
** '''[[Modular Pathfinding Kit]]''' - code snippets designed to be plugged together to quickly build unique behaviours.
** '''[[Holistic Pathfinding Management]]''' - Strategies for managing large numbers of pathfinding objects.
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__

Good Building Practices

2012-06-23T09:43:29Z

Myopic Mole: /* Scripting */

== Welcome to Good Building Practices ==
This page is all about how to be creative and efficient at the same time!

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Let's make Second Life move, without dragging it to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.

</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Smart Scripting]]''' - No lag scripting tips.
* '''[[Debugging Tips]]''' - how to work out what your code is doing without a conventional IDE
* '''[[Holistic Pathfinding Management]]''' - Strategies for managing large numbers of pathfinding objects.
* '''[[Scripting for Pathfinding]]''' - Pathfinding scripting help.
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__

Good Building Practices

2012-06-23T09:40:18Z

Myopic Mole: /* Scripting */

== Welcome to Good Building Practices ==
This page is all about how to be creative and efficient at the same time!

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Let's make Second Life move, without dragging it to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.

</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Smart Scripting]]''' - No lag scripting tips.
* '''[[Debugging Tips]]''' - how to work out what your code is doing without a conventional IDE
* '''[[Scripting for Pathfinding]]''' - Pathfinding scripting help.
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__

Good Building Practices

2012-06-23T09:39:41Z

Myopic Mole: /* Scripting */

== Welcome to Good Building Practices ==
This page is all about how to be creative and efficient at the same time!

{| width="100%"
|-
|valign="top"|
<div id="box">

== Animation ==
<div style="padding: 0.5em">
* '''[[Animation Streamlined]]''' - Let's make Second Life move, without dragging it to a crawl!
</div>
</div>

<div id="box">

== Mesh ==
<div style="padding: 0.5em">
* '''[[Making Mesh Physics]]''' - Why and How.
* '''[[Making Mesh for Pathfinding]]''' - Pathfinding friendly mesh.
</div>
</div>

<div id="box">

== Pathfinding ==
<div style="padding: 0.5em">
*'''[[Pathfinding_Overview]]''' - Pathfinding explained.
*'''[[Pathfinding_Quick_Start_Guide]]''' - The best way to get up and running with Pathfinding.
*'''[[Visual_Guide_to_Pathfinding|A Visual Guide]]''' - Watch how easy it is!
*'''[[Walkability_Coefficients]]''' - Control the speed of your Walkable areas.
*'''[[Material_Volumes]]''' - Control the speed of your characters.

</div>
</div>
<div id="box">

== Physics ==
<div style="padding: 0.5em">
* '''[[Physics Optimization]]''' - Not everything needs physics, learn how to add the least load necessary to the physics engine.
* '''[[PRIM_PHYSICS_SHAPE_NONE]]''' - Additional information on this important attribute.

</div>
</div>
|valign="top" width="50%"|
<div id="box">

== Scripting ==
<div style="padding: 0.5em">
* '''[[Smart Scripting]]''' - No lag scripting tips.
* '''[[Debugging Scripts]]''' - how to work out what your code is doing without a conventional IDE
* '''[[Scripting for Pathfinding]]''' - Pathfinding scripting help.
</div>
</div>

<div id="box">

== Sculpted Prims ==
<div style="padding: 0.5em">
*'''[[Sculpted Prim Usage]]''' - What you need to know about how sculpted prims effect Second Life.
</div>
</div>

<div id="box">

== Textures ==
<div style="padding: 0.5em">
* '''[[Texture Usage]]''' - What size to use, and what to avoid.
</div>
</div>

|}
__NOTOC__

Category:LSL List

2012-05-13T11:01:19Z

Myopic Mole: /* Passing a List Into a Function */

{{LSL Header|ml=*}}{{LSLC|}}{{LSLC|Types}}
{{RightToc}}
A list is a special kind of data type which can contain zero or more elements.

Lists are signified by square brackets surrounding their elements; the elements inside are separated by commas.

Examples:
<lsl>[0,1,2,3,4]

["Yes","No","Perhaps"]</lsl>

(Note: to be clear for those who have other programming backgrounds, there are no arrays in LSL: only lists.)

====Diverse Data Types====

Not all elements in a list need to be the same type of element. In the same list, you can store strings, integers, floats, vectors, etc, right side by side.

Example:
<lsl>//a list with an integer, a float, a string, and a vector.
[1,14.154,"Isn't this fun?",<0,0,0>]</lsl>

However, a list may not contain another list (i.e. you can't nest them.)

<lsl>[1, "one", 2, "two"] + [3, "three"] returns [1, "one", 2, "two", 3, "three"]</lsl>
not
<lsl>[1, "one", 2, "two", [3, "three"]]</lsl>

When you add an element to a list, the list remembers automatically what data type the value was.

Generally, because you're the one adding something to a list, you know what datatype is in what place in the list, and you retrieve it out of the list with the appropriate llList2<type> function such as: [[llList2String]], [[llList2Vector]], etc. (more on this later.)

If for some reason, though, you need to test what data type an element is in a list, you can use the [[llGetListEntryType]] function.

Tip! When adding a [[float]] to a list, always add it with a decimal point (e.g 1.0 as opposed to 1) to ensure that it is preserved as a float.

List can be directly typecast into string
<lsl>default
{
touch_start(integer total_number)
{
list a = ["abc",1,2,3.14,<0,0,0>];
llOwnerSay((string)a); // outcome: abc123.140000<0.000000, 0.000000, 0.000000>
}
}</lsl>

or can use a [[do while]] condition to say each list item separately
<lsl>default
{
touch_start(integer total_number)
{
list a = ["abc","def","ghi","jkl","lmn","opq"];
integer i;
integer s = llGetListLength(a);
do
llOwnerSay(llList2String(a,i));
while(s>++i);
}
}</lsl>

=== Common List Operations ===
====Counting place in a list vs list length====

It's important at the outset to note the following (which can trip up even experienced minds when they are battle-weary):

<lsl>["Yes","No","Perhaps"]</lsl>

The length of this list is 3, because it has 3 elements in it. The length of a list is returned by the [[llGetListLength]]() function:

<lsl>integer length = llGetListLength(mylist);</lsl>

BUT, counting to determine an element's place in its list (aka "indexing") starts at 0 -- NOT 1.

The position of "Yes" in the above list is 0, "No" is at position 1, and "Perhaps" is at position 2.

Consequently, if you have 7 elements in a list, the last item in the list will be at position 6.

Thus to retrieve the last element in a list, without having to know in advance what position it is at, you can just go:

<lsl>integer length = llGetListLength(mylist);
string item = llList2String(myList,length - 1);</lsl>

====List Limits====

''(As of 2/20/11 these limits do not appear to apply for both LSO and Mono.)''

While a script is running, a list can grow dynamically as large as needed, limited only by the amount of memory that is available in the script.

However, at compile (aka save) time, there is a 72 element limit to pre-defined lists hardcoded in the script. Such long, predefined lists are common, for example, when someone is offering the user a plethora of colour choices.

Tip! If you really need 72 or more such choices in a pre-defined list, just make 2 (or more) lists that don't upset the compiler, and join them together in state_entry() or wherever appropriate:

<lsl>biggerlist = biglist01 + biglist02;</lsl>

====Adding an Element to a list====

There are several ways used to add an element to an existing list via prepending/appending:

# <lsl>myList = [new_item] + myList; // Best method for Mono-LSL: prepended list concatenation</lsl>
# <lsl>myList = myList + [new_item]; // appended list concatenation</lsl>
# <lsl>myList += [new_item]; // appended list concatenation with simplified syntax</lsl>
# <lsl>myList = (myList=[]) + myList + [new_item]; // appended list concatenation with memory fragmentation optimization</lsl>
# <lsl>myList = myList + new_item; // appended item</lsl>
# <lsl>myList += new_item; // appended item with simplified syntax</lsl>
# <lsl>myList = (myList=[]) + myList + new_item; // Best method for LSO-LSL: appended item with memory fragmentation optimization</lsl>

=====Notes=====
* As of 8/8/2009 Method 1 gives significant savings over any other method used in Mono-LSL.
** Note that prepending the new_item '''without''' brackets '''negates''' any memory savings in Mono-LSL.
** Method 1 will consume more memory than other methods in LSO-LSL.
* As of 8/8/2009 Method 7 returns the best value for savings in LSO-LSL.
** Method 7 is better than Method 4 due to the fact that Method 7 takes up less script overhead.
** Method 7 test script compiled to have a start memory of 15878, while Method 4 compiled to have a start memory of 15871. As a result Method 7 had more free memory than Method 4 at the end of the test operation.
* Methods 2 & 3 compile to the same thing.
* Methods 5 & 6 compile to the same thing.
* Methods 5, 6 & 7 have a bytecode savings over methods 2, 3 & 4 respectively, though there is an LSO-LSL VM bug that causes the string & key typecasts to not stick properly: {{Jira|SVC-1710}}.
* Methods 4 & 7 can result in a considerable memory savings in LSO-LSL over methods 2, 3, 5 & 6 (it helps reduce heap fragmentation, which would otherwise result in unusable blocks of heap memory){{Footnote|This method was invented and popularized by {{User|Strife Onizuka}}|This method was invented and popularized by Strife Onizuka}}. In Mono-LSL it provides no significant memory advantage or disadvantage.
** Depending upon the situation (in LSO-LSL) this method may not provide any advantage what so ever. If in doubt profile the script with and without using this method.

====Joining Lists (aka Concatenation)====

Lists can be joined simply by using the + sign:

<lsl>newlist = list01 + list02;

newlist = list01 + ["red","brown",<0,0,0>];</lsl>

Note: The above example actually creates 3 lists in memory while the command runs, even though just one is returned. This can affect memory usage.

====Clearing a List====

To clear a list, set it equal to two square, empty brackets like this:

<lsl>myList = [];</lsl>

====Passing a List Into a Function====

Passing a list into a function is little different than passing any other data type, however, there are some useful cases to be aware of:

<lsl>myList = llListReplaceList(myList, ["myString"], 2, 2);</lsl>

In the above code, we call [[llListReplaceList]](), an innocent enough operation, however, due to the way passing of lists, and functions such as llListReplaceList(), [[llDeleteSubList]](), [[llList2List]]() and [[llListSort]]() (and others), work, you can end up using two, three, or even four times the amount of memory required to store your list, just by calling that function! To avoid this problem, we can use a small piece of optimisation; if you know that the list you're passing into such a function will never be read again (for example if the result of the function will overwrite the list) then we can do this:

<lsl>myList = llListReplaceList((myList = []) + myList, ["myString"], 2, 2);</lsl>

The effect of this is to greatly reduce the memory usage, in both LSO-LSL and Mono VMs, and also reduce the fragmentation of memory. This can also work for other cases other than function-calls, for example when concatenating lists (above), you may find that this nearly eliminates any memory problem:

<lsl>list list1 = ["a", "b", "c"];
list2 = ["d", "e", "f"];
list3 = (list1 = list2 = []) + list1 + list2;</lsl>

====Processing a List Into Another List====

A more complex case, but sometimes when processing a large list you may find that you are producing a similarly large list as a result. In such cases there is a very large risk of running out of memory. As a result, in any case where you know you will, or might, be working on a particularly large list, it will often be worth manipulating them similarly to:

<lsl>list myOutput = [];

integer i = 0; integer x = myList != [];
for (; i < x; ++i) {
if (i > 10) { // Prune list every 10 elements
myList = llDeleteSubList((myList = []) + myList, 0, i - 1);
x -= i;
i = 0;
}

// Do some work here:
myOutput += llList2List(myList, i, i); // A silly bit of example work
}</lsl>

This method (deleting every few list entries or strides) is preferable to deleting an entry every loop, as the cost of calling llDeleteSubList() is very high. It is up to the scripter to decide what their optimal chunk-size is for pruning an input list, as you will need to balance memory use with delete cost.

== Strided lists ==

One common use of lists is to duplicate the functionality of structured collections of data (aka <i>structs</i>). Such collections, available in many programming languages, are absent from LSL.

In-world in SL, (still as of July 2008), a strided list is the closest you can get to storing limited amounts of data in some kind of structure that you can access and manipulate in a few, limited ways.

Strided lists allow you to store related data pieces grouped (aka "strided") in sets. You can determine how many pieces of data in each "grouping."

An example is best at this point. You might use a strided list to track the names, gender and rez dates of a group of avatars:

<lsl>list demographics = ["John Adams", "male", "2007-06-22", "Shirley Bassey", "female", "2005-11-02", "Matt Damon", "male", "2008-05-19"];</lsl>

This example has a <i>stride</i> of three, because each grouping (or stride) has three data elements. Index 0 ("John Adams") is the start of the first instance (because list counting starts a 0), index 3 ("Shirley Bassey") is the start of the second instance, and so on.

It is important that the pieces of information in each grouping are always entered in the same sequence for every instance of the grouping in the list! In the example above, this means that the name needs to be always the first of the three related elements. You should consider carefully the order in which you record information because the function to sort a list, [[llListSort]], will only sort on the <i>first element</i> of the instances. In other words, if the avatar's rez date were the most important attribute for your script, then you would need to record it first, and the name second. If you wish to be able to sort by avatar last name rather than first name, the name should be added to the list in Lastname FirstName format (avoiding a comma, though, of course, unless you wanted LastName and FirstName treated as separate elements in the list.)

To add another person to the above list, you would do this:

<lsl>demographics += ["Dorthy Lamour", "female", "2010-01-22"];</lsl>

You cannot do any kind of fancy data analysis or manipulation with strided lists, as you can in off-world databases or spreadsheets, but they can meet some limited, in-world needs, if you don't have the resources to tie-in off-world tools. It should be noted that when manipulating extremely large strided lists, that if you expect to be editing the lists that you may wish to use one list for each "column", this may be more complex but significantly reduces the amount of memory required when manipulating the lists, though it will be a lot more difficult to sort.

Here are the tools we do have for strided lists:

The following three (as of July 2008) native LSL functions can be used with strided lists:

*[[llList2ListStrided]]
*[[llListRandomize]]
*[[llListSort]]

Here are some additional, user-created functions for working with strided lists:

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListStridedMove]] || Moves something in a strided list to another place in the strided list.
|-
|| [[ListStridedRemove]] || Removes part of a strided list.
|-
|| [[ListStridedUpdate]] || Updates part of a strided list.
|-
|| [[ListStridedReorder]] || Reorder the contents of every stride or reorder entire strides.
|-
|}

== Extended List Operations ==

These functions have been created and contributed by LSL users to perform operations not covered by built-in LSL functions.

{|{{Prettytable}}
|+
|-{{Hl2}}
!function
!purpose
|-
|| [[ListCast]] || Processes a list so that its contents are of a single-type.
|-
|| [[List_cast]] || Processes a list so that its contents are converted from strings to their respective types.
|-
|| [[ListCompare]] || Compares two lists for equality
|-
|| [[ListItemDelete]] || Removes one element from a list.
|-
|| [[ListKeyCase]] || Changes the values of the whole list into uppercase or lowercase based on input
|-
|| [[ListToWholeNumbers]] || Given a list of floats, converts them all to whole numbers (aka integers.)
|-
|| [[ListXorY]] || Join two lists to make one new combined list, while also eliminating any resulting duplicates in the new list.
|-
|| [[ListXandY]] || This function examines two lists, and returns a new list composed of the elements that both lists have in common.
|-
|| [[ListXnotY]] || Show what x list has that y list is missing.
|-
|| [[ListXxorY]] || Returns a new list, composed of elements that were in either original script, but not both. Note: This is not the same as getting rid duplicates by preserving just one of each duplicated item. It goes further, and removes both items.
|-
|| [[ListXequY]] || Answers the question: is list X identical to list Y?
|-
|| [[ListXneqY]] || Answers the question: is list X different from list Y?
|-
|| [[ListItemReplace|Replace]] || Replaces a single occurrence of something in a list with something else that you specify.
|-
|| [[Library_Combined_Library#Replace_2|Replace All]] || Replaces all occurrences of 'from list' with those in 'to list' in 'src list'. Not as concise as the replace function above, but will handle multiple items at the same time.
|-
|| [[ListUnique ]] || Given a list of elements, returns a list of only the unique individual elements in that list.
|-
|| [[ccFixListDatatypes ]] || Walks a list, casts the elements to the appropriate types, and returns a fixed list. Useful for things like [[llSetPrimitiveParams]] when you've parsed your data out of a string.
|-
|| [[2D Pseudo-Array]] || A way to emulate the behavior of a 2 dimensional array.
|}