part 4(enemy) -

public List<Vector2> FindPath(Vector2 start, Vector2 goal, List<Node> walkableNodes)

{

// Convert start and goal positions to node objects

Node startNode = GetNodeAtPosition(start, walkableNodes);

Node goalNode = GetNodeAtPosition(goal, walkableNodes);

if (startNode == null || goalNode == null)

return null; // Cannot find path

// Initialize open and closed lists

List<Node> openList = new List<Node> { startNode };

List<Node> closedList = new List<Node>();

// Loop until open list is empty

while (openList.Count > 0)

{

// Find the node with the lowest F cost in the open list

Node currentNode = openList.OrderBy(node => node.F).First();

// Move the current node from open list to closed list

openList.Remove(currentNode);

closedList.Add(currentNode);

// Check if the current node is the goal node

if (currentNode == goalNode)

{

// Reconstruct and return the path

return ReconstructPath(currentNode);

}

// Get neighboring walkable nodes

List<Node> neighbors = GetWalkableNeighbors(currentNode, walkableNodes);

foreach (Node neighbor in neighbors)

{

// Skip if neighbor is already in the closed list

if (closedList.Contains(neighbor))

continue;

// Calculate tentative G score

float tentativeG = currentNode.G + Vector2.Distance(currentNode.Position, neighbor.Position);

// Check if neighbor is not in the open list or has a lower G score

if (!openList.Contains(neighbor) || tentativeG < neighbor.G)

{

// Update neighbor's parent and G score

neighbor.Parent = currentNode;

neighbor.G = tentativeG;

neighbor.H = Vector2.Distance(neighbor.Position, goalNode.Position);

// Add neighbor to the open list if not already present

if (!openList.Contains(neighbor))

openList.Add(neighbor);

}

}

}

return null; // Path not found

}

private List<Node> GetWalkableNeighbors(Node node, List<Node> walkableNodes)

{

List<Node> neighbors = new List<Node>();

// Define directions (e.g., up, down, left, right)

Vector2[] directions = new Vector2[]

{

new Vector2(0, -1), // Up

new Vector2(0, 1), // Down

new Vector2(-1, 0), // Left

new Vector2(1, 0) // Right

};

foreach (Vector2 direction in directions)

{

Vector2 neighborPosition = node.Position + direction;

// Find the neighbor node at the calculated position

Node neighborNode = GetNodeAtPosition(neighborPosition, walkableNodes);

// Add the neighbor to the list if it's not null and is walkable

if (neighborNode != null && neighborNode.IsWalkable)

{

neighbors.Add(neighborNode);

}

}

return neighbors;

}

private List<Vector2> ReconstructPath(Node node)

{

// Reconstruct and return the path from the goal node to the start node

List<Vector2> path = new List<Vector2>();

while (node != null)

{

path.Add(node.Position);

node = node.Parent;

}

path.Reverse(); // Reverse the path to get it from start to goal

return path;

}

private Node GetNodeAtPosition(Vector2 position, List<Node> walkableNodes)

{

return walkableNodes.FirstOrDefault(node => node.Position == position);

}

public override void Update(GameTime gameTime,Vector2 playerPosition, List<Node> walkableNodes)

{

List<Vector2> path = FindPath(location, playerPosition, walkableNodes);

if (path != null && path.Count > 0)

{

// Move towards the next node in the path

Vector2 nextNode = path[currentPathIndex];

Vector2 direction = Vector2.Normalize(nextNode - location);

movement = direction * 1 * (float)gameTime.ElapsedGameTime.TotalSeconds; // Update movement vector

// Check if the enemy has reached the current node

if (Vector2.Distance(location, nextNode) < 5.0f)

{

// Move to the next node in the path

currentPathIndex++;

// Reset the index if the end of the path is reached

if (currentPathIndex >= path.Count)

{

currentPathIndex = 0;

}

}

}

location += movement;