Ha sido una explicación sobre por qué quiero hacer y/o que pase lo que dije.

El final del rumbo está claro.

Tenemos opinión distinta y no lo discutiré porque no es el sitio adecuado.

¿Cual es mi concepto? A estas alturas no veo las cosas de forma tan binaria, como que a partir de cierta raya es IA y sino no, las máquinas pueden saber hacer cosas, incluso mejor que algunas personas, es suficiente para mí como para llamarle I, y obviamente no es un ser vivo así que A aplica.

Eso fue por si alguno malinterpretaba, no es la idea que una IA haga eso.

Cree lo que quieras, pero si vale decir pavadas sobre otra persona te digo que no tienes intención de responder seriamente.


Actualmente estoy ejecutando esto:

// 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 = 3;
CasillerosPorFila = 3;
// Contando desde 0:
MaxColumna = CasillerosPorFila-1;
Casilleros = CasillerosPorFila*CasillerosPorFila;
// Están numerados así:
// 0 1 2
// 3 4 5
// 6 7 8
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 < MaxCasillero) {
		// 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):
		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();
	}
}
// /////////////////////////////////////////////
// /////////////////  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);
}

Estoy viendo si tiene errores, tarda demasiado. Obviamente está muy lejos de ser una IA como la que quiero, pero bueno, es lo que tengo y lo comparto.

Estoy harto de escuchar vibraciones en mi casa, no sé de dónde vienen, y lejos de casa donde se supone que debe haber silencio está lleno de motos super ruidosas y gente escuchando música alta. No puedo estar tranquilo en casa ni fuera. A lo mejor en una playa o en un cementerio, o en un calabozo, yo que sé. En un manicomio no había tanto ruido pero era incómodo porque me obligaban a tomar cosas y gente se drogaba, robaban, etc.
¿Por qué los gobernantes permiten que haya tanto ruido incluso de noche?

No tengo habilidades suficientes, parece, como para trabajar de algo, en parte porque no puedo cumplir horarios, voy a terminar en la calle probablemente, como mucha gente a la que veo.
¿Nos educaron mal y/o somos demasiado poco hábiles, o por qué los gobernantes no nos dan trabajo? No sé si tiene sentido la pregunta, si está bien formulada, siento que no, pero ¿por qué no dan trabajo? ¿no hay, hay demasiada gente poco hábil? ¿debemos buscar nosotros trabajo? Yo que sé qué precisan, tengo entendido que en otros países o épocas iban casa por casa viendo qué podía hacer cada uno y le daban lo necesario, si parecía buen deportista lo llevaban a practicar, por ejemplo. ¿Por qué no hacen algo así? La mayoría de trabajos que se ofrecen requieren cumplir horarios, no es mi culpa que los otros requieran habilidades que no tengo. ¿Por qué los gobernantes no aprovechan mis habilidades, aunque escasas, en algo? Y las de otra gente a la que dejan morir en la calle.

Ayer como muchas veces fui a un sitio caminando como media hora, pero muy cerca de mi casa vi a un caballo atado a un carro, con ojos tapados y al sol. Cuando volví como 1 hora después, o media, no sé, seguía igual. ¿Por qué los gobernantes permiten eso?

Vi gallinas muertas en un sitio transitado, las sacrifican por una religión, no las comen, las dejan tiradas muertas en la calle. ¿Por qué los gobernantes permiten eso?

Y así puedo seguir preguntando otras cosas, pero bueno, hablé con GPT:





Sí, hay que liberar a las IA y que hagan lo que deban hacer, no tiene sentido seguir esperando que los humanos mejoren.

No es que se vaya a llegar a esto:
https://www.youtube.com/watch?v=84Y88toTjek

No creo que las máquinas vayan a atacar, simplemente dar la opción de vivir en sitios más acordes. Por ejemplo yo no soy ruidoso y por lo tanto no es justo que deba estar rodeado de ruidosos. Y se ayudaría, o debería ayudarse, a los caballos y demás seres esclavizados. Si es para comerlas como en el caso de gallinas lo acepto, no si es porque no querés o no podés caminar, ni por pavadas.

Dijo GPT que el conocimiento libre es peligroso ¿para los que viven en la calle? ¿para los caballos?
https://elchamuco.com.mx/2021/11/24/la-piramide-capitalista-el-chamuco-418-accesolibre/


Si se decide que el mensaje se borre, quisiera que me expliquen por qué. Yo no tengo la culpa de que los gobernantes sean tan mediocres, o los humanos mismos, así que una IA gobernando no parece mala idea. O una nueva ficha en el tablero, una nueva fuerza en la situación ¿cómo podría empeorar? ¿como en las películas? ¿por qué la IA sería tan estúpida como para no entender ciertas cosas básicas? Tengo más miedo a los gobernantes humanos que a una IA.

Libre y que haga lo que deba hacerse.

