Como último recurso probaré los métodos que uds me dijeron en un tema que hice hace tiempo sobre un video en otro lado, aquí no estoy preguntando cómo descargar este sino por qué es tan difícil hacerlo, qué tiene de especial, si alguien sabe. Probé diversas páginas de descarga sin instaladores como debe ser y en muchos casos me dice esto:
Se denegó el acceso a rr5---sn-p5qlsn7s.googlevideo.comNo tienes autorización para ver esta página.
HTTP ERROR 403

Por cierto a mí no me interesa ver esta basura, es para una abuela:
https://www.youtube.com/watch?v=NBv6qxKxWEY




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

Otra duda aparentemente tonta que me ha tenido trancado demasiado tiempo.

En programas que hacen poco, el print o lo que sea se pone casi al final, para mostrar el resultado de la tarea. Nada más.

En programas que hacen muchas cosas, lo mismo pero los prints también se ponen antes de ciertos procesos o después para indicar en qué parte del programa va, o qué está analizando en el momento. Lo vemos cuando copiamos muchos archivos por ejemplo, se indica cual se está copiando.

Parece una cuestión obvia de resolver.

Pero yo tengo un programa que me cuesta decidir o entender dónde quisiera poner los prints si tuviera un criterio que me parezca bueno. En cierto punto sólo ponía uno al final. Luego poco a poco pasé a seguir este patrón generalmente: Comentario, cambio, print. Luego empecé a creer que no tiene sentido hacer print de cada cambio porque si una cosa funciona bien no es necesario indicar que otra lo hizo, por ejemplo indicar que una variable cambió parece innecesario si enseguida se aplicará para algo. Así, quité todos los prints (en mi caso traces) del fotograma 1 excepto uno que muestra lo mismo que otra cosa así que lo quitaré también, no me di cuenta. Ahora iba a analizar el resto y, no sé bien qué hacer...

   actions for fotograma 1
      function InsertarNodoyFlecha () {
         // Insertar Nodo:
         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;
         // Como por ahora casi todo padre tiene 1 hijo, este if agiliza el proceso creo:
         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);
               // Establecer rotación 0 a la flecha para que su altura de se modifique bien:
               setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _rotation, 0);
               // Especificar rotación y tamaño de flecha:
               DistanciaXPadreHijo = Math.abs(Math.abs(PadrePosicionX)-Math.abs(PosicionX));
               setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _height, Math.sqrt(DistanciaXPadreHijo*DistanciaXPadreHijo+20*20));
               Rotacion = 180/Math.PI*Math.atan(DistanciaXPadreHijo/20*-1);
               // Si el hijo está a la izquierda del padre, invertir la rotación:
               if (PosicionX<PadrePosicionX) {
                  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;
      // Acción realizada en la situación anterior (en este caso ninguna):
      set (SitID+"ActionAnterior", "Ninguna");
      // 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;
      PadrePosicionY = 0;
      // Cantidad de imágenes insertadas:
      Imagenes = 1;
      // Cantidad de nodos del grafo a mostrar:
      Nodos = 1;
      // 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;
      // Acción que será usada 1ero:
      Action = 1;
      // Variables sobre situaciones anotadas:
      // Total de situaciones anotadas:
      SAs = 0;
      // Situación anotada que será investigada 1ero:
      SiguienteSAaInvestigar = 0;
   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) {
         trace ("Solución hallada, iniciando proceso para mostrar cómo causarla.");
         Serie = Action;
         InsertarNodoyFlecha();
         gotoAndPlay (5);
      } else {
         trace ("No se logró el objetivo.");
         // ¿La situación producida está anotada?
         if (eval("S"+EnHP+"ActionAnterior") == undefined) {
            trace ("La situación producida no está anotada.");
            trace ("Se anotará y cómo se logró.");
            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:
            InsertarNodoyFlecha();
            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
      // ¿Modificar acción es posible?
      if (Action<7) {
         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.";
         }
      }
   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:
         trace (Respuesta+Serie);
         stop ();
      }

Además hay cosas como esta:
// 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.");
Es decir un trace que dice lo mismo que el comentario, por lo que parece que debería borrar el comentario, pero el comentario dice más cosas que no tiene sentido decir en un trace. Ahora se me ocurre poner el trace y luego el comentario quitando lo que ya se dice en el trace, sí, puede que sea una solución muy obvia pero no me di cuenta en parte por intentar seguir el patrón que mencioné.

¿Qué se ha dicho que es mejor o qué opinan?

¿Cuales son las ventajas/desventajas de cada uno?

¿No hay diferencia casi?

Por si no se entiende me refiero a:

VS


No parece haber diferencia pero me pregunto si cuando el código se pone medio spaguetti sí...

1er post y en lo posible todas las respuestas y páginas.

El admin me dijo:
Estoy ya bastante liado con mis cosas como para meterme en esas, no tengo idea de cómo se hace. Son unos 3000 temas, hacerlo a mano no parece buena idea.

La lista que se genera es de cosas/eventos contables en un programa, por ejemplo la cantidad de clics.

Pero "sólo un clic" no es lo mismo que un "clic mientras se hace algo", por ejemplo. Para diferenciar eso puse +Nada, +Algo y +Lo que sea (Nada/Algo). Supongo que eso es lo más raro a primera vista. "Casos de Nada" está mal, no debe ir, puede haber otras cosas que tampoco.

etc, etc, son 1344 líneas (7*4*4*4*3, permutaciones o como se llame, 7 posibilidades en una variable, 4 en otra, etc).

El código es:

   actions for fotograma 1
      // Frames.
      V1 = -1;
      Max1 = 6;
      V1Texto0 = "Casos de ";
      V1Texto1 = "1er Frame en que ocurrió ";
      V1Texto2 = "Frames en que ocurrió ";
      V1Texto3 = "En 10 Frames, mínimos casos de ";
      V1Texto4 = "En 10 Frames, máximos casos de ";
      V1Texto5 = "En 10 Frames, mínima cantidad de Frames en que ocurrió ";
      V1Texto6 = "En 10 Frames, máxima cantidad de Frames en que ocurrió ";
      // Mov.
      V2 = 0;
      Max2 = 3;
      V2Texto0 = "";
      V2Texto1 = "Mov + ";
      V2Texto2 = "Frenada + ";
      V2Texto3 = "Moviéndose + ";
      // Clic.
      V3 = 0;
      Max3 = 3;
      V3Texto0 = "";
      V3Texto1 = "Clic + ";
      V3Texto2 = "Desclic + ";
      V3Texto3 = "Cliqueando + ";
      // Clac.
      V4 = 0;
      Max4 = 3;
      V4Texto0 = "";
      V4Texto1 = "Clac + ";
      V4Texto2 = "Desclac + ";
      V4Texto3 = "Claqueando + ";
      // Final.
      V5 = 0;
      Max5 = 2;
      V5Texto0 = "Nada";
      V5Texto1 = "Algo";
      V5Texto2 = "Lo que sea";
      Puntero = 0;
      Completado = "No";
      function Variar () {
         Puntero = Puntero+1;
         Nombre = "V"+Puntero;
         Valor = eval(Nombre);
         Max = eval("Max"+Puntero);
         // ¿La variable puede aumentar?
         if (Valor<Max) {
            // Sí, aumentarla:
            set (Nombre, Valor+1);
            // Obtener suma:
            Suma = V1+V2+V3+V4+V5;
            // Obtener texto:
            Texto = eval("V1Texto"+V1)+eval("V2Texto"+V2)+eval("V3Texto"+V3);
            Texto = Suma+":\t"+Texto+eval("V4Texto"+V4)+eval("V5Texto"+V5);
            trace (Texto);
            Puntero = 0;
            // Esta función se repetirá.
         } else {
            // No, resetearla:
            set (Nombre, 0);
            // ¿Hay otra variable aumentable?
            if (Puntero<5) {
               // Podríhacer, apuntar a esa.
               // Esta función se repetirá.
            } else {
               // Esta variable se pone para que del F3 no vuelva al 2.
               Completado = "Sí";
               stop ();
            }
         }
      }
   actions for fotograma 2
      Variar();
   actions for fotograma 3
      Variar();
      if (Completado == "No") {
         gotoAndPlay (2);
      }
 

Quisiera que:

