csgo/cstrike15_src/game/client/cstrike15/buy_presets/buy_presets.h

//====== Copyright � 1996-2005, Valve Corporation, All rights reserved. =======
//
// Purpose: 
//
//=============================================================================

#ifndef BUY_PRESETS_H
#define BUY_PRESETS_H
#ifdef _WIN32
#pragma once
#endif

#define USE_BUY_PRESETS 1

/**
 * CLASS STRUCTURE:
 *  Buy presets are managed by TheBuyPresetManager, which has a list of BuyPreset objects.
 *  Each BuyPreset has a list of fallback WeaponSets.  Each WeaponSet is a complete set of
 *  weapons and equipment that could be purchased by a buy preset.
 *
 * BUYING:
 *  When purchasing a buy preset, the fallback WeaponSets are considered in order from first
 *  to last.  When one is deemed to be purchasable, the buy commands are generated and
 *  processing stops.
 *
 * EDITING:
 *  When editing buy presets, TheBuyPresetManager maintains a second list of BuyPresets, to
 *  allow an all-or-nothing undo system.  The editing is done on two main VGUI menus: a
 *  list of the four main buy presets (CBuyPresetEditMainMenu), and a menu showing the
 *  fallbacks for a single preset (CBuyPresetEditOutfitListMenu).
 *
 *  Presets and fallbacks can be copied, created, deleted, etc from these pages.  From the
 *  fallback menu, a wizard can edit the contents of a fallback, specifying primary weapon,
 *  pistol, and equipment.
 */

#include "weapon_csbase.h"
#include <keyvalues.h>
#include <utlvector.h>

class BuyPreset;
class CCSWeaponInfo;

//--------------------------------------------------------------------------------------------------------------
enum BuyPresetStringSizes
{
	BUY_PRESET_COMMAND_LEN = 256,
	MaxBuyPresetName = 64,
	MaxBuyPresetImageFname = 64,
};

enum AmmoSizeType
{
	AMMO_PERCENT,
	AMMO_CLIPS,
	AMMO_ROUNDS
};

enum { NUM_PRESETS = 4 };

//--------------------------------------------------------------------------------------------------------------
/**
 *  A BuyPresetWeapon stores the mp.dll version of the WeaponID, the increment for buying ammo (clips, rounds, etc),
 *  the number of increments to buy, etc.  This is the basic info for buying a weapon that is present in an
 *  item set.
 */
class BuyPresetWeapon
{
public:
	BuyPresetWeapon();
	explicit BuyPresetWeapon( CSWeaponID weaponID );
	//BuyPresetWeapon& operator= (const BuyPresetWeapon& other); // default implementation should work

	const wchar_t*	GetName() const { return m_name; }				///< Returns the display name corresponding to the weapon ID
	CSWeaponID		GetCSWeaponID() const { return m_weaponID; }		///< Returns the WEAPON_* weapon ID
	void			SetWeaponID( CSWeaponID weaponID );				///< Sets the WEAPON_* weapon ID (and resets ammo, etc)

	void			SetAmmoType( AmmoSizeType ammoType ) { m_ammoType = ammoType; }	///< Sets the ammo type - percent (unused), clips, or rounds (unused)
	void			SetAmmoAmount( int ammoAmount ) { m_ammoAmount = ammoAmount; }	///< Sets the amount of ammo, in units relevant to the ammo type
	void			SetFillAmmo( bool fill ) { m_fillAmmo = fill; }	///< Sets whether the weapon's ammo should be topped off

	AmmoSizeType	GetAmmoType() const { return m_ammoType; }		///< Returns ammo type - percent (unused), clips, or rounds (unused)
	int				GetAmmoAmount() const { return m_ammoAmount; }	///< Returns the amount of ammo, in units relevant to the ammo type
	bool			GetFillAmmo() const { return m_fillAmmo; }		///< Returns true if the weapon's ammo should be topped off

protected:
	const wchar_t	*m_name;
	CSWeaponID		m_weaponID;
	AmmoSizeType	m_ammoType;
	int				m_ammoAmount;
	bool			m_fillAmmo;
};

