Estoy usando un método que me ha gustado bastante pero tiene un defecto que quisiera me ayuden a evitar, o que me digan un método mejor.

Lo que estoy listando son posibles variables en juegos sencillos y el método es que estoy usando es:
Paso 1: Se escriben las posibilidades más básicas en la columna 1.
Paso 2: En la cabeza de la columna 2 se escribe un cambio aplicable a alguna de las posibilidades.
Paso 3: En las coordenadas correspondientes se aplica el cambio si es posible.

Paso 4: Se crea otra hoja (Excel).
Paso 5: De la hoja anterior, la columna 1 se copia a la nueva.
Paso 6: De la hoja anterior, las posibilidades surgidas se copian a la nueva, ordenadas según cuántas cosas fueron modificadas desde las originales.
Repetir desde el paso 2.


Entiendo que parezca una pavada pero cada vez me entrevero más en el paso 6.

Las imágenes mostradas son de la hoja 1 y 2, esta es de la 7 y al lado la 8:

Es decir, tengo una tabla como la de la izquierda y debo hacer que quede como la que está en la derecha. ¿Cómo hacerlo sin entreverarse?

Porque, al principio hacía esto:
En cuanto al paso 5 y 6, copiaba la hoja entera. Las filas en que surgió una posibilidad, las copiaba e insertaba en un nivel posterior. Luego regresaba a lo que copié y borraba el contenido de la columna 2 (tras modificar la cabeza, el contenido cambiará también).
Pero me entreveraba un poco, por estar moviendo la pantalla hacia arriba y abajo, me entrevero en cuanto a qué copié y a dónde debo copiarlo.

Ahora intenté esto:
1: Copio el 1er nivel de la columna 1.
2: Copio el siguiente nivel no copiado.
3: Copio las posibilidades surgidas en la columna 2 del nivel anterior.
Pero igual me entrevero.

Antes de empezar el tema pensé en poner otra columna que diga los niveles, y entonces ordenar la tabla por eso, pero por ejemplo las de nivel 2 que quiero poner debajo de las otras de ese nivel, estarán arriba, así que no sirve, o en definitiva no veo que tenga mucho control de todo esto, dudo que sirva. Ahora se me ocurre que puedo escribir cosas como 2a, 2b, etc, para que se ordenen así, pero igual no me fío mucho.

Finalmente, mientras hacía el tema se me ocurrió que en vez de copiar podría copiar y luego cortar, de ese modo no podría entreverarme en cuanto a qué ordené y qué me falta pero bueno, publico el tema igual a ver si me dicen métodos mejores y si a alguien le sirve esto fenómeno.

Estaría bueno poder programar generaciones de listas de posibilidades, sean de lo que sea. No sé si es tan complicado, habría expresiones con distintas cantidades de variables y según sus valores se mostrarían unas palabras u otras ¿no? ¿alguien da un pseudocódigo sobre eso?

¿Les recuerda a algo?



Ni idea qué fue 1ero, pero si quieren ver una buena peli donde aparece el roboto, aprovechen aquí:
https://www.youtube.com/watch?v=CLFVnjk8yro

Sé que cliqueando en la cabeza o cabecera de la columna Modificado, en la vista detallada, se ordenan como quiero. Eso hago. Pero cuando muevo la carpeta hacia otra (debo hacerlo) las configuraciones de sus subcarpetas se pierden, y yo me olvido (porque se supone que están ordenadas como quiero, así suele ser, no me ando fijando a ver si están ordenadas o no) y me acaba de ocurrir que entré a un archivo de ahí pensando que era el más reciente pero no.

Lo que quisiera es que con algunos clics o algo se ordenen por fecha los archivos de todas las subcarpetas que tenga una carpeta. He probado hacerle clic derecho, recuerdo que había una opción de personalizar esta carpeta pero no la veo, veo propiedades. Ah, ya vi por casualidad, aparece si hago clic derecho estando en la carpeta, no al hacer clic en una carpeta. Bue. ¡Pero es lo mismo que propiedades! Y ahí no veo modo de hacerlo.

