def controls(self):
self.__last_state = self.__state
self.__state = CONTROLS
self.clear_buttons()
self.__menu_barra = InterfaceObject(self.__background, menu_sec,-self.__bound[0] * 0.088, self.__bound[1] * 0)
inc = 2 * gunity
incs = [(0, 0), (-inc, +inc), (0, +inc), (+inc, +inc)]
pos0 = Vector2(-self.__rect[0]*0.35, -self.__rect[1]*0.24)
Inc = Vector2(self.__rect[0]*0.358, self.__rect[1]*0.38)
Incs = [(0,0),(Inc[0],0),(0,Inc[1]),Inc]
playerkeys = self.__config['players']['controls']
for i in range(4):
pos1 = pos0 + Incs[i]
InterfaceObject(self.__background, imgsnake_small[i], *pos1 + Vector2(-self.__rect[0]*0.11,0))
InterfaceObject(self.__background, jogador_titulo[i], *pos1 + Vector2(0,-self.__rect[1]*0.15))
for j in range(4):
pos = pos1 + incs[j]
imgs = [imgkeyboard[playerkeys[i][j]],imgkeyboard2[playerkeys[i][j]],imgkeyboard3[playerkeys[i][j]]]
Button(self, imgs, *pos)
Button(self, imgbutton['voltar'], -self.__rect[0]*0.35, self.__rect[1]*0.37)
def exibit_time(self):
font = font_snake
message = ['10', '9', '8', '7', '6', '5', '4', '3', '2', '1']
timer = 0
time = font.render(message[0], True, (0, 177, 11))
timeup = InterfaceObject(self.__gamebox, time, 0, -330)
timedw = InterfaceObject(self.__gamebox, time, 0, 330)
def print_message(end=False):
nonlocal timer
if end:
timeup.destroy()
timedw.destroy()
elif timer >= 10 * fps:
self.shrink_arena()
self.remove_effect(print_message)
else:
newtime = font.render(message[timer // fps], True,
(0, 177, 11))
timeup.set_img(newtime)
timedw.set_img(newtime)
timer += 1
self.add_effect(print_message)
def __init__(self, screen, gamebox, gamemap):
self.__screen = screen
self.__gamebox = gamebox
self.__command = {}
self.__players = []
self.__playerkeys = {}
self.__playeruis = []
self.__obstacles = []
self.__effects = []
self.__powerups = deque()
self.__foods = []
self.__nfood = 0
self.__bound = self.__gamebox.get_rect() // 2 - (gunity, gunity)
self.__walls = [deque() for i in range(4)]
for wall in gamemap['walls']:
params = {'img': imgwall[wall[0]], 'x': wall[1], 'y': wall[2]}
self.add_obstacle(**params)
for x in range(-30 * gunity, +30 * gunity + 1, gunity):
w1 = InterfaceObject(self.__gamebox, imgwall['H1'], x,
+15 * gunity)
w2 = InterfaceObject(self.__gamebox, imgwall['H1'], x,
-15 * gunity)
self.__walls[0].append(w1)
self.__walls[1].append(w2)
for y in range(-14 * gunity, +14 * gunity + 1, gunity):
w1 = InterfaceObject(self.__gamebox, imgwall['H1'], +30 * gunity,
y)
w2 = InterfaceObject(self.__gamebox, imgwall['H1'], -30 * gunity,
y)
self.__walls[2].append(w1)
self.__walls[3].append(w2)
class PlayerUI(InterfaceObject):
def __init__(self, master, player, x, y):
dummy_surface.convert()
dummy_surface.set_alpha(0)
super().__init__(master, dummy_surface, x, y)
self.__player = player
self.__sign = -1 if player.get_id() % 2 == 1 else +1
s1 = size + 2 * padding
self.__pbox = pg.Surface((s1, size + 2 * padding))
s2 = max_health * size + (max_health + 1) * padding
self.__hbox = pg.Surface((s2, size + 2 * padding))
self.__hbox.set_colorkey((0, 0, 0))
self.__avatar = InterfaceObject(self, self.__pbox)
self.__hearts = InterfaceObject(self, self.__hbox,
self.__sign * (s1 + s2) // 2)
self.update()
def update(self):
if self.__player.get_health() > 0:
img_avatar = self.__player.get_head().get_img()
img_avatar = pg.transform.scale(img_avatar, (size, size))
else:
img_avatar = skull
self.__pbox.fill((43, 45, 43))
self.__pbox.blit(img_avatar, (padding, padding))
self.__avatar.set_img(self.__pbox)
health = self.__player.get_health()
if health == inf:
health = self.__player.get_virtual_health()
health = int(health)
self.__hbox.fill((0, 0, 0))
for i in range(health):
x0 = 0 if self.__sign == 1 else (max_health -
1) * size + max_health * padding
self.__hbox.blit(heart, (x0 + i * self.__sign *
(size + padding), padding))
self.__hearts.set_img(self.__hbox)
def __init__(self, master, player, x, y):
dummy_surface.convert()
dummy_surface.set_alpha(0)
super().__init__(master, dummy_surface, x, y)
self.__player = player
self.__sign = -1 if player.get_id() % 2 == 1 else +1
s1 = size + 2 * padding
self.__pbox = pg.Surface((s1, size + 2 * padding))
s2 = max_health * size + (max_health + 1) * padding
self.__hbox = pg.Surface((s2, size + 2 * padding))
self.__hbox.set_colorkey((0, 0, 0))
self.__avatar = InterfaceObject(self, self.__pbox)
self.__hearts = InterfaceObject(self, self.__hbox,
self.__sign * (s1 + s2) // 2)
self.update()
def map_selection(self):
self.__last_state = self.__state
self.__state = MAP_SELECTION
self.clear_buttons()
self.__menu_barra = InterfaceObject(self.__background,menu_sec , -self.__bound[0] * 0.088, self.__bound[1] * 0)
Button(self, imgbutton['mapa_aleatorio'],-self.__bound[0] * 0.655, -self.__bound[1] * 0.70)
labels = ['eights', 'cross_and_borders','lines']
x = self.__bound[0] * 0.05
y = -self.__bound[1] * 0.6
for label in labels:
Button(self, imgbutton[label], x,y)
y += self.__bound[1] * 0.58
Button(self, imgbutton['voltar'], -self.__bound[0] * 0.67, +self.__bound[1] * 0.528)
def __init__(self, screen, x=0, y=0):
self.__pos = Vector2(x, y)
self.__screen = screen
self.__background = InterfaceObject(screen, img_menu_background)
self.__buttons = []
self.__rect = Vector2(img_menu_background.get_rect().size)
self.__bound = self.__rect/2
self.__config = {
'player_number': 0,
'players': {
'sprites': [imgsety, imgsetb, imgseto, imgsetp],
'controls': [
[pg.K_w, pg.K_a, pg.K_s, pg.K_d],
[pg.K_UP, pg.K_LEFT, pg.K_DOWN, pg.K_RIGHT],
[pg.K_y, pg.K_g, pg.K_h, pg.K_j],
[pg.K_KP8, pg.K_KP4, pg.K_KP5, pg.K_KP6]
]
},
'map': choice(list(maps.values()))
}
self.__state = QUIT
self.main()
def ending_screen(self,winners):
pg.mixer.music.load('assets/sounds/ending.wav')
pg.mixer.music.play(0)
self.__last_state = self.__state
self.__state = ENDING_SCREEN
self.__background = InterfaceObject(self.__screen,img_ending_screen)
x = -self.__rect[0] * 0.1
y = -self.__rect[1] * 0.24
delta_y = + self.__rect[1]*0.56/(self.__config['player_number'] + 1)
for i in range(self.__config['player_number']):
y = y + delta_y
InterfaceObject(self.__background,imgsnake[i],x,y)
x = self.__rect[1]*0.25
for player_id in winners:
InterfaceObject(self.__background,crown,x,-self.__rect[1] * 0.24 + (player_id + 1)*delta_y)
Button(self, imgbutton['menu_principal'], -self.__rect[0] * 0.1, self.__rect[1]*0.365)
Button(self, imgbutton['encerrar_w'], +self.__rect[0] * 0.15, self.__rect[1]*0.365)
self.menu_loop()
class MainMenu():
def __init__(self, screen, x=0, y=0):
self.__pos = Vector2(x, y)
self.__screen = screen
self.__background = InterfaceObject(screen, img_menu_background)
self.__buttons = []
self.__rect = Vector2(img_menu_background.get_rect().size)
self.__bound = self.__rect/2
self.__config = {
'player_number': 0,
'players': {
'sprites': [imgsety, imgsetb, imgseto, imgsetp],
'controls': [
[pg.K_w, pg.K_a, pg.K_s, pg.K_d],
[pg.K_UP, pg.K_LEFT, pg.K_DOWN, pg.K_RIGHT],
[pg.K_y, pg.K_g, pg.K_h, pg.K_j],
[pg.K_KP8, pg.K_KP4, pg.K_KP5, pg.K_KP6]
]
},
'map': choice(list(maps.values()))
}
self.__state = QUIT
self.main()
def get_screen(self):
return self.__screen
def main (self):
self.__last_state = self.__state
self.__state = MAIN
if self.__last_state in [QUIT, ENDING_SCREEN]:
pg.mixer.music.load('assets/sounds/intro.wav')
pg.mixer.music.play(-1)
self.clear_buttons()
labels = ['jogar','modo_pratica','controles']
x = -self.__bound[0] * 0.66
y = -self.__bound[1] * 0.70
for label in labels:
Button(self, imgbutton[label], x,y)
y += self.__bound[1] * 0.307
y += self.__bound[1] * 0.307
Button(self, imgbutton['encerrar'], -self.__bound[0] * 0.665, y)
def multijogadores(self):
self.__last_state = self.__state
self.__state = MULTIPLAYER
self.clear_buttons()
labels = ['dois_jogadores','tres_jogadores']
x = -self.__bound[0] * 0.655
y = -self.__bound[1] * 0.70
for label in labels:
Button(self, imgbutton[label], x,y)
y += self.__bound[1] * 0.307
Button(self, imgbutton['quatro_jogadores'],-self.__bound[0] * 0.664 , -self.__bound[1] * 0.086)
Button(self, imgbutton['voltar'], -self.__bound[0] * 0.67, +self.__bound[1] * 0.528)
def map_selection(self):
self.__last_state = self.__state
self.__state = MAP_SELECTION
self.clear_buttons()
self.__menu_barra = InterfaceObject(self.__background,menu_sec , -self.__bound[0] * 0.088, self.__bound[1] * 0)
Button(self, imgbutton['mapa_aleatorio'],-self.__bound[0] * 0.655, -self.__bound[1] * 0.70)
labels = ['eights', 'cross_and_borders','lines']
x = self.__bound[0] * 0.05
y = -self.__bound[1] * 0.6
for label in labels:
Button(self, imgbutton[label], x,y)
y += self.__bound[1] * 0.58
Button(self, imgbutton['voltar'], -self.__bound[0] * 0.67, +self.__bound[1] * 0.528)
def ending_screen(self,winners):
pg.mixer.music.load('assets/sounds/ending.wav')
pg.mixer.music.play(0)
self.__last_state = self.__state
self.__state = ENDING_SCREEN
self.__background = InterfaceObject(self.__screen,img_ending_screen)
x = -self.__rect[0] * 0.1
y = -self.__rect[1] * 0.24
delta_y = + self.__rect[1]*0.56/(self.__config['player_number'] + 1)
for i in range(self.__config['player_number']):
y = y + delta_y
InterfaceObject(self.__background,imgsnake[i],x,y)
x = self.__rect[1]*0.25
for player_id in winners:
InterfaceObject(self.__background,crown,x,-self.__rect[1] * 0.24 + (player_id + 1)*delta_y)
Button(self, imgbutton['menu_principal'], -self.__rect[0] * 0.1, self.__rect[1]*0.365)
Button(self, imgbutton['encerrar_w'], +self.__rect[0] * 0.15, self.__rect[1]*0.365)
self.menu_loop()
def controls(self):
self.__last_state = self.__state
self.__state = CONTROLS
self.clear_buttons()
self.__menu_barra = InterfaceObject(self.__background, menu_sec,-self.__bound[0] * 0.088, self.__bound[1] * 0)
inc = 2 * gunity
incs = [(0, 0), (-inc, +inc), (0, +inc), (+inc, +inc)]
pos0 = Vector2(-self.__rect[0]*0.35, -self.__rect[1]*0.24)
Inc = Vector2(self.__rect[0]*0.358, self.__rect[1]*0.38)
Incs = [(0,0),(Inc[0],0),(0,Inc[1]),Inc]
playerkeys = self.__config['players']['controls']
for i in range(4):
pos1 = pos0 + Incs[i]
InterfaceObject(self.__background, imgsnake_small[i], *pos1 + Vector2(-self.__rect[0]*0.11,0))
InterfaceObject(self.__background, jogador_titulo[i], *pos1 + Vector2(0,-self.__rect[1]*0.15))
for j in range(4):
pos = pos1 + incs[j]
imgs = [imgkeyboard[playerkeys[i][j]],imgkeyboard2[playerkeys[i][j]],imgkeyboard3[playerkeys[i][j]]]
Button(self, imgs, *pos)
Button(self, imgbutton['voltar'], -self.__rect[0]*0.35, self.__rect[1]*0.37)
def update(self):
if self.__state == MAIN:
# multiplayer
if self.__buttons[0].check_hover():
self.multijogadores()
# single player
elif self.__buttons[1].check_hover():
self.__config['player_number'] = 1
self.map_selection()
# controles
elif self.__buttons[2].check_hover():
self.controls()
# encerrar
elif self.__buttons[3].check_hover():
self.__state = QUIT
elif self.__state == MULTIPLAYER:
if self.__buttons[0].check_hover():
self.__config['player_number'] = 2
self.map_selection()
elif self.__buttons[1].check_hover():
self.__config['player_number'] = 3
self.map_selection()
elif self.__buttons[2].check_hover():
self.__config['player_number'] = 4
self.map_selection()
elif self.__buttons[3].check_hover():
self.main()
elif self.__state == MAP_SELECTION:
# mapa aleatorio
if self.__buttons[0].check_hover():
self.__config['map'] = choice(list(maps.values()))
self.__state = QUIT
# eights
elif self.__buttons[1].check_hover():
self.__config['map'] = maps['eights']
self.__state = QUIT
# cross and borders
elif self.__buttons[2].check_hover():
self.__config['map'] = maps['cross_and_borders']
self.__state = QUIT
# lines
elif self.__buttons[3].check_hover():
self.__config['map'] = maps['lines']
self.__state = QUIT
# voltar
elif self.__buttons[4].check_hover():
self.__config['player_number'] = 0
self.__menu_barra.destroy()
if self.__last_state == MULTIPLAYER:
self.multijogadores()
elif self.__last_state == MAIN:
self.main()
elif self.__state == ENDING_SCREEN:
# menu principal
if self.__buttons[0].check_hover():
self.__config['player_number'] = 0
self.__config['map'] = choice(list(maps.values()))
self.__background.destroy()
self.__background = InterfaceObject(self.__screen, img_menu_background)
self.main()
# encerrar
elif self.__buttons[1].check_hover():
self.__config['player_number'] = 0
self.__state = QUIT
elif self.__state == CONTROLS:
if self.__buttons[16].check_hover():
self.__background.remove_all_slaves()
self.main()
else:
for i in range(16):
if self.__buttons[i].check_hover():
n = i//4
k = i % 4
controls = self.__config['players']['controls']
key = get_key()
assigned = False
for a in range(len(controls)):
for b in range(4):
if key == controls[a][b]:
assigned = True
n1 = a
k1 = b
if not key:
self.__config['player_number'] = 0
self.__state = QUIT
elif assigned:
key1 = controls[n][k]
controls[n1][k1] = key1
imgs = [imgkeyboard[key1],imgkeyboard2[key1],imgkeyboard3[key1]]
self.__buttons[n1*4 + k1].set_imglist(imgs)
controls[n][k] = key
imgs = [imgkeyboard[key],imgkeyboard2[key],imgkeyboard3[key]]
self.__buttons[i].set_imglist(imgs)
elif key in imgkeyboard.keys():
controls[n][k] = key
imgs = [imgkeyboard[key],imgkeyboard2[key],imgkeyboard3[key]]
self.__buttons[i].set_imglist(imgs)
def add_button(self, button):
self.__buttons.append(button)
def clear_buttons(self):
for button in self.__buttons:
button.destroy()
self.__buttons.clear()
def menu_loop(self):
clock = Clock()
while self.__state != QUIT:
self.update()
clock.tick(30)
self.__screen.update()
for event in pg.event.get():
if event.type == pg.QUIT:
self.__config['player_number'] = 0
self.__state = QUIT
self.clear_buttons()
self.__background.destroy()
return self.__config
def update(self):
if self.__state == MAIN:
# multiplayer
if self.__buttons[0].check_hover():
self.multijogadores()
# single player
elif self.__buttons[1].check_hover():
self.__config['player_number'] = 1
self.map_selection()
# controles
elif self.__buttons[2].check_hover():
self.controls()
# encerrar
elif self.__buttons[3].check_hover():
self.__state = QUIT
elif self.__state == MULTIPLAYER:
if self.__buttons[0].check_hover():
self.__config['player_number'] = 2
self.map_selection()
elif self.__buttons[1].check_hover():
self.__config['player_number'] = 3
self.map_selection()
elif self.__buttons[2].check_hover():
self.__config['player_number'] = 4
self.map_selection()
elif self.__buttons[3].check_hover():
self.main()
elif self.__state == MAP_SELECTION:
# mapa aleatorio
if self.__buttons[0].check_hover():
self.__config['map'] = choice(list(maps.values()))
self.__state = QUIT
# eights
elif self.__buttons[1].check_hover():
self.__config['map'] = maps['eights']
self.__state = QUIT
# cross and borders
elif self.__buttons[2].check_hover():
self.__config['map'] = maps['cross_and_borders']
self.__state = QUIT
# lines
elif self.__buttons[3].check_hover():
self.__config['map'] = maps['lines']
self.__state = QUIT
# voltar
elif self.__buttons[4].check_hover():
self.__config['player_number'] = 0
self.__menu_barra.destroy()
if self.__last_state == MULTIPLAYER:
self.multijogadores()
elif self.__last_state == MAIN:
self.main()
elif self.__state == ENDING_SCREEN:
# menu principal
if self.__buttons[0].check_hover():
self.__config['player_number'] = 0
self.__config['map'] = choice(list(maps.values()))
self.__background.destroy()
self.__background = InterfaceObject(self.__screen, img_menu_background)
self.main()
# encerrar
elif self.__buttons[1].check_hover():
self.__config['player_number'] = 0
self.__state = QUIT
elif self.__state == CONTROLS:
if self.__buttons[16].check_hover():
self.__background.remove_all_slaves()
self.main()
else:
for i in range(16):
if self.__buttons[i].check_hover():
n = i//4
k = i % 4
controls = self.__config['players']['controls']
key = get_key()
assigned = False
for a in range(len(controls)):
for b in range(4):
if key == controls[a][b]:
assigned = True
n1 = a
k1 = b
if not key:
self.__config['player_number'] = 0
self.__state = QUIT
elif assigned:
key1 = controls[n][k]
controls[n1][k1] = key1
imgs = [imgkeyboard[key1],imgkeyboard2[key1],imgkeyboard3[key1]]
self.__buttons[n1*4 + k1].set_imglist(imgs)
controls[n][k] = key
imgs = [imgkeyboard[key],imgkeyboard2[key],imgkeyboard3[key]]
self.__buttons[i].set_imglist(imgs)
elif key in imgkeyboard.keys():
controls[n][k] = key
imgs = [imgkeyboard[key],imgkeyboard2[key],imgkeyboard3[key]]
self.__buttons[i].set_imglist(imgs)
def game_loop(self):
pg.mixer.music.load('assets/sounds/music.wav')
pg.mixer.music.play(-1)
pg.mouse.set_visible(False)
background = img_wait_background.convert()
background.set_alpha(180)
background = InterfaceObject(self.__screen, background, 0, 0)
inc = 2 * gunity
incs = [(0, 0), (-inc, +inc), (0, +inc), (+inc, +inc)]
pos0 = -self.__bound / 2 - (0, inc)
order = [0, 1, 3, 2]
for i in range(4):
if order[i] in self.__playerkeys.keys():
for j in range(4):
InterfaceObject(
background,
imgkeyboard[self.__playerkeys[order[i]][j]],
*(pos0 + incs[j]))
pos0[i % 2] *= -1
font = font_barbarian
messages = ['Ready>', 'Set..>', 'Fight>']
for i in range(3):
segundosIMG = font.render(messages[i], True, (134, 177, 11))
segundosIMG = InterfaceObject(self.__screen, segundosIMG, 0, 0)
self.__screen.update()
pg.time.wait(1000)
segundosIMG.destroy()
background.destroy()
del background, pos0, inc, incs, font, messages, i, segundosIMG
pg.time.set_timer(SHRINK_ARENA, 90000 - 10000)
pg.key.get_pressed()
for player in self.__players:
player.clear_command_queue()
running = True
clock = Clock()
winners = []
while running:
self.__screen.update()
clock.tick(fps)
self.generate_powerups()
# Resolução da fila de eventos
for event in pg.event.get():
if event.type == pg.QUIT:
running = False
elif event.type == pg.KEYDOWN:
if event.key == pg.K_ESCAPE:
running = False
try:
self.__command[event.key]()
except KeyError:
pass # Chave não associada a nenhum comando
elif event.type == SHRINK_ARENA:
self.exibit_time()
if self.__bound.elementwise() > 3 * gunity:
pg.time.set_timer(SHRINK_ARENA, 10000)
else:
pg.time.set_timer(SHRINK_ARENA, 0)
# Fila de eventos
# Efeitos na tela
for effect in self.__effects:
effect()
# Checagem de colisões fatais
dead_players = []
for player in self.__players:
head = player.get_head()
for other in self.__players:
if other.collision(head):
player.dec_health()
for obstacle in self.__obstacles:
if obstacle.collision(head):
player.dec_health()
pos = head.get_pos()
abs_pos = abs(pos.elementwise())
if abs_pos.x > self.__bound.x + gunity or abs_pos.y > self.__bound.y + gunity:
player.set_health(0)
elif abs_pos.x > self.__bound.x or abs_pos.y > self.__bound.y:
player.dec_health()
player.clear_command_queue()
spd = head.get_spd()
angle = choice([90, -90])
pos = pos + spd.rotate(angle)
abs_pos = abs(pos.elementwise())
if (abs_pos.elementwise() > self.__bound
or abs_pos.x > self.__bound.x + gunity
or abs_pos.y > self.__bound.y + gunity):
head.set_spd(spd.rotate(-angle))
else:
head.set_spd(spd.rotate(angle))
if player.get_health() <= 0:
dead_players.append(player)
for player in dead_players:
self.remove_player(player)
if dead_players and len(self.__players) < 2:
if len(self.__players) == 1:
winners.append(self.__players[0].get_id())
else:
maior = 0
for player in dead_players:
if player.get_pontos() > maior:
maior = player.get_pontos()
for player in dead_players:
if player.get_pontos() == maior:
winners.append(player.get_id())
running = False
# Colisões fatais
# Atualização das posições dos jogadores remanescentes
for player in self.__players:
player.update()
# Atualização das interfaces dos jogadores
for UI in self.__playeruis:
UI.update()
# Checagem de coleta de power-ups
catched_pups = []
catched_foods = []
for player in self.__players:
head = player.get_head()
for pup in self.__powerups:
if pup.collision(head):
pup.catch(player, self)
catched_pups.append(pup)
for food in self.__foods:
if food.collision(head):
food.catch(player, self)
catched_foods.append(food)
for pup in catched_pups:
pup.destroy()
self.__powerups.remove(pup)
for food in catched_foods:
food.destroy()
self.__foods.remove(food)
self.__nfood -= 1
# Coleta de power-ups
# Checagem de timer de power-ups
for pup in self.__powerups:
pup.inc_timer()
if self.__powerups and self.__powerups[0].get_timer() == 10 * fps:
self.__powerups.popleft().destroy()
# Timer de power-ups
pg.time.set_timer(SHRINK_ARENA, 0)
self.clear_effects()
self.__gamebox.destroy()
pg.mouse.set_visible(True)
return winners
from game import pg, Screen, GameObject, InterfaceObject, Player, GameEngine
from game.assets import imgsetb, imgsety, maps, imgwall
from game.constants import gspeed, gunity
screen = Screen()
background = pg.transform.scale(pg.image.load('assets/img/background.jpg'),
(60 * gunity, 30 * gunity))
arena = InterfaceObject(screen, background)
game = GameEngine(screen, arena, maps['eights'])
game.add_player(imgsety, 1, -200, 0, [pg.K_w, pg.K_a, pg.K_s, pg.K_d])
winners = game.game_loop()
print(winners)