Pero nada tiene que ver con hackers....

Recientemente vi un video de una onlyfan que mató al novio. Parece que espiando los fiscales descubrieron que los padres de ella estaban intentando hackear la notebook o algo del asesinado para modificar los mensajes, pero como eso fue espionaje el juez no aprobó la prueba. En fin, es lo más parecido que se me viene a la mente a que hacer las cosas bien, sin hackear ni espiar, es recomendable, pero si los fiscales no hubieran espiado y el hackeo hubiera salido bien entonces la historia sería otra...

Por otro lado en YT hay un tío que postea videos donde supuestamente actúa como caza estafadores y se burla de ellos o similares. Yo no lo sé Rick...

Y por lo que tengo entendido hay muchos extrangeros ocupando ciudades enteras de Europa, así que está bravísimo el tema.

Más que un programador necesitas un hacker o experto en seguridad informática. Un programador es algo más general, como si dijeras médico general, no es experto en ojos, ni en pulmones, etc. Un programador, en general, tampoco es experto en averiguar direcciones de gente.
También podría ser un detective privado, él capaz que conoce a gente que sepa.

Pero dudo que te sirva de mucho conseguir su dirección...

+1.

Estás viendo un video, quieres que no te aparezcan más de ese canal.

Si te aparecen en la lista de recomendados, puedes hacer clic en los 3 puntitos y poner la opción ahí.

¿Y si no te aparecen? ¿si sólo viste 1? No sé... Cuando te aparezcan de nuevo los bloqueas, tendrás que hacer una lista de los que quieres bloquear o memorizarlos, pero parece medio tedioso...

Otro método es que cuando vas a ver un video de un canal sospechosamente malo, lo abras en una nueva pestaña, así tienes en la otra el video en la lista y la opción de bloquearlo, pero esto tampoco está bueno, porque en mi caso se pone lento, y si pasa mucho tiempo la pestaña anterior se recarga, los recomendados cambian y ya no puedo bloquearlo. Además no todos los videos son sospechosamente malos, yo que sé, uno me dice "A sus 90 años, X revela lo que le pasó en..." y luego es el youtuber contando la biografía de esa persona, no habla la persona que crei que iba a hablar (parece) y tiene más relleno que Naruto, yo que iba a saber.

¿No se puede entrar al jodido canal y poner ahí no recomendarmelo? Que yo sepa no...

¿Habrá algún código que se le pueda enviar a YT? ¿algún javascript? ¿o sí hay una forma fácil de bloquear que no conozco?

Flamer:
Hice lo que dijiste, puse
1111111011111110111111101111111011111110111111101111111000000000
y el resultado fue
18374403900871474688

pero al hacerlo aquí:
https://masterplc.com/calculadora/convertir-binario-a-decimal/
fue
18374403900871475000

Y GPT dijo
18,446,744,066,181,791,744

Yo no sé


Ahora en un rato voy a hablar con él sobre el código que me dió porque no lo entendí. Luego actualizo.

Edit: Hablado hasta que me quedé sin puntos.

Resumen:
qué significa Saltar ceros líderes

explica esto
  while (i < n && bin.charAt(i) == "0") { i++; }
  if (i >= n) return "0";

no sé si el while ha terminado, etc. Lo veo así:
while (i < n && bin.charAt(i) == "0") {
   i++;
}
if (i >= n) return "0";
y sigue ¿es así?


