Serie ficheros virtuales

 

 

 

 

RPG Ficheros virtuales

 

 

 

- Sudokus

 

 

- Introducción

 

- Servicios de SRMAGIC

 

- Programa interfaz

 

- Código fuente

 - Código añadido para interacción lúdica

 

 ________

 

 

- Introducción

 

 

En el capítulo  A.II.1 Cuadrados mágicos y sudokus  del blog hermano  C Ficheros virtuales  de la  serie ficheros virtuales,  se presentaba un ejemplo implementado en lenguaje C de generación de Sudokus y Cuadrados Mágicos.

 

Posteriormente se ha ido presentando la implementación en otros lenguajes y plataformas y ahora se presenta la versión iSeries mediante un programa de servicio en C, SRMAGIC, y un interfaz de pantalla en RPG, CCMAGIC. 

 

 

 ________



- Servicios de SRMAGIC

 

 

Se presenta a continuación la lista de servicios de SRMAGIC. Son de destacar SRMAGIC_OPEN y SRMAGIC_GEN que se encargan respectivamente de crear los ficheros virtuales de soporte y de generar cada sudoku. El resto de servicios permiten extraer los datos y controlar la visualización. Se presenta tanto la versión C como su traducción a RPG.

 

 

 

 

 

     long SRMAGIC_ACTIVAR(long i, long j);

 

 

 

     * Activa la visualización de una celda

 

     DSRMAGIC_ACTIVAR  PR            10I 0                                      PosiciónItem/0=Error

     D P_I                           10I 0 VALUE                                Coordenada I      *I

     D P_J                           10I 0 VALUE                                Coordenada J      *I

 

 

 

   

 

      long SRMAGIC_CHAIN(long i, long j, long *k, short int *a);

 

 

      * Recuperación de un ítem de cuadro

 

     DSRMAGIC_CHAIN    PR            10I 0                                      PosiciónItem/0=Error

     D P_I                           10I 0 VALUE                                Coordenada I      *I

     D P_J                           10I 0 VALUE                                Coordenada J      *I

     D P_K                           10I 0                                      Valor de la celda *O

     D P_A                           10I 0                                      0/1 Activa:visible*O

 

 

 

 

      long SRMAGIC_CHAINRSV(long i, long j, long *k, short int *a);

 

 

      * Recuperación de un ítem de cuadro reserva de la situación original

 

     DSRMAGIC_CHAINR   PR            10I 0 EXTPROC('SRMAGIC_CHAINRSV')          PosiciónItem/0=Error

     D P_I                           10I 0 VALUE                                Coordenada I      *I

     D P_J                           10I 0 VALUE                                Coordenada J      *I

     D P_K                           10I 0                                      Valor de la celda *O

     D P_A                           10I 0                                      0/1 Activa:visible*O

 

 

 

 

      short int SRMAGIC_CLOSE(void);

 

 

      * Cierre general estilo PC

 

     DSRMAGIC_CLOSE    PR            10I 0                                      0/1 Error de proceso

 

 

 

 

      long SRMAGIC_DESACTIVAR(long i, long j);

 

 

      * Desactiva la visualización de una celda

 

     DSRMAGIC_DESACTI  PR            10I 0 EXTPROC('SRMAGIC_DESACTIVAR')        PosiciónItem/0=Error

     D P_I                           10I 0 VALUE                                Coordenada I      *I

     D P_J                           10I 0 VALUE                                Coordenada J      *I

 

 

 

 

      char* SRMAGIC_EDIT(long k);

 

 

      * Editor para presentación k --> cK

 

     DSRMAGIC_EDIT     PR              *                                        Valor K editado

     D P_K                           10I 0 VALUE                                Valor a editar    *I

 

 

 

 

      void SRMAGIC_GEN(short int Sudoku, long N);

 

 

      * Rutina de generación principal

 

     DSRMAGIC_GEN      PR

     D P_Sudoku                      10I 0 VALUE                                0/1 GenerarSudoku *I

     D P_N                           10I 0 VALUE                                Dimensión         *I

 

 

 

 

      long SRMAGIC_NUMACTIVAS(void);

 

 

      * Cuenta de celdas activas (Visualizables)

 

     DSRMAGIC_NUMACT   PR            10I 0 EXTPROC('SRMAGIC_NUMACTIVAS')        NºDe celdas activas

 

 

 

 

      long SRMAGIC_NUMACTIVASCOLUMNA(long j);

 

 

      * Cuenta de celdas activas en la columna J

 

     DSRMAGIC_NUMACTC  PR            10I 0 EXTPROC('SRMAGIC_NUMACTIVASCOLUMNA') NºDe celdas activas

     D P_J                           10I 0 VALUE                                Columna J         *I

 

 

 

 

      long SRMAGIC_NUMACTIVASFILA(long i);

 

 

      * Cuenta de celdas activas en la fila I

 

     DSRMAGIC_NUMACTF  PR            10I 0 EXTPROC('SRMAGIC_NUMACTIVASFILA')    NºDe celdas activas

     D P_I                           10I 0 VALUE                                Fila I            *I

 

 

 

 

      long SRMAGIC_NUMDESACTIVAS(void);

 

 

      * Cuenta de celdas desactivas (No visualizables)

 

     DSRMAGIC_NUMDES   PR            10I 0 EXTPROC('SRMAGIC_NUMDESACTIVAS')     NºDe celdas desactiv

 

 

 

 

      long SRMAGIC_OPEN(void);

 

 

      * Apertura de proceso. Crea ficheros virtuales de soporte

 

     DSRMAGIC_OPEN     PR            10I 0                                      NID 'PMAGICR' 0=Erro

 

 

 

 

      long SRMAGIC_RANDIMPAR(long lNMAX);

 

 

      * Generador de randoms impares

 

     DSRMAGIC_RANDIMP  PR            10I 0 EXTPROC('SRMAGIC_RANDIMPAR')         Random solicitado

     D P_N                           10I 0 VALUE                                Dimensión         *I

 

 

 

 

      long SRMAGIC_RANDCUADRADO(long lNMAX);

 

 

      * Genera numero aleatorio impar base y devuelve su cuadrado

 

     DSRMAGIC_RANDCUA  PR            10I 0 EXTPROC('SRMAGIC_RANDCUADRADO')      Random solicitado

     D P_N                           10I 0 VALUE                                Dimensión         *I

 

 

 

 

      long SRMAGIC_RANDOM(long N);

 

 

      * Generador de randoms

 

     DSRMAGIC_RANDOM   PR            10I 0                                      Random solicitado

     D P_N                           10I 0 VALUE                                Dimensión         *I

 

 

 

 

      short int SRMAGIC_READ(long l, long *i, long *j, long *k, short int *a);

 

 

      * Lectura secuencial de ítem de cuadro

 

     DSRMAGIC_READ     PR            10I 0                                      0/1 Error de lectura

     D P_L                           10I 0 VALUE                                ÍndiceLectSecuenci*I

     D P_I                           10I 0                                      Coordenada I asoc *O

     D P_J                           10I 0                                      Coordenada J asoc *O

     D P_K                           10I 0                                      Valor de la celda *O

     D P_A                           10I 0                                      0/1 Activa:visible*O

 

 

 

 

      short int SRMAGIC_READACTIVA(long l, long *i, long *j, long *k);

 

 

      * Lectura secuencial de siguiente ítem de cuadro visualizable (Activo)

 

     DSRMAGIC_READACT  PR            10I 0 EXTPROC('SRMAGIC_READACTIVA')        0/1 Error de lectura

     D P_L                           10I 0 VALUE                                ÍndiceLectSecuenci*I

     D P_I                           10I 0                                      Coordenada I asoc *O

     D P_J                           10I 0                                      Coordenada J asoc *O

     D P_K                           10I 0                                      Valor de la celda *O

 

 

 

 

      short int SRMAGIC_READDESACTIVA(long l, long *i, long *j, long *k);

 

 

      * Lectura secuencial de siguiente ítem de cuadro no visualizable (Desactivo)

 

     DSRMAGIC_READDES  PR            10I 0 EXTPROC('SRMAGIC_READDESACTIVA')     0/1 Error de lectura

     D P_L                           10I 0 VALUE                                ÍndiceLectSecuenci*I

     D P_I                           10I 0                                      Coordenada I asoc *O

     D P_J                           10I 0                                      Coordenada J asoc *O

     D P_K                           10I 0                                      Valor de la celda *O

 

 

 

 

 

      long SRMAGIC_SUMACOLUMNA(long N, long j);

 

 

      * Suma de importes activos (visualizables) de una columna J

 

     DSRMAGIC_SUMACOL  PR            10I 0 EXTPROC('SRMAGIC_SUMACOLUMNA')       ImporteSolictado 0=E

     D P_N                           10I 0 VALUE                                Dimensión         *I

     D P_J                           10I 0 VALUE                                Columna J         *I

 

 

 

 

      long SRMAGIC_SUMAFILA(long N, long i);

 

 

      * Suma de importes activos (visualizables) de una fila I

 

     DSRMAGIC_SUMAFIL  PR            10I 0 EXTPROC('SRMAGIC_SUMAFILA')          ImporteSolictado 0=E

     D P_N                           10I 0 VALUE                                Dimensión         *I

     D P_I                           10I 0 VALUE                                Fila I            *I

 

 

 

 

      short int SRMAGIC_VERACTIVA(long i, long j);

 

 

      * Evalúa si una celda esta activa (Es visualizable)

 

     DSRMAGIC_VERACTI  PR            10I 0 EXTPROC('SRMAGIC_VERACTIVA')         0/1 Activa:visible

     D P_I                           10I 0 VALUE                                Coordenada I      *I

     D P_J                           10I 0 VALUE                                Coordenada J      *I

 

 

 

 

 

 


________

 

 


- Programa interfaz

 

  Se ha preparado el programa interfaz CCMAGIC que se encarga de generar sudokus e irlos desvelando paulatinamente.

 

 

  La imagen del resultado que presenta CCMAGIC es

 

 

 

 

 

CCMAGIC va mostrando los datos sucesivamente hasta presentar cada sudoku al completo si la función AUTO (F11) está activa

 

 

 

En el siguiente epígrafe se puede acceder al código fuente completo del programa interfaz.

 

En esencia, este consiste en una zona de datos donde una estructura iguala los campos de presentación con una serie de trabajo ELE(i,j) una carga inicial y un bucle de presentación de datos que se ejerce bajo autorrespuesta o bajo invocación manual.

 

Los mandatos disponibles son F3 salida, F5 nueva iteración, F7 generar un nuevo Sudoku (Invocando a SRMAGIC_GEN), F10 ver todo (Que ejecuta un bucle de activación de las celdas no visualizables) y F11 que permite activar/desactivar el mecanismo de autorrespuesta.

   


________

 

 

- Código fuente

 

El código del interfaz de presentación CCMAGIC se encuentra en

 

 Archivo de pantalla CCDMAGIC: http://iseries.ficherosvirtuales.com/QDDSSRC/QDDSSRC.CCDMAGIC

 Código del programa CCMAGIC : http://iseries.ficherosvirtuales.com/QRPGLESRC/QRPGLESRC.CCMAGIC

 Código adicional estructura : http://iseries.ficherosvirtuales.com/QRPGLESRC/QRPGLESRC.COCCD_MAGI

 

 

 

 

