Movement Code – by DavidLancaster

Michael Schwarz — Tue, 30 Dec 2008 19:29:32 +0000

I guess, towards the end of this year, I’ll be getting up a bit more to blogging. Just for these few day’s at least. What a better way of demonstrating by talking about the new awesome contribution by DavidLancaster and his movement code contribution.

Apparently it includes incredibly many features such as:
pole climbing
wallclimbing
ledge grabbing and ledge shimmying
utomatic ledge grabbing
rope climbing
rope walking
monkey bars
ladder climbing (including wonkey ladders)
rail grinding
smooth interplation between movement states

Now if that isn’t a nice new-year/christmas-contribution! Huge kudos out there!

Here’s the direct download link, in case you missed it:

http://www.rebelplanetcreations.com/downloads/FreeCode/DiverseMovement.rar

Code Snippet #1

Michael Schwarz — Tue, 15 Apr 2008 13:35:09 +0000

Hereby I introduce the new code snippets section. Today serving you a Half-Life like movement script.

This script works different than most movement scripts, as it uses vec_accelerate instead directly passing the speed to the c_move parameters, thus creating a move natural movement.

More after the click:

First off we want to set a few constants, aswell as a few dynamic variables which we will later use in the script. Using defined constants makes it easier to read the script as it does make it easier to later modify a specific value without having to crawl through the whole script to find a specific value.

define true, 1;
define false, 0; 
  
define relSpeed_x,skill7;
define relSpeed_y,skill8;
define relSpeed_z,skill9;
define absSpeed_x,skill10;
define absSpeed_y,skill11;
define absSpeed_z,skill12;
define P_Speed,skill13;
define P_AngSpeed,skill14;
define P_Weight,skill15;
define P_Friction,skill16; 
  
var GLOB_BkgColor[3];
var PHY_Gravity[3];
var MOV_Playerspeed = 25;
var MOV_Turnspeed = 10;
var MOV_MaxUpAngle = 90;
var MOV_MaxDownAngle = -90;
var MOV_ShiftFactor = 1.35;

So, I use the opportunity to set up my standard defines for true and false, which I prefer to use over 1/0 or on/off respectively.

We store the player input in an imaginary vector called “relSpeed” in the skills of the entity, for the sake of being able to have a better accessibility for external events.

Global acceleration, like gravity, is passed by the absSpeed vector.

Then we have the values P_Speed, P_AngSpeed, P_Weight and P_Friction. P_Speed indicating the current speed the player is moving and P_AngSpeed indicating the speed the player is turning around.

Now we have some dynamic variables that are part of the movement system:

GLOB_BkgColor[3] : Actually just for defining the sky color.
PHY_Gravity[3] : We will define the values for this at game start. It’s as the name says the gravity.
MOV_Playerspeed : You will have to play with this value, as it defines how fast your player will move.
MOV_Turnspeed : You have to play with this value too. Defines the speed you will turn/look around.
MOV_MaxUpAngle : The maximal angle you can look upwards.
MOV_MaxDownAngle : The maximal angle you can look downwards.
MOV_ShiftFactor : The factor the MOV_Playerspeed gets multiplied by when holding the shift key. Use a value over 1.00 to accelerate the movement when pressing this key, or a value below 1.00 if you want the player to slow down when you press the shift key.

Now comes the main function for the whole thing, it is actually this function that does most of the difference to other movement codes:

function FNC_ApplyPhysics(ent, enablePoly)
{
    me = ent;
    vec_set(me.absSpeed_x, PHY_Gravity.x);
  
    while(me)
    {
        c_move(me, nullvector, me.absSpeed_x, IGNORE_SPRITES);
        c_move(me, me.relSpeed_x, nullvector, IGNORE_SPRITES|GLIDE);
        wait(1);
    }
}

