Necesito que unos cuadrados (les llamo Pixeles) se coloquen uno al lado de otro como si fuese un tablero de ajedrez pero de 2x2, luego de 3x3, y así. El tamaño de cada píxel varía según cuantos deben caber en la pantalla. Una vez obtenido el largo, al pixel1 se lo coloca en 64, 0, al 2 en 64+largo, 0, y así hasta cierto punto, es decir, se van colocando cada vez más en la derecha, hasta antes de que se salgan de la pantalla, momento en que vuelve a comenzar desde 64 en X, pero aumenta en Y.

El problema es que ese límite, creo que al hacer sumas con decimales es superado antes de lo que debe. El programa está hecho de modo que coloca el píxel en el límite, y luego cuando lo supera hace lo que dije arriba. Cuando son 5x5 el límite es 371.2. Ocurre esto:
El pixel 1 se colocó en 64, 0
El pixel 2 se colocó en 140.8, 0
El pixel 3 se colocó en 217.6, 0
El pixel 4 se colocó en 294.4, 0
El pixel 5 se colocó en 64, 76.8 <- Mal colocado.

¿Qué puedo hacer para evitar el error? No es sólo para 5x5, debe servir para cualquier número entero digamos.

La parte que interesa está en el fotograma 2:

   actions for fotograma 1
      PixelesdeLargo = 1;
      function Variar () {
         PixelaModificar = "ColordePixel"+Puntero;
         ColordePixelaModificar = eval(PixelaModificar);
         // ¿El pixel puede cambiar de color?
         if (ColordePixelaModificar<1) {
            // Sí, cambiarlo:
            set (PixelaModificar, ColordePixelaModificar+1);
            Col = new Color("Pixel"+Puntero);
            Col.setRGB(parseInt(0, 16));
            SumadePintados = SumadePintados+1;
            // ¿El píxel está en el extremo derecho o abajo, donde no había en una hoja más chica?
            if (Puntero/PixelesdeLargo == Math.floor(Puntero/PixelesdeLargo) or Puntero>MinPixelInferior) {
               // Sí, actualizar SumadePintadosNuevos:
               SumadePintadosNuevos = SumadePintadosNuevos+1;
            }
            // ¿El dibujo tiene píxeles donde no había en una hoja más chica...
            // y son al menos (PixelesdeLargo) píxeles?
            if (SumadePintadosNuevos>0 && SumadePintados>MinSumadePintados) {
               DibujoListo = "Sí";
               // Darme tiempo de ver el dibujo.
               // Volver.
               Puntero = MaxPosiciondePuntero;
               gotoAndPlay (5);
            } else {
               // No, el dibujo es repetido, no mostrarlo y hacer otro:
               DibujoListo = "No";
               Puntero = MaxPosiciondePuntero;
            }
         } else {
            // El pixel no puede cambiar de color, resetearlo:
            set (PixelaModificar, 0);
            Col = new Color("Pixel"+Puntero);
            Col.setRGB(parseInt("FFFFFF", 16));
            SumadePintados = SumadePintados-1;
            // ¿El píxel está en el extremo derecho o abajo, donde no había en una hoja más chica?
            if (Puntero/MaxPosiciondePuntero == Math.floor(Puntero/MaxPosiciondePuntero) or Puntero>MinPixelInferior) {
               // Sí, actualizar SumadePintadosNuevos:
               SumadePintadosNuevos = SumadePintadosNuevos-1;
            }
            // ¿Hay un pixel anterior?
            if (Puntero>1) {
               // Sí, apuntar a ese:
               Puntero = Puntero-1;
               // Continuar haciendo el dibujo:
               DibujoListo = "No";
            } else {
               // No, aumentar tamaño de hoja y reiniciar.
               DibujoListo = "Sí";
               gotoAndPlay (2);
            }
         }
      }
   actions for fotograma 2
      PixelesdeLargo = PixelesdeLargo+1;
      Pixeles = 0;
      DistanciaEntrePixeles = 384/PixelesdeLargo;
      PosicionX = 64-DistanciaEntrePixeles;
      MaxPosicionXdePixel = 64+DistanciaEntrePixeles*(PixelesDeLargo-1);
      PosicionY = 0;
      MaxPosiciondePuntero = PixelesdeLargo*PixelesdeLargo;
      Puntero = MaxPosiciondePuntero;
      // Píxeles pintados:
      SumadePintados = 0;
      MinSumadePintados = PixelesdeLargo-1;
      MinPixelInferior = PixelesdeLargo*(PixelesdeLargo-1);
      // Píxeles pintados que no estaban en hojas de menos píxeles:
      SumadePintadosNuevos = 0;
      // Agregar píxeles en blanco:
      do {
         Pixeles = Pixeles+1;
         PosicionX = PosicionX+DistanciaEntrePixeles;
         if (PosicionX>MaxPosicionXdePixel) {
            PosicionX = 64;
            PosicionY = PosicionY+DistanciaEntrePixeles;
         }
         trace ("El pixel "+Pixeles+" se colocó en "+PosicionX+", "+PosicionY);
         attachMovie("mPixel", "Pixel"+Pixeles, Pixeles);
         setProperty ("Pixel"+Pixeles, _x, PosicionX);
         setProperty ("Pixel"+Pixeles, _y, PosicionY);
         setProperty ("Pixel"+Pixeles, _width, DistanciaEntrePixeles);
         setProperty ("Pixel"+Pixeles, _height, DistanciaEntrePixeles);
      } while (Pixeles<MaxPosiciondePuntero);
      stop ();
   actions for fotograma 3
      Variar();
   actions for fotograma 4
      Variar();
      if (DibujoListo == "No") {
         gotoAndPlay (3);
      }
   actions for fotograma 6
      gotoAndPlay (3);

