llDetectedName to detect SPECIFIC objects?

I'm using a pretty simple script with llSensor and llDetectedName(obj) that I found, it helps me pick out all nearby objects. But that's a bit much for me. Does anyone know if there's a way to get it to detect specific objects by name?

There sure is, though only if you are searching for objects with an EXACT specified name (e.g. if you are looking for "Bob" you won't detect "bob" or "BOB" or "Bobbet". What you are looking for is the "name" parameter of llSensor() or llSensorRepeat().

See:

http://www.lslwiki.net/lslwiki/wakka.php?wakka=llSensor
http://www.lslwiki.net/lslwiki/wakka.php?wakka=llSensorRepeat

Most people do this by calling an unfiltered sensor and then looping through the results to do comparisons.

Well, I'm quite sure that's beyond my scripting skills at the moment. Thanks, though.

Hey come on now! Do not sell your self short. Post the script you are using and we can show where it needs to be changed.

That is fine if you want no more than 16 hits including the ones you can't use. Otherwise a name filter in llSensor or llSensor repeat is better

Well, just for laughs, here's the script I'm using. Found it somewhere and modified it a little.

integer obj;
string display;
default
{
touch_start(integer obj)
{
llSensor("",NULL_KEY,PASSIVE|ACTIVE,20.0,PI);
}
sensor(integer num_detected){
for(obj=0;obj<= num_detected-1;obj++){

string display = (llDetectedName(obj)+" "+(string)llDetectedPos(obj)+"\n"+ display);


llOwnerSay(display);
}
}
no_sensor(){
llOwnerSay("Nothing?");
}
}

Got an example of what you want to search for?

Like.. Anything beginning with "Bob"? Or anything with "bob" in the name anywhere? Or.. something else?

Yes. I'd like to track down anything with the word paul in it. All the objects I create, I call 'em "Paul's [name of item]", and I figured I'd be able to track them down in this mess of a workshop of mine if there were a script I could use to locate objects that way.

Untested but this will probably be close...

default
{
	touch_start(integer obj)
	{
		llSensor("",NULL_KEY,PASSIVE|ACTIVE,20.0,PI);
	}
	
	sensor(integer num_detected)
	{
		integer i;
		string display = "";
		
		for(i = 0; i < num_detected; i++)
		{
			string name;

			name = llDetectedName (i);
			// or ..= llToLower (llDetectedName(i)); for caseless search
			
			if (llSubStringIndex(name, "Paul") == 0) // starts with 'Paul'? (or != -1 for anywhere)
			{
				display = name + " " + (string)llDetectedPos(i) + "\n" + display;
			}
		}

		if (display != "")
		{
			llOwnerSay (display);
		}
		else
		{
			llOwnerSay ("No Paul's found in " + (string)num_detected + " objects!");
		}
	}
	
	no_sensor()
	{
		llOwnerSay("Nothing?");
	}
}

See? It's really not that bad and you pick it up as you go. If I can learn to script then anyone can. Plus you have the community here to nudge you in the right direction when you get lost.

Looking forward to more queries from you.

/me too!!

You know I bill by the character, right?

MORE WHITESPACE!!

I tried counting but lost track. Now how many mealworms do we owe you for this work?

Oh... That works well...

And if I'm correct... Changing that 20.0 in the llSensor changes the range?

None! You get a kickback for encouraging the newbie.


Yep.

Still only scans 16 objects, so I have to be practically on top of what I'm looking for anyway, but at least that gets rid of the long list of worthless stuff...

Is that an SL scripting limitation, or something that can actually be done, to scan more than 16 items?

That's expected - sensors are only able to detect the first 16 matches...

If you REALLY want to look for more, you can decrease the scanning radius (where you have PI in the sensor call now) and rotate your scanner object around..

Yeah, I did increase the range, and tested it by dropping some other items, but it still seems to only scan the 16 nearest items, and misses an object 3 meters away, because the 56 prim cat wandered into scan range...

OR you can put the EXACT name of the object inside the parenthesis in the sensor. THis way you can also strip back out the if tests in the script.:

llSensor("",NULL_KEY,PASSIVE|ACTIVE,20.0,PI);

At work now but I can whip one up this afternoon unless someone beats me to it.

Please take a look at:

http://jira.secondlife.com/browse/SVC-791
http://jira.secondlife.com/browse/SVC-790

Here is a way to do it with an exact name search. Enter the EXACT name (In this case a partial name will not work) of the object you want to locate in the sensor description.:

integer range = 96;
integer switch = 1;
string target;
vector dest;

default {
	state_entry() {
		llSetObjectName("Object Locator");
	}
	touch_start(integer n) {
		if (switch) {//This is same as if(switch == TRUE)
		//This is an integer switch. Everytime you touch the object
		//it is going to change the integer between TRUE & FALSE
			target = llGetObjectDesc();
			if (target == "") {
				llOwnerSay("target is not set correctly");
				llOwnerSay("Sensor off");
				switch = 0;
			}
			else {
				llSensorRepeat(target, NULL_KEY, PASSIVE, range, PI, 0.5);
				llOwnerSay("Sensor on");
			}
		}
		else {
			llOwnerSay("Sensor off");
			llSensorRemove();
		}
		switch = !switch;
	}
	sensor(integer n) {
		integer i;
		for (i = 0; i < n; i++) {
			llOwnerSay("Found " + llDetectedName(i));
			dest = llDetectedPos(i);
			llMapDestination(llGetRegionName(), dest, dest);
			llSensorRemove();
			llOwnerSay("Sensor off");
			switch = 1;

		}
	}
}

This demonstrates a couple of easy concepts. First and more importantly is what we call an integer switch. In LSL TRUE = 1 and FALSE = 0. At the end of the touch_start event you will see this:
switch = !switch;
That is telling the script to change switch between 1 & 0(TRUE & FALSE). If it is 1 then it becomes 0 and if it is 0, it becomes 1. It is a nice, neat, easy way to make a touch_event do more then one thing and you can think of it like a light switch

You will also notice that instead of just saying where the object is located I used llMapDestination instead. Now you have a big beacon shining right on the object and can even teleport there if you want to.

That's pretty cool. Although it keeps finding just one item, nothing else... Even when I put in the name exactly... And it looks like the map location is wrong, which probably has to do with detecting the wrong object... Hmm. great way to learn a script though, that's for sure.

MAJOR EDIT: see below

this will give 16 objects per 109.4713deg arc in 6 arcs but has some overlap (which is why we grab the name AND pos, to get items with the same name but different locations)

 /*//-- updown-south-north-west-east --//*/
list    gLstDir = [<`0.00000, -0.70711, 0.00000, 0.70711>, <`0.00000, 0.70711, 0.00000, 0.70711>,
                   <`0.00000, 0.00000, -0.70711, 0.70711>, <`0.00000, 0.00000, 0.70711, 0.70711>,
                   <`0.00000, 0.00000, -1.00000, 0.00000>, <`0.00000, 0.00000, 0.00000, 1.00000>];
 /*//-- 6 Elements in gLstDir, negative indices are easier. --//*/
integer gIdxCnt = -6;
list    gLstRpt;

uSensorLoop(){
    if (gIdxCnt){
         /*//-- Set rotation before we call the sensor --//*/
        llSetRot( llList2Rot( gLstDir, gIdxCnt++ ) );
         /*//-- 109.4713deg arc / 2 and convert to radians --//*/
        llSensor( "", "", PASSIVE, 95, 0.9553167 );
    }
    else{
         /*//-- we called all our Sensors, now report the findings --//*/
        llOwnerSay( (string)((gLstRpt != []) / 2) + " Objects detected:\n" );
         /*//-- (gLstRpt != []) == llGetListLength( gLstRpt ) --//*/
        
        gIdxCnt = ([] != gLstRpt);
         /*//-- ([] != gLstRpt) == -llGetListLength( gLstRpt ) --//*/
        while (gIdxCnt){
            llOwnerSay( "Name: " + llList2String( gLstRpt, gIdxCnt++ ) + "\n @ " + llList2String( gLstRpt, gIdxCnt++ ) );
        }
         /*//-- we're done, clear our variables --//*/
        gIdxCnt = -6;
        gLstRpt = [];
    }
}

default{
    state_entry(){
        llOwnerSay( "Touch Me to Start" );
    }
    
    touch_start( integer vInt ){
        uSensorLoop();
    }
    
    sensor( integer vIntTotal ){
        list vLstTmp;
         /*//-- loop backwards to reduce variables --//*/
        while (vIntTotal--){
         /*//-- don't use (--vIntTotal), we want to subtract AFTER checking --//*/
            vLstTmp = [llDetectedPos( vIntTotal ), llDetectedName( vIntTotal )];
             /*//-- is it NOT in our list already --//*/
            if (!~llListFindList( gLstRpt, vLstTmp )){
             /*//-- (!~llListFindList()) == (llListFindList() = -1) --//*/
                gLstRpt += vLstTmp;
            }
        }
        uSensorLoop();
    }
    
    no_sensor(){
        uSensorLoop();
    }
}

the most efficient version (least overlap) would have 12 directions, but I didn't feel like doing the math. any regular polygon number of directions will work. more directions = more possible detected objects in range, but takes longer, and uses a lot more processing.

MAJOR EDIT:
the above works, and it's simpler than trying to reflect the sensor ( angle and angle-pi )

MAJOR "FUCK YOU" TO LL:
I now can't print a valid rotation to the forums... thankfully ` is treated by the LSL compiler(s) as a space so it won't interfere with the program

Ibtl

I am so taking notes...