Climbing - Hard to reach places? tutorial - Quake 2

Post tutorial Report RSS Climbing - Hard to reach places?

This tutorial will show you how to add climbing support in your Quake2 mod. With just a few presses of a button and holding +forward, you're on your way to new heights!

Posted by Paril on Feb 17th, 2006 - Basic Server Side Coding

[page=Intro]
This tutorial will show you how to add climbing support in your Quake2 mod. With just a few presses of a button and holding +forward, you're on your way to new heights!

This tutorial is basic/intermediate. It may take a while to get used to though. There are very small things to add for this big feature! Kudos for Mr_Grim for the great mod Dirty for releasing his source!
[page=Doing the code]
Alright, here we go!

First, let's add

//AQC - Climbing
        qb&#111;&#111;lean        hanging;
        vec3_t          hang_p&#111;int;
        fl&#111;at           flip_time;
        //end AQC

to your g_clients struct in G_local.h, which starts with:

// this structure is cleared &#111;n each PutClientInServer&#40;&#41;,
// except f&#111;r &#39;client-&#62;pers&#39;
struct gclient_s
{

That's done!

Now, let's get into the beef and meat.

Head over to g_misc, and add this at the bottom after the bracket:

qb&#111;&#111;lean Grab_n_Climb &#40;edict_t *ent&#41; //AQC
{
        vec3_t  f&#111;rward, start, end;
        int     check = 0;
        int     plusup = 0;
        trace_t tr;

        if &#40;ent-&#62;deadflag &#124;&#124; &#40;ent-&#62;m&#111;vetype == MOVETYPE_NOCLIP&#41;&#41;
                return false;

        if &#40;ent-&#62;gr&#111;undentity&#41;
                return false;

        AngleVect&#111;rs &#40;ent-&#62;s.angles, f&#111;rward, NULL, NULL&#41;;
        //f&#111;rward&#91;2&#93; = 0;
        Vect&#111;rN&#111;rmalize &#40;f&#111;rward&#41;;

        Vect&#111;rC&#111;py &#40;ent-&#62;s.&#111;rigin, start&#41;;
        // Space ab&#111;ve?
        start&#91;2&#93; += 56;
        tr = gi.trace &#40;ent-&#62;s.&#111;rigin, NULL, NULL, start, ent, MASK_SHOT&#41;;
        if &#40;tr.fracti&#111;n &#60; 1.0&#41;
                return false;

        Vect&#111;rC&#111;py &#40;ent-&#62;s.&#111;rigin, start&#41;;

        while &#40;check &#60; 64&#41;
        {
                start&#91;2&#93; += 1;
                Vect&#111;rMA &#40;start, 40, f&#111;rward, end&#41;; // Increased fr&#111;m 24
                tr = gi.trace &#40;start, NULL, NULL, end, ent, MASK_SOLID&#41;;
                if &#40;tr.fracti&#111;n &#60; 1.0&#41;
                        check = 64;
                else
                        check++;
        }

        if &#40;tr.fracti&#111;n &#60; 1.0&#41;
        {
                Vect&#111;rC&#111;py &#40;ent-&#62;s.&#111;rigin, start&#41;;
                start&#91;2&#93; += 84;
                Vect&#111;rMA &#40;start, 40, f&#111;rward, end&#41;;  // Increased fr&#111;m 24
                tr = gi.trace &#40;start, NULL, NULL, end, ent, MASK_SOLID&#41;;

                if &#40;&#33;&#40;tr.fracti&#111;n &#60; 1.0&#41;&#41;
                {
                        Vect&#111;rC&#111;py &#40;end, ent-&#62;client-&#62;hang_p&#111;int&#41;;
                        check = &#40;260 - plusup&#41;;
                        if &#40;ent-&#62;vel&#111;city&#91;2&#93; &#60; 0&#41;
                                ent-&#62;vel&#111;city&#91;2&#93; = 0;
                        ent-&#62;vel&#111;city&#91;2&#93; += check;
                        if &#40;ent-&#62;vel&#111;city&#91;2&#93; &#62; 400&#41;
                                ent-&#62;vel&#111;city&#91;2&#93; = 400;

                        //gi.dprintf &#40;&#34;Grab_n_Climb - pass&#092;n&#34;&#41;;
                        return true;
                }
        }
        //gi.dprintf &#40;&#34;Grab_n_Climb - fail&#092;n&#34;&#41;;
        return false;
}

qb&#111;&#111;lean HangingCheck &#40;edict_t *ent&#41;
{
        vec3_t  f&#111;rward, start, end;
        int     check = 0;
        trace_t tr;

        if &#40;ent-&#62;gr&#111;undentity&#41;
        {
                ent-&#62;client-&#62;hanging = false;
                return false;
        }

        AngleVect&#111;rs &#40;ent-&#62;s.angles, f&#111;rward, NULL, NULL&#41;;
        //f&#111;rward&#91;2&#93; = 0;
        Vect&#111;rN&#111;rmalize &#40;f&#111;rward&#41;;

        Vect&#111;rC&#111;py &#40;ent-&#62;s.&#111;rigin, start&#41;;
        // Space ab&#111;ve?
        start&#91;2&#93; += 56;
        tr = gi.trace &#40;ent-&#62;s.&#111;rigin, NULL, NULL, start, ent, MASK_SHOT&#41;;
        if &#40;tr.fracti&#111;n &#60; 1.0&#41;
        {
                ent-&#62;client-&#62;hanging = false;
                return false;
        }
        Vect&#111;rC&#111;py &#40;ent-&#62;s.&#111;rigin, start&#41;;
        start&#91;2&#93; -= 32;

        while &#40;check &#60; 88&#41;
        {
                start&#91;2&#93; += 1;
                Vect&#111;rMA &#40;start, 40, f&#111;rward, end&#41;; // Increased fr&#111;m 24
                tr = gi.trace &#40;start, NULL, NULL, end, ent, MASK_SOLID&#41;;
                if &#40;tr.fracti&#111;n &#60; 1.0&#41;
                        check = 88;
                else
                        check++;
        }

        if &#40;tr.fracti&#111;n &#60; 1.0&#41;
        {
                Vect&#111;rC&#111;py &#40;ent-&#62;s.&#111;rigin, start&#41;;
                start&#91;2&#93; = ent-&#62;client-&#62;hang_p&#111;int&#91;2&#93;;
                Vect&#111;rMA &#40;start, 40, f&#111;rward, end&#41;;  // Increased fr&#111;m 24
                tr = gi.trace &#40;start, NULL, NULL, end, ent, MASK_SOLID&#41;;

                if &#40;&#33;&#40;tr.fracti&#111;n &#60; 1.0&#41;&#41;
                {
                        ent-&#62;client-&#62;hanging = true;
                        if &#40;ent-&#62;vel&#111;city&#91;2&#93; &#62; 400&#41;
                                ent-&#62;vel&#111;city&#91;2&#93; = 400;
                        return true;
                }
        }
        ent-&#62;client-&#62;hanging = false;
        return false;
}

qb&#111;&#111;lean CheckHang &#40;edict_t *ent&#41;
{
        vec3_t  f&#111;rward, start, end;
        int     check;
        trace_t tr;

        //gi.dprintf &#40;&#34;CheckHang - &#34;&#41;;
        if &#40;ent-&#62;gr&#111;undentity&#41;
        {
                //gi.dprintf &#40;&#34;&#111;n gr&#111;und, fail&#092;n&#34;&#41;;
                return false;
        }
        AngleVect&#111;rs &#40;ent-&#62;s.angles, f&#111;rward, NULL, NULL&#41;;
        f&#111;rward&#91;2&#93; = 0;
        Vect&#111;rN&#111;rmalize &#40;f&#111;rward&#41;;

        Vect&#111;rC&#111;py &#40;ent-&#62;s.&#111;rigin, start&#41;;

        start&#91;2&#93; += 52;

        // Space ab&#111;ve?
        tr = gi.trace &#40;ent-&#62;s.&#111;rigin, NULL, NULL, start, ent, MASK_SHOT&#41;;
        if &#40;tr.fracti&#111;n &#60; 1.0&#41;
        {
                //gi.dprintf &#40;&#34;s&#111;mething ab&#111;ve, fail&#092;n&#34;&#41;;
                return false;
        }

        check = 0;
        while &#40;check &#60; 12&#41;
        {
                Vect&#111;rMA &#40;start, 24, f&#111;rward, end&#41;;
                tr = gi.trace &#40;start, NULL, NULL, end, ent, MASK_SHOT&#41;;
                if &#40;tr.fracti&#111;n &#60; 1.0&#41;
                        check = 12;
                else
                {
                        start&#91;2&#93; += 1;
                        check++;
                }
        }

        if &#40;tr.fracti&#111;n &#60; 1.0&#41;
        {
                //gi.dprintf &#40;&#34;fp pass, &#34;&#41;;
                check = 0;
                while &#40;check &#60; 12&#41;
                {
                        Vect&#111;rMA &#40;start, 24, f&#111;rward, end&#41;;
                        tr = gi.trace &#40;start, NULL, NULL, end, ent, MASK_SHOT&#41;;

                        if &#40;&#33;&#40;tr.fracti&#111;n &#60; 1.0&#41;&#41;
                        {
                                ent-&#62;client-&#62;hanging = true;
                                Vect&#111;rC&#111;py &#40;tr.endp&#111;s, ent-&#62;client-&#62;hang_p&#111;int&#41;;
                                //gi.dprintf &#40;&#34;full pass&#092;n&#34;&#41;;
                                return true;
                        }
                        else 
                                check++;
                        start&#91;2&#93; += 1;
                }
        }

        //gi.dprintf &#40;&#34;fail&#092;n&#34;&#41;;
        ent-&#62;client-&#62;hanging = false;
        return false;
} // AQC END

Big code! Now, go climb those walls and get to those hard to reach places, and pick them off with your sniper!

[page=Conclusion/Credits]

I would like to thank the creator of Dirty, Mr_Grim, for making the Action Quake2 remake. Also, he recently released his source (Because I asked him to for one, and that he got lots of emails asking for it), so I looked through it and added his climbing code to my mod and it worked, so I thought I'd share it with you!

Dirty's new site is located at Brazen.planetquake.gamespy.com
He currently has nothing uploaded, but I am sure he will upload more soon!

Post comment Comments

farbin - Jul 10 2006 - 3 comments

Hmm, more great code ideas, sadly, this tutorial is missing a few important lines of code. So, I had to go out and get the source for DirtyQ2 and find what was missing.

There needs to be a way to activate the climbing routines when you want to climb.

1.) In g_misc.c, the following should be added:

after the end of this function ...

void ThrowClientHead (edict_t *self, int damage)

add these 2 functions ...

/*
==============
Cmd_Action_On
==============
*/
qboolean Grab_n_Climb (edict_t *ent);

void Cmd_Action_On (edict_t *ent)
{
if (ent->deadflag || (ent->movetype == MOVETYPE_NOCLIP))
return;

// If weapon idle...
if (ent->client->weaponstate == WEAPON_READY)
{
// If jumping/falling etc
if (Grab_n_Climb (ent))
{
//ent->client->hanging = true;
return;
}
}
// On
ent->client->pers.grabbing = 1;
}

/*
==============
Cmd_Action_Off
==============
*/
void Cmd_Action_Off (edict_t *ent)
{
if (ent->client->pers.grabbing != 2)
// Off
ent->client->pers.grabbing = -1;
}

2.) Now, you will have to add the following to g_local.h:

in client_persistant_t (somewhere at the end) add ...

int grabbing;

and in struct gclient_s (again, somewhere near the end) add these:

qboolean hanging;
vec3_t hang_point;
float flip_time;

3.) Now, in g_cmds.c you need to add the commands to activate the climbing (the Action_On and Action_Off added previously). So,at the end of void ClientCommand (edict_t *ent), add these:

before ...

else // anything that doesn't match a command will be a chat
Cmd_Say_f (ent, false, true);

add ...

else if (Q_stricmp(cmd, "action_on") == 0)
Cmd_Action_On(ent);
else if (Q_stricmp(cmd, "action_off") == 0)
Cmd_Action_Off(ent);

4.) And the last peice of this would be to add your binds to your .cfg file (just to make life easier). For example:

add ...
alias action "action_on"
alias action_on "action_on;alias action "action_off"
alias action_off "action_off;alias action "action_on"
bind o "action"

or whatever key you which to use.

Additionally, you can fiddle with the value in the line

check = (260 - plusup);
(located in qboolean Grab_n_Climb (edict_t *ent))

to make your player climb faster/slower (more/less force).

farbin

p.s. Sorry, not trying to be a jerk, it just irritates me when a tutorial doesn't work or parts are missing. On the other hand, it makes me actually look at the source and not just copy-n-paste so, I learn a lot more.

Reply Good karma Bad karma+1 vote

Author

Paril - Jul 13 2006 - 24 comments

You don't need those. That block is for the +action, from Dirty.
You can just press the cmd I added to be able to climb up.
All it does is check for a location and up your velocity..
Works fine for me, it was implemented into my oldest AQC mod.

Reply Good karma+1 vote

Note that you have to make a cmd yourself, making it activate "Grab_n_Climb".

else if (Q_stricmp(cmd, "climb") == 0)
Grab_n_Climb(ent);

Taken from AQC.