Capítulo 0: El Despertar Lógico

📌 Tópico 0.1: Contexto Histórico (Los Cimientos)

Antes de teclear nuestro primer comando, es vital entender de dónde viene esta magia que llamamos "Computación". No nació de la noche a la mañana, sino a través de milenios de ingenio humano.

• El Origen de la Algoritmia: La palabra "Algoritmo" proviene del matemático persa Al-Juarismi (siglo IX). Él inventó reglas paso a paso para resolver problemas matemáticos, sentando las bases de lo que hoy hacemos al programar.
• Computación Analógica vs Digital: Las primeras computadoras no tenían pantallas ni teclados. El Mecanismo de Anticitera (Grecia, siglo I a.C.) usaba engranajes físicos (analógico) para predecir eclipses. Miles de años después, en 1945, nació la ENIAC, la primera gran computadora digital que usaba electricidad y "ceros y unos" para calcular trayectorias balísticas.
• La Máquina de Turing: El verdadero padre de la computación moderna es Alan Turing. Él imaginó un dispositivo teórico (una cinta infinita que lee y escribe símbolos) capaz de simular cualquier lógica matemática. Tu computadora, tu teléfono, y tu consola de videojuegos actual, no son más que versiones extremadamente rápidas de esa misma "Máquina de Turing".

📌 Tópico 0.2: ¿Qué es un Algoritmo?

Un algoritmo no es más que una secuencia finita, ordenada y no ambigua de instrucciones para resolver un problema. La computadora es rapidísima, pero no tiene sentido común. Hará exactamente lo que le digas, ni más, ni menos.

Para pensar en algoritmos sin tener que aprender inglés o reglas complicadas de código, los programadores usan el Pseudocódigo: un código "falso" escrito en español simple, pero ordenado paso a paso. ¡Veamos 3 problemas resueltos de forma didáctica!

INICIO
  Tomar rebanada_pan_1
  Tomar rebanada_pan_2
  Abrir frasco_mermelada
  Untar mermelada en rebanada_pan_1
  Unir rebanada_pan_1 con rebanada_pan_2
FIN

INICIO
  Llegar a la esquina de la calle
  Mirar el color del semáforo_peatonal
  SI el color es VERDE:
    Caminar hacia adelante
  SI el color es ROJO:
    Esperar sin moverse
FIN

INICIO
  Tomar primera_carta de la mesa
  Guardarla como "carta_ganadora"
  
  MIENTRAS queden cartas en la mesa:
    Tomar siguiente_carta
    SI siguiente_carta > "carta_ganadora":
      "carta_ganadora" = siguiente_carta
      
  Decir: "La carta mayor es la carta_ganadora"
FIN

📌 Tópico 0.3: Diagramas de Flujo (El Mapa Mental)

Antes de escribir código, los programadores dibujan el algoritmo usando un Diagrama de Flujo. Piensa en esto como el mapa de un tesoro lleno de caminos bifurcados. Usamos Rectángulos para acciones normales y Rombos (Diamantes) para decisiones lógicas de Sí/No.

graph TD
    A[Lámpara no funciona] --> B{¿Está enchufada?}
    B -- NO --> C[Enchufarla]
    B -- SÍ --> D{¿Foco quemado?}
    D -- SÍ --> E[Cambiar foco]
    D -- NO --> F[Comprar lámpara nueva]
                        

graph TD
    A[Dinosaurio Corriendo] --> B{¿Cactus a 2 metros?}
    B -- SÍ --> C[¡Saltar!]
    B -- NO --> D[Seguir corriendo]
    C --> A
    D --> A
                        

graph TD
    A[Suena la Alarma] --> B{¿Es fin de semana?}
    B -- SÍ --> C[Apagar y seguir durmiendo]
    B -- NO --> D[Levantarse de la cama]
                        

📌 Tópico 0.4: Pensamiento Computacional

Existe el mito de que para programar hay que ser un genio matemático. Es falso. Programar es un 80% pensar cómo resolver el problema en tu mente y solo un 20% teclear código. A esa forma de pensar la llamamos Pensamiento Computacional y tiene 4 pilares universales.

📌 Tópico 0.5: Lógica Proposicional (Entrenando el Cerebro)

Las computadoras no sienten, solo calculan Verdadero (True) o Falso (False). A esto le llamamos "Lógica Booleana". En álgebra usamos X y Y para representar números, pero en lógica formal usamos letras como P y Q para representar Proposiciones (frases que pueden ser Verdaderas o Falsas).

• P: "Hice mi tarea."
• Q: "Ordené mi cuarto."

🔹 Tablas de Verdad: Y (AND) / O (OR) / NO (NOT)

Para tomar decisiones complejas, las computadoras combinan estas verdades (P y Q) usando operadores lógicos.

🔹 Operadores Avanzados: Entonces y Sí y Solo Sí

Llevemos esto al siguiente nivel. Las computadoras también usan estructuras condicionales (Causa y Efecto).

📝 Ejercicios Lógico-Mentales Interactivos

Pon a prueba lo que acabas de leer. Responde en las casillas (se guardará tu progreso en el navegador).

1. Si la promesa es "Si comes tus vegetales (P), entonces comerás postre (Q)". Tú NO te comiste los vegetales, pero tu abuela te dio postre de todos modos. ¿Se rompió la promesa original? ¿Por qué? ✔ Guardado

   Solución: La Promesa

   // ¡No se rompió la promesa! 
   // La lógica condicional (P -> Q) dice que la promesa solo es falsa cuando P es Verdad pero Q es Falso (comes los vegetales pero NO hay postre).
   // Como no comiste los vegetales (P es Falso), cualquier resultado es válido sin romper la regla original.

2. Tienes el candado "Abre SI Y SOLO SI [Llave correcta] Y [Giras a la derecha]". Si metes la llave correcta (Verdad), pero NO giras a la derecha (Falso)... usando la tabla de Y (AND), ¿abre el candado? ✔ Guardado

   Solución: El Candado

   // Falso. El candado no abre.
   // El operador Y (AND) es el portero estricto. Requiere obligatoriamente que ambas condiciones sean Verdad (Verdad AND Verdad).
   // Al fallar la segunda condición (Falso), el resultado global colapsa a Falso.

📌 Tópico 0.6: Desafíos Lógicos (Entrenando la mente)

Antes de programar en C#, vamos a calentar tu cerebro. Lee estos 3 acertijos lógicos y escribe tus deducciones en las casillas. Tus respuestas se guardarán automáticamente en tu navegador.

// 1. Cruzas a la Cabra (quedan el Lobo y la Col a salvo).
// 2. Vuelves solo.
// 3. Cruzas al Lobo, lo dejas, y TE LLEVAS a la Cabra de vuelta.
// 4. Dejas a la Cabra y te llevas a la Col.
// 5. Dejas la Col con el Lobo (no se la come) y vuelves solo.
// 6. Finalmente cruzas a la Cabra.

// ¡Imposible que Ana sea la culpable!
// Regla: SI (Ana es culpable) ENTONCES (Bruno NO estuvo).
// Vimos en la cámara que (Bruno SÍ estuvo). 
// Por lógica de contraposición, si la consecuencia (Bruno NO estuvo) es Falsa, entonces la causa original (Ana es culpable) también debe ser Falsa.

// 1. Poner agua y café.
// 2. Encender la cafetera.
// 3. Poner la taza en la mesa.
// 4. Servir en la taza.
// * El error fatal era el paso 5 (Tomar hirviendo de un trago te mandaría al hospital). Un buen algoritmo debe ser seguro (Añadir un paso de "Esperar a que enfríe").

