Por ejemplo en Paint de Windows 7 tengo una imagen de 462x230 pixeles, la copio.

La pego en Macromedia Flash 5 y queda 346.8x172.1 y para colmo reflejada verticalmente, de cabeza.

Si la pego en Word 2013 y desde ahí la copio y la pego en Flash queda de 720x368 (no reflejada).

No sé qué explicación o lógica tiene eso. Se puede arreglar en Flash pero si tengo muchas imágenes a copiar y pegar quisiera un método más rápido. Tengo una imagen de Paint a la que quiero ir copiando distintas partes, si no fuese por eso la abriría con Chrome, la copiaba entera y de ahí al ponerla en Flash queda bien. Pero no puedo pegar un trozo en Chrome ¿no? Tampoco quiero guardar esos trozos en Paint, abrirlos con  Chrome, y copiarlos de ahí a Flash.

Yo antes usaba algún programa como puente, no sé si Photoed.

Las preguntas son ¿por qué se cambia el tamaño e incluso la rotación cuando se copia desde Paint? Desde Word también, se cambia distinto. Desde Chrome no ¿por qué?
¿Con qué puedo copiar los trozos y pegarlos directamente en Flash y que queden bien? ¿o qué programa puedo usar de puente para pegarlos ahí, copiarlos de ahí y que se peguen como deben en Flash?

Puedo abrir la imagen con Flash y separarla en trozos, pero se pone un poco pesado me parece, no creo que sea buena idea.

Si en el videojuego de Mario ocurrieron los siguientes eventos:
- Mario se puso encima de un tubo, ergo lo tocó.
- Mario saltó y cayó en el mismo tubo, ergo lo volvió a tocar.
- Mario hizo eso 2 veces más, ergo lo tocó 2 veces más.
- Mario tocó 2 monedas.
- Mario tocó 1 ongo.
¿qué cosas o eventos se pueden contar?

GPT:

Busco algo más general. Tengo esto escrito, ayudame a ponerlo más claro, diferenciar cosas, etc.
Contactos ocurridos o reocurridos: 7
7: Contactos ocurridos por 1era vez con un objeto o repetidamente.
7 Contactos con un objeto igual o distinto (4+2+1)
...
Tipos de Contactos ocurridos: 3
3: Objetos con los que se hizo un 1er Contacto.
3 Objetos con los que se hizo Contacto (1+1+1)
...
Luego tengo:
Distintos Contactos ocurridos: 4
...
2: Objetos con los que se hizo Contacto más de una vez.
4: Contactos realizados más allá de una 1er vez.
...
7 contactos con el mismo objeto o distintos (4+2+1)
3 objetos con los que se hizo contacto (1+1+1)
3 contactos repetidos (4-1)
4 contactos con el mismo objeto o distintos, sin contar el 1er contacto con él o ellos (4-1+2-1+1-1)

¿El caso 3 no es igual al 5? No lo veo claro, por eso necesito una lista de eventos que dejen claro qué cosas pueden contarse, de modo que cada cosa de un resultado distinto.

¿Qué es contable en videojuegos en cuanto a contactos?

En cuanto a otras cosas también estoy pensando pero de momento me complica eso. Aquí tienen una lista más completa (aunque específica de Donkey Kong) aunque más confusa también U.U


Se me ocurrió este ejemplo (para DK y no ordenado cronológicamente sino por cantidades):
Mario tocó una cartera.
Tocó 20 martillos distintos.
Tocó 300 veces la escalera A.
Tocó 4000 veces la escalera B.
Tocó 50000 veces una escalera.
Entonces:

Contactos: 1+20+50000
50021

Distintos objetos contactados: 1+20+50000-3999-299
45723

Contact. repetidos con un mismo tipo de o.: 19+299+3999
4317

Contactos repetidos: 299+3999
4298

Tipos de objetos contactados: 1+1+1
3

¿Habrá algo más en este sentido?

Uno de los motivos por los que Doom me gustó más que Shogo fue que en Doom sólo necesitas apuntar en el eje X, así que si el juego es más cómodo con un apuntador me parece bien...

Pero si evadir también es incómodo y hacen un evadidor, ya como que no están jugando xD Sólo eligen a qué punto del mapa ir. Parece como un juego de rol, uno mueve al personaje en el mapa pero si pega o evade no depende mucho de uno.

Los desarrolladores podrían hacer una versión normal y otra más cómoda. ¿No puedes hablar con ellos? Antiguamente, el Mu empezó a sacar muchas versiones en que varias cosas se facilitaban, estaba la versión original en la que debías pasar horas para subir de nivel y las otras en que era demasiado rápido, y así.

¿Ven el cartel?

Ahí el puntero del mouse me aparece como un dedo indicando algo. No tengo idea, yo estoy copiando cosas y moviendo celdas y se abre Outlook a cada rato. ¿Qué pasa? ¿cómo lo arreglo?

MOD: Imagen adaptada al maximo permitido.

Este tema lo edité porque en principio decidí intentar algo más simple.

De momento tengo esto:

// Generar comparación:
// Parte 1:
ParteVisible1 = random(3);
if (ParteVisible1 == 0) {
	ParteVisible1 = "...";
} else {
	Parte1 = random(10);
	if (ParteVisible1 == 1) {
		ParteVisible1 = Parte1;
	} else {
		ParteVisible1 = "Incógnita";
	}
}
// Parte 2:
PosiblesSignos = ["==", "!=", "<=", ">=", "<", ">"];
ParteVisible2 = random(3);
if (ParteVisible2 == 0) {
	ParteVisible2 = "...";
} else {
	Parte2 = PosiblesSignos[random(6)];
	if (ParteVisible2 == 2) {
		ParteVisible2 = Parte2;
	} else {
		ParteVisible2 = "Incógnita";
	}
}
// Parte 3:
ParteVisible3 = random(3);
if (ParteVisible3 == 0) {
	ParteVisible3 = "...";
} else {
	Parte3 = random(10);
	if (ParteVisible3 == 1) {
		ParteVisible3 = Parte3;
	} else {
		ParteVisible3 = "Incógnita";
	}
}
Mensaje = ParteVisible1+" "+ParteVisible2+" "+ParteVisible3;

Ejemplo de salida:
5 Incógnita ...

Otro ejemplo:
Incógnita > 1

Cosas que me interesan:
- Debe haber al menos 1 "..."
- Debe poder haber más de un tipo de incógnita (X, Y y Z).
- La probabilidad de que haya 1 "..." debe ser igual a que haya 2 o 3. Pero el método debe poder usarse también si la comparación tuviese más partes.

Quisiera que me ayuden con el punto 3. Yo haré el 1 y 2, actualizo el tema cuando lo haga.

En cuanto a las pistas, más adelante veré, pero se refieren a la incógnita.

En cuanto a que complete la comparación (sustituya los ... por valores de modo que sea true), alguna idea tengo, ejemplo:

   actions for fotograma 1
      // Resolvedor de A A ..., todo dato.
      PosiblesValores = ["==", "!="];
      A = PosiblesValores[random(PosiblesValores.length)];
      // trace ("A: "+A);
      Parte1 = A;
      Parte2 = A;
      CandidatoNoTraducido = 0;
      Mensaje = Parte1+" "+Parte2+" ...";
      // Usada en IntentarResolver:
      function Comparacion () {
         if (Parte2 == "==") {
            return Parte1 == CandidatoTraducido;
         } else {
            return Parte1 != CandidatoTraducido;
         }
      }
      // Se repite en F2:
      function IntentarResolver () {
         CandidatoTraducido = PosiblesValores[CandidatoNoTraducido];
         trace ("Probando el Candidato "+CandidatoTraducido);
         if (Comparacion()) {
            trace ("Solución hallada, ver respuesta.");
            Mensaje = Mensaje+"\n"+Parte1+" "+Parte2+" "+CandidatoTraducido;
            gotoAndStop (3);
         } else if (CandidatoNoTraducido<1) {
            trace ("No se logró el objetivo, pero hay otro candidato que se probará");
            CandidatoNoTraducido = CandidatoNoTraducido+1;
         } else {
            trace ("No es posible modificar al candidato ni lograr el objetivo.");
            Mensaje = Mensaje+"Ninguna, no es posible lograr el objetivo.";
            // Finalizar programa:
            gotoAndStop (3);
         }
      }
   actions for fotograma 2
      stop ();
   actions for Vacío
      onClipEvent (enterFrame) {
         _level0.IntentarResolver();
      }

