Guía de Desarrollo - Donkey Kong Classic

Configuración del Entorno de Desarrollo Development Environment Setup

Prerrequisitos Prerequisites

Python 3.12+ (recomendado) Python 3.12+ (recommended)
Git para control de versiones Git for version control
Editor de código (VS Code, PyCharm, etc.) Code editor (VS Code, PyCharm, etc.)
Cuenta de Firebase (para funciones en la nube) Firebase account (for cloud features)

Configuración Inicial Initial Setup

git clone <repository-url>
cd ClassicGame
python -m venv venv
# En Windows: venv\Scripts\activate# On Windows: venv\Scripts\activate
source venv/bin/activate
pip install -r requirements.txt

cp .env.example .env
# Editar .env con tus credenciales de Firebase# Edit .env with your Firebase credentials

python main.py

Estructura del Proyecto en Profundidad In-Depth Project Structure

ClassicGame/
├── src/                    # Código fuente
│   ├── game/              # Lógica principal del juego
│   │   ├── game_manager.py    # Coordinador principal
│   │   └── level.py           # Definiciones de nivel
│   ├── entities/          # Objetos del juego
│   │   ├── player.py          # Personaje jugador
│   │   ├── enemy.py           # Enemigos con IA
│   │   ├── collectible.py     # Objetos coleccionables
│   │   └── projectile.py      # Objetos lanzables
│   ├── managers/          # Gestores de sistemas
│   │   ├── entity_manager.py      # Ciclo de vida de entidades
│   │   ├── collision_manager.py   # Física/colisiones
│   │   ├── game_state_manager.py  # Gestión de estados
│   │   ├── tutorial_manager.py    # Sistema de tutorial
│   │   ├── level_manager.py       # Generación de niveles
│   │   ├── firebase_manager.py    # Integración en la nube
│   │   ├── sound_manager.py       # Sistema de audio
│   │   ├── save_manager.py        # Guardados locales
│   │   ├── shop_manager.py        # Lógica de tienda
│   │   └── ui_manager.py          # Coordinación de UI
│   ├── ai/                # Inteligencia Artificial
│   │   └── q_learning.py      # Algoritmo Q-Learning
│   ├── ui/                # Interfaz de Usuario
│   │   └── shop_menu.py       # Interfaz de tienda
│   └── utils/             # Utilidades
│       └── config.py          # Configuración del juego
├── assets/                # Assets del juego
│   ├── player/            # Sprites del jugador
│   ├── enemy/             # Sprites de enemigos
│   └── shop/              # Iconos de tienda
├── data/                  # Datos persistentes
├── docs/                  # Documentación
└── tests/                 # Pruebas unitariasClassicGame/
├── src/                    # Source code
│   ├── game/              # Core game logic
│   │   ├── game_manager.py    # Main coordinator
│   │   └── level.py           # Level definitions
│   ├── entities/          # Game objects
│   │   ├── player.py          # Player character
│   │   ├── enemy.py           # AI enemies
│   │   ├── collectible.py     # Collectible objects
│   │   └── projectile.py      # Throwable objects
│   ├── managers/          # System managers
│   │   ├── entity_manager.py      # Entity lifecycle
│   │   ├── collision_manager.py   # Physics/collisions
│   │   ├── game_state_manager.py  # State management
│   │   ├── tutorial_manager.py    # Tutorial system
│   │   ├── level_manager.py       # Level generation
│   │   ├── firebase_manager.py    # Cloud integration
│   │   ├── sound_manager.py       # Audio system
│   │   ├── save_manager.py        # Local saves
│   │   ├── shop_manager.py        # Shop logic
│   │   └── ui_manager.py          # UI coordination
│   ├── ai/                # Artificial Intelligence
│   │   └── q_learning.py      # Q-Learning algorithm
│   ├── ui/                # User Interface
│   │   └── shop_menu.py       # Shop interface
│   └── utils/             # Utilities
│       └── config.py          # Game configuration
├── assets/                # Game assets
│   ├── player/            # Player sprites
│   ├── enemy/             # Enemy sprites
│   └── shop/              # Shop icons
├── data/                  # Persistent data
├── docs/                  # Documentation
└── tests/                 # Unit tests

Flujo de Trabajo de Desarrollo Development Workflow

Agregando Nuevas Características Adding New Features

git checkout -b feature/nueva-caracteristicagit checkout -b feature/new-feature

Sigue los Patrones de Arquitectura: Follow Architecture Patterns:

Usa el patrón manager para nuevos sistemas Use manager pattern for new systems
Implementa manejo adecuado de errores Implement proper error handling
Agrega opciones de configuración a config.py Add configuration options to config.py

python -m pytest tests/

Pautas de Estilo de Código Code Style Guidelines

Estilo Python Python Style

Sigue PEP 8 con estas especificaciones: Follow PEP 8 with these specifications:

# Nomenclatura de clases: PascalCase# Class naming: PascalCase
class EntityManager:
    pass

# Nomenclatura de funciones/variables: snake_case# Function/variable naming: snake_case
def update_entities(self):
    player_position = self.get_player_position()

# Constantes: UPPER_CASE# Constants: UPPER_CASE
MAX_ENEMIES = 10
DEFAULT_SPEED = 5

