Curso C# 2 (Proyecto 1 piedra papel y tijera)

 

Proyecto 1 piedra papel y tijera

Vamos a crear una primera aplicación de consola con los siguientes requisitos:

·         El usuario podrá elegir una única opción (piedra, papel o tijera).

·         La opción del oponente debe ser aleatoria.

·         El usuario debe recibir un mensaje indicando el resultado.

·         El usuario debe ser preguntado si quiere jugar de nuevo o no.

Vamos a empezar por crear un nuevo proyecto en la carpeta Projects que tenemos en el escritorio

Lo abrimos en VS code

Y voy a cambiar el mensaje a consola por piedra papel y tijera

Console.WriteLine("Piedra, Papel, Tijera");

 

Lo que queremos es que el juego dure mientras el usuario no indique lo contrario. Por ello vamos a usar un bucle while, con su condición a true de forma que el juego sea un bucle infinito mientras no se indique lo contrario.

Como se trata de una sencilla app de consola sin interfaz gráfica vamos a ir mandando mensajes por consola para que el usuario entienda por dónde va el juego:

 

Console.WriteLine("Piedra, Papel, Tijera");
while (true)
{
    Console.WriteLine("Are you ready?");
    Console.WriteLine("Let´s begin¡¡¡");
}

Lo primero que tenemos que hacer es dar a elegir al usuario qué opción va a querer seleccionar, piedra, papel o tijera. Para ello como estamos en consola usaremos teclas para elegir las opciones:

Console.WriteLine("Rock Paper Scissors");
while (true)
{
    Console.WriteLine("Are you ready?");
    Console.WriteLine("Let´s begin¡¡¡");
 
    //Opciones
    Console.WriteLine("Choose R, P or S: [R]ock, [P]aper or [S]cissors: ");
}

 Si ejecutamos ahora al ser un bucle infinito estaría imprimiendo constantemente los mensajes y eso no es lo que queremos, vamos a pensar cómo parar el bucle y capturarla opción elegida por el usuario. Para ello tenemos la opción Console.ReadLine(), al escribir este método la ejecución se va a detener hasta que el usuario haga su elección o realice la acción que le indiquemos.

Console.WriteLine("Rock Paper Scissors");
while (true)
{
    Console.WriteLine("Are you ready?");
    Console.WriteLine("Let´s begin¡¡¡");
 
    //Opciones
    Console.WriteLine("Choose R, P or S: [R]ock, [P]aper or [S]cissors: ");
    Console.ReadLine();
}

Vamos a ver si es cierto que el bucle se detiene a la espera de que el usuario escriba, abrimos nuestra terminal y lanzamos el comando dotnet run

Podemos ver como se muestran nuestros mensajes y el bucle se detiene al llegar al readLine

 

Para saber lo que el usuario ha escrito, lo siguiente será guardar el ReadLine en una variable que podemos llamar selecedChoice y validar que el usuario hay escogido alguna delas 3 opciones permitidas es decir R, P o S.

NOTA: El método ReadLine devuelve un string. Así que para la comparación debo comparar contra un string “comillas dobles”, si pongo un char ‘comillas simples me devolverá error’-

Console.WriteLine("Rock Paper Scissors");
while (true)
{
    Console.WriteLine("Are you ready?");
    Console.WriteLine("Let´s begin¡¡¡");
 
    //Opciones
    Console.WriteLine("Choose R, P or S: [R]ock, [P]aper or [S]cissors: ");
   
    //Leemos la respuesta del usuario y lo guardamos en una variable
    var selectedChoice = Console.ReadLine();
 
    /*Validamos que la respuesta sea una de las 3 letras permitidas
      con un operador ternario, además hacemos todas las respuestas
      Minúsculas
    */
   
    if(selectedChoice?.ToLower() != "r" &&
       selectedChoice?.ToLower() != "p" &&
       selectedChoice?.ToLower() != "s")
       {
          Console.WriteLine("Please, select only one letter; R, P or S");
       }
}

 Hasta aquí tenemos hecha la validación, ahora debemos volver a darle al usuario la opción de que vuelva a elegir algo pero esta vez vamos a mover la validación aun método, ya que la estructura de controlo anterior no nos sirve no podemos estar haciendo if else constantemente hasta que el usuario introduzca un respuesta válida.

MÉTODO

Estamos en C# así que a nuestro método debemos darle un tipado, en nuestro caso va a devolver un string por tanto  crearemos nuestro método y dentro de él pondremos nuestra estructura de control:

Console.WriteLine("Rock Paper Scissors");
while (true)
{
    Console.WriteLine("Are you ready?");
    Console.WriteLine("Let´s begin¡¡¡");
 
   
}
 
string SelectChoice()
{
   //Opciones
    Console.WriteLine("Choose R, P or S: [R]ock, [P]aper or [S]cissors: ");
   
    //Leemos la respuesta del usuario y lo guardamos en una variable
    var selectedChoice = Console.ReadLine();
   
    if(selectedChoice?.ToLower() != "r" &&
       selectedChoice?.ToLower() != "p" &&
       selectedChoice?.ToLower() != "s")
       {
          Console.WriteLine("Please, select only one letter; R, P or S");
       }
       return selectedChoice;
}

 RECURSIVIDAD

Por tanto, si llamamos a este método se hará la validación y ahora en caso de que el usuario introduzca una respuesta errónea usaremos una característica muy útil de los métodos y funciones que es la recursividad, es decir que el método se llame a sí mismo:

Console.WriteLine("Rock Paper Scissors");
while (true)
{
    Console.WriteLine("Are you ready?");
    Console.WriteLine("Let´s begin¡¡¡"); 
}
 
string SelectChoice()
{
   //Opciones
    Console.WriteLine("Choose R, P or S: [R]ock, [P]aper or [S]cissors: ");
   
    //Leemos la respuesta del usuario y lo guardamos en una variable
    var selectedChoice = Console.ReadLine();
 
    /*Validamos que la respuesta sea una de las 3 letras permitidas
      con un operador ternario, además hacemos todas las respuestas
      Minúsculas
    */
   
    if(selectedChoice?.ToLower() != "r" &&
       selectedChoice?.ToLower() != "p" &&
       selectedChoice?.ToLower() != "s")
       {
         //Si la respuesta es erróna mandamos mensaje y volvemos a
         //LLamar a este mismo método desde sí mismo RECURSIVIDAD
          Console.WriteLine("Please, select only one letter; R, P or S");
          selectedChoice = SelectChoice();
       }
       return selectedChoice;
}

 

Ahora todas las veces que el usuario responda mal el método se llamará a sí mismo, y solo saldrá de ese bucle si el usuario responde con alguna de las opciones correctas, saliendo por el return, es deci devolviendo la opción escogida.

Pero falta un detalle importante, debemos llamara a nuestro método para que se ejecute, y debemos llamarlo dentro de nuestro bucle while ()

 

Método Parse y Concatenación

Sabemos que nuestro método SelectedChoice nos devuelve un String, pero como es una sola letra, una cosa que podemos hacer es convertir esa respuesta de string a char y así presentamos el método parse. Así que una vez que tenemos la respuesta la convertimos a char y por último mostramos la respuesta en la salida del programa, concatenando texto con la variable, para concatenar anteponemos el símbolo $ y de este modo entre llaves nos deja añadir la variable (template strings) (rojo):

Console.WriteLine("Rock Paper Scissors");
while (true)
{
    Console.WriteLine("Are you ready?");
    Console.WriteLine("Let´s begin¡¡¡");
 
    //Llamamos a nuestro método SelectChoice
    var selectedChoice = SelectChoice();
 
    //Convertimos la respuesta a char con el método Parse
    var yourChoice = char.Parse(selectedChoice);
 
    //Mostramos por salida la respuesta elegida
    Console.WriteLine($"You selected {yourChoice}");
 
   
}
 
