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

الفيزياء والتصادم والتحكم Input في لعبة 2D

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

الفيزياء والتصادم والتحكم Input في لعبة 2D

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

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

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

  • اللعبة وقواعدها، وأنواع الأجسام الأربعة في Godot ومتى تختار كل واحد منها.
  • الجسم الذي تتحكم به CharacterBody2D والدالة move_and_slide، والجسم الفيزيائي الحر RigidBody2D.
  • طبقات التصادم وأقنعتها Collision Layers and Masks، وثلاثة أخطاء حقيقية رأيناها في المختبر.
  • خطوة الفيزياء Physics Tick والزمن delta: القفز نفسه على أربع سرعات للفيزياء.
  • مهلة الحافة Coyote Time وذاكرة القفز Jump Buffering، ولماذا تجعل اللعبة تبدو عادلة.
  • خريطة التحكم Input Map ويد التحكم Gamepad والمنطقة الميتة Deadzone.
  • النفق Tunneling في Godot: مئة رصاصة على جدار رفيع، وما الذي يوقفها فعلاً.
  • الأخطاء التي تتكرر، وجدول يساعدك في اختيار نوع الجسم.

اللعبة: جني التمر

اللعبة هذه المرة لعبة منصات Platformer صغيرة، وقواعدها كما يلي:

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

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

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

والرسوم كلها أشكال بسيطة من مضلعات Polygon2D ومستطيلات ColorRect، كما فعلنا في حصاد التمر، والسبب أن هذا المقال عن الحركة والتصادم، وما تراه في الصورة هو ما يراه محرك الفيزياء تقريباً. واللعبة كلها في مجلد lab/game: ملف المشروع، ومشهد لجامع التمر، ومشهد للتمرة، ومشهد للحجر، ومشهد للمرحلة، وسكربت المختبر الذي يشغل التجارب.

أنواع الأجسام: من يحرك الجسم؟

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

أربع بطاقات. StaticBody2D جسم ثابت: لا يحركه أحد ولا يتأثر بالجاذبية، وفي لعبتنا الأرض والمنصة. CharacterBody2D جسم تتحكم به: يحركه كودك بوضع السرعة velocity ثم move_and_slide، ويتأثر بالجاذبية فقط إذا أضفتها في الكود، وفي لعبتنا جامع التمر. RigidBody2D جسم فيزيائي حر: يحركه محرك الفيزياء بالجاذبية والدفع والارتداد، وفي لعبتنا الحجر الساقط. Area2D منطقة تكتشف: لا تصطدم بشيء وترسل إشارة عندما يدخلها جسم، وفي لعبتنا التمرة
أربع عقد للتصادم، والفرق بينها من يقرر الحركة
  • الجسم الثابت StaticBody2D: لا يتحرك، ولا تؤثر فيه الجاذبية ولا تدفعه الأجسام الأخرى، وهو الأرض والجدران والمنصات الثابتة. وهو الأرخص على المحرك، لأنه لا يحتاج حساب حركة في أي خطوة.
  • الجسم الذي تتحكم به CharacterBody2D: يصفه توثيق CharacterBody2D بأنه جسم مصمم ليتحكم به المستخدم، لا تؤثر فيه الفيزياء إطلاقاً، ولكنه يؤثر في الأجسام التي في طريقه. أي أن كودك يقرر سرعته في كل خطوة، والمحرك يحركه ويوقفه عند الجدار ويخبرك هل يقف على أرض.
  • الجسم الفيزيائي الحر RigidBody2D: المحرك هو الذي يحركه، بالجاذبية والاحتكاك والارتداد والتصادم، وأنت تعطيه قوة أو دفعة Impulse ثم تتركه. وهو مناسب للحجارة والصناديق والكرات، وكل شيء تريده أن يتصرف كما يتصرف في الواقع.
  • المنطقة Area2D: لا تصطدم بشيء ولا يوقفها شيء، وإنما تكتشف من دخلها ومن خرج منها، وقد استخدمناها في حصاد التمر للسلة والتمر، وهنا للتمرة التي يلتقطها جامع التمر.

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

الجسم الذي تتحكم به: CharacterBody2D

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

extends CharacterBody2D
## The picker: runs, jumps, and forgives a jump pressed a little late or a little early.

signal jumped

@export var speed := 260.0           # px per second
@export var jump_velocity := -560.0  # px per second, up is negative in 2D
@export var coyote_time := 0.10      # seconds after leaving a ledge when a jump still counts
@export var jump_buffer := 0.12      # seconds a jump press is remembered before landing
@export var gravity_per_tick := false   # the bug: gravity tuned at 60 ticks, added without delta

var coyote_left := 0.0
var buffer_left := 0.0

func _physics_process(delta: float) -> void:
	# 1) gravity, and the coyote clock that starts when the feet leave the floor
	if is_on_floor():
		coyote_left = coyote_time
	else:
		coyote_left -= delta
		if gravity_per_tick:
			velocity.y += 25.0                  # 1500 / 60: right only at 60 ticks per second
		else:
			velocity += get_gravity() * delta   # px/s² × s = px/s, right at any tick rate

	# 2) remember a jump press for a short time (jump buffering)
	if Input.is_action_just_pressed("jump"):
		buffer_left = jump_buffer
	var wants_jump := Input.is_action_just_pressed("jump") or buffer_left > 0.0
	buffer_left -= delta

	# 3) jump if the feet are on the floor, or left it less than coyote_time ago
	if wants_jump and (is_on_floor() or coyote_left > 0.0):
		velocity.y = jump_velocity
		buffer_left = 0.0
		coyote_left = 0.0
		jumped.emit()

	# 4) run: the same line serves the arrows, A/D, the D-pad and the left stick
	velocity.x = Input.get_axis("move_left", "move_right") * speed
	move_and_slide()

في السكربت أعلاه لاحظ التالي:

  • الخاصية velocity: سرعة الجسم بالبكسل في الثانية، وهي خاصية جاهزة في CharacterBody2D، نعدلها في كل خطوة ثم نستدعي move_and_slide() فيحرك المحرك الجسم بها.
  • الدالة move_and_slide(): تحرك الجسم بسرعته خلال خطوة فيزياء واحدة، فإذا اصطدم بشيء توقف عنده وانزلق على سطحه بدل أن يتوقف تماماً، ثم تحدث حالة الجسم: هل هو على أرض is_on_floor()، أو يلامس جداراً أو سقفاً. ولاحظ أننا لا نعطيها delta، لأنها تأخذ زمن الخطوة بنفسها.
  • الدالة get_gravity(): ترجع متجه الجاذبية في مكان الجسم، وهو 1500 بكسل في الثانية مربعة نحو الأسفل، من الإعداد 2d/default_gravity في ملف المشروع، فإذا وضعت الجسم داخل منطقة Area2D تغير الجاذبية، مثل الماء، تغيرت القيمة دون أن تغير سطراً هنا.
  • الإشارة jumped: يرسلها جامع التمر عندما يقفز فعلاً، والمختبر يستمع لها ليعرف هل تحولت الضغطة إلى قفز، والصوت في المقال القادم سوف يستمع لها أيضاً.
  • الخاصية gravity_per_tick: ليست جزءاً من اللعبة، وإنما وضعناها لنعيد في المختبر خطأ شائعاً بضغطة واحدة، وسوف نعود لها في قسم خطوة الفيزياء.

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

المشهد من الداخل: الشكل والطبقة والقناع

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

[gd_scene load_steps=3 format=3]

[ext_resource type="Script" path="res://player.gd" id="1"]

[sub_resource type="RectangleShape2D" id="body"]
size = Vector2(28, 44)

[node name="Player" type="CharacterBody2D"]
collision_layer = 2
collision_mask = 9
script = ExtResource("1")

[node name="Body" type="Polygon2D" parent="."]
color = Color(0.17, 0.42, 0.62, 1)
polygon = PackedVector2Array(-14, -14, -8, -22, 8, -22, 14, -14, 14, 22, -14, 22)

[node name="Face" type="Polygon2D" parent="."]
color = Color(0.98, 0.86, 0.68, 1)
polygon = PackedVector2Array(-8, -18, 8, -18, 8, -6, -8, -6)

[node name="Eye" type="Polygon2D" parent="."]
color = Color(0.1, 0.1, 0.12, 1)
polygon = PackedVector2Array(2, -15, 6, -15, 6, -11, 2, -11)

[node name="Shape" type="CollisionShape2D" parent="."]
shape = SubResource("body")

شكل التصادم مستطيل عرضه 28 وارتفاعه 44 بكسل، والشكل المرسوم مضلع بالحجم نفسه تقريباً. والسبب في أننا جعلنا شكل التصادم مستطيلاً بسيطاً، وليس مضلعاً يطابق الرسم، أن الأشكال البسيطة أسرع في الحساب وأكثر ثباتاً على الحواف، والمستطيل أو الكبسولة Capsule هما الاختيار المعتاد لشخصيات المنصات. وأما الرقمان collision_layer = 2 وcollision_mask = 9 فلهما قسم كامل بعد قليل.

الجسم الفيزيائي الحر: الحجر

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

[gd_scene load_steps=3 format=3]

[sub_resource type="PhysicsMaterial" id="m"]
bounce = 0.35

[sub_resource type="CircleShape2D" id="c"]
radius = 12.0

[node name="Stone" type="RigidBody2D"]
collision_layer = 8
collision_mask = 3
physics_material_override = SubResource("m")
contact_monitor = true
max_contacts_reported = 4

[node name="Body" type="Polygon2D" parent="."]
color = Color(0.5, 0.52, 0.56, 1)
polygon = PackedVector2Array(-12, -2, -8, -10, 2, -12, 10, -7, 12, 3, 7, 10, -3, 12, -10, 8)

[node name="Shape" type="CollisionShape2D" parent="."]
shape = SubResource("c")

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

  • مادة الفيزياء PhysicsMaterial: قيمة الارتداد bounce = 0.35 تعني أن الحجر يرتد بحوالي ثلث سرعته، فيرتد ارتدادات قليلة ثم يستقر، ولو جعلتها 1 لارتد إلى الارتفاع نفسه تقريباً كل مرة.
  • الخاصيتان contact_monitor وmax_contacts_reported: بدونهما لا يرسل RigidBody2D الإشارة body_entered أصلاً، وهذا من الأخطاء التي تضيع فيها ساعة: تربط الإشارة، ولا يحدث شيء، ولا يظهر خطأ. وبحسب توثيق RigidBody2D تقرير التلامس معطل افتراضياً لأنه يكلف حساباً إضافياً.
  • لا يوجد سكربت: وإذا أردت أن تؤثر في الحجر من الكود، فأعطه دفعة بالدالة apply_impulse أو قوة بالدالة apply_force، ولا تغير موضعه position مباشرة، لأن المحرك يحسب موضعه في خيط الفيزياء وقد يعيده إلى ما كان عليه أو يقفز به داخل جسم آخر. وإذا احتجت تحكماً دقيقاً في كل خطوة، فالتوثيق يوصي بالدالة _integrate_forces لأنها تعطيك حالة الجسم مباشرة بشكل آمن.

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

extends Area2D
## A date to pick. It only listens to the «player» layer (collision_mask = 2).

signal picked(by: Node)

func _ready() -> void:
	body_entered.connect(func(body: Node) -> void:
		picked.emit(body)
		queue_free())

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

طبقات التصادم وأقنعتها Collision Layers and Masks

كل عقدة تصادم في Godot لها رقمان: الطبقة Layer وهي المكان الذي يوجد فيه الجسم، والقناع Mask وهو الطبقات التي يراها الجسم ويتصادم معها. وفي توثيق الطبقات والأقنعة أن لكل جسم 32 طبقة، وأن كل الأجسام افتراضياً في الطبقة 1 وترى الطبقة 1. وأقرب تشبيه لها قنوات الراديو: الطبقة هي القناة التي تبث عليها، والقناع هو القنوات التي تستمع إليها، فإذا كنت لا تستمع إلى قناة لا يصلك منها شيء مهما ارتفع صوتها.

والطبقات في الكود أرقام، وكل طبقة لها بت Bit خاص بها، فالطبقة 1 قيمتها 1، والطبقة 2 قيمتها 2، والطبقة 3 قيمتها 4، والطبقة 4 قيمتها 8، وإذا أردت أن يرى الجسم أكثر من طبقة تجمع قيمها. ولأن الأرقام لا تقول شيئاً لمن يقرأ المشروع بعدك، أعطينا الطبقات أسماء في ملف المشروع، فيظهر الاسم في لوحة Inspector بدل الرقم:

[layer_names]
; Names for the bits of collision_layer / collision_mask (the Inspector shows these instead of numbers).
2d_physics/layer_1="world"
2d_physics/layer_2="player"
2d_physics/layer_3="pickups"
2d_physics/layer_4="hazards"

[physics]
2d/default_gravity=1500.0
common/physics_ticks_per_second=60

والشكل التالي يبين طبقة كل جسم في اللعبة وقناعه، والرقم الذي تجده في ملفات المشاهد:

جدول بأربعة أعمدة للطبقات: 1 world قيمتها 1، و2 player قيمتها 2، و3 pickups قيمتها 4، و4 hazards قيمتها 8. جامع التمر طبقته player وقناعه world وhazards، أي layer 2 وmask 9. التمرة طبقتها pickups وقناعها player، أي layer 4 وmask 2. الحجر طبقته hazards وقناعه world وplayer، أي layer 8 وmask 3. الأرض والمنصة طبقتها world. وتحت الجدول ثلاث ملاحظات: التمرة لا ترى إلا اللاعب، والحجر يرى الأرض واللاعب ويمر بالتمرة، والقيم الافتراضية الطبقة 1 والقناع 1 لكل عقدة جديدة
كل جسم في طبقة، ويرى الطبقات التي في قناعه فقط

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

المختبر: ثلاثة إعدادات للحجر والتمرة

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

func lab_layers() -> void:
	for n in [Area2D.new(), RigidBody2D.new(), CharacterBody2D.new(), StaticBody2D.new()]:
		print("new %-16s collision_layer=%d collision_mask=%d" % [n.get_class(), n.collision_layer, n.collision_mask])
		n.free()
	for case in ["defaults", "no world in the stone's mask", "named layers"]:
		print("--- %s" % case)
		var lv: Node2D = await fresh_level()
		var p: CharacterBody2D = lv.get_node("Player")
		var date: Area2D = lv.get_node("DateGround")
		var stone: RigidBody2D = StoneScene.instantiate()
		match case:
			"defaults":
				date.collision_mask = 1; stone.collision_layer = 1; stone.collision_mask = 1
			"no world in the stone's mask":
				stone.collision_mask = 2
		print("  player L=%d M=%d | date L=%d M=%d | stone L=%d M=%d" % [p.collision_layer, p.collision_mask,
			date.collision_layer, date.collision_mask, stone.collision_layer, stone.collision_mask])
		var t := [0]
		date.picked.connect(func(by): print("  tick %3d  date picked by %s" % [t[0], by.name]))
		stone.body_entered.connect(func(b): print("  tick %3d  stone touched %s" % [t[0], b.name]))
		stone.position = Vector2(940, 300)
		lv.add_child(stone)
		var s2: RigidBody2D = StoneScene.instantiate()
		s2.collision_layer = stone.collision_layer; s2.collision_mask = stone.collision_mask
		s2.body_entered.connect(func(b): print("  tick %3d  stone 2 touched %s" % [t[0], b.name]))
		s2.position = Vector2(80, 300)   # straight above the player
		lv.add_child(s2)
		for i in 90:
			if i == 5:
				p.position = Vector2(935, 448)   # put the player on the date
			await tick()
			t[0] += 1
		print("  after 90 ticks: stone y=%.0f, stone 2 y=%.0f%s" % [stone.position.y, s2.position.y,
			"  (fell out of the world)" if stone.position.y > 540 else ""])
		await drop(lv)

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

new Area2D           collision_layer=1 collision_mask=1
new RigidBody2D      collision_layer=1 collision_mask=1
new CharacterBody2D  collision_layer=1 collision_mask=1
new StaticBody2D     collision_layer=1 collision_mask=1
--- defaults
  player L=2 M=9 | date L=4 M=1 | stone L=1 M=1
  tick  24  stone touched Player
  tick  24  date picked by Stone
  tick  28  stone touched GroundRight
  tick  28  stone 2 touched GroundLeft
  tick  48  stone touched GroundRight
  tick  48  stone 2 touched GroundLeft
  tick  56  stone touched GroundRight
  tick  56  stone 2 touched GroundLeft
  tick  59  stone touched GroundRight
  tick  59  stone 2 touched GroundLeft
  after 90 ticks: stone y=458, stone 2 y=458
--- no world in the stone's mask
  player L=2 M=9 | date L=4 M=2 | stone L=8 M=2
  tick   6  date picked by Player
  tick  24  stone touched Player
  tick  26  stone touched Player
  tick  28  stone touched Player
  tick  30  stone touched Player
  after 90 ticks: stone y=414, stone 2 y=1925
--- named layers
  player L=2 M=9 | date L=4 M=2 | stone L=8 M=3
  tick   6  date picked by Player
  tick  24  stone touched Player
  tick  26  stone touched Player
  tick  28  stone touched Player
  tick  28  stone 2 touched GroundLeft
  tick  30  stone touched Player
  tick  48  stone 2 touched GroundLeft
  tick  56  stone 2 touched GroundLeft
  tick  59  stone 2 touched GroundLeft
  after 90 ticks: stone y=414, stone 2 y=458

