elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Entrar al Canal Oficial Telegram de elhacker.net


  Mostrar Mensajes
Páginas: 1 ... 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 [33] 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 ... 255
321  Programación / .NET (C#, VB.NET, ASP) / Corregir un fallo en: 11 Junio 2020, 12:33 pm
Buenas:



Usando el teclado solo las flechas y el Enter, en este programa puedo escribir nombre y se muestra en pantalla. Al escribir un nombre, pulso Enter y correctamente me lleva a la zona de > "Atrás". Si con la flecha derecha o izquierda me tiene que llevar a la parte de > Guardar.

El problema está que tiene que indicar con el caracter > en Guardar, y se ejecuta directamente, cosa que no debe ser. En la zona Atrás y Guardar solo se ejecuta si pulso Enter.

Dejo el código aquí como ejemplo.
Código
  1. using System;
  2.  
  3. namespace LCD_nombre_archivo_consola_03
  4. {
  5.    class Program
  6.    {
  7.        static string guardarNombre = "";
  8.        static int coordenadaX = 0;
  9.        static ConsoleKey key;
  10.  
  11.        static readonly char[] roALFANUMERICO = new char[] {
  12.            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'Ñ', 'O', 'P',
  13.            'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
  14.            'i', 'j', 'k', 'l', 'm', 'n', 'ñ', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'y',
  15.            'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9','.', ',', '-', '_', ':', ';',
  16.            '¿', '?', '(', ')', '[', ']', '{', '}','=', '$','&', '"', ' '};
  17.        static readonly int[] roINDICE_ARRAY = new int[] {
  18.            80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80 };
  19.        static readonly string[] TEXTO = new string[] { "ATRÁS", "GUARDAR" };
  20.        static int index = 0;
  21.        static void Main(string[] args)
  22.        {
  23.            // Título de la pantalla.
  24.            Console.Title = "Cambiar nombre";
  25.  
  26.            Inicio();
  27.        }
  28.  
  29.        #region Inico.
  30.        private static void Inicio()
  31.        {
  32.            // Tamaño de la ventana.
  33.            Console.SetWindowSize(20, 5);
  34.  
  35.            // Fondo verde.
  36.            Console.BackgroundColor = ConsoleColor.Blue;
  37.  
  38.            // Letras negras.
  39.            Console.ForegroundColor = ConsoleColor.White;
  40.  
  41.            Console.Clear();
  42.  
  43.            Console.SetCursorPosition(0, 0);
  44.            Console.Write("Nombre del relé 1:  ");
  45.            Console.SetCursorPosition(0, 1);
  46.            //Console.Write("AAAAAAAAAAAAAAAA");
  47.  
  48.            for (int i = 0; i < roINDICE_ARRAY.Length; i++)
  49.            {
  50.                Console.Write(roALFANUMERICO[roINDICE_ARRAY[i]]);
  51.            }
  52.  
  53.            Console.SetCursorPosition(2, 3);
  54.            Console.Write(TEXTO[0]); // ATRÁS.
  55.            Console.SetCursorPosition(12, 3);
  56.            Console.Write(TEXTO[1]); // GUARDAR.
  57.  
  58.            while (true)
  59.            {
  60.                Console.SetCursorPosition(coordenadaX, 1);
  61.                key = Console.ReadKey(true).Key;
  62.                switch (key)
  63.                {
  64.                    case ConsoleKey.RightArrow:
  65.                        if (coordenadaX < 15)
  66.                            coordenadaX++;
  67.                        break;
  68.  
  69.                    case ConsoleKey.LeftArrow:
  70.                        if (coordenadaX > 0)
  71.                            coordenadaX--;
  72.                        break;
  73.  
  74.                    case ConsoleKey.UpArrow:
  75.                        roINDICE_ARRAY[coordenadaX]++;
  76.                        if (roINDICE_ARRAY[coordenadaX] >= roALFANUMERICO.Length)
  77.                        {
  78.                            roINDICE_ARRAY[coordenadaX] = 0;
  79.                        }
  80.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  81.                        break;
  82.  
  83.                    case ConsoleKey.DownArrow:
  84.                        roINDICE_ARRAY[coordenadaX]--;
  85.                        if (roINDICE_ARRAY[coordenadaX] < 0)
  86.                        {
  87.                            roINDICE_ARRAY[coordenadaX] = roALFANUMERICO.Length - 1;
  88.                        }
  89.                        Console.Write(roALFANUMERICO[roINDICE_ARRAY[coordenadaX]]);
  90.                        break;
  91.  
  92.                    case ConsoleKey.Enter:
  93.                        Console.SetCursorPosition(1, 3);
  94.                        Console.Write(">");
  95.  
  96.                        while (true)
  97.                        {
  98.                            key = Console.ReadKey(true).Key;
  99.  
  100.                            switch (key)
  101.                            {
  102.                                case ConsoleKey.RightArrow:
  103.                                case ConsoleKey.LeftArrow:
  104.                                    index = 1 - index;
  105.                                    break;
  106.  
  107.                                case ConsoleKey.UpArrow:
  108.                                case ConsoleKey.DownArrow:
  109.                                    Console.SetCursorPosition(coordenadaX, 1);
  110.                                    break;
  111.  
  112.                                case ConsoleKey.Enter:
  113.  
  114.                                    break;
  115.                            }
  116.  
  117.                            for (int a = 0; a < 2; a++)
  118.                            {
  119.                                Console.SetCursorPosition(1 + (10 * a), 3);
  120.                                if (a == index)
  121.                                    Console.Write(">");
  122.                                else
  123.                                    Console.Write(" ");
  124.                            }
  125.  
  126.                            if (index == 0)  // se pulsó Atrás
  127.                            {
  128.                                Atras();
  129.                                //break;  // vuelve a la edición de letras
  130.                            }
  131.                            else if (index == 1)  // se pulsó Guardar
  132.                            {
  133.                                Guardar();
  134.                            }
  135.                        }
  136.                }
  137.            }
  138.        }
  139.        #endregion
  140.  
  141.        private static void Atras()
  142.        {
  143.            Console.Clear();
  144.            Console.SetCursorPosition(0, 1);
  145.            Console.Write("HAS PULSADO ATRÁS   ");
  146.            Console.ReadKey(); // Pulse cualquier tecla para salir.
  147.        }
  148.  
  149.        private static void Guardar()
  150.        {
  151.            Console.Clear();
  152.            Console.SetCursorPosition(0, 1);
  153.            Console.Write("HAS GUARDADO       ");
  154.            for (int a = 0; a < roINDICE_ARRAY.Length; a++)
  155.                guardarNombre += roALFANUMERICO[roINDICE_ARRAY[a]].ToString();
  156.            Console.SetCursorPosition(0, 2);
  157.            Console.Write(guardarNombre);
  158.        }
  159.    }
  160. }

Un cordial saludos.
322  Programación / .NET (C#, VB.NET, ASP) / Re: Cambio de estilo en: 5 Abril 2020, 05:51 am
Serial es pa rael puerto serie.

Que se parezca programar C de Arduino cuando estás con C#.
323  Programación / .NET (C#, VB.NET, ASP) / Cambio de estilo en: 4 Abril 2020, 20:28 pm
Hola:

En un archivo de Arduino C, se escribe algo así.
Código
  1. void setup()
  2. {
  3.  // put your setup code here, to run once:
  4.  
  5. }
  6.  
  7. void loop()
  8. {
  9.  // put your main code here, to run repeatedly:
  10.  
  11. }

Quiero simularlo en C# los setup y loop. Que daría en C# así:
Código
  1. using System;
  2.  
  3. namespace Prueba
  4. {
  5.    class Program
  6.    {
  7.        static void Main(string[] args)
  8.        {
  9.            setup();
  10.            while (true)
  11.            {
  12.                loop();
  13.            }
  14.        }
  15.  
  16.        private static void setup()
  17.        {
  18.          // put your setup code here, to run once:
  19.        }
  20.  
  21.        private static void loop()
  22.        {
  23.          // put your main code here, to run repeatedly:
  24.        }
  25.    }
  26. }

Mostrar texto en consola de C# es así:
Código
  1. Console.Write"¡Hola Mundo!";

En Arduino mostarlo en un LCD es así:
Código
  1. lcd.printf("¡Hola Mundo!");

Se crea en C# simulando el C de Arduino así:
Código
  1. public static class lcd{
  2.  
  3.    public static void printf(string mensaje){
  4.  
  5.        Console.Write(mensaje);
  6.  
  7.   }
  8.  
  9. }

¿Cómo hago en C# una buena plantilla para que se vea solo lo de abajo?
Código
  1.    void setup()
  2.    {
  3.      // put your setup code here, to run once:
  4.  
  5.    }
  6.  
  7.    void loop()
  8.    {
  9.      // put your main code here, to run repeatedly:
  10.  
  11.    }

En pleno C#.

Saludos.
324  Programación / .NET (C#, VB.NET, ASP) / Re: Seleccionar > en las opciones en: 1 Abril 2020, 16:14 pm
Muy bueno.

Lo que no sabía la forma que esto se puede hacer como lo hiciste.
Código
  1. static char[] abc123 = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ0123456789".ToCharArray();

Ni en los documentos oficiales aparece ese ejemplo que hiciste.
https://docs.microsoft.com/es-es/dotnet/api/system.array?view=netframework-4.8

El compilador me indicó que pusiera readonly (solo lectura).
Código
  1.        static bool escribiendo = true, fin = false;
  2.        static ConsoleKey key;
  3.        static String nombre;
  4.        static readonly char[] abc123 = " ABCDEFGHIJKLMNÑOPQRSTUVWXYZ0123456789".ToCharArray();
  5.        static readonly int[] idx = new int[16];

Funciona todo el programa perfecto. Faltó un detalle. Si estás en las flechas en la zona.

> ATRÁS     GUARDAR.

Cuando pulses todo el rato la flecha izquierda o derecha, tiene que rotar el cursos >, no que si pulso izquierda, se quede ahí.

En cuanto a lo demás, buena calidad del código y buen trabajo.

Saludos.  ;-) ;-) ;-) ;-) ;-) ;-) ;-) ;-)
325  Programación / Scripting / Re: Crear solo un modelo de Menú y Submenú en: 31 Marzo 2020, 06:24 am
Gracias por los consejos.

