כיצד להוסיף אובייקטים נעים אקראיים באמצעות ספריית הארקייד של Python

חפצים זזים אקראיים יכולים להביא ריגוש וחוסר חיזוי למשחקים. זה הופך אותם ליותר מרתקים ומאתגרים עבור שחקנים. ספריית Arcade של Python מספקת דרך פשוטה ויעילה לשלב אובייקטים נעים אקראיים במשחקים שלך.

צור משחק פשוט

לפני שמתחילים, ודא שיש לך pip מותקן במכשיר שלך. השתמש בפקודה זו כדי להתקין את מִקמֶרֶת סִפְרִיָה:

ארקייד להתקין pip

לאחר מכן, צור חלון באמצעות ה מִקמֶרֶת. חַלוֹן מחלקה והגדר את צבע הרקע ללבן.

הקוד המשמש במאמר זה זמין כאן מאגר GitHub והוא בחינם עבורך לשימוש תחת רישיון MIT.

הגדר את מיקום הנגן לאמצע המסך בצורה אופקית והוסף מרחק קטן מהחלק העליון. אתה יכול לשלוט בתנועת השחקן באמצעות מקשי החצים.

הנה הקוד למשחק הבסיסי שלנו:

יְבוּא מִקמֶרֶת
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
מעמדהמשחק שלי(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי, רוחב, גובה):
 super().__init__(רוחב, גובה)
 arcade.set_background_color (arcade.color. לבן)
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10
defon_draw(עצמי):





instagram viewer

 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. כְּחוֹל)

defעדכון(עצמי, זמן_דלתא):
לַעֲבוֹר
defon_key_press(עצמי, מפתח, משנה):
אם key == arcade.key. שמאלה:
 self.player_x -= 5
אליף key == arcade.key. ימין:
 self.player_x += 5
אם __שם__ == "__רָאשִׁי__":
 משחק = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

הוספת אובייקטים מרובים

כדי להוסיף אובייקטים נעים אקראיים למשחק שלך, צור רשימה לאחסון מיקומי האובייקט ועדכן אותם בכל פריים. אתה יכול גם להשתמש ספרייטים כאובייקטים.

בקוד המשחק שלך, הוסף רשימה בשם חפצים כדי לאחסן את המיקומים של העצמים הנעים באקראי. לאחר מכן, צור את מספר האובייקטים (NUM_OBJECTS) עם קואורדינטות x ו- y אקראיות בתוך גבולות המסך. האובייקטים מצוירים כעיגולים אדומים באמצעות ה- arcade.draw_circle_filled פוּנקצִיָה.

יְבוּא מִקמֶרֶת
יְבוּא אַקרַאִי
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10
מעמדהמשחק שלי(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי, רוחב, גובה):
 super().__init__(רוחב, גובה)
 arcade.set_background_color (arcade.color. לבן)
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10
 self.objects = []
ל _ ב טווח (NUM_OBJECTS):
 x = random.randint(0, SCREEN_WIDTH)
 y = random.randint(0, SCREEN_HEIGHT)
 self.objects.append((x, y))
defon_draw(עצמי):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. כְּחוֹל)
ל obj ב self.objects:
 x, y = obj
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. אָדוֹם)
defעדכון(עצמי, זמן_דלתא):
לַעֲבוֹר
defon_key_press(עצמי, מפתח, משנה):
אם key == arcade.key. שמאלה:
 self.player_x -= 5
אליף key == arcade.key. ימין:
 self.player_x += 5
אם __שם__ == "__רָאשִׁי__":
 משחק = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

להלן הפלט:

יישום אלגוריתם תנועה אקראית

כדי לגרום לאובייקטים לנוע באופן אקראי, עדכן את מיקומם ב- עדכון שיטה באמצעות אלגוריתם תנועה אקראית.

חזור על כל אובייקט וצור ערכים אקראיים עבור dx ו dy, המייצג את השינוי בקואורדינטות x ו-y. לאחר מכן עדכן את מיקום האובייקט על ידי הוספת ערכים אלה. הנה הקוד שהשתנה:

defעדכון(עצמי, זמן_דלתא):
ל אני ב טווח (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = random.randint(-5, 5)
 dy = random.randint(-5, 5)
 x += dx
 y += dy
 self.objects[i] = (x, y)

להלן הפלט:

חפצים נעים לעבר שחקן

כדי להוסיף עוד אינטראקציה, גרמו לאובייקטים לנוע לעבר הנגן. ניתן להשיג זאת על ידי חישוב וקטור הכיוון בין האובייקט לנגן והתאמת מיקום האובייקט בהתאם.

לשם כך, חשב את ההבדלים בקואורדינטות x ו-y בין האובייקט והשחקן. על ידי נרמול ערכים אלה, אתה מקבל וקטור כיוון. לאחר מכן הכפילו את הווקטור הזה במקדם מהירות (3 במקרה זה) והוסיפו אותו למיקום האובייקט. הנה המעודכן עדכון שיטה:

defעדכון(עצמי, זמן_דלתא):
ל אני ב טווח (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 מרחק = math.sqrt (dx ** 2 + dy ** 2)
 dx /= מרחק
 dy /= מרחק
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

להלן הפלט:

אובייקטים מתחילים לזוז כשהשחקן נכנס לסביבה

כדי להוסיף דינמיקה נוספת, שנה את הקוד כך שהאובייקטים יתחילו לזוז רק כשהשחקן נכנס לאזור הסובב שלו. תוסיף את ה קוד לתנועת השחקן ולהגדיר רדיוס שבתוכו האובייקטים הופכים פעילים.

defעדכון(עצמי, זמן_דלתא):
ל אני ב טווח (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 מרחק = math.sqrt (dx ** 2 + dy ** 2)

אם מרחק < 100: # התאם את הרדיוס לפי הצורך
 dx /= מרחק
 dy /= מרחק
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

זיהוי התנגשות ואינטראקציה

כעת, הוסף זיהוי התנגשות בין הנגן לאובייקטים, והגדר התנהגות כאשר מתרחשת התנגשות. שנה את עדכון שיטה לטיפול בהתנגשויות:

defעדכון(עצמי, זמן_דלתא):
ל אני ב טווח (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 מרחק = math.sqrt (dx ** 2 + dy ** 2)

אם מרחק < PLAYER_RADIUS + OBJECT_RADIUS:
# אם התרחשה התנגשות, טפל בה כאן
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))

אליף מרחק < 100:
 dx /= מרחק
 dy /= מרחק
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

איזון אקראיות

כדי ליצור חווית משחק מאוזנת, חשוב לכוונן עדין את התנועה האקראית והשרצת אובייקטים. הנה כמה דוגמאות לאופן שבו אתה יכול להתאים את הקוד כדי להשיג איזון טוב יותר במשחק שלך:

הגבלת מהירות מרבית

כדי למנוע מעצמים לנוע מהר מדי, אתה יכול להציג הגבלת מהירות מרבית. שנה את עדכון שיטה לכלול אילוצי מהירות:

defעדכון(עצמי, זמן_דלתא):
ל אני ב טווח (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 מרחק = math.sqrt (dx ** 2 + dy ** 2)
אם מרחק < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
אליף מרחק < 100:
 dx /= מרחק
 dy /= מרחק
 מהירות = 3# התאם את ערך המהירות לפי הצורך
 dx = min (מקסימום (dx * מהירות, -MAX_SPEED), MAX_SPEED)
 dy = min (מקסימום (dy * מהירות, -MAX_SPEED), MAX_SPEED)
 x += dx
 y += dy
 self.objects[i] = (x, y)

שליטה בקצב השרצים

אתה יכול גם לשלוט בקצב שבו אובייקטים חדשים מושרים במשחק. התאם את הקוד כך שיכלול עיכוב בין יצירת אובייקטים חדשים:

יְבוּא זְמַן
מעמדהמשחק שלי(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי, רוחב, גובה):
 super().__init__(רוחב, גובה)
 arcade.set_background_color (arcade.color. לבן)
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10
 self.objects = []
 self.last_spawn_time = time.time()
defעדכון(עצמי, זמן_דלתא):
# לשלוט בקצב ההשרצה כאן
אם time.time() - self.last_spawn_time > SPAWN_DELAY:
אם len (self.objects) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
 self.last_spawn_time = time.time()
ל אני ב טווח (len (self.objects)):
 x, y = self.objects[i]
 dx = self.player_x - x
 dy = self.player_y - y
 מרחק = math.sqrt (dx ** 2 + dy ** 2)
אם מרחק < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
אליף מרחק < 100:
 dx /= מרחק
 dy /= מרחק
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

התאם את SPAWN_DELAY ו MAX_OBJECTS ערכים כדי למצוא את האיזון הנכון למשחק שלך. עיכוב ארוך יותר או מספר מקסימלי קטן יותר של חפצים יהפכו את המשחק לפחות צפוף. ואילו איחור קצר יותר או מקסימום גדול יותר יגדילו את הקושי.

הפוך את המשחקים למהנים יותר באמצעות חפצים נעים

הוספת חפצים זזים אקראיים למשחקים יכולה לשפר משמעותית את החוויה הכוללת. הם מציגים אי-חיזוי ואתגר, מה שהופך את המשחק למושך יותר ודינאמי. שחקנים יצטרכו להסתגל ולהגיב במהירות כדי להימנע מהתנגשויות או לתפוס חפצים, וזה יספק תחושה של התרגשות והישג.