Reorganise code

scripts/world/item_entity.gd

···
 var item: Item
 
 @onready var world: World = get_parent()
+@onready var progress_bar: ProgressBar = $ProgressBar
 
 func _ready():
 	texture = item.texture
···
 		position.y = move_toward(position.y, target_position.y, SPEED * delta * TILE_SIZE)
 		world.set_item(position, self)
 		return
-		
+
 	update_process(delta)
 	
 	var direction = world.custom_data(position, "direction")
···
 func update_process(delta):
 	if not process_can_apply():
 		return
-	
+
 	if current_process != null:
 		current_process.progress += delta
-		$ProgressBar.value = current_process.progress
+		progress_bar.value = current_process.progress
 		if current_process.progress >= current_process.process.time:
 			set_item(current_process.process.result)
 			current_process = null
-			$ProgressBar.visible = false
+			progress_bar.visible = false
 		return
-		
+
 	for process in item.processes:
 		if world.custom_data(position, "process") == process.process:
 			var progress = ProcessProgress.new()
 			progress.process = process
-			$ProgressBar.visible = true
-			$ProgressBar.max_value = process.time
+			progress_bar.visible = true
+			progress_bar.max_value = process.time
 			current_process = progress
 
 func process_can_apply():

scripts/world/player.gd

···
 
 const SPEED = 300.0
 const ROTATION_SPEED = 20.0
+var item: Item = null
+
 @onready var world: World = get_parent()
+@onready var marker = $Marker2D
 
 func _physics_process(delta):
-	# Get the input direction and handle the movement/deceleration.
-	# As good practice, you should replace UI actions with custom gameplay actions.
 	var direction = Input.get_vector("move_left", "move_right", "move_up", "move_down")
 	if direction:
 		velocity.x = direction.x * SPEED
···
 			target_rotation = target_rotation + 2*PI
 
 		rotation = move_toward(rotation, target_rotation, delta * ROTATION_SPEED)
-
 	else:
 		velocity.x = move_toward(velocity.x, 0, SPEED)
 		velocity.y = move_toward(velocity.y, 0, SPEED)
···
 
 	move_and_slide()
 
-
-var item: Item = null
-
 func pickup():
-	var entity = world.get_item($Marker2D.global_position)
+	var entity = world.get_item(marker.global_position)
 	if entity != null:
 		self.item = entity.item
 		$Item.texture = entity.item.texture
-		world.remove_item($Marker2D.global_position)
+		world.remove_item(marker.global_position)
 		entity.queue_free()
 
 var item_entity = preload("res://scenes/entities/item_entity.tscn")
 
 func drop():
-	if world.get_item($Marker2D.global_position) != null:
+	if world.get_item(marker.global_position) != null:
 		return
-	if world.custom_data($Marker2D.global_position, "can_hold_item"):
+	if world.custom_data(marker.global_position, "can_hold_item"):
 		var item = item_entity.instantiate()
 		item.item = self.item
-		item.position = $Marker2D.global_position
+		item.position = marker.global_position
 		world.add_child(item)
 		world.set_item(item.position, item)
 		self.item = null

scripts/world/world.gd

···
 extends Node2D
 class_name World
 
-const width = 18
-const height = 10
+const WIDTH = 18
+const HEIGHT = 10
 const TILE_SIZE = 64
 
 @onready var tilemap: TileMapLayer = $Appliances
···
 	var time_remaining: float
 
 var item_queue: Array[Item] = []
-var dishes: Array[ActiveDish] = []
+var active_dishes: Array[ActiveDish] = []
 @export var possible_dishes: Array[Dish]
 
 const DISH_TIMEOUT = 30
···
 @onready var coins_label: Label = ui_vertical.get_node("HBoxContainer/Coins")
 
 func _ready():
-	for i in range(width * height):
+	for i in range(WIDTH * HEIGHT):
 		items.append(null)
 
 var item_entity = preload("res://scenes/entities/item_entity.tscn")
···
 		set_item(item.position, item)
 		item_queue.pop_front()
 
-	var new_dishes = dishes.filter(func(dish): return process_dish(dish, delta))
-	dishes = new_dishes
+	active_dishes = active_dishes.filter(func(dish): return process_dish(dish, delta))
 
 	time_until_next_dish -= delta
 	if time_until_next_dish <= 0:
-		var dish: ActiveDish = ActiveDish.new()
-		dish.dish = possible_dishes.pick_random()
-		var indicator = dish_indicator.instantiate()
-		indicator.get_node("TextureRect").texture = dish.dish.required_item.texture
-		dish.time_remaining = DISH_TIMEOUT * 4
-		indicator.get_node("ProgressBar").max_value = dish.time_remaining
-		indicator.get_node("ProgressBar").value = dish.time_remaining
-		dish.node = indicator
-		ui_vertical.add_child(indicator)
-		item_queue.append_array(dish.dish.ingredients)
-		dishes.append(dish)
-		time_until_next_dish = DISH_TIMEOUT
+		queue_dish()
+
+func queue_dish():
+	var dish: ActiveDish = ActiveDish.new()
+	dish.dish = possible_dishes.pick_random()
+	
+	var indicator = dish_indicator.instantiate()
+	indicator.get_node("TextureRect").texture = dish.dish.required_item.texture
+	dish.time_remaining = DISH_TIMEOUT * 4
+	indicator.get_node("ProgressBar").max_value = dish.time_remaining
+	indicator.get_node("ProgressBar").value = dish.time_remaining
+
+	dish.node = indicator
+	ui_vertical.add_child(indicator)
+	item_queue.append_array(dish.dish.ingredients)
+	active_dishes.append(dish)
+	time_until_next_dish = DISH_TIMEOUT
 
 func process_dish(dish: ActiveDish, delta):
 	if items[0] != null and items[0].item == dish.dish.required_item:
···
 	return data.get_custom_data(name)
 
 static func position_to_index(position: Vector2) -> int:
-	return floor(position.x / TILE_SIZE) + floor(position.y / TILE_SIZE) * width
+	return floor(position.x / TILE_SIZE) + floor(position.y / TILE_SIZE) * WIDTH
 
-func index_to_position(index: int) -> Vector2:
-	var x = index % width * TILE_SIZE + TILE_SIZE/2
-	var y = floor(index / width) * TILE_SIZE + TILE_SIZE/2
+static func index_to_position(index: int) -> Vector2:
+	var x = index % WIDTH * TILE_SIZE + TILE_SIZE/2
+	var y = floor(index / WIDTH) * TILE_SIZE + TILE_SIZE/2
 	return Vector2(x, y)
 
 func set_item(position: Vector2, item: ItemEntity):
···
 	return items[index]
 
 func player_cursor() -> Vector2:
-	return get_node("Player/Marker2D").global_position
+	return $Player/Marker2D.global_position