Có rất ít mẹo nào khiến game 2D trông có chiều sâu nhanh bằng parallax scrolling: núi xa trôi chậm, cây gần vụt qua, và đột nhiên một màn hình phẳng có chiều sâu. Trong devlog này ta dựng một platformer cuộn ngang nhỏ chỉ với HTML <canvas> và JavaScript thuần. Không engine, không thư viện, không file ảnh. Mọi thứ bạn thấy, từ bầu trời đến anh hùng tròn tròn bé xíu, đều được vẽ bằng canvas path.

Ta sẽ đi qua những phần khiến game chơi sướng, chứ không chỉ nhìn đẹp: vòng lặp game fixed-timestep, nền parallax nhiều lớp lặp vô tận, vật lý nhân vật với gia tốc, ma sát, độ cao nhảy thay đổi được, coyote time và jump buffering, va chạm tile, camera mượt, render sắc nét trên màn hình HiDPI, và điều khiển cảm ứng. Hãy thử trước:

Phím mũi tên hoặc A/D để chạy, Space để nhảy. Trên mobile, dùng các nút trên màn hình. Mở toàn màn hình

Hai nút ở góc giúp bạn học. Parallax: off đặt hệ số của mọi lớp về 1, nên cả cảnh di chuyển như một bức tranh phẳng. Show layers gắn nhãn hệ số lên từng lớp và vẽ một đường đứt nét tại chỗ mỗi bản sao của một lớp nối với bản kế tiếp. Hãy bật tắt chúng khi đang chạy và xem điều gì thay đổi.

Vòng lặp game: fixed timestep, render mượt

requestAnimationFrame kích hoạt một lần mỗi lần màn hình làm tươi, có thể là 60 Hz trên màn hình này, 120 Hz trên màn hình khác, và bất cứ giá trị nào khi trình duyệt đang bận. Nếu bạn di chuyển nhân vật bằng velocity * dt với bất kỳ dt nào nhận được, cú nhảy sẽ đạt độ cao hơi khác nhau trên các máy khác nhau và va chạm trở nên chập chờn khi một frame kéo dài quá lâu.

Cách sửa là vòng lặp accumulator kinh điển: cộng thời gian thực vào một cái xô, rồi chạy vật lý theo các lát cố định (ở đây là 1/120 giây) cho đến khi xô gần cạn. Phần lẻ còn lại trở thành hệ số nội suy, nên việc render vẫn mượt dù vật lý và tần số làm tươi không khớp nhau.

const STEP = 1 / 120;        // fixed physics timestep (seconds)
const MAX_FRAME = 0.1;       // clamp long frames (tab switches, breakpoints)

function frame(now) {
  if (!running) return;
  let dt = (now - last) / 1000;
  last = now;
  if (dt > MAX_FRAME) dt = MAX_FRAME;      // never simulate a huge catch-up
  acc += dt;
  while (acc >= STEP) { update(STEP); acc -= STEP; }
  render(acc / STEP);
  rafId = requestAnimationFrame(frame);
}

Việc giới hạn này quan trọng hơn vẻ ngoài của nó. Chuyển tab mười giây rồi quay lại: không có giới hạn, vòng lặp sẽ cố mô phỏng mười giây trong một frame duy nhất, và nhân vật của bạn sẽ xuyên thẳng qua sàn. Mỗi lần update cũng lưu vị trí trước đó, và render(alpha) vẽ tại lerp(previous, current, alpha).

Vòng lặp cũng dừng hẳn khi không ai nhìn thấy nó: listener visibilitychange tạm dừng khi tab bị ẩn, và IntersectionObserver trên canvas tạm dừng khi demo nhúng cuộn ra khỏi tầm nhìn. Như vậy là tử tế với pin laptop, và khi tiếp tục, phần giới hạn ở trên giữ cho frame đầu tiên vẫn bình thường.

Parallax: một con số cho mỗi lớp