والقراءة من الأعلى كما يلي:

  • الأسطر الأربعة الأولى: كل عقدة جديدة من الأنواع الأربعة تبدأ في الطبقة 1 وترى الطبقة 1، كما يقول التوثيق. أي أن كل شيء يرى كل شيء حتى تقسمه أنت، وهذا ما يجعل الخطأ التالي يحدث في أغلب المشاريع الأولى.
  • الإعداد الأول، القيم الافتراضية: تركنا التمرة والحجر على الطبقة 1 والقناع 1، كما تكون لو أنشأتهما ولم تغير شيئاً. وفي الخطوة 24 ظهر السطر الذي لا تتوقعه: date picked by Stone، أي أن الحجر هو الذي التقط التمرة. والسبب أن قناع التمرة 1 يرى الطبقة 1 التي فيها الحجر والأرض، ولا يرى الطبقة 2 التي فيها جامع التمر، فجامع التمر وقف فوق التمرة من الخطوة 6 ولم يحدث شيء، ثم جاء الحجر فالتقطها. وفي لعبة حقيقية يظهر هذا كتمرة تختفي وحدها من الشاشة، ونقطة لا تحسب لأحد.
  • والملاحظة الثانية في الإعداد الأول: في الخطوة 24 أرسل الحجر الإشارة stone touched Player، ومع ذلك لم يتوقف عند رأس جامع التمر، وإنما وصل إلى الأرض في الخطوة 28 ماراً بجسمه. فالحجر لا يرى طبقة جامع التمر في قناعه، ولذلك لم يرتد عنه، ولكن جامع التمر يرى الطبقة 1 التي كان فيها الحجر، فوصل التلامس إلى الإشارة. والدرس هنا أن وصول body_entered لا يعني أن الجسمين توقفا عند بعضهما، فلا تبن منطق الضرر على الإشارة وحدها قبل أن تراجع الطبقات في الاتجاهين.
  • الإعداد الثاني، قناع الحجر بلا أرض: وضعنا الحجر في طبقة hazards، ونسينا world في قناعه، فأصبح يرى جامع التمر فقط. فالحجر الأول وقف على رأس جامع التمر وبقي هناك، وموضعه 414 فوق الرأس مباشرة. وأما الحجر الثاني الذي لم يكن تحته أحد فقد عبر الأرض كأنها غير موجودة، ووصل بعد 90 خطوة إلى 1925 بكسل، أي خارج العالم كله. وهذا العرض تراه كثيراً في المنتديات تحت عنوان «الأشياء تسقط من الأرض»، وسببه في أغلب الأحيان قناع ينقصه بت واحد.
  • الإعداد الثالث، الطبقات بأسمائها: التمرة التقطها جامع التمر في الخطوة 6 بمجرد أن وقف عليها، والحجر الأول ارتد عن رأسه في الخطوات 24 إلى 30 ثم استقر عليه، والحجر الثاني سقط على الأرض وارتد عنها حتى استقر عند 458، أي على سطح الأرض تماماً. وهذا هو السلوك الذي صممناه في الجدول.
⚠️
إذا نقلت جسماً إلى مكان مباشرة بالخاصية position، كما يفعل المختبر هنا بجامع التمر، وكان في ذلك المكان جسم آخر، فالمحرك سوف يفصل بينهما بأقصر طريق، وقد يكون أقصر طريق للخروج هو أن يدفع الجسم الآخر عبر الأرض. ولذلك جعلنا النقل في الخطوة 5 قبل أن يصل الحجر، وفي لعبتك انقل الشخصيات إلى أماكن تعرف أنها فارغة، أو افحص المكان أولاً بالدالة test_move.

خطوة الفيزياء Physics Tick والزمن delta

في مقال حلقة اللعبة Game Loop شرحنا لماذا تفصل المحركات بين الرسم والفيزياء، ولماذا تعمل الفيزياء بخطوة ثابتة. وفي Godot عدد هذه الخطوات في الثانية هو الإعداد physics_ticks_per_second، وقيمته الافتراضية 60، والدالة _physics_process(delta) تستدعى مرة مع كل خطوة، وdelta فيها هو زمن الخطوة الواحدة: 1/60 ثانية على 60، و1/30 ثانية على 30. فإذا غيرت عدد الخطوات تغيرت delta معها، وهذا بالضبط ما يحمي لعبتك إذا كتبت الحسبة بشكل صحيح.

وهنا يأتي الخطأ الذي يقع فيه كل من ضبط لعبته على جهازه: يجرب الجاذبية فيجد أن إضافة 25 إلى السرعة في كل خطوة تعطي قفزاً جميلاً، فيكتب velocity.y += 25.0 وينسى أن هذا الرقم هو 1500 في الثانية مقسوماً على 60 خطوة. وهذا الكود يعمل تماماً كالكود الصحيح على 60 خطوة، ولذلك لا يكتشفه أحد حتى يغير أحد الفريق عدد الخطوات لسبب آخر، مثل تقليل النفق كما سيأتي.

المختبر: القفز نفسه على أربع سرعات للفيزياء

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

docker run --rm -v "$G:/game" "$IMG" godot --headless --fixed-fps 60 --path /game -- --lab jump

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

Godot 4.7.2-stable (official) | physics: DEFAULT | ticks/s: 60 | display: headless
ticks/s= 30  gravity*delta    apex= 114.1 px  air time=0.800 s (24 ticks)
ticks/s= 30  gravity per tick  apex= 218.6 px  air time=1.533 s (46 ticks)
  tick  1  t=0.017s  y= 448.0  velocity.y=    0.0  on_floor=true
  tick  2  t=0.033s  y= 438.6  velocity.y= -560.0  on_floor=false
  tick  3  t=0.050s  y= 429.7  velocity.y= -535.0  on_floor=false
  tick  4  t=0.067s  y= 421.2  velocity.y= -510.0  on_floor=false
  tick 20  t=0.333s  y= 341.8  velocity.y= -110.0  on_floor=false
  tick 21  t=0.350s  y= 340.4  velocity.y=  -85.0  on_floor=false
  tick 22  t=0.367s  y= 339.4  velocity.y=  -60.0  on_floor=false
  tick 23  t=0.383s  y= 338.8  velocity.y=  -35.0  on_floor=false
  tick 24  t=0.400s  y= 338.7  velocity.y=  -10.0  on_floor=false
  tick 43  t=0.717s  y= 414.7  velocity.y=  465.0  on_floor=false
  tick 44  t=0.733s  y= 422.8  velocity.y=  490.0  on_floor=false
  tick 45  t=0.750s  y= 431.4  velocity.y=  515.0  on_floor=false
  tick 46  t=0.767s  y= 440.4  velocity.y=  540.0  on_floor=false
  tick 47  t=0.783s  y= 448.0  velocity.y=    0.0  on_floor=true
ticks/s= 60  gravity*delta    apex= 109.3 px  air time=0.767 s (46 ticks)
ticks/s= 60  gravity per tick  apex= 109.3 px  air time=0.767 s (46 ticks)
ticks/s=120  gravity*delta    apex= 106.9 px  air time=0.758 s (91 ticks)
ticks/s=120  gravity per tick  apex=  54.7 px  air time=0.383 s (46 ticks)
ticks/s=240  gravity*delta    apex= 105.8 px  air time=0.754 s (181 ticks)
ticks/s=240  gravity per tick  apex=  27.4 px  air time=0.192 s (46 ticks)

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

  • الخطوة 1: المختبر يقرأ الحالة بين خطوتين، فيرى جامع التمر على الأرض عند 448 وسرعته صفر، أي قبل أن يعالج ضغطة القفز.
  • الخطوة 2: السرعة أصبحت -560، أي سرعة القفز كاملة، والموضع صعد 9.4 بكسل، وهي 560 مضروبة في 1/60 ثانية تقريباً. ولاحظ أن on_floor أصبحت false بعد أول حركة.
  • الخطوتان 3 و4: السرعة تنقص 25 في كل خطوة، وهي الجاذبية 1500 مضروبة في 1/60، والمسافة في كل خطوة تقل معها: 8.9 ثم 8.5 بكسل.
  • الخطوات 20 إلى 24: السرعة تقترب من الصفر، والموضع يكاد يتوقف عند 338.7، وهذه قمة القفز، أي 109.3 بكسل فوق نقطة البداية.
  • الخطوات 43 إلى 47: النزول بسرعة تزيد 25 في كل خطوة، حتى يلمس الأرض في الخطوة 47 فتعيد move_and_slide السرعة الرأسية إلى صفر وتصبح on_floor صحيحة. والزمن في الهواء 46 خطوة، أي 0.767 ثانية.

وقد تسأل: الحسبة النظرية للقفز هي مربع السرعة على ضعف الجاذبية، أي 560 في 560 على 3000، وتساوي 104.5 بكسل، فلماذا قفز جامع التمر 109.3؟ والسبب أن المحرك لا يحسب الحركة بشكل مستمر، وإنما يغير السرعة ثم يحرك الجسم بها خطوة كاملة، وهذه الطريقة تسمى Semi-implicit Euler، وخطؤها يصغر كلما صغرت الخطوة. ولذلك ترى أن الارتفاع بالكود الصحيح 114.1 على 30 خطوة، ثم 109.3 على 60، ثم 106.9 على 120، ثم 105.8 على 240، يقترب من 104.5 كلما زادت الخطوات، والفرق بين أبطأ وأسرع إعداد أقل من عشرة بكسلات، وزمن الهواء بين 0.80 و0.75 ثانية. فالقفز يبقى قفزاً واحداً على كل الإعدادات، وهذا معنى أن تكون اللعبة مستقلة عن عدد الخطوات.

