Slide Down Walls

Alright, so I have just got into unity so I have been copy and pasting code and then looking over it thoroughly to see what makes it work. This code is mainly from the unity wiki. I am trying to make my character have a different gravity or increased friction on certain game objects like walls. I have tried many things, but none of them work, do you guys have any suggestions? The part I am writing is at the very bottom. I can get it to print "COOL" and jump, but it will not slow velocity.

// Does this script currently respond to Input?
var canControl = true;

// The character will spawn at spawnPoint's position when needed.  This could be changed via a script at runtime to implement, e.g. waypoints/savepoints.
var spawnPoint : Transform;

class PlatformerControllerMovement {
    // The speed when walking 
    var walkSpeed = 3.0;
    // when pressing "Fire1" button (control) we start running
    var runSpeed = 10.0;

    var inAirControlAcceleration = 1.0;

    // The gravity for the character
    var gravity = 60.0;
    var maxFallSpeed = 20.0;

    // How fast does the character change speeds?  Higher is faster.
    var speedSmoothing = 5.0;

    // This controls how fast the graphics of the character "turn around" when the player turns around using the controls.
    var rotationSmoothing = 10.0;

    // The current move direction in x-y.  This will always been (1,0,0) or (-1,0,0)
    // The next line, @System.NonSerialized , tells Unity to not serialize the variable or show it in the inspector view.  Very handy for organization!
    @System.NonSerialized
    var direction = Vector3.zero;

    // The current vertical speed
    @System.NonSerialized
    var verticalSpeed = 0.0;

    // The current movement speed.  This gets smoothed by speedSmoothing.
    @System.NonSerialized
    var speed = 0.0;

    // Is the user pressing the left or right movement keys?
    @System.NonSerialized
    var isMoving = false;

    // The last collision flags returned from controller.Move
    @System.NonSerialized
    var collisionFlags : CollisionFlags; 

    // We will keep track of an approximation of the character's current velocity, so that we return it from GetVelocity () for our camera to use for prediction.
    @System.NonSerialized
    var velocity : Vector3;

    // This keeps track of our current velocity while we're not grounded?
    @System.NonSerialized
    var inAirVelocity = Vector3.zero;

    // This will keep track of how long we have we been in the air (not grounded)
    @System.NonSerialized
    var hangTime = 0.0;
}

var movement : PlatformerControllerMovement;


// We will contain all the jumping related variables in one helper class for clarity.
class PlatformerControllerJumping {
    // Can the character jump?
    var enabled = true;

    // How high do we jump when pressing jump and letting go immediately
    var height = 1.0;
    // We add extraHeight units (meters) on top when holding the button down longer while jumping
    var extraHeight = 4.1;

    var doubleJumpHeight = 2.1;

    // This prevents inordinarily too quick jumping
    // The next line, @System.NonSerialized , tells Unity to not serialize the variable or show it in the inspector view.  Very handy for organization!
    @System.NonSerialized
    var repeatTime = 0.05;

    @System.NonSerialized
    var timeout = 0.15;

    // Are we jumping? (Initiated with jump button and not grounded yet)
    @System.NonSerialized
    var jumping = false;

    // Are where double jumping? ( Initiated when jumping or falling after pressing the jump button )
    @System.NonSerialized
    var doubleJumping = false;

    // Can we make a double jump ( we can't make two double jump or more at the same jump )
    @System.NonSerialized
    var canDoubleJump = false;

    @System.NonSerialized
    var reachedApex = false;

    // Last time the jump button was clicked down
    @System.NonSerialized
    var lastButtonTime = -10.0;

    // Last time we performed a jump
    @System.NonSerialized
    var lastTime = -1.0;

    // the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)
    @System.NonSerialized
    var lastStartHeight = 0.0;
}

var jump : PlatformerControllerJumping;

private var controller : CharacterController;

// Moving platform support.
private var activePlatform : Transform;
private var activeLocalPlatformPoint : Vector3;
private var activeGlobalPlatformPoint : Vector3;
private var lastPlatformVelocity : Vector3;

// This is used to keep track of special effects in UpdateEffects ();
private var areEmittersOn = false;

function Awake () {
    movement.direction = transform.TransformDirection (Vector3.forward);
    controller = GetComponent (CharacterController);
    Spawn ();
}

function Spawn () {
    // reset the character's speed
    movement.verticalSpeed = 0.0;
    movement.speed = 0.0;

    // reset the character's position to the spawnPoint
    transform.position = spawnPoint.position;

}

function OnDeath () {
    Spawn ();
}

function UpdateSmoothedMovementDirection () {   
    var h = Input.GetAxisRaw ("Horizontal");

    if (!canControl)
        h = 0.0;

    movement.isMoving = Mathf.Abs (h) > 0.1;

    if (movement.isMoving)
        movement.direction = Vector3 (h, 0, 0);

    // Grounded controls
    if (controller.isGrounded) {
        // Smooth the speed based on the current target direction
        var curSmooth = movement.speedSmoothing * Time.deltaTime;

        // Choose target speed
        var targetSpeed = Mathf.Min (Mathf.Abs(h), 1.0);

        // Pick speed modifier
        if (Input.GetButton ("Fire2") && canControl)
            targetSpeed *= movement.runSpeed;
        else
            targetSpeed *= movement.walkSpeed;

        movement.speed = Mathf.Lerp (movement.speed, targetSpeed, curSmooth);

        movement.hangTime = 0.0;
    }
    else {
        // In air controls
        movement.hangTime += Time.deltaTime;
        if (movement.isMoving)
            movement.inAirVelocity += Vector3 (Mathf.Sign(h), 0, 0) * Time.deltaTime * movement.inAirControlAcceleration;
    }
}
private var myTransform : Transform;
private var fallStartLevel : float;
private var moveDirection = Vector3.zero;


        function Start  () {
                oldPos = transform.position;
                    myTransform = transform;

        }

function FixedUpdate () {

    // Make sure we are absolutely always in the 2D plane.
 transform.position.z = 0;

     grounded = (controller.Move(moveDirection * Time.deltaTime) & CollisionFlags.Below) != 0;

 if (grounded) {

            if (falling) {
            falling = false;
         if (myTransform.position.y < (jump.lastStartHeight - fallingDamageThreshold))
               FallingDamageAlert (jump.lastStartHeight - myTransform.position.y);
 }
        else {
        if (!falling) {
            falling = true;
            fallStartLevel = myTransform.position.y;

        }
        }
 }



                  }

function ApplyJumping () {
    // Prevent jumping too fast after each other
    if (jump.lastTime + jump.repeatTime > Time.time)
        return;

    if (controller.isGrounded) {
        // Jump
        // - Only when pressing the button down
        // - With a timeout so you can press the button slightly before landing  
        if (jump.enabled && Time.time < jump.lastButtonTime + jump.timeout) {
            movement.verticalSpeed = CalculateJumpVerticalSpeed (jump.height);
            movement.inAirVelocity = lastPlatformVelocity;
            SendMessage ("DidJump", SendMessageOptions.DontRequireReceiver);

        }
    }
}

function ApplyGravity () {
    // Apply gravity
    var jumpButton = Input.GetButton ("Jump");



    if (!canControl)
        jumpButton = false;

    // When we reach the apex of the jump we send out a message
    if (jump.jumping && !jump.reachedApex && movement.verticalSpeed <= 0.0) {
        jump.reachedApex = true;
                falling = true;
print ("jump");
                 fallStartLevel = myTransform.position.y ;

        SendMessage ("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);
    }

    // if we are jumping and we press jump button, we do a double jump or
    // if we are falling, we can do a double jump to

    // if we can do a double jump, and we press the jump button, we do a double jump
    if ( jump.canDoubleJump && Input.GetButtonDown("Jump") && !IsTouchingCeiling () ){
        jump.doubleJumping=true;
        movement.verticalSpeed = CalculateJumpVerticalSpeed( jump.doubleJumpHeight );
        jump.canDoubleJump = false;

    }
    // * When jumping up we don't apply gravity for some time when the user is holding the jump button
    //   This gives more control over jump height by pressing the button longer
    var extraPowerJump =  jump.jumping && !jump.doubleJumping && movement.verticalSpeed > 0.0 && jumpButton && transform.position.y < jump.lastStartHeight + jump.extraHeight && !IsTouchingCeiling ();

    if (extraPowerJump)
        return;
    else if (controller.isGrounded){
        movement.verticalSpeed = -movement.gravity * Time.deltaTime;
        jump.canDoubleJump = false;
    }
    else
        movement.verticalSpeed -= movement.gravity * Time.deltaTime;

    // Make sure we don't fall any faster than maxFallSpeed.  This gives our character a terminal velocity.
    movement.verticalSpeed = Mathf.Max (movement.verticalSpeed, -movement.maxFallSpeed);
}

function CalculateJumpVerticalSpeed (targetJumpHeight : float) {
    // From the jump height and gravity we deduce the upwards speed 
    // for the character to reach at the apex.
    return Mathf.Sqrt (2 * targetJumpHeight * movement.gravity);
}

function DidJump () {
    jump.jumping = true;
    jump.reachedApex = false;
    jump.lastTime = Time.time;
    jump.lastStartHeight = transform.position.y;
    jump.lastButtonTime = -10;
}



function Update () {
    if (Input.GetButtonDown ("Jump") && canControl) {
        jump.lastButtonTime = Time.time;
    }


    UpdateSmoothedMovementDirection();

    // Apply gravity
    // - extra power jump modifies gravity
    ApplyGravity ();

    // Apply jumping logic
    ApplyJumping ();

    // Moving platform support
    if (activePlatform != null) {
        var newGlobalPlatformPoint = activePlatform.TransformPoint(activeLocalPlatformPoint);
        var moveDistance = (newGlobalPlatformPoint - activeGlobalPlatformPoint);
        transform.position = transform.position + moveDistance;
        lastPlatformVelocity = (newGlobalPlatformPoint - activeGlobalPlatformPoint) / Time.deltaTime;
    } else {
        lastPlatformVelocity = Vector3.zero;    
    }

    activePlatform = null;

    // Save lastPosition for velocity calculation.
    lastPosition = transform.position;

    // Calculate actual motion
    var currentMovementOffset = movement.direction * movement.speed + Vector3 (0, movement.verticalSpeed, 0) + movement.inAirVelocity;

    // We always want the movement to be framerate independent.  Multiplying by Time.deltaTime does this.
    currentMovementOffset *= Time.deltaTime;

    // Move our character!
    movement.collisionFlags = controller.Move (currentMovementOffset);

    // Calculate the velocity based on the current and previous position.  
    // This means our velocity will only be the amount the character actually moved as a result of collisions.
    movement.velocity = (transform.position - lastPosition) / Time.deltaTime;

    // Moving platforms support
    if (activePlatform != null) {
        activeGlobalPlatformPoint = transform.position;
        activeLocalPlatformPoint = activePlatform.InverseTransformPoint (transform.position);
    }

    // Set rotation to the move direction   
    if (movement.direction.sqrMagnitude > 0.01)
        transform.rotation = Quaternion.Slerp (transform.rotation, Quaternion.LookRotation (movement.direction), Time.deltaTime * movement.rotationSmoothing);

    // We are in jump mode but just became grounded
    if (controller.isGrounded) {
        movement.inAirVelocity = Vector3.zero;
        if (jump.jumping) {
            jump.jumping = false;
            jump.doubleJumping = false;
            jump.canDoubleJump = false;
            SendMessage ("DidLand", SendMessageOptions.DontRequireReceiver);

            var jumpMoveDirection = movement.direction * movement.speed + movement.inAirVelocity;
            if (jumpMoveDirection.sqrMagnitude > 0.01)
                movement.direction = jumpMoveDirection.normalized;
        }
    }   

    // Update special effects like rocket pack particle effects
}

function OnControllerColliderHit (hit : ControllerColliderHit)
{
    if (hit.moveDirection.y > 0.01) 
        return;

    // Make sure we are really standing on a straight platform
    // Not on the underside of one and not falling down from it either!
    if (hit.moveDirection.y < -0.9 && hit.normal.y > 0.9) {
        activePlatform = hit.collider.transform;    
    }
}

// Various helper functions below:
function GetSpeed () {
    return movement.speed;
}

function GetVelocity () {
    return movement.velocity;
}


function IsMoving () {
    return movement.isMoving;
}

function IsJumping () {
    return jump.jumping;
}

function IsDoubleJumping () {
    return jump.doubleJumping;
}

function canDoubleJump () {
    return jump.canDoubleJump;
}

function IsTouchingCeiling () {
    return (movement.collisionFlags & CollisionFlags.CollidedAbove) != 0;
}

function GetDirection () {
    return movement.direction;
}

function GetHangTime() {
    return movement.hangTime;
}

function Reset () {
    gameObject.tag = "Player";
}

function SetControllable (controllable : boolean) {
    canControl = controllable;

}    

var prefabExplosion:Transform;

    function OnDamage()
{
    // create an explosion
    Instantiate(prefabExplosion, transform.position, Quaternion.identity);
    // send off a message about our death, who knows where it will end up
    // (this is a good thing)
    new MessagePlayerDie();
    // destroy ourselves
    Destroy(gameObject);
}


// receive a MessagePlayerJump


    var wallMaxFallSpeed = 5.0;

var fallingDamageThreshold = 10.0;
private var falling = false;


    function FallingDamageAlert (fallDistance : float) {
        print ("sup");
    print ("Ouch! Fell " + fallDistance + " units!"); 


}

    function OnTriggerEnter(other:Collider)
{
    // if our trigger is touching an objec with tag "Player"

    if(other.gameObject.CompareTag("wall"))
    {    
        moveDirection.y *= wallMaxFallSpeed;
            print("COOL");
            if(Input.GetButton("Jump"))
            {

                jump.canDoubleJump = true;
                } 
}
}

function OnTriggerExit(other:Collider)
{
    // if our trigger is touching an objec with tag "Player"

    if(other.gameObject.CompareTag("wall"))
    {    
            print("COOL");
            if(Input.GetButton("Jump"))
            {
                jump.canDoubleJump = false;
                } 
}
}
// Require a character controller to be attached to the same game object
@script RequireComponent (CharacterController)

Thanks for any advice.