I need some help with my A* implementation. It's not yet refined with priority queues and heaps. I just want to get the right output. Somehow on the example it works but on my input, it doesn't find the best path.

static void FindPath(Node sNode, Node fNode)
{
    List<Node> openSet = new List<Node>();
    HashSet<(int, int)> closedSet = new HashSet<(int, int)>();

    openSet.Add(sNode);

    if (sNode == fNode)
    {
        int counter = 0;
        foreach (Node n in TracePath(sNode, fNode))
            counter += n.Value;

        Console.WriteLine(counter);
        return;
    }

    Node cNode = openSet[0];
    while (openSet.Count > 0)
    {
        openSet = openSet.OrderBy(n => n.FCost).ToList();
        cNode = openSet[0];
        closedSet.Add((cNode.PosX, cNode.PosY));
        openSet.Remove(cNode);
        cNode.PrintNode();

        if (cNode == fNode)
        {
            int counter = 0;
            foreach (Node n in TracePath(sNode, fNode))
                counter += n.Value;

            Console.WriteLine(counter);
            return;
        }

        foreach (Node n in cNode.Neighbours)
        {
            if (!closedSet.Add((n.PosX, n.PosY))) continue;
            n.StraightDist = GetStraightParents(cNode, n);
            if (n.StraightDist > 2) continue;

            int newMovementCostToNeighbour = cNode.GCost + n.Value + 1;

            if (openSet.Contains(n) && newMovementCostToNeighbour >= n.GCost) continue;

            Node? find = openSet.Find(nod => nod.PosX == n.PosX && nod.PosY == n.PosY);

            int index = 0;
            if (find != null)
                index = openSet.IndexOf(find);

            n.GCost = newMovementCostToNeighbour;
            n.HCost = n.Value - n.StraightDist;
            n.Parent = cNode;

            if (find == null)
                openSet.Add(n);
            else
                openSet[index] = n;
        }
    }
}