¿No queda más remedio que entrar en todas las subcarpetas y hacer clics en las cabeceras otra vez? No es que deba hacer este proceso seguido, pero parece absurdo y evitable.

La siguiente función se aplica en distintos sitios del programa, pero no creo que el problema esté fuera de ella, creo que el problema es la altura asignada a la flecha y cómo Flash la aplica:

function InsertarNodo () {
	Imagenes = Imagenes+1;
	Nodos = Nodos+1;
	Grafo.attachMovie("mNodo", "Nodo"+Nodos, Imagenes);
	// Especificar la situación que representa:
	set ("Grafo.Nodo"+Nodos+".EnHP", EnHP);
	// Insertar flecha:
	Imagenes = Imagenes+1;
	Grafo.attachMovie("mFlecha", "Flecha"+Nodos, Imagenes);
	// Especificar el sitio donde se insertan:
	PosicionY = PadrePosicionY+33;
	setProperty ("Grafo.Nodo"+Nodos, _y, PosicionY);
	setProperty ("Grafo.Flecha"+Nodos, _x, PadrePosicionX);
	setProperty ("Grafo.Flecha"+Nodos, _y, PadrePosicionY+6.5);
	Hijos = Hijos+1;
	if ( Hijos == 1 ) {
		PosicionX = PadrePosicionX;
		setProperty ("Grafo.Nodo"+Nodos, _x, PosicionX);
	} else {
		Hijo = 0;
		MinPosicionX = PadrePosicionX-16.5*(Hijos-1);
		SAquedebeActualizarse = SAs-Hijos;
		do {
			Hijo = Hijo+1;
			PosicionX = (Hijo-1)*33+MinPosicionX;
			setProperty ("Grafo.Nodo"+(Nodos-Hijos+Hijo), _x, PosicionX);
			// Actualizar datos de las posiciones guardadas:
			SAquedebeActualizarse = SAquedebeActualizarse+1;
			set ("SA"+SAquedebeActualizarse+"PosicionX", PosicionX);
			// Rotación y tamaño de flecha.
	 		DistanciaXPadreHijo = Math.abs(PosicionX);
			setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _height, Math.sqrt(DistanciaXPadreHijo*DistanciaXPadreHijo+20*20));
			trace ("Altura: "+Math.sqrt(DistanciaXPadreHijo*DistanciaXPadreHijo+20*20));
			Rotacion = 180/Math.PI*Math.atan (DistanciaXPadreHijo/20*-1);
			if ( PosicionX<0 ) {
				Rotacion = Rotacion*-1;
			}
			setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _rotation, Rotacion);
		} while ( Hijo < Hijos );
	}
}

La 1era vez que se aplica esa función inserta una flecha y no la modifica porque no es necesario; queda como quiero:


La 2nda vez inserta otra (ahora hay 2) y modifica el tamaño y rotación de ambas; quedan como quiero:


La 3era vez lo mismo:


La 4ta vez no queda bien:

Algunas están más anchas que otras, ni idea por qué, y probablemente más largas de lo que deben. Pero las alturas supuestamente son iguales en las que deben serlo:
Altura: 53.3877326733399
Altura: 25.9277843249283
Altura: 25.9277843249283
Altura: 53.3877326733399

¿Alguna idea de cual es el problema, error, y cómo corregirlo?

Tema para que muestren cosas que han hecho en 2023 o que no han podido terminar, cuenten sus avances, sus obstáculos, etc. Se admiten sugerencias.

Luego de años dejé de discutir con los locos o tontos de cierto foro de "Filosofía" y empecé a dedicarme más a hacer mis cosas. Pensé que Reddit sería útil pero me insultaron bastante y me banearon sin explicarme por qué. Quora en cambio ha resultado bastante útil. Pensé que hallaría algún foro de videojuegos pero por A o por B no pude usar los que encontré. Hay páginas que debo probar aún...

