nyuuzyou/wikis huggingface dataset:
Logic mirror movement

It is also available on the code of the Source 2013 SDK, however it does not function by default. It mirrors an entity's movement to another entity.
== Keyvalues ==
== Inputs ==
== FGD Code ==
@PointClass base(Targetname, Parentname) = logic_mirror_movement :
	"An entity that can mirror entity movement to another entity."
[
	m_target(target_destination) : "Target Entity" : : "Target entity."
	m_strMirrorTarget(target_destination) : "Mirror Target Entity" : : "Mirror target entity."
	m_strRemoteTarget(target_destination) : "Remote Target Entity" : : "Remote target entity."
	m_strMirrorRelative(target_destination) : "Mirror Relative Entity" : : "Mirror relative entity."
	
 input SetTarget(string) : "Set the Target Entity."
	input SetMirrorTarget(string) : "Set the Mirror Target Entity."
	input SetRemoteTarget(string) : "Set the Remote Target Entity."
	input SetMirrorRelative(string) : "Set the Mirror Relative Entity."
]
Category:Source Base Entities
Category:Point Entities
Category:Entities
Logic multicompare

Compares a set of inputs to each other. If they are all the same, fires an OnEqual. If any are different, fires the OnNotEqual.
This entity has an internal list of integers that it has received from any inputValue input's. Any values sent to this entity, must be sent as an integer or boolean because "if it can't be converted" the entity will "just throw it away" (Source Code comment from dev's). Currently, there is no way to clear this 'list', so the entity is not reusable.
== Keyvalues ==
== Inputs ==
== Outputs ==
== See Also ==
* 
Category:IO System
Logic npc counter aabb

It does calculations based on the number of a specified type of NPC in a specified region.
==Keyvalues==
:
Value	Description
-1 	Any
0 	None
1 	Idle
2 	Alert
3 	Combaat
4 	Script
5 	Playdead
6 	Prone
7 	Dead
==Inputs==
==Outputs==
Logic npc counter obb

It does calculations based on the number of a specified type of NPC in a specified region.
==Keyvalues==
:
Value	Description
-1 	Any
0 	None
1 	Idle
2 	Alert
3 	Combaat
4 	Script
5 	Playdead
6 	Prone
7 	Dead
==Inputs==
==Outputs==
Logic npc counter radius

It does calculations based on the number of a specified type of NPC in a specified region.
==Keyvalues==
:
Value	Description
-1 	Any
0 	None
1 	Idle
2 	Alert
3 	Combaat
4 	Script
5 	Playdead
6 	Prone
7 	Dead
==Inputs==
==Outputs==
Logic playerproxy

It is used to relay inputs/outputs to the player and back to the world.
== Keyvalues ==
== Inputs ==
=== Half-Life 2, HL2 Episodes, Portal and Black Mesa ===
=== Half-Life 2, HL2 Episodes and Portal ===
:
:
:
=== Portal 2 ===
== Outputs ==
=== Half-Life 2, HL2 Episodes, Portal and Black Mesa ===
=== Portal 2, Counter-Strike Global Offensive and Black Mesa ===
:
=== Portal 2 ===
Category:IO System
Logic relay

It is a Output forwarder, which can be used to fire many outputs at once from just one input, or, by being disabled, to break an I/O chain. It can also be very helpful for organization and keeping you from having to edit MANY instances of the same outputs, as opposed to just one.
After a logic_relay is triggered, it cannot be triggered again until all of its outputs are fired. This is useful for when a relay has a sequence of delayed outputs that shouldn't be repeated until the sequence is finished. This behavior can be disabled with the "Allow fast retrigger" spawnflag.
 combines the functionality of and from . The older entities still exist in , but are deprecated.
__NOTOC__
== Keyvalues ==
== Flags ==
 
 
== Inputs ==
== Outputs ==
== See Also ==
* 
Category:IO System
Logic relay (Source 2)

It acts as a message forwarder and can be disabled to prevent forwarding outputs. Useful as an intermediary between one entity and another for turning on or off an I/O connection, or as a container for holding a set of outputs that can be triggered from multiple places.
After a logic_relay is triggered, it cannot be triggered again until all of its outputs are fired. This is useful for when a relay has a sequence of delayed outputs that shouldn't be repeated until the sequence is finished. This behavior can be disabled by setting FastRetrigger to true.
__NOTOC__
==Keyvalues==
==Inputs==
==Outputs==
Logic scene list manager

It manages a list of logic_choreographed_scene entities. Store choreo scenes in them in order that they will be played by other inputs. Whenever a scene plays, the manager will remove all scenes before that one in the list. The name of another logic_scene_list_manager can be entered in a slot instead of an individual scene, which will cause all scenes in that manager to be removed when a later scene in this list is played.
==Keyvalues==
==Inputs==
== See also ==
* logic_choreographed_scene
Category:Choreography
Logic script

__NOTOC__ 
 It is also available in , and .
This entity functions as a container for VScripts. In Left 4 Dead 2, for example, it is used extensively for the logic in "carnival games" found in the Dark Carnival campaign, such as Peanut Gallery, Strongman Contest, Whack-a-Stach, etc.
== KeyValues ==
== See also ==
* L4D2 VScripts
* Left 4 Dead 2 Tool Updates
== External links ==
* It's the VScripting documentation FAQ! (Steam Forums)
* Scripting for Left 4 Dead 2 (Leeland.net) - Example uses of logic_script
Category:Mapbase entities
Category:Mapbase point entities
Category:Team Fortress 2 entities
Category:Team Fortress 2 point entities
Category:Half-Life 2: Deathmatch entities
Category:Half-Life 2: Deathmatch point entities
Logic timescale

It controls the rate at which time passes in the game. Functionally identical to the host_timescale console command, but works without cheats enabled and supports blending between the time scales.
Useful to create temporary slow motion or fast-forward effects, as seen in the playable trailer for the movie Super 8 in Portal 2.
__NOTOC__
== Keyvalues ==
== Inputs ==
== FGD Code ==
@PointClass base(Targetname) = logic_timescale : "An entity that controls the rate at which time passes."
[
	BlendTime(float) : "Blend Time" : "1.0" : "Time in seconds to blend between time scales."
	
	input SetTimescaleBlendTime(float) : "Set time in seconds to blend between time scales."
	input SetDesiredTimescale(float) : "Time scale to blend towards, this is a multiplicative value where 1.0 is normal time, 0.5 is half speed, 2.0 is double speed."
]
== See also ==
* 
*
Logic title unlock test

This entity checks if the game is running in Xbox Live Arcade trial mode when activated, and fires an output if it is. Effectively, it behaves like a whose enabled state is tied to the game being in trial mode.
== Keyvalues ==
== Inputs ==
== Outputs ==
== FGD Code ==
 @PointClass base(Targetname) = logic_title_unlock_test: "Checks if the game is running in trial mode, and fires an output if it is."
 [
 	input TestTitleUnlocked(void) : "Tests the trial mode state."
 	output OnTitleLocked(void) : "Fired in response to TestTitleUnlocked if the game is running in trial mode."
 ]
Logic versus random

It fires random outputs in the first round of a versus map, and then repeats those outputs in the second round of a versus map. In other words, this entity will pick a random number or a series of random numbers in the first round of a versus game, and then repeat those numbers in the second round. This allows designers to add "random" changes to a map (like prop_fuel_barrel placement) and repeat those for the second round.
==Keyvalues==
==Inputs==
==Outputs==
Logistique Act. 1

is a fan-made mod of which puts the player in the eyes of a citizen looking for his wife. It is the first in a supposed series of mods.
The most interesting stand-out feature of this mod is the inability to see your health and ammo, as the citizens wouldn't normally have access to an HEV Suit. Instead, holding R will make the character say about how many rounds are left in the magazine. This forces the player to count their rounds, like how they would in real life. 
==Highlights==
*2-4 Hours of Gameplay.
*4 Playable Chapters.
*New Gameplay Mechanics (Ironsight, Clip system...).
*Original Soundtrack & Sound Design.
*Story told through voice actors.
*Weapons and animation redesigned.
Lord of death

== Description ==
Maud tells life of a professional assassin named Jack Touchi, the first murder by contract,
before he was caught, each chapter is any murder by contract in his life.
== Story ==
Jack Touchi lived quietly with her ​​daughter Elizabeth, and With his wife , until one day them were taken away agency, which
asked to kill a few people, and he had to work for the agency ,
that would be his wife and daughter were intact.... (more spoilers)
== Features ==
* New Weapon 
** Sniper Rifle
** Pistol with a silencer
* GRAPHICS
** Shader Memories
* Mode Accurate readings.
* DEVICES
** Glasses NG33-Glasses that you can get closer to the end of the game, they show the player's health, ammo, and have a built-in torch, you can remove and wear
== media ==
Image:HouseOneB.jpg|Первое укрытие главного героя!
Image:Houseonec.jpg
Image:Sniper_Scope.jpg
Image:Killer.jpg
Image:News.png
Image:Motel.jpg
Image:Home.jpg|Nice view from the window 
== Team ==
* I am: Map and Codder.
== External links ==
* 
Category:Source mods
Category:Help Wanted
Lowering your weapon on sprint

This article provides a basic implementation of weapon lowering while sprinting, and preventing weapon fire while doing so.
== The Code ==
===BASECOMBATWEAPON_SHARED.CPP===
Hit CTRL+F and search for this code:
void CBaseCombatWeapon::ItemPostFrame( void )
Then copy and paste this above it:
void CBaseCombatWeapon::ProcessAnimationEvents(void)
{
	CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
	if (!pOwner)
		return;
	if ( !m_bWeaponIsLowered && (pOwner->m_nButtons & IN_SPEED ) )
	{
		m_bWeaponIsLowered = true;
		SendWeaponAnim( ACT_VM_IDLE_LOWERED );
		m_flNextPrimaryAttack = gpGlobals->curtime + GetViewModelSequenceDuration();
	 m_flNextSecondaryAttack = m_flNextPrimaryAttack;
	}
	else if ( m_bWeaponIsLowered && !(pOwner->m_nButtons & IN_SPEED ) )
	{
		m_bWeaponIsLowered = false;
		SendWeaponAnim( ACT_VM_IDLE );
		m_flNextPrimaryAttack = gpGlobals->curtime + GetViewModelSequenceDuration();
 	 m_flNextSecondaryAttack = m_flNextPrimaryAttack;
	}
	if ( m_bWeaponIsLowered )
	{
		if ( gpGlobals->curtime > m_flNextPrimaryAttack )
		{
			SendWeaponAnim( ACT_VM_IDLE_LOWERED );
			m_flNextPrimaryAttack = gpGlobals->curtime + GetViewModelSequenceDuration();
			m_flNextSecondaryAttack = m_flNextPrimaryAttack;
		}
	}
}
Now to make sure our code gets called we add ProcessAnimationEvents(); here:
void CBaseCombatWeapon::ItemPostFrame( void )
{
 //Add this underneath the pOwner accessor check.
 ProcessAnimationEvents();
}
===BASECOMBATWEAPON_SHARED.H===
Add these declarations under public at line 211 below bool					IsViewModelSequenceFinished( void ); // Returns if the viewmodel's current animation is finished:
	virtual void ProcessAnimationEvents(void);
	bool m_bWeaponIsLowered;
==Finish==
Now your weapon should be lowered when you hit the sprint button and you will not be able to shoot until you release the button!
Category:Weapons programming
Category:Tutorials
LuaManager.h

