شرح البلوبرينت في انرل انجن unreal engine blueprints

 شرح و فهم البلوبرينت في انرل انجن

  Unreal Engine Blueprints

وجدت مشكلة كبيرة في ايجاد دروس تشرح البلوبرينت بالتفصيل كل القنوات تشرح بشكل سطحي فقط ولا ادري هل هو خوف من المنافسة او من اجل بيع الدورات بل حتى في الدورات المدفوعة لا يشرح لك بالتفصيل طريقة عملها مع الاسف

المهم سوف احاول اضافة اي شيء يخص البلوبرينت في هذا الموضوع واذا كان اي حد يقراء هذا الموضوع ادعي لي بالتوفيق

البرمجة الكائنية (Object-Oriented Programming - OOP)

البرمجة الكائنية هي نموذج برمجي يركز على تقسيم البرنامج إلى كائنات (Objects). الكائن هو وحدة تحتوي على بيانات (Data) ووظائف (Functions) تعمل على هذه البيانات. الفكرة الأساسية هي تمثيل العالم الحقيقي في البرمجة عن طريق تقسيمه إلى كائنات تتفاعل مع بعضها البعض.

المفاهيم الأساسية للبرمجة الكائنية:

الكائنات (Objects):

الكائن يمثل وحدة مستقلة تحتوي على بيانات وسلوك.

على سبيل المثال، "سيارة" يمكن اعتبارها كائناً يحتوي على بيانات (مثل اللون والسرعة) وسلوك (مثل الحركة أو الوقوف).

الفئات (Classes):

الفئة هي قالب (Blueprint) تُستخدم لإنشاء الكائنات.

تحتوي على تعريف الخصائص (Properties) والدوال (Methods) التي يمتلكها الكائن.

مثال: "السيارة" كفئة تحتوي على الخصائص العامة لكل السيارات (مثل الطول والسرعة) والدوال (مثل القيادة).

التغليف (Encapsulation):

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

على سبيل المثال، بدلاً من التعديل على محرك السيارة مباشرة، يمكنك استخدام وظيفة StartEngine().

الوراثة (Inheritance):

السماح لفئة بالاستفادة من خصائص ودوال فئة أخرى.

على سبيل المثال، يمكن أن تكون فئة "شاحنة" ترث من فئة "سيارة"، ولكنها تضيف خصائص مثل "حمولة الوزن".

تعدد الأشكال (Polymorphism):

قدرة الكائنات على العمل بطرق مختلفة اعتماداً على السياق.

مثال: دالة Drive() قد تعمل بشكل مختلف إذا كانت الكائن يمثل دراجة أو سيارة.

كيف تعمل البرمجة الكائنية في Unreal Engine؟

في Unreal Engine، البرمجة الكائنية هي جزء أساسي من تصميم اللعبة. يتم استخدام Blueprints وC++ لتعريف الكائنات والتفاعل بينها.

1. الفئات (Classes) في Unreal Engine:

في Unreal Engine، كل عنصر داخل اللعبة هو عبارة عن كائن يتم تعريفه باستخدام Class.

الفئات المدمجة في Unreal تشمل:

Actor: العنصر الأساسي في اللعبة.

Pawn: كائن يمكن للاعب التحكم به.

Character: نسخة محسنة من Pawn تستخدم للشخصيات.

GameMode: تتحكم في قواعد اللعبة.

2. إنشاء كائنات باستخدام Blueprint:

Blueprint هو نظام مرئي قائم على البرمجة الكائنية.

لإنشاء كائن:

اختر نوع الكائن الذي تريد إنشاءه (مثل Actor أو Character).

قم بتحديد الخصائص (مثل الحجم أو اللون).

أضف الوظائف (مثل حركة اللاعب).

3. الوراثة:

يمكنك إنشاء Blueprint جديد يرث من Blueprint آخر.

على سبيل المثال:

فئة أساسية: "سلاح".

فئة فرعية: "بندقية"، ترث الخصائص والدوال العامة ولكن تضيف ميزات جديدة مثل إطلاق النار بسرعة.

4. الربط بين الكائنات:

يتم ربط الكائنات في Unreal باستخدام الأحداث والدوال.

على سبيل المثال:

عند اصطدام اللاعب بكائن (Trigger Event)، يمكنك تشغيل دالة معينة (مثل فتح الباب).

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

إذا كنت تفضل البرمجة النصية، يمكنك استخدام C++ لإنشاء فئات أكثر تعقيداً.

مثال بسيط: إنشاء كائن يمثل شخصية.

// تعريف فئة جديدة ترث من ACharacter

#include "MyCharacter.h"

// البناء الأساسي للفئة

AMyCharacter::AMyCharacter()

{

    // تهيئة الخصائص

    Health = 100.0f;

}

// وظيفة لتحريك الشخصية

void AMyCharacter::MoveForward(float Value)

{

    if (Value != 0.0f)

    {

        AddMovementInput(GetActorForwardVector(), Value);

    }

}

كيفية الجمع بين Blueprints وC++

يمكنك إنشاء فئة أساسية باستخدام C++ وتوسيعها باستخدام Blueprints.

مثال:

قم بإنشاء فئة AMyCharacter في C++ تحتوي على الوظائف الأساسية.

قم بإنشاء Blueprint جديد يرث من هذه الفئة لإضافة الرسومات أو التفاعلات.

مزايا البرمجة الكائنية في Unreal Engine:

إعادة الاستخدام: يمكنك إنشاء فئات قابلة لإعادة الاستخدام بسهولة.

التوسع: الوراثة تسمح بإضافة ميزات جديدة دون تغيير الكود الأساسي.

التنظيم: الكائنات تساعد على تنظيم الكود بشكل أفضل.

إضافة شخصية جديدة باستخدام Blueprint

إذا كنت تستخدم Blueprint (الواجهة المرئية):

أ. إنشاء Blueprint جديد:

في نافذة Content Browser:

اضغط بزر الماوس الأيمن واختر Blueprint Class.

اختر نوع الفئة الأساسية:

Character: إذا كنت تريد شخصية قابلة للحركة.

Pawn: إذا كنت تريد كائنًا يمكن التحكم به، ولكن دون إعدادات شخصية افتراضية.

أعطِ Blueprint اسمًا (مثل "MyCharacter").

ب. تخصيص الشخصية:

افتح الـ Blueprint الذي أنشأته.

أضف Mesh (الهيكل ثلاثي الأبعاد):

من قائمة المكونات (Components) في الجزء الأيسر، اضغط على Add Component واختر Skeletal Mesh.

في جزء الخصائص (Details)، اختر نموذج الشخصية (مثل Mannequin الموجود في Starter Content).

أضف Camera (الكاميرا):

أضف Camera Component لتحديد زاوية الرؤية.

ضع الكاميرا أمام الشخصية ووجهها نحو Mesh.

أضف Capsule Collision (الاصطدام):

هذا يساعد في تحديد اصطدام الشخصية بالأشياء الأخرى.

يتم إضافته تلقائيًا إذا اخترت "Character" كفئة.

أضف Animation (الرسوم المتحركة):

في خصائص الـ Skeletal Mesh، اختر Animation Blueprint مناسبًا للشخصية (مثل "ThirdPerson_AnimBP" إذا كنت تستخدم القالب الجاهز).

3. ضبط الشخصية كـ "Default Pawn"

لكي تظهر الشخصية وتصبح قابلة للتحكم:

اذهب إلى Edit > Project Settings.

في قسم Maps & Modes:

ابحث عن Default Pawn Class.

اختر الشخصية الجديدة التي أنشأتها (مثل "MyCharacter").

4. إضافة الشخصية إلى المشهد

اسحب الشخصية الجديدة من Content Browser وأفلتها في المشهد.

تأكد من أنها في مكان مناسب فوق الأرض.

5. التحكم في الشخصية (Input Setup)

إذا لم تعمل الشخصية عند التشغيل:

اذهب إلى Edit > Project Settings.

في قسم Input: هنا للتاكد فقط اذا كانت الازرار مفعلة هنا

أضف Action Mappings (مثل "Jump") وAxis Mappings (مثل "MoveForward" و"Turn").

اربط هذه المدخلات بوظائف داخل الشخصية (مثل AddMovementInput للحركة).

اولا نود اضافة تحريك للكاميرة بالماوس

 او النظر للاتجاهات للاعب بالماوس نقوم بعمل graph جديد من خيار event graph ونربط الاوامر التالية للحصول على حركة الماوس 

ملاحظة ابحث فقط عن امر turn واضغط عليه سيعطينا نافذة input axis turn

نفس الشء للخيار الثاني Lookup 

دائما تضغط بالاعلى على كلمة compiler لتفعيل التغييرات

في حالة بدانا المشروع بدون اساسيات الحركة سنقوم بالذهاب الى اعدادات project settings ثم Input ونعدل الازرار هنا قبل تفعيلها في خانة event graph 

و الevent graph نجدها حين نضغط على بلوبرينت الشخصية من ملف content browser 

اولا للماوس

في خيار axis mapping نضغط علامة زائد ثم نضيف

نعطيه اسم Turn ثم المربع الثاني في خيار الماوس mouse نختار خيار mouse X

ثم نضيف زر اخر يعني مربعين اخرين ونعطيه اسم lookup ونختار له mouse Y

معلومة مهمة جدا نلاحظ وجود 1 وسالب واحد 1- وهذا معناه

الواحد يعني للامام

وسالب واحد تعني العكس او للخلف 

اذا سنترك واحد امام خيار scal 1 Mouse X

وسالب واحد امام خيار scal -1 Mouse Y

في حالة عدم وجود ازرار الاخرى فنقوم باضافتها

زر التحرك للامام moveforward

ثم نحدد الازرار من keybord لوح المفتاتيح وغيره

الان نضغط على زائد في خيار moveforward ليعطينا خانة اخرى

ونضع في الاخانة الاولى زو التحرك للامام ونعطيه واحد

وفي الخانة الثانية نضع زر للخلف ونعطيه سالب واحد

الان نستخرج زر اخر بالضغط على زائد في خيار axis mapping

ونضع له اسم MoveRight مثلا

ونفس الطريقة نجعل له خانتين الاولى نختار فيها زر لليمين نعطيه واحد

والخانة تحتها لزر تحريك لليسار وهذا نعطيه سالب واحد

الان كود التحريك للشخصية نقوم بتركيب الاوامر التالية 

نتاكد من خيار التدوير الشخصية بالضغط على charachter movment بجانب الشاشة وسوف يعطينا تفاصيل التعديل على الحركة ونبحث عن امر charachter movment rotation settings اعدادات التدوير ونضع علامة في خيار orien rotation 

كود جعل الشخصية تقفز نركب الاوامر التالية

كود اضافة تحريك الشخصية عن طريق لمس الشاشة مثل العاب الهواتف

معلومات اضافية

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

الألوان الأساسية في Blueprint:

الاحمر

مخصص دائما لبداية اي امر جديد ويكون الاحمر دائما هو البداية

الأزرق الفاتح (Light Blue):

يرمز إلى النوع: Object Reference.

يُستخدم للإشارة إلى كائنات معينة داخل اللعبة مثل Actors أو Components.

الأصفر (Yellow):

يرمز إلى النوع: Integer (عدد صحيح).

يُستخدم في العمليات الحسابية التي تحتاج إلى أعداد صحيحة.

الأخضر الفاتح (Light Green):

يرمز إلى النوع: Boolean (صح/خطأ).

يُستخدم للقيم المنطقية مثل true/false.

البرتقالي (Orange):

يرمز إلى النوع: Float (عدد عشري).

يُستخدم في العمليات التي تحتاج إلى أرقام عشرية مثل المواقع أو السرعة.

البنفسجي (Purple):

يرمز إلى النوع: String (نص).

يُستخدم لمعالجة النصوص مثل أسماء اللاعبين أو الرسائل.

الأخضر الداكن (Dark Green):

يرمز إلى النوع: Vector.

يُستخدم لتحديد المواقع أو الاتجاهات أو السرعات (x, y, z).

الرمادي الداكن (Dark Grey):

يرمز إلى النوع: Execution Pin.

يُستخدم لتحديد التدفق بين العقد (أي ما يُنفذ أولًا).

الوردي (Pink):

يرمز إلى النوع: Rotator.

يُستخدم لتحديد الدوران (Yaw, Pitch, Roll).

الأزرق الداكن (Dark Blue):

يرمز إلى النوع: Class Reference.

يُستخدم للإشارة إلى فئات (Classes) بدلاً من كائنات فردية.

نصائح للعمل مع الألوان في Blueprints:

التوافق: لا يمكنك توصيل نوع بيانات بلون معين إلى نوع آخر مختلف (مثل Float مع Boolean).

التنظيم: استخدم التعليقات والألوان المخصصة للعقد لتوضيح منطق البرمجة.

الفحص: إذا كان هناك خطأ في التوصيل، غالبًا ستلاحظ اللون غير متوافق.

المتغيرات (Variables) في Unreal Engine Blueprints:

المتغيرات هي وسيلة لتخزين البيانات التي يمكن استخدامها وتعديلها أثناء تشغيل اللعبة. تُستخدم المتغيرات لتخزين معلومات مثل النقاط، الصحة، الموقع، أو حتى مراجع لكائنات أخرى.

خطوات استخدام المتغيرات في Blueprints:

1. إنشاء متغير:

افتح أي Blueprint (مثل Actor Blueprint أو Widget Blueprint).

في لوحة My Blueprint، ستجد قسمًا يُسمى Variables.

اضغط على أيقونة + بجانب المتغيرات لإضافة متغير جديد.

اختر اسمًا للمتغير يعبر عن الغرض منه (مثل "Health" أو "Score").

2. تحديد نوع المتغير (Variable Type):

حدد المتغير الجديد في قائمة المتغيرات.

في لوحة Details، اختر نوع البيانات (مثل Boolean، Integer، Float، Vector، إلخ).

Boolean: لتخزين قيم منطقية (True/False).

Integer: لتخزين أعداد صحيحة.

Float: لتخزين أرقام عشرية.

String: لتخزين النصوص.

Object Reference: لتخزين مراجع إلى كائنات في اللعبة.

Vector: لتخزين الإحداثيات ثلاثية الأبعاد (X, Y, Z).

Actor Reference: للإشارة إلى كائنات في اللعبة.

3. ضبط قيمة ابتدائية (Default Value):

إذا كان المتغير يحتاج إلى قيمة ابتدائية، قم بتحديدها في لوحة Details. 

على سبيل المثال:

قيمة ابتدائية للصحة: 100.

قيمة افتراضية للنقاط: 0.

4. استخدام المتغير في الرسم البياني (Graph):

للحصول على قيمة المتغير:

اسحب المتغير من لوحة My Blueprint إلى الرسم البياني.

اختر Get لإحضار القيمة الحالية.

لتغيير قيمة المتغير:

اسحب المتغير إلى الرسم البياني.

اختر Set لتعيين قيمة جديدة.

5. التوصيل بين العقد (Nodes):

قم بتوصيل المتغيرات مع عقد أخرى مثل Branch أو Print String أو حتى عمليات حسابية.

 إعداد الخصائص:

يمكنك ضبط الخيارات التالية في تفاصيل المتغير:

Editable: يجعل المتغير قابلًا للتعديل داخل محرر اللعبة.

Expose on Spawn: يتيح تحديد القيمة عند إنشاء الكائن.

Private: يمنع الوصول إليه من خارج الـ Blueprint نفسه.

3. استخدام المتغير:

Get Variable:

اسحب المتغير من الشريط الجانبي وضعه في المحرر.

استخدمه للحصول على قيمته الحالية.

Set Variable:

اسحب المتغير واختر Set.

استخدمه لتغيير قيمة المتغير أثناء التشغيل.

4. الربط بالعقد الأخرى:

اربط المتغير بعقد أخرى لاستخدامه في العمليات (مثل الحسابات أو مقارنة القيم).

 متى تحتاج إلى الحسابات والمتغيرات؟

الحسابات والمتغيرات تُستخدم عندما:

إدارة الحالة: حفظ حالات مثل صحة اللاعب، الذخيرة، النقاط.

الحركات: تعديل أو حساب الحركات المعقدة (مثل القفز أو الجري).

التفاعل مع البيئة: حساب الأبعاد أو التوقيت عند التفاعل مع الأبواب، المصائد، وغيرها.

الفيزياء: معالجة السرعة، التسارع، أو الاصطدام.

أنظمة الألعاب: مثل تعديل صعوبة اللعبة بناءً على أداء اللاعب.

 كيفية استخدام المتغيرات في Blueprint؟

إنشاء متغير:

افتح Blueprint الخاص بك.

من لوحة Variables، اضغط على زر "+" لإضافة متغير جديد.

اختر اسمًا ونوعًا للمتغير (مثل Integer للعداد).

قراءة وكتابة المتغير:

Get Variable: استخدمه لقراءة قيمة المتغير.

Set Variable: استخدمه لتعديل أو تعيين قيمة جديدة للمتغير.

ربط المتغيرات بالحسابات:

اسحب المتغير إلى Graph واستخدمه كمدخل في العمليات الحسابية.

4. أمثلة على الحسابات الأساسية:

مثال 1: حساب الصحة (Health Calculation)

الوصف: تقليل صحة اللاعب عند تلقيه ضرر.

التنفيذ:

أنشئ متغير Health (نوع Float).

استخدم حدث مثل Event AnyDamage.

اطرح قيمة الضرر من الصحة باستخدام عقدة Float - Float.

حدث المتغير باستخدام Set Variable.

مثال 2: حساب نقاط اللاعب (Score System)

الوصف: إضافة نقاط إلى اللاعب عند قتل عدو.

التنفيذ:

أنشئ متغير Score (نوع Integer).

عند تدمير العدو، أضف قيمة النقاط باستخدام عقدة Integer + Integer.

احفظ النتيجة في المتغير Score.

مثال 3: ضبط الحركة (Movement Speed Adjustment)

الوصف: زيادة سرعة اللاعب عند الجري.

التنفيذ:

أنشئ متغير Speed (نوع Float).

عند الضغط على زر الجري، غير القيمة إلى سرعة أعلى باستخدام Set Variable.

أعد تعيين السرعة عند ترك الزر.

 كيفية تحديد الأشياء التي تحتاج إلى حساب؟

تحليل الميكانيكا المطلوبة:

افهم كيف تريد أن تعمل الميكانيكا.

مثال: هل القفزة تعتمد على ضغط اللاعب؟ إذًا تحتاج إلى حساب قوة القفز.

تحديد البيانات الديناميكية:

أي قيمة تتغير أثناء اللعب يجب تمثيلها بمتغير.

مثال: صحة العدو، عداد الوقت، عدد الذخيرة.

التفاعل بين الكائنات:

إذا كان هناك تفاعل بين كائنين (مثل اصطدام شخصية مع عدو)، فقد تحتاج إلى حساب مثل الاتجاه، القوة، أو الزمن.

التوازن داخل اللعبة:

الحسابات تساعد في ضبط التوازن.

مثال: تعديل قوة العدو بناءً على تقدم اللاعب.

 أمثلة عملية لتصميم لعبة:

لعبة منصات (Platformer Game):

الحسابات والمتغيرات:

القفز: احسب ارتفاع القفزة باستخدام متغير قوة القفز (Jump Strength).

جمع النقاط: استخدم متغير Score لحفظ عدد النقاط.

لعبة تصويب (Shooter Game):

الحسابات والمتغيرات:

الذخيرة: متغير Ammo يمثل عدد الرصاصات المتبقية.

الدقة: احسب ارتداد السلاح باستخدام Float لتعديل اتجاه الطلقات.

لعبة ألغاز (Puzzle Game):

الحسابات والمتغيرات:

عداد الوقت: استخدم متغير Timer لضبط الوقت المتبقي.

عدد الحركات: متغير MoveCount لتتبع عدد الحركات.

 نصائح لاستخدام المتغيرات والحسابات:

استخدم أسماء واضحة:

اختر أسماء تصف وظيفة المتغير (مثل PlayerHealth).

التأكد من القيم الافتراضية:

عيّن قيمة افتراضية للمتغيرات لتجنب الأخطاء.

اختبر الأداء:

الحسابات المعقدة قد تؤثر على الأداء. حاول تحسين المنطق قدر الإمكان.

استخدام الرسوم البيانية (Blueprints) بعناية:

نظم العقد داخل Blueprint باستخدام التعليقات لجعل المشروع سهل الفهم.

التدريب والممارسة:

طبق الأمثلة الصغيرة في مشاريعك لتتعلم كيفية استخدام المتغيرات بشكل فعال.

خلاصة:

المتغيرات والحسابات هما حجر الزاوية لتطوير الألعاب في Unreal Engine.

استخدم المتغيرات لتخزين القيم الديناميكية وقم بالحسابات لتنفيذ الميكانيكا.

تحتاج إلى الحسابات عند التعامل مع القيم المتغيرة أو التفاعلات المعقدة داخل اللعبة.

في Unreal Engine 4 (أو أي محرك ألعاب آخر)، المتغيرات (Variables) لا تُستخدم فقط للأشياء التي تتحرك، بل هي عنصر أساسي يمكن استخدامها في مجموعة واسعة من الحالات في أي Blueprint.

متى نستخدم المتغيرات؟

1. للتخزين الديناميكي للمعلومات:

لتخزين أي بيانات تحتاجها اللعبة أثناء تشغيلها.

أمثلة:

حالة اللاعب: الصحة، الطاقة، النقاط.

خصائص الكائنات: اللون، الحجم، السرعة.

حالة اللعبة: عدد الأعداء المتبقيين، مستوى الإضاءة.

2. للتفاعل بين الـ Blueprints:

إذا كنت بحاجة إلى تمرير معلومات بين الـ Blueprints (مثل إرسال موقع اللاعب إلى العدو).

أمثلة:

معرفة إذا كانت باب اللعبة مفتوحًا أو مغلقًا.

تمرير اسم أو نص معين لإظهاره في واجهة المستخدم (UI).

3. للأشياء القابلة للتخصيص:

يمكنك استخدام المتغيرات لتخصيص خصائص الكائنات عند إنشائها.

مثال: عدو لديه سرعة أو قوة مختلفة عن الآخرين.

4. للتكرار (Loops) والحسابات المؤقتة:

إذا كنت تجري عمليات حسابية أو تحتاج إلى تتبع عدد معين من الحلقات أو تكرار الأكواد، تستخدم المتغيرات لتخزين القيم المؤقتة.

أمثلة: عداد لجمع النقاط، أو تخزين نتائج مؤقتة لتعديل الحركة.

هل ننشئ متغيرات لكل Blueprint؟

ليس بالضرورة. 

إنشاء المتغيرات يعتمد على الحاجة:

إذا كانت هناك خاصية أو قيمة تحتاج إلى التغيير أو التتبع داخل هذا الـ Blueprint، استخدم متغير.

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

أمثلة عملية:

1. الأشياء التي تتحرك:

سرعة الحركة (Speed).

الاتجاه (Direction).

الحالة (مثلاً: هل هو يتحرك أم ثابت؟).

2. أشياء لا تتحرك:

حالة الكائن: هل هو نشط أم لا؟

خصائصه: اللون، الحجم، النص المرتبط به.

معلومات ثابتة: مثلاً نوع السلاح أو العدو.

أفضل ممارسات عند استخدام المتغيرات:

اختر أسماء واضحة:

استخدم أسماء تُعبّر عن وظيفة المتغير (مثل PlayerHealth بدلاً من Var1).

تقسيم المتغيرات حسب النوع:

استخدم Booleans للأشياء التي لها حالتان (True/False).

استخدم Floats أو Integers للأرقام.

استخدم Strings للنصوص.

استخدم Arrays لتخزين مجموعة من العناصر (مثل مواقع متعددة).

تحديد صلاحية الاستخدام (Scope):

إذا كان المتغير خاصًا بـ Blueprint واحد، اجعله محليًا.

إذا كان المتغير يجب أن يُشارك بين الـ Blueprints، استخدم Blueprint Communication أو Game Instance.

الخلاصة:

المتغيرات ليست مقتصرة على الأشياء المتحركة؛ بل هي أداة عامة لتخزين البيانات وإدارتها داخل اللعبة.

أي شيء يحتاج إلى تخزين أو تعديل أثناء اللعب هو مرشح جيد ليكون متغيرًا.

كيف ندمجها مع الدوالFunctions؟

يمكن تمرير المتغيرات كـ مدخلات (Inputs) أو تعديلها داخل الدوال.

مثال: إذا أردت أن تقلل صحة اللاعب عند إصابته، تقوم بتخزين صحة اللاعب كمتغير، ثم استخدام دالة لخصم الضرر.

سبب إنشاء المتغيرات في تصميم الألعاب:

لإبقاء معلومات قابلة للاستخدام عبر اللعبة.

لتخصيص خصائص الكائنات أو التحكم في حالات اللعبة بسهولة.

الدوال (Functions)

متى نستخدمها؟

تنفيذ منطق معين:

عندما نحتاج إلى تنفيذ عملية معينة نستخدم الدوال لتقسيم المهام إلى وحدات صغيرة.

مثال: دالة لتحديد إذا كانت اللعبة انتهت بناءً على حالة معينة.

إعادة استخدام الكود:

إذا كنت ستستخدم نفس المنطق عدة مرات، اجعلها دالة بدلاً من تكرار الكود.

مثال: دالة لتحريك الكائن إلى موقع معين.

تنظيم الكود:

الدوال تساعد في جعل الكود منظمًا وسهل الفهم.

مثال: دالة تُدير منطق "فتح الباب" عند اقتراب اللاعب.

كيف ندمجها مع المتغيرات؟

استقبال المدخلات:

 يمكن للدالة أن تأخذ متغيرات كـ Inputs لمعالجة البيانات.

مثال:

 دالة تأخذ متغيرًا يمثل الضرر (Damage) وتُقلل صحة اللاعب بناءً عليه.

تعديل المتغيرات:

 يمكن للدوال تغيير قيم المتغيرات داخلها.

مثال: 

دالة تُحدث قيمة النقاط (Score) عند جمع اللاعب للعملات.

إرجاع القيم: 

يمكن للدالة أن تعيد قيمة لتحديث متغير أو اتخاذ قرار.

مثال: 

دالة تُعيد قيمة "True" إذا كان الباب مفتوحًا.

 سبب استخدام الدوال في تصميم الألعاب بـ Blueprint

أ) الكفاءة وإعادة الاستخدام:

الدوال توفر عليك كتابة نفس الكود عدة مرات.

تجعل الصيانة والتعديل أسهل.

ب) تسهيل التفاعل مع الكائنات:

يمكن أن تحتوي الكائنات على دوال خاصة بها تتحكم في سلوكها.

مثال:

 لكل باب دالة OpenDoor تفتح الباب.

ج) تنظيم العمل:

تسهّل تقسيم المهام المعقدة إلى مهام أصغر وأكثر وضوحًا.

مثال عملي في تصميم الألعاب:

المطلوب: 

عندما يصطدم اللاعب بجسم (Enemy)، تنخفض صحته (Health).

المتغير:

PlayerHealth: متغير من نوع Float لتخزين صحة اللاعب.

Damage: متغير لتحديد مقدار الضرر.

الدالة:

اسم الدالة: ApplyDamage.

المهمة: تأخذ Damage كمدخل وتقلل PlayerHealth.

الخطوات:

قم بإنشاء المتغير PlayerHealth وأعطه قيمة أولية (مثل 100).

قم بإنشاء دالة ApplyDamage التي:

تأخذ مقدار الضرر (Damage) كمدخل.

تقلل قيمة PlayerHealth بناءً عليه.

تتحقق إذا وصلت صحة اللاعب إلى الصفر، وتقوم بإنهاء اللعبة.

دمج الدالة مع الحدث:

اربط الدالة بحدث الاصطدام مع العدو، بحيث يتم استدعاؤها عند وقوع التصادم.

خلاصة:

المتغيرات تُستخدم لتخزين البيانات التي تحتاجها أثناء اللعبة.

الدوال تُستخدم لتنفيذ العمليات التي تؤثر على تلك البيانات أو تحكم سلوك اللعبة.

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

متى تستخدم المتغيرات؟

تستخدم المتغيرات في الحالات التالية:

تخزين بيانات تحتاج إلى التحديث باستمرار:

مثال: الصحة، الذخيرة، الوقت المتبقي.

مشاركة البيانات داخل نفس Blueprint:

إذا كنت بحاجة لاستخدام نفس القيمة في أكثر من وظيفة (مثل تخزين الموقع الحالي للكائن).

التفاعل مع عقد برمجية:

مثل تخزين مرجع لكائن محدد واستخدامه لاستدعاء وظائفه.

مقارنة القيم واتخاذ القرارات:

تخزين عدد النقاط ومقارنته مع قيمة الفوز.

استخدامها عند الحاجة إلى تخزين قيمة:

إذا كانت القيمة تحتاج إلى حفظها واستخدامها لاحقًا في اللعبة.

مثال:

 حفظ نقاط اللاعب أو حالة باب مفتوح/مغلق.

استخدامها عند الحاجة إلى تعديل القيمة:

عندما يتغير شيء بناءً على أحداث في اللعبة.

مثال: تقليل صحة اللاعب بعد تعرضه لهجوم.

استخدامها عند الحاجة إلى مشاركة القيمة بين العقد:

إذا كنت تحتاج إلى استخدام نفس القيمة في أماكن متعددة.

مثال: تخزين موقع إعادة النشر لاستخدامه في أكثر من سيناريو.

متى لا تحتاج إلى المتغيرات؟

تجنب المتغيرات إذا:

القيمة لا تحتاج إلى تخزين دائم:

إذا كنت تستخدم قيمة مرة واحدة فقط ولا تحتاج إلى الاحتفاظ بها (مثل ناتج حساب لحظي).

يمكنك استخدام العقد المباشرة:

مثل الحصول على موقع كائن مباشرة من العقدة Get Actor Location بدلاً من تخزينه في متغير.

القيمة لا تتغير أبدًا:

إذا كانت قيمة ثابتة، يمكن استخدام Constants أو إدخالها مباشرة في العقد.

أفضل الممارسات:

اختيار أسماء وصفية:

اختر أسماء تعبر عن الغرض من المتغير مثل "PlayerHealth" بدلًا من "Var1".

تقليل عدد المتغيرات:

استخدم المتغيرات فقط عند الحاجة لتجنب تعقيد الـ Blueprint.

تنظيم المتغيرات:

اجمع المتغيرات المتشابهة باستخدام الفئات (Categories) لتسهيل التنظيم.

اختبار القيم:

استخدم عقدة Print String لتتبع القيم أثناء التصحيح (Debugging).

بصيغة اخرى لا نستعملها في الاوضاع التالية :

القيم المؤقتة:

إذا كانت القيمة تُستخدم فقط داخل تدفق معين ولن تُستخدم مجددًا، استخدم عقدة محلية بدلاً من متغير.

مثال: تخزين نتيجة عملية حسابية مؤقتة.

القيم الثابتة:

إذا كانت القيمة ثابتة وغير قابلة للتغيير، يمكنك استخدام Constants أو إدخال القيمة مباشرة في العقدة.

عند عدم وجود حاجة للتخزين:

إذا كنت تستطيع استنتاج القيمة مباشرة بدون تخزينها.

مثال 1: التحكم في صحة اللاعب (Player Health)

الهدف:

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

الخطوات:

إنشاء Blueprint:

اذهب إلى Content Browser، ثم أنشئ Blueprint Class من نوع Actor وسمّه PlayerHealthSystem.

إضافة Variable للصحة:

في الشريط الجانبي الأيسر، انقر على علامة "+" بجانب Variables.

سمّ المتغير PlayerHealth.

اختر النوع Float.

اضبط القيمة الافتراضية (Default Value) إلى 100.0 (مثال للصحة الكاملة).

إعداد الصحة عند تلقي الضرر:

افتح الـ Blueprint.

اسحب متغير PlayerHealth وضعه في الرسم (Node Graph).

اختر Set من القائمة.

اسحب عقدة أخرى: Event Any Damage.

اربط مخرج Damage إلى Set PlayerHealth باستخدام عملية حسابية (Float - Float).

اربط قيمة PlayerHealth المحدثة إلى العقدة.

إضافة حد أدنى للصحة:

استخدم عقدة Clamp (Float) لتحديد أن قيمة الصحة لا تقل عن 0.

إظهار الصحة في شاشة اللعب:

أضف عقدة Print String.

اربط قيمة PlayerHealth بـ To String، ثم بـ Print String.

نتيجة:

عندما يتلقى اللاعب ضررًا، ستنقص الصحة، وستظهر القيمة الجديدة في الشاشة.

مثال 2: فتح باب عند الضغط على زر

الهدف:

استخدام متغير من نوع Boolean للتحقق مما إذا كان الباب مفتوحًا أم مغلقًا.

الخطوات:

إنشاء Blueprint للباب:

أنشئ Blueprint Class من نوع Actor وسمّه DoorSystem.

إضافة متغير:

أنشئ متغير جديد باسم IsDoorOpen.

اختر النوع Boolean.

اجعل القيمة الافتراضية False.

إضافة حركة للباب:

أضف Static Mesh يمثل الباب.

أضف عقدة Timeline لتحريك الباب.

عند بدء الحركة، تحقق من حالة IsDoorOpen باستخدام عقدة Branch:

إذا كان False، قم بتحريك الباب ليفتح.

إذا كان True، أعده إلى وضع الإغلاق.

تبديل الحالة:

عند اكتمال الحركة، غيّر قيمة IsDoorOpen باستخدام عقدة Set:

إذا كان False، اجعله True والعكس.

إضافة تحكم بالضغط:

استخدم عقدة Input Action (Interact).

اربطها بمنطق فتح وإغلاق الباب.

نتيجة:

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

مثال 3: عداد النقاط (Score Counter)

الهدف:

إضافة عداد نقاط يظهر في الشاشة عندما يجمع اللاعب عناصر معينة.

الخطوات:

إعداد Blueprint للعناصر:

أنشئ Blueprint Class للعناصر القابلة للجمع وسمّه CollectibleItem.

إضافة Variable للنقاط:

في Blueprint الخاص بالشخصية، أنشئ متغير PlayerScore من النوع Integer واضبطه على 0.

جمع النقاط:

داخل CollectibleItem، أضف عقدة Event BeginOverlap.

تحقق من أن اللاعب هو من قام بالتفاعل باستخدام عقدة Cast to [Player Character].

أضف قيمة جديدة إلى PlayerScore باستخدام عقدة Set.

إظهار النقاط:

استخدم Print String لعرض قيمة PlayerScore الجديدة عند جمع عنصر.

نصائح إضافية:

التنظيم: ضع المتغيرات في تصنيفات باستخدام خاصية Category لتسهيل إدارتها.

التعليقات: أضف ملاحظات (Comments) داخل الرسم البياني لتوضيح المنطق.

الاختبار: استخدم Debug Mode لمراقبة القيم أثناء اللعب.

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

1. العناصر التي يجب تحديد أماكنها وحركاتها:

أ) العناصر المتفاعلة مع اللاعب:

أي شيء يتفاعل معه اللاعب بشكل مباشر يجب تحديد مكانه ووظيفته.

أمثلة:

الأبواب، الصناديق، الأعداء، المفاتيح، أو الأشياء القابلة للجمع (Collectibles).

تحديد مواقع الأعداء وطريقة حركتهم أو مهاجمتهم.

أزرار أو منصات يمكن للاعب استخدامها.

ب) العناصر التي تحرك القصة أو تقدم ميكانيكيات اللعبة:

أي عنصر يؤثر على تدفق اللعبة يحتاج إلى تحديد دقيق.

أمثلة:

NPCs الذين يمنحون مهامًا أو يقدمون حوارات.

العناصر الديناميكية (مثل جسر يتحرك عند الضغط على زر).

ج) العناصر ذات التأثيرات الجمالية الديناميكية:

أي شيء يتفاعل بصريًا أو صوتيًا بناءً على تصرفات اللاعب.

أمثلة:

إضاءة تتغير عند اقتراب اللاعب.

أبواب تفتح بناءً على مكان اللاعب.

2. العناصر التي لا تحتاج إلى تحديد مكانها يدويًا:

أ) العناصر الزخرفية (Decorative Objects):

أي عنصر لا يتفاعل مع اللاعب مباشرةً.

أمثلة:

الأشجار، الصخور، المباني، الخلفيات، أو الديكورات التي تضيف للجو العام.

يمكنك وضع هذه الأشياء عشوائيًا أو باستخدام أدوات مثل Foliage Tool لتعبئة العالم بسرعة.

ب) الأعداء أو الكائنات المتكررة:

يمكن إنشاء منطق Spawn System ديناميكي لوضع الأعداء أو العناصر في مواقع عشوائية أو مبرمجة دون الحاجة لتحديد كل موقع يدويًا.

أمثلة:

توليد الأعداء بناءً على موقع اللاعب.

إسقاط العناصر تلقائيًا عند تحقيق شرط معين.

3. طريق الحركة (Pathing):

أ) الأشياء المتحركة تلقائيًا:

إذا كانت لديك كائنات تتحرك وفق نمط معين (مثل الأعداء أو الكائنات الطائرة)، يمكنك استخدام:

Spline Components: لتحديد مسارات الحركة.

AI Navigation Mesh (NavMesh): للسماح للذكاء الاصطناعي بالتنقل بشكل ديناميكي بناءً على البيئة.

ب) اللاعب:

تحتاج فقط إلى تحديد البيئة (الأرض، المنصات، السلالم) التي يمكن للاعب التحرك عليها.

باستخدام NavMesh، يمكن للشخصيات الذكية معرفة طريقها دون الحاجة لتحديد كل التفاصيل يدويًا.

4. العمل على التفاصيل بشكل ديناميكي:

أ) التفاعل التلقائي:

يمكنك استخدام أدوات مثل Triggers وBlueprints لجعل العناصر تتفاعل تلقائيًا عند دخول اللاعب منطقة معينة.

مثال: عندما يدخل اللاعب غرفة، تظهر الأعداء أو تتغير الإضاءة.

ب) استخدام المنطق البرمجي:

استخدم Blueprint Logic لتحديد ما يحدث عند اقتراب اللاعب من كائن معين.

مثال: عند اقتراب اللاعب من باب، يتم تشغيل الأنيميشن الخاص بفتحه.

5. نصائح لتصميم عالم اللعبة:

أ) التخطيط أولاً:

استخدم ورقة أو أداة تخطيط لرسم خريطة العالم (تصميم المستوى) قبل البدء بوضع العناصر.

حدد العناصر المهمة (مثل النقاط التي تركز على التفاعل أو الصعوبة).

ب) تصميم متوازن:

اجعل التفاصيل أكثر في الأماكن التي يزورها اللاعب ويتفاعل معها، وقلل من التفاصيل في الخلفيات البعيدة.

ج) أدوات ديناميكية لتوفير الوقت:

استخدم أنظمة توليد المحتوى التلقائية للعناصر المتكررة.

استغل Blueprints لتقليل العمل اليدوي على العناصر المتفاعلة.

خلاصة:

حدد التفاصيل الدقيقة فقط للأشياء المتفاعلة أو التي تلعب دورًا مهمًا في اللعبة.

اجعل العناصر الزخرفية أكثر عشوائية باستخدام الأدوات المتوفرة.

استفد من الأنظمة الديناميكية مثل AI وNavMesh وBlueprint Logic لتوفير الوقت وتحسين الأداء.

Event Begin Play

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

استعمالات Event BeginPlay:

1. تهيئة الكائنات (Initialization):

إعداد المتغيرات أو الحالات الأولية الخاصة بالكائن. مثال:

تعيين قيمة صحة اللاعب إلى 100 عند بدء اللعبة.

2. تحميل البيانات:

جلب البيانات المحفوظة من ملفات أو قواعد بيانات. مثال:

تحميل النقاط أو التقدم المحفوظ للعبة.

3. تشغيل الأنظمة أو العمليات:

تشغيل أنظمة معينة عند بدء اللعبة. مثال:

تشغيل الموسيقى الخلفية أو المؤثرات الصوتية.

4. التحكم في الكاميرا:

إعداد الكاميرا أو تغيير زاويتها لتناسب المشهد الأول. 

مثال:

نقل الكاميرا إلى موقع معين عند بدء اللعبة.

5. تفعيل الحركات أو المؤثرات:

تشغيل مؤثرات مرئية أو حركات محددة عند دخول الكائن.

 مثال:

تشغيل رسوم متحركة تظهر الشخصية في البداية.

6. الربط بين الكائنات:

التحقق من وجود كائنات أخرى والتفاعل معها.

 مثال:

العثور على اللاعب في العالم باستخدام Get Player Character وربطه بالكائن.

7. ضبط واجهة المستخدم:

إنشاء أو إعداد واجهة المستخدم (UI).

 مثال:

عرض شريط الصحة أو النقاط عند بدء اللعبة.

8. إعداد الفيزياء أو الاصطدامات:

تفعيل أو تعطيل الخصائص الفيزيائية للكائنات.

 مثال:

تفعيل الجاذبية للكائنات عند بدء اللعبة.

9. التحكم في الأضواء والبيئة:

تغيير خصائص الإضاءة أو البيئة بناءً على مشهد البداية.

 مثال:

تشغيل تأثير الضباب عند بدء اللعبة.

10. تسجيل الأحداث:

إضافة الكائن إلى قائمة متابعة أو نظام إحصائي. 

مثال:

تسجيل عدد الأعداء الموجودين في المشهد.

كيفية استخدام Event BeginPlay في Blueprint:

1. إضافة العقدة:

افتح Blueprint الخاص بالكائن.

ستجد Event BeginPlay موجودة بشكل افتراضي في الرسوم البيانية (Graph).

2. تنفيذ منطق مخصص:

اربط العقدة بالأحداث أو العقد التي تريد تنفيذها عند بداية اللعبة.

أمثلة على الاستخدام:

مثال 1: إعداد صحة اللاعب

أضف متغيرًا باسم PlayerHealth (نوع Integer).

اربط Event BeginPlay بعقدة Set لتعيين قيمة الصحة إلى 100.

مثال 2: عرض رسالة ترحيبية

أضف عقدة Print String.

اربطها بـ Event BeginPlay وادخل نصًا مثل "Welcome to the Game!".

مثال 3: العثور على لاعب والتحكم بالكاميرا

استخدم عقدة Get Player Character لالتقاط مرجع اللاعب.

اضبط الكاميرا باستخدام عقدة Set View Target with Blend.

مثال 4: تشغيل موسيقى الخلفية

أضف عقدة Play Sound 2D.

اربطها بـ Event BeginPlay واختر ملف الصوت المطلوب.

مثال 5: تفعيل نظام الوقت الديناميكي

اربط Event BeginPlay بعقدة تغيير الإضاءة أو السماء.

استخدم متغيرات لتحديد الوقت الأولي (صباح/ليل).

الفرق بين Event BeginPlay و Event Tick:

Event BeginPlay

يُستدعى مرة واحدة عند بداية اللعبة

إعداد الكائنات والبيئة

منخفض التأثير على الأداء

Event Tick

يُستدعى كل إطار خلال اللعبة

العمليات المستمرة مثل تحديث الحركات

قد يؤثر سلبًا على الأداء إذا لم يُستخدم بحذر

نصائح عند استخدام Event BeginPlay:

تنظيم الكود:

قسّم العمليات المعقدة إلى دوال (Functions) لتجنب ازدحام المخطط.

الأداء:

قم فقط بإجراء العمليات الضرورية في BeginPlay لتحسين زمن التحميل.

اختبار القيم الأولية:

تأكد من أن جميع المتغيرات التي تعتمد عليها اللعبة تم إعدادها بشكل صحيح.

الترتيب:

إذا كنت تستخدم عدة كائنات تعتمد على بعضها، تأكد من أن BeginPlay يتم تنفيذها بالترتيب المطلوب.

Event Tick

Event Tick هو عقدة في Blueprint يتم تنفيذها مرة واحدة في كل إطار (Frame) أثناء تشغيل اللعبة. بمعنى آخر، يتم تشغيلها بشكل مستمر طوال الوقت بسرعة تعتمد على معدل الإطارات (FPS) الخاص باللعبة.

حاول عدم الاكثار منه لانه يستهلك الرام وقد يسبب ثقل اللعبة

أهم استعمالات Event Tick:

تحديث القيم باستمرار:

تُستخدم Event Tick لتحديث القيم المتغيرة مع الوقت، مثل:

الموقع.

الدوران.

السرعة.

مثال:

تحريك كائن في اللعبة بناءً على مدخلات اللاعب أو تغييرات بيئية.

plaintext

Event Tick → Add World Offset → Location

إجراء الحسابات الزمنية:

حساب الوقت الذي مضى منذ بدء اللعبة أو تنفيذ إجراء معين.

مثال:

قياس مدة تشغيل المؤقت (Timer) أو تنفيذ عد تنازلي.

plaintext

Copy code

Event Tick → Delta Seconds → Float Add

تحقق مستمر:

التحقق من شروط معينة خلال تشغيل اللعبة، مثل:

هل اللاعب قريب من هدف؟

هل حدث تصادم؟

مثال:

تتبع مسافة اللاعب من هدف معين، وإذا وصلت إلى قيمة معينة، يتم تنفيذ حدث.

تأثيرات ديناميكية:

تحديث تأثيرات معينة ديناميكيًا مع الوقت، مثل:

وميض الضوء.

تغيير الألوان.

مثال:

تعديل شدة إضاءة Light Source لتبدو كأنها تومض.

محاكاة الفيزياء:

تحديث الحركة أو القوى المطبقة على الكائنات في كل إطار.

مثال:

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

تحريك الكاميرا أو الكائنات:

تحريك الكاميرا بسلاسة أو جعلها تتبع اللاعب.

مثال:

الكاميرا تتحرك باستمرار لتبقى على نفس محور اللاعب.

الفرق بين Event Tick و Timer:

Event Tick:

يتم تشغيله كل إطار (Frame) بمعدل يعتمد على FPS.

يُفضل عند الحاجة إلى تحديث مستمر.

Timer:

يُشغل بشكل دوري بناءً على فترة زمنية ثابتة (مثل كل ثانية).

أقل استهلاكًا للأداء لأنه لا يعتمد على الإطارات.

نصائح عند استخدام Event Tick:

التقليل من الاستعمال غير الضروري:

Event Tick يستهلك الكثير من الموارد إذا استخدم بشكل مفرط، لأنه يعمل في كل إطار. حاول استخدامه فقط عند الضرورة.

تقسيم المنطق الثقيل:

إذا كان لديك منطق معقد، استخدم Custom Events لتوزيعه.

Delta Seconds:

استخدم Delta Seconds (المخرجة من Event Tick) لجعل العمليات الزمنية متزنة مع معدل الإطارات.

مثال: تحريك كائن بسرعة تعتمد على الوقت، وليس الإطارات.

plaintext

Copy code

Event Tick → Delta Seconds → Float Multiply → Set Actor Location

استخدام بدائل عند الحاجة:

إذا كنت تحتاج إلى تشغيل عملية معينة بشكل متكرر ولكن ليس في كل إطار، استخدم Timer by Event بدلاً من Event Tick.

مثال عملي: تحريك كائن باستخدام Event Tick

الهدف:

جعل كائن يتحرك باستمرار على المحور X.

الخطوات:

أضف Event Tick.

أضف عقدة Delta Seconds.

اضرب قيمة Delta Seconds بسرعة الحركة (مثل 100).

أضف النتيجة إلى موقع الكائن باستخدام Add Actor World Offset.

النتيجة:

الكائن يتحرك بسلاسة على المحور X بناءً على الوقت، وليس الإطارات.

متى لا تستخدم Event Tick؟

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

عندما يمكنك استخدام Timer أو Custom Event مع منطق محدد.

إذا كنت بحاجة إلى تكرار حدث بمعدل زمني ثابت.

Event TouchEnter

ما سيحدث عند اللمس في العاب الهواتف

Event Touch Enter هو حدث (Event) يُستخدم في Blueprints للكشف عن لمسة أولى على شاشة الجهاز (مثل الهواتف الذكية أو الأجهزة اللوحية) أو عند بدء لمس واجهة اللعبة باستخدام الشاشة اللمسية.

استعمالات Event Touch Enter:

1. التفاعل مع العناصر في العالم:

يُستخدم لتنفيذ أحداث عند لمس اللاعب كائنًا معينًا.

مثال: إذا لمس اللاعب زرًا أو عنصرًا في البيئة، يتم تفعيل حدث معين مثل فتح باب أو تشغيل مؤثر صوتي.

2. التحكم في حركة الكائنات:

يمكن استخدامه لتحريك كائن أو شخصية بناءً على موقع اللمس.

مثال: لمس الشاشة لتحريك كائن إلى موقع اللمس.

3. إنشاء واجهات تفاعلية (Interactive UI):

عند لمس زر أو عنصر تفاعلي في واجهة المستخدم (Widget)، يمكنك تشغيل أحداث محددة مثل:

بدء اللعبة.

الانتقال إلى شاشة جديدة.

تشغيل قائمة.

4. إضافة تأثيرات بصرية:

يمكن تشغيل تأثير بصري في مكان اللمس.

مثال: عند لمس الشاشة، يتم إنشاء تأثير انفجار صغير أو دائرة مضيئة في الموقع.

5. التحكم في الكاميرا:

التحكم في الكاميرا أو زاوية الرؤية بناءً على موقع اللمس.

مثال: لمس الشاشة لتدوير الكاميرا أو تقريبها.

6. الألعاب القائمة على اللمس:

يُستخدم Event Touch Enter لبناء ألعاب تعتمد على التفاعل اللمسي، مثل ألعاب الألغاز، الرسم، أو الألعاب الحركية.

كيفية استخدام Event Touch Enter:

1. إضافة الحدث:

افتح الـ Blueprint الخاص بك.

أضف عقدة Event Touch Enter من قسم Input Events.

2. الحصول على بيانات اللمس:

Finger Index: يحدد أي إصبع تم استخدامه (في حالة اللمسات المتعددة).

Location: يعطي موقع اللمسة على الشاشة.

Touch Input Handle: مرجع لعملية اللمس الحالية.

3. تنفيذ أحداث بناءً على اللمس:

بناءً على Finger Index وLocation، يمكنك إنشاء منطق للتحكم أو التفاعل.

أمثلة عملية:

مثال 1: تحريك كائن إلى موقع اللمس

أضف Event Touch Enter.

استخدم Get Hit Result Under Finger by Channel للحصول على موقع اللمسة في العالم.

اربط الموقع بعقدة Set Actor Location لتحريك الكائن.

مثال 2: إضافة تأثير بموضع اللمس

أضف Event Touch Enter.

احصل على موقع اللمسة باستخدام Get Hit Result Under Finger by Channel.

أضف مؤثرًا بصريًا (مثل Particle Effect) في الموقع باستخدام عقدة Spawn Emitter at Location.

مثال 3: التنقل بين القوائم باستخدام اللمس

عند لمس زر معين على الشاشة، استخدم Event Touch Enter.

اربطه بعقدة Open Level أو Set Visibility لتغيير المشهد أو إظهار واجهة جديدة.

ملاحظات مهمة:

الأجهزة المدعومة:

Event Touch Enter يعمل بشكل أساسي على الأجهزة التي تدعم الشاشات اللمسية (الهواتف الذكية، الأجهزة اللوحية).

الفرق بين Touch Events وMouse Events:

Touch Events مخصصة للشاشات اللمسية، بينما Mouse Events تعمل مع الماوس على أجهزة الحاسوب.

لمسات متعددة:

يمكنك استخدام Finger Index للتعامل مع اللمسات المتعددة في وقت واحد.

متى تستخدم Event Touch Enter؟

في الألعاب أو التطبيقات المخصصة للأجهزة اللمسية.

عندما تحتاج إلى استجابة فورية لأول لمسة على الشاشة.

إذا كان لديك عناصر تفاعلية تتطلب إدخال لمس مباشر.

Event TouchLeave

حدث يعطيك ما سيحدث عند رفع اصبعك من اللمس

Event Touch Leave هو حدث (Event) يُطلق عند انتهاء لمسة على الشاشة وخروج الإصبع من منطقة التفاعل الخاصة بالكائن أو واجهة المستخدم. بمعنى آخر، يُستخدم لتحديد متى يترك اللاعب كائنًا أو سطحًا تفاعليًا بعد لمس الشاشة.

استعمالات Event Touch Leave:

1. إنهاء تفاعل اللاعب مع كائن معين:

يُستخدم لإنهاء أحداث أو منطق بدأ عند لمس اللاعب الكائن.

مثال: إذا لمس اللاعب زرًا لإبقاء المصعد يتحرك، يتم إيقاف الحركة عندما يترك اللمسة.

2. إعادة ضبط الحالة:

إعادة الكائن أو النظام إلى حالته الافتراضية عند انتهاء التفاعل.

مثال:

إغلاق قائمة عند إزالة اللمسة.

إيقاف تغيير اللون أو الحركة عند ترك اللمسة.

3. إنشاء تجربة مستخدم ديناميكية:

يمكن استخدامه لتوفير استجابات فورية عند انتهاء التفاعل.

مثال:

عند ترك كائن مرئي مثل زر، يمكن تغيير لونه للإشارة إلى انتهاء التفاعل.

4. تحسين واجهات المستخدم (UI):

يستخدم مع الأزرار أو العناصر التفاعلية الأخرى لإيقاف الأحداث عند توقف لمس العنصر.

5. إلغاء الأوامر عند إيقاف اللمس:

إذا كان حدث معين يعتمد على استمرار لمس اللاعب (مثل شحن سلاح)، يمكن إلغاء العملية عند انتهاء اللمسة.

كيفية استخدام Event Touch Leave في Blueprints:

1. إضافة الحدث:

افتح الـ Blueprint الخاص بك (مثل Actor أو Widget).

أضف عقدة Event Touch Leave من قسم Input Events.

2. الحصول على تفاصيل اللمسة:

Finger Index: لتحديد أي إصبع كان يتفاعل مع الكائن.

Touch Input Handle: لمعرفة تفاصيل عملية اللمس الحالية.

3. تنفيذ الأحداث عند انتهاء اللمسة:

اربط الحدث بما تريد تنفيذه عند ترك الكائن.

أمثلة عملية:

مثال 1: إيقاف حركة كائن عند ترك اللمس

أضف Event Touch Enter وابدأ حركة الكائن عند لمس الشاشة.

أضف Event Touch Leave لإيقاف الحركة عند ترك الشاشة.

الناتج:

الكائن يتحرك فقط أثناء لمس الشاشة ويتوقف عند انتهاء اللمسة.

مثال 2: تغيير لون كائن عند لمس وترك الشاشة

عند Event Touch Enter، قم بتغيير لون الكائن إلى لون نشط.

عند Event Touch Leave، أعد اللون إلى الحالة الأصلية.

الناتج:

يظهر التأثير بصريًا عند لمس وترك الكائن.

مثال 3: إنهاء تفاعل تفاعلي مع قائمة

إذا لمس اللاعب قائمة (Widget) باستخدام Event Touch Enter، افتح القائمة أو قم بإجراء معين.

عند Event Touch Leave، أغلق القائمة أو أوقف التفاعل.

الناتج:

تتحكم اللمسة وإزالتها في ظهور القائمة واختفائها.

متى تستخدم Event Touch Leave؟

إدارة التفاعلات الديناميكية:

عندما ترغب في توفير استجابة فورية عند انتهاء التفاعل.

على سبيل المثال، إيقاف حركة، أو إلغاء اختيار عنصر.

إضافة تفاصيل لواجهة المستخدم:

عندما تريد تحسين تجربة المستخدم بميزات ديناميكية تعتمد على وقت اللمس.

إنهاء العمليات المستمرة:

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

Event AnyDamage

حدث اي ضرر يستعمل مع امر apply Damage تفعيل الضرر

damaged actor تحدد الشكل المرغوب ان تدمجه

Damage تحدد مقدار الضرر 

Damage Causer مسبب الدمج

Event Any Damage هو حدث (Event) يتم تشغيله عندما يتلقى الكائن (Actor) أي نوع من الضرر (Damage) داخل اللعبة. يتم استخدامه لإدارة العمليات المتعلقة بالصحة (Health)، أو الكائنات القابلة للتدمير، أو أي منطق آخر يعتمد على تلقي الضرر.

استعمالات Event Any Damage:

1. تقليل الصحة (Health Reduction):

يستخدم لتقليل قيمة الصحة الخاصة بالكائن عندما يتلقى ضررًا.

مثال:

عند ضرب لاعب أو عدو بسلاح، يتم تقليل نقاط الصحة بناءً على قيمة الضرر.

2. تشغيل أحداث عند تلقي الضرر:

يمكن تفعيل تأثيرات معينة عند حدوث الضرر، مثل:

عرض تأثيرات بصرية (مثل وميض الشاشة).

إصدار صوت أو تأثير صوتي.

تغيير لون الكائن لإظهار الضرر.

3. تدمير الكائن (Destroy Actor):

يستخدم للتحقق مما إذا كانت صحة الكائن وصلت إلى الصفر وتدميره إذا لزم الأمر.

مثال:

عند انتهاء صحة العدو، يتم تدميره وإضافة نقاط إلى اللاعب.

4. حسابات الضرر المعقدة:

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

الضرر المباشر (Direct Damage).

الضرر المستمر (مثل الحريق أو السموم).

الضرر الناتج عن الانفجارات.

5. التفاعل مع أنواع معينة من الأسلحة:

يمكن تخصيص المنطق بناءً على مصدر الضرر أو نوعه.

مثال:

ضرر إضافي إذا كان السلاح المستخدم هو قنبلة.

تقليل الضرر إذا كان الكائن لديه درع.

6. عرض معلومات الضرر:

عرض قيمة الضرر الذي تلقاه الكائن (مثل أرقام تطفو فوق العدو عند الهجوم).

تفاصيل عقدة Event Any Damage:

Damage:

كمية الضرر التي تلقاها الكائن.

Damage Type:

نوع الضرر (مثل حريق، انفجار، أو ضرر عادي).

يمكن تخصيص منطق مختلف بناءً على هذا النوع.

Instigator:

يشير إلى الكائن (Player Controller أو Actor) الذي تسبب في الضرر.

Damage Causer:

الكائن الذي أطلق الضرر (مثل قذيفة أو طلقة).

كيفية استخدام Event Any Damage:

1. تقليل الصحة:

في الكائن (Actor)، أضف Event Any Damage.

أضف متغير Health من النوع Float.

اسحب متغير Health وأضف عقدة Set.

استخدم Subtract Float لطرح قيمة الضرر من الصحة.

تحقق من أن القيمة الجديدة للصحة أكبر من صفر باستخدام عقدة Branch:

إذا كانت القيمة ≤ 0، قم بتدمير الكائن.

2. تأثير بصري عند تلقي الضرر:

أضف Event Any Damage.

اربطها بعقدة Spawn Emitter at Location لتشغيل تأثير انفجار أو شرار.

3. عرض رقم الضرر:

أضف Event Any Damage.

اربط قيمة Damage بعقدة Print String لعرض الرقم على الشاشة.

4. تخصيص الضرر بناءً على النوع:

أضف Event Any Damage.

استخدم عقدة Switch on Damage Type.

نفّذ منطقًا مختلفًا بناءً على نوع الضرر:

حريق: قلل الصحة تدريجيًا.

انفجار: قلل الصحة مباشرة وأضف قوة دفع.

مثال عملي: نظام صحة بسيط

إنشاء Blueprint للشخصية:

أضف متغير Health واجعل قيمته الافتراضية 100.

معالجة الضرر:

أضف Event Any Damage.

قم بتقليل قيمة Health بناءً على الضرر المستلم.

إظهار تأثيرات عند تلقي الضرر:

اربط الحدث بـ Spawn Emitter at Location لتشغيل تأثيرات بصرية.

أضف Print String لعرض قيمة الضرر.

التحقق من الصحة:

إذا كانت الصحة ≤ 0، استخدم Destroy Actor لتدمير الكائن.

نصائح عند استخدام Event Any Damage:

تجنب الاستخدام العشوائي:

تأكد من أن الحدث يُستخدم فقط للكائنات التي تحتاج إلى منطق خاص بالضرر.

تنظيم أنواع الضرر:

استخدم فئات Damage Type Classes لتنظيم وإدارة أنواع الضرر.

تجنب الحسابات الثقيلة:

حاول تقليل العمليات الثقيلة عند تنفيذ الحدث، خاصة إذا كان الكائن يتلقى الضرر بشكل متكرر.

اختبار السيناريوهات المختلفة:

تأكد من أن كل نوع ضرر يعمل كما هو متوقع.

كيفية جعل الشخصية تضرب باللكم أو السيف أو السلاح باستخدام Blueprints في Unreal Engine

1. فهم النظام الأساسي:

في Unreal Engine، يمكن تنفيذ الضرب أو الهجوم باستخدام Animations وHit Detection (كشف الاصطدام) ومنطق اللعبة الذي يتحكم في كيفية تأثير الضربات على الأعداء أو الكائنات.

الخطوات التفصيلية

الجزء الأول: إعداد الرسوم المتحركة (Animations)

إضافة حركة الضرب (Attack Animation):

احصل على ملفات الرسوم المتحركة المناسبة (مثل حركة اللكم أو ضرب السيف).

أضف هذه الرسوم المتحركة إلى Animation Blueprint الخاص بالشخصية.

إنشاء حدث AnimNotify:

افتح حركة الضرب في محرر الرسوم المتحركة.

في الخط الزمني للحركة، أضف AnimNotify عند نقطة التأثير (مثل عند وصول قبضة اليد أو السيف للهدف).

ربط AnimNotify بحدث:

داخل Animation Blueprint، اربط AnimNotify بحدث يتم تشغيله خلال الرسوم المتحركة.

الجزء الثاني: إنشاء نظام الضرب باستخدام Blueprints

1. إعداد المدخلات (Input Setup):

افتح Project Settings:

انتقل إلى Input.

أضف إدخالًا جديدًا، مثل:

Punch: مفتاح لوحة المفاتيح أو زر وحدة التحكم.

Attack: للاستخدام مع السيف أو السلاح.

2. تنفيذ الضربات في Blueprint:

افتح Character Blueprint الخاص بك (مثل ThirdPersonCharacter).

إضافة زر الهجوم:

اسحب العقدة Input Action Attack أو Punch.

اربطها بعقدة Play Animation لتشغيل حركة الضرب.

تفعيل الضرر أثناء الهجوم:

استخدم AnimNotify لتحديد لحظة الهجوم.

عندما يتم تشغيل AnimNotify:

قم بالكشف عن التصادم باستخدام Sphere Trace by Channel أو Line Trace by Channel.

الجزء الثالث: كشف الاصطدام وإحداث الضرر

تحديد منطقة التأثير:

استخدم Sphere Trace by Channel لتحديد منطقة الضرب:

نقطة البداية: موقع اليد أو السيف (استخدم Socket Location).

نقطة النهاية: نقطة أمام اليد أو السيف بناءً على الاتجاه.

الاعداد

Event AnimNotify → Sphere Trace by Channel → Break Hit Result → Apply Damage

إحداث الضرر:

أضف عقدة Apply Damage للهدف المتضرر (Actor الذي تم لمسه بواسطة Trace).

قم بتحديد مقدار الضرر المطلوب.

الجزء الرابع: تخصيص الضربات حسب السلاح

1. اللكمات (Punch):

استخدم الرسوم المتحركة للكم.

عند تشغيل AnimNotify:

استخدم Line Trace للكشف عن هدف أمام اليد.

إذا تم العثور على هدف:

أضف تأثيرًا (مثل وميض أحمر) باستخدام Spawn Emitter.

طبق الضرر باستخدام Apply Damage.

2. السيف (Melee Weapon):

إضافة السيف:

أضف Mesh خاص بالسيف إلى شخصية اللاعب.

اربطه بعظم اليد باستخدام Socket.

كشف الضربات بالسيف:

استخدم Box Collision حول السيف.

عند بدء حركة الهجوم:

فعّل التصادم باستخدام Set Collision Enabled.

عند انتهاء الحركة:

عطّل التصادم.

إحداث الضرر عند التصادم:

عند ضرب الهدف بالسيف (OnComponentHit):

طبق الضرر باستخدام Apply Damage.

شغل تأثيرات بصرية أو صوتية.

3. الأسلحة النارية:

إطلاق النار:

عند الضغط على زر Fire:

استخدم Line Trace لإطلاق خط وهمي من السلاح إلى الأمام.

إذا أصاب الخط هدفًا:

طبق الضرر باستخدام Apply Damage.

إضافة تأثيرات السلاح:

عند إطلاق النار:

شغل تأثير الإطلاق باستخدام Spawn Emitter.

أضف صوت إطلاق النار باستخدام Play Sound at Location.

أمثلة عملية:

1. إنشاء لكمة بسيطة:

Input Action Punch → Play Animation (Punch)

عند AnimNotify:

Sphere Trace by Channel أمام اليد.

إذا أصاب هدفًا:

Apply Damage.

تشغيل تأثير صوتي.

2. تفعيل السيف:

عند الضغط على Attack:

Play Animation (Sword Swing)

فعّل تصادم السيف:

Set Collision Enabled → Query and Physics.

عند انتهاء الرسوم المتحركة:

عطّل التصادم.

3. إطلاق النار:

عند الضغط على Fire:

Line Trace by Channel:

إذا أصاب هدفًا:

طبق الضرر.

شغل تأثيرات مثل الانفجار.

نصائح:

تحسين الأداء:

تجنب استخدام Event Tick مع كشف الاصطدام؛ استخدم AnimNotify لتقليل العمليات الحسابية.

تأثيرات بصرية:

أضف تأثيرات جذابة (Particles) عند الضرب لجعل اللعبة أكثر تفاعلية.

إدارة أنواع الأسلحة:

استخدم متغيرًا لتحديد نوع السلاح الحالي (Punch, Sword, Gun) وقم بتبديل المنطق بناءً عليه.

Event Hit

حدث الضرب يشغل لنا هذا الكود مرة واحدة فقط 

hit location موقع الضربة

othrt مسبب هذا الضرب

break Hit result قائمة اكثر تفصيلا

trace start بداية الشعاع الذي ينتطلق 

Trace End نهاية الشعاع اللذي تم اطلاقه

Hit component ضرب المجسم

Event Hit هو حدث (Event) يتم استدعاؤه عندما يتصادم (يُضرب) كائن معين (Actor أو Component) بكائن آخر داخل العالم الافتراضي. يمكن استخدامه لإدارة مجموعة واسعة من السلوكيات المرتبطة بالاصطدامات.

استعمالات Event Hit:

1. إحداث ضرر عند الاصطدام:

يُستخدم لتطبيق ضرر عند اصطدام الكائن بكائن آخر.

مثال:

عند اصطدام طلقة (Projectile) بالعدو، يتم تقليل صحة العدو بناءً على قوة الاصطدام.

2. تفعيل أحداث فيزيائية:

يُستخدم لتطبيق قوى رد فعل بناءً على تفاصيل الاصطدام (مثل الاتجاه والقوة).

مثال:

دفع الكائن عند الاصطدام بجسم متحرك.

3. تشغيل تأثيرات مرئية وصوتية:

تشغيل تأثيرات عند حدوث الاصطدام، مثل:

شرار عند اصطدام سيارة بجدار.

صوت اصطدام أو كسر.

4. تدمير الكائنات عند الاصطدام:

يمكن استخدامه لتدمير الكائن عند اصطدامه. مثال:

تدمير قذيفة صاروخية عندما تصطدم بأي شيء.

5. كشف الاصطدامات لمعالجة المنطق:

يستخدم للكشف عن الاصطدام مع كائنات معينة بناءً على تصنيفات (Tags) أو أنواع.

مثال:

إذا اصطدم اللاعب بكائن يحمل تصنيفًا "Enemy"، يتم تشغيل حدث خاص.

6. تسجيل بيانات التصادم:

يمكنك استخدامه لجمع معلومات حول الاصطدام لتحليلها أو استخدامها.

مثل:

قوة الاصطدام.

النقطة التي حدث فيها الاصطدام.

الجسم الذي اصطدمت به.

7. إيقاف الحركة أو تغيير الاتجاه:

يمكن استخدامه لإيقاف حركة الكائن أو تعديل اتجاهه بعد الاصطدام.

مثال:

كرة ترتد عن جدار بناءً على زاوية الاصطدام.

تفاصيل عقدة Event Hit:

Hit Actor:

الكائن الذي تم الاصطدام به.

Hit Location:

النقطة التي حدث فيها الاصطدام.

Hit Normal:

الاتجاه العمودي على السطح عند نقطة الاصطدام.

Impact Point:

النقطة المحددة بدقة حيث حدث التأثير.

Impact Normal:

الاتجاه العمودي على السطح عند نقطة التأثير.

Velocity:

سرعة الكائن عند حدوث الاصطدام.

Phys Material:

المادة الفيزيائية للكائن الذي تم الاصطدام به (مثل المعدن، الخشب).

كيفية استخدام Event Hit:

1. تطبيق ضرر عند الاصطدام:

أضف Event Hit إلى Blueprint الخاص بالكائن.

أضف عقدة Apply Damage.

اربط Other Actor من Event Hit بعقدة Apply Damage لتطبيق الضرر على الكائن المصطدم به.

2. إنشاء تأثير عند الاصطدام:

أضف Event Hit.

أضف عقدة Spawn Emitter at Location.

اربط Hit Location لتحديد موقع التأثير.

3. ارتداد الكائن عند الاصطدام:

أضف Event Hit.

أضف عقدة Launch Character أو Add Impulse.

استخدم Hit Normal لتحديد اتجاه الدفع.

4. كشف الاصطدام مع كائن محدد:

أضف Event Hit.

استخدم عقدة Compare Tag للتحقق من نوع الكائن المصطدم.

قم بتشغيل منطق محدد بناءً على النتيجة.

أمثلة عملية:

مثال 1: تدمير كائن عند الاصطدام

افتح Blueprint الخاص بالكائن (مثل Projectile).

أضف Event Hit.

أضف عقدة Destroy Actor لتدمير الكائن عند الاصطدام.

مثال 2: دفع اللاعب عند الاصطدام بجسم متحرك

أضف Event Hit إلى الكائن المتحرك.

استخدم Add Impulse لتطبيق قوة دفع على اللاعب بناءً على Hit Normal.

مثال 3: تغيير لون السطح عند الاصطدام

أضف Event Hit.

استخدم عقدة Set Material لتغيير مادة السطح المصطدم به.

مثال 4: إحداث ضرر مع تأثير صوتي ومرئي

أضف Event Hit.

اربط:

Apply Damage لتقليل الصحة.

Spawn Emitter at Location لإضافة تأثير مرئي.

Play Sound at Location لتشغيل صوت.

نصائح عند استخدام Event Hit:

التأكد من الإعدادات الفيزيائية:

يجب تمكين إعدادات التصادم للكائنات المتفاعلة (Collision Enabled).

تجنب الإفراط في العمليات الحسابية:

إذا كان لديك عدد كبير من الكائنات التي تستخدم Event Hit، تأكد من تحسين الكود لتجنب انخفاض الأداء.

استخدام الفلاتر:

استخدم Collision Channels أو Tags لتحديد الكائنات التي تتفاعل مع Event Hit.

الفرق بين Event Hit و Event Overlap:

Event on StartCrouch

Event on EndCrouch

حدث بداية ونهاية الانحناء 

Event On Start Crouch هو حدث (Event) يتم استدعاؤه عند بدء اللاعب أو الشخصية وضعية الانحناء (Crouching). يُستخدم هذا الحدث في Blueprints لتفعيل أي منطق أو تأثيرات تتعلق بعملية الانحناء.

استعمالات Event On Start Crouch:

1. تغيير السرعة أثناء الانحناء:

تعديل سرعة حركة الشخصية لجعلها أبطأ أثناء وضعية الانحناء.

مثال:

تقليل سرعة اللاعب إلى 50% من السرعة الأصلية.

2. تغيير التصادم (Collision):

ضبط حجم تصادم الشخصية لتتناسب مع وضعية الانحناء.

مثال:

تقليل ارتفاع الشخصية لتجنب الاصطدام بالأشياء المنخفضة.

3. تفعيل الرسوم المتحركة (Animation):

تشغيل رسوم متحركة مخصصة لوضعية الانحناء.

مثال:

تشغيل حركة Crouching Idle عند بدء الانحناء.

4. تفعيل تأثيرات بصرية:

إضافة تأثيرات عند الانحناء لجعل اللعبة أكثر تفاعلية.

مثال:

خفض الكاميرا تدريجيًا لمحاكاة الانحناء.

تشغيل تأثير ظل أو تغيير لون الشخصية عند الانحناء.

5. تفعيل صوتيات:

تشغيل صوت عند بدء الانحناء.

مثال:

صوت حركة الملابس أو الاحتكاك بالأرض.

6. تحسين أسلوب اللعب (Gameplay Enhancements):

تنفيذ منطق خاص يعتمد على وضعية الانحناء:

أمثلة:

تحسين قدرة اللاعب على التسلل (Stealth).

إخفاء اللاعب عن الأعداء أثناء الانحناء.

7. التفاعل مع البيئة:

جعل الشخصية قادرة على المرور من خلال مناطق منخفضة أو تحت الأجسام.

مثال:

عند بدء الانحناء، السماح بالدخول إلى ممر منخفض.

8. تغيير منظور الكاميرا:

تعديل زاوية الكاميرا لتناسب وضعية الانحناء.

مثال:

تقريب الكاميرا من الأرض أو خفضها قليلاً.

كيفية استخدام Event On Start Crouch في Blueprints:

1. إعداد الوظيفة في Blueprint:

افتح Character Blueprint.

أضف حدث Event On Start Crouch من قائمة الأحداث.

2. تقليل السرعة أثناء الانحناء:

أضف عقدة Set Max Walk Speed.

اربطها بـ Event On Start Crouch.

ضع قيمة أقل للسرعة (مثل 150 بدلًا من 600).

3. خفض الكاميرا عند الانحناء:

أضف متغيرًا يسمى Crouch Camera Offset لتحديد المسافة التي تتحرك بها الكاميرا.

أضف عقدة Set Relative Location لمكون الكاميرا.

اربطها بـ Event On Start Crouch لتغيير موقع الكاميرا.

4. تشغيل رسوم متحركة مخصصة:

أضف متغيرًا يسمى IsCrouching لتتبع حالة الانحناء.

في Animation Blueprint، أضف منطقًا لتشغيل الحركة بناءً على IsCrouching.

قم بتحديث المتغير عند بدء الحدث.

5. تفعيل تأثير صوتي:

أضف عقدة Play Sound at Location.

اربطها بـ Event On Start Crouch.

مثال عملي: تحسين نظام التسلل

هدف المثال:

جعل الشخصية تتحرك ببطء أثناء الانحناء مع تقليل صوت الحركة وزيادة التفاعل مع البيئة.

الخطوات:

تقليل السرعة:

عند بدء الانحناء:

استخدم Set Max Walk Speed لتقليل سرعة الحركة.

عند الخروج من الانحناء:

أعد السرعة إلى القيمة الأصلية.

خفض مستوى الصوت:

أضف متغيرًا لتقليل حجم الأصوات الناتجة عن الحركة أثناء الانحناء.

تغيير التصادم:

استخدم Set Capsule Half Height لتقليل ارتفاع الشخصية.

تفعيل التفاعل مع الأعداء:

أضف منطقًا يخفض فرصة اكتشاف الشخصية من قبل الأعداء أثناء الانحناء.

Event on EndCrouch حين يعود للحالة الطبيعية ونهاية الانحناء

Event ActorBeginOverlap

يشبه امر Hit ولكن هذا يمكن تكراره اكثر من مرة 

Event ActorBeginOverlap هو حدث (Event) في Blueprints يتم استدعاؤه عندما يدخل كائن (Actor) معين في منطقة تصادم (Collision Area) لكائن آخر. يمكن استخدامه لتفعيل منطق مخصص عند حدوث التداخل (Overlap).

استعمالات Event ActorBeginOverlap:

1. بدء التفاعل مع الكائنات:

تفعيل منطق أو سلوك عند دخول لاعب أو كائن معين في منطقة محددة.

مثال:

فتح الباب عندما يقترب اللاعب من منطقة الباب.

2. جمع العناصر (Pickup Items):

يُستخدم لتحديد متى يلتقط اللاعب عناصر مثل الأسلحة، الصحة، أو الذخيرة.

مثال:

عند دخول اللاعب إلى منطقة الكائن، يتم إخفاؤه وإضافته إلى مخزون اللاعب.

3. تفعيل أفخاخ أو عوائق:

يُستخدم لتشغيل فخ عندما يدخل اللاعب منطقة التفاعل.

مثال:

إطلاق سهم أو تفعيل انفجار عند دخول اللاعب منطقة الفخ.

4. تنشيط المناطق أو الأنظمة:

تنشيط منطقة معينة عند دخول كائن محدد.

مثال:

تشغيل إضاءة أو تأثير عندما يدخل اللاعب منطقة محددة.

5. بدء الحوارات أو النصوص التوضيحية:

يمكن استخدامه لعرض حوار أو نصوص على الشاشة عندما يدخل اللاعب منطقة معينة.

مثال:

إظهار رسالة "اضغط E للتفاعل" عند الاقتراب من كائن.

6. التحكم بالكاميرا:

تغيير موضع الكاميرا أو إعداداتها عند دخول منطقة معينة.

مثال:

تفعيل وضع الكاميرا السينمائي عندما يدخل اللاعب منطقة معينة.

7. إحداث ضرر عند التداخل:

يُستخدم لتطبيق ضرر عندما يدخل كائن منطقة معينة.

مثال:

تقليل صحة اللاعب عند دخوله منطقة حمم بركانية أو ميدان كهربائي.

8. تغيير خصائص الكائنات:

تعديل خصائص كائن معين عند حدوث التداخل.

مثال:

عند دخول لاعب إلى منطقة، يتم تغيير لون أو حجم كائن محدد.

كيفية استخدام Event ActorBeginOverlap في Blueprints

1. إعداد عقدة Event ActorBeginOverlap:

افتح Blueprint الخاص بالكائن الذي تريد التعامل معه.

أضف Event ActorBeginOverlap من قائمة الأحداث.

2. استخدام العقد المرتبطة:

Other Actor:

يشير إلى الكائن الذي دخل منطقة التداخل.

Get Class:

للتحقق من نوع الكائن (مثلاً إذا كان لاعبًا أو عدوًا).

Compare Tag:

للتحقق من وجود Tag معين على الكائن.

3. أمثلة على التنفيذ:

مثال 1: جمع عنصر (Pickup Item):

أضف Event ActorBeginOverlap.

تحقق مما إذا كان الكائن المتداخل هو اللاعب باستخدام Cast to Character.

أضف الكائن إلى مخزون اللاعب باستخدام متغير.

قم بإخفاء العنصر باستخدام Set Visibility أو تدميره باستخدام Destroy Actor.

مثال 2: إحداث ضرر عند التداخل:

أضف Event ActorBeginOverlap.

تحقق مما إذا كان الكائن المتداخل هو اللاعب.

استخدم Apply Damage لتقليل صحة اللاعب.

مثال 3: فتح باب عند الاقتراب:

أضف Event ActorBeginOverlap.

تحقق مما إذا كان الكائن هو اللاعب.

شغل حركة فتح الباب باستخدام Timeline أو Play Animation.

مثال 4: تفعيل تأثير مرئي وصوتي:

أضف Event ActorBeginOverlap.

أضف عقدة Spawn Emitter at Location لتشغيل تأثير.

أضف عقدة Play Sound at Location لتشغيل صوت.

نصائح لتحسين الاستخدام:

تحسين الأداء:

استخدم Collision Channels لضبط التداخل فقط مع الكائنات المطلوبة.

تجنب تشغيل منطق ثقيل عند كل تداخل.

التحقق من نوع الكائن:

استخدم Tags أو Cast to للتحقق من أن الكائن هو النوع الصحيح قبل تنفيذ المنطق.

التعامل مع التداخل المتكرر:

تأكد من إضافة منطق يمنع التداخل المتكرر إذا لم يكن ضروريًا.

Event Destroyed

عندما يتم تدمير البلوبرينت يشتغل هذا الكود

Event Destroyed هو حدث (Event) يُستدعى عندما يتم تدمير كائن (Actor) داخل العالم الافتراضي. يحدث هذا الحدث بعد استدعاء وظيفة Destroy Actor أو عندما يتم إنهاء وجود الكائن لأي سبب آخر.

استعمالات Event Destroyed:

1. تنظيف الموارد:

يُستخدم للتأكد من تحرير الموارد التي استخدمها الكائن قبل تدميره.

مثال:

إزالة العناصر المرتبطة بالكائن من واجهة المستخدم أو القائمة.

2. إحداث تأثيرات بعد التدمير:

تشغيل تأثيرات مرئية أو صوتية عند تدمير الكائن.

مثال:

تشغيل انفجار أو ظهور غبار عند تدمير جسم.

3. إرسال إشعارات أو إشارات:

يمكن استخدامه لإرسال إشارات إلى أنظمة أخرى لإعلامها بأن الكائن قد تم تدميره.

مثال:

تحديث عداد الأعداء عند تدمير أحد الأعداء.

4. التحكم في سلوك الشخصيات الأخرى:

تعديل سلوك شخصيات أو كائنات أخرى بناءً على تدمير الكائن.

مثال:

عند تدمير قائد العدو، يمكن جعل الجنود يفرّون.

5. إنهاء أحداث أو عمليات جارية:

التأكد من إيقاف أي عمليات جارية ترتبط بالكائن.

مثال:

إنهاء تأثير ضرر مستمر أو إيقاف صوت معين مرتبط بالكائن.

6. إسقاط مكافآت أو عناصر:

إسقاط العناصر عند تدمير الكائن.

مثال:

عند تدمير عدو، يتم إسقاط ذخيرة أو نقاط صحة.

7. تسجيل الإحصائيات:

تسجيل معلومات حول الكائن قبل تدميره لأغراض التحليل أو التقييم.

مثال:

تسجيل عدد الأعداء الذين تم القضاء عليهم في المستوى.

8. التفاعل مع البيئة:

تعديل البيئة بناءً على تدمير الكائن.

مثال:

عند تدمير بوابة، يتم فتح طريق جديد.

كيفية استخدام Event Destroyed في Blueprints:

1. إعداد العقدة:

افتح Blueprint الخاص بالكائن الذي تريد استخدامه.

أضف عقدة Event Destroyed من قائمة الأحداث.

2. أمثلة على التنفيذ:

مثال 1: تشغيل تأثير انفجار عند التدمير

أضف Event Destroyed.

اربطها بعقدة Spawn Emitter at Location لتشغيل تأثير الانفجار.

استخدم Get Actor Location لتحديد موقع الكائن.

مثال 2: إرسال إشعار إلى اللاعب

أضف Event Destroyed.

أضف عقدة Print String لعرض رسالة على الشاشة.

استخدم النص "تم تدمير الكائن!" لإعلام اللاعب.

مثال 3: إسقاط عنصر عند التدمير

أضف Event Destroyed.

استخدم Spawn Actor لإنشاء عنصر جديد عند موقع الكائن.

اربط ذلك بموقع الكائن باستخدام Get Actor Location.

مثال 4: تحديث عداد الأعداء

أضف Event Destroyed إلى Blueprint الخاص بالعدو.

اربطها بعقدة Get Game Mode لاستدعاء وظيفة داخل Game Mode.

قلل عداد الأعداء عند تدمير كل عدو.

مثال 5: تنظيف الموارد أو إنهاء العمليات

أضف Event Destroyed.

قم بإزالة أي متغيرات أو مؤشرات قيد الاستخدام.

تأكد من إنهاء أي Timers أو Loops جارية.

نصائح لاستخدام Event Destroyed:

تجنب العمليات الثقيلة:

تأكد من أن المنطق المستخدم داخل Event Destroyed خفيف لتجنب التأثير على الأداء.

تحقق من الكائنات المرتبطة:

إذا كان الكائن مرتبطًا بعناصر أخرى، تحقق من وجودها قبل محاولة التفاعل معها.

التأكد من عدم استدعاء المنطق أكثر من مرة:

تأكد من أن الكائن لا يقوم بتشغيل أحداث زائدة عند التدمير.

سيناريوهات شائعة لاستخدام Event Destroyed:

ألعاب التصويب:

تفجير الأعداء أو العقبات عند تدميرها.

إسقاط ذخيرة أو أسلحة عند القضاء على العدو.

ألعاب الألغاز:

تحرير مسارات جديدة عند تدمير حواجز أو فتح أبواب.

ألعاب تقمص الأدوار:

منح اللاعب نقاط خبرة عند القضاء على الأعداء.

إسقاط عناصر نادرة عند هزيمة الأعداء الرئيسيين.

الفرق بين Event Destroyed و Event EndPlay:

Event Possessed

Event Unpossessed

بداية ونهاية التحكم في الشخصية عند تغييرها الى شخصية اخرى

Event Possessed هو حدث يتم استدعاؤه عندما يتم السيطرة (Possession) على كائن (Pawn) بواسطة لاعب أو ذكاء اصطناعي (Controller). يتم استخدام هذا الحدث لتنفيذ منطق خاص بمجرد أن يتولى كائن التحكم على الكائن القابل للتحكم (Pawn).

استعمالات Event Possessed:

1. إعداد الشخصية عند التحكم بها:

تهيئة إعدادات معينة للشخصية بمجرد أن يتم السيطرة عليها.

مثال:

إعداد الكاميرا أو التحكم بناءً على نوع اللاعب.

2. تغيير مظهر أو حالة الشخصية:

تحديث مظهر الشخصية أو تشغيل تأثيرات مرئية عند التحكم بها.

مثال:

تفعيل تأثير ضوئي أو تغيير لون الشخصية عند تولي لاعب السيطرة عليها.

3. تخصيص إعدادات التحكم:

تخصيص عناصر التحكم بناءً على نوع الجهاز أو اللاعب.

مثال:

تمكين التحكم بالماوس ولوحة المفاتيح إذا كان اللاعب هو الذي يسيطر.

4. تحميل بيانات اللاعب:

تحميل معلومات أو بيانات محفوظة بمجرد أن يتم التحكم في الكائن.

مثال:

استرداد حالة اللاعب أو معداته.

5. تفعيل وظائف متقدمة:

تشغيل وظائف خاصة بمجرد بدء السيطرة على الكائن.

مثال:

تفعيل ميكانيكا خاصة، مثل القدرة على الطيران أو تغيير أسلوب الحركة.

6. ربط واجهة المستخدم:

إظهار واجهة المستخدم أو تحديثها عند السيطرة على الكائن.

مثال:

عرض شريط الصحة أو الذخيرة عند تولي التحكم بالشخصية.

7. إعداد الذكاء الاصطناعي:

ضبط إعدادات الذكاء الاصطناعي إذا كان الذي يسيطر على الكائن هو AI Controller.

مثال:

تخصيص سلوك الذكاء الاصطناعي عند السيطرة على كائن معين.

8. التحكم في الانتقال بين الشخصيات:

تنفيذ منطق عند انتقال السيطرة بين شخصيات مختلفة.

مثال:

نقل الكاميرا أو إعدادات التحكم عند تغيير الكائن الذي يتم التحكم به.

9. تحديث الأحداث في العالم:

تفعيل أو تعديل عناصر في البيئة بناءً على السيطرة.

مثال:

إغلاق الأبواب أو فتحها عند السيطرة على شخصية في غرفة معينة.

10. تسجيل الإحصائيات:

تسجيل معلومات مثل وقت بدء السيطرة أو عدد المرات التي تم السيطرة فيها على الكائن.

مثال:

تحديث عداد اللاعبين الذين استخدموا الكائن.

كيفية استخدام Event Possessed في Blueprints:

1. إعداد العقدة:

افتح Blueprint الخاص بالكائن (Pawn) الذي تريد تنفيذ المنطق عليه.

أضف عقدة Event Possessed من قائمة الأحداث.

2. أمثلة على الاستخدام:

مثال 1: تخصيص الكاميرا:

أضف Event Possessed.

تحقق من نوع الـ Controller (هل هو لاعب أم ذكاء اصطناعي) باستخدام Cast to Player Controller.

اربط الكاميرا بالشخصية باستخدام Set View Target with Blend.

مثال 2: تغيير المظهر:

أضف Event Possessed.

استخدم Set Material لتغيير مادة (Material) الشخصية.

حدد المظهر بناءً على نوع الـ Controller.

مثال 3: تحميل بيانات اللاعب:

أضف Event Possessed.

استخدم Game Instance لاسترداد البيانات المحفوظة.

حدث خصائص الشخصية مثل الصحة أو الذخيرة.

مثال 4: تفعيل واجهة المستخدم:

أضف Event Possessed.

تحقق مما إذا كان الـ Controller هو لاعب.

أضف واجهة مستخدم باستخدام Create Widget وربطها بالـ Viewport.

مثال 5: التحكم في الذكاء الاصطناعي:

أضف Event Possessed.

تحقق مما إذا كان الـ Controller هو AI Controller.

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

نصائح لاستخدام Event Possessed:

التحقق من نوع الـ Controller:

استخدم Cast to Player Controller أو AI Controller للتأكد من تنفيذ المنطق الصحيح.

تنظيف البيانات عند انتهاء السيطرة:

تأكد من إعادة تعيين الإعدادات عند تحرير السيطرة باستخدام Event UnPossessed.

استخدام متغيرات مرتبطة:

اربط المتغيرات مثل حالة اللاعب أو عناصر التحكم بالـ Pawn لتسهيل الإدارة.

دمج مع Event BeginPlay:

استخدم Event Possessed لتنفيذ إعدادات تعتمد على السيطرة بعد انتهاء المنطق العام في BeginPlay.

الفرق بين Event Possessed و Event UnPossessed:

Event Possessed

عند تولي السيطرة على الكائن

تخصيص الكائن وإعداده للتحكم

تحميل البيانات، تغيير التحكم

Event UnPossessed

عند تحرير السيطرة من الكائن

تنظيف أو إعادة تعيين الإعدادات

إنهاء الأحداث الجارية وإعادة التهيئة

Event On Landed

كود يبدا التفبعيل حين يتصادم اللاعب مع الارضية

location موقع التصادم

Hit Actor الجسم المتصادم عليه كالارضية او جبل او غيره

Event On Landed هو حدث يتم استدعاؤه عندما تهبط شخصية (Character) على سطح بعد أن كانت في الهواء. هذا الحدث موجود داخل Blueprint الخاص بالشخصية (Character Blueprint) ويُستخدم لتنفيذ منطق محدد عند الهبوط.

استعمالات Event On Landed:

1. تشغيل تأثيرات مرئية وصوتية عند الهبوط:

تشغيل صوت تأثير الهبوط أو تأثير بصري عند ملامسة الأرض.

مثال:

ظهور غبار أو اهتزاز الكاميرا عند الهبوط.

2. إحداث تغييرات بناءً على قوة الهبوط:

تحديد قوة الهبوط باستخدام بيانات FHitResult، مثل Impact Velocity.

مثال:

تقليل صحة اللاعب إذا كانت قوة الهبوط مرتفعة (سقوط كبير).

3. إعادة ضبط الحركات الخاصة بالطيران:

تعطيل حالة الطيران أو القفز عند ملامسة الأرض.

مثال:

إنهاء وضع "Double Jump" أو الطيران بعد الهبوط.

4. تحديث واجهة المستخدم:

تحديث عناصر واجهة المستخدم مثل عرض الطاقة أو الإشعارات عند الهبوط.

مثال:

إظهار رسالة "هبطت بأمان" عند الهبوط بنجاح.

5. التفاعل مع البيئة:

إحداث تغييرات بيئية بناءً على الهبوط.

مثال:

تشغيل تأثير ضغط على الأرضية في ألعاب الألغاز.

6. تنفيذ منطق خاص بعد القفز:

استخدام الحدث لتحديد أن اللاعب قد أكمل القفزة وهبط بنجاح.

مثال:

بدء حركة جديدة أو تمكين القدرات الخاصة بعد الهبوط.

7. إعداد الكاميرا أو الحركة:

ضبط وضع الكاميرا أو إعادة تمكين ميكانيكا الحركة بعد الهبوط.

مثال:

إعادة ضبط زاوية الكاميرا بعد الهبوط.

8. حساب الإحصائيات:

تسجيل عدد مرات الهبوط أو المسافة المقطوعة في الهواء.

مثال:

تحديث عداد القفزات أو المسافة المقطوعة في الجو.

كيفية استخدام Event On Landed في Blueprints:

1. إعداد العقدة:

افتح Blueprint الخاص بالشخصية (Character Blueprint).

أضف عقدة Event On Landed من قائمة الأحداث.

2. العقد المرتبطة بـ Event On Landed:

FHitResult:

يوفر معلومات عن السطح الذي تم الهبوط عليه، مثل:

نوع المادة (Material) للسطح.

سرعة الاصطدام (Impact Velocity).

3. أمثلة على الاستخدام:

مثال 1: تشغيل تأثير غبار عند الهبوط

أضف Event On Landed.

اربطها بعقدة Spawn Emitter at Location لتشغيل تأثير غبار.

استخدم Get Actor Location لتحديد موضع الشخصية.

مثال 2: تقليل الصحة عند الهبوط بقوة كبيرة

أضف Event On Landed.

احصل على السرعة العمودية من Impact Velocity داخل FHitResult.

إذا تجاوزت السرعة قيمة محددة (مثل -1000)، استخدم Apply Damage لتقليل صحة اللاعب.

مثال 3: تغيير الصوت بناءً على السطح

أضف Event On Landed.

احصل على نوع المادة من FHitResult.

اختر الصوت المناسب للسطح (مثل صوت خشب، حديد، أو حجر) باستخدام Play Sound at Location.

مثال 4: إظهار عداد الهبوط

أضف Event On Landed.

استخدم متغير Landing Count لزيادة العدد عند كل هبوط.

أضف النص إلى الشاشة باستخدام Print String.

مثال 5: إنهاء وضع الطيران:

أضف Event On Landed.

تحقق مما إذا كانت الشخصية في وضع الطيران.

أعد ضبط المتغير المرتبط بحالة الطيران (مثل IsFlying = False).

نصائح لاستخدام Event On Landed:

استخدام بيانات FHitResult:

استغل بيانات الاصطدام لتحديد المنطق المناسب (مثل نوع السطح أو السرعة).

التحقق من السرعة:

تجنب تشغيل تأثيرات أو أحداث عند الهبوط بسرعات منخفضة (مثل خطوات عادية).

تقليل تأثير الأداء:

إذا كنت تضيف تأثيرات مرئية أو صوتية، تأكد من تحسينها لتجنب التأثير على الأداء.

دمج مع Events أخرى:

استخدم Event On Landed مع أحداث مثل Event On Jumped لتخصيص ميكانيكا الحركة بالكامل.

الفرق بين Event On Landed و Event Hit:

Event On Landed

يتم استدعاؤه عند هبوط الشخصية على سطح

خاص بالشخصيات وحركتها

يتضمن معلومات السطح والسرعة أثناء الهبوط

Event Hit

يتم استدعاؤه عند اصطدام أي جسم بآخر

يمكن استخدامه مع أي كائن في العالم

يتضمن معلومات عن الاصطدام واتجاهه

 

CustomEvent

اذا ربطناه مع عقدة set time by event فهنا احدد تكرار الحدث في كل ثانية اكتب فيه عدد الثواني وعدد التكرار

customEvent هو حدث تقوم بانشائه انت وتضع فيه الاكواد وتستدعيها وقتما تريد في العقاد الاخرى 

مثلا في الصورة استدعيناه بعد تغيير اسمه الى CustomEvent12

وهذا الاخير يقبل التاخير Delay ويستخذم اكثر في الاونلاين 

ويظهر ذلك حين نضغط عليه وفي التفاصيل بجانب الشاشة Replicates

نظام Replicates في Unreal Engine Blueprint يُستخدم لدعم التزامن الشبكي (Networking Replication) بين العميل (Client) والخادم (Server) في الألعاب متعددة اللاعبين. يتيح هذا النظام تبادل البيانات والإجراءات بين اللاعبين مع الحفاظ على التوافق والتزامن، وهو أساسي لجعل اللعبة تعمل بسلاسة في بيئة متعددة اللاعبين.

كيف يعمل نظام Replication؟

الخادم (Server):

الخادم هو المسؤول الرئيسي عن معالجة البيانات والتحكم في منطق اللعبة.

يتم إرسال البيانات من الخادم إلى العملاء لضمان التزامن.

العملاء (Clients):

العملاء هم الأجهزة أو اللاعبين الذين يتصلون بالخادم.

يتلقون البيانات المكررة من الخادم لتحديث حالتهم وفقًا للمعلومات التي يرسلها الخادم.

أنواع البيانات أو الأحداث التي يمكن تكرارها:

المتغيرات (Variables):

يمكن تعيين خاصية Replicated للمتغيرات لجعلها تُرسل تلقائيًا من الخادم إلى العملاء.

مثال: صحة اللاعب (Health) أو موقعه (Location).

الإجراءات (Functions):

يمكن تصنيف الوظائف حسب نوع التكرار:

Run on Server: يتم استدعاؤها من العميل ولكن تُنفذ فقط على الخادم.

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

Run on Owning Client: تُنفذ فقط على العميل الذي يمتلك الكائن.

يتم إرسال RPC للعميل ('تشغيل على العميل المالك') فقط من العميل المالك. وبنفس الطريقة التي يمكن بها فقط للعميل المالك إرسال RPCs للخادم، فإن العميل المالك فقط سوف يتلقى RPCs للعميل المرسلة من الخادم.

Multicast: يتم استدعاؤها على الخادم وتُنفذ على الخادم وجميع العملاء.

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

الكائنات (Actors):

يمكن تحديد الكائنات كـ Replicates، مما يعني أن حالتها يتم تحديثها على جميع الأجهزة.

استخدامات نظام Replicates:

تزامن موقع وحركة اللاعبين:

 لضمان أن جميع اللاعبين يرون حركات بعضهم البعض في نفس الوقت.

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

تنفيذ المهام المشتركة:

 مثل فتح الأبواب، تشغيل الأزرار، أو التحكم في الكائنات المشتركة.

إدارة الأحداث المرئية: مثل تأثيرات الانفجارات أو الإشعارات التي يجب أن تظهر لجميع اللاعبين.

خطوات تفعيل Replication في Blueprint:

تفعيل التكرار على الكائن:

افتح تفاصيل الكائن (Actor).

فعل خاصية Replicates وخاصية Replicate Movement إذا كان للكائن حركة.

تحديد المتغيرات للتكرار:

اختر المتغير.

فعل خاصية Replicated في إعداداته.

استخدام وظائف مكررة:

عند إنشاء وظيفة، اختر نوع التكرار المناسب (Run on Server، Multicast).

إعدادات المشروع:

تأكد من تمكين التزامن الشبكي في إعدادات اللعبة.

مثال عملي:

لنفترض أن لديك لعبة متعددة اللاعبين حيث يمكن للاعب فتح باب:

عندما يضغط العميل على زر فتح الباب:

استدعِ وظيفة Run on Server من العميل.

الخادم ينفذ المنطق (Logic):

يفتح الباب (مثل تحريك الباب).

إرسال التحديث لجميع العملاء:

استدعِ وظيفة Multicast لتحديث حالة الباب (مفتوح/مغلق) على جميع الأجهزة.

لإنشاء لعبة ثنائية اللاعبين بدون إنترنت على الهاتف باستخدام Unreal Engine وBlueprints، ستحتاج إلى استخدام ميزة Local Multiplayer التي تدعم اللعب على نفس الجهاز أو عبر شبكة محلية (LAN).

إليك الخطوات بالتفصيل:

1. تهيئة المشروع للعب الثنائي:

افتح مشروعك في Unreal Engine.

في Project Settings، اذهب إلى قسم Maps & Modes:

قم بتغيير Number of Players إلى 2 أو أكثر.

في Input Settings:

أضف إعدادات الإدخال لكل لاعب (Player 1 وPlayer 2) بحيث تكون لكل لاعب مجموعة خاصة من الأزرار.

2. إنشاء وضع اللعبة (Game Mode):

قم بإنشاء Blueprint جديد من نوع Game Mode.

في هذا الـGame Mode:

عيّن القواعد المطلوبة للعبة (مثل عدد اللاعبين، كيفية التحكم في البداية).

تأكد من أن الكائن الافتراضي لـ Player Controller تم إعداده بشكل صحيح.

3. تصميم واجهة اللاعبين (Split Screen):

افتراضيًا، Unreal Engine يدعم ميزة Split Screen، حيث يتم تقسيم الشاشة لعرض منظورين مختلفين.

لتفعيلها:

اذهب إلى Project Settings > Local Multiplayer.

فعل خيار Use Split Screen.

يمكنك تخصيص طريقة تقسيم الشاشة (أفقي/رأسي) من نفس القائمة.

4. إنشاء شخصيتين (Characters):

قم بإنشاء Blueprint من نوع Character لكل لاعب (Player 1 وPlayer 2) إذا كنت تريد أن يكون لديهم قدرات مختلفة.

إذا كان اللاعبان سيستخدمان نفس القدرات:

يمكنك استخدام Blueprint واحد لشخصية واحدة مع اختلاف إدخالات التحكم.

5. إعداد Player Controller:

قم بإنشاء Blueprint جديد من نوع Player Controller.

في الـ Player Controller:

أضف إدخالات التحكم المختلفة لكل لاعب باستخدام Input Mappings.

مثال:

Player 1: الأسهم للحركة.

Player 2: WASD للحركة.

6. تخصيص الكاميرا:

لكل لاعب، يمكنك إنشاء كاميرا مخصصة.

تأكد من تعيين الكاميرات لتتبع كل شخصية عند اللعب.

7. إعداد المستوى (Level):

قم بوضع نقطة Player Start لكل لاعب داخل المستوى.

إذا كان هناك كائنات أو أهداف مشتركة، تأكد من ضبطها بحيث تدعم لاعبين (مثل جمع النقاط أو القتال ضد كائنات العدو).

8. اختبار اللعبة:

اضغط على Play في المحرر مع تحديد عدد اللاعبين في شريط التشغيل (Set Number of Players = 2).

ستلاحظ تقسيم الشاشة وعمل اللاعبين معًا.

9. تصدير اللعبة للهاتف:

قم بتخصيص واجهة التحكم (HUD) لتكون مناسبة للمس بدلاً من لوحة المفاتيح.

استخدم Touch Interface المدمجة في Unreal Engine.

قم بإعداد اللعبة للتصدير إلى Android:

اذهب إلى Platforms > Android.

تأكد من إعداد SDK وNDK وJDK بشكل صحيح.

قم ببناء اللعبة وتثبيتها على الهاتف لاختبارها.

أمثلة على الألعاب الممكنة:

لعبة سباق بين شخصيتين.

لعبة قتال 2D بين لاعبين.

لعبة تعاونية حيث يعمل اللاعبان معًا لتحقيق هدف مشترك.

لإنشاء لعبة أونلاين متعددة اللاعبين باستخدام Unreal Engine وBlueprints، ستحتاج إلى فهم نظام الشبكات المدمج في Unreal. Unreal Engine يعتمد على نموذج Client-Server، حيث يدير الخادم (Server) منطق اللعبة الأساسي ويتواصل مع العملاء (Clients). سأشرح لك كل التفاصيل خطوة بخطوة.

الخطوات التفصيلية:

1. تهيئة المشروع لدعم الشبكات:

فتح مشروعك:

تأكد من استخدام قالب يدعم الشبكات (مثل Third Person أو First Person).

إعداد Game Mode:

أنشئ Blueprint جديد من نوع Game Mode Base.

عيّن هذا الـGame Mode في إعدادات المستوى من خلال World Settings.

في هذا الـGame Mode، حدد Default Player Controller، وDefault Pawn Class.

تفعيل الشبكات:

في Project Settings، انتقل إلى Engine > Network.

فعل خيار Enable Multiplayer.

2. تصميم النظام الشبكي الأساسي:

أ) الكائنات المكررة (Replicated):

أي بيانات أو وظائف تحتاج إلى المشاركة بين الخادم والعملاء يجب أن تُضبط على Replicated.

على سبيل المثال:

افتح متغيرًا تريد تكراره.

في خصائص المتغير، فعل خيار Replicated.

ب) وظائف الشبكة:

في Blueprint، هناك 3 أنواع من الوظائف للشبكات:

Run on Server:

تُستدعى من العميل ولكن تُنفذ على الخادم.

تُستخدم للمنطق الذي يحتاج إلى التحقق من الخادم، مثل ضرب لاعب آخر.

Run on Owning Client:

تُنفذ فقط على العميل الذي يمتلك الكائن.

تُستخدم لإظهار تأثيرات مرئية خاصة باللاعب.

Multicast:

تُنفذ على الخادم ثم تُرسل إلى جميع العملاء.

تُستخدم لإظهار تأثير مشترك بين جميع اللاعبين، مثل انفجار.

ج) الكائنات المكررة (Replicating Actors):

افتح الكائن الذي تريد تكراره (مثل شخصية اللاعب).

في تفاصيل الكائن،

 فعل:

Replicates

Replicate Movement إذا كان يتحرك.

3. إعداد اللعب عبر الإنترنت:

أ) إعداد الخادم (Host Server):

لإنشاء جلسة لعب:

أنشئ وظيفة جديدة في الـBlueprint الخاص بـPlayer Controller.

استخدم العقدة Create Session.

اضبط العدد الأقصى للاعبين.

استدعِ العقدة Open Level مع إعداد مستوى اللعبة كالتالي:

LevelName?listen

ب) انضمام العملاء (Clients):

لإنضمام العملاء إلى اللعبة:

أنشئ وظيفة جديدة في الـBlueprint الخاص بـPlayer Controller.

استخدم العقدة Find Sessions للبحث عن الجلسات المتاحة.

بعد العثور على جلسة، استخدم العقدة Join Session للاتصال بالخادم.

4. تهيئة عناصر التحكم (Inputs):

تأكد من أن جميع إدخالات اللاعب (Input Mappings) مكررة على الخادم، خاصة في الحالات التنافسية.

5. إعداد HUD أو واجهة المستخدم:

صمم واجهة مستخدم (مثل قائمة رئيسية تحتوي على خيارات لإنشاء جلسة أو الانضمام إليها).

استخدم Blueprint Widget لتنفيذ منطق التفاعل مع الشبكة.

6. اختبار اللعبة متعددة اللاعبين:

أ) في المحرر:

من شريط التشغيل، اضبط عدد اللاعبين (عدد العملاء والخادم).

اختر خيار Play As Listen Server لتشغيل اللعبة كمضيف.

ب) خارج المحرر:

قم بتصدير اللعبة (Package Game) للمنصة المطلوبة.

شغل اللعبة على أجهزة متعددة.

عند التشغيل:

الجهاز الأول يستضيف الجلسة.

الأجهزة الأخرى تنضم باستخدام عنوان IP أو عبر قائمة الجلسات.

7. تصدير اللعبة وتجربتها عبر الإنترنت:

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

استخدم خدمات مثل Epic Online Services أو Steam لتسهيل إعداد الجلسات.

ستحتاج إلى إعداد API Keys وربط مشروعك بالخدمة المطلوبة.

8. تحسين الأداء:

تأكد من تقليل البيانات المكررة إلى الحد الأدنى لتحسين الأداء.

استخدم Server Optimization Techniques،

 مثل:

تحديد الأحداث المهمة فقط لتكرارها.

استخدام وظائف Reliable/Unreliable حسب الحاجة.

9. الخطوة النهائية: تجربة المشروع:

جرب لعبتك باستخدام أجهزة مختلفة وشبكات لضمان الاستقرار.

تأكد من إعدادات الأمان، مثل التحقق من صحة بيانات العميل على الخادم.

مثال انشاء لعبة من نوع mmorpg ار بي جي عالم مفتوح

إنشاء لعبة MMORPG أونلاين باستخدام Unreal Engine يمثل تحديًا كبيرًا ولكنه ممتع جدًا! سأشرح الخطوات الأساسية لإنشاء مشروع بسيط يدعم عناصر MMORPG باستخدام الشبكات في Unreal Engine.

خصائص المشروع:

لعبة أونلاين متعددة اللاعبين تدعم عددًا كبيرًا من اللاعبين.

عناصر MMORPG الأساسية:

تحكم في شخصية.

تفاعل مع العالم (NPCs، أعداء، وجمع موارد).

نظام مهام (Quests).

تكرار (Replication) للحالة بين الخادم والعملاء.

1. إنشاء المشروع:

افتح Unreal Engine.

اختر قالب Third Person Template (لأنه يدعم الحركات ثلاثية الأبعاد ويحتوي على إعدادات جاهزة للحركة).

قم بتسمية المشروع واختيار مكان حفظه.

2. إعداد الشبكات في المشروع:

أ) إعداد الخادم (Server):

أنشئ Game Mode جديد من نوع GameModeBase.

قم بتعيين Default Pawn Class إلى شخصية اللاعب.

عين الـ Game Mode في إعدادات المستوى.

تأكد من أن الكائنات المهمة مكررة:

افتح تفاصيل شخصية اللاعب (Character).

فعل خاصيتي Replicates وReplicate Movement.

ب) نظام إنشاء الجلسة (Session):

أنشئ قائمة رئيسية (Main Menu) باستخدام Widget Blueprint

 تحتوي على:

زر لإنشاء جلسة (Host).

زر للانضمام لجلسة (Join).

في Player Controller:

لإنشاء جلسة:

استخدم العقدة Create Session.

عين عدد اللاعبين وحدد الخيارات الأخرى.

بعد نجاح الإنشاء، استخدم عقدة Open Level مع اسم المستوى وعبارة "?listen".

للانضمام إلى جلسة:

استخدم العقدة Find Sessions للبحث عن جلسات متاحة.

بعد العثور على جلسة، استخدم عقدة Join Session.

3. تصميم شخصيات اللاعبين (Player Characters):

أضف متغيرات قابلة للتكرار (Replicated Variables):

نقاط الصحة (Health).

مستوى الشخصية (Level).

نقاط الخبرة (Experience Points).

أنشئ وظائف لمعالجة التفاعل بين الخادم والعملاء:

وظيفة Run on Server لتطبيق الضرر.

وظيفة Multicast لتحديث الحالة على جميع الأجهزة.

4. إضافة الأعداء (Enemies):

أنشئ Blueprint من نوع AI Controller وأضفه لكائن العدو.

فعل تكرار الكائن (Replicate) ليظهر لجميع اللاعبين.

استخدم Behavior Tree لتصميم ذكاء اصطناعي بسيط:

جعل العدو يطارد اللاعب عند الاقتراب.

تنفيذ هجوم إذا كان اللاعب في مدى الهجوم.

5. تصميم نظام المهام (Quests):

أنشئ Blueprint جديد من نوع Actor يمثل NPC يعطي المهام.

أضف قائمة مهام (Quest List) لكل لاعب:

قائمة المهام تكون متغيرة مكررة (Replicated Variable).

عند تفاعل اللاعب مع الـ NPC:

استدعِ وظيفة Run on Server لبدء المهمة.

حدث واجهة المستخدم باستخدام Widget يظهر تقدم المهمة.

6. نظام التفاعل مع العالم:

جمع الموارد (Resources):

أنشئ Blueprint من نوع Actor يمثل الموارد (مثل صناديق أو نباتات).

فعل خاصية Replicates على الكائن.

عند تفاعل اللاعب مع الكائن:

استخدم وظيفة Run on Server لإزالة الكائن من العالم.

أضف المورد إلى مخزون اللاعب (Inventory).

7. نظام المخزون (Inventory System):

أضف متغير Inventory لكل لاعب:

قائمة (Array) تحتوي على عناصر اللاعب.

فعل التكرار لهذا المتغير.

أنشئ Widget يظهر واجهة المخزون.

أضف عناصر إلى المخزون عند التفاعل مع العالم.

8. تحسين الأداء:

استخدم Level Streaming لتحميل أجزاء من العالم حسب الحاجة لتقليل استهلاك الموارد.

فعل ميزة Server-Side Validation للتحقق من صحة العمليات التي يرسلها العميل.

9. تصدير اللعبة واختبارها:

للاختبار المحلي:

شغل اللعبة في المحرر مع عدة لاعبين:

اضبط عدد اللاعبين إلى 2 أو أكثر في إعداد التشغيل (Play Settings).

اختر "Play As Listen Server" ليكون أحد اللاعبين هو الخادم.

للاختبار عبر الإنترنت:

قم بإعداد اللعبة مع خدمات مثل Epic Online Services أو Steam.

احصل على API Key من المنصة المطلوبة واربطها بمشروعك.

10. الأفكار المستقبلية لتطوير اللعبة:

إضافة خريطة عالم مفتوح:

استخدم نظام Landscape في Unreal لإنشاء بيئة واسعة.

إضافة مهارات (Abilities):

استخدم نظام Gameplay Ability System (GAS) في Unreal.

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

صمم واجهة تسمح بتبادل العناصر بين اللاعبين.

نظام Guilds:

اسمح للاعبين بالانضمام إلى جماعات وتعاون لتحقيق أهداف مشتركة.

1. نظام إنشاء الشخصية (Character Creation System):

أ) تصميم واجهة المستخدم (UI):

أنشئ Widget Blueprint خاصًا بواجهة إنشاء الشخصية.

أضف عناصر مثل:

مربعات إدخال الاسم.

قائمة لاختيار العرق (Race) أو الطبقة (Class).

أزرار لتحديد المظهر (لون الشعر، العيون، إلخ).

زر "Create" لحفظ الخيارات.

صمم نظامًا يسمح بتغيير مظهر الشخصية بشكل مباشر:

أضف Preview Mesh داخل Widget لعرض الشخصية أثناء التخصيص.

استخدم العقدة Set Skeletal Mesh لتغيير المظهر بناءً على اختيار اللاعب.

ب) حفظ بيانات الشخصية:

عند الانتهاء من التخصيص:

أرسل الخيارات إلى الخادم باستخدام وظيفة Run on Server.

احفظ البيانات في Game Instance أو Save Game، حسب الحاجة.

في حالة الألعاب الأونلاين:

خزن البيانات في قاعدة بيانات مركزية أو باستخدام خدمات مثل PlayFab.

عند بدء اللعبة:

استخدم البيانات المحفوظة لتحميل الشخصية المخصصة.

قم بتهيئة المظهر (Mesh) والمهارات (Abilities) استنادًا إلى الخيارات.

2. نظام العشائر (Guild System):

أ) إنشاء العشيرة:

أنشئ Widget Blueprint لواجهة إنشاء العشائر:

أضف مربعات إدخال الاسم ووصف العشيرة.

أضف زرًا لإنشاء العشيرة.

عند الضغط على "إنشاء":

استخدم وظيفة Run on Server لإنشاء العشيرة على الخادم.

أضف بيانات العشيرة (Guild Name, Members, Leader) إلى قائمة مكررة (Replicated Array).

ب) إدارة العشيرة:

أضف واجهة إدارة:

قائمة بالأعضاء مع أزرار لإضافة أو إزالة اللاعبين.

أزرار لإرسال دعوات أو قبولها.

قم بإنشاء وظائف مكررة (Replicated Functions) 

للتفاعل مع العشيرة:

دعوة لاعب آخر.

قبول أو رفض الدعوة.

إدارة صلاحيات الأعضاء.

3. نظام قتالات لاعب ضد لاعب (PvP):

أ) تحديد المناطق الصالحة لـ PvP:

استخدم Trigger Volumes لتحديد المناطق التي يمكن فيها القتال.

عند دخول المنطقة:

فعل خاصية "PvP Mode" على شخصية اللاعب.

عطلها عند الخروج من المنطقة.

ب) نظام الاشتباك:

عند ضرب لاعب آخر:

استخدم وظيفة Run on Server للتحقق من صحة الضربة (Server Validation).

طبق الضرر على العدو باستخدام وظيفة Multicast لتحديث الحالة للجميع.

أضف نظام مكافآت:

عند قتل لاعب، أكسب اللاعب الفائز نقاط خبرة (XP) أو موارد.

يمكنك إضافة عقوبات على الموت، مثل فقدان بعض الموارد.

4. حروب السيطرة على المناطق:

أ) إنشاء نظام المناطق:

صمم مناطق السيطرة باستخدام Actors.

أعط كل منطقة متغيرًا مكررًا (Replicated Variable) يمثل العشيرة المسيطرة.

أضف واجهة مستخدم تظهر المناطق المسيطر عليها وأسماء العشائر.

ب) آلية السيطرة:

عند دخول لاعب أو مجموعة من العشيرة إلى المنطقة:

فعل عداد زمني (Timer) لبدء السيطرة.

تحقق من عدد اللاعبين من نفس العشيرة داخل المنطقة لتحديد سرعة السيطرة.

عند انتهاء السيطرة:

قم بتحديث اسم العشيرة المسيطرة.

استخدم وظيفة Multicast لإعلام جميع اللاعبين بتغيير السيطرة.

ج) المكافآت على السيطرة:

لكل منطقة، قدم مكافآت دورية:

موارد مثل الذهب أو العناصر.

تحسينات مثل زيادة الصحة أو قوة الهجوم.

استخدم وظيفة Run on Server لتوزيع المكافآت بشكل عادل على أعضاء العشيرة.

5. خطوات إضافية للتطوير:

أ) تحسين واجهة المستخدم:

أضف خريطة عالمية تظهر مناطق السيطرة.

استخدم Widgets لتسهيل إدارة العشائر والمهام.

ب) تحسين الأداء:

استخدم Level Streaming لتحميل المناطق عند الحاجة فقط.

قلل من البيانات المكررة إلى الحد الأدنى لتقليل استهلاك الشبكة.

ج) نظام الأحداث الخاصة:

قم بإضافة أحداث PvP أو PvE مؤقتة لتشجيع اللاعبين على التفاعل.

مثال: حرب أسبوعية على منطقة تمنح مكافآت خاصة.

1. إضافة قتال البوزات (Boss Fights)

أ) إنشاء شخصية البوز (Boss Character):

إنشاء Blueprint للبوز:

اذهب إلى Content Browser، اضغط بزر الماوس الأيمن واختر Blueprint Class > Character.

سمّ الـ Blueprint باسم BP_Boss.

تصميم البوز:

افتح BP_Boss.

أضف مكونات إضافية مثل Skeletal Mesh، Anim Blueprint، AI Controller.

عين AI Controller مخصص للبوز (أنشئ AIController جديد إذا لزم الأمر).

إعداد الذكاء الاصطناعي:

استخدم Behavior Trees لتحديد سلوك البوز (مثل الهجوم، التحرك، استخدام القدرات الخاصة).

ب) إضافة قتال البوز إلى المستوى:

وضع البوز في المستوى:

افتح المستوى الذي تريد إضافة البوز إليه.

اسحب BP_Boss من Content Browser إلى المستوى.

إعداد نقاط ظهور البوز:

يمكنك استخدام Spawn Points لتحديد مواقع ظهور البوز.

ج) إدارة صحة البوز وقدراته:

إضافة متغيرات الصحة:

في BP_Boss، أنشئ متغيرًا جديدًا باسم Health واجعله Replicated.

تنفيذ الضرر:

عند تلقي البوز للضرر، اطرح القيمة من Health.

إذا وصلت Health إلى الصفر، قم بتنفيذ Death Sequence (مثل تأثيرات، حذف البوز، إلخ).

2. إسقاط مواد نادرة (Dropping Rare Materials)

أ) إنشاء نظام الإسقاط:

إنشاء Blueprint للإسقاط:

أنشئ Blueprint Class جديد من نوع Actor وسميه BP_RareMaterial.

أضف مكون Static Mesh يمثل المادة النادرة.

إعداد الإسقاط في البوز:

في BP_Boss، بعد موت البوز، استدعِ حدث DropItem.

استخدم عقدة Spawn Actor لإنشاء BP_RareMaterial في موقع موت البوز.

أضف احتمالًا (مثلاً 30%) لظهور المادة النادرة باستخدام Random Float ومقارنته بحد معين.

ب) إدارة جمع المواد:

إضافة تفاعل اللاعب:

في BP_RareMaterial، أضف Collision Component (مثل Box Collision).

عند دخول اللاعب إلى منطقة التصادم والضغط على زر جمع، أضف المادة إلى Inventory اللاعب واحذف BP_RareMaterial من المستوى.

3. إضافة زنزانات القتال (Combat Dungeons)

أ) إنشاء زنزانة جديدة:

تصميم المستوى:

أنشئ مستوى جديد يمثل الزنزانة.

صمم البيئة باستخدام Static Meshes، Lighting، Effects.

إنشاء بوابة دخول الزنزانة:

أنشئ Blueprint Actor باسم BP_DungeonEntrance.

أضف Collision Component لتحديد منطقة الدخول.

عند دخول اللاعب إلى المنطقة، استخدم عقدة Open Level أو Teleport لنقل اللاعب إلى مستوى الزنزانة.

ب) إعداد الأعداء داخل الزنزانة:

إضافة أعداء:

اسحب الـ Blueprints الخاصة بالأعداء (مثل BP_Boss أو BP_Enemy) إلى مستوى الزنزانة.

عين نقاط ظهور الأعداء باستخدام Spawn Points.

تحديد الصعوبة والتحديات:

اضبط مستوى صحة الأعداء، قوة الهجوم، وسلوك الذكاء الاصطناعي لتتناسب مع مستوى الزنزانة.

ج) مكافآت الزنزانة:

إسقاط مواد خاصة:

بعد قتل الأعداء أو البوز داخل الزنزانة، قم بإسقاط مواد نادرة أو مكافآت خاصة.

إنهاء الزنزانة:

أنشئ منطقة خروج داخل الزنزانة تعيد اللاعب إلى العالم الرئيسي بعد إكمال الزنزانة.

4. إضافة متجر اللعبة بخاصية الشراء بمال حقيقي

أ) اختيار منصة الدفع:

لتبسيط عملية الشراء المباشر، يمكنك استخدام In-App Purchases (IAP) المتاحة عبر منصات مثل Google Play وApple App Store إذا كنت تستهدف الهواتف المحمولة. بالنسبة للألعاب على الحاسب، يمكنك استخدام منصات مثل Steam أو Epic Games Store. سأركز هنا على IAP للهاتف.

ب) إعداد نظام الشراء في Unreal Engine:

تفعيل IAP في المشروع:

اذهب إلى Project Settings > Platforms > Android أو iOS.

ضمن In-App Purchases، قم بتمكينها وأدخل التفاصيل المطلوبة مثل Store IDs.

إنشاء واجهة متجر:

أنشئ Widget Blueprint باسم BP_Store.

أضف عناصر الواجهة مثل:

قائمة المنتجات (Materials, Clothes).

أزرار الشراء لكل منتج.

إعداد المنتجات:

في حساب المطور الخاص بك (مثل Google Play Console أو Apple Developer)، أنشئ In-App Products وحدد IDs لكل منتج (مثل com.yourgame.materials1).

تنفيذ منطق الشراء:

في BP_Store، عند النقر على زر شراء منتج:

استخدم عقدة IAP Purchase وحدد Product ID المناسب.

تعامل مع الأحداث مثل Purchase Success و Purchase Failure.

توزيع المحتويات بعد الشراء:

بعد تأكيد الشراء الناجح:

استخدم Run on Server لإضافة المواد أو الملابس إلى Inventory اللاعب.

قم بتحديث واجهة المستخدم لتعكس الشراء الجديد.

ج) حماية الشراء:

التحقق من الشراء على الخادم:

لضمان الأمان، تحقق من صحة المعاملات على الخادم قبل توزيع المحتويات.

تخزين بيانات الشراء:

استخدم Save Game أو قاعدة بيانات مركزية لتخزين معلومات الشراء الخاصة بكل لاعب.

د) اختبار الشراء:

تفعيل وضع الاختبار:

استخدم حسابات اختبار في منصة الدفع (مثل Google Play) لاختبار عمليات الشراء دون إجراء معاملات فعلية.

التأكد من عمل النظام بشكل صحيح:

تحقق من أن الشراء يضيف المحتويات بشكل صحيح إلى حساب اللاعب دون أخطاء.

ملخص الخطوات الرئيسية

قتال البوزات:

إنشاء Blueprint مخصص للبوز.

إعداد الذكاء الاصطناعي وسلوك البوز.

وضع البوز في المستوى وإعداد نقاط ظهوره.

إسقاط مواد نادرة:

إنشاء Actor يمثل المادة النادرة.

برمجة احتمالية الإسقاط عند موت البوز.

إعداد نظام جمع المواد من قبل اللاعبين.

زنزانات القتال:

تصميم مستويات الزنزانات وإضافة أعداء.

إنشاء بوابات دخول وخروج الزنزانة.

تحديد المكافآت الخاصة بالزنزانات.

متجر اللعبة:

إعداد In-App Purchases في منصة الدفع المستهدفة.

تصميم واجهة المتجر داخل اللعبة.

تنفيذ منطق الشراء والتوزيع الآمن للمحتويات.

اختبار النظام لضمان عمله بكفاءة.

نصائح إضافية:

إدارة الأداء: تأكد من تحسين مستويات الزنزانات والأعداء لتفادي انخفاض الأداء خاصة في الألعاب متعددة اللاعبين.

الأمان: احرص على حماية نظام الشراء والتأكد من عدم إمكانية التلاعب بالمعاملات من قبل اللاعبين.

تجربة المستخدم: صمم واجهات المستخدم بشكل بسيط وسهل الاستخدام لضمان تجربة لعب سلسة.

التوسع المستقبلي: خطط لإمكانيات توسع مستقبلية مثل إضافة أنواع جديدة من البوزات، الزنزانات، والمنتجات في المتجر.

1. تطوير الدروع والأسلحة

أ) إنشاء واجهة التطوير:

Widget Blueprint:

أنشئ Widget Blueprint باسم BP_UpgradeUI.

أضف:

قائمة الأسلحة/الدروع التي يمكن تطويرها.

متطلبات التطوير (الموارد أو العملة).

زر Upgrade لتنفيذ التطوير.

عرض معلومات السلاح/الدرع:

عند اختيار عنصر:

اعرض معلوماته (مثل مستوى التطوير الحالي، الضرر، أو الدفاع).

أظهر المتطلبات لتطويره.

ب) إعداد السلاح/الدرع:

Blueprint للأدوات:

أنشئ Blueprint Class لكل نوع من الأسلحة أو الدروع.

أضف متغيرات مثل:

Level (مستوى التطوير).

Damage/Defense (القوة/الدفاع).

Effect Mesh (لإضافة التأثيرات المرئية لاحقًا).

زيادة القوة بالتطوير:

عند الضغط على زر Upgrade:

تحقق من توفر الموارد المطلوبة.

إذا نجحت، زد قيمة Level، Damage، وDefense.

أضف تأثيرًا مرئيًا للتطوير باستخدام Niagara System أو Particle System (سنتحدث عنها لاحقًا).

ج) تأثيرات مرئية لتطوير الأسلحة:

إضافة مؤثرات القوة:

صمم Niagara Particle System يمثل الضوء الساطع أو القوة.

أضف تأثيرات مثل:

Glow Effect (سطوع).

Trail Effect (ذيل مضيء عند الحركة).

اربط التأثير بمستوى التطوير:

إذا كان Level >= قيمة معينة، أظهر التأثير.

دمج التأثير مع السلاح/الدرع:

أضف Niagara Component إلى Blueprint السلاح/الدرع.

عند الوصول إلى مستوى التطوير المطلوب، فعل التأثير باستخدام عقدة Activate.

2. بناء المنزل

أ) جمع المواد:

إنشاء الموارد:

صمم Blueprint Actor لكل نوع من المواد (مثل الخشب، الحجر).

أضف Collision Component لجمع المواد.

جمع الموارد:

عند التفاعل مع المادة (مثل الضغط على زر E):

أضف المادة إلى متغير Inventory.

استخدم عقدة Destroy Actor لحذف العنصر بعد جمعه.

ب) نظام البناء:

واجهة البناء:

أنشئ Widget Blueprint لعرض قائمة بالبناءات الممكنة (مثل الجدران، الأبواب).

أضف زر Build لكل عنصر.

إسقاط البناء في العالم:

عند الضغط على Build:

تحقق من وجود المواد المطلوبة.

إذا كانت المواد متوفرة، اسحب Blueprint الخاص بالبناء إلى العالم باستخدام Spawn Actor.

خصم المواد من اللاعب.

ج) التفاعل مع المنزل:

Blueprint للأبنية:

صمم Blueprint Class لكل جزء من المنزل (مثل الجدار، السقف).

أضف ميكانيكيات تفاعلية مثل فتح الأبواب، تدمير الجدران.

3. جمع الموارد

أ) تصميم الموارد:

أنشئ Blueprint Actor لكل نوع من الموارد (مثل شجرة، صخرة).

أضف Static Mesh يمثل المورد.

ب) جمع الموارد:

أضف ميكانيكية التفاعل:

عند ضرب المورد (مثل شجرة بفأس):

قلل من كمية الموارد المتاحة باستخدام متغير Resource Amount.

عند الوصول إلى الصفر، استخدم Destroy Actor لإزالة المورد.

أضف المواد إلى Inventory اللاعب:

قم بزيادة الكمية الموجودة في المتغيرات مثل WoodAmount أو StoneAmount.

4. تأثيرات مرئية للتطوير العالي

أ) تصميم تأثيرات القوة:

Niagara System:

افتح Niagara Editor وصمم نظام جسيمات (Particle System) يعكس القوة:

تأثيرات مثل الشرر، توهج السلاح، أو هالة مضيئة حول الدرع.

استخدم مواد ذات Emissive Maps للحصول على تأثيرات لامعة.

Trail Effect:

أضف ذيلاً مشعًا يتبع السلاح أثناء الحركة باستخدام Ribbon Particle في نظام Niagara.

ب) ربط التأثير بمستوى التطوير:

في Blueprint السلاح/الدرع:

أضف Niagara Component.

تحقق من مستوى التطوير عند التغيير:

إذا كان Level >= 5، فعل التأثير باستخدام Activate.

إذا كان أقل، استخدم Deactivate.

أضف وظيفة Multicast لجعل التأثير مرئيًا لجميع اللاعبين إذا كانت اللعبة متعددة اللاعبين.

ج) تأثيرات إضافية عند الهجوم:

عند الهجوم بسلاح مطور:

أضف انفجارًا صغيرًا أو تأثير ضرب باستخدام Niagara Emitter عند نقطة الاصطدام.

يمكنك استخدام العقدة Spawn Emitter At Location لعرض التأثير في موقع الضربة.

5. ملاحظات إضافية:

تحسين الأداء:

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

التوسع المستقبلي:

يمكنك إضافة قدرات خاصة لكل سلاح أو درع عند مستويات تطوير معينة.

مثال: عند تطوير السيف إلى مستوى 10، يمكنه إطلاق موجة طاقة.

1. نظام اجتياز اختبار للترقية

أ) تصميم الاختبار:

إنشاء Blueprint خاص بالمهمات:

أنشئ Blueprint Actor يمثل كل مهمة اختبار.

أضف مكونات مثل Static Mesh أو Collision حسب نوع المهمة (مثل جمع موارد، قتل أعداء).

إعداد المتطلبات:

لكل مهمة، أضف متغيرات:

Objective Type (نوع المهمة: قتل/جمع/وصول).

Target Count (عدد الأهداف المطلوبة).

التقدم في المهمة:

عند إتمام جزء من المهمة (مثل قتل عدو):

زد متغير Progress.

تحقق إذا اكتملت المهمة بمقارنة Progress مع Target Count.

ب) إدارة الاختبار:

نظام المهمة الكاملة:

أنشئ Blueprint Actor باسم BP_TestSystem.

يحتوي على قائمة بجميع المهمات المطلوبة للاختبار (Array of Missions).

اجتياز الاختبار:

عند اكتمال جميع المهام:

ارفع رتبة اللاعب باستخدام متغير Rank.

أضف رسالة نجاح أو مؤثرات مرئية.

2. نظام تعلم المهارات

أ) تصميم المهارات:

إنشاء Blueprint للمهارات:

أنشئ Blueprint Actor لكل مهارة (مثل هجوم ناري، درع وقائي).

أضف تأثيرات مرئية وصوتية باستخدام Niagara وAudio Component.

إعداد خصائص المهارة:

أضف متغيرات مثل:

Skill Level (مستوى المهارة).

Cooldown Time (مدة الانتظار بين الاستخدامات).

Mana Cost (تكلفة الطاقة).

ب) نظام التعلم:

شجرة المهارات (Skill Tree):

أنشئ Widget Blueprint يعرض قائمة المهارات.

أضف شروط التعلم (مثل مستوى معين أو موارد معينة).

تعلم المهارة:

عند الضغط على زر تعلم مهارة:

تحقق من توافر الشروط.

أضف المهارة إلى قائمة المهارات الخاصة بالشخصية.

ج) استخدام المهارات:

ربط المهارات بالأزرار:

أنشئ قائمة (Array) للمهارات المكتسبة.

اربط الأزرار بلوحة المفاتيح أو واجهة المستخدم.

تنفيذ المهارة:

عند الضغط على زر المهارة:

تحقق من الطاقة المتاحة والـ Cooldown.

نفذ تأثير المهارة باستخدام Blueprint.

تطوير المهارات:

عند رفع مستوى المهارة، زد قوتها (مثل ضرر أعلى أو مدة أطول).

استخدم Niagara Effects لإظهار تحسينات المستوى.

3. نافذة الشخصية

أ) تصميم نافذة الشخصية:

إنشاء Widget Blueprint:

أضف عناصر واجهة لعرض:

الإحصائيات (مثل القوة، السرعة، الصحة).

العتاد (الأسلحة، الدروع).

قائمة المهارات.

ربط الإحصائيات بالشخصية:

أنشئ متغيرات في Blueprint الشخصية (مثل Strength, Agility).

استخدم Bindings لعرض القيم داخل واجهة المستخدم.

ب) تعديل الإحصائيات:

زيادة الإحصائيات:

عند اكتساب نقاط خبرة، امنح اللاعب نقاطًا يمكن إنفاقها على الإحصائيات.

عند التخصيص، زد القيم وحدث واجهة المستخدم.

التأثير على اللعب:

اربط الإحصائيات بالأنظمة الأخرى (مثل زيادة ضرر الهجمات بزيادة Strength).

4. ارتداء ونزع المواد للشخصية

أ) إعداد العتاد:

Blueprint للمواد:

أنشئ Blueprint Actor لكل نوع من المواد (مثل درع، سيف).

أضف متغيرات مثل:

Item Type (Weapon/Armor).

Bonus Stats (مثل زيادة الصحة أو القوة).

واجهة العتاد:

في Widget Blueprint، أضف قائمة (Inventory) لعرض المواد المتوفرة.

ب) تجهيز المواد:

ارتداء المادة:

عند اختيار مادة من القائمة:

تحقق من نوع المادة.

اربط Skeletal Mesh أو Static Mesh بالشخصية.

نزع المادة:

عند النقر على زر Remove:

قم بإزالة المادة من الشخصية.

أعد الإحصائيات إلى قيمها الأصلية.

ج) عرض المواد على الشخصية:

دمج المادة مع الشخصية:

أضف مكون Skeletal Mesh أو Static Mesh إلى الشخصية.

عند تجهيز المادة، غير المظهر باستخدام Set Skeletal Mesh.

تأثيرات المادة:

أضف تأثيرات مرئية للمادة (مثل لمعان الدرع أو ذيل سيف مشع).

5. تأثيرات بصرية للتخصص العالي

Niagara Effects:

صمم مؤثرات خاصة تعكس القوة العالية (مثل هالة طاقة حول الشخصية أو درع ساطع).

أضف Niagara Component للشخصية أو العتاد.

ربط التأثيرات بالتخصص:

عند ترقية التخصص، فعل التأثير باستخدام عقدة Activate.

استخدم شروطًا لإظهار التأثير فقط عند حمل مواد معينة أو الوصول إلى مستوى معين.

خلاصة:

اجمع الأنظمة المختلفة (الاختبارات، المهارات، العتاد) في تصميم متكامل.

ركز على واجهات المستخدم لتحسين تجربة اللعب.

استخدم تأثيرات مرئية وصوتية لتعزيز انطباع التطوير والقوة.

1. إنشاء واجهة المستخدم (HUD)

أ) تصميم الواجهة:

أنشئ Widget Blueprint باسم BP_PlayerHUD.

أضف العناصر التالية:

Progress Bar لشريط الصحة (Health Bar).

Progress Bar لشريط المهارات (Mana/Stamina Bar).

Progress Bar لشريط المستوى (Experience Bar).

نصوص (Text) لعرض القيم الحالية (مثل Health, Mana, وLevel).

ب) إعداد القيم الديناميكية:

اربط شريط الصحة بـ Health:

أضف متغير CurrentHealth وMaxHealth في Blueprint الشخصية.

احسب نسبة الصحة:

makefile

Copy code

HealthPercentage = CurrentHealth / MaxHealth

استخدم Binding لشريط الصحة لعرض هذه النسبة.

اربط شريط المهارات بـ Stamina/Mana:

أضف متغيرات CurrentMana وMaxMana.

احسب نسبة الطاقة:

makefile

Copy code

ManaPercentage = CurrentMana / MaxMana

استخدم نفس الطريقة لتحديث الشريط.

اربط شريط المستوى بـ Experience:

أضف متغيرات:

CurrentExperience (الخبرة الحالية).

ExperienceToNextLevel (الخبرة المطلوبة للمستوى التالي).

احسب النسبة:

makefile

Copy code

ExperiencePercentage = CurrentExperience / ExperienceToNextLevel

اربط الشريط بهذه القيمة.

2. تحديث الصحة والطاقة

أ) تقليل الصحة:

عند تلقي اللاعب ضررًا:

قم بتقليل قيمة CurrentHealth.

إذا وصلت إلى الصفر، شغل نظام الموت أو الإعادة.

حدث شريط الصحة:

استخدم عقدة Set Progress Bar Value لتحديث نسبة الصحة.

ب) استهلاك المهارات:

عند استخدام مهارة:

قلل CurrentMana بناءً على تكلفة المهارة.

تحقق إذا كان لديك ما يكفي من Mana قبل تنفيذ المهارة.

أعد شحن Mana تدريجيًا:

في حدث Tick أو وظيفة متكررة:

css

Copy code

CurrentMana = FMath::Clamp(CurrentMana + RechargeRate * DeltaTime, 0, MaxMana)

3. نظام رفع مستوى الشخصية

أ) إضافة الخبرة:

عند إكمال مهمة أو قتل عدو:

زد قيمة CurrentExperience.

تحقق إذا تجاوزت ExperienceToNextLevel:

إذا كانت كذلك، زد مستوى الشخصية:

Copy code

Level += 1

CurrentExperience -= ExperienceToNextLevel

ExperienceToNextLevel *= 1.25  // لتزيد الصعوبة تدريجيًا.

ب) رفع الإحصائيات عند زيادة المستوى:

زد القيم الأساسية (مثل الصحة، الطاقة):

MaxHealth += 10

MaxMana += 5

أعد ضبط القيم الحالية:

makefile

Copy code

CurrentHealth = MaxHealth

CurrentMana = MaxMana

أضف رسالة للاعب توضح ترقيته:

استخدم Widget أو تأثيرات مرئية/صوتية للإعلان عن المستوى الجديد.

4. عرض المستوى الحالي للشخصية

أ) إضافة نص للمستوى:

في BP_PlayerHUD، أضف عنصر Text لعرض المستوى.

اربطه بـ Level من Blueprint الشخصية.

5. ربط النظام بشخصية اللاعب

أ) إضافة واجهة المستخدم إلى الشاشة:

في Blueprint الشخصية (أو PlayerController):

عند بدء اللعبة، أضف:

sql

Copy code

Create Widget -> BP_PlayerHUD

Add to Viewport

اربط HUD بمتغيرات الشخصية:

قم بتحديث القيم في كل مرة تتغير فيها الصحة، الطاقة، أو الخبرة.

6. تحسين التجربة:

أ) تأثيرات مرئية:

عند تقليل الصحة:

أضف تأثيرات مثل اهتزاز الكاميرا أو وميض الشاشة باللون الأحمر.

عند زيادة المستوى:

أضف تأثيرات مثل انفجار طاقة أو هالة حول الشخصية.

ب) تحسين الأداء:

لا تقم بتحديث شريط الصحة والطاقة والخبرة باستمرار في حدث Tick.

استخدم أحداث مخصصة (مثل OnTakeDamage أو OnGainExperience) لتقليل استهلاك الموارد.

مثال عملي:

شريط الصحة:

أضف Progress Bar.

اربط شريط الصحة بمتغير:

makefile

Copy code

HealthPercentage = CurrentHealth / MaxHealth

حدث القيمة عند تلقي الضرر:

Copy code

CurrentHealth -= Damage

شريط الخبرة:

عند قتل عدو:

csharp

Copy code

CurrentExperience += EnemyKillXP

if (CurrentExperience >= ExperienceToNextLevel) {

    Level += 1

    CurrentExperience -= ExperienceToNextLevel

    ExperienceToNextLevel *= 1.25

}

شريط المهارات:

عند استخدام المهارة:

scss

Copy code

if (CurrentMana >= SkillCost) {

    CurrentMana -= SkillCost

    ActivateSkill()

}

1. نظام الجوع والعطش

أ) إعداد المتغيرات الأساسية:

في Blueprint الشخصية:

أضف المتغيرات:

Hunger (الجوع): يبدأ عند 100 (مشبع تمامًا).

Thirst (العطش): يبدأ عند 100 (مشبع تمامًا).

حدد الحد الأقصى لكل منهما عند 100.

إضافة معدلات الاستنزاف:

أضف متغيرين:

HungerDecayRate: معدل نقصان الجوع (مثل 0.5 لكل ثانية).

ThirstDecayRate: معدل نقصان العطش (مثل 1 لكل ثانية).

ب) تقليل القيم بمرور الوقت:

في حدث Event Tick أو باستخدام Timer:

css

Copy code

Hunger = FMath::Clamp(Hunger - HungerDecayRate * DeltaTime, 0, 100)

Thirst = FMath::Clamp(Thirst - ThirstDecayRate * DeltaTime, 0, 100)

أضف منطقًا لتأثير الجوع والعطش:

إذا وصل الجوع أو العطش إلى صفر:

قلل الصحة تدريجيًا:

Copy code

Health -= HungerDamageRate * DeltaTime

ج) إظهار الجوع والعطش:

في واجهة المستخدم:

أضف شريطي Progress Bar:

واحد للجوع، وواحد للعطش.

اربط كل شريط بالمتغير المناسب (Hunger وThirst).

2. الشرب والأكل

أ) إعداد العناصر:

Blueprint Actor للطعام والشراب:

أضف متغيرين:

HungerRestore: الكمية التي يعيدها الطعام للجوع.

ThirstRestore: الكمية التي يعيدها الشراب للعطش.

Collision Component:

أضف مكونًا مثل Box Collision.

عند التفاعل مع العنصر، تحقق من نوعه (طعام/شراب).

ب) استهلاك الطعام/الشراب:

عند الضغط على زر التفاعل:

تحقق إذا كان العنصر قريبًا:

css

Copy code

Hunger = FMath::Clamp(Hunger + HungerRestore, 0, 100)

Thirst = FMath::Clamp(Thirst + ThirstRestore, 0, 100)

أزل العنصر من العالم باستخدام Destroy Actor.

3. بناء القوارب

أ) تصميم القارب:

Blueprint Actor للقارب:

أضف مكونات مثل:

Static Mesh للقارب.

Collision Component للتفاعل.

حركة القارب:

أضف مكونًا مثل Floating Pawn Movement.

استخدم مدخلات لوحة المفاتيح (أو شاشة اللمس) لتحريك القارب:

css

Copy code

MoveForward -> Add Movement Input

Turn -> Add Controller Yaw Input

ب) إنشاء القارب:

أضف نظامًا لجمع المواد:

عند جمع موارد مثل الخشب:

أضفها إلى متغير Inventory.

واجهة البناء:

أنشئ قائمة بالعناصر القابلة للبناء (مثل قارب صغير).

عند اختيار القارب:

تحقق من توفر المواد.

استخدم Spawn Actor لإضافة القارب للعالم.

4. الإبحار

أ) إعداد نظام المياه:

أضف Water Body (من نظام المياه في Unreal Engine) لتمثيل البحر.

أضف تأثيرات مثل حركة الأمواج باستخدام Niagara.

ب) تفاعل القارب مع المياه:

استخدم فيزيائيات مثل Buoyancy لجعل القارب يطفو.

أضف تأثيرات مثل الرذاذ باستخدام Particle Effects عند الإبحار.

5. الصيد

أ) تصميم الصنارة:

Blueprint Actor للصنارة:

أضف Static Mesh للصنارة والخيط.

أضف نظامًا لمحاكاة رمي الصنارة باستخدام Physics Constraints.

نقطة التفاعل:

عند رمي الصنارة:

تحقق من وجود سمكة في منطقة التفاعل (Collision).

ب) تصميم الأسماك:

Blueprint Actor للأسماك:

أضف مكونًا للحركة:

اجعل الأسماك تتحرك عشوائيًا في الماء باستخدام AI Behavior أو Spline Path.

إمساك الأسماك:

عند التقاط سمكة:

أضفها إلى Inventory.

قم بإزالتها من العالم.

6. الحيوانات

أ) تصميم الحيوانات:

Blueprint Actor لكل نوع من الحيوانات:

أضف مكونات مثل:

Static Mesh أو Skeletal Mesh.

AI Controller.

حركة الحيوانات:

استخدم AI Behavior Tree لجعل الحيوانات تتجول أو تهرب عند الاقتراب.

ب) التفاعل مع الحيوانات:

عند مهاجمة حيوان:

قلل صحته باستخدام Take Damage.

إذا وصلت الصحة إلى صفر:

أضف العناصر الناتجة (مثل اللحم) إلى Inventory.

قم بتدمير الحيوان.

عند الاقتراب من حيوان أليف:

أضف نظام تفاعل (مثل اللعب أو إطعامه).

7. تحسين التجربة

أ) تأثيرات مرئية وصوتية:

عند الجوع أو العطش:

أضف تأثيرات مثل اهتزاز الشاشة أو صوت تنبيه.

عند الإبحار:

أضف صوت الأمواج وحركة الرياح.

ب) تحسين الأداء:

قلل عدد الكائنات التي يتم تحديثها باستمرار.

استخدم LOD (Level of Detail) لتحسين أداء الرسوميات.

تصميم لعبة مشابهة لـ GTA San Andreas باستخدام Unreal Engine 4/5 مع Blueprints، يتطلب تخطيطًا مفصلاً وبنية منظمة لتحقيق توازن بين الحجم الكبير للعبة والأداء الجيد على مختلف الأجهزة، مع ميزات مثل المهمات المختلفة، كسب المال، بناء منزل ومزرعة، وشراء أثاث منزلية. وهذه اهم الخطوات

1. تصميم عالم اللعبة (Open World)

أ) خريطة صغيرة ولكن مليئة بالتفاصيل:

استخدم World Composition (أو Level Streaming) لتقسيم الخريطة إلى أجزاء صغيرة جدًا، بحيث يمكن تحميل أجزاء منها فقط عندما يكون اللاعب قريبًا منها.

استخدم Landscape Tool لإنشاء التضاريس (جبال، سهول، شواطئ) مع Low Poly Assets لخفض استهلاك الذاكرة.

ب) تحسين الأداء:

استخدم Level of Detail (LOD) للمجسمات والأشياء التي تظهر بعيدًا.

دمج Occlusion Culling لتقليل العناصر التي تظهر في كل مرة.

Bake lighting (إضاءة ثابتة) بدلاً من استخدام الإضاءة الديناميكية الثقيلة.

2. إنشاء الشخصية الرئيسية والتفاعل مع العالم

أ) الشخصية الرئيسية:

أنشئ Blueprint للشخصية مع جميع الحركات الأساسية مثل المشي، الجري، القيادة، التفاعل مع الأشياء.

استخدم Character Blueprint مع مكونات مثل Capsule Collider و Character Movement لجعل الشخصية تتفاعل مع البيئة.

أضف Animation Blueprint للتحكم في الحركات مثل الجري، القفز، واستخدام الأسلحة.

ب) التفاعل مع البيئة:

أنشئ Blueprint Interactions مع كائنات مثل أبواب السيارات، النوافذ، الأنظمة التجارية، ومناطق البناء (مثل المزرعة أو المنزل).

استخدم Widget Blueprint لتصميم قوائم التفاعل مع عناصر مثل "شراء الأثاث"، "التحدث مع NPC"، "إتمام مهمة".

3. المهمات (Missions)

أ) نظام المهمات:

أنشئ Mission System باستخدام Blueprints:

أضف Variables لتتبع حالة المهمة (لم تبدأ، جارية، تم إتمامها).

استخدم Event Dispatchers لتحديث واجهة المستخدم بناءً على حالة المهمة.

لكل مهمة، صمم Quest Objectives مثل: "اذهب إلى الموقع X"، "تحدث مع NPC"، "جمع عناصر".

قم بتحديد مناطق خاصة على الخريطة لتنفيذ المهمات، مثل مواقع البناء أو القتال.

استخدم AI Behavior Trees للمهمات التي تشمل NPCs يتفاعلون مع اللاعب.

4. كسب المال والعمل

أ) إنشاء نظام عمل وكسب المال:

أنشئ Blueprint للوظائف المختلفة 

مثل:

العمل في الزراعة: زراعة المحاصيل وجنيها.

العمل في التجارة: شراء وبيع المنتجات في السوق.

العمل كمستأجر: بناء منزل وتأجيره للمواطنين.

إضافة متغيرات للمال:

في Blueprint الشخصية، أضف متغير Money.

عند إتمام مهمة أو جمع المال من العمل، قم بزيادة المال:

makefile

Copy code

Money += EarnedAmount

ب) استخدام المال:

أضف نظامًا يمكن من خلاله شراء أشياء مثل:

الملابس من متجر الملابس.

الأثاث من متجر الأثاث.

المنازل أو المزارع.

5. بناء منزل ومزرعة

أ) إنشاء نظام البناء:

أنشئ Blueprint لكل نوع من المباني (منزل، مزرعة، ورشة).

أضف Static Meshes للمباني.

استخدم Collision Component لاحتساب مكان بناء الكائنات.

عند الضغط على زر البناء:

تحقق من المال المتاح.

قم باستخدام Spawn Actor لإنشاء المبنى في المكان المحدد.

أنشئ نظام تفاعل يسمح للاعب بإضافة عناصر داخل المنزل مثل الأثاث (مثل الأسرة، الطاولات).

أضف Inventory System لتمكين إضافة الأثاث بعد شراءه.

6. إنشاء نظام الأثاث داخل المنزل

أ) إعداد الأثاث:

أنشئ Blueprint للأثاث.

أضف Static Meshes للأثاث.

أضف Collision لتمكين التفاعل مع الأثاث داخل المنزل.

استخدم UI Widgets لعرض قائمة بالأثاث المتاح:

عند شراء الأثاث من المتجر، أضف العناصر إلى Inventory.

أضف Buttons في واجهة المستخدم تتيح للاعب اختيار مكان وضع الأثاث داخل المنزل.

7. التحكم في حجم اللعبة والأداء

أ) تقليل حجم اللعبة:

استخدم Compression لملفات الصوت والصورة لتقليل حجم اللعبة.

Bake الرسوميات بدلًا من استخدام الإضاءة الديناميكية الثقيلة.

استخدم Texture Streaming لتحميل النصوص بشكل ديناميكي.

ب) تحسين الرسوميات والأداء:

استخدم Occlusion Culling لإخفاء الأشياء غير المرئية.

قسم الخرائط الكبيرة إلى خرائط أصغر باستخدام World Composition.

8. تحسين تجربة اللاعب

أ) تأثيرات مرئية وصوتية:

أضف تأثيرات مرئية:

عند البناء أو التفاعل، استخدم Particle Effects مثل الدخان أو الأنوار.

عند كسب المال أو بناء شيء جديد، يمكن إضافة Effects مثل الصوت أو الوميض.

أضف تأثيرات صوتية لكل تفاعل (مثل صوت البناء، الموسيقى أثناء العمل، وأصوات البيئة).

ب) تحسين واجهة المستخدم:

أضف HUD لعرض المال، مستوى الصحة، مستوى الجوع والعطش، وقائمة المهمات.

أضف مؤشر التفاعل لتوجيه اللاعب إلى الأهداف.

خلاصة:

تنظيم المشروع وتخطيطه بعناية لتحديد كيفية تقسيم العالم الكبير مع الحفاظ على الأداء الجيد.

استخدام Blueprints لتصميم الأنظمة (المهمات، العمل، المال، البناء، الأثاث) بشكل متكامل.

تحسين الأداء باستخدام تقنيات مثل Level Streaming و LOD لتقليل استهلاك الذاكرة.

لتصميم لعبة بسيطة في Unreal Engine

باستخدام Blueprints تتضمن عمليات حسابية حيث تحصل على نقاط عن كل إجابة صحيحة وتزداد صعوبة الأسئلة أو تقليص الوقت مع كل مستوى، يمكنك اتباع الخطوات التالية:

الخطوة 1: إعداد الواجهة الرئيسية للعبة

إنشاء واجهة المستخدم (UI):

في Content Browser، أنشئ Widget Blueprint جديدًا (مثلًا: WBP_GameUI).

في هذا الواجهة، أضف المكونات التالية:

Text Block لعرض السؤال.

Text Block لعرض النتيجة.

Text Block لعرض الوقت المتبقي (إذا كنت تستخدم عداد الوقت).

Buttons أو Text Boxes لإدخال الإجابة.

Progress Bar لعرض التقدم في المستوى أو العد التنازلي للوقت.

إظهار واجهة المستخدم عند بداية اللعبة:

في Game Mode Blueprint، قم بإنشاء حدث يبدأ عند بداية اللعبة (مثلًا، في Begin Play):

استخدم Create Widget لإنشاء واجهة المستخدم.

استخدم Add to Viewport لعرض الواجهة.

الخطوة 2: إعداد المتغيرات في اللعبة

متغيرات لإدارة النقاط والمستوى:

في GameMode Blueprint،

 أضف المتغيرات التالية:

Score: لتخزين النقاط.

CurrentLevel: لتخزين المستوى الحالي.

TimeLeft: لتخزين الوقت المتبقي في كل مستوى.

MaxLevel: لتحديد عدد المستويات.

إعداد العمليات الحسابية:

أضف متغيرين في GameMode 

مثل:

FirstNumber و SecondNumber: الأرقام التي ستستخدمها في العمليات الحسابية.

CorrectAnswer: لتخزين الإجابة الصحيحة.

الخطوة 3: إنشاء منطق العمليات الحسابية

اختيار عملية حسابية عشوائية:

في Event Begin Play أو في كل مرة يتغير فيها المستوى:

اختر عملية حسابية عشوائية (مثلًا: جمع، طرح، ضرب):

استخدم Random Integer لاختيار الأرقام.

استخدم Random Integer (Range) لاختيار العمليات الحسابية.

إنشاء الأسئلة:

أنشئ سؤالًا مع FirstNumber و SecondNumber في Text Block على واجهة المستخدم.

بناء على العملية العشوائية، قم بحساب الإجابة باستخدام Blueprints.

قم بتخزين الإجابة في المتغير CorrectAnswer.

الخطوة 4: إدخال الإجابة من اللاعب والتحقق منها

التفاعل مع الإجابة:

أضف Button أو Text Box حيث يمكن للاعب إدخال الإجابة.

عند الضغط على الزر أو إدخال الإجابة، قارن الإجابة المدخلة مع CorrectAnswer:

إذا كانت الإجابة صحيحة:

أضف نقاطًا إلى المتغير Score.

ازداد المستوى CurrentLevel.

قم بتحديد سؤال جديد بناءً على المستوى الجديد.

إذا كانت الإجابة خاطئة:

عرض رسالة تقول أن الإجابة خاطئة وسمح للاعب بتجربة إجابة أخرى.

زيادة صعوبة اللعبة مع كل مستوى:

مع كل مستوى، يمكنك جعل العمليات الحسابية أصعب (مثل إضافة أرقام أكبر أو تغيير نوع العمليات).

لتسريع الوقت مع كل مستوى، يمكنك تقليل قيمة TimeLeft بعد كل مستوى، أو زيادة سرعة المؤقت.

الخطوة 5: إدارة الوقت

عداد الوقت:

أضف متغير TimeLeft في GameMode وابدأ العد التنازلي في Event Tick:

Copy code

TimeLeft -= DeltaTime

اعرض هذا الوقت المتبقي في Text Block على واجهة المستخدم.

تسريع الوقت مع التقدم في المستويات:

كلما زاد المستوى، قم بتقليص وقت الإجابة أو زيادة سرعة العداد.

إذا انتهى الوقت (عند TimeLeft == 0):

أنهي اللعبة أو قدّم للمستخدم خيار إعادة المحاولة.

الخطوة 6: الانتقال بين المستويات

زيادة الصعوبة مع كل مستوى:

عند إتمام كل مستوى (بعد الإجابة الصحيحة)، زد مستوى اللعبة.

قم بزيادة CurrentLevel عند الإجابة الصحيحة.

عند الوصول إلى المستوى الأعلى أو إنهاء اللعبة، قدم للمستخدم رسالة تهنئة.

إعادة تشغيل المستوى:

إذا فشل اللاعب في الإجابة بشكل صحيح أو انتهى الوقت، يمكنه العودة إلى البداية أو إعادة المحاولة.

الخطوة 7: التحسينات والنهاية

إضافة صوتيات:

يمكنك إضافة أصوات للإجابة الصحيحة، الإجابة الخاطئة، أو المؤقت.

إضافة مؤثرات بصرية:

أضف تأثيرات مثل الوميض أو تغيرات الألوان عند الإجابة الصحيحة أو الخطأ.

تحسين واجهة المستخدم:

قد تحتاج إلى إضافة المزيد من التأثيرات البصرية مثل Progress Bar للتقدم، أو Animations للانتقال بين الأسئلة.

خلاصة:

هذه هي الخطوات الأساسية لإنشاء لعبة بسيطة في Unreal Engine باستخدام Blueprints:

إعداد واجهة المستخدم (UI).

إضافة المتغيرات لإدارة النقاط، الوقت، والمستوى.

إنشاء عمليات حسابية عشوائية.

التفاعل مع الإجابة والتحقق منها.

إدارة الوقت مع تسريع المستوى.

الانتقال بين المستويات وزيادة الصعوبة.

إنشاء لعبة بسيطة في Unreal Engine

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

الخطوات الأساسية لتطوير اللعبة:

1. إعداد واجهة المستخدم (UI)

إنشاء Widget Blueprint لواجهة الأسئلة:

في Content Browser، أنشئ Widget Blueprint جديدًا (مثلًا WBP_QuizUI).

في الواجهة، أضف المكونات التالية:

Text Block لعرض السؤال.

Button أو Text Block لعرض 4 خيارات للإجابة 

(على سبيل المثال: Option1, Option2, Option3, Option4).

Text Block لعرض عدد النقاط.

Text Block لعرض عدد الإجابات الخاطئة.

Progress Bar أو Text Block لعرض تقدم اللاعب في الخريطة.

**2. إنشاء المتغيرات في GameMode و PlayerController

في GameMode:

أضف المتغيرات التالية:

Score (عدد النقاط).

WrongAnswers (عدد الإجابات الخاطئة).

CurrentQuestionIndex (لتتبع السؤال الحالي).

MaxWrongAnswers (عدد الإجابات الخاطئة التي تسمح بها اللعبة قبل العودة للبداية، مثل 5).

QuestionsArray (مصفوفة من الأسئلة التي تحتوي على الأسئلة، الخيارات والإجابات الصحيحة).

PlayerLocation (الموقع الحالي للاعب على الخريطة).

3. إنشاء الأسئلة والإجابات

إعداد الأسئلة:

أنشئ Structure Blueprint

 يحتوي على:

QuestionText: النص الخاص بالسؤال.

Options: مصفوفة تحتوي على 4 خيارات.

CorrectAnswer: الرقم الذي يمثل الخيار الصحيح (مثلاً 1 إذا كان الخيار الأول هو الصحيح).

إعداد QuestionsArray:

قم بإنشاء مصفوفة من هذه الـ Structures، حيث تحتوي كل عنصر على سؤال واحد مع الخيارات والإجابة الصحيحة.

4. منطق الإجابة على الأسئلة

تغيير السؤال عند الإجابة:

عند الضغط على أحد الأزرار (التي تمثل الخيارات)، تحقق مما إذا كانت الإجابة صحيحة أو خاطئة باستخدام المقارنة بين الإجابة الصحيحة (CorrectAnswer) والإجابة المختارة من اللاعب.

إذا كانت الإجابة صحيحة:

أضف النقاط إلى المتغير Score.

انتقل إلى السؤال التالي باستخدام CurrentQuestionIndex.

تقدم اللاعب على الخريطة باستخدام Add Actor Location.

إذا كانت الإجابة خاطئة:

أضف نقطة إلى المتغير WrongAnswers.

ارجع اللاعب خطوة واحدة للخلف في الموقع باستخدام Add Actor Location.

إذا وصل WrongAnswers إلى 5، أعد اللاعب إلى البداية (أو أنهي اللعبة).

5. التحكم في تقدم اللاعب على الخريطة

الانتقال بين الأسئلة على الخريطة:

عندما يجيب اللاعب على سؤال بشكل صحيح، يمكنك تغيير موقعه على الخريطة عن طريق تعديل متغير PlayerLocation وتحديث الموقع باستخدام Set Actor Location.

عندما تكون الإجابة خاطئة، يمكن تغيير الموقع للرجوع إلى نقطة سابقة على الخريطة (عن طريق Set Actor Location).

6. إضافة التفاعل مع واجهة المستخدم

في Blueprint الخاص بالـ Widget:

استخدم OnClicked لتحديد أي زر من الأزرار تم الضغط عليه.

عندما يتم الضغط على أحد الأزرار، قم بالتحقق من الإجابة:

إذا كانت صحيحة، أضف النقاط ومرر إلى السؤال التالي.

إذا كانت خاطئة، أضف خطأ وارجع اللاعب للوراء.

7. التعامل مع نهاية اللعبة

الرجوع للبداية بعد 5 إجابات خاطئة:

عندما يصل اللاعب إلى 5 إجابات خاطئة، قم بإرجاعه إلى البداية:

يمكنك إيقاف اللعبة أو إعادة تعيين النقاط والإجابات الخاطئة إلى صفر.

أعد CurrentQuestionIndex إلى 0 وأعد تعيين موقع اللاعب إلى البداية.

8. مثال على منطق في Blueprints

مثال لتغيير السؤال:

عند الإجابة الصحيحة، قم بزيادة CurrentQuestionIndex:

plaintext

Copy code

CurrentQuestionIndex += 1

إذا كانت الإجابة خاطئة، قم بزيادة WrongAnswers:

plaintext

Copy code

WrongAnswers += 1

مثال على التفاعل مع الأزرار:

عند الضغط على زر (الخيار):

تحقق من صحة الإجابة:

plaintext

Copy code

if (SelectedOption == CorrectAnswer)

{

    Score += 10; // إضافة النقاط

    MovePlayerForward(); // تحريك اللاعب للأمام

}

else

{

    WrongAnswers += 1;

    MovePlayerBackward(); // تحريك اللاعب للخلف

}

9. إضافة تحسينات

واجهة مستخدم أكثر تعقيدًا:

يمكنك إضافة شريط للحياة أو وقت العد التنازلي للوقت لإجابة الأسئلة.

أضف أنماطًا صوتية ومرئية لكل إجابة صحيحة أو خاطئة لتحسين التفاعل.

إضافة مؤثرات:

يمكن إضافة Effect مثل وميض أو صوت عند الإجابة الصحيحة أو الخاطئة.

خلاصة

هذه هي الخطوات الأساسية لإنشاء لعبة بسيطة تتضمن أسئلة وأربع خيارات للإجابة:

إنشاء واجهة المستخدم لعرض الأسئلة والأجوبة.

تخزين الأسئلة في مصفوفة تحتوي على الخيارات والإجابة الصحيحة.

منطق الإجابة: إذا كانت صحيحة، يكسب اللاعب نقاطًا ويتقدم على الخريطة، وإذا كانت خاطئة يتم إرجاعه للوراء.

إضافة حساب الأخطاء، وإذا وصل اللاعب إلى 5 إجابات خاطئة، يتم إرجاعه إلى البداية.

تحسين واجهة المستخدم مع تأثيرات صوتية ومرئية.

 لعبة اجتياز العقبات، الأفخاخ، قتال وحوش،

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

الخطوة 1: إعداد المشروع

إنشاء مشروع جديد:

افتح Unreal Engine.

اختر Blank Project، واضغط على Next.

اختر Mobile/Tablet تحت نوع المشروع لتناسب اللعبة الهاتفية.

اختر Blueprint في الأساس، وتأكد من تحديد No Starter Content.

قم بتسمية المشروع، على سبيل المثال: "ObstacleAndCombatGame"، ثم اضغط على Create.

الخطوة 2: إنشاء الشخصيات والعقبات

2.1 إنشاء الشخصية الرئيسية

إنشاء Character Blueprint:

في Content Browser، اضغط على Add New ثم اختر Blueprint Class.

اختر Character كنوع الكلاس، ثم سمه BP_PlayerCharacter.

إضافة مكونات الشخصية:

أضف مكونات مثل Mesh (لتمثيل الشخصية)، Capsule Collider (للتحقق من التصادمات)، و Character Movement (للتحكم في الحركة).

قم بإعداد Animation Blueprint للشخصية لتفعيل الرسوم المتحركة (مثل الجري والقفز).

التحكم في الشخصية:

في BP_PlayerCharacter، افتح الـ Event Graph.

استخدم Input Axis (من الـ Project Settings > Input) للتحكم في حركة الشخصية باستخدام WASD أو Joystick إذا كنت تطور اللعبة للهاتف.

2.2 إنشاء العقبات والأفخاخ

إنشاء العقبات:

أنشئ Blueprint Class جديدًا من النوع Actor، واسمه BP_Obstacle.

أضف Static Mesh (مثل مكعب أو أي شكل آخر يمثل عقبة) في مكونات الـ Actor.

يمكنك إضافة Collision (مثل Box Collider) للتحقق من اصطدام الشخصية بالعقبة.

إضافة الأفخاخ:

أنشئ BP_Trap مماثل لـ BP_Obstacle ولكن مع مكونات إضافية مثل Trigger Box لاكتشاف اصطدام الشخصية بالفخ.

عندما يصطدم اللاعب بالفخ، يمكن إضافة تأثيرات مثل ضرر أو تباطؤ.

2.3 إعداد البيئة والانتقال بين المراحل

إنشاء البوابة:

أنشئ Blueprint Class من النوع Actor، واسمه BP_Gate.

أضف Static Mesh لتمثيل البوابة (مثل بوابة كبيرة).

استخدم Trigger Box للكشف عن اقتراب الشخصية من البوابة.

الانتقال للمرحلة التالية:

في BP_Gate، في Event Begin Overlap، تحقق إذا كانت الشخصية قد دخلت داخل منطقة التفاعل:

plaintext

Copy code

OnOverlap (Character Entered)

عند التفاعل مع البوابة، يمكنك استخدام Open Level للانتقال إلى المرحلة التالية.

الخطوة 3: إضافة قتال وحوش

3.1 إنشاء وحوش القتال

إنشاء Blueprint للوحوش:

أنشئ Blueprint Class جديدًا من النوع Character واسمه BP_EnemyCharacter.

أضف Mesh لتمثيل الوحش، و Capsule Collider لاصطفاف التصادمات.

إضافة AI للوحوش:

في الـ Event Graph للوحش، يمكنك استخدام AI Controller للتحكم في حركة الوحش.

أضف مكونات مثل Behavior Tree و Blackboard للتحكم في حركة الوحش بطريقة ذكية

 (مثل البحث عن اللاعب ومهاجمته).

3.2 القتال بين الشخصية والوحش

إنشاء أسلحة وحركات الهجوم:

أضف Melee Weapon أو Projectile Weapon (إذا كنت تستخدم سلاحًا عن بعد).

عند هجوم الشخصية، قم بإضافة تأثيرات مثل الصوت أو الإضاءة باستخدام Particle System.

إدارة الصحة:

أضف متغيرات Health للشخصية والوحوش.

في Event Graph، عند تفعيل الهجوم (مثلما يضغط اللاعب على زر الهجوم)، تحقق مما إذا كان هناك تصادم مع الوحش.

في حالة الاصطدام، خصم الصحة للوحش أو الشخصية.

الخطوة 4: إضافة الصوت والتفاعل مع الشخصية

إضافة الصوت:

في BP_PlayerCharacter، يمكنك إضافة مكونات Audio Component لتشغيل الصوت عند التفاعل أو عند الهجوم.

يمكنك استخدام Play Sound at Location لتشغيل الصوت في مكان محدد.

إضافة الصوت التفاعلي مع الشخصية:

أضف Audio Files (مثل أصوات التفاعل مع البيئة أو الهجوم أو الوصول إلى البوابة).

في BP_PlayerCharacter، يمكنك إضافة Event Trigger مثل الضغط على زر أو دخول منطقة تفاعل:

Copy code

Play Sound (مثل "حسناً، لقد وصلنا!")

الخطوة 5: إضافة الواجهة الرئيسية

إنشاء واجهة المستخدم (UI):

أنشئ Widget Blueprint لعرض نقاط الصحة والوقت، مثل WBP_HUD.

أضف Text Blocks لعرض Health، Score، و Time.

أضف Progress Bar لتمثيل تقدم اللاعب.

إظهار الـ UI عند بداية اللعبة:

في Game Mode أو Player Controller، استخدم Create Widget لعرض واجهة المستخدم في بداية اللعبة:

Copy code

Create Widget (WBP_HUD) --> Add to Viewport

الخطوة 6: تحسين اللعبة للهاتف المحمول

إعداد التحكم في الشاشة اللمسية:

في Project Settings > Input، قم بإعداد Touch Inputs للتحكم بالشخصية عن طريق اللمس.

يمكنك استخدام OnTouchStart و OnTouchEnd لتنفيذ الحركات (مثل تحريك الشخصية أو الهجوم).

تعديل الأداء للهاتف المحمول:

تأكد من تقليل عدد الأجزاء الكبيرة في المشهد، مثل الظلال المعقدة.

قم بتفعيل Mobile Preview داخل Unreal Engine لاختبار الأداء على الهاتف المحمول.

خلاصة

باتباع هذه الخطوات، يمكنك إنشاء لعبة بسيطة على Unreal Engine تحتوي على:

شخصية تتحرك.

عقبات وفخاخ يجب أن يتجاوزها اللاعب.

قتال مع وحوش باستخدام أسلحة.

الانتقال بين المراحل عند الوصول إلى البوابة.

صوت يتفاعل مع اللاعب في مراحل مختلفة.

مع هذه الأساسيات، يمكنك البدء في إضافة المزيد من الميزات مثل تحسين الذكاء الصناعي (AI)،

 إضافة المؤثرات البصرية، وتحسين التفاعل مع المستخدم في اللعبة!

Custom Event هي ميزة تتيح لك إنشاء أحداث مخصصة في Blueprint لتشغيل منطق معين في وقت محدد أثناء اللعبة. تساعد هذه الأحداث في تنظيم الكود وتحسين قابلية التكرار والوضوح داخل Blueprint.

استعمالات Custom Event:

1. تنظيم الكود:

بدلاً من تكرار نفس المنطق في أماكن متعددة، يمكن استدعاء الحدث المخصص. مثال:

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

2. استجابة للأحداث المختلفة:

تشغيل منطق محدد استجابةً لأحداث متعددة في اللعبة. مثال:

تشغيل مؤثر صوتي عند ضغط زر معين أو عند اصطدام الكائن بشيء.

3. تبسيط العمليات المتكررة:

جمع التعليمات البرمجية المتكررة في حدث مخصص لتقليل الفوضى. مثال:

تشغيل حركة الكاميرا الانتقالية في كل مرة يتغير مشهد اللعبة.

4. تشغيل تسلسل محدد عند الطلب:

ربط خطوات محددة بتسلسل يتم استدعاؤه عند الحاجة. مثال:

إنشاء حدث مخصص لتشغيل رسوم متحركة وتغيير حالة الكائن عند تدميره.

5. التحكم في التدفق:

تشغيل أجزاء مختلفة من المنطق بناءً على شروط أو مدخلات. مثال:

إنشاء حدث مخصص لتغيير لون الكائن عند تلقيه ضرر معين.

6. إعادة الاستخدام (Reusability):

يمكن استدعاء الحدث المخصص عدة مرات من أماكن مختلفة. مثال:

تشغيل صوت أو مؤثر بصري عند استلام رسالة في اللعبة.

7. تعزيز التعاون بين Blueprints:

استدعاء أحداث مخصصة من Blueprints أخرى باستخدام Event Dispatchers أو مرجع الكائن.

 مثال:

تشغيل حدث مخصص لتحديث واجهة المستخدم عند تغير صحة اللاعب.

كيفية إنشاء واستخدام Custom Event:

1. إنشاء الحدث المخصص:

افتح Blueprint الخاص بك.

انقر بزر الماوس الأيمن على الرسم البياني (Graph) واختر Add Custom Event.

أعط الحدث اسمًا مناسبًا (مثل UpdateHealth).

2. تنفيذ المنطق داخل الحدث:

اربط العقد التي تمثل المنطق الذي تريد تنفيذه مع عقدة Custom Event.

3. استدعاء الحدث:

استخدم عقدة Call Function لاستدعاء الحدث من أي مكان في Blueprint.

أمثلة على الاستخدام:

مثال 1: حدث لتقليل صحة اللاعب

أنشئ Custom Event باسم DecreaseHealth.

أضف مدخلًا للحدث (Input) مثل قيمة الضرر (Damage).

اربط العقدة بعملية حسابية (طرح قيمة الضرر من الصحة).

استدعِ الحدث عند تلقي اللاعب ضررًا.

مثال 2: حدث لتحديث واجهة المستخدم

أنشئ Custom Event باسم UpdateUI.

أضف العقد اللازمة لتحديث عناصر واجهة المستخدم (مثل شريط الصحة).

استدعِ الحدث عند تغيير صحة اللاعب أو نقاطه.

مثال 3: حدث لتشغيل حركة معينة

أنشئ Custom Event باسم PlayAnimation.

اربط العقدة بتشغيل حركة (Animation).

استدعِ الحدث عند الضغط على زر أو اصطدام اللاعب بجسم.

مثال 4: حدث للانتقال بين المستويات

أنشئ Custom Event باسم LoadNextLevel.

اربط العقدة بعقدة Open Level.

استدعِ الحدث عند تفاعل اللاعب مع بوابة أو زر.

فوائد Custom Events:

سهولة التنظيم:

تساعد في تقسيم المهام إلى أجزاء صغيرة ومنظمة.

الوضوح:

تجعل الكود أكثر سهولة في القراءة والفهم.

إعادة الاستخدام:

يمكنك استخدام الحدث المخصص في أماكن متعددة دون الحاجة إلى تكرار الكود.

المرونة:

يمكن تعديل المنطق بسهولة داخل الحدث دون التأثير على استدعاءاته.

نصائح لاستخدام Custom Events:

اختر أسماء واضحة:

اجعل أسماء الأحداث تعبر عن وظيفتها (مثل UpdateScore بدلاً من Event1).

استخدام المدخلات والمخرجات:

استفد من المدخلات لتخصيص المنطق، ومن المخرجات لإرجاع النتائج.

تجنب التعقيد:

إذا كان الحدث يحتوي على منطق معقد، حاول تقسيمه إلى أحداث أصغر.

الاختبار:

تأكد من أن الأحداث تعمل كما هو متوقع قبل استدعائها في أماكن متعددة.

الفرق بين Custom Event و Functions:

ولدينا Set Time by function name

هذا الاكثر تقدما من الاول له نفس الاستعمالات لكن هذا يكون التكرار بشكل دائم

ونجر من الobject ونختار self وسنشرح ذلك لاحقا

في faction name نستطيع اضافة اسم الfaction او customevent يعمل معهم كلاهما

لكن الاول اللي هو set time by event يكون الاخف على الجهاز

كلا العقدتين تُستخدمان لإنشاء مؤقتات (Timers) يتم استدعاؤها بعد فترة زمنية معينة بشكل متكرر أو مرة واحدة. المؤقتات مفيدة لتنفيذ منطق معين بشكل دوري أو بعد تأخير زمني.

استعمالات Set Timer by Event:

1. تشغيل منطق متكرر:

يمكن استخدامه لتشغيل حدث معين بشكل دوري.

 مثال:

استدعاء حدث لتقليل صحة اللاعب كل ثانية بسبب تأثير السم.

2. تأخير العمليات:

تشغيل منطق معين بعد فترة زمنية محددة. 

مثال:

تشغيل حدث لتفجير قنبلة بعد 3 ثوانٍ.

3. التحكم في الرسوم المتحركة:

تشغيل تأثير مرئي بشكل دوري. 

مثال:

وميض الضوء في مشهد كل نصف ثانية.

4. معالجة الألعاب:

استدعاء الأحداث التي تتغير بمرور الوقت.

 مثال:

زيادة نقاط اللاعب كل 5 ثوانٍ.

استعمالات Set Timer by Function Name:

1. استدعاء وظيفة ديناميكية:

يمكن استدعاء وظيفة باستخدام اسمها كـ String.

 مثال:

إذا كنت تقوم بتحميل أو تشغيل وظائف محددة بناءً على مدخلات أو حالة اللعبة.

2. توفير مرونة إضافية:

مفيد في الحالات التي يتم فيها تحديد الوظيفة أثناء وقت التشغيل (Runtime). 

مثال:

اختيار وظيفة لتشغيلها بناءً على اختيار اللاعب.

3. تحسين القراءة:

إذا كنت تعرف بالضبط الوظيفة التي تحتاج إلى استدعائها ولست بحاجة إلى حدث مخصص.

4. استدعاء وظائف متعددة بنفس المنطق:

تشغيل منطق متشابه لعدة وظائف مع اختلاف بسيط.

 مثال:

استدعاء وظيفة لتغيير لون كائن بناءً على متغيرات معينة.

خيارات وضبط المؤقتات في كلا العقدتين:

1. الوقت (Time):

يُحدد مدة المؤقت قبل الاستدعاء الأول.

2. حلقة (Looping):

إذا تم تمكينه، سيستمر المؤقت في التكرار حتى يتم إيقافه.

3. عدم التكرار (Non-Looping):

إذا تم تعطيله، يتم استدعاء الحدث أو الوظيفة مرة واحدة فقط.

4. التعامل مع الإرجاع (Return Handle):

كلتا العقدتين تُرجع Timer Handle، وهو مرجع يمكن استخدامه لإيقاف المؤقت لاحقًا باستخدام عقدة Clear Timer by Handle.

أمثلة عملية:

مثال 1: تقليل صحة اللاعب باستخدام Set Timer by Event

أنشئ Custom Event باسم ReduceHealth.

أضف منطقًا داخل الحدث لطرح قيمة معينة من صحة اللاعب.

اربط الحدث بعقدة Set Timer by Event.

اضبط الزمن (مثلاً: 1 ثانية) وقم بتمكين Looping.

مثال 2: تشغيل وظيفة لتغيير اللون باستخدام Set Timer by Function Name

أنشئ وظيفة باسم ChangeColor.

أضف منطقًا داخل الوظيفة لتغيير لون كائن.

استخدم Set Timer by Function Name وأدخل اسم الوظيفة (ChangeColor) كـ String.

اضبط الزمن وتمكين Looping إذا كنت تريد تكرار العملية.

مثال 3: تشغيل مؤثر بعد تأخير

استخدم Set Timer by Event لإنشاء مؤقت يستدعي حدثًا لتشغيل مؤثر (مثل انفجار) بعد 3 ثوانٍ.

قم بإيقاف المؤقت باستخدام Clear Timer by Handle إذا تغيرت الظروف.

مثال 4: تحميل وظيفة ديناميكيًا:

استخدم Set Timer by Function Name لتحديد اسم وظيفة كمدخل خارجي.

بناءً على حالة اللعبة، قم بتغيير اسم الوظيفة واستدعِ منطقًا مختلفًا.

نصائح لاستخدام المؤقتات:

استخدام Timer Handle:

دائمًا احفظ المرجع باستخدام Timer Handle لتتمكن من إيقاف المؤقت عند الحاجة.

التحقق من الوظائف:

عند استخدام Set Timer by Function Name، تأكد من أن اسم الوظيفة مكتوب بشكل صحيح.

التقليل من التكرار:

تجنب تشغيل مؤقتات بتكرار عالٍ دون داعٍ لتجنب تأثيرات الأداء.

استخدام التأخير عند الضرورة:

استخدم مؤقتات بدلاً من Delay إذا كنت بحاجة إلى تشغيل عدة عمليات بالتوازي.

Function

حين نضغط عليه سندخل داخله وسنجد فيه function و return node من سلبياته انه لا يعمل بالاونلاين 

ما هي الـ Functions؟

هي مجموعة من العقد (Nodes) التي تُنفَّذ عند استدعاء الوظيفة. يمكن أن تحتوي على إدخالات (Inputs) وإخراجات (Outputs)، مما يسمح بتمرير القيم واستلام النتائج.

أهم استعمالات الـ Functions:

1. إعادة استخدام الكود (Code Reusability):

إذا كنت تستخدم نفس المنطق في أماكن متعددة، يمكنك وضعه داخل Function واستدعاؤه بدلًا من تكرار نفس الكود.

على سبيل المثال:

حساب الضرر الناتج عن الهجوم.

تحديث شريط الصحة.

التحقق من حالة معينة (مثل هل اللاعب داخل منطقة معينة).

2. تنظيم الكود وتحسين القراءة (Code Organization):

يمكنك تقسيم المنطق المعقد إلى عدة وظائف صغيرة لجعل الكود أكثر تنظيمًا وأسهل قراءة.

مثال:

وظيفة لحساب الضرر.

وظيفة لإضافة النقاط إلى اللاعب.

وظيفة لتحديث الرسوم البيانية (UI).

3. تقليل الأخطاء (Reduce Errors):

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

 (داخل الوظيفة)، مما يقلل من فرص ارتكاب الأخطاء.

4. توفير المرونة:

يمكنك إنشاء Functions تقبل مدخلات مختلفة لإجراء عمليات معينة بناءً على تلك المدخلات.

مثال:

وظيفة للتحقق من حالة العناصر (إذا كانت مفتوحة، مغلقة، أو تالفة) بناءً على قيمة الإدخال.

5. العمل مع القيم المرتجعة (Return Values):

يمكن للـ Function إرجاع قيمة واحدة أو أكثر بعد إجراء عمليات.

مثال:

حساب نتيجة معادلة رياضية وإرجاع النتيجة.

الحصول على موقع معين في اللعبة وإرجاعه.

6. التعامل مع التعقيدات:

الوظائف تجعل من السهل التعامل مع المهام الكبيرة عن طريق تقسيمها إلى أجزاء صغيرة.

مثال:

وظيفة للتحقق من إصابة اللاعب.

وظيفة لمعالجة الضرر الناتج.

وظيفة لتحريك الشخصية بعد الإصابة.

7. تحسين الأداء (Performance):

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

كيفية إنشاء Function في Blueprints:

الخطوات:

افتح Blueprint:

افتح أي Blueprint ترغب في إنشاء وظيفة داخله (مثل شخصية، عدو، أو عنصر معين).

إنشاء Function:

في قائمة My Blueprint (على اليسار)، اختر Functions.

اضغط على زر "+" لإنشاء وظيفة جديدة.

أعطِ الوظيفة اسمًا (مثل CalculateDamage).

إضافة العقد (Nodes):

داخل الوظيفة، أضف المنطق الذي تريد تنفيذه (مثل العقد الخاصة بالضرر أو الحسابات).

إضافة المدخلات والمخرجات (Inputs/Outputs):

في تفاصيل الوظيفة، أضف مدخلات (Inputs) إذا كنت بحاجة لإرسال بيانات إلى الوظيفة.

أضف مخرجات (Outputs) إذا كنت بحاجة لإرجاع نتائج.

استدعاء الوظيفة:

استخدم Call Function Node في المخطط الرئيسي (Event Graph) لاستدعاء الوظيفة.

أنواع الاستخدامات العملية للـ Functions:

1. التعامل مع الصحة والضرر:

وظيفة لحساب الضرر الناتج عن الهجوم:

المدخلات: قوة السلاح، دفاع العدو.

المخرجات: قيمة الضرر.

وظيفة لتحديث شريط الصحة:

المدخلات: الصحة الحالية، الضرر.

العملية: خصم الضرر من الصحة وتحديث الـ UI.

2. العمليات الرياضية:

تنفيذ معادلة معينة وإرجاع النتيجة.

على سبيل المثال:

حساب سرعة الشخصية بناءً على وزنها وسرعة الرياح.

3. التحقق من الشروط:

وظيفة لتحديد إذا كان اللاعب داخل منطقة معينة.

وظيفة لمعرفة إذا كانت الشخصية تمتلك عنصرًا معينًا في حقيبتها.

4. التحكم في الـ AI:

وظيفة تجعل العدو يتحرك باتجاه اللاعب.

وظيفة للتحقق مما إذا كان اللاعب في مرمى رؤية العدو.

5. إدارة واجهة المستخدم (UI):

تحديث النصوص أو الأشرطة الصحية.

وظيفة لتحديث النقاط أو شريط الخبرة.

Macro مميزاته انه يتوفر على مدخلات عديدة ومخرجات ويمكن وضع delay فيه ويستخذم اكثر لترتيب الاكواد

استعمالات عقدة Macro

1. تبسيط العمليات المتكررة

تُستخدم لتجميع العمليات التي يتم تنفيذها بشكل متكرر في مكان واحد.

مثال:

التحقق من حالة معينة (مثل هل اللاعب على الأرض؟).

ضبط المدخلات للاعب أو التحكم في الكاميرا.

2. إدارة مسارات التنفيذ المتعددة

تدعم Macro مسارات متعددة للتنفيذ، مما يجعلها مفيدة للعمليات التي تتطلب خيارات متعددة بناءً على الشروط.

مثال:

فرز الإشارات بناءً على قيم مختلفة.

التحقق من عدة شروط في وقت واحد.

3. تنظيم الكود

تُستخدم لتنظيم الكود داخل نفس المخطط (Blueprint) عندما تكون العمليات صغيرة نسبيًا.

مثال:

تجميع سلسلة من الأحداث المنطقية داخل Macro لجعل المخطط أكثر نظافة.

4. تصميم منطق بسيط

تُستخدم لتجنب تعقيد المخططات الكبيرة من خلال وضع المنطق البسيط في مكان واحد.

مثال:

حساب الزمن المتبقي لعد تنازلي.

تشغيل مؤثر بصري أو صوتي عند تحقيق شرط معين.

5. استبدال العقد المتكررة

عند وجود مجموعة من العقد تُستخدم عدة مرات في المخطط، يمكن استبدالها بـ Macro لتقليل التكرار.

6. التعامل مع المدخلات بشكل ديناميكي

تُستخدم لمعالجة المدخلات المعقدة بطريقة أكثر ديناميكية وسرعة.

كيفية إنشاء واستخدام Macro

1. إنشاء Macro جديد:

افتح أي Blueprint ترغب في استخدامه.

في نافذة My Blueprint (على اليسار)، اختر قسم Macros.

اضغط على زر + لإنشاء Macro جديد.

قم بتسمية الـ Macro (مثل CheckPlayerState).

2. إضافة المدخلات والمخرجات:

من تفاصيل الـ Macro، يمكنك إضافة:

Execution Inputs/Outputs: لتحديد مسارات التنفيذ.

Data Inputs/Outputs: لمعالجة البيانات.

3. إضافة المنطق داخل الـ Macro:

داخل Macro Graph، قم بإضافة العقد التي تمثل العملية أو المنطق المطلوب.

مثال:

إذا كنت تريد التحقق من حالة اللاعب (هل على الأرض أم لا؟)، أضف العقد اللازمة داخل الـ Macro.

4. استدعاء الـ Macro:

بمجرد الانتهاء من إنشاء الـ Macro، يمكنك استخدامه كعقدة داخل نفس الـ Blueprint.

أمثلة على استخدام Macro

1. التحقق من حالة اللاعب:

المدخلات:

IsPlayerOnGround (Boolean).

المخرجات:

تنفيذ مسارين:

إذا كان اللاعب على الأرض.

إذا لم يكن على الأرض.

الاستخدام:

عند الضغط على زر القفز، يتم التحقق إذا كان اللاعب على الأرض أولًا.

2. التعامل مع المدخلات المتكررة:

إنشاء Macro لتحديد المدخلات الخاصة بشخصية اللاعب.

بدلاً من كتابة نفس العقدة لكل إدخال (Input)، يتم تجميعها في Macro.

3. عد تنازلي (Countdown Timer):

المنطق داخل الـ Macro:

تقليل قيمة زمنية (Float) بشكل دوري.

التحقق إذا وصلت القيمة إلى الصفر.

إرسال إشعار عند انتهاء العد التنازلي.

4. تبديل حالة تشغيل الصوت:

المدخلات:

اسم الصوت.

المنطق:

تشغيل الصوت إذا لم يكن قيد التشغيل.

إيقاف الصوت إذا كان قيد التشغيل.

5. إدارة الفروع (Branch Management):

بدلاً من كتابة عقدة فرع (Branch) متكررة، يمكن وضعها داخل Macro.

نصائح عند استخدام Macro:

استخدمها فقط للعمليات البسيطة:

إذا كانت العملية معقدة أو تحتوي على منطق كبير، استخدم Functions بدلاً من ذلك.

تنظيم الكود داخل الـ Macro:

أضف تعليقات داخل الـ Macro لشرح ما يقوم به.

لا تستخدمها بشكل مفرط:

لأن الـ Macro يمكن أن تصبح غير واضحة عند كثرة الاستخدام، مما يجعل من الصعب تتبع الأخطاء.

استخدام مدخلات ومخرجات واضحة:

حدد أسماء المدخلات والمخرجات بطريقة تعكس وظيفتها.

الخلاصة

Macro تُستخدم لتبسيط المنطق المتكرر وإدارة مسارات التنفيذ المتعددة.

تعتبر أداة فعّالة ولكن يجب استخدامها بعناية لتجنب التعقيد غير الضروري.

اختر بين Macro وFunction بناءً على احتياجاتك:

استخدم Macro للمنطق البسيط داخل نفس المخطط.

استخدم Function للمنطق الأكثر تعقيدًا أو الذي يحتاج لإعادة استخدامه عبر المخططات المختلفة.

متى نستخدم Function ومتى نستخدم Macro؟

استخدام Function:

الوظائف (Functions) تكون الخيار الأفضل في الحالات التالية:

إعادة الاستخدام عبر المشروع:

إذا كنت بحاجة إلى منطق يمكن استخدامه في أماكن مختلفة داخل أو خارج الـ Blueprint الحالي.

مثال: حساب الضرر، تحديث الصحة، أو ضبط الإضاءة.

تحسين الأداء:

الوظائف يتم ترجمتها إلى كود عالي الكفاءة عند تشغيل اللعبة.

مناسبة للعمليات التي تُنفَّذ بشكل متكرر مثل الحسابات.

إرجاع القيم:

إذا كنت تحتاج إلى قيمة أو نتيجة بعد التنفيذ (مثل رقم أو نص أو حالة منطقية).

تنظيم الكود:

الوظائف تسهل قراءة الكود لأنها تتطلب مسار تنفيذ واحد.

يمكن استدعاؤها بسهولة بدون تعقيد في مسارات التنفيذ.

استخدام Macro:

Macros تُفضل في الحالات التالية:

إدارة مسارات تنفيذ متعددة:

إذا كان لديك منطق يتطلب عدة مسارات تنفيذ (Multiple Execution Wires).

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

عمليات متكررة داخل نفس الـ Blueprint:

إذا كنت تحتاج إلى إعادة استخدام الكود لكن لا تحتاج إلى استدعائه عبر Blueprints مختلفة.

منطق بسيط ومحدود:

إذا كان المنطق صغيرًا وسريعًا، مثل التحقق من حالة أو تنفيذ شرط بسيط.

تنظيم المهام المتكررة:

تجمع العمليات المتكررة في مكان واحد داخل نفس الـ Blueprint.

لماذا التحقق من حالة اللاعب أو الباب مهم أثناء تصميم لعبة؟

1. تحقيق التفاعل الديناميكي:

الألعاب تحتاج إلى تفاعل بين اللاعب والعناصر المختلفة في العالم.

مثلًا:

لا يمكن فتح الباب إذا كان مقفولًا.

لا يمكن للاعب الهجوم إذا كان ميتًا.

2. منع الأخطاء البرمجية:

التحقق من الحالة يمنع الأخطاء مثل:

محاولة فتح باب غير موجود.

تنفيذ حركة للاعب غير مرئي أو ميت.

هذا يقلل من الأعطال (Bugs) ويحسن تجربة اللاعب.

3. إدارة الحالات المعقدة:

الألعاب تحتوي على العديد من الحالات التي تتغير باستمرار:

اللاعب يصاب، يتعافى، أو ينفذ الذخيرة.

الأبواب تُفتح وتُغلق بناءً على المفاتيح أو الأحداث.

التحقق يضمن أن المنطق يعمل بشكل صحيح بناءً على الحالة الحالية.

4. تحسين تجربة اللاعب:

يعطي التحقق استجابة طبيعية للاعب:

إظهار رسالة "الباب مقفل" إذا حاول فتحه بدون مفتاح.

منع الهجوم إذا كان اللاعب غير قادر على الحركة.

5. التحكم في تدفق اللعبة:

التحقق من الحالة يسمح لك بإدارة تسلسل الأحداث:

لا يمكن الانتقال إلى المرحلة التالية إلا إذا اكتمل الهدف.

يتم تفعيل فخ عند دخول اللاعب منطقة معينة.

أمثلة عملية على التحقق من الحالات:

1. حالة اللاعب:

الهدف:

التأكد من أن اللاعب يمكنه القفز فقط إذا كان على الأرض.

المنطق:

إذا كانت حالة IsOnGround = True، يسمح بالقفز.

إذا كانت False، يمنع التنفيذ.

2. حالة الباب:

الهدف:

التأكد من أن الباب يُفتح فقط إذا كان اللاعب يمتلك المفتاح.

المنطق:

تحقق إذا كانت حالة HasKey = True:

افتح الباب.

إذا كانت False:

أظهر رسالة "لا يمكنك فتح الباب".

3. حالة الزنزانة:

الهدف:

لا يمكن للاعب دخول الزنزانة إلا إذا هزم جميع الوحوش.

المنطق:

إذا كانت حالة AllMonstersDefeated = True:

افتح البوابة.

إذا كانت False:

لا تفعل شيئًا.

4. حالة المهارات:

الهدف:

التأكد من أن اللاعب لا يمكنه استخدام المهارة إلا إذا كان لديه طاقة كافية.

المنطق:

إذا كانت CurrentEnergy >= SkillCost:

نفذ المهارة.

إذا كانت أقل:

أظهر رسالة "لا يوجد طاقة كافية".

نصائح عامة:

استخدام الوظائف للتحقق المتكرر:

إذا كنت تتحقق من نفس الحالة عدة مرات، اجمع المنطق في وظيفة وأعد استخدامها.

مثال: وظيفة CanPlayerJump تتحقق إذا كان اللاعب على الأرض ولديه طاقة كافية.

استخدام Macros للمنطق البسيط:

إذا كنت تتحقق من شرط بسيط، اجعل المنطق داخل Macro لتقليل التكرار.

التنظيم:

اجعل أسماء الوظائف والـ Macros واضحة ومفهومة لتعكس الغرض منها.

مثال: CheckDoorState، UpdateHealthBar.

استخدام التعليقات:

أضف تعليقات داخل المخطط لشرح سبب التحقق من كل حالة.

اختبار الحالات المختلفة:

تأكد من اختبار كل الحالات الممكنة أثناء التصميم لضمان أن المنطق يعمل بشكل صحيح.

كيفية إنشاء منطق معين أو قوانين للعبة في Blueprint داخل Unreal Engine:

"منطق اللعبة" أو "قوانين اللعبة" تشير إلى القواعد التي تحدد كيفية تفاعل اللاعب والعالم مع بعضهما. يتم تصميم هذه القوانين باستخدام Blueprint عن طريق بناء منطق محدد باستخدام العقد (Nodes).

خطوات إنشاء منطق معين داخل Blueprint:

1. فهم الهدف والقانون المطلوب:

ما الذي تريد تحقيقه؟

مثال:

عند دخول اللاعب منطقة معينة، يبدأ قتال الوحوش.

عند تجميع 100 نقطة، يتم فتح باب المرحلة التالية.

2. تحديد المتغيرات المطلوبة:

المتغيرات هي التي تخزن القيم اللازمة لتطبيق القانون.

مثال:

PlayerScore (متغير عدد صحيح - Integer).

IsDoorOpen (متغير منطقي - Boolean).

CurrentHealth (متغير عشري - Float).

3. إنشاء الـ Blueprint الأساسي:

اختر الـ Blueprint المناسب للقانون:

Blueprint Actor: إذا كنت تضيف منطقًا لعناصر داخل اللعبة (مثل باب، وحش، أو مفتاح).

Blueprint Character: إذا كنت تضيف منطقًا لشخصية اللاعب.

Game Mode Blueprint: إذا كان القانون يؤثر على اللعبة بشكل عام.

4. بناء المنطق باستخدام العقد:

استخدم العقد (Nodes) مثل Branch, Event BeginPlay, Event Tick, وغيرها لتنفيذ القواعد.

5. ربط القوانين ببعضها البعض:

استخدم المتغيرات المشتركة والأحداث لربط القوانين.

يمكن تبادل البيانات بين الـ Blueprints باستخدام العقد مثل Cast To أو Event Dispatchers.

أمثلة عملية لإنشاء قوانين اللعبة:

مثال 1: فتح الباب بناءً على النقاط

القانون المطلوب:

يفتح الباب فقط عندما يصل اللاعب إلى 100 نقطة.

الخطوات:

في Blueprint Actor للباب:

أضف متغيرًا IsDoorOpen (Boolean).

أضف العقدة Event Tick للتحقق من النقاط.

اربط المتغير PlayerScore (من شخصية اللاعب) بالعقدة Branch.

إذا كانت النقاط >= 100، اضبط IsDoorOpen = True وافتح الباب.

Copy code

Event Tick → Get Player Score → Branch (Condition: Score >= 100) 

True: Set IsDoorOpen = True → Play Door Opening Animation

ربط القانون:

استخدم Cast To Character داخل باب الـ Blueprint للحصول على متغير النقاط من اللاعب.

مثال 2: بدء قتال الوحوش عند دخول منطقة

القانون المطلوب:

عند دخول اللاعب منطقة معينة، تبدأ الوحوش في الهجوم.

الخطوات:

في Blueprint Actor للمنطقة:

أضف Collision Box لتحديد المنطقة.

أضف حدث On Component Begin Overlap.

تحقق إذا كان الجسم الذي دخل هو اللاعب باستخدام Cast To Character.

إذا كان اللاعب:

استدعِ حدثًا لبدء هجوم الوحوش.

Copy code

On Component Begin Overlap → Cast To Character 

True: Call Start Monster Attack Event

ربط القانون:

استخدم Event Dispatcher لاستدعاء هجوم الوحوش في Blueprint الوحش.

مثال 3: إظهار نافذة فوز عند تجميع جميع الأهداف

القانون المطلوب:

إذا جمع اللاعب 10 أهداف (Items)، تظهر رسالة الفوز.

الخطوات:

في Game Mode Blueprint:

أضف متغيرًا CollectedItems (Integer).

كلما جمع اللاعب عنصرًا، زد القيمة بـ 1.

تحقق إذا كانت القيمة تساوي 10:

إذا True، أظهر نافذة الفوز باستخدام Create Widget.

Copy code

Event Item Collected → Increment CollectedItems → Branch (Condition: CollectedItems == 10)

True: Create Widget (Victory Screen)

ربط القانون:

استخدم حدثًا مشتركًا لكل العناصر المجمعة واستدعِه عند جمع عنصر.

كيفية ربط القوانين ببعضها البعض

1. استخدام المتغيرات المشتركة:

يمكنك تخزين متغيرات عالمية (Global Variables) في:

Game Mode: للقوانين المتعلقة باللعبة عمومًا (مثل النقاط الإجمالية).

Game Instance: للقوانين التي تتطلب البقاء ثابتة عبر المستويات (مثل حالة اللاعب).

مثال:

تخزين النقاط في Game Mode وربطها بمستوى فتح الأبواب أو ظهور الوحوش.

2. استخدام Event Dispatchers:

مفيد لإرسال إشارات (Events) من Blueprint إلى آخر.

مثال:

عند فتح الباب، قم بتشغيل حدث في الوحوش لبدء الهجوم.

3. استخدام Interfaces:

طريقة لنقل البيانات بين الـ Blueprints المختلفة بدون الحاجة إلى معرفة نوع Blueprint الآخر.

مثال:

عند إصابة اللاعب لوحش، يتم إرسال رسالة (Interface Message) لتقليل صحة الوحش.

4. استخدام Cast To:

يسمح لك بالوصول إلى متغيرات أو وظائف في Blueprint آخر.

مثال:

تحقق من النقاط المخزنة في شخصية اللاعب داخل Blueprint الباب.

نصائح عامة عند تصميم منطق اللعبة:

ابدأ بالأبسط:

ابدأ بإنشاء قوانين بسيطة وتأكد من عملها قبل إضافة التعقيد.

استخدم التعليقات:

أضف تعليقات على كل مجموعة من العقد لشرح دورها.

استخدم المخططات النظيفة:

حافظ على ترتيب العقد بشكل منطقي لتسهيل قراءة الكود.

اختبر كل قانون على حدة:

تحقق من عمل كل جزء من منطق اللعبة بشكل مستقل قبل دمجه مع الآخرين.

التحقق من الحالات الخاصة:

فكر في الحالات التي قد تحدث أثناء اللعب (مثل نفاد الصحة أو إعادة تشغيل المستوى).

الخلاصة:

تصميم منطق اللعبة في Blueprint يتطلب فهم القوانين المطلوبة واستخدام الأدوات المناسبة مثل المتغيرات، الأحداث، وطرق الاتصال بين Blueprints.

ربط القوانين يتم عن طريق مشاركة البيانات باستخدام Cast To أو Event Dispatchers أو Interfaces.

التجربة المستمرة والاختبار هما المفتاح لضمان عمل القوانين بسلاسة.

في Unreal Engine Blueprint، نستخدم "Get Player Character" عندما نريد الوصول إلى الشخصية التي يتحكم بها اللاعب (Player Character) في اللعبة. هذا العقدة (Node) تُرجع المرجع إلى الشخصية الحالية التي يتحكم بها اللاعب، مما يسمح لك بتنفيذ عمليات أو الوصول إلى خصائص محددة لهذه الشخصية.

متى نستعمل "Get Player Character"؟

1. الوصول إلى خصائص أو متغيرات الشخصية:

عند الحاجة إلى تعديل أو قراءة خصائص مثل:

الصحة (Health).

السرعة (Speed).

الطاقة أو أي متغير آخر مرتبط بالشخصية.

مثال:

تقليل صحة اللاعب عند اصطدامه بجسم خطير.

Get Player Character → Cast to (نوع الشخصية) → Access Health Variable → Modify Health.

2. تنفيذ أحداث مرتبطة بالشخصية:

لتشغيل أحداث معينة أو وظائف تخص الشخصية.

مثال:

تشغيل حركة قفز (Jump) للشخصية.

تغيير الأنيميشن عند دخول منطقة معينة.

3. التفاعل بين الكائنات والشخصية:

عندما يتفاعل كائن ما مع اللاعب مثل:

جمع عنصر معين.

فتح باب عند اقتراب الشخصية.

مثال:

عند دخول اللاعب إلى منطقة معينة (Trigger Box)، يُفتح الباب.

On Overlap → Get Player Character → Cast to Character → Trigger Door Open.

4. استدعاء الوظائف الخاصة بالشخصية (Custom Functions):

إذا كانت لديك دوال مُعرّفة في Blueprint الشخصية، يمكنك استدعاؤها عبر Get Player Character.

مثال:

استدعاء وظيفة تزيد سرعة اللاعب عند جمع عنصر تعزيز (Power-up).

5. التحقق من حالة اللاعب أو موقعه:

للوصول إلى موقع اللاعب الحالي في العالم (Get Actor Location).

مثال:

تتبع اللاعب من قِبل الأعداء باستخدام موقعه.

6. تحديد الكاميرا أو التحكم:

الوصول إلى الكاميرا أو إعدادات العرض التي يتحكم بها اللاعب.

مثال:

تبديل منظور الكاميرا (من شخص أول إلى ثالث).

كيفية استخدام "Get Player Character" مع الـ Blueprint؟

أضف عقدة "Get Player Character".

اربطها بـ "Cast To" لتحديد نوع الشخصية (مثل ThirdPersonCharacter).

استخدم العقدة الناتجة للوصول إلى المتغيرات أو الوظائف داخل الـ Blueprint الخاصة بالشخصية.

ملاحظات مهمة:

"Get Player Character" تُستخدم غالبًا مع الألعاب الفردية (Single Player).

في حالة تعدد اللاعبين (Multiplayer)، يجب استخدام الـ Player Index لتحديد اللاعب الصحيح.

بشكل افتراضي، تُرجع العقدة اللاعب صاحب الفهرس 0 (Player 0).

مثال عملي:

السيناريو: عند اصطدام اللاعب بمنطقة معينة، يتم تقليل صحته.

Trigger Box:

Event: On Actor Begin Overlap.

الحصول على الشخصية:

استخدم "Get Player Character".

Cast to ThirdPersonCharacter.

تعديل الصحة:

الوصول إلى متغير الصحة (Health) وتخفيضه.

Blueprint Workflow:

On Begin Overlap → Get Player Character → Cast to ThirdPersonCharacter → Modify Health.

الخلاصة:

نستخدم "Get Player Character" للوصول إلى الشخصية التي يتحكم بها اللاعب من أي Blueprint آخر داخل اللعبة لتنفيذ عمليات 

مثل:

تعديل الخصائص (مثل الصحة أو السرعة).

تشغيل وظائف ودوال خاصة بالشخصية.

التفاعل بين الشخصية والكائنات الأخرى.

تتبع موقع اللاعب أو حالته.

الـ Player Controller هو العنصر المسؤول عن التحكم في إدخال اللاعب (مثل لوحة المفاتيح أو أزرار التحكم) وربطها مع الكائنات التي يتحكم بها اللاعب، مثل الشخصية أو الكاميرا.

متى نستخدم "Get Player Controller"؟

1. التعامل مع إدخال اللاعب (Input):

استخدام الـ Player Controller للتحقق من الأزرار أو المدخلات التي يضغطها اللاعب.

مثال:

إيقاف تحكم اللاعب مؤقتًا (Disable Input).

إعادة تفعيل التحكم بعد انتهاء حدث معين (Enable Input).

2. التحكم بالكاميرا:

الوصول إلى الكاميرا وتحريكها أو تغيير إعداداتها.

مثال:

تدوير الكاميرا نحو هدف معين باستخدام وظيفة Set Control Rotation.

تغيير منظور الكاميرا من شخص أول إلى شخص ثالث.

3. إظهار أو إخفاء واجهة المستخدم (UI):

يمكن استخدام Player Controller لإظهار واجهة المستخدم (HUD) أو الإضافات الأخرى.

مثال:

عند الضغط على زر "Esc"، تُظهر قائمة الإيقاف المؤقت (Pause Menu).

4. التحكم في مؤشر الماوس (Mouse Cursor):

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

مثال:

عند فتح قائمة أو واجهة معينة، نقوم بتفعيل الماوس.

Get Player Controller → Set Show Mouse Cursor → True.

5. تنفيذ وظائف مرتبطة باللاعب مباشرةً:

الوصول إلى وظائف عامة أو إعدادات مرتبطة بالتحكم.

مثال:

تفعيل أو تعطيل إدخال اللاعب مؤقتًا عند حدوث سيناريو معين.

Get Player Controller → Disable Input.

6. التفاعل مع أكثر من لاعب في الألعاب متعددة اللاعبين:

في حالة وجود عدة لاعبين (Multiplayer)، يمكن استخدام Player Index لتحديد اللاعب المراد الوصول إلى الـ Controller الخاص به.

مثال:

Get Player Controller مع Index = 0 تعني اللاعب الأول.

كيفية استخدام "Get Player Controller" مع الـ Blueprint؟

أضف عقدة "Get Player Controller".

حدد الـ Player Index (يكون 0 افتراضيًا للألعاب الفردية).

اربط العقدة بالوظائف أو العمليات التي تريد تنفيذها مثل التحكم بالكاميرا أو المدخلات.

أمثلة عملية لاستخدام "Get Player Controller":

1. إيقاف تحكم اللاعب مؤقتًا:

عند دخول اللاعب مشهد سينمائي أو قائمة إيقاف مؤقت (Pause).

Blueprint Workflow:

Get Player Controller → Disable Input → (Player Character).

2. تفعيل مؤشر الماوس عند عرض واجهة المستخدم:

لتمكين تفاعل اللاعب مع القوائم باستخدام الماوس.

Blueprint Workflow:

Get Player Controller → Set Show Mouse Cursor → True.

3. تدوير الكاميرا نحو هدف معين:

لتوجيه كاميرا اللاعب إلى هدف معين (مثل عدو أو حدث مهم).

Blueprint Workflow:

Get Player Controller → Set Control Rotation → (Rotation Value).

4. فتح قائمة الإيقاف المؤقت (Pause Menu):

عند الضغط على زر معين (مثل Escape).

Blueprint Workflow:

Input Key (Escape) → Get Player Controller → Set Game Paused → True.

الفرق بين "Get Player Controller" و "Get Player Character":

نستخدم "Get Player Controller" للتحكم في إدخال اللاعب، الكاميرا، الماوس، وواجهة المستخدم (UI).

مناسب عند الحاجة إلى تنفيذ وظائف تتعلق بالتحكم أو التفاعل مع اللاعب نفسه، وليس بالشخصية التي يتحكم بها.

في Unreal Engine Blueprint، تُستخدم أوامر مثل Int + Int لإجراء العمليات الحسابية بين القيم العددية الصحيحة (Integer) داخل اللعبة. يتم استخدام هذه العمليات عند الحاجة إلى التعامل مع الأرقام، سواء كانت متغيرات، أو حسابات مؤقتة، أو لتغيير قيم بناءً على أحداث معينة.

متى نستخدم "Int + Int" وأوامر مشابهة؟

1. عند تعديل القيم المتعلقة باللعبة:

إضافة نقاط (Score):

عند جمع اللاعب عناصر أو قتل أعداء، يمكننا زيادة النقاط.

Current Score + Points Earned → Set Current Score.

زيادة عدد المحاولات (Lives):

عند حصول اللاعب على "حياة إضافية".

Current Lives + 1 → Set Current Lives.

2. إنشاء عدّاد (Counter):

لتتبع عدد المحاولات، الخطوات، أو الكائنات التي تم جمعها.

مثال: عدّاد العناصر المجمعة:

Collected Items + 1 → Set Collected Items.

3. حساب مؤقت أو مدة زمنية:

عند تشغيل عدّاد زمني بسيط يزيد بمقدار ثابت (مثل عدد الثواني).

Elapsed Time + Delta Time → Set Elapsed Time.

4. العمل مع الحلقات (Loops):

عند استخدام For Loop أو While Loop، يمكن أن نستخدم العمليات الحسابية لتتبع الحالة أو تحديث متغير معين.

مثال: عد العناصر التي تحقق شرطًا معينًا.

5. عند إنشاء معادلات بسيطة:

لتحديد قيم بناءً على مدخلات أو معطيات معينة.

مثال: حساب عدد النقاط التي يحصل عليها اللاعب بناءً على عدد الأعداء المهزومين.

Enemies Defeated * Points Per Enemy → Total Score.

6. تعديل خصائص مرتبطة بشخصيات أو عناصر:

مثال: تقليل صحة اللاعب عند تعرضه للضرر.

Current Health - Damage Taken → Set Current Health.

زيادة كمية الموارد:

Collected Resources + Resource Amount → Set Collected Resources.

7. مقارنة القيم:

يتم دمج العمليات الحسابية مع Comparison Nodes مثل Greater Than (>) أو Equal (==) لاتخاذ قرارات بناءً على النتائج.

مثال: التحقق إذا كانت النقاط المكتسبة تساوي الحد المطلوب لفتح مستوى جديد.

Current Score + Bonus → Check if > Target Score.

كيفية استخدام "Int + Int" في Blueprint:

إضافة عقدة "Int + Int":

اسحب خطًا من أي متغير عدد صحيح (Integer) وابحث عن Int + Int.

وصل القيم:

قم بتوصيل المدخلات بالقيم أو المتغيرات التي تريد جمعها.

تحديد النتيجة:

قم بتوصيل النتيجة بعملية أو متغير جديد لتخزين القيمة الناتجة.

أمثلة عملية:

1. عداد عناصر (Item Counter):

عند جمع عنصر:

Collected Items + 1 → Set Collected Items.

2. زيادة النقاط عند إنهاء مستوى:

عند إنهاء اللاعب مستوى، يتم إضافة النقاط:

Current Score + Level Bonus → Set Current Score.

3. إنشاء مؤقت:

عند استخدام حدث مثل Tick لتحديث الوقت:

Current Time + Delta Time → Set Current Time.

4. توزيع الموارد:

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

Total Resources / Number of Players → Resources Per Player.

أوامر حسابية أخرى شائعة:

نستخدم Int + Int وأوامر الحساب الأخرى عندما نحتاج إلى إجراء عمليات حسابية على القيم العددية داخل اللعبة.

تُستخدم هذه العمليات بشكل شائع لتحديث النقاط، الموارد، العدّادات، وإجراء المقارنات.

دمج العمليات الحسابية مع المتغيرات الأخرى ووظائف اللعبة يتيح تصميم منطق ديناميكي وتفاعلي.

الموضوع قابل للتجديد

وسيتم اضافة معلومات اخرى مستقبلا

فلا تنسى الاطلاع على الموضوع من حين للاخر 

واشترك في قناتنا غلى اليوتيب

@yokagi.1

تحت اسم yokagi

والفايسبوك في

www.facebook.com/yokagi