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 ();

Kung Fu Master de NES es sencillo, ya lo pasé hace mucho, e hice experimentos recientemente, pero quiero hacerlos mejor. Elijo ese juego porque es sencillo y suficientemente bueno.
https://www.youtube.com/watch?v=e7PIr6hpaBY

La idea es empezar también por un experimento sencillo, por ejemplo sólo usar puñetazos normales (no agachado ni saltando). Supongamos que así vencí a 0 jefes. Tengo que anotar datos sobre el resultado:
Usar 1 ataque: 0
Ataque tipo puñetazo: 0
Ataque tipo normal: 0
Puñetazo: 0

El siguiente experimento debe ser lo más distinto posible a ese pero sin complicarme demasiado: 2 ataques, preferentemente que no sean tipo puñetazo, ni normal, y claro que no sean puñetazo.  Por ejemplo patada agachado y patada saltando sin avanzar. Luego pongo los resultados de eso.

Poco a poco se complica comprender cual es el siguiente experimento que conviene hacer, pero mi pregunta es ¿cómo se recomienda que sea la tabla de Excel para anotar los datos o cómo los anotarían? Ciertos datos deben llenarse automáticamente cuando se pone algo en ciertas celdas.

Para empezar pienso en algo así:

Ahí nada se está llenando automáticamente, parece innecesario, es poca cosa.

Luego pienso en algo así:

No sé si tiene sentido tanto dato, creo que es para en el futuro ir viendo qué combinaciones no volver a probar aún, o cuales probar preferentemente, la cosa es que siendo así, ya varios datos se tendrían que llenar automáticamente y probablemente ajustar la tabla para eso o para que quede mejor. Además, si algo tiene puntaje en varias columnas, veo 2 opciones:
A- Crear otra columna que haga un promedio.
B- Que en cada columna se use el nuevo puntaje para promediarlo con el anterior. Creo que esto hace que los últimos puntajes tengan más influencia, no es bueno.

Se va a complicar aún más. El tema es cómo automatizar que se llenen los datos. Lo de las combinaciones lo estoy hablando con GPT.

Pensé en algo así:

Los datos se llenarían así:
Usar 1 ataque: Si en Ataques dice 1, se pone el contenido de Puntaje.
2 ataques: Si en Ataques dice 2, contenido de Puntaje.
Ataque tipo puñetazo: Se busca eso (Ataque tipo puñetazo) en el rango de datos de la columna (hasta donde dice Tipo 2 de Ataque 2). Si se encuentra alguna vez, se pone el Puntaje.
Y así sucesivamente, se busca lo que marca la celda en la fila, y si se encuentra se pone el puntaje.
Entonces llegamos a:
2 ataques   Ataque tipo patada:
Si en Ataques dice 2 y se encuentra "Ataque tipo patada" en el rango de datos, se pone el puntaje.
Más adelante llegamos a:
Ataque tipo patada   Ataque tipo agachado:
Desde ahí se me complica porque lo que se preguntaría es ¿en el experimento se hicieron ataques tipo patada y además otro ataque tipo agachado? Y se se pondría el puntaje si la respuesta es sí, pero no es cuestión de buscar y si aparecen ambas palabras ya está, porque si por ejemplo hubo patadas agachado y puñetazos normales no es que hubo ataques tipo patadas y otro tipo agachado, sino que 1 ataque cumple ambas condiciones, no es lo mismo...
Dicho de otro modo, si es un juego de cartas Pokemon y pongo:
Carta tipo Pokemon   Carta tipo Pokemon tipo planta
lo que se pregunta es ¿hubo una carta Pokemon y otra Pokemon tipo planta? Si hubo un Pokemon tipo planta, eso cumple una condición u otra, no ambas a la vez, para que se cumplan ambas debe haber uno de esos y otro cualquiera.
¿Cómo puedo poner los datos y fórmulas para que se llenen automáticamente la mayoría de datos teniendo en cuenta eso?

No sé qué alternativas tengo.

Consigo en binario la cantidad de dibujos que se van a mostrar en pantalla. DIBUJOS.

Esa cantidad la necesito dividir entre el número de cuadros (o minipantallas), que está en decimal. CUADROS.
Salvo que pudiera hallar alguna regla, que luego comento.

Así que debo convertir el binario en decimal, y luego hacer la división. DIBUJOS/CUADROS.
Una alternativa, trabajar con binarios, lo veo complicado. Supongamos que convierto la cantidad de cuadros, a binario. Luego puedo hacer una división entre binarios, puedo preguntarle a GPT cómo. Pero luego a DIBUJOS tengo que irle restando eso, o sea, hacer restas en binario, y no sé realmente si voy a obtener los números que preciso.
Pero sea como sea, las divisiones van a tener que ser con strings.

Lo de la regla es que los dibujos podrían empezar de cierta forma sin que haya mucho problema. Por ejemplo si hay 4 cuadros de 3*3 cuadraditos cada uno y ponemos que empiecen así:
NNN  NNN
NBB  NBN
NBB  NBB  

NNN  NNN
NBB  NBB
NNB  NBN
Hay que ver si el cuadro inferior derecho queda todo negro (los dibujos van variando) después de que los otros cuadros mostraran todos los dibujos que deben. Si es así y se sigue cumpliendo cuando aumenta la cantidad de cuadros y cuadraditos, bueno, no sería la solución ideal, pero podría ser una solución. Como es difícil saberlo, prefiero hacer una división como se debe. Supongamos que se van a mostrar 512 dibujos. Son menos pero supongamos. Hacemos eso /4, entonces:
512   384
256   128
Me refiero a que un cuadro mostrará el dibujo 512, otro el nro 384, otro el 256, y así. Enseguida, cada uno mostrará el anterior, así:
511  383
255  127
Y así seguirán variando hasta que el inferior derecho llegue a 0 (todo negro), es decir, se muestran todos los dibujos posibles.
Cada número al convertirse a binario se convierte en una representación del dibujo, 0 es negro, 1 blanco.
Más o menos es eso, me puedo haber confundido en algo.
Si los convierto a binario ¿para qué inician como decimales? No sé, me pareció más fácil, lo pensé así, para entender mejor qué estoy haciendo. No creo que sea el problema...

En fin, que yo sepa, para empezar, tengo un binario enorme que debo convertir a decimal pero que sea string. Espero no confundirme en esto.

GPT:

Ahora tengo que intentar entender ese código... Ya había conseguido uno parecido y no pude. Le puedo ir preguntando a GPT lo que no entienda pero... si alguien pudiera hacer un código más comprensible y explicarlo con un ejemplo estaría bueno.

Intento resumir y corregir algunos posibles errores que haya cometido en posts anteriores.

Se consigue el número binario que forma la L invertida, aunque es un string:
"1111111011111110111111101111111011111110111111101111111000000000"

Se intenta convertir a decimal, pero como el número resultante es tan grande, Flash falla:
9.22337203685478e+18
Según GPT, el resultado debería ser 18374686492081295424 y el número raro que pone Flash es casi la mitad de eso. Falla.

Entonces, en principio necesito un método de convertir un string que representa un número binario, en un string que represente un decimal, pero sin que dicho método use variables tipo número que sean demasiado grandes, porque sino falla.

El método que usaba, para convertir DibujoEnBinario en DibujoaMostrar, es:

	// Convertirlo en decimal:
	DibujoaMostrar = 0;
	do {
		DibujoaMostrar = DibujoaMostrar+(Number(DibujoEnBinario.charat(NroDelCaracter))*Math.round(Math.pow(2, DibujoEnBinario.length-1-NroDelCaracter)));
		trace("Convirtiendo en decimal... "+DibujoaMostrar);
		NroDelCaracter++;
	} while (NroDelCaracter<Cuadraditos);
	DibujoaMostrar = Number(DibujoaMostrar);

Le expliqué a GPT y me dijo esto:

function binaryToDecimalString(binStr) {
    var decimal = "0";
    var i = 0;
 
    while (i < binStr.length) {
        // Multiplicar el decimal actual por 2
        decimal = multiplyDecimalStringByTwo(decimal);
 
        // Sumar el bit actual si es 1
        if (binStr.charAt(i) == "1") {
            decimal = addDecimalString(decimal, "1");
        }
 
        i++;
    }
 
    return decimal;
}
 
// Multiplica un string decimal por 2
function multiplyDecimalStringByTwo(decimal) {
    var result = "";
    var carry = 0;
 
    for (var i = decimal.length - 1; i >= 0; i--) {
        var digit = Number(decimal.charAt(i)) * 2 + carry;
        carry = Math.floor(digit / 10);
        result = String(digit % 10) + result;
    }
 
    if (carry > 0) {
        result = String(carry) + result;
    }
 
    return result;
}
 
// Suma dos strings decimales
function addDecimalString(a, b) {
    var result = "";
    var carry = 0;
    var i = a.length - 1;
    var j = b.length - 1;
 
    while (i >= 0 || j >= 0 || carry > 0) {
        var digitA = i >= 0 ? Number(a.charAt(i)) : 0;
        var digitB = j >= 0 ? Number(b.charAt(j)) : 0;
        var sum = digitA + digitB + carry;
        carry = Math.floor(sum / 10);
        result = String(sum % 10) + result;
        i--;
        j--;
    }
 
    return result;
}

Lo voy a pensar.

Luego creo que tendría que dividir un número entre otro, pero siendo strings, y también tendría que hacer restas usando strings.

Quizá debería aprender a no prestar atención a asuntos ajenos. Probablemente. Pero mirar temas de foros parece algo normal.

En Quora, gente postea chistes, curiosidades de la historia, respuestas varias a preguntas de los usuarios... En general, nada me parece tonto, nomás bloqueé a uno que daba mensajes "espirituales" crípticos disfrazados de sabiduría y a otro no recuerdo exactamente por qué, algo como que daba información irrelevante o le ponía demasiada opinión suya con la que no estaba de acuerdo.

Acá, El_Andaluz postea, no cualquier cosa sobre guerras, pero muchas cosas sobre guerras ¿demasiadas? Para mí sí, considerando que es un foro de Informática y que en teoría no se puede opinar de política. Lo que postea sobre eso es generalmente casi todo noticias copiadas de otro lado, que quien quiera verlas las podría leer en otro lado, así que no entiendo para qué. Se puede decir que es un tema importante, preocupante, y que cada uno puede postear de lo que se le de la gana, pero a mí me choca que casi siempre se esté hablando de lo mismo, como si te tiraran el tema en la cara, una y otra vez, donde para colmo no se puede opinar casi y no parece que corresponda, por ser un foro de informática, no de guerras ni tan general como otros foros. No entiendo la intención, me parece incomprensible, esa manía de copiar cosas de guerra de un diario hacia un foro de informática.
También de vez en cuando postea videos de cosas paranormales. Que me hacen sentir más o menos lo mismo: ¿Para qué muestra videos random? ¿por qué tengo que leer sobre eso en un foro de informática? Se lee acá:
https://foro.elhacker.net/unread.html;all
y sí entro porque quiero creer que es algo importante, revolucionario, como pareció que fue lo de la esfera de buga, aunque pasó mucho tiempo y no la abrieron, así que quedó en probable farsa, pero ese video que puso sí estuvo bueno.

Por otro lado, Elektro publicó un tema donde casi que dice haber alcanzado la iluminación, la sabiduría, y hace muchas recomendaciones pero parece decir nada, que tienes que ver los videos enteros o leer los libros para poder opinar debidamente. Para mí si alguien tiene algo importante y sabio que decir lo debería poder resumir un poco, pero bueno, no quise creer que fuera una tontería, aunque ese no resumen inspira desconfianza. Leí un resumen, el señor que recomienda cree que la vida es un videojuego, un montaje de la consciencia para evolucionar.

Ante tanta "espiritualidad" en el foro, me pregunté: ¿Esta gente ha experimentado algo paranormal alguna vez o...?
Por eso en parte hice el tema preguntando si alguna vez experimentaron algo paranormal. Y me pareció interesante. Videos probablemente hechos para lucrar, no. Tampoco me gusta asustarme al pedo.

Electro me insultó más o menos, y el tema se desvió.

Ahora, hice este tema que están leyendo porque quería preguntar cómo se supone que evite que se desvíe si me insulta y casi cualquier cosa menos decir lo que más me interesaba. Si él cree que la vida es un videojuego o no sé qué cosa aparentemente paranormal, podría explicar por qué ¿ha tenido alguna experiencia que lo induzca a creer eso? No explicó. ¿Qué debo pensar? Probablemente nada, pero ese tipo de gente me cansa. Si tienen algo importante que decir, que lo digan, sino es como una burla, no sé explicarlo, como si uno tuviese hambre (de sabiduría) y estos tipos nos intentaran hacer ver que están comiendo, pero algo probablemente falso, que probablemente ni ellos se dan cuenta, así que siento una mezcla de rabia y pena.

Más allá de eso, no sé lo que quiero, explicar algunas cosas sí.

Y bueno, no quiero que se prohíban ciertos temas en el foro, ni quiero que la gente se dedique sólo a cosas "inteligentes", pero siento que algo está mal, que no encaja, puede que sea yo, que necesite unas vacaciones de las redes sociales, o de este foro, pero como digo en Quora es muy difícil que te llegue una notificación de un video random de YT de dudosa credibilidad, de cada puñetero ataque en una guerra, o si llegan, como los mensajes espirituales crípticos, se tiene la opción de bloquear, de ignorar.

Quizá, por ejemplo, podrían hacer que los temas del foro libre no aparezcan acá:
https://foro.elhacker.net/unread.html;all
o denme un link donde no aparezcan, aunque igual me siento un poco mal, se me olvida esto: ¿Por qué no hacen algo más importante o relacionado con la Informática? Avances en la IA por ejemplo. No sé, es como que siento que está mal que alguien pierda su tiempo viendo o leyendo "estupideces", no sé, porque lo que siento cambia a veces, me olvido qué era, yo puedo pensar, en teoría, que son unos locos e ignorarlos, pero los temas me aparecen en el link, así que los veo, no puedo ignorarlos... Además a veces me da como rabia que pierdan el tiempo en "estupideces" pudiendo hacer algo mejor, aunque claro no debo obligarlos, pero me molesta ser obligado a ver esos temas.

En mi barrio hay gente durmiendo en la calle, y varios más revisan contenedores de basura, buscando sobras de comida o algo que vender. Yo no me siento tan distinto. Muy cerca se reúnen unos hinchas de políticos a charlar. ¿Debería spamearles una y otra vez lo mal que está el país? No lo hago porque hacer propaganda, joder una y otra vez con lo mismo, me parece mal.

No sé, lamento si soy el problema, demasiado intolerante, intentaré no prestar atención a temas que no sean de informática aquí y no dar importancia a lo "no importante" que hagan otros, pero sería bueno, y quizá importante, que haya una mejora en el foro como para que nos llegue lo que nos interesa, y no lo que no. ¿Qué sentido tiene que se pueda publicar cualquier cosa y que a la gente le llegue cualquier cosa aunque no quieran?