> ## 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.

# رياضيات الألعاب: المتجهات Vectors والحركة والتصادم
- URL: https://arabroot.io/articles/رياضيات-الالعاب-المتجهات-vectors-والحركة-والتصادم/
- Published: 2026-11-12T06:57:04.000Z
- Updated: 2026-11-12T22:20:49.000Z
- Description: المتجهات والحركة وحاصل الضرب النقطي واختبارات التصادم والارتداد والنفق، بلعبة صغيرة ومختبر Python يصنع الأخطاء الشائعة ثم يصلحها.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, تطوير الألعاب

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

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

وحتى يكون الكلام عملياً سوف نتبع لعبة صغيرة من تصميمنا تنظر إليها من الأعلى Top-down: روبوت توصيل يتحرك في مستودع ليجمع الطرود، وبين الرفوف طائرات حراسة صغيرة تدور وتراقب، وبراميل ورفوف يجب ألا يخترقها الروبوت، وفي المستودع آلة ترمي سهاماً صغيرة على الجدار لاختبار التغليف. وكل سؤال في اللعبة سوف يتحول إلى سطرين أو ثلاثة من الكود ومخرج حقيقي من المختبر.

وهذا المقال من المرحلة الأولى في مسار تطوير الألعاب، وقبله أو بعده يأتي [مقال حلقة اللعبة Game Loop](https://arabroot.io/articles/%D8%AD%D9%84%D9%82%D8%A9-%D8%A7%D9%84%D9%84%D8%B9%D8%A8%D8%A9-game-loop-%D9%88%D8%A7%D9%84%D8%A7%D8%B7%D8%A7%D8%B1%D8%A7%D8%AA-frames/) الذي يشرح كيف تتكرر اللعبة ستين مرة في الثانية، وهنا نشرح ماذا يحدث من حساب في كل مرة من هذه المرات.

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

- لماذا تحتاج اللعبة إلى الرياضيات أصلاً، وكيف تبدو الشاشة في نظر الكود.
- المتجه: الموقع والإزاحة، والطول والمسافة، والاتجاه وتوحيد الطول Normalize.
- تحريك الروبوت نحو هدف، ولماذا يرتجف عند الوصول.
- الحركة القطرية الأسرع، وعصا التحكم Analog Stick، والمتجه الصفري.
- حاصل الضرب النقطي Dot Product: هل الروبوت أمام الطائرة؟ ومخروط الرؤية، واليمين واليسار.
- اختبارات التصادم: الصندوق مع الصندوق AABB، والدائرة مع الدائرة، والدائرة مع الصندوق.
- كم اختباراً تحتاج في كل إطار، والشبكة Grid التي تقلل العدد.
- الارتداد Bounce بمعادلة الانعكاس، والطاقة التي تضيع.
- النفق Tunneling: عندما يعبر الجسم السريع الجدار، والحلول التي تستخدمها المحركات.
- الأرقام البعيدة عن نقطة الأصل، ولماذا يتوقف الشيء البطيء عن الحركة.

## لماذا تحتاج اللعبة إلى الرياضيات؟

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

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

### كيف تبدو الشاشة في نظر الكود؟

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

وفي لعبتنا المستودع شاشة واحدة بعرض 960 وارتفاع 540، وعندما نقول إن الروبوت عند `(100, 400)` فنحن نقصد أنه على بعد 100 نقطة من الحافة اليسرى و400 نقطة من الحافة العليا، أي في الجزء الأيسر السفلي من الشاشة.

## المتجه Vector: الموقع والإزاحة

المتجه في الألعاب ثنائية الأبعاد هو ببساطة رقمان معاً، x وy، ولكن هذين الرقمين يستخدمان بمعنيين مختلفين، ويجب أن تميز بينهما من البداية:

- **الموقع Position:** نقطة على الشاشة، مثل موقع الروبوت `(100, 400)` وموقع الطرد `(400, 0)`. والموقع يجيب عن سؤال «أين؟».
- **الإزاحة Displacement:** سهم له طول واتجاه، مثل «300 إلى اليمين و400 إلى الأعلى». والإزاحة لا تعرف أين تبدأ، فالسهم نفسه يصلح من أي نقطة، وهي تجيب عن سؤال «كم وإلى أين؟». والسرعة Velocity إزاحة أيضاً، ولكنها إزاحة في الثانية الواحدة.

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

والشكل التالي يبين الروبوت والطرد في إحداثيات الشاشة، والسهم الأزرق هو الإزاحة من الروبوت إلى الطرد:

![شبكة إحداثيات الشاشة ونقطة الأصل في الزاوية العليا اليسرى، والمحور x يتجه يميناً والمحور y يتجه إلى الأسفل، وروبوت رمادي عند النقطة 100 و400، وطرد بني عند 400 و0، وسهم أزرق من الروبوت إلى الطرد طوله 500، وخطان برتقاليان متقطعان يمثلان المركبتين x تساوي 300 وy تساوي سالب 400، وسهم أخضر قصير من الروبوت هو الاتجاه 0.6 وسالب 0.8، وعلى اليمين ثلاث بطاقات تشرح الموقع والإزاحة والطول والاتجاه](https://arabroot.io/content/images/2026/11/game-math-01-vector.webp)

الموقع نقطة، والإزاحة سهم بين نقطتين، والاتجاه هو السهم نفسه بعد قسمته على طوله.

### المختبر: متجه من عشرين سطراً

كل محرك ألعاب يعطيك متجهاً جاهزاً، مثل `Vector2` في Godot وUnity، ولكننا سوف نكتبه بأنفسنا في Python حتى ترى أنه لا يوجد فيه أي سحر، وحتى نستطيع أن نصنع الأخطاء ونصلحها دون محرك. والمختبر سبعة برامج صغيرة في مجلد `lab` تعتمد كلها على الملف التالي:

```python
# A small 2D vector, the same operations every game engine gives you (Godot Vector2, Unity Vector2).
# Screen coordinates: x grows to the right, y grows DOWN.
import math

class Vec2:
    __slots__ = ("x", "y")

    def __init__(self, x=0.0, y=0.0):
        self.x, self.y = float(x), float(y)

    def __add__(self, o): return Vec2(self.x + o.x, self.y + o.y)
    def __sub__(self, o): return Vec2(self.x - o.x, self.y - o.y)
    def __mul__(self, k): return Vec2(self.x * k, self.y * k)    # scale by a number
    __rmul__ = __mul__
    def __neg__(self): return Vec2(-self.x, -self.y)

    def length(self): return math.hypot(self.x, self.y)          # Pythagoras: sqrt(x*x + y*y)
    def length_sq(self): return self.x * self.x + self.y * self.y  # no square root, for comparisons

    def normalized(self):
        n = self.length()
        return Vec2(self.x / n, self.y / n)                       # fails on a zero vector, on purpose

    def dot(self, o): return self.x * o.x + self.y * o.y
    def cross(self, o): return self.x * o.y - self.y * o.x        # 2D "cross": the sign says left or right

    def __repr__(self): return f"({self.x:.2f}, {self.y:.2f})"
```

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

- الدوال `__add__` و`__sub__` و`__mul__` تجعل Python يفهم `a + b` و`a - b` و`a * 2` على المتجهات، فالجمع والطرح يتمان لكل مركبة وحدها، والضرب في رقم يضرب المركبتين معاً.
- الدالة `length` هي نظرية فيثاغورس، و`length_sq` هي الطول مربعاً دون الجذر التربيعي، وسوف نرى لماذا نحتاجها في التصادم.
- الدالة `normalized` تفشل عمداً على المتجه الصفري، وسوف نرى ذلك في جزء الحركة القطرية.
- الدالتان `dot` و`cross` هما موضوع جزء الطائرة والحارس.

والملف `run.sh` يشغل البرامج السبعة بالترتيب ويحفظ مخرج كل برنامج بجانبه:

```bash
#!/bin/sh
# Runs every part of the lab and saves its output next to it. From this folder:
#   docker run --rm -v "$PWD:/lab" -w /lab python:3.13.5-slim sh run.sh
set -e
export PYTHONDONTWRITEBYTECODE=1
python3 --version | tee out-00-versions.txt
python3 01_vectors.py   | tee out-01-vectors.txt
python3 02_diagonal.py  | tee out-02-diagonal.txt
python3 03_front.py     | tee out-03-front.txt
python3 04_collision.py | tee out-04-collision.txt
python3 05_bounce.py    | tee out-05-bounce.txt
python3 06_tunneling.py | tee out-06-tunneling.txt
python3 07_far.py      | tee out-07-far.txt
```

ولا تحتاج أي مكتبة خارجية، فكل البرامج تستخدم Python فقط، ونشغلها في Docker حتى تكون النسخة نفسها عندك وعندنا، من داخل مجلد `lab` بالأمر التالي:

```bash
docker run --rm -v "$PWD:/lab" -w /lab python:3.13.5-slim sh run.sh
```

وإذا كان Python 3 مثبتاً عندك فتستطيع تشغيل أي برنامج مباشرة، مثل `python3 01_vectors.py`، والنتيجة نفسها ما عدا أزمنة التنفيذ في الجزء الخامس من برنامج التصادم، لأنها تعتمد على جهازك.

## الطول والمسافة: فيثاغورس في كل إطار

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

```python
# 1) Position, displacement, distance and direction, then moving the robot to a parcel at 60 frames per second.
from vec import Vec2

robot = Vec2(100, 400)
parcel = Vec2(400, 0)
to_parcel = parcel - robot                 # displacement: where the parcel is, seen from the robot
print("### 1. position and direction")
print("robot           ", robot)
print("parcel          ", parcel)
print("robot -> parcel ", to_parcel)
print("distance        ", round(to_parcel.length(), 2), "px")
direction = to_parcel.normalized()
print("direction       ", direction, " length", round(direction.length(), 4))

SPEED, DT = 200.0, 1 / 60                  # pixels per second, one frame at 60 fps
step = SPEED * DT

print("### 2. move without an arrival check")
pos = Vec2(robot.x, robot.y)
for frame in range(1, 200):
    pos = pos + (parcel - pos).normalized() * step
    if frame >= 148 and frame <= 153:
        print(f"frame {frame}  pos {pos}  distance {(parcel - pos).length():.2f}")

print("### 3. move with an arrival check")
pos = Vec2(robot.x, robot.y)
for frame in range(1, 200):
    left = parcel - pos
    if left.length() <= step:               # closer than one step: land exactly on the target
        pos = parcel
        print(f"frame {frame}  arrived at {pos}  time {frame * DT:.2f} s")
        break
    pos = pos + left.normalized() * step
```

والمخرج سوف يكون كما يلي، الجزء الأول منه:

```text
robot            (100.00, 400.00)
parcel           (400.00, 0.00)
robot -> parcel  (300.00, -400.00)
distance         500.0 px
direction        (0.60, -0.80)  length 1.0
```

والقراءة كما يلي:

- الإزاحة `(300.00, -400.00)`، أي أن الطرد على بعد 300 إلى اليمين و400 إلى الأعلى، والإشارة السالبة في y تعني الأعلى لأن y على الشاشة يزيد إلى الأسفل كما ذكرنا.
- المسافة 500 بالضبط، لأن 300 و400 و500 هي المثلث المشهور 3 و4 و5 مضروباً في مئة، واخترنا هذه الأرقام حتى تتحقق من الحساب بنفسك.
- الاتجاه `(0.60, -0.80)` وطوله 1، وهذا موضوع الجزء التالي.

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

## الاتجاه وتوحيد الطول Normalize

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

والحل أن نفصل الاتجاه عن الطول، وذلك بقسمة المتجه على طوله، فنحصل على متجه بالاتجاه نفسه ولكن طوله 1 دائماً، ويسمى متجه الوحدة Unit Vector، وتسمى العملية توحيد الطول Normalize. ووثائق Godot تعرفها كما يلي: [«توحيد طول المتجه يعني تقليل طوله إلى 1 مع الحفاظ على اتجاهه»](https://docs.godotengine.org/en/stable/tutorials/math/vector%5Fmath.html?ref=arabroot.io). وبعد ذلك نضرب الاتجاه في المسافة التي نريدها، فإذا كانت سرعة الروبوت 200 نقطة في الثانية، وكان الإطار يستغرق جزءاً من ستين من الثانية، فالروبوت يتحرك في كل إطار 200 مقسومة على 60، أي 3.33 نقطة تقريباً، في اتجاه الطرد.

### لماذا نضرب في زمن الإطار؟

لاحظ في الكود أننا لم نكتب «تحرك 3 نقاط في كل إطار»، وإنما كتبنا السرعة في الثانية `SPEED` ثم ضربناها في زمن الإطار `DT`. والسبب أن عدد الإطارات في الثانية ليس ثابتاً، فشاشة اللاعب قد تعمل على 60 أو 144 إطاراً في الثانية، والجهاز الضعيف قد ينزل إلى 30، فإذا كانت الحركة ثابتة لكل إطار فإن الروبوت يجري على شاشة 144 بأكثر من ضعف سرعته على شاشة 60، وهذا خطأ قديم ومعروف في الألعاب. وعندما تكون السرعة في الثانية مضروبة في زمن الإطار، فإن الإطار الأطول يعطي خطوة أطول، والنتيجة بعد ثانية واحدة واحدة على كل الأجهزة. وكيف يحسب زمن الإطار، ولماذا تستخدم بعض الألعاب زمناً ثابتاً للفيزياء، هو موضوع [مقال حلقة اللعبة](https://arabroot.io/articles/%D8%AD%D9%84%D9%82%D8%A9-%D8%A7%D9%84%D9%84%D8%B9%D8%A8%D8%A9-game-loop-%D9%88%D8%A7%D9%84%D8%A7%D8%B7%D8%A7%D8%B1%D8%A7%D8%AA-frames/)، وهنا يكفي أن تتذكر القاعدة: كل حركة تكتب في الثانية، ثم تضرب في زمن الإطار.

### الروبوت الذي يرتجف عند الوصول

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

```text
frame 148  pos (396.00, 5.33)  distance 6.67
frame 149  pos (398.00, 2.67)  distance 3.33
frame 150  pos (400.00, -0.00)  distance 0.00
frame 151  pos (398.39, 2.92)  distance 3.33
frame 152  pos (400.00, -0.00)  distance 0.00
frame 153  pos (398.52, 2.99)  distance 3.33
```

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

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

```text
frame 150  arrived at (400.00, 0.00)  time 2.50 s
```

وصل الروبوت في الإطار 150 بعد 2.5 ثانية، ووقف على `(400.00, 0.00)` بالضبط. وهذه القاعدة تتكرر في كل حركة نحو هدف: الأعداء الذين يطاردون نقطة، والكاميرا التي تتبع اللاعب، والمصعد الذي يتحرك بين طابقين، وكلها تحتاج فحص الوصول قبل الخطوة، والسبب أن الخطوة الثابتة لا تنتهي أبداً على الهدف بالضبط، وبالتالي فإما أن تتوقف قبله أو تتجاوزه. وفي Godot توجد دالة جاهزة لهذا هي `move_toward` التي تتحرك نحو الهدف دون أن تتجاوزه.

## لماذا يجري الروبوت أسرع على القطر؟

الآن ننتقل من الحركة الآلية إلى تحكم اللاعب. اللاعب يضغط على أزرار الأسهم، وأبسط طريقة لتحويلها إلى حركة أن نجعل كل زر مركبة: السهم الأيمن يعطي x تساوي 1، والسهم الأيسر سالب 1، والسفلي y تساوي 1، والعلوي سالب 1، ثم نضرب المتجه الناتج في السرعة. وهذا يبدو صحيحاً تماماً، والروبوت يتحرك في الاتجاهات الأربعة بسرعة 200 كما نريد، ثم يضغط اللاعب على السهم الأيمن والسفلي معاً فيصبح المتجه `(1, 1)`، وطول هذا المتجه ليس 1 وإنما الجذر التربيعي لاثنين، أي 1.41 تقريباً. والبرنامج الثاني يقيس المسافة التي يقطعها الروبوت في ثانية واحدة بالطريقتين:

```python
# 2) The faster-diagonal bug: input from the keys as a vector, with and without normalising.
import math
from vec import Vec2

SPEED = 200.0
KEYS = {"right": Vec2(1, 0), "down": Vec2(0, 1), "right+down": Vec2(1, 1), "left+up": Vec2(-1, -1)}

print("### 1. keyboard, distance moved in one second")
print(f"{'keys':<11} {'raw':>8} {'normalised':>11}")
for name, v in KEYS.items():
    raw = (v * SPEED).length()
    fixed = (v.normalized() * SPEED).length()
    print(f"{name:<11} {raw:>8.1f} {fixed:>11.1f}")

def clamp_length(v, max_len=1.0):           # keep the direction, cap the length (what Input.get_vector does)
    n = v.length()
    return v * (max_len / n) if n > max_len else v

print("### 2. analog stick, speed in px/s")
print(f"{'stick':<14} {'raw':>7} {'normalised':>11} {'clamped':>8}")
for s in [Vec2(0.3, 0.2), Vec2(0.7, 0.0), Vec2(0.71, 0.71), Vec2(0.9, 0.9)]:
    raw = (s * SPEED).length()
    norm = (s.normalized() * SPEED).length()
    clamp = (clamp_length(s) * SPEED).length()
    print(f"{str(s):<14} {raw:>7.1f} {norm:>11.1f} {clamp:>8.1f}")

print("### 3. no key pressed")
try:
    Vec2(0, 0).normalized()
except ZeroDivisionError as e:
    print("normalized() on (0, 0):", type(e).__name__, "-", e)
```

والجزء الأول من المخرج:

```text
keys             raw  normalised
right          200.0       200.0
down           200.0       200.0
right+down     282.8       200.0
left+up        282.8       200.0
```

الروبوت على القطر يقطع 282.8 نقطة في الثانية بدل 200، أي أسرع بنسبة 41 في المئة، والسبب في الشكل التالي: الأسهم المستقيمة تنتهي على دائرة نصف قطرها 1، أما القطرية فتنتهي في زاوية المربع، وهي أبعد. وهذا الخطأ له اسم معروف عند اللاعبين، فقد وصفت [صفحة Strafing في ويكيبيديا](https://en.wikipedia.org/wiki/Strafing%5F%28video%5Fgames%29?ref=arabroot.io) ألعاباً قديمة كان اللاعب فيها يتحرك أسرع بنحو 1.4 مرة عندما يجمع الحركة إلى الأمام مع الحركة الجانبية، لأن اللعبة كانت تعامل الحركتين كل واحدة وحدها، وتعلم اللاعبون أن يستغلوا ذلك ليصلوا أسرع.

![لوحتان: على اليمين بعنوان قبل، ثمانية أسهم من نقطة في المركز، أربعة رمادية مستقيمة تنتهي على دائرة متقطعة وأربعة حمراء قطرية تنتهي في زوايا مربع متقطع أكبر، ومكتوب بجانب القطري 1 و1 وطوله 1.41، وفي الأسفل 200 مقابل 282.8 نقطة في الثانية. وعلى اليسار بعنوان بعد، ثمانية أسهم خضراء كلها تنتهي على الدائرة نفسها، والقطري 0.71 و0.71 وطوله 1، وفي الأسفل 200 نقطة في الثانية](https://arabroot.io/content/images/2026/11/game-math-02-diagonal.webp)

زران معاً يعطيان سهماً أطول، والتوحيد يرجع كل الاتجاهات إلى الدائرة نفسها.

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

### عصا التحكم: لا توحد الطول وإنما حدده

![يد تحكم سوداء لجهاز ألعاب مصورة من الأعلى بزاوية، عليها عصا تحكم دائرية على اليسار في الأعلى وعصا ثانية على اليمين في الوسط، وأزرار اتجاه على شكل صليب، وأربعة أزرار ملونة بالحروف Y وB وA وX، وزر دائري في الأعلى](https://arabroot.io/content/images/2026/11/game-math-03-gamepad.webp)

يد تحكم بعصاتين Analog Sticks تعطي كل منهما متجهاً طوله بين 0 و1 حسب ميلها، وأزرار الاتجاه التي على شكل صليب تعطي قيماً كاملة مثل لوحة المفاتيح. الصورة: Evan-Amos، ملكية عامة Public Domain، المصدر: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Microsoft-Xbox-One-controller.jpg?ref=arabroot.io) (تم تحويلها إلى WebP).

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

```text
stick              raw  normalised  clamped
(0.30, 0.20)      72.1       200.0     72.1
(0.70, 0.00)     140.0       200.0    140.0
(0.71, 0.71)     200.8       200.0    200.0
(0.90, 0.90)     254.6       200.0    200.0
```

لاحظ السطر الأول: اللاعب أمال العصا ميلاً خفيفاً فأعطت `(0.30, 0.20)`، والسرعة الصحيحة 72.1، ولكن بعد التوحيد أصبحت 200، أي أن الروبوت ينطلق بسرعته الكاملة عند أقل لمسة. وفي المقابل لاحظ السطر الأخير: بعض أيادي التحكم تعطي في الزوايا قيمة أكبر من 1، مثل `(0.90, 0.90)` وطولها 1.27، فإذا تركناها كما هي فقد عاد خطأ القطر من جديد بسرعة 254.6.

والحل الصحيح هو العمود الأخير: نحدد الطول بحد أعلى قدره 1 Clamp، فإذا كان المتجه أطول من 1 نقصره إلى 1 مع الحفاظ على اتجاهه، وإذا كان أقصر نتركه كما هو. والنتيجة أن الميل الخفيف بقي 72.1 والزاوية لم تتجاوز 200\. وهذا بالضبط ما تفعله الدالة `Input.get_vector` في Godot، فوثائقها تقول إن [المتجه الذي ترجعه طوله محدود بحد أعلى قدره 1 وله منطقة ميتة Deadzone دائرية](https://docs.godotengine.org/en/stable/classes/class%5Finput.html?ref=arabroot.io)، والمنطقة الميتة هي المسافة الصغيرة حول مركز العصا التي تتجاهلها اللعبة، لأن العصا المستعملة لا ترجع إلى الصفر تماماً، فبدونها يتحرك الروبوت وحده ببطء واللاعب لا يلمس شيئاً.

### عندما لا يضغط اللاعب على شيء

بقي خطأ ثالث في هذا الجزء، وهو الأسهل في الوقوع فيه. إذا لم يضغط اللاعب على أي زر فالمتجه `(0, 0)`، وطوله صفر، وتوحيد الطول يعني القسمة على الطول، أي القسمة على صفر:

```text
normalized() on (0, 0): ZeroDivisionError - float division by zero
```

في Python يتوقف البرنامج بخطأ `ZeroDivisionError`، وفي لغات أخرى لا يتوقف وإنما يعطيك القيمة الخاصة `NaN` ومعناها «ليس رقماً» Not a Number، وهي أسوأ، لأنها تنتقل بصمت إلى موقع الروبوت، ثم إلى كل شيء يحسب منه، فيختفي الروبوت من الشاشة دون أي رسالة خطأ. ولهذا لا تقم بتوحيد أي متجه دون أن تتأكد أن طوله ليس صفراً، أو استخدم دالة المحرك التي تتعامل مع هذه الحالة، فوثائق Godot تذكر أن `normalized()` في GDScript تترك المتجه الصفري كما هو. ولاحظ أن هذا ما حدث في الروبوت المرتجف أيضاً، فلو وصل إلى الهدف بالضبط في الإطار 150 لكانت الإزاحة صفراً، ولتوقف البرنامج في الإطار التالي، وفحص الوصول أنقذنا من الحالتين.

## هل الروبوت أمام الطائرة؟ حاصل الضرب النقطي

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

وحاصل الضرب النقطي لمتجهين هو حاصل ضرب المركبتين x زائد حاصل ضرب المركبتين y، أي رقم واحد، ومعناه الهندسي أنه يساوي طول الأول ضرب طول الثاني ضرب جيب تمام الزاوية بينهما. وإذا كان المتجهان بطول 1 فالرقم هو جيب تمام الزاوية مباشرة، ومن هنا قيمته في الألعاب: إذا كان الرقم 1 فالمتجهان في الاتجاه نفسه تماماً، وإذا كان صفراً فهما متعامدان، وإذا كان سالباً فالثاني خلف الأول. وفي [وثائق Godot عن المتجهات](https://docs.godotengine.org/en/stable/tutorials/math/vector%5Fmath.html?ref=arabroot.io) المثال نفسه تقريباً: كائن يعرف أن اللاعب في مجال رؤيته إذا كانت الزاوية بين اتجاه نظره واتجاه اللاعب أقل من 90 درجة، أي إذا كان حاصل الضرب النقطي أكبر من صفر.

ولكن «أمامي» بمعنى نصف الدائرة كاملاً ليس ما تريده في أغلب الألعاب، لأن الحارس الحقيقي لا يرى بزاوية 180 درجة، ولهذا نضيف مخروط رؤية View Cone: زاوية 90 درجة، 45 على كل جانب، ومدى 250 نقطة. والشرط الآن أن يكون حاصل الضرب النقطي أكبر من جيب تمام 45 درجة، وهو 0.707، وأن تكون المسافة أقل من المدى. والبرنامج الثالث يختبر ستة مواقع للروبوت حول طائرة تنظر إلى اليمين:

```python
# 3) Is the robot in front of the guard drone? The dot product, a view cone, and left or right with the cross product.
import math
from vec import Vec2

guard = Vec2(480, 270)
facing = Vec2(1, 0)                        # the drone looks to the right (east)
VIEW_DEG, VIEW_RANGE = 90, 250             # a 90 degree cone, 45 each side
cos_half = math.cos(math.radians(VIEW_DEG / 2))

print("### 1. dot, angle, cone")
print(f"cos(45 deg) = {cos_half:.4f}")
print(f"{'robot':<16} {'dist':>6} {'dot':>6} {'angle':>6}  front  in-cone  sees  side")
for p in [Vec2(680, 270), Vec2(640, 150), Vec2(560, 470), Vec2(480, 120), Vec2(300, 260), Vec2(900, 300)]:
    to_p = p - guard
    d = to_p.normalized().dot(facing)
    angle = math.degrees(math.acos(max(-1.0, min(1.0, d))))
    front = d > 0
    cone = d >= cos_half
    sees = cone and to_p.length() <= VIEW_RANGE
    side = "right" if facing.cross(to_p) > 0 else "left" if facing.cross(to_p) < 0 else "ahead"
    # screen y grows down, so a positive cross is clockwise: to the drone's right
    print(f"{str(p):<16} {to_p.length():>6.0f} {d:>6.3f} {angle:>6.1f}  {str(front):<5}  {str(cone):<7}  {str(sees):<5} {side}")

print("### 2. the same test without normalising")
for p in [Vec2(640, 150), Vec2(900, 300)]:
    to_p = p - guard
    print(f"{str(p):<16} raw dot {to_p.dot(facing):>7.1f}  normalised {to_p.normalized().dot(facing):.3f}")
```

والمخرج:

```text
cos(45 deg) = 0.7071
robot              dist    dot  angle  front  in-cone  sees  side
(680.00, 270.00)    200  1.000    0.0  True   True     True  ahead
(640.00, 150.00)    200  0.800   36.9  True   True     True  left
(560.00, 470.00)    215  0.371   68.2  True   False    False right
(480.00, 120.00)    150  0.000   90.0  False  False    False left
(300.00, 260.00)    180 -0.998  176.8  False  False    False left
(900.00, 300.00)    421  0.997    4.1  True   True     False right
```

![طائرة حراسة رمادية بأربع مراوح تنظر إلى اليمين بسهم أسود، وأمامها مخروط رؤية أخضر بزاوية 90 درجة، وستة روبوتات مربعة: اثنان أخضران داخل المخروط بقيمتي 1.000 و0.800، وواحد برتقالي أسفل المخروط بقيمة 0.371، وواحد رمادي فوق الطائرة مباشرة بقيمة 0.000، وواحد رمادي خلفها بقيمة سالب 0.998، وواحد برتقالي بعيد على اليمين بقيمة 0.997 مكتوب تحته بعيد عن المدى، وعلى اليمين ثلاث بطاقات تشرح الحدود](https://arabroot.io/content/images/2026/11/game-math-04-dot.webp)

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

والقراءة كما يلي:

- الروبوت الأول أمام الطائرة تماماً، فالقيمة 1 والزاوية صفر، وهو في المدى، فالطائرة تراه.
- الثاني بزاوية 36.9 درجة، والقيمة 0.8 أكبر من 0.707، فهو داخل المخروط وتراه.
- الثالث بزاوية 68.2 درجة، والقيمة موجبة 0.371، فهو أمامها بمعنى نصف الدائرة، ولكنه خارج المخروط فلا تراه. وهذه هي الحالة التي يخطئ فيها من يكتفي بشرط «أكبر من صفر».
- الرابع فوقها مباشرة بزاوية 90 والقيمة صفر بالضبط، والخامس خلفها والقيمة سالب 0.998، وكلاهما لا يرى.
- السادس في الاتجاه الصحيح تماماً، والقيمة 0.997، ولكنه على بعد 421 والمدى 250، فلا تراه، ولهذا نضع شرط المسافة بجانب شرط الزاوية دائماً.

والعمود الأخير `side` يجيب عن سؤال آخر تحتاجه الطائرة لتلتفت: هل الروبوت على يمينها أم على يسارها؟ وحاصل الضرب النقطي لا يعرف ذلك، لأن جيب التمام متساو للزاوية 30 يميناً و30 يساراً. والذي يعرفه هو ما يسمى في البعدين حاصل الضرب الاتجاهي Cross Product، وهو رقم واحد أيضاً، وإشارته تقول في أي جهة يقع المتجه الثاني بالنسبة للأول. ولكن هنا يأتي أثر محور y المقلوب: في الشاشة التي يزيد فيها y إلى الأسفل، الإشارة الموجبة تعني اتجاه عقارب الساعة، أي يمين الطائرة، وفي كتب الرياضيات العكس. ولذلك فالروبوت الثاني الذي فوق الطائرة وأمامها على يسارها، وهذا صحيح، لأن الطائرة تنظر إلى الشرق، والأعلى في الشاشة هو الشمال، والشمال على يسار من ينظر إلى الشرق. وإذا انعكس اليمين واليسار في لعبتك، فأول ما تفحصه هو اتجاه المحور y.

### الخطأ الذي يجعل الطائرة ترى أبعد

وكل ما سبق صحيح بشرط واحد: أن يكون المتجهان بطول 1\. والجزء الثاني من البرنامج يحسب حاصل الضرب النقطي دون توحيد طول المتجه إلى الروبوت:

```text
(640.00, 150.00) raw dot   160.0  normalised 0.800
(900.00, 300.00) raw dot   420.0  normalised 0.997
```

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

## التصادم Collision: هل لمس الروبوت الرف؟

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

```python
# 4) Collision tests: box against box (AABB), circle against circle, circle against box, and how many pairs a frame costs.
import random
import time
from vec import Vec2

class Box:                                  # axis-aligned: x, y is the top-left corner
    def __init__(self, x, y, w, h): self.x, self.y, self.w, self.h = x, y, w, h

def aabb_overlap(a, b):
    return a.x < b.x + b.w and b.x < a.x + a.w and a.y < b.y + b.h and b.y < a.y + a.h

def circles_overlap(c1, r1, c2, r2):
    return (c2 - c1).length_sq() < (r1 + r2) ** 2      # compare squares, no square root

def circle_box(c, r, b):
    nearest = Vec2(min(max(c.x, b.x), b.x + b.w), min(max(c.y, b.y), b.y + b.h))   # clamp the centre into the box
    return (c - nearest).length_sq() < r * r, nearest

print("### 1. box against box")
robot = Box(100, 100, 32, 32)
for name, b in [("shelf A", Box(120, 120, 64, 16)), ("shelf B", Box(132, 100, 40, 40)), ("shelf C", Box(60, 140, 30, 30))]:
    print(f"robot vs {name}: {aabb_overlap(robot, b)}")

print("### 2. circle against circle")
c1, r1 = Vec2(200, 200), 16
for c2, r2 in [(Vec2(230, 210), 20), (Vec2(226, 226), 20), (Vec2(236, 200), 20)]:
    d = (c2 - c1).length()
    print(f"barrel at {c2}: distance {d:.2f}, radii {r1 + r2}, hit {circles_overlap(c1, r1, c2, r2)}")

print("### 3. boxes around circles: the corner false alarm")
c2, r2 = Vec2(226, 226), 20
box1, box2 = Box(c1.x - r1, c1.y - r1, 2 * r1, 2 * r1), Box(c2.x - r2, c2.y - r2, 2 * r2, 2 * r2)
print(f"bounding boxes overlap: {aabb_overlap(box1, box2)}, circles overlap: {circles_overlap(c1, r1, c2, r2)}")

print("### 4. circle against box")
shelf = Box(300, 100, 120, 40)
for c in [Vec2(290, 120), Vec2(287, 88), Vec2(295, 92), Vec2(360, 150)]:
    hit, near = circle_box(c, 16, shelf)
    print(f"robot at {c}: nearest point {near}, distance {(c - near).length():.2f}, hit {hit}")

print("### 5. how many pairs per frame")
random.seed(7)
for n in [100, 500, 2000]:
    objs = [(Vec2(random.uniform(0, 1920), random.uniform(0, 1080)), 12) for _ in range(n)]
    t = time.perf_counter(); naive_pairs = hits = 0
    for i in range(n):
        for j in range(i + 1, n):
            naive_pairs += 1
            hits += circles_overlap(objs[i][0], 12, objs[j][0], 12)
    t_naive = time.perf_counter() - t
    CELL = 64                                  # uniform grid: only neighbours in the same or adjacent cells are tested
    t = time.perf_counter(); grid = {}
    for i, (p, _) in enumerate(objs): grid.setdefault((int(p.x // CELL), int(p.y // CELL)), []).append(i)
    grid_pairs = ghits = 0
    for (cx, cy), ids in grid.items():
        for dx in (-1, 0, 1):
            for dy in (-1, 0, 1):
                for j in grid.get((cx + dx, cy + dy), []):
                    for i in ids:
                        if i < j:
                            grid_pairs += 1
                            ghits += circles_overlap(objs[i][0], 12, objs[j][0], 12)
    t_grid = time.perf_counter() - t
    print(f"n={n:<5} all pairs {naive_pairs:>8} ({t_naive * 1000:7.1f} ms)  grid pairs {grid_pairs:>6} ({t_grid * 1000:5.1f} ms)  hits {hits}/{ghits}")
```

![أربع لوحات: الأولى من اليمين صندوق رمادي وصندوق بني متداخلان والجزء المشترك أحمر، وخطان أزرقان يبينان التداخل على x وعلى y. الثانية دائرتان متداخلتان وخط بين مركزيهما مكتوب تحته المسافة أقل من مجموع نصفي القطرين. الثالثة دائرة رمادية بجانب زاوية صندوق بني وخط أحمر من مركز الدائرة إلى أقرب نقطة في الصندوق. الرابعة دائرتان لا تتلامسان وحول كل منهما مربع متقطع، والمربعان يتداخلان في زاوية صغيرة حمراء، ومكتوب الصناديق صحيح والدوائر خطأ](https://arabroot.io/content/images/2026/11/game-math-05-collision.webp)

ثلاثة اختبارات تكفي لأغلب الألعاب ثنائية الأبعاد، والرابع يبين ثمن استخدام الصندوق لشيء دائري.

### الصندوق مع الصندوق AABB

أبسط شكل صندوق جوانبه موازية لمحوري الشاشة، أي لا يدور، ويسمى AABB اختصاراً لـ Axis-Aligned Bounding Box. والصندوق يكفيه أربعة أرقام: موقع الزاوية العليا اليسرى، والعرض والارتفاع. والسؤال عن تداخل صندوقين له إجابة جميلة: الصندوقان يتداخلان إذا وفقط إذا تداخل مداهما على المحور x وتداخل مداهما على المحور y معاً. فإذا كان بينهما فراغ على أي محور منهما فلا تصادم، مهما كانا قريبين على المحور الآخر. وهذا ما تفعله الدالة `aabb_overlap` بأربع مقارنات فقط، والمخرج:

```text
robot vs shelf A: True
robot vs shelf B: False
robot vs shelf C: False
```

الروبوت صندوق 32 في 32 عند `(100, 100)`، فهو يغطي x من 100 إلى 132\. والرف A يتداخل معه على المحورين. والرف B يبدأ عند x تساوي 132 بالضبط، أي أنه يلمس حافة الروبوت دون أن يدخل فيه، ولاحظ أننا استخدمنا علامة «أقل من» لا «أقل من أو يساوي»، فالحافة المشتركة ليست تصادماً، وهذا قرار عليك أن تتخذه بوعي، لأن الروبوت الذي يقف ملاصقاً للرف يجب ألا يعتبر داخله، وإلا علق ولم يستطع التحرك. أما الرف C فيتداخل مع الروبوت على y ولكنه ينتهي عند x تساوي 90، وبالتالي فلا تصادم.

### الدائرة مع الدائرة

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

```text
barrel at (230.00, 210.00): distance 31.62, radii 36, hit True
barrel at (226.00, 226.00): distance 36.77, radii 36, hit False
barrel at (236.00, 200.00): distance 36.00, radii 36, hit False
```

الروبوت هنا دائرة نصف قطرها 16، والبرميل 20، فالمجموع 36\. البرميل الأول على بعد 31.62 فهو يلمس الروبوت، والثاني على بعد 36.77 فلا يلمسه، والثالث على بعد 36 بالضبط، أي أن الدائرتين تتماسان في نقطة واحدة، وقد اعتبرناها ليست تصادماً بالمنطق نفسه الذي استخدمناه للصناديق.

### لماذا لا نضع البرميل في صندوق؟

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

```text
bounding boxes overlap: True, circles overlap: False
```

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

### الدائرة مع الصندوق

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

```text
robot at (290.00, 120.00): nearest point (300.00, 120.00), distance 10.00, hit True
robot at (287.00, 88.00): nearest point (300.00, 100.00), distance 17.69, hit False
robot at (295.00, 92.00): nearest point (300.00, 100.00), distance 9.43, hit True
robot at (360.00, 150.00): nearest point (360.00, 140.00), distance 10.00, hit True
```

والقراءة كما يلي:

- الروبوت الأول على يسار الرف، وأقرب نقطة على الحافة اليسرى `(300, 120)` على بعد 10، ونصف القطر 16، فهو يلمسه.
- الثاني والثالث قرب الزاوية العليا اليسرى، وأقرب نقطة لكل منهما هي الزاوية نفسها `(300, 100)`. الثاني على بعد 17.69 فلا يلمسه، والثالث على بعد 9.43 فيلمسه. ولاحظ أن الروبوت الثاني لو كان صندوقاً لاعتبر ملامساً، وهذا خطأ الزاوية نفسه الذي رأيناه في البراميل.
- الرابع تحت الرف، وأقرب نقطة على الحافة السفلى.

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

## كم اختباراً في كل إطار؟

كل اختبار من الاختبارات السابقة رخيص جداً، بضع عمليات ضرب ومقارنة. ولكن لنفرض أن في المستودع 500 شيء، روبوتات وبراميل وطرود وسهام، وأننا نريد أن نعرف كل زوج يتلامس. والطريقة البسيطة أن نختبر كل شيء مع كل شيء آخر، وعدد الأزواج هنا 500 ضرب 499 مقسومة على 2، أي 124,750 اختباراً في كل إطار، والعدد ينمو مع مربع عدد الأشياء، فإذا تضاعف عدد الأشياء تضاعف عدد الاختبارات أربع مرات. والجزء الخامس من البرنامج يقيس ذلك على دوائر في أماكن عشوائية على شاشة 1920 في 1080:

```text
n=100   all pairs     4950 (   15.6 ms)  grid pairs     76 (  0.9 ms)  hits 0/0
n=500   all pairs   124750 (  490.5 ms)  grid pairs   2038 ( 13.0 ms)  hits 116/116
n=2000  all pairs  1999000 ( 5957.5 ms)  grid pairs  33553 (147.3 ms)  hits 1687/1687
```

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

- مع 500 شيء نزل عدد الاختبارات من 124,750 إلى 2,038، والتصادمات المكتشفة 116 في الطريقتين، أي أننا لم نخسر أي تصادم.
- مع 2,000 شيء نزل العدد من قرابة مليوني اختبار إلى 33,553، والتصادمات 1,687 في الطريقتين.
- الأزمنة في المخرج من Python وهي أبطأ بكثير من محرك ألعاب مكتوب بـ C++، ولذلك لا تنظر إلى الأرقام نفسها، وإنما إلى النسبة بين العمودين: عشرات المرات.

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

## الارتداد Bounce: معادلة الانعكاس

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

والطريقة العامة تحتاج متجهاً جديداً اسمه العمودي Normal، وهو متجه بطول 1 يخرج من سطح الجدار عمودياً عليه. وفكرة الارتداد أن سرعة الكرة تتكون من جزأين: جزء مواز للجدار، وهذا يبقى كما هو، وجزء داخل في الجدار، وهذا ينقلب. والجزء الداخل في الجدار نحصل عليه بحاصل الضرب النقطي بين السرعة والعمودي، وهذا استخدام ثان للعملية نفسها التي استخدمناها مع الطائرة، فالمعادلة تكتب كما يلي: السرعة الجديدة تساوي السرعة القديمة ناقص ضعفي حاصل الضرب النقطي مضروباً في العمودي. ووثائق Godot تصف الفكرة نفسها: نأخذ الحركة الباقية بعد التصادم [ونعكسها باستخدام العمودي](https://docs.godotengine.org/en/stable/tutorials/math/vector%5Fmath.html?ref=arabroot.io)، وتوفر لذلك الدالة `bounce()`. والبرنامج الخامس:

```python
# 5) Bounce: reflecting the velocity on the wall's normal, r = v - 2 (v . n) n
import math
from vec import Vec2

def reflect(v, n):
    return v - n * (2 * v.dot(n))

print("### 1. floor and side wall")
v = Vec2(300, 200)                          # moving right and down
for name, n in [("floor", Vec2(0, -1)), ("right wall", Vec2(-1, 0))]:
    r = reflect(v, n)
    print(f"{name:<11} n={n}  v={v}  v.n={v.dot(n):7.1f}  r={r}  speed {v.length():.1f} -> {r.length():.1f}")

print("### 2. a 45 degree ramp")
v = Vec2(300, 0)                            # moving right into a ramp that faces up-left
for name, n in [("normalised n", Vec2(-1, -1).normalized()), ("raw (-1,-1)", Vec2(-1, -1))]:
    r = reflect(v, n)
    print(f"{name:<13} n={n}  r={r}  speed {v.length():.1f} -> {r.length():.1f}")

print("### 3. losing energy on each bounce (restitution 0.8)")
v, e = Vec2(0, 400), 0.8                    # dropping straight down
for k in range(1, 6):
    n = Vec2(0, -1)
    vn = v.dot(n)
    v = v - n * ((1 + e) * vn)              # only the part into the wall is scaled by e
    print(f"bounce {k}: speed {v.length():6.1f} px/s, peak height {v.length() ** 2 / (2 * 980):5.1f} px")
```

والجزء الأول من المخرج:

```text
floor       n=(0.00, -1.00)  v=(300.00, 200.00)  v.n= -200.0  r=(300.00, -200.00)  speed 360.6 -> 360.6
right wall  n=(-1.00, 0.00)  v=(300.00, 200.00)  v.n= -300.0  r=(-300.00, 200.00)  speed 360.6 -> 360.6
```

![لوحتان: على اليمين أرض رمادية وسهم أزرق نازل نحوها هو السرعة 300 و200، وسهم أخضر يخرج من الأرض إلى الأعلى هو العمودي n، وخط أحمر متقطع يبين الجزء الداخل في الأرض، وسهم برتقالي صاعد هو السرعة بعد الارتداد 300 وسالب 200، والمعادلة وسرعة 360.6 قبل وبعد. وعلى اليسار منحدر رمادي بزاوية 45 درجة وسهم أزرق أفقي يصطدم به، وسهم أخضر صاعد طوله 300 بالعمودي الموحد، وسهم أحمر متقطع أطول بكثير مائل إلى الأعلى واليسار مكتوب عنده 670.8 بالعمودي غير الموحد](https://arabroot.io/content/images/2026/11/game-math-06-bounce.webp)

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

عند الأرض العمودي `(0, -1)`، أي إلى الأعلى، وحاصل الضرب النقطي سالب 200، وهو بالضبط الجزء العمودي من السرعة بإشارة تقول إنه داخل في الأرض. وبعد التطبيق انقلبت y من 200 إلى سالب 200 وبقيت x كما هي، وهي النتيجة نفسها التي كنا نحصل عليها بعكس الإشارة، ولكن الآن من معادلة تعمل مع أي سطح. ولاحظ أن السرعة الكلية 360.6 قبل وبعد، فالارتداد المثالي لا يضيع طاقة.

### المنحدر والعمودي غير الموحد

والآن المنحدر، والكرة تتحرك أفقياً إلى اليمين بسرعة 300، والمنحدر يواجه الأعلى واليسار، فعموديه في الاتجاه `(-1, -1)`:

```text
normalised n  n=(-0.71, -0.71)  r=(0.00, -300.00)  speed 300.0 -> 300.0
raw (-1,-1)   n=(-1.00, -1.00)  r=(-300.00, -600.00)  speed 300.0 -> 670.8
```

بالعمودي الموحد `(-0.71, -0.71)` خرجت الكرة إلى الأعلى مباشرة بسرعة 300، وهذا ما تتوقعه من سطح بزاوية 45 درجة، فالحركة الأفقية تحولت إلى حركة عمودية. أما بالعمودي كما كتبناه `(-1, -1)` دون توحيد فقد خرجت الكرة بسرعة 670.8، أي أكثر من ضعف سرعتها، وفي اتجاه خاطئ. والسبب نفسه الذي رأيناه في الطائرة، فالمعادلة تفترض أن طول العمودي 1، وإذا لم يكن كذلك فحاصل الضرب النقطي يكبر ويضرب مرة ثانية في العمودي الطويل. وهذا الخطأ يظهر في الألعاب ككرة تكتسب سرعة مع كل ارتداد على المنحدرات حتى تطير خارج الشاشة، ولذلك لا تكتب العمودي يدوياً إلا بعد توحيد طوله، والمحركات ترجع لك العمودي موحداً في نتيجة التصادم.

### الطاقة التي تضيع مع كل ارتداد

الكرة الحقيقية لا ترتد إلى الارتفاع نفسه، وإنما تخسر جزءاً من سرعتها في كل ارتداد، والرقم الذي يحدد ذلك يسمى معامل الارتداد Restitution، وهو 1 للارتداد المثالي و0 لكرة من الطين تلتصق بالأرض. والطريقة الصحيحة أن نضرب المعامل في الجزء الداخل في السطح فقط، أما الجزء الموازي فهذا موضوع الاحتكاك Friction. والجزء الثالث يسقط كرة بسرعة 400 بمعامل 0.8:

```text
bounce 1: speed  320.0 px/s, peak height  52.2 px
bounce 2: speed  256.0 px/s, peak height  33.4 px
bounce 3: speed  204.8 px/s, peak height  21.4 px
bounce 4: speed  163.8 px/s, peak height  13.7 px
bounce 5: speed  131.1 px/s, peak height   8.8 px
```

كل ارتداد يأخذ 80 في المئة من السرعة، فالسرعة 320 ثم 256 ثم 204.8، وأقصى ارتفاع تصل إليه الكرة، محسوباً بجاذبية 980 نقطة في الثانية مربعة، ينزل من 52.2 إلى 8.8 بعد خمسة ارتدادات. ولاحظ أن الارتفاع ينزل أسرع من السرعة، لأنه يتناسب مع مربعها، فالسرعة نزلت إلى 0.8 في كل مرة والارتفاع نزل إلى 0.64\. وفي اللعبة سوف تحتاج شرطاً يوقف الكرة عندما تصبح سرعتها صغيرة جداً، وإلا فإنها ترتجف على الأرض بارتدادات لا تراها العين، وهي المشكلة نفسها التي رأيناها في الروبوت عند الوصول.

## النفق Tunneling: السهم الذي عبر الجدار

الآن نصل إلى أغرب خطأ في هذا المقال، وأكثرها إرباكاً عندما تراه أول مرة. آلة الاختبار في المستودع ترمي سهاماً صغيرة بسرعة 3,000 نقطة في الثانية على جدار سمكه 16 نقطة، وكل اختبارات التصادم السابقة تعمل بالطريقة نفسها: نحرك الجسم خطوة، ثم نسأل هل هو داخل الجدار الآن؟ والمشكلة أن السهم في إطار واحد على 60 إطاراً في الثانية يتحرك 50 نقطة، والجدار سمكه 16، فإذا كان السهم قبل الجدار بقليل في إطار، فإنه في الإطار التالي يكون بعد الجدار، ولم يكن داخله في أي إطار، فالاختبار لا يرى شيئاً، والسهم يعبر الجدار كأنه غير موجود. وهذا ما يسمى النفق Tunneling، ووثائق محرك الفيزياء Box2D تعرفه كما يلي: [«إذا لم يأخذ محرك الفيزياء الحركة الكبيرة في الحساب فقد ترى بعض الأجسام تمر خلال بعضها بشكل خاطئ، وهذا الأثر يسمى النفق»](https://box2d.org/documentation/md%5Fsimulation.html?ref=arabroot.io). والبرنامج السادس:

```python
# 6) Tunneling: a fast dart against a thin wall, checked once per frame, then with a swept test and with sub-steps.
import math

SPEED = 3000.0                              # px/s, a dart fired to the right
WALL_X, WALL_W = 500.0, 16.0                # the wall covers x from 500 to 516

def inside_wall(x):
    return WALL_X <= x <= WALL_X + WALL_W

def discrete(start, fps, trace=False):
    """Move, then ask: is the dart inside the wall now? Returns True on a hit."""
    dt, x = 1 / fps, start
    while x < WALL_X + WALL_W:
        prev, x = x, x + SPEED * dt
        if trace and x > 400:
            print(f"   frame: x {prev:6.1f} -> {x:6.1f}  inside wall: {inside_wall(x)}")
        if inside_wall(x):
            return True
    return False

def swept(start, fps):
    """Ask about the whole path of the frame: does the segment prev..x cross the wall's front face?"""
    dt, x = 1 / fps, start
    while x < WALL_X + WALL_W:
        prev, x = x, x + SPEED * dt
        if prev <= WALL_X <= x or inside_wall(x):
            return True
    return False

print("### 1. one dart at 60 fps, from two start points")
for start in (7.0, 27.0):
    print(f" start x={start}")
    print(f" result: {'HIT' if discrete(start, 60, trace=True) else 'PASSED THROUGH'}")

STARTS = [i * 0.97 for i in range(100)]     # 100 darts fired from slightly different places
print("### 2. 100 darts, one check per frame against swept")
print(f"{'fps':>4} {'step px':>8} {'passed (per frame)':>19} {'passed (swept)':>15}")
for fps in [30, 60, 144, 240]:
    miss_d = sum(not discrete(s, fps) for s in STARTS)
    miss_s = sum(not swept(s, fps) for s in STARTS)
    print(f"{fps:>4} {SPEED / fps:>8.1f} {miss_d:>15}/100 {miss_s:>11}/100")

print("### 3. sub-steps instead")
for fps in [30, 60]:
    step = SPEED / fps
    n = math.ceil(step / WALL_W)            # each sub-step must be shorter than the wall is thick
    print(f"{fps:>4} fps  step {step:.1f} px  sub-steps needed {n}  sub-step {step / n:.1f} px")
```

والجزء الأول من المخرج يطلق سهمين على 60 إطاراً في الثانية، الأول من x تساوي 7 والثاني من 27، ويطبع آخر ثلاثة إطارات قبل الجدار:

```text
 start x=7.0
   frame: x  357.0 ->  407.0  inside wall: False
   frame: x  407.0 ->  457.0  inside wall: False
   frame: x  457.0 ->  507.0  inside wall: True
 result: HIT
 start x=27.0
   frame: x  377.0 ->  427.0  inside wall: False
   frame: x  427.0 ->  477.0  inside wall: False
   frame: x  477.0 ->  527.0  inside wall: False
 result: PASSED THROUGH
```

السهم الأول كان عند 457 ثم أصبح عند 507، والجدار من 500 إلى 516، فوقع داخله والاختبار اكتشفه. والسهم الثاني الذي انطلق أبعد بعشرين نقطة فقط كان عند 477 ثم أصبح عند 527، أي أنه قبل الجدار في إطار وبعده في الإطار التالي، ولم يكن داخله في أي لحظة رآها الكود، فمر. والسهمان بالسرعة نفسها وعلى الجدار نفسه، والفرق الوحيد أين وقعت الإطارات، وهذا ما يجعل الخطأ صعب الاكتشاف: يحدث أحياناً، ولا يتكرر عندما تحاول أن تعيده.

![في الأعلى بخلفية حمراء فاتحة ثلاث نقاط زرقاء لمواقع السهم 427 و477 و527 وجدار رمادي بينها من 500 إلى 516، وقوس أحمر مكتوب عليه 50 نقطة يقفز من 477 إلى 527 فوق الجدار ومكتوب لم يلمس شيئاً. وفي الأسفل بخلفية خضراء فاتحة الموقعان 427 و477 وخط أخضر من 477 يصل إلى الجدار وينتهي بنقطة خضراء ومكتوب الخط يقطع الجدار وأصاب عند 500. وعلى اليمين أعمدة أفقية لعدد السهام التي عبرت من 100: 83 على 30 إطاراً، و66 على 60، و21 على 144، وصفر على 240](https://arabroot.io/content/images/2026/11/game-math-07-tunnel.webp)

الاختبار في كل إطار يرى نقاطاً متفرقة، والسهم السريع قد يقع قبل الجدار وبعده دون أن يقع داخله.

والجزء الثاني يطلق 100 سهم من أماكن مختلفة قليلاً، ويعد كم سهماً عبر الجدار على أربع سرعات إطارات:

```text
 fps  step px  passed (per frame)  passed (swept)
  30    100.0              83/100           0/100
  60     50.0              66/100           0/100
 144     20.8              21/100           0/100
 240     12.5               0/100           0/100
```

والقراءة كما يلي:

- على 30 إطاراً في الثانية الخطوة 100 نقطة، وعبر الجدار 83 سهماً من 100\. وعلى 60 الخطوة 50 وعبر 66، وعلى 144 الخطوة 20.8 وعبر 21.
- والنسبة يمكن توقعها: السهم يصيب فقط إذا وقع أحد إطاراته داخل الجدار، واحتمال ذلك سمك الجدار مقسوماً على طول الخطوة، فعلى 60 إطاراً هو 16 من 50، أي 32 في المئة، والباقي 68، وهذا قريب جداً من 66 التي خرجت في المختبر.
- على 240 إطاراً الخطوة 12.5، وهي أقصر من سمك الجدار، فلا يمكن أن يقفز السهم فوقه، والنتيجة صفر.

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

### الحلول: الفحص على المسار والخطوات الصغيرة

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

والحل الثاني أن نقسم حركة الإطار الواحد إلى خطوات أصغر Sub-steps، كل واحدة أقصر من سمك أرق جدار:

```text
  30 fps  step 100.0 px  sub-steps needed 7  sub-step 14.3 px
  60 fps  step 50.0 px  sub-steps needed 4  sub-step 12.5 px
```

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

والمحركات تعطيك الحلين كخيار تفعله للجسم الذي تحتاجه، فمحرك Godot فيه للأجسام الفيزيائية خاصية [continuous\_cd](https://docs.godotengine.org/en/stable/classes/class%5Frigidbody2d.html?ref=arabroot.io)، أي الاكتشاف المستمر للتصادم Continuous Collision Detection واختصاراً CCD، ووثائقه تقول إن الوضع الافتراضي المعطل هو الأسرع ولكنه قد يفوت الأجسام الصغيرة السريعة، وإن الاكتشاف المستمر أبطأ ولكنه أدق ويفوت عدداً أقل منها، وله طريقتان: بشعاع Ray وهي أسرع، وبالشكل كاملاً Shape وهي الأدق والأبطأ. وفي Box2D توجد خاصية مشابهة، فالأجسام السريعة [يمكن إعدادها كطلقات Bullets](https://box2d.org/documentation/md%5Fsimulation.html?ref=arabroot.io)، ومطور المحرك ينصح باستخدامها باعتدال. والقاعدة العملية: فعل الاكتشاف المستمر للطلقات والسهام والكرات السريعة فقط، واترك الباقي على الوضع الافتراضي.

## بعيداً عن نقطة الأصل: عندما يتوقف الشيء البطيء

بقيت مشكلة أخيرة لا تظهر في مستودعنا الصغير، ولكنها تظهر عندما يكبر العالم، في لعبة استكشاف مثلاً أو لعبة فضاء. المواقع في المحركات تخزن كأرقام عشرية بدقة محدودة، وفي Godot تقول [وثائق الإحداثيات الكبيرة](https://docs.godotengine.org/en/stable/tutorials/physics/large%5Fworld%5Fcoordinates.html?ref=arabroot.io) إن الرقم العشري في GDScript بطول 64 بت، ولكن المتجهات `Vector2` و`Vector3` بطول 32 بت افتراضياً، وإن الدقة تقل تدريجياً كلما ابتعد الرقم عن الصفر. وكيف تخزن الأرقام العشرية ولماذا تقل دقتها شرحناه في [مقال Floating Point من الداخل](https://arabroot.io/articles/%D8%A7%D9%84%D8%A3%D8%B1%D9%82%D8%A7%D9%85-%D8%A7%D9%84%D8%B9%D8%B4%D8%B1%D9%8A%D8%A9-floating-point-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/)، وهنا نرى أثر ذلك على الحركة مباشرة. والبرنامج السابع يحرك شيئين لمدة ثانية، 60 إطاراً، ويخزن الموقع بعد كل إطار كرقم 32 بت، كما يفعل المحرك، ويكرر ذلك على مسافات مختلفة من نقطة الأصل:

```python
# 7) Far from the origin: positions stored as 32-bit floats (the default for Vector2 in Godot) lose small steps.
import struct

def f32(x):                                  # round a Python float (64-bit) to the nearest 32-bit float
    return struct.unpack("f", struct.pack("f", x))[0]

def gap(x):                                  # distance to the next representable 32-bit float above x
    i = struct.unpack("I", struct.pack("f", x))[0]
    return struct.unpack("f", struct.pack("I", i + 1))[0] - f32(x)

STEPS = {"robot 200 px/s at 60 fps": 200 / 60, "slow belt 0.6 px/s at 60 fps": 0.6 / 60}
print(f"{'x':>11} {'float32 gap':>12}   " + "   ".join(f"{k} (moved in 60 frames)" for k in STEPS))
for x0 in [100.0, 10_000.0, 100_000.0, 1_000_000.0, 10_000_000.0]:
    cols = []
    for step in STEPS.values():
        x = f32(x0)
        for _ in range(60):
            x = f32(x + step)                # every frame the engine stores the result as float32
        cols.append(f"{x - f32(x0):>12.4f}")
    print(f"{x0:>11.0f} {gap(x0):>12.6f}   {cols[0]:>32}   {cols[1]:>36}")
print("exact answers:", round(200 / 60 * 60, 4), "and", round(0.6 / 60 * 60, 4))
```

والمخرج:

```text
          x  float32 gap   robot 200 px/s at 60 fps (moved in 60 frames)   slow belt 0.6 px/s at 60 fps (moved in 60 frames)
        100     0.000008                           200.0000                                 0.6001
      10000     0.000977                           199.9805                                 0.5859
     100000     0.007812                           200.1562                                 0.4688
    1000000     0.062500                           198.7500                                 0.0000
   10000000     1.000000                           180.0000                                 0.0000
exact answers: 200.0 and 0.6
```

والقراءة كما يلي:

- العمود الثاني هو أصغر فرق يمكن تمثيله عند هذا الموقع، أي المسافة بين الرقم والرقم الذي يليه مباشرة. عند 100 الفرق 0.000008، وعند مليون 0.0625، وعند عشرة ملايين نقطة كاملة.
- الروبوت بسرعة 200 يجب أن يتحرك 200 بالضبط، وهذا ما حدث عند 100\. عند 100,000 تحرك 200.16، وعند مليون 198.75، وعند عشرة ملايين 180 فقط، أي أنه أبطأ بعشرة في المئة لأن كل خطوة تقرب إلى أقرب رقم يمكن تمثيله.
- والسير البطيء الذي يتحرك 0.01 نقطة في كل إطار هو الأسوأ: عند 100,000 تحرك 0.47 بدل 0.6، وعند مليون لم يتحرك أبداً، لأن خطوته أصغر من نصف الفرق بين رقمين متجاورين، فكل إطار يقرب الموقع الجديد إلى الموقع القديم نفسه.

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

## الأخطاء الشائعة وكيف تكتشفها

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

| الخطأ                      | ما تراه في اللعبة                                    | الحل                                                |
| -------------------------- | ---------------------------------------------------- | --------------------------------------------------- |
| الحركة ثابتة لكل إطار      | اللعبة أسرع على الشاشات السريعة                      | السرعة في الثانية مضروبة في زمن الإطار              |
| لا يوجد فحص للوصول         | الشيء يرتجف فوق الهدف ولا يستقر                      | إذا كانت المسافة الباقية أقل من خطوة فضعه على الهدف |
| جمع الأزرار دون توحيد      | القطر أسرع بنسبة 41 في المئة                         | توحيد الطول للوحة المفاتيح                          |
| توحيد طول عصا التحكم       | أقل ميل يعطي السرعة الكاملة                          | تحديد الطول بحد أعلى 1 ومنطقة ميتة                  |
| توحيد المتجه الصفري        | توقف البرنامج أو اختفاء الشيء بقيمة NaN              | افحص الطول قبل التوحيد                              |
| حاصل ضرب نقطي دون توحيد    | الحارس يرى بزاوية واسعة، والبعيد أسهل                | وحد المتجهين، وافحص المسافة وحدها                   |
| محور y المقلوب             | اليمين واليسار معكوسان                               | تذكر أن y يزيد إلى الأسفل في الشاشة                 |
| صندوق حول شيء دائري        | تصادم وبينهما فراغ واضح عند الزوايا                  | شكل تصادم قريب من الشكل الحقيقي                     |
| اختبار كل شيء مع كل شيء    | اللعبة تصبح أبطأ كلما زاد عدد الأشياء                | مرحلة عريضة بشبكة أو بمحرك الفيزياء                 |
| عمودي غير موحد في الارتداد | الكرة تكتسب سرعة على المنحدر                         | وحد العمودي أو خذه من نتيجة التصادم                 |
| جسم سريع وجدار رقيق        | الطلقة تعبر الجدار أحياناً، خاصة على الأجهزة الضعيفة | الاكتشاف المستمر CCD أو خطوات أصغر                  |
| عالم كبير بدقة 32 بت       | ارتجاف وحركة بطيئة تتوقف في أطراف العالم             | إبقاء اللاعب قرب نقطة الأصل أو الدقة المضاعفة       |

## تطبيق عملي

1. في البرنامج `01_vectors.py` غير سرعة الروبوت إلى 450، وتوقع قبل التشغيل: في أي إطار يصل؟ وهل يرتجف في النسخة دون فحص الوصول؟ ثم شغله وقارن.
2. في `03_front.py` اجعل الطائرة تنظر إلى الأسفل `(0, 1)` بدل اليمين، وتوقع لكل روبوت هل تراه، وعلى أي جانب منها يقع، ثم شغله وتأكد من فهمك لمحور y المقلوب.
3. في `04_collision.py` غير حجم مربع الشبكة `CELL` إلى 16 ثم إلى 256، ولاحظ عدد الاختبارات والزمن والتصادمات المكتشفة. لماذا لا يصلح مربع أصغر من قطر الدائرة؟
4. في `06_tunneling.py` اجعل سمك الجدار 4 نقاط، وأعد التشغيل، وكم سهماً يعبر الآن على 240 إطاراً؟ وكم خطوة صغيرة تحتاج على 60؟
5. أضف إلى `05_bounce.py` شرطاً يوقف الكرة عندما تنزل سرعتها عن 50، وكم ارتداداً تحتاج حتى تتوقف؟

## الخلاصة Summary

- المتجه رقمان، ويستخدم موقعاً أو إزاحة، والموقع ناقص الموقع يعطي الإزاحة، والموقع زائد الإزاحة يعطي موقعاً جديداً، وy على الشاشة يزيد إلى الأسفل.
- الطول من فيثاغورس، والاتجاه هو المتجه مقسوماً على طوله، والحركة هي الاتجاه ضرب السرعة في الثانية ضرب زمن الإطار، مع فحص الوصول قبل الخطوة الأخيرة.
- أزرار القطر تعطي سرعة أكبر بنسبة 41 في المئة، والحل توحيد الطول للوحة المفاتيح وتحديده بحد أعلى 1 لعصا التحكم، ولا توحد المتجه الصفري أبداً.
- حاصل الضرب النقطي لمتجهين بطول 1 هو جيب تمام الزاوية بينهما، ومنه تعرف ما أمام الحارس وما داخل مخروط رؤيته، وحاصل الضرب الاتجاهي يعرف اليمين من اليسار.
- التصادم على أشكال بسيطة: الصندوق بالتداخل على المحورين، والدائرة بالمسافة بين المركزين، والدائرة مع الصندوق بأقرب نقطة، والشبكة تقلل عدد الاختبارات عشرات المرات.
- الارتداد يعكس الجزء الداخل في السطح فقط، والعمودي يجب أن يكون بطول 1، ومعامل الارتداد يضيع جزءاً من السرعة في كل مرة.
- الجسم الأسرع من سمك الجدار في الإطار الواحد قد يعبره، وفي المختبر عبر 66 سهماً من 100 على 60 إطاراً وصفر بالفحص على المسار، والمحركات تحل ذلك بالاكتشاف المستمر CCD.
- المواقع بدقة 32 بت تفقد الخطوات الصغيرة بعيداً عن نقطة الأصل، وعند مليون نقطة توقف الشيء البطيء تماماً.

وفي المقالات القادمة من هذه المرحلة بإذن الله سوف نتحدث عن [حلقة اللعبة Game Loop](https://arabroot.io/articles/%D8%AD%D9%84%D9%82%D8%A9-%D8%A7%D9%84%D9%84%D8%B9%D8%A8%D8%A9-game-loop-%D9%88%D8%A7%D9%84%D8%A7%D8%B7%D8%A7%D8%B1%D8%A7%D8%AA-frames/) التي تكرر كل هذا الحساب في كل إطار وكيف يحسب زمن الإطار، ثم عن محركات الألعاب وكيف تختار بينها، ثم نبني أول لعبة كاملة مع Godot ونستخدم فيها الدوال الجاهزة التي كتبنا ما يشبهها هنا بأيدينا.

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

- نوفمبر 2026: كتابة المقال، وتشغيل المختبر على Python 3.13.5 في Docker Image الرسمية `python:3.13.5-slim` على Docker Engine 29.8.0.