nyuuzyou/wikis huggingface dataset:
C4 Commando

A modification for Half-Life 2
==About==
In this third person shooter, you control commando Jack "Rambo" Sheppard.With a pack of explosives, grenades, a sniper rifle and a combat knife, wherever Jack goes, he leaves a wake of destruction. In multiplayer mode, Commanders can train infantry, build units and structures, and soldiers can utilize a vast amount of weapons and vehicles.
Drive, ride, pilot. Ranging from a Raptor Attack Cycle, M1026A1 HMMWV, AH-64A Apache, M113A2 Armored Personnel Carrier to Air Cushioned All Terrain Landing Craft, there are more than 30 ways to crush the opposition.
==Features==
* All out warfare for Half-Life 2 
* Realistic Physics
* Explosive Action
* Heavy weapons and vehicles
* Hand-to-hand combat
==Team==
Team info is available on the C4 website.
==Other info==
* C4 Commando Forums
* C4 Commando Image Gallery
* C4 Commando
CAreaPortal

The CAreaPortal class represents an areaportal. It's a very simple affair in game code, but also a very unusual entity.
== Caveats ==
; Areaportals do not exist in the world
: Although portals are created as brushes in Hammer, at runtime they are something quite unique: while they do exist at a location, that location is not in the same dimension, as it were, as anything else. Any function with which you try to return a portal's origin will only give (0,0,0).
: If you really do want to give an areaportal an origin, you can add a new keyvalue to your FGD - but don't use the standard origin key or the portal will fail to compile. Make a new KV and link it to m_vecOrigin in your DataDesc instead.
: Alternatively, you could follow CFuncAreaPortalWindow's example and piggyback on an associated brush entity's origin.
;Areaportals are closed and opened on the server
:Since portal flow also helps decide which entities are transmitted to a client, a portal's state is decided by the server. This happens separately for each connected player. The resulting value is presumably networked to the client for rendering control somewhere outside the SDK's code.
== UpdateVisibility() ==
This is the function called every tick by the server to decide whether or not the portal should be opened or closed.
As well as simply responding to a 'hard' value of closure (i.e. input, initial state, or linked door status) that is the same for every client, it calculates a 'soft' value by checking whether or not the plane facing towards the player's current area is also facing the player's origin (vOrigin). If it isn't, which is to say if the player has doubled back around a corner from it, the portal is closed for them.
A small amount of padding is added to backfacing tests to prevent client-server latency from causing the portal to open too late (look for VIEWER_PADDING in server\func_areaportalbase.cpp). This is why UpdateVisibility() is called even when the portal isn't in PVS.
== See also ==
*Areaportal
*func_areaportal
*CFuncAreaPortalWindow / func_areaportalwindow
*CAreaPortalOneWay (source code for new entity)
Category:Classes
CBaseAnimating

CBaseAnimating is the C++ class from which all entities with models inherit, even if they don't actually move.
== Keyvalue handling ==
Doesn't override CBaseEntity's KeyValue function so no special keys are present. 
, , 
=== Keyfields ===
== Inputs ==
=== Input keys ===
=== Input functions ===
== Outputs ==
== Other fields ==
=== Keyless fields ===
=== Array fields ===
=== Custom fields ===
 
== Entity debugging ==
=== ===
Additional information added to ent_text overlay by this class
* Sequence: (<sequence number>) <sequence name>
* Activity: <activity name> (only if there is one) 
* Cycle: <cycle> (<animation time>)
exact format: 
"Sequence: (%3d) %s",GetSequence(), GetSequenceName( GetSequence() )
"Activity %s", GetSequenceActivityName(GetSequence()) (only if there is one) 
"Cycle: %.5f (%.5f)", (float)GetCycle(), m_flAnimTime.Get()
B
CBaseModFrame

