sg04_cpy

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

using System.Text.RegularExpressions;

public class LevelManager : MonoBehaviour {

    // singleton
    public static LevelManager instance;

    // file prefix
    private readonly string prefix = "Assets/Levels/";

    // player prefab
    public Transform pacman;

    // enemy prefabs
    public Transform blinky;
    public Transform pinky;
    public Transform inky;
    public Transform clyde;

    // walls
    public Transform corridor;
    public Transform corner;
    public Transform cross;
    public Transform tCross;
    public Transform deadEnd;

    // corresponding strings
    readonly char sCorridorHorizontal = '-';
    readonly char sCorridorVertical = '|';
    readonly char sCross = '+';             // could be cross or tCross or corner

    // the level as a string
    private List<string> level = new List<string> ();
    private bool isReady;

    // the waypoints
    private List<WayPoint> wayPoints = new List<WayPoint>();

    // a struct that helps setting the wayPoints
    struct AuxStruct {
        public Transform tile;
        public bool goUp;
        public bool goDown;
        public bool goLeft;
        public bool goRight;
    };
    List<AuxStruct> auxList = new List<AuxStruct>();
    AuxStruct[,] auxArray;
    int rows = 0;
    int cols = -1;
    int r = 0;
    int c = 0;

    void Awake() {
        instance = this;
    }


    void Update() {
        if(isReady) {
            auxArray = new AuxStruct[rows, cols];
            CreateLevel ();
            isReady = false;
        }
    }


    public void ReadFile(string fileName) {
        string text = System.IO.File.ReadAllText (prefix + fileName);
        level.Clear ();
        List<string> lines = new List<string>(Regex.Split (text, "\n"));

        for(int i=0; i < lines.Count; ++i) {
            string currentLine = lines[i].Trim();
            string[] currentLineSplit = Regex.Split (currentLine, " ");

            switch(currentLineSplit[0]) {
            case "Pacman":
                pacman.transform.position = StringCoordsToVec (
                    currentLineSplit [1],
                    pacman.transform.position.y.ToString (),
                    currentLineSplit [2]);
                break;
            case "Blinky":
                blinky.transform.position = StringCoordsToVec (
                    currentLineSplit [1],
                    blinky.transform.position.y.ToString (),
                    currentLineSplit [2]);
                break;
            case "Pinky":
                pinky.transform.position = StringCoordsToVec (
                    currentLineSplit [1],
                    pinky.transform.position.y.ToString (),
                    currentLineSplit [2]);
                break;
            case "Inky":
                inky.transform.position = StringCoordsToVec (
                    currentLineSplit [1],
                    inky.transform.position.y.ToString (),
                    currentLineSplit [2]);
                break;
            case "Clyde":
                clyde.transform.position = StringCoordsToVec (
                    currentLineSplit [1],
                    clyde.transform.position.y.ToString (),
                    currentLineSplit [2]);
                break;
            default:
                // else it must be some level object
                level.Add (currentLine);
                rows++;
                if(cols == -1) {
                    cols = currentLine.Length;
                }
                break;
            } // switch()
        } // for()

        isReady = true;
    } // ReadFile()



    Vector3 StringCoordsToVec(string x, string y, string z) {
        float newX = float.Parse (x);
        Debug.Log (y);
        float newY = float.Parse (y);
        float newZ = float.Parse (z);

        return new Vector3 (newX, newY, newZ);
    }


    void CreateLevel() {
        float startX = 0f;

        float x = startX;
        float y = 0f;
        float z = 0f;

        for(int i=0; i < level.Count; ++i) {
            for(int j=0; j < level[i].Length; ++j) {
                Vector3 vec = new Vector3 (x, y, z);


                if(level[i][j] == sCorridorHorizontal) {
                    bool isDeadEndLeft  = (j == 0);
                    bool isDeadEndRight = (j == level[i].Length-1);

                    if(isDeadEndLeft) {
                        // InstantiateWithRotation (deadEnd, vec, -90f);
                        InstantiateWithRotationAndCreateWayPoint(deadEnd, vec, -90f, false, false, false, true);
                    }
                    else if(isDeadEndRight) {
                        // InstantiateWithRotation (deadEnd, vec, 90f);
                        InstantiateWithRotationAndCreateWayPoint(deadEnd, vec, 90f, false, false, true, false);
                    }
                    else {
                        // InstantiateWithRotation (corridor, vec, 90f);
                        InstantiateWithRotationAndCreateWayPoint(corridor, vec, 90f, false, false, true, true);
                    }

                }
                else if(level[i][j] == sCorridorVertical) {
                    bool isDeadEndUp    = (i == 0);
                    bool isDeadEndDown  = (i == level.Count-1);

                    if(isDeadEndUp) {
                        // InstantiateWithRotation (deadEnd, vec, 0f);
                        InstantiateWithRotationAndCreateWayPoint(deadEnd, vec, 0f, false, true, false, false);
                    }
                    else if(isDeadEndDown) {
                        // InstantiateWithRotation (deadEnd, vec, 180f);
                        InstantiateWithRotationAndCreateWayPoint(deadEnd, vec, 180f, true, false, false, false);
                    }
                    else {
                        // InstantiateWithRotation (corridor, vec, 0f);
                        InstantiateWithRotationAndCreateWayPoint(corridor, vec, 0f, true, true, false, false);
                    }
                }

                char empty = ' ';
                if(level[i][j] == sCross) {
                    Debug.Log (level [i][level[i].Length-1]);
                    char up     = ((i - 1) >= 0)                ? level [i - 1] [j] : empty;
                    char down   = ((i + 1) < level.Count)       ? level [i + 1] [j] : empty;
                    char left   = ((j - 1) >= 0)                ? level [i] [j - 1] : empty;
                    char right  = ((j + 1) < level [i].Length)  ? level [i] [j + 1] : empty;

                    // important: assumes that loaded level is syntactically correct! (@see SyntaxChecker)

                    bool isLeftTopCorner        = (up == empty && left == empty && right != empty && down != empty);
                    bool isLeftBottomCorner     = (up != empty && left == empty && right != empty && down == empty);
                    bool isRightTopCorner       = (up == empty && left != empty && right == empty && down != empty);
                    bool isRightBottomCorner    = (up != empty && left != empty && right == empty && down == empty);

                    bool isLeftTCross           = (up != empty && left == empty && right != empty && down != empty);
                    bool isRightTCross          = (up != empty && left != empty && right == empty && down != empty);
                    bool isTopTCross            = (up == empty && left != empty && right != empty && down != empty);
                    bool isBottomTCross         = (up != empty && left != empty && right != empty && down == empty);

                    bool isCenterCross          = (up != empty && left != empty && right != empty && down != empty);

                    if(isLeftTopCorner) {
                        // InstantiateWithRotation (corner, vec, -90f);
                        InstantiateWithRotationAndCreateWayPoint(corner, vec, -90f, false, true, false, true);
                    }
                    else if(isLeftBottomCorner) {
                        // InstantiateWithRotation (corner, vec, 180f);
                        InstantiateWithRotationAndCreateWayPoint(corner, vec, 180f, true, false, false, true);
                    }
                    else if(isRightTopCorner) {
                        // InstantiateWithRotation (corner, vec, 0f);
                        InstantiateWithRotationAndCreateWayPoint(corner, vec, 0f, false, true, true, false);
                    }
                    else if(isRightBottomCorner) {
                        // InstantiateWithRotation (corner, vec, 90f);
                        InstantiateWithRotationAndCreateWayPoint(corner, vec, 90f, true, false, true, false);
                    }
                    else if(isLeftTCross) {
                        // InstantiateWithRotation (tCross, vec, 0f);
                        InstantiateWithRotationAndCreateWayPoint(tCross, vec, 0f, true, true, false, false);
                    }
                    else if(isRightTCross) {
                        // InstantiateWithRotation (tCross, vec, 180f);
                        InstantiateWithRotationAndCreateWayPoint(tCross, vec, 180f, true, true, false, false);
                    }
                    else if(isTopTCross) {
                        // InstantiateWithRotation (tCross, vec, 90f);
                        InstantiateWithRotationAndCreateWayPoint(tCross, vec, 90f, false, false, true, true);
                    }
                    else if(isBottomTCross) {
                        // InstantiateWithRotation (tCross, vec, -90f);
                        InstantiateWithRotationAndCreateWayPoint(tCross, vec, -90f, false, false, true, true);
                    }
                    else if(isCenterCross) {
                        // InstantiateWithRotation (cross, vec, 0f);
                        InstantiateWithRotationAndCreateWayPoint(cross, vec, 0f, true, true, true, true);
                    }
                }

                x += 1f;    // advance to the right
            } // for(j)
            z -= 1f;        // advance down
            x = startX;     // start from the left
        } // for(i)
    } // CreateLevel()

    Transform InstantiateWithRotation(Transform obj, Vector3 vec, float deg) {
        Vector3 rot = obj.transform.eulerAngles;
        rot = new Vector3 (rot.x, rot.y + deg, rot.z);
        Transform result = Instantiate (obj, vec, Quaternion.Euler (rot));
        wayPoints.Add (result.GetComponent<WayPoint> ());
        return result;
    }


    void InstantiateWithRotationAndCreateWayPoint(Transform obj, Vector3 vec, float deg, bool goUp, bool goDown, bool goLeft, bool goRight) {
        Vector3 rot = obj.transform.eulerAngles;
        rot = new Vector3 (rot.x, rot.y + deg, rot.z);
        Transform result = Instantiate (obj, vec, Quaternion.Euler (rot));

        AuxStruct temp;
        temp.tile = result;
        temp.goUp = goUp;
        temp.goDown = goDown;
        temp.goLeft = goLeft;
        temp.goRight = goRight;

        auxArray [r, c++] = temp;;
        if(c == cols) {
            r++;
            c = 0;
        }
    }

    void SetWayPoints() {
        for(int i=0; i < rows; ++i) {
            for(int j=0; j < cols; ++j) {
                AuxStruct temp = auxArray [i, j];
                Transform obj = temp.tile;
                Debug.Log (obj.position);

                WayPoint wp = obj.GetComponent<WayPoint> ();
                if(temp.goUp) {
                    wp.upWaypoint = auxArray [i - 1, j].tile.GetComponent<WayPoint> ();
                }
                if(temp.goDown) {
                    wp.downWaypoint = auxArray [i + 1, j].tile.GetComponent<WayPoint> ();
                }
                if(temp.goLeft) {
                    wp.leftWaypoint = auxArray [i, j - 1].tile.GetComponent<WayPoint> ();
                }
                if(temp.goRight) {
                    wp.rightWaypoint = auxArray [i, j + 1].tile.GetComponent<WayPoint> ();
                }
            }
        }
    } // SetWayPoints()
}