[14.3] Fair enough. So how do I actually go about it?

Making a parent script is dead easy. The trickier bit is working out what you want it to do and how you make it do it. Let's get the glib explanations out of the way first. Here's what you need to do to make the parent :
  1. create a new movie script in the script window, and give it a name
  2. declare any property variables you want like this: 
     property blah, wotsit, doodah
  3. give it a "birth" handler like this: 
      on birth me
    -- do whatever initialization you like here
    return me
  end birth
  4. add handlers for the things you want it to do: 
        
on whatever me
   -- whatever
end whatever
  5. close it

Like any other handlers, those in parent scripts can take other arguments if you want, but they should always take "me" first. The me argument is used to pass a copy of the object, which Director can use to determine what messages it responds to and what the values of its property variables are. Eg, a slightly more complex birth handler might look like this : 

on birth me, myRect, mySprite
  -- do whatever initialization you want
  -- including stuff using myRect and mySprite return me
end birth
Once you've written your parent script, you create objects from it using birth calls like this : 
put birth( script "myScript", someRect, someSprite ) into someVariable
What this does is potentially confusing, so let's take it slow. Bear with me here, it's much easier to use than it is to explain!

First of all, Director creates a generic script object based on your parent script. Think of this as being a copy of the parent, with little slots for all the data the script uses. At this stage, the slots are just empty.

Then, it calls the birth handler in this copy, and passes it a value telling it where all those empty slots can be found. It also passes all the other arguments you've specified in the remainder of that birth() call (in this example, someRect and someSprite).

Your "on birth" handler then does whatever it is you've set it up to do. This usually means initializing the property variables on the basis of the parameters passed, and any other initialization stuff (eg puppeting a sprite channel, swapping castmembers etc), ready for the stuff the rest of your child object is going to do later (that is, the stuff detailed in the other handlers in the parent script: "on whatever" etc).

When the birth handler is finished, it passes back the value (me) that keeps track of where all this stuff is kept, so that you can store it away in someVariable.

At the end of this palaver, what you've got is a little variable (called someVariable in this case, though it could be anything) which points Director to that particular script object with its own set of property variables. You can now use this to call up the handlers in that script, and get at those properties. You can also make copies of it, put it in lists, and generally spread it around. All of these copies will point to this same object. If you want to create another, different, object, you have to issue another birth() statement.

One important thing here is that when you pass around or copy the value in someVariable, you aren't actually schlepping the whole object from place to place, you are just moving a copy of its address, much as you might send a copy of someone's email address around. This is why doing things like sending an object a copy of itself doesn't lead to a horrendous infinite regression. It's just a way of telling the object "you are here".

The other important thing is that anything that has this address (ie has a copy of someVariable) can access not only the data it contains, but also the handlers it uses. Eg, if you have a few routines that you want to be able to use anywhere throughout a set of movies, you can create an object with them and pass it around. (Bear in mind that this can also lead to confusion, and it uses up RAM. It isn't, for example, a sensible replacement for a shared.dir.)