As the commentary says, we use c_move twice here. One time for the absolute speed and one time for the relative speed. This is necessary as for the normal “movement” we need the GLIDE flag, or else we would become stuck in edges; and honestly you would actually not even move without it. Then we need the second c_move without the GLIDE flag because else you wouldn’t be able to walk up stairs or ledges.

And finally, the main movement code:

function FNC_MoveWASD(ent)
{
    // :: Assign ME pointer to entity.
    me = ent;
  
    // :: Main loop
    while(me)
    {
        // :: Rotate camera
        camera.pan += -((mouse_force.x * MOV_Turnspeed) * time_step);
  
        // :: Assign camera pan to entity pan
        me.pan = camera.pan;
        
        // :: Camera Tilting
        // : If Camera tilt is over or under maximal tilt angles
        if(camera.tilt > MOV_MaxUpAngle || camera.tilt < MOV_MaxDownAngle)
        {
            if(camera.tilt > MOV_MaxUpAngle)
            {
                // :: If it is over the maximal upper limit
                camera.tilt = int(camera.tilt - 2*time_step);
                // : Limit mouse movement
                if(mouse_force.y < 0){camera.tilt += ((mouse_force.y * MOV_Turnspeed) * time_step);}
            }
            else
            {
                // :: If it is over the maximal lower limit
                camera.tilt = int(camera.tilt + 2*time_step);
                // : Limit mouse movement
                if(mouse_force.y > 0){camera.tilt += ((mouse_force.y * MOV_Turnspeed) * time_step);}
            }
        }
        else
        {
            // :: Else
            // : Free tilting
            camera.tilt += ((mouse_force.y * MOV_Turnspeed) * time_step);
        }
        
        // :: If camera roll is not equal to 0°
        if(camera.roll != 0)
        {
            // :: And if camera roll is higher or equal to 180°
            if(camera.roll >= 180)
            {
                // : Roll clockwise
                camera.roll = int(camera.roll + 2*time_step);
            }
            else
            {
                // :: else
                // : roll counter-clockwise
                camera.roll = int(camera.roll - 2*time_step);
            }
        }
        
        vec_accelerate(my.relSpeed_x, my.P_Speed, vector(((key_w-key_s)*MOV_Playerspeed*(1+key_shift*MOV_ShiftFactor))*time_step, ((key_a-key_d)*MOV_Playerspeed*(1+key_shift*MOV_ShiftFactor))*time_step, me.relSpeed_z), 0.5);
        wait(1);
    }
}
  
function FNC_AttachCam(ent, z_offset)
{
    me = ent;
    vec_set(camera.x, vector(me.x, me.y, me.z));
    if(!key_ctrl){ camera.z += z_offset; }    
}
  
action ACT_Player
{
    player = me;
    FNC_ApplyPhysics(player, false);
    FNC_MoveWASD(player);
    
    camera.genius = player;
    
    while(1)
    {
        FNC_AttachCam(player, 35);
        wait(1);
    }
}

In the action ACT_Player you might want to change the second parameter of the FNC_AttachCam inside the while-loop, it defines the height of the camera from the origin of the player, so depending of the size of your player model this value can vary.

Inside your main function, you will also need to include the following BEFORE loading any level:

PHY_Gravity[0] = 0;
PHY_Gravity[1] = 0;
PHY_Gravity[2] = (-9.8); 
  
camera.arc = 75;
fps_max = 60;
fps_min = 35;
fps_lock = on;

This defines the Gravity. The value of (-9.8) should be adequate to the real earth gravity when using the Warlock/Cbabe/Guard model as reference. The FOV is set to 75, as it gives the whole thing a more natural feeling overall and we set an FPS lock so the movement doesn’t get jumpy or jerky whenever your FPS should rise or fall unexpectedly.

Now just attach the ACT_Player action to your player model in WED and have some Half-Life-Movement-Fun !

Stay tuned for the upcoming issue #2 of Code Snippets!

The 3DGS Nerd » movement

Movement Code – by DavidLancaster

Code Snippet #1