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

# خوادم الألعاب المخصصة Dedicated Servers على سيرفرك
- URL: https://arabroot.io/articles/خوادم-الالعاب-المخصصة-dedicated-servers-على-سيرفرك/
- Published: 2026-11-18T14:06:32.000Z
- Updated: 2026-11-18T15:06:20.000Z
- Description: نصدر سيرفر لعبة Godot بقالب التصدير ونغلفه في Docker، ونقيسه مع 64 لاعباً آلياً، ونجعله يحفظ ويفرغ مبارياته عند الإيقاف ونحدثه دون طرد أحد، ثم نقارنه بسيرفر Luanti ونعرف متى تحتاج Agones.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, تطوير الألعاب

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

وفي مقال اللعب الجماعي في هذه المرحلة بنينا سيرفراً صاحب قرار Authoritative Server في Godot مع لاعبين آليين Bots يتصلون به، وشغلناه في Docker للتجارب. وفي هذا المقال سوف نأخذ السيرفر نفسه ونجعله شيئاً يمكن تشغيله على سيرفرك فعلاً: نسخة تصدير خاصة بالسيرفر، وDocker Image صغيرة تعمل بمستخدم عادي، ومنفذ UDP منشور بشكل صحيح، وقياس لما يستهلكه من المعالج والذاكرة مع عدد متزايد من اللاعبين، وإيقاف لا يضيع فيه شيء، وحفظ لحالة العالم ونسخة احتياطية نستعيدها، وتحديث دون أن نطرد اللاعبين في منتصف المباراة. وسوف نقارن ذلك بسيرفر جاهز للعبة مفتوحة المصدر هي Luanti، ثم نعرف متى تحتاج منصة مثل Agones فوق Kubernetes ومتى لا تحتاجها.

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

- الفرق بين السيرفر المخصص وسيرفر اللاعب Listen Server والاتصال المباشر بين اللاعبين، وماذا يفعل السيرفر في كل ثانية.
- بناء نسخة السيرفر من Godot: المحرر أم قالب التصدير Export Template، ونمط التصدير Dedicated Server، والميزة `dedicated_server`.
- تغليف السيرفر في Docker Image، ومشكلتان حقيقيتان: سجلات Logs لا تظهر، ومنفذ نسينا أن نقول إنه UDP.
- قياس المعالج CPU والذاكرة RAM وحركة الشبكة Bandwidth مع 0 إلى 64 لاعباً آلياً.
- الإيقاف الآمن Graceful Shutdown: ماذا يفعل Godot عندما يرسل له Docker الإشارة SIGTERM، وكيف نحفظ ونفرغ السيرفر من اللاعبين Draining، وعطل ظهر لنا عندما وصل لاعب أثناء ذلك.
- حفظ حالة العالم World State والنسخ الاحتياطي Backup والاستعادة Restore، والتحديثات Updates واختلاف النسخ بين الكلاينت والسيرفر.
- سيرفر Luanti للمقارنة، والاستضافة، وAgones، وأخطاء شائعة، وقائمة فحص.

## ما هو السيرفر المخصص Dedicated Server؟

في أي لعبة جماعية يوجد سؤال واحد يحدد شكل كل شيء بعده: أين تعيش نسخة العالم التي يتفق عليها الجميع؟ وهناك ثلاث إجابات شائعة، والشكل التالي يبينها:

