Cleanomancer/Player.gd

tool
extends Area2D


export var speed : float = 1
export var speed_dash : float = 3
export var rest : float = 1
export var dashes : int  = 1

export var tile_position := Vector2(0,0)
export(NodePath) var level_tilemap

onready var level = get_node(level_tilemap) as Level

var last_move_time := 0.0
var step_count := 0
var stepped := false
var dashing := false

class Movement:
	var action: String
	var direction: Vector2
	var animation: String
	
	func _init(_action, _direction, _animation):
		action = _action
		direction = _direction
		animation = _animation
	
var movements = [
	Movement.new("ui_right", Vector2.RIGHT, "right"),
	Movement.new("ui_left",  Vector2.LEFT,  "left"),
	Movement.new("ui_up",    Vector2.UP,    "back"),
	Movement.new("ui_down",  Vector2.DOWN,  "front")
]

var movement_queue = []
var current_target = null
var current_direction : Movement = movements.back()
onready var sprite = $AnimatedSprite as AnimatedSprite

func _process(delta):
	
	
		
	if Engine.editor_hint:
		
		
		if level == null and not level_tilemap == "":
			
			level = get_node(level_tilemap) as Level
		
		if level != null:
			
			tile_position.x = round(tile_position.x)
			tile_position.y = round(tile_position.y)
			
			update_position()
	
	else:
		
		if (last_move_time + rest) * 1000 < OS.get_ticks_msec():
			for movement in movements:
				if Input.is_action_pressed(movement.action):
					current_direction = movement
					if not Input.is_action_pressed("lock_move"):
						var target = level.get_tile_v(tile_position + movement.direction)
						if target.can_walk() or target.can_push(movement.direction):
							movement_queue.push_back(movement)
							
					
		update_animation()
		
		if not movement_queue.empty():
						
			var current_movement : Movement = movement_queue.front()
						
			if current_target == null:
				current_target = tile_position + current_movement.direction
				var tile = level.get_tile_v(current_target)
				if not tile.can_walk() and not tile.can_push(current_movement.direction):
					current_target = null
					movement_queue.pop_front()
				else:
					tile.push(current_movement.direction)
			
			if current_target != null:
				tile_position += current_movement.direction * delta * (speed_dash if dashing else speed)
				
				var remaining : Vector2 = current_target - tile_position
				
				if remaining.dot(current_movement.direction) <= 0:
					tile_position = current_target
					current_target = null
					movement_queue.pop_front()
					stepped = false
					dashing = false
				elif remaining.length() < 0.5 and not stepped:
					step_count += 1
					stepped = true
				
				update_position()
				last_move_time = OS.get_ticks_msec() / 1000.0
		
		if dashes > 0 and Input.is_action_just_pressed("dash"):
			
			if not current_target == null:
				tile_position = current_target
			
			var dash_end :Level.Tile = level.get_tile_v(tile_position).dash(current_direction.direction)
			if dash_end:
				movement_queue = [current_direction]
				current_target = Vector2 (dash_end.x, dash_end.y)
				dashing = true
				dashes = dashes - 1

func update_position():
	position = level.cell_custom_transform * (tile_position + Vector2.ONE / 2 )
	
func update_animation():
	sprite.animation = current_direction.animation
	sprite.frame = step_count % 2 + (0 if dashes > 0 else 2)