[Tachikomaia]

Sigo sin ver donde te gace la diferencia el programa, quiza tu función  math.round() no devuelve exacto lo que se necesita

Demasiado improbable, pero vemos.
trace (Math.round(0.1));
trace (Math.round(1.2));
trace (Math.round(3.3));
trace (Math.round(6.4));
trace (Math.round(10.5));
trace (Math.round(15.6));
trace (Math.round(21.7));
trace (Math.round(28.8));
trace (Math.round(36.9));
trace (Math.round(45.0));

Resultado:
0
1
3
6
11
16
22
29
37
45

Yo lo veo bien ¿el problema es que el .5 lo redondea para arriba?

Fijate si puedes crear tu propia función  de redondeo

Lo hice, el resultado parece el mismo.

Al hacer la función así (para que el .5 se redondé hacia abajo):

Código: [Seleccionar]

function RRound (valor) {
if (valor - Math.floor(valor) < 0.6) {
        valor = Math.floor(valor);
    } else {
        valor = Math.floor(valor) + 1;
    }
return valor;
} Las filas con menos puntos suelen ser las de arriba.

Mira, resultado de antes y de ahora:




Hice los demás cambios que dijiste y parece igual:

Pd: hice un programita que hace las ventanas que muestras para cada recta y  usando la funcion de redondeo definida en el propio programa y funciono excelente, pero con round() daba ciertas curvas

Justo te iba a decir que si quieres lo imites en Python a ver si ahí te sale, mostrame si quieres una foto y el programa, yo tengo Python, sólo que no sé usarlo mucho, pero puedo pegar el código y pedir a la IA que me ayude a que funcione, si es necesario. Sino puedo pedirle que transforme mi programa a Python. En un rato pongo el resultado.

[Tachikomaia]

Luego de algunos líos logramos que me funcione Python
https://share.google/aimode/rcy7UDreayXsUANZd
Y mejoró el resultado pero sigue habiendo error

El último asumo que es por no poner suficientes cuadraditos en el cuadro, es otra cosa.

Tendré que averiguar por qué en Flash me resulta diferente.

Puse traces, el cuadro problemático (arriba derecha) dice:
NroDelCuadroaColocar: 2
FilaDePunto1: 0
ColumnaDePunto1: 0
FilaDePunto2: 2
ColumnaDePunto2: 4
dx es 4
Se está aplicando el for con valor i siendo 0
El punto debería pintarse en la fila 0
y columna 0
Se está aplicando el for con valor i siendo 1
El punto debería pintarse en la fila 0
y columna 1
Se está aplicando el for con valor i siendo 2
El punto debería pintarse en la fila 1
y columna 2
Se está aplicando el for con valor i siendo 3
El punto debería pintarse en la fila 1
y columna 3
Se está aplicando el for con valor i siendo 4
El punto debería pintarse en la fila 2
y columna 4

Según entiendo, lo que falla es esto
fila = FilaDePunto1 + RRound(i * dy / pasos);
Pruebo hacerlo a mano
Con i 0:
0 + Redondear(0 * 2/4)
0 + Redondear(0) = 0
Con i 1:
Redondear(1 * 2/4) = Redondear(1 * 0.5) = 0.5
Estoy asumiendo que redondea el .5 hacia arriba
Con i 2:
Redondear(2 * 2/4) = Redondear(2 * 0.5) = 1
Bueno, parece claro que los resultados serán
0
0.5
1
1.5
2
Si redondeas el .5 hacia abajo, la cantidad de cuadraditos en las filas de las líneas será 2, 2, 1
Si redondeas hacia arriba, será 1, 2, 2

No veo que Flash funcione mal, el código de Python debe ser diferente. Fijate vos que lo entiendes más si quieres, yo si lo hago es en unos días.

[Richard R Richard]

El que marcas con circulo, creo que es lógico y correcto se vea así , porque la alternativa es 3 seguidos en la primera fila de arriba, solo dos en el medio y tres en la de abajo, y se ve peor como recta.
Queda como el de arriba del que marcaste  para mi ese debe ser 1,3,1 la cantidad de cuadradito por fila  y no 2,1,2 , pero se ve que el programa lo calcula así.

[Tachikomaia]