string SelectChoice()
{
   //Opciones
    Console.WriteLine("Choose R, P or S: [R]ock, [P]aper or [S]cissors: ");
   
    //Leemos la respuesta del usuario y lo guardamos en una variable
    var selectedChoice = Console.ReadLine();
 
    /*Validamos que la respuesta sea una de las 3 letras permitidas
      con un operador ternario, además hacemos todas las respuestas
      Minúsculas
    */
   
    if(selectedChoice?.ToLower() != "r" &&
       selectedChoice?.ToLower() != "p" &&
       selectedChoice?.ToLower() != "s")
       {
         //Si la respuesta es erróna mandamos mensaje y volvemos a
         //LLamar a este mismo método desde sí mismo RECURSIVIDAD
          Console.WriteLine("Please, select only one letter; R, P or S");
          selectedChoice = SelectChoice();
       }
       return selectedChoice;

Podemos ejecutar desde la terminal de VS o desde el símbolo de sistema

AGREGANDO LA OPCIÓN DEL OPONENTE

Vamos ahora a añadir la opción del oponente, para ello vamos a crear un nuevo método. Esta vez en vez de trabajar con el tipo string vamos a trabajar directamente con el tipo char.

char GetOpponentChoice()
{
   
}

 

Lo que queremos hacer es elegir un número aleatorio, para ello crearemos un Array de tipo char con las opciones posibles, mira como declaramos un array con su tipo y como lo inicializamos con sus valores:

char GetOpponentChoice()
{
  char[] options  = new char[] { 'R', 'P', 'S' };
}

 

Lo que queremos es elegir de forma aleatoria una de estas 3 opciones, para ello usaremos el método random.

char GetOpponentChoice()
{
  char[] options  = new char[] { 'R', 'P', 'S' };
 
  Random random = new Random();
}
 

Ahora vamos a trabajar con el índice del Array usando el método random que nos elegirá aleatoriamente una posición del Array para guardarlo como respuesta aleatoria y lo guardamos en una variable que podemos llamar como queramos en este caso la he llamado randomIndex:

char GetOpponentChoice()
{
  //Creamos e inicailizamos una arry char con las opciones
  char[] options  = new char[] { 'R', 'P', 'S' };
  //Creamos un objeto Random
  Random random = new Random();
  //Escogemos de modo alatorio una opción del array
  int randomIndex = random.Next(0, options.Length);
}

 

Observa que a la variaboe randomIndex le hemos dado el tipo integer ya que lo que lo que va a guardar es un numero entero que se corresponderá con alguna posición del array (0, 1, 2).

Sólo nos queda devolver la respuesta aleatoria que como puedes ver es lo que contiene el Array en la posición indicada de forma aleatoria:

char GetOpponentChoice()
{
  //Creamos e inicailizamos una arry char con las opciones
  char[] options  = new char[] { 'R', 'P', 'S' };
  //Creamos un objeto Random
  Random random = new Random();
  //Escogemos de modo alatorio una opción del array
  int randomIndex = random.Next(0, options.Length);
  //Retornamos la repuesta que será lo que contenga el array options
  //en la posición que le indicamos en la variable randomIndex
  return options[randomIndex];
}

 

Ahora hay que llamar a nuestro nuevo método en el bucle While que es donde tenemos la secuencia principal de nuestro juego:

Console.WriteLine("Rock Paper Scissors");
while (true)
{
    Console.WriteLine("Are you ready?");
    Console.WriteLine("Let´s begin¡¡¡");
 
    //Llamamos a nuestro método SelectChoice
    var selectedChoice = SelectChoice();
    var yourChoice = char.Parse(selectedChoice);
   
   //Mostramos por salida la respuesta elegida
    Console.WriteLine($"You selected {yourChoice}");
 
 
 
 
   /*Llamamos al método char GetOpponentChoice() que es el que
   nos devuelve la respuesta aleatoria de nuestro oponente y
   guardamos esa respuesta en una variable
   */  
   var opponentChoice = GetOpponentChoice();
}

 

Vamos a ejecutarlo para ver que tenemos hasta ahora esta vez desde la consola de VSCode.

Como puedes ver yo elijo r y el PC elije P, no tenemos nada mas codificado por lo que el bucle vuelve a empezar, por tanto de momento vamos bien.

RESOVIENDO EL GANADOR DE LA PARTIDA

Primero resolveremos el caso de que sea un empate, que es cuando los dos escogemos la misma opción, por supuesto todo esto lo programamos dentro de nuestro while que es el flujo principal de nuestro juego:

Console.WriteLine("Rock Paper Scissors");
   if(opponentChoice == yourChoice)
   {
      Console.Write("Tie¡");
   }
 
}

 

Ahora debemos pensar cómo vamos a solucionar quien gana en caso de que no sea un empate, podríamos hacerlo con estructuras de contro if else en el while, pero para hacerlo más limpio lo vamos a hacer en un nuevo método en este caso un método de tipo void (que no devuelve nada).

Obsrva que al método le tenemos que pasar como parámetros las variables de las elecciones de cada contrincante, opponentChoice y yourChoice, separadas con una coma e indicando su tipo en cada una (rojo)

void  DecideWinner(char opponentChoice, char yourChoice)
{
  //CASO EMPATE
   if(opponentChoice == yourChoice) Console.Write("Tie¡");
   
}

 

Y por supuesto hay que llamar al método desde el while

Console.WriteLine("Rock Paper Scissors");
while (true)
{
    Console.WriteLine("Are you ready?");
    Console.WriteLine("Let´s begin¡¡¡");
 
    //Llamamos a nuestro método SelectChoice
    var selectedChoice = SelectChoice();
    var yourChoice = char.Parse(selectedChoice);
   
   //Mostramos por salida la respuesta elegida
    Console.WriteLine($"You selected {yourChoice}");
 
   /*Llamamos al método char GetOpponentChoice() que es el que
   nos devuelve la respuesta aleatoria de nuestro oponente y
   guardamos esa respuesta en una variable para mostrar la
   respuesta de nuestro oponente virtul
   */  
   var opponentChoice = GetOpponentChoice();
   Console.WriteLine($"I chose {opponentChoice}");
 
   //Llamada al método para ver el ganador o el empate
   DecideWinner(opponentChoice, yourChoice);
 
}
 

Ya tenemos el método que analiza si hay empate, ahora debemos pensar como resolver quien es el ganador y lo vamos a hacer con un Switch, analizando la opción del usuario contra la opción del sistema

switch (yourChoice)
   {  
      //El usuario elige roca
      case 'R':
      case 'r': //Esto no hace falta ya que la hemos pasado a MAUSCULAS ES SOL PARA VER QUE ESTO SE PUEDE HACER
        if(opponentChoice == 'P') //Si el pc elige Papel gana el pc
         Console.WriteLine("Paper beats rock, I win¡");
        else if(opponentChoice == 'S') //Si el pc elige Tijeras gan el usuario
        Console.WriteLine("Rock beats Scissors, you win¡");
        break;
      //El usuario elige roca
      case 'S':
      case 's':
        if(opponentChoice == 'P') //Si el pc elige Papel gana el pc
         Console.WriteLine("Scissord beats paper, You win¡");
        else if(opponentChoice == 'R') //Si el pc elige Tijeras gan el usuario
        Console.WriteLine("Rock beats Scissors, I win¡");
        break;
      //El usuario elige roca
      case 'P':
      case 'p':
        if(opponentChoice == 'S') //Si el pc elige Papel gana el pc
         Console.WriteLine("Scissord beats paper, I win¡");
        else if(opponentChoice == 'R') //Si el pc elige Tijeras gan el usuario
        Console.WriteLine("Paper beats Rock, You win¡");
        break;  
   }

 