Toàn bộ hiệu ứng quy về một ý tưởng. Mỗi lớp nền có một hệ số parallax. Khi camera di chuyển camera.x pixel, một lớp di chuyển camera.x × factor. Hệ số 0 không bao giờ di chuyển (bầu trời). Hệ số 1 di chuyển đúng bằng thế giới (mặt đất bạn đứng). Bất cứ giá trị nào ở giữa đọc như "ở xa", và hệ số trên 1 đọc như "gần hơn nhân vật", rất hợp để làm tiền cảnh.

Sơ đồ bảy lớp xếp chồng từ bầu trời đến tiền cảnh, mỗi lớp kèm hệ số parallax, và các mũi tên cho thấy mỗi lớp trượt bao xa khi camera di chuyển 100 pixel: 0, 15, 30, 60, 80, 100 và 130 pixel.
Khi camera di chuyển 100 px, mỗi lớp trượt 100 × hệ số của nó. Hệ số nhỏ tạo cảm giác ở xa.

Demo dùng bầu trời ×0, mây ×0.15, núi ×0.3, đồi ×0.6, cây ×0.8, lớp chơi ×1.0 và tiền cảnh cỏ ×1.3. Màn chơi rộng 4000 px, nhưng hình nền thì không cần vậy. Mỗi lớp chỉ vẽ đúng một chu kỳ phong cảnh (chẳng hạn 1100 px núi), và ta lặp nó khắp màn hình bằng phép modulo:

function drawLayer(L, camX, camY) {
  const f = parallaxOn ? L.factor : 1;
  const scroll = camX * f - (L.drift ? time * L.drift : 0);
  const shift = ((scroll % L.period) + L.period) % L.period;   // always 0..period
  const ty = layerY(f, camY);
  for (let x = -shift - L.period; x < viewW; x += L.period) {
    ctx.save();
    ctx.translate(x, ty);
    L.draw(ctx);
    ctx.restore();
  }
}

Vài chi tiết đáng học theo:

  • Modulo kép. Trong JavaScript, -30 % 1000 là -30, không phải 970. Cộng thêm chu kỳ rồi lấy modulo lần nữa giữ shift trong phạm vi ngay cả khi giá trị scroll âm, như mây tự trôi.
  • Bắt đầu sớm một chu kỳ. Vòng lặp bắt đầu từ -shift - period. Một đám mây hay cái cây gần mép phải của một bản sao tràn sang bản sao kế tiếp, nên vẽ bản sao nằm ngay ngoài màn hình bên trái giúp những phần thò ra đó không bị bật hiện đột ngột.
  • Làm hình liền mạch. Các dải đồi được dựng từ một mảng độ cao quấn vòng: điểm sau điểm cuối cùng lại là điểm đầu tiên, nên cuối bản sao này khớp hoàn hảo với đầu bản sao kế tiếp. Hãy bật Show layers trong demo và thử tìm các đường nối khi không có đường đứt nét.

Chuyển động dọc của camera được xử lý tương tự: layerY nhân độ lệch dọc của camera với hệ số, nên nhảy lên một platform cao làm núi xa chìm xuống một chút chứ không nhiều.

Vật lý nhân vật cho cảm giác tốt

Di chuyển nhân vật với tốc độ cố định mỗi khi một phím được nhấn thì chạy được, nhưng cảm giác cứng đờ. Chuyển động có cảm giác thật có gia tốc (bạn tăng dần lên tốc độ tối đa) và ma sát (bạn trượt đến khi dừng). Khi quay đầu, cả hai được cộng lại, cho một cú đổi hướng dứt khoát mà không làm nhân vật giật giật.

const dir = (input.right ? 1 : 0) - (input.left ? 1 : 0);
if (dir !== 0) {
  let a = p.onGround ? PHYS.accel : PHYS.airAccel;
  if (p.vx * dir < 0) a += p.onGround ? PHYS.friction : PHYS.airFriction; // snappy turn-around
  p.vx = clamp(p.vx + dir * a * dt, -PHYS.maxRun, PHYS.maxRun);
  p.face = dir;
} else {
  const f = (p.onGround ? PHYS.friction : PHYS.airFriction) * dt;
  p.vx = Math.abs(p.vx) <= f ? 0 : p.vx - Math.sign(p.vx) * f;
}