Me dedicaba digamos randomicamente a mis proyectos, es decir, podía estar varios días con uno, sin avanzar en otros. El resultado era que al retomar otro no recordaba bien por qué hacía lo que hacía, digamos subproyectos. Así, empecé a hacer listas de cosas que me interesa hacer y seguirlas como si fuese una rutina. También anoto en qué me quedé, qué debo corregir o mejorar. Se pierde algo de tiempo escribiendo, pero ayuda a escribir mejor supongo, y por supuesto me ayuda a recordar más fácil lo relativo a mis proyectos. Me entretengo, cambiar de proyecto a cada rato es más divertido y menos cansador que estar "media vida" con alguno que puede ser interminable o casi.

Proyecto 1: Escribir un libro para gente como yo era.
La idea es que lo pueda entender CUALQUIERA, por ejemplo un mosquito, pero luego de muchas vueltas, teniendo en cuenta que esto:
https://www.pictocuentos.com/el-patito-feo/4
...se entiende bastante bien sin necesidad de que enseñen desde 0, y considerando que no sabía qué enseñar 1ero, decidí simplemente hacer una autobiografía. En la 1er versión escribo un año o varios, mi edad en él o ellos, una palabra que lo/s resuma o represente lo más relevante de él y una imagen que también. En próximas versiones pondría más hechos, relatados con más palabras, y más imágenes. Decidir la palabra más adecuada no me resulta siempre fácil, pero lo que me tranca más es encontrar las imágenes. Por ejemplo aún busco una de alguien llorando sintiéndose estúpido. Pensé en Shinji Ikari pero lo suyo es más amplio, en Gady de Rescue Rangers del episodio "The Case of the Cola Cult" pero como es mujer no pega mucho, me dijeron cierto episodio de Friends pero nada que ver... Las imágenes que generé con IA no me han gustado así que no uso eso. Básicamente voy por el año 2000, no llegué ni a la mitad de años. He aquí una parte:

...obviamente no se puede entender detalladamente qué ocurrió en esos años pero será ampliado y se agregará fondo y otras cosas a la imagen de lanzador.

2: Hacer programas que resuelvan dudas.
Esto lo intenté más o menos desde 2008 hasta 2019, y aunque muchas veces lo que intenté fue escribir sobre eso y entender cuales son los tipos de dudas, no tanto "hacer...", lo cierto es que no he logrado mucho. Eso y que mi amor platónico y los psiquiatras me trataran de loco me llevó a dejarlo. Debido en parte a que luego se puso de moda la IA decidí continuar, aunque lo mío es búsqueda mediante fuerza bruta y creo que backtracking, no hago redes neuronales ni cosas de moda. No avancé en cuanto a la complejidad de dudas a resolver, sólo a partir de programas que tenía mejoré los nombres de sus variables, las descripciones e intento que muestren grafos de las situaciones o estados a l@s que van llegado, cosa que antes me pareció que sería demasiado difícil, y lo sigue siendo para mí, pero parece que va bien, gracias a ayudas, aunque quedan cosas que hacer.
Lista incompleta de las variables de las dudas (hay palabras cortadas para que entre en 1 línea en el archivo donde las tengo):

Muestra de un grafo generado por un programa habiendo establecido que hay 5 acciones posibles (obviamente lo relativo a las flechas debe mejorarse, pero los nodos aparecen donde quiero, bien, cualquiera sea el nro de acciones posibles):

"Vencer al enemigo mediante acciones, el enemigo tiene 11 HP. Se recomienda la serie... 1 5 5" (significa que el método más rápido hallado es usar el ataque 1 que quita 1HP, y luego el 5 dos veces).
El código debería poder mejorarse especialmente en el aspecto de las referencias (ver SAquedebeActualizarse), pero intentaré que los nodos hijos, en vez de mostrarse cada vez que surge uno de un mismo padre, se muestren recién cuando hayan surgido todos, con lo cual por ahora no será necesario hacer referencias, creo.

   actions for fotograma 1
      function InsertarNodo () {
         Imagenes = Imagenes+1;
         Nodos = Nodos+1;
         Grafo.attachMovie("mNodo", "Nodo"+Nodos, Imagenes);
         // Especificar la situación que representa:
         set ("Grafo.Nodo"+Nodos+".EnHP", EnHP);
         // Insertar flecha:
         Imagenes = Imagenes+1;
         Grafo.attachMovie("mFlecha", "Flecha"+Nodos, Imagenes);
         // Especificar el sitio donde se insertan:
         PosicionY = PadrePosicionY+33;
         setProperty ("Grafo.Nodo"+Nodos, _y, PosicionY);
         setProperty ("Grafo.Flecha"+Nodos, _x, PadrePosicionX);
         setProperty ("Grafo.Flecha"+Nodos, _y, PadrePosicionY+6.5);
         Hijos = Hijos+1;
         if (Hijos == 1) {
            PosicionX = PadrePosicionX;
            setProperty ("Grafo.Nodo"+Nodos, _x, PosicionX);
         } else {
            Hijo = 0;
            MinPosicionX = PadrePosicionX-16.5*(Hijos-1);
            SAquedebeActualizarse = SAs-Hijos;
            do {
               Hijo = Hijo+1;
               PosicionX = (Hijo-1)*33+MinPosicionX;
               setProperty ("Grafo.Nodo"+(Nodos-Hijos+Hijo), _x, PosicionX);
               // Actualizar datos de las posiciones guardadas:
               SAquedebeActualizarse = SAquedebeActualizarse+1;
               set ("SA"+SAquedebeActualizarse+"PosicionX", PosicionX);
               // Rotación y tamaño de flecha.
               DistanciaXPadreHijo = Math.abs(PosicionX);
               setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _height, Math.sqrt(Math.pow(DistanciaXPadreHijo, 2)+20*20));
               Rotacion = 180/Math.PI*Math.atan(DistanciaXPadreHijo/20*-1);
               if (PosicionX<0) {
                  Rotacion = Rotacion*-1;
               }
               setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _rotation, Rotacion);
            } while (Hijo<Hijos);
         }
      }
      Respuesta = "Vencer al enemigo mediante acciones, el enemigo tiene 11 HP. Se recomienda la serie... ";
      // Situación inicial:
      // HP inicial del enemigo:
      EnBaseHP = 33;
      trace ("EnBaseHP: "+EnBaseHP);
      // Guardar situación y cómo se produjo:
      // Parte inicial del nombre de los datos (en este caso S11):
      SitID = "S"+EnBaseHP;
      trace ("SitID: "+SitID);
      // Acción realizada en la situación anterior (en este caso ninguna):
      set (SitID+"ActionAnterior", "Ninguna");
      trace (SitID+"ActionAnterior: "+eval(SitID+"ActionAnterior"));
      // En este caso la variable es S11Action y su valor es "Ninguna".
      // Posición X e Y del nodo que representa la situación desde la cual se originó la que será representada por otro nodo...
      // ...pero en este caso es la posición del 1er nodo.
      PadrePosicionX = 0;
      trace ("PadrePosicionX: "+PadrePosicionX);
      PadrePosicionY = 0;
      trace ("PadrePosicionY: "+PadrePosicionY);
      // Cantidad de imágenes insertadas:
      Imagenes = 1;
      trace ("Imágenes: "+Imagenes);
      // Cantidad de nodos del grafo a mostrar:
      Nodos = 1;
      trace ("Nodos: "+Nodos);
      // Insertar nodo inicial:
      Grafo.attachMovie("mNodo", "Nodo1", 1);
      // Especificar la situación que representa:
      Grafo.Nodo1.EnHP = EnBaseHP;
      // Hijos del nodo de la situación que se está analizando:
      Hijos = 0;
      trace ("Hijos: "+Hijos);
      // Acción que será usada 1ero:
      Action = 1;
      trace ("Action: "+Action);
      // Variables sobre situaciones anotadas:
      // Total de situaciones anotadas:
      SAs = 0;
      trace ("Situaciones anotadas: "+SAs);
      // Situación anotada que será investigada 1ero:
      SiguienteSAaInvestigar = 0;
      trace ("ID de la situación anotada a investigar cuando se comience a investigar las anotadas: "+SiguienteSAaInvestigar);
   actions for fotograma 2
      trace ("Reset de la situación, aplicación de la acción, la situación ahora es:");
      EnHP = EnBaseHP-Action;
      trace ("EnHP: "+EnHP);
      // ¿Se logró el objetivo?
      if (EnHP<=0) {
         // Sí, iniciar muestra de serie de acciones que la causan:
         Serie = Action;
         trace ("Solución hallada, iniciando proceso para mostrar respuesta.");
         InsertarNodo();
         gotoAndPlay (5);
      } else {
         trace ("No se logró el objetivo.");
         // ¿La situación producida está anotada?
         if (eval("S"+EnHP+"ActionAnterior") == undefined) {
            // No, anotarla y cómo se logró:
            trace ("La situación producida no está anotada.");
            SitID = "S"+EnHP;
            set (SitID+"EnHPAnterior", EnBaseHP);
            set (SitID+"ActionAnterior", Action);
            trace ("Ahora está anotada: "+SitID);
            trace ("Su antecedente fue ("+SitID+"EnHPAnterior): "+EnBaseHP);
            trace ("y la acción fue ("+SitID+"ActionAnterior): "+Action);
            // También se agrega como situación a investigar y se anota en qué consiste:
            SAs = SAs+1;
            SitID = "SA"+SAs;
            set (SitID+"EnHP", EnHP);
            trace ("Situaciones anotadas: "+SAs);
            trace ("La última consiste en (EnHP): "+eval(SitID+"EnHP"));
            // Se inserta el nodo que la representa y se guarda su posición:
            InsertarNodo();
            set (SitID+"PosicionX", PosicionX);
            trace (SitID+"PosicionX: "+PosicionX);
            set (SitID+"PosicionY", PosicionY);
         } else {
            trace ("La situación producida ya está anotada.");
         }
      }
   actions for fotograma 3
      // La situación está anotada. ¿Modificar acción es posible?
      if (Action<25) {
         // Sí, modificarla:
         trace ("Es posible modificar acción.");
         Action = Action+1;
         trace ("Action fue modificada, es: "+Action);
         gotoAndPlay (2);
      } else {
         trace ("No es posible modificar la acción.");
         if (SiguienteSAaInvestigar<SAs) {
            // Aún hay situaciones anotadas sin investigar, investigar una (probablemente lo ideal sería investigar la más diferente a las investigadas, pero me es difícil programar eso):
            trace ("Aún hay situaciones anotadas sin investigar.");
            SiguienteSAaInvestigar = SiguienteSAaInvestigar+1;
            EnBaseHP = eval("SA"+SiguienteSAaInvestigar+"EnHP");
            trace ("Se investigará la situación anotada nro: "+SiguienteSAaInvestigar);
            trace ("Consiste en EnBaseHP: "+EnBaseHP);
            // Guardar su posición para saber dónde poner a sus posibles hijos:
            PadrePosicionX = eval("SA"+SiguienteSAaInvestigar+"PosicionX");
            trace ("Nuevo PadrePosicionX: "+PadrePosicionX);
            PadrePosicionY = eval("SA"+SiguienteSAaInvestigar+"PosicionY");
            Hijos = 0;
            // Reset de la acción a usar:
            Action = 1;
            trace ("Reset de la acción a usar, es: "+Action);
            gotoAndPlay (2);
         } else {
            trace ("No hay situaciones anotadas sin investigar ni es posible lograr el objetivo.");
            Respuesta = "No es posible lograr el objetivo.";
            stop ();
         }
      }
   actions for fotograma 5
      // Obtener acción anterior:
      ActionAnterior = eval("S"+EnBaseHP+"ActionAnterior");
      trace ("La acción anterior fue: "+ActionAnterior);
      // ¿Hubo?
      if (ActionAnterior != "Ninguna") {
         // Sí, agregarla en la lista:
         Serie = ActionAnterior+" "+Serie;
         trace ("Acción agregada en la serie.");
         // Averiguar cual fue la situación anterior:
         EnBaseHP = eval("S"+EnBaseHP+"EnHPAnterior");
         trace ("Se realizó en la situación: S"+EnBaseHP);
         // Repetir este frame.
         gotoAndPlay (4);
      } else {
         // No hubo una acción anterior, mostrar la serie:
         Respuesta = Respuesta+Serie;
         stop ();
      }

3: Graficar y mejorar programas que resuelvan dudas.
Ah, sí, son proyectos separados, pero arriba me confundí y los mezclé xP

4: Aprender Química.
Fui a un curso pero lo dejé porque era más hacer cálculos que hacer cosas, útiles, además casi nada entendía. Similarmente me ocurrió con un curso que empecé a ver en Youtube. Un curso que leía también lo dejé porque me pareció que definían las cosas como el traste. Otro resultó ser lo que debí suponer, lo que decía el título, un megaresúmen que no enseña mucho. Lo que hice más bien fueron preguntas por ahí, y algo aprendí. Uno de mis objetivos es hacer una lista de las posibles moléculas. Según una noticia, que no sé si es cierta, una niña jugando con un juego de Química representó una molécula desconocida, y hubo un tío que inventó un material ultraresistente al fuego pero no quiso decir cómo se hace, así que creo que aún es un secreto. A mí me interesan los RPGs, entender en qué se basarían los HPs y demás si fuesen realistas, así que la Química y Física me interesan también por eso. Por ahora mi "lista" es esta:

Las moléculas son las que tiene 2 colores de fondo. Lo demás es para usarlo "de base" en posteriores filas.
Átomos de gases nobles no incluyo porque me dijeron que es casi imposible que formen enlaces con algo.
En una versión anterior cuando había 3 posibles enlaces yo ponía 2 para el costado y uno hacia arriba por ejemplo, pero según vi eso no es así y tuve que corregirlo :/
Obviamente sería cool que esto lo haga un programa, pero no creo ser capaz de hacer uno así, al menos aún.

