Kotlin A* Algorithm - algorithm

Question

I am trying to write a "simple" A* search algorithm for my game, so far it finds its way, but somethings not quite right and I can't figure out what I am doing wrong.
The maze which the algorithm will go through consists of nodes, which have coordinates. There is also a class "squareField", which holds further information which is mostly irrelevant for the algorithm except of the "blocked"-state which indicates that this field (node) is not traversable.
Nodes:
//node represents a single coordinate on the playground holding important information for the algorithm to work
data class Node(val x: Int, val y: Int) : Comparable<Node> {
// parent is the node that came previous to the current one
var parent: Node? = null
// g = distance from selected node to start node
var g: Int = 0
// h = distance from selected node to end node -> optimistic assignment: either equal or less than real distance
var h: Int = 0
// f = g + h -> the lower the value the more attractive it is as a path option
var f: Int = g + h
fun getNeighbors(maxRows: Int, maxCols: Int): MutableSet<Node> {
val neighbors = mutableSetOf<Node>()
if (x - 1 > 0) neighbors.add(Node(x - 1, y))
if (x + 1 < maxRows) neighbors.add(Node(x + 1, y))
if (y - 1 > 0) neighbors.add(Node(x, y - 1))
if (y + 1 < maxCols) neighbors.add(Node(x, y + 1))
return neighbors
}
override fun compareTo(other: Node): Int = this.f.compareTo(other.f)
}
Algorithm:
fun findPath(startNode: Node, targetNode: Node, playGroundRows: Int, playGroundCols: Int): MutableSet<Node>? {
val openSet = PriorityQueue<Node>()
val closedSet = mutableSetOf<Node>()
openSet.add(startNode)
Log.i("Path: ", "openSet at Start: $openSet")
while (openSet.any()) {
var currentNode = openSet.first()
for(i in openSet) {
if(i.f > currentNode.f) {
currentNode = i
}
}
openSet.remove(currentNode)
closedSet.add(currentNode)
if (currentNode == targetNode) {
val path = mutableSetOf<Node>()
var tempNode = currentNode
while (tempNode != null) {
path.add(tempNode)
Log.i("Path: ", "node: $tempNode, f = ${tempNode.f}")
tempNode = tempNode.parent
}
return path
}
val neighbors = currentNode.getNeighbors(playGroundRows, playGroundCols)
neighbors.forEach neighbors#{ node ->
if (GameView.playGround.squareArray[node.x][node.y].isBlocked) {
return#neighbors
}
for(closed_child in closedSet){
if(closed_child == node) {
return#neighbors
}
}
node.parent = currentNode
node.g = currentNode.g + 1
node.h = ((node.x - targetNode.x)) + ((node.y - targetNode.y))
node.f = node.g + node.h
openSet.forEach { openNode ->
if(node == openNode && node.g > openNode.g) {
return#neighbors
}
}
openSet.add(node)
}
}
return null
}
Problem is: The resulting route is not the direct one, it seems to make some detours and walks wiggly lines before finally arriving at its destination.
I've tried for several days now, can't seem to find a correct solution. Maybe someone got an idea what I'm doing wrong?
I do appreciate any help regarding this issue.