Vamos a ejecutar nuestro juego esta vez usando la consola PowerShell,

1.       Elijo R y el sistema elije R hay empate

2.       Elijo P y el sistema también, hay empate

3.       Elijo s y el sistema elije P, gano yo ya que las tijeras ganan al papel.

Al final el juego se reanuda ya que estamos dentro de un while hecho true, así que si no hacemos nada el juego se reanudará eternamente vamos a dar la opción al usuario de seguir o salir del juego.

En nuestro While añadimos (en rojo)

Console.WriteLine("Rock Paper Scissors");
while (true)
{
    Console.WriteLine("Are you ready?");
    Console.WriteLine("Let´s begin¡¡¡");
 
    //Llamamos a nuestro método SelectChoice
    var selectedChoice = SelectChoice();
    var yourChoice = char.Parse(selectedChoice);
   
   //Mostramos por salida la respuesta elegida
    Console.WriteLine($"You selected {yourChoice}");
 
   /*Llamamos al método char GetOpponentChoice() que es el que
   nos devuelve la respuesta aleatoria de nuestro oponente y
   guardamos esa respuesta en una variable para mostrar la
   respuesta de nuestro oponente virtul
   */  
   var opponentChoice = GetOpponentChoice();
   Console.WriteLine($"I chose {opponentChoice}");
 
   //Llamada al método para ver el ganador o el empate
   DecideWinner(opponentChoice, yourChoice);
 
   //Le preguntamos al usuario si quiere juegar de nuevo
   //Guardamos su respuesta e una variable
   Console.WriteLine("Do you want to play again?");
   Console.WriteLine("Enter[Y] yo play again or any other key to sto...");
 
   //Capturo la respuesta del usuario
   var playAgain = Console.ReadLine();
   //Valido i la respuesta es y continuo en el while
   if(playAgain?.ToLower() == "y")
      continue;
   else
      break;
 
}
 

Si ahora ejecuto:

Curso C# 1 ( Instalación .NET creación de proyectos de consola y web)

 

Documentación y programa de entrenamiento oficial

https://dotnet.microsoft.com/es-es/learn

https://learn.microsoft.com/es-mx/users/dotnet/collections/yz26f8y64n7k07

 

1 CLR (Common Language Runtime)

CLR es un entorno de ejecución para códigos de programas que corren sobre plataformas Microsoft, en el caso que nos ocupa .NET. CLR es el encargado de compilar una forma de código intermedio llamado Common Intermediate Language al código nativo mediante un compilador en tiempo de ejecución.

No debe confundirse el CLR con una máquina virtual que, una vez compliado el código corre de forma nativa sin necesidad de ninguna capa de abstracción sobre le hardaware. Es una implementación del estándar CLI (Common Languages Insfraestructure).

Los desarrolladores que usan CLR escriben el código fuente en un lenguaje compatible con .NET; C#, Visual basic… y en tiempo de compilación un compilador .NET convierte el código.

CLR funciona solamente en máquinas Windows. La manera en que la máquina virtual se relaciona con el CLR permite a los programadores ignorar muchos detalles específicos del microprocesador que se estará ejecutando en el programa, CLR también permite otros servicios importantes, como

·         Administración de la memorio

·         Administración de hilos (threads)

·         Manejo de excepciones

·         Recolección de basura

·         Seguridad

¿Qué tipo de aplicaciones se pueden desarrollar con .NET

Microsoft lanzó la primera versión del framework .NET en 2002, en esa época las aplicaciones desarrolladas en .NET sólo podían ejecutarse en máquinas Windows con NET Framework instalado. Esto ha cambiado con NET core.

Las aplicaciones desarrolladas en .NET Framework siguen pudiendo funcionar sólo en máquinas Windows, Mientras que NET Core se puede usar tanto en Windows como en MAC o Linux.

La última aplicación .NET es NET Core que apareció por 2016, se trata de una fuente de reimplementación abierta en el firmware al completo. Está disponible para Windows Mac y Linux, se proporciona un subconjunto de las bibliotecas de las clases .NET.

NET Core es compatible con el desarrollo de aplicaciones de consola y aplicaciones web basadas en ASP NET Core compatible con todos los sistemas operativos.

Diferencias de .NET Framework con .NET Core

Las diferencias principales son las siguientes:

 

.NET Framenwork

·        Ligado a Windows

·        Uso de CLR

·        Librería completa pero pesada

·        No es Open Source

.NET Core

·        Multiplataforma (Windows, Mac, Linux)

·        Open Source

·        Se puede implementar como parte de la propia aplicación

·        La herramienta de desarrollo no está fuertemente a VisualEstudio

·        Mejor rendimiento y tiempo de ejecución

·        Solo migradas aplicaciones Web y de consola(en la versión 3 se amplía con Windows forms y WPF)

 

C# & dotnet con Visual Studio

Una vez tenemos descargado e instalado VS code, necesitamos una manera de poder crear proyectos de C#, para ello vamos a descargar un SDK o un conjunto de programas que nos van a permitir crear proyectos, ejecutarlos, testearlos, etc. Pero para poder hacer esto en dotnet por lo general vamos a descargar el SDK para ello iremos a

https://dotnet.microsoft.com/en-us/download

Esta página es donde se encuentren la mayoría  de proyectos que maneja Microsoft, aquí encontraremos .NET Core y .NET Framework.

En nuestro caso descargaremos .NET Core para empezar a crear proyectos, pero en este caso descargaremos solo el SDK

Haremos la instalación del SDK el típico siguiente, una vez instalado para ver si todo se ha instalado correctamente, podemos abrir una terminal de símbolo del sistema y ejecutar:

Lo que nos indica que ya tenemos el SDK correctamente instalado y nos da la versión en este caso es la 7.0.201

Creando un proyecto de consola

Vamos a ver los diferentes tipos de proyecto que podemos crear con .NET y la manera de hacerlo. Para tener una primera fotografía de todo lo que podemos hacer con dotnet podemos abrir una terminal y ejecutar el comando dotnet new –help, lo cual nos mostrará información muy relevante:

Vamos a generar nuestro primer proyecto

Con la consola navegaremos a la ubicación deseada en este caso vamos a ir al desktop y crearemos una carpeta con el comando mkdir que podemos llamar proyecto_1.

Nos metemos en la carpeta con cd proyecto_1 y una vez dentro podemos generar el primer proyecto que será un proyecto de consola con el comando:

dotnet new console -o myfirstapp

donde -o es donde queremos la salida de nuestro proyecto y le indicamos que lo cree en otra carpeta que podemos llamar myfirstapp:

Si hacemos enter

Si vamos al escritorio veremos que se han creado las carpetas de nuestro primer proyecto:

Podemos abrir este nuevo proyecto en nuestro VScode veremos nuestro primer proyecto:

VScode detecta que es un proyecto C# y nos pedirá que agregemos las extensiones correspondientes para tener soporte, le diremos que si.

Si no apereciera podemos instalarla desde extensiones buscando C#

Para ejecutar nuestro proyecto de consola hello world lo único que tenemos que hacer es abir una terminal en vscode  y ejecutar el comando dotnet run

Con esto ya vemos nuestra salida del programa “Hello. World”

Creando un proyecto Web

Del mismo modo que hemos creado un proyecto de consola podemos crear proyectos web vamos a ver cómo.

Volvemos a abrir una consola en el pc y nos ubicamos en la carpeta proyecto_1

Y una vez dentro vamos a crear un nuevo proyecto esta vez web con el comando

 Donde aspnetapp es el nombre de nuestro proyecto (puedes poner el que quieras) si hacemos intro veremos que se crea nuestro proyecto web

Si abrimos nuestro proyecto en VScode, en el archivo program.cs veremos el siguiente código:

var builder = WebApplication.CreateBuilder(args);
 
// Add services to the container.
builder.Services.AddControllersWithViews();
 
var app = builder.Build();
 
// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}
 
app.UseHttpsRedirection();
app.UseStaticFiles();
 
app.UseRouting();
 
app.UseAuthorization();
 
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
 
app.Run();

si nos fijamos nuestra app está usando autorización (remarcado en azul), cuando creamos una nueva App mvc esto es así por defecto. Si queremos crear una App sin Auth en nuestro comando en la consola deberemos añadir el siguiente flag:

Y listo ya hemos creado nuestro proyecto mvc c#

Para ejecutar nuestra app, como ene l caso de la app de consola bastará con abrir la consola y hacer dotnet run

Se iniciará la compilación y nos creará un servidor (en amarillo)´

Si vamos a esa dirección local podremos ver nuestro proyecto web de inicio

Guía para escribir prompts para Midjourney ( IA texto - imagen )

 

En esta entrada vamos a hacer un “cheatsheet” detallado de palabras clave, comandos y trucos para mejorar la producción de imágenes con la conocida IA Midjourney. 

¿Qué es Midjourney?

Si aún no conoces esta increíble IA debes leer esta entrada del blog. 

Midjourney es una inteligencia artificial de generación de imágenes mediante texto (prompts) similar a DALLE-2 de Open AI y DreamStudio de Stable Diffusion. Esta aplicación  usa alrededor de setecientos millones de imágenes distribuidas por todo internet para generar impresionantes imágenes basadas en el texto o prompt proporcionado por el usuario. 

Pese a encontrarse en fase beta, cada día se le van añadiendo más y más funciones y mejoras, si ya en esta fase beta las posibilidades parecen infinitas cuesta imaginar a dónde puede llegar en un futuro. 

Lo primero que vas a necesitar es descargarte Discord y crearte una cuenta verificada. Luego buscarás el servidor de Midjourney y entrarás en alguna de las salas para “novatos”  newbies.

En el cuadro de diálogo debes escribir /imagine y hacer click en la etiqueta que te aparecerá encima que dice “prompt”, una vez hecho esto podrás escribir la descripción que la imagen que deseas que la IA realice. 

Prompt texto bruto

Si ya has utilizado la aplicación midjouney habrás observado que cuanto más descriptivo y detallado sea tu prompt, más espectacular y único será el resultado entregado. Normalmente los usuarios principiantes suelen usar textos directos y sin formato como “estudio de música realista” lo que podría generar algo como la siguiente imagen. 

Estas imágenes que vienen a ser el resultado de un prompt básico, pueden ser suficientemente atractivas en función de lo que el usuario necesite pero existen muchas más opciones que un texto sin formato para poder generar resultados predecibles y muy consistentes. 

Vamos a ver una lista de opciones avanzadas con las que podremos generar variaciones en las imágenes y algunos de los ajustes avanzados . 

En nuestro prompt añadiremos la palabra clave "estilo", seguido de alguna de las siguientes opciones:

• estilizar 
• caos
• Resolución 
• Relación de aspecto 
• Imagen como URL
• Ponderación de palabras 
• Filtrado de palabras 

En pocas palabras, el estilo se ve afectado por las palabras clave de nuestra elección, podemos especificar qué tipo de estilo queremos, podemos ver una amplia clasificación de los tipos de estilo que podemos elegir: 

1. Palabra clave estilo

Proporcionar un conjunto de palabras clave de apoyo asociadas a los estilos creará diferentes resultados en función del tipo de estilo elegido. Estas son algunas de las palabras clave y subtipos basados en tipo de arte/diseño/artista/género que podemos elegir como estilos: 

2. utilizar el nombre del artista como estilo

También puede especificar el artista como su estilo de salida . A continuación se muestran algunos ejemplos
/imagine caballo galopando al atardecer pintando al estilo Andy Warhol

3. utilizando las propiedades de renderizado/iluminación como estilo

4. Estilizar el resultado

Puedes añadir el ajuste--s <some number>( denotando estilo )

