string targetName = "Example"; // Name des Zielobjekts, das dupliziert werden soll
string seedName = "seed";      // Name des Ausgangs-Prims, der dupliziert werden soll
vector offset = <5,0,0>;       // Versatz für die Duplikate
 
 
integer primcnt;                // Anzahl der Prims im Wurzelobjekt
integer primnum;                // Aktuelle Nummer des zu kopierenden Prims
key rootKey;                    // Schlüssel des Wurzelobjekts
 
// Funktion zur Bestimmung der Länge eines Tupels basierend auf dem Parameter
integer TupleLength (integer param)
{
    if (param == PRIM_GLOW)       return 1;
    if (param == PRIM_COLOR)      return 2;
    if (param == PRIM_TEXGEN)     return 1;
    if (param == PRIM_TEXTURE)    return 4;
    if (param == PRIM_NORMAL)     return 4;
    if (param == PRIM_SPECULAR)   return 7;
    if (param == PRIM_BUMP_SHINY) return 2;
    if (param == PRIM_FULLBRIGHT) return 1;
 
    return 0; // Not a by-side parameter
}
 
// Funktion zum Iterieren durch die Seiten (Faces) eines Prims und Rückgabe der Parametertupel für jede Seite
list IterateFaces (list p, integer param)
{
    integer tuplelength = TupleLength (param);
    integer numsides =  llGetListLength(p) / tuplelength;
 
    // Une seule face, retourner [ param, ALL_SIDES, p ]
    if (numsides == 1) return [ param, ALL_SIDES ] + p;
 
    list result = [ ];
    for (integer s=0; s<numsides; s++) {
        list tuple = llList2List (p, s*tuplelength, (s+1)*tuplelength-1);
        result += [ param, s ] + tuple;
    }  
    return result;
}
 
// Funktion zum Kopieren der Parameter eines Prims von einer Quelle zu einem Ziel
CopyParams (key srcprim, key dstprim, integer param) {
    if (TupleLength(param) == 0)
    {
        list p = osGetPrimitiveParams (srcprim, [ param ]);
        if (param == PRIM_POSITION) p = [ llList2Vector (p,0) + offset ];
        osSetPrimitiveParams (dstprim, [ param ] + p);
    }
    else
    {
        list p = osGetPrimitiveParams (srcprim, [ param, ALL_SIDES ]);
        p = IterateFaces (p, param);
        osSetPrimitiveParams (dstprim, p);
    }
    llSleep (0.1);
}
 
// Funktion zum Erstellen eines neuen Prims
RezAPrim ()
{
    if (++primnum > primcnt) llResetScript();
    llRezObject (seedName, llGetPos()+<0,0,1>, ZERO_VECTOR, ZERO_ROTATION, 0);
}
 
// Funktion, die aufgerufen wird, wenn ein Prim rezisiert wurde
// Kopiert die Parameter des ursprünglichen Prims auf den rezisierten Prim
PrimRezed (key dstkey)
{
    llOwnerSay ("Processing link "+(string)primnum+" of "+(string)primcnt);
    key srckey = llGetObjectLinkKey (rootKey, primnum);
    llSleep (0.1);
 
    CopyParams (srckey, dstkey, PRIM_POSITION);
    CopyParams (srckey, dstkey, PRIM_ROTATION);
    CopyParams (srckey, dstkey, PRIM_TYPE);
    CopyParams (srckey, dstkey, PRIM_SIZE);
    CopyParams (srckey, dstkey, PRIM_COLOR);
    CopyParams (srckey, dstkey, PRIM_TEXTURE);
    CopyParams (srckey, dstkey, PRIM_NORMAL);
    CopyParams (srckey, dstkey, PRIM_SPECULAR);
    CopyParams (srckey, dstkey, PRIM_TEXGEN);
    CopyParams (srckey, dstkey, PRIM_BUMP_SHINY);
    CopyParams (srckey, dstkey, PRIM_FULLBRIGHT);
    CopyParams (srckey, dstkey, PRIM_PHYSICS_SHAPE_TYPE);
 
    RezAPrim ();
}
 