No sabía que había tal cosa ya y por ahora sólo vi un poco de esto:
https://www.youtube.com/watch?v=0jrtOBM97X4
donde no veo bien.

El hecho de que una máquina cante así (creo) ya es sorprendente, pero esto se pasa.

Quité el Parseint y simplifiqué el cambio de colores como me dijiste, dejo los archivos a quien le interesen:
https://drive.google.com/file/d/1z3lL4wWYmJ_SCZcZliXx7fK8dH4TdOUS/view?usp=sharing
Incluye la versión anterior y la nueva (simplificando).
El objeto Vacío en frame 3 está en la punta inferior derecha, tiene la función Variar.

Como alternativa, el código:

   actions for fotograma 1
      // Los píxeles mayores están abajo en la derecha, ejemplo:
      // 12
      // 34
      PixelesdeLargo = 1;
      // En F3 se repite:
      function Variar () {
         // trace("Variando");
         PixelaModificar = "Pixel"+Puntero;
         ColorDePixel = new Color(PixelaModificar);
         // trace("Color: "+ColorDePixel.getRGB());
         // ¿El pixel puede cambiar de color? ¿es blanco?
         if (ColorDePixel.getRGB() == 0xFFFFFF) {
            // Sí, cambiarlo:
            ColorDePixel.setRGB(0);
            // trace ("Se pintó el pixel "+PixelaModificar);
            // Para juzgar: ¿El dibujo es repetido? o:
            // ¿El dibujo tiene píxeles pintados en toda columna y fila?
            // Averiguar la columna del pixel:
            Columna = 1+(Puntero-1)%PixelesdeLargo;
            // trace ("Columna: "+Columna);
            // Esto se usa para evitar repeticiones de concatenaciones y simplificarlas:
            ColumnaRelevante = "PintadosenC"+Columna;
            // Incrementar contador de píxeles pintados en ella:
            set (ColumnaRelevante, eval(ColumnaRelevante)+1);
            // Averiguar la fila del pixel:
            Fila = Math.ceil(Puntero/PixelesdeLargo);
            // trace ("Fila: "+Fila);
            // Esto se usa para evitar repeticiones de concatenaciones y simplificarlas:
            FilaRelevante = "PintadosenF"+Fila;
            // Incrementar contador de píxeles pintados en ella:
            set (FilaRelevante, eval(FilaRelevante)+1);
            // trace ("Pintados: "+ColordePixel1+" "+ColordePixel2+" "+ColordePixel3+" "+ColordePixel4);
            // trace ("PintadosenC1: "+PintadosenC1);
            // trace ("PintadosenC2: "+PintadosenC2);
            // trace ("PintadosenF1: "+PintadosenF1);
            // trace ("PintadosenF2: "+PintadosenF2);
            // Para juzgar: ¿El dibujo tiene píxeles pintados en toda columna y fila?
            Puntero2 = 0;
            Repetido = "N";
            do {
               Puntero2 = Puntero2+1;
               // ¿La columna Puntero2 no tiene algún pixel pintado?
               if (eval("PintadosenC"+Puntero2)<1) {
                  // trace (eval("PintadosenC"+Puntero2)+ "< 1");
                  Repetido = "S";
               } else if (eval("PintadosenF"+Puntero2)<1) {
                  // La fila Puntero2 no tiene algún pixel pintado.
                  // trace (eval("PintadosenF"+Puntero2)+ "< 1");
                  Repetido = "S";
               }
            } while (Repetido == "N" && Puntero2<PixelesdeLargo);
            // Preparar Puntero para la próxima generación:
            Puntero = MaxPosiciondePuntero;
            // ¿El dibujo tiene píxeles pintados en toda columna y fila?
            if (Repetido == "N") {
               // trace ("   Mostrando dibujo.");
               ContadorDeDibujos = ContadorDeDibujos+1;
            } else {
               // No, el dibujo es repetido, no mostrarlo y hacer otro:
               // trace ("   Repetido, salteándolo.");
               Variar();
            }
         } else {
            // El pixel no puede cambiar de color, resetearlo:
            ColorDePixel.setRGB(0xFFFFFF);
            // trace ("Se reseteó el pixel "+PixelaModificar);
            // Actualizar los valores de PintadosenC y PintadosenF:
            // Averiguar la columna del pixel:
            Columna = 1+(Puntero-1)%PixelesdeLargo;
            // Esto se usa para evitar repeticiones de concatenaciones y simplificarlas:
            ColumnaRelevante = "PintadosenC"+Columna;
            // Disminuir contador de píxeles pintados en ella:
            set (ColumnaRelevante, eval(ColumnaRelevante)-1);
            // Averiguar la fila del pixel:
            Fila = Math.ceil(Puntero/PixelesdeLargo);
            // Esto se usa para evitar repeticiones de concatenaciones y simplificarlas:
            FilaRelevante = "PintadosenF"+Fila;
            // Disminuir contador de píxeles pintados en ella:
            set (FilaRelevante, eval(FilaRelevante)-1);
            // ¿Hay un pixel anterior?
            if (Puntero>1) {
               // Sí, apuntar a ese:
               Puntero = Puntero-1;
               // Continuar haciendo el dibujo:
               // trace ("   Haciendo dibujo, apuntando al pixel anterior.");
               // trace ("SumadePintados: "+SumadePintados);
               // trace ("SumadePintadosNuevos: "+SumadePintadosNuevos);
               Variar();
            } else {
               // No, aumentar tamaño de hoja y reiniciar.
               trace (ContadorDeDibujos);
               gotoAndPlay (2);
            }
         }
      }
   actions for fotograma 2
      ContadorDeDibujos = 0;
      PixelesdeLargo = PixelesdeLargo+1;
      // Colocados:
      Pixeles = 0;
      DistanciaEntrePixeles = 384/PixelesdeLargo;
      PosicionX = 64-DistanciaEntrePixeles;
      EnlaFilaActual = 0;
      PosicionY = 0;
      MaxPosiciondePuntero = PixelesdeLargo*PixelesdeLargo;
      // Aquí MinPixelInferior es 3:
      // 12
      // 34
      MinPixelInferior = PixelesdeLargo*(PixelesdeLargo-1)+1;
      // Agregar y distribuir píxeles en blanco:
      do {
         Pixeles = Pixeles+1;
         if (EnlaFilaActual<PixelesdeLargo) {
            EnlaFilaActual = EnlaFilaActual+1;
            PosicionX = PosicionX+DistanciaEntrePixeles;
         } else {
            PosicionX = 64;
            EnlaFilaActual = 1;
            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);
         ColorDePixel = new Color("Pixel"+Pixeles);
         ColorDePixel.setRGB(0xFFFFFF);
      } while (Pixeles<MaxPosiciondePuntero);
      // Pintar una diagonal /:
      Incremento = PixelesdeLargo-1;
      Puntero = PixelesdeLargo-Incremento;
      do {
         Puntero = Puntero+Incremento;
         Col = new Color("Pixel"+Puntero);
         Col.setRGB(0);
         // trace("Se pintó el pixel "+Puntero);
      } while (Puntero<MinPixelInferior);
      // Asignar que en cada columna y fila hay 1 pixel pintado:
      Puntero = 0;
      do {
         Puntero = Puntero+1;
         set ("PintadosenC"+Puntero, 1);
         set ("PintadosenF"+Puntero, 1);
      } while (Puntero<PixelesdeLargo);
      // El puntero debe estar abajo a la derecha:
      Puntero = MaxPosiciondePuntero;
      // El 1er dibujo mostrado no será la diagonal sino...
      // ella con el pixel mayor pintado, así que...
      // los dibujos producible siempre son +1 de lo que se dice aquí.
   actions for fotograma 3
      stop ();
   actions for Vacío
      onClipEvent (enterFrame) {
         _level0.Variar();
      }