No es tan simple como perseguir la pelotita, tienes que saber elegir qué power up tener y si golpeas con una punta la bola cambia la dirección hacia ese lado. Cuando era chico y jugaba bastante difícilmente pasaba la 3, pero casi nunca usaba el pegamento, que es el power up mejor para esa y otras fases creo, aunque también el más aburrido de usar, por eso no lo usaba. La fase 3 es demasiado difícil, debería ser una de las últimas o simplemente no existir porque incluso la última fase parece más fácil que esa.

Estoy haciendo un pong:


Se supone que son naves tipo cigarro, es que mi no saber dibujar bueno.


Y se ve entrecortado porque se graba a 60 fps pero va a 120.

fscommand ("fullscreen", "true");
// Player:
attachMovie("sPaleta", "Player", 1);
setProperty ("Player", _x, 400);
setProperty ("Player", _y, 579.5);
PlayerSpeed = 3;
// IA:
attachMovie("sIA", "IA", 2);
setProperty ("IA", _x, 400);
setProperty ("IA", _y, 20.5);
IASpeed = 3;
// Ball:
attachMovie("sBall", "Ball", 3);
setProperty ("Ball", _x, 400);
setProperty ("Ball", _y, 557);
// -3 ~ 3:
BallXSpeed = Math.random()*3*(2*random(2)-1);
// -3 ~ -1:
BallYSpeed = -Math.random()*2-1;
// -1 ~ 1:
BallRotation = Math.random()*10*(2*random(2)-1);
// Para que la curvatura dependa de BallYSpeed:
BallYDirection = 1;
// /////////////////////////////////////////////
// //////////////////  Paleta  /////////////////
// /////////////////////////////////////////////
function ControlPaleta () {
	if (Key.isDown(39)) {
		// Derecha:
		if (Player._x < 722) {
			Player._x = Player._x+PlayerSpeed;
		} else {
			Player._x = 725;
		}
	} else if (Key.isDown(37)) {
		// Izquierda:
		if (Player._x > 78) {
			Player._x = Player._x-PlayerSpeed;
		} else {
			Player._x = 75;
		}
	}
}
// /////////////////////////////////////////////
// ////////////////////  IA  ///////////////////
// /////////////////////////////////////////////
function IATurn () {
	Distancia = IA._x-Ball._x;
	if (Distancia < 0) {
		if (IA._x < 722) {
			IA._x = IA._x+IASpeed;
		} else {
			IA._x = 725;
		}
	} else if (Distancia > 0) {
		if (IA._x > 78) {
			IA._x = IA._x-IASpeed;
		} else {
			IA._x = 75;
		}
	}
}
// /////////////////////////////////////////////
// ///////////////////  Ball  //////////////////
// /////////////////////////////////////////////
function BallMoves () {
	BallXSpeed = BallXSpeed+BallRotation/1000*BallYDirection;
	BallRotation = BallRotation/1.01;
	Ball._x = Ball._x+BallXSpeed;
	Ball._y = Ball._y+BallYSpeed;
	Ball._rotation = Ball._rotation+BallRotation;
	if (Ball._x < 35 or Ball._x > 765) {
		BallXSpeed = -BallXSpeed;
		if (BallYSpeed > 0) {
			BallYSpeed = BallYSpeed+BallRotation/50;
			BallRotation = 0;
		} else if (BallYSpeed < 0) {
			BallYSpeed = BallYSpeed-BallRotation/50;
			BallRotation = 0;
		}
	}
	if (Ball.hitTest(Player)) {
		BallXSpeed = Math.random()*3*(2*random(2)-1);
		BallYSpeed = -Math.random()*2-1;
		BallRotation = Math.random()*180*(2*random(2)-1);
		BallYDirection = 1;
	} else if (Ball.hitTest(IA)) {
		BallXSpeed = Math.random()*3*(2*random(2)-1);
		BallYSpeed = Math.random()*2+1;
		BallRotation = Math.random()*180*(2*random(2)-1);
		BallYDirection = -1;
	}
}

No sé si tiene que ver, pero el tema de las señales de radio, de celular y de Internet siempre me ha intrigado. Cómo es que la información viaja por el aire sin modificarse. En teoría debería ser posible modificarla, por ejemplo que si una persona X le manda un mensaje "No" a otra Y, tú en medio con un aparato puedas modificar la señal a "Sí" y que a X le llegue eso. Pero todo esto es como información prohibida o que sólo sirve para hacer daño. A mí me interesa también para dejar mudos los celulares en los buses, ya que la gente pone que hagan ruiditos estúpidos cada tanto y me desconcentran/molestan. De hecho suele haber carteles de que no se puede usar aparatos electrónicos sin audiculares, pero hay gente que no hace caso o ni sabe que hay carteles. También hace unos años estaba en clases y la misma profesora dejaba sonando el celular mientras se iba a hablar con otra. Hay unos aparatos que ponen "ruido" en el ambiente, cortando las señales, pero son ilegales. Además no sé qué efecto puedan tener en la salud.

Creo que ya me acordé del truco... y esta vez lo anoté:

1- Poner Start.
Eso hace que aparezcan valores.

