character controller.

extends CharacterBody3D

# Player Nodes
@onready var neck = $neck
@onready var head = $neck/Head
@onready var eyes = $neck/Head/eyes
@onready var camera = $neck/Head/eyes/Camera3D
@onready var standing_collision_shape = $standing_collision_shape
@onready var crouching_collision_shape = $crouching_collision_shape
@onready var crouching_raycast = $crouching_raycast
@onready var animation_player = $PlayerModel/AnimationPlayer


# Speed Variables
var current_speed = 5.0

const walking_speed = 5.0
const sprinting_speed = 8.0
const crouching_speed = 3.0
const wallrun_speed = 4.0

# States
var walking = false
var sprinting = false
var crouching = false
var freelooking = false
var sliding = false
var jumping = false
var wallrunning = false

var paused = false

# Slide Vars
var slide_timer = 0.0
var slide_timer_max = 1.0
var slide_vector = Vector2.ZERO
var slide_speed = 10.0

# Headbobbing vars
const head_bobbing_sprinting_speed = 22.0
const head_bobbing_walking_speed = 14.0
const head_bobbing_crouching_speed = 10.0

const head_bobbing_sprinting_instensity = 0.2
const head_bobbing_walking_instensity = 0.1
const head_bobbing_crouching_instensity = 0.05

var head_bobbing_current_intensity = 0.0

var head_bobbing_vector = Vector2.ZERO
var head_bobbing_index = 0.0

# Wallrunning vars
var can_wallrun = false
var wallrun_delay = 0.2
@onready var wallrun_delay_default = wallrun_delay
@export var wallrun_angle = 15.0
var wallrun_current_angle = 0.0
var side = ""
var is_wallrun_jumping = false
var wall_jump_dir = Vector3.ZERO
@export var wall_jump_horizontal_power = 0.75
@export var wall_jump_vertical_power = 1.0
@export var wall_jump_factor = 0.4

# Movement Variables
const jump_velocity = 4.5
var crouching_depth = -0.5
var freelook_lerp_speed = 15.0
var lerp_speed = 10.0
var air_lerp_speed = 3.0
var freelook_tilt_amount = 6.0
var last_velocity = Vector3.ZERO


# Input Variables
var direction = Vector3.ZERO
@export var mouse_sens = 0.25

# Pause screen instanctiate vars
var pause_menu = preload("res://scenes/Pause menu.tscn")
var pause_screen_instance = pause_menu.instantiate()

# Get the gravity from the project settings to be synced with RigidBody nodes.
var gravity = ProjectSettings.get_setting("physics/3d/default_gravity")

func _ready():
    Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)

func _input(event):
# Mouse Movement
    if event is InputEventMouseMotion and !paused:
        if freelooking:
            neck.rotate_y(deg_to_rad(-event.relative.x * mouse_sens))
            neck.rotation.y = clamp(neck.rotation.y,deg_to_rad(-120),deg_to_rad(120))
        else:
            rotate_y(deg_to_rad(-event.relative.x * mouse_sens))
            head.rotate_x(deg_to_rad(-event.relative.y * mouse_sens))
            head.rotation.x = clamp(head.rotation.x,deg_to_rad(-89),deg_to_rad(89))

func _process(delta):
    if Input.is_action_just_pressed("quit") and !paused:
        Pause()
    elif Input.is_action_just_pressed("quit") and paused:
        Unpause()

