Gör dina arkadspel ännu roligare och spännande genom att lägga till slumpmässiga rörliga föremål.
Slumpmässiga rörliga föremål kan skapa spänning och oförutsägbarhet till spel. Det gör dem mer engagerande och utmanande för spelare. Pythons Arcade-bibliotek ger ett enkelt och effektivt sätt att införliva slumpmässiga rörliga objekt i dina spel.
Skapa ett enkelt spel
Innan du börjar, se till att du har pip installerad på din enhet. Använd det här kommandot för att installera arkad bibliotek:
pip installera arkadEfter det skapar du ett fönster med hjälp av arkad. Fönster klass och ställ in bakgrundsfärgen på vit.
Koden som används i den här artikeln är tillgänglig i denna GitHub-förråd och är gratis för dig att använda under MIT-licensen.
Ställ in spelarens position till mitten av skärmen horisontellt och lägg till ett litet avstånd från toppen. Du kan styra spelarens rörelser med hjälp av piltangenterna.
Här är koden för vårt grundläggande spel:
importera arkadSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
super().__init__(bredd, höjd)
arcade.set_background_color (arcade.color. VIT)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10defon_draw(själv):
arcade.start_render()
arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLÅ)defuppdatering(själv, delta_tid):
passeradefon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
self.player_x -= 5
elif nyckel == arkad.nyckel. HÖGER:
self.player_x += 5
om __namn__ == "__huvud__":
spel = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
Lägga till flera objekt
För att lägga till slumpmässiga rörliga objekt till ditt spel, skapa en lista för att lagra objektets positioner och uppdatera dem varje bildruta. Du kan också använda sprites som objekt.
Lägg till en lista som heter i din spelkod föremål för att lagra positionerna för de slumpmässiga rörliga föremålen. Därefter genererar du antalet objekt (NUM_OBJECTS) med slumpmässiga x- och y-koordinater inom skärmgränserna. Objekten ritas som röda cirklar med hjälp av arcade.draw_circle_filled fungera.
importera arkad
importera slumpmässigSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10klassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
super().__init__(bredd, höjd)
arcade.set_background_color (arcade.color. VIT)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10self.objects = []
för _ i intervall (NUM_OBJECTS):
x = random.randint(0, SCREEN_WIDTH)
y = random.randint(0, SCREEN_HEIGHT)
self.objects.append((x, y))defon_draw(själv):
arcade.start_render()
arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. BLÅ)för obj i self.objects:
x, y = obj
arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. RÖD)defuppdatering(själv, delta_tid):
passeradefon_key_press(själv, nyckel, modifierare):
om nyckel == arkad.nyckel. VÄNSTER:
self.player_x -= 5
elif nyckel == arkad.nyckel. HÖGER:
self.player_x += 5
om __namn__ == "__huvud__":
spel = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
Nedan är utgången:
Implementering av slumpmässig rörelsealgoritm
För att få objekten att röra sig slumpmässigt, uppdatera deras positioner i uppdatering metod som använder en slumpmässig rörelsealgoritm.
Iterera genom varje objekt och generera slumpmässiga värden för dx och dy, representerar förändringen i x- och y-koordinater. Uppdatera sedan objektets position genom att lägga till dessa värden. Här är den modifierade koden:
defuppdatering(själv, delta_tid):
för i i intervall (NUM_OBJECTS):
x, y = själv.objekt[i]
dx = random.randint(-5, 5)
dy = random.randint(-5, 5)
x += dx
y += dy
self.objects[i] = (x, y)Nedan är utgången:
Objekt som rör sig mot spelare
För att lägga till mer interaktion, gör objekten att flytta mot spelaren. Du kan uppnå detta genom att beräkna riktningsvektorn mellan objektet och spelaren och justera objektets position därefter.
För detta, beräkna skillnaderna i x- och y-koordinater mellan objektet och spelaren. Genom att normalisera dessa värden får man en riktningsvektor. Multiplicera sedan denna vektor med en hastighetsfaktor (3 i detta fall) och addera den till objektets position. Här är den uppdaterade uppdatering metod:
defuppdatering(själv, delta_tid):
för i i intervall (NUM_OBJECTS):
x, y = själv.objekt[i]
dx = self.player_x - x
dy = self.player_y - y
avstånd = math.sqrt (dx ** 2 + dy ** 2)
dx /= avstånd
dy /= avstånd
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)Nedan är utgången:
Objekt börjar röra sig när spelaren går in i omgivningen
För att lägga till ytterligare dynamik, ändra koden så att objekten börjar röra sig först när spelaren går in i sitt omgivande område. Lägg till kod för spelarens rörelse och definiera en radie inom vilken objekten blir aktiva.
defuppdatering(själv, delta_tid):
för i i intervall (NUM_OBJECTS):
x, y = själv.objekt[i]
dx = self.player_x - x
dy = self.player_y - y
avstånd = math.sqrt (dx ** 2 + dy ** 2)
om avstånd < 100: # Justera radien efter behov
dx /= avstånd
dy /= avstånd
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)Kollisionsdetektering och interaktion
Lägg nu till kollisionsdetektering mellan spelaren och objekten och definiera beteende när en kollision inträffar. Ändra uppdatering metod för att hantera kollisioner:
defuppdatering(själv, delta_tid):
för i i intervall (NUM_OBJECTS):
x, y = själv.objekt[i]
dx = self.player_x - x
dy = self.player_y - y
avstånd = math.sqrt (dx ** 2 + dy ** 2)
om avstånd < PLAYER_RADIUS + OBJECT_RADIUS:
# om en kollision inträffade, hantera den här
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif avstånd < 100:
dx /= avstånd
dy /= avstånd
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)Balanserande slumpmässighet
För att skapa en balanserad spelupplevelse är det viktigt att finjustera den slumpmässiga rörelsen och uppkomsten av objekt. Här är några exempel på hur du kan justera koden för att uppnå en bättre balans i ditt spel:
Begränsning av maximal hastighet
För att förhindra att föremål rör sig för fort kan du införa en högsta hastighetsgräns. Ändra uppdatering metod för att inkludera hastighetsbegränsningar:
defuppdatering(själv, delta_tid):
för i i intervall (NUM_OBJECTS):
x, y = själv.objekt[i]
dx = self.player_x - x
dy = self.player_y - y
avstånd = math.sqrt (dx ** 2 + dy ** 2)om avstånd < PLAYER_RADIUS + OBJECT_RADIUS:
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif avstånd < 100:
dx /= avstånd
dy /= avståndhastighet = 3# Justera hastighetsvärdet efter behov
dx = min (max (dx * hastighet, -MAX_SPEED), MAX_SPEED)
dy = min (max (dy * hastighet, -MAX_SPEED), MAX_SPEED)
x += dx
y += dy
self.objects[i] = (x, y)
Kontrollerar Spawn Rate
Du kan också styra hastigheten med vilken nya objekt leker i spelet. Justera koden för att inkludera en fördröjning mellan att skapa nya objekt:
importera tidklassMitt spel(arkad. Fönster):
def__i det__(själv, bredd, höjd):
super().__init__(bredd, höjd)
arcade.set_background_color (arcade.color. VIT)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10self.objects = []
self.last_spawn_time = time.time()defuppdatering(själv, delta_tid):
# kontrollera lekhastigheten här
om time.time() - self.last_spawn_time > SPAWN_DELAY:
om len (self.objects) < MAX_OBJECTS:
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
self.last_spawn_time = time.time()för i i intervall (len (self.objects)):
x, y = själv.objekt[i]
dx = self.player_x - x
dy = self.player_y - y
avstånd = math.sqrt (dx ** 2 + dy ** 2)om avstånd < PLAYER_RADIUS + OBJECT_RADIUS:
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif avstånd < 100:
dx /= avstånd
dy /= avstånd
x += dx * 3
y += dy * 3
self.objects[i] = (x, y)
Justera SPAWN_DELAY och MAX_OBJECTS värden för att hitta rätt balans för ditt spel. En längre fördröjning eller ett mindre maximalt antal objekt kommer att göra spelet mindre trångt. Medan en kortare fördröjning eller ett större maximum kommer att öka svårigheten.
Gör spel roligare med rörliga objekt
Att lägga till slumpmässiga rörliga föremål till spel kan förbättra den totala upplevelsen avsevärt. De introducerar oförutsägbarhet och utmaning, vilket gör spelet mer engagerande och dynamiskt. Spelare måste anpassa sig och reagera snabbt för att undvika kollisioner eller fånga föremål, och det kommer att ge en känsla av spänning och prestation.
