تطوير الألعاب الأدلة التقنية

كيف تعمل اللعبة من الداخل؟ حلقة اللعبة Game Loop

لماذا تتحرك الشخصية بالسرعة نفسها على شاشة 144 هرتز وحاسوب بطيء: نبني حلقة اللعبة من الصفر حتى الخطوة الثابتة والاستيفاء، ونقيس كل طريقة في مختبر.

كيف تعمل اللعبة من الداخل؟ حلقة اللعبة Game Loop

عندما تلعب على شاشة سريعة بمعدل 144 هرتز، وصديقك يلعب اللعبة نفسها على حاسوب محمول قديم لا يعطي أكثر من 30 إطاراً في الثانية، فإن الشخصية عندكما تقطع المسافة نفسها في الثانية، وتقفز إلى الارتفاع نفسه، وتصطدم بالجدار نفسه. وقد يبدو هذا أمراً بديهياً لا يستحق السؤال، ولكن جهازك يرسم الصورة خمس مرات تقريباً في الوقت الذي يرسمها فيه جهاز صديقك مرة واحدة، فكيف لا تتحرك الشخصية عندك أسرع خمس مرات؟ والإجابة أن هذا لا يحدث تلقائياً، وإنما يحدث لأن مبرمج اللعبة كتب الحلقة التي تدير اللعبة بطريقة معينة، وإذا كتبها بالطريقة البسيطة فإن اللعبة تصبح فعلاً أسرع على الجهاز الأسرع، وقد حدث هذا في ألعاب حقيقية كما سوف نرى.

هذه الحلقة هي حلقة اللعبة Game Loop، وهي أول ما يجب أن تفهمه قبل أي محرك ألعاب، لأن كل محرك يبنى عليها، وكل إعداد في المحرك عن الفيزياء والإطارات يفهم من خلالها. وفي هذا المقال سوف نبني الحلقة من الصفر خطوة خطوة، ونبدأ بالطريقة البسيطة ونرى أين تفشل، ثم نحسنها حتى نصل إلى الطريقة التي تستخدمها المحركات، وكل خطوة نثبتها بمختبر يعمل على جهازك بأمر واحد.

وسوف نناقش في هذا المقال ما يلي:

  • لماذا تحتاج اللعبة حلقة، وما الإطار Frame وما ميزانيته من الزمن.
  • الطريقة البسيطة: تحريك عدد ثابت من البكسلات في كل إطار، ولماذا تجعل اللعبة أسرع على الجهاز الأسرع.
  • الزمن المتغير Delta Time: يصلح المسافة ويفسد القفز والتصادم.
  • لماذا لا يصل الإطار في وقته، بقياس حقيقي على جهازك.
  • الخطوة الثابتة Fixed Timestep مع المجمع Accumulator، وهي الطريقة الصحيحة.
  • الاستيفاء Interpolation، ودوامة الموت Spiral of Death وكيف تحمي اللعبة منها.
  • كيف تطبق Godot وUnity هذه الأفكار، والأخطاء التي تتكرر.

لماذا تحتاج اللعبة حلقة؟

أغلب البرامج التي تكتبها كمطور تنتظر حدثاً ثم تتصرف، فصفحة الويب لا تفعل شيئاً حتى ينقر المستخدم، والسيرفر لا يفعل شيئاً حتى يصل طلب، وهذا ما شرحناه في مقال حلقة الأحداث Event Loop: البرنامج ينام ويستيقظ عند الحدث. واللعبة مختلفة عن ذلك، لأن العالم فيها يتحرك حتى لو لم يضغط اللاعب أي زر، فالعدو يمشي، والكرة تسقط بفعل الجاذبية، والوقت ينفد، ولذلك لا يمكن أن تنتظر اللعبة حدثاً، وإنما تحتاج حلقة تدور باستمرار وتسأل في كل دورة: ماذا تغير منذ آخر مرة؟

وكل دورة من هذه الحلقة تتكون من ثلاث خطوات، والشكل التالي يبينها:

ثلاث بطاقات مرقمة من اليمين: 1 اقرأ المدخلات Input وفيها لوحة مفاتيح ويد تحكم، و2 حدث العالم Update وفيها ترس، و3 ارسم الصورة Render وفيها شاشة، وسهم متقطع يعود من الخطوة 3 إلى الخطوة 1، وتحتها شريط ميزانية الإطار عند 60 إطاراً في الثانية مقسم إلى Input وUpdate وRender وانتظار الشاشة، ومجموعه 16.7 ms
الإطار دورة واحدة: اقرأ المدخلات، ثم حدث العالم، ثم ارسمه، وكل ذلك يجب أن ينتهي داخل ميزانية الإطار.
  • اقرأ المدخلات Input: أي زر ضغطه اللاعب، وأين تحركت الفأرة، وهل وصلت رسالة من الشبكة في لعبة جماعية.
  • حدث العالم Update: حرك الشخصيات، وطبق الجاذبية، وافحص التصادم Collision، وطبق قواعد اللعبة، كأن ينقص الوقت أو تزيد النقاط.
  • ارسم الصورة Render: ارسم العالم كما هو الآن، ثم اعرض الصورة على الشاشة.

ثم تعود الحلقة إلى البداية، وكل دورة كاملة تسمى إطاراً Frame، وعدد الدورات في الثانية هو معدل الإطارات Frame Rate أو FPS اختصاراً لـ Frames Per Second. والكود التالي هو أبسط شكل لهذه الحلقة، وسوف نطوره في بقية المقال:

while (running) {
  readInput();
  update();
  render();
}

الإطار وميزانيته من الزمن

إذا أردت أن تعمل اللعبة بمعدل 60 إطاراً في الثانية، فلديك 1000 مقسومة على 60، أي 16.7 مللي ثانية لكل إطار، وهذه هي ميزانية الإطار Frame Budget، ويجب أن تنتهي فيها الخطوات الثلاث كلها. وعند 144 إطاراً تصبح الميزانية 6.9 مللي ثانية فقط، وعند 30 إطاراً تصبح 33.3 مللي ثانية. وإذا تجاوز إطار واحد ميزانيته، فإن الشاشة تعرض الصورة القديمة مرة أخرى، ويلاحظ اللاعب توقفاً قصيراً يسمى التقطيع Stutter.

ولاحظ أن الإطار لا يأخذ الزمن نفسه في كل مرة، فإطار فيه انفجار وعشرون عدواً يأخذ وقتاً أطول من إطار فيه شخصية واحدة في ممر فارغ، والجهاز نفسه يشغل برامج أخرى في الخلفية، ونظام التشغيل قد يوقف اللعبة جزءاً من المللي ثانية ليعطي المعالج لغيرها. ولذلك فإن السؤال الحقيقي في تصميم الحلقة ليس «كم إطاراً في الثانية؟» وإنما «كيف أجعل العالم يتحرك بالسرعة الصحيحة مهما اختلف طول الإطار؟»، وهذا ما سوف نبنيه الآن.

المختبر: عالم صغير وأربع حلقات

لكي نقارن الطرق بالأرقام لا بالكلام، سوف نبني عالماً صغيراً جداً فيه شخصية تجري بسرعة 240 بكسل في الثانية، وتقفز بسرعة ابتدائية 600 بكسل في الثانية ضد جاذبية مقدارها 1800 بكسل في الثانية المربعة، وهذه الأرقام تعطي قفزاً ارتفاعه 100 بكسل بالضبط حسب قانون الحركة، أي سرعة القفز مربعة مقسومة على ضعف الجاذبية. وفيه أيضاً كرة سريعة تطير بسرعة 2400 بكسل في الثانية نحو جدار سمكه 10 بكسل يبدأ عند x = 500.

والمختبر ملف واحد بلغة JavaScript يعمل على Node 18 أو أحدث دون أي مكتبة، ويشغل العالم نفسه بأربع طرق مختلفة لكتابة الحلقة، وبمعدلات إطارات مختلفة: 30 و60 و144 إطاراً في الثانية، ومعدل رابع متذبذب Jitter يأتي فيه كل إطار بطول عشوائي بين 5 و40 مللي ثانية، وهو أقرب إلى ما يحدث في الواقع. والزمن في المختبر محسوب لا مقاس، أي أننا نعطي الحلقة أطوال الإطارات بأنفسنا، ولذلك فإن المخرج سوف يكون نفسه على جهازك وعلى أي جهاز، وهذا مقصود لأننا نريد أن نرى أثر طريقة كتابة الحلقة وحدها. والقياس الحقيقي للإطارات على جهازك يأتي في مختبر ثان بعد قليل.

وفيما يلي الملف كاملاً، ولا تحتاج أن تفهمه كله الآن، فسوف نمر على كل قسم منه مع مخرجه:

// Game loop lab: the same small 2D game world run by four kinds of loop, at different frame rates.
//   node loop.mjs            (Node 18 or newer, no packages)
// Everything here is simulated time, so the output is the same on every machine: that is the point of section 3.
// World: a character runs at 240 px/s and jumps at 600 px/s against gravity 1800 px/s^2 (the exact apex is 100 px),
// and a ball flies at 2400 px/s toward a wall 10 px thick that starts at x = 500.

const RUN = 240, JUMP = 600, G = 1800;
const WALL = [500, 510], BALL = 2400;
const DT = 1 / 60;                                   // the fixed step of sections 3 to 6
const f = (n, d = 1) => n.toFixed(d);

// frame times in seconds: a steady rate, or a jittery one from a fixed seed (a real game never gets a steady rate)
const steady = (fps, seconds) => Array(Math.round(fps * seconds)).fill(1 / fps);
function jitter(seconds, seed = 7) {
  const out = []; let t = 0, s = seed;
  while (t < seconds) { s = (s * 1103515245 + 12345) % 2147483648; const ms = 5 + (s / 2147483648) * 35; out.push(ms / 1000); t += ms / 1000; }
  return out;
}
const RATES = [['30 FPS', steady(30, 2)], ['60 FPS', steady(60, 2)], ['144 FPS', steady(144, 2)], ['jitter 5-40 ms', jitter(2)]];

// one physics step of the jump (semi-implicit Euler: velocity first, then position)
function jumpStep(s, dt) { s.vy -= G * dt; s.y += s.vy * dt; if (s.y <= 0) { s.y = 0; s.landed = true; } s.top = Math.max(s.top, s.y); }

console.log('### 1. Move a fixed number of pixels per frame (x += 4)');
for (const [name, frames] of RATES.slice(0, 3)) {
  const oneSecond = frames.slice(0, frames.length / 2);
  console.log(`${name.padEnd(8)} after 1 s: x = ${oneSecond.length * 4} px`);
}

console.log('### 2. Variable timestep (x += v * dt): distance right, jump and collisions not');
for (const [name, frames] of RATES) {
  let x = 0; const s = { y: 0, vy: JUMP, top: 0, landed: false }; let t = 0, land = 0;
  for (const dt of frames) { t += dt; if (t <= 1 + 1e-9) x += RUN * dt; if (!s.landed) { jumpStep(s, dt); if (s.landed) land = t; } }
  // the ball: collision checked only where the ball is at each frame
  let bx = 0, hit = 'passed through';
  for (const dt of frames) { bx += BALL * dt; if (bx >= WALL[0] && bx <= WALL[1]) { hit = `hit at x=${f(bx)}`; break; } if (bx > 600) break; }
  console.log(`${name.padEnd(15)} run 1 s: ${f(x)} px | jump top ${f(s.top, 2)} px, lands at ${f(land, 3)} s | ball: ${hit}`);
}

// the fixed-step loop of «Fix Your Timestep»: real time goes into an accumulator, the world moves in steps of DT only
function fixedLoop(frames, { onStep, onFrame, maxFrame = Infinity } = {}) {
  let acc = 0, steps = 0;
  for (const raw of frames) {
    const frame = Math.min(raw, maxFrame);           // the clamp of section 6
    acc += frame; let n = 0;
    while (acc >= DT - 1e-12) { onStep?.(); acc -= DT; steps++; n++; }
    onFrame?.(acc / DT, n);                          // alpha: how far we are between the last two steps
  }
  return steps;
}

console.log('### 3. Fixed timestep with an accumulator (60 steps per second)');
for (const [name, frames] of RATES) {
  const s = { y: 0, vy: JUMP, top: 0, landed: false }; let landStep = 0, k = 0;
  let bx = 0, hit = 'passed through', bdone = false;
  fixedLoop(frames, { onStep: () => {
    k++; if (!s.landed) { jumpStep(s, DT); if (s.landed) landStep = k; }
    if (!bdone) { bx += BALL * DT; if (bx >= WALL[0] && bx <= WALL[1]) { hit = `hit at x=${f(bx)}`; bdone = true; } else if (bx > 600) bdone = true; }
  } });
  console.log(`${name.padEnd(15)} frames ${String(frames.length).padStart(3)} | jump top ${f(s.top, 2)} px, lands at step ${landStep} | ball: ${hit}`);
}
// the same ball with a swept test: check the whole segment it crossed in the step, not only where it ended
{ let bx = 0, k = 0, hit = 'passed through';
  while (bx < 600) { const from = bx; bx += BALL * DT; k++; if (from <= WALL[1] && bx >= WALL[0]) { hit = `hit in step ${k} (segment ${f(from)} to ${f(bx)})`; break; } }
  console.log(`swept test, same 40 px steps: ball ${hit}`); }

console.log('### 4. Interpolation: drawing at 144 FPS a world that moves at 60 steps per second');
for (const interp of [false, true]) {
  let prev = 0, cur = 0; const drawn = [];
  fixedLoop(steady(144, 0.1), {
    onStep: () => { prev = cur; cur += RUN * DT; },
    onFrame: (alpha) => drawn.push(interp ? prev + (cur - prev) * alpha : cur),
  });
  const moves = drawn.slice(1).map((x, i) => x - drawn[i]);
  const still = moves.filter(m => Math.abs(m) < 1e-9).length;
  console.log(`${interp ? 'with interpolation   ' : 'without interpolation'} x on frames 1-12: ${drawn.slice(0, 12).map(x => f(x)).join(' ')}`);
  console.log(`${' '.repeat(21)} moves between frames: min ${f(Math.min(...moves), 2)} max ${f(Math.max(...moves), 2)} px, frames that did not move: ${still} of ${moves.length}`);
}

console.log('### 5. Spiral of death: one step costs 20 ms of CPU, more than the 16.7 ms it simulates');
for (const cap of [Infinity, 8]) {
  const STEP_COST = 0.020, DRAW_COST = 0.002; let acc = 0, frame = 1 / 60, sim = 0, real = 0; const rows = [];
  for (let i = 1; i <= 20; i++) {
    acc += frame; let n = 0;
    while (acc >= DT - 1e-12 && n < cap) { acc -= DT; n++; sim += DT; }
    if (n === cap) acc = 0;                          // give up the time we could not simulate: the game slows down instead of freezing
    real += frame; frame = DRAW_COST + n * STEP_COST;
    rows.push(`${n}`);
    if (i === 20) console.log(`${cap === Infinity ? 'no cap       ' : 'cap 8 steps  '} steps per frame: ${rows.join(' ')} | last frame took ${f(frame * 1000, 0)} ms | game time / real time ${f(sim / real, 2)}`);
  }
}

console.log('### 6. What happens if the game stops for 0.4 s while the character falls onto a thin platform?');
// platform top at y = 50, 4 px thick; the character jumps from y = 60 so it falls onto the platform
for (const mode of ['variable dt', 'fixed', 'fixed + clamp']) {
  const s = { y: 60, vy: JUMP, top: 60 }; let result = 'fell through the platform', t = 0;
  const frames = [...steady(60, 0.4), 0.4, ...steady(60, 1)];        // 0.4 s pause while the character is near the top
  const step = (dt) => { const before = s.y; s.vy -= G * dt; s.y += s.vy * dt;
    if (s.vy < 0 && s.y <= 50 && s.y >= 46) { s.y = 50; s.vy = 0; result = `landed on the platform at t=${f(t, 2)} s`; return true; }
    if (s.y < 0) { result = `fell through the platform (one step went from y=${f(before)} to y=${f(s.y)})`; return true; } };
  if (mode === 'variable dt') { for (const dt of frames) { t += dt; if (step(dt)) break; } }
  else { let done = false, most = 0; fixedLoop(frames, { maxFrame: mode === 'fixed' ? Infinity : 0.25, onStep: () => { t += DT; if (!done) done = step(DT); }, onFrame: (a, n) => { most = Math.max(most, n); } });
    result += ` | steps in the long frame: ${most}`; }
  console.log(`${mode.padEnd(14)} ${result}`);
}

ولتشغيله:

node loop.mjs

الطريقة البسيطة: عدد ثابت من البكسلات في كل إطار

أول ما يكتبه أي مبتدئ هو أن يحرك الشخصية مقداراً ثابتاً في كل إطار، فإذا كانت اللعبة مصممة على 60 إطاراً في الثانية ويريد سرعة 240 بكسل في الثانية، فإنه يحرك الشخصية 4 بكسل في كل إطار، أي x += 4. وهذا يعمل على جهازه تماماً، لأن جهازه يعطي 60 إطاراً، والمشكلة تظهر على جهاز غيره. والقسم الأول من المختبر يشغل هذا السطر لمدة ثانية واحدة على ثلاثة معدلات، والمخرج سوف يكون كما يلي:

30 FPS   after 1 s: x = 120 px
60 FPS   after 1 s: x = 240 px
144 FPS  after 1 s: x = 576 px

لاحظ أن الشخصية على جهاز 144 هرتز قطعت 576 بكسل في الثانية بدل 240، أي أنها أسرع مرتين ونصف، وعلى جهاز 30 إطاراً قطعت نصف المسافة، فاللعبة على الجهاز البطيء تبدو كأنها بالحركة البطيئة. والسبب أن السرعة في هذا الكود ليست بكسل في الثانية وإنما بكسل في الإطار، وعدد الإطارات في الثانية يختلف من جهاز إلى جهاز، والشكل التالي يبين ذلك:

رسم بالأعمدة لمكان الشخصية بعد ثانية واحدة: في الأعلى تحريك 4 بكسل في كل إطار يعطي 120 px عند 30 إطاراً و240 px عند 60 و576 px عند 144، وفي الأسفل تحريك السرعة مضروبة في زمن الإطار يعطي 240 px في المعدلات الثلاثة، وخط متقطع أخضر عند 240 px هو الإجابة الصحيحة
نتيجة القسمين الأول والثاني من المختبر: السرعة بالإطار تختلف باختلاف الجهاز، والسرعة بالثانية لا تختلف.

وقد يتساءل البعض: هل وقعت ألعاب حقيقية في هذا الخطأ؟ نعم، وأشهرها لم يكن خطأ وإنما مصادفة أصبحت جزءاً من تصميم اللعبة:

📌
في عام 1978 صدرت لعبة Space Invaders التي برمجها Tomohiro Nishikado، وفيها صفوف من الكائنات الفضائية تتحرك نحو اللاعب. وأثناء تطويرها لاحظ Nishikado أن المعالج يرسم إطارات الكائنات بسرعة أكبر كلما قل عددها على الشاشة، فكلما قتل اللاعب كائناً تحركت البقية أسرع، لأن الحركة كانت مربوطة بعدد الإطارات لا بالزمن. وأبقى Nishikado هذا السلوك لأنه جعل نهاية كل مرحلة أصعب وأكثر إثارة، كما تذكر صفحة اللعبة في ويكيبيديا ومصادرها. والدرس أن ربط الحركة بالإطار يجعل سرعة اللعبة تتبع سرعة الجهاز وكمية ما يرسم، فإذا كان هذا ما تريده فاكتبه عمداً، لا مصادفة.

والأمر نفسه تجده اليوم في الويب، فدالة requestAnimationFrame في المتصفح تستدعي الكود مرة مع كل تحديث للشاشة، وتوثيق MDN يذكر أن عدد مرات الاستدعاء يطابق في الغالب معدل تحديث الشاشة، وأن أشهرها 60 هرتز وأن 75 و120 و144 هرتز منتشرة أيضاً، ويحذر صراحة من أن الحركة التي لا تحسب الزمن سوف تكون أسرع على الشاشات ذات معدل التحديث العالي. لذلك لا تقم بتحريك أي شيء بمقدار ثابت لكل إطار إلا إذا كنت متأكداً أن معدل الإطارات ثابت، وهذا لا يحدث إلا في أجهزة الألعاب القديمة ذات العتاد الواحد.

الحل الثاني: الزمن المتغير Delta Time

الحل الذي يأتي بعد ذلك مباشرة هو أن تقيس الزمن الذي مضى منذ الإطار السابق، ويسمى Delta Time أو dt اختصاراً، ثم تضرب السرعة فيه، فتصبح الحركة x += speed * dt. فعلى جهاز 144 هرتز يكون dt صغيراً والحركة في كل إطار صغيرة، وعلى جهاز 30 إطاراً يكون dt كبيراً والحركة في كل إطار كبيرة، والمجموع في الثانية واحد. وهذه الطريقة تسمى الخطوة المتغيرة Variable Timestep، وهي ما تفعله دالة _process(delta) في Godot ودالة Update مع Time.deltaTime في Unity كما سيأتي.

والقسم الثاني من المختبر يشغل الجري والقفز والكرة بهذه الطريقة على المعدلات الأربعة، والمخرج سوف يكون كما يلي:

30 FPS          run 1 s: 240.0 px | jump top 90.00 px, lands at 0.633 s | ball: passed through
60 FPS          run 1 s: 240.0 px | jump top 95.00 px, lands at 0.650 s | ball: passed through
144 FPS         run 1 s: 240.0 px | jump top 97.92 px, lands at 0.660 s | ball: hit at x=500.0
jitter 5-40 ms  run 1 s: 238.6 px | jump top 90.98 px, lands at 0.655 s | ball: passed through

في المخرج أعلاه لاحظ التالي:

  • المسافة صحيحة: 240 بكسل في الثانية على المعدلات الثلاثة الثابتة، فالمشكلة الأولى انحلت. والمعدل المتذبذب أعطى 238.6 لأن آخر إطار قبل نهاية الثانية انتهى قبلها بقليل، والإطار الذي بعده تجاوز الثانية فلم نحسبه.
  • ارتفاع القفز مختلف: 90 بكسل عند 30 إطاراً، و95 عند 60، و97.92 عند 144، و90.98 مع التذبذب، والارتفاع الصحيح حسب القانون 100 بكسل. فإذا كان في المرحلة حاجز ارتفاعه 92 بكسل، فإن اللاعب على الشاشة السريعة يعبره، واللاعب على الحاسوب البطيء لا يستطيع مهما حاول.
  • زمن الهبوط مختلف: من 0.633 إلى 0.660 ثانية، فالشخصية تقضي في الهواء أزماناً مختلفة على أجهزة مختلفة.
  • الكرة تعبر الجدار: عند 30 و60 إطاراً وعند التذبذب مرت الكرة من الجدار كأنه غير موجود، وعند 144 فقط اصطدمت به.

