Foro SofosAgora

Foro abierto a los intereses de sus usuarios. Debate, aprende y diviértete.
Fecha actual 26 Ago 2019, 05:31

Todos los horarios son UTC + 1 hora [ DST ]




Nuevo tema Responder al tema  [ 2 mensajes ] 
Autor Mensaje
NotaPublicado: 26 May 2015, 03:55 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 9711
Hace más o menos 1 año...
https://dl.dropboxusercontent.com/u/169164922/02jf.swf

Ahora:
https://dl.dropboxusercontent.com/u/169 ... uestra.swf

Hay varias cosas que están a medio hacer ergo no andan bien quizá. Por ejemplo la lista que se despliega en Condiciones parte 1 al cliquear Elemento.

Y bueno no es tanto "la mitad", pero si se divide el programa en 2 partes: 1-Descripción del problema y 2-Búsqueda de la solución, entonces han visto la 1 no muy lejos de completarse.

Sugerencias? Dudas?

_________________
Si no puedes hacerlo, intenta primero hacer algo más simple aunque similar.


Última edición por Tachikomaia el 10 Oct 2015, 00:21, editado 1 vez en total

Arriba
 Perfil  
Responder citando  
NotaPublicado: 10 Oct 2015, 00:14 
Desconectado
Avatar de Usuario

Registrado: 10 Ago 2011, 20:39
Mensajes: 9711
Me han preguntado por pm sobre esto y he respondido:
Citar:
El 1er link, o sea este:
https://dl.dropboxusercontent.com/u/169164922/02jf.swf
...simplemente tiene una cosa a elegir, un valor, y como puedes ver lo que hace es variar la cantidad de puntos en el rango, o sea marca la cantidad de posiciones o valores que una variable puede tener. Y el programa busca un valor que esté dentro del rango, contando desde el 1, así que siempre termina en el 1.
Como solucionador de problemas deja muchísimo que desear, era más bien una práctica, un paso previo. Pero como forma de representar un problema y cómo se resolvía, me fue muy difícil. Es decir, hacer que aparezcan cruces o puntos según el caso, distanciados igual, y hacer que el robot aparezca en el punto que se marque, me fue difícil.

El 2ndo link...
https://dl.dropboxusercontent.com/u/169 ... uestra.swf
Bueno es normal que no entiendas lo que hace cada cosa, porque en él no se muestra... te paso una versión más avanzada:
https://dl.dropboxusercontent.com/u/169164922/C2.swf
Pero... tiene errores por lo que he visto, y no recuerdo bien "en qué iba" en aquél entonces (ni siquiera tengo un archivo de nombre "muestra" para saber de dónde sale exactamente), así que no sé bien cómo arreglarlos. Comprende que es de la fecha 28/05 y desde entonces hice varias cosas, es normal que no recuerde o que esté mal en ciertos aspectos que dejé sin arreglar (pero que no recuerde aunque tenga archivos "historial" o que no los entienda del todo cuando los leo, eso sí no es normal xD ). Básicamente porque decidí dejar de lado los temas de representación.
Lo que puedes hacer, no obstante, es:
En el 2ndo 5 (está al lado de Extensión vertical), pon un un número alto, como 222.
En esa pantalla estás definiendo los elementos de la situación, o sea cuántas manzanas tienes en un canasto (H1) y en otro (V2), por ejemplo. Y al lado de cada variable eliges cómo se mostrará en pantalla, si como forma de puntos en horizontal, o en vertical, pero eso no funciona del todo bien así que por ahora no lo cambies, sólo haz lo que está en negrita. La simbólica no recuerdo bien qué era pero más o menos lo mismo, servía también para decimales...
Las variables tienen un identificador (ID) para hacer referencia a ellas en otras partes. Lo ideal es que sea elegido por el usuario pero lograr eso era un poco complicado así que no lo intenté, o sea se definen automáticamente según lo que se elija en la columna representación.
Presiona el botón >
En esta pantalla se definirían condiciones que serán usadas en una o más partes del programa. Acá por ejemplo está definido "cuando H1 sea igual que V1". Cada condición tiene un ID para hacer referencia a ellas, más adelante.
Presiona el botón >
Acá se definen grupos de condiciones, como si fuese "cuando se cumple la condición 1 Y la condición 2", pero ojo, hay 2 filas divididas en 2. Cada fila es un grupo distinto, y cada subfila expresa si la condición en ella es tomada por el grupo como "y" o "pero no", o sea, si debe cumplirse para que se cumpla el grupo de condiciones, o si por el contrario al cumplirse esa condición no se cumple el grupo.
En este caso está definido que el grupo 1 de condiciones se cumple si se cumple la condición 1 (definida en la pantalla anterior: Cuando H1==V1).
Y el grupo 2 es totalmente al revés: Se cumple cuando no se cumple H1==V1, dicho de otro modo: Se cumple cuando H1!=V1.
Comprende que todo esto era para que se pudiese "programar" desde una interfase en vez de programar desde un editor de código común y corriente. También, que toda esta estructura era porque me resultaba complicado hacer que la estructura de una condición fuese variable. O sea, normalmente no hay "grupos de condiciones", sino cosas así:
"Si el número es > 6 y < 22 y entero entonces ganaste."
Yo para imitar eso tendría que permitir variar el nro de columnas y especificar al programa una interpretación diferente según qué estructura se eligiera. El sistema que "inventé" también permitía evitar repetir ciertas cosas, y ahorrar espacio en la pantalla.
Pero ya está viejo. Luego te muestro uno más nuevo (que también dejé de usarlo, porque también dejé de lado la cuestión de la interfase, luego te explico).
Presiona el botón >
En esta pantalla se especifica qué elementos cambiarán, en qué condiciones, y cómo (variado según condiciones), al menos esa es la idea...
En este momento está configurado que H1 tome el valor de Act. Dice condiciones "or" pero no recuerdo bien por qué o cómo usaba eso.
Presiona el botón >
Es la última pantalla de configuración, donde puedes especificar cuando se soluciona el problema (en este caso, cuando se cumple el grupo 1 de condiciones), cual será el valor de la acción inicial y cómo variará. Como ves, dice que la acción inicial es 1 y que se va modificando de a 1. Y antes decía que H1 toma el valor de Act, lo cual significa que H1 será 1, luego 2... y así sucesivamente hasta que se cumpla la solución, que es: Cuando H1==V1
Presiona el botón >
Aparecerá 1 fila y 1 columna, centradas. En la fila habrá menos puntos que en la columna pero irán aumentando, y se detendrá cuando sean iguales.
Se ha representado el problema y la búsqueda de la solución. Se ha mostrado H1 como si fuese una cantidad de puntos dentro de una extensión horizontal y se ha mostrado V1 como si fuese una cantidad de puntos en una extensión vertical. Además, se ha mostrado que Act determinaba a H1 y que iba aumentando de a 1. Y dicho proceso se ha detenido cuando H1 fue igual que V1, momento en que se mostró en pantalla un Act recomendado, una acción con la cual se logra el objetivo especificado.
Eso es todo. Puedes probar más cosas, pero como dije no funcionan bien...
Aquí tienes el código (copiado usando la función movie explorer de Flash; quizá falte algo):
Spoiler: show
Código:
Escena 1
   Fondo, (Manto)
      actions for Fondo
         onClipEvent (load) {
            setProperty (this, _visible, false);
         }
   actions for fotograma 1
      // SitElm1:
      SitID1 = "H1";
      H1 = 5;
      H1Rep = "Extensión horizontal";
      H1Tipo = "RepBas";
      H1Repis = "Max";
      H1RepMin = 0;
      H1RepMax = 5;
      // SitElm2:
      SitID2 = "V2";
      V2 = 5;
      V2Rep = "Extensión vertical";
      V2Tipo = "RepBas";
      V2Repis = "Max";
      V2RepMin = 0;
      V2RepMax = 5;
      SitElms = 2;
      // Conds.
      Cond1Elm1 = "H1";
      Cond1Elm1T = "Elm";
      Cond1Comp = "==";
      Cond1CompT = "Eq";
      Cond1Elm2 = "V2";
      Cond1Elm2T = "Elm";
      Cond2Elm1 = "---";
      Cond2Elm1T = "---";
      Cond2Comp = "---";
      Cond2CompT = "---";
      Cond2Elm2 = "---";
      Cond2Elm2T = "---";
      Conds = 2;
      // Gruos.
      Grup1p1 = "---";
      Grup1y1 = 1;
      Grup2p1 = 1;
      Grup2y1 = "---";
      A = 1;
      do {
         A = A+1;
         set ("Grup1p"+A, "---");
         set ("Grup1y"+A, "---");
         set ("Grup2p"+A, "---");
         set ("Grup2y"+A, "---");
      } while (A<10);
      Grups = 2;
      // Cam1.
      A = 0;
      do {
         A = A+1;
         set ("Cam1Cond"+A, "---");
      } while (A<10);
      Cam1Elm = "H1";
      Cam1Elm1 = "Act";
      Cam1Tipo1 = "Elm";
      Cam1Op = "---";
      Cam1Elm2 = "---";
      Cam1Tipo2 = "---";
      // Cam2.
      Cam2Cond1 = "---";
      Cam2Elm = "---";
      Cam2Elm1 = "---";
      Cam2Tipo1 = "---";
      Cam2Op = "---";
      Cam2Elm2 = "---";
      Cam2Tipo2 = "---";
      Cams = 1;
      // Ors = 1;
      // Cams B:
      Sol1 = 1;
      ActIni = 1;
      ActOp = "+";
      ActMod = 1;
      // ////////////////////////////////////////
      // ////   Readd líneas y sus botones   ////
      // ////////////////////////////////////////
      // ///////////   Dependencia 0   //////////
      // ////////////////////////////////////////
      function ReaddSitLinep () {
         // p es parte; también usada por Func ReaddCond1Line
         // ReaddCond2Lines, ReaddCamLine
         A = A+1;
         B = "Lines.Line"+A;
      }
      function ReaddSitLinep2 () {
         // Func ReaddCond1Line, ReaddCond2Lines, ReaddCamLine
         C = 23.4*(A-1);
         setProperty (eval(B), _y, C);
         set ("LinesBots.Bot"+A+".A", A);
         // En cada línea de bots, var que indica qué nro de linea es.
         setProperty ("LinesBots.Bot"+A, _y, C);
      }
      // ////////////////////////////////////////
      // ///////////   Dependencia 1   //////////
      // ////////////////////////////////////////
      function ReaddSitLine () {
         // F2.
         A = 0;
         do {
            ReaddSitLinep();
            Lines.attachMovie("SitLine", "Line"+A, A);
            C = eval("SitID"+A);
            set (B+".SitID", C);
            set (B+".SitVal", eval(C));
            set (B+".SitRep", eval(C+"Rep"));
            LinesBots.attachMovie("SitBots", "Bot"+A, A);
            ReaddSitLinep2();
         } while (A<SitElms);
      }
      function ReaddCond1Line () {
         // F4.
         A = 0;
         do {
            ReaddSitLinep();
            Lines.attachMovie("Cond1Line", "Line"+A, A);
            C = "Cond"+A;
            set (B+".Cond", A);
            set (B+".Elm1", eval(C+"Elm1"));
            set (B+".Comp", eval(C+"Comp"));
            set (B+".Elm2", eval(C+"Elm2"));
            LinesBots.attachMovie("Cond1Bots", "Bot"+A, A);
            ReaddSitLinep2();
         } while (A<Conds);
      }
      function ReaddCond2Lines () {
         // F6.
         A = 0;
         do {
            ReaddSitLinep();
            Lines.attachMovie("Cond2Line", "Line"+A, A);
            C = "Grup"+A;
            set (B+".Grup", A);
            D = 0;
            do {
               D = D+1;
               set (B+".p"+D, eval(C+"p"+D));
               set (B+".y"+D, eval(C+"y"+D));
            } while (D<10);
            LinesBots.attachMovie("Cond2Bots", "Bot"+A, A);
            ReaddSitLinep2();
         } while (A<Grups);
      }
      function ReaddCamLine () {
         // F8.
         A = 0;
         do {
            ReaddSitLinep();
            Lines.attachMovie("CamLine", "Line"+A, A);
            C = "Cam"+A;
            set (B+".Cond", eval(C+"Cond1"));
            set (B+".Elm", eval(C+"Elm"));
            set (B+".Elm1", eval(C+"Elm1"));
            set (B+".Op", eval(C+"Op"));
            set (B+".Elm2", eval(C+"Elm2"));
            C = 100*(A-1)*(A-1);
            setProperty (eval(B), _x, C);
            LinesBots.attachMovie("CamBots", "Bot"+A, A);
            set ("LinesBots.Bot"+A+".A", A);
            // En cada línea de bots, var que indica qué nro de linea es.
            setProperty ("LinesBots.Bot"+A, _x, C);
         } while (A<Cams);
      }
      // ////////////////////////////////////////
      // /////   Add líneas y sus botones   /////
      // ////////////////////////////////////////
      // ///////////   Dependencia 0   //////////
      // ////////////////////////////////////////
      function AddSitLine () {
         // Bot + en F2.
         SitElms = SitElms+1;
         B = "Lines.Line"+SitElms;
         Lines.attachMovie("SitLine", "Line"+SitElms, SitElms);
         set (B+".SitID", "Unrep"+SitElms);
         set (B+".SitVal", 5);
         set (B+".SitRep", "---");
         C = 23.4*(SitElms-1);
         setProperty (eval(B), _y, C);
         LinesBots.attachMovie("SitBots", "Bot"+SitElms, SitElms);
         set ("LinesBots.Bot"+SitElms+".A", SitElms);
         // En cada línea de bots, var que indica qué nro de linea es.
         setProperty ("LinesBots.Bot"+SitElms, _y, C);
         set ("SitID"+SitElms, "Unrep"+SitElms);
         set ("Unrep"+SitElms, 5);
         set ("Unrep"+SitElms+"Rep", "---");
         set ("Unrep"+SitElms+"Tipo", "RepBas");
         set ("Unrep"+SitElms+"Repis", "Max");
         set ("Unrep"+SitElms+"RepMin", 0);
         set ("Unrep"+SitElms+"RepMax", 5);
      }
      function AddCond1Line () {
         // Bot + en F4.
         Conds = Conds+1;
         B = "Lines.Line"+Conds;
         Lines.attachMovie("Cond1Line", "Line"+Conds, Conds);
         set (B+".Cond", Conds);
         set (B+".Elm1", "---");
         set (B+".Comp", "---");
         set (B+".Elm2", "---");
         C = 23.4*(Conds-1);
         setProperty (eval(B), _y, C);
         LinesBots.attachMovie("Cond1Bots", "Bot"+Conds, Conds);
         set ("LinesBots.Bot"+Conds+".A", Conds);
         // En cada línea de bots, var que indica qué nro de linea es.
         setProperty ("LinesBots.Bot"+Conds, _y, C);
         set ("Cond"+Conds+"Elm1", "---");
         set ("Cond"+Conds+"Comp", "---");
         set ("Cond"+Conds+"Elm2", "---");
      }
      function AddCond2Line () {
         // Bot + en F6.
         Grups = Grups+1;
         B = "Lines.Line"+Grups;
         Lines.attachMovie("Cond2Line", "Line"+Grups, Grups);
         set (B+".Grup", Grups);
         A = 0;
         C = "Grup"+Grups+"p";
         D = "Grup"+Grups+"y";
         do {
            A = A+1;
            set (B+".p"+A, "---");
            set (C+A, "---");
            set (B+".y"+A, "---");
            set (D+A, "---");
         } while (A<10);
         C = 23.4*(Grups-1);
         setProperty (eval(B), _y, C);
         LinesBots.attachMovie("Cond2Bots", "Bot"+Grups, Grups);
         set ("LinesBots.Bot"+Grups+".A", Grups);
         // En cada línea de bots, var que indica qué nro de linea es.
         setProperty ("LinesBots.Bot"+Grups, _y, C);
      }
      // ////////////////////////////////////////
      // ///   Remove líneas y sus botones   ////
      // ////////////////////////////////////////
      // ///////////   Dependencia 0   //////////
      // ////////////////////////////////////////
      function RemoveSitLine () {
         // Bot - en F2.
         if (SitElms>1) {
            removeMovieClip ("Lines.Line"+SitElms);
            removeMovieClip ("LinesBots.Bot"+SitElms);
            SitElms = SitElms-1;
         }
      }
      function RemoveCond1Line () {
         // Bot - en F4.
         if (Conds>1) {
            removeMovieClip ("Lines.Line"+Conds);
            removeMovieClip ("LinesBots.Bot"+Conds);
            Conds = Conds-1;
         }
      }
      function RemoveCond2Line () {
         // Bot - en F6.
         if (Grups>1) {
            removeMovieClip ("Lines.Line"+Grups);
            removeMovieClip ("LinesBots.Bot"+Grups);
            Grups = Grups-1;
         }
      }
      // ////////////////////////////////////////
      // ////////////////   Ax   ////////////////
      // ////////////////////////////////////////
      // ///////////   Dependencia 0   //////////
      // ////////////////////////////////////////
      function Mainx () {
         // Func LinesBotsx, MainxCalc
         setProperty ("Bots", _visible, false);
         setProperty ("Manto", _visible, true);
      }
      // ////////////////////////////////////////
      // ///////////   Dependencia 1   //////////
      // ////////////////////////////////////////
      function LinesBotsx () {
         // SitRep, List, Operadores, Comparadores,
         // Func LinesBotsxCalc
         Mainx();
         setProperty ("LinesBots", _visible, false);
      }
      // ////////////////////////////////////////
      // ///////////////   AxB   ////////////////
      // ////////////////////////////////////////
      // ///////////   Dependencia 0   //////////
      // ////////////////////////////////////////
      function LinesBotsxCalc () {
         // Bot Sitval.
         LinesBotsx();
         attachMovie("Calc", "Vent", 1);
      }
      function MainxCalc () {
         // Bots de CB
         Mainx();
         attachMovie("Calc", "Vent", 1);
      }
      function VentxLinesBots () {
         // Func CalcmaynotifP, CalcmaynotifHS, Calcrepcheck
         // Bot Ok de Calc, Func SitRepmaynotifP, Bot ---
         // RepPinvalid, RepHSMinMax. Bot Ok de SitRepHS
         removeMovieClip ("Vent");
         setProperty ("Manto", _visible, false);
         setProperty ("Bots", _visible, true);
         setProperty ("LinesBots", _visible, true);
      }
      // ////////////////////////////////////////
      // //////////////   Otros   ///////////////
      // ////////////////////////////////////////
      // ///////////   Dependencia 0   //////////
      // ////////////////////////////////////////
      function RepPmaynotif () {
         // Fun Calcrepcheck, SitRep
         D = eval(D);
         if (D == Math.floor(D) && D>0) {
            VentxLinesBots();
         } else {
            attachMovie("RepPinvalid", "Vent", 1);
         }
      }
      function RepHSmaynotif () {
         // Fun Calcrepcheck, bot ok de Calc, bot ok de SitRepHS
         if (eval(E+"Min")<=eval(E+"Max")) {
            VentxLinesBots();
         } else {
            // Notificación.
            attachMovie("RepHSMinMax", "Vent", 1);
         }
      }
      function SitRepp () {
         // Bots de SitRep.
         B = eval(A);
         // Abreviación de la referencia al nuevo ID
         set (B, eval(D));
         set (B+"Tipo", "RepBas");
         set (B+"Repis", eval(D+"Repis"));
         set (B+"RepMin", eval(D+"RepMin"));
         set (B+"RepMax", eval(D+"RepMax"));
      }
      // ////////////////////////////////////////
      // //////////////   DoReps   //////////////
      // ////////////////////////////////////////
      // ///////////   Dependencia 0   //////////
      // ////////////////////////////////////////
      //
      //
      // CHEQUED: Usos, >1, abreviante, nombre indicado.
      //
      //
      function DoRepBC () {
         // DoRepHp1, DoRepHp1.
         B = eval("SitID"+A);
         // Contenido de SitID(num). Ej: "H1".
         C = "Rep."+B;
         // Para abreviar referencia a la movie interior. Ej: "Rep.H1"
      }
      function DoRepCuadroH () {
         // También usada en DoRepH.
         Rep.attachMovie("RepH", B, A);
         setProperty (eval(C), _x, 20);
         setProperty (eval(C), _y, 150);
      }
      function DoRepPVM () {
         // También usada en DoRepVp1.
         set (B+"Puntos", D);
         // Cantidad de puntos que habrá. Usado por Mod para...
         // saber si hay que agregar o quitar puntos.
         set (C+".ValDis", E);
         // Queda pues se requiere en chequeos y...
         // puede por ej para agregar un objeto.
         set (C+".Margen", F);
         // Similar.
      }
      function DoRepxd () {
         setProperty (eval(C+".P"+D), _x, F+E*(D-1));
         D = D-1;
      }
      function DoRepyd () {
         setProperty (eval(C+".P"+D), _y, F+E*(D-1));
         D = D-1;
      }
      function DoRepwi () {
         setProperty (eval(C+".P"+D), _width, E/2);
         setProperty (eval(C+".P"+D), _height, E/2);
      }
      // ////////////////////////////////////////
      // ///////////   Dependencia 1   //////////
      // ////////////////////////////////////////
      function DoRepHp1 () {
         // También usada en DoRepV.
         DoRepBC();
         D = eval(B);
         // Contenido del contenido de B, que es una referencia. Ej: 5.
      }
      function DoRepHp2 () {
         // También usada en ModRepH.
         E = 360/D;
         F = 360/(D*2);
         DoRepPVM();
      }
      function DoRepVp1 () {
         // También usada en ModRepV
         E = 260/D;
         F = 260/(D*2);
         DoRepPVM();
      }
      function DoRepcxd () {
         eval(C).attachMovie("Cros", "P"+D, D);
         DoRepxd();
      }
      function DoRepcyd () {
         eval(C).attachMovie("Cros", "P"+D, D);
         DoRepyd();
      }
      function DoRepcw () {
         eval(C).attachMovie("Cros", "P"+D, D);
         DoRepwi();
      }
      function DoRepvxd () {
         eval(C).attachMovie("LineV", "P"+D, D);
         DoRepxd();
      }
      function DoRephyd () {
         eval(C).attachMovie("LineH", "P"+D, D);
         DoRepyd();
      }
      function DoRepxdo () {
         do {
            DoRepxd();
         } while (D>0);
      }
      function DoRepydo () {
         do {
            DoRepyd();
         } while (D>0);
      }
      // ////////////////////////////////////////
      // ///////////   Dependencia 2   //////////
      // ////////////////////////////////////////
      function DoRepcxdo () {
         do {
            DoRepcxd();
         } while (D>0);
      }
      function DoRepcydo () {
         do {
            DoRepcyd();
         } while (D>0);
      }
      function DoRepcwxdo () {
         do {
            DoRepcw();
            DoRepxd();
         } while (D>0);
      }
      function DoRepcwydo () {
         do {
            DoRepcw();
            DoRepyd();
         } while (D>0);
      }
      function DoRepvxdo () {
         do {
            DoRepvxd();
         } while (D>0);
      }
      function DoRephydo () {
         do {
            DoRephyd();
         } while (D>0);
      }
      // ////////////////////////////////////////
      // ///////////   Dependencia 3   //////////
      // ////////////////////////////////////////
      function DoRepH () {
         // F6
         DoRepHp1();
         DoRepCuadroH();
         if (D == Math.floor(D) && D>0) {
            // Agregar puntos (cruces o líneas v) en horizontal.
            DoRepHp2();
            if (E>=22) {
               // Tamaño ok para cruces normales.
               DoRepcxdo();
            } else if (E>=11) {
               // Tamaño reducido.
               DoRepcwxdo();
            } else {
               // Líneas verticales.
               DoRepvxdo();
            }
         } else {
            set (B+"Puntos", 0);
         }
      }
      function DoRepV () {
         // F6
         DoRepHp1();
         Rep.attachMovie("RepV", B, A);
         setProperty (eval(C), _x, 200);
         setProperty (eval(C), _y, 20);
         if (D == Math.floor(D) && D>0) {
            // Agregar puntos (cruces o líneas h) en vertical.
            E = 260/D;
            F = 260/(D*2);
            DoRepPVM();
            if (E>=22) {
               // Tamaño ok para cruces normales.
               DoRepcydo();
            } else if (E>=11) {
               // Tamaño reducido.
               DoRepcwydo();
            } else {
               // Líneas horizontales.
               DoRephydo();
            }
         } else {
            set (B+"Puntos", 0);
         }
      }
      function DoRepHS () {
         // F6
         DoRepBC();
         DoRepCuadroH();
         set (C+".Dif", eval(B+"Max")-eval(B+"Min"));
         // Queda pues se requiere en chequeos.
      }
      // ////////////////////////////////////////
      // //////////////   ModReps   /////////////
      // ////////////////////////////////////////
      // ///////////   Dependencia 0   //////////
      // ////////////////////////////////////////
      function ModRepHp1 () {
         // También usado por ModRepV.
         C = "Rep."+B;
         // Para abreviar referencia a la movie interior. Ej: "Rep.H1"
         D = eval(B);
         // Contenido del contenido de B, que es una referencia. Ej: 5.
      }
      //
      //
      // CHEQUED: Usos, >1, abreviante, nombre indicado.
      //
      //
      function ModRepHRemove () {
         // ModRepH, ModRepV.
         H = G;
         do {
            removeMovieClip (eval(C+".P"+H));
            H = H-1;
         } while (D<H);
      }
      // ////////////////////////////////////////
      // ///////////   Dependencia 1   //////////
      // ////////////////////////////////////////
      function ModRepH () {
         // F7
         ModRepHp1();
         // Contenido del contenido de B, que es una referencia. Ej: 5.
         if (D == Math.floor(D) && D>0) {
            // Rep posible.
            G = eval(B+"Puntos");
            // Abreviador de la cantidad de marcas. Ej: 5
            DoRepHp2();
            if (D>G) {
               // El valor aumentó; agregar marcas.
               if (E>=22) {
                  // Tamaño ok para cruces normales.
                  do {
                     DoRepcxd();
                  } while (D>G);
                  // Redistanciar las que había, si había.
                  if (D>0) {
                     DoRepxdo();
                  }
               } else if (E>=11) {
                  // Tamaño reducido.
                  do {
                     DoRepcw();
                     DoRepxd();
                  } while (D>G);
                  // Redistanciar y reducir, a las que había.
                  do {
                     DoRepwi();
                     DoRepxd();
                  } while (D>0);
               } else {
                  // Líneas verticales.
                  if (G<33) {
                     // No había. Agregar normalmente.
                     DoRepvxdo();
                  } else {
                     // Ya había. Agregar sólo las necesarias.
                     do {
                        DoRepvxd();
                     } while (D>G);
                     // Redistanciar las que había.
                     DoRepxdo();
                  }
               }
            } else if (D<G) {
               // El valor disminuyó; hay que quitar marcas.
               ModRepHRemove();
               if (G<33) {
                  // Había cruces.
                  if (E>=22) {
                     // Serán de tamaño normal.
                     if (eval(C+".P1._width") == 11) {
                        // Ya lo tienen; Sólo cambiar posiciones.
                        DoRepxdo();
                     } else {
                        // No lo tienen; redistanciar y a tenerlo.
                        do {
                           setProperty (eval(C+".P"+D), _width, 11);
                           setProperty (eval(C+".P"+D), _height, 11);
                           DoRepxd();
                        } while (D>0);
                     }
                  } else {
                     // Serán de tamaño reducido; redistanciar y a tenerlo.
                     DoRepcwxdo();
                  }
                  // En los siguientes casos había líneas.
               } else if (E>=22) {
                  // Colocar cruces desde 1, tamaño normal.
                  DoRepcxdo();
               } else if (E>=11) {
                  // Colocar cruces desde 1, tamaño reducido.
                  DoRepcwxdo();
               } else {
                  // Redistanciar líneas.
                  DoRepxdo();
               }
            }
         } else {
            // Ocultar rep o mostrar cartelito de imposibilidad
         }
      }
      function ModRepV () {
         // F7
         ModRepHp1();
         if (D == Math.floor(D) && D>0) {
            // Rep posible.
            G = eval(B+"Puntos");
            DoRepVp1();
            if (D>G) {
               // El valor aumentó; agregar marcas.
               if (E>=22) {
                  // Tamaño ok para cruces normales.
                  do {
                     DoRepcyd();
                  } while (D>G);
                  // Redistanciar las que había, si había.
                  if (D>0) {
                     DoRepydo();
                  }
               } else if (E>=11) {
                  // Tamaño reducido.
                  do {
                     DoRepcw();
                     DoRepyd();
                  } while (D>G);
                  // Redistanciar y reducir, a las que había.
                  do {
                     DoRepwi();
                     DoRepyd();
                  } while (D>0);
               } else {
                  // Líneas verticales.
                  if (G<33) {
                     // No había. Agregar normalmente.
                     DoRephydo();
                  } else {
                     // Ya había. Agregar sólo las necesarias.
                     do {
                        DoRephyd();
                     } while (D>G);
                     // Redistanciar las que había.
                     DoRepydo();
                  }
               }
            } else if (D<G) {
               // El valor disminuyó; hay que quitar marcas.
               ModRepHRemove();
               if (G<33) {
                  // Había cruces.
                  if (E>=22) {
                     // Serán de tamaño normal.
                     if (eval(C+".P1._width") == 11) {
                        // Ya lo tienen; Sólo cambiar posiciones.
                        DoRepydo();
                     } else {
                        // No lo tienen; redistanciar y a tenerlo.
                        do {
                           setProperty (eval(C+".P"+D), _width, 11);
                           setProperty (eval(C+".P"+D), _height, 11);
                           DoRepyd();
                        } while (D>0);
                     }
                  } else {
                     // Serán de tamaño reducido; redistanciar y a tenerlo.
                     DoRepcwydo();
                  }
                  // En los siguientes casos había líneas.
               } else if (E>=22) {
                  // Colocar cruces desde 1, tamaño normal.
                  DoRepcydo();
               } else if (E>=11) {
                  // Colocar cruces desde 1, tamaño reducido.
                  DoRepcwydo();
               } else {
                  // Redistanciar líneas.
                  DoRepydo();
               }
            }
         } else {
            // Ocultar rep o mostrar cartelito de imposibilidad
         }
      }
      // ////////////////////////////////////////
      // ///////////   Comparaciones   //////////
      // ////////////////////////////////////////
      function CompEq () {
         if (C1A1 == C1A2) {
            Oks = Oks+1;
         }
      }
      function CompUn () {
         if (C1A1 != C1A2) {
            Oks = Oks+1;
         }
      }
      function CompEL () {
         if (C1A1<=C1A2) {
            Oks = Oks+1;
         }
      }
      function CompLs () {
         if (C1A1<C1A2) {
            Oks = Oks+1;
         }
      }
      function CompEM () {
         if (C1A1>=C1A2) {
            Oks = Oks+1;
         }
      }
      function CompMr () {
         if (C1A1>C1A2) {
            Oks = Oks+1;
         }
      }
      // Flash:
      Fram = 2;
      gotoAndStop (2);
   actions for fotograma 2
      ReaddSitLine();
   Bot < y > de Sit, (Bots)
   Mv, (Lines)
   Mv, (LinesBots)
   actions for fotograma 4
      ReaddCond1Line();
   Mv, (Lines)
   Mv, (LinesBots)
   Bot < y > de Cond1, (Bots)
   actions for fotograma 6
      ReaddCond2Lines();
   Mv, (Lines)
   Mv, (LinesBots)
   Bot < y > de Cond2, (Bots)
   actions for fotograma 8
      ReaddCamLine();
   Mv, (Lines)
   Mv, (LinesBots)
   Bot < y >, (Bots)
   CB Bots, (Bots)
   actions for fotograma 12
      // Reps.
      A = 1;
      do {
         B = eval(eval("SitID"+A)+"Rep");
         if (B == "Extensión horizontal") {
            DoRepH();
         } else if (B == "Extensión vertical") {
            DoRepV();
         } else if (B == "Extensión horizontal simbólica") {
            DoRepHS();
         }
         A = A+1;
      } while (A<=SitElms);
      Act = ActIni;
      play ();
   actions for fotograma 13
      // Cam
      Oks = 0;
      ReqOks = 1;
      A = 0;
      do {
         A = A+1;
         B = eval("Cam"+A+"Cond1");
         // Por ahora sólo se analiza 1 condición, pero...
         // hay "ors".
         if (B == "---") {
            // No hay condiciones a cumplir.
            Oks = ReqOks;
         } else {
            // Ver cuales son las condiciones y si se cumplen.
            // Por ahora sólo la 1er y.
            C1 = eval("Grup"+B+"y1");
            C1A1 = eval("Cond"+C1+"Elm1");
            C1A1T = eval("Cond"+C1+"Elm1T");
            if (C1A1T == "Elm") {
               C1A1 = eval(C1A1);
            } else {
               C1A1 = "---";
            }
            C1C = eval("Cond"+C1+"CompT");
            C1A2 = eval("Cond"+C1+"Elm2");
            C1A2T = eval("Cond"+C1+"Elm2T");
            if (C1A2T == "Elm") {
               C1A2 = eval(C1A2);
            } else {
               C1A2 = "---";
            }
            eval("Comp"+C1C)();
         }
         if (Oks>=ReqOks) {
            // Iniciar cam.
            // Averigua qué Elms usará, cómo, según el tipo
            B = eval("Cam"+A+"Tipo1");
            if (B == "Elm") {
               C = eval(eval("Cam"+A+"Elm1"));
            } else if (B == "Num") {
               C = eval("Cam"+A+"Elm1");
            } else if (B == "Entero") {
               C = Math.floor(eval(eval("Cam"+A+"Elm1Cen")));
            } else {
               C = "---";
            }
            // El 2ndo Elm.
            B = eval("Cam"+A+"Tipo2");
            if (B == "Elm") {
               D = eval(eval("Cam"+A+"Elm2"));
            } else if (B == "Num") {
               D = eval("Cam"+A+"Elm2");
            } else if (B == "Entero") {
               D = Math.floor(eval(eval("Cam"+A+"Elm2Cen")));
            } else {
               D = "---";
            }
            B = eval("Cam"+A+"Elm");
            // Abrevia referencia a la var en que Act se aplica. Ej: "H1"
            // Hay que poner el caso de C (elm1) ---
            if (D == "---") {
               set (B, C);
            } else if (eval("Cam"+A+"Op") == "+") {
               set (B, C+D);
            } else if (eval("Cam"+A+"Op") == "-") {
               set (B, C-D);
            } else if (eval("Cam"+A+"Op") == "*") {
               set (B, C*D);
            } else if (eval("Cam"+A+"Op") == "/") {
               set (B, C/D);
            } else if (eval("Cam"+A+"Op") == "^") {
               set (B, Math.pow(C, D));
            }
            if (eval(B+"Tipo") == "RepTipo") {
               //
            } else if (eval(B+"Tipo") == "RepBas") {
               if (eval(B+"Rep") == "Extensión horizontal") {
                  ModRepH();
               } else if (eval(B+"Rep") == "Extensión vertical") {
                  ModRepV();
               }
            }
         }
      } while (A<Cams);
   actions for fotograma 14
      // ObjCheck.
      Oks = 0;
      ReqOks = 1;
      // Por ahora sólo se analiza 1 condición, pero...
      // hay "ors".
      // Ver cuales son las condiciones y si se cumplen.
      // Por ahora sólo la 1er y.
      C1 = eval("Grup"+Sol1+"y1");
      C1A1 = eval("Cond"+C1+"Elm1");
      C1A1T = eval("Cond"+C1+"Elm1T");
      if (C1A1T == "Elm") {
         C1A1 = eval(C1A1);
      } else {
         C1A1 = "---";
      }
      C1C = eval("Cond"+C1+"CompT");
      C1A2 = eval("Cond"+C1+"Elm2");
      C1A2T = eval("Cond"+C1+"Elm2T");
      if (C1A2T == "Elm") {
         C1A2 = eval(C1A2);
      } else {
         C1A2 = "---";
      }
      eval("Comp"+C1C)();
   actions for fotograma 15
      if (Oks<ReqOks) {
         // ActMod.
         if (ActOp == "+") {
            Act = Act + ActMod;
         } else if (ActOp == "-") {
            Act = Act - ActMod;
         } else if (ActOp == "*") {
            Act = Act * ActMod;
         } else if (ActOp == "/") {
            Act = Act / ActMod;
         } else {
            Act = Math.pow ( Act, ActMod );
         }
         // No a ese frame, hay que resetear sit.
         // Por ahí también hay que mostrar reps si se ocultaron.
         gotoAndPlay (13);
      }
   actions for fotograma 16
      stop ();
    Bot Reset
      actions for Bot Reset
         on (release, keyPress "<Space>") {
            A = Objs*2;
            B = 1;
            do {
               set ("Obj"+B, B);
               B = B+1;
            } while (B<=A);
            Fram = 2;
            gotoAndStop (2);
         }
   Mv, (Rep)


Aquí el archivo editable (precisas Macromedia Flash 5, no sé bien cómo conseguirlo, yo lo tengo instalado, pero, para leer el archivo quizá te sirva una versión cualquiera más avanzada, de Flash):
https://dl.dropboxusercontent.com/u/169164922/C2.fla
Sólo resuelve problemas que se puedan resolver en 1 acción y tiene varias otras limitaciones, según estoy viendo:
http://www.forosdelweb.com/f14/reto-fav ... ost4747316
(desde donde dice Problema 1 en negrita).
Repito es del 28/5, no te va a servir de mucho.

Algo más actualizado...
Spoiler: show
Imagen

Eso (que son varias pantallas en realidad) fue hecho dejando de lado el tema de la representación en pantalla (las rayitas, aunque la idea era que las formas de representaciones pudieran ser más). Tengo una versión que funciona, de... 22/9, también dejada de lado ergo con errores no sé en qué casos, pero esa no la voy a compartir (puede resolver problemas que requieren más de una acción, aunque sencillos sí), además genera archivos en la computadora y es un exe, no se podría ver y usar sin descargar como sí los otros.
Bueno ¿diferencias en la interfase?
- El tema de la representación se dejó de lado. Era complicado eso y quería avanzar en lo importante, eso era más bien "estética".
- El ID de las variables pasó a ser siempre "V"+número. Expliqué los motivos aquí:
http://www.forosdelweb.com/f14/reto-fav ... ost4746972
- Permite usar M.Act en vez de Act, no recuerdo bien el motivo.
- La definición de condiciones fue simplificada, son todas "y", ya no hay "pero no" (las "pero no" se definirían al revés, como negaciones, o en otro grupo).
- Cambio en el orden de las pantallas, tampoco recuerdo el motivo.
- La solución se define como un grupo or de condiciones. Si mal no recuerdo. Significa que si se ponen 2 o más grupos, alcanza conque se cumpla 1 para que se considere que se cumplió la condición. Si eso no se quiere entonces hay que agrandar los grupos o crear una unión o poner menos grupos en la parte de solución.
- CompChar se usa como expliqué de CompNum en el link que di más arroba. Lo ideal sería que se defina automáticamente pero eso me pareció absurdo, es decir hacer un if a cada rato por algo que generalmente podría definirse en principio...
- Ya no se usan "---" para "nada".

Ok, luego de que Nil dijera "eso conviene hacerlo en texto plano" y cansado yo con el tema que se me avecinaba, de decirle al programa cómo interpretar estructuras tipo "V1*2 > V2+1" y permitirlas, seguí su consejo y ahora todo es más simple, aunque menos usable, es decir, ahora es todo código, ya no hay interfase, y sólo lo puedo usar yo o quien sepa programar.
Aquí habrá más info:
http://www.forosdelweb.com/f14/reto-fav ... r-1138773/

Copiaré la explicación general en el tema, por si alguien más me pregunta (sino tengo que volver a escribir todo esto, imaginate xP ), espero no te importe.
Pero ya fue... la idea era que mi programa pudiese usarse como se usa una calculadora, simplemente ingresar cosas y listo, no tener que programar propiamente dicho. Me sigue pareciendo una buena idea, adelante si alguien quiere seguirla, pero me parece bastante complicado sin que de mucho resultado útil. En principio sugiero resolver problemas difíciles; el tema de representarlo con dibujos y cómo se busca la solución y que pueda "programarse sin saber un lenguaje de programación" mejor dejarlo para más adelante...

_________________
Si no puedes hacerlo, intenta primero hacer algo más simple aunque similar.


Arriba
 Perfil  
Responder citando  
Mostrar mensajes previos:  Ordenar por  
Nuevo tema Responder al tema  [ 2 mensajes ] 

Todos los horarios son UTC + 1 hora [ DST ]


¿Quién está conectado?

Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 1 invitado


No puede abrir nuevos temas en este Foro
No puede responder a temas en este Foro
No puede editar sus mensajes en este Foro
No puede borrar sus mensajes en este Foro

Buscar:
Saltar a:  
POWERED_BY
Traducción al español por Huan Manwë para phpbb-es.com
phpBB SEO