nyuuzyou/wikis huggingface dataset:
De/TF2/Round time

Zeit ist kostbar - mit ihr lassen sich erstaunliche Dinge realisieren, und ohne Zeit würde eine Map niemals enden.
__TOC__
== Warum die Zeit so wichtig ist ==
Die Zeit kann den Ausgang eines Matches wesentlich beeinflussen, den Spielverlauf sogar unausgeglichen werden lassen.
Zu wenig Zeit macht einem die Arbeit als Verteidiger einfacher, denn man muss weniger lange Widerstand leisten und die Map ist somit schneller gewonnen. Zuviel Zeit hingegen macht es für die Angreifer einfacher, ihr Mapziel zu erreichen und die Verteidigung wird schwerer. Stell dir zum Beispiel dustbowl mit Roundtimes von 30 Minuten vor...
Mit diesem Wissen solltest du darauf achten, die Rundenzeit so zu wählen, dass der Spielverlauf für beide Seiten nicht zur unlösbaren Aufgabe wird.
==Bevor es los geht==
#Platziere den irgendwo auf der Map. Das Enity ist sehr wichtig, denn es kontrolliert die Roundtime!
#Gib' dem Enity irgend einen Namen, zum Beispiel roundtimer.
==Die Zeit einstellen==
=== Setup Timer ===
Um die Setupzeit einzustellen, also die Zeit die vergeht, bevor die Runde startet, brauchst du nur das team_round_timer Entity.
#Öffne die Einstellungen von team_round_timer.
#Ändere setup_length in den gewünschten Wert (Angabe in Sekunden). 
Aber: Stell die Zeit nicht zu hoch ein, alles über 2 Minuten ist definitiv zu lang!
===Zeit hinzufügen oder verringern===
In deinem erstellten team_round_timer Entity brauchst du nur AddTime auszuwählen:
#Tippe bei dem Enity, von welchem aus die Zeit erhöht werden soll, den Namen deines team_round_timer Entities ein.
#In der Zeile "Via this input" wählst du AddTime aus.
#Gib' in der Zeile "With a parameter override of" die Zeit in Sekunden ein, die hinzugefügt/abgezogen werden soll (fürs Abziehen negative Angaben benutzen).
#(Optional) Du kannst in der Zeile "After a delay in seconds of" noch eine Verzögerung einbauen, nach welcher deine Einstellungen aktiv werden.
===Absolute Zeit einstellen===
Mit dem SetTime Feld kannst du einen absoluten Wert für die Zeit nach deinem Belieben einstellen.
#Tippe bei dem Enity, von welchem aus die Zeit erhöht werden soll, den Namen deines team_round_timer Entities ein.
#In der Zeile "Via this input" wählst du SetTime aus.
#Gib' in der Zeile "With a parameter override of" die Zeit in Sekunden ein, die nun eingestellt werden soll.
#(Optional) Du kannst in der Zeile "After a delay in seconds of" noch eine Verzögerung einbauen, nach welcher deine Einstellungen aktiv werden.
==Siehe auch==
De/Team Fortress 2

ist das Follow-up zu beiden und der ursprüngliche Quake Mod, Team Fortress.
Im Gegensatz zu anderen "klassenbasierten" Spielen, die nur eine Vielzahl von Kampfklassen anbieten, bietet Team Fortress 2 eine Vielzahl von Klassen, die ein breites Spektrum an taktischen Fähigkeiten und Persönlichkeiten bieten und sich für eine Vielzahl von Spielerfähigkeiten eignen.
Play as the flame-throwing Pyro, the room clearing Heavy, or the Spy, a master of disguises. Other classes include: Scout, Sniper, Medic, Engineer, Demoman, and Soldier.
== Inhalt ==
* Team Fortress 2 (tf2)
* Source 2013 shared (hl2)
* Source shared (hl2)
* engine branch
== Siehe auch ==
* Team Fortress 2 auf Wikipedia
* TF2Maps.net
* 
*
De/Team Fortress 2/Docs/Level Design

__NOTOC__
== http://developer.valvesoftware.com/w/images/8/84/Tf2-16px.png Erste Schritte ==
* 
* 
* 
* 
* 
== http://developer.valvesoftware.com/w/images/8/84/Tf2-16px.png Bauelemente ==
=== Grundlegende Dinge ===
* 
* 
=== Spawnräume ===
* 
==== Spawn-Elemente ====
* 
* 
* 
* 
=== Punktesysteme ===
* 
* 
* 
* 
* 
* 
=== User Modes ===
* 
* 
* 
* 
=== Kniffe & Auswirkungen ===
* 
* 
* 
* 
* 
== http://developer.valvesoftware.com/w/images/8/84/Tf2-16px.png Sonstiges Wissenswertes über TF2 Mapping ==
* 
* 
* 
* 
* 
== http://developer.valvesoftware.com/w/images/8/84/Tf2-16px.png Inhalte auf Benutzerseiten der VDC ==
* Baliame/TF2 Progress
* Baliame/TF2 Gamemode Theories
* 
* Mode6's TF2 Map Hybridization article
* Daeval's Experiments
* Haydon's Mapping Adventures
* Team NightHawK's TF2 Mapping
De/Testing Portal 2 Co-Op Maps Alone

Dies ist eine Anleitung, wie Du Coop-Maps alleine testen kannst, indem Du den -Modus der Source-Engine benutzt. Das funktioniert auch mit heruntergeladenen Coop-Maps. Du musst dazu nichts an der Map-Datei selbst verändern.
== Die Map laden ==
; mapname
: Lädt mapname im Splitscreen-2-Spieler-Modus. Analog zum im Singleplayer. Wie bei map ist es nicht nötig, am Ende .bsp anzuhängen.
; mode
: Ändert den Splitscreen-Modus.
: ss_splitmode 0: Benutzt die empfohlene Einstellung basierend auf der Breite: ss_splitmode 1: Split zwischen oben und unten
: ss_splitmode 2: Split zwischen links und rechts
Wenn Deine Map im Lade-Screen hängen bleibt, versuche, den .vmf-Dateinamen zu verkürzen und neu zu kompilieren.
=== Zwei Monitore ===
Wenn Du zwei Monitore hast und zwischen beiden splitten willst, folge diesem Guide (Englisch)
== Den zweiten Spieler steuern ==
Wenn Du die Map tatsächlich mit nur einem Spieler spielen könntest, wäre es keine echte Coop-Map. So steuerst Du den zweiten Spieler:
===in_forceuser===
; playerindex
: Übernimm denn zweiten Spielern. Alle Bewegungstasten und andere Binds bleiben dieselben. Damit das funktioniert, müssen die Cheats aktiviert sein.
: 1: Schaltet Cheats ein
: in_forceuser 0: Steuert Spieler #1 (Atlas)
: in_forceuser 1: Steuert Spieler #2 (P-Body)
Damit das einfach zu benutzen ist, mach Dir ein dafür:
; "z" in_forceuser
: Damit wechselst Du zwischen erstem und zweitem Spieler hin und her, wenn Du „z“ drückst.
=== Einen Controller benutzen ===
Das ist komplizierter als es klingt, es sei denn, Du hast zwei Controller. Wenn nicht, gibt es einen Workaround, um den Computer „denken“ zu lassen, Du hättest zwei Controller. Weitere Informationen dazu findest Du im Steam-Forum (Englisch).
=== change_portalgun_linkage ===
Mit diesem Befehl kannst Du ein extra Paar verbundener Portale abfeuern, ohne den Spieler zu wechseln.
; integer
: Bestimmt, zu welchem Spieler oder Team die abgefeuerten Portale gehören.
:: change_portalgun_linkage_id 0: Singleplayer
:: change_portalgun_linkage_id 1: Blau
:: change_portalgun_linkage_id 2: Orange
:: change_portalgun_linkage_id [3-9]: Extra / Reserviert
== Weitere nützliche Konsolenbefehle ==
; command
: Führt command aus, als wäre es vom zweiten Spieler eingegeben worden.
: cmd2 name Player2: Legt den Namen des zweiten Spielers fest.
; enable
: Schaltet für den ersten Spieler den Fullscreen-Modus an (wenn enable=1 ist) und versteckt den Blickwinkel des zweiten Spielers.
: Es scheint keinen Weg zu geben, dasselbe für den zweiten Spieler festzulegen, außerdem zeigt „Tab“ nicht mehr den Blickwinkel des Partners an (+remote_view).
== Externe links (Englisch) ==
* Original version of this guide hosted at ThinkingWithPortals.com
* How-to: Split Screen Coop
* How-to: SplitScreen with 2 monitors
* How-to: Play Co_Op Alone
Category:Portal 2 Tutorials
De/Texture

