camelCase es la convención donde la primera palabra va en minúscula y cada palabra siguiente comienza con mayúscula, sin espacios. Se usa para variables locales, parámetros y campos privados.
int playerHealth = 100; float movementSpeed = 5.5f; string currentWeapon = "Espada Legendaria"; bool isGameOver = false;
Incorrecto: PlayerScore, enemy_count, isgameover
✍️ Ejercicio: Completa el código
Declara una variable camelCase para guardar la cantidad de vidas del jugador con valor 3, y otra para el nombre del nivel actual.
🧠 Quiz Rápido
PascalCase es igual que camelCase pero la primera letra también va en mayúscula. Se usa para clases, métodos públicos, propiedades y enumeraciones.
public class EnemyController { } public void TakeDamage(int damage) { } public int MaxHealth { get; set; } public enum GameState { Playing, Paused, GameOver }
✍️ Ejercicio: Completa el código
Escribe el nombre correcto en PascalCase para una clase que controla al jugador y un método que le cura vida.
🧠 Quiz Rápido
El código limpio es aquel que cualquier programador puede leer y entender rápidamente. No solo tú ahora, sino tú mismo en 6 meses.
🔀 Antes vs Después — Toggle interactivo
void u(){if(h>0){h-=d;if(h<=0){d=true;}}}
void UpdatePlayerHealth() { if (health > 0) { health -= damageReceived; if (health <= 0) { isDead = true; } } }
♻️ Refactoring — Toggle interactivo
void Update() { if (Input.GetKey(KeyCode.W)) transform.position += Vector3.forward * 5 * Time.deltaTime; if (Input.GetKey(KeyCode.S)) transform.position += Vector3.back * 5 * Time.deltaTime; if (Input.GetKey(KeyCode.A)) transform.position += Vector3.left * 5 * Time.deltaTime; if (Input.GetKey(KeyCode.D)) transform.position += Vector3.right * 5 * Time.deltaTime; }
private float playerSpeed = 5f; void Update() { HandlePlayerMovement(); } void HandlePlayerMovement() { float horizontal = Input.GetAxis("Horizontal"); float vertical = Input.GetAxis("Vertical"); Vector3 movement = new Vector3(horizontal, 0, vertical); transform.position += movement * playerSpeed * Time.deltaTime; }
🧠 Quiz Rápido
Una variable es un contenedor que puede cambiar su valor durante el juego. Una constante guarda un valor que nunca cambia.
📦 Variables
int playerScore = 0; // Puntos del jugador float playerHealth = 100.5f; // Vida decimal string playerName = "Héroe"; // Nombre del personaje bool hasKey = false; // ¿Tiene la llave? // Cambian durante el juego: playerScore += 100; // Suma 100 puntos playerHealth -= 25; // Quita 25 de vida
🔒 Constantes
const float MAX_PLAYER_SPEED = 10f; const int MAX_HEALTH = 100; const int LEVEL_COUNT = 10;
📊 Tipos de Datos Principales
| Tipo | Descripción | Ejemplo en juego |
|---|---|---|
int | Números enteros | int lives = 3; |
float | Números decimales | float speed = 5.5f; |
bool | Verdadero / Falso | bool isAlive = true; |
string | Texto | string weapon = "Espada"; |
char | Un solo carácter | char grade = 'A'; |
✍️ Ejercicio: Completa el código
Declara una constante para la vida máxima (100) y una variable para la vida actual (75).
🧠 Quiz Rápido
Los condicionales permiten que tu código tome decisiones. Es como preguntarle al juego: "¿Si esto es verdad, haz esto; si no, haz aquello?"
// Sistema de vida if (health <= 0) { GameOver(); } else if (health < 30) { ShowLowHealthWarning(); } else { // El jugador está bien } // Sistema de puerta con llave if (hasKey) { OpenDoor(); ShowMessage("¡Puerta abierta!"); } else { ShowMessage("Necesitas una llave"); }
✍️ Ejercicio: Completa el código
Completa este sistema de score: si el puntaje supera 1000, muestra "¡Récord!"; si no, muestra "Sigue intentando".
🧠 Quiz Rápido
🔁 Bucle for — cuando sabes cuántas veces
// Crear 10 enemigos for (int i = 0; i < 10; i++) { Instantiate(enemyPrefab, spawnPosition, Quaternion.identity); } // Dar puntos combo for (int combo = 1; combo <= 5; combo++) { score += combo * 100; // 100, 200, 300, 400, 500 }
🔁 Bucle while — mientras algo sea verdad
// Temporizador float timer = 10f; while (timer > 0) { timer -= Time.deltaTime; UpdateTimerDisplay(timer); }
🔁 Bucle do-while — siempre ejecuta al menos una vez
// Menú: muestra al menos una vez int option; do { ShowMenu(); option = GetPlayerInput(); ProcessOption(option); } while (option != 0); // 0 = salir
✍️ Ejercicio: Completa el código
Completa este bucle for que genera 5 power-ups en posiciones distintas.
🧠 Quiz Rápido
➕ Aritméticos
int damage = 10 + 5; // Suma = 15 int health = 100 - 25; // Resta = 75 int score = 10 * 5; // Mult = 50 int lives = 10 / 2; // División= 5 int remainder= 10 % 3; // Módulo = 1
🔍 Comparación
if (playerHealth == 100) // Igual a if (playerHealth != 0) // Diferente de if (playerHealth > 50) // Mayor que if (playerHealth < 30) // Menor que if (playerHealth >= 50) // Mayor o igual if (playerHealth <= 100) // Menor o igual
🔗 Lógicos
if (hasKey && doorLocked) // AND: ambos verdaderos if (isDay || hasLantern) // OR: al menos uno if (!isGameOver) // NOT: invierte
📝 Asignación
score = 100; // Asignación simple score += 50; // score = score + 50 health -= 20; // health = health - 20 damage *= 2; // damage = damage * 2
✍️ Ejercicio: Sistema de golpe crítico
Completa el sistema: si el golpe es crítico, el daño se duplica usando el operador de asignación correcto.
🧠 Quiz Rápido
Una clase es el molde o plano. Un objeto es la instancia concreta creada a partir de ese molde. Si Player es el molde, jugador1 y jugador2 son los jugadores reales.
public class Player { // Atributos (características) public string playerName; public int health; public float speed; // Métodos (comportamientos) public void Move() { /* mueve al jugador */ } public void TakeDamage(int damage) { health -= damage; } } // Crear objetos (instancias) Player jugador1 = new Player(); jugador1.playerName = "Aragorn"; jugador1.health = 100; Player jugador2 = new Player(); jugador2.playerName = "Legolas"; jugador2.health = 90;
✍️ Ejercicio: Crea una clase Weapon
Completa la declaración de la clase y crea un objeto espada con daño 50.
🧠 Quiz Rápido
Los atributos definen las características (datos) de un objeto. Los métodos definen lo que puede hacer (acciones).
public class Enemy { public int health = 50; // Sin parámetros, sin retorno public void Patrol() { Debug.Log("Enemigo patrullando..."); } // Con parámetro, sin retorno public void TakeDamage(int damage) { health -= damage; if (health <= 0) Die(); } // Sin parámetros, con retorno public bool IsAlive() { return health > 0; } // Con parámetros y retorno public int CalculateDamage(int baseDamage, float multiplier) { return (int)(baseDamage * multiplier); } }
🧠 Quiz Rápido
La herencia permite crear una clase hija que hereda todo de la clase padre y además puede agregar o modificar comportamientos.
// Clase padre public class Enemy { public int health = 50; public int damage = 10; public virtual void Attack() { Debug.Log("Ataque básico"); } } // Clase hija — hereda de Enemy public class BossEnemy : Enemy { public int armor = 20; public BossEnemy() { health = 200; // Sobreescribe valor heredado damage = 25; } public override void Attack() // Sobreescribe el método { Debug.Log("¡Ataque especial del jefe!"); } } // Otra clase hija public class FlyingEnemy : Enemy { public float flyHeight = 5f; public void Fly() { Debug.Log("Volando a altura: " + flyHeight); } }
✍️ Ejercicio: Crea una clase hija
Crea una clase ArmoredEnemy que herede de Enemy y sobreescriba el método Attack.
🧠 Quiz Rápido
El polimorfismo permite que objetos de distintas clases respondan diferente al mismo método. Literalmente "muchas formas".
public class Character { public virtual void Attack() { Debug.Log("Ataque genérico"); } } public class Warrior : Character { public override void Attack() { Debug.Log("¡Golpe con espada!"); } } public class Mage : Character { public override void Attack() { Debug.Log("¡Bola de fuego!"); } } public class Archer : Character { public override void Attack() { Debug.Log("¡Disparo de flecha!"); } } // USO: mismo método, resultados distintos List<Character> party = new List<Character>(); party.Add(new Warrior()); party.Add(new Mage()); party.Add(new Archer()); foreach (Character character in party) { character.Attack(); // Cada uno ataca diferente }
🧠 Quiz Rápido
La encapsulación oculta los detalles internos y solo expone lo necesario. Evita que otros modifiquen datos de formas inesperadas.
public class Player { public int health = 100; // ¡Peligro! Modificable libremente } // Desde cualquier parte: player.health = -50; // ¡Error! Vida negativa player.health = 99999; // ¡Trampa!
public class Player { private int health = 100; private int maxHealth = 100; public int Health { get { return health; } } public void TakeDamage(int damage) { if (damage < 0) return; health -= damage; if (health < 0) health = 0; } public void Heal(int amount) { health += amount; if (health > maxHealth) health = maxHealth; } } // Uso correcto: player.TakeDamage(30); // ✓ player.Heal(20); // ✓ // player.health = -50; ✗ ERROR de compilación
🧠 Quiz Rápido
Declara las variables indicadas y escribe la condicional correcta. El sistema verificará tu código.
int playerHealth = 75; y un if que imprima "Vida baja" si health es menor a 30, o "Vida normal" si no.
20 y vuelve a ejecutar. ¿Cambia el resultado?Crea una clase con atributos y métodos. El sistema detecta tu clase e instancia.
Enemy con atributos health (int) y name (string). Crea un objeto con new Enemy() y asigna valores a sus atributos.
TakeDamage(int damage) a tu clase y llámalo en tu objeto.Escribe un bucle que genere salida. El editor simula la ejecución y te muestra el output.
for que imprima "Enemigo #1", "Enemigo #2"... hasta "Enemigo #5" usando Debug.Log().
¡Felicitaciones, Programador!
Has completado la Guía Completa de C# para Videojuegos de UBES Academy.
¡Ahora tienes las bases para crear juegos increíbles en Unity!
© 2026 UBES Academy · Todos los derechos reservados