Puede que sea peor, pero básicamente quiero que cuando sea posible haya simetría y no haya muchos cuadraditos pegados. Si pones 2, 4, 2, en una fila tienes 2 más que en las otras, a eso me refiero con "pegados".
También, en el caso de 4 filas, si resulta 1, 2, 2, 1, considero que hay "pegados", en el centro hay más densidad de cuadraditos. La solución sería 2, 1, 1, 2, se podrá decir que ahora en el medio hay demasiado pocos, pero bueno, no me molesta.

En el caso de 3 filas quiero:
1, 1, 1
1, 2, 1
2, 1, 2

2, 2, 2
2, 3, 2
3, 2, 3

3, 3, 3
etc

Ojo, tampoco se trata de mandar los puntos a los extremos, por ejemplo con 5 filas sería
1, 1, 1, 1, 1
1, 1, 2, 1, 1
1, 2, 1, 2, 1
es el intermedio entre los extremos y el medio.

Con 7 tendrías este caso
2, 1, 2, 1, 2, 1, 2
Los extras están repartidos de modo que las filas con extras no están una al lado de la otra, y están equidistantes.
No siempre se puede lograr.

Seguiré pensando por mi cuenta, tengo una idea que testear.

[Tachikomaia]

Logré que funcione con 3 y 4 filas, con 5 me falla:

Agrega unos extras que no debe al final, intento averiguar por qué pero he podido.

Código: [Seleccionar]

