How a Rush map works

A Rush map is one BSP holding a set of small, sealed rooms. Each match plays a route of seven of them, one room per round, with three players a side.

Every room has a tower. The team that owns it when the clock runs out wins the round: 40 seconds in most rooms, 60 in a castle. A round win moves play one room towards the enemy's castle. Taking the enemy castle wins the match outright; otherwise the first team to 8 round wins takes it.

Only the room being played is used. Players spawn there, the other rooms sit empty, and nobody ever walks from one room to another.

At kick-off CT owns the start room, so T attacks first. The in-game route panel uses the same layout, with the CT castle on the left.

Rush handles the match itself: it picks the route, shows only the active tower, colours it for the owning team, and runs the HUD, sounds, timer and bots. You supply:

• the rooms, each with its own team spawns, tower, buy zones and radar volume
• a navigation mesh, so bots can play
• a list of your rooms, defined in the map's own vScript
• optionally, a screenshot of each room for the route panel

Before you start

• Name the map ru_{name}. Rush only offers maps whose names start with ru, in the gamemode's map list and in the end-of-match map vote. Keep the name lowercase: room screenshots are looked up by it.
• The Rush FGD is installed for you. lambda_rush.fgd adds the two tower entities. It is installed by the Lambda Content Authoring Tools, which copy it into Hammer++ and set it up automatically.
• Play ru_world as your reference. Its source VMF is not available, but the compiled map shows a complete set of rooms, spawns, towers and buy zones. It is older than the current release, so trust this guide where the two differ. The map is downloaded when you play Rush.
• Design for 3v3. Rush is balanced for three players a side; bots fill empty slots up to six players. Every room needs a spawn for each player.

Planning your rooms

Give every room a three-digit ID; its hundreds digit sets the room's role. A map needs at least seven rooms: 101, 301, 401 and four middle rooms. Extra rooms of any role go into that role's pool, and each match draws from the pools at random, so more rooms means more variety.

ru_world has 14 rooms: four start rooms (101–104), eight middle rooms (201–208) and one castle per team.

The team that owns the tower defends it, and the round rules shape the layout:

• A capture is instant. One press of Use on the tower switches its owner. The owner when the clock hits zero wins.
• Wiping the attackers wins the round for the defenders straight away.
• Wiping the defenders starts a deadline. If the attackers have killed at least one of them, they get 7 seconds to take the tower, or 14 in a castle. Keep every part of the room within that run of the tower, or a wipe won in a far corner cannot be converted.
• Start and middle rooms must be fair both ways. Either team can be defending, but T always uses the T spawns and CT the CT spawns. Put the two teams' spawns at an equal distance from the tower, with equally good routes to it.
• Castles can be one-sided. CT always defends 3XX and T always defends 4XX, so a castle can favour its owners. The attackers get the longer 60-second clock to break in.
• Buying happens at the spawns. Freeze time is 11 seconds, and the buy window closes 4 seconds after it ends.

Building a room

Each room needs the same five things: walls that seal it off, three spawns per team, one tower, a buy zone per team and a radar volume. Everything is found by entity name, so the names below must be exact; {ID} is the room's ID, such as 203.

Seal every room

Players must not be able to walk, fall or see from one room into another. A gap lets players leave the room, and lets bots plan routes into rooms nobody is playing. Rooms that can see each other also cost rendering for nothing, since only one is ever in use.

Team spawns

• Place at least as many spawns per team as players per team: three for 3v3. With fewer, extra players spawn on top of each other.
• Keep each spawn's 32 × 32 × 64 unit box clear of walls and of the other spawns. A spawn with a live player in that box is skipped.
• Give every spawn a unique name. Spawns with other names are ignored by Rush, so leftover spawns elsewhere in the map do no harm.

The tower

Place exactly one tower per room, named ant.base.{ID}. There are two models:

• cs_rush_antenna_short for enclosed rooms with low ceilings
• cs_rush_antenna_tall for open spaces

Put its origin on the floor. Players capture it by looking at it and pressing Use from within 80 units, with nothing solid between their eyes and the tower, so keep props, glass and clip brushes out of the way. The tower is solid while its room is active. It is hidden and non-solid in every other room, and it cannot be damaged. Rush colours it for the owning team and adds its glow, plus a team-coloured halo during freeze time.

Buy zones

Add one func_buyzone per team per room, covering that team's spawns, with TeamNum set to Terrorist or Counter-Terrorist. Players can only buy inside a buy zone.

Radar volume

Radars are required for Rush. Wrap each room in a lambda_minimap_volume brush entity, and set its Minimap Name field to the room's ID, for example 101.

Generate the radars with Cartographer, in the Lambda Content Authoring Tools. It takes your VMF file and supports lambda_minimap_volume: it generates a separate radar for each room, plus one radar that contains all of them.

Everything else

The whole map resets at the start of every round, so doors, breakables and map-placed weapons come back each time. Map-placed weapons are allowed. Bots open prop_door_rotating doors by themselves, so prefer those on the routes bots take.

Navigation mesh for bots

Bots fill empty slots in most matches, and without a navigation mesh they cannot move. Ship maps/ru_{name}.nav with the BSP.

The recommended way to generate it is the out-of-game navigation mesh generator in the Lambda Content Authoring Tools, which produces better results than the in-game commands. Open the Hammer app in the Content Authoring Tools and go to the Map Tools tab.