Las siguientes imágenes son de las mismas indicaciones con la opción de estilizar bajo y alto.

/imagine bomberos --s 6000

5. caos - Aumentar la abstracción

Toma un número de 0 a 100 para aumentar o disminuir el nivel de abstracción del tema

/imagine la torre Eiffel --caos 60

6. Resolución

Para especificar la resolución de salida, puede utilizar algunas de las palabras clave habituales como 8K , 4K , fotorrealista , ultra fotorrealista , ultra detallada, detalles intrincados etc

O puede ir con los ajustes estándar para salidas predecibles hd y calidad / --q son dos de estos ajustes

/imagine flor de rosa roja --hd

/imagine flor de rosa roja --calidad 5

7.  Relación de aspecto

Puede especificar la relación anchura:longitud de la imagen de salida. Esto se denomina relación de aspecto. La salida por defecto es una imagen cuadrada (relación de aspecto 1:1). Pero si quieres una vista más cinematográfica - o simplemente quieres hacer un papel de pared para tu portátil, puedes cambiar la relación de aspecto

/imagine jazmín en la flor silvestre --ar 4:3

Si desea especificar un tamaño de imagen personalizado, utilice el siguiente ejemplo

/imagine jasmine in the wild flower --w 600 --h 300

¡👉 No puedes especificar sus relaciones de aspecto personalizadas - pero puede especificar algunas de las relaciones estándar y algunas no estándar también ! ( He aquí algunos ejemplos)

8. Imagen como prompt

Si desea obtener salidas similares a un estilo de imagen, ( cuando desee obtener salidas consistentes ) a través de múltiples imágenes, pase una URL de la imagen

/imagine http://www.imgur.com/Im3424.jpg caja llena de bombones

La imagen generada tomará señales tanto de la imagen semilla ( de la URL que pasó ) y también las indicaciones de texto.

👉 Puedes dar múltiples imágenes como prompts

👉 Puedes especificar pesos a las imágenes ( ver el siguiente punto )

Pesos a los prompt de las imágenes

Si desea que su salida se parezca más a su imagen prompt ( ver el punto anterior), dé un mayor peso a esa imagen (palabra clave : --iw <número>) .

/imagine http://www.imgur.com/ks34f24.jpg chocolates --iw:4

9. Pesos a la indicación de texto

/imagine animales salvajes tigre::2 cebra::4 leones::1.5

10.  Filtrar palabras de la imagen

Utilice la palabra clave --no para descartar cualquier tema no deseado que aparezca en su imagen

/imagine pollo frito KFC --sin salsa

11. Por último, algunas palabras clave interesantes que puede intentar utilizar

* Sony Alpha α7, ISO1900, Leica M, = para especificar cualquier tipo de lente o tipo de cámara * photorealistic , ultra photoreal , ultra detailed, intricate details, = para especificar algunos detalles posibles y un aspecto realista y menos de artístico * unreal = para especificar una sensación de motor irreal* volumetric light , cinematic lighting = para especificar algunas condiciones de iluminación

Fuente: traducción del sitio: 

https://medium.com/mlearning-ai/an-advanced-guide-to-writing-prompts-for-midjourney-text-to-image-aa12a1e33b6

Master en Ciberseguridad y Privacidad UOC

 

El próximo 1 de Marzo es un día muy especial para mi ya que por fin empiezo mis estudios de posgrado en la Universitat Oberta de Catalunya en el Master de Ciberseguridad y privacidad. 

Dejo el folleto de presentación de este Master embebido en esta entrada. 

Cuando empecé el grado Multimedia en esta universidad no tuve la idea de registrar mi avance en los estudios en un blog desde el principio, por supuesto con el posgrado va a ser distinto, esta vez no solo pretendo registrar aquí todo los trabajos y prácticas que vaya desarrollando de forma organizada sino que pretendo poner en marcha un canal de Twitch en el que poder hacer streamings, resolviendo máquinas de la plataforma “Hack the box”.