GrappleTest/Player/BasicCharacter/CharacterController.gd

extends CharacterBody2D

const SPEED = 500.0
const ACCEL = 7.0
var direction = 0
var addedveloc = 0
var forcedVeloc = 0

const JUMP_VELOCITY = -450.0
const MAX_JUMPS = 1
var jumps = MAX_JUMPS

var wallKayote = 0

const FALL_SPEED = -JUMP_VELOCITY 
var falling = false

var floorTime = 0
var kayote = 0

var gravity = ProjectSettings.get_setting("physics/2d/default_gravity")

var checkpointPos = Vector2.ZERO

@export var ghostMode = false
var ghostFrame = 0
var startPos = Vector2.ZERO

var can_move = true

var camera : Camera2D

@export var savedInputsPath : String

@onready var sceneReload = load(get_tree().current_scene.scene_file_path)

var savedInputs = []

var wallPower = 0

var squishers = -1

func actionPressed(inp):
	if ghostMode:
		if inp in savedInputs[ghostFrame]:
			return true
		return false
	else:
		return Input.is_action_pressed(inp)

func actionJustPressed(inp):
	if ghostMode:
		if inp in savedInputs[ghostFrame] and not inp in savedInputs[ghostFrame - 1]:
			return true
		return false
	else:
		return Input.is_action_just_pressed(inp)

func getAxis(inp1, inp2):
	if ghostMode:
		var dir = 0
		if actionPressed("left"):
			dir -= 1
		if actionPressed("right"):
			dir += 1
		return clamp(dir, -1, 1)
	else:
		return Input.get_axis(inp1, inp2)

func isWallSliding():
	for collisionNumb in get_slide_collision_count():
		var collision = get_slide_collision(collisionNumb)
		var object = collision.get_collider()
		
		if object is TileMap:
			var tileMap : TileMap = object
			var tilePos = tileMap.get_coords_for_body_rid(collision.get_collider_rid())
			var tileData = tileMap.get_cell_tile_data(0, tilePos)
			
			if tileData and not tileData.get_custom_data("Slidable") == true:
				return false
	return is_on_wall_only() and direction

func getGravMulti():
	var axis = (gen.boolToNumb(actionPressed("up") or forceLowGrav, 1))
	if velocity.y < 0:
		return axis
	return 1

func launch(veloc):
	addedveloc = veloc
	velocity.x = veloc

func forceLaunch(veloc):
	forcedVeloc = veloc
	velocity.x = veloc

signal Jumped
signal Died

var deathParticles = preload("res://Particles/Player/deathParticles.tscn")

var doubleWallJumped = false

var forceLowGrav = true

var landed = false

func die():
	Died.emit()
	var parti = deathParticles.instantiate()
	parti.modulate = $Sprite.self_modulate
	add_child(parti)
	can_move = false
	$Sprite.visible = false
	
	gen.savedPos = checkpointPos
	
	await Camera.deathAnim().finished
	
	get_tree().change_scene_to_packed(sceneReload)

func _ready():
	RenderingServer.set_default_clear_color(Color8(0, 0, 0))
	if find_child("Camera"):
		camera = $Camera
	
	if ghostMode:
		startPos = global_position
		var rc = load(savedInputsPath)
		
		if rc:
			var inputKeyRaw = rc["actions"]
			var frameDataRaw = rc["data"]
			
			var inputKey = []
			var frameData = {}
			
			for action in inputKeyRaw:
				inputKey.append(action)
			
			for frame in frameDataRaw:
				frameData[frame] = {}
				for x in frameDataRaw[frame]:
					frameData[frame][x] = frameDataRaw[frame][x]
			var frameCount = gen.getRecordingFrameCount(frameData)
			
			var held = []
			
			for frame in range(frameCount):
				savedInputs.append([])
				if frameData.has(frame):
					for actID in frameData[frame]:
						var pressed = frameData[frame][actID]
						var inputName = inputKey[actID]
						if pressed == 1:
							held.append(inputName)
						elif inputName in held:
							held.remove_at(held.find(inputName))
				savedInputs[frame] += held
	else:
		Camera.player = self
		var parti = deathParticles.instantiate()
		parti.modulate = $Sprite.self_modulate
		add_child(parti)
		$Sprite.visible = true
		$"../Smoother".reset_node(self)
		#camera.position_smoothing_enabled = true
		if gen.savedPos != Vector2.ZERO:
			global_position = gen.savedPos
		gen.savedPos = Vector2.ZERO
		velocity = Vector2(0, 0)
		#camera.reset_smoothing()

@onready var trail = $"Sprite/Trail"
var ghosting = true

var ghostParti = preload("res://Particles/Ghosts/spawnParticles.tscn")

var lastFloor = null

func spawnParti():
	var parti = ghostParti.instantiate()
	add_child(parti)
	parti.top_level = true
	parti.global_position = global_position