function GenerarLineas () {
// Pintar cuadraditos de modo que se forme una línea:
// Elegir un color distinto al color del cuadro:
do {
ColorDeImagen = PosiblesColores[random(PosiblesColores.length)];
} while (ColorDelCuadro == ColorDeImagen);
// Determinar ubicación del punto 1,
// llamado Punto en vez de Cuadradito porque...
// ese nombre puede que se esté usando en otra cosa:
FilaDePunto1 = 0;
ColumnaDePunto1 = 0;
// trace("FilaDePunto1: "+FilaDePunto1);
// trace("ColumnaDePunto1: "+ColumnaDePunto1);
// Punto 2 asegurando que no sea igual:
do {
ColumnaDePunto2 = NroDelCuadroaColocar+4;
FilaDePunto2 = 4;
} while (ColumnaDePunto1 == ColumnaDePunto2 && FilaDePunto1 == FilaDePunto2);
// trace("FilaDePunto2: "+FilaDePunto2);
// trace("ColumnaDePunto2: "+ColumnaDePunto2);
// Para cálculos:
FilasDeDistancia = FilaDePunto2-FilaDePunto1;
FilasDeLinea = FilasDeDistancia+1;
ColumnasDeDistancia = ColumnaDePunto2-ColumnaDePunto1;
ColumnasDeLinea = ColumnasDeDistancia+1;
// trace("FilasDeDistancia: "+FilasDeDistancia);
// trace("ColumnasDeDistancia: "+ColumnasDeDistancia);
// Averiguar la distancia mayor y graficar en función de ella:
// Si hay más columnas que filas o son igual cantidad:
if (Math.abs(ColumnasDeDistancia) >= Math.abs(FilasDeDistancia)) {
PuntosRequeridosPorFila = Math.floor(ColumnasDeLinea/FilasDeLinea);
trace("PuntosRequeridosPorFila: "+PuntosRequeridosPorFila);
// Puntos que no se pudieron repartir equitativamente...
// entre las filas:
PuntosExtraRequeridos = ColumnasDeLinea%FilasDeLinea;
trace("PuntosExtraRequeridos: "+PuntosExtraRequeridos);
// Para repartirlos estéticamente:
FilaCentralDeLinea = FilasDeDistancia/2;
trace("FilaCentralDeLinea: "+FilaCentralDeLinea);
ExtraaAgregar = 1;
// Si sólo se requiere 1 extra, irá en el medio:
if (PuntosExtraRequeridos == 1) {
// En caso de no haber medio se pone en la izquierda o...
// derecha, de él, decidido por azar:
if (random(2) == 0) {
SiguienteFilaConExtra = Math.floor(FilaCentralDeLinea);
} else {
SiguienteFilaConExtra = Math.ceil(FilaCentralDeLinea);
}
// Para evitar que se ponga otro extra:
DistanciaDeExtras = FilaDePunto2+1;
trace("PuntosExtraRequeridos es 1");
trace("DistanciaDeExtras (enorme): "+DistanciaDeExtras);
trace("SiguienteFilaConExtra (centro): "+SiguienteFilaConExtra);
} else if (PuntosExtraRequeridos > 1) {
DistanciaDeExtras = FilasDeDistancia/(PuntosExtraRequeridos+1);
SiguienteFilaConExtra = Math.floor(DistanciaDeExtras);
trace("PuntosExtraRequeridos es > 1");
trace("DistanciaDeExtras (normal): "+DistanciaDeExtras);
trace("SiguienteFilaConExtra (normal): "+SiguienteFilaConExtra);
if (DistanciaDeExtras == 1 && FilasDeDistancia > 2) {
// Para evitar que en este caso los extras se acumulen en el medio:
SiguienteFilaConExtra = Math.max(0, SiguienteFilaConExtra-1);
trace("Caso especial, SiguienteFilaConExtra se redujo: "+SiguienteFilaConExtra);
}
} else {
// Para evitar que se ponga un punto extra...
// en la fila 0:
// DistanciaDeExtras es irrelevante aquí?
DistanciaDeExtras = FilaDePunto2+1;
SiguienteFilaConExtra = FilaDePunto2+1;
// trace("PuntosExtraRequeridos es 0");
// trace("DistanciaDeExtras (enorme): "+DistanciaDeExtras);
// trace("SiguienteFilaConExtra (afuera): "+SiguienteFilaConExtra);
}
ColumnasCompletadas = 0;
FilaCompletandose = FilaDePunto1;
// Mientras haya columnas que agregar:
while (ColumnasCompletadas < ColumnasDeLinea) {
trace("Aún no se insertaron todas las columnas, van "+ColumnasCompletadas);
PuntosEnFila = 0;
// Mientras se deba agregar puntos en la fila:
while (PuntosEnFila < PuntosRequeridosPorFila) {
trace("Aún no se insertaron los puntos de esta fila, van "+PuntosEnFila);
NroDelCuadraditoaPintar = FilaCompletandose * CuadraditosPorFila + ColumnaDePunto1 + ColumnasCompletadas;
ParaColorDeCuadradito = new Color(Cuadro_pCuadradito + NroDelCuadraditoaPintar);
ParaColorDeCuadradito.setRGB(ColorDeImagen);
ColumnasCompletadas++;
trace("Se pintó un punto. ColumnasCompletadas: "+ColumnasCompletadas);
PuntosEnFila++;
trace("PuntosEnFila: "+PuntosEnFila);
}
// Si en esta fila debe agregarse un extra:
if (FilaCompletandose == SiguienteFilaConExtra) {
trace("Agregando extra");
NroDelCuadraditoaPintar = FilaCompletandose * CuadraditosPorFila + ColumnaDePunto1 + ColumnasCompletadas;
ColumnasCompletadas++;
trace("ColumnasCompletadas: "+ColumnasCompletadas);
ParaColorDeCuadradito = new Color(Cuadro_pCuadradito + NroDelCuadraditoaPintar);
ParaColorDeCuadradito.setRGB(ColorDeImagen);
ExtraaAgregar++;
SiguienteFilaConExtra = DistanciaDeExtras*ExtraaAgregar;
trace("SiguienteFilaConExtra: "+SiguienteFilaConExtra);
// Si el extra iría en una posición con decimales,
// se pone en la entera anterior, siguiente o...
// una de ellas al azar según el caso:
if (SiguienteFilaConExtra < FilaCentralDeLinea) {
SiguienteFilaConExtra = Math.floor(SiguienteFilaConExtra);
if (DistanciaDeExtras == 1 && FilasDeDistancia > 2) {
// Para evitar que en este caso los extras se acumulen en el medio:
SiguienteFilaConExtra = Math.max(0, SiguienteFilaConExtra-1);
}
trace("SiguienteFilaConExtra es anterior a la fila central, se le hace floor: "+SiguienteFilaConExtra);
} else if (SiguienteFilaConExtra > FilaCentralDeLinea) {
SiguienteFilaConExtra = Math.ceil(SiguienteFilaConExtra);
if (DistanciaDeExtras == 1 && FilasDeDistancia > 2) {
// Para evitar que en este caso los extras se acumulen en el medio:
// SiguienteFilaConExtra = Math.min(FilaDePunto2, SiguienteFilaConExtra+1);
SiguienteFilaConExtra++;
}
trace("SiguienteFilaConExtra es posterior a la fila central, se le hace ceil: "+SiguienteFilaConExtra);
} else if (random(2) == 0) {
SiguienteFilaConExtra = Math.floor(SiguienteFilaConExtra);
trace("SiguienteFilaConExtra es en la fila central, se eligió hacerle floor: "+SiguienteFilaConExtra);
} else {
SiguienteFilaConExtra = Math.ceil(SiguienteFilaConExtra);
trace("SiguienteFilaConExtra es en la fila central, se eligió hacerle ceil: "+SiguienteFilaConExtra);
}
}
FilaCompletandose++;
trace("FilaCompletandose: "+FilaCompletandose);
}
// OJO QUE QUIZÁ SE AGREGA UN PUNTO AL FINAL INCLUSO CON PuntosExtraRequeridos 0 PORQUE ES DISTANCIA/(PuntosExtraRequeridos+1)
} else {
}
}
Esto es sobre el cuadro de arriba derecha:
NroDelCuadroaColocar: 2
PuntosRequeridosPorFila: 1
PuntosExtraRequeridos: 2
FilaCentralDeLinea: 2
PuntosExtraRequeridos es > 1
DistanciaDeExtras (normal): 1.33333333333333
SiguienteFilaConExtra (normal): 1
Aún no se insertaron todas las columnas, van 0
Aún no se insertaron los puntos de esta fila, van 0
Se pintó un punto. ColumnasCompletadas: 1
PuntosEnFila: 1
FilaCompletandose: 1
Aún no se insertaron todas las columnas, van 1
Aún no se insertaron los puntos de esta fila, van 0
Se pintó un punto. ColumnasCompletadas: 2
PuntosEnFila: 1
Agregando extra
ColumnasCompletadas: 3
SiguienteFilaConExtra: 2.66666666666667
SiguienteFilaConExtra es posterior a la fila central, se le hace ceil: 3
FilaCompletandose: 2
Aún no se insertaron todas las columnas, van 3
Aún no se insertaron los puntos de esta fila, van 0
Se pintó un punto. ColumnasCompletadas: 4
PuntosEnFila: 1
FilaCompletandose: 3
Aún no se insertaron todas las columnas, van 4
Aún no se insertaron los puntos de esta fila, van 0
Se pintó un punto. ColumnasCompletadas: 5
PuntosEnFila: 1
Agregando extra
ColumnasCompletadas: 6
SiguienteFilaConExtra: 4
SiguienteFilaConExtra es posterior a la fila central, se le hace ceil: 4
FilaCompletandose: 4
Aún no se insertaron todas las columnas, van 6
Aún no se insertaron los puntos de esta fila, van 0
Se pintó un punto. ColumnasCompletadas: 7
PuntosEnFila: 1
Agregando extra
ColumnasCompletadas: 8
SiguienteFilaConExtra: 5.33333333333333
SiguienteFilaConExtra es posterior a la fila central, se le hace ceil: 6
FilaCompletandose: 5

Luego de resolver esa duda creo que voy a abandonar esto hasta fecha desconocida o para siempre, en vez de intentar hacer líneas "perfectas" intentaré que sean caminos al azar, como para ser contornos de un dibujo. Pensé que hacer líneas más normales sería más fácil, pero teniendo que cumplir tantos requisitos se ve que no.

EDIT: Parece que ya lo logré:

Simplemente tenía que poner un if para que si ya había agregado todos los extras, no agregue otro. Pero creo que no debería ser necesario, mi código está mal hecho, aunque funcione xP
En la imagen puede verse gran variedad de tamaños de líneas. Los cuadros que no tienen es porque en ellos la cantidad de filas es mayor que la de columnas y aún no hice eso, sería el mismo código pero con algunas cosas al revés.

También me faltaría generar líneas de este estilo / pero noooo, paso, paso.