Facepunch

https://docs.facepunch.com/
Admin
Facepunch is an online community and forum primarily focused on gaming and general discussion.
Tokens:226,301
Snippets:909
Trust Score:9.8
Update:1 year ago
Show doc for...
Tokens:
Raw
### Run s&box Dedicated Server

Source: https://docs.facepunch.com/s/sbox-dev/doc/dedicated-servers-WGeGAD9U8d

Example batch file to start the s&box dedicated server with specified game and map.

```batch
echo off
sbox-server.exe +game facepunch.walker garry.scenemap +hostname My Dedicated Server
```

--------------------------------

### S&box Shader Graph Documentation

Source: https://docs.facepunch.com/s/sbox-dev/doc/shader-graph-O1KJlOQ8Pe

Details the Shader Graph system within S&box, including getting started guides, properties, variables, custom nodes, and shader creation.

```APIDOC
Shader Graph:
  - Getting Started
  - Properties
  - Variables
  - Custom Nodes
  - Shaders
  - Terrain
  - UI
  - VR
```

--------------------------------

### S&box Documentation Overview

Source: https://docs.facepunch.com/s/sbox-dev/doc/assetsresources-vfClHodkqi

Provides an overview of the S&box documentation structure, covering key areas like Getting Started, Code, Libraries, Systems, and Editor tools.

```English
S&box Documentation

About
Getting Started
FAQ
Status
Code
Code Basics
Advanced Topics
Libraries
Systems
ActionGraph
Assets/Resources
Custom Assets
GameResource Extensions
Cloud Assets
Effects
File System
Input
Movie Maker
Networking & Multiplayer
Navigation
Post Processing
Services
Shader Graph
Shaders
Terrain
UI
VR
Scene
Scenes
GameObject
Components
GameObjectSystem
Prefabs
Editor
Editor Project
Editor Widgets
Editor Apps
Property Attributes
Custom Editors
Asset Previews
Editor Shortcuts
Editor Events
Texture Generators
Editor Tools
Undo System
Assets
Clothing
Ready-to-use Assets
```

--------------------------------

### ISceneStartup Example Implementation

Source: https://docs.facepunch.com/s/sbox-dev/doc/iscenestartup-UaHEQHresW

Provides a C# example of implementing the ISceneStartup interface within a GameObjectSystem. It demonstrates how to use OnHostInitialize to load additive scenes and initiate networking.

```csharp
public sealed class MyGameManager : GameObjectSystem<GameManager>, ISceneStartup
{
	public MyGameManager( Scene scene ) : base( scene )
	{
	}

	void ISceneStartup.OnHostInitialize()
	{
		// Spawn the engine scene.
		// This scene is sent to clients when they join.
		var slo = new SceneLoadOptions();
		slo.IsAdditive = true;
		slo.SetScene( "scenes/engine.scene" );
		Scene.Load( slo );

		// If we're not hosting a lobby, start hosting one
		// so that people can join this game.
		Networking.CreateLobby();
	}
}
```

--------------------------------

### S&box Project Setup

Source: https://docs.facepunch.com/s/sbox-dev/doc/first-time-setup-vXGEshDxIa

Instructions on how to create a new S&box project and configure it for asset creation. Emphasizes selecting the 'Addon' template and enabling 'Show Base Content' for access to core files.

```English
Open S&box and make a new project. You can select ‘Addon’ as your template since we’re only going to publish a model.

Make sure to turn on _‘Show Base Content’_. This will allow you to see important ‘core’ folders and files in the asset browser, which you will be using during the clothing creation process.

You will **never** need to add or adjust files within the core folders (e.g. the citizen addon folder). Only within your local project folder.
```

--------------------------------

### Grabbing Citizen Reference Files

Source: https://docs.facepunch.com/s/sbox-dev/doc/first-time-setup-vXGEshDxIa

Details on how to locate and use the `citizen_REF.fbx` file for building clothing around the citizen mesh and rig. This file is essential for the initial setup in 3D modeling software.

```English
Find useful files in `Steam\steamapps\common\sbox\addons\citizen\Assets\models\citizen`
In that folder can use `citizen_REF.fbx`, which supplies you with the citizen mesh and simple rig. 

Moving forward, we will use `citizen_REF.fbx` to build our clothing around it.
By the end of this set up, you should have the citizen in your 3D software of choice and you’ll be ready to make some clothing.
```

--------------------------------

### S&box Documentation Overview

Source: https://docs.facepunch.com/s/sbox-dev/doc/shader-graph-O1KJlOQ8Pe

Provides a high-level overview of the S&box documentation structure, covering key areas like Getting Started, Code, Libraries, Systems, and Editor functionalities.

```APIDOC
S&box Documentation:
  - About
  - Getting Started
  - FAQ
  - Status
  - Code:
    - Code Basics
    - Advanced Topics
  - Libraries
  - Systems:
    - ActionGraph
    - Assets/Resources
    - Effects
    - File System
    - Input
    - Movie Maker
    - Networking & Multiplayer
    - Navigation
    - Post Processing
    - Services
    - Shader Graph
    - Terrain
    - UI
    - VR
  - Scene:
    - Scenes
    - GameObject
    - Components
    - GameObjectSystem
    - Prefabs
  - Editor:
    - Editor Project
    - Editor Widgets
    - Editor Apps
    - Property Attributes
    - Custom Editors
    - Asset Previews
    - Editor Shortcuts
    - Editor Events
    - Texture Generators
    - Editor Tools
    - Undo System
  - Assets:
    - Clothing
    - Ready-to-use Assets
  - Systems:
    - Shader Graph
  - Documents:
    - Getting Started
    - Properties
    - Variables
    - Custom Nodes
  - Shader Graph
```

--------------------------------

### S&box Documentation Structure

Source: https://docs.facepunch.com/s/sbox-dev/doc/reference-BJL2nZu6aE

Overview of the S&box documentation, detailing its organization into sections like Getting Started, Code, Libraries, Systems, and Editor tools. It highlights key areas such as ActionGraph, Assets, Effects, Input, Networking, and UI.

```APIDOC
S&box Documentation:
  - About
  - Getting Started
  - FAQ
  - Status
  - Code:
    - Code Basics
    - Advanced Topics
  - Libraries
  - Systems:
    - ActionGraph
    - Assets/Resources
    - Effects
    - File System
    - Input
    - Movie Maker
    - Networking & Multiplayer
    - Navigation
    - Post Processing
    - Services
    - Shader Graph
    - Shaders
  - Classes:
    - Reference:
      - Screen-Space Reflections
      - Default Vertex and Pixel Shader Inputs
      - Global Variables
      - Vertex Helpers
    - Modes
    - Attributes and Variables
    - Shading Model
    - Sampler States
    - Render States
    - Material
    - Command Lists
    - GPU Instancing
    - Terrain
  - UI
  - VR
  - Scene:
    - Scenes
    - GameObject
    - Components
    - GameObjectSystem
    - Prefabs
  - Editor:
    - Editor Project
    - Editor Widgets
    - Editor Apps
    - Property Attributes
    - Custom Editors
    - Asset Previews
    - Editor Shortcuts
    - Editor Events
    - Texture Generators
    - Editor Tools
    - Undo System
  - Assets:
    - Clothing
    - Ready-to-use Assets
```

--------------------------------

### Adding Components

Source: https://docs.facepunch.com/s/sbox-dev/doc/components-zIujvXKpIl

Demonstrates how to add new components to a GameObject using AddComponent and GetOrAddComponent, including initial setup.

```C#
// Create
var modelRenderer = go.AddComponent<ModelRenderer>();

// Set up
modelRenderer.Model = Model.Load( "models/dev/box.vmdl" );
modelRenderer.Tint = Color.Red;
```

```C#
// Get or create
var modelRenderer = go.GetOrAddComponent<ModelRenderer>();

// Set up
modelRenderer.Model = Model.Load( "models/dev/box.vmdl" );
modelRenderer.Tint = Color.Green;
```

--------------------------------

### Texture Asset Preview Example

Source: https://docs.facepunch.com/s/sbox-dev/doc/asset-previews-ikgF8IYAjX

Provides an example of creating a custom asset preview for a texture. It sets up a SpriteRenderer with the texture and configures the camera for a static, orthographic view.

```C#
[AssetPreview("mytex")]
public class PreviewMyTextureResource : AssetPreview
{
	// Since we're only previewing a texture, we don't need to bother rendering a video
	public override bool IsAnimatedPreview => false;

	public PreviewMyTextureResource( Asset asset ) : base( asset )
	{
	}

	public override Task InitializeAsset()
	{
		// Get the resource from the asset
		var resource = Asset.LoadResource<MyTextureResource>();

		// Get the Texture from the resource
		var texture = resource?.Texture;
		if ( texture is null )
		{
			return Task.CompletedTask;
		}

		// Make sure we are scoped to the preview scene
		using ( Scene.Push() )
		{
			// Create a new GameObject with a SpriteRenderer component 
			PrimaryObject = new GameObject( true, "Texture Preview" );
			PrimaryObject.WorldTransform = Transform.Zero;

			var spriteRenderer = PrimaryObject.AddComponent<SpriteRenderer>();
			spriteRenderer.Texture = texture; // Set the texture on the renderer
			spriteRenderer.Size = 100;
		}

		return Task.CompletedTask;
	}

	public override void UpdateScene( float cycle, float timeStep )
	{
		base.UpdateScene( cycle, timeStep );

		// Override the Camera settings so the camera is fixed on the Texture
		Camera.Orthographic = true;
		Camera.OrthographicHeight = 100;
		Camera.WorldPosition = Vector3.Backward * 100;
		Camera.WorldRotation = Rotation.LookAt( Vector3.Forward );
	}
}
```

--------------------------------

### MoviePlayer Setup

Source: https://docs.facepunch.com/s/sbox-dev/doc/api-TtGca3qY5b

Demonstrates how to set up a MoviePlayer component, assign a MovieClip, configure its binder, and control playback position.

```C#
var moviePlayer = GameObject.AddComponent<MoviePlayer>();

moviePlayer.Clip = clip;
moviePlayer.Binder.Get( clip.GetReference( "Camera" ) ).Bind( Game.ActiveScene.Camera );

moviePlayer.Position = 0.75;
```

--------------------------------

### Install s&box Dedicated Server

Source: https://docs.facepunch.com/s/sbox-dev/doc/dedicated-servers-WGeGAD9U8d

Command to install or update the s&box Dedicated Server using SteamCMD.

```bash
./steamcmd +login anonymous +app_update 1892930 validate +quit
```

--------------------------------

### OnClientInitialize Example

Source: https://docs.facepunch.com/s/sbox-dev/doc/iscenestartup-UaHEQHresW

Demonstrates the usage of OnClientInitialize within a GameManager class to load the engine scene and create a network lobby.

```csharp
public sealed class MyGameManager : GameObjectSystem<GameManager>, ISceneStartup
{
	public MyGameManager( Scene scene ) : base( scene )
	{
	}

	void ISceneStartup.OnHostInitialize()
	{
		//
		// We don't have a menu, but if we did we could put something in the menu
		// scenes that we'd now be able to detect, and skip doing the stuff below.
		//

		//
		// Spawn the engine scene.
		// This scene is sent to clients when they join.
		//
		var slo = new SceneLoadOptions();
		slo.IsAdditive = true;
		slo.SetScene( "scenes/engine.scene" );
		Scene.Load( slo );

		// If we're not hosting a lobby, start hosting one
		// so that people can join this game.
		Networking.CreateLobby();
	}
}
```

--------------------------------

### C# Component Using ActionGraph

Source: https://docs.facepunch.com/s/sbox-dev/doc/using-with-c-qqYkuRx3Gc

Example C# component demonstrating how to declare an ActionGraph property and invoke it based on input.

```C#
public class ExampleComponent : Component
{
	[Property]
	public Action ExampleAction { get; set; }

	protected override void OnUpdate()
	{
		if ( Input.Down( "attack1" ) )
		{
			ExampleAction?.Invoke();
		}
	}
}
```

--------------------------------

### S&box Movie Maker Recording Guide

Source: https://docs.facepunch.com/s/sbox-dev/doc/recording-xB1JECmTcv

This guide explains how to record gameplay and animations using S&box's Movie Maker. It covers setting up tracks, initiating and stopping recordings in both play mode and editor mode, and essential editing techniques for polishing recorded footage.

```APIDOC
S&box Movie Maker Recording:

Recording in Play Mode:
  - Purpose: Capture gameplay, animate cameras, or record trailers by controlling characters directly in-game.
  - Setup: Create tracks for properties to be recorded. Common tracks (e.g., for Player Controllers) are added automatically when dragging objects to the track list.
  - Process: Enter play mode, press the 'Toggle Record' button to start. Changes to properties bound to tracks are recorded. Press 'Toggle Record' again to stop.
  - Post-Recording: Recordings persist after exiting play mode, allowing for further editing and saving.

Recording in Editor Mode:
  - Purpose: Puppet properties as a starting point for animation without entering play mode.
  - Setup: Ensure tracks are created for desired properties.
  - Process: Use the 'Toggle Record' button to start and stop recording.

Editing Recorded Footage:
  - Tools: Utilize the Motion Editor or Keyframe Editor for polishing.
  - Cutting:
    - Recommendation: Save recordings to a separate .movie file.
    - Method: Reference the saved .movie as a sequence block in the main project.
    - Benefit: Allows extraction of clips and adjustment of start/end times.
  - Smoothing:
    - Problem: Recordings can be shaky due to manual control (puppeting, camera operation).
    - Solution: Use the 'Smoothen' option in the Motion Editor context menu.
    - Application: Apply to a selected time range to round out rough edges.
    - Control: Adjust the smoothing window size; larger values result in smoother tracks.
```

--------------------------------

### S&box Networking and Multiplayer

Source: https://docs.facepunch.com/s/sbox-dev/doc/effects-mxZGUPQ268

Guides on implementing networking and multiplayer features in S&box, covering client-server communication and synchronization.

```English
S&box Documentation
Networking & Multiplayer
```

--------------------------------

### s&box Testbed Game Exploration

Source: https://docs.facepunch.com/s/sbox-dev/doc/first-steps-7IyiSplYmn

Instructions on how to launch the s&box 'testbed' game to explore engine features through various scenes. The game uses a UI system similar to Blazor (HTML with C#) and a scene-based engine architecture.

```text
Start s&box (not the editor) and find the game called `testbed`.
When you enter the game you’ll find a menu of scenes. Each scene tests a different engine feature.
Click a scene to enter it, have a play around, press escape to return to the main menu. You can hold escape to completely leave any game.
```

--------------------------------

### Grabbing Human Reference Files

Source: https://docs.facepunch.com/s/sbox-dev/doc/first-time-setup-vXGEshDxIa

Explains where to find the `citizen_human_male_REF` and `citizen_human_female_REF` files, which serve the same purpose as the citizen reference but for human models. These are crucial for creating human-specific clothing.

```English
We also have the `citizen_human_male_REF` and `citizen_human_female_REF` which both have the same use-case, but for the human versions of your clothing. 
These can be found in `sbox\game\addons\citizen\Assets\models\citizen_human`.
```

--------------------------------

### s&box Project Creation and Scene Editing

Source: https://docs.facepunch.com/s/sbox-dev/doc/first-steps-7IyiSplYmn

Guidance on creating a new s&box project using the editor, starting with a minimal game template. It explains how to create GameObjects and Components, and how to edit scenes which are stored as JSON files.

```text
Open the s&box editor and on the welcome screen, choose New Project. Create a Minimal Game project.
Once open you have an empty scene. You can experiment by creating GameObjects by right clicking the tree on the left, and selecting an object type to create.
After that, try to **make a GameObject** that you can control by creating a custom component by selecting **Add Component** on the GameObject inspector and typing in a name. The file should open in Visual Studio.
```

```json
Scenes are json files on disk
```

--------------------------------

### Define Game Setting Console Variable

Source: https://docs.facepunch.com/s/sbox-dev/doc/console-variables-7ZIbxHBMq4

Exposes a console variable to the game's creation screen, typically as a slider, allowing configuration during game setup. This example sets player speed.

```csharp
//
// Shows up in the game creation screen, as a slider.
//
[ConVar("player_speed", ConVarFlags.GameSetting ),Range(50f,1024f,1)]
public static float PlayerSpeed { get; set; } = 250f;
```

--------------------------------

### S&box NavMesh API Usage

Source: https://docs.facepunch.com/s/sbox-dev/doc/navigation-vwoSUsEPJ9

Provides examples of common operations using the s&box NavMesh API, including getting random points, finding the closest point, generating paths, and marking the NavMesh as dirty for rebuilding.

```C#
var pos = Scene.NavMesh.GetRandomPoint();

var pos = Scene.NavMesh.GetRandomPoint( testposition, radius );

var pos = Scene.NavMesh.GetClosestPoint( testposition );

var pos = Scene.NavMesh.GetClosestEdge( testposition );

List<Vector3> path = Scene.NavMesh.GetSimplePath( startPos, endPos );

Scene.NavMesh.SetDirty();
```

--------------------------------

### Calling Async from Synchronous Code (Manual Task Management)

Source: https://docs.facepunch.com/s/sbox-dev/doc/async-c0vp1CRxmo

Provides an example of how to manually manage an asynchronous task initiated from synchronous code. The task is started in `OnEnabled` and its result is checked and processed in `OnUpdate` once the task is completed.

```C#
Task<string> getQuoteTask;

protected override void OnEnabled()
{
	getQuoteTask = GetKanyeQuote();
}

protected override void OnUpdate()
{
	if ( getQuoteTask is not null && getQuoteTask.IsCompletedSuccessfully )
	{
		Log.Info( $"Kanye: {getQuoteTask.Result}" );
		getQuoteTask = null;
	}
}
```

--------------------------------

### Setting up .Clothing File

Source: https://docs.facepunch.com/s/sbox-dev/doc/publishing-clothing-7L7quFgY3u

This section details the initial setup of a .Clothing file, which is essential for defining custom clothing assets. It includes specifying VMDL files for the clothing and human models, VMAT files, and configuring the clothing's category and sub-category for proper in-game display.

```English
Right click in your folder - `New / Citizen / Clothing Definition`
Add your Vmdls, original Citizen model goes in ‘Model’. Standard male human version goes in `Human Alt Model` and your Female human variation goes in the `Human Alt Female Model`.
Give your Clothing a suitable name and description. In this example, we’re making a Hat, so we set the category to `Hat` and we type _“_** _Hats”_** for the Sub Category. So it’ll show up correctly in the character menu.
In Icon, we can generate a thumbnail for our .clothing file. Since we’re making a hat, we want the Mode set to `Head`, which will orient the camera on the head. `Save Icon to Disk` to generate and save your clothing Icon.
```

--------------------------------

### Shader Graph Editor Overview

Source: https://docs.facepunch.com/s/sbox-dev/doc/getting-started-Zf6VDrVgwG

Describes the main sections of the Shader Graph Editor: Preview, Properties, Graph, and Output. Explains how to open the editor and customize the layout.

```APIDOC
Shader Graph Editor Sections:
1. Preview - Displays real-time shader output. Allows changing preview model/lighting.
2. Properties - Inspector for editing shader properties and selected nodes.
3. Graph - Workspace for nodes, ending with a 'Material' node for output values.
4. Output - Shows errors/warnings, with tabs for Console, Undo History, and Node Palette.

Customization: Tabs can be repositioned.
```

--------------------------------

### Configuring Body Slots for Clothing

Source: https://docs.facepunch.com/s/sbox-dev/doc/publishing-clothing-7L7quFgY3u

This guide explains how to set body slots for clothing items, determining how they layer with other assets. It differentiates between 'Slots Under' for base layers and 'Slots Over' for items that layer on top, providing examples for shirts, jackets, and hats.

```English
We also want to set our Body Slots, for a Hat like a baseball cap that only covers to the top of the Head, we’d want to set it to _Slots Under_ - `HeadTop`.

**Slots Under** is where shirts, trousers and shoes go, (Layer 1). Anything that fits over that would be **Slots Over**. This doesn’t remove the Layer 1 clothing when selected, which would be for open jackets or vests; treat it as your Layer 2. 
If you’re making a clothing asset that completely covers the whole body. Select all the slots on both **Slots Under** and **Slots Over** to make sure nothing can be selected when it’s worn.
As an example, you can see that the **Shirt** has `Chest, LeftArm, RightArm` selected in **Slots Under.**
To pair a jacket on top, the open Jacket (Open) has `LeftArm, RightArm` selected in **Slots Over.**
Though, if we have a jacket that sits on top of shirts, but completely covers the shirt as well as the whole torso bodygroup, we can use `LeftArm, RightArm` in **Slots Over** and `Chest` in **Slots Under**. Since Shirts have `Chest` selected in their **Slots Under** , this’ll mean the shirt will be removed when selecting the **closed Jacket** since it’s covering it completely.
Best bet is to follow the examples laid out above, if you’re making a shirt, follow the Body Slots of the example.
What part of the body is being covered? If you’re clothing is on Layer 1 (something that will have a jacket / vest / anything on top of it), then select your body slots in ‘**Slots Under’. I** f you’re clothing is on Layer 2 (open coat that’s expected to sit on top of shirts), then select your body slots in **‘Slots Over’**.
```

--------------------------------

### S&box FAQ

Source: https://docs.facepunch.com/s/sbox-dev/doc/faq-sV2ZwDvc6K

Frequently asked questions about S&box, covering release date, pricing, addon system, developer preview access, engine choice (Source 2 vs. Unity/UE), creator monetization, and the nature of S&box as an engine or platform.

```APIDOC
FAQ:
  When will it be released?
    We're not in a rush (obviously). I think we'll know when it's ready to be released and it's probably best not to speculate.
  How much will it cost?
    We don't know. We haven't decided yet.
  Are you using workshop?
    No. We're trying to try to make a system where you don't have to install addons. This is what sbox.game is. In the same way you don't have to install videos from YouTube, you just download what you need.
  How can I get access to the developer preview?
    Head over to https://sbox.game/give-me-that, log in and click the button to add it to your steam account.
  Why not Unity? Why not UE?
    We're sentimental about the Source engine. Source2 has a beautiful renderer and brings the engine up to date with tools like ModelDoc and Animgraph.
    It would have been cheaper and easier to do this all on Unity or UE, but we would have loved it less.
  Will creators be able to monetize?
    Yes. But we want to be careful about what that means. We don’t want everything becoming pay to win like on other platforms.
  So is it an engine, or a platform?
    It’s everything. An explanation was posted on this blog here.
```

--------------------------------

### S&box Body Slot Layering Guide

Source: https://docs.facepunch.com/s/sbox-dev/doc/publishing-clothing-7L7quFgY3u

Explains the 'Body Slots' system in S&box for layering clothing assets. Differentiates between 'Slots Under' (Layer 1) and 'Slots Over' (Layer 2) and provides examples for correct slot assignment based on coverage.

```APIDOC
Body Slot Layering:

Layer 1 (Slots Under):
  - Used for base clothing items like shirts, trousers, and shoes.
  - Defines which body parts are covered by this layer.
  - Example: A shirt might have 'Chest', 'LeftArm', 'RightArm' selected.

Layer 2 (Slots Over):
  - Used for clothing items worn over Layer 1 items, like open jackets or vests.
  - Does not remove Layer 1 clothing by default.
  - Example: An open jacket might have 'LeftArm', 'RightArm' selected.

Complete Body Coverage:
  - To ensure no other clothing can be selected when an item is worn, select all slots in both 'Slots Under' and 'Slots Over'.

Overlapping Coverage:
  - If Layer 2 clothing completely covers Layer 1 clothing (e.g., a closed jacket covering a shirt), the Layer 1 item will be removed.
  - Example: A closed jacket using 'LeftArm', 'RightArm' in 'Slots Over' and 'Chest' in 'Slots Under' will remove a shirt that has 'Chest' in its 'Slots Under'.
```

--------------------------------

### S&box UI System

Source: https://docs.facepunch.com/s/sbox-dev/doc/first-steps-7IyiSplYmn

The s&box UI system is described as being similar to HTML with C# embedded, akin to Blazor. It is used for creating menus and interfaces within the engine.

```APIDOC
UI System:
  Description: Similar to HTML with C# embedded (like Blazor).
  Usage: Used for creating menus and interfaces within the s&box engine.
```

--------------------------------

### Reading Player Stats

Source: https://docs.facepunch.com/s/sbox-dev/doc/stats-As30shVf3K

Provides examples for retrieving player statistics, including global counts and individual player data. It shows how to get the total number of 'zombies_killed' globally and for the local player, as well as fetching stats for a specific player by their identifier.

```csharp
// get global zombie kill count
var zombies = Sandbox.Services.Stats.Global.Get( "zombies_killed" );

Log.Info( $"there have been {zombies.Sum} zombies killed by {zombies.Players} players!" );
```

```csharp
// Get local player zombie kill count
var zombies = Sandbox.Services.Stats.LocalPlayer.Get( "zombies_killed" );

Log.Info( $"You have killed {zombies.Sum} zombies!" );
```

```csharp
// Get stats for Garry in SS1
var stats = Sandbox.Services.Stats.GetPlayerStats( "facepunch.ss1", 76561197960279927 );

// wait for them to download
await stats.Refresh();

var zombies = stats.Get( "zombies_killed" );

Log.Info( $"Garry has killed {zombies.Sum} zombies!" );
```

--------------------------------

### Game Project Startup and Map Loading

Source: https://docs.facepunch.com/s/sbox-dev/doc/game-project-y3Rm2sZORZ

This C# code demonstrates how to implement a GameObjectSystem for a game project in S&box. It shows how to initialize a startup scene and load additional scenes additively, which is useful for setting up game managers or UI elements when a map is loaded from the main menu.

```C#
public sealed class MyGameManager : GameObjectSystem<MyGameManager>,ISceneStartup
{
	public MyGameManager( Scene scene ) : base( scene )
	{
	}

	void ISceneStartup.OnHostInitialize()
	{
		var slo = new SceneLoadOptions();
		slo.IsAdditive = true;
		slo.SetScene( "scenes/engine.scene" );
		Scene.Load( slo );
	}
}
```

--------------------------------

### Multi-Frame Action Undo Scope (Box Collider Resize)

Source: https://docs.facepunch.com/s/sbox-dev/doc/undo-system-d4mhnmtil1

Provides an example of managing an undo scope across multiple frames for an action like resizing a Box Collider, ensuring the scope is created when the action starts and disposed when it ends.

```C#
public class BoxColliderTool : EditorTool<BoxCollider>
{
	private IDisposable _componentUndoScope;

	public override void OnUpdate()
	{
		var boxCollider = GetSelectedComponent<BoxCollider>();
		if ( boxCollider == null )
			return;

		var currentBox = BBox.FromPositionAndSize( boxCollider.Center, boxCollider.Scale );

		using ( Gizmo.Scope( "Box Collider Editor", boxCollider.WorldTransform ) )
		{
			if ( Gizmo.Control.BoundingBox( "Bounds", currentBox, out var newBox ) )
			{
				if ( _componentUndoScope == null )
				{
                   // Create scope if it not exists
					_componentUndoScope = SceneEditorSession.Active.UndoScope( "Resize Box Collider" )
                                            .WithComponentChanges( boxCollider )
                                            .Push();
				}
				boxCollider.Center = newBox.Center;
				boxCollider.Scale = newBox.Size;
			}
   
            // Dispose scope when mouse is release
			if ( Gizmo.WasLeftMouseReleased )
			{
				_componentUndoScope?.Dispose();
				_componentUndoScope = null;
			}
		}
	}
}
```

--------------------------------

### S&box Code Generation: Networked Variables Example

Source: https://docs.facepunch.com/s/sbox-dev/doc/code-generation-zhqowLeADO

Illustrates using the CodeGenerator attribute with WrapPropertySet and WrapPropertyGet flags to implement a networked variable system. It includes the attribute definition for networked variables and the callback methods for getting and setting property values.

```C#
[CodeGenerator( CodeGeneratorFlags.WrapPropertySet | CodeGeneratorFlags.Instance,"OnNetVarSet")]
[CodeGenerator( CodeGeneratorFlags.WrapPropertyGet | CodeGeneratorFlags.Instance,"OnNetVarGet")]
public class NetVar : Attribute {}

public class MyObject
{
  [NetVar] public string Name { get; set; }
  
  internal T OnWrapGet<T>( WrappedPropertyGet<T> p)
  {
    // Return the actual value from the network.
    if ( MyNetVarTable.TryGetValue( p.PropertyName, out var netValue ) )
    {
      return (T)netValue;
    }
    
    return val;
  }

  internal void OnWrapSet<T>( WrappedPropertySet<T> p )
  {
    if ( IsServer )
    {
      MyNetVarTable[propertyName] = p.Value;
      // Send a networked message setting the property to this value for all clients.
    }
    
    p.Setter( p.Value);
  }
}
```

--------------------------------

### C# CodeGenerator Attribute Example

Source: https://docs.facepunch.com/s/sbox-dev/doc/code-generation-zhqowLeADO

This C# code demonstrates the usage of the `CodeGenerator` attribute with multiple flags to wrap property sets, property gets, and methods for both static and instance members. It includes the attribute definition, usage on class members, and the static callback methods.

```C#
[CodeGenerator(
	CodeGeneratorFlags.WrapPropertySet | CodeGeneratorFlags.WrapPropertyGet | CodeGeneratorFlags.WrapMethod |
	CodeGeneratorFlags.Static | CodeGeneratorFlags.Instance, "MyStaticClass.OnWrapAnything" )]
public class WrapAnything : Attribute {}

public class MyObject
{
  [WrapAnything] public string MyString { get; set; }
  [WrapAnything] public static string MyStaticString { get; set; }
  
  [WrapAnything]
  public void MyMethod()
  {
  }
  
  [WrapAnything]
  public static void MyStaticMethod()
  {
  }
}

public static class MyStaticClass
{
  internal static void OnWrapAnything<T>( WrappedPropertySet<T> p )
  {
  }

  internal static T OnWrapAnything<T>( WrappedPropertyGet<T> p )
  {
    return value;
  }

  internal static void OnWrapAnything( WrappedMethod m, params object[] args )
  {
    m.Resume();
  }

  internal static T OnWrapAnything<T>( WrappedMethod<T> p, params object[] args )
  {
    m.Resume();
  }
}
```

--------------------------------

### Handling Player Input

Source: https://docs.facepunch.com/s/sbox-dev/doc/first-steps-7IyiSplYmn

Instructions on how to read player input (keys) and use it to modify game elements like GameObject positions or camera positions. It suggests using the Input section of the documentation for detailed guidance.

```APIDOC
Player Input Handling:
  Read Keys: Refer to the 'Input' section of the documentation.
  Modify Position: Update 'WorldPosition' based on key presses.
  Control Camera: Parent camera to GameObject or set 'Scene.Camera.WorldPosition' directly.
```

--------------------------------

### S&Box Leaderboard API Example Usage

Source: https://docs.facepunch.com/s/sbox-dev/doc/web-api-jEUfgSS9j8

Example URL for fetching leaderboard data for 'zombies_killed' stat from the S&Box package.

```APIDOC
https://services.facepunch.com/sbox/package/leaderboard/facepunch.ss1/?stat=zombies_killed
```

--------------------------------

### Movie Maker Editor Overview

Source: https://docs.facepunch.com/s/sbox-dev/doc/getting-started-NtNuzKqN4J

Explains how to access and use the Movie Maker editor within the S&box environment. It details toggling the editor visibility and docking it within the UI.

```English
To open the Movie Maker editor, toggle it in the View menu. It can be docked as a tab in the lower panel.
```

--------------------------------

### RPC Broadcast Example

Source: https://docs.facepunch.com/s/sbox-dev/doc/networking-multiplayer-kaVboe3yRD

An example of a broadcast Remote Procedure Call (RPC) method. This method, when called, will be executed on all connected clients.

```C#
[Rpc.Broadcast]
public void OnJump()
{
	Log.Info( $"{this} Has Jumped!" );
}
```

--------------------------------

### Example Input Texture Definition

Source: https://docs.facepunch.com/s/sbox-dev/doc/attributes-and-variables-UMUgpxSzA1

A practical example of defining an input texture named 'AlbedoImage' for the Material Editor, specifying its properties and how it will be filtered in the UI.

```Shader
CreateInputTexture2D( AlbedoImage, Linear, 8, "", "_albedo", "Material,10/30", Default( 0.5 ) );
```

--------------------------------

### Transition Property Examples

Source: https://docs.facepunch.com/s/sbox-dev/doc/style-properties-WSPC2zsKHu

Provides examples of how to use the 'transition' CSS property to animate property changes over time. It shows single property transitions and multi-property transitions.

```css
transition: all 0.1s ease;
transition: opacity 0.1s transform 0.2s ease-out;
```

--------------------------------

### Player Input and Camera Control in s&box

Source: https://docs.facepunch.com/s/sbox-dev/doc/first-steps-7IyiSplYmn

Instructions on how to handle player input (keyboard controls) to manipulate game objects and camera positions within the s&box engine. This involves reading key presses and updating `WorldPosition` or camera transforms.

```csharp
Use the Input section of this site to figure out how to read keys, and change the `WorldPosition` depending on which keys are being pressed.
After that, maybe control the position of the camera too, either by parenting it to your object, or by setting the position directly using `Scene.Camera.WorldPosition`.
```

--------------------------------

### Creating GameObjects and Components

Source: https://docs.facepunch.com/s/sbox-dev/doc/first-steps-7IyiSplYmn

This section details the process of creating GameObjects and custom Components within the s&box editor. GameObjects can be created via the editor's tree view, and custom Components can be added to GameObjects, opening in Visual Studio for editing.

```APIDOC
GameObject and Component Creation:
  Create GameObject: Right-click in the editor's tree view and select an object type.
  Add Component: Select 'Add Component' on a GameObject's inspector and provide a name. The component file opens in Visual Studio.
```

--------------------------------

### Material Fog Effect Example

Source: https://docs.facepunch.com/s/sbox-dev/doc/depth-TeFIlRYujJ

An example demonstrating how to use Depth::GetWorldPosition to calculate the distance between a surface and what's behind it, creating a fog effect on translucent materials.

```C++
Material m = ..

float3 fogColor = float3( 0.1f, 0.1f, 0.1f );
float fogRange = 100.0f;

float3 surfacePos = m.WorldPosition;
float3 depthPos   = Depth::GetWorldPosition( m.ScreenPosition );

float dist = distance( surfacePos, depthPos );

m.Emission = lerp( m.Emission, fogColor, saturate( dist / fogRange ) );
```

--------------------------------

### S&box Documentation Structure

Source: https://docs.facepunch.com/s/sbox-dev/doc/ready-to-use-assets-omNgqQFtXP

This outlines the main sections of the S&box documentation, covering core concepts, advanced topics, libraries, systems, and editor functionalities.

```APIDOC
S&box Documentation:
  About
  Getting Started
  FAQ
  Status
  Code:
    Code Basics
    Advanced Topics
  Libraries
  Systems:
    ActionGraph
    Assets/Resources
    Effects
    File System
    Input
    Movie Maker
    Networking & Multiplayer
    Navigation
    Post Processing
    Services
    Shader Graph
    Shaders
    Terrain
    UI
    VR
  Scene:
    Scenes
    GameObject
    Components
    GameObjectSystem
    Prefabs
  Editor:
    Editor Project
    Editor Widgets
    Editor Apps
    Property Attributes
    Custom Editors
    Asset Previews
    Editor Shortcuts
    Editor Events
    Texture Generators
    Editor Tools
    Undo System
  Assets:
    Clothing
    Ready-to-use Assets
    First-Person Weapons
    Citizen Characters
```

--------------------------------

### Next Steps in ActionGraph

Source: https://docs.facepunch.com/s/sbox-dev/doc/intro-to-actiongraphs-9NEIKrUEyn

After understanding the basics, further learning for ActionGraph involves exploring variables and creating custom nodes.

```English
Now you know the basics, the next things to learn are:
  * How to use variables
  * Creating your own custom nodes
```

--------------------------------

### ActionGraph Overview and Example

Source: https://docs.facepunch.com/s/sbox-dev/doc/actiongraph-CUMGi4q3sS

ActionGraphs provide a node-based visual scripting approach for creating game logic in S&box. This section introduces the concept and provides an example of implementing jumping and falling with gravity.

```English
ActionGraphs let you throw together little scripts using nodes instead of code.

An example ActionGraph that implements jumping and falling with gravity
```

--------------------------------

### Example S&box Component Test in C#

Source: https://docs.facepunch.com/s/sbox-dev/doc/unit-tests-xtbQZBAVAb

An example of a unit test in C# that tests a CameraComponent within the S&box engine. It demonstrates creating a scene, adding a camera, and verifying its presence and absence.

```cs
using Sandbox;

[TestClass]
public class Camera
{
	[TestMethod]
	public void MainCamera()
	{
		var scene = new Scene();
		using var sceneScope = scene.Push();

		Assert.IsNull( scene.Camera );

		var go = scene.CreateObject();
		var cam = go.Components.Create<CameraComponent>();

		Assert.IsNotNull( scene.Camera );

		go.Destroy();
		scene.ProcessDeletes();

		Assert.IsNull( scene.Camera );
	}
}
```

--------------------------------

### S&box Scene System Overview

Source: https://docs.facepunch.com/s/sbox-dev/doc/development-5GTpzPsBCz

Explains the scene system used in S&box for game creation, emphasizing its ease of use and power. It covers Scenes, GameObjects, and Components.

```Documentation
S&box utilizes a scene system for game creation.

Scenes: Represent the game world, containing everything that renders and updates. Scenes can be saved and loaded.

GameObject: World objects within a scene, possessing position, rotation, and scale. They can form a hierarchy.

Component: Provides modular functionality to GameObjects. Examples include ModelRender and BoxCollider.
```

--------------------------------

### S&box Custom Shading Model Example (Toon Shader)

Source: https://docs.facepunch.com/s/sbox-dev/doc/shading-model-E6j9LshRnx

An example of implementing a custom Shading Model in S&box, specifically a toon shader. It demonstrates how to segment lighting into direct/indirect and specular/diffuse components.

```HLSL
class ShadingModelToon
{
    static float4 Shade( Material m )
    {
        float4 color = 0;
        
        // Direct Lighting
        for( int i=0; i < DynamicLight::Count(); i++ )
        {
            Light l = DynamicLight::From( ScreenPosition, WorldPosition, i );
            ...
            
            float3 diffuse = /* */
            float3 specular = /* */
            
            color += diffuse + specular;
        }
        
        // Indirect Lighting
        {
            float3 diffuse = 0;
            {
                diffuse = /* ambient light */
                diffuse *= min( m.AmbientOcclusion, ScreenSpaceAmbientOcclusion::Sample( m.ScreenPosition );
            }
            
            float3 specular = 0;
            {
                specular = /* envmap */
                specular += /* toon fresnel */
            }
            
            color += diffuse + specular;
        }
        
        if( DepthNormal::WantsDepthNormal() )
            return DepthNormal::Output( m );

        if( ToolVis::WantsToolVis() )
            return ToolVis::Output( color, m );

        // Composite atmospherics after lighting
        color.xyz = Fog::Apply( m.WorldPosition, m.ScreenPosition.xy, color );
        
        return color;
    }
}
```

--------------------------------

### S&box Scene Management

Source: https://docs.facepunch.com/s/sbox-dev/doc/first-steps-7IyiSplYmn

The s&box engine is scene-based, differing from map-based engines. Scenes are JSON files that allow for fast loading and switching.

```APIDOC
Scene Management:
  Type: Scene-based (not map-based).
  Format: Scenes are JSON files.
  Performance: Fast loading and switching.
```

--------------------------------

### Read Custom Snapshot Data

Source: https://docs.facepunch.com/s/sbox-dev/doc/custom-snapshot-data-fYAi0nQOHl

Implement the ReadSnapshot method to deserialize custom data from the network snapshot. This example reads voxel data and includes an example of an asynchronous loading process.

```C#
void INetworkSnapshot.ReadSnapshot( ref ByteStream reader )
{
    var length = reader.Read<int>();
    MyVoxelData = reader.ReadArray<byte>( length ).ToArray();
}

protected override Task OnLoad()
{
    await LoadVoxelWorld( MyVoxelData );
}

private Task LoadVoxelWorld( byte[] data )
{
    // ...
}
```

--------------------------------

### S&box Clipping Check Guide

Source: https://docs.facepunch.com/s/sbox-dev/doc/layering-clothing-uDmoCIx5Lq

Provides a step-by-step guide on how to check clothing assets for clipping issues within the S&box editor by using the citizen model and testing different clothing combinations.

```English
1. In S&box, add an empty asset to the Hierarchy.
2. Add a 'Model Renderer' component to the asset.
3. Set the 'Model' input to `citizen\assets\models\citizen\Citizen.vmdl`.
4. Add clothing assets from `citizen\assets\models\citizen_clothes` to test for clipping.
5. Test Layer 1 clothing (e.g., Polo Shirt) with Layer 2 clothing (e.g., Bomber Jacket) to identify clipping issues.
```

--------------------------------

### S&box Ready-to-use Assets

Source: https://docs.facepunch.com/s/sbox-dev/doc/ready-to-use-assets-omNgqQFtXP

Documentation pages for provided assets, including first-person weapons and citizen characters.

```APIDOC
Ready-to-use Assets:
  Pages documenting some of the assets we’re providing to you.
  Documents:
    First-Person Weapons
    Citizen Characters
```

--------------------------------

### Model Asset Preview Example

Source: https://docs.facepunch.com/s/sbox-dev/doc/asset-previews-ikgF8IYAjX

Demonstrates how to create a custom asset preview for a model. It initializes a scene with a SkinnedModelRenderer, sets the model, and configures the camera to center on the model's bounds.

```C#
[AssetPreview("mymdl")]
public class PreviewMyModelResource : AssetPreview
{
	// The speed at which the model rotates. The length of a cycle in seconds is 1 / CycleSpeed
	public override float PreviewWidgetCycleSpeed => 0.2f;

	// This will evaluate a few frames and pick the one with the least alpha and most luminance for the thumbnail
	public override bool UsePixelEvaluatorForThumbs => true;

	public PreviewMyModelResource( Asset asset ) : base( asset )
	{
	}

	public override Task InitializeAsset()
	{
		// Get the resource from the asset
		var resource = Asset.LoadResource<MyModelResource>();

		// Get the Model from the resource
		var model = resource?.Model;
		if ( model is null )
		{
			return Task.CompletedTask;
		}

		// Make sure we are scoped to the preview scene
		using ( Scene.Push() )
		{
			// Create a new GameObject with a SkinnedModelRenderer component 
			PrimaryObject = new GameObject( true, "Model Preview" );
			PrimaryObject.WorldTransform = Transform.Zero;

			var modelRenderer = PrimaryObject.AddComponent<SkinnedModelRenderer>();
			modelRenderer.PlayAnimationsInEditorScene = true;
			modelRenderer.Model = model; // Set the model on the renderer

			// Center the scene around the model bounds, so the camera is positioned correctly
			SceneSize = model.Bounds.Size;
			SceneCenter = model.Bounds.Center;
		}

		return Task.CompletedTask;
	}
}
```
Tokens:
Raw