Sprite2D bug

extends Node2D

@onready var mr_scrumples_node : Node2D = $"Mr Scrumples"
@onready var food : Sprite2D = $Food

const BODY_PART : PackedScene = preload("res://Body Part.tscn")
const TILE_SIZE : int = 40
const STATE_LIST : Dictionary[String, String] = {
    "starting" : "Starting", "playing" : "Playing"
}

const body_straight_left_right : Object = preload("res://Graphics/body straight left right.png")
const body_straight_up_down : Object = preload("res://Graphics/body straight up down.png")
const body_turn_1 : Object = preload("res://Graphics/body turn 1.png")
const body_turn_2 : Object = preload("res://Graphics/body turn 2.png")
const body_turn_3 : Object = preload("res://Graphics/body turn 3.png")
const body_turn_4 : Object = preload("res://Graphics/body turn 4.png")

var state : String = STATE_LIST.starting

var mr_scrumples_entity : Array[Dictionary]
var direction : Vector2i = Vector2i(1, 0)
var next_direction : Vector2i = Vector2i(1, 0)
var new_tile : Vector2i
var stored_tile : Vector2i

var speed : float = 1.0
var speed_multiplier : int = 4
var walk_timer : float = 0.0

var food_tile : Vector2i
var score : int = 0

func _ready() -> void:
    randomize()

func _process(delta: float) -> void:
    if state == STATE_LIST.playing:
        mr_scrumples_walk(delta)

func _input(event: InputEvent) -> void:
    if state == STATE_LIST.playing:
        var dir_list : Dictionary[String, Vector2i] = {
            "ui_left" : Vector2i(-1, 0),
            "ui_right" : Vector2i(1, 0),
            "ui_up" : Vector2i(0, -1),
            "ui_down" : Vector2i(0, 1)
        }
        var available_dir_list : Dictionary[Vector2i, Array] = {
            Vector2i(-1, 0) : [Vector2i(-1, 0), Vector2i(0, -1), Vector2i(0, 1)],
            Vector2i(1, 0) : [Vector2i(1, 0), Vector2i(0, -1), Vector2i(0, 1)],
            Vector2i(0, -1) : [Vector2i(0, -1), Vector2i(-1, 0), Vector2i(1, 0)],
            Vector2i(0, 1) : [Vector2i(0, 1), Vector2i(-1, 0), Vector2i(1, 0)]
        }

        for dir in dir_list:
            if event.is_action_pressed(dir) and available_dir_list[direction].has(dir_list[dir]):
                next_direction = dir_list[dir]
                break

    elif state == STATE_LIST.starting:
        if event.is_action_pressed("ui_select"):
            reset_all()
            await get_tree().create_timer(0.02).timeout
            set_first_mr_scrumples()

func reset_all() -> void:
    mr_scrumples_entity.clear()
    direction = Vector2i(1, 0)
    next_direction = Vector2i(1, 0)
    walk_timer = 0.0

    if mr_scrumples_node.get_child_count() > 0:
        for node in mr_scrumples_node.get_children():
            node.queue_free()

func set_food() -> void:
    var mr_scrumples_tiles : Array[Vector2i]
    var available_tiles : Array[Vector2i]

    for body in mr_scrumples_entity:
        mr_scrumples_tiles.append(body["self_tile"])

    for num_y in range(7):
        for num_x in range(12):
            if not mr_scrumples_tiles.has(Vector2i(num_x, num_y)):
                available_tiles.append(Vector2i(num_x, num_y))

    food_tile = available_tiles.pick_random()
    food.position = Vector2(food_tile * TILE_SIZE) + (Vector2(TILE_SIZE, TILE_SIZE) / 2)

    if food.visible == false:
        food.visible = true

func set_first_mr_scrumples() -> void:
    var first_data : Array[Array] = [
        [null, Vector2i(6, 3), Vector2i(5, 3)],
        [Vector2i(6, 3), Vector2i(5, 3), Vector2i(4, 3)],
        [Vector2i(5, 3), Vector2i(4, 3), null]
    ]

    for num in range(3):
        mr_scrumples_entity.append({
            "origin_tile" : first_data[num][0],
            "self_tile" : first_data[num][1],
            "after_tile" : first_data[num][2]
        })

    set_mr_scrumples_visuals()
    set_food()
    state = STATE_LIST.playing

func mr_scrumples_walk(delta : float) -> void:
    walk_timer += delta

    if walk_timer >= (speed / speed_multiplier):
        walk_timer = 0.0
        direction = next_direction

        for num in range(mr_scrumples_entity.size()):
            if num != 0 and num != mr_scrumples_entity.size() - 1:
                new_tile = stored_tile
                stored_tile = mr_scrumples_entity[num]["self_tile"]
                mr_scrumples_entity[num]["origin_tile"] = mr_scrumples_entity[num - 1]["self_tile"]
                mr_scrumples_entity[num]["self_tile"] = new_tile
                mr_scrumples_entity[num]["after_tile"] = stored_tile
            elif num == 0:
                stored_tile = mr_scrumples_entity[num]["self_tile"]
                mr_scrumples_entity[num]["self_tile"] += direction
                mr_scrumples_entity[num]["after_tile"] = stored_tile
            elif num == mr_scrumples_entity.size() - 1:
                new_tile = stored_tile
                stored_tile = mr_scrumples_entity[num]["self_tile"]
                mr_scrumples_entity[num]["origin_tile"] = mr_scrumples_entity[num - 1]["self_tile"]
                mr_scrumples_entity[num]["self_tile"] = new_tile

        if mr_scrumples_entity[0]["self_tile"] == food_tile:
            var new_butt : Dictionary[String, Variant] = {
                "origin_tile" : mr_scrumples_entity[mr_scrumples_entity.size() - 1]["self_tile"],
                "self_tile" : stored_tile,
                "after_tile" : null
            }
            score += 1
            mr_scrumples_entity[mr_scrumples_entity.size() - 1]["after_tile"] = new_butt["self_tile"]
            mr_scrumples_entity.append(new_butt)
            set_food()

        var mr_scrumples_tiles : Array[Vector2i]

        for num in range(mr_scrumples_entity.size()):
            if num != 0:
                mr_scrumples_tiles.append(mr_scrumples_entity[num]["self_tile"])

        if (
            (mr_scrumples_entity[0]["self_tile"].x < 0
            or mr_scrumples_entity[0]["self_tile"].y < 0
            or mr_scrumples_entity[0]["self_tile"].x > 11
            or mr_scrumples_entity[0]["self_tile"].y > 6)
            or
            (mr_scrumples_tiles.has(mr_scrumples_entity[0]["self_tile"]))
        ):
            game_over()

        set_mr_scrumples_visuals()

func set_mr_scrumples_visuals() -> void:
    if mr_scrumples_node.get_child_count() != mr_scrumples_entity.size():
        var interval : int = mr_scrumples_entity.size() - mr_scrumples_node.get_child_count()
        var first_index : int = mr_scrumples_entity.size() - interval

        for num in range(interval):
            var new_sprite : Sprite2D = BODY_PART.instantiate()

            new_sprite.name = str(first_index + num)
            mr_scrumples_node.add_child(new_sprite)

    for node in mr_scrumples_node.get_children():
        var node_num : int = int(node.name)
        var body_connection : String = ""
        var dir_list : Dictionary[Vector2i, String] = {
            Vector2i(-1, 0) : "l",
            Vector2i(1, 0) : "r",
            Vector2i(0, -1) : "u",
            Vector2i(0, 1) : "d"
        }

        if (node_num != 0
        and node_num != mr_scrumples_entity.size() - 1):
            body_connection += dir_list[
                mr_scrumples_entity[node_num]["origin_tile"] -
                mr_scrumples_entity[node_num]["self_tile"]
            ]
            body_connection += dir_list[
                mr_scrumples_entity[node_num]["after_tile"] -
                mr_scrumples_entity[node_num]["self_tile"]
            ]

        if (node_num != 0
        and node_num != mr_scrumples_entity.size() - 1):
            if body_connection == "lr" or body_connection == "rl":
                node.texture = body_straight_left_right
            elif body_connection == "ud" or body_connection == "du":
                node.texture = body_straight_up_down
            elif body_connection == "lu" or body_connection == "ul":
                node.texture = body_turn_1
            elif body_connection == "ur" or body_connection == "ru":
                node.texture = body_turn_2
            elif body_connection == "dr" or body_connection == "rd":
                node.texture = body_turn_3
            elif body_connection == "ld" or body_connection == "dl":
                node.texture = body_turn_4

        elif node_num == 0:
            var head_list : Dictionary[Vector2i, Array] = {
                Vector2i(-1, 0) : [load("res://Graphics/head side.png"), false],
                Vector2i(1, 0) : [load("res://Graphics/head side.png"), true],
                Vector2i(0, -1) : [load("res://Graphics/head up.png"), false],
                Vector2i(0, 1) : [load("res://Graphics/head down.png"), false]
            }
            var head_dir : Vector2i = (
                mr_scrumples_entity[node_num]["self_tile"] -
                mr_scrumples_entity[node_num]["after_tile"]
            )

            node.texture = head_list[head_dir][0]
            node.flip_h = head_list[head_dir][1]

        elif node_num == mr_scrumples_entity.size() - 1:
            var butt_list : Dictionary[Vector2i, Array] = {
                Vector2i(-1, 0) : [load("res://Graphics/butt side.png"), false],
                Vector2i(1, 0) : [load("res://Graphics/butt side.png"), true],
                Vector2i(0, -1) : [load("res://Graphics/butt up down.png"), false],
                Vector2i(0, 1) : [load("res://Graphics/butt up down.png"), true]
            }
            var butt_dir : Vector2i = (
                mr_scrumples_entity[node_num]["origin_tile"] -
                mr_scrumples_entity[node_num]["self_tile"]
            )

            node.texture = butt_list[butt_dir][0]

            if butt_dir == Vector2i(-1, 0) or butt_dir == Vector2i(1, 0):
                node.flip_h = butt_list[butt_dir][1]
                node.flip_v = false
            elif butt_dir == Vector2i(0, -1) or butt_dir == Vector2i(0, 1):
                node.flip_v = butt_list[butt_dir][1]
                node.flip_h = false

        node.position = Vector2(mr_scrumples_entity[int(node.name)]["self_tile"] * TILE_SIZE) + Vector2(TILE_SIZE, TILE_SIZE) / 2

    var _count : int = 1
    for node in mr_scrumples_node.get_children():
        print(_count)
        print("Position: " + str(node.position))
        print("Path: " + node.texture.load_path)
        _count += 1

func game_over() -> void:
    state = STATE_LIST.starting
    print(score)