// Funktion zum Abrufen des Besitzers eines Objekts anhand der Objekt-ID
key OwnerOf (key id)
{
    list l = llGetObjectDetails (id, [ OBJECT_OWNER ]);
    return llList2Key (l, 0);
}
 
 
default
{
    state_entry()
    {
        // Initialisierung des Skripts
        llSetText ("READY", <0,1,0>, 1.0);
    }
 
    touch_start (integer n)
    {
        // Wenn das Objekt berührt wird, wechselt der Zustand in den Dialog-Modus
        state dialog;
    }
}
 
 
integer dlgchan = 99;
integer dlglistener;
state dialog
{
    state_entry()
    {
        // Initialisierung des Dialog-Modus
        llSetText ("LISTENING", <0,1,0>, 1.0);
        llDialog (llGetOwner(), "Action?", ["CLEANUP", "REPLICATE"], dlgchan);
        dlglistener = llListen (dlgchan, "", llGetOwner(), "");
        llSetTimerEvent (10);
    }
 
    // Abhören von Dialognachrichten und Auslösen entsprechender Aktionen
    listen (integer chan, string name, key id, string msg)
    {
        if (msg == "CLEANUP")   state cleanup;
        if (msg == "REPLICATE") state replicate;
    }
 
    timer ()
    {
        // Timer-Ereignis zum Zurückkehren in den Standardzustand nach einer bestimmten Zeit
        state default;
    }
 
    state_exit ()
    {
        // Aufräumen beim Verlassen des Dialog-Modus
        llSetTimerEvent (0.0);
        llListenRemove (dlglistener);
    }
}
 
 
state cleanup
{
    state_entry()
    {
        // Zustand für die Bereinigung von Prims
        llSetText ("CLEANUP", <0,1,0>, 1.0);
        llSensor (seedName, NULL_KEY, PASSIVE|SCRIPTED, 100, PI);
    }
 
    sensor (integer num) {
        // Ereignis, das ausgelöst wird, wenn Sensoren aktiv sind
        llOwnerSay ("Garbage collecting "+(string)num);
        for (integer i=0; i<num; i++) osDie (llDetectedKey(i));
        state default;
    }
 
    no_sensor() {
        // Ereignis, das ausgelöst wird, wenn keine Sensoren aktiv sind
        llOwnerSay ("All clean.");
        state default;
    }
}
 
 
state replicate
{
    state_entry()
    {
        // Zustand für die Replikation von Prims
        llSetText ("REPLICATE", <0,1,0>, 1.0);
        llSensor (targetName, NULL_KEY, PASSIVE|SCRIPTED, 100, PI);
    }
 
    sensor (integer num) {
        // Ereignis, das ausgelöst wird, wenn Sensoren aktiv sind
        rootKey = llDetectedKey (0);
 
        if (OwnerOf(rootKey) != llGetOwner())
        {
            llOwnerSay ("I don't own "+targetName+". Aborting.");
            state default;
        }
 
        primcnt = llGetObjectPrimCount (rootKey);
        primnum = 0; RezAPrim ();
    }
 
    no_sensor() {
        // Ereignis, das ausgelöst wird, wenn keine Sensoren aktiv sind
        llOwnerSay ("Object "+targetName+" was not found.");
        state default;
    }
 
    object_rez (key uuid) {
        // Ereignis, das ausgelöst wird, wenn ein Objekt rezisiert wird
        PrimRezed (uuid);
    }
}

// Indizes der Eigenschaften für PRIM_TYPE_BOX, PRIM_TYPE_CYLINDER, PRIM_TYPE_PRISM
 
integer INDEX_TYPE      = 0; // Typ
integer INDEX_HOLE      = 1; // Lochgröße
integer INDEX_CUT       = 2; // Schnittgröße
integer INDEX_HOLLOW    = 3; // Leeregröße
integer INDEX_TWIST     = 4; // Verdrehung
integer INDEX_TAPER     = 5; // Zulauf
integer INDEX_SHEAR     = 6; // Scherung
 
