[Guía] Qué es un FGD?

El FGD, Forge Game Data o también Game Definition File, es un archivo donde está almacenado los datos que hace "referencia" a una entidad. Esto significa que en el FGD no está almacenado las entidades, por lo tanto, no se podrán crear ni modificar entidades con ésta. Todas las entidades están definidas en las librerías (.dll) del juego. El FGD trabaja con el Valve Hammer Editor facilitando las propiedades de cada entidad para poder trabajar más cómodamente (Es una especie de API).
Le iré explicando lentamente, al final les responderé directamente las preguntas planteadas.

Qué es?
Aclaración: Esta explicación es para tener más o menos una idea cómo es que funciona y para qué sirve un FGD. No todas las informaciones escritas en esta explicación es exacta o funciona exactamente como está. Las operaciones son mucho mas complejas.

El Juego trabaja siempre constantemente con la librería (.dll) donde está almacenado todo tipo de información; desde armas, fuerzas de las balas, vida, cámara en el juego, renderización, sistema de juego, etc... Casi todo. Y las entidades también se encuentran definidas ahí, en esa librería. Por lo tanto cuando mientras jugamos un mapa, el juego busca las entidades y lee o copia las informaciones necesarias. Sería más o menos así:
Entonces, cómo y cuando se utiliza el FGD? Para entender necesitamos entender ciertas cosas.
Cuando creamos un mapa, utilizamos programas como Valve Hammer Editor u otros editores. Al configurar estos programas nos piden los archivos FGD, pero podemos ignorar esa opción. Aquí podemos entender que el FGD tiene relación con Editor de mapas.
Ahora, los juegos no necesitan el FGD; como por ejemplo el Half-Life, normalmente no encontramos ningún archivo FGD dentro de la carpeta “valve. O sea, el FGD no es necesario para jugar.
Así que podemos deducir y concluir lo siguiente:
* El FGD es necesario pero no obligatorio en Editor de mapas.
* El FGD no es necesario en los Juegos.

Al agregar el FGD al Editor de mapa, tenemos las entidades cargadas para comenzar a crear mapas. Y… las entidades están en FGD? La respuesta es NO porque en FGD está simplemente la “Lista” de entidades PERO las entidades originales siguen en la Librería del juego.
Entonces, para qué sirve el FGD? Para saber eso debemos conocer que tipo de información contiene. No es así?
El FGD, además de estar alistado las entidades, tiene anotado las propiedades para cada entidad. Hay una propiedad para la entidad light, func_wall, func_ladder, info_player_start, etc.
Como por ejemplo, una entidad func_wall puede poseer las siguientes propiedades (Observemos “Nombres Originales” y “Interfaz”):
Y acá una pregunta. Cual es más fácil de entender? La “Nombres Originales” o la “Interfaz”? La respuesta creo que es obvia. La de “Interfaz”. Es como si fuera que el “Interfaz” traduce o tiene una función como una etiqueta para los “Nombres Originales” ya que los “Nombres Originales” es un poco más difícil de entender.
Los “Nombres Originales” están cumpliendo las normas de programación pero resulta un poco difícil de entender. Así que la “Interfaz” nos facilita. Esta es la base del API (Interfaz de programación de aplicaciones)

El “Nombre Original” que es el más complicado, es utilizado en el juego. Esos nombres ya están definidos en la librería, así que solamente se pueden usar los “Nombres Originales” en el mapa para que funcione.

En un Editor de mapas, cuando entramos en las propiedades de las entidades, simplemente usamos el “Interfaz” ya que es más fácil (Pero también es posible utilizar el “Nombre Original”). Estos nombres, en Valve Hammer Editor nos aparecen como “SmartEdit” (que sería el “Interfaz”). Si desactivamos el “SmartEdit” entramos en modo “Nombre Original”
(Estos términos como “Nombre Original” o “Interfaz” son inventadas por mí. Así que puede llegar a ser un poco inapropiado. Disculpas.)

El Usuario (o sea, Usted) crea mapas con Editor de mapas. Al entrar en propiedades de la entidad courre lo siguiente: el Editor de mapas lee el archivo FGD y ofrece al Usuario el SmartEdit (Interfaz). Este proceso ocurre cuando hacemos clic derecho sobre la entidad, entramos en propiedades y nos sale una ventana.

Cuando se guarda, lee los “Nombres Originales” ya que esos son los que funcionan.

Así es. FGD es solamente un Interfaz que ayuda al Usuario facilitándole varias operaciones como estas. Tiene como función de renombrar y ordenar detalladamente las distintas entidades que existen en el Juego.

Ojala que se haya entendido con imágenes y todo.
Entonces, cómo y cuando se utiliza el FGD?
El FGD Solamente se utiliza en la edición de mapas cuando quiere editar alguna propiedad de la entidad.
Las entidades están en FGD?
NO porque FGD es una simple “Lista” de entidades. Las entidades originales se encuentran en la Librería del juego.
Aquí van las Conclusiones:
* El FGD es necesario pero no obligatorio en Editor de mapas.
* El FGD no es necesario en los Juegos.
* El FGD para facilitar el uso de las entidades
* El FGD tiene como función de etiquetar y clasificar propiedades de entidades
* El FGD no es Indispensable



