PFM: Creación de un generador de enemigos en UDK

Para crear las oleadas de enemigos del juego, será necesario de alguna manera controlar dónde y cuándo aparecen los enemigos. Para facilitar esto se creará un Actor que sea simplemente un generador de enemigos.

Este actor, PFMEnemySpawner, creará un área a su alrededor en el que se generarán los enemigos (evitando que se generen siempre en el mismo punto). El código es el siguiente:

class PFMEnemySpawner extends Actor
placeable;

// Cilindro en el que se hará el spawn de los enemigos, editable en el editor
var() editconst const CylinderComponent CylinderComponent;

// Enemigos que quedan por "spawnear"
var int enemiesLeft;

auto state Spawning
{
    local Vector newSpawnLocation;

    Begin:
    while(true)
    {
        if(enemiesLeft > 0)
        {
            // Cálculo de localización dentro del cilindro
            newSpawnLocation = VRand();     //Vector unitario aleatorio
            newSpawnLocation.Z = 0;         //Se elimina la componente Z (vertical)
            Normal(newSpawnLocation);       //Se normaliza el nuevo vector
            newSpawnLocation *= CylinderComponent.CollisionRadius * FRand();  //Se le da una longitud aleatoria
            newSpawnLocation += Location;   //Se suma a la posición del spawner

            // Se intenta hacer spawn del enemigo
            if(SpawnPFMEnemy(newSpawnLocation) != none)
            {
                enemiesLeft--;
            }
        }
        Sleep(0.1);
    }
}

function Pawn SpawnPFMEnemy(Vector spawnLocation)
{
    local AIController EC;
    local Pawn EP;

    // Spawn del EnemyPawn
    EP = spawn(class'PFMEnemyPawn',self,,spawnLocation);
    if(EP == none)
    {
        // En caso de no haber sido posible hacer el spawn
        return none;
    }
    // Spawn del EnemyController
    EC = spawn(class'PFMEnemyController');
    // El EnemyController posee al EnemyPawn
    if(EC != none && EP != none)
    {
        EC.Possess(EP,false);
    }
    return EP;
}

function SpawnPFMEnemies(int num)
{
    enemiesLeft += num;
}

defaultproperties
{
    // Cilindro que define el area de spawn
    Begin Object Class=CylinderComponent Name=CollisionCylinder
        CollideActors=true
        CollisionRadius=+0040.000000
        CollisionHeight=+0040.000000
        bAlwaysRenderIfSelected=true
    End Object
    CollisionComponent=CollisionCylinder
    CylinderComponent=CollisionCylinder
    Components.Add(CollisionCylinder)

    // Sprite para verlo en el editor
    Begin Object Class=SpriteComponent Name=Sprite
        Sprite=Texture2D'EditorResources.S_Actor'
        HiddenGame=False
    End Object
    Components.Add(Sprite)

    enemiesLeft=0
}

En el estado por defecto Spawning, el generador está continuamente comprobando si le quedan enemigos por hacer aparecer. En caso afirmativo se busca una posición aleatoria dentro del área definida por un cilindro invisible durante el juego. Sabemos las dimensiones de dicho cilindro, pues se halla referenciado en la variable CylinderComponent. Hallada la posición aleatoria dentro del área permitida se intenta generar el nuevo enemigo, y sólo si se hace con éxito se reduce el número de enemigos restantes. Si no ha habido éxito en la generación se seguirá intentando en otras posiciones hasta que se consiga.

La función SpawnPFMEnemy es la que se encarga realmente de intentar generar un nuevo enemigo en la posición que se le pasa como argumento. Como sabemos, el PNJ básico que creamos necesitaba de un Pawn y un AIController para funcionar correctamente, por lo que en realidad habrá que generar ambas entidades y hacer que el controller ‘posea’ el Pawn para manejarlo.

En la zona de defaultproperties vemos cómo se crea un componente cilindrico que servirá para definir el área de generación de enemigos. Al principio de la clase también vemos que se define la variable CylinderComponent. Al usar la palabra var() en lugar de la habitual var para declararla, posibilitamos que esta variable sea editable directamente en el editor, dentro de las propiedades del actor PFMEnemySpawner, pudiendo así modificar su tamaño según convenga en el mapa.

Para probar las funciones de generación de enemigos de momento las invocaremos mediante funciones exec. Las funciones exec son un tipo de funciones especiales que pueden invocarse desde la consola de juego, por tanto son muy útiles para pruebas. Estas funciones exec sólo pueden definirse en clases especiales como los GameType (entre otras), así que modificaremos el nuestro para incluirlas.

class PFMGame extends UTDeathMatch;

var PFMEnemySpawner enemySpawner;

simulated function PostBeginPlay()
{
    local PFMEnemySpawner ES;

    super.PostBeginPlay();

    //Se busca el enemySpawner
    foreach DynamicActors(class'PFMEnemySpawner',ES)
        enemySpawner = ES;
}

exec function SpawnEnemies(int num)
{
    enemySpawner.SpawnPFMEnemies(num);
}

exec function SpawnEnemy()
{
    enemySpawner.SpawnPFMEnemies(1);
}

defaultproperties
{
    //Se especifica el Pawn por defecto
    DefaultPawnClass=class'PFM.PFMPawn'
    //Se especifica el controlador
    PlayerControllerClass=class'PFM.PFMPlayerController'
}

El resultado final:

Los enemigos aparecen alrededor del icono y dentro del cilindro definido.