// Indizes der Eigenschaften für PRIM_TEXTURE
 
integer INDEX_TEXTURE   = 0; // Textur
integer INDEX_REPEATS   = 1; // Wiederholungen
integer INDEX_OFFSETS   = 2; // Versatz
integer INDEX_ROTATION  = 3; // Rotation
 
// Indizes der Eigenschaften für PRIM_COLOR 
//                client        script
//          +---------------+------------+
//  Taper   | -1.0 0  +1.0  |  2.0   0.0 | 
//  Shear   | -0.5 0  +0.5  | -0.5  +0.5 |
//  Twist   | -180 0  +180  | -1.0  +1.0 | 
//          +---------------+------------+
 
 
// Set-Methoden
 
mySetLinkName (integer link, string text) {
    // Setzt den Namen eines Links
    llSetLinkPrimitiveParamsFast (link, [PRIM_NAME, text]);
}
 
mySetLinkDesc (integer link, string text) {
    // Setzt die Beschreibung eines Links
    llSetLinkPrimitiveParamsFast (link, [PRIM_DESC, text]);
}
 
mySetLinkText (integer link, string text, vector color) {
    // Setzt den Text eines Links mit Farbe
    llSetLinkPrimitiveParamsFast (link, [PRIM_TEXT, text, color, 1.0]);
}
 
mySetLinkColor (integer link, vector color, integer face) {
    // Setzt die Farbe eines Links für eine bestimmte Seite
    llSetLinkPrimitiveParamsFast (link, [PRIM_COLOR, face, color, 1.0]);
}
 
mySetLinkBright (integer link, integer bright, integer face) {
    // Setzt die Helligkeit eines Links für eine bestimmte Seite
    llSetLinkPrimitiveParamsFast (link, [PRIM_FULLBRIGHT, face, bright]);
}
 
mySetLinkGlow (integer link, float glow, integer face) {
    // Setzt das Leuchten eines Links für eine bestimmte Seite
    llSetLinkPrimitiveParamsFast (link, [PRIM_GLOW, face, glow]);
}
 
// Die folgenden drei funktionieren nicht für ALL_SIDES
 
mySetLinkTexture (integer link, key texture, integer face) {
    // Setzt die Textur eines Links für eine bestimmte Seite
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    l = llListReplaceList(l, [texture], INDEX_TEXTURE, INDEX_TEXTURE);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TEXTURE, face] + l);
}
 
mySetLinkRepeat (integer link, vector repeat, integer face) {
    // Setzt die Texturwiederholungen eines Links für eine bestimmte Seite
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    l = llListReplaceList(l, [repeat], INDEX_REPEATS, INDEX_REPEATS);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TEXTURE, face] + l);
}
 
mySetLinkOffset (integer link, vector offset, integer face) {
    // Setzt den Texturversatz eines Links für eine bestimmte Seite
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    l = llListReplaceList(l, [offset], INDEX_OFFSETS, INDEX_OFFSETS);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TEXTURE, face] + l);
}
 
mySetLinkPos (integer link, vector pos) {
    // Setzt die Position eines Links relativ zum Elternobjekt
    llSetLinkPrimitiveParamsFast (link, [PRIM_POS_LOCAL, pos]);
}
 
mySetLinkRot (integer link, rotation rot) {
    // Setzt die Rotation eines Links relativ zum Elternobjekt
    llSetLinkPrimitiveParamsFast (link, [PRIM_ROT_LOCAL, rot]);
}
 
mySetLinkSize (integer link, vector size) {
    // Setzt die Größe eines Links
    llSetLinkPrimitiveParamsFast (link, [PRIM_SIZE, size]);
}
 
