def __init__(self, addr, lvl_map, SCREEN):
Client.__init__(self, addr)
self._number_player = int(self._get_number_player())
'''
Iniciando el display antes de cargar el tilemap
'''
self.WIDTH, self.HEIGHT = SCREEN.get_size()
self.SCREEN = SCREEN
#self.SCREEN = pg.display.set_mode((self.WIDTH,self.HEIGHT))
pg.display.set_icon(pg.image.load(ROUTE('lemon.ico')))
'''
TILEMAP
'''
self.tile = TileMap(lvl_map)
self.tile_image = self.tile.make_map()
self.tile_rect = self.tile_image.get_rect()
self._players = {}
self.POSITIONS = {}
'''
Cargando los jugadores y rectangulos
'''
self._load()
pg.display.set_caption(
'Lemon Tank - Client {value} '.format(value=self._number_player))
self.player = Player(self.POSITIONS[self._number_player])
self.player._num_player = self._number_player
self._send(self.player)
if self._data:
self._players = self._data
'''
CAMERA
'''
self.camera = Camera(
self.tile.WIDTH,
self.tile.HEIGHT,
(self.WIDTH, self.HEIGHT),
)
self._bullets = pg.sprite.Group()
def get_player(self):
# determines where is the player and returning it
player = None
for i, row in enumerate(self.maze):
for j, col in enumerate(row):
if col == "1":
player = Player(j, i)
return player
def main():
"""the main function"""
pygame.init()
window_surface = pygame.display.set_mode((800, 600))
pygame.display.set_caption('2020爭霸戰')
# /Users/anthelope/Documents/GitHub/win_the_2020_election/img/main/start.png
background = pygame.image.load(os.path.join("img","main","start.png"))
background = pygame.transform.scale(background, (800, 600))
background.convert()
choose_char = pygame.image.load(os.path.join("img","main","choose_role.png"))
choose_char = pygame.transform.scale(choose_char, (800, 600))
choose_char.convert()
stage_complete = pygame.image.load(os.path.join("img","else","collect_success.png"))
stage_complete = pygame.transform.scale(stage_complete, (800, 600))
stage_complete.convert()
while True:
button_main = start(window_surface, background)
if button_main == "start":
char = choose_player(window_surface, choose_char)
player = Player(0)
for i in range(5):
story = Intelude(window_surface, char, i, 0)
story.run()
stage = Stage(window_surface, char, i)
stage.run(player)
result = stage.get_result()
if not result:
fail(window_surface)
break
window_surface.blit(stage_complete, (0, 0))
pygame.display.update()
time.sleep(3)
player.stage_clear()
story = Intelude(window_surface, char, i, 1)
story.run()
elif button_main == "instruction":
rule(window_surface)
class Game:
def __init__(self):
pygame.init()
self.window = Window()
self.player = Player(3, 3, consts.S_PLAYER_FRONT, self)
def main_loop(self):
running = True
while running:
self.window.draw_game()
self.player.draw_self()
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_w:
self.player.move(0, -1)
if event.key == pygame.K_s:
self.player.move(0, 1)
if event.key == pygame.K_a:
self.player.move(-1, 0)
if event.key == pygame.K_d:
self.player.move(1, 0)
pygame.display.flip()
def play(algorithm):
fps= 7
time = pygame.time.Clock()
loop = True
game_time = 0
time_count = 1/ fps
begin_node = grid_list[0][0]
player = Player(begin_node, (200, 0, 0))
objective = grid_list[-1][-1]
menu_button_rect = pygame.Rect(10, 440, 100, 30)
menu_button = Button(menu_button_rect, text= '< MENU')
while loop:
window.fill((0, 0, 0))
mx, my = pygame.mouse.get_pos()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
player.set_dir(event)
if menu_button.click(event, mx, my):
loop = False
if player.actual == objective:
draw_text('YOU WIN!', window, 30, (200, 200, 200), (window.get_rect().center[0], 440))
else:
game_time += time_count
algorithm.draw_grid(window, grid_list)
menu_button.draw(window)
draw_text('Time: ' + str(round(game_time, 2)), window, 25, (200, 200, 200), (570, 440))
player.move(grid_list)
player.draw(window)
pygame.draw.rect(window, (0, 0, 0), objective.rect, border_radius= 20)
pygame.display.update()
time.tick(fps)
from werkzeug.utils import secure_filename
STATIC_FOLDER = './static'
UPLOAD_FOLDER = './static/uploads'
LOG_FOLDER = './static/logs'
WAV_FOLDER = './static/wav_files'
SCRIPT_FOLDER = './scripts'
ALLOWED_EXTENSIONS = set(['wav'])
app = Flask(__name__)
app.config['STATIC_FOLDER'] = STATIC_FOLDER
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['LOG_FOLDER'] = LOG_FOLDER
app.config['WAV_FOLDER'] = WAV_FOLDER
app.config['SCRIPT_FOLDER'] = SCRIPT_FOLDER
app.config['PLAYER'] = Player()
app.config['ANALYZER'] = AudioAnalyzer()
app.config['SPECTROGRAM'] = Spectrogram()
os.system('mkdir -p ' + app.config['LOG_FOLDER'])
os.system('mkdir -p ' + app.config['UPLOAD_FOLDER'])
@app.route('/')
@app.route('/index')
def index():
return render_template('index.html')
@app.route('/upload', methods=['GET', 'POST'])
def upload():
class Game(Client):
def __init__(self, addr, lvl_map, SCREEN):
Client.__init__(self, addr)
self._number_player = int(self._get_number_player())
'''
Iniciando el display antes de cargar el tilemap
'''
self.WIDTH, self.HEIGHT = SCREEN.get_size()
self.SCREEN = SCREEN
#self.SCREEN = pg.display.set_mode((self.WIDTH,self.HEIGHT))
pg.display.set_icon(pg.image.load(ROUTE('lemon.ico')))
'''
TILEMAP
'''
self.tile = TileMap(lvl_map)
self.tile_image = self.tile.make_map()
self.tile_rect = self.tile_image.get_rect()
self._players = {}
self.POSITIONS = {}
'''
Cargando los jugadores y rectangulos
'''
self._load()
pg.display.set_caption(
'Lemon Tank - Client {value} '.format(value=self._number_player))
self.player = Player(self.POSITIONS[self._number_player])
self.player._num_player = self._number_player
self._send(self.player)
if self._data:
self._players = self._data
'''
CAMERA
'''
self.camera = Camera(
self.tile.WIDTH,
self.tile.HEIGHT,
(self.WIDTH, self.HEIGHT),
)
self._bullets = pg.sprite.Group()
#self._text_damage = Text((self.WIDTH//2,self.HEIGHT),f'Damage: {self.player._damage} %')
def _damage(self):
return self.player._damage
def _load(self):
#self._bricks= []
self._bricks = pg.sprite.Group()
for tile_object in self.tile.tmxdata.objects:
if tile_object.name == 'player':
self.POSITIONS[tile_object.id] = (tile_object.x, tile_object.y)
elif tile_object.name == 'brick':
self._bricks.add(
Brick(tile_object.x, tile_object.y, tile_object.width,
tile_object.height))
#self._bricks = np.array(self._bricks)
def update(self):
self.camera.update(self.player)
'''
Si self._data no está vacio,
actualizar self._players
'''
if self._data:
self._players = self._data
else:
pass
for i in self._players.keys():
player = self._players[i]
#player.update()
if player._fire == True:
self._bullets.add(self._add_obj(Bullet, player))
player._fire == False
for bullet in self._bullets:
self._collided_bullet(bullet)
bullet.update()
self._collided_bullet_with_player(bullet)
self._collided_player(self.player)
if self.player._fire == True:
self._bullets.add(self._add_obj(Bullet, self.player))
self.player._fire = False
self._move()
self._send(self.player)
sprites = pg.sprite.groupcollide(self._bricks, self._bullets, 1, 0)
if sprites:
for i in sprites.keys():
for bullet in sprites[i]:
bullet.explosion = True
sprites = {}
def _move(self):
key = pg.key.get_pressed()
if key[pg.K_d]:
self.player._rotate(-1, TANK[self._number_player][0])
self.player._angle_cannon, self.player._rect_cannon = self.player.rotate(
-1, self.player._angle_cannon, TANK[self._number_player][1],
self.player._rect_cannon)
elif key[pg.K_a]:
self.player._rotate(1, TANK[self._number_player][0])
self.player._angle_cannon, self.player._rect_cannon = self.player.rotate(
1, self.player._angle_cannon, TANK[self._number_player][1],
self.player._rect_cannon)
radians = math.radians(self.player._angle)
self.player.vlx = self.player._VL * -math.sin(radians)
self.player.vly = self.player._VL * -math.cos(radians)
if key[pg.K_w]:
self.player.rect.centerx += self.player.vlx
self.player.rect.centery += self.player.vly
if key[pg.K_s]:
self.player.rect.centerx -= self.player.vlx
self.player.rect.centery -= self.player.vly
self.player._rect_interno.center = self.player.rect.center
self.player._rect_cannon.center = self.player._rect_interno.center
if key[pg.K_i]:
self.player._angle_cannon, self.player._rect_cannon = self.player.rotate(
-1, self.player._angle_cannon, TANK[self._number_player][1],
self.player._rect_cannon)
elif key[pg.K_p]:
self.player._angle_cannon, self.player._rect_cannon = self.player.rotate(
1, self.player._angle_cannon, TANK[self._number_player][1],
self.player._rect_cannon)
if key[pg.K_o]:
self.player._fire = True
def draw(self):
self.SCREEN.blit(self.tile_image,
self.camera.apply_rect(self.tile_rect))
for i in self._players.keys():
player = self._players[i]
tank = player._draw(TANK[player._num_player][0], player._angle)
cannon = player._draw(TANK[player._num_player][1],
player._angle_cannon)
self.SCREEN.blit(tank, self.camera.apply(player))
self.SCREEN.blit(cannon,
self.camera.apply_rect(player._rect_cannon))
for brick in self._bricks:
self.SCREEN.blit(brick.image, self.camera.apply(brick))
'''
Dibujando el tank y el cannon por separado
'''
tank = self.player._draw(TANK[self._number_player][0],
self.player._angle)
cannon = self.player._draw(TANK[self._number_player][1],
self.player._angle_cannon)
self.SCREEN.blit(tank, self.camera.apply(self.player))
self.SCREEN.blit(cannon,
self.camera.apply_rect(self.player._rect_cannon))
'''
Debugenado los rectangulos
'''
pg.draw.rect(self.SCREEN, (0, 100, 0),
self.camera.apply_rect(self.player._rect_interno), 1)
pg.draw.rect(self.SCREEN, (100, 0, 0),
self.camera.apply_rect(self.player._rect_cannon), 1)
for bullet in self._bullets:
self.SCREEN.blit(bullet.image, self.camera.apply(bullet))
def _collided_player(self, player):
if player.rect.left <= 0:
player.rect.left = 0
elif player.rect.right >= self.tile.WIDTH:
player.rect.right = self.tile.WIDTH
if player.rect.top <= 0:
player.rect.top = 0
elif player.rect.bottom >= self.tile.HEIGHT:
player.rect.bottom = self.tile.HEIGHT
def _add_obj(self, Object, player):
position = (player._rect_cannon.center)
return Object(position, player._angle_cannon, player._num_player)
def _collided_bullet(self, bullet):
if bullet.rect.left <= 32 or bullet.rect.right >= (self.tile.WIDTH -
32):
if bullet._done != True:
bullet.explosion = True
if bullet.rect.top <= 32 or bullet.rect.bottom >= (self.tile.HEIGHT -
32):
if bullet._done != True:
bullet.explosion = True
def _collided_bullet_with_player(self, bullet):
if self._number_player != bullet._num_player:
if self.player._rect_interno.colliderect(bullet.rect):
self.player._damage += 2.5
bullet.kill()
else:
for i in self._players.keys():
player = self._players[i]
if player._num_player != bullet._num_player:
if player._rect_interno.colliderect(bullet.rect):
bullet.explosion = True
break
def _collided_object_with_player(self, object):
if self.player._rect_interno.colliderect(object.rect):
if self.player.rect.left <= object.rect.left:
self.player.rect.left = object.rect.left
elif self.player.rect.right >= object.rect.right:
self.player.rect.right = object.rect.left
if self.player.rect.top <= object.rect.top:
self.player.rect.top = object.rect.top
elif self.player.rect.bottom >= object.rect.bottom:
self.player.rect.bottom = object.rect.bottom
from scripts.player import Player
from scripts.websockets import Sock
from quart import Quart, jsonify, render_template, request, websocket, render_template_string
from PyLog import Log, Logger
from bs4 import BeautifulSoup
from user_agents import parse
import json
Logger.level = 5
devices = {}
database = dataset.connect(
f"sqlite:///data.db?check_same_thread=False")
app = Quart(__name__)
socket = Sock(app)
player = Player(app)
@socket.on("test")
def test(data):
"""."""
Log(data)
@socket.on("test1")
def test(data):
"""."""
Log(data)
# @app.route("/search")
# @app.websocket('/search')
# def youtube_search(args=None):
# Log(args)
def __init__(self):
pygame.init()
self.window = Window()
self.player = Player(3, 3, consts.S_PLAYER_FRONT, self)
MENU = pygame.transform.scale(MENU, (LARGURA, ALTURA))
PLAY = pygame.image.load('imagens/menus/menu/play.jpg')
GAME_OVER = pygame.image.load('imagens/menus/game_over/game_over.jpg')
VOLTAR = pygame.image.load('imagens/menus/game_over/voltar.jpg')
GANHOU = pygame.image.load('imagens/menus/ganhar/wins.jpg')
VOLTAR_GANHOU = pygame.image.load('imagens/menus/ganhar/voltar_ganhou.jpg')
SAIR_GANHOU = pygame.image.load('imagens/menus/ganhar/sair_ganhou.jpg')
SAIR_MENU = pygame.image.load('imagens/menus/menu/sair_menu.jpg')
SAIR_GAMEOVER = pygame.image.load('imagens/menus/game_over/sair_gameover.jpg')
PLAY2 = pygame.image.load('imagens/menus/menu/2play.jpg')
CREDITOS = pygame.image.load('imagens/menus/menu/creditos.jpg')
#inicializando grupos e instanciando as classes
player_grupo2 = pygame.sprite.Group()
player_grupo1 = pygame.sprite.Group()
player = Player('imagens/players/ferro.png')
player2 = Player('imagens/players/capitao.png')
player_grupo2.add(player2)
player_grupo1.add(player)
item_grupo = pygame.sprite.Group()
item_grupo2 = pygame.sprite.Group()
item = Item('imagens/itens/gameBoy.png')
item2 = Item('imagens/itens/gameBoy2.png')
item_grupo.add(item)
item_grupo2.add(item2)
inimigo_grupo = pygame.sprite.Group()
inimigo = Inimigo('imagens/inimigos/mum.png', 5)
inimigo2 = Inimigo('imagens/inimigos/dragao.png', 3)
inimigo3 = Inimigo('imagens/inimigos/mago.png', 4)
def __init__(self):
pygame.init() #inicializa o pygame
self.game_start = True # variavel que comanda se o jogo comeca ou nao
self.window_width = 1200 # largura da janela
self.window_height = 600 # altura da janela
self.window = pygame.display.set_mode(
(self.window_width, self.window_height
)) # cria a janela passando a largura e a altura como parametros
self.background = pygame.image.load(
"img/background.jpg") # pega a imagem de background
self.background = pygame.transform.scale(
self.background,
(self.window_width, self.window_height
)) # defini um width e um height para imagem do background
# Player
self.player_group = pygame.sprite.Group(
) # cria um grupo para o player
self.player = Player() # cria o player
self.player_group.add(self.player) # adiciona o player no grupo
self.player_right = False # inicializa do a variavel de movimento FALSE
self.player_left = False # inicializa do a variavel de movimento FALSE
#Tiro
self.shoot_group = pygame.sprite.Group() # cria o grupo dos tiros
# Enemy
self.create_enemy = True
self.enemy_group = pygame.sprite.Group()
# INFORMAÇÕES DOS PONTOS E LEVEL
self.player_points = self.player.points
self.font = pygame.font.Font("font/8bit.ttf", 30)
self.points_text = self.font.render(
"SCORE: " + str(self.player_points), 1, (255, 255, 255))
self.level = 0
self.enemy_in_window = 5
self.level_text = self.font.render("LEVEL: " + str(self.level), 1,
(255, 255, 255))
# MUSICA AMBIENTE
pygame.mixer.init()
pygame.mixer.set_reserved(0)
self.game_music = pygame.mixer.Sound("sounds/game_music.wav")
pygame.mixer.Channel(0).play(self.game_music, -1)
# FPS
self.fps = pygame.time.Clock(
) # joga olock dentro de uma variavel para controle de fps
# LOOP PRINCIPAL
self.game_init = True
while self.game_init:
self.fps.tick(30) # defini o fps do jogo
for event in pygame.event.get(): # evento para os comandos do jogo
if event.type == QUIT:
pygame.quit()
if event.type == KEYDOWN: # quando a tecla estiver apertada
if event.key == K_RIGHT:
self.player_right = True
if event.key == K_LEFT:
self.player_left = True
if event.key == K_SPACE: # botao para atirar
self.player_shot = Shot() # pega a classe do tiro
self.player_shot.rect[0] = self.player.rect[
0] + 23 # passa a posicao inicial em x
self.player_shot.rect[1] = self.player.rect[
1] # passa a posicao inicial em y
self.shoot_group.add(
self.player_shot
) # adiciona o tiro no grupo dos tiros
pygame.mixer.Channel(1).play(
pygame.mixer.Sound(
"sounds/shot.wav")) # musica dos tiros
if event.type == KEYUP: # quando soltar a tecla
if event.key == K_RIGHT:
self.player_right = False
if event.key == K_LEFT:
self.player_left = False
if self.player_right: # se a condicao for verdadeira o player mexe para direita
self.player.rect[0] += self.player.speed
if self.player_left: # se a condicao for verdadeira o player mexe para esquerda
self.player.rect[0] -= self.player.speed
self.window.blit(self.background, (0, 0)) # desenha o background
self.window.blit(self.points_text, (850, 10)) # texto do score
self.window.blit(self.level_text, (650, 10))
self.shoot_group.update(
) # chama a funcao de update de todos que tiverem no grupo de tiros
self.player_group.update(
) # chama a funcao update de todos que tiverem no grupo do player
self.player_group.draw(
self.window) # desenha todo grupo do player na tela
self.enemy_group.update() # chama o update do grupo de inimigos
self.enemy_group.draw(self.window) # desenha os inimigos na tela
if len(
self.enemy_group
) < 5: # se tiver menos que 5 inimigos , adiciona mais inimigo
for i in range(5):
self.enemy = Enemy()
self.enemy_group.add(self.enemy)
print("adicionou mais um")
if self.enemy.rect[
1] > 600: # quando os inimigos chegarem a 700px da tela, eles são destruidos
self.enemy_group.remove(self.enemy)
print("saiu da tela")
# VERIFICAÇÃO DE SCORE E LEVEL
if self.player_points > 500:
self.enemy.speed = 2
self.level = 1
self.level_text = self.font.render("LEVEL: " + str(self.level),
1, (255, 255, 255))
if self.player_points > 2000:
self.enemy.speed = 3
self.level = 2
self.level_text = self.font.render("LEVEL: " + str(self.level),
1, (255, 255, 255))
if self.player_points > 4000:
self.enemy.speed = 4
self.level = 3
self.level_text = self.font.render("LEVEL: " + str(self.level),
1, (255, 255, 255))
if self.player_points > 8000:
self.enemy.speed = 6
self.level = 4
self.level_text = self.font.render("LEVEL: " + str(self.level),
1, (255, 255, 255))
if self.player_points > 10000:
self.enemy.speed = 8
self.level = 5
self.level_text = self.font.render("LEVEL: " + str(self.level),
1, (255, 255, 255))
if self.player_points > 20000:
self.enemy.speed = 9
self.level = 6
self.level_text = self.font.render("LEVEL: " + str(self.level),
1, (255, 255, 255))
if self.player_points > 50000:
self.enemy.speed = 12
self.level = "FINAL LEVEL"
self.level_text = self.font.render("LEVEL: " + str(self.level),
1, (255, 255, 255))
for bullet in self.shoot_group: # para cada tiro que estiver no grupo de tiros
self.shoot_group.draw(self.window) # desenha o tiro na tela
if self.player_shot.rect[
1] < -20: # verifica se a posicao y do tiro é menor que -20 , no caso se ja saiu da tela
self.shoot_group.remove(
self.player_shot
) # se a verificacao for verdadeira, entao ela elimina aquele tiro do grupo de tiros
#VERIFICANDO AS COLISÕES
if (pygame.sprite.groupcollide(self.shoot_group, self.enemy_group,
True, True)):
self.player_points += random.randint(1, 10)
self.points_text = self.font.render(
"SCORE: " + str(self.player_points), 1, (255, 255, 255))
pygame.mixer.Channel(2).play(
pygame.mixer.Sound("sounds/enemy_death.wav")
) # musica da morte do inimigo
if (pygame.sprite.groupcollide(self.player_group, self.enemy_group,
True, False)):
Game()
self.game_init = False
pygame.display.update()