H2O y todas esas normales.

Anormales son cuando son iones o radicales libres.

Para hacer esto hay que saber Química, claro ¿alguno sabe suficiente?

He pensado esto:
Puede que el código ese tenga alguna falla, pero lo que necesito más urgentemente es:

- Entender qué átomos pueden formar 1 enlace, cuales 2, cuales 3 y cuales 4. Quizá hay más, pero es raro así que no lo consideraré. Se supone que eso es indicado por la valencia y que está en la tabla periódica, pero hay casos en que ponen muchos números y entonces no sé.

- Entender qué condiciones cumple una molécula normal.
Por ejemplo H3O no es normal porque la suma de las valencias no es par: 3+2=5
Pero eso no basta, por ejemplo CH6 tiene suma par pero no es normal, es un radical libre, normal sería esto:
  H
HCH
  H
El C con 4 enlaces y los H con 1, así que los 2H restantes no pueden formar parte de la molécula. Pensé que alcanzaba con decir que la suma de valencias de átomos con más de 1 debía ser mayor o igual que los con valencia 1 (en este caso 4<6 por lo que no sería normal), pero hay casos como NOH5 en que eso se cumple y aún así no es normal:
3+2+5=10, par, bien
3+2=<5, bien.
Pero la molécula sería: 2H-N-O-H y no hay forma de enlazar los 2H que faltan.

Okx4 pero miren, yo suelo descargar usando esta página:
https://yt5s.io/en91

Y otras similares. En general no tengo problema, descargo varios, pero con ese video me acaba de dar esto:
Se denegó el acceso a r6---sn-5ouxa-h8qk.googlevideo.comNo tienes autorización para ver esta página.
HTTP ERROR 403

Temo que eso se convierta en la norma del futuro y para descargar deba sí o sí instalar un programa.

Atando un poco de cabos una posible explicación que se me ocurrió es que ese video al ser de un programa de TV tiene una protección especial, que con vuestros métodos no se nota, pero con los que dije sí.

En mi opinión sólo sería un problema si quien los postea parece que quiere romper un record de posteos similares y por eso no los revisa o lo hace tan rápido que es como si no lo hiciera. Si es alguno sin revisar de vez en cuando o revisados, no le veo problema.

En Quora hay casos en que la persona que pregunta dice "ver mi comentario", y la persona o bot (es que ya no se sabe) que responde con una IA dice "No se ve un comentario", es decir la persona no se tomó la molestia de mirarlo o es que ya ni siquiera saben leer, como sea la cuestión es que una respuesta así puede ser más molesta que útil. Incluso yo que no tengo celular ya puedo usar una IA, si quisiera preguntarle lo hago ¿qué sentido tiene que se responda con eso? Pero me remito a lo dicho arriba.

