sg04_workingCpy2

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;

    // player coods
    int pacmanX;
    int pacmanZ;

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

    // enemy coords
    int blinkyX;
    int blinkyZ;
    int pinkyX;
    int pinkyZ;
    int inkyX;
    int inkyZ;
    int clydeX;
    int clydeZ;

    // tiles
    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;

    // a struct that helps setting the wayPoints
    struct WayPointData {
        public Transform tile;
        public bool goUp;
        public bool goDown;
        public bool goLeft;
        public bool goRight;
    };
    WayPointData[,] wayPointDataArray;  // 2D array
    int rows = 0;                       // final # of rows
    int cols = -1;                      // final # of columns
    int r = 0;                          // row idx  (needed when filling in the array)
    int c = 0;                          // col idx  (needed when filling

    // instantiated objects
    List<Transform> createdTiles = new List<Transform>();
    List<Transform> createdCharacters = new List<Transform>();

    void Awake() {
        instance = this;
    }

    void Update() {
        if(isReady) {
            wayPointDataArray = new WayPointData[rows, cols];
            CreateLevel ();
            SetWayPoints ();
            SetAndInstantiateCharacters ();
            isReady = false;
        }
    }

    /// <summary>
    /// Reads the file. In doing so, it also destroys the current level and creates the data necessary for the new level.
    /// While reading the file, syntax and semantic checks are done as well.
    /// </summary>
    /// <param name="fileName">File name.</param>
    public void ReadFile(string fileName) {
        Destroy ();

        string text = System.IO.File.ReadAllText (prefix + fileName);
        SyntaxChecker.instance.errorMsg.text = "";
        SemanticsChecker.instance.errorMsg.text = "";

        if(!SyntaxChecker.instance.IsSyntacticallyCorrect (text)) {
            SyntaxChecker.instance.errorMsg.text = "Syntax Error!";
            return;
        }

        level.Clear ();
        List<string> lines = new List<string>(Regex.Split (text, "\n"));

        rows = 0;
        cols = -1;
        r = 0;
        c = 0;

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

            // important note #1: we have to invert the provided z-value as the level grows downward but the z-axis points upward
            // important note #2: the x-value is to be used in the 2nd dimension of the level-array (-> columns!)
            // important note #3: as the z-value will be negative, we have to invert it again when accessing the level-array later on

            switch(currentLineSplit[0]) {
            case "Pacman":
                pacmanX = int.Parse (currentLineSplit [1]);
                pacmanZ = -int.Parse (currentLineSplit [2]);
                break;
            case "Blinky":
                blinkyX = int.Parse (currentLineSplit [1]);
                blinkyZ = -int.Parse (currentLineSplit [2]);
                break;
            case "Pinky":
                pinkyX = int.Parse (currentLineSplit [1]);
                pinkyZ = -int.Parse (currentLineSplit [2]);
                break;
            case "Inky":
                inkyX = int.Parse (currentLineSplit [1]);
                inkyZ = -int.Parse (currentLineSplit [2]);
                break;
            case "Clyde":
                clydeX = int.Parse (currentLineSplit [1]);
                clydeZ = -int.Parse (currentLineSplit [2]);
                break;
            default:
                // else it must be some level object
                level.Add (currentLine);
                rows++;
                if(cols == -1) {
                    // assumes that each row is of the same length
                    cols = currentLine.Length;
                }
                break;
            } // switch()
        } // for()

        if(!SemanticsChecker.instance.IsSemanticallyCorrect (lines, rows, cols)) {
            SemanticsChecker.instance.errorMsg.text = "Semantics Error!";
            return;
        }

        isReady = true;
    } // ReadFile()


    /// <summary>
    /// Destroys the level and the characters.
    /// </summary>
    void Destroy() {
        foreach(Transform character in createdCharacters) {
            if(character != null) {
                Destroy (character.gameObject);
            }
        }

        foreach(Transform tile in createdTiles) {
            if(tile != null) {
                Destroy (tile.gameObject);
            }
        }

        createdCharacters.Clear ();
        createdTiles.Clear ();
    }


    /// <summary>
    /// Creates the level by instantiating the tiles in the correct position and rotation.
    /// </summary>
    void CreateLevel() {
        float startX = 0f;

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

        Transform tile;

        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) || level[i][j-1] == sCorridorVertical;
                    bool isDeadEndRight = (j == level[i].Length-1) || level[i][j+1] == sCorridorVertical;

                    if(isDeadEndLeft) {
                        tile = InstantiateWithRotationAndCreateWayPointData(deadEnd, vec, -90f, false, false, false, true);
                        createdTiles.Add (tile);
                    }
                    else if(isDeadEndRight) {
                        tile = InstantiateWithRotationAndCreateWayPointData(deadEnd, vec, 90f, false, false, true, false);
                        createdTiles.Add (tile);
                    }
                    else {
                        tile = InstantiateWithRotationAndCreateWayPointData(corridor, vec, 90f, false, false, true, true);
                        createdTiles.Add (tile);
                    }

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

                    if(isDeadEndUp) {
                        tile = InstantiateWithRotationAndCreateWayPointData(deadEnd, vec, 0f, false, true, false, false);
                        createdTiles.Add (tile);
                    }
                    else if(isDeadEndDown) {
                        tile = InstantiateWithRotationAndCreateWayPointData(deadEnd, vec, 180f, true, false, false, false);
                        createdTiles.Add (tile);
                    }
                    else {
                        tile = InstantiateWithRotationAndCreateWayPointData(corridor, vec, 0f, true, true, false, false);
                        createdTiles.Add (tile);
                    }
                }

                char empty = ' ';
                if(level[i][j] == sCross) {
                    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;

                    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) {
                        tile = InstantiateWithRotationAndCreateWayPointData(corner, vec, -90f, false, true, false, true);
                        createdTiles.Add (tile);
                    }
                    else if(isLeftBottomCorner) {
                        tile = InstantiateWithRotationAndCreateWayPointData(corner, vec, 180f, true, false, false, true);
                        createdTiles.Add (tile);
                    }
                    else if(isRightTopCorner) {
                        tile = InstantiateWithRotationAndCreateWayPointData(corner, vec, 0f, false, true, true, false);
                        createdTiles.Add (tile);
                    }
                    else if(isRightBottomCorner) {
                        tile = InstantiateWithRotationAndCreateWayPointData(corner, vec, 90f, true, false, true, false);
                        createdTiles.Add (tile);
                    }
                    else if(isLeftTCross) {
                        tile = InstantiateWithRotationAndCreateWayPointData(tCross, vec, 0f, true, true, false, true);
                        createdTiles.Add (tile);
                    }
                    else if(isRightTCross) {
                        tile = InstantiateWithRotationAndCreateWayPointData(tCross, vec, 180f, true, true, true, false);
                        createdTiles.Add (tile);
                    }
                    else if(isTopTCross) {
                        tile = InstantiateWithRotationAndCreateWayPointData(tCross, vec, 90f, false, true, true, true);
                        createdTiles.Add (tile);
                    }
                    else if(isBottomTCross) {
                        tile = InstantiateWithRotationAndCreateWayPointData(tCross, vec, -90f, true, false, true, true);
                        createdTiles.Add (tile);
                    }
                    else if(isCenterCross) {
                        tile = InstantiateWithRotationAndCreateWayPointData(cross, vec, 0f, true, true, true, true);
                        createdTiles.Add (tile);
                    }
                }

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


    /// <summary>
    /// Instantiates the given Transform object (a tile) at position 'vec', rotated by 'deg' degrees.
    /// The boolean parameters are used to store the necessary information to create the WayPoint data for each tile later on.
    /// </summary>
    /// <returns>The instantiated object at position 'vec', rotated by 'deg' degrees.</returns>
    /// <param name="obj">The Transform to be instantiated.</param>
    /// <param name="vec">The Position at which the object is instantiated.</param>
    /// <param name="deg">The degree by which the object is rotated.</param>
    /// <param name="goUp">If set to <c>true</c> it's possible to go up.</param>
    /// <param name="goDown">If set to <c>true</c> it's possible to go down.</param>
    /// <param name="goLeft">If set to <c>true</c> it's possible to go left.</param>
    /// <param name="goRight">If set to <c>true</c> it's possible to go right.</param>
    Transform InstantiateWithRotationAndCreateWayPointData(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));

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

        if(r < rows && c < cols) {
            wayPointDataArray [r, c++] = temp;

            if(c == cols) {
                r++;
                c = 0;
            }
        }

        return result;
    } // InstantiateWithRotationAndCreateWayPointData()

    /// <summary>
    /// Sets the way points of each tile in the level.
    /// </summary>
    void SetWayPoints() {
        // map
        for(int i=0; i < rows; ++i) {
            for(int j=0; j < cols; ++j) {
                WayPointData temp = wayPointDataArray [i, j];
                Transform obj = temp.tile;

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


    /// <summary>
    /// Sets the necessary data (currentWayPoint and position) of each character and instantiates them.
    /// </summary>
    void SetAndInstantiateCharacters() {
        int x;
        int z;
        Transform tile;
        WayPoint wp;
        Transform character;

        x = pacmanX;
        z = -pacmanZ;
        tile = wayPointDataArray [z, x].tile;
        if(tile != null) {
            wp = tile.GetComponent<WayPoint> ();
            pacman.GetComponent<PlayerControlScript> ().currentWaypoint = wp;
            character = Instantiate (pacman, new Vector3 (pacmanX, pacman.transform.position.y, pacmanZ), Quaternion.identity);
            createdCharacters.Add (character);
        }

        x = blinkyX;
        z = -blinkyZ;
        tile = wayPointDataArray [z, x].tile;
        if(tile != null) {
            wp = tile.GetComponent<WayPoint> ();
            blinky.GetComponent<EnemyBehaviourScript> ().currentWaypoint = wp;
            character = Instantiate (blinky, new Vector3 (blinkyX, blinky.transform.position.y, blinkyZ), Quaternion.identity);
            createdCharacters.Add (character);
        }

        x = pinkyX;
        z = -pinkyZ;
        tile = wayPointDataArray [z, x].tile;
        if(tile != null) {
            wp = tile.GetComponent<WayPoint> ();
            pinky.GetComponent<EnemyBehaviourScript> ().currentWaypoint = wp;
            character = Instantiate (pinky, new Vector3 (pinkyX, pinky.transform.position.y, pinkyZ), Quaternion.identity);
            createdCharacters.Add (character);
        }

        x = inkyX;
        z = -inkyZ;
        tile = wayPointDataArray [z, x].tile;
        if(tile != null) {
            wp = tile.GetComponent<WayPoint> ();
            inky.GetComponent<EnemyBehaviourScript> ().currentWaypoint = wp;
            character = Instantiate (inky, new Vector3 (inkyX, inky.transform.position.y, inkyZ), Quaternion.identity);
            createdCharacters.Add (character);
        }

        x = clydeX;
        z = -clydeZ;
        tile = wayPointDataArray [z, x].tile;
        if(tile != null) {
            wp = tile.GetComponent<WayPoint> ();
            clyde.GetComponent<EnemyBehaviourScript> ().currentWaypoint = wp;
            character = Instantiate (clyde, new Vector3 (clydeX, clyde.transform.position.y, clydeZ), Quaternion.identity);
            createdCharacters.Add (character);
        }
    } // SetAndInstantiateCharacters()
}