CBaseModFrame is the basic C++ class that each user interface window in GameUI inherits from.
== Simple example ==
#include "gameui\swarm\basemodui.h"
using namespace BaseModUI;
class MyWindow : public CBaseModFrame
{
	DECLARE_CLASS_SIMPLE( MyWindow, CBaseModFrame );
public:
	MyWindow(vgui::Panel *parent, const char *panelName):BaseClass(parent, panelName) { }
};
A "MyWindow.res" layout script is also required in resource\ui\basemodui\:
Resource/UI/MyWindow.res
{
	MyWindow
	{
		ControlName		Frame
		fieldName		MyWindow
		xpos			c
		ypos			c
		wide			1024
		tall			768
		autoResize		0
		pinCorner		0
		visible			1
		enabled			1
		tabPosition		0
		usetitlesafe		1
	}
}
== Key functions ==
* void OnOpen()
* void OnClose()
* void SetDataSettings(KeyValues*)
* CBaseModFrame* SetNavBack(CBaseModFrame*)
* CBaseModFrame* GetNavBack()
* void PushModalInputFocus()
** void PopModalInputFocus()
* void RunFrame()
* void AddFrameListener(IBaseModFrameListener*)
** void RemoveFrameListener(IBaseModFrameListener*)
** void RunFrameOnListeners()
== See also ==
* GameUI
Category:VGUI B
CBasePlayer

CBasePlayer is the class from which all player classes should inherit. See also :Category:CBasePlayer.
==Mapping==
Using trigger_ brushes and !activator, !player, or !pvsplayer keywords, you can access player entities. Some of these functions can be called using input/output systems. 
==Server==
===Functions===
This list is cursory and may be inaccurate:
(see: player for properties and functions.)
*Weapon selection
*Viewmodel state
*FOV (including zoom)
*Eye position & smoothing
*Current PVS (for network updates)
*Flashlight state
 * DisableFlashlight: Disables the player's flashlight.
 * EnableFlashlight: Enables the player's flashlight.
*Battery state (sprinting, flashight drain, oxygen supply...)
*Ladder state
*Hint system
*Respawn state
*Connection state
*Receiving & managing usercmds (CPlayerMove executes)
*Some prediction setup
*CreatePlayer (called from <game>_client)
*Autokick enabled/disabled
*Player name, chat, team & serverID
*Spectator system
*Bot plug-in support
*Client-to-server console commands
*MP tonemap Hammer input (new addition, available in SDK but has yet to roll out to Valve's own games)
*Armour amount
*Score, kills, deaths
*Suicide
*Time-based damage (drowning, fire...)
*VPhysics shadow
*Special QPhysics movement code
*"Player-simulated entities"
*Auto-aim
*HEV suit (vox, Geiger counter)
*HUD updates (inc. damage received)
*Using/picking up objects
*Vehicle interaction
*"Replay mode"
*Footsteps
*Gamepad rumble
*Debug overlays
*Level fog
===Related classes===
*CBaseCombatCharacter (base class)
*CBotManager (friend class)
*CPlayerMove
*CUserCmd
*CPlayerInfo
*CPlayerCmdInfo
*CPlayerSimInfo
*CCommandContext
*CBloodSplat
==Client==
...
==See also==
* CBaseMultiplayerPlayer - Multiplayer-oriented player base class.
B
!
CBeam

==Keyvalues / Inputs==
=== KeyFields ===
=== Inputs ===
=== Input Functions ===
== Fields ==
=== Array fields ===
=== Only in ===
== Constants ==
*MAX_BEAM_WIDTH = 102.3f
*MAX_BEAM_SCROLLSPEED = 100.0f
*MAX_BEAM_NOISEAMPLITUDE = 64
== Entity debugging ==
=== Additional information in overlay ===
* start: <origin>
* end: <m_vecEndPos>
exact format:
start: (%.2f,%.2f,%.2f)", GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z
end : (%.2f,%.2f,%.2f)", m_vecEndPos.GetX(), m_vecEndPos.GetY(), m_vecEndPos.GetZ()
 
== See Also ==
CCExporter

== CCExporter ==
CCExporter is a software that allows you to export closedcaption_languge.txt files into JSON and back into VDF
It Also Has support for compiling JSON files straight into .dat files that the source engine uses
Eliminating the need to use CaptionCompiler.exe
The main feature is its exporter which can allow you to quickly export closed caption files into a suitable format 
for crowdsourced translation websites and make moder's life easier with the help of the community to help translate mods
faster and easier
 also has a built-in CLI and GUI 
For more information visit the GitHub page 
CCExporter GitHub Page
== Download ==
Latest Release Build CCExporter GitHub Release
CCommand

CCommand is a tokenizer used mainly in ConCommands.
It tokenizes a string like "say Valve Developer Community" to a series of arguments (args), in this case being:
Argument 0: say 
Argument 1: Valve 
Argument 2: Developer 
Argument 3: Community
== Functions ==
; int CCommand::ArgC()
: Returns number of arguments.
; const char *CCommand::Arg( int nIndex )
: Returns the argument nIndex of this CCommand.
; const char *CCommand::ArgS()
: Returns all args that occur after the 0th arg, in string form
; const char *CCommand::GetCommandString()
: Returns the original command (the entire command in string form, including the 0th arg)
Category:Programming
Category:Console
CFG

Configuration file (or CFG) is a games text file used to execute a newline-delimited list of console commands to the Developer Console. The .cfg file extension can be found everywhere and is not specific to Source.
== File format ==
* Each line is considered a command. Note that each command can still consist of multiple commands delimited with the semicolon ;.
* Comments can be added by using //. These two characters and everything following after them is ignored by the engine until the next line starts.
* Cheat commands require enabled, otherwise they have no effect. To configure a mod's default cheat convars, VScript or can achieve this on map start without having to enable sv_cheats.
==Files==
The folder <game>/cfg/ is usually dedicated to CFG files and can be further organized in subdirectories, and referred in by relative path.
This is a table listing common CFG files found in mods and games alike.
CFG 	Description
autoexec.cfg 	Ran on game start up, so one can easily create the file and put any commands that one doesn't want to type each time.
chapter#.cfg 	Ran when the player picks the chapter, with # being the chapter number, see Adding chapters to your mod.
config.cfg 	Ran on game start up, this is created automatically when the player runs the game/mod for the first time.
config_default.cfg 	Ran when no config.cfg is present or when player clicks the 'Use Defaults' button in the keyboard tab in the options panel, see Customizing Options: Keyboard.
360controller.cfg 	Used for players using , (or XInput-compatible) controllers, lists the controls for the controller. Automatically executed when player enable Gamepad support in game options.
360controller-linux.cfg 	Used for players using , , (or XInput-compatible) controllers on Linux systems, lists the controls for the controller.
undo360controller.cfg 	Used for players using , , (or XInput-compatible) controllers when they want to undo the effects of the controller.
game.cfg 	Ran every time a map is loaded.
listenserver.cfg 	Ran when a listen server is being started, and runs every time the map is changed.
modsettings.cfg 	Ran on game start up, unless not found in mod folder.
server.cfg 	Ran when a dedicated server is being started, and runs every time the map is changed.
skill_manifest.cfg 	Runs every time the map is changed, used to list the skill.cfgs to execute.
sourcevr_modfoldername.cfg	Ran when the player enables VR, replace modfoldername with the name of your folder that gameinfo.txt is in.
userconfig.cfg 	Ran on game start up, for "custom configurations", as a comment in config.cfg describes it. The pre-Steam version of Half-Life does not load it automatically, and users place configurations in autoexec.cfg instead. (rumor)
valve.rc 	Special cfg file with the .rc extension, it's ran on game start up and executes autoexec.cfg along with a few other commands.
==See also==
* Mini-mod tutorial
* vtest - Alternative to cfg files.
* 
* 
Category:Plain text formats
Category:Plain text files
Category:File formats
Category:Source
CHRONOPORT

== Overview ==
This Mod is about time travel (or chronoportation). While traveling in time, one can create different kinds of anachronysms, paradoxes, etc. It was implemented in CHRONOPORT a mathematical model which describes some of anachronism phenomenas caused by travel in time. The action happens in Portal-like settings in some very isolated place, so that the time-line variations would not influence much the rest of the world. In this Mod I would like to demonstrate the potential of the idea of time-travel for the first-person shooter/adventure/puzzle games. Travel in time should create the feeling of more dimensions and of existence of multiple variations for the same Universe.
=== EPISODE 1 - THE HYPOTHESIS ===
In this short episode the player will face a puzzle involving a weighted cube and buttons. This puzzle can be solved only by changing the time-line. As a fathefull researcher, the player's task will be to prove experimentally the existence of time-line variation and to establish the basic time-line variation rules.
=== EPISODE 2 ===
TBA
== Features ==
* Time travel (chronoportation)
* Timeline variation
* Anachronisms
* Experiments
* Puzzles
== Media ==
== Team ==
* Vladimir Rogojin
* Mika Vihersaari
I greatly appreciate the help and advice of my friends:
* Elizaveta Rastorgueva
* Jani Sainio
== External links ==
* 
Category:Single Player Mods
CHandle

CHandle is a C++ class that represents a 32-bit ID (entindex + serial number) unique to every past and present entity in a game. It is used to refer to entities where pointers and entity indexes are unsafe; mainly across the client/server divide and after restoring a saved game.
== Usage ==
 CHandle<YourStoredClass> hMyHandle;
A CHandle is broadly similar to a pointer, but as it is a custom C++ class, and not a built-in feature, extra syntax is needed in some places:
* You must assign a pointer to the object, not the object itself.
* The CHandle's Get() function, or a cast, is required access the class it is storing.
* IsValid() is used to check whether a value is stored.
* To invalidate, call Term() or assign INVALID_EHANDLE_INDEX.
== EHANDLE ==
CHandle is often used through the EHANDLE typedef, which is shorthand for CHandle<C_BaseEntity>. If you want to store a particular class it's better to declare a more specific CHandle manually (see previous section).
== Example ==
// Create a pointer to an entity
CBasePlayer* pPlayer = gEntList.FindEntityByClassname( NULL, "player" );
 
// Store it (twice, for demonstration purposes)
EHANDLE hPlayer = pPlayer;
CHandle<CBasePlayer> hPlayer_ = pPlayer;
 
// Convert the EHANDLE back to a CBasePlayer pointer
pPlayer = dynamic_cast<CBasePlayer*>( hPlayer.Get() );
== See also ==
* Accessing other entities
* Entity index
* Networking Entities
Category:Source class
Category:Variables
CMeshBuilder

The CMeshBuilder can be used to draw primitives. In most cases it is required that you call CMeshBuilder inside of DrawModel. Also, DrawModel will only be called for your C_BaseEntity if you have the ShouldDraw function return true.
#ifdef CLIENT_DLL
	virtual bool	ShouldDraw() { return true; }
	virtual int	DrawModel( int flags );
#endif
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: Override to allow us to draw motion blur quads
//-----------------------------------------------------------------------------
int YourClass::DrawModel( int flags )
{
// Do something here to get your vectors....
	CMatRenderContextPtr pRenderContext( materials );
	IMesh *pMesh;
//Must be bound before the call to get the mesh
	pRenderContext->Bind( pBlurMaterial );
	pMesh = pRenderContext->GetDynamicMesh();
	CMeshBuilder meshBuilder;
	meshBuilder.Begin( pMesh, MATERIAL_QUADS, 1 );
	meshBuilder.Color3f( 1.0f, 1.0f, 1.0f );
	meshBuilder.TexCoord2f( 0,0,0 );
	meshBuilder.Position3f( posL.x,posL.y,posL.z );
	meshBuilder.AdvanceVertex();
	meshBuilder.Color3f( 1.0f, 1.0f, 1.0f );
	meshBuilder.TexCoord2f( 0,1,0 );
	meshBuilder.Position3f( posR.x,posR.y,posR.z );
	meshBuilder.AdvanceVertex();
	meshBuilder.Color3f( 1.0f, 1.0f, 1.0f );
	meshBuilder.TexCoord2f( 0,1,1 );
	meshBuilder.Position3f( oldPosL.x, oldPosL.y, oldPosL.z );
	meshBuilder.AdvanceVertex();
 meshBuilder.Color3f( 1.0f, 1.0f, 1.0f );
	meshBuilder.TexCoord2f( 0,0,1 );
 meshBuilder.Position3f( oldPosR.x, oldPosR.y, oldPosR.z );
	meshBuilder.AdvanceVertex();
	meshBuilder.End();
	pMesh->Draw();
	}
	return BaseClass::DrawModel( flags );
}
#endif
Category:Programming
CPointEntity/definitions