Eine Textur ist eine zwei-dimensional gerasterter Graifk innerhalb einer Spielengine. In Source werden Texturen als gespeichert und findet mit einigen Ausnahmen als Zwischen- Verwendung. 
Am häufigsten werden Texturen als sogenante verwendet, finden aber in heutigen Spielengine noch weitere verschiedenste Anwendungen. Zum Beispiel , die dreidimensionale Raster codiert und den Farbwert jedes Pixels bestimmt oder bei die Intensität einer bestimmen. 
== Tutorials ==
* (beinhaltet Anweisung zur Texturerstellung)
* (in )
*
*
== Siehe auch unter ==
*
*
* and 
*Seiten zum Materialdownload
De/Thermal Discouragement Beam

Der Thermale Entmutigungsstrahl oder einfach nur Laser ist ein Puzzleelement in . Laser entspringen aus speziellen Emittern und können dazu benutzt werden, um Laserempfänger zu aktivieren, die wiederum den Zustand anderer Puzzlelemente - etwa Türen oder Treppen - verändern, können. Ein weitere Verwendungszweck von Lasern ist das Zerstören von . Sie können wie jedes andere Puzzle Element Portale durchqueren. Falls ein Spieler den Strahl berührt, erhält er einen minimalen Schaden und wird zurückgestoßen. Anhaltender Kontakt mit dem Strahl kann den Spieler töten. Normale blockieren Laser, Refelktionswürfel hingegen leiten ihn parallel zum Boden um.
==Erzeugung==
Den Ausgangspunkt des Lasers bildet ein und der Endpunkt wird durch einen festgelegt.
Bei dem ist zu beachten, dass Should auto aim auf No gestellt wird.
Andernfalls sucht der Laser sich den nächsten im Sichtfeld als Ziel.
Es gibt noch zwei weitere Elemente für Rätselaufgaben in Bezug auf den Laser. Eines ist der mit folgenden Einstellungen:
::
Property Name	Value
CubeType 	Reflective (2)
Use new skins	Yes (1)
Ein weiteres Element ist das . Für den Catcher und das Relay sollten dann natürlich noch erstellt werden.
Auch ist ein sinnvoll, um zu überprüfen, ob alle Relays vom Laser getroffen werden, falls die Aktivierung von mehr als einem Element erforderlich ist, um das Zielelement zu aktivieren.
De/UTIL EntitiesInBox

UTIL_EntitiesInBox ist ein , bereitgestellt durch den code, um innerhalb einer Box zu finden. Es nimmt eine Entity-Liste, Minimum, Maximum und und liefert eine Anzahl von Entities und eine Liste der Entities.
== Benutzung ==
//-----------------------------------------------------------------------------
// Zweck : Liefert die Anzahl der Entities in der Box plus ein Array von Pointern auf die Entities.
// 
// Input : CBaseEntity - *pList | Ein Pointer auf ein Array, in dem die Funktion die Pointer auf die Entities speichern wird.
// Input : int - listMax | Maximale Anzahl der zurückzugebenden Entities.
// Input : Vector - &mins | Das Minimum der zu prüfenden Box. Weltkoordinaten.
// Input : Vector - &maxs | Das Maximum der zu prüfenden Box. Weltkoordinaten.
// Input : int - flagmask | 
// Output: *pList
// Output: int - Liefert die Anzahl der gefundenen Entities
//-----------------------------------------------------------------------------
inline int UTIL_EntitiesInBox( CBaseEntity **pList, int listMax, const Vector &mins, const Vector &maxs, int flagMask )
//-----------------------------------------------------------------------------
// Zweck : Liefert die Anzahl der Entities in der Box.
// 
// Input : Vector - &mins | Das Minimum der zu prüfenden Box. Weltkoordinaten.
// Input : Vector - &maxs | Das Maximum der zu prüfenden Box. Weltkoordinaten.
// Input : CFlaggedEntitiesEnum *pEnum | TODO
// Output: int - Liefert die Anzahl der gefundenen Entities
//-----------------------------------------------------------------------------
int UTIL_EntitiesInBox( const Vector &mins, const Vector &maxs, CFlaggedEntitiesEnum *pEnum );
flagmask ist in const.h, Zeilen 97-132, verfügbar
== Beispiele ==
//Erzeugt ein Array mit CBaseEntity-Pointern
CBaseEntity*	pList[20];
//Legt die Pointer in pList und speichert die Anzahl der Entities
int count = UTIL_EntitiesInBox( pList, 20, spawnOrigin + NAI_Hull::Mins( HULL_MEDIUM ), spawnOrigin + NAI_Hull::Maxs( HULL_MEDIUM ), 0 );
//Iteriert über alle möglichen Ziele
for ( int i = 0; i < count; i++ )
{
 //Wenn ein einzelner movetype einer Entity nicht MOVETYPE_VPHYSICS ist, wird der Rest der Schleife übersprungen und am Anfang vortgesetzt
	if ( pList[i]->GetMoveType() != MOVETYPE_VPHYSICS )
		continue;
	if ( PhysGetEntityMass( pList[i] ) > ANTLION_MAKER_BLOCKED_MASS )
	{
		bBlocked = true;
		iNumBlocked++;
		pBlocker = pList[i];
		if ( pTestHint == pNode )
		{
			bChosenHintBlocked = true;
		}
		break;
	}
}
//verwendet die überladene Funktion und liefert nur die Anzahl der Entities.
CBaseEntity *entityList[64];
Vector range(ROLLERMINE_WAKEUP_DIST,ROLLERMINE_WAKEUP_DIST,64);
int boxCount = UTIL_EntitiesInBox( entityList, ARRAYSIZE(entityList), GetAbsOrigin()-range, GetAbsOrigin()+range, FL_NPC );
De/UTIL Remove

