#include <conio.h>

void Letrero(int AX_register );
char  mi_estruct[] = "Esto solo es una prueba, de mi primer programa en Assembly      JD     $                                                                                                                                                                     000018000000000000";

long dir_fuentes;


void main( void )
{


  Letrero( 1 );

 while( !kbhit() )
          Letrero( 0 );

}


void Letrero(int AX_register )
{

 asm{

 push DS
 mov AX, SEG mi_estruct
 mov DS, AX
 mov SI, OFFSET mi_estruct

 mov AX,  AX_register


//; Funci¢n para generar un letrero digital 100 % ASM
//;
//; Entradas:
//;               SI              ptr a las estructura de datos 256 bytes
//;
//;                      237 cadena a mostrar en el letrero: el final es $
//;                        2 posici¢n X
//;                        2 posici¢n Y
//;                        1 (1nibble Escala X | 2nibble Escala Y )
//;                        1 n£mero de d¡gitos a mostrar en pantalla
//;                        1 color de fondo
//;                        1 color principal
//;                     -----------------------------------------------
//;                        1 posici¢n dentro de la cadena
//;                        1 posici¢n en el byte
//;                        8 FUTURA AMPLIACIàN
//;
//;               AX              si 1, inicializa nuestra informacion
//;

//;  letrero_digital  PROC near    //;--------------------------------------------

        cmp AX, 1               //;  si no hay que inicializar nada,
        jne generar_digitos     //;  empezamos a generar los d¡gitos

        mov AX, 1130h           //;  obtenemos la direccion del juego
        mov BH,   03h           //;  de caracteres 8x8 de la ROM ( 0 - 127 )
        int 10h                 //;  Funci¢n de video 10h

        mov [dir_fuentes],   ES   //;  guardamos el segmento en dir_fuentes
        mov [dir_fuentes+2], BP   //;  guardamos el offset en dir_fuentes

        mov [SI + F6h], 0       //;  posicion dentro de la cadena <-- 0
        mov [SI + F7h], 0       //;  posicion dentro del byte <------ 0

     generar_digitos:

        mov BH, [ SI + F3h ]    //;  n§ de digitos a mostar

        push  [ SI + F6h ]      //;  guardo el contenido original de la pos.

        mov BP, [ SI + F6h ]    //;  posicion dentro de la cadena
        add BP, SI              //;  posicion del digito a procesar
                
        mov AL, [BP]            //;  digito a procesar



     nuevo_digito:

        mov AH, 0
        mov CL, 3               //;  multiplico por 8 AX para tener la
        shl AX, CL              //;  posicion dentro de la ROM
                                
        add AX, dir_fuentes+2   //;  cargo AX con la direccion de la letra

        mov CH, 0               //; recorre las 8 filas ( 0 - 7 )

     siguiente_fila:

//; **************************
         mov DH, 0
         mov DL, CH
         add AX, DX
//;        add AX, CH              //;  direccion por fila de la letra a recorrer
//; **************************
        mov BL, dir_fuentes:[AX]//;  colocamos en BL la fila del digito a tratar

        mov CL, 8               //;  recorre los 8 puntos horizontales
     
     sigue_horizontal:

//; ************************** muestro en (x,y) un punto o un espacio
        push AX        push BX        push CX

        mov DH, [SI+238]        //;  coordenada x inicial
        mov DL, [SI+240]        //;  coordenada y inicial

        add DL, CH              //;  coordenada y final

        mov AL, [SI+F3]         //; n§ de digitos a mostar
        sub AL, BH              //; ndm - digitos que quedan = digitos mostrados

        mov CL, 3               //;
        shl AL, CL              //; multiplico por 8 los digitos mostrados

        add DH, AL              //; coordenada y final
                        
        mov AH,   02h
        mov BH,    1h
        int 10h

        pop CX        pop BX        pop AX
//; ************************** muestro en (x,y) un punto o un espacio
//; ************************** muestro en (x,y) un punto o un espacio
        push AX        push BX        push CX

        shl BL, 1               //;  dezplaza 1 bit a la izquierda

        jc punto_letrero_on

        mov AL, 32d
                    
        jmp fin_punto

     punto_letrero_on:

        mov AL, 43d

     fin_punto:

        mov AH, 0Ah
        mov BH,  1h
        mov CX,  1h
        int 10h
        
        pop CX        pop BX        pop AX
//; ************************** muestro en (x,y) un punto o un espacio

        dec CL                  //;
        jnz sigue_horizontal    //;  continua hasta los 8 bit's

        inc CH                  //;
        cmp CH, 8               //;
        jne siguiente_fila      //;  procesa las 8 filas

        inc [ SI + F6h ]        //;  inc el puntero de posicion

        mov BP, [ SI + F6h ]    //;  posicion dentro de la cadena
        add BP, SI              //;  posicion del digito a procesar

        mov AL, [BP]            //;  digito a procesar

        inc [SI + F6h]          //;  inc la posicion dentro de la frase
        cmp AL, '$'             //;  si no fin de frase continuo normalmente
        jne es_fin_frase        //;
        mov [SI + F6h], 0       //;  si no, posicion de frase == 0

     es_fin_frase:

        dec  BH                 //;  solo visualiza los digitos que manda el
        jnz  nuevo_digito       //;  usuario.

        pop  [ SI + F6h ]       //;  restauro el contenido original de la pos.

        inc [ SI + F6h ]        //;  actualizo la rotacion para la proxima vez
        cmp AL, '$'             //;
        je frase_rotada         //;
        mov [ SI + F6h ], 0     //;

     frase_rotada:

        RET                     //;  regreso de la llamada

//;    letrero_digital endp


  POP DS
}


}