triangle skript

Hier ist dein korrigiertes und überarbeitetes Skript, welches nun eindeutig ein Dreieck zwischen den drei Bällen spannt:

### Erklärung der Änderungen:

- Ich habe festgestellt, dass die ursprüngliche Version "Kanten" korrekt positioniert, aber die eigentliche Fläche des Dreiecks (PRIM_TRIANGLE) nicht berücksichtigt/gesetzt hat.
- Ein sichtbares Dreieck zwischen drei Punkten kann mittels des Typs "PRIM_TYPE_PRISM" oder speziell "PRIM_TYPE_SCULPT" nicht ordentlich erzeugt werden, da Second Life keine direkte Fläche zwischen drei Punkten bereitstellt. Standardmäßig gibt es keinen primitiven Typ, der ein Dreieck direkt zwischen drei frei platzierbaren Punkten erzeugt.
- Die beste Möglichkeit, das gewünschte Ergebnis zu erhalten, ist, den PRIM_TYPE entsprechend scalieren, positionieren und rotieren (normalerweise mit einer flachen Prim "PRIM_TYPE_PRISM" oder "PRIM_TYPE_BOX") und per Rotation genau auf die drei Punkte auszurichten. Beispielsweise kannst du eine flache Box (Plane) nutzen und per Transformation exakt zwischen den drei Bällen ausrichten und skalieren.

Da Second Life Standard-Prims keine echte dreipunktbasierte Transformation erlauben, empfehle ich folgendes einfache Verfahren:

### Vorgeschlagene funktionierende Lösung:
Verwende ein dünnes Dreieck (flacher Prism), das standardmäßig eine Dreiecksform hat — und positioniere, rotiere und skaliere dieses zwischen den drei Punkten.

### Korrigiertes vollständiges Skript (benutzt PRISM Typ als Dreiecksfläche):

```lsl
integer LINK_EDGE_0 = 2;
integer LINK_EDGE_1 = 3;
integer LINK_EDGE_2 = 4;

integer LINK_BALL_0 = 5;
integer LINK_BALL_1 = 6;
integer LINK_BALL_2 = 7;

integer LINK_TRIANGLE = 8;

update() {
    vector pos0 = llList2Vector(llGetLinkPrimitiveParams(LINK_BALL_0, [PRIM_POS_LOCAL]), 0);
    vector pos1 = llList2Vector(llGetLinkPrimitiveParams(LINK_BALL_1, [PRIM_POS_LOCAL]), 0);
    vector pos2 = llList2Vector(llGetLinkPrimitiveParams(LINK_BALL_2, [PRIM_POS_LOCAL]), 0);

    vector center = (pos0 + pos1 + pos2) / 3.0;

    // Edge 0
    vector edge0Pos = (pos0 + pos1) / 2.0;
    float edge0Len = llVecDist(pos0, pos1);
    rotation edge0Rot = llRotBetween(<0,0,1>, llVecNorm(pos1 - pos0));

    // Edge 1
    vector edge1Pos = (pos1 + pos2) / 2.0;
    float edge1Len = llVecDist(pos1, pos2);
    rotation edge1Rot = llRotBetween(<0,0,1>, llVecNorm(pos2 - pos1));

    // Edge 2
    vector edge2Pos = (pos2 + pos0) / 2.0;
    float edge2Len = llVecDist(pos2, pos0);
    rotation edge2Rot = llRotBetween(<0,0,1>, llVecNorm(pos0 - pos2));

    llSetLinkPrimitiveParamsFast(LINK_EDGE_0, [
        PRIM_POS_LOCAL, edge0Pos,
        PRIM_SIZE, <0.01, 0.01, edge0Len>,
        PRIM_ROT_LOCAL, edge0Rot
    ]);

    llSetLinkPrimitiveParamsFast(LINK_EDGE_1, [
        PRIM_POS_LOCAL, edge1Pos,
        PRIM_SIZE, <0.01, 0.01, edge1Len>,
        PRIM_ROT_LOCAL, edge1Rot
    ]);

    llSetLinkPrimitiveParamsFast(LINK_EDGE_2, [
        PRIM_POS_LOCAL, edge2Pos,
        PRIM_SIZE, <0.01, 0.01, edge2Len>,
        PRIM_ROT_LOCAL, edge2Rot
    ]);

    // Dreieck-Fläche (Prisma-Typ) skalieren und ausrichten
    vector localX = llVecNorm(pos1 - pos0);
    vector tempZ  = llVecNorm((pos2 - pos0) % localX);
    vector localY = tempZ % localX;
    rotation triRot = llAxes2Rot(localX, localY, tempZ);

    // Transformiere Punkte ins lokale Raum des Dreiecks zur Berechnung Größe
    vector tri_p0 = <0,0,0>; // definiere Punkt 0 als Ursprung
    vector tri_p1 = <llVecDist(pos0,pos1),0,0>; // Punkt 1 auf X-Achse
    vector tri_p2_local = (pos2 - pos0) / triRot; // Punkt 2 transformiert

    float sizeX = llFabs(tri_p1.x);
    float sizeY = llFabs(tri_p2_local.y);

    // Kleiner offset für Z damit Fläche sichtbar
    float thickness = 0.01;

    vector triangleSize = <sizeX, sizeY, thickness>;

    // Positioniere Mittelpunkt korrekt
    vector triangleLocalPos = pos0 + (localX * sizeX * 0.5) + (localY * sizeY * 0.5);

    llSetLinkPrimitiveParamsFast(LINK_TRIANGLE, [
        PRIM_POS_LOCAL, triangleLocalPos,
        PRIM_SIZE, triangleSize,
        PRIM_ROT_LOCAL, triRot,
        PRIM_TYPE, PRIM_TYPE_PRISM, PRIM_HOLE_DEFAULT, <0,1,0>, 0.0, ZERO_VECTOR, <1,1,0>, ZERO_VECTOR
    ]);
}

default {
    state_entry() {
        llSetTimerEvent(0.1); // Aktualisiere alle 0.1 Sekunden
        update();
    }

    timer() {
        update();
    }
}
```

### Wichtige Hinweise zum Setup in Second Life:

- Bitte stelle sicher:
   - Link-Nummern: 2,3,4 sind "Kanten" (z.B. dünne Zylinderprims)
   - Link-Nummern: 5,6,7 sind "Bälle", deren Positionen das Dreieck bestimmen
   - Link-Nummer: 8 ist eine flache Prismaform (Setze auf "PRISM", flach (Z-Size sehr klein), idealerweise Textur auf 100% Transparent oder eine sichtbare Farbe).
- Positioniere und rotiere das PRISM ursprünglich ausgerichtet wie du willst. Das Skript übernimmt dann kontinuierlich das exakte Anpassen der Position, Größe und Rotation.

Jetzt sollte das Dreieck korrekt zwischen den drei angegebenen Punkten aufgespannt werden!