Máster en Programación de Videojuegos .

Módulo 1. Fundamentos de programación

1.1. Introducción a la programación

1.1.1. Estructura básica de un ordenador
1.1.2. Software
1.1.3. Lenguajes de programación
1.1.4. Ciclo de vida de una aplicación informática

1.2. Diseño de algoritmos

1.2.1. La resolución de problemas
1.2.2. Técnicas descriptivas
1.2.3. Elementos y estructura de un algoritmo

1.3. Elementos de un programa

1.3.1. Origen y características del lenguaje C++
1.3.2. El entorno de desarrollo
1.3.3. Concepto de programa
1.3.4. Tipos de datos fundamentales
1.3.5. Operadores
1.3.6. Expresiones
1.3.7. Sentencias
1.3.8. Entrada y salida de datos

1.4. Sentencias de control

1.4.1. Sentencias
1.4.2. Bifurcaciones
1.4.3. Bucles

1.5. Abstracción y modularidad: funciones

1.5.1. Diseño modular
1.5.2. Concepto de función y utilidad
1.5.3. Definición de una función
1.5.4. Flujo de ejecución en la llamada de una función
1.5.5. Prototipo de una función
1.5.6. Devolución de resultados
1.5.7. Llamada a una función: parámetros
1.5.8. Paso de parámetros por referencia y por valor
1.5.9. Ámbito identificador

1.6. Estructuras de datos estáticas

1.6.1. Arrays
1.6.2. Matrices. Poliedros
1.6.3. Búsqueda y ordenación
1.6.4. Cadenas. Funciones de E/S para cadenas
1.6.5. Estructuras. Uniones
1.6.6. Nuevos tipos de datos

1.7. Estructuras de datos dinámicas: punteros

1.7.1. Concepto. Definición de puntero
1.7.2. Operadores y operaciones con punteros
1.7.3. Arrays de punteros
1.7.4. Punteros y arrays
1.7.5. Punteros a cadenas
1.7.6. Punteros a estructuras
1.7.7. Indirección múltiple
1.7.8. Punteros a funciones
1.7.9. Paso de funciones, estructuras y arrays como parámetros de funciones

1.8. Ficheros

1.8.1. Conceptos básicos
1.8.2. Operaciones con ficheros
1.8.3. Tipos de ficheros
1.8.4. Organización de los ficheros
1.8.5. Introducción a los ficheros C++
1.8.6. Manejo de ficheros

1.9. Recursividad

1.9.1. Definición de recursividad
1.9.2. Tipos de recursión
1.9.3. Ventajas e inconvenientes
1.9.4. Consideraciones
1.9.5. Conversión recursivo-iterativa
1.9.6. La pila de recursión

1.10. Prueba y documentación

1.10.1. Pruebas de programas
1.10.2. Prueba de la caja blanca
1.10.3. Prueba de la caja negra
1.10.4. Herramientas para realizar las pruebas
1.10.5. Documentación de programas

Módulo 2. Estructura de datos y algoritmos

2.1. Introducción a las estrategias de diseño de algoritmos

2.1.1. Recursividad
2.1.2. Divide y conquista
2.1.3. Otras estrategias

2.2. Eficiencia y análisis de los algoritmos

2.2.1. Medidas de eficiencia
2.2.2. Medir el tamaño de la entrada
2.2.3. Medir el tiempo de ejecución
2.2.4. Caso peor, mejor y medio
2.2.5. Notación asintónica
2.2.6. Criterios de análisis matemático de algoritmos no recursivos
2.2.7. Análisis matemático de algoritmos recursivos
2.2.8. Análisis empírico de algoritmos

2.3. Algoritmos de ordenación

2.3.1. Concepto de ordenación
2.3.2. Ordenación de la burbuja
2.3.3. Ordenación por selección
2.3.4. Ordenación por inserción
2.3.5. Ordenación por mezcla (Merge_Sort)
2.3.6. Ordenación rápida (Quick_Sort)

2.4. Algoritmos con árboles

2.4.1. Concepto de árbol
2.4.2. Árboles binarios
2.4.3. Recorridos de árbol
2.4.4. Representar expresiones
2.4.5. Árboles binarios ordenados
2.4.6. Árboles binarios balanceados

2.5. Algoritmos con heaps

2.5.1. Los heaps
2.5.2. El algoritmo heapsort
2.5.3. Las colas de prioridad

2.6. Algoritmos con grafos

2.6.1. Representación
2.6.2. Recorrido en anchura
2.6.3. Recorrido en profundidad
2.6.4. Ordenación topológica

2.7. Algoritmos greedy

2.7.1. La estrategia greedy
2.7.2. Elementos de la estrategia greedy
2.7.3. Cambio de monedas
2.7.4. Problema del viajante
2.7.5. Problema de la mochila

2.8. Búsqueda de caminos mínimos

2.8.1. El problema del camino mínimo
2.8.2. Arcos negativos y ciclos
2.8.3. Algoritmo de Dijkstra

2.9. Algoritmos greedy sobre grafos

2.9.1. El árbol de recubrimiento mínimo
2.9.2. El algoritmo de Prim
2.9.3. El algoritmo de Kruskal
2.9.4. Análisis de complejidad

