异质瓷砖和佩林噪声

Question

I am trying to implement a tiled game with heterogeneous tiles; tiles of different sizes. All tilesizes are rounded in size (to a meter) to make it easier. I am looking for a algorithm that fits the tiles in pseudorandom order, with the requirement that ofcourse everything must be tiled.

Below are a few lines I wrote, however it does not work as needed. Somehow the spacing between the tiles is not respected.

First I generate a map of perlin noise which is created on the go. I use a dictionary for my tilemap.

A tile's object meters variable is the width and depth of the square tile in meters. The first tile in tiles array is an empty tile, for specifying a skip.

Edit: I see now there is a scaling issue in Unity, where as I apply a scale of 1 to a plane in game it will result in a size of 10. Can someone provide an explanation for that?

 for(int i=-viewSpreadMeters;i<=viewSpreadMeters;i++)
        {
            for(int j=-viewSpreadMeters;j<=viewSpreadMeters;j++)
            {   
                int x = currentTerrainID[0] + i;
                int y = currentTerrainID[1] + j;

                if (!tileMap.ContainsKey(x, y)) {
                    int id = noiseMap[x, y];
                    int iteratedTiles = 0;
                Restart:
                    for (int k = 1; k < tiles[id].meters; k++) {
                        for (int l = 1; l < tiles[id].meters; l++) {
                            int x2 = x + k;
                            int y2 = y + l;
                            if (tileMap.ContainsKey(x2, y2)) {
                                int prevMeters;
                                do {
                                    iteratedTiles++;
                                    print ("Iterated tiles" + iteratedTiles);
                                    if (iteratedTiles >= tiles.Length - 1) {
                                        id = 0;
                                        goto EndLoop;
                                    }
                                    prevMeters = tiles[id].meters;
                                    id++;
                                    id %= tiles.Length;
                                    if (id == 0) id++;
                                } while(tiles[id].meters >= prevMeters);                            
                                goto Restart;
                            }
                        }
                    }
                EndLoop:
                    tileMap.Add(x, y, id);
                    for (int k = 1; k < tiles[id].meters; k++) {
                        for (int l = 1; l < tiles[id].meters; l++) {
                            int x2 = x + k;
                            int y2 = y + l;
                            tileMap.Add(x2, y2, 0);
                        }
                    }
                }
            }
        }

Answer 1

There's a fault in the above code, a missing continue. Also, I needed chunks to make heterogeneous tiles work.

Answer 2

The scaling issue depends on how you're importing your assets. If the tiles are created programatically they should be at 1:1 scale; however if you're importing them from a DCC tool like Max or Maya you need to check the 'glbal scale' setting in the models' import settings - Depending on the source application and the settings there the global scale may get set to enlarge or shrink imported units anywhere from 1:100 to 100:1.

Heterogeneous tiles are tricky because you have to manage edge matching along partial edges. Are you sure you need heterogeneous sizes?