القائمة الرئيسية

الصفحات

دليل شامل عن بناء لعبة موبايل من الصفر باستخدام LibGDX

best guide to build android game in LibGDX، guide to building a game from scratch using LibGDX، best guide to build scratch mobile game in LibGDX، LibGDX game، Mobile game Java، Android game development، LibGDX tutorial، Build Android game، Game development framework، 2D game Java، How to create a mobile game with LibGDX from scratch، Step-by-step LibGDX game development tutorial for beginners، Building a simple 2D game on Android using LibGDX، LibGDX game loop and rendering explained، Handling user input in LibGDX mobile games، Managing game assets in LibGDX using AssetManager، Structuring game logic in a LibGDX project، Using SpriteBatch for efficient 2D rendering in LibGDX، Packaging and deploying a LibGDX game to Android، Best practices for LibGDX mobile game development، كيفية إنشاء لعبة جوال باستخدام LibGDX من الصفر، دليل تطوير ألعاب LibGDX خطوة بخطوة للمبتدئين، بناء لعبة ثنائية الأبعاد بسيطة على أندرويد باستخدام LibGDX، شرح حلقة اللعبة والعرض باستخدام LibGDX، التعامل مع مدخلات المستخدم في ألعاب LibGDX للجوال، إدارة أصول اللعبة في LibGDX باستخدام AssetManager، هيكلة منطق اللعبة في مشروع LibGDX، استخدام SpriteBatch لعرض ثنائي الأبعاد بكفاءة في LibGDX، تغليف ونشر لعبة LibGDX على أندرويد، أفضل الممارسات لتطوير ألعاب LibGDX للجوال، دليل شامل عن بناء لعبة موبايل من الصفر باستخدام LibGDX، تطوير ألعاب LibGDX،  Mobile game Java، LibGDX tutorial، 2D game Java،  بناء لعبة موبايل من الصفر باستخدام LibGDX، بناء لعبة موبايل من الصفر، استخدام LibGDX،




دليل شامل عن بناء لعبة موبايل من الصفر باستخدام LibGDX


LibGDX هو إطار عمل (Framework) قوي ومتعدد المنصات
 لتطوير الألعاب بلغة Java. يوفر مجموعة واسعة من الأدوات والمكتبات
 لإنشاء ألعاب ثنائية وثلاثية الأبعاد تعمل على مختلف الأنظمة الأساسية، بما في
 ذلك Android و iOS. يتطلب بناء لعبة من الصفر باستخدام LibGDX فهمًا 
لأساسيات برمجة الألعاب وهيكل الإطار نفسه. يهدف هذا الدليل الشامل إلى تزويدك
 بالخطوات والمفاهيم الأساسية لبدء بناء لعبة موبايل بسيطة باستخدام LibGDX.

خطوات بناء لعبة من الصفر باستخدام LibGDX



هذا هو ملف اللعبة الرئيسي الخاص بك، والذي سيعمل على جميع المنصات (Android, Desktop, iOS).
 عادة ما يكون في مجلد 'core/src/com/yourcompany/yourgame/'






package com.yourcompany.myfirstgame; // تأكد من تحديث اسم الحزمة (package) 

import com.badlogic.gdx.ApplicationAdapter; // الفئة الأساسية لتطبيق LibGDX
import com.badlogic.gdx.Gdx; // يوفر الوصول إلى وظائف النظام الأساسية (الرسومات، المدخلات، الصوت)
import com.badlogic.gdx.graphics.GL20; // واجهة OpenGL ES 2.0 للرسومات
import com.badlogic.gdx.graphics.Texture; // لتمثيل الصور
import com.badlogic.gdx.graphics.g2d.SpriteBatch; // لرسم الصور (Sprites) بكفاءة
import com.badlogic.gdx.InputProcessor; // واجهة للتعامل مع مدخلات المستخدم (اللمس، لوحة المفاتيح)

// فئة اللعبة الرئيسية التي ترث من ApplicationAdapter
public class MyFirstGame extends ApplicationAdapter implements InputProcessor {

    // SpriteBatch هو كائن يستخدم لرسم الصور (Sprites).
    // من الأفضل أن يكون لديك كائن SpriteBatch واحد فقط في لعبتك.
    SpriteBatch batch;

    // Texture هو كائن يمثل صورة تم تحميلها في ذاكرة وحدة معالجة الرسومات (GPU).
    // سنستخدمها لرسم صورة بسيطة على الشاشة.
    Texture img;

    // متغير لتتبع موضع الصورة
    float x, y;