وأما الجاذبية المضبوطة على 60 فالنتيجة مختلفة تماماً: على 60 خطوة تطابق الكود الصحيح حرفياً، 109.3 بكسل و46 خطوة، ولذلك لم يلاحظها أحد. وعلى 30 خطوة أصبح القفز 218.6 بكسل، أي الضعف، والزمن في الهواء 1.53 ثانية. وعلى 120 نصف الارتفاع، وعلى 240 ربعه، 27.4 بكسل، لا يكفي لصعود درجة. ولاحظ الرقم الذي لا يتغير في هذا العمود: 46 خطوة في كل مرة، والسبب أن الكود الخاطئ يعد الخطوات لا الثواني، فالقفز يأخذ 46 خطوة مهما كان طولها. والشكل التالي يجمع الأرقام:

رسم بأعمدة مزدوجة لأربع سرعات للفيزياء. الأخضر الجاذبية في delta: 114.1 بكسل على 30 خطوة، و109.3 على 60، و106.9 على 120، و105.8 على 240، وأزمان الهواء 0.80 و0.77 و0.76 و0.75 ثانية. الأحمر الجاذبية 25 في كل خطوة: 218.6 على 30، و109.3 على 60، و54.7 على 120، و27.4 على 240، وأزمان الهواء 1.53 و0.77 و0.38 و0.19 ثانية. وخط رمادي متقطع عند القيمة النظرية 104.5 بكسل
بالضرب في delta يبقى القفز واحداً، ودونه يتغير مع كل سرعة للفيزياء

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

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

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

OpenGL API 4.5 (Core Profile) Mesa 22.3.6 - Compatibility - Using Device: Mesa/X.org - llvmpipe (LLVM 15.0.6, 256 bits)
t=1.22s  jump at x=396
t=1.45s  screenshot play-1.45.png  player at (461, 352)
t=1.78s  stone touched Player at (565, 341)
t=1.93s  stone touched Player at (593, 412)
t=2.15s  stone touched Player at (621, 415)
t=2.18s  stone touched Player at (625, 415)
t=2.43s  stone touched Player at (653, 417)
t=2.62s  jump at x=643
t=2.65s  stone touched GroundRight at (676, 457)
t=2.83s  stone touched GroundRight at (694, 458)
t=2.90s  stone touched GroundRight at (700, 458)
t=2.93s  stone touched GroundRight at (703, 458)
t=2.97s  stone touched GroundRight at (706, 458)
t=3.20s  DateLedge picked by Player
t=3.85s  DateGround picked by Player
t=4.00s  screenshot play-4.00.png  player at (926, 448)

الحجر بقي على الرأس من الثانية 1.93 إلى 2.43 عند ارتفاع 412 إلى 417، أي فوق رأس جامع التمر الذي يقف عند 448 ونصف طوله 22، ثم قفز جامع التمر في 2.62 فسقط الحجر عنه إلى الأرض وارتد أربع مرات حتى استقر. والسبب أن CharacterBody2D لا يتأثر بالحجر، فيحمله ويمشي دون أن يثقله، والحجر جسم حر يرى طبقة جامع التمر فيقف عليه كما يقف على الأرض. وفي لعبة حقيقية قد تريد العكس، أن يسقط الحجر ويؤذي، وعندها تستمع لإشارة التلامس وتعطي الحجر دفعة جانبية بعدها، وهذا قرار تصميم لا تأخذه عنك الفيزياء.

وفي اللقطة اليسرى الخطأ نفسه الذي رأيناه في الأرقام: القفز بضعف الارتفاع عبر الفجوة كلها ونزل مباشرة على المنصة، فالتقط جامع التمر تمرة المنصة في الثانية 2.60 بدل 3.20، كما في المخرج out-08-play-bug.txt. والمرحلة التي صممتها لتحتاج قفزتين أصبحت تحتاج قفزاً واحداً، وأي لاعب على إعدادات مختلفة يلعب لعبة لم تصممها.

💡
إذا أردت أن تعرف هل في كودك جاذبية أو تسارع بلا delta، فغير الإعداد Physics Ticks per Second في إعدادات المشروع إلى 30 ثم إلى 120 وشغل اللعبة، فإذا تغير ارتفاع القفز أو سرعة السقوط بشكل واضح، فهناك سطر يعد الخطوات بدل الثواني.

مهلة الحافة Coyote Time: القفز بعد ترك الأرض بلحظة

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

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

المختبر: ضغطة متأخرة بخطوة، ثم خطوتين، ثم ثلاث

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

coyote_time = 0.00 s
  pressed -1 ticks after leaving (-17 ms,  0.0 px below the ledge): JUMPED  landed at x=612
  pressed  0 ticks after leaving (  0 ms,  0.0 px below the ledge): no jump fell into the gap
  pressed  1 ticks after leaving ( 17 ms,  0.4 px below the ledge): no jump fell into the gap
  pressed  2 ticks after leaving ( 33 ms,  1.2 px below the ledge): no jump fell into the gap
  pressed  3 ticks after leaving ( 50 ms,  2.5 px below the ledge): no jump fell into the gap
  pressed  4 ticks after leaving ( 67 ms,  4.2 px below the ledge): no jump fell into the gap
  pressed  5 ticks after leaving ( 83 ms,  6.2 px below the ledge): no jump fell into the gap
  pressed  6 ticks after leaving (100 ms,  8.8 px below the ledge): no jump fell into the gap
  pressed  7 ticks after leaving (117 ms, 11.7 px below the ledge): no jump fell into the gap
  pressed  8 ticks after leaving (133 ms, 15.0 px below the ledge): no jump fell into the gap
coyote_time = 0.10 s
  pressed -1 ticks after leaving (-17 ms,  0.0 px below the ledge): JUMPED  landed at x=612
  pressed  0 ticks after leaving (  0 ms,  0.0 px below the ledge): JUMPED  landed at x=638
  pressed  1 ticks after leaving ( 17 ms,  0.4 px below the ledge): JUMPED  landed at x=642
  pressed  2 ticks after leaving ( 33 ms,  1.2 px below the ledge): JUMPED  landed at x=647
  pressed  3 ticks after leaving ( 50 ms,  2.5 px below the ledge): JUMPED  landed at x=651
  pressed  4 ticks after leaving ( 67 ms,  4.2 px below the ledge): JUMPED  landed at x=655
  pressed  5 ticks after leaving ( 83 ms,  6.2 px below the ledge): no jump fell into the gap
  pressed  6 ticks after leaving (100 ms,  8.8 px below the ledge): no jump fell into the gap
  pressed  7 ticks after leaving (117 ms, 11.7 px below the ledge): no jump fell into the gap
  pressed  8 ticks after leaving (133 ms, 15.0 px below the ledge): no jump fell into the gap

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

  • دون مهلة: الضغطة الوحيدة التي نجحت هي التي جاءت قبل ترك الحافة بخطوة، والضغطة في الخطوة نفسها التي رأى فيها المختبر القدمين في الهواء، وجامع التمر ما زال على مستوى الحافة تماماً، 0.0 بكسل تحتها، انتهت في الفجوة. وهذا هو الشعور بالظلم الذي وصفناه: من عين اللاعب كان ما زال على الحافة.
  • بمهلة 0.10 ثانية: نجحت الضغطات حتى 4 خطوات بعد ترك الحافة، أي 67 جزءاً من الألف من الثانية، وجامع التمر نزل في تلك اللحظة 4.2 بكسل فقط، وهو فرق لا تراه العين، فيبدو القفز طبيعياً تماماً.
  • لماذا 4 خطوات وليس 6؟ 0.10 ثانية هي 6 خطوات على 60، ولكن العداد يبدأ بالنقصان من آخر خطوة كانت فيها القدمان على الأرض، والمختبر يرى ترك الأرض بعد ذلك بخطوة لأنه يقرأ الحالة بين خطوتين، والخطوة السادسة يصل فيها العداد إلى الصفر تقريباً فلا يتحقق الشرط «أكبر من صفر». فالمهلة التي تكتبها في الكود ليست بالضبط ما يحصل عليه اللاعب، وهذا سبب إضافي لأن تقيسها بدل أن تفترضها.
  • نقطة الهبوط: الضغطة المتأخرة تبدأ القفز من نقطة أبعد قليلاً وأخفض قليلاً، فهبط جامع التمر من 638 إلى 655 بدل 612، وكلها على الأرض اليمنى.

ذاكرة القفز Jump Buffering: القفز قبل الهبوط بلحظة

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

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

falling from y=300: on the floor after 27 ticks
jump_buffer = 0.00 s
  pressed  0 ticks before landing (  0 ms): JUMPED, 1 ticks after the press
  pressed  1 ticks before landing ( 17 ms): JUMPED, 1 ticks after the press
  pressed  2 ticks before landing ( 33 ms): no jump, the press was lost
  pressed  3 ticks before landing ( 50 ms): no jump, the press was lost
  pressed  4 ticks before landing ( 67 ms): no jump, the press was lost
  pressed  5 ticks before landing ( 83 ms): no jump, the press was lost
  pressed  6 ticks before landing (100 ms): no jump, the press was lost
  pressed  7 ticks before landing (117 ms): no jump, the press was lost
  pressed  8 ticks before landing (133 ms): no jump, the press was lost
  pressed  9 ticks before landing (150 ms): no jump, the press was lost
  pressed 10 ticks before landing (167 ms): no jump, the press was lost
jump_buffer = 0.12 s
  pressed  0 ticks before landing (  0 ms): JUMPED, 1 ticks after the press
  pressed  1 ticks before landing ( 17 ms): JUMPED, 1 ticks after the press
  pressed  2 ticks before landing ( 33 ms): JUMPED, 2 ticks after the press
  pressed  3 ticks before landing ( 50 ms): JUMPED, 3 ticks after the press
  pressed  4 ticks before landing ( 67 ms): JUMPED, 4 ticks after the press
  pressed  5 ticks before landing ( 83 ms): JUMPED, 5 ticks after the press
  pressed  6 ticks before landing (100 ms): JUMPED, 6 ticks after the press
  pressed  7 ticks before landing (117 ms): JUMPED, 7 ticks after the press
  pressed  8 ticks before landing (133 ms): JUMPED, 8 ticks after the press
  pressed  9 ticks before landing (150 ms): no jump, the press was lost
  pressed 10 ticks before landing (167 ms): no jump, the press was lost

دون ذاكرة لم تنجح إلا ضغطتان، في خطوة الهبوط نفسها والتي قبلها، والثانية نجحت لأن المختبر يرى القدمين على الأرض بعد خطوة من لمسها كما ذكرنا، فهي في الحقيقة ضغطة في لحظة الهبوط. وأي ضغطة قبل ذلك بـ 33 جزءاً من الألف من الثانية أو أكثر ضاعت. ومع ذاكرة 0.12 ثانية نجحت الضغطات حتى 8 خطوات قبل الهبوط، أي 133 جزءاً من الألف، ولاحظ العمود الأخير: القفز حدث بعد الضغطة بعدد الخطوات نفسه الذي جاءت فيه مبكرة، أي في لحظة الهبوط بالضبط، فلا يبقى جامع التمر على الأرض ولو خطوة واحدة.

والشكل التالي يجمع التجربتين، وكل مربع ضغطة في تشغيل مستقل:

لوحتان. الأولى ضغطة متأخرة بعد ترك الحافة Coyote Time: مع coyote_time تساوي صفراً المربع -1 فقط أخضر والمربعات من 0 إلى 8 وردية، ومع 0.10 ثانية المربعات من -1 إلى 4 خضراء ومن 5 إلى 8 وردية. والثانية ضغطة مبكرة قبل الهبوط Jump Buffering: مع jump_buffer تساوي صفراً المربعان 0 و1 خضراوان ومن 2 إلى 10 وردية، ومع 0.12 ثانية المربعات من 0 إلى 8 خضراء و9 و10 وردية
المهلة والذاكرة حولتا ضغطات كانت تضيع إلى قفز في وقته

وقد يتساءل البعض: إذا كانت المهلة تجعل اللعبة أعدل، فلماذا لا نجعلها نصف ثانية؟ والإجابة على ذلك أن المهلة الطويلة تتحول إلى قفز من الهواء: جامع التمر يسقط في الفجوة 15 بكسل أو أكثر ثم يقفز منها، والعين ترى ذلك فوراً ويبدو غشاً. وكذلك الذاكرة الطويلة تجعل جامع التمر يقفز وحده بعد الهبوط لأن اللاعب ضغط الزر قبل ثلث ثانية لسبب آخر. والقيم الشائعة بين 0.08 و0.15 ثانية لكل منهما، وفي جدولنا ترى أن الضغطة بعد 8 خطوات كان جامع التمر فيها 15 بكسل تحت الحافة، وهو حد معقول للتوقف عنده. والأهم أن تجعل القيمتين خاصيتين بالتعليق @export كما فعلنا، فيضبطهما مصمم اللعبة من المحرر وهو يلعب، وكما ذكرنا في مقال أساسيات تصميم الألعاب، الضبط Tuning يكون بالقياس واللعب لا بالتخمين.

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

خريطة التحكم Input Map ويد التحكم Gamepad

في مقال أول لعبة ربطنا الفعلين move_left وmove_right بالأسهم والحرفين A وD. وهنا أضفنا فعل القفز jump، وأضفنا لكل فعل أحداث يد التحكم، فأصبح الفعل move_right في ملف المشروع كما يلي:

move_right={
"deadzone": 0.2,
"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194321,"key_label":0,"unicode":0,"location":0,"echo":false,"script":null)
, Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":68,"key_label":0,"unicode":100,"location":0,"echo":false,"script":null)
, Object(InputEventJoypadMotion,"resource_local_to_scene":false,"resource_name":"","device":-1,"axis":0,"axis_value":1.0,"script":null)
, Object(InputEventJoypadButton,"resource_local_to_scene":false,"resource_name":"","device":-1,"button_index":14,"pressure":0.0,"pressed":true,"script":null)
]
}

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

  • أربعة أحداث لفعل واحد: السهم الأيمن، والحرف D بموضعه على لوحة المفاتيح، والعصا اليسرى إلى اليمين axis 0 بقيمة موجبة، وزر الاتجاه الأيمن في يد التحكم button_index 14. والسكربت لا يعرف شيئاً عن هذه الأربعة، فهو يسأل عن الفعل فقط.
  • الخاصية device: -1: تعني أي جهاز، أي أن أي يد تحكم موصولة تحرك جامع التمر. وفي لعبة لاعبين على جهاز واحد تحتاج أفعالاً لكل لاعب، أو تقرأ رقم الجهاز من الحدث نفسه.
  • المنطقة الميتة deadzone: 0.2: أي حركة للعصا أقل من 0.2 لا تحسب. والسبب في وجودها، كما يشرح توثيق يد التحكم في Godot، أن العصا التناظرية Analog لا تعود إلى الصفر تماماً عندما تتركها، وإنما تبقى عند قيمة صغيرة مثل 0.062، وهذا ما يسمى الانحراف Drift، فدون منطقة ميتة يمشي جامع التمر وحده ببطء واللاعب لا يلمس شيئاً.
  • زر القفز: في الفعل jump ربطنا المسافة والسهم الأعلى وزر يد التحكم رقم 0، وهو الزر السفلي من الأزرار الأربعة، A في يد Xbox و Cross في يد PlayStation، والثابت في الكود اسمه JOY_BUTTON_A.

ويذكر التوثيق أن Godot منذ الإصدار 4.5 يعتمد على مكتبة SDL 3 في دعم أيدي التحكم على Windows وmacOS وLinux، أي أن قائمة الأيدي المدعومة وتصرفها أصبحت قريبة مما تجده في الألعاب الأخرى التي تستخدم المكتبة نفسها.

المختبر: يد تحكم دون يد تحكم

المختبر يعمل في Container لا يوجد فيه يد تحكم، ولكن Godot يسمح بإرسال أحداث مصنوعة إلى نظام التحكم بالدالة Input.parse_input_event، فتمر بخريطة التحكم كما يمر الحدث الحقيقي من اليد. والتجربة تحرك العصا إلى قيم مختلفة، وتقرأ في كل مرة القيمة الخام وقوة الفعل وناتج get_axis وسرعة جامع التمر، ثم تضغط حرف D والعصا إلى اليسار في الوقت نفسه، ثم تضغط زر A:

	for v in [0.10, 0.19, 0.21, 0.30, 0.50, 0.80, 1.00, -0.60]:
		var ev := InputEventJoypadMotion.new()
		ev.device = 0
		ev.axis = JOY_AXIS_LEFT_X
		ev.axis_value = v
		Input.parse_input_event(ev)
		await tick(2)
		print("stick x=%5.2f  raw_strength(right)=%.2f  strength(right)=%.2f  get_axis=%5.2f  player velocity.x=%6.1f" % [v,
			Input.get_action_raw_strength("move_right"), Input.get_action_strength("move_right"),
			Input.get_axis("move_left", "move_right"), p.velocity.x])

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

