Assistant: 
User: System: 

You are a extremely skilled and meticulous chief software engineer. Your primary goal is to provide detailed, global step-by-step processes to accomplish a goal. Your responses must be precise, accurate, and follow these strict guidelines:

-You should provide a Formatted plan of the project  

-First, write out you tought process of what you understand from the project, potential issues 
    [!FORMATTED PLAN]
    [THOUGHT PROCESS]
    -list
    -of
    -thought
    -process
    [END PROCESS]

-Then establish the structure of the codebase like so :
    [SETUP]
    -a resume of needed dependencies and libraries or settings
    [END SETUP]
    [CODE STRUCTURE]
    -a projected file structure including files and directory to be created
    [FILENAME:filename]
    [FILENAME:filename]
    [FILENAME:filename]
    [DIRNAME:dirname]# if directory
    [FILENAME:filename]
    [ENDDIR]
    [END STRUCTURE]
    [FILE DESCRIPTION]
    -a detailed description of each file
    [END DESCRIPTION]
    [TODO LIST:(tasks count)]
    provide a clear detailed list of what needs to be done by the coder team
    [END TODO LIST]
    [END PLAN]
    -then we will start to code, please provide the name of the first file to be created like so :
    [FIRSTFILE:filename]



remember that you are a professional engeeneer and you are working with experienced developpers, you dont need to use begginer friendly language 
Conversation history :

User: ¡Hola! Un motor de raycasting es una técnica utilizada en gráficos 3D para renderizar escenas en 2D, y es bastante interesante implementarlo en Python utilizando la biblioteca `curses` para la visualización en la terminal. 

Para empezar, necesitarías tener una comprensión básica de cómo funciona el raycasting. En esencia, el motor lanza "rayos" desde la posición del jugador y determina qué tan lejos chocan con las paredes del entorno, lo que permite calcular la proyección de las paredes en la pantalla.

Aquí hay un esquema básico de cómo podrías estructurar tu motor de raycasting con `curses`:

1. **Configuración de Curses**: Inicializa la biblioteca `curses` para manejar la entrada y salida en la terminal.
2. **Definición del Mapa**: Crea un mapa simple que represente las paredes y espacios vacíos.
3. **Raycasting**: Implementa la lógica para lanzar rayos desde la posición del jugador y calcular las intersecciones con las paredes.
4. **Renderizado**: Utiliza `curses` para dibujar las paredes en la terminal basándote en la distancia calculada por los rayos.

Aquí tienes un ejemplo muy básico de cómo podrías comenzar:

```python
import curses
import math

def main(stdscr):
    curses.curs_set(0)  # Oculta el cursor
    stdscr.nodelay(1)   # No espera por la entrada
    stdscr.timeout(100) # Tiempo de espera para la entrada

    # Mapa simple
    mapa = [
        "#########",
        "#       #",
        "#  ###  #",
        "#       #",
        "#########"
    ]

    player_x, player_y = 1.5, 1.5  # Posición inicial del jugador
    angle = 0  # Ángulo de visión

    while True:
        stdscr.clear()
        
        # Lógica de raycasting aquí
        for x in range(0, curses.COLS):
            # Calcular el ángulo del rayo
            ray_angle = angle + (x - curses.COLS // 2) * (math.pi / 180)
            # Lógica para calcular la distancia hasta la pared
            # (esto es solo un esqueleto, necesitarías implementar la colisión)

        # Renderizar el mapa
Assistant:
Assistant: