Spraw, aby Twoje gry zręcznościowe były jeszcze przyjemniejsze i ekscytujące, dodając losowo poruszające się obiekty.

Losowo poruszające się obiekty mogą wprowadzać do gier ekscytację i nieprzewidywalność. Dzięki temu są bardziej wciągające i stanowią wyzwanie dla graczy. Biblioteka Python's Arcade zapewnia prosty i skuteczny sposób włączania losowo poruszających się obiektów do twoich gier.

Stwórz prostą grę

Zanim zaczniesz, upewnij się, że masz pip zainstalowany na twoim urządzeniu. Użyj tego polecenia, aby zainstalować arkada biblioteka:

zręcznościowa instalacja pip

Następnie utwórz okno za pomocą arkada. Okno class i ustaw kolor tła na biały.

Kod użyty w tym artykule jest dostępny w this Repozytorium GitHub i jest darmowy do użytku na licencji MIT.

Ustaw pozycję gracza na środku ekranu w poziomie i dodaj niewielką odległość od góry. Możesz kontrolować ruch gracza za pomocą klawiszy strzałek.

Oto kod naszej podstawowej gry:

import arkada
SZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600
PROMIEŃ_GRACZA = 15







instagram viewer



klasaMoja gra(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
 super().__init__(szerokość, wysokość)
 arcade.set_background_color (arcade.color. BIAŁY)


 self.player_x = SZEROKOŚĆ_EKRANU // 2
 self.player_y = PROMIEŃ_GRACZA + 10


pokon_draw(samego siebie):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. NIEBIESKI)


pokaktualizacja(ja, delta_czas):
przechodzić


pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
 sam.gracz_x -= 5
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
 sam.gracz_x += 5
Jeśli __nazwa__ == "__główny__":
 gra = moja gra (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Dodawanie wielu obiektów

Aby dodać do gry losowo poruszające się obiekty, utwórz listę do przechowywania pozycji obiektów i aktualizuj je co klatkę. Możesz także użyć duszki jako obiekty.

W kodzie gry dodaj listę o nazwie obiekty do przechowywania pozycji losowo poruszających się obiektów. Następnie wygeneruj liczbę obiektów (NUM_OBJECTS) z losowymi współrzędnymi x i y w granicach ekranu. Obiekty są rysowane jako czerwone kółka za pomocą arcade.draw_circle_filled funkcjonować.

import arkada
import losowy
SZEROKOŚĆ_EKRANU = 800
WYSOKOŚĆ_EKRANU = 600
PROMIEŃ_GRACZA = 15
PROMIEŃ_OBIEKTU = 10
LICZBA_OBIEKTÓW = 10


klasaMoja gra(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
 super().__init__(szerokość, wysokość)
 arcade.set_background_color (arcade.color. BIAŁY)


 self.player_x = SZEROKOŚĆ_EKRANU // 2
 self.player_y = PROMIEŃ_GRACZA + 10


 self.objects = []
Do _ W zakres (NUM_OBJECTS):
 x = losowo.randint(0, SZEROKOŚĆ_EKRANU)
 y = losowo.randint(0, WYSOKOŚĆ_EKRANU)
 self.objects.append((x, y))


pokon_draw(samego siebie):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. NIEBIESKI)


Do obj W obiekty własne:
 x, y = obiekt
 arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. CZERWONY)


pokaktualizacja(ja, delta_czas):
przechodzić


pokon_key_press(ja, klucz, modyfikatory):
Jeśli klucz == klucz.zręcznościowy. LEWY:
 sam.gracz_x -= 5
Elif klucz == klucz.zręcznościowy. PRAWIDŁOWY:
 sam.gracz_x += 5
Jeśli __nazwa__ == "__główny__":
 gra = moja gra (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()

Poniżej znajduje się wyjście:

Implementacja algorytmu ruchu losowego

Aby obiekty poruszały się losowo, zaktualizuj ich pozycje w pliku aktualizacja metodą losowego algorytmu ruchu.

Przejrzyj każdy obiekt i wygeneruj dla niego losowe wartości dx I dy, reprezentujący zmianę współrzędnych x i y. Następnie zaktualizuj pozycję obiektu, dodając te wartości. Oto zmodyfikowany kod:

pokaktualizacja(ja, delta_czas):
Do I W zakres (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = losowo.randint(-5, 5)
 dy = losowo.randint(-5, 5)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Poniżej znajduje się wyjście:

Obiekty poruszające się w kierunku gracza

Aby dodać więcej interakcji, spraw, aby obiekty poruszały się w kierunku gracza. Możesz to osiągnąć, obliczając wektor kierunku między obiektem a graczem i odpowiednio dostosowując położenie obiektu.

W tym celu oblicz różnice we współrzędnych x i y między obiektem a graczem. Normalizując te wartości, uzyskujesz wektor kierunku. Następnie pomnóż ten wektor przez współczynnik prędkości (w tym przypadku 3) i dodaj go do pozycji obiektu. Oto zaktualizowany aktualizacja metoda:

pokaktualizacja(ja, delta_czas):
Do I W zakres (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = sam.gracz_x - x
 dy = sam.gracz_y - y
 odległość = math.sqrt (dx ** 2 + dy** 2)
 dx /= odległość
 dy /= odległość
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Poniżej znajduje się wyjście:

Obiekty zaczynają się poruszać, gdy gracz wchodzi w otoczenie

Aby dodać jeszcze więcej dynamiki, zmodyfikuj kod tak, aby obiekty zaczynały się poruszać dopiero wtedy, gdy gracz wejdzie w ich otoczenie. Dodaj kod ruchu gracza i zdefiniuj promień, w którym obiekty stają się aktywne.

pokaktualizacja(ja, delta_czas):
Do I W zakres (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = sam.gracz_x - x
 dy = sam.gracz_y - y
 odległość = math.sqrt (dx ** 2 + dy** 2)

Jeśli odległość < 100: # W razie potrzeby dostosuj promień
 dx /= odległość
 dy /= odległość
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Wykrywanie kolizji i interakcja

Teraz dodaj wykrywanie kolizji między graczem a obiektami i zdefiniuj zachowanie w przypadku kolizji. Zmodyfikuj aktualizacja metoda obsługi kolizji:

pokaktualizacja(ja, delta_czas):
Do I W zakres (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = sam.gracz_x - x
 dy = sam.gracz_y - y
 odległość = math.sqrt (dx ** 2 + dy** 2)

Jeśli odległość < PLAYER_RADIUS + OBJECT_RADIUS:
# jeśli wystąpiła kolizja, obsłuż ją tutaj
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), losowo.randint(0, WYSOKOŚĆ_EKRANU)))

Elif odległość < 100:
 dx /= odległość
 dy /= odległość
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Równoważenie losowości

Aby zapewnić zrównoważoną rozgrywkę, ważne jest, aby precyzyjnie dostosować losowy ruch i pojawianie się obiektów. Oto kilka przykładów tego, jak możesz dostosować kod, aby uzyskać lepszą równowagę w grze:

Ograniczenie prędkości maksymalnej

Aby zapobiec zbyt szybkiemu poruszaniu się obiektów, możesz wprowadzić ograniczenie maksymalnej prędkości. Zmodyfikuj aktualizacja metoda uwzględniania ograniczeń prędkości:

pokaktualizacja(ja, delta_czas):
Do I W zakres (NUM_OBJECTS):
 x, y = self.objects[i]
 dx = sam.gracz_x - x
 dy = sam.gracz_y - y
 odległość = math.sqrt (dx ** 2 + dy** 2)
Jeśli odległość < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), losowo.randint(0, WYSOKOŚĆ_EKRANU)))
Elif odległość < 100:
 dx /= odległość
 dy /= odległość


 prędkość = 3# W razie potrzeby dostosuj wartość prędkości
 dx = min (maks. (dx * prędkość, -MAX_PRĘDKOŚĆ), MAKS.PRĘDKOŚĆ)
 dy = min (maks. (dy * prędkość, -MAX_SPEED), MAX_SPEED)
 x += dx
 y += dy
 self.objects[i] = (x, y)

Kontrolowanie szybkości odradzania

Możesz także kontrolować tempo pojawiania się nowych obiektów w grze. Dostosuj kod, aby zawierał opóźnienie między pojawianiem się nowych obiektów:

import czas
klasaMoja gra(arkada. Okno):
pok__w tym__(ja, szerokość, wysokość):
 super().__init__(szerokość, wysokość)
 arcade.set_background_color (arcade.color. BIAŁY)


 self.player_x = SZEROKOŚĆ_EKRANU // 2
 self.player_y = PROMIEŃ_GRACZA + 10


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


pokaktualizacja(ja, delta_czas):
# kontroluj częstotliwość tarła tutaj
Jeśli time.time() - self.last_spawn_time > SPAWN_DELAY:
Jeśli len (self.objects) < MAX_OBJECTS:
 self.objects.append((random.randint(0, SCREEN_WIDTH), losowo.randint(0, WYSOKOŚĆ_EKRANU)))
 self.last_spawn_time = czas.czas()


Do I W zakres (len (self.objects)):
 x, y = self.objects[i]
 dx = sam.gracz_x - x
 dy = sam.gracz_y - y
 odległość = math.sqrt (dx ** 2 + dy** 2)


Jeśli odległość < PLAYER_RADIUS + OBJECT_RADIUS:
 self.objects.pop (i)
 self.objects.append((random.randint(0, SCREEN_WIDTH), losowo.randint(0, WYSOKOŚĆ_EKRANU)))
Elif odległość < 100:
 dx /= odległość
 dy /= odległość
 x += dx * 3
 y += dy * 3
 self.objects[i] = (x, y)

Poprawić SPAWN_DELAY I MAX_OBIEKTÓW wartości, aby znaleźć właściwą równowagę dla swojej gry. Dłuższe opóźnienie lub mniejsza maksymalna liczba obiektów sprawi, że gra będzie mniej zatłoczona. Natomiast krótsze opóźnienie lub większe maksimum zwiększy trudność.

Spraw, by gry były przyjemniejsze dzięki ruchomym obiektom

Dodawanie losowo poruszających się obiektów do gier może znacznie poprawić ogólne wrażenia. Wprowadzają nieprzewidywalność i wyzwanie, czyniąc rozgrywkę bardziej wciągającą i dynamiczną. Gracze będą musieli dostosować się i szybko reagować, aby uniknąć kolizji lub złapać przedmioty, a to zapewni poczucie ekscytacji i spełnienia.