Fuente de los servicios de SRMAGIC

 

   Prototipos de exportación RPG : http://iseries.ficherosvirtuales.com/QCOPYSRC/QCOPYSRC.PSRMAGIC

   Prototipos de exportación en C: http://iseries.ficherosvirtuales.com/QCSRC/QCSRC.SRMAGICH

   Fuente principal en C . . . . : http://iseries.ficherosvirtuales.com/QCSRC/QCSRC.SRMAGIC

   Fuente de enlace  . . . . . . : http://iseries.ficherosvirtuales.com/QSRVSRC/QSRVSRC.SSRMAGIC

   Código adicional estructuras C: http://iseries.ficherosvirtuales.com/QCSRC/QCSRC.SRMAGICDS

 

 


________

 

 

 

 

- Código añadido para interacción lúdica

 

 

Utilizando la función SRMAGIC_ACTIVAR y el nuevo mandato F8, se pueden ir activando las celdas que se deseen por medio de un mapa de posición que se carga en un fichero virtual auxiliar. Tambíén se puede utilizar el nuevo mandato F9 para presentar una ventana de ensayo y error. La apariencia visual resultante es

 

 

 

   El mapa de enlace entre posiciones de pantalla y celdas del sudoku utiliza el fichero virtual DSMAGI cuyo mecanismo extractamos a continuación:

 

 

   Al invocar por primera vez F8 se crea y rellena DSMAGI

 

 

   Estructura de soporte de DSMAGI:

 

     D DSMAGIc         DS                  QUALIFIED BASED(pDSMAGIc)            Soporte  DSMAGI

     D  DSK                                LIKEDS(DSWKc)                        Claves   DSMAGI

     D  DSD                                LIKEDS(DSWKd)                        Datos    DSMAGI

 

     D DSWKc           DS                  QUALIFIED BASED(pDSWKc)              Claves

     D  CCFIL                        10S 0                                      FilaPantalla

     D  CCCOL                        10S 0                                      ColumnaPantalla

 

     D DSWKd           DS                  QUALIFIED BASED(pDSWKd)              Datos

     D  CCI                          10S 0                                      Sudoku(i,-)

     D  CCJ                          10S 0                                      Sudoku(-,j)

 

   Código de activación de celda (F8):

 

 . . .

 

// Activar celda

 

            if *IN08;

 

 

               // Carga inicial

 

               TTNID_MAGI = SRAGM_NID('DSMAGI');

               if TTNID_MAGI = *ZEROS;

                  TTNID_MAGI = PrCargaDSMAGI();

               endif;

 

 

               // Localización

 

               *IN90 = PrFilCol(FILCOL:TTFIL:TTCOL);

 

               clear DSMAGI;

 

               DSMAGI.DSK.CCFIL = TTFIL;

               DSMAGI.DSK.CCCOL = TTCOL;

 

               TTResu = SRAGM_CHAIN('DSMAGI':%addr(DSMAGI));

               if TTResu = *ZEROS;

                  iter;

               endif;

 

 

               // Accede a la celda seleccionada, eludiendo celdas ya vistas

 

               TTI = DSMAGI.DSD.CCI;

               TTJ = DSMAGI.DSD.CCJ;

 

               TTResu = SRMAGIC_CHAIN(TTI:TTJ:TTK:TTA);

               if TTA > *ZEROS;

               iter;

               endif;

 

 

               // Activa la celda seleccionada y la presenta en pantalla

 

               TTResu = SRMAGIC_ACTIVAR(TTI:TTJ);

 

               TTIJ = (TTI - 1) * (XXN + 2) + TTJ;

 

               ELE(TTIJ) = SRAGG_Dec(0:%len(ELE(1)):%decpos(ELE(1)):TTK);

 

               N1NP += 1;

 

 

               // Estadísticas

 

               *IN90 = PrEstadisticas();

 

               iter;

 

            endif;

 

 

   El código de carga de DSMAGI PrCargaDSMAGI se extracta como sigue:

 

 . . .

 

        // Crea DSMAGI soporte virtual del mapa de traducción pantalla --> celdas sudoku

 

         T_NID = SRAGM_NEW('DSMAGI':%size(DSMAGIc.DSK):%size(DSMAGIc));

 

 

         // Carga DSMAGI de fila en fila

 

         T_NGen  = PrCargaDSMAGI_I(1:6);

         ...

         T_NGen += PrCargaDSMAGI_I(9:16);

 

 

 

 Y el código de carga de cada línea I sería una repetición de sentencias como sigue:

 

 . . .

 

   // Columnas 1 a 3

 

         DSMAGI.DSD.CCJ = 1;

 

         DSMAGI.DSK.CCCOL = 16;

         for T_I = 1 to 4;

            DSMAGI.DSK.CCCOL += 1;

            T_Resu = SRAGM_WRITE('DSMAGI':%addr(DSMAGI)); // Se va cargando el mapa de relación celda-posiciones de pantalla

            if T_Resu > *ZEROS;

               T_NGEN += 1;

            endif;

         endfor;

 

                  etc