UTIL_Remove ist ein , welches im Quellcode zum Entfernen von Objekten zur Verfügung steht. UTIL_Remove markiert ein Objekt zur Löschung im nächsten Ausführungsschritt, anstatt die Löschung sofort durchzuführen. Objekte im aktuellen Schritt zu löschen kann null-Pointer zur Folge haben, welche das Spiel abstürzen lassen, weshalb UTIL_Remove zur Vermeidung enthalten ist.
==Usage==
void UTIL_Remove( IServerNetworkable *oldObj )
==Examples==
UTIL_Remove( this );
CBaseFire *pEffect = m_hEffect;
if ( pEffect != NULL )
{
	UTIL_Remove( pEffect );
 m_hEffect = NULL;
}
==See also==
* 
* 
*
De/Unit

Eine Einheit ist ein generischer Maßstab, der von Source zum Messen von Distanzen und zum definieren von verwendet wird. Einheiten sind in allen Tools (einschließlich externe 3D-Modellierungsprogramme) äquivalent.
Die Beziehung einer Einheit zum Maßstab der realen Welt ist nicht präzise gegeben oder in Stein gemeißelt: Sie wird nur durch die Skalierung des Spielinhalts definiert.
== Siehe auch ==
* (für die Größe einer Einheit in )
De/VMEX

Valve Map Extractor (VMEX) ist ein Decompiler für -Engine Maps. Er konvertiert -Dateiformate zurück in -Mapformate, welche dann in den geladen werden können. Seit Version 0.98g unterstützt er alle Spiele von Valve.
=== ===
Um Maps für zu decompilieren, downloade die modifizierte Version: VMEX (v0.98e) hier.
=== ===
Eine veränderte Version von VMEX wurde erstellt, um Maps für zu decompilieren von TerabyteDragon. Diese Veränderung löst Probleme mit static props (speziell bei der Größe der Entries in der BSP). Download hier verfügbar (ersetzt die .jar von dem 0.98g Release).
== Siehe auch ==
* VMEX - Die offizielle Webseite.
* VMEX 0.98g - Downloadmirror für die neuste Version.
De/VMT

Ein Material ist eine .vmt-textdatei, die eine zwei-dimensionale Oberfläche definiert. Es enthält alle Informationen die Source braucht um das Material visuell, akustisch und physikalisch zu simulieren. VMT steht für "Valve Material Type".
Die Informationen über das Material fallen in mehrere oder alle folgenden Kategoiren
# 
# 
# -spezifische parameter
# 
# 
== Ein einfaches Beispiel ==
 LightmappedGeneric
 {
 	$basetexture coast\shingle_01
 	$surfaceprop gravel
 }
