nyuuzyou/wikis huggingface dataset:
CSM to a Source Mod

=== About CSM ===
Detailed Explanation of what CSM is can be located here
=== Overview ===
this will be a detailed guide on how to implement celisej567's version of CSM since the guide on their GitHub repository is not detailed and is hard to follow
=== How to implement ===
# you must use 7.x source code only else the CSM will not work
# after downloading src copy the server and client folders from the repository to your own computer, the files inside have to be moved to your sp|mp/game/ directory
# go to your server directory and open server_base.vpc with any text editor and add $Include "$SRCDIR\game\server\csm.vpc" after the line $Include "$SRCDIR\game\server\server_mapbase.vpc" if you can not find this file place $Include "$SRCDIR\game\server\csm.vpc" near where most vpc files are
# now go to the client directory and open client_base.vpc and add the line $Include "$SRCDIR\game\client\csm.vpc" after $Include "$SRCDIR\game\client\client_mapbase.vpc" if you can not find this line please add $Include "$SRCDIR\game\client\csm.vpc" where most .vpc files are listed
# go back to your src directory and launch the creategameprojects.bat and compile your source mod
# Copy materials folder from the repository to the compiled mod
# open Steam library folder (C:\Program Files (x86)\Steam\steamapps\common\) and in Source SDK Base 2013 (Multiplayer or Singleplayer) folder go to bin and copy the fgd/csm.fgd from the repository to the bin folder
# find the halflife2.fgd file and open it with any text editor, and add @include "csm.fgd" at the end of the file
# Now restart hammer and you will have the env_cascade_light entity
CSPromod

==Overview==
First formed in Q1 of 2006, CSPromod was conceived as an attempt to bring a fully-customizable version of Counter-Strike to the Source Engine for the purposes of growing competitive play and broadcast spectatorship. With no disrespect to Valve Software or Turtle Rock Studios, the project arose from the opinion of many in the professional community: namely that Counter-Strike: Source was lacking in many key areas, and could be vastly improved upon. Much of the Counter-Strike community had been expecting CS:Source to be original CS gameplay with better graphics, and unfortunately, that’s not at all what CS:Source ended up being.
==Media==
Image:Csp_train_b20003.1.jpg|csp_train map - click to enlarge
Image:Cspromod_media_hud_004.jpg|CSPromod HUD - click to enlarge
Image:Csp_nuke_b4a0012.jpg|csp_nuke map - click to enlarge
==Development history==
The game's initial Beta 1.0 release in October 2007 represented about nine months of work, and while it admittedly was not fully realized, it did show proof of concept and solid base structure. Sadly, some of the community seemed to turn against the mod, due to the incredibly high expectations that had been built up for the project over time.
Back in 2007, it became very obvious fairly quickly to the entirety of the CSPTeam that for the community, showing was much better than telling. CSPromod Beta 1.04 release addressed many of the community’s questions, skepticism, and criticism, and in doing so, hopefully proved CSPromod to have become what many in the community have always hoped it would be.
==Release information==
* March 23, 2012 | BETA 1.09 (ALPHA DM Test Weekend)
* September 23, 2011 | BETA 1.08
* September 4, 2011 | BETA 1.07
* March 3, 2011 | BETA 1.06
* January 31, 2011 | BETA 1.05
* July 9, 2010 | BETA 1.04 (Hotfix)
* January 31, 2010 | BETA 1.04
* February 9, 2008 | BETA 1.03
* January 3, 2008 | BETA 1.02
* October 21, 2007 | BETA 1.01
* October 18, 2007 | BETA 1.00
==External links==
* Official Website
* Official Developer Updates
* 
* Official Twitter Account
* Official Steam Community Group
* Official Youtube Channel
CSS/Animated Clouds

