MÓDULO 1: TYPESCRIPT

Objetos e Interfaces

Las **Interfaces** definen la estructura que deben tener nuestros objetos. Son contratos que garantizan que todos los personajes, enemigos e items tengan las propiedades esperadas, evitando errores en runtime.


1. Interfaces Básicas

Definimos qué propiedades debe tener un objeto.

interface Personaje {
    nombre: string;
    nivel: number;
    vida: number;
    ataque: number;
}

const guerrero: Personaje = {
    nombre: "Krag",
    nivel: 12,
    vida: 280,
    ataque: 65
};

Nota: TypeScript verifica que TODAS las propiedades requeridas existan y tengan el tipo correcto.


2. Interfaces con Métodos

Las interfaces pueden incluir funciones (métodos).

interface Enemigo {
    nombre: string;
    vida: number;
    daño: number;
    atacar(): number; // método
}

const goblin: Enemigo = {
    nombre: "Goblin Ladron",
    vida: 80,
    daño: 25,
    atacar() {
        return this.daño + Math.floor(Math.random() * 10);
    }
};

console.log(goblin.atacar()); // 25-34 daño aleatorio

3. Interfaces Extendidas (Herencia)

Una interface puede heredar de otra.

interface Jugador extends Personaje {
    experiencia: number;
    mana: number;
    habilidadEspecial(): string;
}

interface JefeFinal extends Enemigo {
    faseActual: number;
    invocarMinions(): void;
}

const mago: Jugador = {
    nombre: "Eldrin",
    nivel: 18,
    vida: 220,
    ataque: 40,
    experiencia: 9500,
    mana: 150,
    habilidadEspecial() {
        return "Bola de Fuego!";
    }
};

Interfaces Opcionales

interface Item {
    nombre: string;
    rareza: string;
    potencia?: number; // opcional (?)
    efecto?: string;
}

4. Type vs Interface (Diferencias Clave)

// INTERFACE - ideal para objetos y APIs
interface Arma {
    nombre: string;
    daño: number;
}

// TYPE - más versátil (uniones, primitivos, etc)
type Rareza = "Común" | "Rara" | "Épica";

type ItemCompleto = Arma & { rareza: Rareza };

5. Arrays de Interfaces

const party: Jugador[] = [
    mago,
    guerrero,
    {
        nombre: "Thief",
        nivel: 14,
        vida: 200,
        ataque: 55,
        experiencia: 7200,
        mana: 80,
        habilidadEspecial: () => "Ataque sorpresa!"
    }
];

6. Ventajas de las Interfaces

Consistencia: Todos los objetos siguen el mismo contrato.
Reutilización: Una interface para múltiples objetos similares.
Autodocumentación: Los tipos explican la estructura del objeto.

🛠️ Tu Misión

Prueba esto en TypeScript Playground:

  1. Crea una interface Item con nombre, rareza (string), y potencia (number).
  2. Extiende la interface Personaje para crear Mago con mana y hechizos.
  3. Crea un array de enemigos con al menos 3 objetos que implementen interface Enemigo.
  4. Bonus: Crea interface Quest con recompensa y requisitos opcionales.