Fă-ți jocurile arcade și mai plăcute și mai incitante adăugând obiecte în mișcare aleatorii.
Obiectele în mișcare aleatorie pot aduce emoție și imprevizibilitate în jocuri. Îi face mai antrenați și mai provocatori pentru jucători. Biblioteca Arcade a lui Python oferă o modalitate simplă și eficientă de a încorpora obiecte în mișcare aleatorie în jocurile tale.
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 arcadă bibliotecă:
pip install arcadeDupă aceea, creați o fereastră folosind arcadă. Fereastră clasa și setați culoarea de fundal la alb.
Codul folosit în acest articol este disponibil în acest articol Depozitul GitHub și este gratuit pentru utilizare sub licența MIT.
Setați poziția jucătorului în mijlocul ecranului pe orizontală și adăugați o mică distanță de sus. Puteți controla mișcarea jucătorului folosind tastele săgeți.
Iată codul jocului nostru de bază:
import arcadăSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15clasăJocul meu(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
super().__init__(lățime, înălțime)
arcade.set_background_color (arcade.color. ALB)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10defon_draw(de sine):
arcade.start_render()
arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. ALBASTRU)defActualizați(self, delta_time):
trecedefon_key_press(sine, cheie, modificatori):
dacă cheie == arcade.key. STÂNGA:
self.player_x -= 5
elif cheie == arcade.key. DREAPTA:
self.player_x += 5
dacă __nume__ == "__principal__":
joc = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
Adăugarea mai multor obiecte
Pentru a adăuga obiecte în mișcare aleatoare în joc, creați o listă pentru a stoca pozițiile obiectului și actualizați-le la fiecare cadru. De asemenea, puteți utiliza sprite-urile ca obiecte.
În codul jocului, adăugați o listă numită obiecte pentru a stoca pozițiile obiectelor în mișcare aleatoare. După aceea, generați numărul de obiecte (NUM_OBJECTS) cu coordonate aleatoare x și y în limitele ecranului. Obiectele sunt desenate ca cercuri roșii folosind arcade.desenă_cerc_umplut funcţie.
import arcadă
import AleatoriuSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10clasăJocul meu(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
super().__init__(lățime, înălțime)
arcade.set_background_color (arcade.color. ALB)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10self.objects = []
pentru _ în interval (NUM_OBJECTS):
x = aleatoriu.randint(0, SCREEN_WIDTH)
y = random.randint(0, SCREEN_HEIGHT)
self.objects.append((x, y))defon_draw(de sine):
arcade.start_render()
arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. ALBASTRU)pentru obj în self.obiecte:
x, y = obj
arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. ROȘU)defActualizați(self, delta_time):
trecedefon_key_press(sine, cheie, modificatori):
dacă cheie == arcade.key. STÂNGA:
self.player_x -= 5
elif cheie == arcade.key. DREAPTA:
self.player_x += 5
dacă __nume__ == "__principal__":
joc = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
Mai jos este rezultatul:
Implementarea algoritmului de mișcare aleatorie
Pentru a face obiectele să se miște aleator, actualizați-le pozițiile în Actualizați metoda folosind un algoritm de mișcare aleatorie.
Iterați prin fiecare obiect și generați valori aleatorii pentru dx și dy, reprezentând modificarea coordonatelor x și y. Apoi actualizați poziția obiectului adăugând aceste valori. Iată codul modificat:
defActualizați(self, delta_time):
pentru i în interval (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)Mai jos este rezultatul:
Obiecte care se deplasează spre jucător
Pentru a adăuga mai multă interacțiune, faceți ca obiectele să se miște spre jucător. Puteți realiza acest lucru calculând vectorul de direcție dintre obiect și jucător și ajustând poziția obiectului în consecință.
Pentru aceasta, calculați diferențele în coordonatele x și y dintre obiect și jucător. Prin normalizarea acestor valori, obțineți un vector de direcție. Apoi înmulțiți acest vector cu un factor de viteză (3 în acest caz) și adăugați-l la poziția obiectului. Aici este actualizat Actualizați metodă:
defActualizați(self, delta_time):
pentru i în interval (NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distanta = math.sqrt (dx ** 2 + dy ** 2)
dx /= distanta
dy /= distanta
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)Mai jos este rezultatul:
Obiectele încep să se miște când jucătorul intră în împrejurimi
Pentru a adăuga o dinamică suplimentară, modificați codul astfel încât obiectele să înceapă să se miște numai atunci când jucătorul intră în zona înconjurătoare. Adaugă cod pentru mișcarea jucătorului și definiți o rază în care obiectele devin active.
defActualizați(self, delta_time):
pentru i în interval (NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distanta = math.sqrt (dx ** 2 + dy ** 2)
dacă distanta < 100: # Ajustați raza după cum este necesar
dx /= distanta
dy /= distanta
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)Detectarea coliziunilor și interacțiunea
Acum, adăugați detectarea coliziunilor între jucător și obiecte și definiți comportamentul atunci când are loc o coliziune. Modificați Actualizați metoda de tratare a coliziunilor:
defActualizați(self, delta_time):
pentru i în interval (NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distanta = math.sqrt (dx ** 2 + dy ** 2)
dacă distanta < PLAYER_RADIUS + OBJECT_RADIUS:
# dacă a avut loc o coliziune, gestionați-o aici
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif distanta < 100:
dx /= distanta
dy /= distanta
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)Echilibrarea aleatoriei
Pentru a crea o experiență de joc echilibrată, este important să ajustați mișcarea aleatorie și generarea obiectelor. Iată câteva exemple despre cum puteți ajusta codul pentru a obține un echilibru mai bun în jocul dvs.:
Limitarea vitezei maxime
Pentru a preveni mișcarea prea rapidă a obiectelor, puteți introduce o limită de viteză maximă. Modificați Actualizați metodă de a include constrângeri de viteză:
defActualizați(self, delta_time):
pentru i în interval (NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distanta = math.sqrt (dx ** 2 + dy ** 2)dacă distanta < PLAYER_RADIUS + OBJECT_RADIUS:
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif distanta < 100:
dx /= distanta
dy /= distantaviteza = 3# Reglați valoarea vitezei după cum este necesar
dx = min (max (dx * viteză, -MAX_SPEED), MAX_SPEED)
dy = min (max (dy * viteză, -MAX_SPEED), MAX_SPEED)
x += dx
y += dy
self.objects[i] = (x, y)
Controlul ratei de apariție
De asemenea, puteți controla rata cu care apar noile obiecte în joc. Ajustați codul pentru a include o întârziere între generarea de noi obiecte:
import timpclasăJocul meu(arcadă. Fereastră):
def__init__(sine, lățime, înălțime):
super().__init__(lățime, înălțime)
arcade.set_background_color (arcade.color. ALB)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10self.objects = []
self.last_spawn_time = time.time()defActualizați(self, delta_time):
# controlați rata de reproducere aici
dacă time.time() - self.last_spawn_time > SPAWN_DELAY:
dacă len (self.objects) < MAX_OBJECTS:
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
self.last_spawn_time = time.time()pentru i în interval (len (self.objects)):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distanta = math.sqrt (dx ** 2 + dy ** 2)dacă distanta < PLAYER_RADIUS + OBJECT_RADIUS:
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif distanta < 100:
dx /= distanta
dy /= distanta
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)
Ajustează SPAWN_DELAY și MAX_OBJECTS valori pentru a găsi echilibrul potrivit pentru jocul tău. O întârziere mai mare sau un număr maxim mai mic de obiecte va face jocul mai puțin aglomerat. În timp ce, o întârziere mai scurtă sau un maxim mai mare va crește dificultatea.
Faceți jocurile mai distractive folosind obiecte în mișcare
Adăugarea de obiecte în mișcare aleatorie la jocuri poate îmbunătăți semnificativ experiența generală. Ele introduc imprevizibilitate și provocare, făcând jocul mai captivant și mai dinamic. Jucătorii vor trebui să se adapteze și să reacționeze rapid pentru a evita coliziunile sau pentru a prinde obiecte, iar asta le va oferi un sentiment de entuziasm și realizare.