5: Aprender cuales son los posibles juegos de Flash 5 para 1 humano.
No es que me quiera limitar a eso, pero no le veo sentido a pensar en un juego que no pueda programarse ahí que es donde más sé, así que me limito a eso. En esto estoy muy liado y es una de las cosas en que más me cuesta avanzar, estoy haciendo una lista de posibles modificaciones a juegos, es mejor que esta:

...pero esa está más compacta, la otra tiene descripciones de lo que hace cada cosa; lo que debo hacer es pensar qué cosas que puse en el colaborador, y otras que no puse, se podrían poner en el desafiante (humano) y hacer que estén mejor ordenadas @_@

Tengo más, luego sigo.

Advertencia: Al darle play o hacer clics por ahí se abren cosas y el antivirus bloquea algunas.
https://gamovideo.com/yo9jx4vlms8v

Probé muchos descargadores online y no hubo caso. ¿Usando y IE y mirando en archivos temporales tal vez? ¿otros métodos?

Hace años compré ese libro, sentía que no aprendía y me dormía, así que lo dejé. No sé qué se supone que enseña, recuerdo que habla del termostato, una máquina que mantiene su estado a pesar de que lo exterior cambie, o que cambia de estado según lo externo, algo así, pero no dice cómo construir uno, no es sobre construir ni sobre programar.