1:
Moviéndose, Cliqueando y Claqueando sólo aparezcan en frames, o sea:
"Casos de Moviéndose" no debe producirse, porque ¿cómo se cuentan los casos en que el mouse se está moviendo o algo se está presionando? Que yo sepa no se puede, se cuenta el tiempo (frames) en que eso sucede.
"1er Frame en que ocurrió Moviéndose" está bien.
"Frames en que ocurrió Moviéndose", ok.
"En 10 Frames, mínimos casos de Moviéndose", no, por lo ya explicado.
"En 10 Frames, máximos casos de Moviéndose", idem.
"En 10 Frames, mínima cantidad de Frames en que ocurrió ", ok.
"En 10 Frames, máxima cantidad de Frames en que ocurrió ", ok.
Lo mismo se aplica cuando lo único que hay es "Nada" o "Lo que sea", porque no se pueden contar los casos de Nada ¿cuántos puede haber en un frame? Lo que puede contarse es la cantidad de tiempo (frames) en que ocurre Nada. "Lo que sea" puede ser Nada también así que se le aplica lo mismo.

2:
Se generaran también expresiones que en vez de Clac tengan 2Clac y otras de 3Clac. Esto probablemente sea lo más fácil de lograr. Y es que no es posible hacer 2 clics al mismo tiempo (o al menos no en lo que estoy haciendo, sólo se usa el clic izquierdo) ni hacer 2 movimientos de mouse al mismo tiempo (quizá arriba+derecha, etc, pero no me refiero a eso), pero tocar varias teclas a la vez sí.

3:
Se generaran también expresiones como "Casos de Mov+Nada, Mov+Nada", "1er Frame en que ocurrió Clic+Clac+Algo, Mov+Lo que sea", etc. Significa que ocurrió una cosa y luego (,) otra. Si dice + es que son "a la vez", no es lo mismo que "luego". No debe haber más de 2 comas.

4:
No se generen combinaciones imposibles como "Clic+Desclic".


Por otro lado ¿qué otras cosas relativas a lo que el usuario haga se les ocurre que se pueden contar en un programa? Por ejemplo: Variedad de teclas presionadas, hay muchas cosas que no he puesto aún.

Blancas deben sobrevivir durante la mayor cantidad de turnos posible. Destruir el peón o quedar encerradas sería infinito, pero se supone que no ocurrirá.

Negras deben ganar en la mínima cantidad posible de turnos.

¿Qué deben hacer blancas para que la partida sea más larga? Bloquear al peón, pero hay varias formas de hacerlo, me refiero a eso. Uno puede ser obligado a permitir el paso antes o después dependiendo de cómo se acerque...

¿Y qué deben hacer para intentar quedar encerradas? Sé posibles situaciones en que ocurre eso, pero no sé bien cómo provocarlas, me refiero a eso.

¿Cómo jugarían negras para ganar lo más rápido posible? Coronar al peón en reina protegiéndolo con el rey y luego dar mate, pero el asunto es cómo hacer eso de la forma más rápida posible.

No sé si hay otra cosa que deba tenerse en cuenta, digan. Plantearé más ejercicios como este si les interesa.

Tengo algo así para el juego The Wizard's Castle de DOS, es un RPG/Rogue no muy complicado. Quisiera que me digan cómo se puede mejorar, en el sentido de cómo expresarlo de modo más claro.


A partir de ahí no sé bien qué decir, depende de qué estadística se maximice, luego contra qué monstruo se vaya a pelear o se esté peleando, si se tiene arma, cuales son las estadísticas... Se me pone complicado. Pero no sé si eso se relaciona con el tema, yo quiero saber si hay algo mejor que esos "Estados" y en caso de que convenga dividir alguno (si tiene ifs), cómo.

GPT:

Si el programa puede hacer crecer la cantidad de nodos, entonces me gusta la idea.

Las explicaciones que he visto respecto a qué es una red neuronal me han dejado siempre un mal sabor.

A GPT:
si hago un programa que averigue cómo es mejor actuar en ciertas situaciones y esa información se puede representar mediante un grafo ¿es una red neuronal?


un programa que aprenda usando una red neuronal ¿hace que ella aumente de tamaño o sólo cambia pesos?


Bue, si conocen buenos videos sobre el tema quisiera que me digan, a ver por qué esa técnica es tan buena.

Por ejemplo ¿puede un hacker hacer que en otra pantalla se muestre lo que el víctimo está viendo en la suya?

¿Puede un hacker escribir cosas en la computadora del víctimo mientras éste lee atónito? Por ejemplo que el víctimo esté escribiendo y de repente en el cuadro de texto en vez de que aparezca lo que escribe aparezca lo que escriba el hacker, que podría ser algo como "No pude comunicarme de otra manera, soy un espíritu, necesito que vayas a...".

¿Que cosas que se suele creer que son imposibles para un hacker, son posibles?

¿Y qué cosas que algunos creen posibles para un hacker, en realidad no lo son (por ahora al menos)?

Sería una versión mejorada de este:
https://www.youtube.com/watch?v=i_aPn9W2WF8
mezclada con Magic The Gathering y Yu-gi-oh.

N = Nro de jugadores.
??? = Cantidades a decidir.

- Cada jugador debe hacer un mazo de cartas.
- Hay 3 tipos de cartas:
--- Números.
--- Operadores.
--- Personas o personajes que han sido relevantes en las Matemáticas.
- Cada jugador baraja su mazo. Luego pone cartas boca arriba, formando cada uno un cuadro de ???x??? cartas.
- Debe haber al menos 1 carta de tipo número en cada cuadro. Cada jugador puede devolver sus cartas a su mazo y volver a poner otras, pero cada vez que lo haga tendrá que poner 1 carta menos. Si llega un punto en que sólo puede poner 1 carta y la que pone no es un número, pierde.
- El órden de los turnos podría ser decidido según la cantidad de números que hayan puesto, o su suma, o cual sea el mayor, o no sé, qué sería mejor. En caso de empate se vería quien tiene la 2nda cantidad mayor, o la suma mayor, o lo que se haya decidido, y así sucesivamente. En caso de que no sea posible desempatar así se comienza a ver quién tiene el número mayor al final de su mazo.
- Podría ser que, quien inicia, no toma una carta de su mazo en esa ocasión. En los demás casos sí, al inicio de su turno, el jugador toma una carta de su mazo.
- En cada turno se puede lanzar sólo 1 operación (1 número, 1 operador y otro número) y sólo a 1 personaje.
- El contexto podría ser:
A: Los números en el cuadro de cada jugador son candados, gana quien abre todos los del adversario.
B: Los cuadros son murallas, gana quien hace un camino vertical en la muralla rival. En este caso al inicio debería haber al menos 1 número en cada columna de cada cuadro.
C: Alguna de esas 2 con el agregado de que luego debe quitarle puntos de vida.

Los personajes causarían efectos especiales en el juego, como obtener 2 cartas del mazo, ver la mano del rival, etc.

Sería bueno que durante el juego los jugadores pudieran poner números en sus cuadros y/o intercambiar sus otras cartas de ahí por números pero no sé si así nomás o de algún modo especial. Se requieren 2 y 1 operador para destruir 1 rival... Si se pudiera poner un número en el cuadro cada vez que se tenga en la mano entonces ¿para qué usar 3 cartas en destruir 1 si se podrían poner 3? Por eso no puede ser. ¿Para poner 1 hay que descartar 2 cartas? Podría ser. También, que si en el cuadro se tiene una carta no número y en la mano un número, se puedan intercambiar.

Podría haber cartas tipo trampa también, estarían en el cuadro y se podrían activar cuando se destruye un número al lado. En este caso las cartas que no sean número estarían boca abajo y se pondrían boca arriba cuando un número sea destruido ¿está bien? O en caso de jugarse en el modo "hacer camino", se activarían cuando deja de haber un número delante y el rival decide pasar.

Tal vez sería bueno que en vez de tomar 1 carta por turno se tomen 2, el problema es que entre más cartas más se tarda en jugarlas porque debe pensarse más, por tener más opciones.

Otra posibilidad es que en vez de jugar con 1 mazo en que están todos los tipos de cartas mezclados, se juegue con varios mazos a la vez. Está bien mientras no se mezclen todas en la mano y en la pila de descarte, sino habría que reacomodarlas al final de cada partida (por supuesto si es un videojuego no sería problema).

Una idea que me gustó es que un efecto especial sea "obtén el menor resultado posible". Ambos jugadores podrían usar todos los números y operadores que quieran intentando eso y el ganador obtendría algún beneficio especial (tomar del mazo el doble de cartas que haya usado, por ejemplo), pero si en general no se tendrá muchas cartas en la mano no tiene mucha gracia.

Ahora que me doy cuenta, debería permitirse lanzar operaciones más grandes, es decir, con más números y más operadores.

En fin ¿qué más se les ocurre?