cambié los i por NroDeCaracteraMirar:
(código)
¿tengo que cambiar los siguientes i o son independientes? Este:
  for (; i < n; i++) {


la variable n es el largo del binario, siempre?


var para qué es, qué diferencia hay entre definir una variable con var y sin var


No sabía o me había olvidado, a veces creaba variables y luego las eliminaba, de esta forma se eliminan solas.

cómo este if no tiene el { ?
  if (NroDeCaracteraMirar >= LargoDelBinario) return "0";
normalmente se pone
si (condición) {
   efecto


¿es posible que NroDeCaracteraMirar quede mayor que LargoDelBinario?
  // Ignorar ceros al inicio del binario:
  var NroDeCaracteraMirar = 0;
  var LargoDelBinario = bin.length;
  // Para eso mira caracteres desde la izquierda hasta que no haya caracteres o hasta que no sea 0:
  while (NroDeCaracteraMirar < LargoDelBinario && bin.charAt(NroDeCaracteraMirar) == "0") {
    NroDeCaracteraMirar++;
  }
  if (NroDeCaracteraMirar >= LargoDelBinario) {
   return "0";
  }

el incremento de NroDeCaracteraMirar ocurre sólo si es menor que LargoDelBinario, por lo que en cierto punto quedará igual y luego ya no aumentará, por lo tanto NroDeCaracteraMirar nunca será mayor que LargoDelBinario ¿correcto?


Código más claro (aún falta aclararlo más):

// Convierte un string binario (p.ej. "1101") a string decimal exacto (p.ej. "13")
// No usa Number para representar el valor completo, solo dígitos individuales.
function binToDecString(bin) {
  // Ignorar ceros al inicio del binario:
  var NroDeCaracteraMirar = 0;
  var LargoDelBinario = bin.length;
  // Para eso mira caracteres desde la izquierda hasta que no haya caracteres o hasta que no sea 0:
  while (NroDeCaracteraMirar < LargoDelBinario && bin.charAt(NroDeCaracteraMirar) == "0") {
    NroDeCaracteraMirar++;
  }
  // Si miró todos los caracteres:
  if (NroDeCaracteraMirar == LargoDelBinario) {
	return "0";
  }
 
  // digits almacena el número decimal en dígitos base 10, LSB primero (digits[0] es las unidades)
  var digits = [0];
 
  // Recorremos desde el primer '1' encontrado
  for (; NroDeCaracteraMirar < LargoDelBinario; NroDeCaracteraMirar++) {
    var c = bin.charAt(NroDeCaracteraMirar);
    if (c != "0" && c != "1") {
      continue; // o maneja error si prefieres
    }
 
    // decimal *= 2
    var carry = 0;
    var j;
    for (j = 0; j < digits.length; j++) {
      var x = digits[j] * 2 + carry;
      digits[j] = x % 10;
      carry = Math.floor(x / 10);
    }
    while (carry > 0) {
      digits[digits.length] = carry % 10;
      carry = Math.floor(carry / 10);
    }
 
    // decimal += bit
    if (c == "1") {
      var k = 0;
      var add = 1;
      while (add > 0) {
        if (k >= digits.length) digits[digits.length] = 0;
        var y = digits[k] + add;
        digits[k] = y % 10;
        add = Math.floor(y / 10);
        k++;
      }
    }
  }
 
  // Construir string (invertir los dígitos)
  var s = "";
  for (var t = digits.length - 1; t >= 0; t--) {
    s += digits[t];
  }
  return s;
}

EdePC te respondo otro día porque por hoy este tema me cansó/aburrió, pero a simple vista, sí, voy a tener que poner que el programa opere así, pero eso es un problema a resolver más adelante.

Se refiere al 3 en raya pero con la configuración que se ponga: En vez de 3 puede ser otro número y en vez de un tablero de 3*3 puede ser otro número independiente del anterior. Lo pensé para tableros cuadrados, pero quizá funcione para rectangulares. De momento está configurado para revisar sólo rayas horizontales, pero basta quitar un par de rayas // para que revise todas las posibilidades, es sólo que para pruebas me pareció mejor así.
Aún no lo probé, acabo de terminarlo, llevo bastante tiempo con esto... Disfrútenlo, analícenlo si quieren a ver qué tal:

// Signos en línea en tableros cuadrados:
// Este programa tiene básicamente 3 etapas,
// que se pueden resumir así:
// Nota: La situación inicial, en que hay 0 signos colocados,
// estará guardada en la lista nro 0.      
// 1:
// Probar acciones en cada situación de la lista nro 0,
// guardando en una nueva lista las nuevas situaciones (que no...
// sean victoria ni empate). Repetir con cada nueva lista hasta...
// la que tenga situaciones en que sólo 1 acción es posible
// (por ejemplo en el 3 en línea es la 8).
// 2:
// Probar acciones en cada situación de la última lista,
// guardando datos sobre las consecuencias (victoria o empate)
// de realizar la única acción posible.
// 3:
// En las situaciones no resueltas, empezando por las...
// penúltimas listas, probar las acciones.
// Guardar cuántas acciones causan victoria de uno, de otro y...
// de empate. Averiguar la mejor acción en cada situación,
// basado en el mejor resultado seguro que causa (asumiendo...
// que el rival juega bien), y en 2nda instancia el más probable
// (asumiendo que el rival juegue al azar).
// Repetir hasta resolver la lista 0.
JuntosRequeridos = 2;
CasillerosPorFila = 2;
// Contando desde 0:
MaxColumna = CasillerosPorFila-1;
Casilleros = CasillerosPorFila*CasillerosPorFila;
// Están numerados así:
// 0 1
// 2 3
MaxCasillero = Casilleros-1;
// En las listas L_SaE se irán poniendo las situaciones a...
// experimentar que tengan _ signos colocados.
// En la lista 0 se agregará una situación:
L0SaE1 = [];
// A continuación se especifica cual, agregando v
// (que significa vacío) en lo que serían los casilleros,
// los elementos del array:
ValoraAgregar = -1;
do {
	ValoraAgregar++;
	L0SaE1.push("v");
} while (ValoraAgregar < MaxCasillero);
delete ValoraAgregar;
// Los datos de las situaciones no están en las listas,
// se crean aparte. Con esta variable se evita repetidamente...
// convertir en texto y concatenar:
S_ = "S"+(L0SaE1.join(""));
// Datos de la situación:
// Usada para fácilmente saber de qué signo es turno:
set (S_+"Turno", "X");
// En otros casos usada para evitar probar acciones...
// innecesarias y con LastAPosible para saber si sólo queda 1:
set (S_+"FirstAPosible", 0);
set (S_+"LastAPosible", MaxCasillero);
NroDeListaRevisandose = -1;
// Última lista que se revisará en la etapa 1:
// LastListaDeEt1 = Casilleros;
// /////////////////////////////////////////////
// /////////////////  Etapa 1  /////////////////
// /////////////////////////////////////////////
// Consiste en llegar a nuevas situaciones y guardarlas,
// si no son victoria. Termina antes de que pueda haber empates.
//
// Usada a continuación y durante la etapa 1 (Et1)...
// cuando no hay más situaciones en la lista revisándose:
function BuscarOtraListaEt1 () {
	trace("Ejecutando BuscarOtraListaEt1");
	NroDeListaRevisandose++;
	PrepararUsoDeLista();
	PrepararSaE();
	// Si las situaciones de la lista tienen más de 1 opción:
	if (NroDeListaRevisandose < MaxCasillero) {
		// Para evitar concatenar cosas al guardar datos de situaciones nuevas:
		NextL_SaE = "L"+(NroDeListaRevisandose+1)+"SaE";
		trace("NextL_SaE: "+NextL_SaE);
		// Usado en EvaluarConocimientoSobreSEt1 para...
		// nombrar las situaciones nuevas que se logren:
		SituacionesNuevas = 0;
	} else {
		trace(	"La lista actual tiene situaciones de sólo 1 opción; inicia la etapa 2.");
		// Iniciar Etapa 2:
		gotoAndStop(3);
	}
}
BuscarOtraListaEt1();
// Usada cuando se cambia de lista, en BuscarOtraListaEt1,
// al comenzar Et2 y en Et3:
function PrepararUsoDeLista () {
	trace("Ejecutando PrepararUsoDeLista");
	// Para evitar concatenar repetidamente:
	L_SaE = "L"+NroDeListaRevisandose+"SaE";
	trace("L_SaE: "+L_SaE);
	NroDeSExperimentandose = 1;
	// También para evitar concatenar repetidamente:
	// L_SaE_ = L_SaE+NroDeSExperimentandose;
	L_SaE_ = L_SaE+"1";
	trace("L_SaE_: "+L_SaE_);
	trace("Comienzan experimentos en una nueva lista, la "+NroDeListaRevisandose);
}
// Usada cuando se elige una SaE, en BuscarOtraListaEt1,
// BuscarOtraSituacionEt1, BuscarOtraSituacionEt2 y PrepararSaEEt3:
function PrepararSaE () {
	trace("Ejecutando PrepararSaE");
	trace("Se inician experimentos en otra situación de la lista, la nro "+NroDeSExperimentandose);
	SituacionBase = eval(L_SaE_).slice();
	S_ = "S"+(SituacionBase.join(""));
	Turno = eval(S_+"Turno");
	FirstActionPosible = eval(S_+"FirstAPosible");
	LastActionPosible = eval(S_+"LastAPosible");
	Action = FirstActionPosible;
}
// Usada en frame 2 (o etapa 1) repetidamente:
function ResetearSituacionEt1 () {
	// Plantear situación porque puede modificarse pero...
	// podría requerirse su estado original luego:
	Situacion = SituacionBase.slice();
	trace("La situación experimentándose es "+Situacion);
	EvaluarAplicabilidadEt1();
}
// Usada luego de que cambia la SaE y/o la acción, en Et1:
function EvaluarAplicabilidadEt1 () {
	trace("Ejecutando EvaluarAplicabilidadEt1");
	if (Situacion[Action] == "v") {
		trace("La acción "+Action+" es realizable.");
		AplicarAccionEt1();
	} else {
		trace("La acción "+Action+" no es realizable.");
		SinResetBuscarOtraAccionEt1();
	}
}
// Usada luego de EvaluarAplicabilidadEt1,
// si una acción es realizable:
function AplicarAccionEt1 () {
	trace("Ejecutando AplicarAccionEt1");
	Situacion[Action] = Turno;
	trace("Se realizó la acción "+Action+"; ahora la situación es "+Situacion);
	// ¿Ganó?
	// Si no se detecta victoria vertical,
	// revisa de otros modos (ver las funciones Chequear):
	ChequearVertical();
	if (Win == "No") {
		EvaluarConocimientoSobreSEt1();
	}
	// ¿Queda alguna acción sin probar en la situación?
	BuscarOtraAccionEt1();
}
// Usada en EvaluarAplicabilidadEt1 cuando una acción no es...
// realizable:
function SinResetBuscarOtraAccionEt1 () {
	trace("Ejecutando SinResetBuscarOtraAccionEt1");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		EvaluarAplicabilidadEt1();
	} else {
		trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt1();
	}
}
// Usada luego de AplicarAccionEt1:
function BuscarOtraAccionEt1 () {
	trace("Ejecutando BuscarOtraAccionEt1");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		// Se ejecutará ResetearSituacionEt1.
	} else {
		trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt1();
	}
}
// Usada en AplicarAccionEt1 cuando no hay victoria (ni empate,
// aunque por ahora no ocurren):
function EvaluarConocimientoSobreSEt1 () {
	trace("Ejecutando EvaluarConocimientoSobreSEt1");
	// Estas 3 variables son para evitar reconcatenar:
	SituacionJoined = Situacion.join("");
	NewS_ = "S"+SituacionJoined;
	NewS_BestAction = NewS_+"BestAction";
	// ¿Se ha llegado antes a la situación?
	if (eval(NewS_BestAction) == undefined) {
		// No, anotar que debe investigarse:
		SituacionesNuevas++; 
		// Copiar array (porque no se puede normalmente):
		trace("Situación a copiar a "+NextL_SaE+SituacionesNuevas+" es "+Situacion);
		set (NextL_SaE+SituacionesNuevas, Situacion.slice());
		trace("Esa situación no está anotada; se anota como nro "+SituacionesNuevas);
		set(NewS_BestAction, "Desconocida");
		if (Turno == "X") {
			set (NewS_+"Turno", "0");
		} else {
			set (NewS_+"Turno", "X");
		}
		// Averiguar cual es su 1er acción posible:
		AccionRevisandose = -1;
		do {
			AccionRevisandose++;
			if (Situacion[AccionRevisandose] == "v") {
				set (NewS_+"FirstAPosible", AccionRevisandose);
				break;
			}
		} while (true);
		// Averiguar cual es su última acción posible:
		AccionRevisandose = Casilleros;
		do {
			AccionRevisandose--;
			if (Situacion[AccionRevisandose] == "v") {
				set (NewS_+"LastAPosible", AccionRevisandose);
				break;
			}
		} while (true);
	}
}
// Usada en BuscarOtraAccionEt1 cuando no hay más acciones posibles,
// y en SinResetBuscarOtraAccionEt1:
function BuscarOtraSituacionEt1 () {
	trace("Ejecutando BuscarOtraSituacionEt1");
	NroDeSExperimentandose++;
	if (eval(L_SaE+NroDeSExperimentandose) != undefined) {
		// Hay otra situación en la lista,
		// prepararse a usarla:
		L_SaE_ = L_SaE+NroDeSExperimentandose;
		PrepararSaE();
	} else {
		trace("No hay más situaciones a experimentar en la lista actual, se mirará otra.");
		BuscarOtraListaEt1();
	}
}
// /////////////////////////////////////////////
// /////////////////  Etapa 2  /////////////////
// /////////////////////////////////////////////
// Consiste en guardar el resultado de las situaciones en que...
// sólo 1 acción es posible. Puede ser victoria o empate.
//
// Usada en frame 3 (o etapa 2) repetidamente:
function ResetearSituacionEt2 () {
	// Plantear situación porque puede modificarse pero...
	// podría requerirse su estado original luego:
	Situacion = SituacionBase.slice();
	trace("La situación experimentándose es "+Situacion);
	AplicarAccionEt2();
}
// Usada luego de ResetearSituacionEt2, parece innecesario que sea función:
function AplicarAccionEt2 () {
	trace("Ejecutando AplicarAccionEt2");
	Situacion[Action] = Turno;
	trace("Se realizó la acción "+Action+"; ahora la situación es "+Situacion);
	// ¿Ganó?
	// Si no se detecta victoria vertical,
	// revisa de otros modos (ver las funciones Chequear):
	ChequearVertical();
	set(S_+"BestAction", Action);
	if (Win == "Sí") {
		trace("Victoria conseguida, guardando datos.");
		if (Turno == "X") {
			// Estas son las chances de que gane...
			// X, 0 o que haya empate:
			set(S_+"VictoriasDeX", 1);
			set(S_+"VictoriasDe0", 0);
			set(S_+"ResultadoEsperado", "X");
		} else {
			set(S_+"VictoriasDeX", 0);
			set(S_+"VictoriasDe0", 1);
			set(S_+"ResultadoEsperado", "0");
		}
		set(S_+"DistanciaaGanar", 1);
		set(S_+"Empates", 0);
	} else {
		trace("Empate conseguido, guardando datos.");
		set(S_+"VictoriasDeX", 0);
		set(S_+"VictoriasDe0", 0);
		set(S_+"Empates", 1);
		set(S_+"ResultadoEsperado", "E");
	}
	// ¿Queda alguna situación en la lista experimentándose?
	BuscarOtraSituacionEt2();
}
// Usada luego de AplicarAccionEt2, parece innecesario que sea función:
function BuscarOtraSituacionEt2 () {
	trace("Ejecutando BuscarOtraSituacionEt2");
	NroDeSExperimentandose++;
	if (eval(L_SaE+NroDeSExperimentandose) != undefined) {
		// Hay otra situación en la lista,
		// prepararse a usarla:
		L_SaE_ = L_SaE+NroDeSExperimentandose;
		PrepararSaE();
	} else {
		trace("No hay más situaciones a experimentar en la lista actual, inicia la etapa 3.");
		BuscarOtraListaEt3();
		gotoAndStop(4);
	}
}
// /////////////////////////////////////////////
// /////////////////  Etapa 3  /////////////////
// /////////////////////////////////////////////
// Consiste en guardar los resultados de las acciones en...
// situaciones en que más de 1 acción es posible.
// Particularmente se guarda la mejor acción.
// El resultado de las acciones puede ser victoria,
// una situación con posibles resultados,
// y en la penúltima lista una situación con un único posible...
// resultado.
//
// Usada antes y durante esta etapa...
// cuando no hay más situaciones en la lista revisándose:
function BuscarOtraListaEt3 () {
	trace("Ejecutando BuscarOtraListaEt3");
	NroDeListaRevisandose--;
	if (NroDeListaRevisandose > -1) {
		// Si se halla una lista:
		PrepararUsoDeLista();
		PrepararSaEEt3();
	} else {
		trace("No hay más listas a revisar; programa terminado.");
		// En este frame nada hay, es sólo para mostrar el mensaje:
		gotoAndStop(5);
	}
}
// Casi como PrepararSaE. Usada cuando se elige una SaE,
// en BuscarOtraListaEt3 y BuscarOtraSituacionEt3:
function PrepararSaEEt3 () {
	trace("Ejecutando PrepararSaEEt3");
	PrepararSaE();
	// Para evitar evals y concatenaciones repetidamente:
	BestAction = "";
	VictoriasDeX = 0;
	VictoriasDe0 = 0;
	Empates = 0;
	// Establecer que hasta ahora los resultados hallados...
	// son peores que lo posible, para que se sustituyan por...
	// cualquier acción:
	if (Turno == "X") {
		// La E antes de Obtenido es Esperado:
		BestResultadoEObtenido = "0";
	} else {
		BestResultadoEObtenido = "X";
	}
	// Si 2 acciones causan victoria segura,
	// esto sirve para elegir la mejor de ellas:
	BestDistanciaaGanar = Casilleros;
	// Si 2 acciones causan empate seguro,
	// esto sirve para elegir la mejor de ellas:
	BestChanceDeGanarEnE = -1;
	BestChanceDeEmpatarEnE = -1;
	// Si 2 acciones causan derrota segura,
	// esto sirve para elegir la mejor de ellas:
	LowestChanceDePerderEnD = -1;
	BestChanceDeGanarEnD = -1;
}
// Usada en frame 4 (o etapa 3) repetidamente:
function ResetearSituacionEt3 () {
	// Plantear situación porque puede modificarse pero...
	// podría requerirse su estado original luego:
	Situacion = SituacionBase.slice();
	trace("La situación experimentándose es "+Situacion);
	EvaluarAplicabilidadEt3();
}
// Usada luego de que cambia la SaE y/o la acción, en Et3:
function EvaluarAplicabilidadEt3 () {
	trace("Ejecutando EvaluarAplicabilidadEt3");
	if (Situacion[Action] == "v") {
		trace("La acción "+Action+" es realizable.");
		AplicarAccionEt3();
	} else {
		trace("La acción "+Action+" no es realizable.");
		SinResetBuscarOtraAccionEt3();
	}
}
// Usada luego de EvaluarAplicabilidadEt3,
// si una acción es realizable:
function AplicarAccionEt3 () {
	// Los datos se guardarán bien en GuardarDatosEt3.
	// Por ahora varios se están guardando en variables más simples de nombrar.
	// Además algunos no se pueden guardar aún (VictoriasDeX, NewVictoriasDe0...).
	// Y DistanciaaGanar se está guardando como -1 de lo que debe, para no tener que estar sumando.
	trace("Ejecutando AplicarAccionEt3");
	Situacion[Action] = Turno;
	trace("Se realizó la acción "+Action+"; ahora la situación es "+Situacion);
	// ¿Ganó?
	// Si no se detecta victoria vertical,
	// revisa de otros modos (ver las funciones Chequear):
	ChequearVertical();
	if (Win == "No") {
		// Agregar los posibles resultados de la...
		// situación obtenida:
		// Estas 5 variables son para evitar reconcatenar:
		SituacionJoined = Situacion.join("");
		NewS_ = "S"+SituacionJoined;
		NewVictoriasDeX = eval(NewS_+"VictoriasDeX");
		NewVictoriasDe0 = eval(NewS_+"VictoriasDe0");
		NewEmpates = eval(NewS_+"Empates");
		VictoriasDeX = VictoriasDeX+NewVictoriasDeX;
		VictoriasDe0 = VictoriasDe0+NewVictoriasDe0;
		Empates = Empates+NewEmpates;
		// Si en la SaE ya se halló una acción que...
		// causa victoria segura: 
		if (BestResultadoEObtenido == Turn) {
			// Si la acción recién usada también causa eso:
			if (eval(NewS_+"ResultadoEsperado") == Turn) {
				// Si dicha acción la causa faster:
				if (eval(NewS_+"DistanciaaGanar") < BestDistanciaaGanar) {
					// Sustituir datos:
					BestDistanciaaGanar = eval(NewS_+"DistanciaaGanar");
					BestAction = Action;
				}
				// SINO SI LA CAUSA IGUAL DE RÁPIDO HABRÍA QUE AVERIGUAR CHANCES, pero se gana igual...
				// sino dicha acción es peor, no prestarle más atención.
			}
			// idem.
		// sino si el mejor resultado esperado hallado...
		// en esta SaE es empate:
		} else if (BestResultadoEObtenido == "E") {
			// Si la acción recién usada causa que...
			// el resultado esperado sea victoria:
			if (eval(NewS_+"ResultadoEsperado") == Turn) {
				// Sustituir datos:
				BestResultadoEObtenido = Turn;
				BestDistanciaaGanar = eval(NewS_+"DistanciaaGanar");
				BestAction = Action;
			// sino si es empate:
			} else if (eval(NewS_+"ResultadoEsperado") == "E") {
				// Averiguar chance de victoria:
				Posibilidades = NewVictoriasDeX+NewVictoriasDe0+NewEmpates;
				ChanceDeGanar = eval("NewVictoriasDe"+Turno)*100/Posibilidades;
				// Si es mejor que la hallada antes:
				if (ChanceDeGanar > BestChanceDeGanarEnE) {
					// Sustituir datos:
					BestChanceDeGanarEnE = ChanceDeGanar;
					BestChanceDeEmpatarEnE = NewEmpates*100/Posibilidades;
					BestAction = Action;
				// sino si la chance es igual:
				} else if (ChanceDeGanar == BestChanceDeGanarEnE) {
					// Averiguar chance de empate:
					ChanceDeEmpatar = NewEmpates*100/Posibilidades;
					// Si es mejor que la hallada antes:
					if (ChanceDeEmpatar > BestChanceDeEmpatarEnE) {
						// Sustituir datos:
						BestChanceDeGanarEnE = ChanceDeGanar;
						BestChanceDeEmpatarEnE = ChanceDeEmpatar;
						BestAction = Action;
					}
				}
				// SINO SI LAS CHANCES SON LAS MISMAS HABRÍA QUE DECIDIR SI SE PREFIERE LA QUE LO CAUSA MÁS RÁPIDO O NO.
				// sino dicha acción no es mejor, no prestarle más atención.
			// idem.
			}
		// El resultado esperado es derrota:
		} else {
			// Si la acción recién usada causa que...
			// el resultado esperado sea victoria:
			if (eval(NewS_+"ResultadoEsperado") == Turn) {
				// Sustituir datos:
				BestResultadoEObtenido = Turn;
				BestDistanciaaGanar = eval(NewS_+"DistanciaaGanar");
				BestAction = Action;
			// sino si es empate:
			} else if (eval(NewS_+"ResultadoEsperado") == "E") {
 				// Averiguar chances y sustituir datos:
				Posibilidades = NewVictoriasDeX+NewVictoriasDe0+NewEmpates;
				BestChanceDeGanarEnE = eval("NewVictoriasDe"+Turno)*100/Posibilidades;
				BestChanceDeEmpatarEnE = NewEmpatesDeX*100/Posibilidades;
				BestResultadoEObtenido = "E";
				BestAction = Action;
			// sino es derrota:
			} else {
				// Averiguar chance de perder:
				Posibilidades = NewVictoriasDeX+NewVictoriasDe0+NewEmpates;
				ChanceDePerder = (Posibilidades-eval("NewVictoriasDe"+Turno)*100/Posibilidades;
				// Si es más baja (mejor) que la hallada antes:
				if (ChanceDePerder < LowestChanceDePerderEnD) {
					// Sustituir datos:
					LowestChanceDePerderEnD = ChanceDePerder;
					BestChanceDeGanarEnD = eval("NewVictoriasDe"+Turno)*100/Posibilidades;
					BestAction = Action;
				// sino si la chance es igual:
				} else if (ChanceDePerder == LowestChanceDePerderEnD) {
					// Averiguar chance de victoria:
					ChanceDeGanar = eval("NewVictoriasDe"+Turno)*100/Posibilidades;
					// Si es mejor que la hallada antes:
					if (ChanceDeGanar > BestChanceDeGanarEnD) {
						// Sustituir datos:
						LowestChanceDePerderEnD = ChanceDePerder;
						BestChanceDeGanarEnD = ChanceDeGanar;
						BestAction = Action;
					}
				}
			}
		}
	// sino la acción causa una victoria inmediata:
	} else {
		// Incrementar victorias:
		// Esta es para evitar reconcatenar:
		VariableaIncrementar = "VictoriasDe"+Turno;
		set (VariableaIncrementar, eval(VariableaIncrementar)+1);
		if (BestDistanciaaGanar > 0) {
			// Sustituir datos:
			BestResultadoEObtenido = Turn;
			BestDistanciaaGanar = 0;
			BestAction = Action;
		}
	}
	// ¿Queda alguna acción sin probar en la situación?
	BuscarOtraAccionEt3();
}
// Usada en EvaluarAplicabilidadEt3 cuando una acción no es...
// realizable:
function SinResetBuscarOtraAccionEt3 () {
	trace("Ejecutando SinResetBuscarOtraAccionEt3");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		EvaluarAplicabilidadEt3();
	} else {
		trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt3();
	}
}
// Usada luego de AplicarAccionEt3:
function BuscarOtraAccionEt3 () {
	trace("Ejecutando BuscarOtraAccionEt3");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		// Se ejecutará ResetearSituacionEt3.
	} else {
		trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt3();
	}
}
// Usada cuando no hay más acciones posibles:
function GuardarDatosEt3 () {
	trace("Ejecutando GuardarDatosEt3");
	set(S_+"VictoriasDeX", VictoriasDeX);
	set(S_+"VictoriasDe0", VictoriasDe0);
	set(S_+"Empates", Empates);
	set(S_+"BestAction", BestAction);
	set(S_+"DistanciaaGanar", BestDistanciaaGanar+1);
	set(S_+"ResultadoEsperado", BestResultadoEObtenido);
}
// Usada en BuscarOtraAccionEt3 cuando no hay más acciones posibles,
// y en SinResetBuscarOtraAccionEt3:
function BuscarOtraSituacionEt3 () {
	trace("Ejecutando BuscarOtraSituacionEt3");
	NroDeSExperimentandose++;
	if (eval(L_SaE+NroDeSExperimentandose) != undefined) {
		// Hay otra situación en la lista,
		// prepararse a usarla:
		L_SaE_ = L_SaE+NroDeSExperimentandose;
		PrepararSaEEt3();
	} else {
		trace("No hay más situaciones a experimentar en la lista actual, se mirará otra.");
		BuscarOtraListaEt3();
	}
}
// /////////////////////////////////////////////
// /////////////////  Chequeos  ////////////////
// /////////////////////////////////////////////
// Usada en ChequeoHorizontal y requerida en otros casos:
function ObtenerColumnayFilaDelMarcado () {
	FilaDelMarcado = Math.floor(Action/CasillerosPorFila);
	ColumnaDelMarcado = Action%CasillerosPorFila;
}
function ChequearVertical () {
	// trace ("Ejecutando ChequearVertical");
	// 
	// SOLO FUNCIONA SI CasillerosPorFila >= JuntosRequeridos.
	// 
	// Se revisará la vertical. Desde el casillero más arriba...
	// que pueda estar incluído en la línea,
	// hasta el casillero marcado. Si se halla alguno que no...
	// tenga la marca requerida, se repite el proceso mirando...
	// desde uno más abajo del fallado, y mirando ahora hasta...
	// más abajo, según corresponda:
	Desde = Action-CasillerosPorFila*(JuntosRequeridos-1);
	// Mientras el casillero no exista:
	while (Desde<0) {
		// trace ("Desde es "+Desde+", se aumentará");
		// Indicar que se empiece a mirar desde más abajo:
		Desde = Desde+CasillerosPorFila;
	}
	do {
		Hasta = Desde+CasillerosPorFila*(JuntosRequeridos-1);
		if (Hasta>MaxCasillero) {
			// Para ganar se necesitaría más casilleros hacia...
			// abajo de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos abajo");
			break;
		}
		Puntero = Desde;
		// trace ("Comenzando chequeo desde "+Desde+" hasta "+Hasta);
		// Puede cambiar:
		Win = "Sí";
		do {
			// trace ("Chequando el casillero "+Puntero);
			if (Situacion[Action] != Situacion[Puntero]) {
				Win = "No";
				Desde = Puntero+CasillerosPorFila;
				break;
			}
			Puntero = Puntero+CasillerosPorFila;
		} while (Puntero<=Hasta);
	} while (Desde<=Action && Win == "No");
	if (Win == "No") {
		// ChequearHorizontal();
	}
}
function ChequearHorizontal () {
	// trace ("Ejecutando ChequearHorizontal");
	// Es similar al chequeo vertical, pero aquí no sirve...
	// sumar o restar a un puntero que marque el casillero...
	// porque puede existir ese casillero pero no estar en...
	// un costado. En vez de eso, se obtiene su columna y...
	// fila, se modifica la columna si es posible,
	// y se calcula cual es el casillero a mirar:
	ObtenerColumnayFilaDelMarcado();
	DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
	// Para que no mire cuadraditos inexistentes en la izq:
	if (DesdeColumna<0) {
		DesdeColumna = 0;
	}
	do {
		HastaColumna = DesdeColumna+JuntosRequeridos-1;
		if (HastaColumna>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// la derecha de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos a la derecha");
			break;
		}
		Puntero = DesdeColumna;
		// trace ("Comenzando chequeo desde "+DesdeColumna+" hasta "+HastaColumna);
		// Puede cambiar:
		Win = "Sí";
		do {
			CasilleroaMirar = FilaDelMarcado*CasillerosPorFila+Puntero;
			// trace ("Chequando el casillero "+CasilleroaMirar);
			if (Situacion[Action] != Situacion[CasilleroaMirar]) {
				Win = "No";
				DesdeColumna = Puntero+1;
				break;
			}
			Puntero++;
		} while (Puntero<=HastaColumna);
	} while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
	if (Win == "No") {
		ChequearDesdeUpIzq();
	}
}
// La diagonal así \
function ChequearDesdeUpIzq () {
	// trace ("Ejecutando ChequearDesdeUpIzq");
	DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
	// trace("DesdeColumna: "+DesdeColumna);
	DesdeFila = FilaDelMarcado-JuntosRequeridos+1;
	// trace("DesdeFila: "+DesdeFila);
	// Para que no mire cuadraditos inexistentes:
	if (DesdeColumna<DesdeFila) {
		Sumar = DesdeColumna;
	} else {
		Sumar = DesdeFila;
	}
	// trace("Sumar: "+Sumar);
	if (Sumar<0) {
		// trace("Sumando.");
		DesdeColumna = DesdeColumna-Sumar;
		// trace("DesdeColumna: "+DesdeColumna);
		DesdeFila = DesdeFila-Sumar;
		// trace("DesdeFila: "+DesdeFila);
	}
	do {
		HastaColumna = DesdeColumna+JuntosRequeridos-1;
		if (HastaColumna>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// la derecha de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos a la derecha");
			break;
		}
		HastaFila = DesdeFila+JuntosRequeridos-1;
		// Sirve usar MaxColumna en vez de crear MaxFila...
		// porque como el tablero es cuadrado serían iguales:
		if (HastaFila>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// abajo de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos abajo");
			break;
		}
		PunteroDeColumna = DesdeColumna;
		PunteroDeFila = DesdeFila;
		// trace ("Comenzando chequeo desde columna "+DesdeColumna+" y fila "+DesdeFila);
		// trace ("hasta columna "+HastaColumna+" y fila "+HastaFila);
		// Puede cambiar:
		Win = "Sí";
		do {
			CasilleroaMirar = PunteroDeFila*CasillerosPorFila+PunteroDeColumna;
			// trace ("Chequando el casillero "+CasilleroaMirar);
			if (Situacion[Action] != Situacion[CasilleroaMirar]) {
				Win = "No";
				DesdeColumna = PunteroDeColumna+1;
				DesdeFila = PunteroDeFila+1;
				break;
			}
			PunteroDeColumna++;
			PunteroDeFila++;
		} while (PunteroDeColumna<=HastaColumna);
	} while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
	if (Win == "No") {
		ChequearDesdeDownIzq();
	}
}
// La diagonal así /
function ChequearDesdeDownIzq () {
	// trace ("Ejecutando ChequearDesdeDownIzq");
	DesdeColumna = ColumnaDelMarcado-JuntosRequeridos+1;
	// trace("DesdeColumna: "+DesdeColumna);
	DesdeFila = FilaDelMarcado+JuntosRequeridos-1;
	// trace("DesdeFila: "+DesdeFila);
	// Para que no mire cuadraditos inexistentes:
	ColumnasInexistentes = 0;
	if (DesdeColumna<0) {
		ColumnasInexistentes = DesdeColumna*-1;
	}
	FilasInexistentes = 0;
	// Está bien usar MaxColumna porque MaxFila sería igual:
	if (DesdeFila>MaxColumna) {
		FilasInexistentes = DesdeFila-MaxColumna;
	}
	if (ColumnasInexistentes>=FilasInexistentes) {
		Ajuste = ColumnasInexistentes;
	} else {
		Ajuste = FilasInexistentes;
	}
	// trace("Ajuste: "+Ajuste);
	if (Ajuste>0) {
		// trace("Ajustando.");
		DesdeColumna = DesdeColumna+Ajuste;
		// trace("DesdeColumna: "+DesdeColumna);
		DesdeFila = DesdeFila-Ajuste;
		// trace("DesdeFila: "+DesdeFila);
	}
	do {
		HastaColumna = DesdeColumna+JuntosRequeridos-1;
		if (HastaColumna>MaxColumna) {
			// Para ganar se necesitaría más casilleros hacia...
			// la derecha de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos a la derecha");
			break;
		}
		HastaFila = DesdeFila-JuntosRequeridos+1;
		if (HastaFila<0) {
			// Para ganar se necesitaría más casilleros hacia...
			// arriba de los que hay, terminar análisis:
			// trace ("No hay suficientes cuadraditos arriba");
			break;
		}
		PunteroDeColumna = DesdeColumna;
		PunteroDeFila = DesdeFila;
		// trace ("Comenzando chequeo desde columna "+DesdeColumna+" y fila "+DesdeFila);
		// trace ("hasta columna "+HastaColumna+" y fila "+HastaFila);
		// Puede cambiar:
		Win = "Sí";
		do {
			CasilleroaMirar = PunteroDeFila*CasillerosPorFila+PunteroDeColumna;
			// trace ("Chequando el casillero "+CasilleroaMirar);
			if (Situacion[Action] != Situacion[CasilleroaMirar]) {
				Win = "No";
				DesdeColumna = PunteroDeColumna+1;
				DesdeFila = PunteroDeFila-1;
				break;
			}
			PunteroDeColumna++;
			PunteroDeFila--;
		} while (PunteroDeColumna<=HastaColumna);
	} while (DesdeColumna<=ColumnaDelMarcado && Win == "No");
	// trace("Win: "+Win);
}

El 1ero se usa como sinónimo de "encuentra".

El 2ndo es como un pasado de haber.

https://www.rae.es/duda-linguistica/es-haya-o-haya

Hasta el nombre del link se cambia  

GPT me dijo:
=DIRECCION(FILA(D8)-1+COINCIDIR(MIN(D8:D22);D8:D22;0); COLUMNA(D8))
y funciona pero sólo entiendo lo que está en negrita, quisiera una alternativa o a ver si me lo pueden hacer entender.

(MIN(D8:D22):
haya el mínimo en ese rango de celdas.
(ll, el foro me cambia la palabra)

COINCIDIR(MIN(D8:D22);D8:D22;0):
Asumo que se lee como:
Buscar índice de (Valor; en el rango; coincidencia total)

¿ DIRECCION(qué fila; qué columna) ?

FILA(D8)-1:
No tengo mucha idea. Creo que le suma 7 al resultado de COINCIDIR, pero ahí dice -1, además pone una D no sé para qué.
Edit: Ya entendí esto, de D8 toma el 8, le resta 1, queda 7, y luego la fórmula dice +, así que ese 7 se suma...


COLUMNA(D8):
Idem. Si toma la columna del parámetro D8, sería más fácil simplemente poner D.

O sea, de D8 a D22 tengo unos datos, y en otra celda quiero que me diga en cual de esas celdas está el mínimo valor. No creo que sea tan complicado ¿GPT se lió?

Edit: Ya entendí más, pero hay como cosas innecesarias, que deberían ser más simples ¿se pueden simplificar?

Edit 2: Según probé se puede simplificar así:
=DIRECCION(7+COINCIDIR(MIN(D8:D22);D8:D22;0); COLUMNA(D8))
Faltaría la columna. Si siempre va a ser D...

La mira es a donde tiene que ir el meteoro cuando toque la nave de abajo. Cuando queda en una punta es como si estuvieses jugando al tenis y apuntando a la punta, es normal.

No importa aquí qué lugar de la nave de abajo toque el meteoro. Mover la nave no cambia la posición de la mira, es como un "charging", apretás A o S y en vez de que el tiro sea más fuerte debe ir más a la punta.

Tengo pensado hacer eso pero no veo que sea la solución al problema... Eso va a ser una 2nda etapa del charging, que vaya justo al centro y rebote, ya que es efectivo contra la IA. Así como está el juego es muy difícil hacerle un punto.

Creo que hay confusión, la trayectoria del tiro debe decidirse cuando toca la nave de abajo y por ahora no debe tocar las paredes. Hago un dibujo...

Cuando el meteoro toque la nave de abajo, debe rebotar siguiendo la línea verde, hacia la mira, sin tocar las paredes.
Si va a tardar 100 frames en recorrer la distanciaY, debe tardar 100 frames en recorrer la distanciaX. Ese es el razonamiento que hago y el cálculo que intento hacer, pero no sé qué pasa.


En tu ejemplo a veces choca en la pared, esa no es la idea, lo demás está bien, no sé cómo hiciste el cálculo...

Ignora la pared por ahora, se va a usar más adelante. Supón que es un juego de golf de cuando usas el palo que la pelota no sube, o sea, todo 2d, visto de arriba, y la mira el hoyo, y se quiere que la pelota vaya ahí.
Se determina una velocidad Y al azar:
MeteorYSpeed = -Math.random()*(2+Dificultad)-1;
¿y luego? Capaz que me falla el cálculo porque esa velocidad es negativa, luego veo.

Si elipse es muy complicado será rectángulo.

Quiero imitar una nube cambiando, más o menos. Circulos aparecerían detrás, crecerían y se achicarían hasta desaparecer. Hay un video que me gustó que más o menos hace eso pero no lo encuentro.

Entonces, tenemos una elipse de 200 de ancho y 100 de alto. Supongamos que está colocado en las coordenadas 0, 0. ¿Cómo los circulos podrían aparecer en cualquier parte del perímetro con igual probabilidad? No en el área.

Si es muy complicado, tenemos un rectángulo, digamos de la misma medida y lugar. Y misma pregunta.
Sobre este lo pensé y no supe. Puedo hacer que aparezca en el perímetro, pero con igual chance cada punto no sé.

https://youtu.be/TmACx8Du3as

Cuando el meteoro se está acercando a la nave de abajo, si presiono A o S aparece una mira, que se va moviendo a la izquierda si apreté A y a la derecha si apreté S.
Cuando el meteoro toque la nave de abajo, debe ir hacia donde haya quedado la mira.

Pueden ver que a veces funciona, y a veces no, no sé por qué...

La pantalla es de 800 pixeles de ancho y 600 de largo. Las coordenadas avanzan a la derecha y abajo, así que arriba a la izquierda es 0, 0
y abajo a la derecha es 800, 600
El 1er número corresponde a X, el 2ndo a Y.

La mira es algo provisorio para mostrar la falla, no habrá mira en el juego.

Creo que el error está acá:

	if (Meteor.hitTest(Player) && MeteorYSpeed>0) {
		// Determinar velocidad Y al azar:
		MeteorYSpeed = -Math.random()*(2+Dificultad)-1;
		// Distancia Y desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaY = Meteor._y-20.5;
		// Cuánto tardará el meteoro en recorrerla:
		TardanzaY = Math.ceil(DistanciaY/-MeteorYSpeed);
		// Distancia X desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaX = Meteor._x-400+Apuntando;
		// Determinar la velocidad X para que el meteoro llegue...
		// al punto X apuntado justo cuando llega al punto Y apuntado:
		MeteorXSpeed = DistanciaX/TardanzaY;

Código completo:

// Algo como esto if (MeteorYSpeed>0) { se está haciendo 2 veces,
// pero evitarlo implicaría unir cosas del jugador y la IA?
//
fscommand ("fullscreen", "true");
// Varía según diferencia de puntajes:
Dificultad = 0;
// Player:
attachMovie("sShip", "Player", 1);
setProperty ("Player", _x, 400);
setProperty ("Player", _y, 579.5);
PlayerSpeed = 3;
PlayerScore = 0;
// IA:
attachMovie("sIA", "IA", 2);
setProperty ("IA", _x, 400);
setProperty ("IA", _y, 20.5);
IASpeed = 3;
IAScore = 0;
// Meteor:
attachMovie("sMeteor", "Meteor", 3);
setProperty ("Meteor", _x, 400);
setProperty ("Meteor", _y, 544.5);
// Se define acá para que luego el programa considere que...
// hubo contacto entre la nave del jugador y el meteoro:
MeteorYSpeed = 1;
// Para que la curvatura dependa de MeteorYSpeed
// (1 es hacia arriba, -1 hacia abajo):
MeteorYDirection = -1;
// Valores del color más brillante del meteoro (F0D9C8):
MaxRojo = 255;
MaxVerde = 217;
MaxAzul = 200;
// /////////////////////////////////////////////
// /////////////////// Ship ////////////////////
// /////////////////////////////////////////////
function ControlShip () {
	if (Key.isDown(39)) {
		// Derecha.
		// Para evitar que se vaya demasiado al extremo derecho:
		if (Player._x<722) {
			Player._x = Player._x+PlayerSpeed;
		} else {
			Player._x = 725;
		}
	} else if (Key.isDown(37)) {
		// Izquierda.
		// Para evitar que se vaya demasiado al extremo izquierdo:
		if (Player._x>78) {
			Player._x = Player._x-PlayerSpeed;
		} else {
			Player._x = 75;
		}
	}
	// Si el meteoro va hacia abajo:
	if (MeteorYSpeed>0) {
		// Si aún no se eligió hacia dónde rebotarlo:
		if (Apuntando == 0) {
			if (Key.isDown(65)) {
				Apuntando = -1;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 399);
				setProperty ("Mira", _y, 20.5);
			} else if (Key.isDown(83)) {
				Apuntando = 1;
				attachMovie("sMira", "Mira", 4);
				setProperty ("Mira", _x, 401);
				setProperty ("Mira", _y, 20.5);
			}
		} else if (Apuntando < 0) {
			Apuntando = Apuntando-3;
			if (Apuntando < -400) {
				Apuntando = -400;
			}
			setProperty ("Mira", _x, 400+Apuntando);
		} else {
			Apuntando = Apuntando+3;
			if (Apuntando > 400) {
				Apuntando = 400;
			}
			setProperty ("Mira", _x, 400+Apuntando);
		}
	}
}
// /////////////////////////////////////////////
// ////////////////////  IA  ///////////////////
// /////////////////////////////////////////////
function IATurn () {
	// Si el meteoro va hacia arriba:
	if (MeteorYSpeed<0) {
		// La IA se moverá hacia él:
		Distancia = IA._x-Meteor._x;
	} else {
		// La IA irá hacia el centro:
		Distancia = IA._x-400;
	}
	if (Distancia < 0) {
		IA._x = IA._x+IASpeed;
		// Para evitar que se vaya demasiado a la derecha:
		if (IA._x > 725) {
			IA._x = 725;
		}
	} else if (Distancia > 0) {
		IA._x = IA._x-IASpeed;
		// Para evitar que se vaya demasiado a la izquierda:
		if (IA._x < 75) {
			IA._x = 75;
		}
	}
}
// /////////////////////////////////////////////
// /////////////////  Meteor  //////////////////
// /////////////////////////////////////////////
function VariarMeteoro () {
	Diametro = 44;
	Radio = Diametro/2;
	// Insertarle imágenes:
	Imagen = 0;
	do {
		Imagen++;
		Name = "Imagen"+Imagen;
		Meteor.attachMovie("sCirculo", Name, Imagen);
		Name = "Meteor."+Name;
		// Para los tamaños y rotación:
		setProperty (Name, _xscale, 400*Math.random());
		setProperty (Name, _yscale, 400*Math.random());
		setProperty (Name, _rotation, 360*Math.random());
		// Para las posiciones:
		X = Math.random()*Diametro - Radio;
		setProperty (Name, _x, X);
		MaxY = Math.sqrt(Radio*Radio - X*X);
		Y = Math.random() * (MaxY*2) - MaxY;
		setProperty (Name, _y, Y);
		// Para los colores:
		ColorDeName = new Color(Name);
		Brillo = 0.2 + 0.8 * Math.random();
		Rojo = Math.round(MaxRojo * Brillo);
		Verde = Math.round(MaxVerde * Brillo);
		Azul = Math.round(MaxAzul * Brillo);
		ColorElegido = (Rojo << 16) | (Verde << 8) | Azul;
		ColorDeName.setRGB(ColorElegido);
	} while (Imagen < 1000);
}
VariarMeteoro ();
function MeteorMoves () {
	MeteorXSpeed = MeteorXSpeed+MeteorRotation/1000*MeteorYDirection;
	MeteorRotation = MeteorRotation/1.01;
	Meteor._x = Meteor._x+MeteorXSpeed;
	Meteor._y = Meteor._y+MeteorYSpeed;
	Meteor._rotation = Meteor._rotation+MeteorRotation;
	// Choque con nave derecha:
	if (Meteor._x > 752.5) {
		MeteorXSpeed = -MeteorXSpeed;
		if (MeteorYSpeed > 0) {
			// Si va hacia abajo:
			MeteorYSpeed = Math.max (MeteorYSpeed, MeteorYSpeed-MeteorRotation/50);
		} else if (MeteorYSpeed < 0) {
			MeteorYSpeed = Math.min (MeteorYSpeed, MeteorYSpeed+MeteorRotation/50);
		}
		MeteorRotation = Math.random()*10*(2*random(2)-1);
	} else if (Meteor._x < 47.5) {
		// Choque con nave izquierda:
		MeteorXSpeed = -MeteorXSpeed;
		if (MeteorYSpeed > 0) {
			// Si va hacia abajo:
			MeteorYSpeed = Math.max (MeteorYSpeed, MeteorYSpeed+MeteorRotation/50);
		} else if (MeteorYSpeed < 0) {
			MeteorYSpeed = Math.min (MeteorYSpeed, MeteorYSpeed-MeteorRotation/50);
		}
		MeteorRotation = Math.random()*10*(2*random(2)-1);
	}
	if (Meteor.hitTest(Player) && MeteorYSpeed>0) {
		// Determinar velocidad Y al azar:
		MeteorYSpeed = -Math.random()*(2+Dificultad)-1;
		if (Apuntando < -400) {
			Apuntando = -400;
		} else if (Apuntando > 400) {
			Apuntando = 400;
		}
		// Distancia Y desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaY = Meteor._y-20.5;
		// Cuánto tardará el meteoro en recorrerla:
		TardanzaY = Math.ceil(DistanciaY/-MeteorYSpeed);
		// Distancia X desde el meteoro hasta el punto hacia donde se lo apuntó:
		DistanciaX = Meteor._x-400+Apuntando;
		// Determinar la velocidad X para que el meteoro llegue...
		// al punto X apuntado justo cuando llega al punto Y apuntado:
		MeteorXSpeed = DistanciaX/TardanzaY;
		MeteorRotation = 0;
		// MeteorRotation = Math.random()*(180+Dificultad)*(2*random(2)-1);
		MeteorYDirection = 1;
		trace("MeteorYSpeed: "+MeteorYSpeed);
		trace("Apuntando: "+Apuntando);
		trace("DistanciaY: "+DistanciaY);
		trace("TardanzaY: "+TardanzaY);
		trace("DistanciaX: "+DistanciaX);
		trace("MeteorXSpeed: "+MeteorXSpeed);
		removeMovieclip("Mira");
	} else if (Meteor.hitTest(IA) && MeteorYSpeed<0) {
		MeteorYSpeed = Math.random()*(2+Dificultad)+1;
		MeteorXSpeed = Math.random()*(3+Dificultad)*(2*random(2)-1);
		MeteorRotation = Math.random()*(180+Dificultad)*(2*random(2)-1);
		MeteorYDirection = -1;
		Apuntando = 0;
	} else if (Meteor._y<0) {
		setProperty ("Meteor", _x, 400);
		setProperty ("Meteor", _y, 55.5);
		PlayerScore++;
		Dificultad++;
		PlayerSpeed = PlayerSpeed+0.1;
		IASpeed = IASpeed+0.11;
		ShowScore();
	} else if (Meteor._y>600) {
		setProperty ("Meteor", _x, 400);
		setProperty ("Meteor", _y, 544.5);
		IAScore++;
		Dificultad--;
		PlayerSpeed = PlayerSpeed-0.1;
		IASpeed = IASpeed-0.11;
		ShowScore();
	}
}
// 
function ShowScore () {
	attachMovie("sPuntaje", "Mensaje", 4);
	setProperty ("Mensaje", _x, 400);
	setProperty ("Mensaje", _y, 300);
	setProperty ("Player", _x, 400);
	setProperty ("IA", _x, 400);
	gotoAndStop (3);
}
// stop ();