Torne seus jogos de fliperama ainda mais divertidos e emocionantes adicionando objetos em movimento aleatórios.
Objetos em movimento aleatório podem trazer emoção e imprevisibilidade aos jogos. Isso os torna mais envolventes e desafiadores para os jogadores. A biblioteca Arcade do Python fornece uma maneira simples e eficiente de incorporar objetos em movimento aleatórios em seus jogos.
Crie um jogo simples
Antes de começar, certifique-se de ter pip instalado no seu dispositivo. Use este comando para instalar o videogames biblioteca:
pip instalar fliperamaDepois disso, crie uma janela usando o videogames. Janela class e defina a cor de fundo como branco.
O código usado neste artigo está disponível neste Repositório GitHub e é gratuito para você usar sob a licença do MIT.
Defina a posição do jogador no meio da tela horizontalmente e adicione uma pequena distância do topo. Você pode controlar o movimento do jogador usando as setas do teclado.
Aqui está o código para o nosso jogo básico:
importar videogamesSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15aulaMeu jogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
super().__init__(largura, altura)
arcade.set_background_color (arcade.color. BRANCO)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10defon_draw(auto):
arcade.start_render()
arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. AZUL)defatualizar(auto, delta_time):
passardefon_key_press(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
self.player_x -= 5
elif chave == arcade.key. CERTO:
self.player_x += 5
se __nome__ == "__principal__":
jogo = MeuJogo (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
Adicionando vários objetos
Para adicionar objetos aleatórios em movimento ao seu jogo, crie uma lista para armazenar as posições do objeto e atualize-as a cada quadro. Você também pode usar sprites como objetos.
No código do jogo, adicione uma lista chamada objetos para armazenar as posições dos objetos móveis aleatórios. Depois disso, gere o número de objetos (NUM_OBJECTS) com coordenadas x e y aleatórias dentro dos limites da tela. Os objetos são desenhados como círculos vermelhos usando o arcade.draw_circle_filled função.
importar videogames
importar aleatórioSCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10aulaMeu jogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
super().__init__(largura, altura)
arcade.set_background_color (arcade.color. BRANCO)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10self.objects = []
para _ em intervalo (NUM_OBJECTS):
x = random.randint(0, SCREEN_WIDTH)
y = random.randint(0, SCREEN_HEIGHT)
self.objects.append((x, y))defon_draw(auto):
arcade.start_render()
arcade.draw_circle_filled (self.player_x, self.player_y, PLAYER_RADIUS, arcade.color. AZUL)para obj em auto.objetos:
x, y = obj
arcade.draw_circle_filled (x, y, OBJECT_RADIUS, arcade.color. VERMELHO)defatualizar(auto, delta_time):
passardefon_key_press(auto, chave, modificadores):
se chave == arcade.key. ESQUERDA:
self.player_x -= 5
elif chave == arcade.key. CERTO:
self.player_x += 5
se __nome__ == "__principal__":
jogo = MeuJogo (SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run()
Abaixo está a saída:
Implementando Algoritmo de Movimento Aleatório
Para fazer os objetos se moverem aleatoriamente, atualize suas posições no atualizar usando um algoritmo de movimento aleatório.
Percorra cada objeto e gere valores aleatórios para dx e morrer, representando a alteração nas coordenadas x e y. Em seguida, atualize a posição do objeto adicionando esses valores. Aqui está o código modificado:
defatualizar(auto, delta_time):
para eu em intervalo (NUM_OBJECTS):
x, y = self.objects[i]
dx = random.randint(-5, 5)
dy = random.randint(-5, 5)
x += d x
y += dy
self.objects[i] = (x, y)Abaixo está a saída:
Objetos se movendo em direção ao jogador
Para adicionar mais interação, faça os objetos se moverem em direção ao jogador. Você pode conseguir isso calculando o vetor de direção entre o objeto e o jogador e ajustando a posição do objeto de acordo.
Para isso, calcule as diferenças nas coordenadas x e y entre o objeto e o jogador. Ao normalizar esses valores, você obtém um vetor de direção. Em seguida, multiplique este vetor por um fator de velocidade (3 neste caso) e adicione-o à posição do objeto. aqui está o atualizado atualizar método:
defatualizar(auto, delta_time):
para eu em intervalo (NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distância = math.sqrt (dx ** 2 + dy ** 2)
dx /= distância
dy /= distância
x += d x * 3
y += dy * 3
self.objects[i] = (x, y)Abaixo está a saída:
Objetos começam a se mover quando o jogador entra ao redor
Para adicionar mais dinâmica, modifique o código para que os objetos comecem a se mover apenas quando o jogador entrar na área circundante. Adicione o código para o movimento do jogador e definir um raio dentro do qual os objetos se tornam ativos.
defatualizar(auto, delta_time):
para eu em intervalo (NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distância = math.sqrt (dx ** 2 + dy ** 2)
se distância < 100: # Ajuste o raio conforme necessário
dx /= distância
dy /= distância
x += d x * 3
y += dy * 3
self.objects[i] = (x, y)Detecção de Colisão e Interação
Agora, adicione detecção de colisão entre o jogador e os objetos e defina o comportamento quando ocorrer uma colisão. Modifique o atualizar método para lidar com colisões:
defatualizar(auto, delta_time):
para eu em intervalo (NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distância = math.sqrt (dx ** 2 + dy ** 2)
se distância < PLAYER_RADIUS + OBJECT_RADIUS:
# se ocorreu colisão, manuseie aqui
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif distância < 100:
dx /= distância
dy /= distância
x += d x * 3
y += dy * 3
self.objects[i] = (x, y)Equilíbrio da aleatoriedade
Para criar uma experiência de jogo equilibrada, é importante ajustar o movimento aleatório e a geração de objetos. Aqui estão alguns exemplos de como você pode ajustar o código para obter um melhor equilíbrio em seu jogo:
Limitando a velocidade máxima
Para evitar que os objetos se movam muito rápido, você pode introduzir um limite máximo de velocidade. Modifique o atualizar método para incluir restrições de velocidade:
defatualizar(auto, delta_time):
para eu em intervalo (NUM_OBJECTS):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distância = math.sqrt (dx ** 2 + dy ** 2)se distância < PLAYER_RADIUS + OBJECT_RADIUS:
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif distância < 100:
dx /= distância
dy /= distânciavelocidade = 3# Ajuste o valor da velocidade conforme necessário
dx = min (max (dx * velocidade, -MAX_SPEED), MAX_SPEED)
dy = min (max (dy * velocidade, -MAX_SPEED), MAX_SPEED)
x += d x
y += dy
self.objects[i] = (x, y)
Controlando a taxa de geração
Você também pode controlar a taxa na qual novos objetos aparecem no jogo. Ajuste o código para incluir um atraso entre a geração de novos objetos:
importar tempoaulaMeu jogo(videogames. Janela):
def__iniciar__(auto, largura, altura):
super().__init__(largura, altura)
arcade.set_background_color (arcade.color. BRANCO)self.player_x = SCREEN_WIDTH // 2
self.player_y = PLAYER_RADIUS + 10self.objects = []
self.last_spawn_time = time.time()defatualizar(auto, delta_time):
# controle a taxa de desova aqui
se time.time() - self.last_spawn_time > SPAWN_DELAY:
se len (self.objects) < MAX_OBJECTS:
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
self.last_spawn_time = time.time()para eu em range (len (self.objects)):
x, y = self.objects[i]
dx = self.player_x - x
dy = self.player_y - y
distância = math.sqrt (dx ** 2 + dy ** 2)se distância < PLAYER_RADIUS + OBJECT_RADIUS:
self.objects.pop (i)
self.objects.append((random.randint(0, SCREEN_WIDTH), random.randint(0, SCREEN_HEIGHT)))
elif distância < 100:
dx /= distância
dy /= distância
x += d x * 3
y += dy * 3
self.objects[i] = (x, y)
Ajusta a SPAWN_DELAY e MAX_OBJECTS valores para encontrar o equilíbrio certo para o seu jogo. Um atraso maior ou um número máximo menor de objetos tornará o jogo menos lotado. Considerando que, um atraso mais curto ou um máximo maior aumentará a dificuldade.
Torne os jogos mais divertidos usando objetos em movimento
Adicionar objetos em movimento aleatórios aos jogos pode melhorar significativamente a experiência geral. Eles introduzem imprevisibilidade e desafio, tornando a jogabilidade mais envolvente e dinâmica. Os jogadores terão que se adaptar e reagir rapidamente para evitar colisões ou pegar objetos, e isso proporcionará uma sensação de emoção e realização.
