Creating a Basic Counter-Strike: Source Mod using C++: A Tutorial

Welcome to this tutorial on how to make a Counter-Strike: Source mod using C++!

Counter-Strike: Source is a popular first-person shooter game developed by Valve Corporation. It is built on the Source engine, which is a highly moddable game engine that allows users to create custom content for the game. One way to do this is by creating mods, which are modifications to the game that add new features or change existing ones.

In this tutorial, we will learn how to create a basic Counter-Strike: Source mod using C++. We will cover the following topics:

1. Setting up your development environment
2. Creating a mod project
3. Adding custom code to your mod
4. Building and testing your mod

Let’s get started!

Setting up your development environment

To create a Counter-Strike: Source mod, you will need to have the following software installed on your computer:

• A source code editor, such as Visual Studio or Eclipse
• The Source SDK, which is a set of tools and libraries provided by Valve for creating mods
• Counter-Strike: Source, which is required to test your mod

To install the Source SDK, you will need to have Steam installed on your computer. Once Steam is installed, follow these steps:

1. Launch Steam and go to the Library tab.
2. Click on the Tools tab in the left sidebar.
3. Find the Source SDK in the list of tools and install it.

Once the Source SDK is installed, you can create a mod project using the Source SDK.

Creating a mod project

To create a mod project, follow these steps:

1. Launch the Source SDK from your Steam library.
2. In the mod selection menu, select “Create a Mod” and click “Next”.
3. Give your mod a name and select “Counter-Strike: Source” as the game.
4. Click “Create Mod” to create the mod project.

This will create a new mod project with the specified name and set it up for use with Counter-Strike: Source.

Adding custom code to your mod

Now that we have a mod project set up, we can start adding custom code to it. To do this, we will need to create a new C++ class that will contain our custom code.

To create a new C++ class, follow these steps:

1. Right-click on your mod project in the Solution Explorer and select “Add > New Item”.
2. In the Add New Item dialog, select “C++ Class” and click “Add”.
3. Give your class a name and click “Add”.

This will create a new C++ class with a header file and a source file. You can then add your custom code to these files.

For example, let’s say we want to create a new weapon for our mod. We can do this by creating a new C++ class that inherits from the CBaseCombatWeapon class, which is the base class for all weapons in the game.

Here is an example of what our custom weapon class might look like:

#include "cbase.h"

class CMyCustomWeapon : public CBaseCombatWeapon
{
public:
    DECLARE_CLASS( CMyCustomWeapon, CBaseCombatWeapon );

    void Precache( void );
    void Spawn( void );
    void PrimaryAttack( void );
    void SecondaryAttack( void );
};

LINK_ENTITY_TO_CLASS( weapon_mycustomweapon, CMyCustomWeapon )

Here, we have created a new class called CMyCustomWeapon that inherits from CBaseCombatWeapon. We have also defined some basic functions that are commonly implemented in weapon classes, such as Precache, Spawn, and PrimaryAttack.

Now that we have our custom weapon class, we need to register it with the game so that it can be used in-game. To do this, we can use the LINK_ENTITY_TO_CLASS macro, which creates a global instance of our weapon class and registers it with the game.

In the example above, we are using the LINK_ENTITY_TO_CLASS macro to register our CMyCustomWeapon class with the game, using the entity name weapon_mycustomweapon.

Building and testing your mod

Now that we have added some custom code to our mod, we can build and test it to see how it works in-game. To build your mod, follow these steps:

1. In the Source SDK, select “Build > Build Solution” from the menu.
2. Once the build is complete, select “Debug > Start Debugging” from the menu.

This will launch Counter-Strike: Source and load your mod. You can then test your mod by using the custom weapon or other custom features you have added.

Filling it in

Here is an example of how you could fill in the CMyCustomWeapon class to load a 3D model of a gun and to upgrade the gun to the next one in a series of guns every time the player kills someone, with the UpgradeWeapon function and logic included:

#include "cbase.h"

class CMyCustomWeapon : public CBaseCombatWeapon
{
public:
    DECLARE_CLASS( CMyCustomWeapon, CBaseCombatWeapon );

    void Precache( void )
    {
        PrecacheModel("models/weapons/w_mycustomweapon.mdl");
        PrecacheScriptSound("MyCustomWeapon.Shoot");
    }

    void Spawn( void )
    {
        SetModel("models/weapons/w_mycustomweapon.mdl");
        BaseClass::Spawn();
    }

    void PrimaryAttack( void )
    {
        // Implement primary attack logic here
        // ...

        // Play the weapon's shooting sound
        EmitSound("MyCustomWeapon.Shoot");
    }

    void SecondaryAttack( void )
    {
        // Implement secondary attack logic here
        // ...
    }

    void UpgradeWeapon( void )
    {
        // Check the current weapon level
        int weaponLevel = GetWeaponLevel();

        // Apply upgrades based on the weapon level
        switch (weaponLevel)
        {
            case 1:
                // Upgrade the damage
                SetDamage(50);
                break;
            case 2:
                // Add a scope
                AddScope();
                break;
            case 3:
                // Add a silencer
                AddSilencer();
                break;
            // Add more upgrades as needed
        }

        // Increment the weapon level
        SetWeaponLevel(weaponLevel + 1);

        // Reload the weapon to apply the upgrades
        Reload();
    }
};

LINK_ENTITY_TO_CLASS( weapon_mycustomweapon, CMyCustomWeapon )

In this implementation, we have added the UpgradeWeapon function, which contains a switch statement that applies upgrades based on the current weapon level. The function also increments the weapon level and calls the Reload function to apply the upgrades to the weapon.

To call the UpgradeWeapon function, you can add a call to it in the code that handles player kills. For example, you could create a new function called OnKill that is called every time a player kills another player, and have it call the UpgradeWeapon function. Here is an example of what this might look like:

void OnKill( CBasePlayer *pKiller, CBasePlayer *pVictim )
{
    // Check if the killer is using our custom weapon
    if (pKiller->GetActiveWeapon() == WEAPON_MYCUSTOMWEAPON)
    {
        // Upgrade the weapon
        static_cast<CMyCustomWeapon*>(pKiller->GetActiveWeapon())->UpgradeWeapon();
    }
}

This function will check if the killer is using the CMyCustomWeapon and, if so, call the UpgradeWeapon function to upgrade the weapon.

I hope this tutorial has been helpful in getting you started with creating a Counter-Strike: Source mod using C++. For more information and examples, you can refer to the official Source SDK documentation and the modding community forums. Happy modding!