using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Codificación_UTF_8_01
{
    internal class Program
    {
        static void Main(string[] args)
        {
            #region Configuración ventana.
            // Título de la ventana.
            Console.Title = "Encoder UTF-8";
 
            // Tamaño de la ventana, x, y.
            Console.SetWindowSize(80, 25);
 
            // Color de fondo.
            Console.BackgroundColor = ConsoleColor.Gray;
 
            // Color de las letras.
            Console.ForegroundColor = ConsoleColor.Black;
 
            // Limpiar pantalla y dejarlo todo gris.
            Console.Clear();
 
            // Visible el cursor.
            Console.CursorVisible = true;
            #endregion
 
            // Cree una codificación UTF-8.
            UTF8Encoding utf8 = new UTF8Encoding();
 
            // Una cadena Unicode con dos caracteres fuera de un rango de código de 8 bits.
            String unicodeString =
                "Esta cadena Unicode tiene 2 caracteres fuera del " +
                "rango ASCII:\n" +
                "Pi (\u03a0), y Sigma (\u03a3).";
            Console.WriteLine("Cadena original:");
            Console.WriteLine(unicodeString);
 
            // Codifica la cadena.
            Byte[] encodedBytes = utf8.GetBytes(unicodeString);
            Console.WriteLine();
            Console.WriteLine("Bytes codificados:");
            for (int ctr = 0; ctr < encodedBytes.Length; ctr++)
            {
                Console.Write("{0:X2} ", encodedBytes[ctr]);
                if ((ctr + 1) % 25 == 0)
                    Console.WriteLine();
            }
            Console.WriteLine();
 
            // Decodifica bytes de nuevo a cadena. 
            String decodedString = utf8.GetString(encodedBytes);
            Console.WriteLine();
            Console.WriteLine("Bytes decodificados:");
            Console.WriteLine(decodedString);
 
            // Pulse cualquier tecla para salir.
            Console.ReadKey();
        }
    }
}

using System;
using System.IO;
 
namespace LCD_nombre_archivo_consola_12
{
    class Program
    {
        // Variables.
        static string guardarNombre = ""; // Guardar nombre escrito.
        static int coordenadaX = 0; // Coordenada X del setCursorPisition.
        static ConsoleKey tecla; // Guarda cualquier tecla pulsada.
        static int index = 0; // Índice.
 
        // Caracteres de este array.
        static readonly char[] roALFANUMERICO = new char[]
        {
         'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
         'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
         'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
         'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
         '¿', '?', '(', ')', '[', ']', '{', '}', '<', '>', '=', '$', '&', '@', '\'', '"', ' '
        };
 
        // Dirección del carácter del array. El 83 presenta al espacio ' ' del array roALFANUMERICO indicado justo arriba.
        // Hay un total de 85 caracteres. Se cuenta desde el 0 al 84.
        static readonly int[] roINDICE_ARRAY = new int[]
        {
         84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84
        };
 
        // Palabras del array para imprimir en pantalla.
        static readonly string[] roTEXTO = new string[] { "ATRÁS", "GUARDAR" };
 
        static void Main(string[] args)
        {
            // Título de la pantalla.
            Console.Title = "Cambiar nombre";
 
            Inicio();
        }
 
        static void MainMenu()
        {
            Console.Clear(); // Limpiar pantalla.
 
            Console.SetCursorPosition(0, 0);
            Console.Write("Nombre del relé 1:  ");
            Console.SetCursorPosition(0, 1);
 
            // Recorre el índice del array, del 0 hasta donde llegue.
            for (int i = 0; i < roINDICE_ARRAY.Length; i++)
            {
                // Imprime los caracteres del array.
                Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
            }
 
            Console.SetCursorPosition(3, 3);
            Console.Write(roTEXTO[0]); // ATRÁS.
            Console.SetCursorPosition(12, 3);
            Console.Write(roTEXTO[1]); // GUARDAR.
        }
 