________

 

 

   En cuanto a la ventana de ensayo, que se invoca bajo F9, se ha encapsulado en el procedimiento PrW1 que sigue

 

 . . .

         // Recupera estadísticas de juego previas

         // (Al utilizar SRAGG_Pasoxx tienen una permanencia asociada al fichero virtual implícito que utiliza SRAGG [DSPASO])

 

         W1Ok = SRAGG_PasoRn('CCMAGIC.W1OK':%len(W1OK));

         W1Er = SRAGG_PasoRn('CCMAGIC.W1ER':%len(W1ER));

         W1Tt = W1Ok + W1Er;

 

         if W1Tt > *ZEROS;

 

            W1POk = SRAGG_DEC(100*W1Ok/W1Tt:%len(W1POk):%decpos(W1POk));

            W1PEr = SRAGG_DEC(100*W1Er/W1Tt:%len(W1PEr):%decpos(W1PEr));

 

         endif;

 

 

   // Ciclo de presentación

 

         dow true;

 

 

            // Presentación

 

            exfmt W1;

 

 

            // Salida

 

            if *IN03;

               leave;

            endif;

 

 

            // Inz control

 

            clear *IN91;

            clear *IN92;

            clear *IN93;

 

            clear W1ERRI;

            clear W1ERRJ;

            clear W1ERRK;

 

 

            // Control de entrada

 

            if W1I <= *ZEROS or W1I > 9;

 

               *IN91 = *ON;

               W1ERRI = 'ERROR';

 

               iter;

 

            endif;

 

 . . .

 

 

            // Acceso y control

 

            T_Resu = SRMAGIC_CHAIN(W1I:W1J:TTK:TTA);

            if TTA > *ZEROS;

               W1ERRK = 'Visto';

               iter;

            endif;

 

 

            // Error

 

            if W1K <> TTK;

 

               *IN93 = *ON;

               W1ERRK = '*NO* ';

 

               W1Er += 1;

               T_Resu = SRAGG_PasoW('CCMAGIC.W1ER':%editc(W1ER:'X'));

 

               W1Tt = W1Ok + W1Er;

 

               W1POk = SRAGG_DEC(100*W1Ok/W1Tt:%len(W1POk):%decpos(W1POk));

               W1PEr = SRAGG_DEC(100*W1Er/W1Tt:%len(W1PEr):%decpos(W1PEr));

 

               iter;

 

            endif;

 

 

            // Ok

 

            W1ERRK = ' OK! ';

 

            W1Ok += 1;

            T_Resu = SRAGG_PasoW('CCMAGIC.W1OK':%editc(W1OK:'X'));

 

            W1Tt = W1Ok + W1Er;

 

            W1POk = SRAGG_DEC(100*W1Ok/W1Tt:%len(W1POk):%decpos(W1POk));

            W1PEr = SRAGG_DEC(100*W1Er/W1Tt:%len(W1PEr):%decpos(W1PEr));

 

 

 

            // Activa la celda seleccionada

 

            T_Resu = SRMAGIC_ACTIVAR(W1I:W1J);

            N1NP += 1;

 

 

            // Actualiza resultados en pantalla principal

 

            *IN90 = PrDsp();

 

            write N1;

 

 

            // Inz control

 

            clear *IN91;

            clear *IN92;

            clear *IN93;

 

            clear W1ERRI;

            clear W1ERRJ;

 

         enddo;

 

. . .

________