Skip to main content

Stage 9: Kinetic KillWall + VR ledge grab

Course progressStage 9 of 10
~45 min
Before you start

Make sure you've finished Stage 8: Spinning KillBricks + grab & ride. The VR ledge grab needs your Stage 1 climb code — the part of VRController that lifts you when you grip near a Climbable part.

Build

a corridor with a sliding deadly wall and climbable ledges

Learn

how to make a part glide smoothly with TweenService — and how much you can reuse

Ship

a hall you beat by timing the wall, or in VR by climbing the ledges over it

The big idea​

The last obstacle is a kinetic kill wall — a deadly wall that slides back and forth across a corridor on its own, never stopping. Touch it and you respawn. Time the gap and you slip past.

You'll move it with a tool built exactly for smooth motion: TweenService. Instead of nudging the wall every frame yourself (like the spinner), you describe the motion once — "slide to here, over 2 seconds, ease in and out, repeat forever, reverse each time" — and Roblox animates it for you. It's the clean, professional way to make things glide.

Then the part that should make you proud: the VR ledge grab needs no new code at all. Back in Stage 1 you wrote a climb that lifts you whenever you grip near a Climbable part. So to add ledges you climb over the wall, you just build them and tick Climbable — your Stage 1 code already does the rest. Nine stages in, your VRController is a real toolbox, and this is the proof: a brand-new way to play, zero new lines.

New words
TweenService
a service that smoothly animates a property (like Position) from one value to another
TweenInfo
the recipe for a tween: how long, what easing, how many times, and whether it reverses
EasingStyle
the shape of the motion — Sine eases gently in and out instead of moving at a constant clip
reuse (Climbable)
tagging ledges Climbable so your Stage 1 climb handles them with no new code
kinetic
moving; a kinetic wall is one that travels on its own instead of staying put

Build it​

Step 1 — Build the corridor​

Build this part

HallFloor

Block
Open recipe
Size
16 × 1 × 40
Color
Medium stone grey
Material
Slate
Anchored
✓ Yes
Place
Just past the Stage 9 pad — a long, narrow walkway
Build this part

HallWall_Left

Block
Open recipe
Size
1 × 12 × 40
Color
Dark stone grey
Material
Brick
Anchored
✓ Yes
Place
Along the left edge of HallFloor, running its full length
Build this part

HallWall_Right

Block
Open recipe
Size
1 × 12 × 40
Color
Dark stone grey
Material
Brick
Anchored
✓ Yes
Place
Along the right edge of HallFloor, mirroring the left

Step 2 — Build and animate the sliding wall​

Build this part

SlidingWall

Block
Open recipe
Size
10 × 12 × 2
Color
Really red
Material
Neon
Anchored
✓ Yes
Place
Across the hall partway down, blocking most of the width but leaving a gap on one side

Add a Killer attribute (boolean, true) — your Stage 4 scan makes it deadly. It will slide side to side in Step 2.1.

2.1 Script the slide with TweenService​

Insert a server Script into SlidingWall and type:

local wall = script.Parent
local TweenService = game:GetService("TweenService")

local START = wall.Position
local ACROSS = wall.Position + Vector3.new(10, 0, 0)   -- slide 10 studs sideways

-- 2 seconds, gentle ease, repeat forever (-1), reverse each time (true).
local info = TweenInfo.new(2, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, -1, true)

local slide = TweenService:Create(wall, info, { Position = ACROSS })
slide:Play()

Press ▶ Play. The red wall glides smoothly side to side, opening and closing the gap. Touch it and you respawn. Walk through the gap when it's open. Tune the slide distance and the 2 (seconds) so there's a fair window. Fully testable today.

Step 3 — Add climbable ledges (no new VR code!)​

Here's the reuse payoff. Build two ledges sticking out from the HallWalls, above the sliding wall's reach. Tag them Climbable, and your Stage 1 climb code lets a VR player grab and pull up over the wall — you write nothing new.

Build this part

Ledge_1

Block
Open recipe
Size
4 × 1 × 6
Color
Sand
Material
Slate
Anchored
✓ Yes
Place
Sticking out from HallWall_Left, above and before the SlidingWall

Add a Climbable attribute (boolean, true) — exactly like the Stage 1 climb blocks.

Build this part

Ledge_2

Block
Open recipe
Size
4 × 1 × 6
Color
Sand
Material
Slate
Anchored
✓ Yes
Place
Sticking out from HallWall_Right, above and past the SlidingWall — the dismount

That's it. Your VRController already scans for Climbable parts and lifts you when you grip near one. In VR, a player grabs Ledge_1, climbs up over the kill wall, and drops onto the far side past Ledge_2. On a laptop, you time the gap instead. Both routes work; VR just earned a clever shortcut.

In VR

Rather than dance with the sliding wall, reach up and grip Ledge_1. The same pull-down-to-climb you learned on the very first wall lifts you onto the ledge — above the deadly wall entirely. Traverse the ledges and drop down past the danger. The skill you built in Stage 1 just became your escape route in Stage 9.

Script anatomy

How TweenService animates the wall (and why ledges needed no code)