typedef CUtlVector< BuyPresetWeapon > BuyPresetWeaponList;

//--------------------------------------------------------------------------------------------------------------
/**
 *  A WeaponSet is part of a buy preset.  Each buy preset is composed of a series of (fallback) WeaponSets.
 *  The WeaponSet contains a snapshot of a set of weapons and equipment that should be bought.
 */
class WeaponSet
{
public:
	WeaponSet();

	void GetCurrent( int& cost, WeaponSet& ws ) const;								///< Generates a WeaponSet containing only items that would be bought right now
	void GetFromScratch( int& cost, WeaponSet& ws ) const;							///< Generates a WeaponSet containing everything that would be bought from scratch

	void GenerateBuyCommands( char command[BUY_PRESET_COMMAND_LEN] ) const;			///< Generates a list of commands to buy the current WeaponSet.

	int FullCost() const;															///< Calculates the full cost of the WeaponSet, including all optional items

	void Reset( void );

	const BuyPresetWeapon& GetPrimaryWeapon() const { return m_primaryWeapon; }
	const BuyPresetWeapon& GetSecondaryWeapon() const { return m_secondaryWeapon; }

	BuyPresetWeapon m_primaryWeapon;
	BuyPresetWeapon m_secondaryWeapon;

	// Equipment --------------------------------
	int		m_armor;
	bool	m_helmet;
	bool	m_smokeGrenade;
	bool	m_HEGrenade;
	int		m_flashbangs;
	bool	m_defuser;
	bool	m_nightvision;
};

typedef CUtlVector< WeaponSet > WeaponSetList;

//--------------------------------------------------------------------------------------------------------------
/**
 *  The BuyPreset is a complete representation of a buy preset.  Essentially, it consists of the preset name,
 *  whether or not the preset is used for autobuy, and a list of fallback WeaponSets.
 */
class BuyPreset
{
public:
	BuyPreset();
	~BuyPreset();
	BuyPreset(const BuyPreset& other);

	void SetName( const wchar_t *name );
	const wchar_t * GetName() const { return m_name; }

	void Parse( KeyValues *data );								///< Populates data from a KeyValues structure, for loading
	void Save( KeyValues *data );								///< Fills in a KeyValues structure with data, for saving

	int GetNumSets() const { return m_weaponList.Count(); }		///< Returns the number of fallback WeaponSets
	const WeaponSet * GetSet( int index ) const;				///< Returns the specified fallback WeaponSet, or NULL if it doesn't exist

	int FullCost() const;										///< Calculates the full cost of the preset, which is exactly the full cost of the first fallback WeaponSet

	// editing functions --------------------
	void DeleteSet( int index );								///< Deletes a fallback
	void SwapSet( int firstIndex, int secondIndex );			///< Switches the order of two fallbacks
	void ReplaceSet( int index, const WeaponSet& weaponSet );	///< Replaces a fallback with the supplied WeaponSet

private:
	wchar_t m_name[MaxBuyPresetName];

	WeaponSetList m_weaponList;
};

typedef CUtlVector< BuyPreset > BuyPresetList;

//--------------------------------------------------------------------------------------------------------------
/**
 *  The BuyPresetManager singleton manages saving/loading/buying the individual BuyPresets.  It also tracks the
 *  ownership of some items that aren't explicitly known by the client (defuser, nightvision).
 *
 *  Two sets of BuyPresets are maintained - the live set used for purchasing, and a set that is acted upon for
 *  editing.  This provides the basic save changes/abandon changes ability when editing presets.
 */
class BuyPresetManager
{
public:
	BuyPresetManager();

	void Save();

	void PurchasePreset( int presetIndex );							///< Generates and sends buy commands to buy a specific preset

	int GetNumPresets() { VerifyLoadedTeam(); return m_presets.Count(); }
	const BuyPreset * GetPreset( int index ) const;					///< Returns the specified "live" preset, or NULL if it doesn't exist
	void SetPreset( int index, const BuyPreset *preset );