Promezzzas dichas con poezzzía... Bueno, es "Introducción a la cibernética", se puede asumir que describe esa ciencia, en qué consiste, su historia, pero tantas páginas para eso sin enseñar a aplicarla o a aprovecharse de sus logros parece inútil.

Veo que aquí se vende por 14 euros usado.
https://www.iberlibro.com/pensamiento-artificial-Introducci%C3%B3n-Cibern%C3%A9tica-Latil-Pierre/5767892024/bd

¿¡600 pesos uruguayos!? Eso es mucho, yo pensaba venderlo por $100 y bajarlo hasta regalarlo si nadie me lo compraba, que yo sepa no es fácil vender libros, y menos ahora que hay tanta info free.

En fin... ¿ustedes dirían que vale o valdrá algo, para quién, en dónde? ¿en una facultad de ingeniería tal vez?

Por ejemplo tengo:

if ( MaxLongitud>1 ) {
	set ("N"+(MaxLongitud+1), eval("N"+MaxLongitud)*10-1);
} else {
	set ("N"+(MaxLongitud+1), 9);
}
 

Eso crea una variable cuyo valor debe ser 9, 99, 999, etc, según cuánto sea la variable MaxLongitud. Creo que se podría simplificar pero en mi lenguaje hacer potencias funciona mal parece. Pero eso no es la cuestión. La cuestión es que como no sé una fórmula matemática que en cualquier caso resulte los valores que necesito, usé un if. Yo necesitaría esto:
Si X (MaxLongitud) es 1, Y (el resultado) debe ser 9.
Si X es 2, Y debe ser 99.
etc.
Creo que es Y=10^X-1, pero como la potencia funciona mal no puedo hacer eso. Lo que hago es tomar el valor de una variable que en ese momento es +1 y luego /10, creo, o sea, cuando necesito asignar un 99, la variable anterior es 10, la cuestión es que le hago *10-1 y listo. El problema es la 1era vez. La 1era vez esa variable es 0, y si hago 0*10-1 no me da 9.

Yo supongo que hay alguna fórmula matemática que cumpla eso, y así no es necesario poner un if, y por curiosidad o manía o no sé qué quiero saber cual es la bendita fórmula, pero ¿conviene programar así usando fórmulas "complicadas" en vez de ifs, o conviene usar ifs? En este caso puse una fórmula, pero digo que sería posible poner una probablemente más compleja que sirva para ambos casos ¿pero conviene? ¿qué método enlentece menos a los programas?

Trato de evitar ifs porque con ellos la máquina debe hacer 2 cosas en vez de una, pero si la fórmula es muy larga puede que sea peor usarla.

Busco una respuesta más específica que "saber de informática, ser inteligente, tener memoria, etc", o quizá debería preguntar, a quienes más o menos me conocen: ¿Yo cumplo los requisitos? ¿hay gente que pagaría porque le hagan tareas que yo puedo hacer? ¿qué tareas serían? ¿cómo me contacto con esa gente, si es que existe?

Yo tengo familiares que no saben usar Google por ejemplo, entonces quizá podría imprimir cosas que gente así quiera leer, o conseguirles videos, pero gente así difícilmente tenga con qué pagar xP o se interesarían en aprender, no como esos familiares míos que se quedaron atascados en la TV y la radio. Quizá me parezco demasiado por no tener interés en aprender nuevos lenguajes, pero si con el que soy "experto" no puedo hacer gran cosa entonces con otros casi seguro que tampoco, además probé algunos o he visto y no me gustaron.

Había pensado en ofrecerme a hacer videojuegos pero no supe hacer el diagrma de modo que entre en el espacio que necesitaba de la hoja a imprimir (ag, qué lío fue eso, ignoren lo colorido que lo iba a borrar):

