Sobre ponerle IA ya hice un tema, en ese sentido no pregunto en este.

Tampoco sobre el modo conque chequea si hubo victoria.

Lo que pregunto tiene que ver conque quiero agregarle cosas, por ejemplo:
- Opción de que jueguen más de 2 jugadores.
- Si es posible, opción de casilleros con otras formas, de modo que la cantidad de direcciones posibles sea distinta a 8. Por ahora sólo vi de 6:
https://es.wikipedia.org/wiki/Teselado_hexagonal
- Opción de que no se gane por hacer una línea de signos requeridos, sino por ser quien haya hecho más cuando el tablero esté lleno.
- Opción de que se gane por tener la mayor cantidad de unidos, independientemente de cuan larga sea la línea. Aunque debo pensar si esto tendría gracia.
- Opción de que se gane por haber formado la línea más larga posible (puede ocurrir antes de que el casillero se llene).
- Opciones anti, como el antichess, o sea, que en vez de ganar por hacer una cosa u otra, eso lleve a perder.
- Opción de que se gane no por hacer una línea, sino alguna figura. Por ejemplo una L.
- Opción de que gane quien haga la figura más grande.
- Opción de que en vez de ser signos se pongan letras y gane quien 1ero forme una palabra.
- Que gane quien forme más palabras.
- Las letras a poner van rotando, el jugador no elige. Por ejemplo si hay que formar "Win".
- Al comienzo los jugadores se turnan en elegir una letra, luego empieza el juego poniéndolas según el orden conque las eligieron.
- Lo mismo pero en cualquier orden.
- Lo mismo pero puedes usar las letras de tu oponente.
- Repetición de letras se permite.

Y tal vez más... Algunas cosas no son excluyentes.

Algunas cosas quizá sea mejor hacerlas en un programa aparte, pero ya que son juegos tan similares sería bueno un "todo en 1" ¿no? Además no sé cuales debería hacer aparte, tal vez el que se puede poner letras y el que es sobre formar figuras. Serían 3. ¿Ustedes harían 3 juegos o más o menos?

Teniendo en cuenta todo eso, quisiera que mi código esté mejor preparado, porque intenté hacrlo eficiente pero en eso decidí hacerlo así nomás y por ahora está así. ¿Cómo lo mejorarían?

Imagen para referencia:


Frame 1:

CasillerosPorFila = 9;
JuntosRequeridos = 3;
MarcadorDeX = "Humano";
MarcadorDe0 = "IA";
Jugadores = "HumanoIA";
// Usado en el botón de quién marca con X:
function CambiarMarcadorDeX () {
	if (MarcadorDeX == "Humano") {
		MarcadorDeX = "IA";
	} else {
		MarcadorDeX = "Humano";
	}
	Jugadores = MarcadorDeX+MarcadorDe0;
	HacerTablero();
}
// Usado en el botón de quién marca con 0:
function CambiarMarcadorDe0 () {
	if (MarcadorDe0 == "IA") {
		MarcadorDe0 = "Humano";
	} else {
		MarcadorDe0 = "IA";
	}
	Jugadores = MarcadorDeX+MarcadorDe0;
	HacerTablero();
}
// Usado ahora y en general cuando se cambia la configuración de la partida:
function HacerTablero () {
	// Esto se irá especificando en el próximo while:
	Situacion = [];
	PosiblesAcciones = [];
	// Los casilleros se cuentan desde 0:
	MaxCasillero = CasillerosPorFila*CasillerosPorFila-1;
	// Las columnas también. Esto es para no repetir restas por ahí:
	MaxColumna = CasillerosPorFila-1;
	LargoDeCasilleros = 384/CasillerosPorFila;
	NroDeCasilleroaColocar = -1;
	// Sus columnas y filas se cuentan desde 0,
	// sirven para posicionarlos más fácil:
	Columna = 0;
	Fila = 0;
	do {
		NroDeCasilleroaColocar++;
		// v es vacío:
		Situacion.push("v");
		PosiblesAcciones.push(NroDeCasilleroaColocar);
		CasilleroaColocar = "Casillero"+NroDeCasilleroaColocar;
		// set ("SignoEn"+CasilleroaColocar, "v");
		// sCasillero tiene código:
		attachMovie("sCasillero", CasilleroaColocar, NroDeCasilleroaColocar);
		setProperty (CasilleroaColocar, _x, LargoDeCasilleros*Columna);
		setProperty (CasilleroaColocar, _y, LargoDeCasilleros*Fila);
		setProperty (CasilleroaColocar, _width, LargoDeCasilleros);
		setProperty (CasilleroaColocar, _height, LargoDeCasilleros);
		Columna++;
		if (Columna == CasillerosPorFila) {
			Columna = 0;
			Fila++;
		}
		// Para que al presionar el botón se sepa qué modificar:
		set (CasilleroaColocar+".CasilleroAsociado", NroDeCasilleroaColocar);
		// trace("Colocado el "+NroDeCasilleroaColocar);
	} while (NroDeCasilleroaColocar < MaxCasillero);
	// Para que no muestre el mensaje de victoria:
	Win = "No";
	// Esto es para evitar restas:
	LastNroDeAcccionPosible = PosiblesAcciones.length-1;
	trace ("LastNroDeAcccionPosible: "+LastNroDeAcccionPosible);
	SignoDeTurno = "X";
	if (Jugadores == "HumanoIA") {
		gotoAndStop(2);
	} else if (Jugadores == "IAHumano") {
		TurnoDeIA();
		if (Win == "No") {
// OJO QUE SI HAY EMPATE NO DEBE IR AL F2, O NO ES NEC
			gotoAndStop(2);
		}
	} else if (Jugadores == "HumanoHumano") {
		gotoAndStop(2);
	} else {
		// IA VS IA:
		InutilizarBotones();
		gotoAndStop(3);
	}
}
HacerTablero();
// Usada cuando el humano marca en un casillero:
function HumanoHaMarcado () {
	// trace("PosiblesAcciones.length: "+PosiblesAcciones.length);
	// trace("Humano ha marcado");
	// Inutilizar botón del casillero marcado:
	setProperty (eval("Casillero"+CasilleroMarcado+".Boton"), _visible, false);
	// Agregar signo:
	// SignosColocados++;
	eval("Casillero"+CasilleroMarcado).attachMovie("s"+SignoDeTurno, "Signo", 1);
	Situacion[CasilleroMarcado] = SignoDeTurno;
	// set ("SignoEnCasillero"+CasilleroMarcado, "X");
	// ¿Gana?
	// Si esta función dice que no, usa otras:
	ChequearVertical();
	if (Win == "Sí") {
		// Sí, inutilizar botones del tablero
		// (debería ser sólo los activos):
		InutilizarBotones();
		// Mostrar mensaje de victoria:
		attachMovie("sGano"+SignoDeTurno, "Mensaje", NroDeCasilleroaColocar+1);
		UbicarMensaje();
	} else if (PosiblesAcciones.length>=2) {
		// Sino, si aún hay >=2 acciones posibles
		// (la que usó aún no se quitó):
		// Quitar su acción de las posibles acciones:
		// Se busca en qué posición del array está:
		AccionRevisandose = -1;
		// Condición original: AccionRevisandose < LastNroDeAcccionPosible
		do {
			AccionRevisandose++;
			if (PosiblesAcciones[AccionRevisandose] == CasilleroMarcado) {
				// Se elimina la acción de la lista de posibles:
				PosiblesAcciones.splice(AccionRevisandose, 1);
				trace (PosiblesAcciones.join(""));
				break;
			}
		} while (true);
		LastNroDeAcccionPosible--;
		trace ("LastNroDeAcccionPosible disminuyó: "+LastNroDeAcccionPosible);
		// trace("PosiblesAcciones.length: "+PosiblesAcciones.length);
		CambiarSigno();
		if (Jugadores == "HumanoIA" or Jugadores == "IAHumano") {
			TurnoDeIA();
		}
	} else {
		// (sólo queda 1 acción en la lista,
		// pero es la que acaba de usar,
		// que debe borrarse, así que no quedan)
		trace ("Empate luego de que marcó el humano");
		// trace("PosiblesAcciones.length: "+PosiblesAcciones.length);
		Empate();
	}
}
// Usada en ChequeoHorizontal y requerida en otros chequeos:
function ObtenerColumnayFilaDelMarcado () {
	ColumnaDelMarcado = CasilleroMarcado%CasillerosPorFila;
	// trace ("Su Columna según el cálculo es: "+ColumnaDelMarcado);
	FilaDelMarcado = Math.floor(CasilleroMarcado/CasillerosPorFila);
	// trace ("Su Fila: "+FilaDelMarcado);
}
// Usada cuando alguien gana o en HacerTablero si es IA VS IA:
function InutilizarBotones () {
	BotonesInutilizados = -1;
	do {
		BotonesInutilizados++;
		setProperty ("Casillero"+BotonesInutilizados+".Boton", _visible, false);
	} while (BotonesInutilizados<MaxCasillero);
}
// Usada cuando hay que ubicar un mensaje, duh:
function UbicarMensaje () {
	setProperty (Mensaje, _x, 192.4);
	setProperty (Mensaje, _y, 192);
	// gotoAndStop (3);
}
// En caso de empate:
function Empate () {
	attachMovie("sEmpate", "Mensaje", NroDeCasilleroaColocar+1);
	UbicarMensaje();
	// Para que en el modo IA VS IA, la IA no juegue más:
	Win = "Sí";
	trace("Empate");
}
function CambiarSigno () {
	if (SignoDeTurno == "X") {
		SignoDeTurno = 0;
	} else {
		SignoDeTurno = "X";
	}
}
function TurnoDeIA () {
	// Elegir una acción al azar:
	NroDeAccionElegida = random(PosiblesAcciones.length);
	AccionElegida = PosiblesAcciones[NroDeAccionElegida];
	trace ("IA ha marcado: "+AccionElegida);
	// Eliminar la que está en el nro elegido:
	PosiblesAcciones.splice(NroDeAccionElegida, 1);
	trace (PosiblesAcciones.join(""));
	LastNroDeAcccionPosible--;
	trace ("LastNroDeAcccionPosible disminuyó: "+LastNroDeAcccionPosible);
	eval("Casillero"+AccionElegida).attachMovie("s"+SignoDeTurno, "Signo", 0);
	Situacion[AccionElegida] = SignoDeTurno;
	// Inutilizar el botón de ahí:
	setProperty (eval("Casillero"+AccionElegida+".Boton"), _visible, false);
	// Ver si IA ganó:
	CasilleroMarcado = AccionElegida;
	// trace ("JuntosRequeridos: "+JuntosRequeridos);
	ChequearVertical();
	// trace("PosiblesAcciones.length: "+PosiblesAcciones.length);
	if (Win == "Sí") {
		// Sí, inutilizar botones del tablero
		// (debería ser sólo los activos):
		InutilizarBotones();
		// Mostrar mensaje de victoria:
		attachMovie("sGano"+SignoDeTurno, "Mensaje", NroDeCasilleroaColocar+1);
		UbicarMensaje ();
	} else if (PosiblesAcciones.length == 0) {
		trace ("Empate luego de que marcó la IA");
		// trace("PosiblesAcciones.length: "+PosiblesAcciones.length);
		Empate();
	} else {
		CambiarSigno();
	}
}

ChequeoHorizontal lo que hace es fijarse si hay victoria. Si hay, hace que Win sea "Sí". Sino, llama a otros chequeos que hacen cosas parecidas. Pueden ver el código en mi otro tema reciente, pero como dije no es la cuestión aquí.

Frame 2:
stop();
Nada relevante aquí, simplemente ocurre el juego, el jugador hace clic en los casilleros. Los casilleros tienen un botón con esto:

Frame 3:
Aquí funciona el modo IA VS IA, un objeto tiene:

onClipEvent (enterFrame) {
	trace("SignoDeTurno: "+_level0.SignoDeTurno);
	_level0.TurnoDeIA();
	trace("Win: "+_level0.Win);
	if (_level0.Win == "No") {
		trace("SignoDeTurno: "+_level0.SignoDeTurno);
		_level0.TurnoDeIA();
		trace("Win: "+_level0.Win);
	}
	trace("Win: "+_level0.Win);
	// No va un else, esto es que si la IA ganó en su 1er turno o...
	// en su 2ndo, frana:
	if (_level0.Win == "Sí") {
		trace("Va al frame 2");
		_root.gotoAndStop (2);
	}
}

No me gusta mucho usar distintos frames pero parece la forma más eficiente de evitar ifs, evals, etc, no sé...

Aquí pueden ver a la máquina jugando al azar:
https://youtu.be/NtGWCFXvfk8

En vez de 4 en línea puede ser 3, 5, etc.

Lo que tengo no es suficiente y no lo apliqué:

// Signos en línea en tablero de Lado*Lado:
// Este programa tiene básicamente 2 etapas,
// que se pueden resumir así:
// 1:
// Desde la situación inicial probar las acciones,
// guardando las situaciones nuevas,
// y probando acciones en ellas también.
// Guardar las situación-acción que causan una victoria,
// y las que causan un empate. Es el RE de esa situación,
// resultado esperado (porque en otros casos es el que...
// se espera o supone si el rival juega bien).
// 2:		ACTUALIZAR ESTA
// En las situaciones no resueltas, probar las acciones.
// Si las consecuencias tienen RE, anotar cuantas de ellas...
// son victoria de X, 0 o empate y anotar la acción que...
// cause la RE más favorable, considerando secundariamente...
// las cantidades.
//
JuntosRequeridos = 2;
CasillerosPorFila = 2;
// Contando desde 0:
MaxColumna = CasillerosPorFila-1;
// Los casilleros están numerados así:
// 0 1 2
// 3 4 5
// 6 7 8
Casilleros = CasillerosPorFila*CasillerosPorFila;
MaxCasillero = Casilleros-1;
// Uso arrays porque es más fácil así modificar partes...
// de los valores de variables (los casilleros):
// Situación a experimentar nro 1, signo en los casilleros
// (a este array se le agregarán valores):
SaE1 = [];
ValoraAgregar = -1;
do {
	ValoraAgregar++;
	// v significa vacío
	SaE1.push("v");
	// trace("ValoraAgregar es "+ValoraAgregar);
} while (ValoraAgregar < MaxCasillero);
delete (ValoraAgregar);
// Situaciones a experimentar (cuántas son):
SaE = 1;
NroDeSExperimentandose = 0;
NoEvaluedSaE = "SaE1";
SaEEvaluedyJoined = "S"+(eval(NoEvaluedSaE).join(""));
// Usada para fácilmente saber de qué signo es turno:
set (SaEEvaluedyJoined+"Turno", "X");
// Con LastAPosible, usada para evitar probar...
// acciones innecesarias y saber si sólo queda 1:
set (SaEEvaluedyJoined+"FirstAPosible", 0);
set (SaEEvaluedyJoined+"LastAPosible", MaxCasillero);
// Usada a continuación y en varios casos:
function PrepararExperimentosEnOtraS () {
	// trace("Ejecutando PrepararExperimentosEnOtraS");
	NroDeSExperimentandose++;
	trace("Se inician experimentos en otra situación, la anotada nro "+NroDeSExperimentandose);
	// Usada para evitar concatenar repetidamente:
	NoEvaluedSaE = "SaE"+NroDeSExperimentandose;
	SituacionBase = eval(NoEvaluedSaE);
	SaEEvaluedyJoined = "S"+(SituacionBase.join(""));
	Turno = eval(SaEEvaluedyJoined+"Turno");
	FirstActionPosible = eval(SaEEvaluedyJoined+"FirstAPosible");
	LastActionPosible = eval(SaEEvaluedyJoined+"LastAPosible");
	Action = FirstActionPosible;
}
PrepararExperimentosEnOtraS();
// Usada en frame 2 repetidamente:
function BuscarBuenasSituacionesEt1 () {
	// 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:
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.");
		BuscarAccionEt1();
	}
}
// 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 == "Sí") {
		// Sí, crear datos sobre eso:
		// trace("Ganó, ahora se sabe que en la situación "+SituacionBase+" se gana usando la acción "+Action);
		set (SaEEvaluedyJoined+"BestAction", Action);
		set (SaEEvaluedyJoined+"RE", Turno);
		// Se borra la situación de la lista a experimentar,
		// pues ya se halló la mejor acción en ella:
		BorrarSaE();
		BuscarOtraSituacionEt1();
	} else if (FirstActionPosible == LastActionPosible) {
		// sino si es empate (no hay más acciones posibles):
		// Parecido, crear datos sobre eso:
		// trace("Empató, ahora se sabe que en la situación "+SituacionBase+" se empata usando la acción "+Action);
		// (y es la mejor acción porque no hay otra)
		set (SaEEvaluedyJoined+"BestAction", Action);
		set (SaEEvaluedyJoined+"RE", "Empate");
		// Se borra la situación de la lista a experimentar,
		// pues ya se halló la mejor acción en ella:
		BorrarSaE();
		BuscarOtraSituacionEt1();
	} else {
		EvaluarConocimientoSobreSEt1();
		// ¿Queda alguna acción sin probar...
		// en la situación?
		BuscarAccionEt1();
	}
}
// Usada luego de AplicarAccionEt1,
// si causa victoria o empate:
function BorrarSaE () {
	// La última SaE ponerla en la actual:
	// trace("ATENCIÓN: "+NoEvaluedSaE+", que es "+SaEEvaluedyJoined);
	set (NoEvaluedSaE, eval("SaE"+SaE).slice());
	// trace("...ahora es: "+eval(NoEvaluedSaE));
	// Borrar la última:
	delete (eval("SaE"+SaE));
	// Indicar que hay una menos:
	SaE--;
	// También se borran datos prácticos que ya no se usarán:
	// trace("SaEEvaluedyJoined: "+SaEEvaluedyJoined);
	// trace("SaEEvaluedyJoined+Turno: "+eval(SaEEvaluedyJoined+"Turno"));
	delete (eval(SaEEvaluedyJoined+"Turno"));
	// trace("SaEEvaluedyJoined+Turno: "+eval(SaEEvaluedyJoined+"Turno"));
	delete (eval(SaEEvaluedyJoined+"FirstAPosible"));
	delete (eval(SaEEvaluedyJoined+"LastAPosible"));
	// Indicar que vuelva a invertigarse la del número actual,
	// pues ahora es otra:
	NroDeSExperimentandose--;
}
// Usada luego de EvaluarAplicabilidadEt1,
// cuando una acción no es realizable:
function BuscarAccionEt1 () {
	// trace("Ejecutando BuscarAccionEt1");
	if (Action < LastActionPosible) {
		// Si queda alguna acción sin probar...
		// en la situación, probarla:
		Action++;
		// Se ejecutará BuscarBuenasSituaciones.
	} else {
		// trace("No hay más acciones realizables.");
		BuscarOtraSituacionEt1();
	}
}
// Usada luego de que hay victoria, empate o si no hay más acciones posibles:
function BuscarOtraSituacionEt1 () {
	// trace("Ejecutando BuscarOtraSituacionEt1");
	if (SaE > NroDeSExperimentandose) {
		PrepararExperimentosEnOtraS();
	} else {
		trace(	"No hay más situaciones a experimentar; inicia la etapa 2.");
		// IniciarEtapa2();
		gotoAndStop(4);
	}
}
// Usada en AplicarAccionEt1 cuando no hay victoria ni empate:
function EvaluarConocimientoSobreSEt1 () {
	// trace("Ejecutando EvaluarConocimientoSobreSEt1");
	SituacionJoined = Situacion.join("");
	NombreDeSituacion = "S"+SituacionJoined;
	ResumenDeBest = NombreDeSituacion+"BestAction";
	// ¿Se ha llegado antes a la situación?
	if (eval(ResumenDeBest) == undefined) {
		// No, anotar que debe investigarse:
		SaE++;
		// Copiar array (porque no se puede normalmente):
		set ("SaE"+SaE, Situacion.slice());
		// trace("Esa situación no está anotada; se anota como nro "+SaE);
		set(ResumenDeBest, "Desconocida");
		if (Turno == "X") {
			set (NombreDeSituacion+"Turno", "0");
		} else {
			set (NombreDeSituacion+"Turno", "X");
		}
		// Averiguar cual es su 1er acción posible:
		AccionRevisandose = -1;
		do {
			AccionRevisandose++;
			if (Situacion[AccionRevisandose] == "v") {
				set (NombreDeSituacion+"FirstAPosible", AccionRevisandose);
				break;
			}
		} while (true);
		// Averiguar cual es su última acción posible:
		AccionRevisandose = Casilleros;
		do {
			AccionRevisandose--;
			if (Situacion[AccionRevisandose] == "v") {
				set (NombreDeSituacion+"LastAPosible", AccionRevisandose);
				break;
			}
		} while (true);
	}
}
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 haya 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);
}

Resumen:


Mi idea con eso es hallar las mejores acciones en cada posible situación de un tablero de cierto tamaño cuando se requieren cierta cantidad de signos en línea, es decir, si por ejemplo en el "aprendedor" se configura que el tablero tiene 6 casilleros de largo y se requieren 5 signos en línea, el programa aprendería a jugar así, no en 5 casilleros de largo, ni 7, etc, ni con 6 signos requeridos, etc.
Así que en ese sentido no voy por buen camino, ya que no puedo correr el programa poniendo cada pares posibles de valores. Y aunque pudiera programar que los varíe, los resultados son de este estilo:
SvX0vBestAction = 0
es decir el nombre de la variable indica la situación, lo que sucederá es que serán un montón de variables con nombres cada vez más largos, es mejor algo más deductivo, unas reglas generales, siempre y cuando den buenos resultados.

La etapa 2 creo que debería tener en cuenta probabilidades, es decir, que cuando por ejemplo el resultado esperado es un empate, busque llegar a situaciones en que la mayoría de opciones del rival lo lleven a una derrota. Las probabilidades se basarían en la cantidad de opciones y las que salvan al rival, o a uno mismo (si el resultado esperado es derrota, aunque en este juego una IA no debería llegar a eso), no en cuan evidentes para un humano son las opciones mejores, porque eso parece subjetivo y complicado, ni lo intento.

Aún no tengo del todo claro cómo hacer la etapa 2. Y he estado cambiando cosas de la 1. En eso empecé a creer que en la etapa 1 debería guardar las posibilidades o en la 2nda no podría saber las probabilidades, o sería complicado. Creo que debería poner 3 etapas...
1- Se pueban acciones en las posibles situaciones, se van anotando las situaciones, y se anota "la mejor acción" y resultado cuando en la situación sólo hay 1 acción posible.
2- En las situaciones que quedaron sin resolver, se prueban acciones...

No sé bien... en ese punto una acción puede:
- Llevar a una situación resuelta, que luego será un empate o derrota.
- Llevar a una situación no resuelta.
- Llevar a una victoria.

Supongamos que está en:
0XX
XX0
0AB
Turno del 0.
Si pone en A, lleva a una situación resuelta, sólo queda una posible jugaba, B, y es empate.
Si pone en B, también es resuelta, pero es derrota.
Entonces deben crearse unas variables digamos así:
S0XXXX00vvWinX = 1
S0XXXX00vvEmpate = 1
marcando que en esa situación hay 1 posibilidad de que gane X y otra de que haya empate. La idea es que en la etapa 3, cuando haya que elegir cual es la mejor acción en una situación anterior a esta, cuando se llegue a esta se vea que X tiene 1/2 de probabilidad de ganar, aunque el resultado esperado sea empate, logrando entonces que el programa deduzca que para X es una situación más conveniente a llegar que otras, por ejemplo:
0CX
XX0
0AB
Turno de X. Si 0 juega bien, será empate, pero X poniendo en C o A tiene probabilidades de ganar, poniendo en B no.
Se trata de guardar posibilidades y luego guardar las acciones que lleven a situaciones en que haya más probabilidades de ganar.

Otra posibilidad es que lleve a una victoria, ejemplo:
0Xv
0Xv
vvv
Turno del X.
Lo que le conviene a X es evidente, pero... 0 debe tener en cuenta la posibilidad de que no haga eso. En tableros más grandes, puede que se deba elegir entre 2 situaciones inconvenientes, quizá en una X tiene 2 formas de ganar y en la otra sólo 1, por lo tanto debe grabarse la 2nda. Para eso debe haber datos sobre qué puede suceder, y por eso aunque la mejor acción aquí sea evidente, la situación no se puede resolver mientras no se tengan datos de las próximas, para saber exactamente qué tan probable es que gane X en esta (parece 1/5 pero es más complejo), para que previamente 0 pueda saber si esta situación es peor que otra alternativa, como expliqué.
Todo esto es como muy rebuscado, creo que sólo tiene sentido en tableros grandes. Normalmente la IA no llegaría a situaciones en que pueda perder. A ver un caso más realista:
vvvv
vXvv
vvvv
vvvv
Turno de 0, se requieren 3 para ganar. Parece que no importa lo que haga, perderá, pero la idea es que tenga las mayores probabilidades posibles de ganar o al menos empatar.

En fin, parece que entonces es cuestión de ir hacia atrás, en orden, es decir, resolver 1ero las situaciones en que sólo 1 acción es posible, luego las que sólo tienen 2, etc. Aunque en algunas sea obvio cómo ganar, no se pueden considerar resueltas antes de tiempo. Así que sería:
Etapa 1: Las acciones pueden llevar a situaciones nuevas, no resueltas, empates o victorias.
Etapa 2: Las acciones pueden llevar a situaciones no resueltas, resueltas o victorias.
Etapa 3: Las acciones pueden llevar a situaciones no resueltas o resueltas.
Considero importantes las diferencias para evitar ifs en vano...

Una posible mejora del programa sería, en vez de partir de un tablero vacío e ir grabando situaciones a las que se llegue, generar las posibles situaciones finales, resolverlas, generar las situaciones previas, resolverlas, y así. O en vez de tener 1 lista de situaciones, tener una por cada cantidad de signos puestos, o sea:
Una lista de situaciones en que sólo 1 acción es posible.
Otra en que sólo 2 acciones son posibles.
Etc.
Son mejoras alternativas. Sirven para evitar que el programa analice repetidamente situaciones que sabemos que aún no podrá resolver.

¿Ustedes cómo lo harían? Un programa que aprenda a jugar expertamente Signos en línea.

¿Me puedes explicar mejor dónde o cómo lo viste? Hace casi 2 meses que espero me responda un asunto y tampoco lo he visto postear en el foro.

¿O tu comentario es un sarcasmo/bait?

En otro tema preguntas qué pasó con el foro. Yo participo desde hace unos 10 7 años creo, no lo noto tan distinto. Antes no sé, pero no es poco común que un foro pierda actividad, las causas no las sé, en mi caso que me borraron comentarios sin explicación. Ahora postié porque es un caso especial ya que dijiste que viste al admin, pf, espero que sea cierto.

¿Y tú por qué te fuiste? Quejarse es fácil pero por haberte ído eres, probablemente, parte del culpable de que el foro haya perdido actividad o calidad según tu criterio.

Ni siquiera ha posteado en algún tema, o no lo he visto.

Hace poco he tenido días difíciles así que no estoy de ánimo para luchar por un foro más justo, si es que al admin le interesa, o para entender qué pasa con algún moderador o algunos, que me borra/n mensajes injustamente y sin explicar, pero, dejo este comentario, que quizá sea borrado también, meh, pero algún usuario lo verá:

Si quieren decirle algo al admin, mejor por email, quizá, es un consejo.

Yo es que paso de hablar por email con un hacker.

Mi idea era que él me explique o solucione el problema y luego seguir participando en el foro. Pero al parecer está muy ocupado, complicado, o no le interesa lo suficiente mi asunto o lo que pasa en su foro. O a lo mejor es una fachada y en realidad es de algún moderador.

No quiero hacer aportes a un foro que es injusto conmigo.

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

La cantidad de casilleros por fila y columna es configurable.

La cantidad de contiguos para ganar, también.

Pero por ahora quiero resolver el caso de 2 contiguos simplemente.

La situación se guarda en un array, es decir lo que tiene cada casillero, por ejemplo esta:
vv0
vXv
vvv
Es: v, v, 0, v, X, v, v, v, v
donde v es vacío

Mi idea es que, cuando un casillero se marque, se mire arriba, luego arriba-derecha, y así sucesivamente como las agujas de un reloj.

El reto es averiguar qué casillero en el array es el de arriba, y demás. Y si es que existe, sino capaz que mira alguno que no debe, no sé.

Si por ejemplo el casillero marcado es el nro 0, el de arriba no existe, el de arriba-derecha tampoco, el de la derecha es su +1...
Pero si se marca el nro 2, el de su derecha no es el +1, sino que no existe.

Quizá la mejor forma de resolver esto es creando variables estilo:
Casillero0_0 = "v"
Casillero1_0 = "v"
Casillero2_0 = "0"

Pero entre más grande sea el tablero, más variables así habría y son una copia de las otras así que no parece buena idea.

Debe haber una forma de calcular en qué posición del array está el casillero contiguo que se quiere mirar ¿cómo?

Intento hacer una IA que aprenda a poner una X en un tablero y luego otra en la derecha o izquierda.

El problema que intento resolver en cuanto a eso, es que puede poner una X donde ya hay, debo evitarlo.

Sé que debo poner algo como:
Pero no sé bien qué pasa, es como que si hago eso tendría que poner código igual en distintos lados (aunque a ese código lo convierta en una función, siento que es innecesario que se repita), innecesariamente.

Aún no tengo el código completo. Díganme cómo pondrían uds ese if, dónde, o cómo harían.

// 2 en línea horizontal, en tablero de 2x2, sólo X:
// 
// Uso arrays porque es más fácil así modificar los nombres...
// de variables:
// 
// Los casilleros están numerados así:
// 0 1
// 2 3
// Situación inicial (v es casillero vacío):
SituacionBase = ["v", "v", "v", "v"];
// Ponerla en la lista de situaciones a experimentar:
SaE1 = SituacionBase.slice();
// Situaciones a experimentar (cuántas son):
SaE = 1;
NroDeSExperimentandose = 1;
NombreDeSE = "S"+(SaE1.join(""));
// Acción a realizarse (casillero a marcar):
Action = 0;
function BuscarAccionesGanadoras () {
	PlantearSyActuar();
	// ¿Ganó?
	// Para averiguarlo, calcular fila (contando desde 0):
	Fila = Math.floor(Action/2);
	// trace("	Fila: "+Fila);
	if (Situacion[Fila*2] == Situacion[Fila*2+1]) {
		// trace("Situacion[Fila*2] == Situacion[Fila*2+1]: "+Situacion[Fila*2]+" == "+Situacion[Fila*2+1]);
		// Sí, crear datos sobre eso:
		// En la situación base conviene la acción realizada:
		set (NombreDeSE+"BestAction", Action);
		// En esa situación se requiere 1 acción para ganar:
		set (NombreDeSE+"DistanciaaGanar", 1);
		trace("Ganó, ahora se sabe que en la situación "+SituacionBase+" se gana usando la acción "+Action);
		// ¿Aún hay situaciones a experimentar?
		if (SaE > NroDeSExperimentandose) {
			IniciarExperimentosEnOtraS();
		} else {
			// Comenzar la etapa 2.
			IniciarEtapa2();
		}
	} else {
		EvaluarConocimientoSobreSyEtc();
	}
}
function PlantearSyActuar () {
	// 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);
	// Aplicación de la acción:
	Situacion[Action] = "X";
	trace("	Se realizó la acción "+Action+"; ahora la situación es "+Situacion);
}
function IniciarExperimentosEnOtraS () {
	NroDeSExperimentandose++;
	SituacionBase = eval("SaE"+NroDeSExperimentandose);
	// trace("SituacionBase: "+SituacionBase);
	// Reset de la acción a probar:
	Action = 0;
	trace("Se inician experimentos en otra situación");
}
function IniciarEtapa2 () {
	DistanciaaGanarAceptada = 1;
	trace("Se experimentaron todas las situaciones; se reexperimentarán buscando resultados menos óptimos");
	trace("Son "+SaE+" situaciones; se acepta que la distancia a la victoria sea "+DistanciaaGanarAceptada);
	gotoAndStop (3);
}
function EvaluarConocimientoSobreSyEtc () {
	SituacionHechaTexto = Situacion.join("");
	NombreDeSituacion = "S"+SituacionHechaTexto;
	Resumen = NombreDeSituacion+"BestAction";
	if (eval(Resumen) == undefined) {
		// No, anotar que debe investigarse:
		SaE++;
		set ("SaE"+SaE, Situacion.slice());
		trace("Esa situación no está anotada; se anota como nro "+SaE);
		// Esto para saber que está anotada:
		set (Resumen, "Desconocida");
	}
	// ¿Queda alguna acción sin probar?
	if (Action < 3) {
		// Sí, probar otra:
		Action++;
	} else if (SaE > NroDeSExperimentandose) {
		// Sino si aún hay situaciones a experimentar:
		trace("No hay más acciones posibles en la situación");
		IniciarExperimentosEnOtraS();
	} else {
		// Comenzar la etapa 2.
		IniciarEtapa2();
	}
}

Ah, BuscarAccionesGanadoras se repite hasta que empiece la etapa 2.

Así funcionaba:

function HacerTablero () {
	MaxCasillero = CasillerosPorFila*CasillerosPorFila;
	LargoDeCasilleros = 384/CasillerosPorFila;
	CasillerosColocados = 0;
	// Sus columnas y filas se cuentan desde 0,
	// sirven para posicionarlos más fácil:
	Columna = 0;
	Fila = 0;
	do {
		CasillerosColocados++;
		CasilleroaColocar = "Casillero"+CasillerosColocados;
		// v es vacío.
		set ("SignoEn"+CasilleroaColocar, "v");
		// sCasillero tiene código.
		attachMovie("sCasillero", CasilleroaColocar, CasillerosColocados);
		setProperty (CasilleroaColocar, _x, LargoDeCasilleros*Columna);
		setProperty (CasilleroaColocar, _y, LargoDeCasilleros*Fila);
		setProperty (CasilleroaColocar, _width, LargoDeCasilleros);
		setProperty (CasilleroaColocar, _height, LargoDeCasilleros);
		Columna = Columna+1;
		if (Columna == CasillerosPorFila) {
			Columna = 0;
			Fila = Fila+1;
		}
		// Para que al presionar el botón se sepa qué modificar:
		set (CasilleroaColocar+".CasilleroAsociado", CasillerosColocados);
	} while (CasillerosColocados<MaxCasillero);
}

Intenté poner que se cuenten desde 0 en vez desde 1 (o sea, que en vez de Casillero1, Casillero2, etc, sean Casillero0, Casillero1, etc) y ahora anda mal, pone uno menos y además lo borra mal (eso es otro tema):

function HacerTablero () {
	// Esto se irá especificando en el while:
	Situacion = [];
	PosiblesAcciones = [];
	// Los casilleros se cuentan desde 0:
	MaxCasillero = CasillerosPorFila*CasillerosPorFila-1;
	LargoDeCasilleros = 384/CasillerosPorFila;
	NroDeCasillerosaColocar = -1;
	// Sus columnas y filas se cuentan desde 0,
	// sirven para posicionarlos más fácil:
	Columna = 0;
	Fila = 0;
	do {
		NroDeCasilleroaColocar++;
		// v es vacío:
		Situacion.push("v");
		PosiblesAcciones.push(NroDeCasilleroaColocar);
		CasilleroaColocar = "Casillero"+NroDeCasilleroaColocar;
		// set ("SignoEn"+CasilleroaColocar, "v");
		// sCasillero tiene código.
		attachMovie("sCasillero", CasilleroaColocar, NroDeCasilleroaColocar);
		setProperty (CasilleroaColocar, _x, LargoDeCasilleros*Columna);
		setProperty (CasilleroaColocar, _y, LargoDeCasilleros*Fila);
		setProperty (CasilleroaColocar, _width, LargoDeCasilleros);
		setProperty (CasilleroaColocar, _height, LargoDeCasilleros);
		Columna = Columna+1;
		if (Columna == CasillerosPorFila) {
			Columna = 0;
			Fila = Fila+1;
		}
		// Para que al presionar el botón se sepa qué modificar:
		set (CasilleroaColocar+".CasilleroAsociado", NroDeCasilleroaColocar);
		trace("Colocado el "+NroDeCasilleroaColocar);
	} while (NroDeCasilleroaColocar<MaxCasillero);
}

Si el tablero es de 3*3, se deben colocar 9, pero el máximo será 8 porque se cuentan desde 0. Y puse que el 1er colocado sea el 0. Pero el trace no lo indica, el 1er trace es del 1:
Colocado el 1
Colocado el 2
...
Colocado el 8

¿Qué pasa?

Edit: Creo que era una s de más, sorry >___<

NroDeCasillerosaColocar = -1;
debe ser:
NroDeCasilleroaColocar = -1;

Pregunta a los de Insta si hay una opción para ver cómo se ha ingresado últimamente. Desde qué dispositivo, Windows, IP, esas cosas.

El siguiente link tiene un exe, un fla que es el archivo editable, y un swf que es como un exe menos peligroso pero sólo sirve si tienen Flash Player.
Actualización de acuerdo al momento en que el post fue editado: 25-01-15, 16:18
https://drive.google.com/file/d/17Mn04J7GUnn4CGaqjnE70UeGHISAVqbN/view?usp=sharing

Nota: Al cliquear un dibujo, muta.

Errores conocidos que intentaré arreglar más adelante:

1: La flecha de abajo que apunta a la izquierda, cuando se usa en la 1er pantalla quiero que lleve a las opciones de la última, pero aún no existe, así que está mal, no la usen en la 1er pantalla, saca las opciones y el programa se vuelve inusable.

2: Los botones de colores en la 2nda pantalla (flecha de abajo que apunta a la derecha) no deberían estar ahí. No los usen porque aún no llegué a arreglar esa parte, esos botones quedaron ahí por error.

3: No hay 3era pantalla así que tocar dos veces el botón de la derecha es mala idea.

4: Si habiendo X colores definidos (por ejemplo 3) se define uno salteando intermedios (por ejemplo habiendo 3, se define el 5), entonces al producirse los dibujos los colores intermedios serán negro.
Solución planeada: Se elegirán colores al azar para esos.

5: Aparentemente, si mientras se generan los dibujos señalas un botón de colores preestablecidos y quitas el mouse antes de que el proceso termine, el botón quedará parpadeando. Es un efecto que debería ocurrir sólo mientras el mouse apunta al botón, pero como el programa estaba haciendo otras cosas no notó que el mouse se fue de ahí, supongo. En PC rápidas posiblemente no ocurra por poca cosa, tendrían que aumentar la cantidad de dibujos y cuadraditos, tal vez.

6: Puede que se vean pequeñas líneas entre los cuadraditos, como si no ocuparan todo el espacio que deben. Un problema del largo y ancho supongo, que es calculado, si el resultado es en decimales ya saben que pueden pasar ese tipo de cosas.

7: Si bajas la cantidad de cuadraditos por fila, la mínima cantidad de colores requeridos debe bajar, porque si por ejemplo es 3 pero sólo hay 2 cuadraditos pintables (el resto son simétricos), entonces podrá haber 3 colores en el dibujo. Eso se corrige pero la corrección hace que a partir de ahí el último color definido se elimine, o se deje de usar, aunque en el la pantalla se vea que está definido.

8: Si agregas un color, luego aumentas la cantidad de mínimos requeridos, y luego bajas la cantidad de cuadraditos por fila, el programa se tranca por lo que expliqué en el punto anterior. No sé por qué no lo corrige en este caso.

Estoy corrigiendo, me toma tiempo...

Sirvió, tema resuelto.


Songoku, te muestro.

Luego de tomar una foto que quería, quedó así:

La podría tomar de otro modo pero ya había tomado 4 así, además no creí que fuese un problema.

A las 4 las moví hacia arriba (con flechas) para que desapareciera el menú de arriba y quedara justito donde empieza el cuadro donde está la imagen, una cosa blanca y gris que se ve poco:


Ahora tenía que quitar todo lo de abajo, de modo que la imagen termine justito donde termina el cuadro que te comenté, así (esta es otra foto pero sirve para que se entienda):


Usando el mouse, no es fácil. Te pasás un pixel para un lado u otro, yo al menos sí, por más que ponga zoom. Poner un número como se mostró, es más fácil.

EdePC, al intentar eso me pone esto:

Pero tengo 160 GB libres, no sé. ¿Falta de ram?

Pero al intentar descargarla me descarga una página dice, no me dice que es un gif, me dice Chrome HTML document.

Vivo en Uruguay.