# Docstrings: Estilo Google# Docstrings: Google style
def calculate_distance(self, point_a, point_b):
    """Calcula la distancia euclidiana entre dos puntos.
    
    Args:
        point_a (tuple): Primer punto (x, y)
        point_b (tuple): Segundo punto (x, y)
    
    Returns:
        float: Distancia entre puntos
    """"""Calculate euclidean distance between two points.
    
    Args:
        point_a (tuple): First point (x, y)
        point_b (tuple): Second point (x, y)
    
    Returns:
        float: Distance between points
    """

Agregando Nuevas Entidades Adding New Entities

Paso 1: Crear Clase de Entidad Step 1: Create Entity Class

# src/entities/nueva_entidad.py# src/entities/new_entity.py
import pygame

class NuevaEntidad:class NewEntity:
    def __init__(self, x, y, config):
        self.config = config
        self.rect = pygame.Rect(x, y, 30, 30)
        self.velocity_x = 0
        self.velocity_y = 0
        self.active = True
        
        # Cargar sprites# Load sprites
        self.sprites = self.load_sprites()
        
    def load_sprites(self):
        """Cargar sprites de la entidad""""""Load entity sprites"""
        # Implementación aquí# Implementation here
        pass
    
    def update(self):
        """Actualizar lógica de la entidad""""""Update entity logic"""
        # Física, IA, etc.# Physics, AI, etc.
        pass
    
    def render(self, screen):
        """Renderizar entidad""""""Render entity"""
        if self.sprites:
            screen.blit(self.sprites[0], self.rect)
        else:
            pygame.draw.rect(screen, (255, 0, 0), self.rect)

Testing Testing

Testing Unitario Unit Testing

# tests/test_nueva_entidad.py# tests/test_new_entity.py
import unittest
from src.entities.nueva_entidad import NuevaEntidadfrom src.entities.new_entity import NewEntity
from src.utils.config import Config

class TestNuevaEntidad(unittest.TestCase):class TestNewEntity(unittest.TestCase):
    def setUp(self):
        self.config = Config()
        self.entidad = NuevaEntidad(100, 100, self.config)self.entity = NewEntity(100, 100, self.config)
    
    def test_initialization(self):
        """Test inicialización de entidad""""""Test entity initialization"""
        self.assertEqual(self.entidad.rect.x, 100)
        self.assertEqual(self.entidad.rect.y, 100)
        self.assertTrue(self.entidad.active)self.assertEqual(self.entity.rect.x, 100)
        self.assertEqual(self.entity.rect.y, 100)
        self.assertTrue(self.entity.active)
    
    def test_update(self):
        """Test lógica de actualización de entidad""""""Test entity update logic"""
        initial_x = self.entidad.rect.x
        self.entidad.velocity_x = 5
        self.entidad.update()
        self.assertEqual(self.entidad.rect.x, initial_x + 5)initial_x = self.entity.rect.x
        self.entity.velocity_x = 5
        self.entity.update()
        self.assertEqual(self.entity.rect.x, initial_x + 5)

if __name__ == '__main__':
    unittest.main()

Despliegue Deployment

Construir Ejecutable Build Executable

python build.py

Lista de Verificación de Distribución Distribution Checklist

☐ Todos los assets incluidos ☐ All assets included
☐ Variables de entorno configuradas ☐ Environment variables configured
☐ Dependencias resueltas ☐ Dependencies resolved
☐ Testing multiplataforma ☐ Cross-platform testing
☐ Validación de rendimiento ☐ Performance validation
☐ Verificación de manejo de errores ☐ Error handling verification

Pautas de Contribución Contribution Guidelines

Proceso de Pull Request Pull Request Process

Fork el repositorio Fork the repository
Crear rama de característica Create feature branch
Implementar cambios con tests Implement changes with tests
Actualizar documentación Update documentation
Enviar pull request con descripción Submit pull request with description

Lista de Verificación de Code Review Code Review Checklist

☐ El código sigue las pautas de estilo ☐ Code follows style guidelines
☐ Los tests pasan ☐ Tests pass
☐ Documentación actualizada ☐ Documentation updated
☐ Sin regresiones de rendimiento ☐ No performance regressions
☐ Manejo de errores implementado ☐ Error handling implemented
☐ Assets gestionados apropiadamente ☐ Assets managed appropriately

Mejores Prácticas Best Practices

Arquitectura Architecture

Mantener separación clara de responsabilidades Maintain clear separation of concerns
Usar el patrón manager para nuevos sistemas Use manager pattern for new systems
Implementar manejo robusto de errores Implement robust error handling
Seguir principios SOLID Follow SOLID principles

Rendimiento Performance

Perfilar regularmente el código Profile code regularly
Usar cache para assets costosos Use caching for expensive assets
Optimizar bucles críticos Optimize critical loops
Monitorear uso de memoria Monitor memory usage

Mantenibilidad Maintainability

Escribir código autodocumentado Write self-documenting code
Usar nombres descriptivos Use descriptive names
Mantener funciones pequeñas y enfocadas Keep functions small and focused
Documentar decisiones arquitectónicas Document architectural decisions

Conclusión Conclusion

Esta guía de desarrollo proporciona la base para contribuir y extender Donkey Kong Classic. Siguiendo estos patrones y pautas, puedes mantener la calidad del código y la arquitectura del sistema mientras agregas nuevas características emocionantes.

Recuerda: el objetivo es crear código que sea no solo funcional, sino también mantenible, testeable y extensible para futuros desarrolladores.

🛠️ Guía de Desarrollo 🛠️ Development Guide