🛠️ Guía de Desarrollo 🛠️ Development Guide

Todo lo que necesitas saber para contribuir al proyecto Everything you need to know to contribute to the project

Configuración del Entorno de Desarrollo Development Environment Setup

Prerrequisitos Prerequisites

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:

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

  1. Fork el repositorio Fork the repository
  2. Crear rama de característica Create feature branch
  3. Implementar cambios con tests Implement changes with tests
  4. Actualizar documentación Update documentation
  5. 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

Rendimiento Performance

Mantenibilidad Maintainability

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. This development guide provides the foundation for contributing to and extending Donkey Kong Classic. By following these patterns and guidelines, you can maintain code quality and system architecture while adding exciting new features.

Recuerda: el objetivo es crear código que sea no solo funcional, sino también mantenible, testeable y extensible para futuros desarrolladores. Remember: the goal is to create code that is not only functional, but also maintainable, testable, and extensible for future developers.