	void SetPresets( const BuyPresetList& presets ) { m_presets = presets; }

	void SetEditPresets( const BuyPresetList& presets ) { m_editPresets = presets; }
	int GetNumEditPresets() const { return m_editPresets.Count(); }

	BuyPreset * GetEditPreset( int index );							///< Returns the specified editing preset, or NULL if it doesn't exist
	const CUtlVector< BuyPreset >& GetEditPresets() const { return m_editPresets; }

	void ResetEditPresets() { m_editPresets = m_presets; }			///< Resets the editing presets to the live presets (e.g. when starting editing)
	void ResetEditToDefaults( void );							///< Loads the default presets into the editing presets (e.g. when hitting the "Use Defaults" button)

	void GetCurrentLoadout( WeaponSet *weaponSet );

private:
	BuyPresetList	m_presets;		///< Current (live) presets
	BuyPresetList	m_editPresets;	///< BuyPresets used when editing

	int m_loadedTeam;
	void VerifyLoadedTeam( void );
};

//--------------------------------------------------------------------------------------------------------------
extern BuyPresetManager *TheBuyPresets;

//--------------------------------------------------------------------------------------------------------------
/**
 *  Functions for controlling the display of the various buy preset editing menus.  Opening one closes any
 *  others open.
 */
enum { REOPEN_YES, REOPEN_NO, REOPEN_DONTCHANGE };					///< Determines if we need to re-open the buy menu when done editing.
void ShowBuyPresetMainMenu( bool runUpdate, int reopenBuyMenu );	///< Open the main preset editing menu
void ShowBuyPresetEditMenu( int presetIndex );						///< Open the menu for editing the list of fallbacks for an individual preset

//--------------------------------------------------------------------------------------------------------------
/**
 *  Constructs a list of weapons that will satisfy the any unfinished weapon-specific career tasks:
 *   1.  If there are no unfinished career tasks, the source list is returned
 *   2.  If there are unfinished career tasks, all weapons that can be used for the tasks are added
 *       to the front of the list.  This list of career weapons is sorted according to the order of
 *       weapons in the source list, so that if any weapons in the source list can be used for career
 *       tasks, they will be.
 */
BuyPresetWeaponList CareerWeaponList( const BuyPresetWeaponList& source, bool isPrimary, CSWeaponID currentClientID );

//--------------------------------------------------------------------------------------------------------------
/**
 *  Returns the number of clips that will have to be bought for the specified BuyPresetWeapon
 */
class CCSWeaponInfo;
int CalcClipsNeeded( const BuyPresetWeapon *pWeapon, const CCSWeaponInfo *pInfo, const int ammo[MAX_AMMO_TYPES] );

//--------------------------------------------------------------------------------------------------------------
/**
 *  Fills the ammo array with the ammo currently owned by the local player
 */
void FillClientAmmo( int ammo[MAX_AMMO_TYPES] );

//--------------------------------------------------------------------------------------------------------------
/**
 *  Returns true if the client can currently buy the weapon according to class/gamemode restrictions.  Returns
 *  true also if the player owns the weapon already.
 */
bool CanBuyWeapon( CSWeaponID currentPrimaryID, CSWeaponID currentSecondaryID, CSWeaponID weaponID );

//--------------------------------------------------------------------------------------------------------------
/**
 *  Returns the display name for a weapon, based on it's weaponID
 */
const wchar_t* WeaponIDToDisplayName( CSWeaponID weaponID );

//--------------------------------------------------------------------------------------------------------------
// If our weapon is NONE, we want to be able to buy up to this many clips for the current gun we're holding
enum { NUM_CLIPS_FOR_CURRENT = 4 };

#if USE_BUY_PRESETS
extern ConVar cl_buy_favorite_quiet;
extern ConVar cl_buy_favorite_nowarn;
#endif // USE_BUY_PRESETS

#endif // BUY_PRESETS_H