Cosas que quiero hacer luego:
- Simplificar la creación de Píxeles, si es posible, debo ver bien cómo lo hiciste.
- Evitar repeticiones por simetría horizontal.
- Intentar que el orden sea según la combinación más distinta.

La idea es que se muestren todos los dibujos posibles en que haya algún píxel pintado en cada columna y fila, pero son TANTOS, que es algo inútil de ver, no se produce mucho interesante...

Por eso luego...
- Hacer un generador random, de muchos dibujos con tamaño y colores a elección. Y programación genética.

La idea es hacer un generador de sprites.

No he visto que te estén pidiendo dinero ¿es peligroso enviarles un email, por qué?

Es que no me doy maña ni para buscar info, en mi país existe la página Mercado libre pero no sé si hay que pagar algo a los dueños, ni qué requisitos tiene, ni cómo usarla, etc, y si bien no he googleado "cómo usar Mercado libre" busco algo que me parezca más efectivo.

Lo que tengo son antiguedades, que en general no se consiguen. Por ejemplo tengo una colección de tazos de Chester. Lo mejor que puedo imaginar es organizar un remate para gente que tenga mucho dinero, pero como dije no me doy maña, tendría que ir a un barrio de gente así y poner carteles pero me parece poco ético (es spam) y como soy horrible para cumplir horarios no puedo decir "X día a Y hora", tendría que ser en una página o algo donde la gente pueda ir ofreciendo cada vez más, pero ¿cómo sé si lo están haciendo en serio? Bueno, si alguno me ofrece más y resulta broma, pruebo venderle al anterior y así sucesivamente.

