Discussion: Simple RC Chopper Script

Current Version

///////////////////\\\\\\\\\\\\\\\\
//Updated RC Chopper Script\\
///////By Mrc Homewood\\\\\\\
///////////////////\\\\\\\\\\\\\\\\\

// Rudder/H4 updated (BETA)

vector angular_motor;
float myMass;
float speed = 0;
float turn = 0;
float lift = 0;
float rudder = 0;
integer move = FALSE;
integer turning = FALSE;


key avatar;
integer on;

default
{
    state_entry()
    {
        llSay(0,"Preparing Helicopter");
llSetTimerEvent(.1);        
myMass = llGetMass();
        llSetVehicleType(VEHICLE_TYPE_AIRPLANE);
        llRemoveVehicleFlags(-1);
        llSetVehicleVectorParam( VEHICLE_LINEAR_FRICTION_TIMESCALE, <1, 2, 1> );
        llSetVehicleVectorParam( VEHICLE_ANGULAR_FRICTION_TIMESCALE, <0.5,0.5,0.5> );
        llSetVehicleVectorParam( VEHICLE_LINEAR_MOTOR_DIRECTION, <0, 0, 0> );
        llSetVehicleFloatParam( VEHICLE_LINEAR_MOTOR_TIMESCALE, 0.2 );
        llSetVehicleFloatParam( VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE, 0.75 );
        llSetVehicleVectorParam( VEHICLE_ANGULAR_MOTOR_DIRECTION, <0, 0, 0> );
        llSetVehicleFloatParam( VEHICLE_ANGULAR_MOTOR_TIMESCALE, 0.2 );
        llSetVehicleFloatParam( VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE, 0.3 );
        llSetVehicleFloatParam( VEHICLE_HOVER_HEIGHT, 0 );
        llSetVehicleFloatParam( VEHICLE_HOVER_EFFICIENCY, 0 );
        llSetVehicleFloatParam( VEHICLE_HOVER_TIMESCALE, 1000 );
        llSetVehicleFloatParam( VEHICLE_BUOYANCY, 0.99 );
        llSetVehicleFloatParam( VEHICLE_LINEAR_DEFLECTION_EFFICIENCY, 1 );
        llSetVehicleFloatParam( VEHICLE_LINEAR_DEFLECTION_TIMESCALE, 2 );
        llSetVehicleFloatParam( VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY, 1 );
        llSetVehicleFloatParam( VEHICLE_ANGULAR_DEFLECTION_TIMESCALE, 2 );
        llSetVehicleFloatParam( VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY, 0.5 );
        llSetVehicleFloatParam( VEHICLE_VERTICAL_ATTRACTION_TIMESCALE, 2 );
        llSetVehicleFloatParam( VEHICLE_BANKING_EFFICIENCY, 0.7 );
        llSetVehicleFloatParam( VEHICLE_BANKING_MIX, 0.5 );
        llSetVehicleFloatParam( VEHICLE_BANKING_TIMESCALE, 0.2 );
        llSetVehicleRotationParam( VEHICLE_REFERENCE_FRAME, <0, 0, 0, 1> );
        llRemoveVehicleFlags( VEHICLE_FLAG_HOVER_WATER_ONLY
                            | VEHICLE_FLAG_HOVER_TERRAIN_ONLY
                            | VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT
                            | VEHICLE_FLAG_LIMIT_ROLL_ONLY
                            | VEHICLE_FLAG_HOVER_UP_ONLY
                            | VEHICLE_FLAG_LIMIT_MOTOR_UP);

        llStopSound();
        llCollisionSound("", 0.0);
        llSetStatus(STATUS_PHYSICS, FALSE);
        llSay(0,"Helicopter is ready to fly");
    }

    touch_start(integer t)
    {
        avatar = llDetectedKey(0);
        string name=llKey2Name(avatar);
            if((avatar == llGetOwner()) && (on == TRUE))
            {
                llSetStatus(STATUS_PHYSICS, FALSE);
                llStopSound();
                llSetStatus(STATUS_ROTATE_X | STATUS_ROTATE_Y | STATUS_ROTATE_Z, FALSE);
                llReleaseControls();
                on = FALSE;
            }
            else if((avatar == llGetOwner()) && (on == FALSE))
            {
                llSetStatus(STATUS_ROTATE_X | STATUS_ROTATE_Y | STATUS_ROTATE_Z, TRUE);
                llRequestPermissions(avatar,PERMISSION_TAKE_CONTRO  LS);
                on = TRUE;
            }
    }

    run_time_permissions(integer perms)
    {
        if(perms & (PERMISSION_TAKE_CONTROLS))
        {
            llTakeControls(CONTROL_FWD | CONTROL_BACK | CONTROL_RIGHT | CONTROL_LEFT | CONTROL_ROT_RIGHT | CONTROL_ROT_LEFT | CONTROL_UP | CONTROL_DOWN, TRUE, FALSE);
            llSetStatus(STATUS_PHYSICS, TRUE);
        }
        else
        {
            llReleaseControls();
            llSetStatus(STATUS_PHYSICS,FALSE);
        }
    }

    control(key id, integer level, integer edge)
    {
        if (level & CONTROL_FWD)
        {
            angular_motor.y = .5; // front tilt
            speed = 2; // fwd power
            move = TRUE;
        }

        if (level & CONTROL_BACK)
        {
            angular_motor.y = -.2;//back tilt
            speed = -.9; // reverse power
            move = TRUE;
        }

        if (level & CONTROL_UP)
        {
            lift = .8; // up speed
            move = TRUE;
        }

        if (level & CONTROL_DOWN)
        {
            lift = -.6; // down speed
            move = TRUE;
        }

        if ((level & CONTROL_ROT_RIGHT) || (level & CONTROL_RIGHT))
        {
            turn = 5; // right turn/bank speed
            rudder = -.1;
            turning = TRUE;
        }

        if ((level & CONTROL_ROT_LEFT) || (level & CONTROL_LEFT))
        {
            turn = -5; // left turn/bank speed
            rudder = .1;
            turning = TRUE;
        }

        if(move)
        {
            llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIREC  TION, <speed,0,lift>);
            llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRE  CTION, angular_motor);
            angular_motor.y = 0;
            lift = 0;
            speed = 0;
            move = FALSE;
        }

        if(turning)
        {
            if(speed < 1)
            {
                llApplyRotationalImpulse(<0,0,rudder> * myMass, TRUE);
                turn = 0;
                rudder = 0; 
                turning = FALSE;
            }
            else
            {
                llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRE  CTION, <turn,0,0>);
                turn = 0;
                turning = FALSE;
            }
        }

    }
    timer()
    {
        integer speed = (integer)(llVecMag(llGetVel()) * 1.94384449 + 0.5);
    }
    on_rez(integer start_param)
    {
        llResetScript();
    }
} 

Current Bugs:
Turning/Moving = Alt Lose/Gain

This updated version appears to work just fine for piloting directly (non-remote-controlled). So, whatever was preventing that before seems to have gone away.

It seems to work relatively on the surface; though the altitude drifting problem exists. And the speed in all directions is agonizingly slow. I suppose that's an easy enough adjustment though.

Any idea what we can do about the altitude drop?

Thanks for sharing this!