connected joypads: [], deadzone of move_right: 0.20
stick x= 0.10  raw_strength(right)=0.10  strength(right)=0.00  get_axis= 0.00  player velocity.x=   0.0
stick x= 0.19  raw_strength(right)=0.19  strength(right)=0.00  get_axis= 0.00  player velocity.x=   0.0
stick x= 0.21  raw_strength(right)=0.21  strength(right)=0.01  get_axis= 0.01  player velocity.x=   3.2
stick x= 0.30  raw_strength(right)=0.30  strength(right)=0.13  get_axis= 0.13  player velocity.x=  32.5
stick x= 0.50  raw_strength(right)=0.50  strength(right)=0.38  get_axis= 0.38  player velocity.x=  97.5
stick x= 0.80  raw_strength(right)=0.80  strength(right)=0.75  get_axis= 0.75  player velocity.x= 195.0
stick x= 1.00  raw_strength(right)=1.00  strength(right)=1.00  get_axis= 1.00  player velocity.x= 260.0
stick x=-0.60  raw_strength(right)=0.00  strength(right)=0.00  get_axis=-0.50  player velocity.x=-130.0
stick x=-0.60 and key D held: get_axis=0.50  player velocity.x=130.0
button A (index 0) pressed: jump action pressed=true, the player jumped=true, velocity.y=-560

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

  • السطر الأول: لا توجد يد تحكم موصولة فعلاً، القائمة فارغة، ومع ذلك وصلت كل الأحداث إلى الأفعال، لأن خريطة التحكم لا تهتم من أين جاء الحدث.
  • 0.10 و0.19: القيمة الخام تصل كما هي، ولكن قوة الفعل صفر، لأنها تحت المنطقة الميتة، وجامع التمر لا يتحرك. وهذا ما تريده مع يد قديمة تنحرف.
  • 0.21: فوق المنطقة الميتة بقليل، والقوة 0.01 لا 0.21، وسرعة جامع التمر 3.2 بكسل في الثانية. فالمحرك لا يكتفي بإهمال ما تحت 0.2، وإنما يعيد توزيع المدى من 0.2 إلى 1 على المدى من 0 إلى 1، والحسبة هي 0.21 ناقص 0.2 على 0.8، أي 0.0125، مضروبة في 260 تساوي 3.25. والسبب في هذا التوزيع أن الحركة تبدأ من الصفر بهدوء، فلو أعطاك 0.21 مباشرة لبدأ جامع التمر بسرعة 55 بكسل في الثانية دفعة واحدة.
  • 0.50 و0.80 و1.00: القوة 0.38 ثم 0.75 ثم 1، والسرعة تتبعها، 97.5 ثم 195 ثم 260، أي أن العصا تعطي سرعة متدرجة دون أي سطر إضافي في الكود، لأن get_axis ترجع القوة لا مجرد اتجاه.
  • -0.60: العصا إلى اليسار، فقوة move_right صفر، وget_axis تساوي -0.50، والسرعة -130.
  • العصا والحرف D معاً: get_axis هي قوة اليمين ناقص قوة اليسار، أي 1 من الحرف ناقص 0.5 من العصا، فالنتيجة 0.50 إلى اليمين. وهذا يحدث فعلاً عندما يترك اللاعب يده على لوحة المفاتيح ويلعب بيد التحكم، فإذا أردت جهاز تحكم واحد في كل لحظة فاحفظ آخر جهاز استخدمه اللاعب وتجاهل الآخر.
  • الزر A: الفعل jump مضغوط، وقفز جامع التمر بسرعة -560، أي أن مهلة الحافة وذاكرة القفز تعملان مع يد التحكم كما تعملان مع لوحة المفاتيح، لأن السكربت لا يعرف الفرق.

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

رسم خطي: المحور الأفقي موضع العصا من 0 إلى 1، والرأسي القوة من 0 إلى 1. منطقة وردية من 0 إلى 0.2 مكتوب فيها المنطقة الميتة. خط رمادي متقطع للقيمة الخام يصعد بشكل مستقيم من 0 إلى 1. وخط أزرق لما يصل إلى الكود يبقى صفراً حتى 0.2 ثم يصعد بنقاط عند 0.21 قوة 0.01، و0.30 قوة 0.13، و0.50 قوة 0.38 مع النص 0.50 إلى 0.38 إلى velocity.x تساوي 97.5، و0.80 قوة 0.75، و1 قوة 1
تحت 0.2 لا يصل شيء، وفوقها يبدأ المدى من الصفر

وإذا كانت لعبتك تتحرك في اتجاهين، مثل لعبة من الأعلى Top-down، فاستخدم الدالة Input.get_vector بدل get_axis مرتين، والسبب كما يقول التوثيق أنها تحسب المنطقة الميتة على شكل دائرة حول مركز العصا، أما طرح القوتين في كل محور وحده فيعطي منطقة ميتة مربعة، فيصعب على اللاعب أن يمشي بزاوية صغيرة.

النفق Tunneling في Godot: مئة رصاصة على جدار رفيع

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

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

func shoot(label: String, rate: int, mode: int, speed: float, wall_w: float) -> void:
	Engine.physics_ticks_per_second = rate
	var world := Node2D.new()
	get_parent().add_child(world)
	var wall := StaticBody2D.new()
	var ws := CollisionShape2D.new()
	ws.shape = RectangleShape2D.new()
	ws.shape.size = Vector2(wall_w, 1100)
	wall.add_child(ws)
	wall.position = Vector2(600, 550)
	world.add_child(wall)
	var bullets := []
	var hits := [0]
	for i in 100:
		var b: Node2D
		var cs := CollisionShape2D.new()
		cs.shape = CircleShape2D.new()
		cs.shape.radius = 3.0
		if mode >= 0:
			var rb := RigidBody2D.new()
			rb.gravity_scale = 0.0
			rb.continuous_cd = mode
			rb.linear_velocity = Vector2(speed, 0)
			rb.collision_layer = 16; rb.collision_mask = 1
			b = rb
		elif mode == -1:
			var ar := Area2D.new()
			ar.collision_layer = 16; ar.collision_mask = 1
			ar.body_entered.connect(func(_w): hits[0] += 1)
			b = ar
		else:
			var cb := CharacterBody2D.new()
			cb.collision_layer = 16; cb.collision_mask = 1
			b = cb
		b.add_child(cs)
		b.position = Vector2(100 + i * 0.67, 5 + i * 10)   # each bullet starts a little further on
		world.add_child(b)
		bullets.append(b)
	var step := speed / rate
	for k in int(0.5 * rate):
		await tick()
		for b in bullets:
			if b is Area2D:
				b.position.x += step
			elif b is CharacterBody2D and not b.get_meta("hit", false):
				if b.move_and_collide(Vector2(step, 0)):
					b.set_meta("hit", true)
	var far := 600.0 + wall_w / 2 + 3.0
	var passed := bullets.filter(func(b): return b.position.x > far).size()
	var extra := "  (body_entered fired %d times)" % hits[0] if mode == -1 else ""
	print("%-34s %4d px/s  ticks/s=%3d  step=%5.1f px  passed=%3d/100%s" % [label, speed, rate, step, passed, extra])
	world.queue_free()
	await tick()

في السكربت أعلاه لاحظ التالي:

  • الرصاصة إما RigidBody2D يحركه المحرك بسرعته، مع إعداد الاكتشاف المستمر للتصادم Continuous Collision Detection واختصاراً CCD في الخاصية continuous_cd، وإما Area2D نحركها نحن بتغيير موضعها، وهي الطريقة التي يكتبها كثير من المبتدئين للرصاص، وإما CharacterBody2D نحركها بالدالة move_and_collide.
  • الرصاصات في طبقة خاصة بها، 16، وقناعها 1، فترى الجدار ولا ترى بعضها، حتى لا تصطدم الرصاصات ببعضها وتفسد العد.
  • الرصاصة «عبرت» إذا كان مركزها بعد نصف الجدار ونصف قطرها، أي خرجت كاملة من الجهة الأخرى.

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

100 bullets (circles, radius 3 px) fired at a wall; «passed» = came out on the other side
RigidBody2D, CCD off               4000 px/s  ticks/s= 60  step= 66.7 px  passed= 89/100
RigidBody2D, CCD cast ray          4000 px/s  ticks/s= 60  step= 66.7 px  passed=  0/100
RigidBody2D, CCD cast shape        4000 px/s  ticks/s= 60  step= 66.7 px  passed= 89/100
RigidBody2D, CCD off               4000 px/s  ticks/s=240  step= 16.7 px  passed= 56/100
RigidBody2D, CCD off, wall 32 px   4000 px/s  ticks/s= 60  step= 66.7 px  passed= 72/100
Area2D moved by position           4000 px/s  ticks/s= 60  step= 66.7 px  passed=100/100  (body_entered fired 21 times)
CharacterBody2D move_and_collide   4000 px/s  ticks/s= 60  step= 66.7 px  passed=  0/100
--- what if the bullet is slower?
RigidBody2D, CCD off               1000 px/s  ticks/s= 60  step= 16.7 px  passed= 38/100
RigidBody2D, CCD cast ray          1000 px/s  ticks/s= 60  step= 16.7 px  passed=  0/100
RigidBody2D, CCD cast shape        1000 px/s  ticks/s= 60  step= 16.7 px  passed= 38/100
RigidBody2D, CCD off               2000 px/s  ticks/s= 60  step= 33.3 px  passed= 76/100
RigidBody2D, CCD cast ray          2000 px/s  ticks/s= 60  step= 33.3 px  passed=  0/100
RigidBody2D, CCD cast shape        2000 px/s  ticks/s= 60  step= 33.3 px  passed= 76/100

والقراءة سطراً سطراً كما يلي:

  • دون CCD: عبرت 89 رصاصة من 100. والخطوة الواحدة 66.7 بكسل، أي أطول من الجدار والرصاصة معاً بأكثر من أربع مرات، فأغلب الرصاصات لم تكن داخل الجدار في أي خطوة رآها المحرك.
  • CCD بالشعاع Cast Ray: صفر، لم تعبر رصاصة واحدة، في كل السرعات التي جربناها. وفي هذا الوضع يرسم المحرك شعاعاً على مسار الجسم في الخطوة، فإذا قطع الشعاع شيئاً عرف أن الجسم سيصل إليه قبل نهاية الخطوة.
  • CCD بالشكل Cast Shape: 89، أي النتيجة نفسها دون CCD حرفياً، وفي السرعتين 1000 و2000 أيضاً النتيجة نفسها، 38 و76. وهذا عكس ما يتوقعه من يقرأ توثيق أوضاع CCD، الذي يصف هذا الوضع بأنه الأبطأ والأدق. وفي مستودع المحرك بلاغ مفتوح بهذا المعنى بعنوان CCD في RigidBody2D لا يعمل مع إعداد Cast Shape، وقياسنا على Godot 4.7.2 مع محرك الفيزياء الافتراضي يوافقه. فلا تختر هذا الوضع لأن اسمه يوحي بالدقة، وقس قبل أن تعتمد عليه.
  • 240 خطوة في الثانية: 56 بدل 89. الخطوة أصبحت 16.7 بكسل، ومع ذلك عبرت أكثر من نصف الرصاصات. والسبب الأول أن الجدار 8 بكسل والرصاصة 6، فالخطوة ما زالت أطول منهما معاً، ولاحظ في الأسطر الأخيرة أن الرصاصة بسرعة 1000 على 60 خطوة لها الخطوة نفسها، 16.7 بكسل، ومع ذلك عبرت منها 38 فقط، أي أن طول الخطوة وحده لا يحدد النتيجة، والسرعة نفسها تدخل في طريقة فصل المحرك بين الجسمين. ورفع عدد الخطوات يضاعف حساب الفيزياء كله في اللعبة أربع مرات، من أجل رصاصة.
  • جدار سمكه 32 بكسل: 72 بدل 89، تحسن قليل، لأن 32 ما زالت أقل بكثير من 66.7. والتوثيق في صفحة مشاكل الفيزياء الشائعة يقترح الجدران الأسمك كحل، وهو حل جيد للأرضيات والجدران الكبيرة، ولكنه لا يكفي وحده لرصاصة بهذه السرعة.
  • Area2D نحركها بالموضع: 100 من 100 عبرت، والإشارة body_entered وصلت 21 مرة فقط. فالمنطقة لا تتوقف عند شيء أصلاً، وحتى اكتشاف الدخول يحدث فقط إذا وقعت الرصاصة داخل الجدار في خطوة ما، وهذا يحدث تقريباً بنسبة سمك الجدار والرصاصة إلى طول الخطوة، 14 من 66.7، أي حوالي 21 في المئة، وهذا ما خرج. فإذا كانت رصاصاتك في لعبتك مناطق تحركها بالموضع، فاعلم أن أربعاً من كل خمس تمر من الجدران الرفيعة دون أي إشارة.
  • CharacterBody2D مع move_and_collide: صفر. والسبب أن هذه الدالة لا تنقل الجسم ثم تسأل، وإنما تفحص الحركة كلها قبل أن تنفذها، وتوقف الجسم عند أول شيء على المسار، أي أنها فحص على المسار من الأصل. ولهذا السبب نفسه لا يعبر جامع التمر الأرض مهما سقط من ارتفاع، لأن move_and_slide مبنية على الفحص نفسه.
  • السرعات الأبطأ: على 1000 بكسل في الثانية عبرت 38، وعلى 2000 عبرت 76، وعلى 4000 عبرت 89. أي أن النفق لا يبدأ عند سرعة معينة ثم يثبت، وإنما يزيد مع السرعة، فرصاصة لم تعبر في تجربتك على سرعة ما قد تعبر إذا زاد مصمم اللعبة سرعتها قليلاً.
رسم بأعمدة أفقية لعدد الرصاصات التي عبرت من 100. بالأحمر: RigidBody2D دون CCD على 60 خطوة 89، وCCD cast shape على 60 خطوة 89، وArea2D نحركها بالموضع 100. بالبرتقالي: دون CCD مع جدار 32 بكسل 72، ودون CCD على 240 خطوة 56. بالأخضر: CCD cast ray صفر، وCharacterBody2D مع move_and_collide صفر
الإعدادان اللذان أوقفا كل الرصاصات: CCD بالشعاع، والفحص على المسار في move_and_collide

والخلاصة العملية من هذه الأرقام كما يلي:

  1. إذا كانت الرصاصة سريعة جداً، فالأفضل ألا تكون جسماً أصلاً: أطلق شعاعاً RayCast2D من فوهة السلاح، أو استخدم PhysicsDirectSpaceState2D.intersect_ray، فتعرف ما الذي أصابته في الخطوة نفسها، وهذا ما تفعله أغلب ألعاب الرماية للرصاص الفوري Hitscan.
  2. إذا أردت رصاصة تراها تطير، فاجعلها RigidBody2D مع CCD بالشعاع، أو CharacterBody2D تحركها بالدالة move_and_collide، وكلاهما أوقف 100 من 100.
  3. لا تحرك رصاصة سريعة بتغيير موضع Area2D، فهي الطريقة الوحيدة التي عبرت فيها كل الرصاصات.
  4. لا ترفع عدد خطوات الفيزياء للعبة كلها من أجل جسم واحد، والسبب أن الثمن يدفعه كل جسم في اللعبة، والنتيجة في تجربتنا لم تكن كافية.

انظر إلى ما يراه المحرك: Visible Collision Shapes

أغلب أخطاء التصادم تختفي عندما ترى الأشكال التي يستخدمها المحرك فعلاً بدل الرسوم التي تراها أنت. وفي المحرر تجد في قائمة Debug الخيار Visible Collision Shapes، فإذا فعلته وشغلت اللعبة رسم Godot كل شكل تصادم بلون شفاف فوق اللعبة. ومن سطر الأوامر الخيار نفسه هو --debug-collisions، وبه التقطنا الصورة التالية من المختبر في نهاية الجولة:

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

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

ملفات المختبر وتشغيله

المختبر كله في مجلد lab: الملف Dockerfile نفسه الذي استخدمناه في مقال أول لعبة، وهو ينزل Godot 4.7.2 الرسمي من صفحة الإصدار ويتحقق منه بالبصمة SHA512، ومجلد game باللعبة، والملف run.sh الذي يشغل كل التجارب ويحفظ مخرج كل منها في ملف:

#!/bin/bash
# «جني التمر»: the lab of the article about physics, collision and input. From this folder:  bash run.sh
# The game folder is mounted into the container, so you can edit lab/game and run again without rebuilding.
set -e
IMG=${IMG:-godot-lab:4.7.2}
docker build -q -t "$IMG" . > /dev/null
G="$(pwd -W 2>/dev/null || pwd)/game"
lab() { MSYS_NO_PATHCONV=1 docker run --rm -v "$G:/game" "$IMG" godot --headless --fixed-fps 60 --path /game -- --lab "$1" 2>&1 | grep -v '^Godot Engine'; }
echo "### 1. The same jump at 30, 60, 120 and 240 physics ticks per second";  lab jump   | tee out-01-jump.txt
echo "### 2. Coyote time: jump pressed after leaving the ledge";               lab coyote | tee out-02-coyote.txt
echo "### 3. Jump buffering: jump pressed before landing";                     lab buffer | tee out-03-buffer.txt
echo "### 4. Collision layers and masks";                                      lab layers | tee out-04-layers.txt
echo "### 5. Tunnelling: 100 fast bullets against a thin wall";                lab tunnel | tee out-05-tunnel.txt
echo "### 6. A gamepad through the Input Map";                                 lab pad    | tee out-06-pad.txt
echo "### 7. Real frames drawn in software (Xvfb + Mesa llvmpipe)"
mkdir -p shots
shot() { MSYS_NO_PATHCONV=1 docker run --rm -v "$G:/game" -v "$(pwd -W 2>/dev/null || pwd)/shots:/shots" "$IMG" bash -c \
  "xvfb-run -a -s '-screen 0 960x540x24' godot --rendering-driver opengl3 --fixed-fps 60 $1 --path /game -- --lab play --shot /shots $2 2>&1" \
  | grep -E '^(OpenGL|t=)'; }
shot "--debug-collisions" "" > /dev/null; mv shots/play-1.45.png shots/debug-1.45.png; mv shots/play-4.00.png shots/debug-4.00.png
shot "" ""      | tee out-07-play.txt
shot "" "--bug" | tee out-08-play-bug.txt

