> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# لماذا كانت الشخصيات ترمش؟ حدود رسوميات NES
- URL: https://arabroot.io/articles/لماذا-كانت-الشخصيات-ترمش-حدود-رسوميات-nes/
- Published: 2026-11-20T10:24:42.000Z
- Updated: 2026-11-20T11:25:22.000Z
- Description: نشرح لماذا لا يرسم جهاز NES أكثر من ثماني شخصيات في السطر، ونكتب ROM صغيراً يزدحم عمداً ونقيس في FCEUX أي طريقة رمش توزع الاختفاء بعدل.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, تطوير الألعاب

إذا لعبت على جهاز NES أو على نسخته اليابانية Famicom في طفولتك، فغالباً تتذكر هذا المشهد: يزدحم المستوى بالأعداء والطلقات، وفجأة تبدأ بعض الشخصيات بالرمش، تظهر في إطار وتختفي في الذي يليه، وكأن الجهاز يتعب من كثرة ما على الشاشة. وكثير منا فسر ذلك وقتها بأن «الجهاز بطيء»، ولكن الحقيقة أن المعالج لم يكن هو المشكلة في أغلب هذه الحالات، وإنما قاعدة صارمة داخل شريحة الرسوم Graphics Chip نفسها: في السطر الأفقي Scanline الواحد من الشاشة لا ترسم الشريحة أكثر من ثماني شخصيات متحركة Sprites، ومهما فعل المبرمج فإن التاسعة لا تظهر في ذلك السطر. والرمش الذي تتذكره لم يكن عطلاً، وإنما كان حلاً اختاره المبرمجون عن قصد ليتعاملوا مع هذه القاعدة.

في [مقال الرسم مع شعاع الشاشة](https://arabroot.io/articles/atari-2600-%D8%A7%D9%84%D8%B1%D8%B3%D9%85-%D9%85%D8%B9-%D8%B4%D8%B9%D8%A7%D8%B9-%D8%A7%D9%84%D8%B4%D8%A7%D8%B4%D8%A9-racing-the-beam/) رأينا جهازاً لا يملك ذاكرة للصورة أصلاً، ويكتب فيه المبرمج كل سطر بيده. وجهاز NES الذي صدر بعده بست سنوات خطا خطوة كبيرة، فصارت فيه شريحة رسوم مستقلة ترسم الخلفية والشخصيات وحدها من جداول في الذاكرة، ولكن هذه الشريحة جاءت بحدودها هي، وأشهرها حد الشخصيات الثماني في السطر. وفي هذا المقال لن نكتفي بوصف الحد، وإنما سوف نكتب برنامج NES صغيراً من صنعنا بلغة التجميع Assembly، ونشغله في محاكي Emulator مفتوح المصدر Open Source دون شاشة، ونقيس إطاراً بإطار Frame by Frame أي شخصية ظهرت وأيها اختفت، ثم نجرب أربع طرق للرمش ونرى أيها عادلة وأيها لا.

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

- ماذا كان داخل جهاز NES، ولماذا صممت رسومه بهذه الحدود.
- معالج الرسوم PPU، والمربعات Tiles، وذاكرة الشخصيات OAM، وما يحمله كل بايت فيها.
- لماذا ثماني شخصيات في السطر بالذات، وكيف يختار المعالج الثماني، وما قصة علامة الفيض Sprite Overflow وخطئها.
- لماذا ترمش الشخصيات، وكيف يصنع المبرمج الرمش بتغيير الترتيب Sprite Cycling.
- مختبر يعمل: ROM من صنعنا بأداة ca65، وتشغيله في FCEUX دون شاشة، ولقطات حقيقية، وقياس 580 إطاراً لكل طريقة.
- ماذا يحدث إذا ألغينا الحد في المحاكي، ولماذا يبقى أفضل حل هو التصميم نفسه.

وهذا المقال جزء من مرحلة «حيل الألعاب الكلاسيكية»، وفيها نشرح كل حيلة ثم نعيد بناءها بكود يعمل:

[![](https://arabroot.io/content/images/2026/11/light-gun-how-it-works-cover-cover.webp)دليلكيف عرف المسدس الضوئي Light Gun أين أصبت البطة؟نشرح كيف عرف المسدس الضوئي هدفك على شاشة CRT بإطار أسود ومربع أبيض لكل هدف، ونعيد بناء الحيلة في المتصفح ونقيس لماذا تفشل على شاشات اليوم.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%B9%D8%B1%D9%81-%D8%A7%D9%84%D9%85%D8%B3%D8%AF%D8%B3-%D8%A7%D9%84%D8%B6%D9%88%D8%A6%D9%8A-light-gun-%D8%A7%D9%8A%D9%86-%D8%A7%D8%B5%D8%A8%D8%AA-%D8%A7%D9%84%D8%A8%D8%B7%D8%A9/)[![](https://arabroot.io/content/images/2026/11/racing-the-beam-cover-cover.webp)دليلAtari 2600: الرسم مع شعاع الشاشة Racing the Beamكيف رسمت ألعاب Atari 2600 صورها دون ذاكرة إطار: نكتب برنامج 6502 صغيراً ونعد دوراته في Stella لنرى ماذا يحدث حين يتأخر الكود عن الشعاع.](https://arabroot.io/articles/atari-2600-%D8%A7%D9%84%D8%B1%D8%B3%D9%85-%D9%85%D8%B9-%D8%B4%D8%B9%D8%A7%D8%B9-%D8%A7%D9%84%D8%B4%D8%A7%D8%B4%D8%A9-racing-the-beam/)[![](https://arabroot.io/content/images/2026/11/pacman-ghost-ai-cover-cover.webp)دليلكيف تفكر أشباح Pac-Man؟ ذكاء بقواعد بسيطةنشرح القواعد الأربع التي تختار بها أشباح Pac-Man أهدافها وجدول موجاتها وخطأ الفيض الشهير، ثم نبنيها على متاهتنا ونقيس أثر كل قاعدة في 392 لعبة.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%AA%D9%81%D9%83%D8%B1-%D8%A7%D8%B4%D8%A8%D8%A7%D8%AD-pac-man-%D8%B0%D9%83%D8%A7%D8%A1-%D8%A8%D9%82%D9%88%D8%A7%D8%B9%D8%AF-%D8%A8%D8%B3%D9%8A%D8%B7%D8%A9/)[![](https://arabroot.io/content/images/2026/11/doom-bsp-cover-cover.webp)دليلكيف رسمت Doom عالماً ثلاثي الأبعاد بشجرة BSP؟نشرح كيف رتبت Doom جدرانها بشجرة BSP ورسمتها من القريب إلى البعيد، ونبني الشجرة والمرسم بـ Python ونعد ما يفحصه كل أسلوب على خرائط حتى 1,225 جداراً.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%B1%D8%B3%D9%85%D8%AA-doom-%D8%B9%D8%A7%D9%84%D9%85%D8%A7-%D8%AB%D9%84%D8%A7%D8%AB%D9%8A-%D8%A7%D9%84%D8%A7%D8%A8%D8%B9%D8%A7%D8%AF-%D8%A8%D8%B4%D8%AC%D8%B1%D8%A9-bsp/)[![](https://arabroot.io/content/images/2026/11/fast-inverse-sqrt-cover-cover.webp)دليلالجذر التربيعي العكسي السريع في Quake IIIنفك حيلة 0x5f3759df في Quake III ونرى لماذا تعمل، ثم نقيس خطأها على كل عدد float موجب ونبحث عن أفضل ثابت ونقارن سرعتها بأمر rsqrtss.](https://arabroot.io/articles/%D8%A7%D9%84%D8%AC%D8%B0%D8%B1-%D8%A7%D9%84%D8%AA%D8%B1%D8%A8%D9%8A%D8%B9%D9%8A-%D8%A7%D9%84%D8%B9%D9%83%D8%B3%D9%8A-%D8%A7%D9%84%D8%B3%D8%B1%D9%8A%D8%B9-%D9%81%D9%8A-quake-iii-0x5f3759df/)

## ماذا كان داخل جهاز NES؟

صدر الجهاز في اليابان باسم Family Computer عام 1983، ثم في أمريكا الشمالية باسم Nintendo Entertainment System عام 1985، كما تذكر [صفحة الجهاز في Wikipedia](https://en.wikipedia.org/wiki/Nintendo%5FEntertainment%5FSystem?ref=arabroot.io). وكان الهدف كما في كل أجهزة تلك الفترة أن يباع بسعر يقدر عليه بيت عادي، ولذلك فإن كل رقم في هذا المقال هو في الأصل قرار تكلفة: كم ذاكرة نضع، وكم شيئاً ترسمه الشريحة، وكم سلكاً يخرج من كل شريحة.

![جهاز NES رمادي مستطيل بغطاء أمامي يفتح لإدخال الخرطوشة، وبجانبه يد تحكم مستطيلة فيها أسهم الاتجاهات وزرا Select وStart وزران أحمران A وB](https://arabroot.io/content/images/2026/11/sprite-flicker-limits-nes-console-photo.webp)

جهاز NES مع يد التحكم Controller، والخرطوشة تدخل من الغطاء الأمامي. الصورة: Evan-Amos، ملكية عامة Public Domain، المصدر: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:NES-Console-Set.jpg?ref=arabroot.io) (تم تصغيرها).

وداخل الجهاز شريحتان رئيسيتان يهمنا أمرهما. الأولى هي المعالج CPU من صنع Ricoh، وهو نسخة من معالج 6502 الشهير نفسه الذي رأيناه في Atari 2600، يعمل بتردد يقارب 1.79 ميغاهرتز MHz في النسخة الأمريكية، ومعه ذاكرة عشوائية RAM حجمها 2 كيلوبايت فقط. والثانية هي معالج الرسوم PPU، اختصاراً لـ Picture Processing Unit، وهي شريحة صممت خصيصاً للجهاز تحمل الرقم 2C02 في نسخة NTSC، ومعها 2 كيلوبايت أخرى من ذاكرة الفيديو VRAM. ويوثق ويكي NESdev، وهو المرجع الذي يعتمد عليه مطورو ومحاكو هذا الجهاز منذ سنوات، كل تفصيل في هذه الشريحة حتى مستوى الدورة الواحدة، ومنه أخذنا الأرقام في هذا المقال.

![اللوحة الأم لجهاز NES الأصلي: لوحة خضراء عليها شريحتان كبيرتان طويلتان هما المعالج ومعالج الرسوم، وشرائح ذاكرة أصغر، وفي الخلف فتحة الخرطوشة الطويلة](https://arabroot.io/content/images/2026/11/sprite-flicker-limits-nes-board-photo.webp)

اللوحة الأم Motherboard لجهاز NES الأصلي، وعليها المعالج ومعالج الرسوم PPU وذاكرتا 2 كيلوبايت. الصورة: Evan-Amos، ملكية عامة Public Domain، المصدر: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Nintendo-NES-Mk1-Motherboard-Top.jpg?ref=arabroot.io) (تم تصغيرها).

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

## معالج الرسوم PPU: الخلفية والشخصيات

يرسم معالج الرسوم طبقتين فوق بعضهما. الطبقة الأولى هي الخلفية Background، وهي شبكة من المربعات بحجم 8 في 8 بكسل تغطي الشاشة كلها، 32 مربعاً في العرض و30 في الارتفاع، أي 256 في 240 بكسل، وتحفظ أرقام هذه المربعات في جداول تسمى Nametables داخل ذاكرة الفيديو. والطبقة الثانية هي الشخصيات المتحركة Sprites، وهي مربعات مستقلة يستطيع المبرمج أن يضعها في أي بكسل من الشاشة دون التقيد بالشبكة، وهي التي تستخدم للاعب والأعداء والطلقات وكل ما يتحرك بحرية.

أما رسم المربعات نفسه، أي البكسلات التي تكون شكل الحرف أو قدم البطل، فلا يوجد في الجهاز أصلاً، وإنما في الخرطوشة Cartridge، في ذاكرة تسمى CHR ROM حجمها في أبسط الخرطوشات 8 كيلوبايت. وكل مربع فيها 16 بايتاً: كل بكسل له بتان فقط، أي أن المربع الواحد لا يعرف إلا أربع قيم من 0 إلى 3، والقيمة 0 تعني شفاف في الشخصيات. أما الألوان الحقيقية فتأتي من لوحات الألوان Palettes، وهي 32 بايتاً داخل معالج الرسوم: أربع لوحات للخلفية وأربع للشخصيات، في كل لوحة ثلاثة ألوان إضافة إلى الشفاف، كما توضح صفحة ألوان PPU. والشكل التالي يجمع هذه الأجزاء:

![مخطط بثلاثة أجزاء: الخرطوشة وفيها ذاكرة الكود PRG ROM وذاكرة الرسوم CHR ROM، والمعالج CPU مع ذاكرته 2 كيلوبايت التي فيها نسخة جدول الشخصيات في الصفحة $0200، ومعالج الرسوم PPU وفيه ذاكرة الشخصيات OAM بحجم 256 بايت وOAM الثانوية 32 بايت والألوان 32 بايت، وسهم برتقالي من ذاكرة المعالج إلى OAM مكتوب عليه نسخ DMA في 513 دورة، وتحت معالج الرسوم ذاكرة الفيديو 2 كيلوبايت وتلفاز](https://arabroot.io/content/images/2026/11/sprite-flicker-limits-01-inside.webp)

الرسوم تأتي من الخرطوشة، ومكان كل شخصية يأتي من ذاكرة OAM داخل معالج الرسوم، والمعالج يجهز الجداول ولا يرسم بكسلاً واحداً.

ولاحظ في هذا التصميم كم هي صغيرة الأرقام: الشاشة كلها 61,440 بكسلاً، ولو خصصنا لكل بكسل بايتاً لاحتجنا 60 كيلوبايت، أي ثلاثين ضعف ذاكرة الفيديو كلها. والحل كان أن تحفظ الشاشة كمراجع لمربعات بدل البكسلات، فرقم مربع واحد بايت واحد يغطي 64 بكسلاً، والخلفية كلها 960 بايتاً. وهذه الفكرة نفسها، أي ضغط الصورة إلى مراجع لقطع متكررة، هي التي جعلت الشخصيات أيضاً تعامل كجدول صغير لا كصور.

## ذاكرة الشخصيات OAM: جدول من 64 سطراً

كل الشخصيات التي يمكن أن تظهر على الشاشة في وقت واحد موصوفة في جدول واحد داخل معالج الرسوم يسمى OAM، اختصاراً لـ Object Attribute Memory، وحجمه 256 بايتاً، وفيه 64 سجلاً بالضبط، لكل شخصية 4 بايتات كما توضح صفحة OAM في NESdev. وبالتالي فإن 64 هو الحد الأول: لا توجد شخصية رقم 65، وإذا أردت أكثر من ذلك فلا بد أن تعيد استخدام السجلات نفسها لأشياء مختلفة.

![أربعة مستطيلات للبايتات الأربعة: البايت 0 الموضع الرأسي Y ويظهر في السطر Y + 1، والبايت 1 رقم المربع Tile من رسوم الخرطوشة، والبايت 2 الخصائص Attributes، والبايت 3 الموضع الأفقي X من 0 إلى 255، وتحتها بتات البايت 2: البت 7 قلب رأسي، و6 قلب أفقي، و5 خلف الخلفية، و4 و3 و2 غير مستخدمة، و1 و0 اللوحة، وتحتها شريط من 64 خانة 29 منها زرقاء](https://arabroot.io/content/images/2026/11/sprite-flicker-limits-02-oam.webp)

كل شخصية 4 بايتات، والجدول 64 سجلاً، وترتيب السجلات هو الأولوية: السجل 0 أولاً.

والبايتات الأربعة لكل سجل هي:

- **البايت 0، الموضع الرأسي Y:** رقم السطر الذي تبدأ منه الشخصية، مع ملاحظة غريبة توثقها NESdev: الشخصية ترسم متأخرة سطراً واحداً، فإذا كتبت 47 ظهرت من السطر 48\. ولإخفاء شخصية لا يوجد بت للإخفاء، وإنما تضعها تحت الشاشة بقيمة من $EF إلى $FF، وهذا ما سوف نفعله مع السجلات التي لا نحتاجها.
- **البايت 1، رقم المربع:** أي مربع من رسوم الخرطوشة يرسم.
- **البايت 2، الخصائص Attributes:** البتان 0 و1 يختاران واحدة من لوحات الشخصيات الأربع، والبت 5 يضع الشخصية خلف الخلفية، والبتان 6 و7 يقلبانها أفقياً أو رأسياً، أي أن رسماً واحداً لشخصية تمشي يميناً يكفي لتمشي يساراً.
- **البايت 3، الموضع الأفقي X:** من 0 إلى 255.

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

### كيف يصل الجدول إلى OAM؟ النسخ المباشر DMA

لا يكتب المعالج عادة في OAM بايتاً بايتاً، لأن الكتابة في ذاكرة معالج الرسوم آمنة فقط في فترة الإطفاء الرأسي Vertical Blank، أي الفترة القصيرة بعد أن ينتهي الشعاع من آخر سطر وقبل أن يبدأ الإطار التالي، وقد شرحنا هذه الفترات في [مقال كيف تعمل الشاشة من الداخل](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%AA%D8%B9%D9%85%D9%84-%D8%A7%D9%84%D8%B4%D8%A7%D8%B4%D8%A9-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/). والطريقة المعتادة أن يجهز البرنامج نسخة كاملة من الجدول في ذاكرة المعالج، في صفحة من 256 بايتاً تكون غالباً الصفحة $0200، ثم يكتب رقم الصفحة في المسجل $4014، فيتوقف المعالج وتنسخ الدوائر الـ 256 بايتاً كلها إلى OAM في 513 دورة معالج أو 514، كما تذكر صفحة مسجلات PPU. وهذا النسخ يسمى DMA، اختصاراً لـ Direct Memory Access، وهو أسرع بكثير من أن يكتب المعالج كل بايت بنفسه.

وتضيف NESdev تفصيلاً مهماً يفسر لماذا تنسخ الألعاب الجدول كله في كل إطار حتى لو لم يتغير: ذاكرة OAM من نوع ديناميكي تحتاج إلى تحديث مستمر Refresh، وهي تتحدث أثناء الرسم، ولكن إذا توقف الرسم فترة أطول من الإطفاء الرأسي فإن محتواها يبدأ بالتلف Decay في أجهزة NTSC. ولذلك فإن القاعدة العملية هي: جهز الجدول في الذاكرة، وانسخه بـ DMA في بداية كل إطفاء رأسي، ولا تعتمد على أن ما في OAM سوف يبقى.

## لماذا ثماني شخصيات في السطر بالذات؟

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

1. **أثناء رسم السطر الحالي:** في النقاط Dots من 65 إلى 256 من كل سطر، يمر المعالج على السجلات الـ 64 بالترتيب، ويختار الشخصيات التي تغطي السطر التالي، وينسخها إلى ذاكرة صغيرة ثانية تسمى OAM الثانوية Secondary OAM، حجمها 32 بايتاً فقط، أي 8 سجلات.
2. **بعد نهاية الجزء المرئي من السطر:** في النقاط من 257 إلى 320، يجلب رسوم هذه الشخصيات الثماني من الخرطوشة، 8 نقاط لكل شخصية، ويحملها في ثماني وحدات إخراج داخلية، ثم يرسمها في السطر التالي.

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

![ثلاثة صفوف: الأول تسعة سجلات في OAM مرتبة من #0 إلى #8 تحمل الشخصيات 3 و8 و1 و6 و2 و9 و4 و7 و5 والأخير مشطوب بالأحمر، والثاني ثماني خانات في OAM الثانوية وخانة تاسعة متقطعة حمراء فيها 5 ومكتوب لا مكان، والثالث شاشة سوداء فيها الشخصيات من 1 إلى 9 والشخصية 5 مكانها فارغ متقطع، وتحتها شرح علامة الفيض](https://arabroot.io/content/images/2026/11/sprite-flicker-limits-03-evaluation.webp)

من يختفي يحدده ترتيب الجدول لا مكان الشخصية على الشاشة: هنا الخامسة في المنتصف هي التي تختفي لأنها في السجل الأخير.

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

### علامة الفيض Sprite Overflow وخطؤها المشهور

بعد أن يجد المعالج ثماني شخصيات يكمل البحث عن تاسعة، فإذا وجدها رفع علامة الفيض، وهي البت 5 في المسجل PPUSTATUS، وتبقى مرفوعة حتى بداية الإطار التالي. والفكرة أن يعرف البرنامج أن هناك شخصيات ضاعت فيتصرف، ولكن صفحة تقييم الشخصيات توثق أن هذا البحث فيه خطأ في العتاد Hardware Bug: بعد السجل التاسع يقرأ المعالج البايتات قطرياً، فيعامل بايت الخصائص أو الموضع الأفقي لشخصية أخرى كأنه موضع رأسي، والنتيجة أن العلامة قد ترتفع دون فيض حقيقي، وقد لا ترتفع مع فيض حقيقي. ولذلك لم تعتمد الألعاب على هذه العلامة لاكتشاف الفيض في الغالب، وإنما حسب المبرمج بنفسه كم شخصية على كل سطر، أو صمم اللعبة بحيث لا يحتاج إلى أن يعرف.

### وماذا عن Sprite 0 Hit؟

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

## لماذا ترمش الشخصيات؟ الدوران Sprite Cycling

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

أي أن الرمش هو المقايضة Trade-off: بدل أن تخسر شخصية واحدة بالكامل، توزع الخسارة على كل الشخصيات في السطر المزدحم، فتصبح كل واحدة منها شفافة جزئياً في عين اللاعب. وشاشات CRT ساعدت قليلاً، لأن الفسفور يبقى مضيئاً لحظة بعد مرور الشعاع، والعين تحتفظ بالصورة جزءاً من الثانية، كما شرحنا في [مقال المسدس الضوئي](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%B9%D8%B1%D9%81-%D8%A7%D9%84%D9%85%D8%B3%D8%AF%D8%B3-%D8%A7%D9%84%D8%B6%D9%88%D8%A6%D9%8A-light-gun-%D8%A7%D9%8A%D9%86-%D8%A7%D8%B5%D8%A8%D8%AA-%D8%A7%D9%84%D8%A8%D8%B7%D8%A9/). ولكن السؤال الذي لا تجيب عنه الفكرة وحدها هو: كيف تغير الترتيب؟ فهناك طرق كثيرة، وليست كلها عادلة، وهذا ما سوف نقيسه الآن.

## المختبر: ROM من صنعنا يزدحم عمداً

الآن سوف نكتب برنامجاً حقيقياً لجهاز NES. والبرنامج من صنعنا بالكامل، فلا ننسخ أي لعبة ولا أي رسومات منها، حتى المربعات نرسمها بسكربت Python صغير. والفكرة بسيطة: ثلاثة صفوف أفقية من الشخصيات المرقمة، في الصف الأول 8 شخصيات، وفي الثاني 9، وفي الثالث 12، أي 29 شخصية في الجدول. والصف الأول هو المجموعة الضابطة Control، فيجب أن يظهر كاملاً دائماً، والصفان الآخران يتجاوزان الحد بشخصية وبأربع. ثم نصنع من الكود نفسه ست نسخ تختلف فقط في ترتيب كتابة الشخصيات في الجدول، ونقيس في كل نسخة أي شخصية ظهرت في كل إطار.

### الأدوات: ca65 وFCEUX داخل Container

نحتاج ثلاثة أشياء. الأول مجمع Assembler لمعالج 6502 يخرج ملف NES، واخترنا ca65 مع الرابط ld65 من حزمة [cc65](https://cc65.github.io/doc/ca65.html?ref=arabroot.io) بالإصدار 2.19 من حزم [Debian 13](https://packages.debian.org/trixie/cc65?ref=arabroot.io). والثاني محاكي Emulator يمكن التحكم فيه من سكربت، واخترنا [FCEUX](https://github.com/TASVideos/fceux?ref=arabroot.io) وهو محاكي مفتوح المصدر يستخدمه كثير من المطورين، بالإصدار 2.6.5 من [حزم Debian 13](https://packages.debian.org/trixie/fceux?ref=arabroot.io)، وميزته هنا أنه يشغل سكربتات Lua في كل إطار، ومن خلالها نقرأ بكسلات الشاشة والذاكرة ونحفظ اللقطات، كما في [قائمة دوال Lua في FCEUX](https://fceux.com/web/help/LuaFunctionsList.html?ref=arabroot.io). والثالث Xvfb، أي شاشة X وهمية في الذاكرة، لأن FCEUX برنامج بواجهة رسومية ولا يعمل دون شاشة. وقد شرحنا في [مقال المحاكاة Emulation](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D8%AD%D8%A7%D9%83%D8%A7%D8%A9-emulation-%D9%88%D8%A7%D9%84%D8%AA%D8%B1%D8%AC%D9%85%D8%A9-%D8%A7%D9%84%D8%AB%D9%86%D8%A7%D8%A6%D9%8A%D8%A9-qemu-%D9%88-rosetta-2/) كيف يقلد المحاكي معالجاً آخر، وFCEUX يقلد معالج الرسوم أيضاً، بما في ذلك حد الشخصيات الثماني، وهذا ما يجعل التجربة ممكنة.

وكل ذلك في Docker Image واحدة، وهذا هو الـ Dockerfile:

```dockerfile
# Lab image for sprite-flicker-limits: cc65 2.19 (ca65 assembler + ld65 linker) to build our own NES ROM,
# FCEUX 2.6.5 to run it, Xvfb so FCEUX runs without a screen; FCEUX's Lua engine saves the frames.
FROM debian:13-slim
RUN apt-get update && apt-get install -y --no-install-recommends cc65 fceux xvfb xauth python3 \
 && rm -rf /var/lib/apt/lists/*
WORKDIR /lab
```

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

- الحزمتان cc65 وfceux موجودتان في Debian 13 مباشرة، فلا نحتاج إلى بناء أي شيء من الكود المصدري Source Code.
- FCEUX في Debian مبني بواجهة Qt، ولذلك يسحب معه مكتبات كثيرة، والـ Image كلها كانت 673 ميغابايت، وهذا هو الثمن الوحيد لمحاكي بواجهة رسومية داخل Container.
- python3 نحتاجه لتوليد ملف الرسوم قبل التجميع.

### الرسوم: مربعات نرسمها بأنفسنا

قبل الكود نحتاج ملف رسوم CHR بحجم 8 كيلوبايت. والسكربت التالي يرسم فيه 12 مربعاً للشخصيات، كل واحد كتلة ملونة فيها رقم من 1 إلى 9 أو حرف من A إلى C، و10 أرقام للخلفية نكتب بها عدد الشخصيات بجانب كل صف:

```python
# make_chr.py: builds tiles.chr (8 KB of NES pattern data) for the ArabRoot sprite-flicker lab.
# All tiles are drawn here by hand; nothing comes from a game.
#   tile 0       : blank
#   tiles 1..12  : sprite tiles, a full 8x8 block (colour 1) with a glyph 1-9, A, B, C (colour 3)
#   tiles $30-$39: plain digits 0-9 (colour 1) for the row labels on the background
GLYPHS = {
    '0': ["01110", "10001", "10011", "10101", "11001", "10001", "01110"],
    '1': ["00100", "01100", "00100", "00100", "00100", "00100", "01110"],
    '2': ["01110", "10001", "00001", "00110", "01000", "10000", "11111"],
    '3': ["11110", "00001", "00001", "01110", "00001", "00001", "11110"],
    '4': ["00010", "00110", "01010", "10010", "11111", "00010", "00010"],
    '5': ["11111", "10000", "11110", "00001", "00001", "10001", "01110"],
    '6': ["00110", "01000", "10000", "11110", "10001", "10001", "01110"],
    '7': ["11111", "00001", "00010", "00100", "01000", "01000", "01000"],
    '8': ["01110", "10001", "10001", "01110", "10001", "10001", "01110"],
    '9': ["01110", "10001", "10001", "01111", "00001", "00010", "01100"],
    'A': ["01110", "10001", "10001", "11111", "10001", "10001", "10001"],
    'B': ["11110", "10001", "10001", "11110", "10001", "10001", "11110"],
    'C': ["01110", "10001", "10000", "10000", "10000", "10001", "01110"],
}

def tile(pixels):
    """pixels: 8 rows of 8 values 0..3 -> 16 bytes (plane 0, then plane 1)."""
    p0 = [sum(((v & 1) << (7 - x)) for x, v in enumerate(row)) for row in pixels]
    p1 = [sum((((v >> 1) & 1) << (7 - x)) for x, v in enumerate(row)) for row in pixels]
    return bytes(p0 + p1)

def glyph_pixels(ch, fg, bg):
    rows = [[bg] * 8 for _ in range(8)]
    for y, line in enumerate(GLYPHS[ch]):
        for x, c in enumerate(line):
            if c == '1':
                rows[y][x + 2] = fg      # 5 px wide glyph placed at columns 2..6, rows 0..6
    return rows

chr_data = bytearray(8192)
for i, ch in enumerate("123456789ABC", start=1):
    chr_data[i * 16:(i + 1) * 16] = tile(glyph_pixels(ch, 3, 1))
for d in range(10):
    t = 0x30 + d
    chr_data[t * 16:(t + 1) * 16] = tile(glyph_pixels(str(d), 1, 0))
open("tiles.chr", "wb").write(chr_data)
print("tiles.chr", len(chr_data), "bytes,", 12 + 10, "tiles drawn")
```

في السكربت أعلاه لاحظ أن الدالة `tile` تكتب المربع في مستويين Planes: الثمانية بايتات الأولى هي البت الأدنى لكل بكسل، والثمانية الثانية هي البت الأعلى، وهذا هو الشكل الذي يقرؤه معالج الرسوم كما توضح صفحة جداول الرسوم Pattern Tables. والكتلة الملونة لها القيمة 1 والرقم داخلها القيمة 3، فاللون الأول من كل لوحة يملأ الكتلة، واللون الثالث يرسم الرقم.

### الكود: flicker.s

وفيما يلي البرنامج كاملاً، وهو ملف واحد مع ملف ربط صغير nrom.cfg يحدد أين يقع الكود والرسوم في ملف NES:

```text
; flicker.s: a small, original NES program for the ArabRoot article on sprite limits.
; Three rows of numbered sprites: row A has 8 sprites, row B has 9, row C has 12 (29 in total).
; The PPU draws at most 8 sprites on one scanline, so rows B and C lose sprites.
; MODE decides the order in which our 29 logical sprites are copied into OAM each frame:
;   MODE=0  fixed order                     (the 9th sprite of a row never shows)
;   MODE=1  forward, then reversed           (ping-pong, two sprites share the drop)
;   MODE=2  rotate the start by 1 each frame (start, start+1, ... wrapping at 29)
;   MODE=3  start+1 each frame, stride STRIDE through the list
; STAGGER=1 moves every second sprite of rows B and C 8 lines down, so no scanline has more than 6.
; Build: ca65 -D MODE=n flicker.s && ld65 -C nrom.cfg flicker.o -o modeN.nes

.ifndef MODE
MODE = 0
.endif
.ifndef STAGGER
STAGGER = 0                     ; 1 = every second sprite of rows B and C is 8 lines lower
.endif
.ifndef STRIDE
STRIDE = 12                     ; any value 2..28 visits all 29 sprites, 29 is prime
.endif
NSPR = 29

PPUCTRL   = $2000
PPUMASK   = $2001
PPUSTATUS = $2002
OAMADDR   = $2003
PPUSCROLL = $2005
PPUADDR   = $2006
PPUDATA   = $2007
OAMDMA    = $4014
OAM       = $0200               ; shadow copy of the 256-byte OAM, sent by DMA every vblank

.segment "HEADER"
    .byte "NES", $1A
    .byte 1                     ; 1 x 16 KB PRG ROM
    .byte 1                     ; 1 x 8 KB CHR ROM
    .byte $01                   ; mapper 0 (NROM), vertical mirroring
    .byte $00
    .res 8, 0

.segment "ZEROPAGE"
frame:     .res 1               ; frame counter, +1 in every NMI
nmi_flag:  .res 1               ; set by NMI, cleared by the main loop
ovf_last:  .res 1               ; PPUSTATUS bit 5 (sprite overflow) read at the start of vblank
start:     .res 1               ; first logical sprite written to OAM slot 0
step:      .res 1               ; distance between consecutive logical sprites
shown:     .res 1               ; "start" of the table that the last DMA sent (for the log)
shown_step:.res 1
built:     .res 1               ; "start" of the table now waiting in the shadow OAM
built_step:.res 1

.segment "CODE"
reset:
    sei
    cld
    ldx #$40
    stx $4017                   ; no APU frame IRQ
    ldx #$FF
    txs
    inx                         ; X = 0
    stx PPUCTRL                 ; NMI off while we set up
    stx PPUMASK                 ; rendering off
    stx $4010
@vb1: bit PPUSTATUS             ; wait for the first vblank: the PPU needs time to warm up
    bpl @vb1
    txa
@clr: sta $0000,x               ; clear the 2 KB of CPU RAM
    sta $0100,x
    sta $0300,x
    sta $0400,x
    sta $0500,x
    sta $0600,x
    sta $0700,x
    inx
    bne @clr
    lda #$FF
@hide: sta OAM,x                ; Y = $FF puts every OAM entry below the screen
    inx
    bne @hide
@vb2: bit PPUSTATUS             ; second vblank: now the PPU accepts writes
    bpl @vb2

    lda #$3F                    ; palettes at $3F00
    sta PPUADDR
    lda #$00
    sta PPUADDR
    ldx #0
@pal: lda palettes,x
    sta PPUDATA
    inx
    cpx #32
    bne @pal

    lda #$20                    ; clear nametable 0 ($2000-$23FF) to tile 0
    sta PPUADDR
    lda #$00
    sta PPUADDR
    ldx #4
    ldy #0
@nt: sta PPUDATA
    iny
    bne @nt
    dex
    bne @nt

    ldx #0                      ; row labels "8", "9", "12" in tile column 1
@lab: lda labels,x
    sta PPUADDR
    lda labels+1,x
    sta PPUADDR
    lda labels+2,x
    sta PPUDATA
    inx
    inx
    inx
    cpx #12
    bne @lab

    lda #0
    sta start
    lda #1
    sta step
    jsr build_oam               ; first table, so the first frame already has sprites
    lda #0
    sta PPUSCROLL
    sta PPUSCROLL
    lda #%10000000              ; NMI on, 8x8 sprites, both pattern tables at $0000
    sta PPUCTRL
    lda #%00011110              ; show background and sprites, also in the left 8 pixels
    sta PPUMASK

main:
    lda nmi_flag
    beq main                    ; wait for the next vblank
    lda #0
    sta nmi_flag
    jsr choose_order
    jsr build_oam               ; prepare the table for the next DMA
    jmp main

; ---- choose start and step for the next frame ---------------------------
choose_order:
.if MODE = 0
    lda #0
    sta start
    lda #1
    sta step
.elseif MODE = 1
    lda frame
    and #1
    bne @rev
    lda #0                      ; even frame: 0, 1, 2, ... 28
    sta start
    lda #1
    sta step
    rts
@rev: lda #NSPR-1               ; odd frame: 28, 27, ... 0 (step 28 = -1 mod 29)
    sta start
    lda #NSPR-1
    sta step
.else
    lda start                   ; start = start + 1 (mod 29)
    clc
    adc #1
    cmp #NSPR
    bcc @ok
    lda #0
@ok: sta start
  .if MODE = 2
    lda #1
  .else
    lda #STRIDE
  .endif
    sta step
.endif
    rts

; ---- copy the 29 logical sprites into OAM slots 0..28 -------------------
; slot j receives logical sprite (start + j*step) mod 29
build_oam:
    lda start
    sta built
    lda step
    sta built_step
    ldx #0                      ; X = slot * 4
    lda start
@next:
    pha
    asl                         ; logical index * 4 = offset in the sprite table
    asl
    tay
    lda sprites,y               ; Y position
    sta OAM,x
    lda sprites+1,y             ; tile
    sta OAM+1,x
    lda sprites+2,y             ; attributes (palette)
    sta OAM+2,x
    lda sprites+3,y             ; X position
    sta OAM+3,x
    pla
    clc
    adc step
    cmp #NSPR
    bcc @in
    sec
    sbc #NSPR
@in: inx
    inx
    inx
    inx
    cpx #NSPR*4
    bne @next
    rts

nmi:
    pha
    txa
    pha
    tya
    pha
    lda PPUSTATUS               ; bit 5 = sprite overflow of the frame that just ended
    and #$20
    sta ovf_last
    lda #0
    sta OAMADDR
    lda #>OAM
    sta OAMDMA                  ; copy the shadow OAM into the PPU (513 CPU cycles)
    lda built
    sta shown
    lda built_step
    sta shown_step
    lda #0
    sta PPUSCROLL
    sta PPUSCROLL
    inc frame
    lda #1
    sta nmi_flag
    pla
    tay
    pla
    tax
    pla
irq:
    rti

; ---- data ---------------------------------------------------------------
palettes:
    .byte $0F,$30,$10,$00, $0F,$30,$10,$00, $0F,$30,$10,$00, $0F,$30,$10,$00   ; background
    .byte $0F,$16,$27,$30, $0F,$1A,$27,$30, $0F,$12,$27,$30, $0F,$28,$27,$0F   ; sprites

labels:                         ; PPU address (hi, lo), tile
    .byte $20,$C1,$38           ; row 6,  "8"
    .byte $21,$81,$39           ; row 12, "9"
    .byte $22,$41,$31           ; row 18, "1"
    .byte $22,$42,$32           ;         "2"

; 29 logical sprites: Y, tile, attributes, X (sprite Y is drawn one line lower)
.macro ROW yy, count
  .repeat count, i
    .byte yy + STAGGER * (i .mod 2) * 8 * (yy > 50), i+1, i .mod 4, 40 + i*18
  .endrepeat
.endmacro
sprites:
    ROW 47, 8                   ; row A: 8 sprites, logical 0..7
    ROW 95, 9                   ; row B: 9 sprites, logical 8..16
    ROW 143, 12                 ; row C: 12 sprites, logical 17..28

.segment "VECTORS"
    .word nmi, reset, irq

.segment "CHARS"
    .incbin "tiles.chr"
```

في الكود أعلاه لاحظ التالي:

- **الترويسة HEADER:** 16 بايتاً بصيغة iNES التي تقرؤها المحاكيات: خرطوشة من نوع NROM، أبسط الأنواع، فيها 16 كيلوبايت للكود و8 كيلوبايت للرسوم ودون أي شرائح إضافية.
- **التهيئة reset:** ينتظر البرنامج إطفاءين رأسيين قبل أن يكتب في معالج الرسوم، لأن الشريحة تحتاج وقتاً بعد التشغيل حتى تقبل الكتابة، ثم يمسح الذاكرة، ويضع 255 في كل الجدول فتختفي كل الشخصيات تحت الشاشة، ثم يكتب الألوان وأرقام الصفوف في الخلفية.
- **الجدول sprites:** 29 شخصية منطقية Logical Sprites، أي الشخصيات كما يراها منطق اللعبة، والماكرو ROW يولد كل صف: الموضع الرأسي نفسه، ورقم المربع، ولوحة تتغير كل شخصية، وموضع أفقي كل 18 بكسلاً.
- **build\_oam:** قلب التجربة كلها، فهو ينسخ الشخصيات المنطقية إلى الجدول بالترتيب: السجل j يأخذ الشخصية `(start + j*step) mod 29`. وكل الطرق التي سوف نجربها هي مجرد اختيار مختلف لـ start وstep في كل إطار.
- **choose\_order:** يختار start وstep حسب MODE: الصفر ثابت، والواحد يعكس الترتيب في الإطارات الفردية بخطوة 28، وهي تساوي سالب واحد في الحساب بباقي 29، والاثنان يزيد start بواحد كل إطار، والثلاثة يفعل الشيء نفسه مع خطوة STRIDE.
- **nmi:** المقاطعة التي تحدث في بداية كل إطفاء رأسي، وفيها يقرأ البرنامج علامة الفيض من الإطار الذي انتهى ويحفظها، ثم ينسخ الجدول بـ DMA، ويحفظ start وstep للجدول الذي صار على الشاشة حتى يقرأهما سكربت القياس.
- **الحلقة main:** تنتظر المقاطعة، ثم تجهز جدول الإطار التالي في الصفحة $0200\. أي أن الجدول يجهز أثناء رسم الإطار الحالي، وينسخ في بداية الإطار التالي.

### التجميع: ست نسخ من ملف واحد

الملف build.sh يولد الرسوم، ثم يجمع النسخ الأربع الأساسية، ونسخة الخطوة 7، ونسخة الإزاحة الرأسية stagger التي سوف نصل إليها لاحقاً:

```bash
#!/bin/sh
# Builds the CHR data and five ROMs: one per OAM ordering mode, plus mode 3 with stride 7 and mode 0 with staggered rows.
set -e
python3 make_chr.py
for m in 0 1 2 3; do
  ca65 -D MODE=$m flicker.s -o mode$m.o -l mode$m.lst
  ld65 -C nrom.cfg mode$m.o -o mode$m.nes
done
ca65 -D MODE=3 -D STRIDE=7 flicker.s -o mode3s7.o
ld65 -C nrom.cfg mode3s7.o -o mode3s7.nes
ca65 -D MODE=0 -D STAGGER=1 flicker.s -o stagger.o
ld65 -C nrom.cfg stagger.o -o stagger.nes
ca65 --version 2>&1 | head -1
ls -l *.nes
```

```bash
docker build -t nes-lab lab/
docker run --rm -v "$PWD/lab:/lab" -w /lab nes-lab sh build.sh
```

والمخرج سوف يكون كما يلي:

```text
tiles.chr 8192 bytes, 22 tiles drawn
ca65 V2.18 - Debian 2.19-2
-rw-r--r-- 1 root root 24592 Nov 20 10:00 mode0.nes
-rw-r--r-- 1 root root 24592 Nov 20 10:00 mode1.nes
-rw-r--r-- 1 root root 24592 Nov 20 10:00 mode2.nes
-rw-r--r-- 1 root root 24592 Nov 20 10:00 mode3.nes
-rw-r--r-- 1 root root 24592 Nov 20 10:00 mode3s7.nes
-rw-r--r-- 1 root root 24592 Nov 20 10:00 stagger.nes
```

كل ملف 24,592 بايتاً: 16 للترويسة، و16,384 للكود، و8,192 للرسوم. والجزء المستخدم فعلاً من مساحة الكود في النسخة الأولى 460 بايتاً فقط، منها 116 بايتاً لجدول الشخصيات، وبقية الـ 16 كيلوبايت مملوءة بالقيمة $FF. ولاحظ أن ca65 يعرض نفسه بالرقم V2.18 رغم أن الحزمة 2.19، وهذا اختلاف معروف في نسخة Debian ولا يؤثر على شيء.

### التشغيل: FCEUX مع سكربت Lua دون شاشة

السكربت التالي يعمل داخل FCEUX، وبعد كل إطار يقرأ بكسلاً واحداً من كل شخصية من الـ 29، وهو البكسل في الزاوية السفلى اليسرى من الكتلة، فإذا كان ملوناً فالشخصية ظهرت، وإذا كان أسود فقد اختفت. ويقرأ أيضاً من ذاكرة المعالج ثلاثة بايتات حفظها برنامجنا: علامة الفيض، وstart وstep للجدول المعروض، ثم يكتب سطراً لكل إطار ويحفظ لقطات لإطارات محددة:

```text
-- watch.lua: runs inside FCEUX. For every frame it logs which of our 29 sprites are on the screen
-- (by reading one pixel of each sprite's coloured block), the sprite overflow flag the ROM saved,
-- and the OAM order of the table that was on screen. Saves a few frames as PNG, then quits.
local name   = os.getenv("ROMNAME") or "rom"
local frames = tonumber(os.getenv("FRAMES") or "300")
local shots  = {}
for f in string.gmatch(os.getenv("SHOTS") or "", "%d+") do shots[tonumber(f)] = true end
emu.speedmode("nothrottle")

-- the same table as in flicker.s: rows at OAM Y 47, 95, 143 with 8, 9, 12 sprites
local spr = {}
for _, row in ipairs({{47, 8}, {95, 9}, {143, 12}}) do
  local drop = (os.getenv("STAGGER") == "1" and row[1] > 50) and 8 or 0   -- STAGGER=1 ROM: odd sprites 8 lines lower
  for i = 0, row[2] - 1 do spr[#spr + 1] = {x = 40 + i * 18, y = row[1] + 1 + (i % 2) * drop} end
end

local log = io.open("logs/" .. name .. ".txt", "w")
for f = 1, frames do
  emu.frameadvance()
  local vis = {}
  for k, s in ipairs(spr) do
    local r, g, b = emu.getscreenpixel(s.x, s.y + 7, true)   -- bottom-left pixel: block colour, never the glyph
    vis[k] = (r + g + b > 60) and "1" or "0"
  end
  local ovf   = memory.readbyte(0x0002)                    -- ovf_last
  local start = memory.readbyte(0x0005)                    -- shown
  local step  = memory.readbyte(0x0006)                    -- shown_step
  log:write(string.format("%d %d %d %d %s\n", f, ovf, start, step, table.concat(vis)))
  -- FCEUX writes the screenshot when it draws the next frame, so ask one frame early
  if shots[f + 1] then gui.savescreenshotas(string.format("shots/%s-f%03d.png", name, f + 1)) end
end
log:close()
emu.frameadvance()
emu.frameadvance()
os.exit(0)
```

والملف run.sh يشغل FCEUX لكل نسخة تحت Xvfb مع هذا السكربت. والخيار nolimit يكتب في ملف إعدادات FCEUX المفتاح `SDL.DisableSpriteLimit`، وهو الخيار الذي يسمح للمحاكي برسم أكثر من ثماني شخصيات في السطر، ولم نجده في خيارات سطر الأوامر في هذا الإصدار، فكتبناه في ملف الإعدادات مباشرة:

```bash
#!/bin/sh
# Runs each ROM in FCEUX 2.6.5 under Xvfb with watch.lua.
#   sh run.sh            : sprite limit on (the real hardware)
#   sh run.sh nolimit    : FCEUX's "allow more than 8 sprites per scanline" option
export HOME=/tmp/fceux-home SDL_AUDIODRIVER=dummy QT_QPA_PLATFORM=xcb
mkdir -p $HOME/.fceux logs shots
suffix=""
if [ "$1" = "nolimit" ]; then
  echo "SDL.DisableSpriteLimit = 1" > $HOME/.fceux/fceux.cfg; suffix="-nolimit"
else
  echo "SDL.DisableSpriteLimit = 0" > $HOME/.fceux/fceux.cfg
fi
for m in 0 1 2 3 3s7 stagger; do
  rom=mode$m; [ $m = stagger ] && rom=stagger
  STAGGER=$([ $m = stagger ] && echo 1 || echo 0) ROMNAME=$rom$suffix FRAMES=${FRAMES:-300} SHOTS="${SHOTS:-200 201 202 203}" \
    xvfb-run -a -s "-screen 0 1024x768x24" /usr/games/fceux --sound 0 --loadlua watch.lua $rom.nes >/dev/null 2>&1 &
  pid=$!
  ( sleep 120; kill $pid 2>/dev/null ) &
  wait $pid
  echo "$rom$suffix: $(wc -l < logs/$rom$suffix.txt) frames logged"
done
```

```bash
docker run --rm -v "$PWD/lab:/lab" -w /lab -e FRAMES=600 nes-lab sh -c "sh run.sh; sh run.sh nolimit"
```

```text
mode0: 600 frames logged
mode1: 600 frames logged
mode2: 600 frames logged
mode3: 600 frames logged
mode3s7: 600 frames logged
stagger: 600 frames logged
mode0-nolimit: 600 frames logged
mode1-nolimit: 600 frames logged
mode2-nolimit: 600 frames logged
mode3-nolimit: 600 frames logged
mode3s7-nolimit: 600 frames logged
stagger-nolimit: 600 frames logged
```

⚠️

في أول تشغيل ظهرت اللقطة التي سميناها الإطار 201 مطابقة للإطار 202 في السجل. والسبب أن `gui.savescreenshotas` في FCEUX لا يحفظ الإطار الحالي، وإنما يحفظ الإطار التالي الذي يرسمه المحاكي، فطلبنا اللقطة قبلها بإطار، كما في التعليق داخل watch.lua. وإذا كتبت سكربتاً مشابهاً فقارن دائماً اللقطة بما تقوله الأرقام عن الإطار نفسه، لأن خطأ إطار واحد يكفي لتظن أن الرمش يعمل بشكل معاكس.

### قراءة السجلات: analyze.py وmodel.py

كل نسخة أخرجت 600 سطر، ونترك أول 20 إطاراً لأن الجهاز في بدايته يمسح الذاكرة ويرسم إطارات فارغة، فيبقى 580 إطاراً، أي 20 دورة كاملة من 29 إطاراً. والسكربت analyze.py يحسب لكل شخصية في الصفين المزدحمين كم في المئة من الإطارات ظهرت، وأطول فترة اختفت فيها متصلة بالإطارات، وكم إطاراً رفعت فيه علامة الفيض. ثم يفعل شيئاً أهم: يأخذ start وstep من كل سطر، ويسأل نموذجاً من بضعة أسطر في model.py عن الشخصيات التي يجب أن تظهر حسب قاعدة NESdev، أي أول ثماني في ترتيب الجدول لكل سطر، ويقارن ذلك بما رآه على الشاشة:

```python
# model.py: the PPU sprite rule in a few lines, used to predict what the screen shows.
# On each scanline the PPU takes the first 8 sprites in OAM order that cover the line; the rest are not drawn.
N = 29
ROWS = {"A": range(0, 8), "B": range(8, 17), "C": range(17, 29)}

def order(start, step):
    """OAM slot j holds logical sprite (start + j*step) mod 29."""
    return [(start + j * step) % N for j in range(N)]

def visible(start, step):
    vis = set()
    oam = order(start, step)
    for members in ROWS.values():
        on_line = [s for s in oam if s in members]   # sprites of this row, in OAM order
        vis.update(on_line[:8])                       # only the first 8 are drawn
    return vis

def schedule(mode, frames, stride=7):
    """(start, step) per frame for the four modes of flicker.s."""
    out, start = [], 0
    for f in range(frames):
        if mode == 0: out.append((0, 1))
        elif mode == 1: out.append((0, 1) if f % 2 == 0 else (N - 1, N - 1))
        else:
            start = (start + 1) % N
            out.append((start, 1 if mode == 2 else stride))
    return out

def stats(sched):
    frames = len(sched)
    seen = {k: 0 for k in range(N)}
    gap = {k: 0 for k in range(N)}; run = {k: 0 for k in range(N)}
    for st in sched * 2:                       # twice, so a gap that wraps around is measured too
        v = visible(*st)
        for k in range(N):
            run[k] = 0 if k in v else run[k] + 1
            gap[k] = max(gap[k], run[k])
    for st in sched:
        for k in visible(*st): seen[k] += 1
    return {k: (seen[k] / frames, gap[k]) for k in range(N)}

if __name__ == "__main__":
    import sys
    if len(sys.argv) > 1 and sys.argv[1] == "strides":
        for p in range(2, 29):
            s = stats(schedule(3, 29, p))
            b = [s[k] for k in ROWS["B"]]; c = [s[k] for k in ROWS["C"]]
            print(f"stride {p:2}: row B min {min(x[0] for x in b):.2f} max gap {max(x[1] for x in b)}"
                  f" | row C min {min(x[0] for x in c):.2f} max {max(x[0] for x in c):.2f} max gap {max(x[1] for x in c)}")
```

```bash
python3 analyze.py mode0 mode1 mode2 mode3 mode3s7 stagger mode0-nolimit mode3-nolimit
```

والمخرج سوف يكون كما يلي، وسوف نمر على كل نسخة على حدة:

```text
== mode0: 580 frames, overflow flag set in 580 frames
  row B (sprite: shown %/longest gap) 1:100%/0 2:100%/0 3:100%/0 4:100%/0 5:100%/0 6:100%/0 7:100%/0 8:100%/0 9:  0%/580
  row C (sprite: shown %/longest gap) 1:100%/0 2:100%/0 3:100%/0 4:100%/0 5:100%/0 6:100%/0 7:100%/0 8:100%/0 9:  0%/580 A:  0%/580 B:  0%/580 C:  0%/580
  row A: all 8 sprites on screen in every frame: True
  model.py prediction from the logged OAM order matches the screen in 580/580 frames
== mode1: 580 frames, overflow flag set in 580 frames
  row B (sprite: shown %/longest gap) 1: 50%/1 2:100%/0 3:100%/0 4:100%/0 5:100%/0 6:100%/0 7:100%/0 8:100%/0 9: 50%/1
  row C (sprite: shown %/longest gap) 1: 50%/1 2: 50%/1 3: 50%/1 4: 50%/1 5:100%/0 6:100%/0 7:100%/0 8:100%/0 9: 50%/1 A: 50%/1 B: 50%/1 C: 50%/1
  row A: all 8 sprites on screen in every frame: True
  model.py prediction from the logged OAM order matches the screen in 580/580 frames
== mode2: 580 frames, overflow flag set in 580 frames
  row B (sprite: shown %/longest gap) 1: 97%/1 2: 97%/1 3: 97%/1 4: 97%/1 5: 97%/1 6: 97%/1 7: 97%/1 8: 97%/1 9: 28%/21
  row C (sprite: shown %/longest gap) 1: 86%/4 2: 86%/4 3: 86%/4 4: 86%/4 5: 86%/4 6: 86%/4 7: 86%/4 8: 86%/4 9: 28%/21 A: 28%/21 B: 28%/21 C: 28%/21
  row A: all 8 sprites on screen in every frame: True
  model.py prediction from the logged OAM order matches the screen in 580/580 frames
== mode3: 580 frames, overflow flag set in 580 frames
  row B (sprite: shown %/longest gap) 1: 90%/1 2: 90%/1 3: 83%/1 4: 83%/1 5: 83%/1 6: 93%/1 7: 93%/1 8: 93%/1 9: 93%/1
  row C (sprite: shown %/longest gap) 1: 66%/1 2: 66%/1 3: 66%/1 4: 66%/1 5: 66%/1 6: 66%/1 7: 66%/1 8: 66%/1 9: 69%/1 A: 69%/1 B: 69%/1 C: 69%/1
  row A: all 8 sprites on screen in every frame: True
  model.py prediction from the logged OAM order matches the screen in 580/580 frames
== mode3s7: 580 frames, overflow flag set in 580 frames
  row B (sprite: shown %/longest gap) 1: 97%/1 2: 97%/1 3: 86%/1 4: 86%/1 5: 86%/1 6: 86%/1 7: 86%/1 8: 86%/1 9: 90%/1
  row C (sprite: shown %/longest gap) 1: 55%/4 2: 69%/3 3: 72%/2 4: 72%/2 5: 72%/2 6: 69%/3 7: 59%/3 8: 55%/4 9: 59%/3 A: 72%/2 B: 72%/2 C: 72%/2
  row A: all 8 sprites on screen in every frame: True
  model.py prediction from the logged OAM order matches the screen in 580/580 frames
== stagger: 580 frames, overflow flag set in 0 frames
  row B (sprite: shown %/longest gap) 1:100%/0 2:100%/0 3:100%/0 4:100%/0 5:100%/0 6:100%/0 7:100%/0 8:100%/0 9:100%/0
  row C (sprite: shown %/longest gap) 1:100%/0 2:100%/0 3:100%/0 4:100%/0 5:100%/0 6:100%/0 7:100%/0 8:100%/0 9:100%/0 A:100%/0 B:100%/0 C:100%/0
  row A: all 8 sprites on screen in every frame: True
== mode0-nolimit: 580 frames, overflow flag set in 580 frames
  row B (sprite: shown %/longest gap) 1:100%/0 2:100%/0 3:100%/0 4:100%/0 5:100%/0 6:100%/0 7:100%/0 8:100%/0 9:100%/0
  row C (sprite: shown %/longest gap) 1:100%/0 2:100%/0 3:100%/0 4:100%/0 5:100%/0 6:100%/0 7:100%/0 8:100%/0 9:100%/0 A:100%/0 B:100%/0 C:100%/0
  row A: all 8 sprites on screen in every frame: True
== mode3-nolimit: 580 frames, overflow flag set in 580 frames
  row B (sprite: shown %/longest gap) 1:100%/0 2:100%/0 3:100%/0 4:100%/0 5:100%/0 6:100%/0 7:100%/0 8:100%/0 9:100%/0
  row C (sprite: shown %/longest gap) 1:100%/0 2:100%/0 3:100%/0 4:100%/0 5:100%/0 6:100%/0 7:100%/0 8:100%/0 9:100%/0 A:100%/0 B:100%/0 C:100%/0
  row A: all 8 sprites on screen in every frame: True
```

## التجربة الأولى: الترتيب الثابت

في النسخة mode0 تكتب الشخصيات بالترتيب نفسه في كل إطار، وهذا ما يفعله أي مبرمج لم يفكر في الحد بعد. والنتيجة في المخرج واضحة: في الصف الثاني الشخصيات من 1 إلى 8 ظاهرة في 100% من الإطارات، والتاسعة في 0%، وأطول اختفاء لها 580 إطاراً، أي التجربة كلها. وفي الصف الثالث تختفي أربع شخصيات بالكامل: 9 وA وB وC. والصف الأول ظاهر كاملاً في كل الإطارات، فالحد لم يمسه لأنه ثماني شخصيات بالضبط. والشكل التالي يبين لقطات حقيقية من FCEUX، دون أي تعديل إلا التكبير:

![أربع لقطات سوداء من FCEUX فيها ثلاثة صفوف من المربعات الملونة المرقمة بجانبها الأرقام 8 و9 و12: في الترتيب الثابت يظهر في كل صف ثماني مربعات فقط، ومع خيار إلغاء الحد تظهر 8 و9 و12 كاملة، وفي الإطار 200 من الترتيب المتبدل يغيب آخر مربع في الصفين المزدحمين، وفي الإطار 201 يغيب الأول في الصف الثاني والأربعة الأولى في الصف الثالث](https://arabroot.io/content/images/2026/11/sprite-flicker-limits-04-captures.webp)

لقطات حقيقية من FCEUX 2.6.5: الترتيب الثابت يخفي الأخيرة دائماً، والترتيب المتبدل يوزع الاختفاء بين إطارين.

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

## التجربة الثانية: للأمام ثم معكوساً

أبسط فكرة للرمش أن تكتب الجدول للأمام في الإطارات الزوجية ومعكوساً في الفردية. وفي النسخة mode1 كانت النتيجة: في الصف الثاني الشخصيتان 1 و9 ظاهرتان في 50% من الإطارات، وأطول اختفاء لكل منهما إطار واحد، والبقية 100%. والسبب أن الترتيب للأمام يخفي التاسعة، والمعكوس يخفي الأولى، فتتبادلان الاختفاء، وتبدو الاثنتان على الشاشة كأنهما ترمشان بسرعة 30 مرة في الثانية، وهذا ما تراه في اللقطتين السفليتين في الشكل أعلاه.

ولكن انظر إلى الصف الثالث: الشخصيات من 1 إلى 4 ومن 9 إلى C كلها 50%، أي ثماني شخصيات ترمش، وأربع في المنتصف لا ترمش أبداً. وهذا عيب هذه الطريقة: هي عادلة فقط حين يتجاوز السطر الحد بشخصية واحدة، أما حين يتجاوزه بأربع فإن الطرفين يدفعان الثمن كله والمنتصف لا يدفع شيئاً. وبالتالي فإن العدو الذي في طرف الصف سوف يبدو باهتاً بوضوح مقارنة بالذي في منتصفه.

## التجربة الثالثة: الدوران بخطوة واحدة

الفكرة التالية تبدو أعدل: في كل إطار نبدأ الجدول من الشخصية التالية، فالإطار الأول يبدأ من 0، والثاني من 1، وهكذا حتى 28 ثم نعود. وتوقعنا قبل التشغيل أن تختفي كل شخصية بالدور، ولكن النتيجة في mode2 كانت مفاجئة: في الصف الثاني الشخصيات من 1 إلى 8 ظاهرة في 97% من الإطارات، والتاسعة في 28% فقط، وأطول اختفاء لها 21 إطاراً متصلة، أي ثلث ثانية كاملة. وفي الصف الثالث الأربع الأخيرة 28% والبقية 86%. أي أن هذه الطريقة أسوأ من السابقة رغم أنها تبدو أذكى.

ولكن لماذا؟ الإجابة في مكان «الالتفاف» Wrap Point في الجدول. فالدوران يغير بداية الجدول، ولكن ترتيب الشخصيات داخل الصف الواحد لا يتغير إلا إذا وقعت نقطة الالتفاف داخل الصف نفسه. وفي الجدول 29 شخصية، والصف الثاني يشغل 9 منها فقط، أي أن نقطة البداية تقع داخله في 8 إطارات من كل 29، وفي الإطارات الـ 21 الباقية يبقى ترتيبه الطبيعي وتختفي التاسعة نفسها. وبحساب بسيط فإن التاسعة تظهر في 8 من 29 إطاراً، أي 28%، وهو بالضبط ما قاسه السكربت، وهذا يفسر أيضاً الرقم 21 لأطول اختفاء. والدرس هنا أن الدوران على الجدول كله ليس عادلاً لكل صف، لأن كل صف يرى جزءاً صغيراً فقط من الدوران.

## التجربة الرابعة: الدوران بخطوة 12

الحل الذي جربناه بعد ذلك أن نخلط الترتيب نفسه، لا أن نحرك بدايته فقط. ففي mode3 يأخذ السجل j الشخصية `(start + 12*j) mod 29`، أي أننا نقفز في الجدول 12 خطوة كل مرة، ولأن 29 عدد أولي فإن أي خطوة من 2 إلى 28 تمر على الشخصيات الـ 29 كلها قبل أن تتكرر. وبهذا الشكل يتغير ترتيب الشخصيات داخل كل صف في كل إطار، لا في بعض الإطارات فقط. وقبل أن نختار الرقم 12 شغلنا model.py على كل الخطوات من 2 إلى 28، فهو يحسب النتيجة دون محاكي في أقل من ثانية، واخترنا الخطوة التي تعطي أقرب نتيجة للقسمة العادلة في الصفين وأقصر اختفاء متصل.

والنتيجة في المحاكي: في الصف الثاني تظهر كل شخصية بين 83% و93% من الإطارات، والقسمة العادلة 8 من 9 أي 89%، وأطول اختفاء لأي شخصية إطار واحد. وفي الصف الثالث تظهر كل شخصية بين 66% و69%، والعادل 8 من 12 أي 67%، وأطول اختفاء أيضاً إطار واحد. أي أن هذه الطريقة وزعت الخسارة بالتساوي تقريباً على كل الشخصيات في كل صف، ولم تترك أي شخصية تختفي أكثر من إطار متصل، والشكل التالي يبين أربعة إطارات متتالية منها، وفي كل إطار تغيب شخصيات مختلفة:

![أربع لقطات متتالية صغيرة من FCEUX للنسخة mode3، وفي كل لقطة تغيب مربعات مختلفة من الصفين الثاني والثالث، وتحتها لقطة كبيرة للنسخة stagger فيها الصفوف الثلاثة كاملة ولكن كل مربع ثان في الصفين الثاني والثالث منخفض 8 أسطر، وبجانبها شرح أن أي سطر لا يتجاوز 6 شخصيات](https://arabroot.io/content/images/2026/11/sprite-flicker-limits-05-rotation.webp)

في الأعلى: الدوران بخطوة 12 في الإطارات من 200 إلى 203\. وفي الأسفل: الحل من التصميم، كل شخصية ثانية أخفض بـ 8 أسطر فلا يزدحم أي سطر.

### ماذا لو اخترنا خطوة 7؟

كانت الخطوة 7 هي اختيارنا الأول قبل أن نشغل النموذج على كل الخطوات، ولذلك أبقيناها نسخة مستقلة mode3s7 لنرى الفرق في المحاكي. والنتيجة: الصف الثاني جيد، بين 86% و97% وأطول اختفاء إطار واحد، ولكن في الصف الثالث تراوحت الشخصيات بين 55% و72%، وأطول اختفاء للشخصيتين 1 و8 أربعة إطارات متصلة. وأربعة إطارات بسرعة 60 إطاراً في الثانية تعني 67 مللي ثانية، وهذا يكفي لترى الشخصية تختفي فعلاً لا ترمش. والدرس أن الخطوة ليست تفصيلاً، وأن أرخص طريقة لاختيارها أن تحسب كل الاحتمالات بنموذج صغير قبل أن تكتب سطراً بلغة التجميع، والشكل التالي يجمع النسخ الأربع:

![رسم بياني من ثمانية أجزاء، أربعة للصف الثاني بتسعة أعمدة وأربعة للصف الثالث باثني عشر عموداً، لكل ترتيب: الثابت فيه أعمدة كاملة وأعمدة فارغة، وللأمام ثم معكوس فيه أعمدة برتقالية عند 50% في الطرفين، والدوران بخطوة 1 فيه أعمدة حمراء قصيرة عند 28%، والدوران بخطوة 12 أعمدة متقاربة قرب الخط الأخضر للقسمة العادلة](https://arabroot.io/content/images/2026/11/sprite-flicker-limits-06-results.webp)

نسبة الإطارات التي ظهرت فيها كل شخصية من 580 إطاراً: الدوران بخطوة 12 هو الوحيد القريب من القسمة العادلة في الصفين.

## ماذا لو ألغينا الحد في المحاكي؟

أغلب المحاكيات الحديثة، ومنها FCEUX، فيها خيار يسمح برسم أكثر من ثماني شخصيات في السطر، والهدف منه أن يلعب اللاعب الألعاب القديمة دون رمش. وفي النسختين mode0-nolimit وmode3-nolimit ظهرت كل الشخصيات في 100% من الإطارات، كما في اللقطة العلوية اليسرى في شكل اللقطات. أي أن المحاكي يرسم ما في الجدول كله، ويتجاهل حد العتاد.

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

## الحل من التصميم: لا تضع تسعة على سطر

كل ما سبق علاج للمشكلة بعد حدوثها. أما أفضل حل فهو ألا تحدث أصلاً، وفي النسخة stagger جربنا أبسط صورة لذلك: نزلنا كل شخصية ثانية في الصفين الثاني والثالث 8 أسطر، أي ارتفاع شخصية كاملة، فصار كل صف صفين متداخلين، ولا يتجاوز أي سطر 6 شخصيات. والنتيجة في المخرج: الشخصيات الـ 29 ظاهرة في 100% من الإطارات، وعلامة الفيض لم ترتفع في أي إطار من 580، دون أي دوران ودون سطر كود إضافي في الحلقة. وهذا ما كان يفعله مصممو المستويات في الألعاب الجيدة: يوزعون الأعداء على ارتفاعات مختلفة، ويحسبون كم شخصية يمكن أن تجتمع على سطر قبل أن يضعوها.

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

- **رسم الأشياء الكبيرة في الخلفية:** الزعيم Boss الكبير الذي لا يتحرك كثيراً يمكن أن يرسم بمربعات الخلفية، فلا يستهلك أي شخصية، ثم تحرك الخلفية كلها بالتمرير لتبدو كأنه يتحرك.
- **الشخصيات الطويلة 8×16:** البت 5 في PPUCTRL يجعل كل شخصية بارتفاع 16 بكسل بدل 8، فالبطل الطويل يحتاج نصف عدد السجلات، ولكن الحد في السطر لا يتغير، لأن العرض هو الذي يستهلك الحد.
- **حد للأعداء في الشاشة:** أن يقرر منطق اللعبة ألا يظهر أكثر من عدد معين من الأعداء أو الطلقات في وقت واحد، وهو قرار في تصميم اللعبة Game Design قبل أن يكون في الكود، كما ناقشنا في [مقال أساسيات تصميم الألعاب](https://arabroot.io/articles/%D8%A7%D8%B3%D8%A7%D8%B3%D9%8A%D8%A7%D8%AA-%D8%AA%D8%B5%D9%85%D9%8A%D9%85-%D8%A7%D9%84%D8%A7%D9%84%D8%B9%D8%A7%D8%A8-game-design/).
- **الأولوية الذكية:** أن تكتب شخصية اللاعب دائماً في أول الجدول خارج الدوران، فلا تختفي أبداً، وتدور الأعداء والمؤثرات فقط، لأن اللاعب يجب أن يرى نفسه في كل إطار.

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

- **الاعتماد على علامة الفيض لمعرفة الازدحام:** رأينا أنها مرفوعة في كل الإطارات حين يزدحم أي سطر، فهي لا تقول أي سطر ولا كم شخصية، وفيها خطأ عتاد يجعلها تخطئ في الاتجاهين. احسب الازدحام بنفسك في منطق اللعبة.
- **الدوران على الجدول كله بخطوة واحدة:** النسخة mode2 أعطت التاسعة 28% واختفاء 21 إطاراً متصلاً، لأن نقطة الالتفاف نادراً ما تقع داخل الصف. اخلط الترتيب داخل الصف، واختبر الخطوة على الأرقام قبل أن تثق بها.
- **الاختبار مع إلغاء الحد:** لعبتك سوف تبدو سليمة في المحاكي وترمش على الجهاز. أبق الحد مفعلاً دائماً أثناء التطوير.
- **نسيان أن Y يرسم بعد سطر:** إذا كتبت الموضع الرأسي كما تراه في الرسم فسوف تظهر الشخصية أخفض بسطر واحد، والتصادم الذي تحسبه سوف يختلف عما يراه اللاعب.
- **إخفاء الشخصية بموضع غير صحيح:** لا يوجد بت للإخفاء، فالقيمة صفر في Y لا تخفي الشخصية، وإنما تضعها في أعلى الشاشة. ضع الشخصيات غير المستخدمة تحت الشاشة بقيمة بين $EF و$FF.
- **الوثوق باللقطة دون مقارنتها بالأرقام:** لقطات FCEUX في سكربتنا كانت متأخرة إطاراً، ولو لم نقارنها بالسجل لكتبنا أن الترتيب المعكوس يخفي الأخيرة.

## أي طريقة تختار؟ جدول قرار Decision Table

| الطريقة                    | ما قسناه في الصف المزدحم                     | التكلفة                    | متى تناسب                                      |
| -------------------------- | -------------------------------------------- | -------------------------- | ---------------------------------------------- |
| ترتيب ثابت                 | التاسعة 0%، تختفي دائماً                     | لا شيء                     | فقط إذا ضمن التصميم ألا يزدحم أي سطر           |
| للأمام ثم معكوس            | الطرفان 50%، والمنتصف 100%                   | سطران في الكود             | حين يتجاوز السطر الحد بشخصية أو اثنتين         |
| دوران البداية بخطوة 1      | التاسعة 28% واختفاء 21 إطاراً                | بسيطة                      | لا ينصح بها حين يكون الجدول أكبر بكثير من الصف |
| دوران بخطوة 12 مع عدد أولي | 83% إلى 93%، و66% إلى 69%، واختفاء إطار واحد | جمع وطرح في حلقة النسخ     | الحل العام حين يكثر الأعداء في صفوف            |
| إزاحة رأسية في التصميم     | 100% دون رمش ودون فيض                        | قيد على تصميم المستوى      | دائماً حين يمكن، فهو أفضل من أي رمش            |
| إلغاء الحد في المحاكي      | 100%، والعلامة ما زالت مرفوعة                | لا يوجد على الجهاز الحقيقي | للعب على المحاكي فقط، لا للتطوير               |

## ماذا يبقى من هذا الحد اليوم؟

لا يوجد في شرائح الرسوم الحديثة حد للشخصيات في السطر، ولكن الفكرة التي يجبرك عليها هذا الجهاز ما زالت في كل لعبة: كل إطار له ميزانية Budget ثابتة، وحين يزيد العمل عنها لا بد أن تختار ما تضحي به. في NES كانت الميزانية 64 نقطة لجلب رسوم الشخصيات في كل سطر، واليوم هي 16.7 مللي ثانية للإطار كله، وعدد أوامر الرسم Draw Calls، وذاكرة الشريحة، وما رأيناه في [مقال قياس أداء اللعبة Profiling](https://arabroot.io/articles/%D8%A7%D8%AF%D8%A7%D8%A1-%D8%A7%D9%84%D9%84%D8%B9%D8%A8%D8%A9-%D9%82%D9%8A%D8%A7%D8%B3-%D8%A7%D9%84%D8%A7%D8%B7%D8%A7%D8%B1%D8%A7%D8%AA-profiling-%D9%88%D8%AA%D8%AD%D8%B3%D9%8A%D9%86%D9%87%D8%A7/) هو النسخة الحديثة من السؤال نفسه. والمحركات اليوم تفعل ما فعله مبرمج NES ولكن بأسماء أخرى: مستويات التفصيل LOD تقلل ما يرسم للأشياء البعيدة، وأنظمة الجزيئات Particles تضع حداً أعلى لعدد الجزيئات وتسقط الأقدم حين تمتلئ، وهي كلها قرارات «من يختفي حين يزدحم المشهد».

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

## تطبيق عملي

1. شغل `python3 model.py strides` واقرأ الجدول: أي خطوة تعطي أقل اختفاء متصل في الصف الثالث؟ ولماذا تعطي الخطوتان 14 و15 اختفاء 7 إطارات؟ تلميح: انظر إلى 2 في 14 و2 في 15 بباقي 29.
2. اجعل الصف الثالث 16 شخصية بدل 12، وأعد التجميع، وتوقع قبل التشغيل نسبة الظهور العادلة لكل شخصية، ثم قارنها بما يقيسه analyze.py مع الخطوة 12.
3. أضف شخصية «لاعب» في السجل 0 خارج الدوران، أي اجعل build\_oam يكتب من السجل 1، وتحقق من السجل أن اللاعب ظاهر في 100% من الإطارات حتى لو وضعته في الصف المزدحم.
4. غير الإزاحة في نسخة stagger إلى 4 أسطر بدل 8، وتوقع كم شخصية سوف تجتمع على الأسطر المتداخلة، ثم تحقق من علامة الفيض.

## الخلاصة Summary

- معالج الرسوم في NES يرسم الشخصيات من جدول OAM فيه 64 سجلاً من 4 بايتات، ولا يرسم أكثر من 8 شخصيات في السطر الواحد، لأن وقت جلب رسومها 64 نقطة في كل سطر، 8 نقاط لكل شخصية.
- من يختفي يحدده ترتيب الجدول لا مكان الشخصية: أول ثماني في الترتيب تحجز أماكنها، والقاعدة البسيطة في model.py توقعت ما على الشاشة في كل الإطارات التي قسناها.
- الرمش حل مقصود يوزع الخسارة على الشخصيات: الترتيب الثابت أخفى التاسعة في 100% من الإطارات، والعكس أعطى الطرفين 50%، والدوران بخطوة واحدة أعطى التاسعة 28% فقط مع اختفاء 21 إطاراً، والدوران بخطوة 12 أعطى كل شخصية قرابة نصيبها العادل مع اختفاء لا يتجاوز إطاراً واحداً.
- علامة الفيض لا تقول أي سطر ازدحم، وفيها خطأ عتاد موثق، وتبقى مرفوعة حتى مع إلغاء الحد في المحاكي.
- إلغاء الحد في المحاكي يصلح الصورة للاعب، ولكنه يخفي المشكلة عن المطور، والحل الأفضل هو التصميم: الإزاحة الرأسية في مختبرنا أظهرت الشخصيات الـ 29 كلها دون رمش ودون فيض.

وفي المقالات القادمة بإذن الله نكمل حيل هذه المرحلة: كيف رسمت Doom عالماً ثلاثي الأبعاد على حاسوب بطيء بشجرة تقسيم المساحة BSP، وكيف حسبت Quake III الجذر التربيعي العكسي بحيلة على بتات الرقم:

[![](https://arabroot.io/content/images/2026/11/doom-bsp-cover-cover.webp)دليلكيف رسمت Doom عالماً ثلاثي الأبعاد بشجرة BSP؟نشرح كيف رتبت Doom جدرانها بشجرة BSP ورسمتها من القريب إلى البعيد، ونبني الشجرة والمرسم بـ Python ونعد ما يفحصه كل أسلوب على خرائط حتى 1,225 جداراً.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%B1%D8%B3%D9%85%D8%AA-doom-%D8%B9%D8%A7%D9%84%D9%85%D8%A7-%D8%AB%D9%84%D8%A7%D8%AB%D9%8A-%D8%A7%D9%84%D8%A7%D8%A8%D8%B9%D8%A7%D8%AF-%D8%A8%D8%B4%D8%AC%D8%B1%D8%A9-bsp/)[![](https://arabroot.io/content/images/2026/11/fast-inverse-sqrt-cover-cover.webp)دليلالجذر التربيعي العكسي السريع في Quake IIIنفك حيلة 0x5f3759df في Quake III ونرى لماذا تعمل، ثم نقيس خطأها على كل عدد float موجب ونبحث عن أفضل ثابت ونقارن سرعتها بأمر rsqrtss.](https://arabroot.io/articles/%D8%A7%D9%84%D8%AC%D8%B0%D8%B1-%D8%A7%D9%84%D8%AA%D8%B1%D8%A8%D9%8A%D8%B9%D9%8A-%D8%A7%D9%84%D8%B9%D9%83%D8%B3%D9%8A-%D8%A7%D9%84%D8%B3%D8%B1%D9%8A%D8%B9-%D9%81%D9%8A-quake-iii-0x5f3759df/)[![](https://arabroot.io/content/images/2026/11/racing-the-beam-cover-cover.webp)دليلAtari 2600: الرسم مع شعاع الشاشة Racing the Beamكيف رسمت ألعاب Atari 2600 صورها دون ذاكرة إطار: نكتب برنامج 6502 صغيراً ونعد دوراته في Stella لنرى ماذا يحدث حين يتأخر الكود عن الشعاع.](https://arabroot.io/articles/atari-2600-%D8%A7%D9%84%D8%B1%D8%B3%D9%85-%D9%85%D8%B9-%D8%B4%D8%B9%D8%A7%D8%B9-%D8%A7%D9%84%D8%B4%D8%A7%D8%B4%D8%A9-racing-the-beam/)[![](https://arabroot.io/content/images/2026/11/game-performance-cover-cover.webp)دليلأداء اللعبة: قياس الإطارات Profiling وتحسينهانبني في Godot 4 بستاناً من 2,500 نخلة بطيئاً عن قصد، ثم نقيسه بأدوات المحرك ونصلحه في ست خطوات، ونعرف بالأرقام كم وفرت كل خطوة ومن أين، وما الثمن الذي دفعناه في رقم آخر.](https://arabroot.io/articles/%D8%A7%D8%AF%D8%A7%D8%A1-%D8%A7%D9%84%D9%84%D8%B9%D8%A8%D8%A9-%D9%82%D9%8A%D8%A7%D8%B3-%D8%A7%D9%84%D8%A7%D8%B7%D8%A7%D8%B1%D8%A7%D8%AA-profiling-%D9%88%D8%AA%D8%AD%D8%B3%D9%8A%D9%86%D9%87%D8%A7/)

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

- 20 نوفمبر 2026: كتابة المقال، وتشغيل المختبر على cc65 2.19 وFCEUX 2.6.5 داخل debian:13-slim، وقياس 580 إطاراً لكل نسخة من النسخ الست مع الحد ودونه.