أنهيت لعبتك الأولى في Godot، وفيها شخصية تجري وتقفز، ثم طلب منك صديق أن تلعبا معاً، كل واحد من جهازه. والحل الذي يخطر لأي مبرمج أولاً بسيط: كل جهاز يرسل موقع شخصيته للآخر عشرين مرة في الثانية، والآخر يرسمها حيث قيل له. وتجرب ذلك على شبكة البيت فيعمل كأنه سحر، ثم يجربه صديقك من بيته عبر الإنترنت، فتبدأ الشخصيات تقفز من مكان إلى مكان، وتتأخر حركة شخصيتك عن يدك، وبعد أسبوع يكتشف أحد اللاعبين أنه يستطيع أن يكتب في ذاكرة اللعبة أي موقع يريده، فيظهر عند خط النهاية قبل الجميع. وهذه المشاكل الثلاث، التأخير والتقطع والغش، ليست أخطاء في كودك، وإنما هي طبيعة اللعب عبر شبكة، وكل لعبة جماعية تعالجها بالأفكار نفسها التي سوف نبنيها هنا.
وفي مقال حلقة اللعبة عرفنا أن اللعبة تحاكي العالم بخطوة ثابتة، وأن الرسم بين خطوتين يحتاج استيفاءً حتى لا تهتز الصورة. وفي هذا المقال نضيف إلى ذلك طرفاً ثالثاً بعيداً، هو السيرفر، تفصلنا عنه عشرات المللي ثواني. وسوف نبني في Godot 4.7.2 سيرفراً مخصصاً يعمل دون شاشة، وكلاينتات آلية Bots في Containers، ثم نضيف بينهما تأخيراً وارتعاشاً وفقداناً حقيقياً، ونقيس بالأرقام ما يراه اللاعب في كل طريقة.
وسوف نناقش في هذا المقال ما يلي:
- لماذا اللعب الجماعي مشكلة توقيت قبل أن يكون مشكلة شبكة، ومن يملك القرار في النماذج الأربعة المعروفة.
- لماذا تستخدم الألعاب UDP، وما الذي تضيفه ENet فوقه، وكيف تعمل الطبقة العليا للعب الجماعي في Godot: MultiplayerPeer ودوال RPC وأنماطها.
- مختبر حقيقي: سيرفر مخصص صاحب القرار، ولاعب آلي يتحرك، ومشاهدون، ومرحل يضيف التأخير والارتعاش والفقدان، وToxiproxy للاتصالات TCP.
- التنبؤ على الكلاينت Client-side Prediction والمطابقة مع السيرفر Server Reconciliation، مقيسة مقابل الطريقة البسيطة.
- استيفاء اللاعبين الآخرين Entity Interpolation، وكم تأخيراً تحتاج، وماذا يحدث عندما تنفد اللقطات.
- الفقدان وإعادة الترتيب، ولماذا يضيع أكثر مما يضيع في الشبكة، ومعدل التحديث Tick Rate وثمنه في الـ Bandwidth.
- أخطاء الصلاحيات في دوال RPC، وكيف يستغلها كلاينت معدل.
- الأخطاء الشائعة، وجدول قرار، وقائمة فحص.
لماذا اللعب الجماعي مشكلة توقيت؟
في اللعبة الفردية يوجد عالم واحد في ذاكرة واحدة، وكل ضغطة زر تغيره في الإطار نفسه. أما في اللعبة الجماعية فكل لاعب يرى نسخة من العالم على جهازه، وهذه النسخ يجب أن تبقى متفقة، والطريق الوحيد بينها شبكة تأخذ وقتاً. ووحدة القياس هنا زمن الذهاب والعودة Round Trip Time، واختصاراً RTT: الزمن من لحظة إرسال رسالة حتى وصول ردها. وفي مقال زمن الاستجابة Latency والإنتاجية Throughput بالأرقام قسنا أن جولة ذهاب وعودة واحدة إلى سيرفر في قارة أخرى تأخذ بين 139 و291 مللي ثانية، وجزء من هذا الرقم حد فيزيائي، فالضوء في الألياف يقطع قرابة 200 كيلومتر في المللي ثانية، وبالتالي لا يوجد إصلاح لهذا الرقم في كود اللعبة، والذي نستطيع فعله أن نخفي أثره عن اللاعب.
ولنأخذ مثالاً بأرقام اللعبة التي سوف نبنيها: الشخصية تتحرك 200 بكسل في الثانية، وزمن الذهاب والعودة 100 مللي ثانية. فإذا انتظر جهازك رد السيرفر قبل أن يحرك شخصيتك، فهي تبدأ الحركة بعد أن تضغط بعشر ثانية على الأقل، وتتوقف بعد أن ترفع إصبعك بعشر ثانية، أي أنها دائماً متأخرة عن يدك 20 بكسلاً. وإذا رسم جهازك اللاعب الآخر حيث قالت آخر رسالة وصلت، فأنت ترى ماضيه لا حاضره، وتراه يقفز كلما وصلت رسالة جديدة. وإذا تأخرت رسالة واحدة أو ضاعت، يتوقف في مكانه ثم يقفز مسافة أكبر.
وفوق ذلك كله، اللاعبون ليسوا كلهم أمناء. فأي شيء يحسبه جهاز اللاعب يستطيع اللاعب أن يغيره، لأن الجهاز جهازه والذاكرة ذاكرته. ولذلك السؤال الأول في تصميم أي لعبة جماعية ليس «كيف أرسل البيانات؟» وإنما «من صاحب القرار Authority؟»، أي من يحسب الحالة الحقيقية للعالم، ومن عليه أن يصدق من.
من صاحب القرار؟ أربعة نماذج Network Models
الشكل التالي يبين النماذج الأربعة التي ستجدها في أغلب الألعاب، ولكل منها ثمن مختلف:

- الخطوة المتزامنة Lockstep: كل جهاز يرسل مدخلاته فقط، أي الأزرار التي ضغطها في هذه الخطوة، وكل جهاز يحاكي العالم كاملاً بنفسه، ولا يتقدم أحد إلى الخطوة التالية حتى تصله مدخلات الجميع. والبيانات قليلة جداً لأنها مدخلات لا حالة، ولذلك تناسب ألعاب الاستراتيجية التي فيها آلاف الوحدات، ولكنها تحتاج محاكاة حتمية Deterministic تعطي النتيجة نفسها بالبت على كل جهاز، وأبطأ اتصال يحدد سرعة الجميع.
- الكلاينت صاحب القرار Client Authority: كل جهاز يحسب شخصيته ويرسل نتيجتها: موقعي هنا، وأصبت فلاناً. وهو أسهل نموذج تبنيه، وأغلب الدروس الأولى تبدأ به، ولكن الغش فيه لا يحتاج إلا تغيير رقم في الذاكرة، والخلاف بين جهازين على من أصاب من لا يحله أحد.
- اللاعب المستضيف Listen Server: جهاز أحد اللاعبين يعمل سيرفراً وكلاينتاً معاً. لا تدفع ثمن سيرفر، وهو ما تفعله ألعاب كثيرة مع الأصدقاء، ولكن المستضيف يلعب بتأخير صفر بينما يلعب الآخرون بتأخير، ويستطيع أن يغش لأنه السيرفر، وإذا أغلق لعبته انتهت المباراة للجميع.
- السيرفر المخصص صاحب القرار Dedicated Authoritative Server: برنامج يعمل على سيرفر لا يلعب عليه أحد، والكلاينت لا يرسل إلا نيته: الأزرار التي ضغطها، والسيرفر يحسب العالم ويرسل لقطات Snapshots من حالته للجميع. وهذا النموذج يحل مشكلة الثقة، ولكنه يجعل كل شيء يصل اللاعب متأخراً، ويحتاج سيرفراً يعمل وتدفع ثمنه.
ويلخص توثيق اللعب الجماعي في Godot هذا الاختيار في قسم «التصميم الآمن»: عامل كل مدخلات الكلاينت على أنها غير موثوقة، واجعل السيرفر مصدر الحقيقة للحالة المهمة، وأرسل نية الحركة لا الموقع النهائي، مع الاعتراف بأن ثمن ذلك أداء على السيرفر وتعقيد التنبؤ على الكلاينت. وهذا الثمن بالضبط هو موضوع بقية المقال، لأننا سوف نبني النموذج الرابع ثم ندفع ثمنه خطوة خطوة.
لماذا UDP؟ وما الذي تضيفه ENet فوقه
شرحنا في مقال TCP وUDP وDHCP ببساطة أن TCP يضمن وصول كل بايت بالترتيب، وأن UDP يرسل الحزمة ولا ينتظر. والمشكلة في TCP للألعاب ليست البطء، وإنما الترتيب الإجباري: إذا ضاعت حزمة واحدة، فكل الحزم التي بعدها تنتظر في ذاكرة المستقبل حتى تعاد الحزمة الضائعة، وهذا ما يسمى حجب رأس الطابور Head-of-Line Blocking. ولعبة ترسل الموقع عشرين مرة في الثانية لا تحتاج الموقع القديم الذي ضاع، لأن الأحدث منه في الطريق، ولكن TCP يصر على إعادته أولاً، فيصل كل شيء بعده متأخراً.
ولذلك تبني أغلب الألعاب بروتوكولها فوق UDP، وتضيف بنفسها ما تحتاجه من TCP فقط، لبعض الرسائل فقط. ومكتبة ENet التي يستخدمها Godot مثال على ذلك: اتصال فوق UDP، وفيه قنوات Channels منفصلة، وكل رسالة تختار طريقة إرسالها:
- موثوقة Reliable: تعاد حتى يصل إقرارها، وتصل بالترتيب داخل قناتها. للرسائل التي لا يجوز أن تضيع: الشراء، والانضمام، ونتيجة المباراة.
- غير موثوقة مرتبة Unreliable Ordered: لا تعاد، وإذا وصلت رسالة أقدم بعد رسالة أحدث منها يرميها المستقبل. للحالة التي تتجدد باستمرار مثل اللقطات.
- غير موثوقة Unreliable: لا تعاد، وقد تصل بأي ترتيب، والكود يرتبها بنفسه إذا أراد.
وهذه الأنماط الثلاثة هي نفسها التي تكتبها في Godot عند تعريف أي دالة RPC، كما سيأتي. وانتبه إلى الوصف الدقيق للنمط الثاني في التوثيق: الرسالة التي تصل متأخرة بعد أحدث منها يتجاهلها المستقبل، وهذا يعني أن الشبكة التي تعيد ترتيب الحزم تضيع رسائلك حتى لو لم تفقد أي حزمة، وسوف نقيس ذلك في المختبر.
وأما في المتصفح فلا يوجد UDP متاح للصفحة، ولذلك يصدر Godot لعبة الويب بالنقل WebSocketMultiplayerPeer، وهو اتصال TCP، أو WebRTC. وشرحنا WebSocket نفسه في مقال التواصل اللحظي Polling وSSE وWebSocket، والذي يهمنا هنا أن كل رسالة فيه موثوقة ومرتبة مهما طلبت، فإذا كانت لعبتك ستصدر للويب كما في مقال تصدير اللعبة من Godot، فاعرف أن نسختها على الويب ستتصرف مع الفقدان بطريقة مختلفة عن نسخة سطح المكتب.
اللعب الجماعي في Godot: MultiplayerPeer ودوال RPC
الطبقة العليا للعب الجماعي في Godot لها ثلاثة أجزاء. الأول هو الـ MultiplayerPeer، أي طريقة النقل: ENetMultiplayerPeer أو WebSocketMultiplayerPeer أو WebRTCMultiplayerPeer، وكلها تقدم الواجهة نفسها، فتغير النقل بسطر واحد. والثاني هو الـ MultiplayerAPI الذي تصل إليه من أي عقدة بالخاصية multiplayer، وفيه رقم كل جهاز: السيرفر رقمه 1 دائماً، وكل كلاينت يأخذ رقماً عشوائياً كبيراً عند الاتصال، وفيه إشارات Signals مثل peer_connected وpeer_disconnected. والثالث دوال RPC، أي دوال تستدعيها على جهاز آخر كأنها دوال محلية. وهذا كل ما يحتاجه السيرفر ليبدأ:
var peer := ENetMultiplayerPeer.new()
var err := peer.create_server(7777, 64) # UDP port 7777, at most 64 clients
multiplayer.multiplayer_peer = peer
multiplayer.peer_connected.connect(func(id: int) -> void: print("peer %d connected" % id))والكلاينت يستدعي create_client(address, 7777) بدل create_server. وأما دالة RPC فتعرفها بالتعليق @rpc قبلها، وله أربعة معاملات، وقيمه الافتراضية كما يذكر التوثيق هي @rpc("authority", "call_remote", "reliable", 0):
- من يحق له الاستدعاء Mode:
"authority"يعني أن صاحب القرار في العقدة فقط يستدعيها، وهو السيرفر افتراضياً، و"any_peer"يعني أن أي كلاينت يستطيع أن يستدعيها على السيرفر، وهذا ما تحتاجه لإرسال المدخلات، وهو أيضاً الباب الذي يدخل منه الغش كما سنرى. - هل تنفذ محلياً Sync:
"call_remote"على الأجهزة الأخرى فقط، و"call_local"عليها وعلى الجهاز الذي استدعاها، وهو مفيد في نموذج اللاعب المستضيف. - طريقة النقل Transfer Mode:
"reliable"أو"unreliable_ordered"أو"unreliable"، أي الأنماط الثلاثة التي شرحناها في ENet. - القناة Channel: رقم القناة، حتى لا تنتظر رسائل الحركة رسائل الدردشة الموثوقة مثلاً.
ويشترط Godot أن تكون كل دوال RPC في السكربت معرفة على السيرفر وعلى الكلاينت بالتوقيع نفسه وفي مسار العقدة نفسه، لأنه يتحقق من مجموع تحقق Checksum لكل دوال RPC في السكربت، والخطأ الذي يظهر عندما يختلفان قد لا يذكر الدالة التي سببته. ولهذا السبب كتبنا المختبر كله في سكربت واحد يعمل سيرفراً أو كلاينتاً بحسب الخيار الذي تمرره له، فلا يمكن أن يختلف الطرفان. وداخل أي دالة RPC تعطيك multiplayer.get_remote_sender_id() رقم الجهاز الذي استدعاها، وهي السطر الأهم في أي سيرفر، كما سيأتي في قسم الصلاحيات.
وفي Godot أيضاً عقدتان تبنيان كثيراً من هذا تلقائياً: MultiplayerSpawner الذي ينشئ العقد على كل الأجهزة، وMultiplayerSynchronizer الذي ينسخ خصائص عقدة من صاحب القرار فيها إلى الآخرين. وهما مناسبان للنماذج الأولى والألعاب التعاونية، ولكنهما لا يقدمان التنبؤ والمطابقة، ولذلك كتبناهما في المختبر بدوال RPC صريحة، حتى ترى كل رسالة وكل رقم.
المختبر Lab: سيرفر مخصص وكلاينتات آلية
اللعبة في المختبر أبسط ما يمكن حتى لا يخفي شيء الأرقام: كل لاعب نقطة في عالم ثنائي الأبعاد، تتحرك 200 بكسل في الثانية بالأسهم، والمحاكاة 60 خطوة في الثانية على السيرفر وعلى الكلاينت. والسيرفر نسخة Godot 4.7.2 الرسمية نفسها تعمل بالخيار --headless، أي دون شاشة ودون صوت، وكل كلاينت نسخة أخرى منها دون شاشة، يلعب بدل الإنسان بنمط ثابت: يمين ثانية، ثم يتوقف نصف ثانية، ثم يسار ثانية، ثم يتوقف نصف ثانية. وكل جهاز في Container مستقل على شبكة Docker واحدة، والشكل التالي يبين المختبر كله:

والكلاينتات بأدوارها كما يلي:
- اللاعب المتحرك mover: يرسل مدخلاً في كل خطوة، ويقيس ثلاثة أرقام: الزمن من «الضغطة» حتى تتحرك شخصيته على شاشته، وعدد التصحيحات التي فرضها السيرفر وحجمها، والمسافة بين ما تعرضه شاشته وما تقوله يده، أي الموقع الذي كانت ستصله الشخصية لو لم توجد شبكة أصلاً.
- المشاهدون watchers: لا يتحركون، وإنما يرسمون اللاعب المتحرك كما يصلهم، ويقيسون سرعته كما تظهر على الشاشة إطاراً إطاراً. والسرعة الحقيقية 200 بكسل في الثانية، فكل انحراف عنها تقطع يراه اللاعب.
- الكلاينت المعدل cheat: نسخة من اللعبة غيرنا فيها سطرين، لنجرب أخطاء الصلاحيات.
والسكربت main.gd واحد للجميع كما ذكرنا، ويختار دوره من الخيارات بعد -- في سطر الأوامر، والتي يقرؤها بالدالة OS.get_cmdline_user_args(). وهذا تشغيل السيرفر ولاعب ومشاهد:
docker run -d --init --name gm3-srv --network gm3-net -v "$PWD/game:/game" gm3-godot:4.7.2 \
godot --headless --path /game -- --server --snap 20 --inbuf on
docker run -d --init --name gm3-c2 --network gm3-net -v "$PWD/game:/game" -v "$PWD/out:/out" gm3-godot:4.7.2 \
godot --headless --path /game -- --client --name c2 --host gm3-relay --role watcher --render interp --delay 100 --duration 22
docker run -d --init --name gm3-c1 --network gm3-net -v "$PWD/game:/game" -v "$PWD/out:/out" gm3-godot:4.7.2 \
godot --headless --path /game -- --client --name c1 --host gm3-relay --role mover --mode reconcile --duration 20في الأوامر أعلاه لاحظ التالي:
--init: يضع عملية init صغيرة أول عملية في الـ Container، تمرر الإشارات Signals إلى Godot وتجمع العمليات المنتهية، وما يحدث للسيرفر عند إيقافه موضوع مقال خوادم الألعاب المخصصة في هذه المرحلة.--host gm3-relay: الكلاينتات لا تتصل بالسيرفر مباشرة، وإنما بالمرحل، والمرحل يتصل بالسيرفر. وهكذا نتحكم بكل حزمة في الطريق.--snap 20: السيرفر يحاكي 60 خطوة في الثانية ويرسل لقطة كل ثلاث خطوات، أي 20 لقطة في الثانية، وسوف نغير هذا الرقم في قسم الـ Bandwidth.- الـ Image:
gm3-godot:4.7.2هيdebian:bookworm-slimمع ملف Godot الرسمي من GitHub بعد التحقق من بصمته SHA512، والـ Dockerfile في مجلدlab.
مشكلة في الطريق: Toxiproxy لا يمرر UDP
لصناعة إنترنت سيئ على جهاز واحد، الطريقة المعتادة على Linux هي الأداة tc مع netem، التي استخدمناها في مقال TCP وUDP. ولكن نواة WSL 2 التي يعمل عليها Docker Desktop لا تحتوي وحدة netem، وهذا ما ظهر عند المحاولة في Container بصلاحية NET_ADMIN:
$ docker run --rm --cap-add NET_ADMIN alpine sh -c "apk add -q iproute2-tc; tc qdisc add dev eth0 root netem delay 50ms"
Error: Specified qdisc kind is unknown.فانتقلنا إلى Toxiproxy من Shopify، وهو وسيط Proxy تضيف إليه «سموماً» Toxics مثل التأخير والارتعاش وقطع الاتصال من واجهة HTTP، واستخدمنا إصداره 2.13.0. ولكن Toxiproxy وسيط TCP فقط، أي أنه يستقبل اتصالات TCP ويمررها، ولعبتنا تتكلم UDP عبر ENet. وهذا ما حدث عندما وجهنا كلاينت ENet إلى منفذ في Toxiproxy:
$ python toxi.py udp-test 0.0.0.0:7777 gm3-srv:7777 # Toxiproxy log: "Started proxy" listen 0.0.0.0:7777
c1: connecting to gm3-toxi (enet) role mover mode reconcile render interp delay 100 ms redundancy 1, err=0
31.52 s connection failedولاحظ أن err=0 لا يعني أن الاتصال نجح، فالدالة create_client تجهز الطرف المحلي فقط وترجع فوراً، ثم ترسل ENet طلب الاتصال عبر UDP إلى المنفذ 7777، حيث يستمع Toxiproxy على TCP فقط، فلا يرد أحد، وتعيد ENet المحاولة حتى تستسلم بعد 31.5 ثانية وتطلق الإشارة connection_failed. وهذا درس صغير ينفعك في أي سيرفر لعبة: افتح المنفذ بالبروتوكول الصحيح في الجدار الناري وفي Docker، أي 7777/udp لا 7777 وحده، لأن الخطأ لا يظهر رسالة واضحة، وإنما مهلة طويلة ثم فشل.
ولذلك كتبنا مرحلاً صغيراً بلغة Python، في سبعين سطراً، يستقبل حزم UDP من كل كلاينت ويفتح لكل كلاينت Socket خاصاً نحو السيرفر، فيرى السيرفر كل كلاينت جهازاً مستقلاً، ويؤخر كل حزمة في الاتجاهين ويحذف بعضها. وهذا قلبه:
def later(send, data, direction):
c = count[direction]
if rng.random() < LOSS:
c[2] += 1
return
c[0] += 1; c[1] += len(data)
d = max(0.0, DELAY + rng.uniform(-JITTER, JITTER)) # each packet its own delay: packets can arrive out of order
asyncio.get_running_loop().call_later(d, send, data)ولاحظ أن كل حزمة تأخذ تأخيرها الخاص، فإذا كان التأخير 50 مللي ثانية والارتعاش 20، فحزمة أرسلت بعد أخرى بـ 16 مللي ثانية قد تصل قبلها، وهذا ما يحدث في الإنترنت الحقيقي عندما تسلك الحزم طرقاً مختلفة أو تنتظر في طوابير مختلفة. والتأخير في كل اتجاه، فإذا ضبطناه على 50 فزمن الذهاب والعودة 100 مللي ثانية زائداً ما يضيفه Godot والجهاز، وقد قاسته ENet نفسها بين 108 و129 مللي ثانية في التجارب. وأما Toxiproxy فبقي له دور مهم: نسخة الويب من اللعبة تتكلم WebSocket فوق TCP، فاستخدمناه لها كما سيأتي.
الطريقة البسيطة: الشاشة ترسم ما يقوله السيرفر
نبدأ بأبسط سيرفر صاحب قرار يمكن كتابته. الكلاينت يرسل في كل خطوة المدخل الذي ضغطه، مع رقم تسلسل Sequence يزيد واحداً كل خطوة، والسيرفر يطبقه على موقع اللاعب، ثم يرسل لقطة بمواقع الجميع، والكلاينت يرسم شخصيته حيث قالت اللقطة. وهذه دالة السيرفر التي تستقبل المدخلات:
@rpc("any_peer", "unreliable_ordered")
func client_input(entries: Array) -> void:
## entries: the last N inputs [[seq, dx, dy], ...], oldest first. Redundancy hides single lost packets.
var id := multiplayer.get_remote_sender_id()
if not players.has(id):
return
var p: Dictionary = players[id]
for e in entries:
var s: int = e[0]
if s <= p.last_seq:
continue # already applied (a redundant copy)
if s > p.last_seq + 1 and p.last_seq > 0:
p.missed += s - p.last_seq - 1 # these inputs never arrived: they are lost for good
p.last_seq = s
if opt("inbuf", "off") == "on":
p.queue.append(e) # applied one per tick in server_tick()
else:
apply_input(p, e) # applied the moment it arrives
func apply_input(p: Dictionary, e: Array) -> void:
var d := Vector2(e[1], e[2])
if opt("check", "on") == "on":
d = d.limit_length(1.0) # the server decides the speed, not the client
p.pos += d * SPEED * DT
p.dir = d
p.done_seq = e[0]
p.applied += 1في الكود أعلاه لاحظ التالي:
"any_peer": لأن الكلاينتات هي التي تستدعيها، و"unreliable_ordered"لأن المدخل القديم لا قيمة له إذا وصل بعد الأحدث، وسوف نرى أن هذا الاختيار له ثمن.get_remote_sender_id(): السيرفر لا يسأل الكلاينت «من أنت؟»، وإنما يعرف المرسل من الاتصال نفسه، فلا يستطيع كلاينت أن يرسل مدخلات باسم غيره.limit_length(1.0): الكلاينت يرسل اتجاهاً فقط، وطول المتجه لا يزيد على واحد مهما أرسل، والسرعةSPEEDثابت في السيرفر. وهذا السطر وحده يوقف أبسط غش في السرعة، وسوف نعود إليه في مقال مكافحة الغش.done_seq: رقم آخر مدخل طبقه السيرفر، ويرسله في كل لقطة، وعليه يقوم كل ما سيأتي.- الطابور
queue: الخيار--inbufيجعل المدخلات تنتظر في طابور ويطبق السيرفر واحداً في كل خطوة بدل أن يطبقها لحظة وصولها، وسوف نشرح سببه بعد قليل.
شغلنا اللاعب المتحرك مرة دون تأخير في المرحل، ومرة بتأخير 50 مللي ثانية في كل اتجاه، وفي المرتين ترسم شاشته موقع السيرفر فقط، وهذا سطر النتيجة الثانية:
c1 RESULT own: input->screen avg 168.2 ms max 183.6 ms (7 starts) | corrections 0 avg 0.00 px max 0.00 px | backward frames 0 | disagree 0 avg 0.00 max 0.00 px | behind the hand avg 21.7 px max 36.7 px | final screen (230.0, 140.0) server (230.0, 140.0)والقراءة كما يلي:
input->screen avg 168.2 ms: في كل مرة بدأ اللاعب الحركة، وهي سبع مرات في عشر ثوان، مر 168 مللي ثانية في المتوسط قبل أن تتحرك شخصيته على شاشته. وهذا الرقم أكبر من زمن الذهاب والعودة الذي قاسته ENet، 116 مللي ثانية، لأنه يضيف انتظار المدخل في طابور السيرفر، وانتظار اللقطة التالية، فهي ترسل كل 50 مللي ثانية، وانتظار الإطار التالي على الكلاينت.behind the hand avg 21.7 px: في المتوسط كانت الشخصية على الشاشة متأخرة 21.7 بكسل عن الموقع الذي تقوله يد اللاعب، وفي أسوأ لحظة 36.7 بكسل، أي أكثر من عرض شخصية صغيرة.final screenوserver: متطابقان، لأن الشاشة لا تعرض إلا ما قاله السيرفر. فلا خلاف ولا تصحيح، ولكن اللعبة تبدو ثقيلة كأن الشخصية تسبح في الوحل.
وحتى دون أي تأخير في المرحل، على شبكة Docker داخل الجهاز نفسه، كان المتوسط 98 مللي ثانية في تشغيل و78 في آخر، لأن الطابور وانتظار اللقطة ثابتان مهما كانت الشبكة. والقاعدة التي يعرفها مطورو ألعاب الحركة أن اللاعب يشعر بالتأخير بين يده والشاشة بداية من عشرات المللي ثواني، ولذلك لا تقبل هذه الطريقة إلا في الألعاب البطيئة مثل الألعاب الدورية Turn-based، حيث لا يهم إن ظهرت الحركة بعد عشر ثانية.
التنبؤ على الكلاينت Client-side Prediction
الفكرة بسيطة: حركة شخصيتك تعتمد على مدخلاتك فقط، وأنت تعرف مدخلاتك قبل السيرفر، والكلاينت يملك كود الحركة نفسه، فلماذا ينتظر؟ يحرك الكلاينت شخصيته فوراً كما سيحركها السيرفر، ويرسل المدخل في الوقت نفسه، ويحفظه في قائمة المدخلات التي لم يؤكدها السيرفر بعد. وهذا ما يفعله الكلاينت في كل خطوة:
seq += 1
history.append([seq, d.x, d.y])
var n := int(opt("redundancy", "1"))
client_input.rpc_id(1, history.slice(maxi(0, history.size() - n)))
ideal += d * SPEED * DT # where the player's hand says the character should be
if opt("mode", "reconcile") != "naive":
pred += d * SPEED * DT
pred_by_seq[seq] = predوالسطر rpc_id(1, ...) يرسل للسيرفر وحده، فرقمه 1 دائماً. والمتغير ideal هو موقع اليد الذي نقيس منه التأخر فقط، وpred هو الموقع المتنبأ به، وهو ما ترسمه الشاشة، وpred_by_seq يحفظ ما توقعناه بعد كل مدخل حتى نقارنه بما يقوله السيرفر عن المدخل نفسه. والنتيجة على الشبكة نفسها، بزمن ذهاب وعودة 121 مللي ثانية:
c1 RESULT own: input->screen avg 0.5 ms max 2.2 ms (7 starts) | corrections 0 avg 0.00 px max 0.00 px | backward frames 0 | disagree 0 avg 0.00 max 0.00 px | behind the hand avg 0.0 px max 0.0 px | final screen (236.7, 140.0) server (223.3, 140.0)من 168 مللي ثانية إلى نصف مللي ثانية، أي في الإطار نفسه، والشخصية لم تتأخر عن اليد بكسلاً واحداً. ولاحظ السطر الأخير: الشاشة عند 236.7 والسيرفر عند 223.3، لأن الشاشة أصبحت في المستقبل بالنسبة للسيرفر، فهي تعرض مدخلات ما زالت في الطريق إليه. والشكل التالي يقارن الطريقتين على خط زمني واحد:

وقد يتساءل البعض: إذا كان الكلاينت يحرك نفسه، فما الفرق بينه وبين النموذج الذي يكون فيه الكلاينت صاحب القرار؟ والإجابة أن الكلاينت هنا يتنبأ فقط، والسيرفر ما زال يحسب الحقيقة من المدخلات، فإذا تنبأ الكلاينت بشيء لم يحدث، لأن مدخلاً ضاع أو لأن السيرفر يعرف شيئاً لا يعرفه، مثل جدار تحرك أو لاعب دفعه، فالسيرفر هو من يحكم، والكلاينت هو من يصحح نفسه. وهنا يأتي السؤال: كيف يصحح نفسه؟
لماذا لا يكفي أن تأخذ موقع السيرفر؟
الطريقة البسيطة للتصحيح: كلما وصلت لقطة، ضع الشخصية حيث يقول السيرفر، ثم تابع التنبؤ من هناك. وهذا ما يفعله الخيار --mode snap، ونتيجته على الشبكة نفسها:
c1 RESULT own: input->screen avg 7.4 ms max 16.9 ms (7 starts) | corrections 69 avg 7.10 px max 13.33 px | backward frames 21 | disagree 147 avg 26.85 max 33.33 px | behind the hand avg 20.4 px max 33.3 px | final screen (226.7, 140.0) server (226.7, 140.0)الحركة تبدأ فوراً تقريباً، ولكن السيرفر لا يعطي إلا الماضي: اللقطة التي تصل الآن تصف موقعك بعد مدخل أرسلته قبل زمن الذهاب والعودة، والمدخلات التي أرسلتها بعده لم يرها بعد. فإذا وضعت الشخصية عند موقع السيرفر، فأنت ترجعها إلى الماضي، ثم يتابع التنبؤ منه. ولذلك رأينا 69 تصحيحاً في عشر ثوان، و21 إطاراً رأى فيها اللاعب شخصيته ترجع إلى الخلف وهو يضغط إلى الأمام، وهذا ما يسميه اللاعبون الشريط المطاطي Rubber Banding، وبقيت الشخصية متأخرة عن اليد 20.4 بكسل في المتوسط، أي قريباً من الطريقة البسيطة تماماً. فقد ربحنا بداية الحركة، وخسرنا كل شيء بعدها.
المطابقة مع السيرفر Server Reconciliation
الحل الصحيح، كما يشرحه Gabriel Gambetta في مقاله عن التنبؤ والمطابقة والذي أصبح المرجع الذي يحيل إليه أغلب المطورين: خذ موقع السيرفر بعد المدخل الذي أكده، ثم أعد تطبيق كل المدخلات التي أرسلتها بعده ولم يرها بعد. فإذا كان السيرفر قد طبقها كما طبقتها أنت، تصل إلى الموقع نفسه الذي كنت فيه، فلا يرى اللاعب شيئاً، وإذا اختلف شيء، فأنت تصحح الفرق وحده لا كل زمن الذهاب والعودة. والشكل التالي يبين الطريقتين:

وهذه الدالة في المختبر، وتعمل عند وصول كل لقطة:
while history.size() > 0 and history[0][0] <= server_seq:
history.pop_front()
var before := pred
if mode == "snap":
pred = server_pos # trust the server, drop my unacknowledged inputs
elif mode == "reconcile":
pred = server_pos # start from the server's truth ...
for h in history: # ... and replay what it has not seen yet
pred += Vector2(h[1], h[2]) * SPEED * DT
pred_by_seq[h[0]] = predوالحلقة الأولى ترمي من القائمة كل مدخل أكده السيرفر، فيبقى فيها ما بعد server_seq فقط، وعند 60 مدخلاً في الثانية وزمن ذهاب وعودة 120 مللي ثانية يبقى فيها سبعة أو ثمانية مدخلات، أي أن إعادة التطبيق رخيصة جداً في لعبتنا. ولكن في لعبة يمر فيها كل مدخل على فيزياء كاملة، فإعادة تطبيق عشرة مدخلات مع كل لقطة تعني عشر خطوات فيزياء إضافية في الإطار، وهذا من أسباب أن بعض المحركات تحاكي شخصية اللاعب وحدها في التنبؤ، لا العالم كله. والنتيجة رأيناها في التشغيل السابق: صفر تصحيحات، وصفر إطارات للخلف، والشاشة مطابقة لليد.
ماذا لو تنبأت ولم تطابق أبداً؟
قد يبدو أن المطابقة لا تفعل شيئاً إذا كانت النتيجة صفر تصحيحات، فلماذا لا يتنبأ الكلاينت ويتجاهل السيرفر في حركته؟ شغلنا ذلك بالخيار --mode predict على شبكة فيها فقدان 5% وارتعاش 20 مللي ثانية:
c1 RESULT own: input->screen avg 0.3 ms max 0.7 ms (14 starts) | corrections 0 avg 0.00 px max 0.00 px | backward frames 0 | disagree 359 avg 16.22 max 33.33 px | behind the hand avg 0.0 px max 0.0 px | final screen (133.3, 140.0) server (153.3, 140.0)الشاشة سلسة تماماً، ولكن الكلاينت اختلف مع السيرفر 359 مرة في عشرين ثانية، بمتوسط 16 بكسل، وانتهى في موقع يبعد 20 بكسل عن موقعه الحقيقي. أي أن اللاعب يرى نفسه في مكان، والسيرفر واللاعبون الآخرون يرونه في مكان آخر، فيصوب عليه أحدهم ويصيبه وهو يرى نفسه بعيداً، وكلما طالت المباراة كبر الفرق. والمطابقة هي ما يمنع هذا التراكم، حتى لو لم يحتجها في أغلب الوقت. وفي التشغيل نفسه مع إرسال آخر أربعة مدخلات في كل حزمة كانت الخلافات صفراً، وسنرى السبب في قسم الفقدان.
استيفاء اللاعبين الآخرين Entity Interpolation
التنبؤ يصلح شخصيتك أنت، لأنك تعرف مدخلاتك. أما اللاعب الآخر فلا تعرف مدخلاته، وكل ما يصلك عنه لقطات من السيرفر، عشرون في الثانية، بينما شاشتك ترسم ستين إطاراً. فإذا رسمته عند آخر لقطة وصلت، فهو يقف في مكانه إطارين ثم يقفز 10 بكسل في الإطار الثالث. والحل الذي تستخدمه أغلب الألعاب، ويشرحه Glenn Fiedler في مقاله عن استيفاء اللقطات، أن ترسم اللاعب الآخر في الماضي عمداً، بتأخير ثابت، فيكون عندك دائماً لقطتان، واحدة قبل اللحظة التي ترسمها وواحدة بعدها، وتستوفي بينهما. وهذه هي الفكرة نفسها التي رأيناها في مقال حلقة اللعبة بين خطوتي فيزياء، ولكن الفاصل هنا 50 مللي ثانية تأتي عبر شبكة، لا 16 مللي ثانية تأتي من المعالج. وهذا الكود في المختبر:
var est := 0.0
for o in offsets:
est = o[1] if est == 0.0 else minf(est, o[1]) # smallest (arrival - server time) = least delayed packet
var server_now := now / 1000000.0 - est
var render_t := server_now - float(opt("delay", "100")) / 1000.0
...
var j := buf.size() - 1
while j > 0 and buf[j - 1][0] > render_t:
j -= 1
if j == 0 or buf[j][0] < render_t:
disp = buf[-1][1] if buf[-1][0] <= render_t else buf[0][1]
moving = buf[-1][2]
if buf[-1][0] <= render_t:
stats.underrun += 1 # no newer snapshot yet: hold the last position
else:
var s0: Array = buf[j - 1]
var s1: Array = buf[j]
var w := clampf((render_t - s0[0]) / maxf(s1[0] - s0[0], 0.0001), 0.0, 1.0)
disp = (s0[1] as Vector2).lerp(s1[1], w)في الكود أعلاه لاحظ التالي:
- ساعة السيرفر: كل لقطة تحمل رقم خطوة السيرفر، والكلاينت يحسب لكل لقطة الفرق بين لحظة وصولها وزمنها في السيرفر، ويأخذ أصغر فرق في آخر ثلاث ثوان، لأن أسرع حزمة وصلت هي الأقرب إلى التأخير الحقيقي دون انتظار. ومنه يقدر «الآن» بتوقيت السيرفر دون أن تتفق الساعتان.
render_t: اللحظة التي نرسمها، وهي «الآن» بتوقيت السيرفر ناقص تأخير الاستيفاء، 100 مللي ثانية افتراضياً، أي لقطتان عند 20 لقطة في الثانية.- نفاد اللقطات Underrun: إذا لم تصل لقطة بعد اللحظة التي نرسمها، لأن لقطة تأخرت أو ضاعت، فلا يوجد ما نستوفي إليه، فنبقي اللاعب في آخر موقع ونعد الإطار. وبعض الألعاب تستقرئ Extrapolate في هذه الحالة، أي تكمل الحركة بالسرعة الأخيرة، وثمنها أن تخطئ عندما يغير اللاعب اتجاهه.
والشكل التالي من تشغيل حقيقي فيه زمن ذهاب وعودة قرابة 115 مللي ثانية وارتعاش 20 مللي ثانية، ومشاهدان يرسمان اللاعب نفسه في الوقت نفسه، كل نقطة إطار واحد:

وهذان سطرا النتيجة من التشغيل نفسه:
c2 RESULT remote (snap): moving frames 224, screen speed avg 202 px/s sd 307, frames without movement 67.0%, underrun frames 0
c3 RESULT remote (interp): moving frames 332, screen speed avg 195 px/s sd 29, frames without movement 0.0%, underrun frames 24والقراءة كما يلي: المتوسط في الحالتين قريب من 200، لأن اللاعب يقطع المسافة نفسها في النهاية، ولكن الانحراف المعياري للسرعة على الشاشة 307 بكسل في الثانية مع آخر لقطة، أي أن السرعة تتأرجح بين صفر و600، و67% من الإطارات لم يتحرك فيها اللاعب أصلاً، وهذا ما تراه عينك تقطعاً. ومع الاستيفاء نزل الانحراف إلى 29 بكسل في الثانية، ولم يبق إطار واحد دون حركة، و24 إطاراً فقط من قرابة 500 نفدت فيها اللقطات. والثمن واضح في الكود: أنت ترى اللاعب الآخر متأخراً 100 مللي ثانية فوق تأخير الشبكة، وهذا ثمن تدفعه أغلب ألعاب التصويب، ويعالج التعويض عن التأخير أثره على الإصابات كما سيأتي.
لماذا يتحرك اللاعب بخطوات غير متساوية؟ طابور المدخلات Input Buffer
في أول نسخة من المختبر كان السيرفر يطبق كل مدخل لحظة وصوله، وكان الاستيفاء يعطي حركة أقل انتظاماً مما توقعنا حتى دون أي تأخير في المرحل. فأضفنا عداداً يحسب كم تحرك اللاعب بين كل لقطتين متتاليتين، والمفروض 10 بكسل دائماً، أي ثلاثة مدخلات في 50 مللي ثانية. وهذا ما طبعه المشاهد على شبكة بتأخير 50 مللي ثانية في كل اتجاه، مرة دون طابور ومرة بطابور:
no input buffer: remote movement between snapshots (px: count) 3: 2, 7: 12, 10: 50, 13: 7, 17: 4
input buffer: remote movement between snapshots (px: count) 7: 2, 10: 107دون طابور، كثير من اللقطات حملت حركة مدخل واحد أو اثنين أو أربعة أو خمسة، أي 3 أو 7 أو 13 أو 17 بكسل، لأن الحزم لا تصل بانتظام: الكلاينت يرسلها كل 16.7 مللي ثانية، ولكن Godot على الكلاينت ينفذ أحياناً خطوتي فيزياء في إطار واحد، والشبكة تجمع حزمتين أحياناً وتؤخر أخرى، فيطبق السيرفر في فترة لقطة واحدة أربعة مدخلات وفي التالية اثنين. والنتيجة أن السرعة نفسها التي ترسلها اللقطات غير منتظمة، والاستيفاء لا يستطيع أن يصلح ذلك، فانحراف السرعة على الشاشة كان 59 بكسل في الثانية دون طابور و32 بالطابور في التشغيلين نفسيهما.
والطابور أن يضع السيرفر المدخلات في قائمة لكل لاعب، ويطبق واحداً فقط في كل خطوة، كما فعل الكلاينت حين تنبأ:
if opt("inbuf", "off") == "on":
for id in players:
var p: Dictionary = players[id]
if p.dir != Vector2.ZERO or p.queue.size() > 0:
p.qsum = p.get("qsum", 0) + p.queue.size(); p.qn = p.get("qn", 0) + 1 # how many inputs wait = added delay
if p.queue.size() > 0:
apply_input(p, p.queue.pop_front()) # exactly one input per tick, like the client simulated it
while p.queue.size() > 4:
apply_input(p, p.queue.pop_front()) # too far behind: catch up instead of adding delay
elif p.dir != Vector2.ZERO:
p.starved = p.get("starved", 0) + 1والطابور له ثمن، فكل مدخل ينتظر فيه دوره، وهذا تأخير يضاف إلى كل ما سبق. ولذلك أضفنا إلى السيرفر عداداً لطول الطابور، وقسنا الطريقة البسيطة، أي الشاشة التي ترسم موقع السيرفر، مرة دون طابور ومرة به، في الظروف نفسها:
LAN, no buffer: input->screen avg 56.9 ms max 75.9 ms queue avg 0.0 inputs
LAN, buffer: input->screen avg 77.7 ms max 105.3 ms queue avg 3.1 inputs
RTT 100, no buffer: input->screen avg 155.2 ms max 172.6 ms queue avg 0.0 inputs
RTT 100, buffer: input->screen avg 189.7 ms max 218.0 ms queue avg 3.1 inputsكان في الطابور ثلاثة مدخلات في المتوسط، أي أن كل مدخل انتظر قرابة 50 مللي ثانية قبل أن يطبق، وظهر ذلك في زمن الضغطة حتى الشاشة زيادة بين 21 و35 مللي ثانية. والسبب في كودنا أن السيرفر لا يلحق إلا إذا زاد الطابور على أربعة، فيستقر الطابور قرب هذا الحد. والتنبؤ يخفي هذا التأخير عن اللاعب نفسه كما رأينا، ولكن اللاعبين الآخرين يرونه، والسيرفر يحكم على الإصابات بموقع متأخر أكثر. والألعاب التي تستخدم الطابور تجعله صغيراً قدر الإمكان، مدخلاً أو اثنين، وتقلصه تدريجياً إذا بقي أطول من ذلك فترة، وهذا من التمارين في آخر المقال. وتذكر أن هذا اختيار، لا قاعدة: الطابور يشتري انتظام الحركة بزمن، ولعبة بطيئة لا تحتاجه، ولعبة تصويب تنافسية تقيس كل مللي ثانية فيه.
الفقدان والارتعاش Packet Loss and Jitter
إلى هنا كانت الشبكة بطيئة ولكنها منتظمة. الآن نضيف ما يحدث في شبكات الجوال والواي فاي المزدحمة: فقدان 5% من الحزم في كل اتجاه، وارتعاش ±20 مللي ثانية في تأخير كل حزمة. ولنفصل أثر كل منهما شغلنا اللاعب نفسه ثلاث مرات، كل مرة عشرين ثانية، والسيرفر يطبع عند خروج اللاعب كم مدخلاً طبق وكم مدخلاً لم يصله أبداً:
loss 5%, no jitter: peer 1539889564 left: inputs applied 1119, missed 70, starved ticks 47
no loss, jitter +-20 ms: peer 323589224 left: inputs applied 939, missed 245, starved ticks 158
loss 5% and jitter: peer 2050355547 left: inputs applied 916, missed 274, starved ticks 187والقراءة هنا هي أهم درس في المقال:
- الفقدان وحده: ضاع 70 مدخلاً من 1,189، أي 5.9%، وهذا قريب مما يحذفه المرحل، فكل حزمة ضاعت أضاعت مدخلها.
- الارتعاش وحده، دون أي حزمة مفقودة: ضاع 245 مدخلاً من 1,184، أي 20.7%. والسبب ما قرأناه في وصف النمط
unreliable_ordered: الحزمة التي تصل بعد حزمة أحدث منها ترمى. ومع ارتعاش ±20 مللي ثانية وحزم كل 16.7 مللي ثانية، تتبادل الحزم أماكنها كثيراً، فترمي ENet كل حزمة تأخرت عن التي بعدها، وفي كودنا أيضاً لا يقبل السيرفر مدخلاً رقمه أقل من آخر رقم رآه. - الاثنان معاً: 274 مدخلاً من 1,190، أي 23%. واللاعب الذي ضغط عشرين ثانية تحرك على السيرفر قرابة خمس عشرة ثانية فقط.
والحل الذي ذكرناه في الكود منذ البداية رخيص جداً: كل حزمة تحمل آخر عدة مدخلات لا آخر مدخل فقط، والسيرفر يتجاهل ما طبقه من قبل. فإذا ضاعت حزمة أو رميت، فمدخلها موجود في الحزمة التالية. وهذه نتيجة اللاعب نفسه على الشبكة السيئة نفسها، مرة بمدخل واحد في كل حزمة ومرة بأربعة:
redundancy 1: c1 RESULT own: ... corrections 138 avg 4.61 px max 10.00 px | backward frames 39 | ... | behind the hand avg 20.6 px max 50.0 px
peer 2050355547 left: inputs applied 916, missed 274, starved ticks 187
redundancy 4: c1 RESULT own: ... corrections 0 avg 0.00 px max 0.00 px | backward frames 0 | ... | behind the hand avg 0.0 px max 0.0 px
peer 503175972 left: inputs applied 1183, missed 0, starved ticks 6من 274 مدخلاً ضائعاً إلى صفر، ومن 138 تصحيحاً إلى صفر، ومن 39 إطاراً رجع فيها اللاعب للخلف إلى صفر. والثمن في الـ Bandwidth من الكلاينت إلى السيرفر: سجل المرحل في تشغيلين على الشبكة نفسها بكلاينتين 59,457 بايت في الاتجاه الصاعد مع مدخل واحد في كل حزمة، و169,811 بايت مع أربعة، أي قرابة ثلاثة أضعاف، لأن ترميز Godot العام للمصفوفات يضيف بايتات لكل عنصر. وهذا ثمن مقبول في الاتجاه الصاعد عادة، فالمدخلات صغيرة، والذي يكبر بسرعة هو اللقطات النازلة كما سنرى. والشكل التالي يجمع الأرقام:

كم تأخيراً تحتاج للاستيفاء؟
في التشغيل نفسه كان أربعة مشاهدين يرسمون اللاعب، ثلاثة بالاستيفاء بتأخير 50 و100 و150 مللي ثانية، وواحد بآخر لقطة:
c2 RESULT remote (interp): ..., screen speed avg 138 px/s sd 143, frames without movement 25.3%, underrun frames 1198 # delay 50 ms
c3 RESULT remote (interp): ..., screen speed avg 150 px/s sd 90, frames without movement 3.6%, underrun frames 141 # delay 100 ms
c4 RESULT remote (interp): ..., screen speed avg 149 px/s sd 52, frames without movement 0.9%, underrun frames 45 # delay 150 ms
c5 RESULT remote (snap): ..., screen speed avg 148 px/s sd 255, frames without movement 69.0%, underrun frames 0تأخير 50 مللي ثانية يساوي فاصل لقطة واحدة، فأي لقطة تتأخر أو تضيع تجعله ينفد، فنفد في 1,198 إطاراً، وبقي اللاعب ثابتاً في ربع الإطارات. ومع 100 مللي ثانية نزلت إلى 141، ومع 150 إلى 45 فقط. ولاحظ أن متوسط السرعة قرابة 150 لا 200 في كل المشاهدين، لأن اللاعب المتحرك في هذا التشغيل كان يرسل مدخلاً واحداً في كل حزمة فضاع ربع حركته على السيرفر، فالمشاهدون رسموا بدقة ما حدث فعلاً. والقاعدة التي تخرج بها: اجعل تأخير الاستيفاء لقطتين على الأقل، وثلاثاً إذا كان لاعبوك على شبكات فيها فقدان، وقس الفجوات بين اللقطات عند لاعبيك الحقيقيين، لأن الرقم الصحيح يأتي من النسبة المئوية 99 للفجوات لا من متوسطها. وفي التشغيل أعلاه كانت الفجوة الوسيطة بين لقطتين 50 مللي ثانية، والنسبة المئوية 99 بين 117 و133، والأكبر 200.
معدل التحديث Tick Rate وثمنه في الـ Bandwidth
حتى الآن كان السيرفر يحاكي 60 خطوة في الثانية ويرسل 20 لقطة، وقد يتساءل البعض: لماذا لا يرسل لقطة في كل خطوة، فتصل الحركة أنعم وأسرع؟ والإجابة في الـ Bandwidth. فاللقطة تذهب إلى كل لاعب، وفيها سطر لكل لاعب، فحجم ما يرسله السيرفر في الثانية يساوي تقريباً معدل اللقطات في عدد اللاعبين في عدد اللاعبين في حجم السطر. ولنقيس ذلك شغلنا أربعة لاعبين يتحركون معاً قرابة أربعين ثانية، بأربعة معدلات للقطات، وبطريقتين لترميز اللقطة: الأولى مصفوفة Array عادية يرمزها Godot بنفسه، والثانية PackedByteArray نكتب فيه كل سطر بأنفسنا في 17 بايت: رقم اللاعب 4 بايت، وx وy كل منهما رقم عشري 4 بايت، ورقم آخر مدخل 4 بايت، وبايت للحركة:
for id in players:
var p: Dictionary = players[id]
buf.encode_u32(o, id); buf.encode_float(o + 4, p.pos.x); buf.encode_float(o + 8, p.pos.y)
buf.encode_u32(o + 12, p.done_seq); buf.encode_u8(o + 16, 1 if p.dir != Vector2.ZERO else 0)
o += 17
snapshot_packed.rpc(buf)والأرقام من سطر السيرفر الذي يطبعه كل ثانية من إحصاءات ENet نفسها، بالدالة pop_statistic التي يشرحها توثيق ENetConnection، والمتوسط على الثواني التي كان فيها اللاعبون الأربعة كلهم:
| اللقطات في الثانية | Array عادية: بايت في الثانية | PackedByteArray: بايت في الثانية | الحزم في الثانية |
|---|---|---|---|
| 10 | 7,458 | 3,538 | 55 |
| 20 | 14,778 | 6,883 | 94 إلى 95 |
| 30 | 22,280 | 10,327 | 134 إلى 135 |
| 60 | 44,446 | 20,499 | 254 |

