void PlaceSelf()
    {
        List<List<Vector3>> floorParts = floor.GetPartialFloorRects(false).ToList();
        List<Vector3> outerWall = floor.GetCircumferance(false).ToList();
        int outerWallsLength = outerWall.Count;

        bool validated = false;

        while (!validated)
        {
            List<Vector3> compartment = floorParts[Random.Range(0, floorParts.Count)];

            Vector3 v1 = compartment[1] - compartment[0];
            Vector3 v2 = compartment[2] - compartment[1];

            //Vector3 c = compartment.Aggregate(Vector3.zero, (sum, e) => sum + e) / compartment.Count;

            Vector3 pt = compartment[0] + Random.value * v1 + Random.value * v2;
            
            validated = true;
            
            for (int i=0; i<outerWallsLength; i++)
            {
                float d = ProcGenHelpers.GetMinDist(pt, outerWall[i], outerWall[(i + 1) % outerWallsLength]);                
                if (d < proximityThreshold)
                {
                    Debug.Log("Invalid");
                    validated = false;
                    break;
                }
            }

            if (validated)
            {
                transform.position = pt;
            }
            
        }

        GetComponentInParent<RotateMe>().rotating = false;
        PlayerController.Instance.Spawn(transform);

    }
    //List<Vector3> outsideTriFail = new List<Vector3>();

    public List <Vector3> TraceSurface(int tri, Vector3 thirdVert, Vector3 intercept, Vector3 normal, Dictionary <int, List <Vector3> > allIntercepts, out List <Ray> rayTrain, float proximityOfInterceptThreshold = 0.01f, int searchDepth = 20)
    {
        List <Vector3> traceLine        = new List <Vector3>();
        Vector3        orginalIntercept = intercept;

        //Vector3 originalNorm = myTriNormals[tri];
        rayTrain = new List <Ray>();
        Ray r;

        if (ProcGenHelpers.InterceptionRay(normal, intercept, myTriNormals[tri], out r))
        {
            r.direction = Mathf.Sign(Vector3.Dot(thirdVert - intercept, r.direction)) * r.direction;

            while (tri >= 0)
            {
                rayTrain.Add(new Ray(r.origin, r.direction));
                int     v     = tri * 3;
                Vector3 vertA = myVerts[myTris[v]];
                Vector3 vertB = myVerts[myTris[v + 1]];
                Vector3 vertC = myVerts[myTris[v + 2]];

                int hitEdge;

                //TODO: Sensitive as edge condition in some rotations
                Vector3 rayHit = ProcGenHelpers.RayHitEdge(vertA, vertB, vertC, r, out hitEdge);

                if (hitEdge == -1)
                {
                    /*
                     * outsideTriFail.Clear();
                     * outsideTriFail.Add(vertA);
                     * outsideTriFail.Add(vertB);
                     * outsideTriFail.Add(vertC);
                     * Debug.LogError(string.Format("Intercept {0} was not in the reported triangle {2} (trace length = {1}, normal = {3})!", intercept, traceLine.Count(), tri, normal));
                     * Debug.Log(string.Format("{0} {1} {2} ray {3} -> ({4}, {5}, {6}) missed", vertA, vertB, vertC, r.origin, r.direction.x, r.direction.y, r.direction.z));
                     * Debug.Log(string.Format("Norm calc {0} Norm pre calc {1}, Other Norm {2}, Ray direction {3}",
                     *  Vector3.Cross(vertB - vertA, vertC - vertA), originalNorm, normal, Vector3.Cross(originalNorm, normal)));
                     * outsideTriFail.Clear();
                     * outsideTriFail.Add(vertA);
                     * outsideTriFail.Add(vertB);
                     * outsideTriFail.Add(vertC);
                     */

                    traceLine.Clear();
                    tri = -1;
                    Debug.LogError(string.Format("Intercept {0} was not in the reported triangle {2} (trace length = {1}, normal = {3})!", intercept, traceLine.Count(), tri, normal));
                    float t1;
                    float t2;
                    bool  val = ProcGenHelpers.LineSegmentInterceptIn3D(vertB, vertC, r, 0.01f, out t1, out t2);
                    Debug.LogError(string.Format("t1 {0} t2 {1} dist {2} {3}, {4}", t1, t2, Vector3.Distance(vertB + (vertC - vertB).normalized * t1, r.GetPoint(t2)), val, (vertC - vertB).magnitude));
                }
                else
                {
                    if (allIntercepts.Keys.Contains(tri))
                    {
                        List <Vector3> hitIntercepts = allIntercepts[tri]
                                                       .Where(v1 => Vector3.SqrMagnitude(v1 - orginalIntercept) > proximityOfInterceptThreshold)
                                                       .Select(v2 => new {
                            vert = v2,
                            dist = ProcGenHelpers.GetMinDist(v2, intercept, rayHit)
                        })
                                                       .Where(e => e.dist < proximityOfInterceptThreshold)
                                                       //TODO: Potentially order by proximity to intercept
                                                       .Select(e => e.vert).ToList();

                        if (hitIntercepts.Count > 0)
                        {
                            //Debug.Log(string.Format("Found path connecting intercepts {0} - {1}", orginalIntercept, hitIntercepts[0]));
                            traceLine.Add(hitIntercepts[0]);
                            return(traceLine);
                        }
                        else
                        {
                            /*
                             * Debug.Log(string.Format("No close intercept on {0} ({1} - {2}), closest: {3}",
                             *  tri,
                             *  intercept, rayHit,
                             *  allIntercepts[tri]
                             *      //.Where(v1 => Vector3.SqrMagnitude(v1 - orginalIntercept) > proximityOfInterceptThreshold)
                             *      .Select(v2 => new {
                             *          vert = v2,
                             *          dist = ProcGenHelpers.GetMinDist(v2, intercept, rayHit)
                             *      })
                             *      .OrderBy(e => e.dist)
                             *      //TODO: Potentially order by proximity to intercept
                             *      .Select(e => e.vert).FirstOrDefault().magnitude
                             *  ));
                             */
                        }
                    }
                    else
                    {
                        //Debug.Log("No intercept in tri " + tri);
                    }

                    if (traceLine.Contains(rayHit))
                    {
                        Debug.LogError("Going back over myself");
                        return(traceLine);
                    }
                    else
                    {
                        //Debug.Log("Hit tri edge at " + rayHit);
                        traceLine.Add(rayHit);
                    }

                    int nextTri = GetNeighbourTri(myTris[v + hitEdge], myTris[v + (hitEdge + 1) % 3], tri);
                    if (nextTri != -1)
                    {
                        intercept = rayHit;

                        if (ProcGenHelpers.InterceptionRay(normal, intercept, myTriNormals[nextTri], out r))
                        {
                            int     idThirdVert = GetMissingVert(nextTri, myTris[v + hitEdge], myTris[v + (hitEdge + 1) % 3]);
                            Vector3 d3          = myVerts[idThirdVert] - intercept;
                            float   sign        = Mathf.Sign(Vector3.Dot(d3, r.direction));

                            /*Debug.Log(string.Format("{3} ({9}) -> {4} ({10}): {0} - {1}, {2} ({5}, {6}) [{7} {8}]",
                             *  myTris[v + hitEdge], myTris[v + (hitEdge + 1) % 3], idThirdVert,
                             *  tri, nextTri,
                             *  r.direction, sign,
                             *  myVerts[idThirdVert], intercept,
                             *  myTriNormals[tri], myTriNormals[nextTri]
                             *  ));*/
                            r.direction = sign * r.direction;
                            tri         = nextTri;
                            //Debug.Log("Found next tri");
                        }
                        else
                        {
                            Debug.LogError("The identified next tri didn't intercept cutting Tri");
                            tri = -1;
                        }
                    }
                    else
                    {
                        Debug.LogError("No neighbour");
                    }
                }

                if (traceLine.Count() >= searchDepth)
                {
                    Debug.LogWarning("Aborted trace because reached search depth");
                    traceLine.Clear();
                    return(traceLine);
                }
            }
        }

        traceLine.Clear();
        Debug.Log("Found strange line that started in " + orginalIntercept);
        return(traceLine);
    }