c# - posicion - como hacer un score en unity

En Unity3D, estoy siguiendo un tutorial de mapas de mosaico. Sin embargo, el diseño UV está saliendo extraño. ¿Cómo puedo arreglar esto?

Question

Estoy siguiendo este conjunto de tutoriales: https://www.youtube.com/watch?v=owBt9SNKXCI&index=6&list=PLbghT7MmckI4qGA0Wm_TZS8LVrqS47I9R para construir dinámicamente un diseño de mapa de mosaicos. Funciona hasta cierto punto, pero genera un diseño muy extraño con mosaicos de 128 x 128.

Claramente, esa partición extraña no debería estar sucediendo, pero parece que no puedo rastrear qué está causando eso. Aquí está mi versión del código, que es en su mayoría idéntica a la versión de quill18creates sin algunas pequeñas diferencias:

using UnityEngine;
using System.Collections;

[ExecuteInEditMode]
public class TileMap : MonoBehaviour {

    public int size_x = 100;
    public int size_z = 50;
    public float tileSize = 1.0f;

    public Texture2D terrainTiles;
    int tileResolution = 128;

    // Use this for initialization
    void Start () {
        BuildMesh();
    }

    Color[][] ChopUpTiles() {
        int numTilesPerRow = terrainTiles.width / tileResolution;
        int numRows = terrainTiles.height / tileResolution;

        Color[][] tiles = new Color[numTilesPerRow*numRows][];

        for(int y=0; y < numRows; y++) {
            for(int x=0; x < numTilesPerRow; x++) {
                tiles[y * numTilesPerRow + x] = terrainTiles.GetPixels( x*tileResolution , y*tileResolution, tileResolution, tileResolution );
            }
        }

        return tiles;
    }

    void BuildTexture() {
        //DTileMap map = new DTileMap(size_x, size_z);

        int texWidth = size_x * tileResolution;
        int texHeight = size_z * tileResolution;
        Texture2D texture = new Texture2D(texWidth, texHeight);

        Color[][] tiles = ChopUpTiles();


        for(int y=0; y < size_z; y++) {
            for(int x=0; x < size_x; x++) {
                Color[] p = tiles[Mathf.RoundToInt(Random.Range(0, 5))];
                texture.SetPixels(x * tileResolution, y * tileResolution, tileResolution, tileResolution, p);
            }
        }

        //texture.filterMode = FilterMode.Bilinear;
        texture.wrapMode = TextureWrapMode.Clamp;
        texture.Apply();

        MeshRenderer mesh_renderer = GetComponent<MeshRenderer>();
        mesh_renderer.sharedMaterials[0].mainTexture = texture;
    }

    public void BuildMesh() {
        int numTiles = size_x * size_z;
        int numTris = numTiles * 2;

        int vsize_x = size_x + 1;
        int vsize_z = size_z + 1;
        int numVerts = vsize_x * vsize_z;

        // Generate the mesh data
        Vector3[] vertices = new Vector3[ numVerts ];
        Vector3[] normals = new Vector3[numVerts];
        Vector2[] uv = new Vector2[numVerts];

        int[] triangles = new int[ numTris * 3 ];

        int x, z;
        for(z=0; z < vsize_z; z++) {
            for(x=0; x < vsize_x; x++) {
                vertices[ z * vsize_x + x ] = new Vector3( x*tileSize, 0, -z*tileSize );
                normals[ z * vsize_x + x ] = Vector3.up;
                uv[ (z * vsize_x) + x ] = new Vector2( (float)x / size_x, (float)z / size_z );
            }
        }
        Debug.Log ("Done Verts!");

        for(z=0; z < size_z; z++) {
            for(x=0; x < size_x; x++) {
                int squareIndex = z * size_x + x;
                int triOffset = squareIndex * 6;
                triangles[triOffset + 0] = z * vsize_x + x +           0;
                triangles[triOffset + 2] = z * vsize_x + x + vsize_x + 0;
                triangles[triOffset + 1] = z * vsize_x + x + vsize_x + 1;

                triangles[triOffset + 3] = z * vsize_x + x +           0;
                triangles[triOffset + 5] = z * vsize_x + x + vsize_x + 1;
                triangles[triOffset + 4] = z * vsize_x + x +           1;
            }
        }

        // Create a new Mesh and populate with the data
        Mesh mesh = new Mesh();
        mesh.vertices = vertices;
        mesh.triangles = triangles;
        mesh.normals = normals;
        mesh.uv = uv;

        // Assign our mesh to our filter/renderer/collider
        MeshFilter mesh_filter = GetComponent<MeshFilter>();
        MeshCollider mesh_collider = GetComponent<MeshCollider>();

        mesh_filter.mesh = mesh;
        mesh_collider.sharedMesh = mesh;


        BuildTexture();
    }   
}

Answer 1

No entiendo exactamente qué parte está mal en la imagen, pero creo que es que las mismas fichas se están uniendo. Probé tu código y funciona bien para mí. Pero supongo que la siguiente parte podría estar causando el problema de agrupamiento para usted:

Color[] p = tiles[Mathf.RoundToInt(Random.Range(0, 5))];

En cambio, debes hacer:

Color[] p = tiles[Random.Range(0, 5)];

Porque, a la inversa, Random está generando números flotantes y quizás están cerca el uno del otro que al redondearlos al número entero da el mismo mosaico. Darle una oportunidad. Recordando también, asegúrese de que el ancho y la altura de su textura sean divisibles por 128.

Answer 2

Bueno, definitivamente era un problema de tamaño, pero también había un problema con el posicionamiento. Las baldosas tienen que comenzar en la esquina inferior izquierda para que el sistema de coordenadas las encuentre.