كيفية استخدام ++C في Unreal Engine 4

تعد المخططات (Blueprints) طريقة شائعة جداً لإنشاء طريقة لعب في (Unreal Engine 4)، ومع ذلك، إذا كنت مبرمجاً منذ فترة طويلة وتفضل التمسك بالكود، فإن ++C تناسبك، وباستخدام ++C، يمكنك أيضاً إجراء تغييرات على المحرك وأيضاً إنشاء المكونات الإضافية الخاصة بك.

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

  1. إنشاء فئات ++C.
  2. إضافة المكونات واجعلها مرئية للمخططات (Blueprints).
  3. إنشاء فئة مخطط (Blueprint) بناءً على فئة ++C.
  4. إضافة متغيرات وجعلها قابلة للتعديل في المخططات (Blueprints).
  5. ربط المحور وتعيينات الإجراءات بالوظائف.
  6. تجاوز وظائف ++C في المخططات.
  7. ربط حدث تداخل بدالة.

يرجى ملاحظة أن هذا ليس برنامجاً تعليمياً حول تعلم ++C، بدلاً من ذلك، سيركز هذا البرنامج التعليمي على العمل مع ++C في سياق (Unreal Engine).

ملاحظة: يفترض هذا البرنامج التعليمي أنك تعرف بالفعل أساسيات استخدام (Unreal Engine)، وإذا كنت جديداً في (Unreal Engine)، فيجب أن تنتقل أولاً إلى سلسلة البرامج التعليمية (Unreal Engine for Beginners) المكونة من 10 أجزاء.

البداية

إذا لم تكن قد قمت بذلك بالفعل، فستحتاج إلى تثبيت (Visual Studio)، اتبع دليل (Epic) الرسمي حول إعداد (Visual Studio for Unreal Engine 4)، وعلى الرغم من أنه يمكنك استخدام (IDEs) بديلة، فإن هذا البرنامج التعليمي سيستخدم (Visual Studio) حيث تم تصميم (Unreal) بالفعل للعمل معه.

بعد ذلك، قم بتنزيل مشروع البداية وفك ضغطه، انتقل إلى مجلد المشروع (project folder) وافتح (CoinCollector.uproject)، وإذا طلب منك إعادة إنشاء الوحدات النمطية، فانقر فوق “نعم”.

تنزيل مشروع البداية

وبمجرد الانتهاء من ذلك، سترى المشهد التالي:

مشهد البداية

وفي هذا البرنامج التعليمي، ستقوم بإنشاء كرة يتحكم فيها اللاعب لجمع العملات المعدنية، وفي البرامج التعليمية السابقة، كنت تقوم بإنشاء شخصيات يتحكم فيها اللاعب باستخدام المخططات (Blueprints)، وهنا، ستقوم بإنشاء واحد باستخدام (++C).

إنشاء فئة سي بلس بلس  (Creating a C++ Class)

لإنشاء فئة ++C، انتقل إلى (Content Browser) وحدد (Add New \ New C++ Class).

إنشاء فئة سي بلس بلس

وسيؤدي هذا إلى إظهار معالج فئة ++C، وأولاً، تحتاج إلى تحديد أي فئة ترث منها، ونظراً لأن الفئة يجب أن يتحكم فيها اللاعب، فستحتاج إلى بيدق، حدد البيدق وانقر فوق التالي.

تحديد بيدق اللعب

في الشاشة التالية، يمكنك تحديد اسم ومسار ملفات (. h) و (.cpp)، قم بتغيير الاسم إلى (BasePlayer) ثم انقر فوق إنشاء فئة (Create Class).

تحديد بيدق اللعب

وسيؤدي ذلك إلى إنشاء ملفاتك ثم تجميع مشروعك، وبعد التجميع، سيفتح (Unreal Visual Studio)، وإذا لم يكن (BasePlayer.cpp) و(BasePlayer.h) مفتوحين، فانتقل إلى مستكشف الحلول (Solution Explorer) وافتحهما.

ويمكنك العثور عليها ضمن (Games \ CoinCollector \ Source \ CoinCollector).

إنشاء الملفات وتجميع المشروع

قبل أن نتابع، يجب أن تعرف نظام انعكاس أنريل (Unreal’s reflection)، يقوم بتشغيل أجزاء مختلفة من المحرك مثل لوحة التفاصيل (Details panel) وجمع القمامة (garbage collection)، وعند إنشاء فئة باستخدام معالج فئة ++C، سيضع (Unreal) ثلاثة أسطر في الترويسة:

  1. #include “TypeName.generated.h”
  2. UCLASS()
  3. GENERATED_BODY()

ويتطلب (Unreal) هذه الخطوط حتى تكون الطبقة مرئية لنظام الانعكاس، وإذا كان هذا يبدو محيراً، فلا تقلق، فقط اعلم أن نظام الانعكاس سيسمح لك بالقيام بأشياء مثل عرض التوابع والمتغيرات في المخططات (Blueprints) والمحرر.

وستلاحظ أيضاً أن الفئة تحمل اسم (ABasePlayer) بدلاً من (BasePlayer)، وعند إنشاء فئة من نوع الممثل، سيبدأ (Unreal) اسم الفئة بـ A (للممثل).

ويتطلب نظام الانعكاس أن يكون للفئات البادئات المناسبة لكي تعمل، ويمكنك أن تقرأ عن البادئات الأخرى في (Epic’s Coding Standard).

ملاحظة: لن يتم عرض البادئات في المحرر، وعلى سبيل المثال، إذا أردت إنشاء متغير من النوع (ABasePlayer)، فيمكنك البحث عن (BasePlayer).

هذا كل ما تحتاج لمعرفته حول نظام الانعكاس في الوقت الحالي، وبعد ذلك، ستضيف نموذج لاعب وكاميرا، وللقيام بذلك، تحتاج إلى استخدام المكونات (components).

إضافة المكونات (Adding Components)

بالنسبة لبيدق اللاعب، ستضيف ثلاثة مكونات:

  1. شبكة ثابتة (Static Mesh): سيسمح لك ذلك بتحديد شبكة لتمثيل المشغل.
  2. ذراع الزنبرك (Spring Arm): يعمل هذا المكون مثل ذراع الكاميرا، وسيتم توصيل أحد الطرفين بالشبكة وسيتم توصيل الكاميرا بالطرف الآخر.
  3. الكاميرا (Camera): كل ما تراه هذه الكاميرا هو ما سيعرضه Unreal للاعب.

