لوحة

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

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

هذا مثال على كيفية تحقيق ذلك باستخدام Dictionary:

csharpCopy code
StreamReader SR = new StreamReader(FILE_PATH);
Dictionary<string, double> wordPoints = new Dictionary<string, double>();

while ((line = SR.ReadLine()) != null)
{
    short unique = (short)line.Distinct().ToArray().Length;
    short total = (short)line.Length;
    double value = (15 * Math.PI * Math.Pow(unique, 2)) / total;

    wordPoints.Add(line, value);
}

var bestWords = wordPoints.OrderByDescending(pair => pair.Value).Take(10); // اختر أفضل 10 كلمات

Console.WriteLine("Leaderboard:");
foreach (var pair in bestWords)
{
    Console.WriteLine("Word: " + pair.Key + ", Points: " + pair.Value);
}

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

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

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

باستخدام هذا التصميم، يمكنك بسهولة استدعاء وعرض الكلمات والنقاط ذات الصلة في لوحة القيادة. في المثال السابق، تم استخدام LINQ لترتيب الكلمات واختيار أعلى 10 كلمات لعرضها. يمكنك تعديل هذا الرقم وفقا لاحتياجاتك.

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

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

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

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

لنفترض أننا لدينا ملكة واحدة في الموضع (row، col)، سنركز على فحص وجود ملكة أخرى على القطر الرئيسي الأيمن والأيسر.

القطر الأيمن:

• يتحرك الفحص من (row، col) بزيادة الصف والعمود بمقدار واحد في كل خطوة حتى نصل إلى حافة اللوحة.
• خلال كل تحرك، نقوم بفحص ما إذا كان هناك ملكة في الخانة الحالية.
• إذا كان هناك ملكة، فإن الوضع غير صالح.

القطر الأيسر:

• يتحرك الفحص من (row، col) بزيادة الصف ونقصان العمود بمقدار واحد في كل خطوة حتى نصل إلى حافة اللوحة.
• خلال كل تحرك، نقوم بفحص ما إذا كان هناك ملكة في الخانة الحالية.
• إذا كان هناك ملكة، فإن الوضع غير صالح.

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

pythonCopy code
def diagonal_check(board, row, col):
    # Check right diagonal
    for i in range(1, len(board)):
        if row + i < len(board) and col + i < len(board):
            if board[row + i][col + i] == 1:
                return False
        else:
            break
    
    for i in range(1, len(board)):
        if row - i >= 0 and col - i >= 0:
            if board[row - i][col - i] == 1:
                return False
        else:
            break
    
    # Check left diagonal
    for i in range(1, len(board)):
        if row + i < len(board) and col - i >= 0:
            if board[row + i][col - i] == 1:
                return False
        else:
            break
    
    for i in range(1, len(board)):
        if row - i >= 0 and col + i < len(board):
            if board[row - i][col + i] == 1:
                return False
        else:
            break
    
    return True

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

بالطبع! سنواصل الآن مع توضيح بعض النقاط الهامة حول هذا الحل وكيفية تطبيقه في مشكلة N-Queens.

قبل الدخول في تفاصيل الخوارزمية، دعنا نلقي نظرة سريعة على مشكلة N-Queens. في هذه المشكلة، يتعين وضع N ملكات على لوحة الشطرنج بحيث لا تهاجم بعضها البعض. يعني ذلك أنه لا يجب أن تكون هناك ملكتان في نفس الصف أو العمود أو القطر. تُعد هذه مشكلة تحديًا شهيرة في علم الحوسبة.

الآن، سندمج خوارزمية فحص القطرين الرئيسيين التي كتبناها في وظيفة diagonal_check في حل لمشكلة N-Queens. لتحقيق ذلك، سنقوم بتحديد مواقع الملكات على اللوحة بشكل تتابعي ونستخدم وظيفة diagonal_check للتحقق مما إذا كان هناك تعارض في المواقع.

إليك كيف يمكننا تنفيذ ذلك:

pythonCopy code
def solve_n_queens(n):
    def backtrack(row):
        nonlocal result
        if row == n:
            result += 1
            return
        for col in range(n):
            if can_place(row, col):
                board[row][col] = 1
                backtrack(row + 1)
                board[row][col] = 0
    
    def can_place(row, col):
        return row_check[row] == 0 and col_check[col] == 0 and diagonal_check(board, row, col)
    
    # Initialize the board and auxiliary arrays
    board = [[0] * n for _ in range(n)]
    row_check = [0] * n
    col_check = [0] * n
    result = 0
    
    # Start backtracking
    backtrack(0)
    
    return result

# Example usage:
n = 8
print(f"Number of solutions for {n}-Queens problem: {solve_n_queens(n)}")

في هذا الحل، نقوم بتكوين وظيفة solve_n_queens التي تأخذ حجم اللوحة N كمدخل وتُعيد عدد الحلول الممكنة لمشكلة N-Queens. تستخدم هذه الوظيفة تقنية الإرجاع المتكرر (Backtracking) للتحقق من جميع التوزيعات الممكنة.

تحتوي الوظيفة على دالة مساعدة backtrack التي تقوم بالتجريب عبر كل صف في اللوحة وتحاول وضع ملكة في كل خانة من الصف الحالي. إذا كان من الممكن وضع ملكة في الموقع الحالي دون تعارض، فإنها تقوم بوضع الملكة وتقوم بالتوجه إلى الصف التالي. إذا تم وضع جميع الملكات بنجاح، يتم زيادة العداد result بواحد.

تحتوي الوظيفة أيضًا على دالة مساعدة can_place التي تقوم بالتحقق مما إذا كان بإمكاننا وضع ملكة في موضع محدد دون تعارض في الصف والعمود والقطر.

باستخدام هذا الحل، يمكننا بسهولة حساب عدد الحلول الممكنة لمشكلة N-Queens بشكل فعال وبدون تعارضات.

في تطبيقات Windows Forms، عند العمل مع لوحة (Panel) تحتوي على عناصر تحكم مثل علامات (Label controls)، قد تحتاج أحيانًا إلى معرفة موضع العناصر داخل اللوحة أثناء التمرير الرأسي (vertical scrolling). هذا يمكن أن يكون مفيدًا لتنفيذ سلوك مخصص أثناء التمرير، مثل تحميل المزيد من البيانات أو تحديث العرض.

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

1. مراقبة حدث التمرير الرأسي (Vertical Scroll Event): يمكنك الاشتراك في حدث التمرير الرأسي للوحة (Panel) باستخدام الحدث المناسب، مثل Scroll، لتنفيذ السلوك الذي ترغب في تنفيذه عند التمرير.

2. تحديد موضع العناصر الظاهرة: خلال معالجة حدث التمرير الرأسي، يمكنك استخدام الخصائص المتاحة في عناصر التحكم داخل اللوحة لتحديد موضع العناصر الظاهرة. على سبيل المثال، يمكنك استخدام خاصية Top للعنصر العلوي لمعرفة موضعه النسبي داخل اللوحة.

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

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

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

csharpCopy code
private void panel1_Scroll(object sender, ScrollEventArgs e)
{
    foreach (Control control in panel1.Controls)
    {
        if (control is Label)
        {
            Label label = (Label)control;
            // حساب الموضع النسبي للعنصر داخل اللوحة
            int relativePosition = label.Top - panel1.VerticalScroll.Value;
            
            // التحقق مما إذا كان العنصر مرئيًا بالكامل
            bool fullyVisible = relativePosition >= 0 && relativePosition + label.Height <= panel1.Height;

            if (fullyVisible)
            {
                // هنا يمكنك تنفيذ السلوك المطلوب عندما يكون العنصر مرئيًا بالكامل
                // على سبيل المثال:
                // تحديث عرض الواجهة أو تحميل المزيد من البيانات
                // أو أي عملية أخرى تحتاجها التطبيق
                break; // انقطاع الحلقة بمجرد العثور على العنصر المرئي بالكامل
            }
        }
    }
}

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

بالتأكيد، سنقوم بتوسيع المقال ليشمل مزيدًا من التفاصيل والتوضيحات.

استكشاف موضع العناصر أثناء التمرير الرأسي في ويندوز فورمز (WinForms)

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

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

أول خطوة للتعامل مع هذا السيناريو هي مراقبة حدث التمرير الرأسي للوحة. يمكن ذلك عن طريق استخدام الحدث المناسب للتمرير الرأسي، مثل حدث Scroll. يتيح لنا هذا الحدث فرصة التفاعل عند حدوث التمرير الرأسي للوحة.

تحديد موضع العناصر الظاهرة

أثناء معالجة حدث التمرير الرأسي، يمكننا استخدام الخصائص المتاحة في عناصر التحكم داخل اللوحة لتحديد موضع العناصر الظاهرة. على سبيل المثال، يمكن استخدام خاصية Top للعنصر العلوي لمعرفة موضعه النسبي داخل اللوحة.

التحقق من الظهور

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

تحديث العرض حسب الحاجة

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

ختامًا

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

اختبار الحل

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

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

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

أولًا، يوجد خطأ في تعريف المصفوفة board في الكلاس Board. يجب عليك استخدام board بدلاً من board = [[]] حيث أن الأخير ينشئ قائمة فارغة داخل قائمة واحدة فقط.

pythonCopy code
class Board():    
    board = []

    def __init__(self, width, height):
        self.width = width
        self.height = height

    def __repr__(self):
        return str(self.board)

    def setup(self):
        for y in range(self.height):
            row = []  # إنشاء قائمة فارغة لكل صف
            for x in range(self.width):
                row.append(0)
            self.board.append(row)

board = Board(8, 8)
board.setup()
print(board.board)

تم إجراء بعض التعديلات في الشيفرة، حيث تم استبدال print(self.board) بـ return str(self.board) في دالة __repr__ للتأكد من أن الدالة تعيد قيمة نصية بدلاً من طباعة القيمة مباشرة. كما تم إضافة خط لإنشاء قائمة جديدة (row) لكل صف في دالة setup، ثم تمت إضافة هذا الصف إلى المصفوفة الكبيرة board.

بعد تصحيح هذه الأخطاء، يجب أن يكون لديك لوحة لعبة الداما بحجم 8×8 تحتوي على القيم المبدئية 0. يمكنك الآن استكمال تطوير برنامجك لتنفيذ قواعد الداما وواجهة المستخدم الخاصة باللعبة.

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

في تصميم الألعاب، تعتبر استخدام الصفائف (Arrays) أمرًا ذا أهمية خاصة. في حالة لوحة لعبة الداما، يمكن تمثيل المربعات على اللوحة باستخدام قيم رقمية. على سبيل المثال، يمكن تعيين القيمة 0 للمربعات الفارغة، 1 للقطع السوداء، و2 للقطع البيضاء.

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

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

pythonCopy code
class Board():
    EMPTY = 0
    BLACK = 1
    WHITE = 2

    def __init__(self, width, height):
        self.width = width
        self.height = height
        self.board = [[self.EMPTY for _ in range(width)] for _ in range(height)]

    def __repr__(self):
        return str(self.board)

    def setup(self):
        # تحديد القيم الابتدائية لبعض المربعات
        self.board[1][0] = self.board[0][1] = self.board[1][2] = self.BLACK
        self.board[6][5] = self.board[7][6] = self.board[6][7] = self.WHITE

    def make_move(self, start_x, start_y, end_x, end_y):
        # تحديث المربعات بناءً على الحركة
        self.board[end_y][end_x] = self.board[start_y][start_x]
        self.board[start_y][start_x] = self.EMPTY

board = Board(8, 8)
board.setup()
print(board.board)

# قم بإجراء حركة لاختبار الدالة make_move
board.make_move(1, 0, 2, 1)
print(board.board)

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

إن تطوير لعبة “Four-in-a-Row” باستخدام لغة البرمجة بايثون يمثل تحديًا ممتعًا وفرصة لتحسين مهارات البرمجة الخاصة بك. سأقوم بتوفير معلومات شاملة حول كيفية بدء تنفيذ هذه اللعبة، مع التركيز على الجوانب الرئيسية والمهمة في عملية البرمجة.

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

pythonCopy code
board = [
    [' ', ' ', ' ', ' ', ' ', ' ', ' '],
    [' ', ' ', ' ', ' ', ' ', ' ', ' '],
    [' ', ' ', ' ', ' ', ' ', ' ', ' '],
    [' ', ' ', ' ', ' ', ' ', ' ', ' '],
    [' ', ' ', ' ', ' ', ' ', ' ', ' '],
    [' ', ' ', ' ', ' ', ' ', ' ', ' '],
]

حيث ‘ ‘ تعبر عن الخانات الفارغة على اللوحة.

ثم يمكنك تعريف دالة لطباعة اللوحة لترى التطورات أثناء اللعب. يمكن استخدام حلقتين متداخلتين للتحقق من وجود أربع نقاط متتالية في صف معين.

pythonCopy code
def print_board(board):
    for row in board:
        print('|'.join(row))
        print('-' * 15)

# مثال لاستخدام الدالة
print_board(board)

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

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

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

على الرغم من أن هذا مجرد نظرة سريعة، إلا أن بناء لعبة Four-in-a-Row باستخدام بايثون سيكون تحدًا رائعًا لتعلم البرمجة وتحسين مهاراتك. استمتع بالبرمجة وابدأ في تطوير اللعبة!

بالطبع، سأقوم بتوفير مزيد من المعلومات حول تطوير لعبة Four-in-a-Row باستخدام لغة البرمجة بايثون.

فيما يلي مزيد من الخطوات والمعلومات التي يمكن أن تكون مفيدة:

1. تحديث اللوحة بناءً على اختيار اللاعب:

pythonCopy code
def drop_piece(board, col, player_piece):
    for row in range(5, -1, -1):
        if board[row][col] == ' ':
            board[row][col] = player_piece
            break

هذه الدالة تساعد في وضع قطعة اللاعب في العمود المحدد.

2. فحص الفوز:

pythonCopy code
def check_win(board, piece):
    # فحص الأعمدة
    for col in range(7):
        for row in range(3):
            if board[row][col] == piece and board[row + 1][col] == piece and board[row + 2][col] == piece and board[row + 3][col] == piece:
                return True

    # فحص الصفوف
    for row in range(6):
        for col in range(4):
            if board[row][col] == piece and board[row][col + 1] == piece and board[row][col + 2] == piece and board[row][col + 3] == piece:
                return True

    # فحص القطر
    for row in range(3):
        for col in range(4):
            if board[row][col] == piece and board[row + 1][col + 1] == piece and board[row + 2][col + 2] == piece and board[row + 3][col + 3] == piece:
                return True

            if board[row + 3][col] == piece and board[row + 2][col + 1] == piece and board[row + 1][col + 2] == piece and board[row][col + 3] == piece:
                return True

    return False

3. التفاعل مع المستخدم:

pythonCopy code
def get_player_input():
    try:
        col = int(input("اختر رقم العمود (0-6): "))
        if 0 <= col <= 6:
            return col
        else:
            print("الرجاء اختيار رقم صحيح بين 0 و 6.")
            return get_player_input()
    except ValueError:
        print("الرجاء ادخال رقم صحيح.")
        return get_player_input()

4. دمج كل الأجزاء:

pythonCopy code
def play_game():
    board = initialize_board()
    current_player = 'X'

    while True:
        print_board(board)
        col = get_player_input()
        drop_piece(board, col, current_player)

        if check_win(board, current_player):
            print_board(board)
            print(f"اللاعب {current_player} فاز!")
            break

        if is_board_full(board):
            print_board(board)
            print("تعادل!")
            break

        current_player = 'O' if current_player == 'X' else 'X'

if __name__ == "__main__":
    play_game()

5. تحسين اللعبة:

• إضافة تحسينات مثل تحسين واجهة المستخدم باستخدام مكتبة مثل Pygame.
• تحسين قواعد الفوز والتعادل.
• تجربة إضافة مستويات صعوبة للذكاء الاصطناعي إذا كنت ترغب في تحسين مهاراتك في هذا المجال.

تذكر أن هذه مجرد اقتراحات ويمكنك تعديل وتحسين اللعبة حسب تفضيلاتك. استمتع ببرمجتك واستمر في تعلم المزيد!