func _physics_process(delta):
    # getting movement input
    var input_dir = Input.get_vector("left", "right", "forward", "backward")

    #Handle movement state

    # crouching
    if Input.is_action_pressed("crouch") || sliding and !wallrunning and !paused:

        current_speed = lerp(current_speed, crouching_speed, delta * lerp_speed)
        head.position.y = lerp(head.position.y,crouching_depth, delta * lerp_speed)

        # Slide begin logic

        if sprinting && input_dir != Vector2.ZERO:
            sliding = true
            slide_timer = slide_timer_max
            slide_vector = input_dir
            freelooking = true

        standing_collision_shape.disabled = true
        crouching_collision_shape.disabled = false

        walking = false
        sprinting = false
        crouching = true
    else:
        head.position.y = lerp(head.position.y,0.5, delta * lerp_speed)

        crouching = false
        standing_collision_shape.disabled = false
        crouching_collision_shape.disabled = true
    if Input.is_action_pressed("sprint"):
    # Sprinting and Walking
        current_speed = lerp(current_speed, sprinting_speed, lerp_speed * delta)

        walking = false
        sprinting = true
        crouching = false
    else:
        current_speed = lerp(current_speed, walking_speed, delta * lerp_speed)

        walking = true
        sprinting = false
        crouching = false

    # Handle Freelooking
    if Input.is_action_pressed("freelook") || sliding:
        freelooking = true

        if sliding:
            eyes.rotation.z = lerp(eyes.rotation.z, -deg_to_rad(7.0), lerp_speed * delta)
        else:
            eyes.rotation.z = -deg_to_rad(neck.rotation.y*freelook_tilt_amount)
    else:
        freelooking = false
        neck.rotation.y = lerp(neck.rotation.y,0.0,freelook_lerp_speed * delta)
        eyes.rotation.z = lerp(eyes.rotation.y,0.0,freelook_lerp_speed*delta)

    # Add Gravity
    if !is_on_floor():
        velocity.y -= gravity * delta

    # Handle Wallrunning
    if is_on_floor():
        wallrunning = false
        can_wallrun = false
        is_wallrun_jumping = false
        wallrun_delay = wallrun_delay_default
    else:
        wallrun_delay = clamp(wallrun_delay - delta, 0 , wallrun_delay_default)

        if wallrun_delay == 0.0:
            can_wallrun = true

    # Wallrun jump
    if Input.is_action_just_pressed("jump") && wallrunning:
        can_wallrun = false
        wallrunning = false
        is_wallrun_jumping = true

        velocity.y = jump_velocity * wall_jump_vertical_power

        if side == "LEFT":
            wall_jump_dir = global_transform.basis.x * wall_jump_horizontal_power
        elif side == "RIGHT":
            wall_jump_dir = -global_transform.basis.x * wall_jump_horizontal_power

        wall_jump_dir *= wall_jump_factor

    if is_wallrun_jumping:
        direction = (direction * (1 - wall_jump_factor)) + wall_jump_dir

    process_wallrun()
    wallrun_anims(delta)

    # Handle jump.
    if Input.is_action_pressed("jump") and is_on_floor() and !paused:
        velocity.y = jump_velocity
        jumping = true
        sliding = false
    elif is_on_floor() && jumping:
        jumping = false


    # Handle Sliding
    if sliding:
        slide_timer -= delta
        print(slide_timer)
        if slide_timer <= 0:
            sliding = false
            freelooking = false

    # Handle Head Bobbing
    if sprinting:
        head_bobbing_current_intensity = head_bobbing_sprinting_instensity
        head_bobbing_index += head_bobbing_sprinting_speed * delta
    elif walking:
        head_bobbing_current_intensity = head_bobbing_walking_instensity
        head_bobbing_index += head_bobbing_walking_speed * delta
    elif crouching:
        head_bobbing_current_intensity = head_bobbing_crouching_instensity
        head_bobbing_index += head_bobbing_crouching_speed * delta

    if is_on_floor() && !sliding && input_dir != Vector2.ZERO:
        head_bobbing_vector.y = sin(head_bobbing_index)
        head_bobbing_vector.x = sin(head_bobbing_index/2) + 0.5

        eyes.position.y = lerp(eyes.position.y, head_bobbing_vector.y * (head_bobbing_current_intensity / 2.0), delta * lerp_speed)
        eyes.position.x = lerp(eyes.position.x, head_bobbing_vector.x * head_bobbing_current_intensity, delta * lerp_speed)
    else:
        eyes.position.y = lerp(eyes.position.y, 0.0, delta * lerp_speed)
        eyes.position.x = lerp(eyes.position.x, 0.0, delta * lerp_speed)

    # Get the input direction and handle the movement/deceleration.
    # As good practice, you should replace UI actions with custom gameplay actions.

    if is_on_floor():
        direction = lerp(direction,(transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized(),delta*lerp_speed)
    else:
        if input_dir != Vector2.ZERO:
            direction = lerp(direction,(transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized(),delta*air_lerp_speed)

    if sliding:
        direction = (transform.basis * Vector3(slide_vector.x,0,slide_vector.y)).normalized()
        current_speed = direction.x * (slide_timer + 0.1) * slide_speed



    if direction and !paused:
        velocity.x = direction.x * current_speed
        velocity.z = direction.z * current_speed


        if sliding:
            velocity.x = direction.x * (slide_timer + 0.1) * slide_speed
            velocity.z = direction.z * (slide_timer + 0.1) * slide_speed
    else:
        velocity.x = move_toward(velocity.x, 0, current_speed)
        velocity.z = move_toward(velocity.z, 0, current_speed)


    last_velocity = velocity

    move_and_slide()

func process_wallrun():
    if can_wallrun:
        if is_on_wall() && Input.is_action_pressed("forward") && Input.is_action_pressed("sprint"):
            # Get collision data, and its normal
            var collision = get_slide_collision(0)
            var normal = collision.get_normal()

            # Calculate direction on which we have to move
            var wallrun_dir = Vector3.UP.cross(normal)

            var player_view_dir = -camera.global_transform.basis.z
            var dot = wallrun_dir.dot(player_view_dir)
            if dot < 0:
                wallrun_dir = -wallrun_dir

            # Push against wall for stability
            wallrun_dir += -normal * 0.01

            # Enable Wallrunning
            wallrunning = true

            # sets side to a string, thats tells where the wall is
            side = get_side(collision.get_position())

            # Set gravity close to 0, and movement direction to new calculated wallrun direction
            velocity.y = -0.01
            direction = wallrun_dir
        else:
            wallrunning = false

func wallrun_anims(delta):
    # Tilt the view
    if wallrunning:
        if side == "RIGHT":
            wallrun_current_angle += delta * 60
            wallrun_current_angle = clamp(wallrun_current_angle, -wallrun_angle, wallrun_angle)
        elif side == "LEFT":
            wallrun_current_angle -= delta * 60
            wallrun_current_angle = clamp(wallrun_current_angle, -wallrun_angle, wallrun_angle)

    # Return to normal view
    else:
        if wallrun_current_angle > 0:
            wallrun_current_angle -= delta * 40
            wallrun_current_angle = max(0, wallrun_current_angle)
        elif wallrun_current_angle < 0:
            wallrun_current_angle += delta * 40
            wallrun_current_angle = min(wallrun_current_angle, 0)

    neck.rotation_degrees = Vector3(0, 0, 1) * wallrun_current_angle

func get_side(point):
    point = to_local(point)

    if point.x > 0:
        return "RIGHT"
    elif point.x < 0:
        return "LEFT"
    else:
        return "CENTER"

func Pause():
    paused = true
    Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
    add_child(pause_screen_instance)

func Unpause():
    paused = false
    Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
    remove_child(pause_screen_instance)