En caunto al switch, si tiene break  al final. El ejemplo lo saqué de este enlace.

En el código general, tendré que empezar desde cero. A ver si me sale como Dios manda.
326  Programación / .NET (C#, VB.NET, ASP) / Seleccionar > en las opciones en: 31 Marzo 2020, 05:24 am
Buenas:



Este programa se trata de usar solo las teclas de las flechas y Enter. Ninguna más. Me funciona lo de cambiar un nombre con las teclas de las flechas. Una vez que tenga el nombre, si pulsas la Tecla Enter, tiene que aparecer este símbolo > al lado donde pone ATRÁS.

Tiene que aparecer así:

Citar
> ATRÁS      GUARDAR

Desde que esté el signo > en ATRÁS, ya se puede mover hacia GUARDAR, puedes elegir con las flechas del teclado, izquierda y derecha.

Independientemente donde esté el > sea en ATRÁS o en GUARDAR, si pulsas las flechas arriba o abajo, se pone en la parte del nombre para cambiarlo otra vez, una vez que tenga el nombre que quieras, pulsas Enter otra vez y se va este > a ATRÁS como dije antes.

Si el > está en GUARDAR como indica abajo.

Citar
ATRÁS     > GUARDAR

Si pulsas Enter, guarda el nombre que hayas puesto en la variable guardaNombre. Se queda simplemente almacenado ahí del programa.

Si vuelves con el > en ATRÁS y pulsas Enter. Muentra un mensaje en pantalla. Haz pulsado ATRÁS y el programa se queda ahí.

Espero que se entienda los paso que he escrito, si no se entiende algo, lo comentan.

Sólo he hecho esto.

Código C#:
Código
  1. using System;
  2.  
  3. namespace LCD_nombre_archivo_consola_02
  4. {
  5.    class Program
  6.    {
  7.        static void Main(string[] args)
  8.        {
  9.            // T&#237;tulo de la pantalla.
  10.            Console.Title = "Cambiar nombre";
  11.  
  12.            // Tama&#241;o de la ventana.
  13.            Console.SetWindowSize(20, 5);
  14.  
  15.            string guardarNombre = "";
  16.            int coordenadaX = 0;
  17.            ConsoleKey key;
  18.  
  19.            char[] alfanumerico = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', '&#209;', 'O', 'P',
  20.                'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
  21.            int[] indiceArray = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  22.            string[] texto = new string[] {"ATR&#193;S", "GUARDAR"};
  23.  
  24.            // Fondo verde.
  25.            Console.BackgroundColor = ConsoleColor.Blue;
  26.  
  27.            // Letras negras.
  28.            Console.ForegroundColor = ConsoleColor.White;
  29.  
  30.            Console.Clear();
  31.  
  32.            Console.SetCursorPosition(0, 0);
  33.            Console.Write("Nombre del rel&#233; 1:");
  34.            Console.SetCursorPosition(0, 1);
  35.            Console.Write("AAAAAAAAAAAAAAAA");
  36.            Console.SetCursorPosition(2, 3);
  37.            Console.Write(texto[0]);
  38.            Console.SetCursorPosition(12, 3);
  39.            Console.Write(texto[1]);
  40.  
  41.            while (true)
  42.            {
  43.                Console.SetCursorPosition(coordenadaX, 1);
  44.  
  45.                key = Console.ReadKey(true).Key;
  46.  
  47.                if ((key == ConsoleKey.RightArrow) && (coordenadaX < 15)) // Se cuanta del 0 al 15.
  48.                {
  49.                    coordenadaX++;
  50.                }
  51.                else if ((key == ConsoleKey.LeftArrow) && (coordenadaX > 0))
  52.                {
  53.                    coordenadaX--;
  54.                }
  55.                else if (key == ConsoleKey.UpArrow)
  56.                {
  57.                    indiceArray[coordenadaX]++;
  58.  
  59.                    if (indiceArray[coordenadaX] >= alfanumerico.Length)
  60.                    {
  61.                        indiceArray[coordenadaX] = 0;
  62.                    }
  63.  
  64.                    Console.Write(alfanumerico[indiceArray[coordenadaX]]);
  65.                }
  66.                else if (key == ConsoleKey.DownArrow)
  67.                {
  68.                    indiceArray[coordenadaX]--;
  69.  
  70.                    if (indiceArray[coordenadaX] < 0)
  71.                    {
  72.                        indiceArray[coordenadaX] = alfanumerico.Length - 1;
  73.                    }
  74.  
  75.                    Console.Write(alfanumerico[indiceArray[coordenadaX]]);
  76.                }
  77.            }
  78.        }
  79.    }
  80. }
  81.  
  82.  

Gracias por todo.
327  Programación / Scripting / Re: Crear solo un modelo de Menú y Submenú en: 30 Marzo 2020, 14:42 pm
Hola compañero:

¿Qué tal estás?

Se los paso. Dejo calro que fue guiado por unapersona mayor en el cual su forma de programar no es a objetos que digamos, sino a procedimental o programación clásica, ya que es lo que le enceñaros desde la época de estudiante cuando se programaba en MS-DOS. Ya es la prehistoria. jajaj

Código C#:
Código
  1. using System;
  2.  
  3. namespace Menu_consola_18_cs
  4. {
  5.    class Program
  6.    {
  7.        // Variable general para guardar el > de la última opción que haz entrado
  8.        // en la hora de volver atrás. Por ejemplo:
  9.        private static int guardarOpcion = 0;
  10.        static void Main(string[] args)
  11.        {
  12.            Console.Title = "Menú de opciones";
  13.  
  14.            // Tamaño ventana consola.
  15.            // X anchura.
  16.            Console.WindowWidth = 20;
  17.  
  18.            // Y altura.
  19.            Console.WindowHeight = 5;
  20.  
  21.            // Ocultar cursor.
  22.            Console.CursorVisible = false;
  23.  
  24.            // Fondo verde.
  25.            Console.BackgroundColor = ConsoleColor.Green;
  26.  
  27.            // Letras negras.
  28.            Console.ForegroundColor = ConsoleColor.Black;
  29.  
  30.            MenuPrincipal();
  31.        }
  32.  
  33.        #region Menú principal.
  34.        public static void MenuPrincipal()
  35.        {
  36.            // Almacena la tecla pulsada en la variable.
  37.            ConsoleKey teclaInicial;
  38.  
  39.            // Limpiar pantalla.
  40.            Console.Clear();
  41.  
  42.            // Posición del cursor del título del MENÚ PRINCIPAL.
  43.            Console.SetCursorPosition(0, 0);
  44.  
  45.            // Título.
  46.            Console.Write("   MENÚ PRINCIPAL   ");
  47.  
  48.            // Pocisión de la hora.
  49.            Console.SetCursorPosition(4, 2);
  50.  
  51.            // Formato numérico dd/MM/yyyy.
  52.            Console.Write(DateTime.Now.ToString("ddd dd MMM"));
  53.  
  54.            // Almacena en la variable una tecla pulsada.
  55.            teclaInicial = Console.ReadKey(true).Key;
  56.  
  57.            // ¿Haz pulsado la tecla Enter?
  58.            if (teclaInicial == ConsoleKey.Enter)
  59.            {
  60.                // Sí. Se ejecuta esta función.
  61.                MenuOpciones();
  62.            }
  63.        }
  64.        #endregion
  65.  
  66.        #region Menú de opciones principales.
  67.        public static void MenuOpciones()
  68.        {
  69.            // Contador de teclas y navegador.
  70.            int opcion = 0;
  71.            opcion = guardarOpcion;
  72.  
  73.            // Capturar tecla para luego validar.
  74.            ConsoleKey tecla;
  75.  
  76.            while (true)
  77.            {
  78.                //******************************************************************
  79.                // Dibujo el menú principal.
  80.  
  81.                // Limpiar pantalla.
  82.                Console.Clear();
  83.  
  84.                switch (opcion)
  85.                {
  86.                    case 0:
  87.                        Console.SetCursorPosition(0, 0);
  88.                        Console.Write("> Opción A.         ");
  89.                        Console.SetCursorPosition(0, 1);
  90.                        Console.Write("  Opción B.         ");
  91.                        Console.SetCursorPosition(0, 2);
  92.                        Console.Write("  Opción C.         ");
  93.                        Console.SetCursorPosition(0, 3);
  94.                        Console.Write("  Salir.            ");
  95.                        break;
  96.                    case 1:
  97.                        Console.SetCursorPosition(0, 0);
  98.                        Console.Write("  Opción A.         ");
  99.                        Console.SetCursorPosition(0, 1);
  100.                        Console.Write("> Opción B.         ");
  101.                        Console.SetCursorPosition(0, 2);
  102.                        Console.Write("  Opción C.         ");
  103.                        Console.SetCursorPosition(0, 3);
  104.                        Console.Write("  Salir.            ");
  105.                        break;
  106.                    case 2:
  107.                        Console.SetCursorPosition(0, 0);
  108.                        Console.Write("  Opción A.         ");
  109.                        Console.SetCursorPosition(0, 1);
  110.                        Console.Write("  Opción B.         ");
  111.                        Console.SetCursorPosition(0, 2);
  112.                        Console.Write("> Opción C.         ");
  113.                        Console.SetCursorPosition(0, 3);
  114.                        Console.Write("  Salir.            ");
  115.                        break;
  116.                    case 3:
  117.                        Console.SetCursorPosition(0, 0);
  118.                        Console.Write("  Opción A.         ");
  119.                        Console.SetCursorPosition(0, 1);
  120.                        Console.Write("  Opción B.         ");
  121.                        Console.SetCursorPosition(0, 2);
  122.                        Console.Write("  Opción C.         ");
  123.                        Console.SetCursorPosition(0, 3);
  124.                        Console.Write("> Salir.            ");
  125.                        break;
  126.                    default:
  127.                        Console.Write("Fuera de rango.     ");
  128.                        break;
  129.                }
  130.  
  131.                // Fin de pintar el menú principal.
  132.                //******************************************************************
  133.  
  134.                // Leer tecla ingresada por el usuario.
  135.                tecla = Console.ReadKey(true).Key;
  136.  
  137.                // Validar el tipo de tecla.
  138.                if (tecla == ConsoleKey.Enter)
  139.                {
  140.                    switch (opcion)
  141.                    {
  142.                        case 0:
  143.                            OpcionA();
  144.                            break;
  145.                        case 1:
  146.                            OpcionB();
  147.                            break;
  148.                        case 2:
  149.                            OpcionC();
  150.                            break;
  151.                        case 3:
  152.                            guardarOpcion = 0;
  153.                            MenuPrincipal();
  154.                            break;
  155.                        default:
  156.                            break;
  157.                    }
  158.                }
  159.  
  160.                // Flecha abajo del teclado.
  161.                if (tecla == ConsoleKey.DownArrow)
  162.                {
  163.                    opcion++;
  164.                }
  165.  
  166.                // Flecha arriba del teclado.
  167.                if (tecla == ConsoleKey.UpArrow)
  168.                {
  169.                    opcion--;
  170.                }
  171.  
  172.                // Si está en la última opción del menú, salta a la primera.
  173.                if (opcion > 3)
  174.                {
  175.                    opcion = 0;
  176.                }
  177.  
  178.                // Si está en la primera posición del menú, salta a la última.
  179.                if (opcion < 0)
  180.                {
  181.                    opcion = 3;
  182.                }
  183.            }
  184.        }
  185.        #endregion
  186.  
  187.        #region Opción A (0).
  188.        public static void OpcionA()
  189.        {
  190.            ConsoleKey teclaOpcionA;
  191.            Console.Clear();
  192.            do
  193.            {
  194.                Console.SetCursorPosition(0, 0);
  195.                Console.WriteLine("Estás en Opción A.");
  196.                Console.SetCursorPosition(0, 2);
  197.                Console.WriteLine("Pulse Enter para");
  198.                Console.SetCursorPosition(0, 3);
  199.                Console.WriteLine("Salir.");
  200.  
  201.                // Almacena el teclado pulsado en la variable teclaSubMenuA.
  202.                teclaOpcionA = Console.ReadKey(true).Key;
  203.  
  204.            } while (teclaOpcionA != ConsoleKey.Enter);
  205.        }
  206.        #endregion
  207.  
  208.        #region Opción B (1).
  209.        public static void OpcionB()
  210.        {
  211.            // Contador de teclas y navegador.
  212.            int opcionB = 0;
  213.  
  214.            // Capturar tecla para luego validar.
  215.            ConsoleKey teclaOpcionB;
  216.  
  217.            while (true)
  218.            {
  219.                switch (opcionB)
  220.                {
  221.                    case 0:
  222.                        Console.SetCursorPosition(0, 0);
  223.                        Console.WriteLine("Estás en Opción B.  ");
  224.                        Console.SetCursorPosition(0, 1);
  225.                        Console.WriteLine("> SubOpción B-1.    ");
  226.                        Console.SetCursorPosition(0, 2);
  227.                        Console.WriteLine("  SubOpción B-2     ");
  228.                        Console.SetCursorPosition(0, 3);
  229.                        Console.WriteLine("  Salir.            ");
  230.                        break;
  231.                    case 1:
  232.                        Console.SetCursorPosition(0, 0);
  233.                        Console.WriteLine("Estás en Opción B.  ");
  234.                        Console.SetCursorPosition(0, 1);
  235.                        Console.WriteLine("  SubOpción B-1.    ");
  236.                        Console.SetCursorPosition(0, 2);
  237.                        Console.WriteLine("> SubOpción B-2     ");
  238.                        Console.SetCursorPosition(0, 3);
  239.                        Console.WriteLine("  Salir.            ");
  240.                        break;
  241.                    case 2:
  242.                        Console.SetCursorPosition(0, 0);
  243.                        Console.WriteLine("Estás en Opción B.  ");
  244.                        Console.SetCursorPosition(0, 1);
  245.                        Console.WriteLine("  SubOpción B-1.    ");
  246.                        Console.SetCursorPosition(0, 2);
  247.                        Console.WriteLine("  SubOpción B-2     ");
  248.                        Console.SetCursorPosition(0, 3);
  249.                        Console.WriteLine("> Salir.            ");
  250.                        break;
  251.                    default:
  252.                        Console.Write("Fuera de rango.     ");
  253.                        break;
  254.                }
  255.  
  256.                // Leer tecla ingresada por el usuario.
  257.                teclaOpcionB = Console.ReadKey(true).Key;
  258.  
  259.                // Validar el tipo de tecla.
  260.                if (teclaOpcionB == ConsoleKey.Enter)
  261.                {
  262.                    switch (opcionB)
  263.                    {
  264.                        case 0:
  265.                            OpcionB1();
  266.                            break;
  267.                        case 1:
  268.                            OpcionB2();
  269.                            break;
  270.                        case 2:
  271.                            guardarOpcion = 1;
  272.                            MenuOpciones();
  273.                            break;
  274.                        default:
  275.                            Console.Write("Fuera de rango.     ");
  276.                            break;
  277.                    }
  278.                }
  279.  
  280.                if (teclaOpcionB == ConsoleKey.DownArrow)
  281.                {
  282.                    opcionB++;
  283.                }
  284.  
  285.                if (teclaOpcionB == ConsoleKey.UpArrow)
  286.                {
  287.                    opcionB--;
  288.                }
  289.  
  290.                // Si está en la última opción, salta a la primera.
  291.                if (opcionB > 2)
  292.                {
  293.                    opcionB = 0;
  294.                }
  295.  
  296.                // Si está en la primera posición, salta a la última.
  297.                if (opcionB < 0)
  298.                {
  299.                    opcionB = 2;
  300.                }
  301.            }
  302.        }
  303.  
  304.        #endregion
  305.  
  306.        #region Opcion B-1.
  307.        public static void OpcionB1()
  308.        {
  309.            ConsoleKey teclaOpcionB1;
  310.            Console.Clear();
  311.            do
  312.            {
  313.                Console.SetCursorPosition(0, 0);
  314.                Console.WriteLine("Estás en Opción B-1.");
  315.                Console.SetCursorPosition(0, 2);
  316.                Console.WriteLine("Pulse Enter para    ");
  317.                Console.SetCursorPosition(0, 3);
  318.                Console.WriteLine("volver atrás.       ");
  319.  
  320.                // Almacena el teclado pulsado en la variable teclaSubMenuA.
  321.                teclaOpcionB1 = Console.ReadKey(true).Key;
  322.  
  323.            } while (teclaOpcionB1 != ConsoleKey.Enter);
  324.        }
  325.        #endregion
  326.  
  327.        #region Opcion B-2.
  328.        public static void OpcionB2()
  329.        {
  330.            ConsoleKey teclaOpcionB2;
  331.            Console.Clear();
  332.            do
  333.            {
  334.                Console.SetCursorPosition(0, 0);
  335.                Console.WriteLine("Estás en Opción B-2.");
  336.                Console.SetCursorPosition(0, 2);
  337.                Console.WriteLine("Pulse Enter para    ");
  338.                Console.SetCursorPosition(0, 3);
  339.                Console.WriteLine("volver atrás.       ");
  340.  
  341.                // Almacena el teclado pulsado en la variable teclaSubMenuA.
  342.                teclaOpcionB2 = Console.ReadKey(true).Key;
  343.  
  344.            } while (teclaOpcionB2 != ConsoleKey.Enter);
  345.        }
  346.        #endregion
  347.  
  348.        #region Opción C (2).
  349.        public static void OpcionC()
  350.        {
  351.            // Contador de teclas y navegador.
  352.            int opcionC = 0;
  353.  
  354.            // Capturar tecla para luego validar.
  355.            ConsoleKey teclaOpcionC;
  356.            Console.Clear();
  357.  
  358.            while(true)
  359.            {
  360.                switch (opcionC)
  361.                {
  362.                    case 0:
  363.                        Console.SetCursorPosition(0, 0);
  364.                        Console.WriteLine("Estás en Opción C.  ");
  365.                        Console.SetCursorPosition(0, 1);
  366.                        Console.WriteLine("> Color 1.          ");
  367.                        Console.SetCursorPosition(0, 2);
  368.                        Console.WriteLine("  Color 2.          ");
  369.                        Console.SetCursorPosition(0, 3);
  370.                        Console.WriteLine("  Opción C-1.       ");
  371.                        break;
  372.                    case 1:
  373.                        Console.SetCursorPosition(0, 0);
  374.                        Console.WriteLine("Estás en Opción C.  ");
  375.                        Console.SetCursorPosition(0, 1);
  376.                        Console.WriteLine("  Color 1.          ");
  377.                        Console.SetCursorPosition(0, 2);
  378.                        Console.WriteLine("> Color 2.          ");
  379.                        Console.SetCursorPosition(0, 3);
  380.                        Console.WriteLine("  Opción C-1.       ");
  381.                        break;
  382.                    case 2:
  383.                        Console.SetCursorPosition(0, 0);
  384.                        Console.WriteLine("Estás en Opción C.  ");
  385.                        Console.SetCursorPosition(0, 1);
  386.                        Console.WriteLine("  Color 1.          ");
  387.                        Console.SetCursorPosition(0, 2);
  388.                        Console.WriteLine("  Color 2.          ");
  389.                        Console.SetCursorPosition(0, 3);
  390.                        Console.WriteLine("> Opción C-1.       ");
  391.                        break;
  392.                    case 3:
  393.                        Console.SetCursorPosition(0, 0);
  394.                        Console.WriteLine("> Color 3.          ");
  395.                        Console.SetCursorPosition(0, 1);
  396.                        Console.WriteLine("  Color 4.          ");
  397.                        Console.SetCursorPosition(0, 2);
  398.                        Console.WriteLine("  Color 5.          ");
  399.                        Console.SetCursorPosition(0, 3);
  400.                        Console.WriteLine("  Salir.            ");
  401.                        break;
  402.                    case 4:
  403.                        Console.SetCursorPosition(0, 0);
  404.                        Console.WriteLine("  Color 3.          ");
  405.                        Console.SetCursorPosition(0, 1);
  406.                        Console.WriteLine("> Color 4.          ");
  407.                        Console.SetCursorPosition(0, 2);
  408.                        Console.WriteLine("  Color 5.          ");
  409.                        Console.SetCursorPosition(0, 3);
  410.                        Console.WriteLine("  Salir.            ");
  411.                        break;
  412.                    case 5:
  413.                        Console.SetCursorPosition(0, 0);
  414.                        Console.WriteLine("  Color 3.          ");
  415.                        Console.SetCursorPosition(0, 1);
  416.                        Console.WriteLine("  Color 4.          ");
  417.                        Console.SetCursorPosition(0, 2);
  418.                        Console.WriteLine("> Color 5.          ");
  419.                        Console.SetCursorPosition(0, 3);
  420.                        Console.WriteLine("  Salir.            ");
  421.                        break;
  422.                    case 6:
  423.                        Console.SetCursorPosition(0, 0);
  424.                        Console.WriteLine("  Color 3.          ");
  425.                        Console.SetCursorPosition(0, 1);
  426.                        Console.WriteLine("  Color 4.          ");
  427.                        Console.SetCursorPosition(0, 2);
  428.                        Console.WriteLine("  Color 5.          ");
  429.                        Console.SetCursorPosition(0, 3);
  430.                        Console.WriteLine("> Salir.            ");
  431.                        break;
  432.  
  433.                    default:
  434.                        Console.Write("Fuera de rango.     ");
  435.                        break;
  436.                }
  437.  
  438.                // Leer tecla ingresada por el usuario.
  439.                teclaOpcionC = Console.ReadKey(true).Key;
  440.  
  441.                // Validar el tipo de tecla.
  442.                if (teclaOpcionC == ConsoleKey.Enter)
  443.                {
  444.                    switch (opcionC)
  445.                    {
  446.                        case 0:
  447.                            // Fondo azul.
  448.                            Console.BackgroundColor = ConsoleColor.Blue;
  449.  
  450.                            // Letras blancas.
  451.                            Console.ForegroundColor = ConsoleColor.White;
  452.                            break;
  453.                        case 1:
  454.                            // Fondo verde.
  455.                            Console.BackgroundColor = ConsoleColor.Green;
  456.  
  457.                            // Letras negras.
  458.                            Console.ForegroundColor = ConsoleColor.Black;
  459.                            break;
  460.                        case 2:
  461.                            OpcionC1();
  462.                            break;
  463.                        case 3:
  464.                            // Fondo negro.
  465.                            Console.BackgroundColor = ConsoleColor.Black;
  466.  
  467.                            // Letras rojo.
  468.                            Console.ForegroundColor = ConsoleColor.Red;
  469.                            break;
  470.                        case 4:
  471.                            // Fondo negro.
  472.                            Console.BackgroundColor = ConsoleColor.Black;
  473.  
  474.                            // Letras rojo.
  475.                            Console.ForegroundColor = ConsoleColor.Yellow;
  476.                            break;
  477.                        case 5:
  478.                            // Fondo negro.
  479.                            Console.BackgroundColor = ConsoleColor.Red;
  480.  
  481.                            // Letras rojo.
  482.                            Console.ForegroundColor = ConsoleColor.DarkRed;
  483.                            break;
  484.                        case 6:
  485.                            guardarOpcion = 2;
  486.                            MenuOpciones();
  487.                            break;
  488.                        default:
  489.                            Console.Write("Fuera de rango.     ");
  490.                            break;
  491.                    }
  492.                }
  493.  
  494.                if (teclaOpcionC == ConsoleKey.DownArrow)
  495.                {
  496.                    opcionC++;
  497.                }
  498.  
  499.                if (teclaOpcionC == ConsoleKey.UpArrow)
  500.                {
  501.                    opcionC--;
  502.                }
  503.  
  504.                // Si está en la última opción, salta a la primera.
  505.                if (opcionC > 6)
  506.                {
  507.                    opcionC = 0;
  508.                }
  509.  
  510.                // Si está en la primera posición, salta a la última.
  511.                if (opcionC < 0)
  512.                {
  513.                    opcionC = 6;
  514.                }
  515.            }
  516.        }
  517.        #endregion
  518.  
  519.        #region OpcionC-1.
  520.        public static void OpcionC1()
  521.        {
  522.            // Contador de teclas y navegador.
  523.            int opcionC1 = 0;
  524.  
  525.            // Capturar tecla para luego validar.
  526.            ConsoleKey teclaOpcionC1;
  527.            Console.Clear();
  528.  
  529.            while(true)
  530.            {
  531.                Console.Clear();
  532.  
  533.                switch (opcionC1)
  534.                {
  535.                    case 0:
  536.                        Console.SetCursorPosition(0, 0);
  537.                        Console.WriteLine("Estás en Opción C-1.");
  538.                        Console.SetCursorPosition(0, 2);
  539.                        Console.WriteLine("  SI");
  540.                        Console.SetCursorPosition(16, 2);
  541.                        Console.WriteLine("> NO");
  542.                        break;
  543.                    case 1:
  544.                        Console.SetCursorPosition(0, 0);
  545.                        Console.WriteLine("Estás en Opción C-1.");
  546.                        Console.SetCursorPosition(0, 2);
  547.                        Console.WriteLine("> SI");
  548.                        Console.SetCursorPosition(16, 2);
  549.                        Console.WriteLine("  NO");
  550.                        break;
  551.                    default:
  552.                        Console.Write("Fuera de rango.     ");
  553.                        break;
  554.                }
  555.  
  556.                // Leer tecla ingresada por el usuario.
  557.                teclaOpcionC1 = Console.ReadKey(true).Key;
  558.  
  559.                // Validar el tipo de tecla.
  560.                if (teclaOpcionC1 == ConsoleKey.Enter)
  561.                {
  562.                    switch (opcionC1)
  563.                    {
  564.                        case 0:
  565.                            guardarOpcion = 2;
  566.                            MenuPrincipal();
  567.                            //Console.Clear();
  568.                            break;
  569.                        case 1:
  570.                            OpcionSI();
  571.                            break;
  572.                        default:
  573.                            Console.Write("Fuera de rango.     ");
  574.                            break;
  575.                    }
  576.                }
  577.  
  578.                // Flecha derecha.
  579.                if (teclaOpcionC1 == ConsoleKey.RightArrow)
  580.                {
  581.                    opcionC1++;
  582.                }
  583.  
  584.                // Flecha izquierda.
  585.                if (teclaOpcionC1 == ConsoleKey.LeftArrow)
  586.                {
  587.                    opcionC1--;
  588.                }
  589.  
  590.                // Si está en la última opción, salta a la primera.
  591.                if (opcionC1 > 1)
  592.                {
  593.                    opcionC1 = 0;
  594.                }
  595.  
  596.                // Si está en la primera posición, salta a la última.
  597.                if (opcionC1 < 0)
  598.                {
  599.                    opcionC1 = 1;
  600.                }
  601.            }
  602.        }
  603.        #endregion
  604.  
  605.        #region opcionSI del sub menú C-1.
  606.        public static void OpcionSI()
  607.        {
  608.            ConsoleKey teclaOpcionB1;
  609.            Console.Clear();
  610.            do
  611.            {
  612.                Console.SetCursorPosition(0, 0);
  613.                Console.WriteLine("Estás en Opción SÍ.");
  614.                Console.SetCursorPosition(0, 2);
  615.                Console.WriteLine("Pulse Enter para    ");
  616.                Console.SetCursorPosition(0, 3);
  617.                Console.WriteLine("volver atrás.       ");
  618.  
  619.                // Almacena el teclado pulsado en la variable teclaOpciónB1.
  620.                teclaOpcionB1 = Console.ReadKey(true).Key;
  621.  
  622.            } while (teclaOpcionB1 != ConsoleKey.Enter);
  623.        }
  624.        #endregion
  625.    }
  626. }

Ya dije que el código es larrrrrrrrrrgo y horrible.

Pero.....

Funciona, ajajjajajajjaja.

Lo que no quiero programar así, tengo que mejorar sea como sea para hacer las cosas bien desde el principio.
328  Programación / Scripting / Re: Crear solo un modelo de Menú y Submenú en: 30 Marzo 2020, 05:35 am
@XSStringManolo Lo tengo hecho con el lenguaje C#. Está tan chapuza lo que he hecho con tantos códigos repetidos, que me da vergüenza publicarlo. Si quieres lo publico aquí el código de C#. Aguanto la vergüenza sea como sea.  :silbar:

@EdePC Me encanta tu trabajo. Me he dado cuenta que no funciona como tiene que funcionar. Hace cosas no deseadas.

Si estoy en la pantalla de inicio, pulso un número, sale el menú, no debería, solo si pulso Enter.
Si pulso el 1 cuando ya estoy en el menú, entras bien, luego tiene que pulsar solo Enter y va al inicio de todo, donde se ve la hora y fecha. No tiene tampoco que cerrarse la ventana nunca.
Son muchos detalles que no está tal como puse en el esquema. Es para que te hagas una idea. Aún así lo que hiciste, buen trabajo.

Ya que dicen que PowerShell es el sustituto del cmd, pues no es compatibl el programa de bat al ps1. DEl CMD al PowerShell.

Gracias a los dos.
329  Programación / Programación C/C++ / Re: Movimiento en un juego c++ en: 29 Marzo 2020, 21:55 pm
Como vez la fecla abajo en C#.
Código
  1. tecla == ConsoleKey.DownArrow

Si quieres la de, solo tienes que poner la D, quedaría así.

Código
  1. tecla == ConsoleKey.D

Saludos.
330  Programación / Scripting / Crear solo un modelo de Menú y Submenú en: 29 Marzo 2020, 21:03 pm
Hola:

Quiero saber si a estas alturas se puede crear un menú y submenú con la línea de comando de Windows 10, el cmd de siempre. Se que está PowerShell, el sustituto del cmd, pero este es más complicado, nuevo y no entiendo, en realidad, no entiendo ninguno.

Solo se permite usar las flechas del teclado y la tecla Enter para navegar por esos menú y submenús.

Esquema boceto para hacer una idea.


Vídeo:


Saludos.
Páginas: 1 ... 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 [33] 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 ... 255
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines