הנפשת אובייקטי משחק עם ספריית ארקייד

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

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

צור משחק פשוט

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

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

לאחר מכן, צור קובץ Python בשם simple-game.py והתחל בהגדרת משחק שבו השחקן יכול לנוע ימינה ושמאלה.

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

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

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





instagram viewer

defon_draw(עצמי):
 arcade.start_render()
 col = arcade.color. כְּחוֹל
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, קול)
defon_key_press(עצמי, מפתח, משנה):
אם key == arcade.key. שמאלה:
 self.player_x -= 10
אליף key == arcade.key. ימין:
 self.player_x += 10
defרָאשִׁי():
 משחק = MyGame()
 arcade.run()
אם __שם__ == "__רָאשִׁי__":
 רָאשִׁי()

הוסף אנימציית תנועה בסיסית

כעת, קח את המשחק שלך צעד קדימה והוסף אנימציית תנועה בסיסית לאובייקט הנגן. כדי להנפיש את שחקן בתנועה, צור 3 מעגלים שונים וחזור ביניהם ברצף כשהשחקן מתחיל לזוז. להלן קטע הקוד המעודכן עבור move-animation.py קוֹבֶץ:

מעמדהמשחק שלי(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "המשחק שלי")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
defon_draw(עצמי):
 arcade.start_render()
 col1 = arcade.color. כְּחוֹל
 col2 = arcade.color. ירוק
 col3 = arcade.color. אָדוֹם
אם self.frame_counter < 10:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,col1)
אליף self.frame_counter < 20:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20,col2)
אַחֵר:
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, col3)
defon_key_press(עצמי, מפתח, משנה):
אם key == arcade.key. שמאלה:
 self.player_x -= 10
 self.frame_counter = (self.frame_counter + 1) % 30
אליף key == arcade.key. ימין:
 self.player_x += 10
 self.frame_counter = (self.frame_counter + 1) % 30

להלן מסגרת פלט לדוגמה:

שליטה במהירות ובכיוון האנימציה

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

הנה קטע הקוד שהשתנה עבור frame-rate.py קוֹבֶץ:

מעמדהמשחק שלי(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "המשחק שלי")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.frame_counter = 0
 col1 = arcade.color. כְּחוֹל
 col2 = arcade.color. ירוק
 col3 = arcade.color. אָדוֹם
 self.frames = [col1, col2, col3]
 self.frame_rate = 10
defon_draw(עצמי):
 arcade.start_render()
 frame_index = self.frame_counter // self.frame_rate % len (self.frames)
אם self.player_x < SCREEN_WIDTH // 2:
 frame_index = len (self.frames) - 1 - frame_index
 index = self.frames[frame_index]
 arcade.draw_circle_filled (self.player_x, self.player_y, 20, אינדקס)
defon_key_press(עצמי, מפתח, משנה):
אם key == arcade.key. שמאלה:
 self.player_x -= 10
 self.frame_counter += 1
אליף key == arcade.key. ימין:
 self.player_x += 10
 self.frame_counter += 1

השתמש באופרטור המודולוס % עם len (self.frames) כדי להבטיח כי frame_index תמיד נשאר בטווח הפריימים הזמינים. זה מונע את שגיאת אינדקס מתרחש כאשר האנימציה עוברת דרך הפריימים.

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

כולל תכונות נוספות

ספריית Arcade מספקת תכונות שונות לשיפור האנימציות שלך.

השפעות חלקיקים

אתה יכול ליצור אפקטים של חלקיקים, כגון פיצוצים או עשן, כדי להוסיף ריאליזם למשחק שלך. צור קובץ בשם particle.py והוסיפו את הקוד שלהלן ליישום מערכת חלקיקים פשוטה באמצעות Python וספריית הארקייד:

יְבוּא מִקמֶרֶת
יְבוּא אַקרַאִי
# מידות מסך
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# צבעים
לבן = (255, 255, 255)
# כיתת חלקיקים
מעמדחֶלְקִיק:
def__init__(עצמי, x, y, dx, dy, רדיוס, צבע, תוחלת חיים):
 self.x = x
 self.y = y
 self.dx = dx
 self.dy = dy
 self.radius = רדיוס
 self.color = צבע
 self.lifespan = תוחלת חיים
defעדכון(עצמי):
 self.x += self.dx
 self.y += self.dy
 self.lifespan -= 1
defלצייר(עצמי):
 arcade.draw_circle_filled (self.x, self.y, self.radius, self.color)
# שיעור משחק
מעמדהמשחק שלי(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי, רוחב, גובה):
 super().__init__(רוחב, גובה, "דוגמה לחלקיקים")
 self.particles = []
defלהכין(עצמי):
# צור חלקיקים
ל _ ב טווח(100):
 x = random.randrange (SCREEN_WIDTH)
 y = random.randrange (SCREEN_HEIGHT)
 dx = random.uniform(-1, 1)
 dy = random.uniform(-1, 1)
 radius = random.uniform(2, 5)
 color = arcade.color. לבן
 lifespan = random.randint(60, 120)
 חלקיק = חלקיק (x, y, dx, dy, רדיוס, צבע, תוחלת חיים)
 self.particles.append (חלקיק)
defon_draw(עצמי):
 arcade.start_render()
ל חֶלְקִיק ב self.particles:
 particle.draw()
defעדכון(עצמי, זמן_דלתא):
ל חֶלְקִיק ב self.particles:
 particle.update()
אם particle.lifespan <= 0:
 self.particles.remove (חלקיק)
defרָאשִׁי():
 משחק = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 game.setup()
 arcade.run()
אם __שם__ == "__רָאשִׁי__":
 רָאשִׁי()

אתה אמור לראות אנימציה הכוללת חלקיקים נעים רבים:

אנימציות אינטראקטיביות

הטמע אנימציות אינטראקטיביות המגיבות לקלט המשתמש או לאירועי משחק. לדוגמה, כאשר השחקן מקיים אינטראקציה עם אובייקט, הוא יכול להנפש, לשנות צבע או לשנות בצורה כלשהי. אנימציות אינטראקטיביות אלו מספקות משוב ומשפרות את המעורבות של השחקן במשחק. הנה הקוד של interactive-animation.py קוֹבֶץ:

יְבוּא מִקמֶרֶת
# מידות מסך
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
# צבעים
לבן = (255, 255, 255)
אדום = (255, 0, 0)
מעמדהמשחק שלי(מִקמֶרֶת. חַלוֹן):
def__init__(עצמי, רוחב, גובה):
 super().__init__(רוחב, גובה, "אנימציה אינטראקטיבית")
 self.player_x = 400
 self.player_y = 300
 self.player_radius = 30
 self.player_color = אדום
 self.animation_radius = 60
 self.animation_color = WHITE
 self.animation_active = שֶׁקֶר
defon_draw(עצמי):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.player_radius,
 self.player_color)
אם self.animation_active:
 arcade.draw_circle_filled (self.player_x,
 self.player_y,
 self.animation_radius,
 self.animation_color)
defon_mouse_press(עצמי, x, y, לחצן, משנה):
אם (self.player_x - self.player_radius <=
 x <= self.player_x + self.player_radius ו
 self.player_y - self.player_radius <=
 y <= self.player_y + self.player_radius
 ):
 self.animation_active = נָכוֹן
defעדכון(עצמי, זמן_דלתא):
אם self.animation_active:
 self.animation_radius += 1
אם self.animation_radius > 100:
 self.animation_active = שֶׁקֶר
 self.animation_radius = 0
defרָאשִׁי():
 משחק = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
אם __שם__ == "__רָאשִׁי__":
 רָאשִׁי()

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

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

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

שיטות עבודה מומלצות להוספת אנימציה

בעת הוספת אנימציה למשחקים שלך, שקול את השיטות המומלצות הבאות:

הגבל את מספר האנימציות

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

עיבוד אצווה של אובייקטים דומים

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

השתמש באינטרפולציה להנפשה חלקה

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

שקול את מהירות הנפשה ותזמון

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

בדוק ובצע אופטימיזציה

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

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

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

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