def ask():
screen.fill(BLACK)
text_box = TextBox(screen, (WIDTH // 2) - 250, (HEIGHT // 2) - 50,
500,
100,
fontSize=75,
borderColour=BLACK,
textColour=BLACK)
waiting = True
while waiting:
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RETURN:
waiting = False
text_box.listen(events)
text_box.draw()
if not waiting:
screen.fill(BLACK)
draw_text(text_box.getText(), WHITE, WIDTH // 2, HEIGHT // 2)
pygame.display.flip()
del text_box
def display_user_score(self, user):
userScore = TextBox(self.win, 10, 380, 90, 50, fontSize=30)
score = user.getHandValue()
if not user.hasAce():
userScore.setText(score[0])
elif score[0] < 22 and score[1] < 22:
userScore.setText(str(score[0]) + '/' + str(score[1]))
elif score[0] > 21 and score[1] > 21:
userScore.setText(score[0])
else:
userScore.setText(score[0])
userScore.draw()
class LabeledSlider:
def __init__(self,
screen,
pos_x,
pos_y,
label_text,
width=200,
label_size=150,
min=0.0,
max=1.0,
initial=0.5,
margin=20):
self.width = width
self.label_size = label_size
self.label = TextBox(screen, pos_x, pos_y, label_size, 30, fontSize=16)
self.label.setText(label_text)
self.slider = Slider(screen,
pos_x + self.label_size + margin,
pos_y,
self.width,
20,
min=min,
max=max,
step=0.01,
initial=initial)
self.output = TextBox(screen,
pos_x + self.label_size + self.width +
margin * 2,
pos_y,
30,
20,
fontSize=10)
def draw(self):
self.label.draw()
self.slider.draw()
self.output.draw()
def update(self, events):
self.slider.listen(events)
self.output.setText("%.2f" % self.slider.getValue())
def get_value(self):
return self.slider.getValue()
def set_value(self, value):
self.slider.setValue(value)
def show_options_screen(self):
bg = pg.image.load(background_path('japan_menu.png'))
bg = pg.transform.scale(bg, WINDOW_SIZE)
button_width = 200
button_height = 50
x = WIDTH // 16
y = HEIGHT // 16
sliderMusic = Slider(self.screen,
WIDTH // 3,
y * 5,
WIDTH // 3,
40,
min=0,
max=100,
step=1,
colour=DARKGREY,
handleColour=LIGHTGREY,
handleRadius=30,
initial=self.audioplayer.get_music_volume())
sliderSounds = Slider(self.screen,
WIDTH // 3,
y * 7,
WIDTH // 3,
40,
min=0,
max=100,
step=1,
colour=DARKGREY,
handleColour=LIGHTGREY,
handleRadius=30,
initial=self.audioplayer.get_sound_volume())
outputMusic = TextBox(self.screen,
sliderMusic.getX() + sliderMusic.getWidth() + 50,
y * 5,
50,
40,
fontSize=30)
outputSounds = TextBox(self.screen,
sliderSounds.getX() + sliderSounds.getWidth() +
50,
y * 7,
50,
40,
fontSize=30)
running_options = True
while running_options:
self.screen.blit(bg, (0, 0))
draw_text('Options', self.font, WHITE, self.screen,
WIDTH // 2 - len('Options') * button_width // 30, y * 3)
mx, my = pg.mouse.get_pos()
button_exit = pygame.Rect(x * 5, y * 14, button_width,
button_height)
button_save = pygame.Rect(x * 9, y * 14, button_width,
button_height)
if button_exit.collidepoint((mx, my)):
if self.click:
running_options = False
if button_save.collidepoint((mx, my)):
if self.click:
running_options = False
self.audioplayer.set_sounds_volume(sliderSounds.getValue())
self.audioplayer.set_music_volume(sliderMusic.getValue())
pygame.draw.rect(self.screen, LIGHTGREY, button_exit)
pygame.draw.rect(self.screen, LIGHTGREY, button_save)
draw_text(
'Exit', self.font, WHITE, self.screen,
x * 5 + button_width // 2 - len('Exit') * button_width // 30,
y * 14 + button_height // 2 - 11)
draw_text(
'Save', self.font, WHITE, self.screen,
x * 9 + button_width // 2 - len('Save') * button_width // 30,
y * 14 + button_height // 2 - 11)
self.click = False
sliderMusic.listen(self.events())
sliderMusic.draw()
outputMusic.setText(sliderMusic.getValue())
outputMusic.draw()
sliderSounds.listen(self.events())
sliderSounds.draw()
outputSounds.setText(sliderSounds.getValue())
outputSounds.draw()
self.events()
pg.display.update()
self.clock.tick(FPS)
class EstadoDerrota(Estado):
def __init__(self, jogador, obstaculo_controller, efeito_controller):
super().__init__(jogador, obstaculo_controller, efeito_controller)
self.__recorde_salvo = False
self.__texto_derrota = Texto("Derrota", "Materials/Early GameBoy.ttf",
50, self.BLACK, [30, 40])
self.__fundo_pontuacao = Fundo([20, 140, 360, 70], self.DARK_GREY)
self.__texto_pontuacao = Texto(f"Pontos: {self.pontuacao.pontos}",
"Materials/Early GameBoy.ttf", 20,
self.WHITE, [30, 160])
self.__nome = TextBox(self.tela.display,
20,
250,
280,
70,
borderColour=(0, 0, 0),
textColour=(0, 0, 0),
radius=10,
borderThickness=5)
self.__nome.font = pygame.font.Font("Materials/Retro Gaming.ttf", 30)
self.__texto_recorde = Texto("Insira seu nome e clique em salvar.",
"Materials/Retro Gaming.ttf", 12,
self.BLACK, [25, 325])
self.__events_derrota = EventsDerrota(self.__nome)
self.__imagem_botao_salvar = pygame.image.load(
"Materials/disquete.png").convert_alpha(self.tela.display)
self.__fundo_salvar = Fundo([310, 250, 70, 70], self.WHITE)
self.__botao_salvar = BotaoImagem(self.__imagem_botao_salvar,
(315, 255), self.__fundo_salvar,
self.GREEN, self.DARK_GREEN,
self.__events_derrota)
self.__texto_jogar_novamente = Texto("Jogar novamente",
"Materials/Retro Gaming.ttf", 30,
self.WHITE, [40, 395])
self.__fundo_jogar_novamente = Fundo([20, 380, 360, 70], self.WHITE)
self.__botao_jogar_novamente = Botao(self.__texto_jogar_novamente,
self.__fundo_jogar_novamente,
self.GREEN, self.DARK_GREEN,
self.__events_derrota)
self.__texto_menu = Texto("Menu", "Materials/Retro Gaming.ttf", 40,
self.WHITE, [135, 490])
self.__fundo_menu = Fundo([20, 480, 360, 70], self.WHITE)
self.__botao_menu = Botao(self.__texto_menu, self.__fundo_menu,
self.GREEN, self.DARK_GREEN,
self.__events_derrota)
def salvar_recorde(self):
if self.__nome.getText() != "":
if len(self.__nome.getText()) > 10:
self.__texto_recorde.texto = "Digite um nome menor, limite 10 caracteres."
elif not self.__recorde_salvo:
msg, salvo = self.recordes_controller.inclui_recorde(
self.__nome.getText(), self.pontuacao.pontos)
self.__texto_recorde.texto = msg
self.__recorde_salvo = salvo
else:
self.__texto_recorde.texto = "Só é possível salvar o recorde uma vez."
else:
self.__texto_recorde.texto = "Digite um nome."
self.__nome.setText("")
self.__nome.cursorPosition = 0
def start(self):
#Updates
self.__events_derrota.check_events()
jogar_novamente = self.__botao_jogar_novamente.update()
menu_derrota = self.__botao_menu.update()
salvar_recorde = self.__botao_salvar.update()
if salvar_recorde:
self.salvar_recorde()
#Draws
self.tela.fill(self.GREY)
self.__texto_derrota.draw()
self.__fundo_pontuacao.blitme()
self.__texto_pontuacao.texto = str(f"Pontos: {self.pontuacao.pontos}")
self.__texto_pontuacao.draw()
self.__nome.draw()
self.__botao_salvar.draw()
self.__texto_recorde.draw()
self.__botao_jogar_novamente.draw()
self.__botao_menu.draw()
if jogar_novamente:
self.__recorde_salvo = False
self.__texto_recorde.texto = "Insira seu nome e clique em salvar."
self.pontuacao.zerar()
self.velocidade_controller.zerar()
self.fases_controller.zerar()
self.jogador.reset()
self.obstaculo_controller.zerar()
self.efeito_controller.zerar()
'''
self.som_controller.stop_music()
self.som_controller.play_music(0)
'''
return "jogando"
elif menu_derrota:
self.__recorde_salvo = False
self.__texto_recorde.texto = "Insira seu nome e clique em salvar."
self.pontuacao.zerar()
self.velocidade_controller.zerar()
self.fases_controller.zerar()
self.jogador.reset()
self.obstaculo_controller.zerar()
self.efeito_controller.zerar()
return "inicial"
else:
return "derrota"
class Tela:
def __init__(self, window, largura, altura):
pygame.init()
fontearquivo = os.path.dirname(os.path.abspath(__file__)).replace(
"view", "").replace("model", "")
fontearquivo = os.path.join(fontearquivo, "lib")
fontearquivo = os.path.join(fontearquivo, "FreeSansBold.ttf")
self.fa = fontearquivo
self.altura = altura
self.fontetipo = 'comicsansms'
self.ajuste = 360
self.desenhaalertaCaixaPerdeu = False
self.opcoesFases = False
self.largura = largura
self.scala_x = self.largura / 1366
self.scala_y = self.altura / 768
self.tamanho = (self.largura, self.altura)
self.indexAjuda = 1
self.continua = False
# pygame.display.set_mode(self.tamanho,pygame.SCALED)
self.janela = window
self.__janela = carrega_imagem("janela.png")
self.cadeado = carrega_imagem("cadeado.png")
self.imgVazia = carrega_imagem("rect.png")
self.__janela2 = pygame.transform.smoothscale(
self.__janela.convert_alpha(),
(int(30 * self.scala_x), int(30 * self.scala_y)))
# FONTES
self.fonteGrande = pygame.font.Font(fontearquivo,
int(22 * self.scala_x))
self.fontePequena = pygame.font.Font(fontearquivo,
int(12 * self.scala_x))
self.fonteTitulo = pygame.font.Font(fontearquivo,
int(55 * self.scala_x))
self.corBranca = Cores.BRANCO
self.corfundo = Cores.CORFUNDO
self.corPrincipal = Cores.CORPRINCIPAL
self.corSecundaria = Cores.CORSECUNDARIA
self.corTexto = Cores.CORSECUNDARIA
self.cor1Elemento = Cores.CORELEMENTO
self.telaInicio = False
self.telaConfig = True
self.telaSaves = self.telaJogo = self.telaCriar = self.telaFases = self.telaAjuda = False
self.rolagem = 0
pygame.display.set_icon(carrega_imagem("icon.png"))
pygame.display.set_caption("PaintCoding")
# pygame.display.set_mode((self.largura, self.altura),pygame.FULLSCREEN)
self.ok = Sprite("ok.png", 1, 2)
self.ok.definirPosicao((760, 380))
self.menu = Sprite("menu.png", 1, 2)
self.menu.definirPosicao((550, 360))
self.reiniciar = Sprite("reiniciar.png", 1, 2)
self.reiniciar.definirPosicao((630, 360))
self.continuar = Sprite("continuar.png", 1, 2)
self.continuar.definirPosicao((710, 360))
self.desenhaAlerta = self.desenhaNovoJogo = False
self.textoAlerta = ("TEXTO TITULO!", "PRESSIONE OK PARA CONTINUAR!")
self.caixaTexto = TextBox(self.janela,
int(550 * ESCALAX),
int(300 * ESCALAY),
250 * ESCALAX,
40 * ESCALAY,
fontSize=20,
borderColour=Cores.CORPRINCIPAL,
radius=10,
borderThickness=5)
# INICIO
self.botaostart = Sprite("BOTAOJOGAR.PNG", 1, 2)
self.botaoCriar = Sprite("BOTAOCRIAR.PNG", 1, 2)
self.botaoSair = Sprite("BOTAOSAIR.PNG", 1, 2)
self.botaoVolume = Sprite("BOTAOVOLUMEON.PNG", 1, 2)
self.btAjuda = Sprite("ajuda.png", 1, 2)
self.btyt = Sprite("youtube.png", 1, 2)
self.btConfig = Sprite("engrenagem.png", 1, 2)
self.img = carrega_imagem("img2.png")
self.logo = carrega_imagem("img2.png", escala=3)
self.c1 = carrega_imagem("c1.png")
self.c2 = carrega_imagem("c2.png")
self.c3 = carrega_imagem("c3.png")
self.c4 = carrega_imagem("c4.png")
self.c5 = carrega_imagem("c5.png")
# self.botaostart.definirPosicao((((largura/2)-self.botaostart.rect.h), 330))
self.botaostart.definirPosicao((350 + (self.ajuste / 2), 330))
self.botaoCriar.definirPosicao((350 + (self.ajuste / 2), 450))
self.botaoSair.definirPosicao((350 + (self.ajuste / 2), 570))
# self.botaoCriar.definirPosicao((((largura / 2) - self.botaoCriar.rect.h), 450))
# self.botaoSair.definirPosicao((((largura / 2) - self.botaoSair.rect.h), 590))
self.btyt.definirPosicao((1040, 40))
self.btAjuda.definirPosicao((1130, 50))
self.btConfig.definirPosicao((1210, 50))
self.botaoVolume.definirPosicao((1290, 50))
# ESCOLHERSAVE
self.botaoNovoJogo = Sprite("BOTAONOVOJOGO.PNG", 1, 2)
self.botaoFasesPersonalizadas = Sprite("BOTAOCRIACOES.PNG", 1, 2)
self.botaoVoltar = Sprite("VOLTAR.png", 1, 2)
self.botaoCima = Sprite("BOTAOCIMA.png", 1, 2)
self.botaoBaixo = Sprite("BOTAOBAIXO.png", 1, 2)
self.botaoNovoJogo.definirPosicao((90 + (self.ajuste / 2), 610))
self.botaoFasesPersonalizadas.definirPosicao(
(350 + (self.ajuste / 2), 610))
self.botaoCima.definirPosicao((860 + (self.ajuste / 2), 84))
self.botaoBaixo.definirPosicao((860 + (self.ajuste / 2), 510))
self.savesPane = Painel(self.escalarX(943), self.escalarY(493),
self.escalarX(25 + (self.ajuste / 2)),
self.escalarY(100))
self.moverretangulo = False
self.botaoPlay = []
self.botaolixeira = []
self.saves = None
# self.fasesPersonalizadas = None
# CRIAR
self.colunas = self.linhas = 2
self.execucoes = 1
self.btCimaCol = Sprite("BOTAOCIMA.png", 1, 2, 2)
self.btCimaLi = Sprite("BOTAOCIMA.png", 1, 2, 2)
self.btBaixoCol = Sprite("BOTAOBAIXO.png", 1, 2, 2)
self.btBaixoLi = Sprite("BOTAOBAIXO.png", 1, 2, 2)
self.btCimaEx = Sprite("BOTAOCIMA.png", 1, 2, 2)
self.btBaixoEx = Sprite("BOTAOBAIXO.png", 1, 2, 2)
self.btCimaCol.definirPosicao((90, 180))
self.btBaixoCol.definirPosicao((90, 250))
self.btCimaLi.definirPosicao((200, 180))
self.btBaixoLi.definirPosicao((200, 250))
self.btCimaEx.definirPosicao((250, 380))
self.btBaixoEx.definirPosicao((250, 450))
self.botaoProximo = Sprite("BOTAOPROX.PNG", 1, 2)
self.botaoVoltarCriar = Sprite("VOLTAR.png", 1, 2)
self.botaoVoltarCriar.definirPosicao((1080, 580))
self.botaoProximo.definirPosicao((790, 580))
# config
self.sliderVl = Slider(self.janela,
self.escalarX(170),
self.escalarY(400),
self.escalarX(400),
self.escalarY(20),
min=20,
max=300,
step=1,
colour=Cores.CORSECUNDARIA,
handleColour=Cores.CORPRINCIPAL)
self.sliderVl.value = Util.Config.VELOCIDADE
# self.btCimaVel = Sprite("BOTAOCIMA.png", 1, 2, 2)
# self.btBaixoVel = Sprite("BOTAOBAIXO.png", 1, 2, 2)
# self.btCimaVel.definirPosicao((250, 280))
# self.btBaixoVel.definirPosicao((250, 350))
self.botaoConfirmar = Sprite("BOTAOSALVAR.PNG", 1, 2)
self.botaoConfirmar.definirPosicao((800 + (self.ajuste / 2), 580))
# TELA FASES PERSONALIZADAS
self.botaoEsquerda = Sprite("BOTAOESQUERDA.png", 1, 2)
self.botaoDireita = Sprite("BOTAODIREITA.png", 1, 2)
self.botaoEsquerda.definirPosicao((60, 350))
self.botaoDireita.definirPosicao((1220, 350))
self.contornoFase = None
self.btVoltarFases = Sprite("VOLTAR.png", 1, 2)
self.btVoltarFases.definirPosicao((950, 600))
self.fasespersonalizadas = None
self.rolagemCriacoes = 0
# MSG PERRGUNTA
self.desenhaConfirmacao = False
self.textopergunta = ("Confirma a exclusão do Progresso?",
" Essa ação não poderá ser desfeita!")
self.confirmarbotao = Sprite("confirmar.png", 1, 2)
self.cancelarbotao = Sprite("cancelar.png", 1, 2)
self.confirmarbotao.definirPosicao((850, 390))
self.cancelarbotao.definirPosicao((695, 390))
# JOGO
# 943, 493, 25, 70)
self.jogoPane = PainelJogo(self, self.largura, self.altura, 0, 0)
self.botoesFases = gerarBotaoFase(janela=self.janela)
self.nivelJogador = 0
self.telaMenuFases = False
# IMAGEM
self.imagemConteiner = carrega_imagem("conteiner.png")
# TEXTOS
self.tituloTelaSave = self.fonteTitulo.render("Jogar", True,
self.corPrincipal)
self.tituloTelaMenuFase = self.fonteTitulo.render(
"Escolha um nível para jogar", True, self.corPrincipal)
self.tituloTelaFases = self.fonteTitulo.render("Fases personalizadas",
True, self.corPrincipal)
self.txt_pane = self.fonteTitulo.render(
"Selecione as características da fase: ", True, self.corTexto)
self.txt_desenho = self.fonteGrande.render(
"Selecione a quantidade de linhas e colunas do desenho: ", True,
self.corTexto)
self.txt_col_lin = self.fonteGrande.render("Colunas x Linhas: ",
True, self.corPrincipal)
self.txt_X = self.fonteGrande.render("X", True, self.corPrincipal)
self.txt_qntvidas = self.fonteGrande.render(
"Selecione a quantidade de execuções disponíveis para concluir o desenho:",
True, self.corTexto)
self.txt_ex = self.fonteGrande.render("Nº Execuções:", True,
self.corPrincipal)
self.txt_CONFIG = self.fonteTitulo.render("CONFIGURAÇÕES ", True,
self.corTexto)
self.txt_descVelocidade = self.fonteGrande.render(
"Ajuste com o slider abaixo a velocidade das animações dentro do PaintCode:",
True, self.corTexto)
self.txt_velocidade = self.fonteGrande.render("VELOCIDADE:", True,
self.corPrincipal)
self.txt_explicacaoVelocidade = self.fonteGrande.render(
"Deslize ", True, self.corPrincipal)
def desenhar(self):
if not self.desenhaNovoJogo and not self.desenhaAlerta and not self.desenhaConfirmacao:
self.janela.fill(self.corBranca)
# TELA INICIO
if self.telaInicio:
# BOTÕES
self.botaoVolume.definirPosicao((1290, 50))
self.botaoVolume.desenharBt(self.janela)
self.btAjuda.definirPosicao((1130, 50))
self.btyt.definirPosicao((1040, 40))
self.btyt.desenharBt(self.janela)
self.btAjuda.desenharBt(self.janela)
self.btConfig.desenharBt(self.janela)
self.janela.blit(self.img, (((self.largura / 2) -
(self.img.get_width() / 2)), 0))
self.botaostart.desenharBt(self.janela)
self.botaoCriar.desenharBt(self.janela)
self.botaoSair.desenharBt(self.janela)
# TELA SAVES
elif self.telaSaves:
if self.saves is None or len(self.saves) <= 0:
self.botaoVolume.definirPosicao((1290, 50))
self.botaoVolume.desenharBt(self.janela)
self.btAjuda.definirPosicao((1130, 50))
self.btyt.definirPosicao((1040, 40))
self.btyt.desenharBt(self.janela)
self.btAjuda.desenharBt(self.janela)
self.btConfig.desenharBt(self.janela)
self.janela.blit(self.img,
(((self.largura / 2) -
(self.img.get_width() / 2)), 0))
self.botaoNovoJogo.definirPosicao(
(350 + (self.ajuste / 2), 330))
self.botaoFasesPersonalizadas.definirPosicao(
(350 + (self.ajuste / 2), 450))
self.botaoVoltar.definirPosicao(
(350 + (self.ajuste / 2), 570))
else:
self.savesPane.fill(self.corfundo)
self.janela.blit(self.logo,
(((self.largura / 2) -
(self.logo.get_width() / 2)), -20))
# contornar(self.janela, self.escalar((25 + (self.ajuste / 2),70,943,493), 4)
contornar(self.janela,
int(ESCALAX * (25 + (self.ajuste / 2))),
int(100 * ESCALAY), int(ESCALAX * 943),
int(ESCALAY * 493), 4)
#self.janela.blit(self.tituloTelaSave,((self.largura / 2) - 80, 7))
self.desenharPainelSaves(self.saves)
self.janela.blit(self.savesPane,
self.savesPane.get_posicao())
# BOTÕES
self.botaoNovoJogo.definirPosicao(
(50 + (self.ajuste / 2), 610))
self.botaoFasesPersonalizadas.definirPosicao(
(360 + (self.ajuste / 2), 610))
self.botaoVoltar.definirPosicao(
(670 + (self.ajuste / 2), 610))
self.botaoCima.desenharBt(self.janela)
self.botaoBaixo.desenharBt(self.janela)
self.botaoNovoJogo.desenharBt(self.janela)
self.botaoFasesPersonalizadas.desenharBt(self.janela)
self.botaoVoltar.desenharBt(self.janela)
# TELA FASES PERS
elif self.telaMenuFases:
self.desenharMenuFases(self.nivelJogador)
elif self.telaFases:
#self.janela.blit(self.tituloTelaFases,self.escalarXY(375, 35))
self.janela.blit(self.logo,
(((self.largura / 2) -
(self.logo.get_width() / 2)), -20))
self.botaoEsquerda.desenharBt(self.janela)
self.botaoDireita.desenharBt(self.janela)
self.desenharDesenhoGuia(self.fasespersonalizadas,
self.rolagemCriacoes)
self.btVoltarFases.desenharBt(self.janela)
if self.telaJogo:
self.janela.blit(self.jogoPane, self.jogoPane.get_posicao())
elif self.telaCriar:
self.desenharPainelCriar()
elif self.telaConfig:
self.desenharPainelConfig()
elif self.telaAjuda:
t = getTutorials()
if len(t) <= self.indexAjuda:
self.telaAjuda = False
self.telaInicio = True
else:
self.jogoPane.desenharTutorial(t[self.indexAjuda],
self.janela,
c=Cores.CORFUNDO)
if self.desenhaAlerta:
self.deesenharAlerta(self.textoAlerta)
if self.desenhaConfirmacao:
self.deesenharMsgPergunta(self.textopergunta)
if self.desenhaNovoJogo:
self.desenharNovoJogo()
def desenharMenuFases(self, nivel):
self.janela.blit(self.logo, (((self.largura / 2) -
(self.logo.get_width() / 2)), -20))
#self.janela.blit(self.tituloTelaMenuFase, escalarXY(320, 25))
self.botaoVoltar.definirPosicao((1070, 600))
self.botaoVoltar.desenharBt(self.janela)
i = 0
for bt in self.botoesFases:
if int(bt.string) <= (int(nivel) + 1):
bt.setInactiveColour((0, 205, 255))
bt.setHoverColour((0, 0, 255))
bt.setImage(self.imgVazia)
else:
bt.setInactiveColour((153, 153, 153))
bt.setHoverColour((153, 153, 153))
bt.setImage(self.cadeado)
bt.draw()
def desenharPainelCriar(self):
self.janela.blit(self.txt_pane, self.escalarXY(20, 50))
self.janela.blit(self.txt_desenho, self.escalarXY(50, 130))
self.janela.blit(self.txt_col_lin, self.escalarXY(70, 160))
self.btBaixoLi.desenharBt(self.janela)
self.btCimaLi.desenharBt(self.janela)
self.btCimaCol.desenharBt(self.janela)
self.btBaixoCol.desenharBt(self.janela)
self.janela.blit(self.txt_X, self.escalarXY(163, 230))
txt_col = self.fonteGrande.render(str(self.colunas), True,
self.corTexto)
txt_li = self.fonteGrande.render(str(self.linhas), True, self.corTexto)
self.janela.blit(txt_col, self.escalarXY(110, 230))
self.janela.blit(txt_li, self.escalarXY(220, 230))
contornar(self.janela, 90, 225, 50, 30, eX=ESCALAX, eY=ESCALAY)
contornar(self.janela, 200, 225, 50, 30, eX=ESCALAX, eY=ESCALAY)
#self.janela.blit(self.txt_qntvidas, self.escalarXY(50, 350))
#self.janela.blit(self.txt_ex, self.escalarXY(70, 430))
# self.btCimaEx.desenharBt(self.janela)
# self.btBaixoEx.desenharBt(self.janela)
# txt_execucoes = self.fonteGrande.render(
# str(self.execucoes), True, self.corTexto)
#self.janela.blit(txt_execucoes, self.escalarXY(270, 430))
#contornar(self.janela, 250, 425, 50, 30, eX=ESCALAX, eY=ESCALAY)
self.botaoVoltarCriar.desenharBt(self.janela)
self.botaoProximo.desenharBt(self.janela)
def desenharPainelConfig(self):
self.janela.blit(self.txt_CONFIG, self.escalarXY(20, 50)) # TITULO
self.janela.blit(self.txt_descVelocidade,
self.escalarXY(50, 250)) # DESC VELOCIDADE
self.janela.blit(self.txt_velocidade, self.escalarXY(70, 330)) # V
self.sliderVl.draw()
# self.btCimaVel.desenharBt(self.janela)
# self.btBaixoVel.desenharBt(self.janela)
# txt_vel = self.fonteGrande.render(
# str(Util.Config.VELOCIDADE), True, self.corTexto)
# self.janela.blit(txt_vel, self.escalarXY(260, 330))
#contornar(self.janela, 250, 325, 50, 30, eX=ESCALAX, eY=ESCALAY)
self.botaoConfirmar.desenharBt(self.janela)
self.botaoVoltar.definirPosicao((470 + (self.ajuste / 2), 580))
self.botaoVoltar.desenharBt(self.janela)
def escalar(self, x, y, tamx, tamy):
return int(ESCALAX * x), int(y * ESCALAY), int(ESCALAX * tamx), int(
ESCALAY * tamy)
def escalarXY(self, x, y):
return int(ESCALAX * x), int(y * ESCALAY)
def escalarX(self, x):
return int(ESCALAX * x)
def escalarY(self, y):
return int(ESCALAY * y)
def desenharPainelSaves(self, jogador):
espaco = 117
qntsaves = 0
text2 = self.fontePequena.render("PROGRESSO: ", True,
self.corSecundaria)
#text3 = self.fontePequena.render("Jogar ", True, self.corSecundaria)
for x in jogador:
text = self.fonteGrande.render("NOME: " + x.getNome(), True,
self.corSecundaria)
self.savesPane.blit(
self.imagemConteiner,
(self.escalarX(25),
self.escalarY((espaco * qntsaves) + 10 + self.rolagem)))
self.savesPane.blit(
text, (self.escalarX(55),
self.escalarY((espaco * qntsaves) + 25 + self.rolagem)))
self.savesPane.blit(
text2,
(self.escalarX(75),
self.escalarY((espaco * qntsaves) + 60 + self.rolagem)))
# self.savesPane.blit(
# text3, (self.escalarX(710), self.escalarY((espaco * qntsaves) + self.escalarY(90) + self.rolagem)))
pygame.draw.rect(
self.savesPane, self.corSecundaria,
(self.escalarX(75),
self.escalarY((espaco * qntsaves) + 75 + self.rolagem),
self.escalarX(580), self.escalarY(30)))
pygame.draw.rect(
self.savesPane, self.corPrincipal,
(self.escalarX(75),
self.escalarY((espaco * qntsaves) + 75 + self.rolagem),
self.escalarX(40 * x.getNivel()), self.escalarY(30)))
self.botaoPlay[qntsaves].definirPosicao(
(700, (espaco * qntsaves) + 30 + self.rolagem))
self.botaolixeira[qntsaves].definirPosicao(
(653, (espaco * qntsaves) + 72 + self.rolagem))
# BOTAO
self.botaolixeira[qntsaves].desenharBt(self.savesPane)
self.botaoPlay[qntsaves].desenharBt(self.savesPane)
qntsaves += 1
def deesenharAlerta(self, textolist):
superfice = self.janela
texto = textolist[0]
texto2 = textolist[1]
rect = pygame.Rect((superfice.get_rect().w / 4),
(superfice.get_rect().h / 4), self.escalarX(600),
self.escalarY(150))
font = pygame.font.Font(self.fa, self.escalarX(23))
textod = font.render(texto, True, Cores.PRETO)
textod2 = font.render(texto2, True, Cores.PRETO)
if self.opcoesFases:
if self.desenhaalertaCaixaPerdeu:
superfice.blit(self.c3, rect)
else:
superfice.blit(self.c5, rect)
else:
superfice.blit(self.c4, rect)
superfice.blit(textod, (self.escalarX(421), self.escalarY(282)))
superfice.blit(textod2, (self.escalarX(421), self.escalarX(302)))
if len(textolist) > 2:
font = pygame.font.Font(self.fa, self.escalarX(17))
textod3 = font.render(textolist[2], True, Cores.PRETO)
superfice.blit(textod3, (self.escalarX(441), self.escalarY(372)))
if self.opcoesFases:
self.reiniciar.desenharBt(superfice)
self.menu.desenharBt(superfice)
if self.continua:
self.continuar.desenharBt(superfice)
else:
self.ok.desenharBt(superfice)
def desenharNovoJogo(self):
superfice = self.janela
rect = pygame.Rect(self.escalar(300, 150, 800, 416))
font = pygame.font.Font(self.fa, self.escalarX(25))
font2 = pygame.font.Font(self.fa, self.escalarX(17))
novojogo = font.render("Novo Jogo", True, Cores.CORPRINCIPAL)
textod2 = font2.render("Digite seu Nome:", True, Cores.PRETO)
superfice.blit(self.c1, rect)
superfice.blit(novojogo, self.escalarXY(650, 230))
superfice.blit(textod2, self.escalarXY(400, 305))
self.caixaTexto.draw()
self.confirmarbotao.desenharBt(superfice)
self.cancelarbotao.desenharBt(superfice)
def deesenharMsgPergunta(self, texto):
superfice = self.janela
rect = pygame.Rect(self.escalar(300, 150, 800, 416))
font = pygame.font.Font(self.fa, self.escalarX(25))
font2 = pygame.font.Font(self.fa, self.escalarX(17))
textod = font.render(texto[0], True, Cores.PRETO)
textod2 = font2.render(texto[1], True, Cores.PRETO)
superfice.blit(self.c2, rect)
superfice.blit(textod, self.escalarXY(390, 270))
superfice.blit(textod2, self.escalarXY(390, 300))
self.confirmarbotao.desenharBt(superfice)
self.cancelarbotao.desenharBt(superfice)
def desenharDesenhoGuia(self, fases, x=0, y=0, escala=30):
if fases is not None:
# if escala != self.__janela2.get_rect().h:
# self.__janela2=pygame.transform.scale(
# self.__janela, (escala, escala))
inty = 270 + y
intx = -60 + x
espaco = 700
qntdFase = 0
for fase in fases:
desenho = fase.desenhoResposta
aux = auxX = 0
if desenho.colunas <= 3:
auxX = 60
if desenho.linhas < 4:
aux = 60
self.contornoFase[qntdFase].definirPosicao(
(intx + (espaco * qntdFase) + 230, inty - 20))
self.contornoFase[qntdFase].desenharBt(self.janela)
# desenhando Telhado
pygame.gfxdraw.filled_trigon(
self.janela,
self.escalarX(intx + auxX + (espaco * qntdFase) + 265 +
int((escala * desenho.colunas) / 2)),
self.escalarY(inty + aux + 50),
self.escalarX(intx + auxX + (espaco * qntdFase) + 260),
self.escalarY(85 + inty + aux),
self.escalarX(intx + auxX + (espaco * qntdFase) + 270 +
escala * desenho.colunas),
self.escalarY(85 + inty + aux), Cores.TELHADO)
for i in range(0, desenho.colunas):
for j in range(0, desenho.linhas):
if int(desenho.tiles[i][j]) >= 0:
pygame.draw.rect(
self.janela, get_cor(int(desenho.tiles[i][j])),
self.escalar(
(self.ajuste / 2) + intx + auxX +
(espaco * qntdFase) + 85 + (escala * i),
85 + inty + aux + (escala * j), escala,
escala))
else:
self.janela.blit(
self.__janela2,
self.escalar(
(self.ajuste / 2) + intx + auxX +
(espaco * qntdFase) + 85 + (escala * i),
85 + inty + aux + (escala * j), escala,
escala))
contornar(self.janela, (self.ajuste / 2) + intx + auxX +
(espaco * qntdFase) + 85,
inty + aux + 85,
escala * desenho.colunas,
escala * desenho.linhas,
eX=ESCALAX,
eY=ESCALAY)
qntdFase += 1
def carregarContornos(self):
self.contornoFase = list()
for fase in self.fasespersonalizadas:
self.contornoFase.append(Sprite("contorno4.png", 1, 2))
def getValue(self):
return self.value
if __name__ == '__main__':
pygame.init()
win = pygame.display.set_mode((1000, 600))
slider = Slider(win, 100, 100, 800, 40, min=0, max=99, step=1)
output = TextBox(win, 475, 200, 50, 50, fontSize=30)
run = True
while run:
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
pygame.quit()
run = False
quit()
win.fill((255, 255, 255))
slider.listen(events)
slider.draw()
output.setText(slider.getValue())
output.draw()
pygame.display.update()
min=0,
max=99,
step=1,
vertical=True)
v_output = TextBox(win, 800, 320, 50, 50, fontSize=30)
run = True
while run:
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
pygame.quit()
run = False
quit()
win.fill((255, 255, 255))
slider.listen(events)
v_slider.listen(events)
slider.draw()
v_slider.draw()
output.setText(slider.getValue())
v_output.setText(v_slider.getValue())
output.draw()
v_output.draw()
pygame.display.update()
nav_status = build_nav_status(eta, ni, mission_mode)
mission_com.send1c(nav_status)
# executing this block of code if mission mode is active
if mission_mode:
button2.inactiveColour = GREEN
# receiving message from mission_manager
command = mission_com.getPacket()
if command != None:
command[0:3] = geo2ned(command[0:3])
eta_des = matrix(command[0:6]).T
else:
button2.inactiveColour = RED
# drawing all graphic elements
draw_elements(screen, image_1, image_2, image_3, eta, ni, tau)
textbox.draw()
button1.draw()
button2.draw()
# updating GUI screen
pg.display.update()
sleep(TS)
# closing UDP connection with Unity
unity_com.close()
# closing serial connection with mission manager
mission_com.close()
# closing pygame
pg.quit()
def display_dealer_score(self, dealer):
dealerScore = TextBox(self.win, 10, 180, 90, 50, fontSize=30)
score = dealer.getHandValue()
dealerScore.setText(score)
dealerScore.draw()
100)
CONSTANTS['y'] = randint(
0,
screen_size.get_height() - image.get_height())
pygame.display.update()
textbox.setText("Image Loaded")
else:
textbox.setText("Wrong file type")
events = pygame.event.get()
moving()
pygame.draw.rect(
root, (91, 100, 103),
pygame.Rect(screen_size.get_width() - 100, 0, 100,
screen_size.get_height()))
textbox.draw()
xslider.listen(events)
xslider.draw()
xtextbox.setText(f"X-speed: {xslider.getValue()}")
xtextbox.draw()
'''
Remembering the momentum in the x direction
'''
if CONSTANTS['x_move'] > 0:
CONSTANTS['x_move'] = xslider.getValue()
if xslider.getValue() != 0:
last_x = CONSTANTS['x_move']
elif CONSTANTS['x_move'] == 0 and xslider.getValue() > 0:
if last_x > 0:
CONSTANTS['x_move'] = xslider.getValue()
else: