Variable _level0.L2SaE10 está bien.
Variable _level0.L2SaE11 está bien.
Variable _level0.L2SaE12 no:

Ven que
  Variable _level0.L2SaE12 = [object #15]
es como un acceso directo a un array, no es uno independiente.

El error tiene que ver con EvaluarConocimientoSobreSEt1, la penúltima función:

// Signos en línea en tableros cuadrados:
// Este programa tiene básicamente ?????????????????????????????????????? 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,
// guardando en una nueva lista las nuevas situaciones (que no...
// sean victoria ni empate). Repetir con cada lista hasta la que...
// tenga situaciones en que sólo 1 acción es posible (por...
// ejemplo en el 3 en línea es 8).
// 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;
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 agregar una situación, aún no se dice cual:
L0SaE1 = [];
// A continuación se especifica cómo es, 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 = MaxCasillero;
// /////////////////////////////////////////////
// /////////////////  Etapa 1  /////////////////
// /////////////////////////////////////////////
// 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++;
	// Si las situaciones de la lista tienen más de 1 opción:
	if (NroDeListaRevisandose < LastListaDeEt1) {
		// Para evitar concatenar repetidamente:
		L_SaE = "L"+NroDeListaRevisandose+"SaE";
		NextL_SaE = "L"+(NroDeListaRevisandose+1)+"SaE";
		NroDeSExperimentandose = 1;
		// También para evitar concatenar repetidamente:
		// L_SaE_ = L_SaE+NroDeSExperimentandose;
		L_SaE_ = L_SaE+"1";
		// Usado en EvaluarConocimientoSobreSEt1 para...
		// nombrar las situaciones nuevas que se logren:
		SituacionesNuevas = 0;
		trace("Comienzan experimentos en una nueva lista, la "+NroDeListaRevisandose);
		PrepararSaE();
	} else {
		trace(	"La próxima lista tiene situaciones de sólo 1 opción; inicia la etapa 2.");
		// IniciarEtapa2();
		gotoAndStop(4);
	}
}
BuscarOtraListaEt1();
// Usada cuando se elege una SaE, en BuscarOtraListaEt1 y...
// BuscarOtraSituacionEt1:
function PrepararSaE () {
	trace("Ejecutando PrepararSaE");
	trace("Se inician experimentos en otra situación de la lista, la nro "+NroDeSExperimentandose);
	SituacionBase = eval(L_SaE_);
	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 BuscarSituacionesDistantes () {
	// 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.");
		BuscarOtraAccionEt1();
	}
}
// 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, y 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á BuscarSituacionesDistantes.
	} 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");
	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:
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();
	}
}

ChequearVertical y otras funciones que ella usa creo que son irrelevantes ahí así que no las puse.

Pero los traces parecen bien, dice:

// Copiar array (porque no se puede normalmente):
trace("Situación a copiar a "+NextL_SaE+SituacionesNuevas+" es "+Situacion);
set (NextL_SaE+SituacionesNuevas, Situacion.slice());

Si dice que la situación a copiar (Situacion) es v,v,0,X, debería generarse un array con eso, y le puse slice para que el array sea una copia y no un acceso directo (o el nombre que le corresponde), funcionó en todos los casos anteriores ¿qué pasa?

Hablando con GPT le plantié la posibilidad de que Macromedia Flash 5 esté limitado a 32 arrays, porque vean que llega hasta 31, que si se cuenta el 0 (si existe) son 32, y dijo que sí tiene problemas con eso pero puede que lo haya alucinado ¿qué pasa? ¿qué hago para averiguar el error?

Situacion, que es un array, en ese momento es v,v,0,X.

El nombre del array a crear es L2SaE12.

Quiero que se genere ese array, conteniendo una copia (independiente, no acceso directo) de Situacion.

El nombre se genera bien, pero el contenido es una copia acceso directo.

@_@


EDIT: No sé qué pasó que ahora me funciona:

Parece haber un array menos, no sé por qué, usando esto:
https://text-compare.com/es/

Lo único que vi de diferente es que puse como comentario esto y le cambié el valor:
// LastListaDeEt1 = Casilleros;

y:
 if (NroDeListaRevisandose < Casilleros) {
en vez de usar LastListaDeEt1, que cuando hice las pruebas no sé si lo tenía como MaxCasilleros o eso +1, pero no veo que sea relevante, eso sólo hace que se revisen más listas...

Tengo la versión anterior, que fallaba, voy a ver por qué la cantidad de arrays es distinta.

Porque al revisar una lista que no tiene situaciones, Situacion queda indefinida, no es un array, entonces es 1 menos.

¿Pero qué tiene que ver cuántas listas revisa con si graba bien una situación o no?

O sea, está revisando la lista 1, situación v,v,v,X.
Realizando la acción 2, llega a v,v,0,X.
Debe grabarla.

¿Por qué si revisa la lista 2 y/o 3 la variable se ve bien y sino no? No veo que tenga relación esa variable (cuántas listas se revisan) con cómo se graba una situación.

A ver gente:
Se hace esto:
   if (NroDeListaRevisandose < LastListaDeEt1) {
eso determina cuántas listas de situaciones se revisan.

Si al principio pongo que LastListaDeEt1 = 1
va a revisar sólo la lista 0, y la última situación nueva a la que llega es:
  Variable _level0.L1SaE4 = [object #19] [
    0:"v",
    1:"v",
    2:"v",
    3:"X"

Si en cambio le pongo 2, revisa hasta la lista 1 y me está funcionando bien:
 Variable _level0.L2SaE12 = [object #31] [
    0:"v",
    1:"v",
    2:"0",
    3:"X"
  ]
  Variable _level0.Svv0XBestAction = "Desconocida"
  Variable _level0.Svv0XTurno = "X"
  Variable _level0.Svv0XFirstAPosible = 0
  Variable _level0.Svv0XLastAPosible = 1

No tengo mucha idea de qué pasó, por qué antes no funcionaba y ahora sí, ah... si le pongo 3 ocurre el error ¿pero por qué? Lo pensaré.