        #region Inicio.
        static void Inicio()
        {
            Console.SetWindowSize(20, 5); // Residemensiona pantalla. X = 20, Y = 5.
            Console.BackgroundColor = ConsoleColor.Gray; // Fondo gris.
            Console.ForegroundColor = ConsoleColor.Black; // Letras negras.
 
            // ¿El archivo Existe?
            if (File.Exists("Archivo.txt"))
            {
                // Sí. Lee el archivo de texto.
                string nombre = File.ReadAllText("Archivo.txt");
                int a, b; // Almacena ídice array.
                for (a = 0; a < nombre.Length; a++)
                {
                    for (b = 0; roALFANUMERICO[b] != nombre[a]; b++)
                    {
                        ;
                    }
                    roINDICE_ARRAY[a] = b; // b indica índice y lo añade al roINDICE_ARRAY.
                }
            }
            // No. El Archivo.txt no existe.
            else
            {
                // Crea un archivo nuevo, escribe el contenido en el archivo y, a continuación, lo cierra.
                // Si el archivo de destino ya existe, se sobrescribe.
                File.WriteAllText("Archivo.txt", guardarNombre);
            }
 
            MainMenu(); // Dibuja el menú.
 
            while (true)
            {
                Console.CursorVisible = true; // Cursor invisible.
                index = 0;
 
                // Si se cumple estas condiciones, Enter, flecha izquierda, flecha derecha
                if ((tecla == ConsoleKey.Enter) || (tecla == ConsoleKey.RightArrow) || (tecla == ConsoleKey.LeftArrow))
                {
                    MainMenu(); // Dibuja el menú.
                }
 
                // Posiciona cursor.
                Console.SetCursorPosition(coordenadaX, 1);
 
                // Almacena en la variable tecla, la tecla pulsada.
                tecla = Console.ReadKey(true).Key;
 
                // Si coincide una tecla pulsada.
                switch (tecla)
                {
                    case ConsoleKey.RightArrow: // Flecha derecha detectada.
                        // ¿CoordenadaX menor que 15?
                        if (coordenadaX < 15)
                        {
                            coordenadaX++; // Sí. Añada + 1 en la coordenadaX.
                        }
                        // No. Sale de aquí.
                        break;
 
                    case ConsoleKey.LeftArrow: // Flecha izquierda detectada.
                        // ¿coordenadaX es mayor que 0?
                        if (coordenadaX > 0)
                        {
                            coordenadaX--; // Sí. Decremente o quita -1.
                        }
                        // No. Sale de aquí.
                        break;
 
                    case ConsoleKey.UpArrow: // Flecha arriba.
                        roINDICE_ARRAY[coordenadaX]++; // En el índice del array añade + en coordenadaX.
                        // ¿El índice del array es mayor o igual que el array Alfanumérico?
                        if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
                        {
                            roINDICE_ARRAY[coordenadaX] = 0; // Sí. Deja en 0 la coordenada del índice del array.
                        }
                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                        break;
 
                    case ConsoleKey.DownArrow: // Flecha abajo detectado.
                        roINDICE_ARRAY[coordenadaX]--; // Decrementa a -1 el índice del array.
                        // ¿La coordenadaX del indice del array es menor que 0?
                        if (roINDICE_ARRAY[coordenadaX] < 0)
                        {
                            // Sí. Imprimir el valor alfanumérico.
                            roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
                        }
                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
                        break;
 
                    case ConsoleKey.Enter: // Detecta la tecla Enter.
                        Console.SetCursorPosition(1, 3); // Posición del cursor.
                        Console.CursorVisible = false; // Se oculta el cursor.
                        Console.Write(">"); // Imprime en pantalla >.
 
                        // ¿La tecla almacenada es distinto a la tecla Enter?
                        while ((tecla = Console.ReadKey(true).Key) != ConsoleKey.Enter)
                        {
                            // Sí.
                            switch (tecla)
                            {
                                case ConsoleKey.RightArrow:
                                    index = 1;
                                    Console.SetCursorPosition(1, 3);
                                    Console.Write(" ");
                                    Console.SetCursorPosition(10, 3);
                                    Console.Write(">");
                                    break;
                                case ConsoleKey.LeftArrow:
                                    Console.SetCursorPosition(10, 3);
                                    Console.Write(" ");
                                    Console.SetCursorPosition(1, 3);
                                    Console.Write(">");
                                    index = 0;
                                    break;
 
                                case ConsoleKey.UpArrow:
                                    Inicio();
                                    break;
 
                                case ConsoleKey.DownArrow:
                                    Inicio();
                                    Console.SetCursorPosition(coordenadaX, 1);
                                    break;
                            }
                        }
 
                        if (index == 0)
                        {
                            Atras();
                        }
                        if (index == 1)
                        {
                            Guardar();
                        }
                        break;
                }
            }
        }
        #endregion
 
        static void Atras()
        {
            Console.Clear();
            Console.SetCursorPosition(0, 1);
            Console.Write("HAS PULSADO ATRÁS   ");
            Console.ReadKey(); // Pulse cualquier tecla para salir.
        }
 
        static void Guardar()
        {
            guardarNombre = "";
            Console.Clear(); // Limpia la pantalla.
 
            // Lee todo el contennido del array y lo guarda en guardarNombre.
            for (int a = 0; a < roINDICE_ARRAY.Length; a++)
            {
                guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
            }
            Console.SetCursorPosition(0, 2);
            Console.Write(guardarNombre); // Imprime el contenido.
 
            // Crear Archivo.txt y el contenido de guardarNombre.
            File.WriteAllText("Archivo.txt", guardarNombre);
 
            Console.SetCursorPosition(0, 1);
            Console.Write("HAS GUARDADO       ");
 
            // Pulsa otra vez tecla.
            Console.ReadKey();
        }
    }
}

int Variar_este_valor = Convert.ToInt32(Recibidos);

using System;
using System.IO.Ports; // No olvidar.
using System.IO;
 