وقد يتساءل البعض: لماذا اختلف ارتفاع القفز ما دمنا نضرب في الزمن؟ والإجابة أن الجري حركة بسرعة ثابتة، فضربها في الزمن دقيق مهما كان طول الإطار، أما القفز فالسرعة فيه تتغير باستمرار بسبب الجاذبية، والكود يحسبها على خطوات: في كل إطار ينقص السرعة بمقدار الجاذبية مضروبة في dt، ثم يحرك الشخصية بالسرعة الجديدة. وهذه الطريقة في الحساب تسمى التكامل العددي Numerical Integration، والنوع الذي استخدمناه اسمه Semi-implicit Euler، وهو الأشهر في الألعاب لبساطته واستقراره، ولكنه تقريب لا حساب دقيق، والخطأ فيه يكبر كلما كبرت الخطوة. فعند 30 إطاراً تكون الخطوة 33 مللي ثانية والخطأ 10 بكسل، وعند 144 إطاراً تكون الخطوة 6.9 مللي ثانية والخطأ 2 بكسل تقريباً. وهذا يعني أن نتيجة الفيزياء في لعبتك تعتمد على جهاز اللاعب، وهي مشكلة أخطر من المسافة، لأنها لا تظهر على جهازك أثناء التطوير.

أما الكرة فمشكلتها مختلفة، والشكل التالي يبينها:

أربعة صفوف لمواقع الكرة قرب جدار رمادي بين x = 500 و510: عند 30 إطاراً في الثانية النقاط كل 80 px ولا تقع واحدة منها داخل الجدار فتمر الكرة passed، وعند 60 إطاراً النقاط كل 40 px وتمر أيضاً، وعند 144 إطاراً النقاط كل 16.7 px وتقع نقطة حمراء داخل الجدار فتصطدم hit، وفي الصف الأخير فحص المسار بأكمله من 480 إلى 520 يغطي الجدار فتصطدم hit
الكرة تتحرك 2400 بكسل في الثانية، والفحص الذي يرى مكانها في نهاية كل إطار فقط لا يرى أنها مرت بالجدار.

الكود يفحص التصادم في مكان الكرة بعد كل إطار، والكرة عند 30 إطاراً تقطع 80 بكسل في الإطار الواحد، فتكون قبل الجدار عند 480 ثم بعده عند 560، ولا تكون داخله في أي لحظة يفحص فيها الكود. وهذه الظاهرة تسمى العبور Tunneling، وتحدث مع كل جسم سريع وجدار رفيع، كالرصاصة في لعبة إطلاق نار، أو الشخصية التي تسقط من ارتفاع كبير على أرضية رفيعة. وكلما كان الإطار أطول كانت المسافة بين الفحصين أكبر، ولذلك فإن اللاعب على الجهاز البطيء يرى الرصاص يمر من الجدران، واللاعب على الجهاز السريع لا يراه.

وبالتالي فإن الزمن المتغير أصلح المسافة، ولكنه ربط نتائج الفيزياء بجهاز اللاعب، والحل الأنسب ليس في ضرب أدق في الزمن، وإنما في أن نفصل زمن الفيزياء عن زمن الرسم تماماً، ولكن قبل ذلك نحتاج أن نعرف كم يختلف طول الإطار في الواقع.

لماذا لا يصل الإطار في وقته؟

قد تظن أن التذبذب الذي وضعناه في المختبر مبالغ فيه، وأن الإطار في الواقع يأتي في وقته تقريباً. والطريقة الوحيدة لمعرفة ذلك أن نقيس، والمختبر الثاني يقيس طول 120 إطاراً حقيقياً على جهازك بطريقتين: حلقة تعتمد على المؤقت setTimeout بفترة 16 مللي ثانية في Node، وهي الطريقة التي يكتبها من يظن أن المؤقت دقيق، وحلقة تعتمد على requestAnimationFrame في متصفح Chrome، وهي الطريقة الصحيحة في الويب:

// Real frame times on your machine: a loop driven by setTimeout(16) in Node, and requestAnimationFrame in Chrome.
//   node frames.mjs            (the Chrome part needs scripts/lab/browser.mjs from this repository and Chrome installed)
import { launch } from '../../../../scripts/lab/browser.mjs';
const stats = (name, ms) => {
  const s = [...ms].sort((a, b) => a - b), avg = ms.reduce((a, b) => a + b, 0) / ms.length;
  const near = ms.filter(x => Math.abs(x - 1000 / 60) <= 1).length;
  console.log(`${name.padEnd(28)} frames ${ms.length} | min ${s[0].toFixed(1)} avg ${avg.toFixed(1)} max ${s.at(-1).toFixed(1)} ms | within 1 ms of 16.7: ${near}`);
  console.log(`${''.padEnd(28)} first 10: ${ms.slice(0, 10).map(x => x.toFixed(1)).join(' ')}`);
};
console.log('### 1. setTimeout(16) in Node');
const ms = []; let last = performance.now();
await new Promise(done => { const tick = () => { const now = performance.now(); ms.push(now - last); last = now; ms.length < 120 ? setTimeout(tick, 16) : done(); }; setTimeout(tick, 16); });
stats('setTimeout(16)', ms);
console.log('### 2. requestAnimationFrame in headless Chrome');
const b = await launch({ port: 9988, width: 800, height: 600 });
try {
  await b.goto('data:text/html,<canvas id=c width=400 height=200></canvas>', { wait: 500 });
  const raf = await b.evaluate(`new Promise(r => { const out = []; let last = 0;
    const f = (t) => { if (last) out.push(t - last); last = t; out.length < 120 ? requestAnimationFrame(f) : r(out); }; requestAnimationFrame(f); })`);
  stats('requestAnimationFrame', raf);
} finally { await b.close(); }

والجزء الثاني يحتاج Chrome مثبتاً على الجهاز، ويشغله المختبر دون واجهة Headless عبر الملف المساعد في مستودع الموقع. وعند تشغيله:

node frames.mjs

والمخرج سوف يكون قريباً مما يلي، والأرقام عندك سوف تختلف لأنها قياس حقيقي:

### 1. setTimeout(16) in Node
setTimeout(16)               frames 120 | min 15.7 avg 29.0 max 47.3 ms | within 1 ms of 16.7: 13
                             first 10: 23.2 30.9 30.7 16.0 26.6 29.3 31.0 31.0 30.5 26.5
### 2. requestAnimationFrame in headless Chrome
requestAnimationFrame        frames 120 | min 16.5 avg 16.7 max 16.8 ms | within 1 ms of 16.7: 120
                             first 10: 16.7 16.6 16.7 16.7 16.7 16.6 16.7 16.7 16.6 16.7

في المخرج أعلاه لاحظ التالي:

  • المؤقت لا ينفذ في الوقت الذي طلبته: طلبنا 16 مللي ثانية، فجاء متوسط الإطار 29 مللي ثانية، وأطول إطار 47 مللي ثانية، و13 إطاراً فقط من 120 جاءت قريبة من 16.7. والسبب أن setTimeout يعدك بألا ينفذ الكود قبل المدة، ولا يعدك بأن ينفذه بعدها مباشرة، فالتوقيت يعتمد على دقة مؤقت نظام التشغيل وعلى ما يشغله الجهاز في تلك اللحظة.
  • دقة المؤقت في Windows إعداد في النظام: توثيق الدالة timeBeginPeriod من Microsoft يذكر أن البرنامج يطلب بها دقة أعلى للمؤقت، وأن Windows منذ الإصدار 10 نسخة 2004 لا يضمن للبرنامج الذي لم يطلبها دقة أعلى من الدقة الافتراضية للنظام، وأن الدقة العالية تزيد استهلاك الطاقة لأنها تمنع المعالج من دخول أوضاع التوفير. ولذلك فإن الحلقة نفسها قد تعطي أرقاماً مختلفة على جهاز آخر أو نظام آخر.
  • requestAnimationFrame ثابت: كل الإطارات الـ 120 جاءت بين 16.5 و16.8 مللي ثانية، لأن المتصفح يربطها بتحديث الشاشة لا بمؤقت عام، والشاشة الافتراضية لـ Chrome دون واجهة تعمل بمعدل 60 هرتز.

ولا تعني النتيجة الثانية أن مشكلة طول الإطار انتهت في المتصفح، فالإطار الثابت هنا لأن الصفحة لا ترسم شيئاً، وعندما ترسم اللعبة مشهداً ثقيلاً يتأخر إطار ويأتي الذي بعده في وقته. والأخطر من ذلك ما يذكره توثيق MDN من أن أغلب المتصفحات توقف استدعاءات requestAnimationFrame عندما يكون التبويب في الخلفية، فإذا ترك اللاعب التبويب دقيقة ثم عاد، فإن أول إطار بعد عودته يأتي بزمن dt مقداره ستون ثانية، والحلقة التي تضرب في هذا الرقم مباشرة سوف تحرك كل شيء في العالم مسافة دقيقة كاملة في خطوة واحدة. وسوف نرى في نهاية المقال ماذا يحدث في هذه الحالة بالتحديد، وكيف تحمي الحلقة منها.

والخلاصة من هذا القسم أن طول الإطار متغير دائماً، فهو يتغير بتغير الجهاز، وبتغير ما يرسم في المشهد، وبتغير ما يشغله النظام، وأي تصميم للحلقة يفترض إطاراً ثابتاً سوف يفشل عند أحد اللاعبين.

الحل الصحيح: خطوة ثابتة مع المجمع Accumulator

الفكرة التي تحل المشكلتين معاً شرحها Glenn Fiedler في مقاله المشهور Fix Your Timestep المنشور عام 2004، وهي أن نفصل بين أمرين: الرسم، ويحدث مرة في كل إطار مهما كان طوله، وتحديث العالم، ويحدث بخطوات ثابتة الطول دائماً، ولتكن 1/60 من الثانية. وبين الاثنين متغير يسمى المجمع Accumulator، وهو مثل وعاء: في كل إطار نضيف إليه الزمن الحقيقي الذي مضى، ثم نخرج منه خطوات ثابتة ما دام فيه ما يكفي لخطوة كاملة، والباقي يبقى في الوعاء للإطار التالي. والشكل التالي يبين ذلك بأطوال إطارات حقيقية من المعدل المتذبذب في المختبر:

في الأعلى ستة إطارات حقيقية بأطوال مختلفة 26 و15 و24 و40 و29 و24 مللي ثانية، وتحتها خط زمني عليه خطوات المحاكاة كل 16.7 ms بالضبط، وتحته عدد الخطوات في كل إطار 1 و1 و1 و3 و2 و1، وفي الأسفل وعاء المجمع Accumulator مع الكود acc += frame; while (acc >= DT) { step(DT); acc -= DT; }
الإطار الطويل (40 مللي ثانية) ينفذ ثلاث خطوات، والإطار القصير (15 مللي ثانية) قد لا ينفذ إلا خطوة أو لا شيء، والعالم في كل الأحوال يتحرك بخطوات من 16.7 مللي ثانية فقط.

والحلقة بهذه الطريقة تصبح كما يلي، وهي الدالة fixedLoop في المختبر بعد إزالة ما يخص القياس:

const DT = 1 / 60;
let acc = 0, last = now();
while (running) {
  const frame = now() - last; last = now();
  acc += frame;
  while (acc >= DT) {     // as many fixed steps as the real time allows
    readInput();
    update(DT);           // always the same step, on every machine
    acc -= DT;
  }
  render();
}

والقسم الثالث من المختبر يشغل العالم نفسه بهذه الحلقة على المعدلات الأربعة، والمخرج سوف يكون كما يلي:

30 FPS          frames  60 | jump top 95.00 px, lands at step 39 | ball: passed through
60 FPS          frames 120 | jump top 95.00 px, lands at step 39 | ball: passed through
144 FPS         frames 288 | jump top 95.00 px, lands at step 39 | ball: passed through
jitter 5-40 ms  frames  91 | jump top 95.00 px, lands at step 39 | ball: passed through
swept test, same 40 px steps: ball hit in step 13 (segment 480.0 to 520.0)

في المخرج أعلاه لاحظ التالي:

  • عدد الإطارات مختلف: 60 إطاراً في ثانيتين على الجهاز البطيء، و288 على السريع، و91 مع التذبذب، فالرسم ما زال يتبع الجهاز، وهذا ما نريده لأن الجهاز الأسرع يجب أن يعرض صورة أنعم.
  • ارتفاع القفز واحد: 95.00 بكسل على المعدلات الأربعة، والهبوط في الخطوة 39 في كل مرة، لأن الفيزياء الآن لا ترى طول الإطار أصلاً، فهي تتقدم دائماً بخطوات من 1/60 من الثانية.
  • الارتفاع ما زال 95 لا 100: الخطوة الثابتة لا تجعل التكامل العددي دقيقاً، وإنما تجعل خطأه واحداً على كل الأجهزة. وهذا هو المهم في لعبة، لأنك تصمم المراحل وأنت ترى 95، فيرى كل لاعب 95.
  • الكرة ما زالت تعبر الجدار: وفي كل المعدلات هذه المرة، فالخطوة الثابتة جعلت الخطأ ثابتاً لا مختفياً، والكرة تقطع 40 بكسل في كل خطوة، والجدار سمكه 10 بكسل.

والنتيجة الأخيرة مهمة، لأن كثيراً من المطورين يظنون أن الخطوة الثابتة تحل العبور، وهي لا تحله، وإنما تجعله يظهر على جهازك أثناء التطوير كما يظهر عند اللاعب، وهذا في حد ذاته مكسب كبير لأنك تستطيع إصلاحه. والإصلاح له ثلاث طرق: أن تقصر الخطوة، أي تزيد عدد خطوات الفيزياء في الثانية، وهذا يزيد استهلاك المعالج، أو أن تجعل الجدران أسمك من أقصى مسافة يقطعها أسرع جسم في خطوة واحدة، أو أن تفحص المسار كله بدل النقطة الأخيرة، وهذا ما يسمى الفحص الممتد Swept Test أو الكشف المستمر عن التصادم Continuous Collision Detection. والسطر الأخير في مخرج القسم الثالث يبين الطريقة الثالثة: الكرة نفسها بالخطوات نفسها من 40 بكسل، ولكن الكود يفحص هل يتقاطع المقطع من 480 إلى 520 مع الجدار، فيكتشف التصادم في الخطوة 13. والمحركات توفر هذا جاهزاً، ففي Godot مثلاً خاصية continuous_cd في RigidBody2D، والتوثيق يصفها بأنها أبطأ ولكنها أدق ولا تفوت التصادم مع الأجسام الصغيرة السريعة، ولذلك فعلها للأجسام السريعة فقط لا لكل جسم في اللعبة.

وللخطوة الثابتة فائدة أخرى لا تظهر في المختبر، وهي أن اللعبة تصبح قابلة للتكرار Deterministic: إذا أعطيتها المدخلات نفسها في الخطوات نفسها أعطتك العالم نفسه، وهذا ما تبنى عليه ميزة إعادة عرض المباراة Replay، حيث تحفظ اللعبة المدخلات فقط لا مواقع كل الأجسام، وتبنى عليه أيضاً كثير من الألعاب الجماعية التي ترسل المدخلات بين اللاعبين لا حالة العالم. ولكن تذكر أن التكرار الكامل بين أجهزة مختلفة يحتاج أكثر من الخطوة الثابتة، لأن حساب الأرقام العشرية نفسه قد يختلف قليلاً بين معالج ومترجم كما شرحنا في مقال Floating Point من الداخل.

الاستيفاء Interpolation: لماذا تهتز الصورة رغم أن الفيزياء صحيحة؟

