Player.gd

extends CharacterBody2D


# Declare member variables here. Examples:
# var a = 2
# var b = "text"
const pad = 100
const WIDTH = 1280
const HEIGHT = 720
const MAX_FRUIT = 10
var _bounds := Rect2(pad,pad,WIDTH-2*pad,HEIGHT-2*pad)

@export var speed := 500
@export var friction = 0.18
var _velocity := Vector2.ZERO
var _action = Vector2.ZERO
var _heuristic = "player"
@onready var fruit = $"../Fruit"
@onready var raycast_sensor = $"RaycastSensor2D"
@onready var walls := $"../Walls"
@onready var colision_shape := $"CollisionShape2D"
var fruit_just_entered = false
var just_hit_wall = false
var done = false
var best_fruit_distance = 10000.0
var fruit_count = 0
var n_steps = 0
var MAX_STEPS = 20000
var needs_reset = false
var reward = 0.0

func _ready():
	raycast_sensor.activate()
	reset()

func _physics_process(delta):
	n_steps +=1    
	if n_steps >= MAX_STEPS:
		done = true
		needs_reset = true

	if needs_reset:
		needs_reset = false
		reset()
		return
	
	var direction = get_direction()
	if direction.length() > 1.0:
		direction = direction.normalized()
	# Using the follow steering behavior.
	var target_velocity = direction * speed
	_velocity += (target_velocity - _velocity) * friction
	set_velocity(_velocity)
	move_and_slide()
	_velocity = velocity
	
	update_reward()
		
	if Input.is_action_just_pressed("r_key"):
		reset()

func reset():
	needs_reset = false
	fruit_just_entered = false
	just_hit_wall = false
	#done = false
	fruit_count = 0
	_velocity = Vector2.ZERO
	_action = Vector2.ZERO
	position = _calculate_new_position()
	spawn_fruit()
	
#    position.x = randf_range(_bounds.position.x, _bounds.end.x)
#    position.y = randf_range(_bounds.position.y, _bounds.end.y)	
#    fruit.position.x = randf_range(_bounds.position.x, _bounds.end.x)
#    fruit.position.y = randf_range(_bounds.position.y, _bounds.end.y)
	best_fruit_distance = position.distance_to(fruit.position)
	n_steps = 0 

func _calculate_new_position(position: Vector2=Vector2.ZERO) -> Vector2:
	var new_position := Vector2.ZERO
	new_position.x = randf_range(_bounds.position.x, _bounds.end.x)
	new_position.y = randf_range(_bounds.position.y, _bounds.end.y)	
	
	if (position - new_position).length() < 4.0*colision_shape.shape.get_radius():
		return _calculate_new_position(position)

	var radius = colision_shape.shape.get_radius()
	var rect = Rect2(new_position-Vector2(radius, radius), 
	Vector2(radius*2, radius*2)
	)    
	for wall in walls.get_children():
		#wall = wall as Area2D
		var cr = wall.get_node("ColorRect")
		var rect2 = Rect2(cr.get_position()+wall.position, cr.get_size())
		if rect.intersects(rect2):
			return _calculate_new_position()
	
	return new_position
	
	
func get_direction():
	if done:
		_velocity = Vector2.ZERO
		return Vector2.ZERO
		
	if _heuristic == "model":
		return _action
		
	var direction := Vector2(
		Input.get_action_strength("move_right") - Input.get_action_strength("move_left"),
		Input.get_action_strength("move_down") - Input.get_action_strength("move_up")
	)
	
	return direction
	
func set_action(action):
	_action.x = action["move"][0]
	_action.y = action["move"][1]
	
func reset_if_done():
	if done:
		reset()
		
func get_obs():
	var relative = fruit.position - position
	var distance = relative.length() / 1500.0 
	relative = relative.normalized() 
	var result := []
	result.append(((position.x / WIDTH)-0.5) * 2)
	result.append(((position.y / HEIGHT)-0.5) * 2)  
	result.append(relative.x)
	result.append(relative.y)
	result.append(distance)
	var raycast_obs = raycast_sensor.get_observation()
	result.append_array(raycast_obs)

	return {
		"obs": result,
	}
	
	
func update_reward():
	reward -= 0.01 # step penalty
	reward += shaping_reward()
	
func zero_reward():
	reward = 0.0   

func get_reward():
	return reward

	
func shaping_reward():
	var s_reward = 0.0
	var fruit_distance = position.distance_to(fruit.position)
	
	if fruit_distance < best_fruit_distance:
		s_reward += best_fruit_distance - fruit_distance
		best_fruit_distance = fruit_distance
		
	s_reward /= 100.0
	return s_reward
	
func set_heuristic(heuristic):
	self._heuristic = heuristic

func get_obs_space():
	# typs of obs space: box, discrete, repeated
	return {
		"obs": {
			"size": [len(get_obs()["obs"])],
			"space": "box"
 }
 }
	
func get_action_space():
	return {
		"move" : {
		"size": 2,	
			"action_type": "continuous"
 }
 }   

func get_done():
	return done
	
func set_done_false():
	done = false

func spawn_fruit():
	fruit.position = _calculate_new_position(position)
	best_fruit_distance = position.distance_to(fruit.position)

func fruit_collected():
	fruit_just_entered = true
	reward += 10.0
	fruit_count += 1
	spawn_fruit()
#    if fruit_count > MAX_FRUIT:
#        done = true

	
func wall_hit():
	done = true
	reward -= 10.0
	just_hit_wall = true
	reset()

func _on_Fruit_body_entered(body):
	fruit_collected()


func _on_LeftWall_body_entered(body):
	wall_hit()
func _on_RightWall_body_entered(body):
	wall_hit()
func _on_TopWall_body_entered(body):
	wall_hit()
func _on_BottomWall_body_entered(body):
	wall_hit()