    // ------------
    // دالة create(): يتم استدعاؤها مرة واحدة عند بدء تشغيل التطبيق.
    // هنا نقوم بتهيئة موارد اللعبة وتحميل الأصول.
    // ------------
    @Override
    public void create () {
        // تهيئة SpriteBatch
        batch = new SpriteBatch();

        // تحميل الصورة من مجلد assets/.
        // تأكد من وجود ملف "badlogic.jpg" في مجلد "core/assets/".
        // يمكنك استبداله بأي صورة أخرى (مثل "my_player.png").
        img = new Texture("badlogic.jpg");

        // تعيين الموضع الأولي للصورة في منتصف الشاشة تقريبًا
        x = Gdx.graphics.getWidth() / 2f - img.getWidth() / 2f; // منتصف العرض
        y = Gdx.graphics.getHeight() / 2f - img.getHeight() / 2f; // منتصف الارتفاع

        // تعيين هذه الفئة (MyFirstGame) كمعالج للمدخلات.
        // هذا يسمح لنا بتلقي أحداث اللمس والنقر.
        Gdx.input.setInputProcessor(this);

        Gdx.app.log("MyFirstGame", "اللعبة بدأت! تم تهيئة الموارد.");
    }

    // ------------
    // دالة render(): يتم استدعاؤها بشكل متكرر في كل إطار (Frame).
    // هنا نقوم بتحديث منطق اللعبة ورسم العناصر على الشاشة.
    // ------------
    @Override
    public void render () {
        // 1. تحديث منطق اللعبة (Game Logic Update)
        // في هذه اللعبة البسيطة، لا يوجد منطق تحديث معقد.
        // يمكن أن يكون هنا تحديث لموضع اللاعب، حركة الأعداء، الكشف عن التصادمات، إلخ.
        // Gdx.graphics.getDeltaTime() يعطي الوقت المنقضي منذ الإطار الأخير، مفيد للحركة المستقلة عن الإطارات.

        // 2. مسح الشاشة (Clear the Screen)
        // يمسح الشاشة بلون معين (هنا، لون أزرق داكن).
        // GL20.GL_COLOR_BUFFER_BIT يحدد أننا نمسح مخزن الألوان.
        Gdx.gl.glClearColor(0.2f, 0.2f, 0.3f, 1); // R, G, B, Alpha (0.0-1.0)
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

        // 3. بدء الرسم (Begin Drawing)
        // يجب أن تبدأ SpriteBatch قبل أي عمليات رسم.
        batch.begin();

        // 4. رسم الصورة (Draw the Image)
        // نرسم الصورة (img) في الموضع (x, y).
        batch.draw(img, x, y);

        // 5. إنهاء الرسم (End Drawing)
        // يجب أن تنهي SpriteBatch بعد الانتهاء من جميع عمليات الرسم.
        batch.end();
    }

    // ------------
    // دالة dispose(): يتم استدعاؤها مرة واحدة عند إغلاق التطبيق.
    // هنا نقوم بتحرير الموارد التي تم تحميلها لمنع تسرب الذاكرة.
    // ------------
    @Override
    public void dispose () {
        // تحرير موارد SpriteBatch
        batch.dispose();
        // تحرير موارد Texture (الصورة)
        img.dispose();
        Gdx.app.log("MyFirstGame", "اللعبة أغلقت! تم تحرير الموارد.");
    }

    // ------------
    // دوال InputProcessor: للتعامل مع مدخلات المستخدم.
    // ------------

    // يتم استدعاؤها عند لمس الشاشة أو النقر بزر الفأرة.
    @Override
    public boolean touchDown (int screenX, int screenY, int pointer, int button) {
        Gdx.app.log("Input", "تم لمس الشاشة عند: (" + screenX + ", " + screenY + ")");
        // يمكنك هنا إضافة منطق لتغيير موضع الصورة أو إطلاق حدث ما
        x = screenX - img.getWidth() / 2f;
        y = Gdx.graphics.getHeight() - screenY - img.getHeight() / 2f; // تحويل الإحداثيات (LibGDX يستخدم الأصل في الأسفل)
        return true; // يشير إلى أن الحدث قد تم التعامل معه
    }

    // يتم استدعاؤها عند سحب الإصبع على الشاشة أو سحب الفأرة.
    @Override
    public boolean touchDragged (int screenX, int screenY, int pointer) {
        Gdx.app.log("Input", "تم سحب اللمس إلى: (" + screenX + ", " + screenY + ")");
        x = screenX - img.getWidth() / 2f;
        y = Gdx.graphics.getHeight() - screenY - img.getHeight() / 2f;
        return true;
    }

    // يتم استدعاؤها عند رفع الإصبع من الشاشة أو رفع زر الفأرة.
    @Override
    public boolean touchUp (int screenX, int screenY, int pointer, int button) {
        Gdx.app.log("Input", "تم رفع اللمس من: (" + screenX + ", " + screenY + ")");
        return true;
    }

