Пример #1
0
 private void SpawnRandomItemOnMap(List <Transform> items)
 {
     if (items.Count > 0)
     {
         int id = UnityEngine.Random.Range(0, items.Count);
         GeneratedPath.AddItem(Instantiate(items[id], MapManager.m.spawnPoint.transform.position, new Quaternion()));
     }
     else
     {
         Debug.Log("No items to spawn.");
     }
 }
    // Creates every floor tile for a given room.
    // Room r - the room to have its floor tiles created
    // GameObject floor - the floor tile prefab to be created. See CreateDoor for notes about this.
    // float baseX, baseZ - the beginning of a maze. Position at which the 0, 0 room's floor tile will go.
    // float size - the size of a floor tile. Used for positioning with relative indices in room objects.
    private void CreateFloors(Room r, GameObject floor, float baseX, float baseZ, float size, HashSet <Room> inclusions)
    {
        IEnumerator <Vector2> enumer = r.Space.GetEnumerator();

        enumer.MoveNext();
        Vector2 first = enumer.Current;

        float minX = first.x;
        float minY = first.y;

        foreach (Vector2 point in r.Space)
        {
            if (point.x < minX)
            {
                minX = point.x;
            }
            if (point.y < minY)
            {
                minY = point.y;
            }
        }


        List <Vector2> aspTiles       = new List <Vector2>();
        List <Vector2> aspStartPoints = new List <Vector2>();

        foreach (Vector2 point in r.Space)
        {
            aspTiles.Add(new Vector2(point.x - minX, point.y - minY));
        }
        foreach (Room adj in r.Adj)
        {
            if (inclusions.Contains(adj))
            {
                aspStartPoints.AddRange(ConnectingPoints(r, adj, minX, minY));
            }
        }
        foreach (Vector2 pt in r.Space)
        {
            foreach (Connection c in connections)
            {
                if (c.Point.x - baseX == pt.x && c.Point.y - baseZ == pt.y)
                {
                    float x = 0;
                    float y = 0;
                    switch (c.Dir)
                    {
                    case Direction.Up:
                        x = (pt.x - minX) * GridSizeOfEachTile + (GridSizeOfEachTile / 2);
                        y = (pt.y - minY) * GridSizeOfEachTile + GridSizeOfEachTile - 1;
                        break;

                    case Direction.Down:
                        x = (pt.x - minX) * GridSizeOfEachTile + (GridSizeOfEachTile / 2);
                        y = (pt.y - minY) * GridSizeOfEachTile;
                        break;

                    case Direction.Left:
                        x = (pt.x - minX) * GridSizeOfEachTile;
                        y = (pt.y - minY) * GridSizeOfEachTile + (GridSizeOfEachTile / 2);
                        break;

                    case Direction.Right:
                        x = (pt.x - minX) * GridSizeOfEachTile + GridSizeOfEachTile - 1;
                        y = (pt.y - minY) * GridSizeOfEachTile + (GridSizeOfEachTile / 2);
                        break;
                    }
                    aspStartPoints.Add(new Vector2(x, y));
                }
            }
        }
        //Debug.Log("Creating floors for room " + r.Id);
        IEnumerator <Vector2> pointEnumer = r.Space.GetEnumerator();

        pointEnumer.MoveNext();
        //Debug.Log("Room " + r.Id + "contains a point " + pointEnumer.Current);
        //Debug.Log("room " + r.Id + " has " + r.Space.Count + " rooms");
        //Debug.Log("TIles");
        foreach (Vector2 v in aspTiles)
        {
            //Debug.Log(v);
        }
        //Debug.Log("start points");
        foreach (Vector2 v in aspStartPoints)
        {
            //Debug.Log(v);
        }
        GeneratedPath     p          = PathGeneration.RunPathGeneration(aspTiles, aspStartPoints, NumModels, GridSizeOfEachTile, aspTiles.Count * (2 * (int)GridSizeOfEachTile - 1), Random.Range(0, 2));
        List <Vector2>    points     = p.Spaces;
        HashSet <Vector2> rampPoints = new HashSet <Vector2>(p.Ramps);

        //Debug.Log("Now laying tiles...");
        //Debug.Log("BaseX: " + baseX);
        //Debug.Log("BaseZ: " + baseZ);
        //Debug.Log("MinY: " + minY);
        //Debug.Log("MinX: " + minX);
        //Debug.Log("Size: " + size);

        float scale = 1 / GridSizeOfEachTile;

        Debug.Log(scale);
        //Center to edge of a tile
        float offset        = TileWidth / 2;
        float indexMultiple = 10 / GridSizeOfEachTile;

        foreach (Vector2 v in points)
        {
            if (!rampPoints.Contains(v))
            {
                float basePositionX = minX * size + baseX * size;
                float basePositionY = minY * size + baseZ * size;
                // Now with 100% fewer magic numbers!
                float   offsetX = v.x * indexMultiple - offset * (1 - 1 / (float)GridSizeOfEachTile);
                float   offsetY = v.y * indexMultiple - offset * (1 - 1 / (float)GridSizeOfEachTile);
                Vector3 pos     = new Vector3(basePositionX + offsetX, 0, basePositionY + offsetY);

                GameObject g = Instantiate(FloorTilePiece, pos, Quaternion.identity);
                g.transform.localScale = new Vector3(g.transform.localScale.x * scale, 1, g.transform.localScale.z * scale);
            }
        }
        if (p.Ramps.Count > 0)
        {
            for (int i = 0; i < p.Ramps.Count; i += 3)
            {
                Vector2 avg = AveragePoint(p.Ramps, i, i + 3);

                float basePositionX = minX * size + baseX * size;
                float basePositionY = minY * size + baseZ * size;
                // magic numbers are BAD GABE WHY YOU DO THIS
                // currently they're magic for GridSize=4
                // They're magic because I don't actually know what their values are supposed to be.
                float      offsetX = avg.x * indexMultiple - offset * (1 - 1 / (float)GridSizeOfEachTile);
                float      offsetY = avg.y * indexMultiple - offset * (1 - 1 / (float)GridSizeOfEachTile);
                Vector3    pos     = new Vector3(basePositionX + offsetX, 0, basePositionY + offsetY);
                GameObject g       = Instantiate(Ramp, pos, DirectionOfPoints(p.Ramps, i));
                g.transform.localScale = new Vector3(g.transform.localScale.x * scale, 1, g.transform.localScale.x * scale);
            }
        }


        //foreach (Vector2 point in r.Space)
        //{
        //    float x = point.x * size + baseX * size;
        //    float y = 0;
        //    float z = point.y * size + baseZ * size;
        //    floors.Add(Instantiate(floor, new Vector3(x, y, z), Quaternion.identity));
        //}
    }