Gør dine arkadespil endnu mere underholdende og spændende ved at tilføje tilfældige bevægelige objekter.

Tilfældige bevægelige objekter kan bringe spænding og uforudsigelighed til spil. Det gør dem mere engagerende og udfordrende for spillere. Pythons Arcade-bibliotek giver en enkel og effektiv måde at inkorporere tilfældige bevægelige objekter i dine spil.

Opret et simpelt spil

Før du starter, skal du sikre dig, at du har pip installeret på din enhed. Brug denne kommando til at installere arkade bibliotek:

pip installere arkade

Derefter skal du oprette et vindue ved hjælp af arkade. Vindue klasse og sæt baggrundsfarven til hvid.

Koden brugt i denne artikel er tilgængelig i denne GitHub-depot og er gratis for dig at bruge under MIT-licensen.

Indstil afspillerens position til midten af ​​skærmen vandret og tilføj en lille afstand fra toppen. Du kan styre spillerens bevægelse ved hjælp af piletasterne.

Her er koden til vores grundlæggende spil:

importere arkade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15







instagram viewer



klasseMit Spil(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde)
 arcade.set_background_color (arcade.color. HVID)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


defon_draw(selv):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLÅ)


defopdatering(selv, delta_tid):
passere


defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.player_x -= 5
elif nøgle == arkade.nøgle. HØJRE:
 self.player_x += 5
hvis __navn__ == "__main__":
 spil = Mit spil (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Tilføjelse af flere objekter

For at tilføje tilfældige bevægelige objekter til dit spil, skal du oprette en liste til at gemme objektets positioner og opdatere dem hver ramme. Du kan også bruge sprites som objekter.

Tilføj en liste kaldet i din spilkode genstande at gemme positionerne af de tilfældige bevægelige objekter. Derefter genererer du antallet af objekter (NUM_OBJECTS) med tilfældige x- og y-koordinater inden for skærmgrænserne. Objekterne tegnes som røde cirkler ved hjælp af arcade.draw_circle_filled fungere.

importere arkade
importere tilfældig
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10


klasseMit Spil(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde)
 arcade.set_background_color (arcade.color. HVID)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


 self.objects = []
til _ i interval (NUM_OBJECTS):
 x = random.randint(0, SCREEN_WIDTH)
 y = random.randint(0, SCREEN_HEIGHT)
 self.objects.append((x, y))


defon_draw(selv):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLÅ)


til obj i self.objects:
 x, y = obj
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. RØD)


defopdatering(selv, delta_tid):
passere


defon_key_press(selv, nøgle, modifikatorer):
hvis nøgle == arkade.nøgle. VENSTRE:
 self.player_x -= 5
elif nøgle == arkade.nøgle. HØJRE:
 self.player_x += 5
hvis __navn__ == "__main__":
 spil = Mit spil (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Nedenfor er output:

Implementering af tilfældig bevægelsesalgoritme

For at få objekterne til at bevæge sig tilfældigt skal du opdatere deres positioner i opdatering metode ved hjælp af en tilfældig bevægelsesalgoritme.

Gentag gennem hvert objekt og generer tilfældige værdier for dx og D y, der repræsenterer ændringen i x- og y-koordinater. Opdater derefter objektets position ved at tilføje disse værdier. Her er den ændrede kode:

defopdatering(selv, delta_tid):
til jeg i interval (NUM_OBJECTS):
 x, y = selv.objekter[i]
 dx = random.randint(-5, 5)
 dy = random.randint(-5, 5)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Nedenfor er output:

Objekter, der bevæger sig mod spilleren

For at tilføje mere interaktion skal du få objekterne til at bevæge sig mod afspilleren. Du kan opnå dette ved at beregne retningsvektoren mellem objektet og afspilleren og justere objektets position i overensstemmelse hermed.

Til dette skal du beregne forskellene i x- og y-koordinater mellem objektet og spilleren. Ved at normalisere disse værdier får man en retningsvektor. Derefter ganges denne vektor med en hastighedsfaktor (3 i dette tilfælde) og læg den til objektets position. Her er den opdaterede opdatering metode:

defopdatering(selv, delta_tid):
til jeg i interval (NUM_OBJECTS):
 x, y = selv.objekter[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + dy ** 2)
 dx /= afstand
 dy /= afstand
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Nedenfor er output:

Objekter begynder at bevæge sig, når afspilleren går ind i omgivelserne

For at tilføje yderligere dynamik skal du ændre koden, så objekterne først begynder at bevæge sig, når spilleren kommer ind i deres omgivende område. Tilføj kode for spillerens bevægelse og definere en radius, inden for hvilken objekterne bliver aktive.

defopdatering(selv, delta_tid):
til jeg i interval (NUM_OBJECTS):
 x, y = selv.objekter[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + dy ** 2)

hvis afstand < 100: # Juster radius efter behov
 dx /= afstand
 dy /= afstand
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Kollisionsdetektion og interaktion

Tilføj nu kollisionsdetektion mellem afspilleren og objekterne, og definer adfærd, når der opstår en kollision. Rediger opdatering metode til at håndtere kollisioner:

defopdatering(selv, delta_tid):
til jeg i interval (NUM_OBJECTS):
 x, y = selv.objekter[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + dy ** 2)

hvis afstand < PLAYER_RADIUS + OBJECT_RADIUS:
# hvis kollision fandt sted, skal du håndtere det her
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))

elif afstand < 100:
 dx /= afstand
 dy /= afstand
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Balancerende tilfældighed

For at skabe en afbalanceret spiloplevelse er det vigtigt at finjustere den tilfældige bevægelse og gydning af objekter. Her er et par eksempler på, hvordan du kan justere koden for at opnå en bedre balance i dit spil:

Begrænsning af maksimal hastighed

For at forhindre genstande i at bevæge sig for hurtigt, kan du indføre en maksimal hastighedsgrænse. Rediger opdatering metode til at inkludere hastighedsbegrænsninger:

defopdatering(selv, delta_tid):
til jeg i interval (NUM_OBJECTS):
 x, y = selv.objekter[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + dy ** 2)
hvis afstand < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif afstand < 100:
 dx /= afstand
 dy /= afstand


 hastighed = 3# Juster hastighedsværdien efter behov
 dx = min (maks. (dx * hastighed, -MAX_SPEED), MAX_SPEED)
 dy = min (max (dy * hastighed, -MAX_SPEED), MAX_SPEED)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Styring af spawn rate

Du kan også kontrollere hastigheden, hvormed nye objekter gyder i spillet. Juster koden for at inkludere en forsinkelse mellem gydning af nye objekter:

importere tid
klasseMit Spil(arkade. Vindue):
def__i det__(selv, bredde, højde):
 super().__init__(bredde, højde)
 arcade.set_background_color (arcade.color. HVID)


 self.player_x = SCREEN_WIDTH // 2
 self.player_y = PLAYER_RADIUS + 10


 self.objects = []
 self.last_spawn_time = time.time()


defopdatering(selv, delta_tid):
# styr gydehastigheden her
hvis time.time() - self.last_spawn_time > SPAWN_DELAY:
hvis len (self.objects) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
 self.last_spawn_time = time.time()


til jeg i interval (len (selv.objekter)):
 x, y = selv.objekter[i]
 dx = self.player_x - x
 dy = self.player_y - y
 distance = math.sqrt (dx ** 2 + dy ** 2)


hvis afstand < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif afstand < 100:
 dx /= afstand
 dy /= afstand
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Juster SPAWN_DELAY og MAX_OBJECTS værdier for at finde den rigtige balance til dit spil. En længere forsinkelse eller et mindre maksimalt antal genstande vil gøre spillet mindre overfyldt. Hvorimod en kortere forsinkelse eller et større maksimum vil øge sværhedsgraden.

Gør spil sjovere ved at bruge objekter i bevægelse

Tilføjelse af tilfældige bevægelige objekter til spil kan forbedre den samlede oplevelse markant. De introducerer uforudsigelighed og udfordring, hvilket gør gameplayet mere engagerende og dynamisk. Spillere bliver nødt til at tilpasse sig og reagere hurtigt for at undgå kollisioner eller fange genstande, og det vil give en følelse af spænding og præstation.