    // يتم استدعاؤها عند الضغط على زر في لوحة المفاتيح.
    @Override
    public boolean keyDown (int keycode) {
        Gdx.app.log("Input", "تم الضغط على زر لوحة المفاتيح: " + keycode);
        return true;
    }

    // يتم استدعاؤها عند رفع زر من لوحة المفاتيح.
    @Override
    public boolean keyUp (int keycode) {
        return false;
    }

    // يتم استدعاؤها عند كتابة حرف (مثل عند استخدام لوحة المفاتيح الافتراضية).
    @Override
    public boolean keyTyped (char character) {
        return false;
    }

    // يتم استدعاؤها عند تحريك الفأرة (لا ينطبق على اللمس).
    @Override
    public boolean mouseMoved (int screenX, int screenY) {
        return false;
    }

    // يتم استدعاؤها عند التمرير بعجلة الفأرة.
    @Override
    public boolean scrolled (float amountX, float amountY) {
        return false;
    }

    // ------------
    // دوال دورة حياة التطبيق الإضافية (مفيدة للأجهزة المحمولة)
    // -----------

    // يتم استدعاؤها عند تغيير حجم الشاشة.
    @Override
    public void resize(int width, int height) {
        Gdx.app.log("MyFirstGame", "تم تغيير حجم الشاشة إلى: " + width + "x" + height);
        // يمكنك هنا تحديث الكاميرا أو viewports لضمان أن اللعبة تتكيف مع الحجم الجديد.
    }

    // يتم استدعاؤها عندما يتم إيقاف اللعبة مؤقتًا (مثلاً عند تلقي مكالمة هاتفية).
    @Override
    public void pause() {
        Gdx.app.log("MyFirstGame", "اللعبة في وضع الإيقاف المؤقت.");
    }

    // يتم استدعاؤها عندما يتم استئناف اللعبة من وضع الإيقاف المؤقت.
    @Override
    public void resume() {
        Gdx.app.log("MyFirstGame", "اللعبة استؤنفت.");
    }
}



--



الخطوة 1: إعداد بيئة التطوير
- تثبيت Java Development Kit (JDK) : LibGDX مبني
 بلغة Java، لذا فإن تثبيت JDK هو الخطوة الأولى.
- تثبيت Android Studio (لتطوير Android): على الرغم من أن
 LibGDX متعدد المنصات، ستحتاج إلى Android Studio لتطوير واختبار
 لعبتك على أجهزة Android. يتضمن Android SDK وأدوات البناء اللازمة.
- تثبيت Gradle: يستخدم LibGDX Gradle كنظام بناء. غالبًا ما يتم تثبيته تلقائيًا مع
 Android Studio، ولكن تأكد من وجوده وتكوينه بشكل صحيح.
- إنشاء مشروع LibGDX: يوفر LibGDX أداة إعداد بسيطة لإنشاء هيكل المشروع
 الأساسي. يمكنك تنزيلها من الموقع الرسمي وتشغيلها لحديد اسم اللعبة،
 الحزم، والمكونات الإضافية التي تريد تضمينها.




الخطوة 2: فهم هيكل مشروع LibGDX
- android/: يحتوي على الكود الخاص بمنصة Android (Activity، Launcher).
- ios/: يحتوي على الكود الخاص بمنصة iOS (Launcher).
- desktop/: يحتوي على الكود لتشغيل اللعبة على سطح المكتب (Launcher).
- core/: هذا هو الجزء الرئيسي من مشروعك. يحتوي على الكود المشترك
 للعبة الذي يعمل على جميع المنصات. 
هنا ستجد :
-YourGame.java (أو اسم المشروع الذي اخترته): نقطة دخول اللعبة.
يحتوي على دورة حياة اللعبة (create(), render(), dispose()).
- assets/: مجلد لتخزين جميع أصول اللعبة (الصور، الأصوات، الخطوط، الخرائط).

الخطوة 3: إنشاء نقطة دخول اللعبة (YourGame.java)
- create(): يتم استدعاؤها مرة واحدة عند بدء تشغيل اللعبة.
 هنا تقوم بتحميل الأصول وتهيئة المتغيرات والكائنات.
- render(): يتم استدعاؤها بشكل متكرر في كل إطار (Frame). 
هنا تقوم بتحديث حالة اللعبة ورسم العناصر على الشاشة.
- dispose(): يتم استدعاؤها مرة واحدة عند إغلاق اللعبة. 
هنا تقوم بتحرير الموارد التي تم تحميلها لمنع تسرب الذاكرة.

