class EstadoSom(Estado):
def __init__(self):
super().__init__()
self.__texto_som = Texto("Som", "Materials/Early GameBoy.ttf", 50, self.BLACK, [130, 40])
self.__texto_musica = Texto("Volume música:", "Materials/Retro Gaming.ttf", 25, self.WHITE, [20, 150])
self.__texto_efeitos = Texto("Volume efeitos:", "Materials/Retro Gaming.ttf", 25, self.WHITE, [20, 300])
self.__slider_musica = Slider(self.tela.display, 20, 230, 300, 20, min=0, max=1, step=0.1, handleColour=self.GREEN)
self.__slider_musica.setValue(self.som_controller.volume_atual_music)
self.__slider_sons = Slider(self.tela.display, 20, 380, 300, 20, min=0, max=1, step=0.1, handleColour=self.GREEN)
self.__slider_sons.setValue(self.som_controller.volume_atual_sound)
self.__sliders = [self.__slider_musica, self.__slider_sons]
self.__events_som = EventsSom(self.__sliders)
self.__numero_musica = Texto("", "Materials/Retro Gaming.ttf", 25, self.WHITE, [335, 225])
self.__numero_sons = Texto("", "Materials/Retro Gaming.ttf", 25, self.WHITE, [335, 375])
self.__imagem_botao_voltar = pygame.image.load("Materials/voltar.png").convert_alpha(self.tela.display)
self.__fundo_voltar = Fundo([20, 510, 70, 70], self.WHITE)
self.__botao_voltar = BotaoImagem(self.__imagem_botao_voltar, (25, 515), self.__fundo_voltar, self.GREEN, self.DARK_GREEN, self.__events_som)
self.__texto_vol_padrao = Texto("Volume Padrão", "Materials/Retro Gaming.ttf", 27, self.BLACK, [125, 525])
self.__fundo_vol_padrao = Fundo([110, 510, 270, 70], self.WHITE)
self.__botao_vol_padrao = Botao(self.__texto_vol_padrao, self.__fundo_vol_padrao, self.GREEN, self.DARK_GREEN, self.__events_som)
def start(self):
#Updates
self.__events_som.check_events()
self.som_controller.set_volume_music(self.__slider_musica.getValue())
self.som_controller.set_volume_sounds(self.__slider_sons.getValue())
voltar = self.__botao_voltar.update()
padrao = self.__botao_vol_padrao.update()
if padrao:
self.som_controller.set_volume_padrao()
self.__slider_musica.setValue(self.som_controller.volume_atual_music)
self.__slider_sons.setValue(self.som_controller.volume_atual_sound)
porcentagem_musica = self.__slider_musica.getValue() * 100
porcentagem_sons = self.__slider_sons.getValue() * 100
self.__numero_musica.texto = str(int(porcentagem_musica)) + "%"
self.__numero_sons.texto = str(int(porcentagem_sons)) + "%"
#Draws
self.tela.fill(self.GREY)
self.__texto_som.draw()
self.__texto_musica.draw()
self.__texto_efeitos.draw()
self.__slider_musica.draw()
self.__slider_sons.draw()
self.__numero_musica.draw()
self.__numero_sons.draw()
self.__botao_voltar.draw()
self.__botao_vol_padrao.draw()
if voltar:
return "inicial"
else:
return "som"
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 Settings():
def __init__(self, sounds):
self.frame_h = int(str_dict.get("h"))
self.frame_w = int(str_dict.get("w"))
self.sc = pygame.display.set_mode((self.frame_w, self.frame_h))
self.mus_curr_vol = 0
self.snd_curr_vol = 0
self.sounds = sounds
self.diff = 'medium'
# Инициализация слайдеров, координаты наверное можно лучше сделать
self.sound_vol_slider = Slider(self.sc,
self.frame_w * 2 // 5,
self.frame_h * 1 // 10,
100,
20,
colour=(100, 100, 100),
handleColour=(40, 40, 40))
self.music_vol_slider = Slider(self.sc,
self.frame_w * 2 // 5,
self.frame_h * 2 // 10,
100,
20,
colour=(100, 100, 100),
handleColour=(40, 40, 40))
update_settings()
self.sound_vol_slider.setValue(
int(float(settings_dict.get('sound_volume')) * 100))
self.music_vol_slider.setValue(
int(float(settings_dict.get('music_volume')) * 100))
self.BACKGROUND_offset = 0
self.BACKGROUND_speed = 3
self.FPS = int(str_dict.get("FPS"))
self.clock = pygame.time.Clock()
# Запуск
def run(self):
global event
while True:
events = pygame.event.get()
# Обновление слайдеров
self.music_vol_slider.listen(events)
self.sound_vol_slider.listen(events)
self.clock.tick(self.FPS)
for event in events:
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
rect = pygame.Rect(
0,
self.sc.get_height() - int(str_dict.get('button_y')),
int(str_dict.get('button_x')),
int(str_dict.get('button_y')))
# Взаимодействие с кнопками сложности
if self.easy_b_rect.collidepoint(pos):
self.diff = 'easy'
elif self.medium_b_rect.collidepoint(pos):
self.diff = 'medium'
elif self.hard_b_rect.collidepoint(pos):
self.diff = 'hard'
# Выход из настроек. Сохранение настроек.
if rect.collidepoint(pos):
with open('Res/CSV/settings.csv',
encoding="utf8") as csvfile:
change, write = dict(), list()
reader = csv.reader(csvfile,
delimiter=',',
quotechar='"')
for row in reader:
change[row[0]] = row[1]
# В change записываются изменённые настройки
change[
'music_volume'] = self.music_vol_slider.getValue(
) / 100
change[
'sound_volume'] = self.sound_vol_slider.getValue(
) / 100
change['difficulty'] = self.diff
write = list(
map(lambda x: [x, change[x]], change.keys()))
writer = csv.writer(open('Res/CSV/settings.csv',
'w',
encoding="utf8",
newline=''),
delimiter=',',
quoting=csv.QUOTE_ALL)
writer.writerows(write)
return
self.redraw_window()
# Перерисовка окна
def redraw_window(self):
# Текст около слайдеров
sound_text = MAIN_FONT.render("Sound:", True, (170, 170, 170))
music_text = MAIN_FONT.render("Music:", True, (170, 170, 170))
# Движение фона
self.sc.blit(BACKGROUND,
(0, self.BACKGROUND_offset - BACKGROUND.get_height()))
self.sc.blit(BACKGROUND, (0, self.BACKGROUND_offset))
self.BACKGROUND_offset += self.BACKGROUND_speed
if self.BACKGROUND_offset > BACKGROUND.get_height():
self.BACKGROUND_offset = 0
self.sc.blit(BACK_BUTTON,
(0, self.sc.get_height() - int(str_dict.get('button_y'))))
# Кнопки сложности
self.easy_b_rect = self.sc.blit(easy_b, (40, 180))
self.medium_b_rect = self.sc.blit(medium_b, (150, 180))
self.hard_b_rect = self.sc.blit(hard_b, (260, 180))
# Текст около слайдеров
self.sc.blit(sound_text,
(self.frame_w * 1 // 10 - 10, self.frame_h * 1 // 10 - 5))
self.sc.blit(music_text,
(self.frame_w * 1 // 10 - 1, self.frame_h * 2 // 10 - 5))
self.sc.blit(settings_txt,
((self.frame_w - settings_txt.get_width()) // 2,
settings_txt.get_height()))
self.music_vol_slider.draw()
self.sound_vol_slider.draw()
# Изменение громкости если значение было изменено
if self.mus_curr_vol != self.music_vol_slider.getValue():
self.change_volume(music=True,
volume=self.music_vol_slider.getValue())
self.mus_curr_vol = self.music_vol_slider.getValue()
if self.snd_curr_vol != self.sound_vol_slider.getValue():
self.change_volume(music=False,
volume=self.sound_vol_slider.getValue())
self.snd_curr_vol = self.sound_vol_slider.getValue()
pygame.display.update()
# Изменение громкости, music - отвечает за тип звуков (True - изменение громкости музыки, False - остальных звуков)
def change_volume(self, music=False, volume=99):
volume /= 100
for i in self.sounds.keys():
if not (music ^ ('music' in i)):
for j in self.sounds[i]:
pygame.mixer.Channel(j).set_volume(volume)
def settings(mode='STANDARD'):
pygame.init()
json_file = open(os.getcwd() + r"\components\constants.json", "r")
json_content = json.load(json_file)
round_int = json_content["round_int"]
json_file.close()
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREY = (100, 100, 100)
BROWN = (138, 79, 28)
font = pygame.font.SysFont("DejaVu Sans", 30)
# RED = (255, 0, 0), GREEN = (0, 255, 0), BLUE = (0, 0, 255)
screen = pygame.display.set_mode((720, 480))
screen.fill(BROWN)
clock = pygame.time.Clock()
pygame.display.update()
title_label = font.render(mode, True, BLACK)
Player1_label = font.render("Player 1:", True, BLACK)
Player2_label = font.render("AI Difficuly:", True, BLACK)
Player1 = InputBox(345, 200, 120, 32, WHITE, GREY)
bot_diff = Slider(screen,
350,
260,
120,
15,
min=1,
max=20,
step=1,
initial=6)
Accept_Button = Button(x=300,
y=300,
w=100,
h=50,
color_b=BLACK,
color_in=WHITE,
color_t=WHITE,
command=lambda: [
main(player1=Player1.export(),
player2='Computer',
mode=mode,
bot_bool=True,
bot_difficulty=bot_diff.getValue())
],
text='Start Game')
while True:
clock.tick(60)
for event in pygame.event.get():
if event.type == pygame.QUIT:
quit()
Player1.checkActivation(event)
bot_diff.listen(event)
Accept_Button.processEvent(event)
screen.fill(BROWN)
screen.blit(Player1_label, (150, 200))
screen.blit(Player2_label, (150, 250))
screen.blit(title_label, (pygame.display.get_window_size()[0] / 2 -
title_label.get_rect().w / 2, 30))
Player1.draw(screen)
bot_diff.draw()
Accept_Button.draw(screen)
pygame.display.flip()
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))
pygame.gfxdraw.aacircle(screen, arrow_tup[2][0], arrow_tup[2][1], 15,
(0, 255, 255, 250))
#-------------------------------------------------------------------
# Keyboard and Mouse Interactions
#-------------------------------------------------------------------
events = pygame.event.get()
keys = pygame.key.get_pressed()
c1, c2, c3 = pygame.mouse.get_pressed()
mx, my = pygame.mouse.get_pos()
if c3:
theta = -np.arctan2(mx - origin[0], my - origin[1]) + np.pi
omega = 0
if c2:
origin = [mx, my]
omega = 0
if keys[pygame.K_q]:
done = True
slider.listen(events)
slider.draw()
l = slider.getValue(
) + 0.001 # a value of zero will result in a divide by zero error
output.setText("{:.2f}m".format(slider.getValue()))
output.draw()
pygame.display.flip()
if keys[pygame.K_s]:
pygame.image.save(
screen,
datetime.now().strftime("CapturedImages/%m%d%Y_%H%M%S.png"))
clock.tick(framerate)
pygame.display.quit()
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:
CONSTANTS['x_move'] = -xslider.getValue()
else: