Buenos días,
 
estoy intentando hacer un tablero dinámico de cartas para un juego. El problema que tengo es que el tablero no me sale centrado cuando el tamaño del mismo varía. Lo he intentado de todas las maneras pero no encuentro la manera de hacer que funcione.
 
creo el tablero de la siguiente manera:
 

public void CrearTableroCartas () {
   int cont = 0;
   for(int x=0; x<anchoAlto; x++){
      for(int i=0; i<anchoAlto; i++){
         float factor = 9.0f / anchoAlto;
         Vector3 posicionTemp = new Vector3(x * factor, i * factor, 0);
         GameObject cartaTemporal = Instantiate(carta, posicionTemp, Quaternion.Euler(new Vector3(0, 180, 0)));
         cartaTemporal.transform.localScale *= factor;
         cartaTemporal.transform.position = posicionTemp;
      }
   }      

 
 Adjunto dos imágenes del problema. Pueden ver que si el tablero tiene muchas cartas,  se centra pero si hay pocas se escala bien el tamaño pero no se quedan centradas y se pierden un poco.
 
¿Alguien tiene alguna idea de como resolverlo?
 
Muchas gracias de antemano!
 
Saludos.
 
 
 

Hola, mas alla de lo que estes haciendo ahora, si lo vas a hacer lo mas general posible tenes que tener algunas consideraciones, primero optar por sprites (podrias con UI con todo redimensionable por slots, pero los sprites van mejor en situaciones asi), cada sprite de cada carta tendra su ppu (pixel per unit), osea que vamos a suponer una carta de 32 ppu por ejemplo, eso seria 1x1 en Unity o 32x32 px de pantalla. Como lo pense yo (vos lo podes hacer a tu modo) , es algo asi:  espacio, carta, espacio , carta..... carta final, espacio final, Generalizando para n cartas, como P porcentaje (0f a 1f) de espacio y ancho de tablero W:
 
n * newSize + (n+1) * P * newSize = (n + (n+1) * P) newSize = W
 
Entonces una vez tengas los valores de entrada (n, P , W) podes encontrar los "factores" basandote en tu PPU
 
del calculo anterior debes encontrar nuevo tamaño de carta:
 
newSize = W / ((n + (n+1) * P))
 
Al final encontrar el factor:
 
originalSize * factor = newSize  ----> factor = newSize / originalSize
 
si fuera en C#:
 

int W;
float p;
int n;
int newSize;
int originalSize;
float factor;
const int PPU = 32; //32 ppu por ejemplo
void Resize(){

int originalSize = PPU; //aca podes multiplicar por dimensiones de la carta, lo deje en 1....(1x1)
     int newSize = W / ((n + (n+1) * P));
     float factor = newSize / originalSize;
     
     Vector3 newScale = Vector3.one * factor;
     //si sale factor1 te quedan cartas en el ppu original
     //a mayor cartas el factor decrece, logico
  
     //resta a cada carta aplicarle la nueva escala, y posicionarlas bien, 
     //pero es redimensionamiento ya estaria hecho en base a las entradas ya mencionadas
//...
}

 
AL resize lo aplicas cada vez que se deba cambiar el numero de cartas, no lo haces cuadro a cuadro.
 
Ahora a modo de ejemplo, con un PPU = 32, vamos a darle un tamaño de 76 pixeles de tablero horizontal, y queres que entren 5 cartas, con un espacio del 20% de la dimension de la carta, entonces todo te queda algo asi:
 
newSize = 76 / ((5 + 6 * 0.2f))
 
factor = 12.25 / 32
 
factor = 0.38 ---> escala < 0.38 , 0.38 , 0.38 >
 
-----------------------------------------------------------------------------------------------------------------------------
 
Volviendo un poco, quizas te quede mal cuando se relaciona numero de cartes y escala en tu ejemplo, por eso te propuse hacer esto.
 
saludos

Muchas gracias lightbug! Voy a poner en práctica tus indicaciones y te comento el resultado . 
 
Saludos!