C# Floor类代码示例

 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;
    }