The wall's motion is a recipe you hand to Roblox. The ledges, meanwhile, prove the course's whole idea: a feature you 'add' by reusing code you already wrote.

local wall = script.Parent
local TweenService = game:GetService("TweenService")

local START = wall.Position
local ACROSS = wall.Position + Vector3.new(10, 0, 0)

local info = TweenInfo.new(2, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, -1, true)

local slide = TweenService:Create(wall, info, { Position = ACROSS })
slide:Play()
  1. Lines 4–5Where it slides from and to.

    START is where you placed the wall; ACROSS is 10 studs sideways. The tween moves the Position between these two points.

  2. Line 7The motion recipe.

    TweenInfo.new(time, style, direction, repeatCount, reverses): 2 seconds long, Sine easing (gentle slow-down at each end), InOut, -1 means repeat forever, and true means reverse each loop so it returns. One line describes the entire endless slide.

  3. Lines 9–10Create and play.

    TweenService:Create binds the recipe to the wall and the target Position. :Play() starts it. Roblox handles every in-between frame — far less code than nudging it yourself, and smoother too.

  4. Line (ledges)The ledges have no script — on purpose.

    Your Stage 1 climb already finds Climbable parts and lifts you near them. Tagging Ledge_1 and Ledge_2 Climbable is the entire 'VR ledge grab.' Nine stages of building a toolbox pays off here: new gameplay, zero new code.

Understand it​

TweenService is the describe-it-once lesson. The spinner in Stage 8 moved by you nudging it every frame — fine for endless spin, but fiddly for a there-and-back glide. A tween flips the work: you state the destination, the duration, the easing, and the repeat behavior in a single TweenInfo, and Roblox computes every frame between. EasingStyle.Sine with InOut is why the wall slows gracefully at each end instead of snapping direction — the same kind of smoothing as your Stage 5 fade, but built into the engine. Reach for a tween whenever something moves from here to there; reach for a Heartbeat loop when it moves continuously.

The ledge grab is the reuse lesson at its peak. You added a whole new way to beat the hardest obstacle and wrote not one line of VR code, because Stage 1's climb was written to handle any Climbable part. That's not luck — it's what good code does. Every stage you tagged parts and scanned for tags (Climbable, Killer, Hidden, Boulder) so that future content could plug in for free. Stage 9 is where that discipline hands you a gift: the kill wall has a clever VR bypass, and building it was just two parts and two checkboxes.

Try this​

Learning beat

Try this

Three short experiments. Predict before you run, then test your guess.

Predict first

The TweenInfo time is 2 seconds. Predict how the hall plays at 0.7 (fast wall) versus 4 (slow wall). One makes timing the gap frantic; one makes it a stroll. Find the value that's tense but fair — then notice the VR ledge route cares less about wall speed. Why?

Compare

Change EasingStyle.Sine to EasingStyle.Linear. Watch the wall move at a constant speed with hard direction changes. Which feels more like a real machine — Sine or Linear — and where in a game might the robotic feel of Linear actually be the better choice?

Connect

You reused the Stage 1 climb just by tagging Climbable. Think back over the whole course: Killer, Hidden, Boulder, Climbable. What's the single habit that made all this reuse possible? (You'll lean on it one more time in Stage 10's puzzle.)

Test your stage​

  • Press ▶ Play — the red wall glides smoothly side to side, opening and closing the gap.
  • Touch the wall and confirm you respawn (Killer scan — no new code).
  • Time the gap and walk through to the far side of the hall.
  • Confirm Ledge_1 and Ledge_2 both have the Climbable attribute (the VR route).
  • Touch the Stage 10 pad, reset, and confirm you respawn there.
  • Output is empty on a clean Play — no errors from the slide script or VRController.
  • Design check. Is the open-gap window readable — can a player see when it's safe to go? And are the ledges placed so the VR climb genuinely clears the wall? Walk both routes to be sure each is possible.

If it breaks​

  • The wall doesn't move. Check the slide script is inside SlidingWall and there are no red errors. Confirm :Play() is called.
  • The wall slides the wrong way or off the floor. ACROSS adds Vector3.new(10, 0, 0) — change the 10 (or move it to the Z axis with Vector3.new(0, 0, 10)) so it slides across the hall, not into a wall.
  • The wall doesn't kill me. It needs the Killer attribute, and your Stage 4 KillBricks script must be in ServerScriptService.
  • The VR ledges don't lift me (in VR). They must have Climbable = true, and your Stage 1 climb code must still be in VRController. If the climb worked in Stage 1, it works here — same code.
  • Nothing climbs on my laptop. Expected — the climb is VR-only (VREnabled). Cross by timing the wall today; the ledge grab is verified at the Stage 10 playtest.
Coach notes

TweenService is the headline skill: contrast it with the Stage 8 spinner out loud — "spin forever = Heartbeat loop; glide there and back = a tween." Campers who internalize that pick the right tool every time.

But the emotional beat is the ledges. Stop the room when a camper realizes the VR ledge grab needs no new code. Ask them why it works, and let them answer: "because Stage 1's climb handles any Climbable part." That sentence is the whole course. As always, the climb can't be tested on a laptop — confirm the ledges are tagged and placed to clear the wall, and trust the Stage 1 code that already passed.