أولاً، تحتاج إلى تضمين رؤوس لكل نوع من المكونات، افتح (BasePlayer.h) ثم أضف الأسطر التالية (#include “BasePlayer.generated.h”).

إضافة المكونات

ملاحظة: من المهم أن يكون ملف (.generated.h) هو آخر ملف، وفي هذه الحالة، يجب أن تبدو محتوياتك كما يلي:

إضافة المكونات

أنت الآن بحاجة إلى إعلان المتغيرات لكل مكون، أضف الأسطر التالية بعد ذلك (SetupPlayerInputComponent()).

إضافة المكونات

سيكون الاسم الذي تستخدمه هنا هو اسم المكون في المحرر، في هذه الحالة، ستظهر المكونات كـ (Mesh) و(SpringArm) و(Camera).

بعد ذلك، تحتاج إلى جعل كل متغير مرئياً لنظام الانعكاس، وللقيام بذلك، أضف UPROPERTY () فوق كل متغير، ويجب أن يبدو الرمز الخاص بك الآن كما يلي:

إضافة المكونات

يمكنك أيضاً إضافة محددات إلى UPROPERTY ()، وستتحكم هذه في كيفية تصرف المتغير مع جوانب مختلفة من المحرك.

أضف (VisibleAnywhere) و(BlueprintReadOnly) داخل الأقواس لكل UPROPERTY ()، وافصل بين كل محدد بفاصلة.

إضافة المكونات

سيسمح (VisibleAnywhere) أن يكون كل مكون مرئياً داخل المحرر (بما في ذلك Blueprints).

وسيسمح لك (BlueprintReadOnly) بالحصول على مرجع للمكون باستخدام عقد (Blueprint)، ومع ذلك، لن يسمح لك بتعيين المكون.

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

ولاحظ أن (BlueprintReadOnly) سيظل يسمح لك بتعيين المتغيرات داخل المكون، وهو السلوك المطلوب.

ملاحظة: بالنسبة للمتغيرات التي لا تحتوي على مؤشر (int وfloat وboolean وما إلى ذلك)، استخدم (EditAnywhere) و(BlueprintReadWrite) بدلاً من ذلك.

الآن بعد أن أصبح لديك متغيرات لكل مكون، فأنت بحاجة إلى تهيئتها، وللقيام بذلك، يجب عليك إنشاؤها داخل المنشئ (constructor).

تهيئة المكونات (Initializing Components)

لإنشاء مكونات، يمكنك استخدام CreateDefaultSubobject <Type> (“InternalName”).

افتح (BasePlayer.cpp) وأضف الأسطر التالية داخل ABasePlayer ():

تهيئة المكونات

سيؤدي هذا إلى إنشاء مكون من كل نوع، وسيقوم بعد ذلك بتعيين عنوان ذاكرتهم إلى المتغير المقدم، وستكون وسيطة السلسلة هي الاسم الداخلي للمكون الذي يستخدمه المحرك (وليس اسم العرض على الرغم من أنهما متماثلان في هذه الحالة).

بعد ذلك، تحتاج إلى إعداد التسلسل الهرمي (أي مكون هو الجذر وما إلى ذلك)، ويضاف ما يلي بعد الكود السابق:

تهيئة المكونات

السطر الأول سيجعل (Mesh) مكون الجذر، والسطر الثاني سيربط (SpringArm) بالشبكة، وأخيراً، سيقوم السطر الثالث بإرفاق الكاميرا بـ (SpringArm).

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

  1. في (Visual Studio)، حدد (Build \ Build Solution).
  2. في (Unreal Engine)، انقر فوق (Compile) في شريط الأدوات (Toolbar).

بعد ذلك، تحتاج إلى تعيين الشبكة المراد استخدامها ودوران ذراع الزنبرك (spring arm)، ومن المستحسن القيام بذلك في (Blueprints) لأنك لا تريد ترميز مسارات الأصول في ++C، وعلى سبيل المثال، في ++C، ستحتاج إلى القيام بشيء كهذا لتعيين شبكة ثابتة:

تهيئة المكونات

أما في المخططات (Blueprints)، يمكنك فقط تحديد شبكة من القائمة المنسدلة.

تهيئة المكونات

وإذا كنت ستنقل الأصل إلى مجلد آخر، فلن تنكسر (Blueprints)، أما في ++C، سيتعين عليك تغيير كل مرجع لهذا الأصل.

ولضبط الشبكة (mesh) ودوران ذراع الزنبرك (spring arm) داخل (Blueprints)، ستحتاج إلى إنشاء مخطط يستند إلى (BasePlayer).

ملاحظة: من الشائع إنشاء فئات أساسية في ++C ثم إنشاء فئة فرعية (Blueprint)، هذا يجعل من السهل على الأدوار مثل الفنانين والمصممين تحرير الفئات.

تصنيف فئات ++C فرعية (Subclassing C++ Classes)

في (Unreal Engine)، انتقل إلى مجلد (Blueprints) وأنشئ فئة (Blueprint)، ثم قم بتوسيع قسم (All Classes) وابحث عن (BasePlayer)، وحدد (BasePlayer) ثم انقر فوق تحديد (Select).

تصنيف فئات ++C فرعية

أعد تسميته إلى (BP_Player) ثم افتحه.

أولاً، سوف تقوم بتعيين الشبكة، حدد مكون (Mesh) وقم بضبط (Static Mesh) على (SM_Sphere).

تصنيف فئات ++C فرعية

بعد ذلك، تحتاج إلى ضبط دوران ذراع الزنبرك (pring arm) وطوله، وستكون هذه لعبة من أعلى إلى أسفل، لذا يجب أن تكون الكاميرا فوق اللاعب.

حدد مكون (SpringArm) واضبط الدوران على (0 ، -50 ، 0)، وسيؤدي هذا إلى تدوير ذراع الزنبرك بحيث تشير الكاميرا لأسفل باتجاه الشبكة.

تصنيف فئات ++C فرعية

نظراً لأن الذراع الزنبركية تابعة للشبكة، فستبدأ في الدوران عندما تبدأ الكرة في الدوران.

لإصلاح ذلك، تحتاج إلى ضبط دوران ذراع الزنبرك ليكون مطلقاً، انقر فوق السهم الموجود بجانب الدوران (Rotation) وحدد العالم (World).

تصنيف فئات ++C فرعية

بعد ذلك، اضبط طول ذراع الهدف على 1000، وسيؤدي ذلك إلى وضع الكاميرا بعيداً عن الشبكة بمقدار 1000 وحدة.

تصنيف فئات ++C فرعية

بعد ذلك، تحتاج إلى تعيين فئة البيدق الافتراضية من أجل استخدام البيدق الخاص بك، انقر فوق (Compile) ثم ارجع إلى المحرر، افتح الإعدادات العالمية (World Settings) واضبط البيدق الافتراضي (Default Pawn) على (BP_Player).

تصنيف فئات ++C فرعية

اضغط على تشغيل (Play) لرؤية البيدق الخاص بك في اللعبة.

تصنيف فئات ++C فرعية

الخطوة التالية هي إضافة توابع حتى يتمكن اللاعب من التحرك.

تنفيذ الحركة (Implementing Movement)

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

ارجع إلى (Visual Studio) وافتح (BasePlayer.h)، وأضف ما يلي بعد متغيرات المكون:

تنفيذ الحركة

يتيح لك (EditAnywhere) تعديل (MovementForce) في لوحة التفاصيل (Details panel)، وسوف يسمح لك (BlueprintReadWrite) بتعيين وقراءة (MovementForce) باستخدام عقد (Blueprint).

بعد ذلك، ستقوم بإنشاء تابعين، واحد للتحرك صعوداً وهبوطاً والآخر للتحرك اليسار واليمين.

إنشاء توابع الحركة (Creating Movement Functions)

أضف إعلانات التوابع التالية أدناه (MovementForce):

إنشاء توابع الحركة

لاحقاً، ستقوم بربط تعيينات المحاور بهذه التوابع، من خلال القيام بذلك، ستكون تعيينات المحاور قادرة على تمرير مقياسها (ولهذا السبب تحتاج التوابع إلى معامل قيمة الطفو (float Value parameter)).

ملاحظة: إذا لم تكن معتاداً على تعيينات المحاور والمقياس، فراجع برنامج (Blueprints) التعليمي.

الآن، أنت بحاجة إلى إنشاء تنفيذ لكل تابع، افتح (BasePlayer.cpp) وأضف ما يلي في نهاية الملف:

إنشاء توابع الحركة

ستضيف MoveUp () قوة فيزيائية على المحور (X) إلى (Mesh)، ويتم توفير القوة بواسطة (MovementForce)، بضرب النتيجة في القيمة (مقياس تعيين المحور)، ويمكن للشبكة أن تتحرك إما في الاتجاهين الموجب أو السالب.

ويقوم MoveRight () بنفس طريقة MoveUp () ولكن على المحور (Y).

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

ربط تعيينات المحور بالتوابع (Binding Axis Mappings to Functions)

من أجل البساطة، قمت بالفعل بإنشاء تعيينات المحاور لك، ويمكنك العثور عليها في إعدادات المشروع (Project Settings) ضمن الإدخال (Input).

ربط تعيينات المحور بالتوابع

ملاحظة: لا تحتاج تعيينات المحاور إلى نفس اسم التابع التي تقوم بربطها به.

أضف ما يلي داخل SetupPlayerInputComponent ():

ربط تعيينات المحور بالتوابع

وسيؤدي هذا إلى ربط تعيينات محور (MoveUp) و(MoveRight) مع MoveUp () وMoveRight ().

هذا كل شيء عن توابع الحركة، وبعد ذلك، تحتاج إلى تمكين الفيزياء على مكون الشبكة.

تمكين الفيزياء (Enabling Physics)

أضف الأسطر التالية داخل ABasePlayer ():

تمكين الفيزياء

سيسمح السطر الأول لقوى الفيزياء بالتأثير على (Mesh)، وسيحدد السطر الثاني (MovementForce) إلى 100،000.

وهذا يعني أنه سيتم إضافة 100000 وحدة من القوة إلى الكرة عند التحرك، وبشكل افتراضي، تزن الأجسام الفيزيائية حوالي 110 كيلوجرام، لذا فأنت بحاجة إلى الكثير من القوة لتحريكها.

وإذا كنت قد أنشأت فئة فرعية، فلن تتغير بعض الخصائص حتى إذا قمت بتغييرها داخل الفئة الأساسية، وفي هذه الحالة، لن يتم تمكين محاكاة الفيزياء في (BP_Player)، ومع ذلك، فإن أي فئات فرعية تقوم بإنشائها الآن سيتم تمكينها افتراضياً.

اضغط (Compile) ثم ارجع إلى (Unreal Engine)، وافتح (BP_Player) وحدد مكون الشبكة (Mesh)، وبعد ذلك، قم بتمكين محاكاة الفيزياء (Simulate Physics).

تمكين الفيزياء

انقر فوق (Compile) ثم اضغط على تشغيل (Play)، واستخدم W و A و S و D للتنقل.

تمكين الفيزياء

بعد ذلك، ستعلن عن تابع ++C الذي يمكنك تنفيذه باستخدام (Blueprints)، ويتيح ذلك للمصممين إنشاء توابع دون الحاجة إلى استخدام ++C، ولمعرفة ذلك، سوف تقوم بإنشاء تابع قفز.

إنشاء تابع القفز (Creating the Jump Function)

تحتاج أولاً إلى ربط تعيين القفزة بتابع ما، وفي هذا البرنامج التعليمي، تم تعيين القفز على شريط المسافة.

إنشاء تابع القفز

ارجع إلى (Visual Studio) وافتح (BasePlayer.h)، وأضف ما يلي MoveRight ():

إنشاء تابع القفز

الأول هو متغير عائم يسمى (JumpImpulse)، وسوف تستخدم هذا عند تنفيذ القفزة، ويستخدم (EditAnywhere) لجعله قابلاً للتحرير داخل المحرر، كما أنه يستخدم (BlueprintReadWrite) حتى تتمكن من قراءته وكتابته باستخدام عقد (Blueprint).

التالي هو تابع القفز، حيث UFUNCTION () سيجعل () Jump مرئياً لنظام الانعكاس، وسوف يسمح (BlueprintImplementableEvent) للمخططات بتنفيذ Jump ()، وإذا لم يكن هناك تنفيذ، فإن أي استدعاءات لـ Jump () لن تفعل شيئاً.

ملاحظة: إذا كنت تريد توفير تطبيق افتراضي في ++C، فاستخدم (BlueprintNativeEvent) بدلاً من ذلك، وستتعلم كيفية القيام بذلك لاحقاً في البرنامج التعليمي.

ونظراً لأن Jump هو تعيين إجراء، فإن طريقة ربطه مختلفة قليلاً، أغلق (BasePlayer.h) ثم افتح (BasePlayer.cpp)، وأضف ما يلي داخل SetupPlayerInputComponent ():

إنشاء تابع القفز

سيؤدي هذا إلى ربط تعيين الانتقال بـ Jump ()، وسيتم تنفيذه فقط عند الضغط على مفتاح القفز، وإذا كنت تريد أن يتم تنفيذه عند تحرير المفتاح، فاستخدم (IE_Released) بدلاً من ذلك.

التالي هو تجاوز Jump () في (Blueprints).

تجاوز التوابع في المخططات (Overriding Functions in Blueprints)

اضغط (Compile) ثم قم بإغلاق (BasePlayer.cpp)، وبعد ذلك، ارجع إلى (Unreal Engine) وافتح (BP_Player)، وانتقل إلى لوحة (My Blueprints) وقم بالتمرير فوق التوابع لعرض قائمة (Override) المنسدلة، وانقر فوقه وحدد الانتقال (Jump)، وسيؤدي هذا إلى إنشاء حدث قفزة (Event Jump).

تجاوز التوابع في المخططات

ملاحظة: سيكون التجاوز حدثاً إذا لم يكن هناك نوع إرجاع، وإذا كان هناك نوع إرجاع، فسيكون تابع.

بعد ذلك، قم بإنشاء الإعداد التالي:

تجاوز التوابع في المخططات

سيضيف هذا دفعة (JumpImpulse) على المحور (Z) إلى (Mesh)، ولاحظ أنه في هذا التطبيق، يمكن للاعب القفز إلى أجل غير مسمى.

بعد ذلك، تحتاج إلى تعيين قيمة (JumpImpulse)، انقر فوق (Class Defaults) في شريط الأدوات (Toolbar) ثم انتقل إلى لوحة (Details)، واضبط (JumpImpulse) على (100000).

تجاوز التوابع في المخططات

انقر فوق (Compile) ثم أغلق (BP_Player)، اضغط تشغيل (Play) وانتقل باستخدام شريط المسافة.

تجاوز التوابع في المخططات

في القسم التالي، ستجعل العملات المعدنية تختفي عندما يلمسها اللاعب.

جمع العملات (Collecting Coins)

للتعامل مع التداخلات، تحتاج إلى ربط تابع بحدث متداخل، وللقيام بذلك، يجب أن يفي التابع بمتطلبين.

الأول هو أن التابع يجب أن يحتوي على الماكرو UFUNCTION ().

والشرط الثاني هو أن التابع يجب أن يكون له التوقيع الصحيح.

وفي هذا البرنامج التعليمي، ستستخدم حدث (OnActorBeginOverlap)، ويتطلب هذا الحدث تابع له التوقيع التالي:

جمع العملات

ارجع إلى (Visual Studio) وافتح (BaseCoin.h)، وأضف ما يلي PlayCustomDeath ():

جمع العملات

بعد الربط، سيتم تنفيذ OnOverlap () عندما تتداخل العملة مع فاعل آخر، وسيكون (OverlappedActor) هو العملة وسيكون (OtherActor) هو الممثل الآخر.

بعد ذلك، تحتاج إلى تنفيذ OnOverlap ().

تنفيذ التداخلات (Implementing Overlaps)

افتح (BaseCoin.cpp) وأضف ما يلي في نهاية الملف:

تنفيذ التداخلات

نظراً لأنك تريد فقط اكتشاف التداخلات مع المشغل، فأنت بحاجة إلى إرسال (OtherActor) إلى (ABasePlayer), وقبل القيام بعملية التمثيل، تحتاج إلى تضمين الترويسة (ABasePlayer).

أضف ما يلي #include “BaseCoin.h”:

تنفيذ التداخلات

الآن أنت بحاجة إلى أداء فريق التمثيل، وفي (Unreal Engine)، يمكنك إلقاء مثل هذا:

تنفيذ التداخلات

إذا نجح فريق التمثيل، فسيعيد المؤشر إلى (ObjectToCast)، وإذا لم ينجح، فإنه سيعود (nullptr)، وبالتحقق مما إذا كانت النتيجة (nullptr)، يمكنك تحديد ما إذا كان الكائن من النوع الصحيح.

أضف ما يلي داخل OnOverlap ():

تنفيذ التداخلات

الآن، عند تنفيذ OnOverlap ()، سيتحقق مما إذا كان (OtherActor) من النوع (ABasePlayer)، وإذا كان الأمر كذلك، فقم بتدمير العملة المعدنية.

بعد ذلك، تحتاج إلى ربط OnOverlap ().

ربط تابع التداخل (Binding the Overlap Function)

لربط تابع بحدث تداخل، تحتاج إلى استخدام AddDynamic () في الحدث، أضف ما يلي داخل ABaseCoin ():

ربط تابع التداخل

سيؤدي هذا إلى ربط OnOverlap () بحدث (OnActorBeginOverlap)، يحدث هذا الحدث عندما يتداخل هذا الممثل مع ممثل آخر.

اضغط على (Compile) ثم ارجع إلى (Unreal Engine)، واضغط على تشغيل Play وابدأ في جمع العملات المعدنية، وعندما تتداخل مع عملة معدنية، ستدمر العملة نفسها، مما يؤدي إلى اختفائها.

تجاوز التوابع في المخططات

ملاحظة: إذا لم تختف العملات المعدنية، فحاول إعادة تشغيل المحرر لإجراء إعادة تجميع كاملة، تتطلب بعض تغييرات التعليمات البرمجية إعادة التشغيل حتى تعمل.

في القسم التالي، ستقوم بإنشاء تابع ++C أخرى قابلة للتجاوز، ومع ذلك، ستقوم هذه المرة أيضاً بإنشاء تطبيق افتراضي، ولتوضيح ذلك، سوف تستخدم OnOverlap ().

إنشاء التنفيذ الافتراضي للتابع (Creating a Function’s Default Implementation)

لإنشاء تابع بتطبيق افتراضي، تحتاج إلى استخدام محدد (BlueprintNativeEvent)، ارجع إلى (Visual Studio) وافتح (BaseCoin.h)، وأضف (BlueprintNativeEvent) إلى UFUNCTION () من OnOverlap ():

إنشاء التنفيذ الافتراضي للتابع

لجعل إحدى التوابع هي التنفيذ الافتراضي، تحتاج إلى إضافة لاحقة (_Implementation)، افتح (BaseCoin.cpp) وقم بتغيير (OnOverlap) إلى (OnOverlap_Implementation):

إنشاء التنفيذ الافتراضي للتابع

الآن، إذا لم يقم برنامج (Blueprint) التابع بتنفيذ OnOverlap ()، فسيتم استخدام هذا التنفيذ بدلاً من ذلك.

الخطوة التالية هي تنفيذ OnOverlap () في (BP_Coin).

إنشاء تنفيذ المخطط (Creating the Blueprint Implementation)

لتنفيذ (Blueprint)، ستتصل بـ PlayCustomDeath ()، وسيعمل تابع ++C هذه على زيادة معدل دوران العملة المعدنية، وبعد 0.5 ثانية، ستدمر العملة نفسها.

ولاستدعاء تابع ++C من (Blueprints)، تحتاج إلى استخدام محدد (BlueprintCallable)، أغلق (BaseCoin.cpp) ثم افتح (BaseCoin.h)، وأضف ما يلي PlayCustomDeath ():

إنشاء تنفيذ المخطط

اضغط على (Compile) ثم أغلق (Visual Studio)، وارجع إلى (Unreal Engine) وافتح (BP_Coin)، ثم (Override On Overlap) ثم قم بإنشاء الإعداد التالي:

إنشاء تنفيذ المخطط

الآن عندما يتداخل اللاعب مع عملة معدنية، سيتم تنفيذ (Play Custom Death).

انقر فوق (Compile) ثم أغلق (BP_Coin)، واضغط على تشغيل (Play) واجمع بعض القطع النقدية لاختبار التطبيق الجديد.

إنشاء تنفيذ المخطط

المصدر
هنا

مقالات ذات صلة

اترك تعليقاً

لن يتم نشر عنوان بريدك الإلكتروني.