To edit the mesh afterwards, use Place Forge in the Content Authoring Tools, which lets you edit navigation meshes in a modern editor.

You can still generate it in game with native Source tooling: use sv_cheats 1 and nav_generate. If a room is missed, stand in it, run nav_mark_walkable, then nav_generate_incremental. Check the result with nav_edit 1 before you save.

Rush relies on the mesh in four places:

• Each room is its own nav island. Rush treats a room as every nav area reachable from its spawns, on foot or by ladder. If one room's mesh connects to another's, bots can wander into the other room during warmup and between rounds. Remove stray connections with nav_disconnect.
• Spawns sit on the mesh. Every spawn needs a nav area within 256 units, or the room's island cannot be found from it.
• The tower sits on the mesh. Attacking bots head for the nav area nearest the tower, and Rush looks no further than 256 units for it.
• Defenders need cover around the tower. Defending bots spread out to hiding spots between 192 and 1,024 units from the tower, at roughly the tower's height (within 128 units). Without hiding spots they stand in the open at area centres, so give that ring real cover.

Ladders count: nav ladders join the floors they connect into the same room. Regenerate the mesh after any change to the room layout.

Defining your rooms

Rush only plays the rooms you define. Define them in Lambda vScript, which ships inside the BSP and is initialised by a lambda_point_script entity in the map.

Write a JavaScript file that calls Rush.DefineRoom once per room, at the top level of the script rather than inside a callback, so the rooms exist before the match starts:

import { Instance, Rush } from "lambda_script/point_script";

if (Instance.IsAvailable("Rush")) {
    Rush.DefineRoom(101, { name: "Rail Yard" });

    Rush.DefineRoom(201, { name: "Loading Dock" });
    Rush.DefineRoom(202, { name: "Signal Box" });
    Rush.DefineRoom(203, { name: "Water Tower" });
    Rush.DefineRoom(204, { name: "Freight Office" });

    Rush.DefineRoom(301, { name: "Depot", label: "CT Castle - Depot" });
    Rush.DefineRoom(401, { name: "Bridge", label: "T Castle - Bridge" });
}

The IsAvailable check keeps the script harmless if the map is loaded in another gamemode. Pack the file into the BSP under scripts/vscripts/, for example scripts/vscripts/rush/ru_example.js, without compression: the script loader cannot read compressed or encrypted files. Then add a lambda_point_script entity with its scriptfile keyvalue set to the path after scripts/vscripts/, here rush/ru_example.js.

• name is the room's location name, used for player location labels and in radio messages.
• label is the caption under the room's card in the route panel shown during freeze time. It defaults to the name; ru_world prefixes castle labels with "CT Castle -" or "T Castle -".

Rooms can change while the map loads and during warmup; after that they are fixed for the match. DefineRoom returns false when it refuses a room: an ID outside 100–499, an empty name or label, or a change after warmup. The script runs again every round, so repeating the same definitions is harmless.

Every room you define must exist in the map with its spawns and tower; one missing room stops the whole map from starting. Rooms built in the map but left undefined are ignored, which keeps an unfinished room out of rotation until it is ready.

Room screenshots

During freeze time, Rush shows the match route as a row of cards, one per room. A card shows your screenshot of the room, or a tower icon and the room ID when there is none. The room's label is printed under every card.

• File: materials/lambda/rush/rooms/{map name}/{room ID}.jpg, shipped with the map, for example materials/lambda/rush/rooms/ru_example/203.jpg. Use the lowercase map name and one file per room ID in your room definitions.
• Size: a 1920 × 1080 JPG. The card is filled without stretching, and whatever does not fit is cropped evenly from the edges.
• Framing: most cards are taller than they are wide, so they show only a vertical slice from the middle of the image. Put the room's most recognisable feature, often the tower, in the middle third of the shot.

You can embed these screenshots in your BSP using Assembly

Testing

For now, the Lambda Team reviews and tests every submission and sends you feedback. You cannot test your own map in Rush yet, so check your map against this guide and the submission checklist before you send it.

Current limitations

A few CS2 Rush features are not in this version yet. Design around them for now:

• Fog and sky are shared. CS2 Rush changes the fog for each room; this version does not. Every room is seen through the map's main env_fog_controller and the same skybox, so pick settings that suit all of your rooms.
• No tiebreaker room. CS2 Rush switches to a special room when the score reaches 7–7. Here the match carries on along the normal route, and there is no room role for a tiebreaker.
• The tower is not on the radar. Players find it by sight, so make the tower easy to spot from both teams' spawns.
• The route is always seven rooms. Extra rooms add variety between matches, not length.

Submission checklist

Send the BSP, its .nav file, its radars and any screenshots to the Lambda Workshop once every box is ticked:

• The map is named ru_{name}, in lowercase.
• Your vScript is packed uncompressed in the BSP and loaded by a lambda_point_script entity, and its room definitions list 101, 301, 401 and at least four 2XX rooms, and nothing that isn't built.
• Every listed room has three CT spawns, three T spawns, one tower named ant.base.{ID} and a buy zone per team.
• No room can walk into or see into another.
• maps/ru_{name}.nav is saved, with each room its own nav island.
• Screenshots, if any, are at materials/lambda/rush/rooms/ru_{name}/{ID}.jpg.
• Every room is wrapped in a lambda_minimap_volume named with its room ID, and the radars have been generated with Cartographer.