Save file as ge_luamanager.h
See also: LuaManager.cpp
///////////// Copyright © 2008 LodleNet. All rights reserved. /////////////
//
// Project : Server
// File : ge_luamanager.h
// Description :
// [TODO: Write the purpose of ge_luamanager.h.]
//
// Created On: 3/5/2009 4:58:58 PM
// Created By: <mailto:admin@lodle.net>
////////////////////////////////////////////////////////////////////////////
#ifndef MC_GE_LUAMANAGER_H
#define MC_GE_LUAMANAGER_H
#ifdef _WIN32
#pragma once
#endif
extern "C"
{
 #include <lua.h>
 #include <lauxlib.h>
 #include <lualib.h>
}
#include <vector>
inline void CallLUA(lua_State *L, int iV1, int iV2, int iV3, const char* pszFunc = "")
{
	// iV1 = # Arguments pushed onto the stack, DO NOT INCLUDE THE FUNCTION!
	// iV2 = # returns to push onto the stack
	// iV3 = Where to store the error
	if (lua_pcall(L, iV1, iV2, iV3) != 0) 
	{
 Warning("[LUA-ERR] Error running function \"%s\": %s\n", pszFunc, lua_tostring(L, -1));
		lua_pop(L, 1);
	}
};
#define REG_FUNCTION_GLOBAL( name )			\
	extern int lua##name(lua_State *L);	\
	lua_register(L, # name , lua##name );
#define REG_FUNCTION( name )				\
	extern int lua##name(lua_State *L);	\
	lua_register(GetLua(), # name , lua##name );
#define LG_DEFINE_INT(_name,_value) \
	lua_pushinteger(GetLua(),_value); lua_setglobal(GetLua(), _name);
#define LG_DEFINE_STRING(_name,_value) \
	lua_pushstring(GetLua(),_value); lua_setglobal(GetLua(), _name);
#define LG_DEFINE_BOOL(_name,_value) \
	lua_pushboolean(GetLua(),_value); lua_setglobal(GetLua(), _name);
#define LG_DEFINE_INT_GLOBAL(_name,_value) \
	lua_pushinteger(L,_value); lua_setglobal(L, _name);
#define LG_DEFINE_STRING_GLOBAL(_name,_value) \
	lua_pushstring(L,_value); lua_setglobal(L, _name);
#define LG_DEFINE_BOOL_GLOBAL(_name,_value) \
	lua_pushboolean(L,_value); lua_setglobal(L, _name);
#define MAX_EVENT_STRING 255
// Structure to define an event function that the game mode's LUA file
// uses to override default functions for gameplay
struct EventFunc_s
{
	EventFunc_s(int id, const char* pszName) 
	{
		iEventID = id;
		pszFunc = new char[MAX_EVENT_STRING];
		Q_strcpy(pszFunc, pszName);
	}
	int		iEventID;
	char*	pszFunc;
};
//This maps a string definition to a ID (must match above)
typedef struct
{
	int			iEventID;
	const char	*pszEvent;
} LuaEvent_t;
class LuaHandle
{
public:
	LuaHandle();
	~LuaHandle();
	virtual void Init()=0;
	virtual void Shutdown()=0;
	virtual void RegFunctions()=0;
	virtual void RegGlobals()=0;
	void InitDll();
	void ShutdownDll();
	lua_State* GetLua(){return pL;}
	//this needs to be called in the child class constructor
	void Register();
	bool m_bLuaLoaded;
private:
	bool m_bStarted;
	lua_State *pL;
};
class CGELUAManager
{
public:
	CGELUAManager();
	~CGELUAManager();
	virtual void InitDll();
	void InitHandles();
	virtual void ShutdownDll();
	void ShutdownHandles();
	void RegisterLuaHandle(LuaHandle* handle);
	void DeRegisterLuaHandle(LuaHandle* handle);
protected:
	void InitLUA();
	void CloseLUA();
private:
	std::vector<LuaHandle*> m_vHandles;
	bool m_bInit;
};
extern CGELUAManager* GELua();
#endif //MC_GE_LUAMANAGER_H
Category:Programming
LumpStich

is a deobfuscation tool made by .
 
==Overview==
Maps are often given anti-decompile protection to prevent players from decompiling, studying and sometimes even playing those maps. This program removes such lump protection and restores a map to its original state. This tool is intended to work with and maps.
==How it works==
A protected BSP file and it's acompanying LMP file are carefully stiched together at a specific binary offset to reform an unobstructed BSP. This ubobstrcuted BSP can then easily be decompiled and played while the protected BSP cannot be decompiled, lacks entities and may even crash the game.
== Release information ==
*v1.00 - January 11th 2023 - Initial Release
*v1.01 - January 17th 2023 - Small Bug Fixes
*v1.05 - January 19th 2023 - Improvements & Bug Fixes
*v2.00 - October 6th 2023 - Major Improvements & GUI Release
*v2.01 - October 25th 2023 - Small Bug Fixes & Improvements
*v2.02 - January 6th 2024 - Small Visual Changes
== See also ==
* BSP (Source)
* Lump file format
== External links ==
* GitHub Repository
Lump file format

Lump files are used to store lump data independently from a BSP file in separate files with the file extension .lmp.
Each lump file contains a 20 bytes long header before the actual lump data. It contains some information about the lump that were stored in the BSP file before extraction.
struct lumpfileheader_t
{
	int lumpOffset; // offset in the file where the lump data begins (should be 0x14)
	int lumpID; // the lump ID according to the lump table
	int lumpVersion; // same as "version" in lump_t	
	int lumpLength; // same as "filelen" in lump_t
	int mapRevision; // same as in dheader_t
};
== See also ==
* 
* Source BSP File Format
* Patching levels with lump files
* ENT file
Category:File formats
M0rt@nius

M0rt@nius is the nickname of an Estonian-English developer, which has been developing mods and maps for games since at least year 2005.
=External Links=
Former Website
=List of Contributions (found from website)=
*"Palace" Deathmatch map for Half-Life.
*"Route City" Half-Life mod.
*"Alternative Origin" Half-Life Singleplayer map.
*Unfinished maps: "A-rides", "Cave", "Desert", "FunnelZone", "Gloom", "Paratroop", "TeamWar" (for Team Fortress Classic.)
*cs_penetration map for Counter-Strike.
*de_railstation map for Counter-Strike.
*de_quakepalace map for Counter-Strike.
*Socialist Tension (ModDB link black-listed on the wiki.)
*Super Gordon Bros. for Half-Life 2 (requires Half-Life 2 on older engine.)
MACe

== Overview ==
 MACe is an adventure/puzzle game.
MACe the Adventure is a puzzle-oriented adventure game developed by S.V. Bhikharie as part of his Master Thesis for Computer Science, specialization Multimedia, at the Vrije Universiteit of Amsterdam.
The game development was supervised by Dr. Anton Eliens.
Please visit the website http://www.few.vu.nl/~mace/ for the latest information about MACe the Adventure!
For questions or comments: mace@few.vu.nl
== Basic story ==
MACe the Adventure is a puzzle-oriented adventure game. The player takes on the role of a heroine, who decides to visit the local arcade center, owned by the eccentric Minos. Unknown to her, this is the start of a strange journey.
== External links ==
* Official site
Category:Single Player Mods
MAT file

A MAT file is what uses for it's uniquely built particle system that is specific to the textures in the game. It covers everything that you might imagine a particle effect could do. For example, when a concrete wall is shot in game, one would expect that things like a bullet decal, gray smoke would be emitted, chips of concrete would fall out of the wall, Among other things such as the gravity, fade speed, color and what sprite the chips of concrete use. The .MAT format is highly customizable and very easy to work with once the terms and formatting are explained. But there are limits to what we can do in because of the mostly hardcoded nature of the game itself.
Can be used to make a cool particle effect when you shoot a wall in .
== Limits ==
Limitations of the .MATs on .
== File format ==
The file structure is important. There are two directories that .MATs should be. One for defining the .MATs for levels, and one for creating material .MATs to be used.
Directory for defining .MATs for a level:
 
Files in directory define the .MAT file for your levels, and can also be the area where a global czero.MAT is stored for loading when the game is started. The format for these is generally YOURMAPNAME.MAT, with the exception of the global czero.mat.
Directory for defining the material .MATs:
Files in subdirectory define the materials used within the above mentioned directory. Basic materials such as dirt and grass are stored and referenced from here, as well as the prior mentioned 'custom' .MAT.
These two directories are linked in a way. So you should always place the correct file in the correct directory, otherwise they may not work as intended. The next section is going to explain how to create and link a texture a .MAT file.
==Linking a texture to an effect==
Lets say we have a brick texture. We need to assign the correct .MAT material for this texture. How do we do this? We need to create a .MAT file for our level first.
We can copy one from the base game directory, rename it to whatever your custom map name is, and put it in the materials folder.
Next, open your new custom level .MAT using notepad, I am using notepad++ for this. Delete all it's contents and use this handy prefab.
texture "YOUR_TEXTURE_NAME"
[
	material
	{
		type "brick"
	}
]
If you used the above prefab, this would assign the "brick" base material that can be found in the "default" directory, to the texture name you put in. This means that, when the texture is hit, it will make the "brick" particle effect. You can choose other base materials out of that folder too. Play around with the different materials and see what suits the texture that you put in. Save your custom level .MAT file and fire up your map in game and test it out. If we want to define more materials, just copy the previous entry, change the texture name and the basic material and it should work.
== Files ==
mat
mat
mat
MAX MAP BRUSHSIDES

MAX_MAP_BRUSHSIDES occurs when your map exceeds the maximum defined brush face amount.
The current limit is 65536, due to the engine internally using 16-bit integers (also known as "shorts") to count the number of brushsides. The maximum value of a 16-bit unsigned integer is 65535 (2^16), hence the limit.
There is no fix for this without changing the brushside structure in the engine to use 32-bit integers. 
== Hammer/Compiled brushsides discrepancy ==
The term "brush sides" is a bit misleading, if you've paid attention to your brush sides in Hammer before, you may have noticed the compiled result was higher.
This is because when compiling, it includes the bounding box of a brush (required for QPhysics), which can be up to an additional 6 brushsides per brush. If a face is lined up with the edge of the bounding box(meaning not angled in any way) it will not add an additional brushside.
Example: A 5 sided pyramid shaped brush with the bottom face lining up the bottom of the bounding box. While the brush itself is only 5 sides, it will count as 10. The 5 extra brushsides come from the bounding box.
As rule of thumb for figuring this out easier. 6 + angled faces = brushsides per brush
== Instance discrepancy ==
Putting angled geometry in an instance will lower brushsides. This can be easily observed by compiling a rotated building in the main map, then in an instance, and comparing the brush side count. It is unknown why this works, but it messes up some QPhysics calculations.
==External links==
* TF2Maps.net Article on Reducing "Brush Sides"
category:Level_Design
MBSPC

which is a cmd map decompiler for Goldsource games, written in C++. It converts BSP files into sources AAS and MAP ones that can be loaded in Hammer.
== Features ==
* Supported and updated.
* Few bugs to fix in decompiled maps. (Invalid solid structure)
* Proper textures places
* Load huge BSPs
* Customizable decompile options
== Drawbacks ==
* Complex shapes aren't decompiled perfectly, still need a lot of manual fixing, or redo from scratch.
* On windows 10 it works fine, on windows 7 some of you can get missing .dll errors, like "ucrtbased.dll".
* No GUI, command line only
* Only Tree-Based decompiles
* Does not automatically extract embedded textures
* Does not decompile overly complex maps (such as dust2_2020) or decompiles them with missing brushes.
* Does not apply a "null" texture to brushes, instead applies nearby textures => poorly optimized.
== Limitations ==
== Commands ==
bsp2map <[pakfilter/]filter.bsp> = convert BSP to MAP
bsp2map220 <[pakfilter/]filter.bsp> = convert BSP to Valve 220 MAP
bsp2aas <[pakfilter/]filter.bsp> = convert BSP to AAS
reach <filter.bsp> = compute reachability & clusters
cluster <filter.aas> = compute clusters
aasopt <filter.aas> = optimize aas file
aasinfo <filter.aas> = show aas file info
entlist <[pakfilter/]filter.bsp> = extract entity list
texinfo <[pakfilter/]filter.bsp> = extract texture list
output <output path> = set output path
threads <X> = set number of threads to X
cfg <filename> = use this cfg file
optimize = enable optimization
noverbose = disable verbose output
breadthfirst = breadth first bsp building
capsule = use spherical collision model
nobrushmerge = don't merge brushes
noliquids = don't write liquids to map
freetree = free the bsp tree 
nocsg = disables brush chopping 
forcesidesvisible = force all sides to be visible
grapplereach = calculate grapple reachabilities
== Usage ==
* mbspc.exe -bsp2map %filename% - converts BSP to MAP file
* Drag and drop a .bsp on bspc.bat
== Screenshots ==
MBSPC1.png|MBSPC Interface
MBSPC22.png|MBSPC decompiles #1
MBSPC33.png|MBSPC decompiles #2
== See also ==
* Decompiling maps
== External links ==
* GitHub Repository
Category:Third Party Tools
Category:Third Party GoldSrc Tools
Category:Non-Steam Applications
Category:GoldSrc Level Design