VT Medieval dance

This week I've done a couple of builds that finish off a process that I started summer last year. Simply put: I've built the last two cells that will replace old-style Z&A cells in the shop (they go on sale next week). So, at the moment, I'm actually "between projects". I've got a couple of ideas of what to work on next, and doubtless there's a couple or so more new cell designs in me yet. There's also the small matter of a fair to work towards this June.

So, yesterday afternoon, while contemplating a couple of things in the workshop, I saw the announcement that VT's dance yesterday was Medieval-themed and, of course, Miss Eve was DJing. Have fun shopping for an outfit and make a point of going out and being social, or stick in the workshop and tinker with things? I even surprised myself by selecting the former!

And select it I did:

As normally happens, while there, I got a little snap-happy. There's an album of all the shots I took over on imgur.

Quick steps maker

While contemplating an upcoming build the other day the idea for this script popped into my head and, having thought of it, I had to knock it together quickly. Like a few other scripts I've put on here this stems from my use of Mesh Studio, where I'll make mesh objects in-world from lots of prims. This time around I wanted to make some simple stairs.

I've done this before and it's easy enough: rez and size a prim, copy it, move it to the next spot, copy, move to the next spot, and so on. But it'd be easier done with a script, right?

So the Z&A Quick Steps Maker was born. With this you simply rez out as many cubes as you want steps:

Link all the cubes and drop the script into the root prim. When you do so it'll texture the "top" face of the root so you know what direction the stairs will build in.

Next, size the root prim to the size of a step.

Once you're happy with it, touch the linkset and...

...the steps build themselves. If it doesn't quite look right all you need to do is resize the root prim to taste...

...and touch again to have the stairs rebuild:

Of course, a far more sophisticated system could be made where an object rezzes other objects out, building the stairs for you dynamically (could be something like that even exists -- I've not bothered to look), but that wasn't the point of this script. The point here was to knock up something that works quickly and easily for those times where you know what it is you're doing but you just want to save some fingerwork. It also means that there's no need to consider things like the grey-goo fence as it's you making all the prims up front.

Anyway, on the off chance that it's useful to anyone else, here's the script:

	//////////////////////////////////////////////////////////////////////
	// Z&A Quick Steps Maker
	// By Antony Fairport
	//
	// Z&A Quick Steps Maker - Quickly make steps from a linkset of prims.
	//
	// While a more sophisticated stair maker can be made that would rez objects
	// as it goes, sometimes you just want to create a linkset and have it all
	// size and position correctly. This script does that. Here's how it works:
	//
	// 1) Rez out as many cubes as you need steps.
	// 2) Link them all together.
	// 3) Drop this script into the root prim.
	// 4) Make note of the face that gets textured with arrows. I shows you
	// what the step top is and the direction they'll build in.
	// 5) Size the root prim to the size you want the steps to be.
	// 6) Touch the object and watch all the other prims size and move.
	// 7) When you're happy with things, delete this script.
	//
	// Revision history:
	// ------------------------------------------------------------
	//
	// 2015-03-24
	// Initial revision.
	//////////////////////////////////////////////////////////////////////
	// Default state.
	default
	{
	//////////////////////////////////////////////////////////////////////
	// On state entry...
	state_entry()
	{
	// Show the direction we'll be building in.
	llSetLinkPrimitiveParamsFast( LINK_ROOT, [
	PRIM_TEXGEN, 0, PRIM_TEXGEN_DEFAULT,
	PRIM_COLOR, 0, < 1.0, 1.0, 1.0 >, 1.0,
	PRIM_TEXTURE, 0, "87b5b2d9-2eff-d1ae-fada-fd5961cac15c", < 1.0, 1.0, 0.0 >, ZERO_VECTOR, 0.0
	] );
	}
	//////////////////////////////////////////////////////////////////////
	// Handle a touch.
	touch_start( integer _ )
	{
	// Don't let others mess with the build.
	if ( llDetectedKey( 0 ) == llGetOwner() )
	{
	// Get the number of objects in the linkset.
	integer iMax = llGetNumberOfPrims();
	// If this is actually a linkset...
	if ( iMax > 1 )
	{
	// Get the dimensions of the root prim. It's the template.
	vector vScale = llGetScale();
	// For every other prim in the linkset...
	integer i;
	for ( i = 2; i <= iMax; i++ )
	{
	// ..size and move it into position.
	llSetLinkPrimitiveParamsFast( i, [
	PRIM_SIZE, vScale,
	PRIM_POS_LOCAL, < vScale.x * ( i - 1 ), 0, vScale.z * ( i - 1 ) >,
	PRIM_ROT_LOCAL, ZERO_ROTATION
	] );
	}
	}
	else
	{
	// Not really anything to do here.
	llOwnerSay( "This isn't a linkset. Looks like your step is done already." );
	}
	}
	}
	}

view raw Z&A Quick Steps Maker.lsl hosted with ❤ by GitHub

Rocking out at VT

Yesterday I took one of my rare trips out to a dance. Miss Eve was DJing a biker-themed dance at VT, the music being start to finish rock. Couldn't miss out on that could I?

I took a bunch of photos while there; you can find them all over on imgur.

RLV REPL

This script is being filed under "why the heck didn't I think of this before?" as well as "surely someone else has done this, I wonder why I've never seen it before?"

A little earlier today I found myself needing to quickly test a handful of different RLV commands. Now, as I have done over the past 5 years, I could have made a script, ran it, changed it, ran it again, changed it some more, run it again, etc... Really though, that gets rather tedious. And then it hit me! What I really need is a RLV REPL.

What I came up with isn't a REPL in the strictest sense but it more or less does the job. Rez a cube, throw the script inside and then touch it to turn it on (it'll be obvious when it's on and off). In the on state it listens to all local chat by the object owner and, if the text starts with an @, it repeats it via llOwnerSay. Instant quick and dirty RLV command line/REPL thing!

	//////////////////////////////////////////////////////////////////////
	// RLV REPL
	// By Antony Fairport
	//
	// RLV REPL - Quick and dirty "REPL" for testing RLV commands.
	//
	// Revision history:
	// ------------------------------------------------------------
	//
	// 2015-03-09
	// Initial revision.
	//////////////////////////////////////////////////////////////////////
	// Default state.
	default
	{
	//////////////////////////////////////////////////////////////////
	// State entry.
	state_entry()
	{
	// Start out in the idle state.
	state Idle;
	}
	}
	//////////////////////////////////////////////////////////////////////
	// Idle state.
	state Idle
	{
	//////////////////////////////////////////////////////////////////
	// State entry.
	state_entry()
	{
	// Show that we're idle.
	llSetColor( < 1.0, 0.0, 0.0 >, ALL_SIDES );
	llSetText( "RLV REPL idle", < 1.0, 0.0, 0.0 >, 1.0 );
	}
	//////////////////////////////////////////////////////////////////
	// Handle a touch event.
	touch_end( integer _ )
	{
	// If it's our owner touching us...
	if ( llDetectedKey( 0 ) == llGetOwner() )
	{
	// ...fire up the REPL.
	state REPL;
	}
	}
	}
	//////////////////////////////////////////////////////////////////////
	// Active REPL state.
	state REPL
	{
	//////////////////////////////////////////////////////////////////
	// State entry.
	state_entry()
	{
	// Show that we're working.
	llSetColor( < 0.0, 1.0, 0.0 >, ALL_SIDES );
	llSetText( "Listening for RLV commands from\n" + llKey2Name( llGetOwner() ), < 0.0, 1.0, 0.0 >, 1.0 );
	// Listen to local chat from the owner.
	llListen( 0, "", llGetOwner(), "" );
	}
	//////////////////////////////////////////////////////////////////
	// State exit.
	state_exit()
	{
	// Ensure all restictions are cleared.
	llOwnerSay( "@clear" );
	}
	//////////////////////////////////////////////////////////////////
	// Handle incoming listen events.
	listen( integer channel, string name, key id, string message )
	{
	// Local chat?
	if ( channel == 0 )
	{
	// Belt and braces. Yes, I know, we filter when we make the
	// listen but, hey, it can't hurt to be really sure, right?
	if ( id == llGetOwner() )
	{
	// Looks like an RLV command?
	if ( llGetSubString( message, 0, 0 ) == "@" )
	{
	// Seems so.
	llOwnerSay( message );
	llOwnerSay( "Executed: " + message );
	}
	}
	}
	}
	//////////////////////////////////////////////////////////////////
	// Handle a touch event.
	touch_end( integer _ )
	{
	// If it's our owner touching us...
	if ( llDetectedKey( 0 ) == llGetOwner() )
	{
	// ...go idle.
	state Idle;
	}
	}
	//////////////////////////////////////////////////////////////////
	// Handle changes.
	changed( integer change )
	{
	// Owner has changed?
	if ( change & CHANGED_OWNER )
	{
	// They have. Reset all the things.
	llResetScript();
	}
	}
	}

view raw RLV REPL.lsl hosted with ❤ by GitHub

This should save me a bit of faffing about the next time I want to test something.

Day2K

On the one hand it's just another day on the grid. Nothing that special. Not an actual anniversary or anything like that. Not a rezday. On the other hand though there's something kind of special about those big round numbers.

Those 2,000 days have been eventful, that's for sure. While I often seem people in various groups (especially D/s groups) complain that they're "bored" in-world this is something I've never really had a problem with. In those 2,000 days I've gone from a nervous and curious observer of the SL D/s world to someone who's fully embraced it, learnt to have fun with and make things using RLV and has generally become someone comfortable with getting to know that side of myself.

There's been ups and downs, of course. When I hit 1,000 days I happened to be uncollard, something which happened again just in time for day2k. Overall though I've really enjoyed the time I spend as Antony.

And, hopefully, I will do for some time to come.