والقراءة كما يلي:
- الحجم يكبر مع المعدل بالنسبة نفسها: من 10 إلى 60 لقطة تضاعف ما يرسله السيرفر ست مرات تماماً، وعدد الحزم في الثانية كذلك، فكل لقطة تكلف الثمن نفسه مهما كان المعدل.
- الترميز اليدوي أقل من النصف: كل سطر لاعب في كل لقطة كلف قرابة 185 بايت بالمصفوفة العادية و86 بايت بالترميز اليدوي، وهذا يشمل رؤوس ENet ورأس رسالة RPC، لأن Godot يرمز كل عنصر في المصفوفة مع رأس يبين نوعه، ويضيف رأساً للمصفوفة نفسها، بينما الترميز اليدوي يعرف الطرفان شكله مسبقاً فلا يحتاج أي رأس.
- الحجم يكبر مع مربع عدد اللاعبين: شغلنا ثمانية لاعبين بعشرين لقطة، فأرسل السيرفر 55,145 بايت في الثانية بالمصفوفة و24,755 بالترميز اليدوي، أي بين 3.6 و3.7 مرة ما أرسله لأربعة، لا مرتين، لأن ضعف اللاعبين يعني ضعف اللقطات وضعف الأسطر في كل لقطة.
- الاتجاه الصاعد ثابت: استقبل السيرفر قرابة 13,000 بايت في الثانية من الأربعة في كل المعدلات، لأن كل كلاينت يرسل 60 مدخلاً في الثانية مهما كان معدل اللقطات.
ولنحول الأرقام إلى قرار: عند 20 لقطة بالترميز اليدوي يرسل السيرفر لكل لاعب قرابة 1.7 كيلوبايت في الثانية في مباراة رباعية، أي قرابة 6 ميجابايت في الساعة، وهذا رقم صغير لأي سيرفر. ولكن لعبة فيها 64 لاعباً في المباراة نفسها، بلقطة كاملة لكل لاعب، تضاعف الرقم لكل لاعب 16 مرة، وتضاعف مجموعه 256 مرة. ولذلك تفعل الألعاب الكبيرة ثلاثة أشياء معاً: ترسل لكل لاعب ما يقترب منه أو يراه فقط، وترسل الفرق عن آخر لقطة أكدها الكلاينت Delta Compression بدل الحالة كاملة، وتضغط الأرقام بالدقة التي تحتاجها، فالموقع لا يحتاج 32 بتاً إذا كانت الخريطة 4,000 بكسل. وأما معدل اللقطات نفسه فاختر أقل رقم يعطيك حركة مقبولة بعد الاستيفاء، فقد رأينا أن 20 لقطة مع تأخير 100 مللي ثانية أعطت حركة منتظمة، وأن مضاعفته تضاعف الثمن.
أخطاء الصلاحيات في دوال RPC
السيرفر صاحب القرار لا يحميك إذا ترك باباً مفتوحاً. والباب الأشهر في Godot دالة عرفت بـ @rpc("any_peer") لأن الكلاينت يحتاج أن يستدعيها، ثم لم يفحص أحد فيها من استدعاها وعلى من. وفي المختبر تركنا عمداً دالة من هذا النوع، كأنها أداة مساعدة كتبها مطور ليختبر بها المراحل ثم نسيها في اللعبة المنشورة:
@rpc("any_peer", "reliable")
func set_player_pos(id: int, x: float, y: float) -> void:
## MISTAKE on purpose: an "editor helper" left in the game. any_peer + no sender check = anyone moves anyone.
var sender := multiplayer.get_remote_sender_id()
if opt("check", "on") == "on" and sender != 1:
print("%6.2f s REJECTED set_player_pos(%d) from peer %d" % [now_s(), id, sender])
return
if players.has(id):
print("%6.2f s peer %d moved player %d to (%d, %d)" % [now_s(), sender, id, x, y])
players[id].pos = Vector2(x, y)والكلاينت المعدل يفعل شيئين بعد ثلاث ثوان من دخوله: يستدعي هذه الدالة على كل لاعب آخر ليرميه إلى الموقع (-500, -500)، ثم يحاول أن يستدعي على السيرفر دالة اللقطات snapshot نفسها، وهي معرفة بالنمط الافتراضي "authority". ولا يحتاج ذلك أي أداة خاصة، فهو يملك السكربت نفسه، وتكفي أسطر قليلة:
for id in remote:
print("%6.2f s cheat: set_player_pos(%d, -500, -500)" % [now_s(), id])
set_player_pos.rpc_id(1, id, -500.0, -500.0)
print("%6.2f s cheat: calling snapshot() on the server" % now_s())
snapshot.rpc_id(1, 0, [])وهذا سجل السيرفر دون الفحص، ثم معه:
# --check off
13.45 s peer 153103920 moved player 464250102 to (-500, -500)
ERROR: RPC 'snapshot' is not allowed on node /root/Main from: 153103920. Mode is "authority", authority is 1.
# --check on
13.72 s REJECTED set_player_pos(1649257430) from peer 532064993
ERROR: RPC 'snapshot' is not allowed on node /root/Main from: 532064993. Mode is "authority", authority is 1.والقراءة كما يلي:
- دون الفحص: الكلاينت المعدل نقل اللاعب الآخر إلى (-500, -500)، والسيرفر صدق لأن الدالة تسمح لأي كلاينت. واللاعب الضحية رأى ذلك من جهته: سجل تصحيحاً واحداً بطول 862 بكسل، فالمطابقة نقلته حيث قال السيرفر، لأن السيرفر هو الحقيقة حتى لو كانت الحقيقة خطأ.
- مع الفحص: السيرفر قرأ
get_remote_sender_id()، فوجد أن المرسل ليس السيرفر نفسه، فرفض. ورقم المرسل لا يستطيع الكلاينت أن يزوره، لأنه يأتي من اتصال ENet لا من معاملات الدالة. - استدعاء
snapshot: رفضه Godot نفسه في المرتين قبل أن يصل إلى كودنا، والرسالة تقول السبب بدقة: النمطauthority، وصاحب القرار هو 1. وهذا سبب أن تبقي النمط الافتراضي لكل دالة لا يحتاج الكلاينت أن يستدعيها، ولا تغيره إلىany_peerلأن شيئاً لم يعمل في تجربة سريعة.
وقد يتساءل البعض: ولكن من سيعرف أن هذه الدالة موجودة؟ والإجابة أن كل كود GDScript في لعبتك المصدرة يمكن استخراجه وقراءته من ملف الحزمة، وأسماء دوال RPC تظهر فيه كما هي، فاعتبر أن كل دالة any_peer معروفة لكل لاعب، واكتب أول سطر فيها على هذا الأساس: من أرسلها؟ وهل يحق له؟ وهل القيم معقولة؟ والفحص الكامل لهذه القيم موضوع مقال مكافحة الغش في هذه المرحلة.
WebSocket عبر Toxiproxy: ماذا يفعل TCP باللقطات؟
بقي سؤال نسخة الويب: ماذا يحدث للعبة نفسها عندما يكون النقل WebSocket فوق TCP؟ شغلنا السيرفر بالخيار --transport ws، فأصبح يستمع بـ WebSocketMultiplayerPeer على المنفذ 8081، ووضعنا Toxiproxy بينه وبين الكلاينتات بتأخير 50 مللي ثانية وارتعاش 20 في كل اتجاه، وهذا رد واجهته عند إنشاء الـ Proxy والسموم:
{'name': 'game', 'listen': '[::]:8081', 'upstream': 'gm3-srv:8081', 'enabled': True, 'Logger': {}, 'toxics': []}
{'attributes': {'latency': 50, 'jitter': 20}, 'name': 'lag_upstream', 'type': 'latency', 'stream': 'upstream', 'toxicity': 1}
{'attributes': {'latency': 50, 'jitter': 20}, 'name': 'lag_downstream', 'type': 'latency', 'stream': 'downstream', 'toxicity': 1}ثم شغلنا اللاعب والمشاهد عشرين ثانية، وكررنا التشغيل نفسه عبر ENet والمرحل بالأرقام نفسها، 50 مللي ثانية وارتعاش 20 ودون فقدان. والكود في الحالتين واحد، والفرق سطر النقل فقط:
# WebSocket (TCP) through Toxiproxy
c2 RESULT snapshots 433 gap p50 50.0 ms p99 98.2 ms max 548.6 ms enet rtt -1 ms loss -1.0%
c2 RESULT remote (interp): moving frames 789, screen speed avg 190 px/s sd 116, frames without movement 11.9%, underrun frames 173
33.08 s peer 2067101294 left: inputs applied 1192, missed 0, starved ticks 24, queue avg 3.2 inputs
# ENet (UDP) through the relay
c2 RESULT snapshots 437 gap p50 50.0 ms p99 85.3 ms max 104.3 ms enet rtt 116 ms loss 0.0%
c2 RESULT remote (interp): moving frames 787, screen speed avg 162 px/s sd 59, frames without movement 0.3%, underrun frames 0
26.63 s peer 851788023 left: inputs applied 972, missed 220, starved ticks 146, queue avg 1.3 inputsوالقراءة كما يلي:
- مع WebSocket لم يضع مدخل واحد: 1,192 مدخلاً طبقت كلها، لأن TCP يعيد ويرتب كل شيء، ولذلك جاء متوسط سرعة اللاعب عند المشاهد قريباً من 200.
- ولكن أكبر فجوة بين لقطتين 548 مللي ثانية: مقابل 104 مع ENet. فالـ Proxy يؤخر أجزاء التدفق، وTCP لا يسلم جزءاً قبل الذي قبله، فإذا تأخر جزء انتظرت خلفه كل اللقطات التي بعده ثم وصلت دفعة واحدة. والنتيجة 173 إطاراً نفدت فيها اللقطات، و11.9% من الإطارات دون حركة، رغم أن المتوسط والوسيط 50 مللي ثانية كما في ENet.
- ومع ENet لم تنفد اللقطات أبداً: ولكن ضاع 220 مدخلاً بسبب إعادة الترتيب، لأن هذا التشغيل أرسل مدخلاً واحداً في كل حزمة، وعرفنا علاجه في القسم السابق.
وهذه المقارنة لا تقول إن WebSocket لا يصلح للألعاب، فكثير من ألعاب المتصفح تعمل به، وإنما تقول إن مشاكله مختلفة: لا شيء يضيع، ولكن كل تأخير في حزمة يصبح تجمداً في كل ما بعدها. فإذا كانت لعبتك على الويب، فاجعل تأخير الاستيفاء أكبر من نسختها على سطح المكتب، وتوقع لحظات تجمد على الشبكات السيئة، وانظر إلى WebRTC بقنوات البيانات غير الموثوقة إذا كانت لعبتك سريعة.
التعويض عن التأخير Lag Compensation: من أصاب من؟
الاستيفاء يحل مشكلة الحركة، ولكنه يخلق مشكلة جديدة في ألعاب التصويب: أنت ترى اللاعب الآخر في الماضي، بمقدار تأخير الاستيفاء ونصف زمن الذهاب والعودة تقريباً. فإذا صوبت على رأسه كما تراه وأطلقت، فالسيرفر عنده الرأس في مكان آخر قد تحرك، فيقول لك إنك أخطأت، مع أنك أصبت ما رأيته بالضبط. والحل الذي وصفته Valve في ورقتها عن طرق التعويض عن التأخير، وفي شرح الشبكات في محرك Source، أن يحفظ السيرفر مواقع اللاعبين لكل خطوة في آخر ثانية تقريباً، وعندما يصله أمر إطلاق يرجع العالم إلى اللحظة التي كان يراها فيها اللاعب، أي زمن الأمر مطروحاً منه تأخيره وتأخير الاستيفاء عنده، ويفحص الإصابة هناك، ثم يعيد العالم إلى حاضره.
وهذا يعني أن السيرفر يصدق ما رآه اللاعب، ضمن حد يضعه هو، ولذلك يقبل أغلب ألعاب التصويب الرجوع إلى الوراء حتى مقدار محدود فقط، لأن اللاعب الذي يدعي أن تأخيره ثانية كاملة يحصل على قدرة أن يطلق على الماضي. وله ثمن يعرفه كل من لعب ألعاب التصويب: الضحية تموت أحياناً بعد أن اختبأت خلف الجدار على شاشتها، لأن القاتل رآها قبل الجدار على شاشته. ولا يوجد حل يرضي الاثنين، وإنما اختيار: إما أن يخطئ من يطلق بدقة على ما يراه، وإما أن يموت من اختبأ متأخراً قليلاً، وأغلب الألعاب تختار الثاني لأن الإطلاق هو الفعل الذي يشعر به اللاعب أكثر. ولم نبن هذا في المختبر لأن لعبتنا ليس فيها إطلاق، ولكن كل ما يحتاجه موجود فيه: رقم الخطوة في كل لقطة، وتأخير الاستيفاء المعروف عند كل كلاينت.
أخطاء شائعة وكيف تعرفها من أعراضها
- الشخصية تتأخر عن يدك على الإنترنت فقط: الشاشة ترسم موقع السيرفر. أضف التنبؤ على الكلاينت للاعب نفسه، ولا تنتظر السيرفر لتحريك شخصيتك.
- الشخصية ترجع للخلف كل لحظة ثم تتقدم Rubber Banding: الكلاينت يأخذ موقع السيرفر ويرمي مدخلاته التي لم يؤكدها بعد. احفظ المدخلات برقم تسلسل، وأعد تطبيق ما لم يؤكده السيرفر بعد كل لقطة.
- اللاعبون الآخرون يتحركون بقفزات: ترسمهم عند آخر لقطة. ارسمهم في الماضي بتأخير ثابت، واستوف بين لقطتين.
- اللاعبون الآخرون يتوقفون لحظة ثم يسرعون: تأخير الاستيفاء أقصر من الفجوات بين اللقطات على شبكة فيها ارتعاش. زد التأخير إلى لقطتين أو ثلاث، أو اجعله يتكيف مع الارتعاش الذي تقيسه.
- الحركة غير منتظمة حتى على الشبكة المحلية: السيرفر يطبق المدخلات لحظة وصولها. اجعلها في طابور، وطبق مدخلاً واحداً في كل خطوة.
- الكلاينت والسيرفر يختلفان أكثر مما تتوقع رغم أن الفقدان قليل: المدخلات ترسل بالنمط
unreliable_orderedعلى شبكة تعيد الترتيب، فيرمي المستقبل كل حزمة وصلت بعد أحدث منها. أرسل آخر عدة مدخلات في كل حزمة. - دالة RPC يستطيع أي كلاينت أن يستدعيها على أي لاعب:
@rpc("any_peer")دون فحصget_remote_sender_id(). افحص المرسل وصلاحيته في أول سطر، أو احذف الدالة من نسخة اللعبة المنشورة. - رسالة «not allowed» في سجل السيرفر: كلاينت حاول استدعاء دالة
authority، وهذا إما خطأ في الكود أو محاولة غش، والإعداد الافتراضي حماك منها. - الـ Bandwidth يكبر بسرعة مع اللاعبين: اللقطة الكاملة لكل لاعب لكل لاعب تكبر مع مربع عددهم. قلل معدل اللقطات، ورمز البيانات بنفسك، وأرسل لكل لاعب ما يقترب منه فقط.
جدول قرار: ماذا تبني للعبتك؟
| نوع اللعبة | النموذج | ما تحتاجه على الكلاينت | النقل |
|---|---|---|---|
| لعبة دورية Turn-based أو بطاقات | سيرفر صاحب القرار، والشاشة تنتظره | لا شيء، التأخير لا يهم | رسائل موثوقة، وWebSocket يكفي حتى على سطح المكتب |
| استراتيجية بآلاف الوحدات RTS | Lockstep بمحاكاة حتمية | تأخير ثابت للمدخلات يخفيه صوت أو حركة | مدخلات موثوقة، قليلة جداً |
| لعبة تعاونية مع الأصدقاء | لاعب مستضيف Listen Server | تنبؤ للاعب نفسه، واستيفاء للآخرين | ENet، أو WebRTC للمتصفح |
| تصويب أو معارك تنافسية | سيرفر مخصص صاحب القرار | تنبؤ ومطابقة، واستيفاء، وتعويض عن التأخير على السيرفر | ENet أو بروتوكول خاص فوق UDP |
| لعبة متصفح سريعة | سيرفر مخصص صاحب القرار | كل ما سبق، مع تأخير استيفاء أكبر | WebSocket مع توقع التجمد، أو WebRTC غير موثوق |
قائمة فحص قبل أن تطلق لعبتك الجماعية
- السيرفر يحسب كل ما يهم: المواقع، والإصابات، والنقاط، والمخزون، والكلاينت يرسل نيته فقط.
- كل دالة
any_peerتفحصget_remote_sender_id()وحدود القيم في أول سطر، وكل دالة أخرى تبقى علىauthority. - كل مدخل له رقم تسلسل، وكل لقطة تحمل رقم آخر مدخل طبقه السيرفر لكل لاعب.
- الكلاينت يتنبأ لشخصيته ويطابق مع كل لقطة بإعادة تطبيق ما لم يؤكده السيرفر.
- اللاعبون الآخرون يرسمون بالاستيفاء بتأخير لقطتين أو ثلاث، وتعرف ماذا يحدث عند نفاد اللقطات.
- كل حزمة مدخلات تحمل آخر عدة مدخلات، والسيرفر يتجاهل المكرر.
- السيرفر يطبق المدخلات من طابور بمعدل ثابت، وتعرف كم تأخيراً يضيف الطابور.
- جربت اللعبة بتأخير 100 مللي ثانية وارتعاش وفقدان قبل أن يجربها اللاعبون، لا على شبكة البيت فقط.
- تعرف كم بايتاً يرسل السيرفر في الثانية لكل لاعب، وكيف يكبر الرقم مع عدد اللاعبين.
- المنفذ مفتوح بالبروتوكول الصحيح، UDP للعبة ENet، في الجدار الناري وفي Docker.
تطبيق عملي
- شغل اللاعب المتحرك بالخيار
--mode naiveثم--mode reconcileبتأخير 100 مللي ثانية في كل اتجاه بدل 50، وقارنinput->screenوbehind the handبالأرقام التي في المقال. - غير شرط اللحاق في طابور السيرفر من 4 إلى 1، وشغل تشغيل الارتعاش مرة أخرى، وانظر ماذا يحدث لمتوسط الطابور ولعدد مرات
starved. - أضف إلى السيرفر جداراً عند x = 300 لا يعرفه الكلاينت، وانظر كم تصحيحاً تسجله المطابقة عندما يصطدم اللاعب به، وكم يرجع للخلف.
- اجعل المشاهد يستقرئ بالسرعة الأخيرة بدل أن يثبت عند نفاد اللقطات، وقارن انحراف السرعة مع تأخير 50 مللي ثانية.
- غير نمط
client_inputإلى"unreliable"، واجعل السيرفر يقبل المدخل المتأخر إذا لم يطبقه بعد، وقس كم مدخلاً ضاع مع الارتعاش دون تكرار.
ملفات المختبر وتشغيله
المختبر في مجلد lab: الـ Dockerfile لصورة Godot 4.7.2، والمشروع في game بسكربت واحد main.gd، والمرحل udp-relay.py، والسكربت toxi.py الذي يضبط Toxiproxy من واجهته على المنفذ 8474، والملفان lib.sh وexp.sh اللذان يعرفان دوال التشغيل، وrun-all.sh وrun-extra.sh وrun-extra2.sh وrun-bw.sh التي تشغل كل التجارب في المقال وتكتب نتائجها في out/results.txt وout/bw-*.log، والسكربت charts.py الذي يرسم الأشكال من تلك النتائج. وتبدأ هكذا:
docker build -t gm3-godot:4.7.2 .
docker tag python:3.13-alpine gm3-python:3.13-alpine
docker pull ghcr.io/shopify/toxiproxy:2.13.0 && docker tag ghcr.io/shopify/toxiproxy:2.13.0 gm3-toxiproxy:2.13.0
docker network create gm3-net
docker run --rm --init -v "$PWD/game:/game" gm3-godot:4.7.2 godot --headless --import --path /game # import once, before many containers start
bash run-all.shوالسطر الأخير قبل التشغيل مهم: Godot يستورد المشروع عند أول تشغيل وينشئ المجلد .godot، فإذا بدأت خمسة Containers في الوقت نفسه على المجلد نفسه قبل أن يستورد، فقد يكتب كل منهم فوق الآخر. وتأخذ التجارب كلها قرابة نصف ساعة، لأن كل تجربة تشغل السيرفر والمرحل وكلاينتين أو أكثر لمدة عشرين ثانية.
حذف المختبر Cleanup
docker rm -f gm3-srv gm3-relay gm3-toxi gm3-c1 gm3-c2 gm3-c3 gm3-c4 gm3-c5 gm3-cheat
docker network rm gm3-net
docker image rm gm3-godot:4.7.2 gm3-python:3.13-alpine gm3-toxiproxy:2.13.0 ghcr.io/shopify/toxiproxy:2.13.0
rm -rf game/.godot outالخلاصة Summary
- اللعب الجماعي مشكلة توقيت: كل ما يقرره السيرفر يصل اللاعب بعد زمن الذهاب والعودة، ولا يوجد إصلاح لهذا الزمن في الكود، وإنما إخفاء لأثره.
- السيرفر المخصص صاحب القرار يحل مشكلة الثقة: الكلاينت يرسل نيته، والسيرفر يحسب، ويرسل لقطات.
- انتظار السيرفر جعل الحركة تبدأ بعد 168 مللي ثانية من الضغطة عند زمن ذهاب وعودة 117، والتنبؤ على الكلاينت جعلها تبدأ في نصف مللي ثانية.
- التنبؤ مع أخذ موقع السيرفر كما هو أعطى 21 إطاراً رجع فيها اللاعب للخلف، والمطابقة بإعادة تطبيق ما لم يؤكده السيرفر جعلتها صفراً، والتنبؤ دون مطابقة ترك الكلاينت يبتعد عن الحقيقة 20 بكسل في عشرين ثانية.
- رسم اللاعب الآخر عند آخر لقطة ترك 67% من الإطارات دون حركة، والاستيفاء بتأخير 100 مللي ثانية جعلها صفراً، والثمن أنك ترى الماضي.
- الارتعاش وحده، دون فقدان، ضيع 20.7% من المدخلات المرسلة بالنمط
unreliable_ordered، وإرسال آخر أربعة مدخلات في كل حزمة جعل الضائع صفراً بثمن قرابة ثلاثة أضعاف في الاتجاه الصاعد. - طابور المدخلات على السيرفر جعل حركة كل لقطة 10 بكسل بالضبط بدل 3 إلى 17، وثمنه تأخير إضافي بقدر ما ينتظر في الطابور.
- ما يرسله السيرفر يتضاعف مع معدل اللقطات ومع مربع عدد اللاعبين: 14,778 بايت في الثانية لأربعة لاعبين بعشرين لقطة و55,145 لثمانية، والترميز اليدوي بـ PackedByteArray قسمها على اثنين.
- دالة
any_peerدون فحص المرسل سمحت لكلاينت معدل أن ينقل لاعباً آخر 862 بكسل، والنمط الافتراضيauthorityرفض الاستدعاء الآخر قبل أن يصل إلى الكود. - WebSocket عبر Toxiproxy لم يضيع مدخلاً واحداً، ولكن أكبر فجوة بين لقطتين وصلت 548 مللي ثانية مقابل 104 مع ENet، وToxiproxy لا يمرر UDP أصلاً.
وفي المقالات التالية من هذه المرحلة نأخذ هذا السيرفر نفسه إلى سيرفر حقيقي في Container ونقيس ما يستهلكه لكل لاعب، ثم نضيف الحسابات والمتصدرين، ثم نعود إلى الكلاينت المعدل لنرى ما الذي يستطيع السيرفر أن يوقفه من الغش:
دليلخوادم الألعاب المخصصة Dedicated Servers على سيرفركنصدر سيرفر لعبة Godot بقالب التصدير ونغلفه في Docker، ونقيسه مع 64 لاعباً آلياً، ونجعله يحفظ ويفرغ مبارياته عند الإيقاف ونحدثه دون طرد أحد، ثم نقارنه بسيرفر Luanti ونعرف متى تحتاج Agones.
دليلخلفية الألعاب Game Backend: الحسابات والمتصدرون مع Nakamaنشغل Nakama مع PostgreSQL في Docker ونبني له حسابات وحفظاً ومتصدرين أسبوعيين وجولة يحسب فيها السيرفر الدرجة بنفسه، ثم نقيس كم يستهلك مع 400 لاعب من Godot وماذا يحدث إذا توقفت قاعدة البيانات.
دليلمكافحة الغش Anti-Cheat في الألعاب: ما يمكن وما لا يمكننكتب كلاينتات تغش في لعبتنا الجماعية بأبسط الطرق، ونوقف كل غش منها بفحص على السيرفر ونقيس أثره على اللاعب الأمين، ثم نشرح ما لا يراه السيرفر وثمن مكافحة الغش في النواة.
دليلكيف تعمل اللعبة من الداخل؟ حلقة اللعبة Game Loopلماذا تتحرك الشخصية بالسرعة نفسها على شاشة 144 هرتز وحاسوب بطيء: نبني حلقة اللعبة من الصفر حتى الخطوة الثابتة والاستيفاء، ونقيس كل طريقة في مختبر.
دليلTCP وUDP وDHCP ببساطة: كيف تنتقل البيانات وتأخذ عنوانككيف يضمن TCP وصول الملف رغم ضياع الحزم، ولماذا تختار المكالمات UDP، وكيف يأخذ جهازك عنوانه من DHCP، مع التقاط حقيقي لكل منها.
دليلزمن الاستجابة Latency والإنتاجية Throughput بالأرقامالأرقام التي يحتاجها كل تصميم من الذاكرة إلى القارات، مقاسة على جهاز واحد، مع الذيل Tail Latency وقانون Little واختبار k6 يبين أين تنهار الخدمة.سجل التحديثات Changelog
- 18 نوفمبر 2026: كتابة المقال، وبناء سيرفر مخصص وكلاينتات آلية في Godot 4.7.2 دون شاشة في Docker، وقياس التنبؤ والمطابقة والاستيفاء والفقدان والارتعاش ومعدل اللقطات عبر مرحل UDP، ومقارنة WebSocket عبر Toxiproxy 2.13.0.