Además en medio de eso creo que me di cuenta de que la letra esa era más pequeña que la del resto de la hoja, y con negrita, todo mal >__< así que dejé eso e incluso más tarde concluí que si me pidieran un videojuego de fútbol por ejemplo (que sería muy probable) no tengo mucha idea de cómo hacerlo, ni casi ninguno.

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

Tal vez debería ser payaso.

Entre comillas porque no creo en eso, creo en algo similar al mundo de las ideas de Platón, donde ya existe todo, lo que se puede es materializar cosas que no han sido materializadas aquí, según se ha dicho.

En cuanto a la duda, creo que se relaciona con ver cuales son las variables de los juegos y variarlas, o pensar qué se le puede agregar, quitar o cambiar a otros juegos.

Pienso en eso pero últimamente estoy bastante trancado, no sé bien cómo continuar.

Se podría decir que las variables se vinculan a uno de estos "objetos" o grupos (relativos a cierto "objeto"), que son:
- Desafiante (el jugador).
- Opciones (acciones posibles, sea para configurar el juego o durante él).
- Colaboradores (digamos IAs que colaboran de algún modo, por ejemplo lanzando la bola, y/o haciendo de juez).
- Juicio (cómo se decide qué debe hacerse en ciertos casos).
- Rivales.
- Aliados.
- Constantes.
- Variables.
- Valores.
- Efectos.
- Condiciones (se refiere a las de victoria, derrota, etc).
- Información (que da el juego).

Tengo una tabla con varias posibilidades pero tengo un "remake" que intenta tener más y explicadas, esta:

En la 1er columna están los objetos y a la derecha están las posibilidades relacionadas con ellos.

Lo relacionado con la percepción del colaborador lo ideé hasta cierto punto aquí:


Debo ir agregando eso en la tabla, modificarla para meter eso, sustituyendo cosas que ya había.

También agregar más cosas.

Ordenarlas, por ejemplo lo que sea "agregar" puesto en la misma columna, lo que sea parecido entre sí en la misma columna.

Y en lo posible mejorar los colores, puede parecer una pavada pero cuando haga otra tabla para mezclar posibilidades ayuda mucho distinguir a la última con un color.

Entonces... ¿alguien quiere ayudar?


También les comento 2 posibles juegos simplones que no sé si alguna vez fueron jugados por 2 personas... (sep, estos no son de 1 jugador).

A uno lo llamo WIN, es basado en el 3 en línea y OSO.
El jugador 1 pone una W en el tablero.
El jugador 2 pone una I.
El jugador 1 pone una N.
El jugador 2 pone una W.
Y así sigue, gana el 1ero en formar WIN como si fuese un 3 en línea, pero a mí me pareció más complicado porque debe pensarse qué opción tocará luego, no es cuestión de poner una I al lado de una W por ejemplo, en el 3 en línea sí simplemente pones tus símbolos al lado de ellos mismos. El juego OSO parece que no tiene reglas claras, o tantas variantes que no sé cuales tienen sentido, pero ahí son 2 símbolos posibles y en mi juego 3.

El otro podría llamarse 123 vs ABC, o usar 3 letras distintas de 2 nombres, y deben ser distintas para cada jugador. Es parecido a los anteriores, pero se juega en tableros más grandes. El objetivo es que en el tablero tu "expresión" (123, ABC o lo que sea) esté la mayor cantidad de veces posible. Un jugador pone cualquiera de sus posibles símbolos, el otro hace lo mismo con uno de los suyos, y así. Es complicado porque no sólo debes pensar dónde poner tus símbolos, que no es gran cosa, sino también cual poner.

Eso me recuerda a otro. Este consiste en quién forma más palabras, poniendo de a 1 letra.

Si puedo los pongo como minijuegos en mi juego de tenis (ahí serían sí para 1 jugador), pero aún no resolví lo básico de ese xP

Hice un video del WIN, quizá haga de los demás también:
https://youtu.be/gG1BjCrcLBo