2.10. Backtracking

2.10.1. El backtracking
2.10.2. Técnicas alternativas

Módulo 3. Programación orientada a objetos

3.1. Introducción a la programación orientada a objetos

3.1.1. Introducción a la programación orientada a objetos
3.1.2. Diseño de clases
3.1.3. Introducción a UML para el modelado de los problemas

3.2. Relaciones entre clases

3.2.1. Abstracción y herencia
3.2.2. Conceptos avanzados de herencia
3.2.3. Polimorfismo
3.2.4. Composición y agregación

3.3. Introducción a los patrones de diseño para problemas orientados a objetos

3.3.1. ¿Qué son los patrones de diseño?
3.3.2. Patrón Factory
3.3.3. Patrón Singleton
3.3.4. Patrón Observer
3.3.5. Patrón Composite

3.4. Excepciones

3.4.1. ¿Qué son las excepciones?
3.4.2. Captura y gestión de excepciones
3.4.3. Lanzamiento de excepciones
3.4.4. Creación de excepciones

3.5. Interfaces de usuarios

3.5.1. Introducción a Qt
3.5.2. Posicionamiento
3.5.3. ¿Qué son los eventos?
3.5.4. Eventos: definición y captura
3.5.5. Desarrollo de interfaces de usuario

3.6. Introducción a la programación concurrente

3.6.1. Introducción a la programación concurrente
3.6.2. El concepto de proceso e hilo
3.6.3. Interacción entre procesos o hilos
3.6.4. Los hilos en C++
3.6.5. Ventajas e inconvenientes de la programación concurrente

3.7. Gestión de hilos y sincronización

3.7.1. Ciclo de vida de un hilo
3.7.2. La clase Thread
3.7.3. Planificación de hilos
3.7.4. Grupos hilos
3.7.5. Hilos de tipo demonio
3.7.6. Sincronización
3.7.7. Mecanismos de bloqueo
3.7.8. Mecanismos de comunicación
3.7.9. Monitores

3.8. Problemas comunes dentro de la programación concurrente

3.8.1. El problema de los productores consumidores
3.8.2. El problema de los lectores y escritores
3.8.3. El problema de la cena de los filósofos

3.9. Documentación y pruebas de software

3.9.1. ¿Por qué es importante documentar el software?
3.9.2. Documentación de diseño
3.9.3. Uso de herramientas para la documentación

3.10. Pruebas de software

3.10.1. Introducción a las pruebas del software
3.10.2. Tipos de pruebas
3.10.3. Prueba de unidad
3.10.4. Prueba de integración
3.10.5. Prueba de validación
3.10.6. Prueba del sistema

Módulo 4. Consolas y dispositivos para videojuegos

4.1. Historia de la programación en videojuegos

4.1.1. Periodo Atari (1977-1985)
4.1.2. Periodo NES y SNES (1985-1995)
4.1.3. Periodo PlayStation / PlayStation 2 (1995-2005)
4.1.4. Periodo Xbox 360, PS3 y Wii (2005-2013)
4.1.5. Periodo Xbox One, PS4 y Wii U–Switch (2013-actualidad)
4.1.6. El futuro

4.2. Historia de la jugabilidad en videojuegos

4.2.1. Introducción
4.2.2. Contexto social
4.2.3. Diagrama estructural
4.2.4. Futuro

4.3. Adaptación a los tiempos modernos

4.3.1. Juegos basados en movimiento
4.3.2. Realidad virtual
4.3.3. Realidad aumentada
4.3.4. Realidad mixta

4.4. Unity: Scripting I y ejemplos

4.4.1. ¿Qué es un Script?
4.4.2. Nuestro primer Script
4.4.3. Añadiendo un Script
4.4.4. Abriendo un Script
4.4.5. MonoBehaviour
4.4.6. Debugging

4.5. Unity: Scripting II y ejemplos

4.5.1. Entrada de teclado y ratón
4.5.2. Raycast
4.5.3. Instanciación
4.5.4. Variables
4.5.5. Variables públicas y serializadas

4.6. Unity: Scripting III y ejemplos

4.6.1. Obteniendo componentes
4.6.2. Modificando componentes
4.6.3. Testeo
4.6.4. Múltiples objetos
4.6.5. Colliders y triggers
4.6.6. Cuaterniones

4.7. Periféricos

4.7.1. Evolución y clasificación
4.7.2. Periféricos e interfaces
4.7.3. Periféricos actuales
4.7.4. Futuro próximo

4.8. Videojuegos: perspectivas futuras

4.8.1. Juego basado en la nube
4.8.2. Ausencia de controladores
4.8.3. Realidad inmersiva
4.8.4. Otras alternativas

4.9. Arquitectura

4.9.1. Necesidades especiales de los videojuegos
4.9.2. Evolución de la arquitectura
4.9.3. Arquitectura actual
4.9.4. Diferencias entre arquitecturas

4.10. Kits de desarrollo y su evolución

4.10.1. Introducción
4.10.2. Tercera generación de kits de desarrollo
4.10.3. Cuarta generación de kits de desarrollo
4.10.4. Quinta generación de kits de desarrollo
4.10.5. Sexta generación de kits de desarrollo