Second Life Copybot

Full Version: Girl PINK CAR + SCRIPT,SOND AND ANIM
You're currently viewing a stripped down version of our content. View the full version with proper formatting.
SONDS UUID:

tunner run d13e4f99-372e-3e86-09f2-3cede5bd7063
car starter 9255ae87-5ed6-4519-4b5a-7e1b1c3693f6
car startup b0572b96-c967-17d6-99df-44fe7a847462
car_idle 7b7acab0-9323-8cbf-ef14-e3548c7edf5c


ANIM FOR SIT IN THE CAR:

UUID: driving generic 4309ebc1-c123-1c45-bb34-12d69229fa09
This animation also in the download in format bvh and anim.

Car Script
PHP Code:
//Drifting Thoughts Car script
//by Kayla Stonecutter
//Date: 3/20/2006
//


//Basic settings
float       ForwardPower//Forward power
list        ForwardPowerGears = [1530456012016020060060000];
float       ReversePower = -40//Reverse power
float       TurnPower 30//Turning power
float       TurnSpeedAdjust 1.0//how much effect speed has on turning, higher numbers effect more. 0.0 to disable

float       FlightForwardPower 24;
float       FlightReversePower 16;
float       FlightUpPower 14;
float       FlightDownPower 14;
float       FlightStrafePower 12;
float       FlightTurnPower 4;


string      SitText "Roll Out"//Text to show on pie menu
string      NonOwnerMessage "GET YOUR OWN CAR YOU ASSHOLE!"//Message when someone other than owner tries to sit

string      OwnerName;
integer     ListenCh 3;
string      HornCommand "h";
string      RevCommand "r";
string      IdleCommand "i";
string      StopCommand "s";
string      FlightCommand "f";
string      GroundCommand "g";
string      BurnCommand "burn";

string      FlightSound "Flight";
string      HornSound "loud horn";
string      NonOwnerSound "Alarm";
string      IdleSound "car_idle"//Sound to play when idling
string      RunSound "tunner run"//Sound to play when the gas in pressed
string      RevSound "tunner rev";
string      StartupSound "car startup"//Sound to play when owner sits
string      DrivingAnim "driving generic"//Animation to play when owner sits

//Other variables
key         Owner;
integer     NumGears;
integer     Gear 0;
integer     NewSound;
string      Sound;
integer     CurDir;
integer     LastDir;
integer     Forward;
vector      SpeedVec;
vector      Linear;
vector      Angular;
integer     Active;
key         sitting;
integer     Moving;
string      SimName;

integer     DIR_STOP 100;
integer     DIR_START 101;
integer     DIR_NORM 102;
integer     DIR_LEFT 103;
integer     DIR_RIGHT 104;
integer     DIR_FLIGHT 105;


default
{
    
state_entry()
    {
        
Owner llGetOwner();
        
OwnerName llKey2Name(Owner);
        
TurnSpeedAdjust *= 0.01;
        
ForwardPower llList2Integer(ForwardPowerGears0);
        
NumGears llGetListLength(ForwardPowerGears);
        
llSetSitText(SitText);
        
llCollisionSound(""0.0);
        
llSitTarget(<0.6,0.65,0.5>, llEuler2Rot(<0,0,0> ));
        
state Ground;
    }
}