الخطوة الثابتة أصلحت الفيزياء، ولكنها أوجدت مشكلة جديدة في الرسم، فالعالم الآن يتحرك 60 مرة في الثانية، والشاشة السريعة ترسم 144 مرة في الثانية، وبالتالي فإن بعض الإطارات ترسم العالم دون أن يتغير منذ الإطار السابق، وبعضها يرسمه بعد خطوة كاملة. والقسم الرابع من المختبر يسجل مكان الشخصية المرسوم في أول 12 إطاراً على شاشة 144 هرتز، مرة كما هو ومرة بالاستيفاء، والمخرج سوف يكون كما يلي:

without interpolation x on frames 1-12: 0.0 0.0 4.0 4.0 8.0 8.0 8.0 12.0 12.0 16.0 16.0 20.0
                      moves between frames: min 0.00 max 4.00 px, frames that did not move: 8 of 13
with interpolation    x on frames 1-12: 0.0 0.0 1.0 2.7 4.3 6.0 7.7 9.3 11.0 12.7 14.3 16.0
                      moves between frames: min 0.00 max 1.67 px, frames that did not move: 1 of 13

دون الاستيفاء تقف الشخصية إطارين أو ثلاثة ثم تقفز 4 بكسل دفعة واحدة، وفي 8 إطارات من 13 لم تتحرك الصورة أصلاً، والعين تلاحظ هذا النمط غير المنتظم كاهتزاز Jitter، خصوصاً في الحركة الأفقية المستمرة وفي حركة الكاميرا. والحل أن نستخدم الباقي في المجمع، فإذا كان في الوعاء نصف خطوة، فهذا يعني أن الزمن الحقيقي الآن في منتصف المسافة بين آخر حالتين للعالم، فنرسم الشخصية في منتصف المسافة بين مكانها السابق ومكانها الحالي. والنسبة هي alpha = acc / DT، والمكان المرسوم هو prev + (cur - prev) * alpha، وهي الصيغة نفسها في مقال Fiedler. والشكل التالي يبين الفرق:

رسم بياني لمكان الشخصية المرسوم x في أول 12 إطاراً على شاشة 144 هرتز: خط أحمر على شكل درج دون استيفاء يقف ثم يقفز 4 px، وخط أخضر مستقيم تقريباً مع الاستيفاء بحركة متساوية في كل إطار، وخط رمادي متقطع للمكان الدقيق، والخط الأخضر تحته بمسافة ثابتة
القسم الرابع من المختبر: الاستيفاء يجعل الحركة متساوية، ولكنه يرسم العالم متأخراً عن مكانه الحقيقي بخطوة واحدة تقريباً.

مع الاستيفاء صارت الحركة 1.67 بكسل في كل إطار، وهي 240 بكسل في الثانية مقسومة على 144 إطاراً بالضبط، والإطار الوحيد الذي لم يتحرك هو الأول قبل أن تبدأ أول خطوة. ولكن لاحظ في الشكل أن الخط الأخضر تحت الخط الرمادي دائماً، لأن الاستيفاء يرسم بين آخر حالتين معروفتين، أي أنه يعرض الماضي القريب لا الحاضر. وتوثيق Godot عن الاستيفاء يذكر هذا صراحة، فالصورة المعروضة تقدير لمكان الجسم بين خطوة وخطوتين في الماضي، ويقول إن أغلب اللاعبين لا يلاحظون ذلك، ولكن تأخير الاستجابة قد يهم في الألعاب التي تعتمد على ردة الفعل السريعة. وهذا التأخير عند 60 خطوة في الثانية يصل إلى 16.7 مللي ثانية، فإذا كانت لعبتك من هذا النوع فارفع عدد الخطوات في الثانية بدل أن تتخلى عن الاستيفاء.

وقد يتساءل البعض: لماذا لا نتوقع المكان القادم بدل أن نرسم الماضي، أي نستخدم السرعة الحالية لنحسب أين ستكون الشخصية بعد جزء من الخطوة؟ وهذه طريقة موجودة وتسمى الاستقراء Extrapolation، وهي لا تتأخر، ولكنها تخطئ عندما يتغير شيء فجأة، فالشخصية التي تصطدم بجدار ترسم لحظة داخل الجدار قبل أن تعود، ولذلك فإن الاستيفاء هو الخيار الافتراضي في أغلب الألعاب.

دوامة الموت Spiral of Death

في الحلقة السابقة افترضنا شيئاً لم نقله، وهو أن الخطوة الواحدة تأخذ من المعالج زمناً أقل من الزمن الذي تحاكيه، فالخطوة تحاكي 16.7 مللي ثانية من زمن اللعبة، ويجب أن ينتهي حسابها في أقل من ذلك بكثير. فماذا يحدث إذا كان المشهد ثقيلاً والجهاز ضعيفاً، فأصبحت الخطوة تأخذ 20 مللي ثانية من المعالج؟ الإطار الأول ينفذ خطوة ويأخذ 20 مللي ثانية، فيضيف إلى الوعاء 20 مللي ثانية، فينفذ الإطار التالي خطوة ويبقى في الوعاء أكثر، ثم يأتي إطار ينفذ خطوتين فيأخذ 40 مللي ثانية، فيضيف 40 إلى الوعاء، فينفذ الإطار التالي ثلاث خطوات، وهكذا. وFiedler يسمي هذا دوامة الموت Spiral of Death، ويعرفه بأنه ما يحدث عندما لا تستطيع المحاكاة أن تلحق بالخطوات المطلوبة منها، فكلما حاولت أن تلحق تأخرت أكثر.

والقسم الخامس من المختبر يحاكي ذلك لمدة 20 إطاراً، مرة دون حد ومرة مع حد أقصى 8 خطوات في الإطار، والمخرج سوف يكون كما يلي:

no cap        steps per frame: 1 1 1 1 2 2 3 4 4 5 7 8 10 12 14 17 21 25 30 36 | last frame took 722 ms | game time / real time 1.00
cap 8 steps   steps per frame: 1 1 1 1 2 2 3 4 4 5 7 8 8 8 8 8 8 8 8 8 | last frame took 162 ms | game time / real time 0.88
رسم بالأعمدة لعدد خطوات المحاكاة في كل إطار لمدة 20 إطاراً: الأعمدة الحمراء دون حد تزيد من 1 إلى 36 خطوة في الإطار العشرين، والأعمدة الزرقاء مع حد 8 خطوات تتوقف عند 8 من الإطار الثاني عشر
القسم الخامس من المختبر: دون حد يزيد عدد الخطوات في كل إطار حتى تتجمد اللعبة، ومع حد 8 خطوات تبطؤ اللعبة ولا تتجمد.

في المخرج أعلاه لاحظ التالي:

  • دون حد: الخطوات في الإطار تزيد من 1 إلى 36، وآخر إطار أخذ 722 مللي ثانية، أي أن اللعبة تعرض أقل من صورتين في الثانية، وفي الإطار التالي سوف تحاول أكثر من 36 خطوة. ونسبة زمن اللعبة إلى الزمن الحقيقي ما زالت 1.00، أي أن المحاكاة تبدو في الأرقام ملحقة بالزمن، ولكن ذلك على حساب الرسم الذي توقف تقريباً، واللاعب يرى لعبة متجمدة.
  • مع حد 8 خطوات: عندما يصل الإطار إلى 8 خطوات نتوقف ونرمي الباقي في الوعاء، فيبقى الإطار عند 162 مللي ثانية ولا يزيد. والثمن أن زمن اللعبة صار أبطأ من الزمن الحقيقي، فالنسبة 0.88 في آخر الإطارات العشرين، وهي في اتجاهها إلى 0.82، أي 8 خطوات من 16.7 مللي ثانية في كل 162 مللي ثانية حقيقية، فاللاعب يرى اللعبة بحركة أبطأ قليلاً، وهذا أفضل بكثير من لعبة متجمدة.

