| Varlock |
GameRules Pack Tutorial 2 of 4 |
GRPack (GameRules Pack) Tutorial 2 of 4: Adding Assault to Your Mod
This is the second tutorial in a four-part series which will help you
implement Two-Team Deathmatch, Assault, CTF, and Domination gamemodes
into your Half-Life mod. These tutorials were designed as a quick and
easy way to add the four gamemodes listed above to a fresh SDK, so you
don't have to keep re-inventing the wheel every time you want to use one
of these gamemodes. As a result the source code is included; first,
because there is so much of it a tutorial would be difficult to follow,
and second because it was originally meant to be used as a bare bones
addition to the Half-Life SDK. Once you've added the code listed here,
you will likely want to modify some (if not all) of the code to fit your
mod's needs.
You MUST have the Two-Team Deathmatch (Tutorial 1) source already installed for this tutorial to work properly. The >>gras.zip<< file included with this tutorial contains two zip files, server.zip and client.zip.
This Assault code contains mostly serverside code, but there is one
small modification to the client dll. The source code for this tutorial
is contained in the gras.zip file which you should already have. To
install, simply unzip the serverside source code (server.zip) on top of
the >>grtdm.zip<< code from Tutorial 1
(/Source/dlls). Make sure you add assault.h and assault.cpp to the
project before you compile or they won't be included in the build. To
add files to your project, open them with 'File | Open' and when the
code appears, right-click anywhere on the code and choose 'Insert File
into Project'.
The Assault gamerules set is basically Two-Team Deathmatch with two
additions: capture points and a timer. The capture point entity makes up
most of the new code in this tutorial. Bring up the server code, open
assault.h, and take a look around. The first section of code here is the
CInfoRulesAssault. This entity is responsible for holding information
about the Assault gamerules which the mapper has set, such as total
round time. It is derived from CBaseEntity and the only function we've
chosen to override is the KeyValue function, so we can extract
information from the map.
Next, there's CFuncCapturePoint. This entity is also derived from
CBaseEntity and is a lot more complicated than the info entity above.
You should be able to figure out what the functions and variables do
from their names and the comments. The guts of this class can be found
in CPThink.
The last thing in assault.h is the actual gamerules. It's derived from
the CRulesTeamDM you installed in Tutorial 1. Why is it derived from
CRulesTeamDM? There's a lot of power in class inheritance, and you can
see it in action here. We don't have to reprogram any of the functions
we created in CRulesTeamDM for our Assault gamerules. They already exist
and are passed down to CRulesAssault through inheritance. Compared to
CRulesTeamDM there's not a whole lot of functions here; only eight, and
five of them are new! This means we've only had to reprogram three
functions instead of the entire set!
Take a look at line 51. The string returned by GetGameDescription is the
text you see in the server browser while you are looking for a game.
You can change the text returned by this function to match your mod.
Here's the .fgd definitions for the new entities (you probably want to add these to your own .fgd file),
@PointClass base(Target) = info_rules_assault: "Assault Info"
[
attacker(choices) : "Attacking Team" : 1 =
[
1: "Red"
2: "Blue"
]
roundtime(integer) : "Round Time (Minutes)" : 5
]
@SolidClass base(Target) = func_capture_point : "Capture Point"
[
captime(integer) : "Capture Time (Seconds)" : 1
name(string) : "Name" : "Point Name"
reqpercent(integer) : "Required % of Team" : 50
]
Now open assault.cpp; the code in this file appears in the same order as
in assault.h. The CInfoRulesAssault :: KeyValue function appears here.
This function grabs the attacker and roundtime values from the map and
sets the appropriate variables in CRulesAssault for future reference.
The only time this entity is accessed is at the beginning of each map
when Half-Life calls the KeyValue function for every entity. NOTE:
Half-Life will crash if the info_rules_assault entity is present in a
non-Assault map! Also, if there is more than one info_rules_assault in
the map, the last one called by Half-Life will be the one the mod uses.
The next section of code is for CFuncCapturePoint. You should see the
CPThink function first. This function contains the guts for the capture
point. Let's take a look at it in detail. At the beginning of the
function it sets up the variables, retrieves a pointer to the Assault
gamerules, and performs a few important checks. After that, it checks to
see how many players are inside the capture point with a simple loop
through every player. Next, if an attacker is inside the capture point
it checks to see if there are enough attackers present based on the
capture point's 'reqpercent' value. Finally if there are enough people
there it starts a timer to make sure they stay there for the required
time. Once it's been captured, it fires the target entity, sets a few
variables and tells the gamerules to check if all the CP's are captured.
Whew! Skip down to line 167 and the PrintToPlayers function. This
function performs a ClientPrint with the passed message on any players
inside the capture point. Next, the spawn function sets the capture
point's origin and size based on the mapper's choice, sets it invisible
and starts the CPThink cycle.
You may want to modify the logic of CPThink to fit your mod's needs. If
you don't plan on having a timer or a player requirement, just delete
the corresponding code.
Finally, there's the CRulesAssault gamerules. Most of these functions
should be self-explanatory, but take a look at ClientCommand. We've
added one more command, "updatetimer". When the server receives this
command it updates the client's version of the round timer. For example,
if you joined an Assault game half-way through a round, you would have
no idea how much time is left. If you send an "updatetimer" message,
your clock will be updated with the server's version and you'll have a
correct timer! If for any reason your timer gets out of sync with the
server, you can also send an "updatetimer" message.
You'll likely want to change the ResetRound function on line 309. This
function is called with a single BOOL parameter. If it's TRUE, the
capture points were captured, if it's FALSE, the round time ran out
instead. There are several places in this function where you might want
to award players more points, set them into some sort of spectator mode,
or change their teams (ie. make the attackers now the defenders and
vice versa). If you DO decided to switch the player's teams here, you
will probably want to remove the 'attacker' variable from
CInfoRulesAssault and modify the .fgd as well.
We're just about done the server now. Open up player.cpp and take a look
at line 188. We've defined a new message,
gmsgRoundTime, and on line 232 we register it. Now check out
gamerules.cpp. On line 29 you'll need to uncomment the preprocessor call
to include "assault.h" if it's not already done. Also, you'll need to
uncomment lines 324 and 325 or else the Assault gamerules will never be
created,
else if ( strncmp( szMapName, "as_", 3 ) == 0 )
return new CRulesAssault( );
That's it for the server. Compile the new code and open up the client
project. Unzip the client.zip source included with this tutorial over
/Source/cl_dll. You'll need to add the roundtimer.cpp file to the
project, just like you did assault.cpp and assault.h for the server. The
changes here are very simple. A new HUD item has been added which
receives the gmsgRoundTime message and displays the time left as a text
string on the screen. You might want to change the position of the timer
or make it use the number sprites instead of a text string, but I'll
leave that up to you.
