# Converting 3D to 2D (A* pathfinding)

I am following Sebastian Lague's A* pathfinding series, and I am on the episode where he explains path smoothing: https://www.youtube.com/watch?v=NjQjl-ZBXoY&list=PLFt_AvWsXl0cq5Umv3pMC9SPnKjfp9eGW&index=8 If you have followed this series, you will know that he is working on a 3d space, so his coordinates are x and z. However, I am working on a 2d space, and so my coordinates should be x and y. For previous episodes, I am able to convert it from 3d to 2d using some of the Youtube comments, but this episode did not have those helpful comments, and so I don't know how to convert it. Without converting, all the points are just not right. Here are the 3 scripts used in the video:

Line script:

using System.Collections.Generic;
using UnityEngine;

public struct Line
{
private const float verticalLineGradient = 1e5f;

private float y_intercept;

private Vector2 pointOnLine_1;
private Vector2 pointOnLine_2;

private bool approachSide;

public Line(Vector2 pointOnLine, Vector2 pointPerpendicularToLine)
{
float dx = pointOnLine.x - pointPerpendicularToLine.x;
float dy = pointOnLine.y - pointPerpendicularToLine.y;

if (dx == 0)
{
}
else
{
}

{
}
else
{
}

y_intercept = pointOnLine.y - gradient * pointOnLine.x;
pointOnLine_1 = pointOnLine;
pointOnLine_2 = pointOnLine + new Vector2(1, gradient);

approachSide = false;
approachSide = GetSide(pointPerpendicularToLine);
}

private bool GetSide(Vector2 p)
{
return (p.x - pointOnLine_1.x) * (pointOnLine_2.y - pointOnLine_1.y) > (p.y - pointOnLine_1.y) * (pointOnLine_2.x - pointOnLine_1.x);
}

public bool HasCrossedLine(Vector2 p)
{
return GetSide(p) != approachSide;
}

public void DrawWithGizmos(float length)
{
Vector3 lineDir = new Vector3(1, 0, gradient).normalized;
Vector3 lineCentre = new Vector3(pointOnLine_1.x, 0, pointOnLine_1.y) + Vector3.up;

Gizmos.DrawLine(lineCentre - lineDir * length / 2f, lineCentre + lineDir * length / 2f);
}
}


Path script:

using System.Collections.Generic;
using UnityEngine;

public class Path
{

public Path(Vector3[] waypoints, Vector3 startPos, float turnDst)
{
lookPoints = waypoints;
turnBoundaries = new Line[lookPoints.Length];
finishLineIndex = turnBoundaries.Length - 1;

Vector2 previousPoint = V3ToV2(startPos);

for (int i = 0; i < lookPoints.Length; i++)
{
Vector2 currentPoint = V3ToV2(lookPoints[i]);
Vector2 dirToCurrentPoint = (currentPoint - previousPoint).normalized;
Vector2 turnBoundaryPoint = (i == finishLineIndex) ? currentPoint :
currentPoint - dirToCurrentPoint * turnDst;
turnBoundaries[i] = new Line(turnBoundaryPoint,
previousPoint - dirToCurrentPoint * turnDst);
previousPoint = turnBoundaryPoint;
}
}

private Vector2 V3ToV2(Vector3 v3)
{
return new Vector2(v3.x, v3.y);
}

public void DrawWithGizmos()
{
Gizmos.color = Color.black;

foreach (Vector3 p in lookPoints)
{
Gizmos.DrawCube(p + Vector3.up, Vector3.one);
}

Gizmos.color = Color.white;

foreach (Line l in turnBoundaries)
{
l.DrawWithGizmos(10);
}
}
}


Units script (for the enemy to move, but I haven't implemented it yet):

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Unit : MonoBehaviour
{
public Transform target;
public float speed = 10f;
public float turnDst = 5f;

private Path path;

private void Start()
{
PathRequestManager.RequestPath(transform.position, target.position, OnPathFound);
}

public void OnPathFound(Vector3[] waypoints, bool pathSuccessful)
{
if (pathSuccessful)
{
path = new Path(waypoints, transform.position, turnDst);

StopCoroutine("FollowPath");
StartCoroutine("FollowPath");
}
}

private IEnumerator FollowPath()
{
while (true)
{
yield return null;
}
}

private void OnDrawGizmos()
{
if (path != null)
{
path.DrawWithGizmos();
}
}
}


If you are reading this, thanks for taking your time to help me out and try to solve the problem.