== Finding the model ==
Moving Clouds are a simple prop_dynamic away, below are some of the models you can use.
Some models available in CS:S are:
* models/props/cs_office/clouds.mdl
* models/props/de_tides/clouds.mdl
* models/props/de_port/clouds.mdl
== Placing the model ==
# Make a 3D skybox.
# Place the model in the map as a prop_dynamic or func_brush if its brushwork.
# Put the prop_dynamic by the center of your sky_camera in the skybox.
# Be sure to make it so the entities Shadow Property is set to Off else it might block the sunlight in your skybox.
== See also ==
* Creating Animated Clouds
Category:Tutorials
Category:Skybox
Category:Counter-Strike: Source
CSS Bugs

This page tries to collect all of the bugs/issues and provide a fix for them if any are available at the current time, for both the games and the SDK itself. If any has further bugs or problems not on the list, please add them with a short guide for how to fix them too if possible.
==SDK==
None yet
==Game==
Both Teams are Full error.
The game cannot find an available spawn point, either because you forgot to place them, or because those you placed are invalid.
You need to have both info_player_counterterrorist and info_player_terrorist entities in the map, or the game will not be set up correctly. If both spawn points has been placed, check the console. If it reports that your spawn points are invalid, the problem is usually that your spawn point entities are intersecting another surface in the map (usually the ground). (Unlike HL2SP and HL2DM spawn point entities, CS:S spawn point entities will intersect the ground if not placed a couple of units above it.) Try moving the entities up a little bit to make sure that they are not intersecting with anything.
Error reading weapon data file for: weapon_cubemap
This error occurs when a mod doesn't have the weapon script file for weapon_cubemap in the mod's directory.
If you're trying to get weapon_cubemap working in a mod, you will have to copy the weapon_cubemap script (hl2\scripts\weapon_cubemap.txt) from the Half-Life 2 folder to the mod's scripts folder. (For example: $SteamUserDir\steamapps\common\counter-strike source\cstrike\scripts\)
Category: Counter-Strike: Source
CSS SCI FI

CSS SCI FI 3: Hardwired is a single-player modification for . Waking up to find himself an augmented clone of Gordon Freeman, the player must fight time-travelling Combine forces and other enemies across 42 unique and replayable missions. 
== Overview ==
__NOEDITSECTION__
Missions in CSS SCI FI are set in 18 retail and 24 custom Counter-Strike: Source maps, which are installed intact to the player's CS:S game folder. The mod edits the entity data for each map as it is loaded, adding and modifying entities to create a seamless single-player experience. The maps remain unchanged and are fully playable in Counter-Strike: Source. Maps have been contributed by established designers, including Bluestrike, Schuzak and d00ds.com. Combat locations range from a snow-covered country church to a dense pine forest to a sun-baked tropical island.
Players enter each map through the mission hub and can choose to play each one at a time or all in 3 linked campaigns. Each mission features a series of goals, such as to rescue hostages or destroy targets, which must be completed to move on to the next map or return to the hub. There are multiple approaches to each goal, and in each map the behaviour and armament of enemies and the distribution of resources are randomly determined within defined parameters. Thus, no two plays are the same, making CSS SCI FI a truly replayable single-player experience.
== Key features at a glance ==
* Single-player.
* Requires only Counter-Strike: Source.
* Retains look and feel of Half-Life 2 while adding new weapons, enemies and abilities.
* Includes a custom mission hub, weapon test range and full configuration utility.
* Includes 24 custom maps for Counter-Strike: Source.
* Features 42 replayable non-linear missions, each with multiple goals and hidden secret weapons.
== Requirements ==
* 
** 
* SteamPipe workaround (if applicable)
* 1GB+ free hard disk space
* Source SDK Base 2006
== Configuration ==
The CSS SCI FI Configuration Utility is included in the mod installation. This program allows users to select and install 48 different game options, each of which may affect the difficulty, graphics, enhancements or gameplay of CSS SCI FI. These options are independent of Half-Life 2's standard in-game graphics and difficulty settings, and can be selected in any desired combination. After the Configuration Utility has been run, players do not need to run it again until they want to change a setting.
The Configuration Utility can be run at any time that the game itself is not running, and can be accessed using the launcher from the desktop or from the mod directory located at SourceMods/CSS SCI FI. For more about the CSS SCI FI Configuration Utility, please see the CSS SCI FI Configuration Reference Manual. 
== Download ==
* GameFront
* Internet Archive
== External links ==
* Mod Site (Archived)
* ModDB (Archived)
* Steam Group (Archived)
Category:Single Player Mods
Category:Source mods
CSTBSP