namespace Porcentaje_Barra_Puerto_Serie_Consola_03
{
    class Program
    {
        public static string recibidos = "";
        public static double Resultado_Porcentaje = 0;
        public static double Resultado_Voltios = 0;
        public static double Mitad_barra = 0;
        public static int Contador = 1;
 
 
        static void Main(string[] args)
        {
            #region Configuración ventana.
            // Título de la ventana.
            Console.Title = "Puerto serie C# - 2019";
 
            // Tamaño de la ventana, x, y.
            Console.SetWindowSize(100, 35);
 
            // Color de fondo.
            Console.BackgroundColor = ConsoleColor.DarkBlue;
 
            // Color de las letras.
            Console.ForegroundColor = ConsoleColor.Yellow;
 
            // Limpiar pantalla y dejarlo todo en color de fondo.
            Console.Clear();
 
            // Visible el cursor.
            Console.CursorVisible = true;
            #endregion
            string COM = "";
 
            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
            SerialPort serialPort1 = new SerialPort();
 
            // Configuración.
            Console.Write(@"
Introduzca un número para seleccionar puerto COM.
Por ejemplo el 4, sería COM4.
 
Puerto: ");
            COM = Console.ReadLine(); // Escribir el número del puerto.
            Console.Clear();
 
            serialPort1.PortName = "COM" + COM; // Número del puerto serie.
 
            // Crear un nuevo objeto SerialPort con la configuración predeterminada.
 
            // Configuración del puerto serie.
            serialPort1.BaudRate = 9600;            // Baudios o velocidad. 115200
            serialPort1.Parity = Parity.None;       // Sin paridad.
            serialPort1.DataBits = 8;               // 8 Bits de datos.
            serialPort1.StopBits = StopBits.Two;    // Bits de parada.
            serialPort1.Handshake = Handshake.None; // Control de flujo.
            serialPort1.ReadBufferSize = 4096;      // Tamaño del Búffer de lectura en Bytes.
            serialPort1.WriteBufferSize = 2048;     // Tamaño del Búffer de escritura en Bytes.
            serialPort1.ReadTimeout = 500;          // Establecer lectura de espera.
            serialPort1.WriteTimeout = 500;         // Establecer escritura de espera.
            serialPort1.DtrEnable = false;
            serialPort1.RtsEnable = false;
 
 
            try
            {
                serialPort1.Open(); // Abrir el puerto serie.
            }
 
            catch (IOException)
            {
                Console.ForegroundColor = ConsoleColor.Red; // Texto en rojo.
                Console.CursorVisible = false;
                Console.SetCursorPosition(16, 6);
                Console.WriteLine(@"El puerto " + serialPort1.PortName + @" no existe
            o no lo encuentra.");
            }
 
            serialPort1.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
 
            Console.Read();
            serialPort1.Close(); // Cerrar puerto.
        }
 
        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
 
        {
 
            try
            {
                SerialPort sp = (SerialPort)sender;
                recibidos = sp.ReadExisting();
                //Console.Clear();
 
                recibidos = recibidos.Replace("\n\r", "");
 
                int Variar_este_valor = Convert.ToInt32(recibidos);
 
                Resultado_Porcentaje = Variar_este_valor * (100.00 / 1023.00);
                Resultado_Voltios = Variar_este_valor * (5.00 / 1023.00);
 
 
                Console.SetCursorPosition(0, 1);
                Console.Write("Datos recibidos: ");
                Console.SetCursorPosition(17, 1);
                Console.Write("    ");
                Console.SetCursorPosition(17, 1);
                Console.Write(recibidos);
 
                // Dibujamos la barra del portentaje.
                Console.SetCursorPosition(0, 3);
                Console.Write("0 %                     50 %                   100 %");
                Console.SetCursorPosition(0, 4);
                Console.Write("┌────────────────────────┬───────────────────────┐");
                Console.Write("                                                  ");
                Console.ForegroundColor = ConsoleColor.Yellow;
 
                // Se dibide por dos la barra del porcentaje para que quepa decuadamente en la pantalla.
                Mitad_barra = Resultado_Porcentaje / 2;
 
                if (Mitad_barra > 50)
                {
                    Mitad_barra = 50;
                }
 
                // Console.SetCursorPosition(0, 5);
                ClearCurrentConsoleLine();
                // Barra de progreso.
                for (int i = 1; i <= Mitad_barra; i++)
                {
                    Console.Write("&#9608;"); // Muestra ASCII 219 Dec y DB en Hex.
                                        // Console.Write((char)219);
                                        // Console.Write(Encoding.ASCII.GetBytes((char)219));
                }
 
                // Si sobre pasa 100, muestra # al final de la barra del porcentaje de color rojo.
                if (Resultado_Porcentaje >= 100)
                {
                    Console.SetCursorPosition(50, 5);
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.Write("#");
                }
 
                Console.ForegroundColor = ConsoleColor.Gray; // Vuelve al color gris.
 
                // Línea 7.
                Console.SetCursorPosition(0, 7);
                Console.Write("Porcentaje: ");
                Console.SetCursorPosition(12, 7);
                Console.Write("            ");
                Console.SetCursorPosition(12, 7);
                Console.Write(Resultado_Porcentaje.ToString("N0") + " %.");
 
                // Línea 8.
                Console.SetCursorPosition(0, 8);
                Console.Write("Voltios: ");
                Console.SetCursorPosition(12, 8);
                Console.Write("            ");
                Console.SetCursorPosition(12, 8);
                Console.Write(Resultado_Voltios.ToString("N2") + " V.");
 
            }
 
            catch (FormatException)
            {
                // Console.WriteLine("La cadena de entrada no tiene el formato correcto.");
                Console.SetCursorPosition(0, 10);
                Console.Write("                 ");
                Console.SetCursorPosition(0, 10);
                Console.Write("Contador: " + Contador++);
                // return;
            }
 
        }
 
        public static void ClearCurrentConsoleLine()
        {
            int currentLineCursor = Console.CursorTop;
            Console.SetCursorPosition(0, Console.CursorTop);
            Console.Write(new string(' ', Console.WindowWidth));
            Console.SetCursorPosition(0, currentLineCursor);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Delimitador_consola_03
{
    class Program
    {
        static void Main(string[] args)
        {
            #region Configuración ventana.
            // Título de la ventana.
            Console.Title = "Probando manipulación de cadena";
 
            // Tamaño de la ventana, x, y.
            Console.SetWindowSize(100, 35);
 
            // Color de fondo.
            Console.BackgroundColor = ConsoleColor.DarkBlue;
 
            // Color de las letras.
            Console.ForegroundColor = ConsoleColor.Yellow;
 
            // Limpiar pantalla y dejarlo todo en color de fondo.
            Console.Clear();
 
            // Visible el cursor.
            Console.CursorVisible = true;
            #endregion
 
            // Cree una codificación ISO-8859-1.
            Encoding ISO_8859_1 = Encoding.GetEncoding("ISO-8859-1");
 
            #region Variables.
            // Partir a trocitos estos caracteres.
            char[] delimitadorComandoB = { '#', ',', 'O', 'I', 'L', 'B', 'V', 'F', 'H', 'R', 'S', };
 
            // Es la cadena de caracteres que me llegó desde el puerto serie.
            // En este ejemplo lo dejo en la varible directamente.
            // Una cadena completa empieza con # y termina en <cr>, o lo que es lo mismo, /r.
            string respuestaB = "#I223.3O224.0L000B100V26.4F50.2H50.2R0080S�„€€„À"; // Comando B.
 
            // Se guarga en este array tipo string los datos ya partidos a tozos.
            string[] palabrasB = respuestaB.Split(delimitadorComandoB);
 
            // Tabla S1 descripción.
            string[] DESCRIPCION_S1 =
            {
                "Indica que este byte está disponible y es válido. [Siempre 1]",             // Posición [0].
                "Indica falla de energía de la red pública; ver detalles en S2.0 y S2.1.",
                "Indica que la capacidad de la batería es menor que el umbral de apagado.",
                "Indica que el zumbador está en estado de pitido.",
                "Indica que la prueba de batería se está procesando.",
                "Indica que el apagado programado está pendiente.",
                "Indica que la restauración programada está pendiente.",
                "Indica falla de hardware; ver detalles sobre el comando X71."               // Posición [7].
            };
 
            string[] DESCRIPCION_S2 =
            {
                "Para indicar que este byte está disponible y es válido. [Siempre 1].",
                "--",
                "XX",
                "Indica sobretemperatura del inversor.",
                "Indica que el inversor tiene una falla.",
                "Indica que el inversor está apagado.",
                "Indica que la frecuencia de la utilidad está fuera de rango.",
                "Indica que el voltaje de la red pública está fuera de rango."
            };
 
            string[] DESCRIPCION_S3 =
            {
                "Para indicar que este byte está disponible y es válido. [Siempre 1].",
                "Indica que la batería está completamente cargada.",
                "Indica que la capacidad de la batería aún es menor que el umbral restaurado del UPS cuando la energía de la red pública restaurado.",
                "Indica que la batería se está cargando.",
                "Indica que la batería se está descargando.",
                "Indica que la capacidad de la batería es inferior al 80 por ciento.",
                "Reservado, debe ser 0.",
                "Indica que la batería no está presente."
            };
 
            string[] DESCRIPCION_S4 =
{
                "Para indicar que este byte está disponible y es válido. [Siempre 1].",
                "Indica que el bypass es una sobrecarga.",
                "Indica que la derivación está activa.",
                "Indica que la salida sufre un cortocircuito.",
                "Indica que la salida tiene carga.",
                "Indica que la salida está sobrecargada.",
                "Indica que la frecuencia de salida está fuera de rango en bypass.",
                "Indica que el voltaje de salida está fuera de rango en derivación."
            };
 
            string[] DESCRIPCION_S5 =
{
                "Para indicar que este byte está disponible y es válido. [Siempre 1].",
                "Indica que no hay salida.",
                "Para indicar que el tiempo de ejecución restante es inferior al umbral.",
                "Para indicar que el zumbador está silenciado (no permanente) en este momento.",
                "Para indicar falla de cableado.",
                "Para indicar SAI en modo ECO.",
                "Para indicar UPS en Bypass manual.",
                "Arreglar 0."
            };
 
            string[] DESCRIPCION_S6 =
            {
                "Para indicar que este byte está disponible y es válido. [Siempre 1].",
                "Indica UPS encendido.",
                "Reservado, debe ser 0.",
                "Reservado, debe ser 0.",
                "Reservado, debe ser 0.",
                "Reservado, debe ser 0.",
                "Reservado, debe ser 0.",
                "Reservado, debe ser 0."
            };
 
            bool boolS1 = true;
            bool boolS2 = false;
            bool boolS3 = false;
            bool boolS4 = false;
            bool boolS5 = false;
            bool boolS6 = false;
            bool boolContador = true;
            bool boolContador2 = false;
            #endregion
 
            // Comando B.
            Console.WriteLine();
 
            // Muestra los resultados en pantalla.
            Console.WriteLine();
            Console.WriteLine("El voltaje de la utilidad es de {0} voltios. ", palabrasB[2]); // I.
            Console.WriteLine("El voltaje de salida del UPS es de {0} voltios. ", palabrasB[3]); // O.
            Console.WriteLine("La carga actual de UPS es del {0} por ciento. ", palabrasB[4]); // L.
            Console.WriteLine("La capacidad de la batería es del {0} por ciento. ", palabrasB[5]); // B.
            Console.WriteLine("El voltaje de la batería es de {0} voltios. ", palabrasB[6]); // V.
            //Console.WriteLine("La temperatura del gabinete del UPS es de {0} grados centígrados. ", palabrasB[7]); // T. No hay T. en mi versión.
            Console.WriteLine("La frecuencia de salida del SAI es de {0} Hz. ", palabrasB[7]); // F.
            Console.WriteLine("La frecuencia de salida del SAI es de {0} Hz. ", palabrasB[8]); // H.
            Console.WriteLine("El tiempo de funcionamiento restante de la batería es de {0} minutos. ", palabrasB[9]);
            //Console.WriteLine(@"Estos son los bits de estados que no se entiende.S:
            //Aquí hay que leer cada bits como cuando se leyeron cada Byte arriba: ", (char)palabrasB[10]);
 
            char[] bits = palabrasB[10].ToCharArray();
 
            //int byteS1 = (byte)bits[0];
            //int byteS2 = (byte)bits[1];
            //int byteS3 = (byte)bits[2];
            //int byteS4 = (byte)bits[3];
            //int byteS5 = (byte)bits[4];
            //int byteS6 = (byte)bits[5];
 
            //Console.WriteLine("Byte S1: {0}", byteS1.ToString());
            //Console.WriteLine("Byte S2: {0}", byteS2.ToString());
            //Console.WriteLine("Byte S3: {0}", byteS3.ToString());
            //Console.WriteLine("Byte S4: {0}", byteS4.ToString());
            //Console.WriteLine("Byte S5: {0}", byteS5.ToString());
            //Console.WriteLine("Byte S6: {0}", byteS6.ToString());
 
 
            //Console.WriteLine();
            //Console.WriteLine(((byteS1 & 128) == 128) ? "ACTIVADO" : "DESACTIVADO");
            //Console.WriteLine(((byteS1 & 128) == 128) ? "1" : "0");
            //Console.WriteLine();
 
            Tabla();
            int contador = 0;
            for (int b = 0; b < bits.Length; b++)
            {
                for (int a = 7; a >= 0; a--)
                {
 
                    Console.Write((((byte)bits[b]) & (1 << a)) >> a);
                    Console.Write(" | ");
 
                    if ((contador <= 7) && (boolS1 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S1[contador]);
 
                        if (contador == 7)
                        {
                            boolS1 = false;
                            boolS2 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }
                    else if ((contador <= 7) && (boolS2 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S2[contador]);
                        boolContador2 = false;
                        if (contador == 7)
                        {
                            boolS2 = false;
                            boolS3 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }
                    else if ((contador <= 7) && (boolS3 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S3[contador]);
                        boolContador2 = false;
                        if (contador == 7)
                        {
                            boolS3 = false;
                            boolS4 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }
                    else if ((contador <= 7) && (boolS4 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S4[contador]);
                        boolContador2 = false;
                        if (contador == 7)
                        {
                            boolS4 = false;
                            boolS5 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }
                    else if ((contador <= 7) && (boolS5 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S5[contador]);
                        boolContador2 = false;
                        if (contador == 7)
                        {
                            boolS5 = false;
                            boolS6 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }
                    else if ((contador <= 7) && (boolS6 == true))
                    {
                        Console.WriteLine(DESCRIPCION_S6[contador]);
                        boolContador2 = false;
                        if (contador == 7)
                        {
                            boolS6 = true;
                            boolContador2 = true;
                            contador = 0;
                        }
                    }
 
                    if (boolContador == true)
                    {
                        contador++;
 
                        if (boolContador2 == true)
                        {
                            contador = 0;
                        }
                    }
                    //Console.WriteLine();
                }
                Console.WriteLine();
            }
 
 
            #region Tabla.
            void Tabla()
            {
                Console.WriteLine();
                Console.WriteLine("Byte | Bit | Estado | Descripción");
                Console.WriteLine("-----+-----+-----------------------------------------------------------------------");
            }
            #endregion
 
            // Pulse cualquier tecla para salir.
            Console.ReadKey();
        }
    }
}

cXLimIzq       EQU  32                  ; X-Limite izquierda juego
  cXLimDer       EQU  320-cXLimIzq        ; X-Limite derecha juego
  cYLimSup       EQU  60                  ; Y-Limite superior juego
  cYLimInf       EQU  180                 ; Y-Limite inferior juego
  cIncYEDisp     EQU  1                   ; Y-incremento de los e-disparos
  cTamDefFig     EQU  7*2                 ; Los words que definen la figura
  cSepIniEDisp   EQU  4                   ; Separación inicial del disparo enemigo
  cColorEDisp    EQU  14                  ; Color del disparo enemigo
  cColorPDisp    EQU  7                   ; Color del disparo del jugador
  cFigAlto       EQU  7                   ; Altura de las figuras
  cFigAncho      EQU  16                  ; Anchura de las figuras
  cAncho         EQU  256                 ; Anchura de la pantalla de juego
  cAlto          EQU  cYLimInf-cYLimSup+1 ; Altura de la pantalla de juego
  cSepMargen     EQU  3                   ; Margen de separación con el borde
  cLinColor      EQU  6                   ; Color de la línea contenedora
  cFrecBomb      EQU  010h                ; Frecuencia con la que empiezan a caer bombas
  cNumEColumn    EQU  11                  ; Número de columnas de enemigos
  cNumEnemigos   EQU  5*cNumEColumn       ; Número de enemigos
  cDispEne       EQU  5                   ; Máximo num disparos x cada enemigo
  cNumDispEne    EQU  7;cDispEne*cNumEColumn; Máximo disparos activos enemigos
  cXESep         EQU  1                   ; X-separación entre enemigos
  cYESep         EQU  3                   ; Y-separación entre enemigos
  cXESup         EQU  (cAncho-((16+cXESep)*10+16))/2  ; X-inicial-superior enemigos
  cYESup         EQU  cYLimSup-cYLimSup   ; Y-superior enemigos
  cYPSup         EQU  cYLimInf-7-cYLimSup ; Y-superior player
  cXPIzq         EQU  0                   ; X-lim izquierda player
  cXPDcha        EQU  256-11              ; X-lim derecha player
  cTimePlayer    EQU  0                   ; Tiempo retardo movimiento player
  cTimeEnemigos  EQU  20                  ; Tiempo retardo movimiento enemigos
  cTimePDisp     EQU  0                   ; Tiempo retardo movimiento player-disparo
  cTimeEDisp     EQU  0                   ; Tiempo retardo movimiento enemigos-disparos
  cTimeESgteDisp EQU  10                  ; Tiempo retardo siguiente enemigos-disparos
  cChgTEnemigos  EQU  2                   ; Cada cuántos enemigos destruidos incrementan velocidad
  cFilasBaja     EQU  2                   ; Filas que bajan los enemigos cada vez
  cYTope         EQU  cYPSup-10           ; Tope superior que no pueden sobrepasar enemigos
  cSoyInmune     EQU  0                   ; 1-soy inmune, 0-no soy inmune
  cTAMTOT        EQU  1024*6              ; Este programa y su pila caben en 6Kb
  cnNotas        EQU  7+6+7+5
 
  TEnemigos   STRUC
    PosX    DW ?
    PosY    DW ?
    OldPosX DW ?
    Def     DW ?                          ; La dirección donde está definido
    Despl   DW ?                          ; El desplazamiento de offsets (+7?)
    Tipo    DB ?                          ; 1, 2, 3, 4, 5
    Color   DB ?
    Vida    DB ?
    Abajo   DB ?                          ; Sólo disparan los que estén abajo
  TEnemigos   ENDS
 
  TCabEDisp STRUC                         ; Estructura de la cabecera de los disparos enemigos
    DirDisp DW ?                          ; Dirección donde se encuentra el disparo
    Vida    DB ?                          ; ¿Está vivo?
  TCabEDisp ENDS
 
  TEDisparos   STRUC                      ; Disparos de los enemigos
    PosX    DW ?
    PosY    DW ?
    Def     DW ?                          ; Matriz de definición del disparo
    Despl   DW ?                          ;   junto con el desplazamiento de offsets (+7?)
    Color   DB ?
  TEDisparos   ENDS
 
  TPlayer   STRUC
    PosX    DW ?
    PosY    DW ?
    Def     DW ?                          ; La dirección donde está definido
    Color   DB ?
    Vida    DB ?
  TPlayer   ENDS
 
  TPDisparos   STRUC                      ; Disparos del jugador
    PosX    DW ?
    PosY    DW ?
    Def     DW ?
    Despl   DW ?                          ; El desplazamiento de offsets (+7?)
    Color   DB ?
    Vida    DB ?
  TPDisparos   ENDS
 
  TNota STRUC
    Frecuencia DW ?
    Duracion   DB ?
  TNota ENDS
 
  LTEnemigos   EQU SIZEOF TEnemigos
  LTEDisparos  EQU SIZEOF TEDisparos
  LTCabEDisp   EQU SIZEOF TCabEDisp
  LTPlayer     EQU SIZEOF TPlayer
  LTPDisparos  EQU SIZEOF TPDisparos
  LTNota       EQU SIZEOF TNota
 
  IF1
    INCLUDE ..\LIB\CtesGphM.inc           ; Constantes gráficas
    INCLUDE ..\LIB\GraphMM.inc            ; Incorporamos las macros gráficas
  ENDIF
 
codigo SEGMENT PARA PUBLIC 'CODE'         ; Abre el segmento de código
  ASSUME CS:codigo, DS:codigo, ES:codigo, SS:codigo
  ORG 100h                                ; COM -> comienza en 100h
  Entrada PROC                            ; Abre el procedimiento
    ; *** Reasigna memoria
    MOV         SP, cTAMTOT               ; La base de la pila
    MOV         AH, 4Ah
    MOV         BX, cTAMTOT/16            ; Lo pasamos a párrafos
    INT         21h                       ; Redimensionamos el bloque de memoria
    JNC         $_Bien1
      MOV        AH, 9
      MOV        DX, OFFSET msg1
      INT        21h
      JMP        $_Salimos
    $_Bien1:
    CALL        VGAColor                  ; Comprobamos si existe VGA en color
    ; Reserva memoria para el búfer pant1
    MOV         BX, (cXLimDer-cXLimIzq+1)*(cYLimInf-cYLimSup+1)/16+1 ; En párrafos
    CALL        ResMem
    MOV         WORD PTR [ScrSeg], AX
    SetMode     13h                       ; Ponemos el modo gráfico
    CALL        DibMarco
    CALL        SaveValSPK
    CALL        Randomize
    CALL        SaveOldInt9h
    CALL        SetNewInt9h
    CALL        SaveOldInt1Ch
    CALL        SetNewInt1Ch
    CALL        IniCabEDisp
    CALL        ResetNivel                ; Inicializamos el nivel del juego
    $_Nueva_Partida:
    CALL        IniElementos              ; Inicializa valores en función de variables y constantes
    $_Main:
      CALL        GetPShoot               ; ¿Hemos pulsado ctrl?
      CALL        GetEShoot               ; ¿Debe disparar un enemigo?
      CALL        SetMotion               ; Movemos las piezas si toca
      JNC         $_Next0
        ; Si STC = 1 significa que los enemigos han llegado al nivel inferior: ganaron
        CALL        ResetNivel            ; Inicializamos el nivel del juego
        CALL        WaitUntilCtrl         ; Esperamos hasta Ctrl pulsado
        JMP         $_Nueva_Partida
      $_Next0:
      CMP         BYTE PTR [NumEnemigos], 0
      JA          $_Next1
        CALL        incNivel              ; Incrementamos el nivel del juego
        JMP         $_Nueva_Partida
      $_Next1:
      CMP         BYTE PTR [Player.Vida], 0
      JA          $_Next2
        CALL        ResetNivel            ; Inicializamos el nivel del juego
        CALL        WaitUntilCtrl         ; Esperamos hasta Ctrl pulsado
        JMP         $_Nueva_Partida
      $_Next2:
      CALL        ClearBuffer             ; Limpiamos el búfer
      CALL        DibujaEnemigos          ; Dibujamos los enemigos en el búfer
      CALL        DibujaJugador           ; Dibujamos el jugador en el búfer
      CALL        DibujaPDisparo          ; Dibujamos el disparo del jugador en búfer
      CALL        DibujaEDisparo          ; Dibujamos los disparos de los enemigos en búfer
      CALL        CheckPDEDColision       ; ¿El disparo del jugador alcanzo al de algun enemigo?
      CALL        CheckMPDColision        ; ¿El disparo del jugador alcanzo algun enemigo?
      CALL        CheckMEDColision        ; ¿El disparo de los enemigos alcanzaron al jugador?
      WRetrace    8                       ; Esperamos al final del retrazo
      MOV         AX, WORD PTR [ScrSeg]   ; Segmento Origen
      MOV         BX, __VgaSeg            ; Segmento destino: mem vídeo
      CALL        Copy64K                 ; Vuelca búfer en mem vídeo
      CMP         BYTE PTR [Escape], 1
    JNZ         $_Main
    SetMode     3h                        ; Volvemos al modo texto
    CALL        RestoreOldInt1Ch
    CALL        RestoreOldInt9h
    CALL        TurnOffSpk
    MOV         AX, WORD PTR [ScrSeg]     ; Libera memoria pantalla
    CALL        LibMem
    $_Salimos:
    ; Salimos al DOS
    MOV      AX, 4C00h                    ; Servicio 4Ch, mensaje 0
    INT      21h                          ; volvemos AL DOS
  Entrada ENDP                            ; cierra el procedimiento
 
  IF1
    INCLUDE  ..\LIB\VGA_M.inc             ; Incorporamos procedimientos
    INCLUDE  ..\LIB\SpcM.inc              ; Incorporamos procedimientos
  ENDIF
 
  ; ****************
 
  TurnOffSpk PROC
    ;  Propósito: Apaga el altavoz
    ;  Entrada  : Ninguna
    ;  Salida   : Ninguna
    ;  Destruye : AX
    MOV      AL, BYTE PTR [vbSpeaker]
    AND      AL, 11111100b                ; Apagamos y descconectamos el altavoz del canal 2 del PIT
    OUT      61h, AL
    RET
  TurnOffSpk ENDP
 
  SaveValSPK PROC
    ;  Propósito: Guarda el valor original del puerto 61h
    ;  Entrada  : Ninguna
    ;  Salida   : Ninguna
    ;  Destruye : AX
    IN       AL, 61h
    AND      AL, 11111100b
    MOV      BYTE PTR [vbSpeaker], AL
    RET
  SaveValSPK ENDP
 
  Frec_Periodo PROC
    ;  Propósito: Convertimos la frecuencia en período
    ;  Entrada  : CX: frecuencia
    ;  Salida   : DX: período
    ;  Destruye : AX, DX
    MOV      DX, 12h
    MOV      AX, 34DCh
    DIV      CX
    MOV      DX, AX                       ; Lo guardamos en DX
    RET
  Frec_Periodo ENDP
 
  PIT_REG_COMM PROC
    ;  Propósito: Le indicamos al PIT lo que vamos a hacer
    ;  Entrada  : DX:periodo
    ;  Salida   : Ninguna
    ;  Destruye : AX
    MOV      AL, 0B6h
    OUT      43h, AL
    MOV      AL, DL                       ; Pasamos el byte bajo del contador
    OUT      42h, AL
    MOV      AL, DH                       ; Y ahora el alto
    OUT      42h, AL
    RET
  PIT_REG_COMM ENDP
 
  SpkOn PROC
    ;  Propósito: Encendemos el altavoz con duración determinada
    ;  Entrada  : Ninguna
    ;  Salida   : Ninguna
    ;  Destruye : AX
    MOV      AL, BYTE PTR CS:[vbSpeaker]
    OR       AL, 3
    OUT      61h, AL
    RET
  SpkOn ENDP
 
  SpkOff PROC
    ;  Propósito: Encendemos el altavoz con duración determinada
    ;  Entrada  : Ninguna
    ;  Salida   : Ninguna
    ;  Destruye : AX
    MOV      AL, BYTE PTR CS:[vbSpeaker]
    AND      AL, 11111100b
    OUT      61h, AL
    RET
  SpkOff ENDP
 
  Sonido PROC
    ;  Propósito: Toca una nota en el altavoz del PC a través del PIT
    ;  Entrada  : CX:frecuencia
    ;  Salida   : Ninguna
    ;  Destruye : Ninguna
    .IF      CX == 0
      CALL     SpkOff
    .ELSE
      CALL     Frec_Periodo
      CALL     PIT_REG_COMM
      CALL     SpkOn
    .ENDIF
    RET
  Sonido ENDP
 
  ResetNota PROC
    ; Propósito: Recogemos los valores de la nueva nota en MNota
    ; entrada  : KeyTable
    ; salida   : KeyTable
    ; Destruye : AX 
    PUSH      AX
    PUSH      BX
    MOV       BX, WORD PTR CS:[vwActual]
    MOV       AX, WORD PTR CS:[Notas1+BX]
    MOV       WORD PTR CS:[MNota.Frecuencia], AX
    MOV       AX, WORD PTR CS:[Notas1+BX+2]
    MOV       BYTE PTR CS:[MNota.Duracion], AL
    POP       BX 
    POP       AX
    RET
  ResetNota ENDP
 
  ; ****************
 
  SaveOldInt1Ch PROC NEAR
    ; Propósito: Guarda la dirección de la antigua ISR de Int 1Ch
    ; entrada  : OldInt1Ch
    ; salida   : Ninguna
    ; Destruye : AX
    MOV       AX, 351Ch                   ; Obtiene la dirección de la
    INT       21h                         ;     interrupción 1Ch
    MOV       WORD PTR OldInt1Ch[2],ES    ; Guarda segmento
    MOV       WORD PTR OldInt1Ch[0],BX    ;     y dirección
    RET
  SaveOldInt1Ch ENDP
 
  RestoreOldInt1Ch PROC NEAR
    ; Propósito: Restaura la dirección de la antigua ISR de Int 1Ch
    ; entrada  : OldInt1Ch
    ; salida   : Ninguna
    ; Destruye : AX, DX
    PUSH      DS                          ; Guardamos DS
    LDS       DX, OldInt1Ch               ; Carga la dirección original
    MOV       AX, 251Ch                   ; Lo restaura a la tabla de vectores
    INT       21h
    POP       DS
    RET
  RestoreOldInt1Ch ENDP
 
  SetNewInt1Ch PROC NEAR
    ; Propósito: Establece la dirección de la nueva ISR para Int 1Ch
    ; entrada  : NuevaInt1Ch
    ; salida   : Ninguna
    ; Destruye : AX, DX
    MOV       DX, OFFSET NuevaInt1Ch      ; Carga la dirección de nueva rutina
    MOV       AX, 251Ch                   ; Establece la nueva interrupción
    INT       21h
    RET
  SetNewInt1Ch ENDP
 
  NuevaInt1Ch PROC FAR
    ; Propósito: Nueva ISR para la INT 1Ch, crea un retardo
    ; entrada  : Ninguna
    ; salida   : Ninguna
    ; Destruye : Ninguna
    PUSHF
    PUSH      AX
    PUSH      BX
    PUSH      CX
    PUSH      DX
    PUSH      DS
    PUSH      ES
    .IF       BYTE PTR CS:[vbEjecutando] == 1
      ; Si está sonando la nota
      DEC       BYTE PTR CS:[MNota.Duracion]            ; Decrementamos la duración
      .IF       BYTE PTR CS:[MNota.Duracion] == 0
        ; Si ya ha terminado la duración de la nota
        ADD       WORD PTR CS:[vwActual], 4             ; Incrementamos puntero a notas
        CALL      ResetNota                             ; Recogemos nueva nota
        .IF       WORD PTR CS:[vwActual] >= cnNotas*4
          ; Si ya hemos terminado todas las notas
          MOV       BYTE PTR CS:[vbEjecutando], 0       ; Marcamos que no tocamos
          MOV       WORD PTR CS:[vwActual], 0           ; Reseteamos el puntero a notas
          CALL      TurnOffSpk
        .ELSE
          ; Si todavía no hemos terminado todas las notas
          MOV       CX, WORD PTR CS:[MNota.Frecuencia]
          CALL      Sonido
        .ENDIF
      .ENDIF
    .ELSE
      ; Si no está sonando ninguna nota
      .IF       BYTE PTR CS:[vbEjecutar] == 1
        ; Si debemos ejecutar las notas
        .IF       WORD PTR CS:[vwActual] == 0
          ; Si estamos al inicio, reseteamos
          CALL      ResetNota
        .ENDIF
        .IF       BYTE PTR CS:[MNota.Duracion] != 0
          ; Si todavía dura la nota, la tocamos
          MOV       BYTE PTR CS:[vbEjecutando], 1       ; Marcamos para tocar
          MOV       CX, WORD PTR CS:[MNota.Frecuencia]
          CALL      Sonido
        .ENDIF
      .ENDIF
    .ENDIF
    CMP       BYTE PTR CS:[TimePlayer], 0
    JZ        $_Next1
      DEC       BYTE PTR CS:[TimePlayer]      ; Decrementamos el contador de pulsos
    $_Next1:
    CMP       BYTE PTR CS:[TimeEnemigos], 0
    JZ        $_Next2
      DEC       BYTE PTR CS:[TimeEnemigos]      ; Decrementamos el contador de pulsos
    $_Next2:
    CMP       BYTE PTR CS:[TimePDisp], 0
    JZ        $_Next3
      DEC       BYTE PTR CS:[TimePDisp]      ; Decrementamos el contador de pulsos
    $_Next3:
    CMP       BYTE PTR CS:[TimeEDisp], 0
    JZ        $_Next4
      DEC       BYTE PTR CS:[TimeEDisp]      ; Decrementamos el contador de pulsos
    $_Next4:
      CMP       BYTE PTR CS:[TimeESgteDisp], 0
      JZ        $_GT_Next5
        DEC       BYTE PTR CS:[TimeESgteDisp]   ; Retardo para el siguiente disparo de los enemigos
      $_GT_Next5:
    POP       ES
    POP       DS
    POP       DX
    POP       CX
    POP       BX
    POP       AX
    POPF
    JMP       [CS:OldInt1Ch]              ; Saltamos a la vieja rutina
  NuevaInt1Ch  ENDP
 
TopInvader1             DW      0c00h,1e00h,2d00h,3f00h,1200h,2100h,1200h
;   0c00   0000110000000000
;   1e00   0001111000000000
;   2d00   0010110100000000
;   3f00   0011111100000000
;   1200   0001001000000000
;   2100   0010000100000000
;   1200   0001001000000000
TopInvader2             DW      0c00h,1e00h,2d00h,3f00h,1200h,2100h,4080h
;   0c00   0000110000000000
;   1e00   0001111000000000
;   2d00   0010110100000000
;   3f00   0011111100000000
;   1200   0001001000000000
;   2100   0010000100000000
;   4080   0100000010000000
MiddleInvader1          DW      2100h,9e40h,0ad40h,7f80h,3f00h,2100h,4080h
MiddleInvader2          DW      2100h,1e00h,2d00h,7f80h,0bf40h,0a140h,1200h
BottomInvader1          DW      01e00h,7f80h,0ccc0h,0ffc0h,2100h,4c80h,2100h
BottomInvader2          DW      01e00h,7f80h,0ccc0h,0ffc0h,2100h,4c80h,8040h
PlayersShip             DW      0400h,0e00h,7fc0h,0ffe0h,0ffe0h,0ffe0h,0000h
;   0400   0000010000000000
;   0e00   0000111000000000
;   7fc0   0111111111000000
;   ffe0   1111111111100000
;   ffe0   1111111111100000
;   ffe0   1111111111100000
;   0000   0000000000000000
TwistedMissile1         DW      0000h,0000h,0000h,0800h,0400h,0800h,0400h
;   0000   0000000000000000
;   0000   0000000000000000
;   0000   0000000000000000
;   0800   0000100000000000
;   0400   0000010000000000
;   0800   0000100000000000
;   0400   0000010000000000
TwistedMissile2         DW      0000h,0000h,0000h,0400h,0800h,0400h,0800h
StraightMissile         DW      0000h,0000h,0000h,0400h,0400h,0400h,0400h
 
  MEnemigos  TEnemigos  cNumEnemigos DUP (<>)    ; Enemigos sin inicializar
  MCabEDisp  TCabEDisp  cNumDispEne  DUP (<>)    ; Disparos de los enemigos
;   align 16
;   db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1             ;16
  MEDisparos TEDisparos cNumDispEne  DUP (<>)    ; Disparos de los enemigos
  Player     TPlayer    <>                       ; Jugador sin inicializar
  MPDisparos TPDisparos <>                       ; Disparos de los enemigos
 
  vbSpeaker    DB   ?
  vbEjecutar   DB   1                     ; Lo definimos indicando que suenen las notas
  vbEjecutando DB   0
  vwActual     DW   0
  Notas1       DW   262, 3, 330, 3, 349, 3, 392, 3, 349, 3, 294, 3, 0, 8     ; 7
               DW   262, 3, 330, 3, 349, 3, 392, 3, 349, 3,   0, 8           ; 6
               DW   262, 3, 330, 3, 349, 3, 392, 3, 349, 3, 294, 3, 0, 8     ; 7
               DW   330, 3, 349, 3, 330, 3, 262, 3, 262, 3                   ; 5
  MNota        TNota  <>
 
msg1           DB  "Error al REDIMENSIONAR memoria$"
msg2           DB  "Error al RESERVAR memoria$"
msg3           DB  "Error al LIBERAR memoria$"
msgAOE         DB  "(c)Abre los ojos al ensamblador", 13, 10
               DB  "Ejemplo de space invaders$"
msgExito       DB  "Enhorabuena, has salvado al planeta Tierra$"
msgFracaso     DB  "Por tu impericia la Tierra ha sido destruida$"
msgBlanco      DB  "                                            $"
NumEnemigos    DB  ?                      ; Número de enemigos que quedan
OldInt9h       DD  ?                      ; Dirección antigua de Int 9h
OldInt1Ch      DD  ?                      ; Dirección antigua de Int 1Ch
ScrSeg         DW  ?                      ; Segmento del búfer de pantalla
DirEnemigos    DW  ?                      ; Dirección del mvto de los enemigos
DesplDefFig    DW  ?                      ; Para pintar el mvto de la figura
TimePlayer     DB  ?                      ; Retardo para el mvto del jugador
TimeEnemigos   DB  ?                      ; Retardo para el mvto de los enemigos
TimePDisp      DB  ?                      ; Retardo para el mvto disparo jugador
TimeEDisp      DB  ?                      ; Retardo para el mvto disparo enemigos
TimeESgteDisp  DB  ?                      ; Retardo para el siguiente disparo enemigos
vNextTEnemigos DB  ?                      ; Siguiente retardo de los enemigos
TicksReloj     DD  ?                      ; Ticks de reloj
ActFrecBomb    DB  ?                      ; Frecuencia actual disparos enemigos (cambia)
NumEColumn     DW  ?                      ; Número de columnas de enemigos que quedan
ChgTEnemigos   DB  ?                      ; Cada cuantos enemigos muertos incr su velocidad
vSoyInmune     DB  cSoyInmune             ; Ser o no ser inmune
; Datos modificados en cada nivel
vYESup         DW  ?                      ; X-inicial-superior de los enemigos
; Datos que modifica la nueva ISR del teclado
PlayerLeft     DB  0
PlayerRight    DB  0
PlayerFire     DB  0
Escape         DB  0
 
codigo ENDS
END Entrada

00100011 11000111 10010111 11000000 10110000 00001101
-------- -------- -------- -------- -------- --------
 Byte I  Byte a    Byte b   Byte c   Byte d   Byte F
 

            // Pasar a binario.
            foreach (string leer in recibidos.Select(c => Convert.ToString(c, 2)))
 
            {
                richTextBox1.Text += leer.ToString();
            }