وهذا هو بالضبط ما تفعله المحركات. ففي Godot يوجد إعداد physics/common/max_physics_steps_per_frame وقيمته الافتراضية 8، وتوثيق إعدادات المشروع يذكر أن القيمة مختارة لتمنع هبوط معدل الإطارات فجأة إلى رقم منخفض جداً عندما لا يستطيع محرك الفيزياء أن يلحق، وأن اللعبة سوف تبدو أبطأ إذا قل معدل الرسم عن 1/8 من عدد خطوات الفيزياء في الثانية، حتى لو كان الكود يستخدم delta في كل حساباته. وفي Unity توجد الخاصية Time.maximumDeltaTime، والتوثيق يذكر أنها تحد عدد مرات تنفيذ FixedUpdate في الإطار الواحد بقسمتها على طول الخطوة الثابتة، وتحد أيضاً قيمة Time.deltaTime بعد إطار بطيء جداً. أما Fiedler فيستخدم في مقاله حداً على طول الإطار نفسه، فإذا زاد عن 0.25 ثانية عامله كأنه 0.25، والنتيجة واحدة: الوعاء لا يمتلئ أكثر من حد معين مهما تأخر الإطار.

ولاحظ أن الحد يحمي اللعبة من التجمد ولا يصلح سبب البطء، فإذا كانت الخطوة تأخذ أكثر من زمنها على أجهزة اللاعبين، فإن الحل في تخفيف الفيزياء نفسها، كتقليل عدد الأجسام المتحركة، أو تبسيط أشكال التصادم، أو تقليل عدد الخطوات في الثانية إذا كانت اللعبة تحتمل ذلك.

ماذا يحدث إذا توقفت اللعبة 0.4 ثانية؟

التوقف المفاجئ يحدث أكثر مما تظن: اللاعب يسحب نافذة اللعبة، أو يعود من تبويب آخر، أو يحمل الجهاز ملفاً من القرص، أو تتوقف اللعبة عند نقطة توقف Breakpoint أثناء التطوير. والقسم السادس من المختبر يحاكي شخصية تقفز من ارتفاع 60 بكسل وتسقط على منصة رفيعة سمكها 4 بكسل عند ارتفاع 50، وأثناء القفز تتوقف اللعبة 0.4 ثانية في إطار واحد، ونشغل ذلك بثلاث حلقات، والمخرج سوف يكون كما يلي:

variable dt    fell through the platform (one step went from y=150.0 to y=-186.0)
fixed          landed on the platform at t=0.67 s | steps in the long frame: 24
fixed + clamp  landed on the platform at t=0.67 s | steps in the long frame: 15
  • الزمن المتغير: الإطار الطويل أعطى dt مقداره 0.4 ثانية، فتحركت الشخصية في خطوة واحدة من ارتفاع 150 إلى 186 تحت الصفر، أي أنها عبرت المنصة والأرض معاً. وهذا هو العبور نفسه الذي رأيناه مع الكرة، ولكن سببه هذه المرة إطار واحد طويل لا جسم سريع.
  • الخطوة الثابتة دون حد: الإطار الطويل نفذ 24 خطوة صغيرة، أي 0.4 ثانية كاملة، فهبطت الشخصية على المنصة بشكل صحيح. ولكن 24 خطوة في إطار واحد هي بداية دوامة الموت إذا كانت الخطوات ثقيلة.
  • الخطوة الثابتة مع الحد: الحد 0.25 ثانية سمح بـ 15 خطوة فقط، فخسرت اللعبة 0.15 ثانية من زمنها ولم يلاحظها أحد، وهبطت الشخصية على المنصة أيضاً.

وهذا يعني أن الحد على طول الإطار يجب أن يكون في كل حلقة، حتى في الحلقة البسيطة التي تستخدم الزمن المتغير، فإذا لم تكن تحتاج الخطوة الثابتة في لعبة صغيرة، فعلى الأقل لا تقم بتمرير dt أكبر من 0.1 أو 0.25 ثانية إلى الفيزياء، والسبب أن إطاراً واحداً طويلاً يكفي لأن تعبر الشخصية أرض المرحلة كلها. وفي المتصفح أوقف اللعبة تماماً عندما يكون التبويب مخفياً، باستخدام حدث visibilitychange، بدل أن تحاول أن تعوض الدقيقة التي غاب فيها اللاعب.

كيف تفعل المحركات ذلك؟

عندما تعمل بمحرك ألعاب فلن تكتب الحلقة بنفسك، فالمحرك يكتبها ويعطيك دوالاً يستدعيها في الأماكن الصحيحة منها، والمهم أن تعرف أي دالة تقع في أي جزء من الحلقة، لأن وضع الكود في الدالة الخطأ يعيدك إلى مشاكل الزمن المتغير.

Godot: _process و_physics_process

في Godot تكتب الكود في دالتين، وتوثيق Godot يشرحهما كما يلي: _process(delta) يستدعيها المحرك مع كل إطار يرسمه، ولذلك فإن عدد مرات استدعائها يختلف بين الأجهزة ومع الوقت، وdelta فيها هو الزمن منذ الاستدعاء السابق، فهي الخطوة المتغيرة. و_physics_process(delta) يستدعيها المحرك قبل كل خطوة فيزياء، والفيزياء تحدث بمعدل ثابت هو 60 مرة في الثانية افتراضياً، فهي الخطوة الثابتة. ويتحكم في هذا المعدل الإعداد physics/common/physics_ticks_per_second وقيمته الافتراضية 60، والحد الذي رأيناه في دوامة الموت هو max_physics_steps_per_frame وقيمته 8.

والقاعدة في Godot أن كل ما يتحرك ويصطدم يكون في _physics_process، أي حركة الشخصية بـ move_and_slide والقفز والجاذبية، وكل ما هو رسم فقط يكون في _process، كحركة الواجهة والمؤثرات التي لا تصطدم بشيء. وللاستيفاء في Godot إعداد جاهز هو physics/common/physics_interpolation، وهو معطل افتراضياً، والتوثيق يصفه بأنه يجعل المحرك يرسم الأجسام بين آخر حالتين لها لتظهر الحركة بانتظام حتى عندما لا تتطابق خطوات الفيزياء مع إطارات الرسم، وينصح بتفعيله إذا غيرت عدد الخطوات في الثانية إلى رقم ليس من مضاعفات 60. وكل هذا هو ما بنيناه بأيدينا في المختبر، ولذلك فإنك عندما تفتح إعدادات الفيزياء في Godot سوف تعرف معنى كل رقم فيها ولماذا هو موجود، وسوف نبدأ العمل الفعلي مع Godot في مقال أول لعبة ثنائية الأبعاد.

Unity: Update وFixedUpdate

وفي Unity الفكرة نفسها بأسماء أخرى: الدالة Update تستدعى مع كل إطار ومعها Time.deltaTime، والدالة FixedUpdate تستدعى بخطوات ثابتة طولها Time.fixedDeltaTime، وهي الفترة التي تنفذ فيها الفيزياء وكل التحديثات ذات المعدل الثابت حسب التوثيق، وmaximumDeltaTime هو الحد الذي يمنع دوامة الموت. والقاعدة نفسها: ما يتعامل مع الفيزياء يكون في FixedUpdate، وقراءة المدخلات اللحظية كضغطة زر واحدة تكون في Update، لأن FixedUpdate قد لا تستدعى في إطار معين أصلاً كما رأينا في الشكل الثالث، فتضيع الضغطة.

الويب: requestAnimationFrame مع المجمع

وإذا كتبت لعبة للمتصفح دون محرك، فإن الحلقة الصحيحة هي حلقة الخطوة الثابتة التي بنيناها، والذي يحركها هو requestAnimationFrame، والزمن يؤخذ من المعامل الذي يمرره المتصفح للدالة، وكل ذلك في بضعة أسطر:

const DT = 1 / 60, MAX_FRAME = 0.25;
let acc = 0, last = null, prev = makeWorld(), cur = makeWorld();
function frame(t) {
  if (last !== null) acc += Math.min((t - last) / 1000, MAX_FRAME);
  last = t;
  while (acc >= DT) { prev = copy(cur); step(cur, DT); acc -= DT; }
  draw(prev, cur, acc / DT);    // interpolate between the last two states
  requestAnimationFrame(frame);
}
requestAnimationFrame(frame);

في الكود أعلاه لاحظ التالي: الزمن من المعامل t لا من Date.now()، والحد MAX_FRAME يحمي من التبويب الذي عاد بعد غياب، والدالة draw تأخذ الحالتين ونسبة الاستيفاء. وهذه الحلقة تعمل على شاشة 60 و144 هرتز بالسرعة نفسها والفيزياء نفسها، والفرق الوحيد أن الشاشة الأسرع تعرض صورة أنعم، وهذا هو الهدف من البداية. وإذا أردت أن تعرف ما يحدث في المتصفح بعد أن ترسم، فقد شرحنا مراحل الرسم في مقال كيف يرسم المتصفح صفحتك.

الأخطاء التي تتكرر

  • التحريك بمقدار ثابت لكل إطار: يجعل اللعبة أسرع على الجهاز الأسرع، وتكتشفه أول مرة عند لاعب لديه شاشة 144 هرتز.
  • الفيزياء في الخطوة المتغيرة: المسافة تصح ولكن القفز والتصادم يختلفان بين الأجهزة، وتصمم المراحل على جهازك فلا يستطيع لاعب على جهاز أبطأ أن يعبر حاجزاً عبرته أنت.
  • الظن أن الخطوة الثابتة تمنع العبور: هي تجعله ثابتاً لا غائباً، والجسم الذي يقطع في الخطوة أكثر من سمك الجدار يحتاج فحصاً ممتداً.
  • نسيان الحد على طول الإطار: إطار واحد طويل بعد تبويب في الخلفية أو نقطة توقف يكفي لأن تعبر الشخصية الأرض، أو لأن تبدأ دوامة الموت.
  • قراءة ضغطة زر واحدة في الخطوة الثابتة: قد لا تنفذ الخطوة في الإطار الذي ضغط فيه اللاعب، فتضيع الضغطة. اقرأ المدخلات في كل إطار واحفظها حتى تستهلكها الخطوة التالية.
  • الاعتماد على setTimeout كمؤقت للحلقة: رأينا أن 16 مللي ثانية صارت 29 في المتوسط، فاستخدم ما يربطك بتحديث الشاشة، أو احسب الزمن الحقيقي في كل إطار ولا تفترضه.
  • رسم الحالة الأخيرة دون استيفاء على شاشة سريعة: الفيزياء صحيحة والصورة تهتز، واللاعب لا يفرق بين الاثنين، فهو يرى لعبة تهتز.

أي حلقة تختار؟

الطريقةمتى تناسبكنقاط القوةنقاط الضعف
مقدار ثابت لكل إطارجهاز واحد بمعدل إطارات مضمون، أو حركة لا يهم فيها الزمنأبسط كود ممكنالسرعة تتبع الجهاز وكمية الرسم
الزمن المتغير Delta Timeلعبة دون فيزياء حقيقية: واجهات ومؤثرات وحركة بسرعة ثابتةبسيط، والمسافة صحيحة على كل الأجهزةالقفز والتصادم يختلفان باختلاف الجهاز، والعبور مع الإطارات الطويلة
خطوة ثابتة مع المجمعأي لعبة فيها فيزياء أو تصادم أو إعادة عرض أو لعب جماعينتائج واحدة على كل الأجهزة، وقابلة للتكراركود أكثر، وتحتاج حداً ضد دوامة الموت
خطوة ثابتة مع الاستيفاءنفس السابق على شاشات بمعدلات تحديث مختلفةفيزياء ثابتة وصورة منتظمةالصورة متأخرة خطوة واحدة عن العالم

وقبل أن تعتبر الحلقة جاهزة، تأكد من التالي:

  • كل حركة في الكود مضروبة في زمن، لا في عدد إطارات.
  • الفيزياء والتصادم في الخطوة الثابتة، والرسم والمؤثرات في الإطار.
  • على طول الإطار حد أقصى، وعلى عدد الخطوات في الإطار حد أقصى.
  • الأجسام السريعة تستخدم فحصاً ممتداً، أو الجدران أسمك من أقصى مسافة في خطوة.
  • المدخلات تقرأ في كل إطار ولا تضيع إذا لم تنفذ خطوة.
  • جربت اللعبة بمعدل إطارات منخفض عمداً، لا على جهازك السريع فقط.

تطبيق عملي

  1. غير DT في loop.mjs إلى 1 / 120 وشغل المختبر: ماذا حدث لارتفاع القفز في القسم الثالث، وهل اصطدمت الكرة بالجدار؟ ثم احسب كم بكسل تقطع الكرة في الخطوة الواحدة الآن.
  2. في القسم الخامس غير STEP_COST إلى 0.012، أي أن الخطوة أسرع من زمنها: هل ما زالت الدوامة تحدث؟ ولماذا لم يعد للحد أي أثر؟
  3. في frames.mjs غير setTimeout(tick, 16) إلى setTimeout(tick, 1) وقارن الأرقام، ثم شغل المختبر وجهازك مشغول ببرنامج ثقيل آخر.

الخلاصة Summary

  • اللعبة حلقة تدور باستمرار: تقرأ المدخلات، وتحدث العالم، وترسمه، وكل دورة إطار له ميزانية من الزمن، 16.7 مللي ثانية عند 60 إطاراً في الثانية.
  • التحريك بمقدار ثابت لكل إطار جعل الشخصية في المختبر تقطع 576 بكسل بدل 240 على شاشة 144 هرتز.
  • الزمن المتغير أصلح المسافة، ولكن ارتفاع القفز صار من 90 إلى 97.92 بكسل حسب الجهاز، والكرة عبرت الجدار في الإطارات الطويلة.
  • الخطوة الثابتة مع المجمع أعطت ارتفاعاً واحداً 95.00 على كل المعدلات، وجعلت العبور ثابتاً يمكن إصلاحه بالفحص الممتد.
  • الاستيفاء جعل الحركة على شاشة 144 هرتز 1.67 بكسل في كل إطار بدل الوقوف ثم التقدم 4 بكسل، مقابل تأخير خطوة واحدة.
  • دون حد على الخطوات وصلت الدوامة إلى 36 خطوة في الإطار، ومع حد 8 خطوات، وهو افتراضي Godot، أبطأت اللعبة ولم تتجمد.

وفي المقالات القادمة بإذن الله نكمل أساسيات هذه المرحلة: الرياضيات التي تحتاجها لتحرك الأجسام وتفحص التصادم، ومحركات الألعاب وكيف تختار بينها:

دليلرياضيات الألعاب: المتجهات Vectors والحركة والتصادمالمتجهات والحركة وحاصل الضرب النقطي واختبارات التصادم والارتداد والنفق، بلعبة صغيرة ومختبر Python يصنع الأخطاء الشائعة ثم يصلحها.دليلمحركات الألعاب: Godot وUnity وUnreal وتراخيصهاما الذي يعطيك محرك الألعاب حتى لا تكتبه بنفسك، وكيف تعمل حلقة اللعبة في مختبر Godot حقيقي، وماذا تدفع لكل محرك ومتى.

سجل التحديثات Changelog

  • نوفمبر 2026: كتابة المقال، وتشغيل المختبرين على Node 22.14 وChrome دون واجهة.
نشرة عرب رووت | ArabRoot

معرفة تستحق مكاناً في بريدك.

مقالات مختارة وأدوات مفيدة وأفكار لمشروعك القادم، في رسالة واحدة كل أسبوع.

يمكنك إلغاء الاشتراك متى شئت. الخصوصية

تم استلام طلبك. افتح بريدك واضغط رابط التأكيد لإتمام الاشتراك.