![ثلاث لوحات. الأولى سيرفر اللاعب Listen Server: جهاز لاعب يرسم اللعبة ويشغل السيرفر في الوقت نفسه، ولاعبان آخران يتصلان به عبر راوتر منزلي، وملاحظة أن اللعبة تتوقف إذا خرج المضيف وأنه يملك أفضلية في التأخير. الثانية الاتصال المباشر Peer to Peer: أربعة لاعبين كل منهم يرسل للآخرين، وملاحظة أن كل جهاز يرى الآخرين وأن الغش أسهل. الثالثة السيرفر المخصص Dedicated Server: سيرفر في مركز بيانات بلا شاشة يشغل العالم وحده، وأربعة لاعبين يتصلون به عبر منفذ UDP 7777، وملاحظة أنه يعمل دائماً وأن قراره هو الحقيقة لكنه يكلف مالاً](https://arabroot.io/content/images/2026/11/game-servers-01-hosting.webp)

ثلاثة أماكن لنسخة العالم: جهاز لاعب، أو كل الأجهزة، أو سيرفر مخصص لا يلعب عليه أحد

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

وقد يتساءل البعض: هل يعني «مخصص» أنك تحتاج سيرفراً فعلياً Bare Metal لكل لعبة؟ والإجابة لا، فالكلمة تعني أن البرنامج مخصص لدور السيرفر ولا يلعب عليه أحد، وأما الجهاز فقد يكون سيرفراً افتراضياً VPS صغيراً، يشغل عشرات المباريات في وقت واحد، كل منها عملية Process مستقلة، كما سنقيس.

## ماذا يفعل سيرفر اللعبة في كل ثانية؟

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

1. **يستهلك المعالج حتى لو لم يلعب أحد:** الحلقة تدور دائماً، ولذلك سوف ترى في القياس أن السيرفر الفارغ يأخذ نسبة صغيرة ثابتة من المعالج.
2. **الوقت عنده أهم من المتوسط:** إذا تأخرت خطوة واحدة عن موعدها لأن المعالج مشغول بشيء آخر، يشعر بها كل اللاعبين في تلك اللحظة، ولذلك لا يحب سيرفر اللعبة أن يشاركه الجهاز برنامج يأخذ المعالج فجأة.
3. **حالته في الذاكرة:** مواضع اللاعبين ونتيجة المباراة لا توجد في قاعدة بيانات، وإنما في ذاكرة العملية، فإذا توقفت العملية فجأة ضاع كل ما لم يحفظ، وهذا سبب قسمي الإيقاف الآمن والحفظ في هذا المقال.
4. **يتحدث UDP:** أغلب الألعاب السريعة ترسل عبر UDP لأن الحزمة المتأخرة لا قيمة لها، كما شرحنا في [مقال TCP وUDP](https://arabroot.io/articles/tcp-%D9%88-udp-%D9%88-dhcp-%D8%A8%D8%A8%D8%B3%D8%A7%D8%B7%D8%A9/)، وGodot يستخدم مكتبة ENet فوق UDP. وكل أداة في طريق الحزمة، من Docker إلى الجدار الناري Firewall، يجب أن تعرف ذلك.

## بناء نسخة السيرفر من Godot

في المختبر السابق كنا نشغل السيرفر بأسهل طريقة: برنامج محرر Godot نفسه مع مجلد المشروع والخيار `--headless`، وهذا مناسب للتطوير. ولكن على سيرفر حقيقي تريد ملفاً واحداً مغلقاً لا يحتاج المحرر ولا ملفات المشروع المفتوحة، ويشرح [توثيق التصدير للسيرفرات المخصصة](https://docs.godotengine.org/en/stable/tutorials/export/exporting%5Ffor%5Fdedicated%5Fservers.html?ref=arabroot.io) أن Godot 4 لم يعد يحتاج برنامج سيرفر خاصاً كما كان في Godot 3، وأن أي برنامج Godot يعمل كسيرفر إذا شغلته بالخيار `--headless` أو إذا كان المشروع مصدراً كسيرفر مخصص.

### المحرر أم قالب التصدير Export Template؟

اللعبة المصدرة تتكون من جزأين: البرنامج الذي يشغلها، وملف الحزمة `.pck` الذي فيه السكربتات والمشاهد والموارد. والبرنامج إما المحرر Editor، وإما قالب التصدير Export Template، وهو نسخة من المحرك دون أدوات التحرير. ويوصي التوثيق بقالب التصدير للسيرفرات لأنه أصغر وأسرع، ويقول إن المحرر يعمل كسيرفر ولكنه لا ينصح به. والفرق في الحجم وحده كبير، فهذا ما قسناه للإصدار 4.7.2 على Linux:

| البرنامج                                   | الحجم                           | من أين؟                                                             |
| ------------------------------------------ | ------------------------------- | ------------------------------------------------------------------- |
| المحرر Godot\_v4.7.2-stable\_linux.x86\_64 | 146,414,384 بايت (146 ميجابايت) | ملف zip مستقل في صفحة الإصدار                                       |
| قالب التصدير linux\_release.x86\_64        | 73,519,416 بايت (73.5 ميجابايت) | داخل ملف القوالب export\_templates.tpz الذي حجمه 1,281,349,702 بايت |

والمشكلة العملية أن القالب لا يوزع وحده، وإنما داخل ملف واحد بحجم 1.28 جيجابايت فيه قوالب كل المنصات: Windows وmacOS وAndroid وiOS والويب، وأنت تحتاج منه ملفاً واحداً. وملف `.tpz` هو ملف zip عادي، وملف zip يحفظ فهرس محتوياته في آخره، وسيرفر GitHub يقبل طلبات تحميل جزء من الملف Range Requests. لذلك كتبنا سكربت Python صغيراً يقرأ الفهرس من آخر الملف، ثم يحمل القطعة التي فيها القالب فقط:

```bash
python get-template.py \
  https://github.com/godotengine/godot/releases/download/4.7.2-stable/Godot_v4.7.2-stable_export_templates.tpz \
  templates/linux_release.x86_64 tpl/linux_release.x86_64
```

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

```text
archive 1281349702 bytes, 35 files: linux_debug.arm32, linux_debug.arm64, linux_debug.x86_32, linux_debug.x86_64, linux_release.arm32, linux_release.arm64, linux_release.x86_32, linux_release.x86_64
extracted templates/linux_release.x86_64 CRC ok, downloaded 33558082 bytes
```

حملنا 33.5 ميجابايت بدل 1.28 جيجابايت، لأن القالب مضغوط داخل الملف. ولاحظ أن مكتبة zipfile في Python تتحقق من رمز CRC-32 للملف المستخرج مقابل الفهرس، ولكن هذا لا يغني عن التحقق من مصدر الملف كله، فالمشروع ينشر بصمة SHA512 لملف `.tpz` كاملاً فقط. فإذا كان سيرفرك في بيئة حساسة، فحمل الملف كاملاً مرة واحدة في خط البناء Pipeline، وتحقق من بصمته مقابل الملف `SHA512-SUMS.txt` في صفحة الإصدار، ثم استخرج منه ما تحتاج. والسكربت كاملاً في مجلد المختبر.

### نمط التصدير Dedicated Server والميزة dedicated\_server

إذا صدرت المشروع للسيرفر كما تصدره للاعبين، فستأخذ معك كل الصور والأصوات والخامات التي لا يرسمها السيرفر أبداً. ولذلك يوفر Godot في إعداد التصدير Export Preset، في تبويب Resources، نمطاً اسمه Export as dedicated server، يستبدل الصور والخامات بفئات فارغة Placeholders تحفظ أبعاد الصورة فقط، ويضيف تلقائياً الميزة `dedicated_server` إلى المشروع المصدر، وهي بحسب التوثيق تجبر اللعبة على العمل دون شاشة كأنك مررت `--headless`. وهذا ملف الإعداد `export_presets.cfg` الذي استخدمناه:

```ini
[preset.0]

name="Linux Server"
platform="Linux"
runnable=false
dedicated_server=true
custom_features=""
export_filter="all_resources"
include_filter=""
exclude_filter="*.md"
export_path="../build/game.pck"

[preset.0.options]

binary_format/architecture="x86_64"
```

والسطر المهم هو `dedicated_server=true`، وهو ما يكتبه المحرر عندما تختار ذلك النمط من الواجهة. وفي مشروعنا لا توجد صور أصلاً لأن السيرفر والبوتات لا يرسمون شيئاً، ولكن في لعبة حقيقية فيها مئات الميجابايتات من الصور والأصوات يصبح هذا الفرق هو الفرق بين Image حجمها 100 ميجابايت وأخرى حجمها جيجابايت، ويوصي التوثيق بالخيار Strip Visuals لأغلب الموارد، وبالحذف Remove فقط لما تتأكد أن السيرفر لا يشير إليه أبداً.

### ملف .pck دون قوالب، ومشكلة --main-pack

تصدير اللعبة كاملة يحتاج قوالب التصدير مثبتة في المحرر، ولكن تصدير الحزمة وحدها لا يحتاجها، لأن الحزمة لا تحتوي البرنامج. والأمر التالي يصدر الحزمة من سطر الأوامر بالمحرر داخل Container، كما يشرح [توثيق سطر الأوامر](https://docs.godotengine.org/en/stable/tutorials/editor/command%5Fline%5Ftutorial.html?ref=arabroot.io):

```bash
docker run --rm --init -v "$PWD/game:/game" -v "$PWD/build:/build" gm3-godot:4.7.2 \
  godot --headless --path /game --export-pack "Linux Server" /build/game.pck
```

والمخرج يبين ما دخل الحزمة:

```text
[   1% ] savepack | Storing File: res://main.gdc
[  50% ] savepack | Storing File: res://.godot/exported/133200997/export-3070c538c03ee49b7677ff960a3f5195-main.scn
[  50% ] savepack | Storing File: res://main.gd.remap
[  50% ] savepack | Storing File: res://main.tscn.remap
[  50% ] savepack | Storing File: res://.godot/global_script_class_cache.cfg
[  50% ] savepack | Storing File: res://.godot/uid_cache.bin
[  50% ] savepack | Storing File: res://project.binary
[ DONE ] savepack
```

ولاحظ أن السكربت دخل الحزمة باسم `main.gdc`، أي بصيغة مرمزة Binary Tokens بدل النص، وأن حجم الحزمة كلها 18,904 بايت. والآن نريد أن نشغل هذه الحزمة بقالب التصدير. والطريقة التي تبدو طبيعية هي الخيار `--main-pack` الذي يحدد للبرنامج مكان الحزمة، وهذا ما حدث عندما جربناه:

```text
ERROR: `--main-pack` was specified on the command line, but this Godot binary was compiled without support for path overrides. Aborting.
To be able to use it, use the `disable_path_overrides=no` SCons option when compiling Godot.
```

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

### كيف يعرف الكود أنه سيرفر؟

عندما يكون السيرفر والكلاينت في مشروع واحد، كما في مختبرنا، يحتاج الكود أن يقرر في `_ready` أي دور يأخذ. ويذكر التوثيق ثلاث طرق، واستخدمناها كلها في سطر واحد:

```gdscript
	if OS.has_feature("dedicated_server") or (DisplayServer.get_name() == "headless" and not a.has("client")):
		a["server"] = "on"                       # an exported server .pck (or plain --headless) starts the server by itself
	if a.has("server"):
		start_server()
```

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

- **`OS.has_feature("dedicated_server")`:** صحيحة فقط في المشروع المصدر بنمط السيرفر المخصص، وهي أوضح الطرق في الإنتاج لأنها لا تعتمد على أي خيار في سطر الأوامر. والمتغير `a` في الكود هو قاموس خيارات سطر الأوامر الذي يبنيه السكربت في بدايته.
- **`DisplayServer.get_name() == "headless"`:** صحيحة عندما يعمل أي برنامج Godot بالخيار `--headless`، ولكن البوتات في مختبرنا تعمل أيضاً دون شاشة، ولذلك أضفنا شرط أنها لم تمرر `--client`.
- **الخيار `--server`:** بقي يعمل كما في المختبر السابق، وهو مفيد لتجربة السيرفر من المحرر دون تصدير.

وأضفنا إلى أول سطر يطبعه السيرفر ما يؤكد ذلك، وهذا ما طبعه عندما شغلنا القالب مع الحزمة:

```text
Godot Engine v4.7.2.stable.official.ed1daf0bf - https://godotengine.org

world: user://world.json boot 1, players so far 0, inputs so far 0, uptime so far 0 s
server 1.0.0, features: dedicated_server=true, display headless, binary export template
server: enet on port 7777, tick 60 Hz, snapshot every 3 ticks (20 Hz), format var, checks on, err=0
```

والقالب لم يأخذ أي خيار في سطر الأوامر، ومع ذلك عمل دون شاشة وبدأ السيرفر بنفسه، لأن الحزمة تحمل الميزة `dedicated_server`، و`binary export template` تعني أن الميزة `editor` غير موجودة.

## تغليف السيرفر في Docker Image

بعد أن أصبح عندنا ملفان، البرنامج `game` والحزمة `game.pck`، نضعهما في Image صغيرة. والشكل التالي يبين من أين يأتي كل جزء، وحجمه:

![مسار البناء من اليمين إلى اليسار. مجلد المشروع فيه main.gd وproject.godot وexport_presets.cfg. المحرر في Container يصدر الحزمة game.pck بحجم 18,904 بايت بالأمر export-pack دون قوالب. ومن ملف القوالب export_templates.tpz بحجم 1.28 جيجابايت يستخرج القالب linux_release.x86_64 بحجم 73.5 ميجابايت بتحميل 33.5 ميجابايت فقط. ثم Dockerfile يجمع debian bookworm-slim مع game وgame.pck وentrypoint.sh ومستخدم gameserver ومنفذ 7777/udp ومجلد /data، والنتيجة Image اسمها gm3-sv-game بوسم رقم الإصدار](https://arabroot.io/content/images/2026/11/game-servers-02-build.webp)

من المشروع إلى Image: الحزمة من المحرر، والبرنامج من قالب التصدير

وهذا ملف `Dockerfile` كاملاً:

```dockerfile
# Dedicated server image: the official Linux release export template (renamed "game") + the server .pck next to it.
FROM debian:bookworm-slim
RUN useradd --create-home --uid 1000 gameserver && mkdir /data && chown gameserver /data
COPY --chmod=755 game /srv/game
COPY game.pck /srv/game.pck
COPY --chmod=755 entrypoint.sh /srv/entrypoint.sh
USER gameserver
WORKDIR /srv
VOLUME /data
EXPOSE 7777/udp
STOPSIGNAL SIGTERM
ENTRYPOINT ["/srv/entrypoint.sh"]
```

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

- **لا توجد مكتبات رسم:** في Image المختبر التي تشغل المحرر ثبتنا Xvfb وMesa لالتقاط الصور، وأما هنا فقالب التصدير يعمل دون شاشة على `debian:bookworm-slim` كما هي، دون أي حزمة إضافية.
- **مستخدم عادي:** `gameserver` برقم 1000، لأن السيرفر يستقبل حزماً من الإنترنت كله، فإذا وجد فيه أحد ثغرة فلا يجب أن يجد نفسه root داخل الـ Container.
- **`EXPOSE 7777/udp`:** توثيق فقط، فهو لا ينشر شيئاً، ولكنه يخبر من يقرأ الـ Image أن المنفذ UDP، وكما سنرى بعد قليل، هذه المعلومة بالذات هي التي ينساها الناس.
- **`VOLUME /data`:** المكان الذي يحفظ فيه السيرفر حالة العالم، حتى تبقى عندما نحذف الـ Container ونشغل نسخة جديدة.
- **`ENTRYPOINT` سكربت لا البرنامج نفسه:** وسبب ذلك في قسم الإيقاف الآمن.

والـ Image الناتجة حجمها 217 ميجابايت كما يعرضها `docker images`، أغلبها Debian الصغير والقالب، ونبنيها بوسم يحمل رقم الإصدار، لا بالوسم `latest`، وسوف نعرف السبب في قسم التحديثات:

```bash
docker build -t gm3-sv-game:1.0.1 build
docker volume create gm3-sv-world
docker run -d --name gm3-sv-game -v gm3-sv-world:/data -p 7777:7777/udp gm3-sv-game:1.0.1
```

### السجلات Logs لا تظهر: flush\_stdout\_on\_print

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

```text
--- docker logs after 8 s:
cpu 5.25% mem 27.01MiB / 31.29GiB
```

السطر الثاني من `docker stats`، وهو يقول إن السيرفر يعمل ويأخذ 27 ميجابايت، ولكن `docker logs` لم يطبع شيئاً، ولا حتى سطر الترحيب الذي يطبعه Godot قبل أي كود. والسبب أن البرنامج يكتب المخرج في ذاكرة مؤقتة Buffer ولا يرسلها إلى المخرج القياسي stdout إلا عندما تمتلئ، وهذا ما يفعله أي برنامج C عندما لا يكون المخرج شاشة طرفية Terminal. ويشرح [توثيق الإعداد flush\_stdout\_on\_print](https://docs.godotengine.org/en/stable/classes/class%5Fprojectsettings.html?ref=arabroot.io#class-projectsettings-property-application-run-flush-stdout-on-print) أنه معطل افتراضياً في نسخ الإصدار Release لأن تفريغ المخرج مع كل سطر يكلف أداءً، ومفعل في نسخ Debug وفي المحرر، ولهذا لم نر المشكلة طوال المختبر السابق. والتوثيق نفسه يقول إن هذا الإعداد لازم إذا أردت أن تجمع السجلات أداة مثل systemd، والأمر نفسه مع Docker. والأسوأ أنك إذا أوقفت السيرفر قبل أن يمتلئ الـ Buffer تضيع تلك السطور تماماً، فقد أوقفنا السيرفر في تجربة أخرى بعد 8 ثوان، فكان الملف الذي يكتب فيه المخرج فارغاً. والإصلاح سطر واحد في `project.godot`:

```ini
[application]
config/name="Multiplayer Lab"
run/main_scene="res://main.tscn"
run/flush_stdout_on_print=true
```

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

### نسيت /udp في -p: الاتصال يفشل بعد 31 ثانية

الخيار `-p 7777:7777` دون أي لاحقة ينشر منفذ TCP، لأن TCP هو الافتراضي في Docker كما يذكر [توثيق نشر المنافذ](https://docs.docker.com/engine/network/port-publishing/?ref=arabroot.io). وسيرفرنا يستمع على UDP، فشغلنا السيرفر مرة بالخيار دون لاحقة، ومرة بـ `/udp`، وفي كل مرة شغلنا بوتاً في Container آخر يتصل بالمنفذ المنشور على الجهاز عبر الاسم `host.docker.internal`، أي من الطريق نفسه الذي يأتي منه أي لاعب من خارج الجهاز:

```text
=== -p 7777:7777
7777/tcp -> 0.0.0.0:7777
7777/tcp -> [::]:7777
bot: connecting to host.docker.internal (enet) role mover mode reconcile render interp delay 100 ms redundancy 1, err=0
 31.54 s  connection failed
client finished after 37 s
=== -p 7777:7777/udp
7777/udp -> 0.0.0.0:7777
7777/udp -> [::]:7777
bot: connecting to host.docker.internal (enet) role mover mode reconcile render interp delay 100 ms redundancy 1, err=0
  0.09 s  connected as peer 526073292
bot RESULT  snapshots 99  gap p50 50.0 ms p99 88.7 ms max 88.7 ms  enet rtt 34 ms loss 0.0%
client finished after 9 s
  5.91 s  peer 526073292 connected (1 players)
 10.87 s  peer 526073292 left: inputs applied 295, missed 0, starved ticks 0
```

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

- **السطران الأولان من `docker port`:** يقولان بوضوح `7777/tcp`، وهذا أسرع فحص تقوم به بعد تشغيل أي سيرفر لعبة، قبل أن تفتح أي سجل.
- **`err=0` ثم فشل بعد 31.54 ثانية:** الكلاينت لا يعرف أن شيئاً خطأ عندما يبدأ، لأن UDP لا يوجد فيه اتصال يرفض، فحزم ENet تذهب ولا يرد عليها أحد، ويعيد المحاولة حتى تنتهي مهلته. ومن جهة اللاعب يبدو ذلك كأن السيرفر بطيء أو معطل، لا كأن المنفذ مغلق.
- **مع `/udp`:** اتصل البوت في 0.09 ثانية، ووصلته 99 صورة حالة في خمس ثوان، والسيرفر طبق 295 مدخلاً دون أن يضيع منها شيء.

والدرس نفسه ينطبق على الجدار الناري: القاعدة التي تفتح 7777 لـ TCP لا تفتحه لـ UDP، وقد شرحنا المنافذ والجدار الناري بالتفصيل في [مقال المنافذ والجدار الناري](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D9%86%D8%A7%D9%81%D8%B0-ports-%D9%88%D8%A7%D9%84%D8%AC%D8%AF%D8%A7%D8%B1-%D8%A7%D9%84%D9%86%D8%A7%D8%B1%D9%8A-firewall-%D8%A8%D8%A7%D9%84%D8%AA%D9%81%D8%B5%D9%8A%D9%84/). وإذا كان السيرفر على Linux فتستطيع أن تتأكد أن البرنامج يستمع فعلاً بالأمر `ss -ulpn`، والحرف `u` فيه يعني UDP.

### فحص الصحة Healthcheck لسيرفر UDP

في تطبيقات الويب يضع الناس في `HEALTHCHECK` أمراً مثل `curl` على مسار `/health`، وسيرفر اللعبة لا يتحدث HTTP. والسؤال الحقيقي الذي تريد إجابته ليس «هل العملية موجودة؟»، فـ Docker يعرف ذلك وحده، وإنما «هل الحلقة ما زالت تدور؟»، لأن السيرفر الذي علق في حلقة لا نهائية أو انتظر قفلاً Deadlock تبقى عمليته موجودة ولا يلعب فيه أحد. وأبسط طريقة أن يكتب السيرفر من داخل حلقته ملفاً صغيراً كل ثانية، وهذا ما أضفناه في النسخة 1.1.0، مع خيار `--hang-at` يدخل الحلقة في دوران لا نهائي بعد عدد من الثواني حتى نجرب الفحص:

```gdscript
	if tick % TICK == 0:
		world.uptime_s += 1
		FileAccess.open("/tmp/heartbeat", FileAccess.WRITE).store_string(str(tick))   # proof that the loop still turns
		if a.has("hang-at") and now_s() >= float(a["hang-at"]):
			print("%6.2f s  simulating a stuck loop" % now_s())
			while true:
				pass
```

ثم يتحقق الفحص في الـ Dockerfile من أن عمر الملف أقل من خمس ثوان:

```dockerfile
# healthy = the server loop wrote /tmp/heartbeat less than 5 s ago
HEALTHCHECK --interval=10s --timeout=3s --retries=3   CMD [ "sh", "-c", "test $(( $(date +%s) - $(stat -c %Y /tmp/heartbeat) )) -lt 5" ]
```

وشغلنا السيرفر بالخيار `--hang-at 40`، وقرأنا حالته من `docker inspect` ونسبة المعالج من `docker stats` كل 15 ثانية تقريباً:

```text
15 s: healthy failing=0 cpu 3.34%
30 s: healthy failing=0 cpu 2.89%
45 s: healthy failing=0 cpu 106.06%
60 s: healthy failing=2 cpu 97.26%
75 s: unhealthy failing=4 cpu 100.13%
90 s: unhealthy failing=5 cpu 105.34%
server 1.1.0, features: dedicated_server=true, display headless, binary export template
 40.96 s  simulating a stuck loop
```

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

- **بعد الثانية 41:** المعالج قفز إلى نواة كاملة تقريباً، والعملية ما زالت موجودة، فلو كان الفحص «هل العملية تعمل؟» لقال إنها سليمة.
- **الحالة `unhealthy` بعد ثلاثة فحوص فاشلة:** كما طلبنا بالخيار `--retries=3`، أي بعد قرابة نصف دقيقة من التعليق.
- **Docker وحده لا يفعل شيئاً بهذه الحالة:** الـ Container بقي يعمل وهو `unhealthy`، لأن إعادة التشغيل عند فشل الفحص عمل من يدير الـ Containers فوق Docker، مثل Swarm أو أداة مراقبة أو سكربت لك. ولكن الحالة نفسها هي الإشارة التي تبني عليها التنبيه أو إعادة التشغيل.

وهذا ما تفعله Agones بطريقة أخرى، فالسيرفر هناك يستدعي الدالة `Health()` من الـ SDK بشكل دوري، وإذا لم يستدعها خلال المدة المحددة في `spec.health.periodSeconds` عدداً متتالياً من المرات تعتبره غير سليم Unhealthy، كما يشرح [توثيق فحص الصحة في Agones](https://agones.dev/site/docs/guides/health-checking/?ref=arabroot.io). والفكرة واحدة: الدليل على الصحة يأتي من داخل الحلقة، لا من خارجها.

## كم لاعباً يتحمل السيرفر؟ قياس CPU وRAM والشبكة

قبل أن تختار حجم السيرفر الذي تستأجره تحتاج رقمين: كم يأخذ سيرفر المباراة الواحدة من المعالج والذاكرة، وكم يرسل إلى الشبكة، وكيف يتغير الرقمان مع عدد اللاعبين. ولا توجد طريقة لمعرفة ذلك إلا أن تقيس بلاعبين حقيقيين أو آليين. واللاعب الآلي في مختبرنا هو الكلاينت نفسه من مقال اللعب الجماعي، يعمل دون شاشة، ويتحرك يميناً ويساراً، ويرسل 60 مدخلاً في الثانية، ويستقبل صور الحالة 20 مرة في الثانية، أي أنه يرسل بالضبط ما يرسله لاعب حقيقي في هذه اللعبة. وكل بوت عملية Godot كاملة، فشغلنا ثمانية بوتات في كل Container، وقسنا السيرفر بالأمر `docker stats` عشر مرات بعد 20 ثانية من دخول البوتات، وأخذنا أرقام الشبكة من السطر الذي يطبعه السيرفر نفسه كل ثانية من إحصاءات ENet. وهذا الجزء من السكربت `load.sh` الذي يشغل البوتات:

```bash
left=$N; c=0
while [ $left -gt 0 ]; do k=$(( left < 8 ? left : 8 )); c=$((c+1))
  MSYS_NO_PATHCONV=1 docker run -d --init --name gm3-sv-bots$c --network gm3-sv-net -v "$W/game:/game:ro" gm3-godot:4.7.2 bash -c \
    "for i in \$(seq $k); do godot --headless --path /game -- --client --host gm3-sv-load --role mover --duration 120 --name b$c-\$i > /dev/null 2>&1 & done; wait" >/dev/null
  left=$((left-k)); done
```

والسيرفر هو الـ Image نفسها، قالب التصدير مع الحزمة، والنتائج كانت كما يلي:

| البوتات         | CPU السيرفر | RAM السيرفر | يرسل       | يستقبل   | حزم خارجة / داخلة في الثانية | كلفة البوتات نفسها |
| --------------- | ----------- | ----------- | ---------- | -------- | ---------------------------- | ------------------ |
| 0               | 3.9%        | 27.04 MiB   | 0          | 0        | 0 / 0                        | لا يوجد            |
| 1               | 4.0%        | 27.03 MiB   | 1.3 KB/s   | 3.3 KB/s | 24 / 62                      | 3%، 37 MiB         |
| 8               | 5.0%        | 27.03 MiB   | 55 KB/s    | 26 KB/s  | 191 / 495                    | 23%، 294 MiB       |
| 16              | 7.5%        | 27.05 MiB   | 213 KB/s   | 52 KB/s  | 382 / 992                    | 61%، 579 MiB       |
| 32              | 11.1%       | 27.02 MiB   | 834 KB/s   | 105 KB/s | 763 / 1,982                  | 191%، 1,153 MiB    |
| 64              | 17.7%       | 29.41 MiB   | 3,358 KB/s | 199 KB/s | 2,792 / 3,776                | 475%، 2,285 MiB    |
| 64 بصيغة packed | 15.9%       | 29.36 MiB   | 1,415 KB/s | 162 KB/s | 1,484 / 3,081                | 322%، 2,295 MiB    |

والنسبة المئوية للمعالج في `docker stats` هي من نواة واحدة، أي أن 17.7% تعني قرابة خمس نواة. والشكل التالي يرسم عمودي المعالج والشبكة من الجدول نفسه:

![رسمان من أرقام المختبر مع 0 و1 و8 و16 و32 و64 لاعباً آلياً. الأول معالج السيرفر بالنسبة المئوية من نواة واحدة: 3.9 ثم 4.0 ثم 5.0 ثم 7.5 ثم 11.1 ثم 17.7، يصعد ببطء وبشكل شبه مستقيم. والثاني ما يرسله السيرفر بالكيلوبايت في الثانية: 0 ثم 1.3 ثم 55 ثم 213 ثم 834 ثم 3358، منحنى يتضاعف أربع مرات كلما تضاعف اللاعبون، ونقطة إضافية عند 64 لاعباً بصيغة packed قيمتها 1415. والذاكرة ثابتة بين 27 و29.4 ميجابايت](https://arabroot.io/content/images/2026/11/game-servers-03-load.webp)

المعالج يزيد ببطء مع اللاعبين، والشبكة تتضاعف أربع مرات كلما تضاعفوا

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

- **الذاكرة لا تهم هنا:** بين 27 و29.4 ميجابايت من السيرفر الفارغ إلى 64 لاعباً، لأن حالة اللاعب الواحد بضعة أرقام. وفي لعبة حقيقية فيها خريطة وفيزياء وذكاء للأعداء تكبر الذاكرة مع الخريطة لا مع اللاعبين غالباً.
- **المعالج يزيد ببطء:** من 3.9% فارغاً إلى 17.7% مع 64 لاعباً. والـ 3.9% دون أي لاعب هي الحلقة التي تدور 60 مرة في الثانية، كما ذكرنا في قسم ما يفعله السيرفر. ولاحظ أن الجهاز الذي قسنا عليه مشترك وعليه عشرات الـ Containers الأخرى، فخذ من الأرقام الاتجاه لا الكسور.
- **الشبكة هي المشكلة:** مع كل مضاعفة لعدد اللاعبين تضاعف ما يرسله السيرفر أربع مرات تقريباً: 55 ثم 213 ثم 834 ثم 3,358 كيلوبايت في الثانية. والسبب أن كل صورة حالة فيها كل اللاعبين، وكل لاعب يستقبل صورته، أي أن الحجم يكبر مع مربع العدد. و3.36 ميجابايت في الثانية تعني قرابة 27 ميجابت في الثانية، و290 جيجابايت في اليوم لو بقيت المباراة ممتلئة طوال اليوم، وهذا رقم يتجاوز الـ Traffic الشهري المسموح في كثير من عروض VPS خلال أسابيع.
- **الحزم الخارجة 2,792 في الثانية مع 64 لاعباً:** وصور الحالة نفسها 64 × 20 = 1,280 فقط. فصورة الحالة بصيغة Variant التي يرمز بها Godot الـ Array صار حجمها قرابة 2,600 بايت، أكبر من حزمة واحدة على الشبكة، فقسمها ENet إلى قطع Fragments، وضياع أي قطعة يضيع الصورة كلها.
- **الصيغة packed:** السيرفر نفسه يستطيع أن يرسل الحالة في `PackedByteArray` بـ 17 بايت لكل لاعب بدل مصفوفة Variant، وهذا خيار `--format packed` الذي بنيناه في مقال اللعب الجماعي. ومع 64 لاعباً نزل ما يرسله من 3,358 إلى 1,415 كيلوبايت في الثانية، والحزم من 2,792 إلى 1,484\. والخطوة التالية في لعبة حقيقية ألا ترسل لكل لاعب إلا اللاعبين القريبين منه Interest Management، فيتوقف النمو مع مربع العدد.
- **البوتات أغلى من السيرفر:** 64 بوتاً أخذت 475% من المعالج، أي قرابة خمس أنوية، و2.3 جيجابايت، بينما أخذ السيرفر الذي يخدمها خمس نواة. وكل بوت عملية Godot كاملة تأخذ قرابة 36 ميجابايت، ولذلك شغل اختبار الضغط من جهاز غير جهاز السيرفر، وإلا قست تنافسهما على المعالج لا السيرفر. ولاحظ في سطر packed أن البوتات أرسلت 3,081 حزمة في الثانية بدل 3,776، أي أنها لم تلحق بستين مدخلاً في الثانية كلها في ذلك التشغيل، وهذا ما يحدث عندما يكون جهاز الاختبار نفسه مضغوطاً.

وما معنى هذا عند اختيار السيرفر؟ لو كانت لعبتك مثل لعبة المختبر، بثمانية لاعبين في المباراة، فكل مباراة تأخذ 5% من نواة و27 ميجابايت و55 كيلوبايت في الثانية، فيستطيع VPS بنواتين أن يشغل عشرات المباريات من ناحية المعالج والذاكرة، وتنتهي حصة الشبكة قبلهما. وقد شرحنا كيف تقرأ مواصفات VPS، ومنها المعالج المشترك Shared والـ Traffic الشهري، في [مقال اختيار VPS](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%AA%D8%AE%D8%AA%D8%A7%D8%B1-%D8%AE%D8%A7%D8%AF%D9%85%D8%A7-%D8%A7%D9%81%D8%AA%D8%B1%D8%A7%D8%B6%D9%8A%D8%A7-vps/). والأرقام تخص لعبة المختبر وحدها، فقس لعبتك بالطريقة نفسها قبل أن تشتري.

## الإيقاف الآمن Graceful Shutdown

كل إيقاف لسيرفرك سوف يمر من الأمر `docker stop`، سواء كتبته بيدك، أو نفذه `docker compose up` عند تحديث، أو أعاد Docker تشغيل الجهاز. ويشرح [توثيق docker stop](https://docs.docker.com/reference/cli/docker/container/stop/?ref=arabroot.io) ما يحدث: يرسل إشارة الإيقاف، وهي SIGTERM افتراضياً، إلى العملية الرئيسية في الـ Container، وينتظر مهلة، يقول التوثيق إنها 10 ثوان افتراضياً في Containers لينكس، ثم يرسل SIGKILL الذي لا يمكن لأي برنامج أن يتجاهله. والبرنامج المهذب يستقبل SIGTERM فيحفظ ويغلق اتصالاته ويخرج بنفسه قبل نهاية المهلة.

### ماذا يفعل Godot مع SIGTERM؟

شغلنا السيرفر بالمحرر في Container، وانتظرنا أربع ثوان، ثم أوقفناه بالإشارة SIGTERM ثم بالإشارة SIGINT التي يرسلها Ctrl+C، مرة والبرنامج هو العملية رقم 1 في الـ Container، ومرة مع الخيار `--init` الذي يضع قبله برنامجاً صغيراً اسمه tini يمرر الإشارات. وقسنا كم استغرق الأمر `docker stop`، ورمز الخروج Exit Code:

```text
init='' signal SIGTERM: stop took 12691 ms, exit code 137
init='--init' signal SIGTERM: stop took 1559 ms, exit code 143
init='' signal SIGINT: stop took 5467 ms, exit code 137
init='--init' signal SIGINT: stop took 3426 ms, exit code 130
```

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

- **دون `--init`، الرمز 137:** أي 128 + 9، أي أن العملية ماتت بالإشارة SIGKILL بعد انتهاء المهلة. والسبب أن نواة Linux لا تطبق السلوك الافتراضي للإشارات على العملية رقم 1 في نطاق العمليات PID Namespace، فإذا لم يسجل البرنامج معالجاً للإشارة فإنه يتجاهلها، وهذا شرح [مستودع tini](https://github.com/krallin/tini?ref=arabroot.io) لسبب وجوده.
- **مع `--init`، الرمز 143 و130:** أي 128 + 15 و128 + 2، فالعملية ماتت بالإشارة نفسها فوراً، دون أن تنفذ أي سطر من كودها. وهذا أسرع، ولكنه ليس إيقافاً آمناً، فالسيرفر لم يحفظ شيئاً ولم يخبر أحداً.
- **لم يطبع السيرفر أي سطر عند الإيقاف** في أي من التشغيلات الأربعة، وأضفنا إلى السكربت دالة `_notification` تطبع إذا وصلها `NOTIFICATION_WM_CLOSE_REQUEST`، وهو الإشعار الذي يصل عند طلب إغلاق النافذة، فلم تطبع شيئاً أيضاً.

أي أن Godot 4.7.2 دون شاشة لا يحول SIGTERM إلى طلب إغلاق يصل إلى كودك، فلا توجد طريقة من GDScript وحده لتحفظ عند `docker stop`. وللمقارنة، سيرفر Luanti الذي سنشغله لاحقاً طبع عند الإشارة نفسها `got SIGTERM, shutting down` وخرج بالرمز 0 في 1.7 ثانية، لأنه يسجل معالجاً للإشارة بنفسه.

### كم ينتظر Docker فعلاً؟ المهلة Stop Timeout

في التشغيل الأول دون `--init` استغرق `docker stop` قرابة 12.7 ثانية كما يتوقع من مهلة 10 ثوان، ثم كررنا التجربة ثلاث مرات أخرى بعد ساعة، فانتهت كلها بالرمز 137 نفسه بعد 4.6 و5.5 و5.9 ثانية فقط. ولنعرف هل الفرق من Godot أم من Docker، شغلنا الأمر `sleep 1000` في Alpine، وهو أيضاً لا يعالج SIGTERM وهو العملية رقم 1:

```text
29.8.0
sleep as PID1: stop 4309 ms exit 137
with -t 10: stop 11693 ms exit 137
```

أي أن Docker Desktop بالإصدار 29.8.0 عندنا قتل الـ Container بعد قرابة أربع ثوان عندما لم نحدد المهلة، وانتظر 10 ثوان كاملة عندما كتبناها صراحة بـ `-t 10`، مع أن التوثيق يقول إن الافتراضي 10 ثوان. ولا نعرف سبب هذا الفرق في بيئتنا، ولكن الدرس العملي واضح: لا تعتمد على المهلة الافتراضية أياً كانت قيمتها، واكتبها صراحة في كل مكان يوقف السيرفر، بالخيار `--stop-timeout` في `docker run`، أو `stop_grace_period` في Compose، أو `-t` في `docker stop`.

### سكربت يحول الإشارة إلى طلب يفهمه السيرفر

الحل أن نضع أمام البرنامج سكربتاً صغيراً هو العملية رقم 1، يستقبل SIGTERM، ويحوله إلى شيء يقرؤه كود السيرفر، ثم ينتظر خروجه. واخترنا أبسط شيء ممكن: ملف `/tmp/stop`. وهذا الملف `entrypoint.sh` كاملاً:

```bash
#!/bin/sh
# Godot does not handle SIGTERM: docker stop would kill the server without a save.
# This script turns the signal into a request the server reads (the file /tmp/stop), then waits for it to save and exit.
rm -f /tmp/stop
/srv/game -- --save /data/world.json "$@" &
pid=$!
trap 'echo "entrypoint: got SIGTERM, asking the server to save and stop"; touch /tmp/stop' TERM INT
wait "$pid"                       # returns early when a signal arrives ...
trap - TERM INT
wait "$pid"                       # ... so wait again for the real exit
code=$?
echo "entrypoint: server exited with code $code"
exit "$code"
```

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

- **البرنامج يعمل في الخلفية بـ `&`:** لو شغلناه بـ `exec` لأصبح هو العملية رقم 1 وعادت المشكلة، ولو شغلناه في المقدمة لما نفذت `sh` الـ `trap` حتى يخرج.
- **`wait` مرتين:** وصول إشارة يجعل `wait` الأولى تعود فوراً قبل أن يخرج البرنامج، فننتظر مرة ثانية خروجه الحقيقي، ونخرج برمزه هو.
- **`"$@"`:** أي خيار تمرره بعد اسم الـ Image في `docker run` يصل إلى السيرفر، مثل `--drain 60`.

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

```gdscript
	if tick % TICK == 0:
		world.uptime_s += 1
		if not stopping and FileAccess.file_exists("/tmp/stop"):
			request_stop()
		if stopping and (players.is_empty() or now_s() >= drain_until):
			server_quit()
		if tick % (TICK * int(opt("autosave", "30"))) == 0:
			save_world("autosave")
```

والدالة `request_stop` تسجل أن السيرفر في طور الإيقاف، وتحسب موعد نهاية مهلة التفريغ من الخيار `--drain`، و`server_quit` تحفظ العالم ثم تخرج. والتفريغ Draining معناه أن السيرفر لا يقبل لاعبين جدداً، ولكنه يترك المباراة الحالية تنتهي، أو تنتهي المهلة، قبل أن يخرج. وهذا ما حدث عندما أوقفنا السيرفر بـ `docker stop -t 90` وفيه لاعب آلي بقي له من مباراته قرابة 15 ثانية، والسيرفر يعمل بالخيار `--drain 60`:

```text
docker stop returned after 40 s, exit code 0
world: /data/world.json boot 4, players so far 1, inputs so far 295, uptime so far 70 s
server 1.0.0, features: dedicated_server=true, display headless, binary export template
server: enet on port 7777, tick 60 Hz, snapshot every 3 ticks (20 Hz), format var, checks on, err=0
 10.39 s  peer 784513524 connected (1 players)
entrypoint: got SIGTERM, asking the server to save and stop
 20.89 s  stop requested: refusing new players, 1 still playing, draining up to 60 s
 29.90 s  world saved (autosave): boot 4, players 2, inputs 1467, uptime 100 s
 35.32 s  peer 784513524 left: inputs applied 1481, missed 13, starved ticks 0
 36.05 s  world saved (quit): boot 4, players 2, inputs 1776, uptime 106 s
server total: 25 s, sent 32737 bytes (1.3 KB/s), received 80011 bytes (3.1 KB/s), snapshots 496
entrypoint: server exited with code 0
```

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

- **بين 20.89 و35.32 ثانية:** استمرت المباراة 14.4 ثانية بعد الإشارة، وطبق السيرفر فيها مدخلات اللاعب كالمعتاد، ثم خرج اللاعب حين انتهت مباراته، فخرج السيرفر بعد أقل من ثانية لأن القائمة أصبحت فارغة.
- **`world saved (quit)` والرمز 0:** هذه المرة حفظ السيرفر حالته قبل الخروج، وخرج برمز نجاح، لا برمز قتل.
- **`docker stop` استغرق 40 ثانية:** أكثر من المهلة الافتراضية بكثير، ولذلك مررنا `-t 90`. ولو تركنا المهلة الافتراضية لقتل Docker السيرفر بعد ثوان في منتصف التفريغ. فاجعل المهلة أطول من أطول مباراة تقبل انتظارها، بالخيار `--stop-timeout` في `docker run`، أو `stop_grace_period` في ملف Compose.
- **`boot 4` ثم الحفظ بـ `boot 4`:** عداد التشغيلات في ملف العالم، وسنعود إليه في قسم الحفظ، لأنه كشف لنا ما يضيع عندما يموت السيرفر قبل أن يحفظ.

![خطان زمنيان. الأعلى دون معالجة: docker stop يرسل SIGTERM إلى Godot وهو العملية رقم 1، فلا يحدث شيء، وبعد انتهاء المهلة SIGKILL، ورمز الخروج 137، والعالم لم يحفظ. والأسفل مع entrypoint.sh: SIGTERM يصل إلى السكربت، فيكتب الملف /tmp/stop، والسيرفر يقرؤه في الثانية التالية ويتوقف عن قبول لاعبين جدد، ثم ينتظر المباراة 14.4 ثانية حتى يخرج آخر لاعب، ثم يحفظ world.json ويخرج بالرمز 0، وdocker stop بمهلة 90 ثانية يعود بعد 40 ثانية](https://arabroot.io/content/images/2026/11/game-servers-04-shutdown.webp)

docker stop على سيرفر Godot: قتل بعد المهلة دون حفظ، أو تفريغ وحفظ وخروج نظيف

### لاعب يصل أثناء التفريغ: خطأ Bus error

في أول نسخة من `request_stop` استخدمنا الخاصية `refuse_new_connections` في [MultiplayerPeer](https://docs.godotengine.org/en/stable/classes/class%5Fmultiplayerpeer.html?ref=arabroot.io)، وهي الطريقة التي يوفرها Godot ليرفض السيرفر الاتصالات الجديدة. ثم كررنا التجربة السابقة، ولكن أرسلنا بوتاً ثانياً يحاول الاتصال بعد ثلاث ثوان من الإشارة، فكان هذا آخر ما طبعه السيرفر:

```text
entrypoint: got SIGTERM, asking the server to save and stop
 32.98 s  stop requested: refusing new players, 1 still playing, draining up to 60 s
entrypoint: server exited with code 135
Bus error (core dumped)
```

الرمز 135 يعني 128 + 7، أي الإشارة SIGBUS، فالسيرفر انهار لحظة وصول الاتصال الجديد، ومعه خرج اللاعب الأول من مباراته، ولم يحفظ شيء منذ آخر حفظ دوري. وكررنا التجربة ثلاث مرات بقالب التصدير، مرتين بالإشارة ومرة بكتابة الملف `/tmp/stop` بيدنا، وانهار في الثلاث. ثم كررناها بالمحرر مع مجلد المشروع، فلم ينهر، ورفض الاتصال كما يجب. أي أن المشكلة ظهرت لنا في قالب الإصدار 4.7.2 فقط، وهذا سبب آخر لتختبر بالبرنامج نفسه الذي تشغله في الإنتاج. والطريقة التي تجنبتها في النسخة 1.0.1 أن السيرفر يقبل الاتصال ثم يقطعه فوراً بنفسه:

```gdscript
	multiplayer.peer_connected.connect(func(id: int) -> void:
		if stopping:
			print("%6.2f s  peer %d arrived while draining: disconnected" % [now_s(), id])
			multiplayer.multiplayer_peer.disconnect_peer(id)    # instead of refuse_new_connections (crashed the release template)
			return
```

ومع النسخة الجديدة، وطلب الإيقاف هذه المرة بكتابة الملف `/tmp/stop` بالأمر `docker exec`، وصل اللاعب المتأخر في الثانية 25.45 فقطع السيرفر اتصاله، وطبع ENet رسالتي خطأ عن قناة لم تعد موجودة، ثم أكمل اللاعب الأول مباراته حتى الثانية 36.22، وحفظ السيرفر وخرج، وقال `docker inspect` إن الـ Container انتهى بالرمز 0:

```text
 17.96 s  stop requested: no new players, 1 still playing, draining up to 60 s
 25.45 s  peer 1460619979 arrived while draining: disconnected
ERROR: Unable to send packet on channel 0, max channels: 0
   at: send (modules/enet/enet_packet_peer.cpp:64)
ERROR: Unable to send packet on channel 1, max channels: 0
   at: send (modules/enet/enet_packet_peer.cpp:64)
 29.95 s  world saved (autosave): boot 1, players 1, inputs 1117, uptime 30 s
 36.22 s  peer 551173245 left: inputs applied 1492, missed 0, starved ticks 0
 36.97 s  world saved (quit): boot 1, players 1, inputs 1492, uptime 37 s
server total: 25 s, sent 33230 bytes (1.3 KB/s), received 80739 bytes (3.2 KB/s), snapshots 499
```

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

## حفظ حالة العالم World State والنسخ الاحتياطي Backup

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

```gdscript
func save_world(why: String) -> void:
	var tmp := save_path() + ".tmp"                  # write a new file, then rename: a crash never leaves half a file
	var f := FileAccess.open(tmp, FileAccess.WRITE)
	if f == null:
		print("world: cannot write %s (%s)" % [tmp, error_string(FileAccess.get_open_error())])
		return
	f.store_string(JSON.stringify(world, "  "))
	f.close()
	DirAccess.rename_absolute(tmp, save_path())
	print("%6.2f s  world saved (%s): boot %d, players %d, inputs %d, uptime %d s" % [now_s(), why, world.boots, world.players_total, world.inputs_total, world.uptime_s])
```

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

- **الكتابة في ملف جديد ثم إعادة التسمية:** لو كتبنا فوق `world.json` مباشرة، ومات السيرفر في منتصف الكتابة، لبقي عندنا نصف ملف لا يقرأ، أي أننا خسرنا النسخة القديمة والجديدة معاً. وإعادة التسمية داخل نظام الملفات نفسه عملية ذرية Atomic، فإما أن يرى السيرفر في التشغيل التالي الملف القديم كاملاً أو الجديد كاملاً.
- **الحفظ في ثلاث مناسبات:** كل 30 ثانية Autosave، وعند الإيقاف الآمن، ولا شيء غيرهما. والحفظ الدوري هو ما يحميك من الانهيار، والحفظ عند الإيقاف هو ما يحميك من التحديث.

وقد رأينا قيمة الحفظ الدوري دون أن نقصد ذلك. ففي تجربة الانهيار في القسم السابق كان السيرفر قد بدأ بالتشغيل رقم 5، وحفظ دورياً في الثانية 29.95 قيمة `inputs 2255`، ثم انهار في الثانية 33 قبل أي حفظ آخر. وعندما شغلنا السيرفر من النسخة الاحتياطية لاحقاً كان أول ما طبعه:

```text
world: /data/world.json boot 6, players so far 3, inputs so far 2255, uptime so far 136 s
```

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

### النسخة الاحتياطية من الـ Volume والاستعادة Restore

حالة العالم في الـ Volume `gm3-sv-world`، والـ Volume يبقى إذا حذفت الـ Container، ولكنه لا يبقى إذا تلف القرص أو حذفته بالخطأ، فهو ليس نسخة احتياطية. والطريقة التي يذكرها [توثيق الـ Volumes في Docker](https://docs.docker.com/engine/storage/volumes/?ref=arabroot.io) هي Container مؤقت يقرأ الـ Volume ويكتب ملف tar في مجلد على الجهاز:

```bash
docker run --rm -v gm3-sv-world:/data:ro -v "$PWD/backup:/backup" debian:bookworm-slim \
  sh -c 'tar czf /backup/world-2026-11-18.tar.gz -C /data . && tar tzvf /backup/world-2026-11-18.tar.gz'
```

والمخرج:

```text
drwxr-xr-x 1000/root         0 2026-11-18 13:55 ./
-rw-r--r-- 1000/1000       111 2026-11-18 13:55 ./world.json
```

ولاحظ `:ro` على الـ Volume، فالنسخ لا يحتاج أن يكتب فيه، والخطأ في أمر النسخ لا يجب أن يستطيع إتلاف الأصل. ثم استعدنا النسخة في Volume جديد تماماً، وشغلنا عليه السيرفر:

```bash
docker volume create gm3-sv-world-restored
docker run --rm -v gm3-sv-world-restored:/data -v "$PWD/backup:/backup:ro" debian:bookworm-slim \
  sh -c 'tar xzf /backup/world-2026-11-18.tar.gz -C /data && chown -R 1000:1000 /data && ls -ln /data'
docker run -d --name gm3-sv-game -v gm3-sv-world-restored:/data gm3-sv-game:1.0.1
```

والمخرج من الاستعادة ثم من السيرفر:

```text
total 4
-rw-r--r-- 1 1000 1000 111 Nov 18 13:55 world.json
world: /data/world.json boot 6, players so far 3, inputs so far 2255, uptime so far 136 s
server 1.0.0, features: dedicated_server=true, display headless, binary export template
```

وفي هذا لاحظ أمرين. الأول `chown -R 1000:1000`، لأن السيرفر يعمل بالمستخدم `gameserver` برقم 1000، ولو بقيت الملفات المستعادة لـ root لفشل الحفظ التالي برسالة `cannot write`. والثاني أن النسخة الاحتياطية التي لم تستعدها مرة واحدة على الأقل لا تعرف هل تعمل، وهذا ما شرحناه في [مقال النسخ الاحتياطي بقاعدة 3-2-1](https://arabroot.io/articles/%D8%A7%D9%84%D9%86%D8%B3%D8%AE-%D8%A7%D9%84%D8%A7%D8%AD%D8%AA%D9%8A%D8%A7%D8%B7%D9%8A-%D8%A8%D9%82%D8%A7%D8%B9%D8%AF%D8%A9-3-2-1-%D9%88%D8%A7%D8%AE%D8%AA%D8%A8%D8%A7%D8%B1-%D8%A7%D9%84%D8%A7%D8%B3%D8%AA%D8%B9%D8%A7%D8%AF%D8%A9/)، ومعه كيف تخرج النسخة من السيرفر نفسه في [مقال النسخة خارج السيرفر](https://arabroot.io/articles/%D8%A7%D9%84%D9%86%D8%B3%D8%AE%D8%A9-%D8%AE%D8%A7%D8%B1%D8%AC-%D8%A7%D9%84%D8%B3%D9%8A%D8%B1%D9%81%D8%B1-off-site-%D8%A7%D9%84%D9%89-s3-%D9%85%D8%B9-restic-%D8%A7%D9%88-kopia/).

وقد يتساءل البعض: هل نستطيع نسخ الـ Volume والسيرفر يعمل؟ في مختبرنا نعم، لأن الملف يستبدل بإعادة تسمية ذرية، فإما أن يأخذ tar الملف القديم أو الجديد. وأما الألعاب التي تحفظ عالمها في قاعدة بيانات SQLite، مثل Luanti كما سنرى، فنسخ ملف القاعدة وهي تكتب قد يعطيك ملفاً تالفاً، كما يشرح [توثيق SQLite عن أسباب تلف القاعدة](https://www.sqlite.org/howtocorrupt.html?ref=arabroot.io). فإما أن توقف السيرفر قبل النسخ، وإما أن تستخدم أداة النسخ التي توفرها اللعبة أو [واجهة النسخ في SQLite](https://www.sqlite.org/backup.html?ref=arabroot.io) نفسها.

## التحديثات Updates دون طرد اللاعبين

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

```gdscript
@rpc("any_peer", "reliable")
func chat(text: String) -> void:
	## new in 2.0.0: players can send a chat line
	print("%6.2f s  chat from %d: %s" % [now_s(), multiplayer.get_remote_sender_id(), text])
```

ثم شغلنا سيرفر 2.0.0، وأوصلنا به بوتاً من النسخة 1.0.0 لم يتغير فيه شيء. وهذا ما طبعه البوت، مع عدد مرات تكرار كل سطر في أوله:

```text
    119 ERROR: RPC - 'Node(main.gd)::snapshot_packed': Method expected 1 argument(s), but called with 2
      1 ERROR: The rpc node checksum failed. Make sure to have the same methods on both nodes. Node path: Main
      1   0.02 s  connected as peer 251397156
      1 v1bot RESULT  snapshots 0  gap p50 0.0 ms p99 0.0 ms max 0.0 ms  enet rtt 18 ms loss 0.0%
```

وهذا ما طبعه السيرفر:

```text
      1 ERROR: The rpc node checksum failed. Make sure to have the same methods on both nodes. Node path: /root/Main
      1   9.08 s  peer 251397156 connected (1 players)
      1  15.06 s  peer 251397156 left: inputs applied 0, missed 0, starved ticks 0
```

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

- **`rpc node checksum failed`:** يشرح [توثيق اللعب الجماعي في Godot](https://docs.godotengine.org/en/stable/tutorials/networking/high%5Flevel%5Fmultiplayer.html?ref=arabroot.io) أن كل دوال RPC في السكربت تفحص معاً ببصمة Checksum، وأنها يجب أن تكون معرفة في سكربت الكلاينت وسكربت السيرفر حتى لو لم تستخدم، وأن عدم تطابقها قد يطبع خطأ أو يسبب سلوكاً غير متوقع. وهذا بالضبط ما حدث: اكتشف الطرفان الاختلاف، وطبعا الخطأ، ثم أكملا كأن شيئاً لم يكن.
- **119 خطأ `snapshot_packed`:** الدالة الجديدة غيرت طريقة تعرف الطرفين على الدوال، فكل صورة حالة يرسلها السيرفر الجديد بالدالة `snapshot` بمعاملين وصلت إلى الكلاينت القديم إلى الدالة `snapshot_packed` التي تأخذ معاملاً واحداً، فلم يصله أي شيء: `snapshots 0`.
- **`inputs applied 0`:** والعكس حدث في الاتجاه الآخر، فلم يطبق السيرفر أي مدخل من البوت. والمهم هنا أن الاتصال نفسه نجح، والرسالة الوحيدة الواضحة كانت في السجلات، فاللاعب يرى لعبة متصلة لا يتحرك فيها شيء.

ولذلك يجب أن يكون في أول رسالة بين الكلاينت والسيرفر رقم نسخة البروتوكول Protocol Version، فإذا اختلف رفض السيرفر الاتصال برسالة يفهمها اللاعب: «حدث اللعبة». ورقم البروتوكول غير رقم الإصدار، فالنسخة 1.0.1 من سيرفرنا أصلحت الانهيار دون أن تغير أي RPC، فتستطيع أن تخدم كلاينت 1.0.0، وأما 2.0.0 فلا. وفي الأسواق التي تفرض فيها المتاجر مراجعة لكل تحديث، يعني هذا أنك قد تحتاج أن تشغل السيرفرين القديم والجديد معاً لأيام، حتى يحدث كل اللاعبين.

![رسم لتحديث السيرفر على مراحل. في الأعلى ما حدث في المختبر: كلاينت 1.0.0 يتصل بسيرفر 2.0.0 أضاف دالة chat، فتختلف أرقام دوال RPC، وتظهر الرسالة rpc node checksum failed، و119 صورة حالة لا تصل، و0 مدخلات مطبقة. وفي الأسفل الطريقة الصحيحة: Images بوسوم 1.0.1 و2.0.0، وسيرفرات قديمة تفرغ من لاعبيها بينما نظام البحث عن مباراة يرسل اللاعبين الجدد إلى السيرفرات الجديدة، ورقم بروتوكول في أول رسالة يرفض الكلاينت القديم برسالة حدث اللعبة](https://arabroot.io/content/images/2026/11/game-servers-05-update.webp)

التحديث: ما يحدث عندما يختلف البروتوكول، وكيف تتبدل السيرفرات دون طرد أحد

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

1. **Image بوسم الإصدار:** `gm3-sv-game:1.0.1` لا `latest`، حتى تعرف دائماً ما الذي يعمل، وتستطيع الرجوع بأمر واحد. وقد ناقشنا أدوات تحديث الـ Containers وأخطارها في [مقال تحديث الـ Containers بأمان](https://arabroot.io/articles/%D8%AA%D8%AD%D8%AF%D9%8A%D8%AB-%D8%A7%D9%84-containers-%D8%A8%D8%A7%D9%85%D8%A7%D9%86-watchtower-%D8%A7%D9%85-diun-%D8%A7%D9%85-renovate/)، والتحديث التلقائي لسيرفر لعبة فيه لاعبون فكرة سيئة، لأن الأداة لا تعرف أن أحداً يلعب.
2. **شغل الجديد بجانب القديم:** على منفذ آخر، 7778 مثلاً، وأخبر نظام البحث عن مباراة أن المباريات الجديدة تذهب إليه.
3. **فرغ القديم:** `docker stop` بمهلة أطول من أطول مباراة، فيكمل اللاعبون الحاليون ثم يحفظ ويخرج.
4. **للعالم المستمر:** لا يوجد سيرفران لعالم واحد، فخذ نسخة احتياطية، ثم أوقف القديم، ثم شغل الجديد على الـ Volume نفسه، وأعلن موعد التحديث للاعبين قبله.

## سيرفر جاهز للمقارنة: Luanti

كل ما سبق بنيناه بأيدينا لأن اللعبة لعبتنا. وأما إذا أردت أن تستضيف سيرفر لعبة مفتوحة المصدر جاهزة لمجتمعك أو لطلابك، فأغلب العمل مكتوب مسبقاً، ولكن الأسئلة نفسها تبقى: أين البيانات؟ وأي منفذ؟ وماذا يحدث عند الإيقاف؟ واخترنا [Luanti](https://www.luanti.org/?ref=arabroot.io)، المحرك المعروف سابقاً باسم Minetest، وهو لعبة بناء بالمكعبات Voxel مفتوحة المصدر، وكوده بترخيص LGPL-2.1 كما في [ملف الترخيص](https://github.com/luanti-org/luanti/blob/master/LICENSE.txt?ref=arabroot.io)، والمشروع ينشر Docker Image رسمية للسيرفر، ويشرحها في [توثيق سيرفر Docker](https://github.com/luanti-org/luanti/blob/master/doc/docker%5Fserver.md?ref=arabroot.io). وجربنا [الإصدار 5.18.0](https://github.com/luanti-org/luanti/releases/tag/5.18.0?ref=arabroot.io)، والـ Image حجمها 102 ميجابايت بعد التحميل، وحملنا منها 30.6 ميجابايت مضغوطة فقط.

### المحرك وحده لا يكفي: اختيار اللعبة

أول تشغيل للـ Image كما هي انتهى في أقل من ثانية بهذا المخرج:

```text
2026-11-18 14:19:04: ERROR[Main]: To run a Luanti server, you need to select a game using the '--gameid' argument.
2026-11-18 14:19:04: ERROR[Main]: Check out https://content.luanti.org for a selection of games to pick from and download.
```

Luanti محرك، واللعبة نفسها حزمة منفصلة، والـ Image الرسمية لا تحمل أي لعبة. فاخترنا [Minetest Game](https://github.com/luanti-org/minetest%5Fgame?ref=arabroot.io)، اللعبة الأساسية التي يصونها مطورو المحرك، وترخيص كودها LGPL-2.1 وصورها وأصواتها CC BY-SA 3.0، وهذا يعني أنك تستطيع أن تستضيفها وتعدلها، بشرط أن تنشر تعديلاتك على الكود بالترخيص نفسه إذا وزعتها، وأن تذكر أصحاب الصور. وحملنا الكود من الفرع الرئيسي، وآخر تعديل فيه بتاريخ 30 أكتوبر 2026، ونسخناه داخل الـ Volume في المكان الذي يبحث فيه المحرك عن الألعاب:

```bash
docker volume create gm3-sv-luanti-data
docker run --rm -v gm3-sv-luanti-data:/var/lib/minetest -v "$PWD/lt-dl/minetest_game:/src:ro" --entrypoint sh gm3-sv-luanti:5.18.0 \
  -c 'mkdir -p /var/lib/minetest/.minetest/games && cp -r /src /var/lib/minetest/.minetest/games/minetest_game'
docker run -d --name gm3-sv-lt -v gm3-sv-luanti-data:/var/lib/minetest -p 30000:30000/udp gm3-sv-luanti:5.18.0 \
  --config /etc/minetest/minetest.conf --gameid minetest_game
```

والمخرج من السجلات ثم من `docker port`:

```text
2026-11-18 14:22:22: ACTION[Main]: World at [/var/lib/minetest/.minetest/worlds/world]
2026-11-18 14:22:22: ACTION[Main]: Server for gameid="minetest" listening on [::]:30000.
30000/udp -> 0.0.0.0:30000
30000/udp -> [::]:30000
```

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

- **المنفذ UDP 30000:** مثل سيرفرنا، ولذلك نشرناه بـ `/udp`. والـ Dockerfile الرسمي يعلن أيضاً `30000/tcp`، وهو لمقاييس Prometheus، ولذلك ينشره توثيق المشروع على `127.0.0.1` فقط، لأن المقاييس لا يجب أن تكون مفتوحة للإنترنت.
- **العالم في `/var/lib/minetest`:** وهو داخل الـ Volume، ومثله الإعداد في `/etc/minetest`، والـ Image تعمل بمستخدم `minetest` برقم 30000 لا بـ root، وهذه القرارات نفسها التي اتخذناها لسيرفرنا.

### الأرقام والإيقاف والنسخة الاحتياطية

والسيرفر دون لاعبين أخذ في المتوسط 0.77% من نواة و18.86 ميجابايت في ثماني قراءات، وملفات العالم بعد التشغيل الأول كانت كما يلي:

```text
-rw-r--r--    1 minetest minetest       525 Nov 18 14:23 env_meta.txt
-rw-r--r--    1 minetest minetest     12288 Nov 18 14:22 map.sqlite
-rw-r--r--    1 minetest minetest      3666 Nov 18 14:22 map_meta.txt
-rw-r--r--    1 minetest minetest     12288 Nov 18 14:22 mod_storage.sqlite
-rw-r--r--    1 minetest minetest       176 Nov 18 14:22 world.mt
```

والعالم كله، الخريطة والحسابات واللاعبين، في قواعد بيانات SQLite بحسب الملف `world.mt`، ولذلك لا ننسخه وهو يعمل كما ذكرنا. ثم أوقفناه بـ `docker stop`:

```text
luanti stop took 1672 ms, exit 0
INFO: signal_handler(): got SIGTERM, shutting down.
2026-11-18 14:23:27: ACTION[Main]: Server: Shutting down
```

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

```bash
docker run --rm -v gm3-sv-luanti-data:/data:ro -v "$PWD/backup:/backup" debian:bookworm-slim \
  sh -c 'tar czf /backup/luanti-world-2026-11-18.tar.gz -C /data .minetest/worlds/world'
```

والجدول التالي يجمع الفرق بين السيرفرين كما قسناهما:

| السؤال           | سيرفرنا من Godot                           | Luanti 5.18.0                     |
| ---------------- | ------------------------------------------ | --------------------------------- |
| من أين البرنامج؟ | قالب التصدير، نستخرجه من ملف 1.28 جيجابايت | Image رسمية جاهزة                 |
| المنفذ           | UDP 7777                                   | UDP 30000، وTCP 30000 للمقاييس    |
| دون لاعبين       | 3.9% من نواة، 27 ميجابايت                  | 0.77% من نواة، 18.9 ميجابايت      |
| SIGTERM          | يموت دون حفظ، ونحتاج سكربتاً أمامه         | يحفظ ويخرج بالرمز 0 في 1.7 ثانية  |
| السجلات          | تحتاج flush\_stdout\_on\_print             | تظهر مباشرة                       |
| حالة العالم      | ملف JSON بحفظ ذري                          | قواعد SQLite، تنسخ والسيرفر متوقف |

ولاحظ أن السيرفر الفارغ في Luanti يأخذ خمس ما يأخذه سيرفرنا من المعالج، لأن حلقته لا تحتاج أن ترسل 20 صورة حالة في الثانية لأحد، وهذا تذكير بأن الأرقام تخص كل لعبة وحدها.

## أين تستضيف السيرفر؟

بعد القياس يصبح السؤال عملياً: أين تضع هذه الـ Image؟ والخيارات الثلاثة الشائعة كما يلي:

- **VPS صغير:** أرخص بداية، ويكفي لمباريات قليلة أو عالم مستمر لمجتمع صغير. ولكن انتبه لأمرين في سيرفرات الألعاب بالذات: المعالج المشترك Shared vCPU قد يتأخر فجأة عندما يضغط جيرانك على الجهاز نفسه، وسيرفر اللعبة يشعر بالتأخر المفاجئ أكثر من موقع الويب، والـ Traffic الشهري قد ينتهي قبل المعالج كما رأينا في القياس.
- **سيرفر مخصص Dedicated Server بمعناه الآخر:** جهاز كامل لك، وهو الخيار عندما تشغل عشرات المباريات في وقت واحد، أو تريد أنوية لا يشاركك فيها أحد.
- **خدمة سحابية بمناطق قريبة من اللاعبين:** زمن الوصول من اللاعب إلى السيرفر جزء من اللعبة نفسها، فالسيرفر في قارة أخرى يضيف عشرات المللي ثانية لا يصلحها أي كود، كما رأينا بالأرقام في [مقال زمن الاستجابة](https://arabroot.io/articles/%D8%B2%D9%85%D9%86-%D8%A7%D9%84%D8%A7%D8%B3%D8%AA%D8%AC%D8%A7%D8%A8%D8%A9-latency-%D9%88%D8%A7%D9%84%D8%A7%D9%86%D8%AA%D8%A7%D8%AC%D9%8A%D8%A9-throughput-%D8%A8%D8%A7%D9%84%D8%A7%D8%B1%D9%82%D8%A7%D9%85/). فضع السيرفر حيث يوجد أغلب لاعبيك.

وأياً كان الخيار، فالخطوات الأولى نفسها: أمن السيرفر من أول دخول كما في [مقال تأمين VPS](https://arabroot.io/articles/%D8%AA%D8%A3%D9%85%D9%8A%D9%86-%D8%AE%D8%A7%D8%AF%D9%85-vps-%D9%85%D9%86-%D8%A3%D9%88%D9%84-%D8%AF%D8%AE%D9%88%D9%84/)، وافتح في الجدار الناري منفذ UDP الذي تحتاجه فقط. وانتبه إلى أن Docker يكتب قواعد الجدار الناري بنفسه عندما تنشر منفذاً، فقد تفتح المنفذ للإنترنت دون أن تمر بـ UFW، وقد شرحنا ذلك في [مقال شبكات Docker](https://arabroot.io/articles/%D8%B4%D8%A8%D9%83%D8%A7%D8%AA-docker-%D9%88%D8%A3%D9%81%D8%B6%D9%84-%D8%A7%D9%84%D9%85%D9%85%D8%A7%D8%B1%D8%B3%D8%A7%D8%AA/). وسيرفرات الألعاب من أكثر الأهداف التي تتعرض لهجمات حجب الخدمة DDoS، لأن لاعباً خاسراً يستطيع أن يستأجر هجوماً بمبلغ صغير، فاقرأ [مقال طبقات الحماية من DDoS](https://arabroot.io/articles/%D8%B7%D8%A8%D9%82%D8%A7%D8%AA-%D8%A7%D9%84%D8%AD%D9%85%D8%A7%D9%8A%D8%A9-%D9%85%D9%86-%D9%87%D8%AC%D9%85%D8%A7%D8%AA-ddos/) قبل أن تعلن عنوان سيرفرك.

## متى تحتاج Agones وKubernetes؟

عندما تصبح المباريات مئات في الساعة، يصبح عمل «شغل سيرفراً جديداً، وأعط اللاعبين عنوانه، ولا تطفئه وفيه لاعبون» عملاً لا يستطيع إنسان أن يقوم به. و[Agones](https://agones.dev/site/docs/overview/?ref=arabroot.io) مشروع مفتوح المصدر يضيف هذا العمل إلى Kubernetes، ويعرف كما يقول توثيقه بأنه مكتبة لاستضافة وتشغيل وتوسيع سيرفرات الألعاب المخصصة فوق Kubernetes. وفكرته الأساسية أن سيرفر اللعبة ليس مثل تطبيق الويب: لا يجوز أن تطفئ أي نسخة منه في أي وقت، لأن فيها لاعبين. والشكل التالي يبين المفاهيم الأساسية:

![رسم لمفاهيم Agones. في الأعلى Fleet فيه عدد من GameServers، كل منها Pod فيه سيرفر اللعبة وبجانبه SDK sidecar. وحالات GameServer بالترتيب: Scheduled ثم RequestReady ثم Ready ثم Allocated ثم Shutdown، وفرع جانبي إلى Unhealthy عندما يتوقف استدعاء Health. ونظام البحث عن مباراة يرسل GameServerAllocation فيختار سيرفراً Ready ويحوله إلى Allocated ويعيد عنوانه ومنفذه، ومنفذ Dynamic من المدى 7000 إلى 8000. وملاحظة أن التحديث المتدرج RollingUpdate لا يطفئ أي سيرفر Allocated](https://arabroot.io/content/images/2026/11/game-servers-06-agones.webp)

Agones: سيرفرات جاهزة في Fleet، وحجز واحد منها لكل مباراة، ولا يطفأ سيرفر فيه لاعبون

- [**GameServer**](https://agones.dev/site/docs/reference/gameserver/?ref=arabroot.io)**:** سيرفر لعبة واحد، أي Pod فيه Container لعبتك. ويحدد له المنفذ بسياسة Dynamic افتراضياً، أي يختار Agones منفذاً حراً على الجهاز ويخبر به من يطلب السيرفر، لأن عشرات السيرفرات على جهاز واحد لا تستطيع كلها أن تأخذ 7777.
- [**Fleet**](https://agones.dev/site/docs/reference/fleet/?ref=arabroot.io)**:** مجموعة من GameServers متشابهة جاهزة للعب، مثل Deployment في Kubernetes ولكنها تعرف أن بعض أعضائها مشغول.
- [**GameServerAllocation**](https://agones.dev/site/docs/reference/gameserverallocation/?ref=arabroot.io)**:** الطلب الذي يرسله نظام البحث عن مباراة: «أعطني سيرفراً جاهزاً». فيختار Agones سيرفراً حالته Ready ويحوله إلى Allocated، ويعيد عنوانه ومنفذه. والسيرفر Allocated بحسب التوثيق لا يحذف حتى يستدعي السيرفر نفسه `Shutdown()` أو يحذفه أحد بيده.
- [**الـ SDK**](https://agones.dev/site/docs/guides/client-sdks/?ref=arabroot.io)**:** مكتبة صغيرة في كود السيرفر تتحدث مع برنامج بجانبه في الـ Pod، ودوالها الأساسية `Ready()` عندما يصبح السيرفر جاهزاً لاستقبال لاعبين، و`Health()` بشكل دوري كما رأينا، و`Shutdown()` عندما تنتهي المباراة. ولا يوجد SDK رسمي لـ Godot في قائمة التوثيق، ولكن يوجد SDK بواجهة REST تستطيع أن تستدعيها بـ `HTTPRequest`.
- [**تحديث Fleet**](https://agones.dev/site/docs/guides/fleet-updates/?ref=arabroot.io)**:** باستراتيجية RollingUpdate يضيف سيرفرات جديدة ويطفئ القديمة، متجاوزاً أي سيرفر Allocated، أي أن التفريغ الذي بنيناه بسكربت وملف يصبح جزءاً من المنصة.

فهل تحتاج ذلك؟ غالباً لا في البداية. فإذا كان عندك عالم مستمر واحد، أو بضع مباريات ثابتة، فسيرفر واحد مع Docker Compose وسكربت التفريغ والنسخ الاحتياطي يكفيك، وKubernetes يضيف عملاً كبيراً قبل أن يضيف فائدة، وقد ناقشنا هذا السؤال كاملاً في [مقال هل تحتاج Kubernetes فعلاً](https://arabroot.io/articles/%D9%87%D9%84-%D8%AA%D8%AD%D8%AA%D8%A7%D8%AC-kubernetes-%D9%81%D8%B9%D9%84%D8%A7/). وتبدأ Agones تستحق عملها عندما تحتاج أن تشغل وتطفئ سيرفرات المباريات تلقائياً بحسب عدد اللاعبين، على أكثر من جهاز، دون أن تقطع مباراة واحدة.

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

المختبر في مجلد `lab`: المشروع في `game`، وهو مشروع مقال اللعب الجماعي مع الإضافات التي في هذا المقال، أي الميزة `dedicated_server` والحفظ وطلب الإيقاف والتفريغ ونبض الصحة، و`export_presets.cfg` و`flush_stdout_on_print`. وفي `build` الـ `Dockerfile` و`entrypoint.sh`، وفي المجلد الرئيسي السكربتات:

- **`get-template.py`:** يستخرج قالب التصدير من ملف القوالب بطلبات Range، ويضعه في `tpl`، ثم تنسخه إلى `build/game`.
- **`export.sh`:** يصدر `game.pck` بالمحرر في Container، ثم يبني الـ Image بالوسم الذي تمرره، مثل `bash export.sh 1.1.0`.
- **`drain.sh`:** يشغل السيرفر وبوتاً، ثم يرسل `docker stop` في منتصف المباراة، ومع الخيار `late` يرسل بوتاً ثانياً أثناء التفريغ.
- **`load.sh`:** يشغل السيرفر وعدداً من البوتات تمرره، ويقيس بـ `docker stats`، ويطبع سطر الملخص، مثل `bash load.sh 16`.

والبوتات تحتاج Image المحرر `gm3-godot:4.7.2` من مقالات المرحلة، والسكربتات مكتوبة لـ Git Bash على Windows مع Docker Desktop، ولذلك فيها `MSYS_NO_PATHCONV=1` و`pwd -W`، وعلى Linux تحذفهما وتستخدم `$PWD`.

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

- **الاتصال يفشل بعد نصف دقيقة دون أي رسالة في السيرفر:** المنفذ منشور TCP لا UDP، أو الجدار الناري يفتحه لـ TCP فقط. افحص `docker port` و`ss -ulpn` قبل أي شيء.
- **`docker logs` فارغ والسيرفر يعمل:** نسخة Release تحتفظ بالمخرج في Buffer. فعل `application/run/flush_stdout_on_print`.
- **`--main-pack` يفشل في الإنتاج:** قوالب الإصدار الرسمية لا تقبل تغيير المسار. سم البرنامج باسم الحزمة وضعهما في مجلد واحد.
- **`docker stop` ينتظر ثم رمز الخروج 137:** البرنامج هو العملية رقم 1 ولا يعالج SIGTERM، فقتله Docker. ومع `--init` يموت فوراً بالرمز 143 دون حفظ أيضاً. ضع أمامه سكربتاً يحول الإشارة إلى طلب حفظ.
- **مهلة الإيقاف أقصر من المباراة:** التفريغ لا قيمة له إذا قتل Docker السيرفر بعد ثوان، والمهلة الافتراضية عندنا كانت أربع ثوان لا عشراً. اجعل `--stop-timeout` أو `stop_grace_period` أطول من أطول مباراة.
- **الانهيار يضيع دقائق من اللعب:** لا يوجد حفظ دوري، أو الحفظ يكتب فوق الملف مباشرة. احفظ كل فترة تقبل خسارتها، واكتب في ملف مؤقت ثم أعد تسميته.
- **السيرفر لا يحفظ بعد الاستعادة:** الملفات المستعادة يملكها root والسيرفر يعمل بمستخدم آخر. صحح المالك بـ `chown` بعد الاستعادة.
- **لاعبون متصلون ولا يتحرك شيء بعد تحديث:** الكلاينت والسيرفر بنسختين مختلفتين من دوال RPC، والرسالة الوحيدة `rpc node checksum failed` في السجلات. ضع رقم بروتوكول في أول رسالة وارفض المختلف برسالة واضحة.
- **اختبار الضغط يقول إن السيرفر ضعيف:** البوتات على الجهاز نفسه تأخذ المعالج منه، و64 بوتاً عندنا أخذت خمس أنوية. شغل البوتات من جهاز آخر.
- **الفحص يقول إن السيرفر سليم واللعبة متوقفة:** الفحص يسأل عن وجود العملية لا عن دوران الحلقة. اجعل الدليل من داخل الحلقة.

## قائمة فحص Checklist قبل أن تفتح السيرفر للاعبين

| البند                                              | كيف تتأكد                                            | ماذا رأينا في المختبر                   |
| -------------------------------------------------- | ---------------------------------------------------- | --------------------------------------- |
| البرنامج قالب تصدير، والحزمة بنمط Dedicated Server | سطر البداية: dedicated\_server=true وexport template | 73.5 ميجابايت بدل 146 للمحرر            |
| السجلات تظهر فوراً                                 | docker logs بعد ثوان من التشغيل                      | فارغ حتى فعلنا flush\_stdout\_on\_print |
| المنفذ UDP منشور ومفتوح                            | docker port يقول /udp، واتصال من خارج الجهاز         | دون /udp فشل الاتصال بعد 31.54 ثانية    |
| مستخدم عادي لا root                                | USER في الـ Dockerfile                               | gameserver برقم 1000                    |
| الإيقاف يحفظ                                       | docker stop ثم رمز الخروج 0 وسطر الحفظ               | 137 دون سكربت، و0 مع السكربت            |
| مهلة الإيقاف تكفي المباراة                         | المهلة أطول من أطول مباراة                           | تفريغ 40 ثانية مع \-t 90                |
| حفظ دوري ذري                                       | شغل ثم اقتل بـ docker kill وانظر ماذا بقي            | ضاعت 3 ثوان فقط عند الانهيار            |
| نسخة احتياطية مستعادة                              | استعد في Volume جديد وشغل عليه                       | عاد العالم بالأرقام نفسها               |
| فحص صحة من داخل الحلقة                             | عطل الحلقة عمداً وانتظر unhealthy                    | أصبح unhealthy بعد ثلاثة فحوص           |
| رقم بروتوكول وأوسمة إصدار                          | كلاينت قديم مع سيرفر جديد                            | دون رقم: اتصال لا يتحرك فيه شيء         |
| الشبكة تكفي                                        | اختبار ضغط بعدد لاعبي المباراة                       | 64 لاعباً: 3.36 ميجابايت في الثانية     |

## تطبيق عملي Practice

1. أضف إلى `load.sh` قراءة حالة الصحة من `docker inspect`، وشغل 64 بوتاً، وانظر هل يبقى السيرفر `healthy` طوال الوقت.
2. غير `--autosave` إلى 5 ثوان، ثم اقتل السيرفر بـ `docker kill` في منتصف مباراة، واحسب من `world.json` كم مدخلاً ضاع، وقارن ذلك بالحفظ كل 30 ثانية.
3. أضف رقم بروتوكول إلى أول رسالة من الكلاينت، واجعل السيرفر يقطع الاتصال إذا اختلف، ثم كرر تجربة الكلاينت 1.0.0 مع السيرفر 2.0.0، واكتب ما يراه الكلاينت.
4. اكتب ملف Compose يشغل سيرفرين على المنفذين 7777 و7778 بوسمين مختلفين، مع `stop_grace_period` مناسب، وجرب التحديث المتدرج بيدك.
5. شغل سيرفر Luanti مع Minetest Game واتصل به من برنامج Luanti على جهازك، ثم أوقفه وانسخ العالم واستعده في Volume جديد.

## حذف المختبر Cleanup

```bash
docker rm -f gm3-sv-game gm3-sv-load gm3-sv-lt 2>/dev/null
docker volume rm gm3-sv-world gm3-sv-world-restored gm3-sv-luanti-data
docker network rm gm3-sv-net
docker image rm gm3-sv-game:1.0.0 gm3-sv-game:1.0.1 gm3-sv-game:1.1.0 gm3-sv-luanti:5.18.0
rm -rf build/game build/game.pck tpl backup out game/.godot game-v2/.godot
```

## الخلاصة Summary

- السيرفر المخصص برنامج اللعبة دون شاشة على جهاز لا يلعب عليه أحد، وحلقته تدور دائماً، وحالته في الذاكرة، ويتحدث UDP، وكل قرار في هذا المقال يخرج من هذه الأربعة.
- استخدم قالب التصدير لا المحرر، 73.5 ميجابايت بدل 146، مع حزمة بنمط Dedicated Server. والحزمة وحدها لا تحتاج القوالب، وقوالب الإصدار لا تقبل `--main-pack`.
- فعل `flush_stdout_on_print` وإلا بقيت `docker logs` فارغة، وانشر المنفذ بـ `/udp` وإلا فشل الاتصال بعد 31 ثانية دون أي رسالة.
- مع 64 لاعباً أخذ السيرفر 17.7% من نواة و29 ميجابايت، وأرسل 3.36 ميجابايت في الثانية، والشبكة تتضاعف أربع مرات كلما تضاعف اللاعبون، فهي أول ما ينتهي.
- Godot 4.7.2 لا يعالج SIGTERM: دون سكربت قتله Docker بعد انتهاء المهلة بالرمز 137، ومع `--init` مات فوراً بالرمز 143، وفي الحالتين دون حفظ. ومع سكربت يحول الإشارة إلى ملف، فرغ السيرفر مباراته في 40 ثانية وحفظ وخرج بالرمز 0.
- قالب الإصدار انهار بـ Bus error عندما اتصل لاعب والخاصية `refuse_new_connections` مفعلة، فاستبدلناها بقطع الاتصال، واختبر دائماً بالبرنامج الذي تشغله في الإنتاج.
- احفظ دورياً بكتابة ذرية، وخذ النسخة الاحتياطية من الـ Volume واستعدها مرة على الأقل، ولا تنسخ قاعدة SQLite وهي تكتب.
- ضع رقم بروتوكول في أول رسالة، فإضافة دالة RPC واحدة جعلت الكلاينت القديم متصلاً لا يصله شيء.
- Agones تضيف إلى Kubernetes حالات Ready وAllocated وتحديثاً لا يطفئ سيرفراً فيه لاعبون، ولا تحتاجها قبل أن تشغل وتطفئ مئات المباريات تلقائياً.

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

[![](https://arabroot.io/content/images/2026/11/multiplayer-networking-cover-cover.webp)دليلاللعب الجماعي Multiplayer: السيرفر صاحب القرار والتأخيرنبني في Godot 4 سيرفراً مخصصاً صاحب قرار وكلاينتات آلية، ثم نضيف التأخير والارتعاش والفقدان ونقيس كيف يخفي التنبؤ والمطابقة والاستيفاء أثرها عن اللاعب.](https://arabroot.io/articles/%D8%A7%D9%84%D9%84%D8%B9%D8%A8-%D8%A7%D9%84%D8%AC%D9%85%D8%A7%D8%B9%D9%8A-multiplayer-%D8%A7%D9%84%D8%B3%D9%8A%D8%B1%D9%81%D8%B1-%D8%B5%D8%A7%D8%AD%D8%A8-%D8%A7%D9%84%D9%82%D8%B1%D8%A7%D8%B1-%D9%88%D8%A7%D9%84%D8%AA%D8%A7%D8%AE%D9%8A%D8%B1/)[![](https://arabroot.io/content/images/2026/11/game-backend-nakama-cover-cover.webp)دليلخلفية الألعاب Game Backend: الحسابات والمتصدرون مع Nakamaنشغل Nakama مع PostgreSQL في Docker ونبني له حسابات وحفظاً ومتصدرين أسبوعيين وجولة يحسب فيها السيرفر الدرجة بنفسه، ثم نقيس كم يستهلك مع 400 لاعب من Godot وماذا يحدث إذا توقفت قاعدة البيانات.](https://arabroot.io/articles/%D8%AE%D9%84%D9%81%D9%8A%D8%A9-%D8%A7%D9%84%D8%A7%D9%84%D8%B9%D8%A7%D8%A8-game-backend-%D8%A7%D9%84%D8%AD%D8%B3%D8%A7%D8%A8%D8%A7%D8%AA-%D9%88%D8%A7%D9%84%D9%85%D8%AA%D8%B5%D8%AF%D8%B1%D9%88%D9%86-%D9%85%D8%B9-nakama/)[![](https://arabroot.io/content/images/2026/11/anti-cheat-basics-cover-cover.webp)دليلمكافحة الغش Anti-Cheat في الألعاب: ما يمكن وما لا يمكننكتب كلاينتات تغش في لعبتنا الجماعية بأبسط الطرق، ونوقف كل غش منها بفحص على السيرفر ونقيس أثره على اللاعب الأمين، ثم نشرح ما لا يراه السيرفر وثمن مكافحة الغش في النواة.](https://arabroot.io/articles/%D9%85%D9%83%D8%A7%D9%81%D8%AD%D8%A9-%D8%A7%D9%84%D8%BA%D8%B4-anti-cheat-%D9%81%D9%8A-%D8%A7%D9%84%D8%A7%D9%84%D8%B9%D8%A7%D8%A8-%D9%85%D8%A7-%D9%8A%D9%85%D9%83%D9%86-%D9%88%D9%85%D8%A7-%D9%84%D8%A7-%D9%8A%D9%85%D9%83%D9%86/)[![](https://arabroot.io/content/images/2026/11/game-export-web-cover-cover.webp)دليلتصدير اللعبة من Godot إلى الويب والجوال وسطح المكتبماذا يحدث فعلاً عند تصدير لعبة Godot، ولماذا تحتاج نسخة الويب Headers خاصة أحياناً، وما تطلبه كل منصة ومتجر، مع مختبر يصدر لعبة واحدة إلى خمس منصات.](https://arabroot.io/articles/%D8%AA%D8%B5%D8%AF%D9%8A%D8%B1-%D8%A7%D9%84%D9%84%D8%B9%D8%A8%D8%A9-%D9%85%D9%86-godot-%D8%A7%D9%84%D9%89-%D8%A7%D9%84%D9%88%D9%8A%D8%A8-%D9%88%D8%A7%D9%84%D8%AC%D9%88%D8%A7%D9%84-%D9%88%D8%B3%D8%B7%D8%AD-%D8%A7%D9%84%D9%85%D9%83%D8%AA%D8%A8/)[![](https://arabroot.io/content/images/2026/11/game-loop-cover-cover.webp)دليلكيف تعمل اللعبة من الداخل؟ حلقة اللعبة Game Loopلماذا تتحرك الشخصية بالسرعة نفسها على شاشة 144 هرتز وحاسوب بطيء: نبني حلقة اللعبة من الصفر حتى الخطوة الثابتة والاستيفاء، ونقيس كل طريقة في مختبر.](https://arabroot.io/articles/%D8%AD%D9%84%D9%82%D8%A9-%D8%A7%D9%84%D9%84%D8%B9%D8%A8%D8%A9-game-loop-%D9%88%D8%A7%D9%84%D8%A7%D8%B7%D8%A7%D8%B1%D8%A7%D8%AA-frames/)

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

- 18 نوفمبر 2026: كتابة المقال، وتصدير سيرفر المختبر بقالب Godot 4.7.2 وتغليفه في Docker، وقياس 0 إلى 64 لاعباً آلياً، وتجارب الإيقاف والتفريغ والحفظ والاستعادة واختلاف النسخ وفحص الصحة، وتشغيل Luanti 5.18.0 مع Minetest Game للمقارنة.