Biblioteca Arcade a lui Python vă acoperă, de la cele mai simple animații bazate pe culori până la modelarea complexă a particulelor.
Animația joacă un rol vital în îmbunătățirea atractivității vizuale și a angajării jocurilor video. Biblioteca Arcade este un cadru Python pentru crearea de jocuri 2D. Oferă o modalitate simplă și eficientă de a încorpora animații în proiectele tale de joc.
Puteți folosi biblioteca Arcade pentru a crea animații de mișcare de bază și animații sincronizate cu evenimente de joc.
Creați un joc simplu
Înainte de a începe, asigurați-vă că aveți pip instalat pe dispozitivul dvs. Utilizați această comandă pentru a instala biblioteca arcade:
pip install arcadeDupă aceea, creați un fișier Python numit joc simplu.py și începeți prin a configura un joc în care jucătorul se poate mișca la stânga și la dreapta.
Codul folosit în acest articol este disponibil în acest articol Depozitul GitHub și este gratuit pentru utilizare sub licența MIT.
Folosind biblioteca Arcade, puteți crea o fereastră, puteți configura mediul de joc și puteți gestiona intrarea jucătorului. Iată un fragment de cod pentru a începe:
import arcadăSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600clasăJocul meu(arcadă. Fereastră):
def__init__(de sine):
super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Jocul meu")
self.player_x = SCREEN_WIDTH // 2
self.player_y = SCREEN_HEIGHT // 2defon_draw(de sine):
arcade.start_render()
col = arcade.color. ALBASTRU
arcade.draw_circle_filled (self.player_x, self.player_y, 20, col)defon_key_press(sine, cheie, modificatori):
dacă cheie == arcade.key. STÂNGA:
self.player_x -= 10
elif cheie == arcade.key. DREAPTA:
self.player_x += 10defprincipal():
joc = MyGame()
arcade.run()
dacă __nume__ == "__principal__":
principal()
Adăugați o animație de mișcare de bază
Acum, duceți-vă jocul cu un pas mai departe și adăugați o animație de mișcare de bază obiectului jucător. Pentru a anima jucător în mișcare, creați 3 cercuri diferite și repetați între ele succesiv când jucătorul începe să se miște. Iată fragmentul de cod actualizat pentru mișcare-animație.py fişier:
clasăJocul meu(arcadă. Fereastră):
def__init__(de sine):
super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Jocul meu")
self.player_x = SCREEN_WIDTH // 2
self.player_y = SCREEN_HEIGHT // 2
self.frame_counter = 0defon_draw(de sine):
arcade.start_render()
col1 = arcade.culoare. ALBASTRU
col2 = arcade.culoare. VERDE
col3 = arcade.culoare. ROȘUdacă self.frame_counter < 10:
arcade.draw_circle_filled (self.player_x, self.player_y, 20,col1)
elif self.frame_counter < 20:
arcade.draw_circle_filled (self.player_x, self.player_y, 20,col2)
altfel:
arcade.draw_circle_filled (self.player_x, self.player_y, 20, col3)
defon_key_press(sine, cheie, modificatori):
dacă cheie == arcade.key. STÂNGA:
self.player_x -= 10
self.frame_counter = (self.frame_counter + 1) % 30
elif cheie == arcade.key. DREAPTA:
self.player_x += 10
self.frame_counter = (self.frame_counter + 1) % 30
Iată un exemplu de cadru de ieșire:
Controlul vitezei și direcției animației
Pentru a controla viteza animației, puteți introduce un sistem de frecvență a cadrelor. De asemenea, puteți schimba ordinea cadrelor în funcție de direcția de mișcare a jucătorului. Când jucătorul se mișcă de la stânga la dreapta, cadrele se vor afișa în ordine inversă.
Iată fragmentul de cod modificat pentru frame-rate.py fişier:
clasăJocul meu(arcadă. Fereastră):
def__init__(de sine):
super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Jocul meu")
self.player_x = SCREEN_WIDTH // 2
self.player_y = SCREEN_HEIGHT // 2
self.frame_counter = 0
col1 = arcade.culoare. ALBASTRU
col2 = arcade.culoare. VERDE
col3 = arcade.culoare. ROȘU
self.frames = [col1, col2, col3]
self.frame_rate = 10defon_draw(de sine):
arcade.start_render()
frame_index = self.frame_counter // self.frame_rate % len (self.frames)dacă self.player_x < SCREEN_WIDTH // 2:
frame_index = len (self.frames) - 1 - cadru_indexindex = self.frames[frame_index]
arcade.draw_circle_filled (self.player_x, self.player_y, 20, index)
defon_key_press(sine, cheie, modificatori):
dacă cheie == arcade.key. STÂNGA:
self.player_x -= 10
self.frame_counter += 1
elif cheie == arcade.key. DREAPTA:
self.player_x += 10
self.frame_counter += 1
Utilizați operatorul modul % cu len (self.frames) pentru a se asigura că index_cadru rămâne întotdeauna în intervalul de cadre disponibile. Acest lucru previne IndexError să apară atunci când animația trece prin cadre.
Ajustează frame_rate valoare pentru a controla viteza animației și bucurați-vă de mișcarea animată a obiectelor dvs. de joc.
Inclusiv caracteristici suplimentare
Biblioteca Arcade oferă diverse funcții pentru a vă îmbunătăți animațiile.
Efectele particulelor
Puteți crea efecte de particule, cum ar fi explozii sau fum, pentru a adăuga realism jocului dvs. Creați un fișier numit particule.py și adăugați codul de mai jos pentru o implementare simplă a sistemului de particule folosind Python și biblioteca arcade:
import arcadă
import Aleatoriu# Dimensiunile ecranului
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600# Culori
ALB = (255, 255, 255)# Clasa de particule
clasăParticulă:
def__init__(sine, x, y, dx, dy, rază, culoare, durată de viață):
sine.x = x
self.y = y
self.dx = dx
self.dy = dy
self.radius = raza
self.color = culoare
self.lifespan = durata de viatadefActualizați(de sine):
self.x += self.dx
self.y += self.dy
sine.durata de viata -= 1defa desena(de sine):
arcade.draw_circle_filled (self.x, self.y, self.radius, self.color)# Clasa de joc
clasăJocul meu(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
super().__init__(lățime, înălțime, "Exemplu de particule")
sine.particule = []defînființat(de sine):
# Creați particule
pentru _ în gamă(100):
x = random.randrange (SCREEN_WIDTH)
y = random.randrange (SCREEN_HEIGHT)
dx = aleatoriu.uniform(-1, 1)
dy = random.uniform(-1, 1)
raza = random.uniform(2, 5)
culoare = arcade.culoare. ALB
durata de viață = random.randint(60, 120)
particulă = Particulă (x, y, dx, dy, rază, culoare, durată de viață)
self.particules.append (particulă)defon_draw(de sine):
arcade.start_render()
pentru particulă în particule de sine:
particule.draw()defActualizați(self, delta_time):
pentru particulă în particule de sine:
particule.actualizare()dacă particule.durata de viata <= 0:
auto.particule.elimină (particulă)defprincipal():
joc = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
game.setup()
arcade.run()
dacă __nume__ == "__principal__":
principal()
Ar trebui să vedeți o animație care implică multe particule în mișcare:
Animații interactive
Implementați animații interactive care răspund la intrarea utilizatorului sau la evenimentele din joc. De exemplu, atunci când jucătorul interacționează cu un obiect, acesta se poate anima, schimba culoarea sau se poate transforma într-un fel. Aceste animații interactive oferă feedback și sporesc implicarea jucătorului în joc. Iată codul pentru interactive-animation.py fişier:
import arcadă# Dimensiunile ecranului
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600# Culori
ALB = (255, 255, 255)
RED = (255, 0, 0)clasăJocul meu(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
super().__init__(lățime, înălțime, „Animție interactivă”)
self.player_x = 400
self.player_y = 300
self.player_radius = 30
self.player_color = RED
self.animation_radius = 60
self.animation_color = ALB
self.animation_active = Falsdefon_draw(de sine):
arcade.start_render()arcade.draw_circle_filled (self.player_x,
self.player_y,
self.player_radius,
self.player_color)dacă self.animation_active:
arcade.draw_circle_filled (self.player_x,
self.player_y,
self.animation_radius,
self.animation_color)defon_mouse_press(self, x, y, buton, modificatori):
dacă (self.player_x - self.player_radius <=
x <= self.player_x + self.player_radius și
self.player_y - self.player_radius <=
y <= self.player_y + self.player_radius
):
self.animation_active = AdevăratdefActualizați(self, delta_time):
dacă self.animation_active:
self.animation_radius += 1dacă auto.rază_animație > 100:
self.animation_active = Fals
self.animation_radius = 0defprincipal():
joc = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
dacă __nume__ == "__principal__":
principal()
Ignorați metodele necesare, cum ar fi on_draw, on_mouse_press, și Actualizați, pentru a gestiona desenarea playerului și a animației, gestionarea clicurilor de mouse și actualizarea animației.
Pentru a desena jucătorul, utilizați arcade.desenă_cerc_umplut funcția, care ia (X y) coordonatele centrului, razei și culorii ca argumente. Funcția draw_circle_filled este una dintre Instrumentele Arcade pe care le puteți folosi pentru a desena elementele de joc. În acest caz, puteți desena un cerc în creștere variind raza în timp.
The on_mouse_press metoda rulează atunci când utilizatorul face clic pe mouse. Verifică dacă coordonatele mouse-ului se află în limitele obiectului jucător și activează animația dacă sunt.
Cele mai bune practici pentru adăugarea de animație
Când adăugați animație la jocuri, luați în considerare următoarele bune practici:
Limitați numărul de animații
A avea multe animații cu multe cadre poate afecta performanța. Luați în considerare reducerea la minimum a numărului de animații sau cadre necesare, în special pentru elementele necritice din joc. Simplificarea animațiilor poate ajuta la menținerea unei rate de cadre consistente și la optimizarea utilizării resurselor.
Lot de randare obiecte similare
Grupați obiecte similare care au aceleași cadre de animație și texturi împreună și redați-le ca un lot. Gruparea reduce numărul de apeluri la extragere, rezultând o performanță îmbunătățită. Această tehnică este deosebit de utilă atunci când animați obiecte care folosesc aceeași foaie de sprite sau au secvențe de animație similare.
Utilizați interpolarea pentru o animație fluidă
Aplicați tehnici de interpolare, cum ar fi interpolarea liniară (lerping), pentru a obține tranziții fluide de animație. Interpolarea calculează valori intermediare între cadrele cheie de animație pentru a crea mișcări fluide. Această abordare previne săriturile bruște sau mișcările sacadate între cadre, rezultând animații mai atractive din punct de vedere vizual.
Luați în considerare viteza și sincronizarea animației
Experimentați cu diferite viteze de animație și sincronizare pentru a găsi echilibrul potrivit pentru jocul dvs. Reglați durata cadrului sau utilizați diferite secvențe de animație pentru a crea variații de viteză, accelerație sau decelerare. Aceste ajustări pot adăuga profunzime și caracter animațiilor jocului tău.
Testați și optimizați
Testați-vă în mod regulat animațiile pe diferite dispozitive și monitorizați performanța. Căutați potențiale blocaje sau încetiniri și optimizați în consecință. Acest proces ajută la asigurarea unor experiențe de animație fluide și consistente pe o gamă largă de dispozitive.
Faceți jocurile mai captivante cu animația
Adăugarea de animații la jocurile dvs. poate îmbunătăți semnificativ implicarea și imersiunea jucătorilor. Animațiile oferă feedback vizual acțiunilor jucătorului, făcând jocul mai intuitiv și mai plăcut. Ele aduc lumi de joc la viață, creând un sentiment de realism și entuziasm.
Fie că este vorba despre un personaj care rulează, un obiect care explodează sau un simplu efect de tranziție, animațiile contribuie la o experiență de joc mai dinamică și mai captivantă.