mySetLinkCut (integer link, vector cut) {
    // Setzt den Schnitt eines Links (nur für Boxen, Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    l = llListReplaceList(l, [cut], INDEX_CUT, INDEX_CUT);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TYPE] + l);
}
 
mySetLinkTwist (integer link, vector twist) {
    // Setzt die Verdrehung eines Links (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    l = llListReplaceList(l, [twist], INDEX_TWIST, INDEX_TWIST);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TYPE] + l);
}
 
mySetLinkTaper (integer link, vector taper) {
    // Setzt den Zulauf eines Links (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    l = llListReplaceList(l, [taper], INDEX_TAPER, INDEX_TAPER);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TYPE] + l);
}
 
mySetLinkShear (integer link, vector shear) {
    // Setzt die Scherung eines Links (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    l = llListReplaceList(l, [shear], INDEX_SHEAR, INDEX_SHEAR);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TYPE] + l);
}
 
mySetLinkHollow (integer link, float hollow) {
    // Setzt die Hohlheit eines Links (nur für Boxen, Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    l = llListReplaceList(l, [hollow], INDEX_HOLLOW, INDEX_HOLLOW);
    llSetLinkPrimitiveParamsFast (link, [PRIM_TYPE] + l);
}
 
// Get-Methoden
 
string myGetLinkName (integer link) {
    // Gibt den Namen eines Links zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_NAME]);
    return llList2String (l,0);
}
 
string myGetLinkDesc (integer link) {
    // Gibt die Beschreibung eines Links zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_DESC]);
    return llList2String (l,0);
}
 
string myGetLinkText (integer link) {
    // Gibt den Text eines Links zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXT]);
    return llList2String (l,0);
}
 
vector myGetLinkColor (integer link, integer face) {
     // Gibt die Farbe eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_COLOR, face]);
    return llList2Vector (l,0);
}
 
integer myGetLinkBright (integer link, integer face) {
    // Gibt die Helligkeit eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_FULLBRIGHT, face]);
    return llList2Integer (l,0);
}
 
float myGetLinkGlow (integer link, integer face) {
    // Gibt das Leuchten eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_GLOW, face]);
    return llList2Float (l,0);
}
 
key myGetLinkTexture (integer link, integer face) {
    // Gibt die Textur eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    return llList2Key(l,0);
}
 
vector myGetLinkRepeat (integer link, integer face) {
    // Gibt die Texturwiederholungen eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    return llList2Vector(l,1);
}
 
vector myGetLinkOffset (integer link, integer face) {
    // Gibt den Texturversatz eines Links für eine bestimmte Seite zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_TEXTURE, face]);
    return llList2Vector(l,2);
}
 
vector myGetLinkPos (integer link) {
    // Gibt die Position eines Links relativ zum Elternobjekt zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_POS_LOCAL]);
    return llList2Vector (l,0);
}
 
vector myGetLinkSize (integer link) {
    // Gibt die Größe eines Links zurück
    list l = llGetLinkPrimitiveParams (link, [PRIM_SIZE]);
    return llList2Vector (l,0);
}
 
vector myGetLinkCut (integer link) {
    // Gibt den Schnitt eines Links zurück (nur für Boxen, Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    return llList2Vector (l, INDEX_CUT);
}
 
vector myGetLinkTwist (integer link) {
    // Gibt die Verdrehung eines Links zurück (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    return llList2Vector (l, INDEX_TWIST);
}
 
vector myGetLinkTaper (integer link) {
    // Gibt den Zulauf eines Links zurück (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    return llList2Vector (l, INDEX_TAPER);
}
 
vector myGetLinkShear (integer link) {
    // Gibt die Scherung eines Links zurück (nur für Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    return llList2Vector (l, INDEX_SHEAR);
}
 
float myGetLinkHollow (integer link) {
    // Gibt die Hohlheit eines Links zurück (nur für Boxen, Zylinder und Prismen)
    list l = llGetLinkPrimitiveParams (link, [PRIM_TYPE]);
    return llList2Float (l, INDEX_HOLLOW);
}