Das ist ein einfaches Kiesstrand-material.
#Es wird der shader beutzt, das heisst, dass das Material für benutztung mit s (z.B. es) gedacht ist.
#Das { zeichen beginnt eine Serie von Parametern.
#Der -parameter ist hier auf coast\shingle_01, einer Textur, gesetzt. Das ist was auf den Bildschirm gemalt wird.
# gibt dem Material die physikalischen Eigenschaften von Kies.
#Das } zeichen beendet die Serie von Parametern.
Wichtig: Dieses Material kann nur für es verwendet werden. Wenn es für ein benötigt wird, müsste man eine andere Version schreiben die den - statt dem -shader benützt.
Die meisten Shader können frei, durch das modifizieren der ersten Zeile, austauscht werden, da die meisten Parameter gleich sind. Aber manche Parameter funktionieren nur mit bestimmten n , wie zum Beispiel, effekte dir vom VertexLitGeneric shader unterstützt werden. Zum Glück gibt es keine Fehlermeldungen wenn ein nicht unterstüzter Parameter verwendet wird, es passiert einfach nichts.
== Materialien finden ==
Materials sind im materials\-ordner deines Spieles oder s gespeichert. Die einfachste Methode sie zu finden ist 's eingebaute Textur-auswahl.
Wenn du Valve's Material-datein sehen und/oder bearbeiten möchtest, muss du sie erst aus dem -archiv mit entpacken. Die meisten Materialien sind in mit "material" im Namen.
== Siehe auch ==
*
*
* 
* (specular mask)
* (environment map)
* (diffuse reflection)
*
De/VPlane

