Introducción a las plataformas de desarrollo de juegos
NOMBRE DE LA ESCUELA
Director: Marcelo Lucero
ELABORACIÓN
Experto disciplinar: Javier Miles Avello
Diseñadora instruccional: Lorena Fernández Alfaro
Editora instruccional: Marjorie Balbontín Azúa
VALIDACIÓN
Experto disciplinar: Helmuth Aubel
Jefa de Diseño Instruccional: Alejandra San Juan Reyes
EQUIPO DE DESARROLLO
Didactic
AÑO
2022
2
Tabla de contenidos
Aprendizaje esperado ................................................................................................................. 4
Introducción ................................................................................................................................ 5
1. Motores de videojuegos ...................................................................................................... 6
2. Desarrollo de videojuegos 2D y 3D ................................................................................... 13
Lenguajes de programación ...................................................................................................... 19
Lenguajes de programación para el desarrollo de juegos en páginas web .............................. 21
Variables.................................................................................................................................... 26
Métodos .................................................................................................................................... 30
Herencia .................................................................................................................................... 31
Programación Orientada a Objetos (POO) ............................................................................... 34
Requerimientos computacionales para videojuegos ............................................................... 36
Redes de computadores, topologías, enrutadores, puertos .................................................... 37
Cierre ......................................................................................................................................... 42
Referencias bibliográficas ......................................................................................................... 43
3
Aprendizaje esperado
Determinan lenguajes de programación e infraestructura para el desarrollo de
videojuegos, de acuerdo con requerimientos.
4
Introducción
En este documento revisaremos los motores de videojuegos, lo que nos permitirá generar un
producto conforme a lo que requieran los usuarios, a sus necesidades de uso. Por ejemplo,
existen usuarios de videojuegos que utilizan tecnologías móviles, computador de escritorio y
navegadores web.
El término “motor de videojuego” hace referencia a librerías de programación que nos ayudan
a diseñar, crear y representar un videojuego. Dentro de los aspectos más relevantes para la
elección de un motor de videojuegos, se encuentran las capacidades gráficas que ofrece el
producto, dado que son las encargadas de “dibujar” o renderizar las imágenes 2D y 3D en la
pantalla, así como también realizar el cálculo de algunos aspectos gráficos como los polígonos,
iluminación y texturas, entre otras.
Algunas de las funcionalidades más importantes de los motores son:
El motor de física: permite aplicar una lógica de movimiento físico a los elementos e imágenes
de videojuegos para que tengan una sensación más realista en la interacción de los objetos
con el entorno.
El motor de sonido: los elementos de sonidos y la banda sonora de un videojuego son los
encargados de cargar pistas de audio, modificar su tasa de bits, quitarlas de reproducción, y
sincronizarlas, entre otras cosas.
El scripting: los motores de videojuegos poseen un lenguaje de programación que permite
implementar el funcionamiento de los personajes y objetos que forman parte del videojuego.
5
1. Motores de videojuegos
En los lenguajes de programación es posible crear videojuegos, aplicando técnicas por medio
del propio lenguaje y algoritmos. Se puede mostrar y sobreponer imágenes e incluso editar las
mismas por medio de un programa. En fin, programar todos los componentes que permiten
dar movimiento a las imágenes, y poder controlarlas por medio del lenguaje de programación.
Sin embargo, esta tarea podría ser muy laboriosa, dada la gran cantidad de código fuente que
se debe programar. Son demasiadas rutinas, para poder abrir, cerrar y mover imágenes.
Además, poder capturar las teclas que presiona el usuario, para poder dar una ubicación a las
imágenes.
En los programas que has desarrollado en cursos anteriores, te habrás dado cuenta de que
muchas de las rutinas que programaste, te podrían servir para futuros proyectos,
parametrizándolos y permitiendo así entregar un resultado al software que lo solicite. Lo
anterior, es lo que en programación denominamos Librería de métodos, procedimientos, y
clases.
Es por ello, que un motor de videojuegos es un conjunto de librerías (que alguien programó),
para que no tengas que programar ciertas funciones que permiten crear, diseñar y mostrar los
elementos de un videojuego. Por ejemplo, mostrar una secuencia de imágenes, en la pantalla,
y permitir que estas imágenes se puedan desplazar por ella, indicando el punto de la pantalla
(pixel), en donde se debe mostrar. Dicha imagen, puede ser mostrada en distintos puntos
seguidos, dando la impresión de movimiento. Posteriormente, si la imagen va descendiendo
por la pantalla, es posible que esté cayendo.
¿A qué velocidad debería caer la imagen?
Es una excelente pregunta, ya que, si realizamos una iteración por medio de un ciclo, (FOR,
WHILE), dependiendo de la velocidad de CPU que tenga tu computador, la imagen recorrerá
6
la pantalla a distintas velocidades (si hiciéramos un benchmark entre ellos). Las velocidades de
las CPU actuales son medidas en GigaHertz (GHz), por ejemplo, una CPU de 2,4 GHz, es capaz
de ejecutar 2400 millones de ciclos por segundo, y 3,2GHz por lo que recorrer una pantalla de
1024x768 en un ciclo, en una CPU de 3,2GHz tardaría menos en finalizar, que en una de 2,4GHz.
Si realizaras el cálculo, y considerando que el ojo humano ve movimiento continuo después de
los 50Hz, apenas seríamos capaces de ver el movimiento de la imagen, entonces debemos
establecer una pausa entre cada ciclo, para que la imagen vaya más lento. Para dar más
realismo a la caída de la imagen, entonces deberíamos realizar el cálculo de la velocidad,
considerando la gravedad de la tierra (o del planeta del personaje). Si bien puede sonar algo
complicado, algunos motores de videojuegos cuentan con un motor de física que realiza estos
cálculos para que podamos aplicarlo en nuestro videojuego.
Ahora que conocemos que es posible mostrar una imagen en una pantalla, por medio de un
motor de videojuegos, debemos decidir si dichas imágenes las mostraremos para representar
una figura en dos o tres dimensiones, lo cual veremos a continuación.
¿Qué motor de videojuegos debería utilizar?
Algunos de los criterios a utilizar, es que el software sea estable. Como bien sabemos todos, el
utilizar sistemas que llevan poco tiempo en el mercado, está propenso a errores, por lo cual el
utilizarlos, es un riesgo que se asume. Es mejor, utilizar software que ya ha pasado por
procesos de estabilización, para reducir los potenciales errores que podría traer. Además,
debemos considerar la fase de mantenimiento, y la periodicidad de lanzamientos de nuevos
“parches”, que son las actualizaciones del sistema, en cuanto a la solución de fallos o errores.
Otro de los aspectos relevantes a la hora de seleccionar un motor, es que la empresa aún
continúe con el proyecto. Es necesario indagar al respecto, revisando si tienen previsto
descontinuar próximamente el producto.
7
Y por último, el tema de costos es crucial al momento de elegir un motor. Algunos motores,
piden un porcentaje de las ventas al utilizar su motor, y otros exigen una licencia para poder
comercializar el producto. La sugerencia, es revisar el software libre disponible, que cumpla
con tus expectativas.
Ya habiendo conocido de qué se trata una imagen 2D/3D, para enlazar lo visto hasta el
momento, te presentamos algunos de los motores de videojuegos que existen en el mercado:
Decima Engine: es un motor de videojuegos, el cual además posee un motor de física. Permite
el desarrollo de videojuegos 2D y 3D.
Imagen 1: Logo Decima Engine
Fuente: Guerrilla (2017)
El primer juego para el que se utilizó el motor fue el videojuego de nombre Killzone: Shadow
Fall. Posteriormente, durante el mes de junio de 2015, Guerrilla Games publicó que el
videojuego Horizon: Zero Dawn, estaba usando el motor para el desarrollo del mismo. Durante
el mismo año, en el mes de agosto, se publica que el videojuego Until Dawn, también utilizaría
el motor decima engine, junto con el motor de física Havok . Durante el mes de diciembre de
2015, Until Dawn: Rush of Blood también utilizó el motor, en conjunto a PlayStation VR. Hideo
Kojima (director y productor de videojuegos japonés), durante el año 2016, anunció la
preparación para el juego “indi” (Juegos independientes), llamado Death Stranding de Kojima
8
Productions , el productor anuncia que se había asociado con Guerrilla Games, utilizando el
motor para el desarrollo.
Una de las principales características del motor, es que utiliza Inteligencia artificial para una
resolución de 4K.
Frostbite Engine: Es un motor de videojuegos diseñado para la creación en primera persona,
como por ejemplo BattleField.
Imagen 2: Logo Frostbite Engine
Fuente: Frostbite (s.f.)
El Frostbite 3 fue el motor de Digital Illusions CE para ser desarrollado en las consolas de
generación PlayStation 4 y Xbox One. Sin embargo, según las empresas EA (Electronics Arts) y
DICE (Digital Illusion CS), no era compatible con las consolas Wii U. Actualmente, sigue siendo
utilizado para la nueva generación de consolas PlayStation 5, Xbox Series X y Series S y
Nintendo Switch.
Dentro de las cualidades del videojuego “BattleField 4”, se aprovechó el 80% de la capacidad
del motor gráfico. Para el videojuego Battlefield 3, solamente se usaba un 30% de la capacidad
del motor.
Otra de las características que se explota del motor, son los efectos climáticos con dinámica
en tiempo real como por ejemplo lluvia, nieve, tormentas de arena, niebla, entre otros.
Además, el motor permite la utilización de nuevas tecnologías de teselado "Tessellation
Technology", la cual consiste en una partición del plano mediante polígonos idénticos, o a un
9
polígono o grupo de polígonos idénticos que convenientemente agrupados recubren
enteramente el plano.
Luminous Engine: este motor de videojuegos es multiplataforma, en el cual se desarrolló el
videojuego Final Fantasy.
Imagen 3: Logo Luminous Engine
Fuente: Luminous Productions (s.f.)
El desarrollo del motor Luminous fue similar a los conceptos utilizados en el motor Unreal
Engine de Epic Games, y también en el motor Unity de Unity Technologies, en el cual
incorporan todas las herramientas de desarrollo necesarias, abordando la fase de edición de
los recursos, simplicidad en el uso, alta velocidad en el proceso de compilación, una
herramienta compacta, y con soporte de metodología de desarrollo de videojuegos. Para este
concepto y enfoque, el equipo de desarrollo se inspiró en Unreal Engine de Epic Games y
CryEngine de Crytek. El nombre "Luminous" fue elegido para representar el tema del cristal
que está presente a lo largo de la serie Final Fantasy.
PyGame: Es un motor de videojuegos para ser utilizado con Python, orientado al manejo de
sprites.
10
Imagen 4: Logo PyGame
Fuente: PyGame.org
Pygame es un módulo para Python, el cual viene instalado por defecto en la versión de
Raspbian para Raspberry Pi. De todas maneras, es posible instalar este módulo en cualquier
otro sistema operativo, dada su característica de multiplataforma. Mediante esta librería,
permite la creación de videojuegos en dos dimensiones de una manera fácil y sencilla. Además,
este módulo o librería permite la utilización de sprites (objetos), y permite cargar y mostrar
imágenes en diferentes formatos, efectos de sonidos, etc. La programación de captura de
eventos de teclado, mouse o joystick, es muy sencillo de utilizar.
Unity: Motor de videojuegos multiplataforma, que utiliza WebGL para la renderización de
gráficos 3D en los navegadores.
Imagen 5: Logo Unity
Fuente: Unity (s.f.)
Una de las principales ventajas de Unity es la versatilidad, en el sentido que permite combinar
entornos en diferentes dimensiones, lo que posibilita el desarrollo de todo tipo de juegos,
como lo son las aventuras gráficas, juegos de rol o shooters en primera y tercera persona.
Comparado con otros motores similares, como Unreal Engine 4, CryENGINE V o Game Make,
en los últimos la integración de escenarios y proyectos en dos dimensiones son más complejos,
ya que los competidores están diseñados específicamente para juegos 3D. Unity permite
combinar proyectos tanto en 2D como en 3D, y es por ello que los desarrolladores utilizan este
motor. Además, por medio del motor Unity, permite realizar complicación de proyectos en
11
más de 25 plataformas, como por ejemplo dispositivos móviles, equipos de escritorio, consolas
de videojuegos, aplicaciones para televisión, web y VR (Virtual Reality). Es por ello que
fabricantes como Apple, Google, Sony, Gear VR, Microsoft y Nintendo lo eligen para muchos
de sus productos y juegos.
Unreal Engine: Motor de videojuegos creado por la empresa Epic Games, programado en C++.
Actualmente, está disponible la versión 5, siendo compatible con las consolas PS5 de Sony y
Xbox X/S de Microsoft. Algunas de las empresas que utilizan este motor, son Electronic Arts y
Ubisoft.
Imagen 6: Logo Unreal Engine
Fuente: Unreal Engine (s.f.)
Unreal Engine es uno de los motores de videojuegos muy utilizado por los usuarios y por las
compañías. Su funcionamiento se basa en código C++. Este motor de videojuegos, ofrece las
herramientas necesarias para el desarrollo tanto como de videojuegos, como de simulación.
Además, este motor es posible utilizar como herramienta de editor de vídeo, estudio de
sonido, código o renderización de animaciones, entre otras formas de trabajo más que se
pueden desarrollar con este software.
Dentro de los usos que se ha dado a este motor, están las áreas de arquitectura, como para
realizar visitas virtuales en construcciones piloto, ingeniería para la simulación de
movimientos, medicina, realidad virtual, desarrolladores de aplicaciones, etc. Incluso, NASA
utiliza este motor para el entrenamiento de astronautas.
En definitiva, para la selección de un motor de videojuegos, debemos considerar la historia del
motor, para que podamos obtener las actualizaciones y soporte necesario de la herramienta.
Si utilizamos un motor muy actual, es posible que presente fallas o errores en nuestro producto
12
final. Además, debemos considerar la cantidad de herramientas disponibles para su uso, como
por ejemplo que permita realizar integración de tecnologías, como por ejemplo editores de
video y audio.
2. Desarrollo de videojuegos 2D y 3D
Los gráficos en dos dimensiones (2D), utilizan los ejes X e Y como un plano cartesiano,
lo cual, en una imagen, se representa como largo y ancho.
Imagen 7: Emoji 2D de Microsoft Word
Fuente: Microsoft Office
Un gráfico en tres dimensiones (3D) es una imagen 2D, que permite por medio de
perspectivas, poder visualizar dicha imagen con un volumen, al utilizar los ejes X,Y y Z.
13
Imagen 8: Emoji 3D de Microsoft Word
Fuente: Microsoft Office
Por medio de las imágenes 3D nos permite nuestra visión permite realizar una
estimación del tamaño de un objeto y la distancia de otro. Si la otra imagen es más
pequeña, entonces nos dará la sensación de profundidad, dada nuestra la capacidad de
percibir la perspectiva.
Imagen 9: Generación de Perspectiva
14
Fuente: Microsoft Office
En la imagen anterior, se puede apreciar el efecto de perspectiva que nuestro cerebro
es capaz de interpretar, pero si descompones las imágenes, verás que una es más
pequeña que la otra, y dos líneas oblicuas.
Imagen 10: Descomposición de imágenes de figura en perspectiva.
Fuente: Microsoft Office
Imagen 11: Esculturas de Moai, Isla de Pascua, Chile.
15
Fuente: Microsoft Office
Imagen 12: pintura sobre un lienzo
Fuente: Microsoft Office
Entre las dos figuras anteriores, se puede apreciar claramente la diferencia entre una
obra en 2D y 3D ¿Cuál de las dos es más complicada?
16
La respuesta a la pregunta anterior, la has podido deducir tú mismo. La misma regla
aplica para el desarrollo de videojuegos 2D y 3D. Al momento de generar un videojuego
en tres dimensiones, requiere mucho más trabajo, ya que son más variables que
debemos utilizar. Los algoritmos de programación, a su vez, son más complejos de
implementar, e incluso el tratamiento de imágenes para dar un efecto en tres
dimensiones, es más laborioso.
Ámbito a considerar 2D 3D
Costo de Producción Moderado Alto
Costo Preproducción Moderado Alto
Costo Postproducción Moderado Alto
Calidad de Animación Moderado Alto
Requerimientos de Bajo Alto
Consolas o dispositivos
Calidad visual (*) Moderado Alto
Dificultad de uso del Bajo Alto
videojuego (**)
17
Movimientos del jugador Plano Mundo
Conocimientos técnicos de Bajo Alto
desarrollo
(*) Existen videojuegos 2D en alta definición, sin embargo, la calidad de 3D sigue siendo
superior.
(**) Normalmente en los videojuegos 3D, se utilizan mandos.
Tabla 1: Comparación motor 2D y 3D, para seleccionar uno de ellos.
Fuente: Elaboración Propia
18
3. Lenguajes de programación
Existen diversos lenguajes de programación, unos más antiguos que otros, sin embargo,
en todos ellos es posible programar un videojuego. Por ejemplo, en un lenguaje que no
está orientado a lo visual, es posible crear un videojuego por medio de trivias,
seleccionando una tecla como alternativa (un cuestionario).
Lenguaje de Máquina: es un lenguaje binario que se ejecuta directamente en la CPU,
representados por ceros y unos (0/1), el cual representa una variación de voltaje, en
electrónica.
Lenguaje Ensamblador: este lenguaje es definido como un lenguaje de “bajo nivel” o
de primera generación, cuyas instrucciones tienen un control directo sobre el
hardware. Las instrucciones escritas sobre un editor de texto requieren de un
compilador para poder ser ejecutadas.
Lenguajes de Medio Nivel: permiten la utilización de funciones aritméticas del chipset,
pero tiene una gran dependencia lógica de ensambladores para su ejecución. Este tipo
de lenguajes está orientado a la generación de rutinas y procedimientos. Algunos de
los lenguajes de programación de medio nivel son C y Basic.
Lenguaje C: es un lenguaje de programación creado por Laboratorios Bell (Bell
Labs) entre los años 1969 y 1972, el cual es el sucesor del lenguaje B (de la misma
empresa). Este lenguaje de programación permitió el desarrollo de sistemas
operativos, como Unix.
19
Lenguaje Basic: es un lenguaje de programación de medio nivel, siendo
introducida en computadores del hogar como el Atari 800XL, a principios de
1980.
Lenguajes de Alto Nivel: este tipo de lenguajes se caracteriza por la capacidad de
interpretar los algoritmos en relación con la forma en que pensamos los humanos y sin
depender de cómo lo ejecutará la máquina. En definitiva, es la abstracción del lenguaje
de máquina, a diferencia de los lenguajes de bajo nivel, en que la programación se
realiza por medio de los registros que se almacenan en la memoria RAM. Este tipo de
lenguajes de programación pueden ser:
Compilados: requieren de un proceso de transformación desde un código fuente
a un ejecutable (binario), por medio de un programa llamado compilador.
Interpretados: posee un programa que interpreta el código fuente para ejecutar
el programa (es decir, un software que ejecuta software).
Algunos lenguajes de alto nivel son:
• Java: lenguaje desarrollado por Sun Microsystem que utiliza una máquina virtual
(JRE) para ser ejecutada.
• PHP: lenguaje de programación interpretado que es utilizado mayormente en
ambiente web.
• Python: lenguaje interpretado de código abierto, utilizado principalmente para
ciencia de datos, que sin embargo se utiliza para una variedad de aplicaciones
(incluyendo videojuegos).
• JavaScript: lenguaje de programación principalmente desarrollado para la
ejecución de rutinas en los navegadores del cliente. Sin embargo, dado su
potencial, es posible convertirlo en un servidor, como nodeJS.
• C#: es un lenguaje de programación multiparadigma, estandarizado por
Microsoft, cuya sintaxis deriva de los lenguajes C/C++.
20
3.1. Lenguajes de programación para el desarrollo de
juegos en páginas web
Como hemos mencionado previamente, existen muchos lenguajes, pero en este
apartado nos enfocaremos solamente a las páginas web.
Uno de los principales conceptos de la web son los documentos HTML, los que permiten
aplicar etiquetas a los textos y objetos para que un navegador los pueda renderizar y el
usuario visualice dichos textos/objetos. Se trata de elementos como: negrita, cursiva y
subrayados, por ejemplo, por medio de los códigos <b>Negrita</b>, <i>Cursiva</i> y
<u>Subrayados</u>, respectivamente (etiquetas no orientadas a la web semántica).
También existen códigos para agregar imágenes a la web, como por ejemplo el archivo
html, que contiene la etiqueta <img src=”laimagen.jpg” />, que mostrará una imagen
en la pantalla (el archivo laimagen.jpg debe estar en el mismo directorio que el
documento html).
Además, existe una etiqueta llamada <canvas></canvas>, que permite agregar
elementos gráficos como textos y gráficos a la web, el cual todo desarrollador de
videojuegos en páginas web, debería conocer.
Para poder introducirse al desarrollo de videojuegos en páginas web, es recomendable
comprender cómo funciona.
A continuación te brindamos un ejemplo: presentamos los pasos para utilizar las
herramientas que nos provee el navegador.
1. Usando el siguiente código puedes insertar un elemento Canvas en una página
html, asignando una dimensión para el elemento:
21
<!DOCTYPE html>
<html lang="es">
<head><title>Ejemplo</title></head>
<body>
<canvas id="micanvas" width="250" height="250">
<img id="laimagen" alt="" />
</canvas>
<script>
window.onload = function(){
var imagen = new Image();
imagen.src = "./laimagen.jpg";
// Esperará a que la imagen se cargue.
imagen.onload = function () {
//Agrega la imagen cargada al canvas.
var elcanvas = document.getElementById("micanvas");
var ctx = elcanvas.getContext("2d");
ctx.drawImage(imagen,0,0);
}
}
</script>
</body>
</html>
Javascript: en el código anterior se agrega un lenguaje de programación que el
navegador web es capaz de interpretar, llamado javascript, el que por medio de sus
etiquetas <script></script> se podrá ejecutar en el navegador web.
2. Abre el editor de imágenes ms Paint, y crea una imagen con las herramientas del
programa, como demuestra la siguiente imagen (procura que las dimensiones
sean de 150x150 en las propiedades del archivo):
22
Imagen 1: Imagen creada con MSPAINT
Fuente: Elaboración Propia
3. A continuación, crea un archivo por medio de bloc de notas de tu computador
con el código HTML presentado previamente, y guarda el archivo en un
directorio de tu computador, con la extensión html, y luego ábrela con un
navegador web.
23
Imagen 2: Creación de un archivo HTML
Fuente: Elaboración Propia
NOTA: Procura seleccionar el tipo desde *.txt a “Todos los Archivos (*.*)”, como indica
la imagen anterior.
El resultado será el siguiente:
24
Imagen 3: Resultado del código HTML con Javascript
Fuente: Elaboración Propia
Dentro de la carga de imágenes, también puedes dibujar formas, como líneas,
circunferencias, rectángulos, etc.
El siguiente ejemplo, agrega líneas a la etiqueta canvas, generando un triángulo sobre
la imagen. Insértalo dentro de la función imagen.onload.
for(i=0;i<150;i++){
ctx.moveTo(0, 0);
ctx.lineTo(150, i);
ctx.stroke();
}
25
Con lo anteriormente visto, ya puedes crear una secuencia de imágenes dentro de la
etiqueta canvas, con un algoritmo que tú puedes crear, dependiendo de las
necesidades.
3.2. Variables
Las variables dentro de los lenguajes de programación son elementos que permiten
almacenar datos, para posteriormente utilizarlos durante el programa que estemos
creando.
Estos lenguajes se pueden clasificar en:
Datos Fuertemente Tipados: significa que su valor no cambiará de manera
repentina. Si una variable es una cadena de caracteres como por ejemplo: “123”, no es
lo mismo que el número 123. Pueden ser de tipado estático o dinámico.
Para los tipos estáticos, la declaración de variables debe especificar el tipo de dato que
se almacenará, para mantener la integridad del dato, al reservar la cantidad específica
de espacio en la memoria RAM. Los tipos dinámicos se caracterizan por no asignar un
tipo de dato específico a las variables, de manera que se asignará una cantidad de
memoria RAM de manera dinámica.
A continuación, listamos algunos lenguajes de programación correspondiente a la
clasificación como fuertemente tipados:
• C#
• Java
• C++
• GO
• Rust
26
• Python
• Pascal
- Datos débilmente tipados: no se controla el tipo de variable que recibe,
pudiendo ser caracteres, decimales, enteros, entre otros. Algunos ejemplos de estos
lenguajes son:
• Lisp
• Perl
• PHP
• Prolog
• Basic
• JavaScript
Para el caso de JavaScript, se puede almacenar los datos sin necesidad de especificar
su tipo (tipado dinámico), como por ejemplo:
i=0
z=”2123”
y=0.123
Sin embargo, para otros lenguajes como C#, es necesario especificar su tipo, como por
ejemplo:
string nombre = “Javier”;
int edad = 12;
float estatura = 1.60;
Tipos de Dato en C#
Tipos de dato primitivo
27
Un tipo de dato primitivo es aquel que viene inserto en el lenguaje (no se necesita
librerías adicionales para utilizarlo).
RECORDAR: cada declaración de variable asume un almacenamiento en RAM (utiliza
espacio). Al momento de declarar una variable, entonces se reserva el espacio
necesario en la memoria.
Tipo Tamaño Rango
bool 1 bit 0 o 1 / true - false
byte 8 bits 28 =256 -> 0-255
char 16 bits U+0000 – u+ffff
decimal 128 bits +-
double 64 bits +-
float 32 bits +-
nt 32 bits (positivos y negativos) -
22147483648 -
+2147483647
28
long 64 bits +-
sbyte 8 bits -128 -> +127
short 16 bits +- -32768 -> + 32767
ushort 16 bits Positivos 0 - 65535
ulong 64 bits positivos
uint 32 bits positivos
Figura 16: Tabla de variables en C#
Fuente: Elaboración Propia
Tipos de dato No Primitivos
Son aquellos que requiere de una clase, por lo tanto se crea un objeto del tipo… por
consiguiente, se puede utilizar los métodos que estén disponibles en la clase. Ej:
.toString(), y comienzan con una mayúscula, dentro del espacio de nombres System.
29
3.3. Métodos
Los métodos son “funciones o rutinas” que contienen las clases. Son un conjunto de
instrucciones agrupadas en bloque, las cuales contienen un nombre para ser llamados.
Por ejemplo: sumar, restar, dividir y multiplicar.
Este conjunto de instrucciones que tienen un nombre, pueden recibir parámetros
dentro de paréntesis, y ser almacenado los valores (que le entreguen al método), en
variables, llamadas parámetros de entrada. De los ejemplos anteriores, quedaría de la
siguiente manera: sumar(int a, int b), restar(),dividir() y multiplicar(),.
Posteriormente, se debe incluir el cuerpo de cada método, el cual contendrá las
instrucciones que realizará, declarando el cuerpo del método, por medio de los
paréntesis curvos (paréntesis de llave).
sumar(int a, int b){
int c = a + b;
}
Y por último, se debe especificar el tipo de retorno que tendrá cada método (anets del
nombre del método). Si no devuelve un resultado, entonces será void, quedando de la
siguiente manera:
void sumar(int a, int b){
int c = a + b;
}
int restar(int a, int b){
return a + b;
}
30
3.4. Herencia
Cuando hablamos de herencia, es muy similar a lo que ocurre con los genes. Los hijos
heredan características de los padres, por medio de dichos genes. En lenguaje de
programación, las clases que son la abstracción de los objetos, permite ir heredando
entre clases, las características.
Para definir una clase, debemos fijarnos en las características que tienen los objetos, y
no en su valor. La definición de una clase, se realiza por medio de la palabra reservada
class, seguido del nombre de la clase, de manera que sea descriptivo. Ejemplo de clase:
class Vehiculo{
//ACÁ VAN LOS ATRIBUTOS (VARIABLES) Y MÉTODOS (FUNCIONES)
}
Posteriormente, debemos fijarnos en las características que tienen todos los vehículos,
por ejemplo, la distancia recorrida, la velocidad y la ubicación. Un ejemplo de atributos
de la clase, sería:
class Vehiculo{
int velocidad=0; //Velocidad del vehículo
int distancia = 0; // Distancia Recorrida
float ubicacionLat = 0; //Latitud GPS
float ubicacionLon=0; //Longitud GPS
31
Para acceder a dichos atributos, se puede definir métodos de acceso, llamados GETTERS
para obtener un valor, y SETTERS, para asignar un valor. No son más que métodos que
retornan o asignan sus valores. Ejemplo para el atributo velocidad, sería:
class Vehiculo{
int velocidad=0; //Velocidad del vehículo
int distancia = 0; // Distancia Recorrida
float ubicacionLat = 0; //Latitud GPS
float ubicacionLon=0; //Longitud GPS
public int getVelocidad(){
return velocidad;
public void setVelocidad( int vel){
this.velocidad = vel;
En C#, para crear nuevas clases que hereden de esta, se realiza por medio del caracter
“:”, quedando de la siguiente manera:
class Automovil : Vehiculo {
int ruedas = 4;
32
Class Avion : Vehiculo {
int motores = 2;
Entonces, Avión y Automóvil, tendrán las mismas características heredadas de la clase
Vehículo, aplicando la herencia.
33
3.5. Programación Orientada a Objetos (POO)
La programación orientada a objetos es un paradigma de programación que organiza
el desarrollo de un sistema, segmentándolo en clases, atributos y métodos,
permitiendo la reutilización de funcionalidades, por medio de la creación de objetos (la
clase realizada, en donde se podrá asignar valores), y la invocación de sus
funcionalidades.
Del ejemplo anterior, en donde se ha aplicado la herencia, se puede crear un objeto de
cada uno de ellos, creando “una variable” de la clase que se desee construir.
Por ejemplo:
Vehiculo unVehiculo = new Vehiculo();
Automovil unAutomovil = new Automovil();
Avion unAvion = new Avion();
Del ejemplo anterior, se ha creado tres objetos, llamados unVehiculo, unAutomovil y
unAvion. Los tres objetos, son independientes entre sí, y son capaces de almacenar sus
propios valores en los atributos, de manera independiente unos de otros.
Se almacenan en espacios de memoria distintos e individuales, quedando de la
siguiente manera:
34
Imagen 4: representación de objetos en memoria RAM
Fuente: Elaboración Propia
35
4. Requerimientos computacionales para
videojuegos
Para crear un videojuego, es necesario contar con un computador con sistema
operativo. Dependiendo del motor que se vaya a utilizar, cada uno de ellos requiere de
un mínimo. Sin embargo, es necesario considerar muchos elementos más, como por
ejemplo la calidad de las imágenes a renderizar. No es lo mismo renderizar una imagen
2D que una en 3D, y también debemos considerar la lógica del juego, tanto como las
reglas del juego, y las etapas de la misma. Recordemos que el desarrollo de videojuegos
es un ciclo eterno que realizará las acciones de movimiento. Si utilizaremos imágenes
en alta resolución, entonces deberíamos considerar una tarjeta gráfica que apoye en la
renderización de dichas imágenes.
De acuerdo con el motor de videojuegos Unity, los requerimientos mínimos
dependerán del proyecto que deseemos generar, y especifica como mínimo, un sistema
operativo Windows 7 de 64 bits, y una tarjeta gráfica compatible con DirectX10.
Otros motores de videojuegos tendrán otros requerimientos para su normal operación.
El mismo proveedor de motor especifica también los requerimientos con los que deben
cumplir los jugadores para ejecutar los videojuegos, para dispositivos móviles, es una
versión Android superior a 4.4, con un procesador ARM 32, o 64, los cuales son
unidades centrales de procesamiento (CPU) de bajo consumo. Además, se requiere de
1G o más en la memoria RAM (Random Access Memory)
36
4.1. Redes de computadores, topologías, enrutadores,
puertos
A la hora de programar un videojuego, debemos considerar el entorno de red sobre el
cual será ejecutado el videojuego, para el caso de programar un videojuego
multijugador o bien para transmitir los “scores” o puntajes a un servidor centralizado.
De acuerdo con el modelo OSI, el cual es un modelo de referencia para los protocolos
de red, divide la comunicación en capas, siendo:
Capa 1: es la capa física, la cual determina la topología de interconexión de los
dispositivos y las conexiones globales. Dentro de las funciones, está definir el tipo de
medio por el cual se comunicarán los dispositivos, por ejemplo: par trenzado (cable
UTP). Dependiendo de la topología que se utilice, entonces se seleccionará el tipo de
cable a utilizar, por ejemplo UTP o coaxial.
Una topología es el mapa lógico o físico de una red, para intercambiar datos entre los
dispositivos. Existen diferentes topologías, dependiendo de cómo están
interconectados entre ellos.
37
Imagen 17: Topologías de red
Fuente: Wikipedia (s.f.)
De la imagen anterior, las redes que mayormente se utilizan dentro del hogar y las
empresas, es la topología estrella, en donde cada terminal se comunica con otros, por
medio de un único dispositivo, ya sea un concentrador (o switch), o bien por medio de
un router. Normalmente, se utiliza cable UTP, para esta topología. Y, cuando es una
topología de anillo, entonces se utiliza Coaxial, normalmente.
38
Imagen 18: Dispositivo de comunicación
Fuente: Wikimedia commons (s.f.)
Capa 2: Esta capa, utiliza el direccionamiento físico de los dispositivos de comunicación,
para identificar de manera unívoca de cada equipo conectado a la red. Puedes obtener
esta información, desde un terminal, escribiendo el comando “ipconfig /all”, y visualiza
la dirección física de la tarjeta.
Capa 3: en esta capa, entran en juego los protocolos de enrutamiento, los cuales
permite conectar con otras redes (por ejemplo internet), entregando el mensaje
(llamado paquete), a un dispositivo llamado router, el cual entregará el mensaje a otro
dispositivo similar, el cual acercará el mensaje al destino. Dicho mensaje, pasará por
muchos de estos dispositivos, hasta llegar al dispositivo final. Es así como funciona
internet.
Capa 4: Es la encargada de entregar los mensajes libre de errores, agregando cálculos
de comprobación.
Capa 5: Encargada de controlar el enlace establecido entre dos dispositivos,
asegurando que la sesión entre ellos se mantenga.
39
Capa 6: El objetivo, es presentar los datos, en donde establece el contenido de la
comunicación, por ejemplo la cantidad de bits transmitidos (ejemplo: bloques de 16,
32 o 64 bits etc.). De esa manera, ambos dispositivos serán capaces de representar los
datos transmitidos.
Capa 7: Define los protocolos que utilizan las aplicaciones para intercambiar los datos
(SMTP, FTP, HTTP, etc).
Finalmente, para poder establecer una comunicación entre dos dispositivos, es
necesario:
Contar con el protocolo TCP/IP en los dispositivos.
Contar con una dirección IP, el cual consta de 32 bits, y dividido en 4 octetos, nos dará
cuatro números entre 0 y 255, el cual identificará un equipo dentro de la red. Ejemplo:
192.168.1.22
Además, es necesario abrir un puerto de comunicación, para poder transmitir/recibir
los datos desde o hacia un servidor.
Ejemplo: Abre un terminal, y escribe el comando “netstat -a”, el cual entregará el
siguiente resultado:
40
Imagen 19: Ejemplo de netstat
Fuente: Elaboración Propia
Entonces, para poder crear un videojuego multijugador, debemos contar con un
servidor en la nube, que reciba los datos de la posición del jugador, y dicho servidor
replicará la información a los otros jugadores que estén conectados al mismo server.
41
Cierre
En el siguiente mapa conceptual podemos identificar los contenidos aprendidos en esta
lección, y que representan las ideas clave de la semana, como se indican en la demarcación de
color.
Podemos concluir que existen diversos lenguajes de programación y en todos ellos podemos
desarrollar un videojuego. Sin embargo, cada uno de ellos cuenta con diferentes
características, por lo cual, dependiendo de los requerimientos, seleccionaremos uno u otro.
Para facilitar el desarrollo podemos hacer uso de un motor de videojuegos, el cual posee
funciones que podemos reutilizar para cargar imágenes y renderizarlas, capturar los eventos
de teclado, etc.
42
Referencias bibliográficas
Villa, D., Pérez, S., & Moya, F. (2015). Desarrollo de Videojuegos. Un enfoque práctico.:
Volumen 3. Técnicas Avanzadas (Volume 3) (Spanish Edition) (4th ed.). CreateSpace
Independent Publishing Platform.
43
