Overview

A weapon is an item which contains the four following components:

• A Weapon Class, which defines the general logic behind your weapon (What happens when you pick up the weapon?, What happens when you drop the weapon?, ...).
• A Fire Mode Class, which defines all kinds of fire parameters like recoil, effects, etc.
• A Projectile Class, which defines for example the logic when hitting another object.
• A Zoom Mode Class, which defines how to handle different zoom steps for your weapon.

The core functionality is implemented in C++ , but these components read the data stored inside XML script files located in: <Game_Folder>/Scripts/Entities/Items/Weapons.

Weapon Class

A new weapon class can be added by implementing the CItem and IWeapon interfaces. A basic weapon implementation is supplied in the GameDLL project which provide the most commonly required weapon functionality:

class CMyWeapon : public CItem, public IWeapon
{
   // IItem, IGameObjectExtension
   virtual bool Init(IGameObject * pGameObject);
   virtual void InitClient(int channelId) { CItem::InitClient(channelId); };
   virtual void Release();
   //...other IItem, IGameObjectExtension methods

   // IWeapon
   virtual void StartFire();
   virtual void StartFire(const SProjectileLaunchParams& launchParams);
   virtual void StopFire();
   virtual bool CanFire() const;
   virtual bool CanStopFire() const { return true; }
   //... other IWeapon methods
}

When implementing a new weapon class, it's recommended to derive from the CWeapon class. The following functions from CWeapon are the most common ones overridden to provide new gameplay functionalities:

The final step for your custom weapon, to be useable in the weapon xml file, is to register it in the Game Factory (Code\Game\GameDll\GameFactory.cpp), the central point to register new Game Objects:

#include "MyWeapon.h"
//...
void InitGameFactory(IGameFramework *pFramework)
{
   //...
   REGISTER_FACTORY(pFramework, "MyWeapon", CMyWeapon, false);
   //...
}

Fire Mode Class

The GameSDK example code already includes many unique fire modes:

• Automatic
• AutomaticShotgun
• Burst
• Charge
• Detonate
• LTagSingle
• Melee
• Plant
• Rapid
• Shotgun
• Single
• Spammer
• Throw

In case these fire modes aren't sufficient, it's possible to implement a new fire mode by deriving from the IFireMode interface:

class CMyFiremode : public IFireMode
{
   virtual void Init(IWeapon *pWeapon, const struct IItemParamsNode *params, uint32 id);
   virtual void PostInit();
   virtual void Update(float frameTime, uint32 frameId);
   virtual void PostUpdate(float frameTime);
   virtual void Reload(int zoomed);

   //...other IFireMode methods
}

In most of the cases, deriving from the existing CSingle class should simplify this process. If this approach is followed, the following functions are usually the only ones needed to override:

The final step for your custom fire mode, to be useable in the weapon xml file, is to register it in the Weapon System implementation (Code\Game\GameDll\WeaponSystem.cpp):

CWeaponSystem::CWeaponSystem(CGame *pGame, ISystem *pSystem)
: m_pGame(pGame),
  m_pSystem(pSystem),
  m_pItemSystem(pGame->GetIGameFramework()->GetIItemSystem()),
  m_pPrecache(0),
  m_reloading(false),
  m_recursing(false),
  m_frozenEnvironment(false),
  m_wetEnvironment(false),
  m_tokensUpdated(false)
{
   //...
   RegisterFireMode("MyFireMode", &CreateIt<CMyFireMode, IFireMode>);
   //...
}

Projectile Class

The CProjectile class implemented in the GameDLL project provides most of the functionality needed. It is possible to extend this class by deriving from it, for example to implement new functionality for homing missiles or to have a new class of explosives.

When deriving from CProjectile, the following functions should be able to give enough flexibility to expand its gameplay features.

The final step for your custom projectile is to register it in the Weapon System implementation (Code\Game\GameDll\WeaponSystem.cpp):

CWeaponSystem::CWeaponSystem(CGame *pGame, ISystem *pSystem)
: m_pGame(pGame),
  m_pSystem(pSystem),
  m_pItemSystem(pGame->GetIGameFramework()->GetIItemSystem()),
  m_pPrecache(0),
  m_reloading(false),
  m_recursing(false),
  m_frozenEnvironment(false),
  m_wetEnvironment(false),
  m_tokensUpdated(false)
{
   //...
   REGISTER_PROJECTILE(MyProjectile, CMyProjectile);
   //...
}

Zoom Mode Class

The SDK example already includes the following zoom modes: IronSight and Scope. In case you need a customized zoom mode for your weapon it's possible to implement a new zoom mode by deriving from the IZoomMode interface:

class CMyZoomMode : public IZoomMode
{
   virtual bool CanZoom() const;
   virtual bool StartZoom(bool stayZoomed = false, bool fullZoomout = true, int zoomStep = 1);
   virtual void StopZoom();
   virtual void ExitZoom(bool force=false);

   //...other IZoomMode methods
}

In most of the cases, deriving from the existing CIronSight class should simplify this process. If this approach is followed, the following functions are usually the only ones needed to override:

The final step for your custom zoom mode is to register it in the Weapon System implementation (Code\Game\GameDll\WeaponSystem.cpp):

CWeaponSystem::CWeaponSystem(CGame *pGame, ISystem *pSystem)
: m_pGame(pGame),
  m_pSystem(pSystem),
  m_pItemSystem(pGame->GetIGameFramework()->GetIItemSystem()),
  m_pPrecache(0),
  m_reloading(false),
  m_recursing(false),
  m_frozenEnvironment(false),
  m_wetEnvironment(false),
  m_tokensUpdated(false)
{
   //...
   RegisterZoomMode("MyZoomMode", &CreateIt<CMyZoomMode, IZoomMode>);
   //...
}

The Weapon XML

Creating the final weapon is completely done in an easy to edit XML file, which should be stored in <Game_Folder>/Scripts/Entities/Items/Weapons/.

A good starting point for creating your own weapon XML implementation is to use the shipped Rifle.xml script. It already includes everything you need to have a usable and realistic weapon. More details about the general structure of a weapon XML implementation can be found via comments inside the Rifle.xml weapon example.