Điều khiển trên không được cố ý làm yếu hơn trên mặt đất, nên một cú nhảy buộc bạn theo một hướng nhưng vẫn cho phép chỉnh lại.

Độ cao nhảy thay đổi được

Người chơi mong đợi chạm nhẹ cho cú nhảy nhỏ và nhấn giữ cho cú nhảy đầy đủ. Cách gọn nhất không phải là cắt ngắn cú nhảy, mà là làm trọng lực nặng hơn khi nhân vật còn đang đi lên và nút đã được nhả. Trong demo đó là một dòng duy nhất: g = (p.vy < 0 && !input.jump) ? gravity * 3 : gravity. Đường cong vẫn mượt trong cả hai trường hợp, và mức trần maxFall cho tốc độ rơi giữ cho những cú rơi dài vẫn dễ đọc.

Coyote time và jump buffering

Hai bộ hẹn giờ khoan dung này là lý do một số platformer cho cảm giác "chặt" còn số khác thì bất công. Coyote time (đặt theo chú sói đồng cỏ hoạt hình chạy ra khỏi vách đá và lơ lửng giữa không trung một lúc) cho phép bạn nhảy trong một khoảng ngắn sau khi bước khỏi mép. Jump buffering nhớ một lần nhấn nhảy đến hơi sớm, ngay trước khi tiếp đất, và thực hiện nó ngay khoảnh khắc chân chạm đất.

Hai dòng thời gian. Coyote time: sau khi chân rời mép, một cú nhảy nhấn trong vòng 100 ms vẫn hoạt động, còn nhấn ở 160 ms thì quá muộn. Jump buffering: một cú nhảy nhấn sớm tối đa 120 ms trước khi tiếp đất sẽ kích hoạt khi tiếp đất, còn nhấn sớm 180 ms thì bị quên.
Coyote time tha thứ cho lần nhấn muộn; jump buffering tha thứ cho lần nhấn sớm.

Cả hai chỉ là các bộ đếm ngược, và một cú nhảy chỉ xảy ra khi cả hai vẫn đang chạy:

p.coyote = p.onGround ? PHYS.coyoteTime : p.coyote - dt;   // 0.10 s
p.buffer = input.jumpPressed ? PHYS.bufferTime : p.buffer - dt; // 0.12 s
input.jumpPressed = false;

if (p.buffer > 0 && p.coyote > 0) {
  p.vy = -PHYS.jumpSpeed;
  p.buffer = 0; p.coyote = 0; p.onGround = false;
  p.sx = 0.75; p.sy = 1.3;                       // stretch on take-off
}

Lưu ý rằng jumpPressed được đặt một lần ở sự kiện keydown, tách biệt với trạng thái jump đang giữ. Nếu không, giữ Space sẽ khiến bạn nhảy cò cò mãi. Dòng cuối là một chút squash and stretch: nhân vật kéo dài khi cất cánh, bè ra khi tiếp đất, và trở lại bình thường dần theo từng bước. Chỉ vài dòng code mà thêm rất nhiều duyên.

Va chạm tile: từng trục một

Màn chơi là một lưới tile 40 px được lưu trong Uint8Array. Nhân vật là một axis-aligned bounding box (AABB). Mẹo giữ va chạm đơn giản và bền vững là di chuyển và xử lý từng trục riêng biệt: di chuyển ngang, đẩy ra khỏi bất kỳ bức tường nào, rồi di chuyển dọc và đẩy ra khỏi bất kỳ sàn hay trần nào. Vì bạn biết mình vừa di chuyển trục nào, bạn luôn biết phải đẩy về hướng nào.

