public Stair(Vector2 enterPos, Vector2 outPos, Floor destination, StairCase target)
 {
     this.enterPos = enterPos;
     this.outPos = outPos;
     this.destination = destination;
     this.target = target;
 }

    public bool createGenerator(Floor end)
    {
        if(!isEmpty())
            return false;

        has=terrain.generator;
        GameObject generatorObject = (GameObject)Instantiate(	generatorPrefab,
                                    new Vector3(transform.position.x, transform.position.y, transform.position.z),
                                    Quaternion.identity
                                );

        GameObject laserObject = (GameObject)Instantiate(	laserPrefab,
                                    new Vector3(transform.position.x, transform.position.y, transform.position.z),
                                    Quaternion.identity
                                );
        laserObject.GetComponent<Laser>().setOriginEnd(generatorObject, end.gameObject);

        Vector3 vect = end.gameObject.transform.position - generatorObject.transform.position;

        float ang=Vector3.Angle(new Vector3(0,0,1), vect);

        if(vect.x<0)
            ang=ang*(-1);

        generatorObject.transform.Rotate(new Vector3(0, ang, 0 ));

        currentObject = generatorObject;
        generatorObject.tag = "Generator";

        emitMineralSprite ("-", GameController.generatorCost.ToString());
        emitParticles(1);

        return true;
    }

        public Meeple(Game game, Floor floor)
            : base()
        {
            CurrentFloor = floor.Number;

            // Gotta pick a floor that's not this one.
            int goingUp = game.Random.Next(2);
            // GOING UP, unless we're on the top floor
            if (goingUp == 1 && CurrentFloor != Game.NUMBER_OF_FLOORS - 1)
            {
                Destination = game.Random.Next(CurrentFloor + 1, Game.NUMBER_OF_FLOORS);
            }

            // GOING DOWN, unless we're on the bottom floor
            else if (CurrentFloor != 0)
            {
                Destination = game.Random.Next(CurrentFloor);
            }

            // GOING UP, because we're on the bottom floor
            else
            {
                Destination = game.Random.Next(0, Game.NUMBER_OF_FLOORS);
            }

            // because meeple get frustrated
            Patience = Math.Abs(Destination - CurrentFloor) * Meeple.FrustrationCoefficient + 3;
            Id = _maxId++;
            InElevator = false;
        }

    public void GenerateCave(Floor floor)
    {
        FillWithRock (floor);
        //		RandomlyPlaceFloor (floor, 50);

        RandomFloor (floor, 50);

        Generate (floor);
        //
        RandomlyDistrabute (floor, 50);
        Generate (floor);
        RandomlyDistrabute (floor, 50);
        Generate (floor);
        RandomlyDistrabute (floor, 50);
        Generate (floor);
        RandomlyDistrabute (floor, 50);
        Generate (floor);
        RandomlyDistrabute (floor, 50);
        Generate (floor);
        RandomlyDistrabute (floor, 50);
        Generate (floor);
        RandomlyDistrabute (floor, 50);
        Generate (floor);
        RandomlyDistrabute (floor, 50);
        Generate (floor);
        RandomlyDistrabute (floor, 50);
        Generate (floor);
        Generate (floor);
        Generate (floor);
        Generate (floor);
        Generate (floor);
    }

    /*
    void Update()
    {

    }
    */
    //****************************************************************************************************
    //*** Functions
    public void MakeFloor()
    {
        // Remove last Floor (except theres an Editor-Test-Level generated already)
        RemoveFloor();

        // Instantiate a new Floor
        activeFloor = new Floor(Global.global.floorSizeX, Global.global.floorSizeZ);

        // Instantiate new Tile-Blocks based on new Floor-Data
        for(int x=0; x<Global.global.floorSizeX; x++)
        {
        for(int z=0; z<Global.global.floorSizeZ; z++)
        {
            byte tile = activeFloor.blockMap[x, z];
            if(tile < 254)
            {
                GameObject tb = Instantiate(tileBlock, new Vector3(x, 0, z), Quaternion.identity) as GameObject;
                tb.renderer.material = materials[tile];

                // group as child into "LEVEL"-GameObject
                tb.transform.parent = this.transform;
            }
        }
        }

        MakeGround();

        SetPlayerPosition();

        SetLightSources();

        MakeMap();

        PositionEnemies();
    }

    /// <summary>
    /// Used to generate all rooms.
    /// </summary>
    /// <description> Generates all rooms by calling the GenerateRoom function until there is either
    /// no more possible room locations in the list PossibleRoomLocations or the amount of rooms made
    /// has hit the target number of rooms specified in the inspector. If it has been specified in the 
    /// inspector to make as many rooms as possible, the target number of rooms will be changed to a 
    /// very large number which would not be possible to complete. </description>
    /// <param name="floor">Floor to generate rooms on</param>
    public void GenerateAllRooms(Floor floor)
    {
        if (floor.reflectRoomsX) reflectX = true;
        else reflectX = false;

        if (floor.reflectRoomsZ) reflectZ = true;
        else reflectZ = false;

        if (asManyAsPossible) targetNumOfRooms = 1000;

        bool finished = false;

        GenerateCentralRoom ();

        while (!finished) {

            if (PossibleRoomLocations ().Count > 0 && targetNumOfRooms > roomList.Count) {

                GenerateRoom ();
            }
            else finished = true;
        }

        if (reflectX) ReflectX ();
        if (reflectZ) ReflectZ ();

        //ConnectRooms (roomList[0], roomList[1]);
    }

 void ElevatorListener.FloorArrived(Floor arrived)
 {
     if (floorOfCallButton == arrived) {
         StatusBtnLight(true);
         blinking = true;
     }
 }

 public void SetFloor(Floor newFloor)
 {
     _isOnStair = false;
     // Debug.Log("newFloor");
     currentFloor = newFloor;
     if (body.velocity.y < -0.5f)
         CrackSound();
 }

        public AimingArrow(PuzzleBooble3dGame game, Floor floor)
            : base(game)
        {
            Floor = floor;

            AngleZ = 0;
            Position = Floor.Position + new Vector3(Floor.WIDTH/2, 0, Ball.BALL_RADIUS);
        }

 public bool IsNextTo(Floor otherFloor)
 {
     int diffX = this.X - otherFloor.X;
     int diffY = this.Y - otherFloor.Y;
     if (diffX == 0 || diffY == 0)
         return (System.Math.Abs(diffX + diffY) == 1);
     return false;
 }

 void DrawFloor(Floor floor, int yOffset)
 {
     for(int i=0; i<floor.rooms.Count; i++)
     {
         Room room = floor.rooms[i];
         DrawRoom (room, 50*(i+1), yOffset);
     }
 }

    // Use this for initialization
    void Start()
    {
        floor = GetComponent<Floor>(); // find the floor game object

        timerValue = spawnSpeed;

        player = GameObject.FindGameObjectWithTag("Player");
    }

    public House(int _size)
    {
        size = _size;

        attic = new Floor(size, FloorType.Attic);
        ground = new Floor(size, FloorType.Ground);
        basement = new Floor(size, FloorType.Basement);
    }

 /// <summary>
 /// constructor
 /// </summary>
 /// <param name="floor">floor to create reinforcement on</param>
 /// <param name="commandData">object which contains reference to Revit Application</param>
 public ProfileFloor(Floor floor, ExternalCommandData commandData)
     : base(commandData)
 {
     m_data = floor;
     List<List<Edge>> faces = GetFaces(m_data);
     m_points = GetNeedPoints(faces);
     m_to2DMatrix = GetTo2DMatrix();
 }

    Floor theFloor;     // the floor object - used by customers for pathfinding

    // CONSTRUCTOR for the class
    public FilmShowing(int id, int screenNumber, int tickets, int hours, int minutes, Floor f)
    {
        screeningID = id;
        screenNum = screenNumber;
        ticketsSold = tickets;
        timeH = hours;
        timeM = minutes;
        theFloor = f;
    }

 public FloorSearcher(Vector2 startingPos, Vector2 targetPos, Floor startingFloor = null, Floor targetFloor = null, StairCase startingStair = null, StairCase targetStair = null)
 {
     pathList = new List<List<Vector2>>();
     this.startingPos = startingPos;
     this.targetPos = targetPos;
     this.startingFloor = startingFloor;
     this.targetFloor = targetFloor;
     this.startingStair = startingStair;
     this.targetStair = targetStair;
 }

 public void CreateCourse()
 {
     if (!IsCourseCreated) {
         FloorList floors = CreateFloorList();
         Floor = floors.Head;
         GetComponent<MeshFilter> ().sharedMesh = floors.Mesh;
         GetComponent<MeshFilter> ().sharedMesh.name = "courseMesh";
         IsCourseCreated = true;
     }
 }

 public void CallToFloor(Floor floor)
 {
     targetFloors |= (int)floor;
     if (IsStanding()) {
         currentTargetFloor = floor;
     }
     else {
         CalculateNearestTargetFloor();
     }
 }

    public void FloorPassed(Floor passed)
    {
        //     Debug.Log("set mat");
         //   ledMat.mainTexture = numbers[FloorUtility.Index(passed)];
          //  ledMat.SetTexture("_EmissionMap", ledMat.mainTexture);
          //  ledMat.SetColor("_EmissionColor", Color.white);
          //  DynamicGI.SetEmissive(GetComponent<Renderer>(), Color.white);

        GetComponent<Renderer>().material = numbers[FloorUtility.Index(passed)];
    }

  public static void Main(string[] args) {
    Table env = new Table();
    Symbol k;
    object v;

    k = Lua.Symbol.Intern("print");
    v = new Print();
    env[k] = v;

    k = Lua.Symbol.Intern("setmetatable");
    v = new SetMetatable();
    env[k] = v;

    k = Lua.Symbol.Intern("pairs");
    v = new Pairs();
    env[k] = v;

    Lua.Symbol s = Lua.Symbol.Intern("tonumber");
    k = s;
    v = new ToNumber();
    env[k] = v;

    k = Lua.Symbol.Intern("os");
    Table os = new Table();
    v = os;
    env[k] = v;
    k = Lua.Symbol.Intern("clock");
    v = new Clock();
    os[k] = v;

    k = Lua.Symbol.Intern("io");
    Table io = new Table();
    v = io;
    env[k] = v;
    k = Lua.Symbol.Intern("write");
    v = new Write();
    io[k] = v;

    k = Lua.Symbol.Intern("math");
    Table math = new Table();
    v = math;
    env[k] = v;
    k = Lua.Symbol.Intern("floor");
    v = new Floor();
    math[k] = v;

    Closure c = (Closure)Assembly.LoadFrom(args[0] + ".dll").
      GetType(args[0] + ".function1").GetConstructor(new Type[0]).
      Invoke(new object[0]);
    c.Env = env;
    c.InvokeS();
    for(int i = 0; i <= System.GC.MaxGeneration; i++)
      Console.WriteLine(System.GC.CollectionCount(i));
  }