VPlane ist eine C++-Klasse, die eine andlose 2-dimensionale Oberfläche repräsentiert.
Jede VPlane enthält einen , der die Richtung (m_Normal) bestimmt und einen , der die Distanz zum aktuellen (m_Dist) bestimmt.
== Memberfunktionen ==
; DistTo( point)
: Die distanz zwischen dem gegebenen Punkt und seinem nächsten Punkt auf der Ebene. Positiv, wenn auf der Vorderseite, Negativ auf der Rückseite.
; SideType GetPointSide(Vector point, vec_t epsilon = 0.01f)
: Führt ein DistTo() aus und wertet das Ergebnis aus. der Optionale epsilon-Wert bestimmt eine -Schwelle, innerhalb derer der zurückgelieferte Wert als SIDE_ON betrachtet wird.
: SideType ist eine redifinierter , der definierte (#define) Werte von SIDE_FRONT, SIDE_BACK und SIDE_ON hat.
; SideType GetPointSideExact(Vector point)
: Wie oben, nur ohne epsilon und der Annahme, dass 0 hinter der Ebene liegt.
; VPlane Flip()
: Liefert eine neue VPlane, deren m_Dist und m_Normal invertiert sind. Ändert nicht die Werte der gegebenen VPlane (aber this = Flip() würde es).
; GetPointOnPlane()
: Liefert den Punkt, der am nahesten zum aktuellen liegt.
; Vector SnapPointToPlane(const Vector &point)
: Liefert einen neuen Vektor, der den nahesten Punkt auf der Ebene zum gegebenen vektor darstellt.
De/Valve Hammer Editor

Der Valve Hammer Editor (inoffiziell bekannt als Hammer) war das offizielle Mapping-Werkzeug für die -Engine - die Engine, mit der Half-Life, Counter Strike und andere pre-Source Valve Spiele liefen. Die neuste Version ist im Source SDK enthalten und dient dem Mapping für die -Engine (mit der alle neueren Valve Spiele laufen). Auf dieser Seite wird die Geschichte des Mapping-Werzeugs dokumentiert.
== Hammer 3.x ==
Ursprünglich unter dem Namen The Forge entwickelt und unter dem Namen Worldcraft auf der Retail-CD von verbreitet, ist Valve Hammer Editor 3.x das offizielle Mapping-Werkzeug.
=== FGDs ===
* ()
* ()
* ()
* ()
* ()
* ()
* ()
* ()
== Hammer 4.x ==
Valve Hammer Editor 4.x, bereitgestellt als ein Teil des , das offizielle Mapping-Werkzeug. Abseits vom konstruieren von Levelarchitektur ist der Valve Hammer Editor 4.x ebenfalls schwer am Erstellen von Levelevents und dem Scripting beteiligt.
=== FGDs ===
* ()
== See also ==
* 
* 
* 
* 
* 
* 
* 
== External links ==
* Wikipedia:Valve Hammer Editor
De/View Navigation

Die Bewegung der ausschnitte ist essentiell, wenn du in Hammer sehen können willst, was du tust. Hammer erlaubt dir, einerseits manuell mit der Tastatur und/oder der Maus zu navigieren und andererseits zwischen Kameras an verschiedenen Positionen umzuschalten.
==Navigation==
===3D-Sichtfensternavigation===
thumb|right|200px|Das Kamerawerkzeug.
In den 3D-Sichtfenstern bewegst Du den sichtbaren Ausschnitt mit den Tasten . Wie im Spiel bewegt man sich hiermit vorwärts (W), rückwärts (S) oder seitwärts (A / D). Mit dem Mausrad kann man sich schnell vorwärts und rückwärts bewegen.
Wenn du dich umsehen bzw. den Sichtausschnitt drehen willst, kannst du das in der aktivieren. Danach kannst Du den 3D-Sichtfensterausschnitt 
* mit um die gegenwärtigen Position in jeder Richtung drehen,
* mit zur Seite und nach oben und unten verschieben und
* mit nach vorne/hinten und seitlich verschieben.
===2D-Sichtfensternavigation===
Der Ausschnitt der 2D-Sichtfenster kann folgendermaßen verschoben werden:
* mit den Pfeiltasten;
* mit den Scrollleisten (soweit diese aktiviert sind);
* mit .
Zum Vergrößern/Verkleinern im aktiven 2D-Sichtfenster kann man folgende Methoden verwenden:
* das Mausrad drehen;
* voreingestellte Zoomstufen über (nicht im Nummernblock!);
* das Vergrößerungswerkzeug benutzen.
Zum gleichzeitigen Vergrößern/Verkleinern im allen 2D-Sichtfenster kann man folgende Methoden verwenden:
* die Tasten und im Nummernblock;
* bei gedrückter -Taste das Mausrad drehen.
== Eine Kamera erzeugen ==
thumb|left|100px|Das Kamerawerkzeug.
Um eine Kamera einzurichten, aktiviert man das Kamerawerkzeug in der Werkzeugleiste mittels eines einfachen Klicks.
Nun klickt man in eines der 2D-Sichtfenster und bewegt die Maus bei gedrückter , wie man es rechts sieht. Der Ausschnitt der 3D-Sichtfenster wird nach dem Loslassen so eingestellt, dass von der in den 2D-Sichtfenstern als blauer Kreis angezeigten Kamera entlang der Blickrichtungslinie geschaut wird.
Man kann die Position der Kamera in den 2D-Sichtfenstern ändern, indem man auf den blauen Kreis klickt und ihn dann bei gedrückter verschiebt. Die Blickrichtung verändert man, indem man die Blickrichtungslinie an ihrem Endpunkt bei gedrückter bewegt. Das Bild in der 3D Ansicht wird nach dem Loslassen automatisch aktuallisiert.
Mit lassen sich nacheinander mehrere Kameras erstellen, die man mit und durchschalten kann. Die aktuelle Kamera kann mit gelöscht werden.
De/Visleaf

Jedes Visleaf (manchmal nur als Leaf bezeichnet) ist ein hohler Raum in einer Map welcher eine Gruppe sichtbarer Oberflächen definiert. jede sichtbare Oberfläche gehört zu mindestens einem Visleaf. Visleafs werden hauptsächlich von der Rendering Engine benutzt, um (vor dem Rendern der Frames) zu bestimmen, welche Bereiche der Map möglicherweise sichtbar sind. Wenn irgendein Teil eines Visleafs aus einem beliebigen Bereich des aktiven Visleafs ist, wird der gesamte Inhalt dieses Visleafs für den Rendervorgang in Betracht gezogen. 
Visleafs werden automatisch vom durch das Compile Tool generiert. jede (interne) Oberfläche eines Visleafs ist entweder ein oder ein Portal zu einem benachbartem Visleaf. 
== Überprüfung ==
Es gibt 3 Wege, Visleafs zu betrachten:
* Aus der Version von Hammer: Die Leaves der derzeitigen Map können direkt in der 3D-Ansicht über das Menü Map > Load Portal File betrachtet werden. Das zeigt Leafecken, die andere Ecken berühren, als dicke blaue Linien.
* Vom Desktop: Die Anwendung (befindlich im Ordner <user>\sourcesdk\bin\orangebox\bin\) kann verwendet werden.
* Von der : Die kann verwendet werden. (mat_leafvis 3 wird alle Visleafs im aktiven zeigen.)
== Siehe auch ==
* (Potentially Visible Set): Die Gruppe der momentan sichtbaren Visleafs
* (Potentially Audible Set): Wie das PVS, nur für Soundeffekte
*
** sind Lücken in der WorldGeometry, die die Generierung von Visleafs verhindern
** können genutzt werden, um Visleafs manuell einzuteilen
*Visleaf Generierung: 
** compiler.
** Ralph van Hoorn's explanation of visleafs.
Category:German
De/Weapon Respawn Fix

== Einleitung ==
Wenn Waffen nicht richtig vom Level Designer platziert werden (z. B. wenn ihre Boundingbox mit einer anderen Entity oder der Weltgeometrie überlappt), Respawnen sie an einer falschen Position, nachdem sie von Spielern aufgehoben wurden. In den meisten Fällen spawnen die Waffen stattdessen an 0 0 0 auf der Map und werden ununterbrochen in einer Schleife des Fallens, des Wartens, des Respawnens und des erneuten Fallens stecken. Glücklicherweise ist die Behebung dieses üblichen Fehlers sehr einfach.
== Voraussetzungen ==
* Der neuste Multiplayer OB SDK Code
== Lösung ==
Öffne game/shared/hl2mp/weapon_hl2mpbase.h und ändere diesen Block:
#ifdef GAME_DLL
	DECLARE_DATADESC();
	void Materialize( void );
	virtual	int	ObjectCaps( void );
#endif
in diesen:
#ifdef GAME_DLL
	DECLARE_DATADESC();
	void Materialize( void );
	virtual	int	ObjectCaps( void );
	virtual void	FallThink( void );						// lässt eine Waffe nach dem Spawnen auf den Boden fallen
#endif
Bearbeite nun game/shared/hl2mp/weapon_hl2mpbase.cpp und ändere in CWeaponHL2MPBase::FallInit( void ):
	SetThink(&CBaseCombatWeapon::FallThink);
zu:
	SetThink(&CWeaponHL2MPBase::FallThink);
Füge den folgenden Block unter CWeaponHL2MPBase::FallInit( void ) hinzu:
#ifdef GAME_DLL
void CWeaponHL2MPBase::FallThink(void)
{
	// Vermeidet den üblichen HL2DM Waffen Respawn Bug
	// Wenn eine Waffe spawnt, werden folgende Events auftreten:
	// - Spawn() wird aufgerufen, welches FallInit() aufruft
	// - FallInit() bereitet die 'Think'-Funktion der Waffe vor (CBaseCombatWeapon::FallThink())
	// - FallThink() führt diverse Prüfungen durch, bevor entschieden wird, ob die Funktion Materialize() der Waffe aufgerufen werden soll
	// - Materialize() (die HL2DM-Version oben), welche die Respawnposition der Waffe festlegt.
	// Das Problem tritt auf, wenn eine Waffe vom Level Designer nicht richtig platziert wurde.
	// Wenn die Waffe sich von der gegebenen Position nicht bewegen kann (z. B. wenn seine Bounding Box zur Hälfte in einer Wand steckt), wird Materialize() nie aufgerufen.
	// Da Materialize() nie aufgerufen wird, wird die Respawnposition der Waffe nie gesetzt, also respawnt sie, wenn sie aufgehoben wird, für immer an
	// 0 0 0 auf der Map (Endlosschleife aus Fallen, Warten, Respawnen - nicht schön für die Performance und die Bandbreite!)
	if ( HasSpawnFlags( SF_NORESPAWN ) == false )
	{
		if ( GetOriginalSpawnOrigin() == vec3_origin )
		{
			m_vOriginalSpawnOrigin = GetAbsOrigin();
			m_vOriginalSpawnAngles = GetAbsAngles();
		}
	}
	return BaseClass::FallThink();
}
#endif // GAME_DLL
Und das ist alles dazu - falsch platzierte Waffen sollten nun an der richtigen Stelle respawnen und nicht an einer ungeschickten Position auf der Map.