function collide(b, axis) {
  const c0 = Math.floor(b.x / TILE), c1 = Math.floor((b.x + b.w - 0.001) / TILE);
  const r0 = Math.floor(b.y / TILE), r1 = Math.floor((b.y + b.h - 0.001) / TILE);
  for (let r = r0; r <= r1; r++) {
    for (let c = c0; c <= c1; c++) {
      if (!solidAt(c, r)) continue;
      if (axis === 'x') {
        if (b.vx > 0) b.x = c * TILE - b.w;
        else if (b.vx < 0) b.x = (c + 1) * TILE;
        b.vx = 0;
      } else {
        if (b.vy > 0) { b.y = r * TILE - b.h; b.onGround = true; }
        else if (b.vy < 0) b.y = (r + 1) * TILE;
        b.vy = 0;
      }
    }
  }
}

// in update():
p.x += p.vx * dt; collide(p, 'x');
p.onGround = false;
p.y += p.vy * dt; collide(p, 'y');

Chỉ các tile nằm dưới cái hộp được kiểm tra, nên chi phí không phụ thuộc vào kích thước màn chơi. Con số nhỏ 0.001 giúp một cái hộp nằm sát đúng mép tile không bị tính là chạm tile bên cạnh. Và vì bước được cố định ở 1/120 giây, ngay cả tốc độ rơi tối đa cũng di chuyển nhân vật ít hơn một phần tư tile mỗi bước, nên ta không bao giờ xuyên qua một platform mỏng.

solidAt coi các cột nằm ngoài màn chơi là tường và các hàng bên dưới là trống, cho ta tường vô hình hai bên và hố không đáy miễn phí. Rơi xuống hố và bạn sẽ hồi sinh ở mặt đất cuối cùng bạn đã đứng.

Một camera không làm bạn say tàu xe

Khóa camera vào vị trí nhân vật làm rung cả thế giới theo từng chuyển động nhỏ. Hai ý tưởng nhỏ sửa điều đó. Một dead zone ở 20% giữa màn hình cho phép nhân vật di chuyển tự do mà không làm camera động đậy. Khi nhân vật rời khỏi vùng đó, camera trượt êm về đích thay vì giật cái.

function cameraTarget() {
  const pcx = player.x + player.w / 2, pcy = player.y + player.h / 2;
  let tx = cam.x;
  const left = cam.x + viewW * 0.4, right = cam.x + viewW * 0.6;   // dead zone
  if (pcx < left) tx = pcx - viewW * 0.4;
  else if (pcx > right) tx = pcx - viewW * 0.6;
  const ty = pcy - viewH * 0.6;
  return { tx, ty };
}

function updateCamera(dt) {
  cam.px = cam.x; cam.py = cam.y;
  const { tx, ty } = cameraTarget();
  // frame-rate independent smoothing: same feel at any step size
  cam.x = lerp(cam.x, tx, 1 - Math.exp(-8 * dt));
  cam.y = lerp(cam.y, ty, 1 - Math.exp(-4 * dt));
  clampCamera();
}

1 - Math.exp(-k * dt) là phiên bản không phụ thuộc frame rate của lerp(a, b, 0.1) quen thuộc. Nó thu hẹp cùng một tỉ lệ khoảng cách mỗi giây bất kể chạy thường xuyên đến đâu. Làm mượt theo chiều dọc chậm hơn chiều ngang, nên những cú nhảy nhỏ không làm đường chân trời nhấp nhô. Cuối cùng, clampCamera giữ tầm nhìn trong màn chơi, để bạn không bao giờ thấy ra ngoài rìa thế giới.

Sắc nét trên mọi màn hình

Canvas có hai kích thước: kích thước CSS nó chiếm trên trang và số pixel trong backing store của nó. Trên màn hình Retina, một canvas rộng 1000 px với backing store 1000 px bị kéo giãn và trông mờ. Vì vậy ta định cỡ backing store theo devicePixelRatio, giới hạn ở 2 vì điện thoại 3× được lợi rất ít về mặt hình ảnh mà phải trả giá cho từng pixel thêm:

function resize() {
  cssW = canvas.clientWidth || window.innerWidth;
  cssH = canvas.clientHeight || window.innerHeight;
  dpr = Math.min(window.devicePixelRatio || 1, 2);
  canvas.width = Math.round(cssW * dpr);
  canvas.height = Math.round(cssH * dpr);
  // Fit VIEW_H world units to the screen height, unless that makes the view too narrow.
  scale = Math.min(cssH / VIEW_H, cssW / MIN_VIEW_W);
  viewW = cssW / scale;
  viewH = cssH / scale;
}

// every frame, draw the world in world units:
ctx.setTransform(dpr * scale, 0, 0, dpr * scale, 0, 0);

Toàn bộ code game khi đó làm việc theo đơn vị thế giới, độc lập với màn hình. Tầm nhìn hiển thị khoảng 440 đơn vị chiều cao, và màn hình rộng hơn đơn giản là thấy nhiều màn chơi hơn. Trên điện thoại dọc cao, tầm nhìn bị giới hạn theo chiều rộng, để nhân vật không co lại thành một chấm.

Điều khiển cảm ứng không chiếm quyền trang

Demo nằm trong một bài viết, nên nó phải là một vị khách lịch sự. Xử lý bàn phím chỉ gọi preventDefault trên các phím game, và chỉ nhận chúng khi frame có focus, nên phím mũi tên và Space vẫn cuộn bài viết bình thường. Trên thiết bị cảm ứng, ba nút HTML xuất hiện. Chỉ các nút đó dùng touch-action: none; canvas để yên cho các lần chạm, nên vuốt trên game vẫn cuộn trang.

for (const btn of document.querySelectorAll('.touch button')) {
  const k = btn.dataset.key;
  const up = () => { btn.classList.remove('on'); press(k, false); };
  btn.addEventListener('pointerdown', (e) => {
    e.preventDefault();
    btn.setPointerCapture(e.pointerId);
    btn.classList.add('on');
    press(k, true);
  });
  btn.addEventListener('pointerup', up);
  btn.addEventListener('pointercancel', up);
  btn.addEventListener('lostpointercapture', up);
}

Pointer capture cộng với các handler cancel và lost-capture nghĩa là ngón cái trượt khỏi nút, hay một cử chỉ hệ thống giành mất lần chạm, không bao giờ để nhân vật chạy mãi. Mỗi nút theo dõi pointer của riêng nó, nên bạn có thể giữ nút phải và chạm nút nhảy cùng lúc.

Bước tiếp theo

Cả demo là một file HTML duy nhất không phụ thuộc gì, nên hãy mở toàn màn hình và đọc mã nguồn. Vài bước tiếp theo tự nhiên:

  • Platform một chiều mà bạn có thể nhảy xuyên lên: chỉ xử lý va chạm dọc khi đang rơi và khi chân nhân vật ở phía trên platform trong bước trước.
  • Camera nhìn trước: dịch đích của camera một chút theo hướng nhân vật đang quay mặt, để bạn thấy nhiều hơn những gì sắp tới.
  • Lớp render sẵn: với hình nền nặng hơn, vẽ chu kỳ của mỗi lớp một lần vào canvas offscreen rồi blit bằng drawImage. Hãy để mắt đến bộ nhớ, vì một lớp cao hết cỡ ở DPR 2× tăng rất nhanh.
  • Chỉnh theo cảm giác: mỗi con số trong object PHYS là một quyết định thiết kế. Giảm nửa coyoteTime, nhân đôi lowJumpMult, và chơi mỗi phiên bản một phút. Bạn sẽ cảm nhận được khác biệt ngay.

Parallax là phần người ta để ý đầu tiên, nhưng các bộ hẹn giờ khoan dung, camera trượt êm và fixed timestep mới là thứ khiến một platformer chơi sướng. Tất cả chỉ là vài dòng JavaScript thuần.