Les iba a dar las cosas a unos familiares pero hasta eso es complicado, es increíble sí, pero miren: Una familiar me dijo que se las diera a mi tía y les envié emails. Mi tía dijo que no entendió qué debía hacer con las cosas, se las di a otra tía, pasó casi un mes y dijo que no tuvo tiempo para dársela a alguien que vive en la misma casa, vi a esa persona un día, le pregunté cuando podía llevarle las cosas y me dijo que se las de a mi tía. No. Y las otras durante meses no respondieron los emails ni el teléfono, mi tía dice que no tienen tiempo pero luego me dijo que estaban paseando. Yo me cansé... Me dediqué un poco a darles un regalo, si lo obstaculizan tanto que no responden o complican diciendo "dáselo a X", chau. Ah, ahora que me acuerdo también le pregunté a un primo si quería las cosas y miró más la caja (un lector de CDs) que el contenido, sacó una bolsa de figuritas con miedo y asco como si fuese un trozo de caca, dijo que no, que sus hijos eran muy chicos.

También pensé en regalárselas a niños con cáncer o algo así pero capaz que se las queda el que las recibe o me dicen que no porque las cosas pueden tener microbios.
Pensé en dárselas a niños con problemas mentales pero si ni les prestan atención o les presten demasiada no quiero (no queremos crear Gollums).

Quiero dárselas a alguien que las aprecie en la medida justa, por eso prefiero venderlas. A una maestra, para que se las ofrezca de premio al mejor alumno, podría ser, pero pa qué premiar al más memorizador y capaz que se las queda la maestra...

¿No es posible que viniera mal de fábrica en cuanto a cds o que algún cable esté mal puesto? Tengo un vago recuerdo de que nunca los leyó, no me preocupó porque estaba concentrado en otras cosas. Como dije, DVDs lee y graba bien.