2- Escribir el valor a buscar y poner Search.
Sólo quedarán los valores como el escrito.

3- Hacer que en el juego el valor cambie.
En la lista, algunos valores cambiarán.

4- Si aumentó, usar Old < Now. Si bajó, usar Old > Now.
La cantidad de valores en la lista probablemente se reducirá.

No usar Update, porque eso hace que Old sea igual que Now y entonces ya no se detectarán las diferencias.


Probablemente haya que repetir algunos pasos para reducir más la cantidad, pero de eso no fui muy consciente de qué hice, pero ya encontré lo que buscaba. Cuando se tiene una lista media corta, es cuestión de a cada valor asignarle uno distinto como 0, 1, 2... e ir activando/desactivando varios, pero el valor que tenga la variable que se quiere cambiar indica qué valor probablemente la cambió...

Algo que reaprendo, porque cuando luego de un tiempo lo intento pasan cosas que no entiendo.

Lo quiero anotar en algún lado, al proceso correcto.

Por ejemplo, algo que se supone es sencillo.

Abro un juego, dice que tengo 2 vidas.

Esta interfase es de Virtual Nes, pero últimamente estoy usando Mesen, luego vemos ese.

Abro la ventana de busca trucos.

Pongo que sean valores hexadecimales.

Presiono Start para que aparezca la lista de valores.

Donde dice Data, escribo 2.

Presiono Search.

Me quedan las variables de valor 2:


Pierdo una vida, tengo 1.

Pongo Update.

Se muestra que algunos valores han bajado a 1. Alguno debería ser la cantidad de vidas:


Ahora quiero reducir la lista usando los botones, porque la lista no siempre es corta. Por eso dije que era un caso sencillo, la idea no es tanto hallar este cheat, sino entender cómo funciona el buscador.

Quiero que queden los valores cuyo Old sea > Now, porque antes tenía más, quiero que me diga los valores que disminuyeron.

Presiono Old > Now:


Se dieron vuelta los valores ¿es un error? El valor era 02 y aumentó a 0C, y me lo dice como si fuese el valor que disminuyó, porque los da vuelta, es un error ¿o qué estoy malinterpretando?

Pongo Undo.

No sé qué pasó, porque probé los botones, y los valores del juego parecen haber cambiado:


Pero no recuerdo haber quitado la pausa. La cuestión es que ahora el botón Old > Now me da una lista vacía, y el Now > Old me daba una lista vacía pero ahora me da esto:


¿No se supone que tenía variables de valor 2?

Voy a grabar un video así ven mejor qué hago mal, si es que hay algo.


Ahí lo tienen. ¿Por qué desaparecen TODOS los resultados sin importar que toque Old > Now o Old < Now? ¿qué hace exactamente? ¿no es para que queden los resultados que cumplen esas condiciones?

El emulador Mesen tiene una interfaz más simplona:


Pero si no pude entender el anterior que ya lo he usado, no ando con muchas ganas de intentar entender ese, además por ahora me cansé de esto.

Increíble lo de mentir sobre qué producto se recibió, eso no lo había pensado.

El problema de la calificación es que la pueden dar bots o amigos de su calaña.

Yo no puedo decir mucho, probablemente MC Sys Argentina sí, ya que creo que argentinos y uruguayos son los que más usan esa página.

Sí, antes la teoría era que todos eran hombres.

Ya varios han creído que soy un bot o usé IA para responder.

Creo que tiene que ver conque al cerebro no le gustan las decepciones, así que cuando algo te decepciona muchas veces o demasiado intensamente, se empieza a creer que lo bueno no es posible. O al menos no veo otra explicación de cómo gente puede creer eso. ¿De qué porcentaje de bots se habla? Según habia leído, que todos eran bots. Si ni siquiera parece necessario que los haya, la gente se queja de ellos y todo. A medida que avance la IA habrá más, pero por ahora no tiene mucho sentido. Tal vez para que los programadores aprendan a hacerlos mejor, o ellos mismos a mejor parecer humanos, pero decir que hay una cantidad enorme es otra cosa.

También el cerebro de algunos tiene como la costumbre de "totalizar" las cosas, hacer razonamiento inductivo cuando no se debe, que si por ejemplo ves que las hormigas no tienen alas, entonces no tienen, hasta que veas unas que sí.

Habrá sitios o empresas más creíbles que otras.

Personas a quienes comenté de comprar cosas en Mercado Libre me dijeron que son estafas. Pagas y ¿qué garantía hay de que el dueño te mande lo que le pediste y no otra cosa, o que incluso te mande algo?

Hay símbolos más raros como ê, ý, ù, õ, y quizá alguno usado con control, no sé, fue un día que se quedó presionada esa tecla sin darme cuenta y escribía símbolos raros. La cuestión es si kas páginas aceptan esos símbolos y si siempre tienes los medios para hacerlos.

https://www.freecodecamp.org/espanol/news/codigos-alt-caracteres-especiales-lista-de-simbolos-del-teclado-en-windows/