state Ground
{
    
state_entry()
    {
        
llListen(ListenChOwnerNameNULL_KEY"");
        
llStopSound();
        if(!
Active)
        {
            
llSetStatus(STATUS_PHYSICSFALSE);
            
llMessageLinked(LINK_ALL_CHILDREN DIR_STOP""NULL_KEY);
            
llUnSit(llAvatarOnSitTarget());
        }else{
            
SimName llGetRegionName();
            
llMessageLinked(LINK_ALL_CHILDRENDIR_START""NULL_KEY);
            
llMessageLinked(LINK_ALL_CHILDRENDIR_NORM""NULL_KEY);
            
NewSound 1;
            
Sound IdleSound;
            
Linear = <0,0,-2>;
        }
        
        
llSetVehicleType(VEHICLE_TYPE_CAR);
        
llSetVehicleFloatParam(VEHICLE_LINEAR_DEFLECTION_EFFICIENCY0.80);
        
llSetVehicleFloatParam(VEHICLE_LINEAR_DEFLECTION_TIMESCALE1.0);
        
        
llSetVehicleFloatParam(VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY0.2);
        
llSetVehicleFloatParam(VEHICLE_ANGULAR_DEFLECTION_TIMESCALE0.1);
        
        
llSetVehicleFloatParam(VEHICLE_LINEAR_MOTOR_TIMESCALE1.0);
        
llSetVehicleFloatParam(VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE0.1);
        
        
llSetVehicleFloatParam(VEHICLE_ANGULAR_MOTOR_TIMESCALE0.3);
        
llSetVehicleFloatParam(VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE0.1);
        
        
llSetVehicleVectorParam(VEHICLE_LINEAR_FRICTION_TIMESCALE, <100.02.01000.0> );
        
llSetVehicleVectorParam(VEHICLE_ANGULAR_FRICTION_TIMESCALE, <1000.01000.01000.0> );
        
        
llSetVehicleFloatParam(VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY0.0);
        
llSetVehicleFloatParam(VEHICLE_VERTICAL_ATTRACTION_TIMESCALE300.0);
        
        
llSetVehicleFloatParam(VEHICLE_HOVER_HEIGHT);
        
llSetVehicleFloatParam(VEHICLE_HOVER_EFFICIENCY);
        
llSetVehicleFloatParam(VEHICLE_HOVER_TIMESCALE1000 );
        
llSetVehicleFloatParam(VEHICLE_BUOYANCY);
        
        
llRemoveVehicleFlags(VEHICLE_FLAG_HOVER_WATER_ONLY VEHICLE_FLAG_HOVER_TERRAIN_ONLY VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT);
        
        
llSetVehicleFlags(VEHICLE_FLAG_NO_DEFLECTION_UP VEHICLE_FLAG_LIMIT_ROLL_ONLY VEHICLE_FLAG_HOVER_UP_ONLY VEHICLE_FLAG_LIMIT_MOTOR_UP);
    }
    
    
on_rez(integer param)
    {
        
llResetScript();
    }
    
    
listen(integer channelstring namekey idstring message)
    {
        if(
llGetOwnerKey(id) != Owner) return;
        
message llToLower(message);
        if(
message == HornCommandllMessageLinked(LINK_SET12345HornSoundNULL_KEY);
        else if(
message == RevCommandllMessageLinked(LINK_SET12345RevSoundNULL_KEY);
        else if(
message == IdleCommandllLoopSound(IdleSound1.0);
        else if(
message == StopCommandllStopSound();
        else if((
message == FlightCommand) && Activestate Flight;
        else if(
message == BurnCommand) { llMessageLinked(LINK_SET5000"burnout"NULL_KEY); llLoopSound(RunSound,1.0); llSleep(10); llLoopSound(IdleSound,1.0); }
    }
    
    
changed(integer change)
    {
        if((
change CHANGED_LINK) == CHANGED_LINK)
        {
            
sitting llAvatarOnSitTarget();
            if((
sitting != NULL_KEY) && !Active)
            {
                if(
sitting != llGetOwner())
                {
                    
llWhisper(0NonOwnerMessage);
                    
llTriggerSound(NonOwnerSound1.0);
                    
llUnSit(sitting);
                }else{
                    
llRequestPermissions(OwnerPERMISSION_TRIGGER_ANIMATION PERMISSION_TAKE_CONTROLS PERMISSION_CONTROL_CAMERA);
                    
llTriggerSound(StartupSound1.0);
                    
llMessageLinked(LINK_ALL_CHILDRENDIR_START""NULL_KEY);
                    
llSetPos(llGetPos() + <0,0,0.15>);
                    
llSetStatus(STATUS_PHYSICSTRUE);
                    
SimName llGetRegionName();
                    
llLoopSound(IdleSound,1);
                    
llSetTimerEvent(0.1);
                    
CurDir DIR_NORM;
                    
LastDir DIR_NORM;
                }
            }else if((
sitting == NULL_KEY) && Active)
            {
                
llSetTimerEvent(0.0);
                
llStopAnimation(DrivingAnim);
                
Active 0;
                
llStopSound();
                
llSetStatus(STATUS_PHYSICSFALSE);
                
llMessageLinked(LINK_ALL_CHILDREN DIR_STOP""NULL_KEY);
                
llReleaseControls();
            }
        }
    }
    
    
run_time_permissions(integer perms)
    {
        if(
perms == (PERMISSION_TRIGGER_ANIMATION PERMISSION_TAKE_CONTROLS PERMISSION_CONTROL_CAMERA))
        {
            
Active 1;
            
Linear = <0,0,-2>;
            
Angular = <0,0,0>;
            
llStopAnimation("sit");
            
llStartAnimation(DrivingAnim);
            
llTakeControls(CONTROL_FWD CONTROL_BACK CONTROL_DOWN CONTROL_UP CONTROL_RIGHT CONTROL_LEFT CONTROL_ROT_RIGHT CONTROL_ROT_LEFTTRUEFALSE);
            
llSetCameraParams([
                
CAMERA_ACTIVE1// 1 is active, 0 is inactive
                
CAMERA_BEHINDNESS_ANGLE2.0// (0 to 180) degrees
                
CAMERA_BEHINDNESS_LAG0.1// (0 to 3) seconds
                
CAMERA_DISTANCE8.0// ( 0.5 to 10) meters
                // CAMERA_FOCUS, <0,0,0>, // region-relative position
                
CAMERA_FOCUS_LAG0.1 // (0 to 3) seconds
                
CAMERA_FOCUS_LOCKEDFALSE// (TRUE or FALSE)
                
CAMERA_FOCUS_THRESHOLD0.5// (0 to 4) meters
                
CAMERA_PITCH20.0// (-45 to 80) degrees
                // CAMERA_POSITION, <0,0,0>, // region-relative position
                
CAMERA_POSITION_LAG0.1// (0 to 3) seconds
                
CAMERA_POSITION_LOCKEDFALSE// (TRUE or FALSE)
                
CAMERA_POSITION_THRESHOLD0.5// (0 to 4) meters
                
CAMERA_FOCUS_OFFSET, <0,0,0// <-10,-10,-10> to <10,10,10> meters
            
]);
        }
    }
    
    
control(key idinteger levelsinteger edges)
    {
        if(!
Moving)
        {
            
Moving 1;
            
llSetStatus(STATUS_PHYSICSTRUE);
        }
        
SpeedVec llGetVel() / llGetRot();
        if((
edges levels CONTROL_UP))
        {
            if((
Gear 1) != NumGears)
            {
                ++
Gear;
                
llWhisper(0"Gear " + (string)(Gear 1));
                
ForwardPower llList2Float(ForwardPowerGearsGear);
                if(
Linear.0Linear.ForwardPower;
            }
        }else if((
edges levels CONTROL_DOWN))
        {
            if((
Gear 1) != -1)
            {
                --
Gear;
                
llWhisper(0"Gear " + (string)(Gear 1));
                
ForwardPower llList2Float(ForwardPowerGearsGear);
                if(
Linear.0Linear.ForwardPower;
            }
        }
        if((
edges levels CONTROL_FWD))
        {
            
Linear.+= ForwardPower;
            
NewSound 1;
        }else if((
edges & ~levels CONTROL_FWD))
        {
            
Linear.-= ForwardPower;
            
NewSound 1;
        }
        if((
edges levels CONTROL_BACK))
        {
            
Linear.+= ReversePower;
            
NewSound 1;
        }else if((
edges & ~levels CONTROL_BACK))
        {
            
Linear.-= ReversePower;
            
NewSound 1;
        }
        if(
NewSound)
        {
            if(
Linear.xSound RunSound;
            else 
Sound IdleSound;
        }
        if(
llFabs(SpeedVec.x) < 0.5)
        {
            if(
levels CONTROL_ROT_LEFTCurDir DIR_LEFT;
            else if(
levels CONTROL_ROT_RIGHTCurDir DIR_RIGHT;
            else 
CurDir DIR_NORM;
            
Angular.0.0;
        }else{
            if(
SpeedVec.0.0)
            {
                
Forward = -1;
                
SpeedVec.*= -TurnSpeedAdjust;
            }else{
                
Forward 1;
                
SpeedVec.*= TurnSpeedAdjust;
            }
            if(
levels CONTROL_ROT_LEFT)
            {
                
CurDir DIR_LEFT;
                
Angular.= (TurnPower SpeedVec.x) * Forward;
            }else if((
edges & ~levels CONTROL_ROT_LEFT))
            {
                
CurDir DIR_NORM;
                
Angular.0;
            }
            if(
levels CONTROL_ROT_RIGHT)
            {
                
CurDir DIR_RIGHT;
                
Angular.= -((TurnPower SpeedVec.x) * Forward);
            }else if((
edges & ~levels CONTROL_ROT_RIGHT))
            {
                
CurDir DIR_NORM;
                
Angular.0;
            }
        }
    }
    
    
moving_end()
    {
        if(
llGetRegionName() == SimName)
        {
            
Moving 0;
            
llSetStatus(STATUS_PHYSICSFALSE);
        }else{
            
SimName llGetRegionName();
        }
    }
    
    
timer()
    {
        if(
Linear != <0.0,  0.0, -2.0>)
        {
            
llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTIONLinear);
            
llApplyImpulse(LinearTRUE);
        }
        if(
Angular != <0.00.00.0>) llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTIONAngular);
        if(
CurDir != LastDir)
        {
            
llMessageLinked(LINK_ALL_CHILDRENCurDir""NULL_KEY);
            
LastDir CurDir;
        }
        if(
NewSound)
        {
            
llStopSound();
            
NewSound 0;
            
llLoopSound(Sound1.0);
        }
    }
}

state Flight
{
    
state_entry()
    {
        
Linear = <0,0,0>;
        
llStopSound();
        
llMessageLinked(LINK_ALL_CHILDRENDIR_FLIGHT""NULL_KEY);
        
llLoopSound(FlightSound1.0);
        
llSetStatus(STATUS_PHYSICSFALSE);
        
llSetPos(llGetPos() + <0,0,0.25>);
        
vector rot llRot2Euler(llGetRot());
        
llSetRot(llEuler2Rot(<0,0,rot.z>));
        
llListen(ListenChOwnerNameNULL_KEY"");
        
llSetVehicleType(VEHICLE_TYPE_AIRPLANE);
        
        
// linear friction
        
llSetVehicleVectorParam(VEHICLE_LINEAR_FRICTION_TIMESCALE, <100.0100.0100.0>);
        
        
// uniform angular friction
        
llSetVehicleFloatParam(VEHICLE_ANGULAR_FRICTION_TIMESCALE0.5);
        
        
// linear motor
        
llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <0.00.00.0>);
        
llSetVehicleFloatParam(VEHICLE_LINEAR_MOTOR_TIMESCALE1.0);
        
llSetVehicleFloatParam(VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE1.0);
        
        
// angular motor
        
llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, <0.00.00.0>);
        
llSetVehicleFloatParam(VEHICLE_ANGULAR_MOTOR_TIMESCALE1.0);
        
llSetVehicleFloatParam(VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE2.0);
        
        
// hover
        
llSetVehicleFloatParam(VEHICLE_HOVER_HEIGHT0.0);
        
llSetVehicleFloatParam(VEHICLE_HOVER_EFFICIENCY0.0);
        
llSetVehicleFloatParam(VEHICLE_HOVER_TIMESCALE360.0);
        
llSetVehicleFloatParam(VEHICLE_BUOYANCY0.988);
        
        
// linear deflection
        
llSetVehicleFloatParam(VEHICLE_LINEAR_DEFLECTION_EFFICIENCY0.0);
        
llSetVehicleFloatParam(VEHICLE_LINEAR_DEFLECTION_TIMESCALE1.0);
        
        
// angular deflection
        
llSetVehicleFloatParam(VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY0.25);
        
llSetVehicleFloatParam(VEHICLE_ANGULAR_DEFLECTION_TIMESCALE100.0);
        
        
// vertical attractor
        
llSetVehicleFloatParam(VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY0.5);
        
llSetVehicleFloatParam(VEHICLE_VERTICAL_ATTRACTION_TIMESCALE1.0);
        
        
// banking
        
llSetVehicleFloatParam(VEHICLE_BANKING_EFFICIENCY0.0);
        
llSetVehicleFloatParam(VEHICLE_BANKING_MIX1.0);
        
llSetVehicleFloatParam(VEHICLE_BANKING_TIMESCALE1.0);
        
        
// default rotation of local frame
        
llSetVehicleRotationParam(VEHICLE_REFERENCE_FRAME, <0.000000.000000.000000.00000>);
        
        
// removed vehicle flags
        
llRemoveVehicleFlags(VEHICLE_FLAG_NO_DEFLECTION_UP VEHICLE_FLAG_HOVER_WATER_ONLY VEHICLE_FLAG_HOVER_TERRAIN_ONLY VEHICLE_FLAG_HOVER_UP_ONLY VEHICLE_FLAG_LIMIT_MOTOR_UP VEHICLE_FLAG_LIMIT_ROLL_ONLY);
        
        
// set vehicle flags
        
llSetVehicleFlags(VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT);
        
llTakeControls(CONTROL_FWD CONTROL_BACK CONTROL_LEFT CONTROL_RIGHT CONTROL_ROT_LEFT CONTROL_ROT_RIGHT CONTROL_UP CONTROL_DOWN CONTROL_LBUTTONTRUEFALSE);
        
        
llSetStatus(STATUS_PHYSICSTRUE);
    }
    
    
listen(integer channelstring namekey idstring message)
    {
        if(
llGetOwnerKey(id) != Owner) return;
        
message llToLower(message);
        if(
message == GroundCommandstate Ground;
    }
    
    
control(key nameinteger levelsinteger edges)
    {
        if((
levels CONTROL_LBUTTON))
        {
            
llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <0,0,0>);
            
llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, <0,0,0>);
            
llSetStatus(STATUS_PHYSICSFALSE);
            
llSleep(0.1);
            
llSetStatus(STATUS_PHYSICSTRUE);
            return;
        }
        
        if((
edges levels CONTROL_UP)) Linear.+= FlightUpPower;
        else if((
edges & ~levels CONTROL_UP)) Linear.0.0;
        
        if((
edges levels CONTROL_DOWN)) Linear.-= FlightDownPower;
        else if((
edges & ~levels CONTROL_DOWN)) Linear.0.0;
        
        if((
edges levels CONTROL_FWD)) Linear.+= FlightForwardPower;
        else if((
edges & ~levels CONTROL_FWD)) Linear.0.0;
        
        if((
edges levels CONTROL_BACK)) Linear.-= FlightReversePower;
        else if((
edges & ~levels CONTROL_BACK)) Linear.0.0;
        
        if((
edges levels CONTROL_LEFT)) Linear.+= FlightStrafePower;
        else if((
edges & ~levels CONTROL_LEFT)) Linear.0.0;
        
        if((
edges levels CONTROL_RIGHT)) Linear.-= FlightStrafePower;
        else if((
edges & ~levels CONTROL_RIGHT)) Linear.0.0;
        
        if((
edges levels CONTROL_ROT_LEFT)) Angular.FlightTurnPower;
        else if((
edges & ~levels CONTROL_ROT_LEFT)) Angular.0;
        
        if((
edges levels CONTROL_ROT_RIGHT)) Angular.= -FlightTurnPower;
        else if((
edges & ~levels CONTROL_ROT_RIGHT)) Angular.0;
    }
    
    
changed(integer change)
    {
        if((
change CHANGED_LINK) == CHANGED_LINK)
        {
            
sitting llAvatarOnSitTarget();
            if(
sitting == NULL_KEY)
            {
                
llSetTimerEvent(0.0);
                
llStopAnimation(DrivingAnim);
                
Active 0;
                
llStopSound();
                
llSetStatus(STATUS_PHYSICSFALSE);
                
llMessageLinked(LINK_ALL_CHILDREN DIR_STOP""NULL_KEY);
                
llReleaseControls();
                
state Ground;
            }
        }
    }
    
    
timer()
    {
        
llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTIONLinear);

        
llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTIONAngular);
    }

shadowintel

interesting. i will say that
thx good car nice!!
lovely car héhé i try this ^^
thank you !!