is a custom version of VBSP compiler written by Adam McKern. Similar in function to its Valve counterpart, CSTBSP creates a binary space partition file that is essentially your playable map.
CST tools were used in the development of SiN Episodes Emergence.
Although CSTBSP can be run by itself to create a basic map, the use of other two tools, CSTVIS and CSTRAD, is highly recommended for optimal results.
== Changelog ==
=== 1.0.1 ===
;Added
* Small plane count increase for the Dystopia team, to remedy their issues with dys_vaccine map.
;Improved 
* The code runs about 2% faster over all.
=== 1.0.1.1 ===
* A small fix for BSP spam.
=== 1.1 (25 Jan 06) ===
* All temp files (log, .lin, pts) are removed at tool startup.
* Correct locations of where level leaks are, thanks to Raven0.
=== Final ===
;Added
* Leaf saw vector - simply follow the steps in the error code to find where the leaf saw is (buggy because the last number is normally off the grid).
* An 64 bit build.
;Fixed
* Cleaned up the error code from beta3/beta4 - sorry for the mega spam.
;Improved
* RAD quality for some lights.
;Changed
* VIS, and RAD executable names.
;Removed
* The redirect files from the download (and setup page).
* All support for bloodlines (no interest was shown).
== See also ==
* ammahls.com - the author's website.
* Map Compiling Theory
Category:Third Party Source Tools
Category:Source 1 BSP compilers
CSTRAD

is a custom version of VRAD compiler written by Adam McKern. Similar in function to its Valve counterpart, CSTRAD creates a lightmap data (radiosity lighting) that will light your map.
Although CSTRAD itself can be skipped during compile to create an unlit map, using the other two tools, CSTBSP and CSTVIS, is highly recommended for optimal results.
== See also ==
* ammahls.com - the author's website.
* Map Compiling Theory
Category:Third Party Source Tools
Category:Source 1 BSP compilers
CSTVIS

is a custom version of VVIS compiler written by Adam McKern. Similar in function to its Valve counterpart, CSTVIS creates a vismatrix data allowing sections of the world to not be drawn when they are not visible.
Although CSTVIS itself can be skipped during compile to create an unoptimized map, using the other two tools, CSTBSP and CSTRAD, is highly recommended for optimal results.
== See also ==
* ammahls.com - the author's website.
* Map Compiling Theory
Category:Third Party Source Tools
Category:Source 1 BSP compilers
CS Beta

== Overview ==
There is a beta version of Counter-Strike 1.6 available for testing. This beta introduces in game advertising. For the duration of the beta default Valve ads will be used, once the feature is released a wider range of advertisements will be present.
== Getting the Counter-Strike Beta ==
Install instructions. 
To run this beta version you will need to add -beta cs to your command line when you start Steam. This can be done by opening up the Windows shortcut you use to launch Steam and adding -beta cs right after Steam.exe. Please report any bugs or issue you find in this article.
 Important: You should also disable Steam from running automatically when Windows starts, to prevent it from running the non-beta Half-Life 1 engine. To disable Steam from running automatically:
# Open the Steam window.
# Choose Settings from the File menu.
# Click on the Interface tab.
# Uncheck the Run Steam when Windows starts option.
If you wish to have the Counter-Strike Beta launch when Windows starts, you can add a copy of your edited shortcut to the Windows Startup program group, under Start Menu > All Programs > Startup.
== Updates ==
2/15/07:
* D3D rendering issue fixed
* Small hud images fixed
* Aliasing images on scoreboard/spectator hud fixed
== Known Issues ==
== Bug reporting ==
To report any issues you find with the Counter-Strike Beta (and not the regular standard engine and games releases), visit these articles:
* Counter-Strike Beta Bug Reports - Report bugs here.
* Talk:Counter-Strike Beta Bug Reports - Discuss bugs here.
== Switching back to the non-beta engine ==
You can revert to the "non-beta" standard Counter-Strike release by following these steps:
# Exit Steam if it's currently running by right-clicking on the Steam tray icon and choosing Exit.
# Open the Windows shortcut you use to launch Steam and remove -beta cs.
# Launch Steam from the shortcut.
# Re-enable Run Steam when Windows starts option if desired.
# If you also added a modified Steam shortcut to the Windows Startup program group in order to launch the Counter-Strike Beta automatically, it also must be removed or edited.
Category:Counter-Strike Beta
CServerOnlyEntity/definitions

=== baseentity.h ===
// Has a position + size
class CServerOnlyEntity : public CBaseEntity
{
	DECLARE_CLASS( CServerOnlyEntity, CBaseEntity );
public:
	CServerOnlyEntity() : CBaseEntity( true ) {}
	
	virtual int ObjectCaps( void ) { return (BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION); }
};
CServerOnlyPointEntity

Server only equivalent of CPointEntity. Its super class is CServerOnlyEntity thus entities inheriting this won't have edicts.
Prevents entities from changing mins/maxs via keyvalues
bool CServerOnlyPointEntity::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 );
}
== See Also ==
* CLogicalEntity - the only difference from CServerOnlyPointEntity is the name (at least in source code)
CTX

CTX is the file format of an ICE encoded script. Most source multiplayer games use ICE encryption for weapon scripts and other gameplay modifying files, a good example of this is in Team Fortress 2. Once there is a CTX file present, the engine will only read from CTX files for that category (eg Weapon Scripts) even if the txt version is present, or there are some CTX files missing.
==See also==
* CtxConverter
* Vice
* Weapon script
Category:File formats
CUtlFlags

CUtlFlags is a simple class that makes the use of flags easier. Code can be found in public/tier1/utlflags.h.
== Setting flags ==
Setting a flag can be done using the SetFlag method, which takes a bitmask and the option to turn the flag on or off.
// Example of a flag enum
enum FlagEnum_t
{
	FLAG_ONE = 0x0001,
	FLAG_TWO = 0x0002,
	FLAG_THREE = 0x0004,
	FLAG_FOUR = 0x0008,
};
// Initialize flag class
CUtlFlags< unsigned short > flags;
// Turn on FLAG_ONE and FLAG_TWO
flags.SetFlag( FLAG_ONE );
flags.SetFlag( FLAG_TWO );
// Turn off FLAG_TWO
flags.SetFlag( FLAG_TWO, false );
== Clearing flags ==
Just as easily, you can clear a flag using SetFlag( FLAG, false ) or the more succinct ClearFlag( FLAG ):
// Clear FLAG_ONE
flags.ClearFlag( FLAG_ONE );
You can also clear all flags:
// Clear all flags
flags.ClearAllFlags();
== Querying flags ==
Using IsFlagSet( FLAG ) and IsAnyFlagSet(), you can check if a certain flag is set:
// Clear all flags
flags.ClearAllFlags();
flags.IsFlagSet( FLAG_ONE ); // Returns false
flags.SetFlag( FLAG_TWO );
flags.IsAnyFlagSet(); // Returns true
Category:Tier1
Category:Classes
Category:Flags
CUtlLinkedList overflow

A cryptic engine error can be encountered in certain situations, with the message CUtlLinkedList overflow! (exhausted memory allocator) or CUtlLinkedList overflow! (exhausted index range). This articles states potential causes and their solutions.
== Big entity bounding boxes ==
The most common reason for this issue is an entity with inflated bounding box size, usually 1000 units or more in size, casting dynamic shadows across a large area which hits the shadow triangle limit in the engine. Models with big bounding boxes can be identified with ent_bbox command, or for brush entities, checking the yellow box when selecting an entity in Hammer. Some may not be easy to catch at first glance, for example 2 chimneys grouped into a func_brush several thousands of units apart will create a very big bounding box which will easily cause the engine error. Another way this can occur is because of a huge translation in any of the model's $sequences (for example, shifting a model 10000 units down during an animation). In this case, the bounding box should be overriden with $bbox to be the "correct" size.
 Example: The sentry blueprint model has a nearly 4000 unit long bounding box due to the sphere range visualizer!
The solution is to disable shadows on such entities, by setting the Disable Shadows property on the entity to true (internally named disableshadows 1).
CUtlMap

CUtlMap is Source's equivalent of the C++ Map type. A map is essentially a CUtlVector where each element, or member, 
is mapped to a specific, unique key value that can be assigned when the member is added to the map. The code can be found in public/tier1/utlmap.h.
== Using CUtlMap ==
// Initialize map for given type
CUtlMap<int, CBaseEntity*> mapList;
// (Populate map here)
CBaseEntity* pOther;
mapList.Insert(pOther->entindex(), pOther);
// Access map
// Note: Element(..) is given type IndexType_t, not KeyType_t. See Accessing section
// Find index of given key
int idx = mapList.Find(pOther->entindex());
//Ensure that it is a valid index
if (mapList.IsValidIndex(idx))
{
 entindex = mapList.Element(idx)->entindex();
}
== Bounds related ==
; Count()
: The total number of items in the map.
; IsValidIndex( int i )
: Checks if a node is valid and in the map.
; InvalidIndex( )
: Returns an invalid index.
; EnsureCapacity( int num )
: Makes sure we have enough memory allocated to store a requested number of elements.
; MaxElement()
: Max "size" of the vector
== Adding elements ==
; Insert( const KeyType_t &key, const ElemType_t &insert )
: Inserts the element and key into the tail of the map.
; InsertOrReplace( ( const KeyType_t &key, const ElemType_t &insert )
: Inserts the element and key into the tail of the map, replacing the element if the key is the same as one that already exists
; Reinsert( const KeyType_t &key, IndexType_t i )
: If you change the search key, this can be used to reinsert the element into the map.
== Accessing Elements ==
You can use array-style or use a method for index access:
; Element( IndexType_t i )
; operator[]( IndexType_t i )
: Returns the element at index i 
; Key( IndexType_t i )
: Returns the key at index i
; Find( const KeyType_t &key )
: Returns the index at the given key
== Removing elements ==
You can remove elements at a given index, a given key, or all at once.
Single:
; RemoveAt( IndexType_t i )
: Removes the element at index i
; Remove( const KeyType %key )
: Removes the element mapped to the given key
All:
; RemoveAll( )
; Purge( )
; PurgeAndDeleteElements( )
: Purges the list and calls delete on each element in it.
== Iteration == 
; FirstInorder()
; NextInorder( IndexType_t i )
; PrevInorder( IndexType_t i )
; LastInorder()
== Other functions ==
You can get the tree which the CUtlMap consists of using
; AccessTree()
: Returns a CTree
You can swap one CUtlMap for another with
; Swap( CUtlMap< K, T, I > &that )
: Self explanatory 
Category:Tier1
U
CUtlSortVector

CUtlSortVector is a CUtlVector that automatically orders its elements using binary search. Code can be found in public/tier1/utlsortvector.h.
== Initialization ==
A CUtlSortVector expects a type and a sorting class. Here is an example:
#include "UtlSortVector.h"
// Sorting class
class CEntityReportLess
{
public:
	bool Less( const CBaseEntity &src1, const CBaseEntity &src2, void *pCtx )
	{
		return stricmp( src1->GetClassname(), src2->GetClassname() ) < 0;
	}
};
CUtlSortVector<CBaseEntity*, CEntityReportLess> sortedList;
The CUtlSortVector will then use the Less method to determine the order of elements. Note how the function has a third argument for a sorting context (see below).
== Adding elements ==
Only Insert( const T& src ) or InsertNoSort( const T& src ) is allowed when adding elements to a CUtlSortVector. InsertNoSort( const T& src ) just puts the element at the tail of the vector.
== Sorting context ==
Using SetLessContext( void *pCtx ), you can set a sorting context that will be passed to the Less function. 
== Searching ==
CUtlSortVector uses binary searches to find elements, which are very fast.
; Find( const T& src )
: Searches through the CUtlVector and returns the element index, or -1 if the given object was not found.
; FindLessOrEqual( const T& src )
; FindLess( const T& src )
: As above, but also considers elements that rank lower than the given object.
== Single elements ==
; Remove( const T& search )
: Searches for the element using Find() and removes it from the vector.
; Remove( int i )
: Removes the element at the specified index.
== Re-sorting ==
With RedoSort( bool bForceSort = false ), the CUtlSortVector is resorted using QuickSort. Use bForceSort to sort regardless if it is necessary or not (it becomes necessary when you use the InsertNoSort method).
Category:Tier1
Category:Classes
Cables on Models

Cables can be placed onto models simply by placing the correct code into the QC file. The cables work in the same fashion as the ones created using the and entities, only that they're more limited in that they can't be broken or made solid. A good example of this is the model of Dog from HL2.
== Adding cables to a model ==
Cables are added to a model first by defining $attachment points.
 $attachment "point1" "staticprop" 0.00 0.00 9.50 rotate 0.00 0.00 0.00
 $attachment "point2" "staticprop" -128.00 0.00 9.50 rotate 0.00 0.00 0.00
 $attachment "point3" "staticprop" 0.00 0.00 25.50 rotate 0.00 0.00 0.00
The code to create the cables must be placed within the $keyvalues block in another block titled Cables. Every time you want to create a single cable you must create a block titled "Cable"
;StartAttachment <attachment name>
:The $attachment point the cable starts from.
;EndAttachment <attachment name>
:The $attachment point the cable ends to.
;Width <float>
:Defines the width of the cable.
;Material <VMT file location>
:The VMT (material) to use. Cable materials are located in "materials/cables".
;NumSegments <int>
:The amount of segments in the cable. More segments make the cable more 'smooth'. Should be increased if the cable bends a lot.
;Length <int>
:The length of cable between the two attachment points. If the length is shorter than the distance between the two points then the cable will remain permanently straight.
:
== Example ==
In this example, two cables are create between the three attachment points.
 $keyvalues
 {
 Cables
 {
 "Cable"
 {
 "StartAttachment" "point1"
 "EndAttachment" "point2"
 "Width" "0.6"
 "Material" "cable\cable"
 "NumSegments" "4"
 "Length" "200"
 }
 "Cable"
 {
 "StartAttachment" "point2"
 "EndAttachment" "point3"
 "Width" "0.6"
 "Material" "cable\cable"
 "NumSegments" "6"
 "Length" "250"
 }
 }
 }
Category:QC Keyvalues
Cache Needs Decryption error

This error occurs when you try to run the SDK without having ever launched Half-Life 2.
To fix this error:
# Run Half-Life 2 from Steam's Play Games window.
# Run the Source SDK from Steam's Play Games window.
# If the problem is not resolved, repeat these steps running Counter-Strike: Source and Half-Life 2: Deathmatch.
Running these applications causes them to validate and repair any cache problems they may have.
Category:Source SDK FAQ