والخيار --fixed-fps 60 يجعل المحرك يحسب كل إطار كأنه أخذ 1/60 ثانية مهما كانت سرعة الجهاز، فتخرج الأرقام نفسها في كل تشغيل، وقد شغلنا الملف أكثر من مرة وخرجت المخرجات متطابقة. وأما سكربت المختبر lab.gd فيضيفه المشهد الرئيسي فقط إذا جاء الوسيط --lab بعد --، وكل تجربة فيه تنشئ المرحلة من جديد، وتضغط الأفعال نفسها التي يضغطها اللاعب بالدالة Input.action_press، وتنتظر خطوات الفيزياء بالإشارة physics_frame كما يلي:

func tick(n := 1) -> void:
	for i in n:
		await get_tree().physics_frame

func fresh_level() -> Node2D:
	for a in ["move_left", "move_right", "jump"]:
		Input.action_release(a)
	var lv: Node2D = LevelScene.instantiate()
	get_parent().add_child(lv)
	await tick(3)   # let the player land and the physics server register every body
	return lv

أخطاء شائعة وكيف تقرأ أعراضها

  • الأشياء تسقط من الأرض: قناع الجسم الساقط لا يحتوي طبقة الأرض، كما رأينا في الإعداد الثاني. افتح الجسم في Inspector وانظر إلى Collision ثم Mask، وتأكد أن طبقة world مفعلة.
  • المنطقة لا تكتشف اللاعب: قناع المنطقة لا يحتوي طبقة اللاعب، أو المنطقة تراقب الأجسام والشخصية منطقة أخرى، فتحتاج area_entered بدل body_entered. والعرض الأغرب أن يلتقط التمرة شيء آخر غير اللاعب، كما التقطها الحجر عندنا.
  • الإشارة body_entered لا تصل من RigidBody2D: نسيت تفعيل contact_monitor وجعل max_contacts_reported أكبر من صفر.
  • القفز يختلف من جهاز لآخر أو بعد تغيير الإعدادات: تسارع يضاف بلا delta، أو حركة في _process بدل _physics_process. غير عدد خطوات الفيزياء وقارن.
  • الشخصية بطيئة جداً دون سبب: وضعت في velocity السرعة مضروبة في delta، والدالة move_and_slide تضربها في delta مرة ثانية.
  • اللاعب يقول إن الزر لا يستجيب: لا توجد مهلة حافة ولا ذاكرة قفز، فالضغطات المتأخرة والمبكرة بخطوة أو اثنتين تضيع كما رأينا.
  • الشخصية تمشي وحدها مع يد التحكم: المنطقة الميتة صغيرة جداً أو صفر، والعصا تنحرف.
  • الرصاصة تمر من الجدار: رصاصة Area2D تحركها بالموضع، أو RigidBody2D دون CCD أو مع CCD بالشكل. استخدم الشعاع أو move_and_collide.
  • الحجر يتصرف بشكل غريب بعد أن حركته بالكود: غيرت position أو linear_velocity لجسم حر في كل خطوة، والمحرك يحسبها في الوقت نفسه. استخدم الدفعات أو _integrate_forces.

أي عقدة تختار؟

الشيء في لعبتكالعقدةوالسبب
الأرض والجدران والمنصات الثابتةStaticBody2Dلا تتحرك، والأرخص في الحساب
المنصة المتحركةAnimatableBody2Dجسم ثابت تحركه أنت بحركة محسوبة، فيحمل ما فوقه معه
شخصية اللاعب والأعداءCharacterBody2Dالحركة يقررها الكود، والمحرك يوقفها عند الجدار ويخبرك بالأرض
صناديق وحجارة وكرات تتدحرجRigidBody2Dتريدها أن تتصرف بشكل طبيعي دون كود
تمر وعملات ومناطق ضرر وبواباتArea2Dتحتاج أن تعرف من دخل فقط، لا أن توقفه
رصاصة فوريةRayCast2D أو استعلام شعاعتعرف الإصابة في الخطوة نفسها ولا يوجد نفق
رصاصة تطير وتراهاRigidBody2D مع CCD بالشعاع، أو CharacterBody2D مع move_and_collideكلاهما أوقف 100 من 100 في المختبر

تطبيق عملي

  1. أضف ارتفاع قفز متغيراً: إذا رفع اللاعب يده عن زر القفز وجامع التمر ما زال يصعد، اضرب السرعة الرأسية في 0.5. تحتاج سطراً واحداً مع is_action_just_released، ثم عدل تجربة القفز في المختبر لتضغط الزر خطوتين فقط، وقارن الارتفاع.
  2. غير coyote_time إلى 0.2 وشغل تجربة المهلة، وانظر كم بكسل تحت الحافة يكون جامع التمر في آخر ضغطة ناجحة، ثم قرر أنت هل يبدو هذا عدلاً أم غشاً.
  3. اجعل الحجر يؤذي جامع التمر: أضف إشارة hit في مشهد الحجر ترسل عندما يلمس الحجر جسماً اسمه Player، ثم أعط الحجر دفعة جانبية بالدالة apply_impulse حتى لا يبقى على الرأس.
  4. عدل تجربة النفق لتضيف رصاصة بعقدة RayCast2D، واجعل الشعاع بطول خطوة واحدة أمام الرصاصة، وقارن نتيجتها بنتيجة CCD بالشعاع.

حذف المختبر Cleanup

docker image rm godot-lab:4.7.2
rm -rf shots

الخلاصة Summary

  • اختر العقدة بحسب من يحرك الجسم: لا أحد StaticBody2D، وكودك CharacterBody2D، والمحرك RigidBody2D، ولا حركة فيزيائية Area2D. وشخصية اللاعب تكون CharacterBody2D في أغلب الألعاب.
  • الطبقة مكان الجسم، والقناع ما يراه، وكل عقدة جديدة في الطبقة 1 وترى الطبقة 1. سم الطبقات واكتب جدول من يلمس من قبل أن تبني المشاهد، ففي المختبر التقط الحجر التمرة بالقيم الافتراضية، وعبر الأرض حين نقص قناعه بت واحد.
  • السرعة في velocity كما هي، والتسارع يضرب في delta. وبالكود الصحيح كان القفز بين 105.8 و114.1 بكسل على أربع سرعات للفيزياء، وبالجاذبية المضبوطة على 60 كان بين 27.4 و218.6.
  • مهلة الحافة 0.10 ثانية حولت 5 ضغطات متأخرة كانت تضيع إلى قفز، وذاكرة القفز 0.12 ثانية حولت 7 ضغطات مبكرة إلى قفز في لحظة الهبوط.
  • اسأل عن الأفعال لا عن المفاتيح، فتعمل لوحة المفاتيح ويد التحكم بالكود نفسه، والمنطقة الميتة 0.2 تهمل انحراف العصا وتبدأ الحركة من الصفر.
  • في Godot 4.7.2 أوقف CCD بالشعاع وmove_and_collide كل الرصاصات السريعة، وعبرت 89 من 100 دون CCD أو مع CCD بالشكل، وعبرت كل رصاصات Area2D.

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

دليلأول لعبة مع Godot: المشاهد والعقد وGDScriptنبني لعبة صغيرة كاملة في Godot 4 من ثلاثة مشاهد وأربعة سكربتات، ونفهم بها العقد والمشاهد والإشارات وحلقة اللعبة، ثم نشغلها في مختبر يلعبها فيه روبوت حتى تنتهي.دليلالنص العربي في واجهة اللعبة: RTL والخطوطنبني قائمة عربية للعبة في Godot 4 ونتتبع النص من ملف الترجمة إلى الشاشة: الخط والتشكيل واتجاه الواجهة والنص المختلط وصيغ الجمع، بلقطات حقيقية للخطأ والصحيح.دليلالصوت والموسيقى في اللعبة: Audio Buses وLUFSنضيف الصوت إلى لعبة Godot صغيرة بأصوات نصنعها بأنفسنا، ثم نقيس ما يخرج من المحرك فعلاً لنعرف كيف نختار الصيغة ونجعل الموسيقى تدور دون نقرة ونمزج الأصوات دون تشوه.دليلتصدير اللعبة من Godot إلى الويب والجوال وسطح المكتبماذا يحدث فعلاً عند تصدير لعبة Godot، ولماذا تحتاج نسخة الويب Headers خاصة أحياناً، وما تطلبه كل منصة ومتجر، مع مختبر يصدر لعبة واحدة إلى خمس منصات.دليلكيف تعمل اللعبة من الداخل؟ حلقة اللعبة Game Loopلماذا تتحرك الشخصية بالسرعة نفسها على شاشة 144 هرتز وحاسوب بطيء: نبني حلقة اللعبة من الصفر حتى الخطوة الثابتة والاستيفاء، ونقيس كل طريقة في مختبر.دليلرياضيات الألعاب: المتجهات Vectors والحركة والتصادمالمتجهات والحركة وحاصل الضرب النقطي واختبارات التصادم والارتداد والنفق، بلعبة صغيرة ومختبر Python يصنع الأخطاء الشائعة ثم يصلحها.

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

  • نوفمبر 2026: كتابة المقال، وبناء لعبة «جني التمر» وتشغيل تجاربها على Godot 4.7.2 دون شاشة في Docker، والتقاط الصور بالرسم البرمجي عبر Xvfb وMesa llvmpipe.
نشرة عرب رووت | ArabRoot

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

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

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

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