الخطوة 4: التعامل مع الرسومات (Graphics)
- SpriteBatch: يستخدم لرسم مجموعة كبيرة من الصور الثنائية الأبعاد بكفاءة.
- Texture و TextureRegion: Texture لتمثيل ملف صورة، و 
TextureRegion لتعريف جزء من Texture (مفيد لـ Spritesheets).
- الرسم الأساسي: داخل دالة render(), ستقوم بمسح الشاشة، ثم تبدأ SpriteBatch,
 وتقوم برسم TextureRegion في مواقع محددة، ثم تنهي SpriteBatch.

الخطوة 5: التعامل مع المدخلات (Input)
- InputProcessor: واجهة لتلقي أحداث الإدخال مثل اللمس، السحب، ضغط الأزرار.
- تنفيذ InputProcessor: قم بإنشاء فئة تنفذ InputProcessor وقم بتسجيلها باستخدام Gdx.input.setInputProcessor(yourInputProcessor);.
- معالجة الأحداث: داخل فئة InputProcessor الخاصة بك، قم بتنفيذ الدوال المختلفة 
(مثل touchDown(), touchDragged(), keyDown()) للتعامل مع مدخلات المستخدم.

الخطوة 6: إدارة الأصول (Asset Management)
- AssetManager: يوفر طريقة منظمة لتحميل وإدارة أصول اللعبة بشكل غير متزامن.
تحميل الأصول: استخدم assetManager.load("path/to/asset", AssetClass.class); 
لتحميل الأصول.
- التحقق من التحميل: استخدم assetManager.update() للتحقق من تقدم التحميل و
 assetManager.isFinished() لمعرفة ما إذا تم تحميل جميع الأصول.
- الحصول على الأصول: استخدم assetManager.get("path/to/asset", AssetClass.class); 
للحصول على الأصل الذي تم تحميله.
- تفريغ الأصول: استخدم assetManager.dispose() عند إغلاق اللعبة لتحرير الذاكرة.

الخطوة 7: بناء منطق اللعبة (Game Logic)
- حالة اللعبة (Game State): تتبع حالة اللعبة (مثل الشاشة الحالية، نقاط اللاعب، حياة العدو).
- التحديث (Update): داخل دالة render(), قبل الرسم، قم بتحديث 
حالة اللعبة بناءً على المدخلات والوقت المنقضي.
- الكائنات (Entities): قم بإنشاء فئات لتمثيل كائنات اللعبة
 (مثل اللاعب، الأعداء، الكائنات القابلة للتجميع) وسلوكها.

الخطوة 8: استخدام المكتبات الإضافية (اختياري)
- Box2D أو Bullet Physics: لمحاكاة الفيزياء الثنائية أو الثلاثية الأبعاد.
- gdx-ai: لتطبيق الذكاء الاصطناعي في اللعبة.
- Scene2D: لبناء واجهات المستخدم ورسوم متحركة قائمة على المشاهد.
- وليونة (Ashley): نظام كيانات ومكونات (ECS) لتنظيم منطق اللعبة بشكل معياري.

الخطوة 9: الاختبار والنشر على الأجهزة المحمولة
- تشغيل على سطح المكتب: اختبر لعبتك على سطح المكتب أثناء التطوير لتسهيل عملية التصحيح.
- تشغيل على جهاز Android: استخدم Android Studio لتشغيل لعبتك على جهاز Android الفعلي أو محاكي.
- تكوين Gradle: قم بتكوين ملفات build.gradle بشكل صحيح لتوقيع تطبيقك.
- بناء ملف APK/AAB: استخدم Android Studio لإنشاء ملف APK 
(لتثبيت مباشر) أو AAB (لنشر على Google Play Store).
- النشر على Google Play Store (iOS App Store): اتبع الإرشادات الخاصة بكل متجر لنشر تطبيقك.

الخلاصة : 
- LibGDX هو إطار عمل قوي ومتعدد المنصات لتطوير الألعاب بلغة Java، يوفر أدوات لإنشاء ألعاب 2D و 3D.
- الخطوات الأساسية لبناء لعبة LibGDX تشمل إعداد البيئة، فهم هيكل المشروع،
 التعامل مع الرسومات والمدخلات، وإدارة الأصول.
- render() هي الدالة الرئيسية في دورة حياة اللعبة التي يتم استدعاؤها بشكل متكرر لتحديث ورسم عناصر اللعبة.
- SpriteBatch يستخدم لرسم مجموعة كبيرة من الصور الثنائية الأبعاد بكفاءة في LibGDX.
- AssetManager يوفر طريقة منظمة لتحميل وإدارة أصول اللعبة بشكل غير متزامن في LibGDX.
- لتلقي مدخلات المستخدم في LibGDX، تحتاج إلى تنفيذ InputProcessor وتسجيله.
- يستخدم Android Studio لتطوير واختبار ونشر ألعاب LibGDX على أجهزة Android.
أتمنى لك التوفيق في رحلتك لبناء لعبة الموبايل الأولى باستخدام LibGDX.


جدول المحتويات