165 results · flexsearch
A component with [Sync] fields added in OnStart (after NetworkSpawn) never replicates — each peer creates its own local instance and the sync pair silently never matches.
@ref on a private field compiles with only a CS0649 warning — the ref stays null at runtime. Bind to a property instead.
Two-stage flow: Blender headless emits Y-up OBJ, then pure Python writes vmats/vmdls and a C# model catalog.
Census tris × instances before decimating; prefer BoxCollider over ModelCollider for decorative props.
Org/ident rules, every store-page field is launch-blocking, AI thumbnails demoted — verify as a player after publish.
Absolute-altitude biome thresholds tuned at one reference amplitude break when the slider moves -- the climate stack squashes or vanishes. Scale every altitude threshold by realized relief.
Trailing children of a tall absolutely-positioned flex column silently vanish — no overflow, no compression — because Yoga's auto-height under-measures the content. Fix: give the column an explicit height.
Disjoint file ownership, serialize hot files, report-don't-fix foreign errors, resume after interrupts — the concurrency rules that keep agent waves shippable.
Angles uses .pitch/.yaw/.roll (lowercase) and Vector3 uses .x/.y/.z — capitalized sightings in a codebase belong to unrelated component properties.
System.Array.Clone() compiles clean in dotnet build but fails SB1000 in the editor — the headless build does not enforce the whitelist.
global using Sandbox + your razor namespace in Assembly.cs — without it, panels and game types don't resolve across the assembly.
MP3 + JSON .sound beside it — no wav/ffmpeg; Distance is in inches; copy schema from addons/menu box_open.sound.
A Blender --background --python pipeline hangs at init forever. --factory-startup -noaudio bypasses the corrupted user prefs and runs instantly.
Blender 5.2 removed Scene.node_tree and CompositorNodeComposite — scripts using the old 4.x/5.0 compositor API silently produce wrong renders with no exception.
bpy.ops.wm.obj_export can reorder face lines across runs on the same mesh — diff the manifest, not the raw OBJ bytes.
Headless Blender wm.obj_import with up_axis=Y stores the Y→Z rotation in the object matrix, not the vertex coords — per-vertex scripts reading raw .co get the wrong axis.
border-style: solid is a parse error in s&box scss. The invalid property aborts the whole stylesheet, collapsing the panel to zero size -- invisible, not just unbordered.
No native drag helper exists for PanelComponent sliders — use the engine's SliderControl pattern: MousePanelEvent.LocalPosition over track width, with pointer-events routing.
One ScreenPanel host, static UIState for modals, self-closing panels, toast stack — BuildHash every flag the markup reads.
Deriving a visual's facing from horizontal velocity causes 180-degree snaps on any momentum reversal — lock facing to an attach-time azimuth for pendulums and oscillators.
A chase camera that reads a raw fixed-tick position field per render frame makes the player model sawtooth side-to-side — read WorldPosition (context-sensitive interpolated getter) instead.
For a chunked runtime-mesh generator, REGEN (single-threaded generation CPU) is the binding resource — not fps or draw calls. Quartering the chunk count produces zero regen change; the lever is threading the passes.
The stock citizen animgraph ships combat params that CitizenAnimationHelper does NOT wrap -- drive them with renderer.Set() directly, and replicate them yourself because the engine only networks locomotion.
HoldType shapes arm+fingers, aim only tilts via aim_body_pitch/yaw, and an IK hand target OWNS hand position — overriding the holdtype arm pose. Move the IK target to place a held item, use holdtype only for the fist.
Published game boots with error.vmdl placeholders; engine may rewrite prefab refs — no auto-retry; restart editor + republish.
BoxCollider is cheap and follows WorldScale; Capsule/ModelCollider don't scale with WorldScale and ModelCollider is costly on clutter.
Components.Get<SkinnedModelRenderer>() only searches the same GameObject — a renderer on a child returns null, silently no-oping every Set() call.
Networking.CreateLobby is async — Networking.IsActive is still false on the same frame, so any branch on IsActive takes the wrong path. Gate on your own synchronous mode enum instead.
Adding a public method to the game assembly and calling it from the editor-tools assembly in the same hot-reload pass throws MissingMethodException at runtime — both compile_status and dotnet build are green.
Set Sequence.Blending = true once — per-clip fade_in/fade_out times in the vmdl shape the blend; no AnimGraph required.
A custom GameResource with a file extension longer than 8 characters silently never registers as a compilable source type — every asset fails with "no source file." Keep extensions to 8 lowercase chars or fewer.
Census tris × instances first — silhouette fails before UVs; inject usemtl after scripted OBJ export.
A freshly SteamCMD-installed sbox-server.exe is not self-contained -- it needs the matching .NET runtime on the box, or it dies before any game logic.
A headless sbox-server running an unpublished local .sbproj boots and creates a lobby, but every joiner fails with 'Package local.<ident> wasn't found!' — publish the package first (Hidden visibility is sufficient).
A stationary vertical sink at a chunk-corner seam defeats eject, mantle, and even hard-recover (the anchor itself can be buried under an overhang) — the terminal escape is a top-out to the chunk surface.
Dev-host streaming sends assemblies and compiled assets but NOT loose data files read via FileSystem.Mounted — a joining client that loads a raw JSON manifest builds differently, silently.
ModelRenderer.CastShadows doesn't exist as a settable property — use renderer.SceneObject.Flags.CastShadows instead.
Headless dotnet build is green while the in-editor compiler emits SB1000 — Environment/IO/Process/reflection are banned in game code.
Jump() helpers clamp against rising velocity, eating the second impulse. Set Velocity.z directly for a reliable double jump.
GameObject.Destroy() in edit mode is deferred; a query fired right after returns the previous build's objects.
Razor HUD emoji and dashes die under Get-Content/Set-Content — edit with byte-safe UTF-8 APIs or a real editor.
Two screenshots of byte-identical geometry differ by tens of percent because editor auto-exposure adapts over wall-clock frames — settle the viewport and exposure-normalize before comparing.
Editor-embedded play mode pins at exactly 60 fps regardless of cvars. The cap is the compositor's vsync on the editor window, not the engine frame sync.
compile_status is fully green and the editor accepts edits, but Play executes the OLD code — touch, syntax-error cycling, and play restart all fail. Only a full editor process restart clears it.
Frame fps pins at 60 in the editor regardless of physics load — implement IScenePhysicsEvents.PrePhysicsStep/PostPhysicsStep with a Stopwatch to get the true, vsync-free CPU cost of the solver step.
The engine ships its built-in [McpTool]s as full C# source, not compiled DLLs — check addons/tools/Code/Mcp/*.cs for canonical patterns before inventing your own.
Failed package compile leaves the editor running the last-good hotload — multi-symptom 'regressions' are often stale code.
A front-flip rotation uses _baseRot.Forward (not .Right) when FacingYawOffset is ±90° — the offset swaps which local axis is perpendicular to travel.
An unqualified FileSystem compiles in a game assembly but CS0104s in an editor assembly — fully-qualify Sandbox.FileSystem in editor code.
Folders → sbproj → Assembly.cs → 4-object scene → green dotnet build → tagged logs on Play — then optional art tools.
RenderType.Off only kills the shadow, not the draw — use Tags.Set("viewer", true) on the visual root plus camera RenderExcludeTags for correct first-person body hiding.
ERROR models or white materials persist after fixing the source — delete the compiled artifact AND touch the source file to force recompilation.
A flex-grow slider track holding a normal-flow fill child sized by width:N% balloons wider as the value increases — take the fill out of flow with position:absolute.
Foot-slide happens when PlaybackRate is tied to movement top speed instead of the clip's own authored stride distance.
Forge delivery job errors out but the build stage's previewGlbUrl stays downloadable — recover the GLB through Blender into your standard delivery shape instead of re-spending.
Sandbox.Diagnostics.FrameStats and PerformanceStats are whitelist-clean and reachable from game-assembly components — build a relative perf probe without any engine benchmark API.
A [Sync(SyncFlags.FromHost)] field on a runtime-created singleton never replicates — the object needs NetworkSpawn, not just NetworkMode.Snapshot.
A runtime-generated world root torn down with GameObject.Destroy() keeps rendering in edit mode because the deferred queue isn't flushed — use DestroyImmediate and sweep all matching roots.
Gamepad triggers DO have a public smooth 0..1 analog read via Input.GetAnalog(InputAnalog.LeftTrigger/RightTrigger). Named Input.config actions bound to triggers remain digital-only (on/off) — use the direct analog surface for proportional control.
.sbproj + Assets/Code/ProjectSettings/tools layout, 4-object scene + Bootstrap, dotnet build before anything else.
A git worktree at a different directory depth than the main checkout breaks the generated csproj's relative references to the sbox install — dotnet build fails with missing-assembly errors.
The s&box glyph-corruption bug is also triggered by cumulative mono text-run count, not only font-size declarations — and it corrupts positionally (last-rendered text first).
Per-cell dither or contour-wander in a greedy voxel mesher turns cliff skirts into vertical stripes — detect walls and key strata on raw height bands with dither neutralised.
compile_status shows Success and dotnet build is green, but play mode reports errors for symbols and lines that no longer exist in source — the play-mode hotloader compiled a stale mid-edit snapshot.
An idempotent ground-snap jitters on curved terrain because the slope curves away within each step — ease the downward snap at a bounded glue rate.
A grounded wish-speed servo (MoveTowards) silently clamps any externally applied velocity (mantle carry, knockback, launch) to the wish target within a few ticks of ground contact -- boundary measurements read green while the effect is imperceptible.
A per-frame visual-smoothing offset computed from raw fixed-tick state double-smooths against the engine's built-in FixedUpdateInterpolation, producing a 50 Hz sawtooth that reads as model flicker on stepped terrain — delete the manual smoother or compute against interpolated state.
dotnet build reports 0 errors on .razor files the in-editor compiler rejects — the headless build doesn't surface the Razor errors the live editor's Roslyn compiler flags.
GameTask.RunInThreadAsync for parse/math; main thread only for engine objects; Yield every N items for loading UI.
A near-white chalky sky stays mid-grey or blue — fixing the sky texture alone isn't enough because the default tonemapping curve crushes highlights.
Top model plans and reviews; cheaper agents execute on disjoint files; telemetry-driven feel tuning — whitelist and stale-assembly traps included.
Deferred Destroy() leaves the old code-built world overlapping the fresh one for a frame — use DestroyImmediate for teardown before rebuild, and pair it with a recipe hash for belt-and-suspenders join verification.
CC0 kits import like any OBJ+vmdl; city kits share colormap.png, nature kits need per-color vmats, and facing is a per-model yaw guess.
An Input.config action bound to an editor/host-reserved key (F1-F3, F7, F8, Escape) silently never fires in Play. The capture map also differs between editor and published client -- bind game hotkeys to plain letters and verify in both.
WASD as Forward/Backward/Left/Right feeds AnalogMove; new Input.config actions need an editor restart — dotnet build is not enough.
Input.Pressed (edge-trigger) is frame-scoped -- reading it in OnFixedUpdate drops presses on frames with no tick, or fires them twice on frames with multiple ticks. Level reads (Input.Down) are fine in OnFixedUpdate. A systematic 100% input failure usually points elsewhere -- instrument each hop.
Whitelist divergence, loose Resource Files, and silent cloud-asset failures after publish.
A static Instance claimed behind if (!IsProxy) in OnStart grabs the host's character on a joining client — the client camera follows the wrong player forever.
A joining client's static join state (invite code, mode, attempt ID) gets wiped by the networked scene handoff — the bootstrap's OnEnabled resets statics before the join handshake uses them.
Standalone export hangs if PackageReferences still need sbox.game to resolve — don't accumulate cloud package deps casually.
Converting euler poses per-key can land on q vs -q — the interpolation takes a violent 360-degree detour. Negate the quat if dot(prev, new) < 0.
Always handle tr.StartedSolid — ignore that frame so an overlapped body can walk free; slide-trace the wish onto the hit plane.
sbox.exe -joinlocal +instanceid 1 gives you a real second peer against an editor host with no publish, no second Steam account, and no lobby discovery.
PNG/WAV/MP3/JSON must be listed in Project Settings → Resource Files without an assets/ prefix — #1 editor-vs-publish break.
Lowering the sea level in a priority-flood water pass doesn't drain interior lakes — they're perched at their own spill surface. Use a per-basin depth gate and a land floor for below-sea valleys instead.
Scene holds four GameObjects; Bootstrap OnStart builds the world in code — hotloads better, no scene/code drift.
Model.Load of a missing vmdl can return the orange ERROR mesh with the requested path as its Name — check IsError, not just null.
Per-instance Tint on a flat-color vmat (white PNG + g_vColorTint) rotates hue or crushes random instances to black — use scale/yaw jitter instead.
Input.AnalogLook returns zero (camera never turns) unless the cursor is locked via Mouse.Visibility = MouseVisibility.Hidden -- the deprecated Mouse.Visible = false does NOT lock it.
Play full path WITH .sound or bare filename only — partial paths like impact/boing never resolve; compiled assets can still be invisible mid-session.
OfType<IInteractable> on GetAllComponents<Component> returns nothing — enumerate concrete types and union them.
RenderMeshFile alone compiles clean with zero physics — ModelCollider needs PhysicsMeshFile/PhysicsHullFile in the vmdl.
Blender +X becomes world −Y after OBJ import; yaw +90° faces +X — and Blender +Y rotation tips the +X edge down.
BuildHash() is the only re-render trigger — hash everything the markup reads, including collection contents and flags.
CapsuleCollider and ModelCollider ignore WorldScale; BoxCollider follows it — bake scale into import_scale instead.
Component.Active is a real inherited member — naming your own bool Active silently shadows the engine's enabled flag.
A newly created .razor.scss file is not picked up by a running editor session — the panel component works but is unstyled until the next restart.
Disabling a collider does nothing for a hand-integrated kinematic controller — noclip must be a movement state that skips traces, gravity, and ground-snap entirely.
A trace-swept NPC with 'wall ahead, hold position this frame' freezes permanently when the desired direction is constant -- the identical trace hits the identical wall every frame.
A cached Component/GameObject reference guarded with == null still throws NullReferenceException after the object is destroyed — only IsValid() catches destroyed objects.
A singleton claimed in OnEnabled and nulled in OnDisabled traps any re-adopt poll that gates on Instance.IsValid() — the entity is never re-driven after a disable.
Rotation.FromYaw alone leaves a decal flat on the floor — build a rotation that aligns the thin axis to the surface normal, then offset along it.
An overhead name tag or health bar anchored to a per-player gameplay field freezes over a remote player's spawn position while their model walks away — anchor off the networked transform instead.
[Sync] owner→proxies, IsProxy early-out; FromHost for shared truth — don't NetworkSpawn scene-wide singletons.
OnAfterTreeRender(bool) is a Panel hook — on a PanelComponent it fails with CS0115; use parameterless OnTreeBuilt() or OnTreeFirstBuilt().
A per-cell white-noise hash for terrain shade choice reads as a 50/50 checkerboard — use a smooth low-frequency noise field instead, confining the hash to threshold-edge dithering.
Ident is org.package — two lowercase segments; keep Org local until real; never put TODO placeholders in Org or the editor won't boot.
A published-build client join reloads the game assembly, wiping all statics — the reconstruct-not-reset fix from the scene-handoff case has nothing to reconstruct from unless join intent is persisted to disk.
The Sandbox.Voice component defaults PushToTalkInput to 'voice', but not every project ships a matching 'Voice' InputAction — PTT is a dead key with zero errors until you add it to Input.config.
PhysicsShapeList + PhysicsJointList in the vmdl + ModelPhysics toggle — no collapse clips, no SetBoneTransform.
A loading screen mounted right before a synchronous multi-second call never paints — one consumed tick isn't enough; gate the block on a frame counter (~6 frames) so the Razor pipeline finishes mount → style → layout → paint.
Thin flex rows with a gap inside a Razor RenderFragment expression under-measure their height and pile on top of each other. The same markup renders fine in the component's main root.
GetVertices/GetIndices flatten a multi-material compiled model into one buffer — rebuilding with Materials[0] paints everything that first material (often black). Split indices by per-submesh counts and build one Mesh per range.
Transfer rest-delta rotations parent-relative (not world) — avoid the forward-hunch bug and never transform_apply scale on Mixamo armatures.
Bone-heat auto-weights fail on AI meshes — use scripted geodesic (along-surface) weights, then FBX + animated vmdl.
Rigidbody API verified across multiple projects — Gravity, MassOverride, Velocity, ApplyForce, and the recipe for a dynamic pushable prop.
s&box ships Roboto Mono (all weights) — JetBrains Mono and Consolas only resolve on dev machines with those system fonts.
Rotation.FromYaw(+angle) is a LEFT (CCW) turn — get the sign right or steering, AI, and autopilot spiral the wrong way.
An [Rpc.Broadcast] called on a component whose GameObject is not networked executes locally and silently never crosses the wire -- no warning at any log level.
SCSS background-image only resolves asset paths — runtime Texture objects must be assigned via Panel.Style.BackgroundImage in OnTreeBuilt.
FlatBox/Prop/Deco/Wire helpers plus Obstacle records as plain data beat physics queries for build validity.
Nesting @{ } inside an already-open Razor code block (like @if or @for) causes RZ1010 — you're already in C#, so drop the @.
OnAwake runs synchronously inside Components.Create — set singletons there; derive from [Property] in OnStart after spawn helpers assign.
Assets / Code / Editor / ProjectSettings / tools — the template every project follows.
App 1892930 via SteamCMD runs a headless server with +game pointing at a local .sbproj — clients stream code/assets, no sbox.game publish required.
1 m = 39.37 engine units — design in SI, convert once at the engine boundary, and audit every consumer.
Scenes never load raw OBJ/GLB — always wrap with a .vmdl and remap materials under both bare and .vmat names.
DTOs + one spawn path + deterministic static world — guard restored defaults; keep enums append-only.
A freshly-scaffolded project's Assembly.cs can be missing global using System — transplanted code using Math/MathF fails with CS0103.
A component with Enabled = false is invisible to GetAllComponents — search returns null even though the component exists.
When a clip already poses hands in a grip and the prop moves/rescales, offset the rendered visual child instead of using IK or SetBoneTransform -- sequence-only rigs have no AnimGraph.
A trace-based ground controller flickers Ground/Air on seams, re-firing landing VFX mid-run — require minimum air time before a JustLanded counts.
The engine SliderControl renders its thumb position as a raw float in a CSS style attribute — near-min values with snap residue produce scientific notation (4.9E-06%), causing a style parse error.
When a continuous-float render surface sits over a quantized-step collision mesh, every quantize boundary becomes an invisible vertical wall the player hits but cannot see.
Sound playback is a static call, not a component. Use Sound.Play() for 2D and Sound.Play(pos) for 3D, and handle missing events gracefully.
On the host, spawning a joiner's character clobbers the host's own camera-target singleton because IsProxy is false at Components.Create time — re-resolve the claim at the first OnFixedUpdate.
If sbox-launcher.exe stays open during a Steam update, files vanish mid-install — validate via steam://validate/590830.
Preview as of 2026-07: Valve approval + Facepunch license; full .NET, lose platform services; clean PackageReferences or startup hangs.
A C# static list/registry survives editor Play stop/start and code hotloads, holding references to destroyed GameObjects — gate iteration on IsValid(), don't rely on clearing alone.
s&box carries old static state forward on hotload and never re-runs static constructors — a registry entry added in source is absent at runtime despite green compile.
A structural .razor change can throw a hotload exception that deregisters the project's entire toolset while compile_status still reports Success — restart the editor to recover.
Use TextEntry with onsubmit and OnTextEdited — standard Blazor input bindings compile but are not how the engine UI works.
An untyped or expression-bodied lambda on TextEntry.OnTextEdited fails with CS8917 or CS0029 — use an explicit param type plus a block body.
Model compiler rewrites upper_arm.L → upper_arm_L; physics KV3 that still says .L makes limb bodies unknown while the torso works.
Default −Z/Y axes, bake_space_transform, no leaf bones, X/Z bone axes, mesh FBX + per-clip armature FBX; scale via ScaleAndMirror 0.3937.
Razor classes get a RootNamespace/folder-derived namespace — declare @namespace and global using or C# can't find your panels.
static Instance set in OnAwake, cleared in OnDestroy — everything reads Foo.Instance with null-guards, no inspector wiring.
SoundEvent has no Looping property — loop via compiled vsnd import options, or re-trigger from code when SoundHandle finishes.
s&box Razor panels have three distinct 'text is there but not on screen' failure modes — long-line clipping, narrow-segment overflow, and inline expression resolution — each with a different structural fix.
StartupScene is what Play loads; Org must be a valid lowercase ident — placeholders break editor bootstrap, not just publishing.
Text renders as solid filled rectangles when a panel crosses a glyph-rendering budget — too many font-size/letter-spacing declarations corrupt the whole panel; too many text runs corrupt the last-rendered run. Carry hierarchy via font-weight/color and treat text-run count as a budget.
A hand-integrated trace mover has no collider component — ITriggerListener and OnTriggerEnter never fire. Use distance-polling instead.
Even-time samples of a ballistic arc cluster at the slow apex and spread at the fast ends — sample by arc length for evenly spaced preview dots.
No paid storefront — revenue is clamped player-hours from a daily pool; retention is the monetization feature.
Shader field support is unknown and no .shader source exists — check the install's templates/ folder for authoritative syntax instead of grepping sibling projects.
AI mesh generators (Tripo, Meshy, Rodin) deliver textured OBJ+vmdl — but modeldoc32 headers, ~1m normalize, corrupt textures, bare texture paths, and missing colliders will ERROR the asset until patched.
Source engine convention: Forward = +X, Left = +Y, Right = -Y. Using Vector3.Right for '+X' silently slides geometry the wrong way.
With a visible cursor (MouseVisibility.Visible), mouse buttons that land on a pointer-events panel never reach Input.Down/Pressed — and Input.Keyboard.Down("mouse2") is not a bypass.
C# hotloads on alt-tab in ms; scene changes and new Input.config actions need Play/editor restart; failed compile keeps the last-good assembly.
Literal spaces adjacent to a tag or @-expression boundary vanish in Razor markup — use a single interpolated string or CSS margin instead.
SetIk is AnimGraph-gated; SetBoneTransform is unsound on clip-keyed bones — use proxy props, whole-visual motion, or commit to AnimGraph.
A long-running process started over a Windows OpenSSH session is killed the moment the session closes -- use a Scheduled Task instead.
Get-Content/Set-Content re-encodes BOM-less UTF-8 as ANSI; CRLF files break \n-only search-replace — use byte-safe APIs.
Stats.Increment/SetValue, Leaderboards.GetFromStat, Achievements.Unlock — cheap platform polish; total achievement score capped at 1000.
A zero-radius Scene.Trace.Ray passes straight through coarse voxel ModelColliders and returns Hit=false. Sweep a thin sphere (.Radius(...)) and it hits.