Ein einfaches Fahrscript mit reichlich Kommentaren.

PHP-Code:
string  animation           = "sit";                    // Name der Animation, muss im Prim sein, oder eine UUID einfügen in Zeile 71 ist das SitTarget
list    geschwindigkeiten   = [5.0, 15.0, 30.0];        // Die Geschwindigkeiten die Anzahl legt automatisch die Anzahl der Gänge fest
float   rueckwaerts         = -5.0;                     // Geschwindgikeit im Rückwärtsgang
list    kurvenbewegung      = [0.5, 0.2, 0.05];         // Wie stark die Kurve wird. Jeder Gang erhält eigenen Wert. Ist geschwindigkeitsadaptiv, siehe controll Event unter nach rechts, nach links

//////////////// hier muss nix gefummelt werden :)   
key     avatar;                                         // Key des Avatars
integer gang;                                           // aktueller Gang

//////////////////////////////////////////////////
init()
// Setzen der physikalischen Parameter, hier könnt ihr die Fahreigenschaften festlegen
{
    llSetVehicleType(VEHICLE_TYPE_CAR);
            
    // linear motor geradeaus Motor
    llSetVehicleVectorParam( VEHICLE_LINEAR_MOTOR_OFFSET, <0.0, 0.0, 0.0> );      // Ort des Antriebs, realtiv zum Massenmittelpunkt (lGetCenterOfMass( );)
    llSetVehicleVectorParam( VEHICLE_LINEAR_FRICTION_TIMESCALE, <50, 20, 20> );  //Reibung, auch Bremswirkung
    llSetVehicleVectorParam( VEHICLE_LINEAR_MOTOR_DIRECTION, <0, 0, 0> );        // Lineare Geschwindigkeit. Wird hier nur gesetzt, wenn das Fahrzeug direkt losfahren soll
    llSetVehicleFloatParam( VEHICLE_LINEAR_MOTOR_TIMESCALE, 2 );                 // Zeit bis zur maximalen Geschwindigkeit
    llSetVehicleFloatParam( VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE, 60 );        //Zeit für den Abbau der Antriebskraft (exponentiell)
    
    // agular motor kurven Motor
    llSetVehicleVectorParam( VEHICLE_ANGULAR_MOTOR_DIRECTION, <0, 0, 0> );      // Winkelgeschwindigkeit. Wird hier nur gesetzt, wenn das Fahrzeug direkt losfahren soll
    llSetVehicleFloatParam( VEHICLE_ANGULAR_MOTOR_TIMESCALE, 0.3 );                 // Zeit bis zur maximalen Geschwindigkeit
    llSetVehicleFloatParam( VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE, 0.4);       //Zeit für den Abbau der Antriebskraft (exponentiell)
    llSetVehicleVectorParam( VEHICLE_ANGULAR_FRICTION_TIMESCALE, <1,0.5,1>);    ////Reibung, auch Bremswirkung
    
    // hover  Schweben
    llSetVehicleFloatParam( VEHICLE_HOVER_HEIGHT, 0 );                          //Schwebehöhe, Auf die zugehörigen Flags achten
    llSetVehicleFloatParam( VEHICLE_HOVER_EFFICIENCY, 0 );                      // Schieberegler zwischen 0 (federnd) und 1 (kritisch gedämpft) Schwebeverhalten
    llSetVehicleFloatParam( VEHICLE_HOVER_TIMESCALE, 10 );                      // Zeitspanne, bis das Fahrzeug seine Schwebehöhe erreicht
    llSetVehicleFloatParam( VEHICLE_BUOYANCY, .977 );                           // Schieberegler zwischen -1 (Doppelgravitation) und 1 (volle Antigravitation) NIEMALS mit llSetBuoyancy mischen
        
    // linear deflection  Ausrichtung, wie das Fahrzeug versucht sich in seine Bewegungsrichtung auszurichten
    llSetVehicleFloatParam( VEHICLE_LINEAR_DEFLECTION_EFFICIENCY, 0.2 );        // Schieberegler zwischen 0 (keine Ausrichtung) und 1 (maximale Stärke)
    llSetVehicleFloatParam( VEHICLE_LINEAR_DEFLECTION_TIMESCALE, 0.5 );         // exponentielle Zeitskala für das Fahrzeug, um die volle Ausrichtung zu erreichen
        
    // angular deflection Ausrichtung, wie das Fahrzeug versucht sich in seine Bewegungsrichtung auszurichten
    llSetVehicleFloatParam( VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY, 1);          // Schieberegler zwischen 0 (keine Ausrichtung) und 1 (maximale Stärke)
    llSetVehicleFloatParam( VEHICLE_ANGULAR_DEFLECTION_TIMESCALE, 0.3);         // exponentielle Zeitskala für das Fahrzeug, um die volle Ausrichtung zu erreichen
            
    // vertical attractor Aufrichter, wie das Fahrzeug aus der Kurvenneigung zurückkommt
    llSetVehicleFloatParam( VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY, 0.2 );      // Schieberegler zwischen 0 (federnd) und 1 (kritisch gedämpft) Anziehung der Fahrzeug-Z-Achse zur Welt-Z-Achse (vertikal)
    llSetVehicleFloatParam( VEHICLE_VERTICAL_ATTRACTION_TIMESCALE, 5.0 );       // exponentielle Zeitskala für das Fahrzeug, um seine Z-Achse an der Welt-Z-Achse (vertikal) auszurichten
         
    // banking  Kurvenneigung
    llSetVehicleFloatParam( VEHICLE_BANKING_EFFICIENCY, 1.0);                   // Schieberegler zwischen -1 (aus Kurven herausgeneigt), 0 (keine Neigung) und +1 (in Kurven hineingeneigt)
    llSetVehicleFloatParam( VEHICLE_BANKING_MIX, 1.0);                          // Schieberegler zwischen 0 (statisches Banking) und 1 (dynamisches Banking)
    llSetVehicleFloatParam( VEHICLE_BANKING_TIMESCALE, 0.5);                    // exponentielle Zeitspanne, bis das Bankingverhalten seine volle Wirkung entfaltet
        
        
    // default rotation of local frame   Fahrtrichtung hier positive x-Achse
    llSetVehicleRotationParam( VEHICLE_REFERENCE_FRAME,<0.000, 0.000, 0.000, 1.000>);  // Fahrtrichtung anstelle des Quaternions kann auch llEuler2Rot(<0,0,0>*DEG_TO_RAD) geschrieben werden
        
    // alle flags entfernen, macht Sinn wenn ihr das Script in ein vorhandenes Fahrzeug kopiert
    llRemoveVehicleFlags( VEHICLE_FLAG_NO_DEFLECTION_UP                     // Dieses Flag verhindert eine lineare Ablenkung parallel zur Welt-Z-Achse. Dies ist nützlich, um zu verhindern, dass Bodenfahrzeuge mit großer linearer Ablenkung, wie z. B. Autoscooter, ihre lineare Ablenkung verlieren und in den Himmel klettern.
                          | VEHICLE_FLAG_HOVER_WATER_ONLY                   // Ignoriert die Geländehöhe beim Schweben.
                          | VEHICLE_FLAG_HOVER_TERRAIN_ONLY                 // Ignoriert die Wasserhöhe beim Schweben.
                          | VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT                // Schwebt auf globaler Höhe statt auf Höhe über dem Boden oder Wasser.
                          | VEHICLE_FLAG_HOVER_UP_ONLY                      // Schweben drückt nicht nach unten. Verwende dieses Flag für schwebende Fahrzeuge, die über ihre Schwebehöhe springen können sollen.
                          | VEHICLE_FLAG_LIMIT_MOTOR_UP                     // Verhindert, dass Bodenfahrzeuge in den Himmel steigen. Diese Markierung hat einen subtilen Effekt in Verbindung mit einer Schräglage: Die Schräglage nimmt ab, sobald das Fahrzeug keine Kollisionen mehr erfährt. Die Abklingzeit entspricht der von VEHICLE_BANKING_TIMESCALE. Dies soll verhindern, dass Bodenfahrzeuge während des Sprungs lenken.
                          | VEHICLE_FLAG_CAMERA_DECOUPLED                   // Lässt die Mausblick-Kamera unabhängig vom Fahrzeug rotieren. Standardmäßig rotiert die Mausblick-Kamera des Clients mit dem Fahrzeug. Ist dieses Flag jedoch gesetzt, ist die Kamerarichtung unabhängig von der Fahrzeugrotation.
                          | VEHICLE_FLAG_LIMIT_ROLL_ONLY                    // Für Fahrzeuge mit vertikalem Attraktor, die steigen/tauchen können sollen, beispielsweise Flugzeuge, die die Schräglagefunktion nutzen möchten.
                          | VEHICLE_FLAG_MOUSELOOK_STEER                    // Steuert das Fahrzeug mit der Maus. Verwende dieses Flag, damit der Winkelmotor versucht, das Fahrzeug so zu drehen, dass seine lokale X-Achse in die gleiche Richtung zeigt wie die clientseitige Kamera.
                          | VEHICLE_FLAG_MOUSELOOK_BANK                     // Wie oben, basiert aber auf der Neigung. Es ordnet Links-Rechts-Bewegungen der Client-Kamera (auch als „Gieren“ bezeichnet) Rotationen um die lokale x-Achse des Fahrzeugs zu. ( Für Flugzeuge genial)
                          );
    
    
    // hier die benötigten flags setzen Erklärung siehe oben
    llSetVehicleFlags( VEHICLE_FLAG_NO_DEFLECTION_UP 
                        | VEHICLE_FLAG_LIMIT_ROLL_ONLY 
                        | VEHICLE_FLAG_HOVER_UP_ONLY 
                        | VEHICLE_FLAG_LIMIT_MOTOR_UP);
}
default
{
    state_entry()
    //start des Scriptes, nicht mit Objekt wird gerezt zu verwechseln
    {
        init();
        llSitTarget(<0,0,1.0>, llEuler2Rot(<0,0,0>*DEG_TO_RAD));  // darf nicht komplett Null sein, sonst kommt kein llAvatarOnSitTarget
    }
    changed(integer change) 
    //Es verändert sich etwas an oder im Objekt
    {
        if (change & CHANGED_LINK)  // Ein Avatar der sich setzt oder aufsteht wird mit dem Objekt ver- oder entlinkt
        {
            avatar = llAvatarOnSitTarget();
            if ( avatar != NULL_KEY)  // avatar sitzt
            {
                llRequestPermissions(avatar, PERMISSION_TAKE_CONTROLS | PERMISSION_TRIGGER_ANIMATION);  // Wenn der Avatar in dem Menü antowrtet wird das run_time_permissions Event ausgelöst
            }
            else //Avatar steht auf
            {
                llSetStatus(STATUS_PHYSICS, FALSE);  // Parkbremse anziehen :))
            }
        }
    }
    run_time_permissions(integer perm) 
    // Zugriffsrechte für den Avatar 
    {
        if (perm & PERMISSION_TAKE_CONTROLS)  
        // controls abfragen reicht, da für alle Rechte nur eine Anfrage gestellt wird
        {
            llTakeControls(CONTROL_FWD  // Pfeiltaste nach oben
            | CONTROL_BACK              // Pfeiltaste nach unten
            | CONTROL_DOWN              // Bild unten / page down
            | CONTROL_UP                // Bild oben / page up
            | CONTROL_RIGHT             // Shift + Pfeil rechts
            | CONTROL_LEFT              // Shift + Pfeil links
            | CONTROL_ROT_RIGHT         // Pfeil links
            | CONTROL_ROT_LEFT          // Pfeil rechts
            , TRUE                      // TRUE, wenn eine der definierten Taste ngedrückt wird, wird das controll event ausgelöst. FALSE, das control event wird nicht ausgelöst
            , FALSE                     // FALSE, die normale Funktion der Taste(z.b. gehen) wird ausgeschaltet, TRUE, die normale Funktion wird ausgeführt
            );             
            llStartAnimation(animation);
            llSetStatus(STATUS_PHYSICS, TRUE);  // Bremse lösen //
        }
    }
    control(key id, integer level, integer edge) 
    // wird eine Aktion mit den in llTakeControls festgelegten Tasten durchgeführt
    { 
        integer start = level & edge;           // Taste wird gedrückt
        integer end = ~level & edge;            // Taste wird losgelassen
        integer held = level & ~edge;           //Taste wird gedrückt gehalten
        integer untouched = ~(level | edge);    // Taste ist nicht gedrückt, kann nur ausgewertet werden, wenn der Event durch eine andere Taste ausgelöst wurde
        
        vector speed = <0.0, 0.0, 0.0>;
        vector anglespeed = <0.0, 0.0, 0.>;

        if ((start | held )& CONTROL_FWD)  // vorwärts
        {
            speed.x = llList2Float(geschwindigkeiten,gang);
        }
        else if ((start | held) & CONTROL_BACK)   // rückwärts
        {
            gang = 0;  // auf den ersten Gang zurück schalten
            speed.x = rueckwaerts;
        }
        
        if ((start | held) & CONTROL_ROT_LEFT)  // nach links
        {
            anglespeed.z = llList2Float(kurvenbewegung, gang)* llList2Float(geschwindigkeiten, gang);
        }
        else if ((start | held) & CONTROL_ROT_RIGHT)  // nach rechts
        {
            anglespeed.z = -1.0 * llList2Float(kurvenbewegung, gang)* llList2Float(geschwindigkeiten, gang);
        }
        
        if (start & CONTROL_UP)  // gang hoch
        {
            if (gang < llGetListLength(geschwindigkeiten)-1)
            {
                gang ++;
                llWhisper(0,(string) (gang+1) + " Gang eingelegt.");  // gang+1 weil der Listenindex bei Null beginnt, aber die Chat Ausgabe  mit Eins beginnnen soll
            }
        }
        else if (start & CONTROL_DOWN)  //gang runter
        {
            if (gang >0)
            {
                gang--;
                llWhisper(0,(string) (gang+1) + " Gang eingelegt.");    // gang+1 weil der Listenindex bei Null beginnt, aber die Chat Ausgabe  mit Eins beginnnen soll
            }
        }
        // Motoren ansprechen
        llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION,speed);        // Linear Motor
        llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION,anglespeed);   // Kurven Motor
    }
}