Como último recurso probaré los métodos que uds me dijeron en un tema que hice hace tiempo sobre un video en otro lado, aquí no estoy preguntando cómo descargar este sino por qué es tan difícil hacerlo, qué tiene de especial, si alguien sabe. Probé diversas páginas de descarga sin instaladores como debe ser y en muchos casos me dice esto:
Se denegó el acceso a rr5---sn-p5qlsn7s.googlevideo.comNo tienes autorización para ver esta página.
HTTP ERROR 403

Por cierto a mí no me interesa ver esta basura, es para una abuela:
https://www.youtube.com/watch?v=NBv6qxKxWEY




https://www.youtube.com/watch?v=NBv6qxKxWEY

El juego que buscan probablemente sea una versión pirateada de Don Doko Don 2, yo jugué al M8 también en la Family Game, Family Computer o como se llame.

https://www.youtube.com/watch?v=1hyhqjE2ut8

El 1 es más difícil, nunca lo pude pasar.

Otra duda aparentemente tonta que me ha tenido trancado demasiado tiempo.

En programas que hacen poco, el print o lo que sea se pone casi al final, para mostrar el resultado de la tarea. Nada más.

En programas que hacen muchas cosas, lo mismo pero los prints también se ponen antes de ciertos procesos o después para indicar en qué parte del programa va, o qué está analizando en el momento. Lo vemos cuando copiamos muchos archivos por ejemplo, se indica cual se está copiando.

Parece una cuestión obvia de resolver.

