PFM: Combate cuerpo a cuerpo en UDK (parte 1)

Para los casos en que la munición se agota, siempre viene bien tener a mano un arma cuerpo a cuerpo con la que proseguir el «trabajo» y eso es lo que crearemos en esta entrada. Se diseñará un sistema de combate cuerpo a cuerpo y se implementará en forma de una espada que el protagonista (de momento Mr. Pepe Dummy) esgrimirá cual mosquetero.

Diseño del sistema de combate

El sistema de combate que vamos a implementar es el más común en los videojuegos pues consiste en ir enlazando ataques. Dado que no coincide exactamente con la manera en que UDK trata las armas habrá que sobreescribir algunas funcionalidades, como se verá más abajo. Es importante definir exactamente cómo se comportará el sistema de combate cuerpo a cuerpo para luego implementarlo correctamente. En mi caso, el comportamiento del sistema será el siguiente:

• Cada animación de ataque está compuesta por dos partes, una primera que consiste en el propio ataque y una segunda que contiene la recuperación (que es pasar del momento final del ataque a la postura neutral)
• Las animaciones se irán enlazando al hacer clic con el ratón en la parte de ataque, siendo la última la que ejecute la recuperación (ataque-ataque-ataque-recuperación).
• Mantener pulsado el botón del ratón tendrá el mismo efecto que hacer un sólo clic (ataque-recuperación)
• Tras una recuperación se comienza un nuevo ataque siempre por la primera animación.
• Si durante una fase de ataque se hace clic de nuevo, al terminar la fase de ataque se enlazará el segundo ataque.
• Si durante la recuperación se hace clic, instantáneamente se activará la siguiente animación de ataque.
• Durante la fase de ataque no puede controlarse el movimiento del personaje.
• Si se pulsa una tecla de movimiento durante la fase de ataque, al terminar esta el personaje comenzará el movimiento, sin mostrarse la fase de recuperación.
• Si podrá modificarse la rotación del personaje, para cambiar la orientación entre un ataque y el siguiente.

Una vez se tiene claro el sistema de combate a utilizar, se puede pasar a la implementación.

Modelos, animaciones y preparativos en UDK

Lo primero será crear el modelo del arma. Para probar el modelo es lo de menos, así que yo no le pondré ni textura:

Lo que sí será importante es que sea un Skeletal Mesh (que contenga un esqueleto), pues usaremos la posición de los huesos para calcular las colisiones con los enemigos. Así, colocaremos una articulación en la base de la espada y el final del hueso en la punta, como se muestra:

Una vez importado en UDK crearemos 2 sockets en el esqueleto, uno en el hueso de la base del arma y otro en su punta, usando para ello el Socket Manager.

Abriendo el personaje podemos previsualizar cómo quedará el modelo de la espada en el socket de la mano del mismo:

A continuación importaremos las animaciones que hemos creado para el movimiento del personaje. En mi caso he hecho 2 (muy cutres por cierto):

Como se puede ver, cada animación contiene tanto la parte del ataque en sí, como la de la recuperación de la posición. Además, la segunda animación comienza en el punto en que termina el ataque de la primera, lo que será importante para enlazar una animación con otra.

Finalmente en UDK ampliaremos el AnimTree del personaje para permitir ejecutar animaciones desde el código cuando sea necesario. Para ello usaremos un nodo AnimNodeSlot, que posibilita esto. Le cambiaremos el nombre para poder acceder a él desde el código, llamándolo MeleeAnimNode.

Hecho esto, podemos pasar al código, donde haremos que se pueda agitar la espada como un loco.

Swing! swing!

Lo primero que haremos será conseguir un acceso al nodo del AnimTree que acabamos de añadir, y para ello modificaremos PFMPawn. Simplemente crearemos una variable para almacenarlo:

var AnimNodeSlot MeleeAnimNode;

Y la inicializaremos en la función PostInitAnimTree, que ya habíamos usado al hacer que el personaje apuntara.

simulated event PostInitAnimTree(SkeletalMeshComponent SkelComp)
{
    // Se busca la referencia del nodo de Aiming
    PFMAimNode = AnimNodeAimOffset(SkelComp.FindAnimNode('PFMAimNode'));

    // Se busca la referencia del nodo de animaciones melee
    MeleeAnimNode = AnimNodeSlot(SkelComp.FindAnimNode('MeleeAnimNode'));
}

Con esto ya tendremos una referencia al nodo y podremos activar las animaciones fácilmente.

PFMWeaponBlade

A continuación vamos a crear la clase que representa el arma en sí. Yo la llamaré PFMWeaponBlade. Ella se encargará de activar las animaciones correspondientes del Pawn y calcular las colisiones con los enemigos. El diseño del sistema de combate no se ajusta muy bien a lo que UDK tiene predefinido (por ejemplo, las armas normales siguen disparando hasta soltar el botón de disparo), así que hay que hacer pequeñas modificaciones en su comportamiento por defecto. Muy recomendable conocer el funcionamiento de las armas en UDK.

class PFMWeaponBlade extends PFMWeapon;

var array <Name> SwingAnimations;         // Nombres de las animaciones a usar
var array <float> SwingIntervals;         // Intervalos de tiempo de cada animación
var int currentSwing;                    // Animación actual

var SoundCue SwingSound;                // Sonido de espadazo

Se declaran algunas variables: Un array para guardar los nombres de las animaciones, un array con los tiempos de la fase de ataque de cada animación, un contador para almacenar qué animación se ejecuta actualmente, etc.

// Se sobreescribe para evitar que al soltar el botón se desactive cualquier ataque
simulated function StopFire(byte FireModeNum);

Por defecto al soltar el botón del ratón se llama a la función StopFire, que automáticamente desactiva el estado de disparar. Lo sobreescribimos para que no haga eso.

// Disparo efectivo
simulated function FireAmmunition()
{
 // Se declara que el ataque se ha cumplido
 Super.StopFire(CurrentFireMode);

 // Se elimina posible Timer de reseteo del sistema de melee
 ClearTimer(nameof(ResetMelee));

 // Animación de melee (AnimName, Rate, BlendInTime, BlendOutTime, bLooping, bOverride)
 PFMPawn(Owner).MeleeAnimNode.PlayCustomAnim(SwingAnimations[currentSwing], 1.0,0.05,0.1,false,true);

 // Efectos
 SpawnSwingEffects();

 // Se reprograma el intervalo de RefireCheckTimer adecuadamente
 FireInterval[0] = SwingIntervals[currentSwing];
 TimeWeaponFiring(CurrentFireMode);

 // Aumenta el índice de las animaciones para pasar a la siguiente
 currentSwing = (currentSwing + 1) % SwingAnimations.length;

 // Se desactiva el desplazamiento del Pawn
 PFMPlayerController(Pawn(Owner).Controller).SetRotationOnly(true);

 Super.FireAmmunition();
}

FireAmmunition es la función que efectúa el disparo del arma, por lo que la sobreescribimos para que ejecute las animaciones, configure el tiempo entre ataques, etc.

// Programa un timer para llamar a RefireCheckTimer
simulated function TimeWeaponFiring( byte FireModeNum )
{
 // Si desde que se inició el ataque anterior se ha pulsado otra vez clic, RefireCheckTimer volverá a
 // lanzar un ataque, pues PendingFire será = 1
 SetTimer( GetFireInterval(FireModeNum), false, nameof(RefireCheckTimer) );
}

La función RefireCheckTimer comprueba si hay que volver a llamar a FireAmmunition (por defecto se haría manteniendo el ratón pulsado). En nuestro caso, se volverá a disparar si hay algún clic pendiente.

// Llamado al desactivar este arma
simulated function PutDownWeapon()
{
 HandleFinishedFiring();
 Super.PutDownWeapon();
}

// Llamado cuando se deja de "disparar". Se llama si RefireCheckTimer determina que no hay que seguir atacando.
simulated function HandleFinishedFiring()
{
 if (PFMPawn(Owner).MeleeAnimNode.GetCustomAnimNodeSeq() != None)
 { // Se activa un Timer que reseteará el sistema de Melee cuando termine la animación actual
 SetTimer(PFMPawn(Owner).MeleeAnimNode.GetCustomAnimNodeSeq().GetTimeLeft(), false, nameof(ResetMelee));
 }

 // Se reactiva el movimiento del Pawn
 PFMPlayerController(Pawn(Owner).Controller).SetRotationOnly(false);

 Super.HandleFinishedFiring();
}

// Se llama cuando la animación de melee concluye. Resetea el sistema para que las animaciones comiencen desde la primera.
function ResetMelee()
{
 // Se resetea el combo
 currentSwing = 0;
}

Estas funciones se encargan de resetear el sistema cuando se cambia de arma o termina una combinación de ataques.

//********************************
// EFECTOS VISUALES Y DE SONIDO
//********************************

// Efectos de ataque
function SpawnSwingEffects()
{
 // Sonido de impacto
 if (SwingSound != None)
 {
 PlaySound(SwingSound, true);
 }
}

defaultproperties
{
 // Mesh
 Begin Object Class=SkeletalMeshComponent Name=GunMesh
 SkeletalMesh=SkeletalMesh'Weapons.PepeDummyWeaponBlade.SM_PepeDummyWeaponBlade'
 HiddenEditor=FALSE
 Scale=1.0
 End Object
 Mesh=GunMesh
 Components.Add(GunMesh)

 bMeleeWeapon=true;
 bInstantHit=true;
 bCanThrow=false;

 FiringStatesArray(0)=WeaponFiring
 WeaponFireTypes(0)=EWFT_Custom

 FireInterval(0)=0.0 // Intervalo entre disparos
 currentSwing=0 // Animación actual
 SwingAnimations=("PepeDummy_Swing1","PepeDummy_Swing2") //Animaciones diferentes
 SwingIntervals=(0.4,0.35) //Intervalos de cada animación

 SwingSound=SoundCue'A_Vehicle_Scorpion.SoundCues.A_Vehicle_Scorpion_BladeExtend'

 // Grupo de inventario
 InventoryGroup=1

 // Tipo de postura
 WeaponType=PWT_Default
}

Inicialización de variables como es habitual. Se especifica el SkeletalMesh, los nombres de las animaciones, sus tiempos de ataque, etc.

Como se ve en el código se hace uso en varias ocasiones la función SetRotationOnly de PFMPlayerController para desactivar/activar el movimiento del personaje. Esta función no existe por defecto en el controlador por lo que hay que modificar PFMPlayerController para añadirla:

var bool bRotationOnly;         // Especifica que el Pawn no puede desplazarse, sólo rotar

function SetRotationOnly(bool rotationOnly)
{
    bRotationOnly = rotationOnly;
}

Se modifica la función PlayerMove del estado PlayerWalking para que sólo pueda moverse el personaje cuando la variable bRotationOnly sea falsa. (Pongo todo el código de PlayerWalking por claridad, pero la única modificación es añadir la llamada a ResetMeleeIfCanMove() y el if(!bRotationOnly), que hace que la función no aclcule la aceleración del personaje si no debe desplazarse. Si te preguntas de dónde sale el código de PlayerWalking, échale un vistazo a esta entrada anterior)

//Extiende el estado PlayerWalking, sobreescribiendo ProcessMove
state PlayerWalking
{
    ignores SeePlayer, HearNoise, Bump;

    function PlayerMove( float DeltaTime )
	{
		local vector			X,Y,Z, NewAccel;
		local eDoubleClickDir	DoubleClickMove;
		local rotator			OldRotation;
		local bool				bSaveJump;

		if( Pawn == None )
		{
			GotoState('Dead');
		}
		else
		{
			GetAxes(Pawn.Rotation,X,Y,Z);

			// Se resetea el melee en caso necesario
			ResetMeleeIfCanMove();

            if(!bRotationOnly)  // Sólo se calcula si podemos desplazarnos
            {
                // La aceleración (y en consecuencia el movimiento) es diferente según el tipo de arma que lleve el Pawn
    			if(PFMPawn(Pawn).WeaponType == PWT_Default || PFMPawn(Pawn).WeaponType == PWT_Sword)
    			{
        			NewAccel = Abs(PlayerInput.aForward)*X + Abs(PlayerInput.aStrafe)*X;
                }
                else
                {
                    NewAccel = PlayerInput.aForward*X + PlayerInput.aStrafe*Y;
                }

    			NewAccel.Z = 0;
    			NewAccel = Pawn.AccelRate * Normal(NewAccel);

    			if (IsLocalPlayerController())
    			{
    				AdjustPlayerWalkingMoveAccel(NewAccel);
    			}
            }

			DoubleClickMove = PlayerInput.CheckForDoubleClickMove( DeltaTime/WorldInfo.TimeDilation );

			// Update rotation.
			OldRotation = Rotation;
			UpdateRotation( DeltaTime );
			bDoubleJump = false;

			if( bPressedJump && Pawn.CannotJumpNow() )
			{
				bSaveJump = true;
				bPressedJump = false;
			}
			else
			{
				bSaveJump = false;
			}

			if( Role < ROLE_Authority ) // then save this move and replicate it
			{
				ReplicateMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
			}
			else
			{
				ProcessMove(DeltaTime, NewAccel, DoubleClickMove, OldRotation - Rotation);
			}
			bPressedJump = bSaveJump;
		}
	}
}

El resto del código no hay que modificarlo. Se añadirá la función ResetMeleeIfCanMove(), que se encarga de desactivar la animación de Melee si queremos movernos durante la fase de recuperación.

//*************************************************************************
// MELEE
//*************************************************************************
function ResetMeleeIfCanMove()
{
    if(!bRotationOnly) // El arma de melee ya lo ha activado (Nos permite movernos)
    {
        if(PFMPawn(Pawn).MeleeAnimNode.GetPlayedAnimation() != '')
        {
            if(PlayerInput.aForward != 0.0 || PlayerInput.aStrafe != 0.0) // Queremos movernos
            {
                // Se para la animación de melee
                PFMPawn(Pawn).MeleeAnimNode.StopCustomAnim(0.2);
                // y resetea el sistema de melee
                if(PFMWeaponBlade(Pawn.Weapon) != None)
                {
                    PFMWeaponBlade(Pawn.Weapon).ResetMelee();
                }
            }
        }
    }
}

Finalmente hay que añadir la espada al inventario por defecto del Pawn, por lo que en PFMPawn, añadiremos o modificaremos la función AddDefaultInventory:

// Sobreescribe la funcion de Pawn
function AddDefaultInventory()
{
    // Se le da al Pawn el arma al comenzar
    InvManager.CreateInventory(class'PFM.PFMWeaponBlade',true);

}

Compilado y ejecutando, este es el resultado:

El sistema está montado, pero si intentamos atacar a los enemigos, no servirá de nada. Estamos ejecutando las animaciones, pero todavía no calculamos los impactos con el entorno ni le aplicamos daño a los enemigos, por lo que de poco sirve menear la espada. El cálculo de daños lo abordaremos en la segunda parte 🙂