Sintaxis
Dentro del FGD, la doble barra "//" indica que es un comentario. Todo lo que viene después de esa barra y que esté en la misma línea, el Valve Hammer Editor no tomará en cuenta o simplemente ignorará.
 

// Esto es un comentario
// El Valve Hammer Editor no reconocerá todos lo que están escrito con la "Doble Barra" al comienzo.

@clase base() color() iconsprite() size() studio() = nombre_de_entidad : "Etiqueta"
[
    propiedad1(tipo) : "etiqueta" : valor_por_defecto
    propiedad2(tipo) : "etiqueta" : valor_por_defecto
    propiedad3(tipo) : "etiqueta" : valor_por_defecto
        .
        .
        .
    propiedadn(tipo) : "etiqueta" : valor_por_defecto
] 

 

 

 

Clase (@clase)
Indica la clase de entidad y se escribe al comienzo de la entidad. Hay 3 diferentes clases:

@PointClass - (también llamado point entity) Es una entidad que es un "punto" situado en algún lugar del plano carteciano. En Valve Hammer Editor es posible ver en diferentes tamaños, colores, (Fig01; a,b,d) o en sprites (Fig01; c). Para crear un point entity en Valve Hammer Editor apretamos el botón "Entity Tool" o simplemente presionamos las teclas [Ctrl]+[E] y damos click a un lugar deseado.

@SolidClass - (también llamado solid entity o brush entity) Es una entidad que tiene un área que es definido por un sólido que es adjuntado. En el Valve Hammer Editor aplicamos el solid entity en escaleras (Fig02; a), agua (Fig02; b) o en trigger (Fig02; c). Podemos aplicar una entidad a un sólido haciendo Click Derecho sobre el sólido seleccionado y elegir "Tie to Entity" o sino simplemente presionamos las teclas [Ctrl]+[T].

@BaseClass - Es una estructura de propiedades que es utilizado para adjuntar con otras entidades. Este BaseClass es actúa con base(). La BaseClass no debe aparecer y no aparecerá en la lista de entidades en Valve Hammer Editor.

Un ejemplo sencillo:

 

// Definimos un BaseClass que tiene una lista de RenderFX 
// con un nombre "RenderFxChoices"

@BaseClass = RenderFxChoices
[
    renderfx(choices) :"Render FX" : 0 =
    [
        0: "Normal"
        1: "Slow Pulse"
        2: "Fast Pulse"
        3: "Slow Wide Pulse"
        4: "Fast Wide Pulse"
        9: "Slow Strobe"
        10: "Fast Strobe"
        11: "Faster Strobe"
        12: "Slow Flicker"
        13: "Fast Flicker"
        5: "Slow Fade Away"
        6: "Fast Fade Away"
        7: "Slow Become Solid"
        8: "Fast Become Solid"
        14: "Constant Glow"
        15: "Distort"
        16: "Hologram (Distort + fade)"
    ]
]

//Definimos un PointClass incluyendo una base "RenderFxChoices"
@SolidClass base(RenderFxChoices) = func_breakable
[
    material(choices) :"Material type" : 0 =
    [
        0: "Glass"
        1: "Wood"
        2: "Metal"
        3: "Flesh"
        4: "Cinder Block"  
        5: "Ceiling Tile"
        6: "Computer"
        7: "Unbreakable Glass"
        8: "Rocks"
    ]
] 

 

  

Como resultado se adjuntarán las dos propiedades de las entidades; el func_breakable tendrá sus propiedades y también tendrá incluido la base "RenderFxChoices".

 

// Ahora Como resultado, un Solid Class func_breakable con propiedad de RenderFxChoices
@SolidClass = func_breakable
[
    renderfx(choices) :"Render FX" : 0 =
    [
        0: "Normal"
        1: "Slow Pulse"
        2: "Fast Pulse"
        3: "Slow Wide Pulse"
        4: "Fast Wide Pulse"
        9: "Slow Strobe"
        10: "Fast Strobe"
        11: "Faster Strobe"
        12: "Slow Flicker"
        13: "Fast Flicker"
        5: "Slow Fade Away"
        6: "Fast Fade Away"
        7: "Slow Become Solid"
        8: "Fast Become Solid"
        14: "Constant Glow"
        15: "Distort"
        16: "Hologram (Distort + fade)"
    ]
    material(choices) :"Material type" : 0 =
    [
        0: "Glass"
        1: "Wood"
        2: "Metal"
        3: "Flesh"
        4: "Cinder Block"  
        5: "Ceiling Tile"
        6: "Computer"
        7: "Unbreakable Glass"
        8: "Rocks"
    ]
] 

 

 

Gráficamente sería así:

Propiedad general ( base() color() iconsprite() size() studio() )
Son propiedades generales de la entidad. Se definen que bases son incluidos, el color, el tamaño y que sprite o model tendrá. En @Solid Class no es posible agregar el color(), iconsprite(), size() y studio(), o sea, el único que es posible agregar es el base(). Es posible ignorar y dejar vacío o no agregar las propiedades generales; en caso que no contengan, tendrá un valor por defecto.

base(BaseClass1, BaseClass2, ...) - Se adjuntan las bases definidas anteriormente para tener sus propiedades. Se pone el nombre de la base definidas anteriormente. En caso de poner varios bases, se separan entre comas ",". Ejemplo: base(Targetname, RenderFields, Angles)

color(R G - Se define el color del point entity (Fig03). Se introduce el valor del "R" (rojo), "G" (verde) y B (azul) separados por un espacio. Por defecto es el color magenta RGB 255 0 255 (Fig03; f). Ejemplo: color(10 10 220)

iconsprite("direccion/nombre_sprite.spr") - Se define que sprite tendrá la entidad. Acá es posible poner un sprite como la imagen anterior que tiene un sprite de un foco (Fig04; b) o un parlante (Fig04; a). Los sprite ser en archivo .spr y deben estar ubicado en una carpeta donde está instalado el Valve Hammer Editor (Fig05). En caso que no tenga ningún valor, aparecerá el sprite elegido posteriormente. Ejemplo:iconsprite("sprites/lightbulb.spr")
size(X1 Y1 Z1, X2 Y2 Z2) - Define el tamaño del sprite (Fig06). Se introduce los valores de un punto donde comienza (X1 Y1 Z1) y donde termina la figura (X2 Y2 Z2). Por defecto, el tamaño es -8 -8 -8, 8 8 8 (sería 16x16x16 units). Ejemplo: size(-16 -16 -16, 16 16 16)

studio("direccion/nombre_model.mdl") - Se define que model tendrá la entidad (Fig07). Los models deben ser en archivo .mdl y estar ubicado en la carpeta donde está instalado en el Valve Hammer Editor. En caso que no tenga ningún valor, aparecerá el model elegido posteriormente. ejemplo: studio("models/tree.mdl")

Nombre de la entidad (nombre_de_entidad : etiqueta)
Es el nombre de la entidad y la etiqueta es para indicar que es.


Propiedades de las entidades (propiedad(tipo) : "etiqueta" : valor_por_defecto)
Son las propiedades que tienen las entidades. Indican qué propiedad tiene y qué valor tiene esa propiedad.
Las "etiquetas" sirven para facilitar el uso de la entidad y son los que es posible ver en "smartedit" (fig11; a) y los nombres reales son los que es posible ver desactivando el "smartedit"(fig11; b).

propiedad - Es el nombre de la propiedad. Estos nombres deben estar en la librería del juego y en el compilador para que funcionen.
tipo - Es el tipo de dato que puede ser introducido o la opción que tiene el usuario para introducir. Hay varios tipos:

string - Indica que es posible ingresar cadena de texto. Cadena de texto puede ser números y letras.
integer - Indica que es posible ingresar números enteros. Puede ser positivo o negativo.
float - Indica que es posible ingresar números con coma.
choices - Crea una estructura de selección múltiple. Hace posible el uso de la caja de desplazamiento (Fig08).

Su sintaxis es:

 

 

propiedad(choices)  : "Etiqueta" : valor_por_defecto =
[
    valor_1 : "Etiqueta1"
        valor_2 : "Etiqueta2"
    .
    .
    .
    valor_n : "Etiquetan"
] 

 

 

flags - Estos flags aparecen en la pestaña "Flag" en propiedad de las entidades. Los valores del flag siempre deben ser potencia de 2;
2^0 = 1
2^1 = 2
2^2 = 4
2^3 = 8
2^4 = 16
2^5 = 32
etc...
... y el valor por defecto son binarios y pueden ser dos: 1 (si/encendido) o 0 (no/apagado)
Su sintaxis es:

 

propiedad(flags) =
[
    1 : "Etiqueta1" : valor_por_defecto1
    2 : "Etiqueta2" : valor_por_defecto2
    4 : "Etiqueta2" : valor_por_defecto4

    .
    .
    .
    valor_2^n : "Etiquetan" : valor_por_defecton
] 

 

 

 

color255 - Es utilizado en la "luz". Agrega un botón que nos permite sacar colores mediante una interfaz gráfica y un valor más que singifica la intensidad. (Fig09)

sound - Es utilizado en "sonido". Agrega un botón que nos permite buscar archivos de sonido mediante un buscador. (Fig10)
sprite - Es utilizado en "sprite". Agrega un botón que nos permite buscar Sprite mediante un buscador. (Fig10)
studio - Es utilizado en "model". Agrega un botón que nos permite buscar Model mediante un buscador. (Fig10)

target_destination - marca las propiedades como otro entidad de targetname.
target_source - marca las propiedades como otro entidad de targetname o clase.

El Decal es un caso especial:
@PointClass decal() base(Targetname) = infodecal : "Decal"
[
texture(decal)
]

Bigrafía/Links
https://developer.valvesoftware.com