Pero yo tengo un programa que me cuesta decidir o entender dónde quisiera poner los prints si tuviera un criterio que me parezca bueno. En cierto punto sólo ponía uno al final. Luego poco a poco pasé a seguir este patrón generalmente: Comentario, cambio, print. Luego empecé a creer que no tiene sentido hacer print de cada cambio porque si una cosa funciona bien no es necesario indicar que otra lo hizo, por ejemplo indicar que una variable cambió parece innecesario si enseguida se aplicará para algo. Así, quité todos los prints (en mi caso traces) del fotograma 1 excepto uno que muestra lo mismo que otra cosa así que lo quitaré también, no me di cuenta. Ahora iba a analizar el resto y, no sé bien qué hacer...

   actions for fotograma 1
      function InsertarNodoyFlecha () {
         // Insertar Nodo:
         Imagenes = Imagenes+1;
         Nodos = Nodos+1;
         Grafo.attachMovie("mNodo", "Nodo"+Nodos, Imagenes);
         // Especificar la situación que representa:
         set ("Grafo.Nodo"+Nodos+".EnHP", EnHP);
         // Insertar flecha:
         Imagenes = Imagenes+1;
         Grafo.attachMovie("mFlecha", "Flecha"+Nodos, Imagenes);
         // Especificar el sitio donde se insertan:
         PosicionY = PadrePosicionY+33;
         setProperty ("Grafo.Nodo"+Nodos, _y, PosicionY);
         setProperty ("Grafo.Flecha"+Nodos, _x, PadrePosicionX);
         setProperty ("Grafo.Flecha"+Nodos, _y, PadrePosicionY+6.5);
         Hijos = Hijos+1;
         // Como por ahora casi todo padre tiene 1 hijo, este if agiliza el proceso creo:
         if (Hijos == 1) {
            PosicionX = PadrePosicionX;
            setProperty ("Grafo.Nodo"+Nodos, _x, PosicionX);
         } else {
            Hijo = 0;
            MinPosicionX = PadrePosicionX-16.5*(Hijos-1);
            SAquedebeActualizarse = SAs-Hijos;
            do {
               Hijo = Hijo+1;
               PosicionX = (Hijo-1)*33+MinPosicionX;
               setProperty ("Grafo.Nodo"+(Nodos-Hijos+Hijo), _x, PosicionX);
               // Actualizar datos de las posiciones guardadas:
               SAquedebeActualizarse = SAquedebeActualizarse+1;
               set ("SA"+SAquedebeActualizarse+"PosicionX", PosicionX);
               // Establecer rotación 0 a la flecha para que su altura de se modifique bien:
               setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _rotation, 0);
               // Especificar rotación y tamaño de flecha:
               DistanciaXPadreHijo = Math.abs(Math.abs(PadrePosicionX)-Math.abs(PosicionX));
               setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _height, Math.sqrt(DistanciaXPadreHijo*DistanciaXPadreHijo+20*20));
               Rotacion = 180/Math.PI*Math.atan(DistanciaXPadreHijo/20*-1);
               // Si el hijo está a la izquierda del padre, invertir la rotación:
               if (PosicionX<PadrePosicionX) {
                  Rotacion = Rotacion*-1;
               }
               setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _rotation, Rotacion);
            } while (Hijo<Hijos);
         }
      }
      Respuesta = "Vencer al enemigo mediante acciones, el enemigo tiene 11 HP. Se recomienda la serie... ";
      // Situación inicial:
      // HP inicial del enemigo:
      EnBaseHP = 33;
      trace ("EnBaseHP: "+EnBaseHP);
      // Guardar situación y cómo se produjo:
      // Parte inicial del nombre de los datos (en este caso S11):
      SitID = "S"+EnBaseHP;
      // Acción realizada en la situación anterior (en este caso ninguna):
      set (SitID+"ActionAnterior", "Ninguna");
      // En este caso la variable es S11Action y su valor es "Ninguna".
      // Posición X e Y del nodo que representa la situación desde la cual se originó la que será representada por otro nodo...
      // ...pero en este caso es la posición del 1er nodo.
      PadrePosicionX = 0;
      PadrePosicionY = 0;
      // Cantidad de imágenes insertadas:
      Imagenes = 1;
      // Cantidad de nodos del grafo a mostrar:
      Nodos = 1;
      // Insertar nodo inicial:
      Grafo.attachMovie("mNodo", "Nodo1", 1);
      // Especificar la situación que representa:
      Grafo.Nodo1.EnHP = EnBaseHP;
      // Hijos del nodo de la situación que se está analizando:
      Hijos = 0;
      // Acción que será usada 1ero:
      Action = 1;
      // Variables sobre situaciones anotadas:
      // Total de situaciones anotadas:
      SAs = 0;
      // Situación anotada que será investigada 1ero:
      SiguienteSAaInvestigar = 0;
   actions for fotograma 2
      trace ("Reset de la situación, aplicación de la acción, la situación ahora es:");
      EnHP = EnBaseHP-Action;
      trace ("EnHP: "+EnHP);
      // ¿Se logró el objetivo?
      if (EnHP<=0) {
         trace ("Solución hallada, iniciando proceso para mostrar cómo causarla.");
         Serie = Action;
         InsertarNodoyFlecha();
         gotoAndPlay (5);
      } else {
         trace ("No se logró el objetivo.");
         // ¿La situación producida está anotada?
         if (eval("S"+EnHP+"ActionAnterior") == undefined) {
            trace ("La situación producida no está anotada.");
            trace ("Se anotará y cómo se logró.");
            SitID = "S"+EnHP;
            set (SitID+"EnHPAnterior", EnBaseHP);
            set (SitID+"ActionAnterior", Action);
            trace ("Ahora está anotada: "+SitID);
            trace ("Su antecedente fue ("+SitID+"EnHPAnterior): "+EnBaseHP);
            trace ("y la acción fue ("+SitID+"ActionAnterior): "+Action);
            // También se agrega como situación a investigar y se anota en qué consiste:
            SAs = SAs+1;
            SitID = "SA"+SAs;
            set (SitID+"EnHP", EnHP);
            trace ("Situaciones anotadas: "+SAs);
            trace ("La última consiste en (EnHP): "+eval(SitID+"EnHP"));
            // Se inserta el nodo que la representa y se guarda su posición:
            InsertarNodoyFlecha();
            set (SitID+"PosicionX", PosicionX);
            trace (SitID+"PosicionX: "+PosicionX);
            set (SitID+"PosicionY", PosicionY);
         } else {
            trace ("La situación producida ya está anotada.");
         }
      }
   actions for fotograma 3
      // ¿Modificar acción es posible?
      if (Action<7) {
         trace ("Es posible modificar acción.");
         Action = Action+1;
         trace ("Action fue modificada, es: "+Action);
         gotoAndPlay (2);
      } else {
         trace ("No es posible modificar la acción.");
         if (SiguienteSAaInvestigar<SAs) {
            // Aún hay situaciones anotadas sin investigar, investigar una (probablemente lo ideal sería investigar la más diferente a las investigadas, pero me es difícil programar eso):
            trace ("Aún hay situaciones anotadas sin investigar.");
            SiguienteSAaInvestigar = SiguienteSAaInvestigar+1;
            EnBaseHP = eval("SA"+SiguienteSAaInvestigar+"EnHP");
            trace ("Se investigará la situación anotada nro: "+SiguienteSAaInvestigar);
            trace ("Consiste en EnBaseHP: "+EnBaseHP);
            // Guardar su posición para saber dónde poner a sus posibles hijos:
            PadrePosicionX = eval("SA"+SiguienteSAaInvestigar+"PosicionX");
            trace ("Nuevo PadrePosicionX: "+PadrePosicionX);
            PadrePosicionY = eval("SA"+SiguienteSAaInvestigar+"PosicionY");
            Hijos = 0;
            // Reset de la acción a usar:
            Action = 1;
            trace ("Reset de la acción a usar, es: "+Action);
            gotoAndPlay (2);
         } else {
            trace ("No hay situaciones anotadas sin investigar ni es posible lograr el objetivo.");
            Respuesta = "No es posible lograr el objetivo.";
         }
      }
   actions for fotograma 5
      // Obtener acción anterior:
      ActionAnterior = eval("S"+EnBaseHP+"ActionAnterior");
      trace ("La acción anterior fue: "+ActionAnterior);
      // ¿Hubo?
      if (ActionAnterior != "Ninguna") {
         // Sí, agregarla en la lista:
         Serie = ActionAnterior+" "+Serie;
         trace ("Acción agregada en la serie.");
         // Averiguar cual fue la situación anterior:
         EnBaseHP = eval("S"+EnBaseHP+"EnHPAnterior");
         trace ("Se realizó en la situación: S"+EnBaseHP);
         // Repetir este frame.
         gotoAndPlay (4);
      } else {
         // No hubo una acción anterior, mostrar la serie:
         trace (Respuesta+Serie);
         stop ();
      }

Además hay cosas como esta:
// Aún hay situaciones anotadas sin investigar, investigar una (probablemente lo ideal sería investigar la más diferente a las investigadas, pero me es difícil programar eso):
trace ("Aún hay situaciones anotadas sin investigar.");
Es decir un trace que dice lo mismo que el comentario, por lo que parece que debería borrar el comentario, pero el comentario dice más cosas que no tiene sentido decir en un trace. Ahora se me ocurre poner el trace y luego el comentario quitando lo que ya se dice en el trace, sí, puede que sea una solución muy obvia pero no me di cuenta en parte por intentar seguir el patrón que mencioné.

Me parece posible que ya haya respondido esta pregunta, y a ti.

Pero estoy seguro de que ya has dicho que el foro está muerto, y queda feo decirlo porque si bien no tiene una actividad enorme sí tiene.

No conozco otros, me basta con este, los que conocía hace años dejé de usarlos porque en unos no respondían (la web del progrador y algún otro) y en otro había un usuario que en vez de responder mis dudas me decía que él era profesional, que yo debería imitarlo, usar un mejor lenguaje, y los moderadores lo dejaban a sus anchas así que decidí no seguir ahí.

En Reddit supongo que algún subreddit habrá como el que buscas. Nomás te recomiendo andar con mucho cuidado, te banean sin mucho motivo y a veces son muy exigentes con el contenido, preguntas concisas y esas cosas, moderan bots en parte.

No es para Quora.

¿Qué se ha dicho que es mejor o qué opinan?

¿Cuales son las ventajas/desventajas de cada uno?

¿No hay diferencia casi?

Por si no se entiende me refiero a:

VS


No parece haber diferencia pero me pregunto si cuando el código se pone medio spaguetti sí...