func _physics_process(delta):
	if ghostFrame + 1 >= savedInputs.size() and ghostMode:
		ghostFrame = 0 
		trail.points = []
		$Sprite.visible = false
		ghosting = false 
		spawnParti()
		global_position = startPos
		velocity = Vector2.ZERO
		await get_tree().create_timer(3).timeout
		spawnParti()
		ghosting = true
		$Sprite.visible = true
	
	if (ghosting or !ghostMode) and can_move:
		var space_state = get_world_2d().direct_space_state
		
		if ghostFrame == 0:
			spawnParti()
		ghostFrame += 1
		
		direction = round(getAxis("left", "right"))
	
		wallKayote -= delta
		
		if is_on_floor() and !landed:
			velocity.y = 0
		
		if not is_on_floor():
			if velocity.y < 2000:
				velocity.y += gravity * delta / getGravMulti()
			
			floorTime = 0
			kayote -= delta
			if lastFloor:
				if "velocity" in lastFloor:
					velocity += lastFloor.velocity
				lastFloor = null
		else:
			#velocity.y = 0
			doubleWallJumped = false
			kayote = 0.3
			floorTime += delta
			jumps = MAX_JUMPS
			falling = false
			
			
			for collisionNumb in get_slide_collision_count():
				var collision = get_slide_collision(collisionNumb)
				var object = collision.get_collider()
				
				if abs(collision.get_angle()) <= floor_max_angle:
					lastFloor = object
		
		if velocity.y <= 0:
			forceLowGrav = false
		
		if isWallSliding():
			wallKayote = 0.3
			falling = false
		
		if actionJustPressed("respawn") or position.y > 5000:
			die()
		
		if actionJustPressed("jump"):
			if wallKayote > 0 and not is_on_floor():
				if doubleWallJumped:
					wallKayote = 0
				else:
					doubleWallJumped = true
					wallKayote += 0.1
			
				if actionPressed("down"):
					launch(get_wall_normal().x * SPEED * 1.75)
					velocity.y = clamp((velocity.y / 2) + JUMP_VELOCITY / 1.8, -INF, JUMP_VELOCITY / 1.8)
				else:
					launch(get_wall_normal().x * SPEED * 1.4)
					velocity.y = clamp(velocity.y + JUMP_VELOCITY, -INF, JUMP_VELOCITY)
				Jumped.emit()
				
				#if result and "velocity" in result.collider:
					#velocity.x += result.collider.velocity.x
			elif jumps > 0:
				velocity.y = clamp(velocity.y + JUMP_VELOCITY, -INF, JUMP_VELOCITY)
				doubleWallJumped = false
				if kayote < 0:
					jumps -= 1
				else:
					var query = PhysicsRayQueryParameters2D.create(global_position + (Vector2.UP * 32), global_position + (Vector2.DOWN * 64))
					query.exclude = [self]
					var result = space_state.intersect_ray(query)
					
					if result and "velocity" in result.collider:
						velocity += result.collider.velocity
				
				falling = false
				if actionPressed("down") and kayote > 0 and abs(velocity.x) < SPEED * 1.5:
					launch(direction * SPEED * 1.5)
				kayote = 0
				Jumped.emit()
		
		if actionJustPressed("down") and not falling and not isWallSliding():
			falling = true
			velocity.y = clamp(velocity.y + FALL_SPEED, FALL_SPEED, INF)
		
		if isWallSliding():
			var upDown = clamp(getAxis("up", "down"), -0.5, 1)
			var holdMulti = (upDown * 2) + 1
			
			var query = PhysicsRayQueryParameters2D.create(global_position + (get_wall_normal() * 32), global_position + (get_wall_normal() * -64))
			query.exclude = [self]
			var result = space_state.intersect_ray(query)

			if result and "velocity" in result.collider and abs(result.collider.velocity.x) > 50:
				velocity.y = lerpf(velocity.y, 0, delta * 30)
			else:
				velocity.y = lerpf(velocity.y, clamp(velocity.y, JUMP_VELOCITY, 100 * holdMulti), delta * 10)
		
		var finalSpeed = clamp(abs(velocity.x), SPEED, INF) 
		if floorTime > 0.05:
			finalSpeed = clamp(lerp(finalSpeed, SPEED, delta * 20), SPEED, INF)
		
		velocity.x = lerp(velocity.x, direction * finalSpeed, delta * ACCEL)
		
		if abs(velocity.x) < abs(addedveloc):
			addedveloc = lerp(addedveloc, velocity.x, ACCEL * 2 * delta)
			velocity.x += addedveloc * delta * 15
		
		if abs(velocity.x) < abs(forcedVeloc):
			forcedVeloc = lerp(forcedVeloc, velocity.x, ACCEL * 2 * delta)
			velocity.x += forcedVeloc * delta * 35
			
		addedveloc = lerpf(addedveloc, 0, delta * 6)
		if not is_on_floor():
			forcedVeloc = lerpf(forcedVeloc, 0, delta)
		else:
			forcedVeloc = lerpf(forcedVeloc, 0, delta * 5)

		landed = is_on_floor()
		move_and_slide()

func _process(_delta):
	if ghostMode:
		if velocity.length() > 5:
			trail.add_point(global_position)
		elif trail.get_point_count() > 0:
			trail.remove_point(0)
		
		if trail.get_point_count() > 100:
			trail.remove_point(0)


func _on_squish_detection_body_shape_entered(_body_rid, _body, _body_shape_index, _local_shape_index):
	squishers += 1
	if squishers >= 2:
		die()


func _on_squish_detection_body_shape_exited(_body_rid, _body, _body_shape_index, _local_shape_index):
	squishers -= 1