📌 Tópico 0.7: El Linaje de los Lenguajes (De C a C#)

Antes de escribir tu primera línea de código en el siguiente capítulo, debes saber qué idioma estás a punto de aprender y por qué. No todos los lenguajes sirven para lo mismo: algunos son buenos para páginas web, otros para inteligencia artificial.

La Evolución:

• C (Los años 70): Un lenguaje puramente matemático y veloz. Sentó las bases, pero era muy difícil de leer y construir cosas grandes era un caos.
• C++ (Los años 80): Añadió "Objetos", permitiendo hacer videojuegos gigantes. Es rapidísimo, pero sigue siendo difícil y no perdona errores de memoria.
• C# (Año 2000): Creado por Microsoft. Es el heredero perfecto. Tiene casi toda la potencia de C++, pero se encarga de limpiar la memoria automáticamente por ti y es mucho más fácil de leer.

INICIO
  Revisar inventario
  SI ( (Tengo Moneda OR Tengo Manzana) AND (NOT Tengo Armas) ) ENTONCES:
    Caminar por el puente
    Imprimir "¡Crucé el puente!"
  SINO:
    Dar la vuelta
    Imprimir "El guardián me rechazó"
FIN

Capítulo 1: El Dojo Lógico (Resolución de Problemas)

📌 Tópico 1.1: Rompiendo el Sistema (Diagramas de Flujo)

Un diagrama de flujo no es más que la radiografía de un algoritmo. Antes de tocar el código, debes saber "leer" los caminos lógicos.

Nivel 1: El Desayuno Lineal (Secuencial)

graph TD
    A[Despertar] --> B[Ir a la cocina]
    B --> C[Preparar cereal]
    C --> D[Comer]
    D --> E[Lavar plato]
    E --> F[Salir de casa]
                    

// La última acción antes de salir es "Lavar plato".

Nivel 2: El Portero de la Discoteca (Bifurcación)

graph TD
    A[Llegar a la puerta] --> B{Edad mayor o igual a 18?}
    B -->|SI| C[Dejar entrar]
    B -->|NO| D[Rechazar entrada]
    C --> E[Fin]
    D --> E
                    

// Como la edad (16) no es mayor o igual a 18, tomará el camino del "NO" y la acción será "Rechazar entrada".

Nivel 3: El Bucle Infinito del NPC (Avanzado)

graph TD
    A[Despertar] --> B{Tiene Hambre?}
    B -->|SI| C[Comer Pan]
    C --> B
    B -->|NO| D[Ir a Trabajar]
                    

Pregunta: Si la cantina tiene pan infinito y el Aldeano siempre dice "Sí" a tener hambre, ¿cuándo irá a trabajar el aldeano?

// El aldeano caerá en un Bucle Infinito. Comerá pan por toda la eternidad y jamás llegará a "Ir a Trabajar".

📌 Tópico 1.2: El Guardián en Pseudocódigo

El código falso (Pseudocódigo) es el puente entre el idioma humano y el código máquina. Te permite pensar en la lógica sin preocuparte por los malditos puntos y comas.

Nivel 1: La Tienda del RPG (Variables)

// Oro = Oro - CostoPocion
// Oro = Oro - CostoPocion
// Oro = Oro - CostoPocion
// Imprimir Oro

Nivel 2: Sistema de Vida y Veneno (Condicionales)

// Vida = Vida - 15
// SI Vida <= 0 ENTONCES:
//   SI TieneAntidoto == Verdad ENTONCES:
//     TieneAntidoto = Falso
//     Vida = 5
//     Imprimir "¡El antídoto te salvó!"
//   SINO:
//     Imprimir "GAME OVER"

Nivel 3: El Minero Automático (Bucles)

// Piedras = 0
// MIENTRAS Piedras < 10 HACER:
//   Picar roca
//   Piedras = Piedras + 1
// Imprimir "Inventario Lleno"

📌 Tópico 1.3: La Bóveda de las Proposiciones

Como vimos en el Capítulo 0, la Lógica Proposicional es el corazón de las computadoras. Ahora vamos a aplicarlo a un problema cerrado.

// Debes jalar la palanca P o la Q (o ambas), y NO tocar la palanca R. 
// Ejemplo: Cambias P a Verdad. P OR Q = Verdad. Como R ya es Falso, se cumple el Y (AND) principal. ¡La puerta se abre!

INICIO
  Saldo = 0
  BUCLE: Mientras el usuario exista
    SI mete una moneda ENTONCES:
      Saldo = Saldo + 1
    
    SI Saldo == 2 ENTONCES:
      Entregar Soda
      Saldo = 0
FIN

Capítulo 2: El Huevo (Primer Código y Variables)

📌 Tópico 2.1: El Linaje de la 'C' (Historia y Poder)

Acabamos de salir del mundo del Pseudocódigo (Capítulo 1), que es un idioma inventado para humanos. Ahora vamos a escribir en un lenguaje real, uno de los más poderosos y solicitados del planeta: C# (pronunciado "C-Sharp").

¿De dónde viene esa 'C'? (El árbol genealógico)

Para entender el poder de C#, primero debes entender a sus ancestros. La historia de la programación moderna es prácticamente la historia de la letra C:

• Lenguaje C (1972): Inventado por Dennis Ritchie para crear el sistema operativo UNIX. Es un lenguaje "de bajo nivel", lo que significa que habla casi directamente con el procesador. Era súper rápido, pero brutalmente difícil de escribir. Obligaba al programador a gestionar manualmente la memoria de la computadora usando algo llamado "Punteros". Si se te olvidaba borrar un dato de la memoria, causabas un Memory Leak (Fuga de Memoria) y la computadora entera se colgaba (Pantallazo Azul).
• C++ (1985): Bjarne Stroustrup quiso mejorar C y le añadió el concepto de "Objetos" (hablaremos de ellos luego). C++ sigue siendo el rey absoluto de la velocidad y es el lenguaje con el que están hechos los motores gráficos pesados como Unreal Engine. Sin embargo, heredó los mismos peligros de gestión manual de memoria que tenía C. Seguía siendo hostil para los mortales.
• C# (2000): Creado por el legendario Anders Hejlsberg en Microsoft. La misión era simple: Tomar toda la potencia bruta de C y C++, pero quitarle el peligro y la dificultad. C# introdujo una maravilla tecnológica llamada Garbage Collector (Recolector de Basura). Es un robot invisible que patrulla la memoria de tu computadora limpiando lo que ya no usas, evitando los Memory Leaks mágicamente.

¿Para qué sirve C# Hoy en Día?

Gracias a que es rápido pero seguro, C# se convirtió en el "lenguaje rey" del desarrollo de videojuegos Indie y AA. Es el lenguaje oficial de motores gigantescos como Unity y Godot 4. Además, sostiene los sistemas de bancos, aplicaciones web gigantes, y la IA corporativa de Microsoft.

Nivel 1: Ejercicio Teórico de Linaje

// Proyecto A: C++
// Al necesitar exprimir el hardware al milisegundo y tener programadores expertos, C++ es ideal porque permite gestionar la memoria manualmente (aunque sea peligroso).
//
// Proyecto B: C#
// Para desarrollar rápido sin sufrir dolores de cabeza con Memory Leaks, C# es perfecto gracias a su Garbage Collector que limpia la memoria automáticamente.

📌 Tópico 2.2: Hola, Mundo Dinosaurio (Anatomía de tu Primer Código)

Antes de dibujar dinosaurios o calcular puntos de daño, primero aprenderemos a enviarle mensajes a la pantalla negra del sistema llamada "Consola". Esta es la tradición de todo programador.

🔹 La Anatomía de una Instrucción

Para decirle a la computadora que imprima texto, usamos esta instrucción exacta en C#:

Console.WriteLine("¡Hola, Mundo Dinosaurio!");

C# es un lenguaje de "Sintaxis Estricta". Si pones una letra mal, el programa explota. ¿Por qué C# es tan exagerado?

Desglosemos las reglas de este contrato (nuestra línea de código) con bisturí:

• Console (La Clase): Representa a "quién" le estamos hablando (La ventana de la consola del sistema). La 'C' debe ser obligatoriamente mayúscula.
• El punto . (El Acceso): Funciona como un botón. Le dice a C#: "Voy a buscar una acción dentro de Console".
• WriteLine (El Método): Es la acción que queremos ejecutar. Significa "Escribe una Línea y presiona Enter". Existen variaciones, como Write, que escribe pero NO presiona Enter. La 'W' y la 'L' son mayúsculas (esta regla se llama PascalCase).
• () (Los Parámetros): Los paréntesis son la "boca" de la acción. Sirven para introducir la información que la acción necesita para funcionar.
• "" (El String): Las comillas dobles le dicen a la computadora "¡Detente! Lo que está aquí dentro es texto puro para humanos, no intentes leerlo ni ejecutarlo como código".
• ; (Punto y coma): Es el punto final de la oración. ¡NUNCA lo olvides! Le grita al sistema: "Terminé mi instrucción, pasa a la siguiente".

Nivel 2: Ejercicio Práctico Guiado

// Console.WriteLine("El Rex tiene hambre");

Nivel 3: El Depurador Humano (Encontrando Errores)

Cuando trabajes en programación, el 90% del tiempo lo pasarás arreglando errores ("Bugs"). Un error de texto (como una minúscula donde va una mayúscula) se llama Error de Sintaxis.

console.WriteLine("Dinosaurio saltando")
Console.Writeline("Puntaje: 100");

// Los 3 errores eran:
// 1. "console" con 'c' minúscula.
// 2. Faltaba el ";" al final de la primera línea.
// 3. "Writeline" con 'l' minúscula (debe ser WriteLine).
//
// Código corregido:
// Console.WriteLine("Dinosaurio saltando");
// Console.WriteLine("Puntaje: 100");

🔹 Los Comentarios (El Diario del Programador)

El código le dice a la computadora CÓMO hacer las cosas, pero a menudo no explica POR QUÉ. Para eso existen los Comentarios: notas de texto que la computadora ignora al 100%.

• Para comentar una sola línea usamos doble barra //.
• Para comentar párrafos largos, abrimos con /* y cerramos con */.

/* Sistema de gravedad V1.0 */
int gravedad = -9; // Negativo porque en nuestro motor se cae hacia abajo

📌 Tópico 2.3: La Magia Oculta (El Gran Traductor IL y JIT)

Ahora que ya escribiste instrucciones perfectas (Console.WriteLine), debes saber qué ocurre tras bambalinas en fracciones de milisegundo cuando presionas el botón "Play" en Unity o .NET Fiddle.

En C#, este proceso no ocurre en un solo paso, sino en una "Tubería" (Pipeline) de dos pasos que es la joya de la corona de Microsoft:

flowchart TD
    A[Tu Código en C#] -->|Fase 1: Roslyn| B(Compilador)
    B -->|Genera| C(Lenguaje Intermedio - IL)
    C -->|Fase 2: Ejecución| D{Motor JIT}
    D -->|Si juegas en PS5 / AMD| E[Ensamblador x86-64]
    D -->|Si juegas en Android| F[Ensamblador ARM]
    E --> G[Procesador]
    F --> G
                    

1. Fase 1 - El Compilador (Roslyn): Cuando guardas tu archivo, el "Compilador" (llamado Roslyn) lee todo tu texto buscando faltas de ortografía (como los puntos y comas). Si hay un error de sintaxis, se detiene y te grita en rojo. Si todo está perfecto, no lo traduce a binario todavía. Lo traduce a un Lenguaje Intermedio (IL - Intermediate Language). Piensa en el IL como un "borrador universal" empaquetado en un archivo .dll o .exe.
2. Fase 2 - El JIT (Just-In-Time Compiler): Aquí ocurre la magia negra de rendimiento. El archivo IL puede viajar a cualquier computadora. Cuando el usuario hace doble clic en el juego para abrirlo, despierta el motor JIT que vive en esa computadora. El JIT lee el IL y lo compila "Justo a Tiempo" (en microsegundos) a Código Máquina nativo, optimizándolo en tiempo real exactamente para la arquitectura del chip del usuario (Intel, AMD o el chip de su teléfono celular).

Sabiendo que existe este traductor robótico estricto en medio, ahora entiendes por qué si le faltaba una mayúscula a tu WriteLine, el Roslyn Compiler no lograba comprender la instrucción y lanzaba un error masivo. Los humanos adivinamos el contexto; las computadoras no.

Nivel 4: Ejercicio Deductivo del Pipeline

// La adaptación de hardware ocurre en la FASE 2 (JIT).
// La Fase 1 (Roslyn) es universal, solo traduce C# a IL.
// El archivo IL viaja por internet, y cuando llega a la Mac, el Motor JIT de la Mac se despierta (Fase 2) y traduce ese IL específicamente a Ensamblador ARM.

📌 Tópico 2.4: ¿Qué es una Variable? (La Anatomía de la Memoria)

🔹 El Concepto Físico

En un videojuego, el motor gráfico necesita recordar miles de cosas simultáneamente: tu puntuación actual, la posición exacta en los ejes X e Y de un enemigo, o si tu escudo está activo. Para recordar esto, usamos Variables.

Al igual que en matemáticas elementales (x = 5), usamos el signo igual = para "asignar" un valor. En programación, el = NO significa igualdad, significa "Toma lo que está a la derecha, y mételo en la caja de la izquierda".

📌 Tópico 2.5: El Tipado Estricto (Formas de Cajas)

La maravilla de C# (y la razón por la que es tan seguro y preferido por empresas multimillonarias) es que tiene Tipado Estricto Fuerte. Esto significa que antes de crear la caja de memoria, debes decirle a la computadora qué FORMA y MATERIAL tiene exactamente.

🔹 1. El Texto Puro (string)

Las cajas de tipo string (cadena de caracteres) sirven para guardar texto. Su contenido siempre debe ir entre comillas dobles "".

string nombreDinosaurio = "T-Rex Rexy";
Console.WriteLine(nombreDinosaurio); // Imprime: T-Rex Rexy

Interpolación ($"")

¿Qué pasa si queremos imprimir un mensaje mezclando texto fijo con nuestra variable? En lugar de hacer una suma de textos confusa, usamos el signo de dólar $ antes de las comillas para inyectar la variable directamente con llaves {}.

Console.WriteLine($"¡Cuidado! Se acerca un {nombreDinosaurio}");

🔹 2. La Matemática Exacta (int)

Las cajas int (integer/entero) guardan números matemáticos exactos, sin puntos decimales. Son perfectas para puntuaciones, vidas o municiones. Nunca llevan comillas.

int puntuacionInicial = 100;
int monedasRecogidas = 50;
int totalPuntos = puntuacionInicial + monedasRecogidas;
Console.WriteLine($"Tu puntaje final es: {totalPuntos}"); // Imprimirá 150

🔹 3. Precisión Milimétrica (double y float)

En el desarrollo de videojuegos físicos, los enteros no son suficientes. La gravedad, la aceleración de un auto o la rotación de un personaje requieren decimales finos. Usamos double (Doble precisión) o float (Punto flotante).

double multiplicadorDanio = 1.75;
double gravedadBase = -9.81;

🔹 4. El Interruptor Universal (bool)

Las cajas bool (booleanas) son el tipo de dato más importante en la lógica computacional y ocupan la memoria mínima (1 bit). Solo pueden guardar dos estados absolutos: true (Verdadero/Encendido) o false (Falso/Apagado).

bool tieneLlaveDorada = false;
bool estaVivo = true;

Nivel 1: Ejercicio Básico de Variables

// int nivelActual = 5;
// string nombreZona = "Valle Jurásico";

Nivel 2: Ejercicio de Interpolación

// Console.WriteLine($"El jugador ha llegado al nivel {nivelActual} en el {nombreZona}");

Nivel 3: El Depurador de Tipos

int vidas = "3";
string nombre = Dino;
bool saltoDoble = "true";

// Errores: número con comillas (es int), texto sin comillas (es string), booleano con comillas (es bool).
// Código corregido:
// int vidas = 3;
// string nombre = "Dino";
// bool saltoDoble = true;

Nivel 4: El Incendio Eléctrico (Análisis Crítico)

// Colapsa porque al final intenta multiplicar el texto "Cien monedas" por 2 matemáticamente.
// C# lo evita obligándote a declarar "int cajaDinero = 100;".
// Al intentar meter "Cien monedas" en un "int", el Compilador (Roslyn) te lanzaría un error rojo y ni siquiera te dejaría darle a Play al juego.
// El bug muere en el taller, no en las manos del jugador.

// Creador: Dino Master
string nombreJugador = "SpeedyDino";
int velocidadMax = 120;
bool modoDificil = true;

Console.WriteLine("  __");
Console.WriteLine(" (_ \\");
Console.WriteLine("   \\ \\_.----._");
Console.WriteLine("    \\         \\");
Console.WriteLine("--- PERFIL DEL JUGADOR ---");
Console.WriteLine($"Nombre: {nombreJugador}");
Console.WriteLine($"Velocidad Máxima: {velocidadMax}");
Console.WriteLine($"Modo Difícil: {modoDificil}");
Console.WriteLine("--------------------------");

Capítulo 3: Reacciones Instintivas

📌 Tópico 3.1: Esquivando el Peligro (La Anatomía del if)

🔹 El Cerebro del Procesador

Un videojuego no es una película que siempre se reproduce igual. Es una entidad viva y reactiva. Si el dinosaurio choca con un cactus, el motor debe mostrar "Game Over"; si no choca, el fondo debe seguir avanzando. Para que el procesador pueda "reaccionar" dinámicamente a estas situaciones cambiantes, utilizamos la estructura de control de flujo más antigua de la informática: La condicional if (Si esto es verdadero...) y else (De lo contrario...).

🔹 Desglosando el Código de Decisión

int distanciaCactus = 0;

if (distanciaCactus <= 0) 
{
    Console.WriteLine("CRASH! GAME OVER.");
    vidas = vidas - 1;
} 
else 
{
    Console.WriteLine("Sigue corriendo.");
    puntos = puntos + 10;
}

Anatomía con bisturí:

• La Palabra Reservada if: Le avisa al compilador que viene una bifurcación de memoria.
• Los Parámetros (): Aquí dentro SIEMPRE debe ir una ecuación o variable que resulte estrictamente en true o false. Usamos operadores relacionales como <= (menor o igual), >, == (comparación estricta), o != (distinto de).
• El Bloque {}: Las llaves agrupan todas las acciones que ocurrirán SI Y SOLO SI la condición fue verdadera.
• La red de seguridad else: No tiene paréntesis porque no evalúa nada. Es el "Plan B" absoluto. Si el if falla, el else se ejecuta sí o sí.

Nivel 1: Ejercicio de Colisión Básica

// if (saludJugador == 0) {
//     Console.WriteLine("El dinosaurio ha caído");
// } else {
//     Console.WriteLine("El dinosaurio resiste");
// }

📌 Tópico 3.2: Combinando Decisiones (&&, || y Cortocircuitos)

En el mundo real, los problemas rara vez dependen de una sola pregunta. ¿Qué pasa si el jugador solo puede entrar a la puerta del Jefe si tiene la Llave Dorada Y (al mismo tiempo) es Nivel 10 o superior? Aquí entran los Operadores Lógicos Booleanos.

🔹 Operador AND (&&) - La Conjunción

¿Recuerdas las Tablas de Verdad del Capítulo 1? El operador && es la fiel representación matemática de la "Conjunción" (V y V = V). Exige que TODAS las condiciones sean verdaderas al mismo tiempo. Si una sola proposición falla, todo el bloque se considera false y el tren salta al else.

if (nivel >= 10 && tieneLlave == true) {
    Console.WriteLine("La puerta del Boss se abre.");
}

🔹 Operador OR (||) - La Disyunción

De igual forma, || representa la "Disyunción" de la lógica clásica (V o F = V). La compuerta lógica OR requiere que AL MENOS UNA de las condiciones sea verdadera para salvar todo el bloque. Si tienes la llave roja O tienes la ganzúa, la puerta normal se abrirá.

if (tecla == "Espacio" || tecla == "W" || tecla == "FlechaArriba") {
    Console.WriteLine("El jugador salta.");
}

🔹 Cadenas de Decisiones (else if)

Cuando un objeto puede estar en múltiples estados únicos y exclusivos, usamos else if. Esto previene que la computadora evalúe opciones innecesarias si ya encontró la correcta.

int municion = 5;
if (municion > 10) {
    Console.WriteLine("Arma Cargada");
} else if (municion > 0) {
    Console.WriteLine("Advertencia: Munición Baja"); // Entrará aquí porque 5 > 0
} else {
    Console.WriteLine("*Click* *Click* ¡Sin balas!");
}

Nivel 2: Ejercicio de Puertas Lógicas

// if (tecla == "Espacio" && saltos > 0) {
//     Console.WriteLine("Salto activado");
// } else {
//     Console.WriteLine("No puedes saltar");
// }

Nivel 3: Depuración de Operadores

if (tieneEscudoMagico == false || temperatura > 100) {
    Console.WriteLine("Te estás quemando vivo");
}

// El problema era que usó || (OR). Eso significaba que si hacía mucho calor (>100), se quemaba igual sin importar el escudo. 
// Debía usar && (AND) para que se cumplan ambas condiciones.
// 
// if (tieneEscudoMagico == false && temperatura > 100) {
//     Console.WriteLine("Te estás quemando vivo");
// }

📌 Tópico 3.3: Decisiones Anidadas (Inception de IFs)

En el diseño de videojuegos a menudo tenemos condiciones complejas que dependen del resultado de una condición anterior. Puedes poner un bloque if completo dentro de otro bloque if. A esto se le conoce como condiciones anidadas.

if (encontrasteCofre == true) {
    Console.WriteLine("¡Cofre encontrado!");
    
    // Esta pregunta SOLO se hace si encontrasteCofre es true
    if (tienesLlave == true) {
        Console.WriteLine("El cofre se abre. Recibes 500 de oro.");
    } else {
        Console.WriteLine("El cofre está bloqueado, necesitas una llave.");
    }
} else {
    Console.WriteLine("Solo hay polvo aquí.");
}

Nivel 4: El Guardaespaldas del Castillo

// if (tienePase == true) {
//     if (armaOculta == true) {
//         Console.WriteLine("Pase válido, pero no puedes pasar armado");
//     } else {
//         Console.WriteLine("Bienvenido al castillo, mi señor");
//     }
// } else {
//     Console.WriteLine("¡Guardias! Intruso.");
// }

int distanciaJugador = 8;
bool jugadorHaciendoRuido = true;

if (distanciaJugador < 2) { 
    Console.WriteLine("El Raptor Ataca."); 
} else if (distanciaJugador < 15 && jugadorHaciendoRuido == true) { 
    Console.WriteLine("El Raptor Persigue."); 
} else { 
    Console.WriteLine("El Raptor Patrulla."); 
}

Capítulo 4: La Carrera Interminable

📌 Tópico 4.1: Corriendo hasta Cansarse (El bucle while)

🔹 El Concepto del Tiempo en los Juegos

Hasta ahora, nuestros programas leen el código de arriba hacia abajo y luego se apagan. Pero un videojuego como el del Dinosaurio debe quedarse encendido, esperando a que presiones un botón, actualizando la posición de los enemigos y dibujando la pantalla 60 veces por segundo. Para atrapar a la computadora en una ejecución continua usamos los Bucles (Loops).

La estructura fundamental es el while (Mientras). Este bloque hace que el procesador ejecute el código, llegue al final de las llaves {}, y en lugar de seguir bajando, sea teletransportado hacia arriba para volver a evaluar la condición. Si sigue siendo verdadera, repite todo de nuevo. A esto se le llama una Iteración.

🔹 Anatomía de un Bucle de Juego Básico

bool elJuegoSigue = true;
int energia = 100;

// El procesador entra aquí porque elJuegoSigue es true
while (elJuegoSigue == true) 
{
    Console.WriteLine("El dinosaurio da un paso.");
    energia = energia - 10;
    
    if (energia <= 0) {
        elJuegoSigue = false; // Abre la puerta de la rueda
    }
}
// Cuando elJuegoSigue sea false, el procesador salta directamente a esta línea
Console.WriteLine("El dinosaurio colapsó.");

Nivel 1: Ejercicio de Bucle Venenoso

// int vida = 50;
// while (vida > 0) {
//     vida = vida - 10;
//     Console.WriteLine($"Recibes 10 de daño. Vida restante: {vida}");
// }

📌 Tópico 4.2: El Peligro del Bucle Infinito (Memory Freeze)

El poder de atrapar al procesador en una rueda viene con una inmensa responsabilidad. ¿Qué pasa si te olvidas de incluir la instrucción que eventualmente vuelve false a la condición?

Nivel 2: Depuración de un Bucle Infinito

int dinero = 100;
while (dinero < 1000) {
    Console.WriteLine("Generando dinero...");
    // dinero = dinero - 10;
}

// El programador estaba RESTANDO dinero (o no haciendo nada por el comentario). 
// Como 100 siempre será menor a 1000 si le restas o lo dejas igual, el bucle nunca termina.
// Solución: ¡Debe SUMAR para que algún día llegue a 1000 y se detenga!
//
// int dinero = 100;
// while (dinero < 1000) {
//     Console.WriteLine("Generando dinero...");
//     dinero = dinero + 100;
// }

📌 Tópico 4.3: Corriendo Vueltas Exactas (El bucle for)

A diferencia del while (que usamos cuando NO sabemos cuántas veces repetiremos algo, como esperar a que el usuario presione una tecla), usamos el bucle for (Para) cuando sabemos EXACTAMENTE cuántas iteraciones queremos hacer. Por ejemplo: generar 5 nubes en el cielo, o dar 3 cartas al jugador.

🔹 Anatomía del For: Las 3 Piezas del Motor

El bucle `for` comprime toda la gestión del contador en una sola línea elegante, separada por punto y coma ;.

for (int i = 1; i <= 3; i++) {
    Console.WriteLine($"Generando enemigo número {i}");
}

• 1. Inicializador (int i = 1): Se ejecuta una sola vez al principio. Crea una caja temporal llamada 'i' (índice) y le mete un 1.
• 2. Condición (i <= 3): Antes de cada vuelta, verifica esto. Si es true, entra al bucle. Si es false, termina todo.
• 3. Iterador o Paso (i++): Se ejecuta automáticamente al final de cada vuelta. i++ es magia negra de C# que significa "súmale 1 a i". También podrías usar i-- para restar 1.

Nivel 3: Ejercicio de Ciclo For

// for (int tiempo = 5; tiempo > 0; tiempo--) {
//     Console.WriteLine($"Quedan {tiempo} segundos");
// }
// Console.WriteLine("¡Ignición!");

📌 Tópico 4.4: Bucles Anidados (El Inception de los Ciclos)

Así como podemos meter un if dentro de otro if, podemos meter un bucle for dentro de otro bucle for. Esto es extremadamente útil para videojuegos porque nos permite generar cuadrículas, mapas 2D (matrices) o coordenadas X e Y.

for (int fila = 1; fila <= 3; fila++) {
    for (int columna = 1; columna <= 3; columna++) {
        Console.WriteLine($"Generando bloque en la coordenada [{fila}, {columna}]");
    }
}

Anatomía de la ejecución: Por CADA vuelta del bucle externo (fila), el bucle interno (columna) da TODAS sus vueltas. En este ejemplo, el Console.WriteLine se ejecutará un total de 9 veces (3 x 3).

Nivel 4: Matriz de Coordenadas

// for (int x = 1; x <= 2; x++) {
//     for (int y = 1; y <= 2; y++) {
//         Console.WriteLine($"Spawneando enemigo en X: {x}, Y: {y}");
//     }
// }

int balas = 30;

while (true) {
    balas--; // Atajo para restar 1
    Console.WriteLine($"Pew! Balas restantes: {balas}");
    
    if (balas == 0) {
        Console.WriteLine("¡Sin munición! Recargando...");
        break; // Destruye el bucle infinito
    }
}

Capítulo 5: Preparando el Nido (Arquitectura Local)

📌 Tópico 5.1: El Salto a las Ligas Mayores

🔹 ¿Qué es un SDK y un IDE?

Hasta ahora, hemos programado en "cajas de arena" web (como .NET Fiddle). El navegador tomaba tu texto, lo enviaba a un servidor de Microsoft en la nube, lo compilaba allá, y te devolvía el resultado. Es cómodo, pero ningún juego comercial se hace en un navegador.

Para construir software real en tu propia computadora, necesitas instalar dos piezas de artillería pesada:

1. El SDK (Software Development Kit): Es el "motor" puro debajo del capó. Contiene el Compilador (Roslyn) y todas las librerías matemáticas de Microsoft. Sin el SDK, tu computadora no tiene idea de qué es la palabra Console.
2. El IDE (Integrated Development Environment): Un Editor de Código de Texto Plano como el bloc de notas, pero "con esteroides". Te ofrece IntelliSense (autocompletado predictivo), coloreado de sintaxis, y botones para invocar al SDK sin escribir comandos complicados. El rey actual es Visual Studio Code.

📌 Tópico 5.2: Instalación en Linux (Zorin OS)

Si usas Linux (como Zorin OS), instalar la magia de C# es cuestión de dos simples líneas en tu Terminal (la consola negra del sistema), usando el gestor de paquetes snap.

# 1. Instalar el Motor (El SDK de .NET 8.0):
sudo snap install dotnet-sdk --classic --channel=8.0/stable

# 2. Instalar el Taller Visual (Visual Studio Code):
sudo snap install code --classic

📌 Tópico 5.3: La Anatomía Oculta de un Proyecto

Crear un proyecto C# no es solo crear un archivo de texto. Al abrir tu terminal y escribir el comando de la CLI (Command Line Interface): dotnet new console -n MiJuego, el motor de Microsoft te generará toda una estructura de carpetas profesionales.

graph TD
    A[Carpeta: MiJuego] --> B[MiJuego.csproj]
    A --> C[Program.cs]
    A --> D[Carpeta: bin]
    A --> E[Carpeta: obj]
    D --> F[Debug / Release]
    F --> G[MiJuego.dll / MiJuego.exe]
                    

🔹 Desglose Arquitectónico

• Program.cs: El lienzo. Aquí escribes tu código humano (Console.WriteLine).
• MiJuego.csproj: El archivo "Proyecto de C Sharp" (C Sharp Project). Es el ADN de la aplicación. Le dice al compilador qué versión de .NET usar y qué librerías extra (ej: paquetes de conexión a Bases de Datos) debe descargar.
• La Carpeta Maldita (obj): "Object". Aquí es donde ocurre la Fase 1 del compilador (Tópico 2.3). Roslyn toma tu código humano y genera basura temporal ilegible mientras traduce. Nunca toques esta carpeta.
• La Bóveda de Salida (bin): "Binaries". Cuando ordenas construir el juego, el archivo mágico Lenguaje Intermedio (IL) empaquetado en un .dll o .exe nace dentro de bin/Debug/net8.0/. ¡Este es el archivo que le pasas a tus amigos para que el Motor JIT de sus computadoras lo ejecute!

Nivel 1: Comprensión de Arquitectura

// Respuesta Nivel 1:
// ¡NO le envías el Program.cs! Ese archivo es solo texto humano y su computadora no sabría qué hacer con él sin un compilador instalado.
// Debes entrar a la carpeta 'bin/Debug' (o bin/Release) y enviarle el archivo '.exe' o '.dll' compilado. Ese es el Lenguaje Intermedio (IL) listo para que el Motor JIT de su computadora lo transforme en un videojuego jugable al instante.

Capítulo 6: El Spawner de Obstáculos (Colecciones)

📌 Tópico 6.1: La Memoria Contigua (Historia de los Arreglos)

🔹 Contexto Histórico: El Problema de las Variables Sueltas

En los inicios de la computación, si querías guardar la puntuación de 3 jugadores, creabas 3 variables: p1, p2, y p3. Pero cuando los creadores de Space Invaders necesitaron guardar en memoria 55 aliens simultáneos en pantalla, crear 55 variables separadas era imposible de gestionar y el código sería kilométrico.

La solución fue el Arreglo (Array): pedirle al sistema operativo un bloque largo y contiguo de memoria RAM. Es decir, celdas de memoria que están físicamente una al lado de la otra en el chip de la computadora.

🔹 La Anatomía de un Arreglo

Vamos a invocar un arreglo de enemigos en C#:

string[] nombresAliens = new string[3];
nombresAliens[0] = "AlienRojo";
nombresAliens[1] = "AlienVerde";
nombresAliens[2] = "AlienJefe";
Console.WriteLine(nombresAliens[1]); // Imprime: AlienVerde

Anatomía con bisturí:

• Los Corchetes []: Le dicen a C# "No quiero una sola caja, quiero una hilera de cajas".
• La palabra reservada new: Es una orden de construcción. Le pide al Sistema Operativo que vaya a la Memoria RAM y reserve físicamente el espacio de inmediato.
• El tamaño [3]: Define el límite inamovible. Solo tiene los índices 0, 1 y 2. Si intentas guardar en nombresAliens[3], el juego colapsará con un IndexOutOfRangeException.

Nivel 1: El Inventario Rígido

int[] puntuaciones = new int[2];
puntuaciones[0] = 100;
puntuaciones[1] = 500;
Console.WriteLine(puntuaciones[1] + 50);

📌 Tópico 6.2: La Mochila Elástica (Listas Genéricas)

A medida que los juegos se hicieron más complejos (como un RPG donde recoges loot infinito), los Arreglos fijos se volvieron un dolor de cabeza. C# solucionó esto introduciendo la estructura de datos más utilizada del mundo moderno: la List<T>.

// Nota: Tienes que decirle qué Tipo de cosa (<T>) llevará la lista
List<string> inventario = new List<string>();
inventario.Add("Poción");    // Índice 0
inventario.Add("Espada");    // Índice 1
inventario.RemoveAt(0);      // Elimina el elemento en el índice 0
// Ahora "Espada" pasa a ser automáticamente el índice 0!
Console.WriteLine($"Objetos restantes: {inventario.Count}");

Nivel 2: Sistema de Spawn de Cactus

List<string> cactusVivos = new List<string>();
cactusVivos.Add("Cactus Chico");
cactusVivos.Add("Cactus Grande");
cactusVivos.RemoveAt(0);
Console.WriteLine(cactusVivos[0]); // Debería imprimir "Cactus Grande"

📌 Tópico 6.3: El Radar Iterativo (Bucle foreach)

Cuando tienes una Lista de 1000 enemigos, no vas a escribir 1000 veces Console.WriteLine. Tampoco es ideal usar un for estándar porque tendrías que llevar la cuenta exacta del tamaño de la lista. Aquí entra el bucle más poderoso para Colecciones: El foreach (Por cada).

foreach (string item in inventario) {
    Console.WriteLine($"Posees: {item}");
}

Anatomía con bisturí: "Por cada item (variable temporal de lectura) en la colección inventario, ejecuta este bloque de código. C# se encarga de saber cuándo empieza y cuándo termina la lista. ¡Cero riesgos de salirte de los límites!

Nivel 3: El Escáner de Peligros

int[] distancias = { 5, 12, 3 };
foreach (int dist in distancias) {
    if (dist < 10) {
        Console.WriteLine("¡Peligro inminente!");
    }
}

List<string> terreno = new List<string>();
while (true) {
    Console.WriteLine("1. Spawn | 2. Despawn | 3. Radar | 4. Salir");
    string opcion = Console.ReadLine();
    
    if (opcion == "1") {
        terreno.Add("Cactus");
        Console.WriteLine("Cactus añadido.");
    } 
    else if (opcion == "2" && terreno.Count > 0) {
        terreno.RemoveAt(0);
        Console.WriteLine("Cactus eliminado.");
    } 
    else if (opcion == "3") {
        Console.WriteLine("--- RADAR ---");
        foreach (string obs in terreno) {
            Console.WriteLine(obs);
        }
    } 
    else if (opcion == "4") {
        break;
    }
}

Capítulo 7: Enseñando Trucos (Métodos y Funciones)

📌 Tópico 7.1: El Principio DRY (Don't Repeat Yourself)

🔹 Contexto Histórico: El Espagueti Ilegible

En los años 60, los programadores escribían cientos de miles de líneas de código seguidas. Si querían que una nave espacial calculara su trayectoria, escribían la ecuación matemática; si querían calcularla otra vez 10 minutos después, volvían a escribir toda la ecuación desde cero. Esto generaba un "Código Espagueti" imposible de leer y lleno de errores al copiar y pegar.

La solución fue el Método (o Función): tomar un bloque de código útil, envolverlo en una cápsula impenetrable, ponerle un nombre de Acción (Verbo), y simplemente llamarlo por su nombre cuando lo necesites.

🔹 Anatomía de un Método Simple (void)

Vamos a enseñarle al jugador a saltar:

// 1. DEFINIMOS la receta (El Método):
void Saltar() {
    Console.WriteLine("Flexionando rodillas...");
    Console.WriteLine("¡Impulso hacia arriba!");
}

// 2. INVOCAMOS la receta (Llamar al método):
Saltar(); 
Saltar(); // ¡Doble salto con solo escribir dos palabras!

Anatomía con bisturí:

• La Firma (void Saltar()): Es el título de la receta. void (Vacío) significa que esta receta hace cosas, pero no te devuelve ningún número ni texto final de regreso. Solo ejecuta las acciones y termina.
• Los Paréntesis (): Son vitales. Le dicen al compilador que "Saltar" no es una variable, sino una acción a ejecutar.

Nivel 1: Enseñando el Verbo "Atacar"

void Atacar() {
    Console.WriteLine("Desenfundando espada...");
    Console.WriteLine("¡Zas!");
}

Atacar();
Atacar();
Atacar();

📌 Tópico 7.2: Pasándole Ingredientes (Parámetros)

Si nuestro juego tiene 50 enemigos distintos, sería absurdo crear un método RecibirDanioFuego(), otro RecibirDanioHielo(), etc. En su lugar, creamos una sola receta maestra que acepta Parámetros (ingredientes personalizables).

// El método EXIGE que le pases un número entero para poder funcionar
void RecibirDanio(int cantidadDaño) {
    Console.WriteLine($"¡Ouch! Perdiste {cantidadDaño} puntos de vida.");
}

// Al llamarlo, le inyectamos la información
RecibirDanio(15);
RecibirDanio(50);

Nivel 2: La Consola de Comandos

void CambiarGravedad(double nuevaGravedad) {
    Console.WriteLine($"Alerta: Gravedad cambiada a {nuevaGravedad}");
}

CambiarGravedad(-4.5);

📌 Tópico 7.3: Recibiendo el Platillo Terminado (return)

Hasta ahora hemos usado void (los métodos trabajan en silencio). Pero ¿qué pasa si queremos que el método calcule una fórmula matemática compleja de daño crítico y nos devuelva la respuesta para guardarla en nuestra vida? Reemplazamos void por el tipo de dato que prometemos devolver, y usamos la orden absoluta: return.

// Prometemos devolver un int. Exigimos un int de entrada.
int CalcularCritico(int danioBase) {
    int superDanio = danioBase * 3;
    return superDanio; // Escupe el valor
}

// Llamamos al método y ATRAPAMOS lo que escupe en una nueva variable
int miGolpeFinal = CalcularCritico(20);
Console.WriteLine(miGolpeFinal); // Imprime 60

Nivel 3: El Escudo Reductor

int CalcularDanioRecibido(int danioEnemigo) {
    int danioReducido = danioEnemigo - 5;
    return danioReducido;
}

int vidaPerdida = CalcularDanioRecibido(20);
Console.WriteLine(vidaPerdida); // Imprime 15

int TomarPocion(int vidaActual) {
    int nuevaVida = vidaActual + 50;
    if (nuevaVida > 100) {
        nuevaVida = 100;
    }
    return nuevaVida;
}

int vidaJugador = 80;
vidaJugador = TomarPocion(vidaJugador);
Console.WriteLine($"Vida tras la poción: {vidaJugador}");

Capítulo 8: Creando Entidades (POO)

📌 Tópico 8.1: El Molde y la Galleta (Historia de POO)

🔹 Contexto Histórico: El Caos de los Datos Sueltos

En los inicios, si querías programar 3 enemigos, creabas int vida1, vida2, vida3 y void Atacar1(), Atacar2()... El código era un desastre inmanejable. La gran revolución del software fue la Programación Orientada a Objetos (POO). La idea era empaquetar las Variables (Atributos) y los Métodos (Comportamientos) dentro de una sola Entidad que representara un concepto del mundo real, como "Coche", "Jugador" o "Enemigo".

🔹 Anatomía de una Clase

Creamos el molde de nuestro protagonista:

// 1. Creamos el MOLDE (Se define fuera del método Main)
class Dinosaurio {
    // Atributos (Las variables internas de la clase)
    public string nombre = "T-Rex";
    public int energia = 100;

    // Métodos (Las acciones que puede hacer la clase)
    public void Rugir() {
        Console.WriteLine($"¡El {nombre} ruge con fuerza!");
    }
}

Anatomía con bisturí: La palabra class define el inicio del molde. La palabra clave public es el modificador de acceso; sin él, todo sería private por defecto y otras partes del juego no podrían ver ni modificar esos valores (una medida de seguridad llamada Encapsulamiento).

Nivel 1: Creando el Molde

class Arma {
    public int danio = 50;
    
    public void Disparar() {
        Console.WriteLine($"¡Pum! Causas {danio} de daño");
    }
}

📌 Tópico 8.2: Horneando Objetos (La palabra new y Constructores)

Para que la clase deje de ser solo teoría y exista físicamente en la Memoria RAM, tenemos que Instanciarla (crear el objeto) usando la palabra clave new.

// 2. Horneamos las GALLETAS en el Main
Dinosaurio d1 = new Dinosaurio();
d1.energia = 80; // Modificamos SU atributo
d1.Rugir();      // Invocamos SU método

Dinosaurio d2 = new Dinosaurio();
d2.nombre = "Raptor";
d2.Rugir();

🔹 Constructores (El Horneado Automático)

Si quieres obligar a que el objeto nazca con configuraciones específicas (como el color o el daño inicial) sin setearlo línea por línea después del new, usamos un Constructor. Es un método especial que tiene el mismo nombre que la clase y se autoejecuta durante la fase del new.

class Enemigo {
    public int velocidad;

    // Esto es el Constructor (Sin void, solo el nombre exacto)
    public Enemigo(int velInicial) {          
        velocidad = velInicial; // Configuración al nacer
    }
}
// Ahora estás OBLIGADO a pasarle la velocidad al hacer el new
Enemigo alien = new Enemigo(45);

Nivel 2: Fábrica de Enemigos

Arma miRifle = new Arma();
miRifle.danio = 90;
miRifle.Disparar();

📌 Tópico 8.3: Hijos y Padres (Herencia)

Si tienes 5 enemigos distintos en tu juego, escribir la variable vida y el método RecibirDaño() 5 veces en 5 clases diferentes es violar el principio DRY (Cap 7). Para eso usamos Herencia (usando los dos puntos :). Una clase Hija puede heredar el ADN (variables y métodos) de una clase Padre.

// Clase PADRE (La base genética)
class Obstaculo {
    public int danio = 20;
}

// Clase HIJA (El Pterodactilo HEREDA de Obstaculo)
class Pterodactilo : Obstaculo {
    public void Volar() {
        Console.WriteLine("El pájaro aletea!");
    }
}

// Al crear el pájaro, mágicamente YA POSEE la variable 'danio' del Padre.
Pterodactilo p = new Pterodactilo();
Console.WriteLine(p.danio); // Imprime 20

// 1. Clases y Herencia
class Personaje {
    public int vida = 100;
}

class Jugador : Personaje {
    public void Curar() {
        vida = vida + 50; // 'vida' es heredada, puede usarla como si fuera suya
    }
}

// 2. Ejecución (Top-level)
Jugador hero = new Jugador();
Console.WriteLine($"Vida inicial: {hero.vida}");
hero.Curar();
Console.WriteLine($"Vida tras curar: {hero.vida}");

Capítulo 9: El Taller Profesional (IDE)

📌 Tópico 9.1: ¿Qué es un IDE?

🔹 El fin de la cajita de texto

Hasta este punto, escribías tu código en las cajitas de texto de esta página. Esas cajas incluían un "IntelliSense" simulado para ayudarte a memorizar las mayúsculas y los puntos y comas. Pero en el mundo real, los desarrolladores no programan en páginas web; usan un IDE (Entorno de Desarrollo Integrado).

📌 Tópico 9.2: Instalando tu Armadura (VS Code)

Aunque Godot tiene un editor interno para su propio lenguaje (GDScript), para programar en C# de forma profesional te exige usar un editor externo. El estándar de la industria es Visual Studio Code.

1. Abre tu terminal en Zorin OS e instala VS Code: flatpak install flathub com.visualstudio.code
2. Abre VS Code y ve a la sección de "Extensiones" (Ctrl+Shift+X).
3. Busca e instala la extensión "C# Dev Kit" (creada por Microsoft). Esto le dará a VS Code el poder de entender todo el código que escribas para Godot.

📌 Tópico 9.3: Nueva Regla de Trabajo

A partir de los siguientes capítulos, entraremos a programar el clon del Dinosaurio en Godot. Ya no habrá cajas de texto interactivas en esta página. Cuando veas un ejercicio, tu tarea será:

• Abrir tu proyecto en Godot.
• Hacer doble clic en el script (esto abrirá VS Code automáticamente).
• Escribir y guardar el código usando tu IDE.
• Correr el juego en Godot para comprobar si funciona.

¡Felicidades por graduarte de los fundamentos! Prepara tu taller y avanza al siguiente capítulo.

Capítulo 10: Despertando al Motor (Godot)

📌 Tópico 10.1: Del Compilador Puro al Motor Visual

🔹 Contexto Histórico: El Problema de la Rueda

En los años 90, para que un personaje se moviera en pantalla y chocara con una pared, el programador debía escribir manualmente matemáticas de trigonometría (Senos, Cosenos), físicas de colisión de cajas, y código de renderizado en OpenGL. Literalmente, cada empresa inventaba la rueda desde cero. Hoy en día usamos Motores de Juegos (Game Engines) como Godot. Son enormes librerías de código pre-hecho que ya resolvieron las físicas, la luz y el sonido. Tú solo le das las órdenes de alto nivel.

# Instalar Godot Engine (Soporte C#) en Zorin OS vía Flatpak:
flatpak install --user flathub org.godotengine.GodotSharp -y

Anatomía de Instalación: Usamos flatpak que es un gestor de paquetes de Linux para instalar contenedores seguros. GodotSharp indica que bajaremos la versión que incluye soporte nativo para el compilador de C# (Mono / .NET).

📌 Tópico 10.2: El Teatro Orientado a Objetos (Nodos)

Godot está obsesionado con la Programación Orientada a Objetos. Aquí, cada elemento visual (una Moneda, un Cactus, el Cielo) es un Objeto instanciado a partir de una Clase Base. Godot llama a estas clases Nodos.

🔹 Tu Primer Script en Godot

Para darle un cerebro a un Nodo "muerto", le pegamos un script en C#. Ese script está obligado a heredar (usando los dos puntos :) de la clase base de Godot.

using Godot; // Importamos toda la librería de Godot
using System;

// Nuestra clase Dinosaurio HEREDA de Sprite2D (Un nodo que dibuja imágenes)
public partial class Dinosaurio : Sprite2D {
    // Aquí irá el código interno...
}

Nivel 1: Reclamando el Trono (En tu IDE)

using Godot;

public partial class SueloEscenario : StaticBody2D {
    public int friccion = 10;
}

📌 Tópico 10.3: El Ciclo de Vida (_Ready y _Process)

En C# puro, el procesador empezaba en Main() y corría linealmente hasta abajo. En Godot, el motor es el jefe absoluto y él decidirá en qué milisegundo ejecutar partes específicas de tu código. Lo hace a través de dos eventos universales:

🔹 La Magia de Delta

Si multiplicas todo movimiento por delta, no importa si el jugador juega a 30 FPS en una laptop o 144 FPS en una PC Gamer; el objeto se moverá a la misma velocidad real.

public override void _Process(double delta) {
    // (float)delta es un "Cast". Transforma el double a float a la fuerza.
    Position = new Vector2(Position.X + (100 * (float)delta), Position.Y);
}

Nivel 2: Depuración del Bucle Infinito (En tu IDE)

public override void _Process(double delta) {
    GirarMoneda();
}
// ¡Nunca uses bucles infinitos en _Ready! El método _Process de Godot ya actúa como un bucle infinito seguro.

using Godot;
using System;

public partial class Cronometro : Node {
    double tiempoSobrevivido = 0;

    public override void _Ready() {
        GD.Print("Inicia la partida");
    }

    public override void _Process(double delta) {
        tiempoSobrevivido = tiempoSobrevivido + delta;
        GD.Print($"Tiempo: {tiempoSobrevivido}");
    }
}

Capítulo 11: Leyes de la Gravedad

📌 Tópico 11.1: Navegando en Dos Ejes (Vector2)

🔹 Contexto Histórico: El Plano Cartesiano Invertido

En matemáticas, el eje Y positivo va hacia arriba hacia el cielo. Pero en los monitores de computadora antiguos (y en Godot), las pantallas dibujan los píxeles desde la esquina superior izquierda hacia abajo. ¡Por lo tanto, en casi todos los motores 2D, aumentar Y mueve el objeto hacia abajo (gravedad)!

🔹 Anatomía de un Vector Godotiano

// Instanciando el contenedor de coordenadas
Vector2 velocidad = new Vector2(0.0f, 0.0f);
velocidad.Y = velocidad.Y + 980.0f; // 980 píxeles por segundo hacia abajo

Anatomía con bisturí: Notarás el sufijo f al final de los números. En C#, los números con decimales son double por defecto (pesados en memoria). Para cálculos frenéticos en videojuegos usamos float (livianos). La f fuerza al número a ser un float amigable con Godot.

Nivel 1: Caída Libre (En tu IDE)

public override void _Process(double delta) {
    float fuerzaGravedad = 50.5f;
    Velocity.Y = Velocity.Y + (fuerzaGravedad * (float)delta);
}

📌 Tópico 11.2: El Mapeo del Mando (Input)

En el Capítulo 3 aprendimos a usar Console.ReadLine() para atrapar texto. Pero en un videojuego de acción, necesitamos leer inputs (entradas) instantáneas de un control o teclado, ignorando pulsaciones repetitivas y evitando "código duro" con teclas específicas.

// IsActionJustPressed detecta si la tecla se hundió en el milisegundo exacto.
// IsActionPressed detecta si el jugador mantiene presionado (útil para ametralladoras)
if (Input.IsActionJustPressed("ui_accept")) {
    GD.Print("¡Salto inicializado!");
}

using Godot;

public partial class Dino : CharacterBody2D {
    public const float Gravedad = 980.0f;
    public const float FuerzaSalto = -400.0f;

    public override void _PhysicsProcess(double delta) {
        Vector2 vel = Velocity;

        // Gravedad constante
        if (!IsOnFloor()) {
            vel.Y = vel.Y + (Gravedad * (float)delta);
        }

        // Salto condicionado
        if (Input.IsActionJustPressed("ui_accept") && IsOnFloor()) {
            vel.Y = FuerzaSalto; // Recuerda: Negativo hacia arriba
        }

        Velocity = vel;
        MoveAndSlide(); // Función del motor que ejecuta la fricción y rebotes
    }
}

Capítulo 12: PROYECTO FINAL 🏆

📌 Tópico 12.1: La Arquitectura de un Juego Moderno

🔹 Contexto Histórico: El Patrón Entidad-Componente

En el pasado, un juego era un solo archivo gigante de 10,000 líneas de código. Esto era imposible de mantener. Hoy usamos el Patrón de Escenas y Nodos (una variación del patrón ECS). Cada elemento es una pieza de Lego independiente que ni siquiera sabe que el otro existe, hasta que el "Director" los une.

📌 Tópico 12.2: El Árbol Principal y las PackedScenes

En tu Escena Principal (Main), el árbol de nodos debería organizarse así:

• 🟩 Mundo (Node2D)
  • 🟦 Dino (CharacterBody2D) -> Controla la gravedad y saltos.
  • 🟨 Piso (StaticBody2D) -> Tiene una caja de colisión para que el dino no caiga al infinito.
  • 🟪 Generador (Timer) -> Un reloj invisible que hace 'Tick' cada 2 segundos.

🔹 Instanciando Prefabs (PackedScenes)

¿Recuerdas el Molde de Galletas del Capítulo 8? En Godot, guardamos un enemigo completo (con sus gráficos, físicas y scripts) en el disco duro como un archivo Cactus.tscn. Godot llama a esto una PackedScene. Para crear clones infinitos de este cactus durante el juego, usamos Instantiate() (el primo lejano del new).

// 1. Traemos el molde de la cocina al disco RAM
PackedScene moldeCactus = GD.Load<PackedScene>("res://Cactus.tscn");

// 2. Horneamos una galleta nueva
Node2D clonCactus = (Node2D)moldeCactus.Instantiate();

// 3. Ponemos la galleta sobre la mesa del juego
AddChild(clonCactus);

📌 Tópico 12.3: Señales (La programación por eventos)

Si el Dinosaurio choca con el cactus, necesitamos detectarlo. En lugar de preguntar 60 veces por segundo en el _Process "¿ya chistaste?", Godot usa Señales.

Nivel 1: El Sentido Arácnido (En tu IDE)

public void AlEntrarCuerpo(Node2D cuerpo) {
    if (cuerpo.Name == "Jugador") {
        GD.Print("¡Moneda recogida!");
        QueueFree(); // Elimina el nodo actual de la memoria de forma segura
    }
}

using Godot;
using System;

public partial class Spawner : Node {
    // 1. Cargamos el molde
    PackedScene escenaCactus = GD.Load<PackedScene>("res://Cactus.tscn");
    
    // 2. Este método es llamado mágicamente por Godot cada 2 segundos
    public void _OnTimerTimeout() { 
        // 3 y 4. Instanciamos la galleta
        Node2D nuevoEnemigo = (Node2D)escenaCactus.Instantiate();
        
        // 5. Lo posicionamos al final de la pantalla (Vector2)
        nuevoEnemigo.Position = new Vector2(1000, 0);
        
        // 6. Lo agregamos al Árbol de Nodos
        AddChild(nuevoEnemigo);
    }
}