=== baseentity.h ===
class CPointEntity : public CBaseEntity
{
public:
	DECLARE_CLASS( CPointEntity, CBaseEntity );
	void	Spawn( void );
	virtual int	ObjectCaps( void ) { return BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
	virtual bool KeyValue( const char *szKeyName, const char *szValue );
private:
};
=== baseentity.cpp ===
bool CPointEntity::KeyValue( const char *szKeyName, const char *szValue ) 
{
	if ( FStrEq( szKeyName, "mins" ) || FStrEq( szKeyName, "maxs" ) )
	{
		Warning("Warning! Can't specify mins/maxs for point entities! (%s)\n", GetClassname() );
		return true;
	}
	return BaseClass::KeyValue( szKeyName, szValue );
}
=== subs.cpp ===
void CPointEntity::Spawn( void )
{
	SetSolid( SOLID_NONE );
//	UTIL_SetSize(this, vec3_origin, vec3_origin);
}
CRecipientFilter

The CRecipientFilter class enables the server to pick and choose which clients it passes an item of data to. Most server-to-client communication supports it.
Alongside adding/removing clients individually or all at once, it can filter by Potentially Audible Set, Potentially Visible Set and Team.
== Examples ==
 CRecipientFilter MyFilter;
 	MyFilter.AddRecipientsByPVS( GetAbsOrigin() );	// Clients within the entity's PVS will be added.
 	MyFilter.MakeReliable();
 CRecipientFilter MyInverseFilter;
 	MyInverseFilter.AddAllPlayers();
 	MyInverseFilter.RemoveRecipientsByPVS( GetAbsOrigin() );	// Leaving only players outside the PVS
 	MyInverseFilter.MakeReliable();
== Reliable vs. Unreliable ==
MakeReliable() gives any command using the filter instance a higher network transmission priority. It causes the data to be sent early on in the next network update, and to be queued if it can't be sent immediately. Data with an unreliable filter is sent at the end of the next packet if there is any room left, and is dropped and forgotten about if not transmitted immediately.
This is useful for prioritising network data at times of heavy traffic. 
== Derived classes ==
Several derived classes exist to automate the creation of common filters, with constructors set up to directly return an appropriately-configured instance.
;CBroadcastRecipientFilter()
;CReliableBroadcastRecipientFilter()
:All players.
;CPASFilter(origin)
;CPASAttenuationFilter(<various constructors>)
:All players in the origin's PAS. CPASAttenuationFilter will additionally remove those too far away to hear the sound.
;CPVSFilter(origin)
:All players in the origin's PVS.
;CSingleUserRecipientFilter(CBasePlayer)
:A specific player.
;CTeamRecipientFilter(int team, bool isReliable = false)
:A multiplayer team.
;CLocalPlayerFilter()
:The local player. Used as a dummy filter when calling functions requiring one on the client. Reliability is irrelevant.
=== Example ===
To make an entity produce a sound from another location:
 EmitSound( CPASFilter(pPuppet->GetAbsOrigin()),pPuppet->entindex(),"Ventriloquist.Hello" );
== See also ==
*Filters
*IRecipientFilter
*IResponseFilter
*INodeListFilter
*INearestNodeFilter
*IMapEntityFilter
*IEntityFindFilter
Category:Classes
CS:GO Map Publish Tool

The CS:GO Map Publish Tool is accessed by the console command workshop_publish from within the game.
__NOTOC__
==Adding your Map==
To upload a new map to workshop, click on Add, then fill out all the fields:
At least one game mode is required and you should check all CS:GO Game Modes your map would support. The checkbox Classic represents the modes and .
If your map is very large and fails to upload, add -lowmemworkshop to your game launch settings and try again.
==Updating your Map==
To make changes to an existing submission, select it in the published files list and click Edit.
This dialog looks allows you to edit any of the fields you set previously. In addition, when you upload a new version of your map you have the option of providing change notes in the Changes this update field.
When updating, only re-browse and select your BSP if you made changes to it. You can update title, description tags or the preview image without uploading a new BSP. These can also be edited on the workshop page of your entry.
==File Packing==
The map publish tool will automatically pack certain files if present. If any of the files are on disk at the time the map is selected for upload, the tool will add these to the BSP's pak file for you:
* maps/mapname.nav - A file used for bot navigation.
* maps/mapname.txt - A file used to populate the loading screen text.
* maps/mapname.kv - A file used to specify default game mode and character skins.
* resource/overviews/mapname_radar.dds - A file used for the radar and spectator overlays.
* resource/overviews/mapname_radar_spectate.dds - An optional file used for the spectator overview if you would like your overview to look different than your radar. If this doesn't exist, it falls back to using the radar file.
* maps/cfg/mapname.cfg - A cfg file to run when this map loads (used to support custom game modes).
Other files (for example, custom materials and textures not shipped with CS:GO) need to be packed in the bsp separately using bspzip or Third Party Tools.
==Known Errors==
When the Map Publish Tool is unable to update or upload the map, it will display a message referring to a specific error number. This section will attempt to explain them and show a possible solution:
* Error 2 - Unknown cause (likely network problem); Solution: Try uploading later. Possibly an issue with your upload stream or the Steam servers.
* Error 8 - Unknown cause (likely formatting issue); Solution: delete all contents within the "Change Notes" and "Description" dialog boxes.
Category:Counter-Strike: Global Offensive
CS:GO User Messages

===== User Messages in Counter-Strike: Global Offensive =====
User messages in CS:GO use Google's Protocol Buffers (protobuf). Protobuf is a message/object serialization language that generates code to serialize the objects efficiently. For information about protobuf, see https://developers.google.com/protocol-buffers/docs/overview
On Windows, follow these steps to generate C++ classes from CS:GO .proto files.
* Download and extract csgo_usermessages.zip 
* Download the protocol buffer compiler protoc-2.3.0 and extract it into the protoc-2.3.0-win32 folder that was created when you extracted csgo_usermessages.zip. The protocol buffer compiler is required to generate C++ classes from CS:GO .proto files. 
* Download protobuf-2.3.0 and extract it into the same folder as csgo_usermessages.zip. This package contains files that are included by CS:GO .proto files
* Run make_cc_files.bat. The generated C++ files are created in subdirectory named generated_proto.
You can now use the generated classes in your C++ code to send user messages. Here is an example of how to send the HintText message
	CSingleUserRecipientFilter filter( this );
	filter.MakeReliable();
	CCSUsrMsg_HintText msg;
	msg.set_text( "ExampleHint" );
	SendUserMessage( filter, CS_UM_HintText, msg );
User Messages
User Messages
CSM Hammer Editor

CSM Hammer Editor is an extension of the standard , featuring several key distinctions from the standard version.
== Features ==
* Manual entity input capability within the Entities field.
* Cursor modifications for enhanced visual cues.
* Toolbar icon revisions for improved accessibility.
* Inclusion of the original editor.wad with system textures.
* Addition of a radius table for the entity.
* Hotkeys implemented for "Save As," "Export to .map," and "Close Map" functions.
* Correction of names and functions for block, wedge, cylinder, spike, and arch entities.
* Default grid scale can now be set to 1 instead of the previous 4.
* Minor bugs have been rectified.
* Redesigned .map loading window.
* Revamped map issue detection window.
* Enhanced compilation window in "Expert" mode, offering a broader range of parameters.
* Increased window size for the list of connected .wad files.
* Overhauled texturing windows.
* Addition of a secret page accessible via a specific key combination.
== See also==
* 
* 
== External links ==