class start:
''' Gera uma classe onde há a tela de partida do jogo da memória.
'''
def __init__(self):
'''Cria os Elementos principais que aparecerão na tela e seus lugares.
'''
self.inicio = Cena(TELA_INICIAL)
self.pegadinha = Elemento(PEGADINHA,
tit="PLAY",
texto="Não é TOUCH",
x=260,
y=170,
w=50,
h=50,
cena=self.inicio)
self.solucao = Elemento(CLIQUE,
tit="MOUSE",
x=380,
y=285,
w=60,
h=60,
cena=self.inicio)
'''O bind liga um evento a um método
.. code-block:: python
widget.bind(event, handler)
'''
#self.solucao.elt.bind("click", self.chama)
def vai(self):
self.inicio.vai()
def anda_boneco(self, ev=None):
matrizPosicaoInicial = [
[60, 280], #matrizPosicaoInicial = [[x_inicial, y_inicial]...]
[450, 50],
[50, 430],
[200, 50]
]
"""" Faz o boneco caminhar com a catura das setas.
:param ev: Importa evento de teclado através do browser.
:retun: self.boneco.x como a posição x do personagem e self.boneco.y como a posição y
"""
key = ev.keyCode # recupera o código da tecla enviada no evento
# os códigos 37 e 38 são a seta para esquerda e para direita
# os códigos 39 e 40 são a seta para cima e para baixo
if key in [37, 39]:
key = (key - 38) * 5
self.boneco.x += key # muda a posição de mais um ou menos um
elif key in [38, 40]:
key = (key - 39) * 5
self.boneco.y += key # muda a posição de mais um ou menos um
#estudo da parede
#if self.boneco.x <= 80
""":if: O personagem atingiu uma porta, muda para a próxima cena
"""
# FALTA mapear os pontos, criar função para passar parametros ou chamar outra classe
#ideia de cria uma matriz com os pontos de localização do portal
if self.boneco.x > 400 and self.boneco.y > 200:
global cont #contador estanciado fora do def para gerar a linha a ser lida na lista/MAtriz
self.ambiente = Cena(
self.listaFase[cont]
) #lê a cena que está descrita no primeiro ítem da lista
STYLE["width"] = 640
self.x2 = int(
matrizPosicaoInicial[cont][0]
) #posição x_inicial da fase, descrita na matriz pela primeira coluna
self.y2 = int(
matrizPosicaoInicial[cont]
[1]) #posição y_inicial da fase descita pela segunda coluna
self.boneco = Elemento(self.BONECO,
x=self.x2,
y=self.y2,
cena=self.ambiente)
""":Contador: cont: Varia a cada momento que o *if* é satisfeito a ser utilizado em cada cenário e posicição
:param self.ambiente: Novos cenários das seguintes fases.
:param self.x2: Posição x inicial das novas fases.
:param self.y2: Posição y inicial das novas fases.
"""
self.boneco.x = self.x2
self.boneco.y = self.y2
self.ambiente.vai()
cont = cont + 1
if cont > 3: #Regulador do contador. Precisa alterar a programação para voltar a fase em um portal de retorno
cont = 0
def __init__(self):
"""Gera o início do jogo com a posição do personagem e a primeira cena
:return: self.boneco com parâmetros (personagem, poisção_x, posição_y, cenário)
"""
self.x1 = 100
self.y1 = 40
self.ambiente = Cena(self.CENA_corredor_1)
self.boneco = Elemento(self.BONECO,
x=self.x1,
y=self.y1,
cena=self.ambiente)
document.bind("keydown",
self.anda_boneco) # captura o evento de teclado
def __init__(self):
self.lado = TAMANHO // 8
self.tabuleiro = Cena(self.MADEIRA)
margin = self.lado // 3
self.tabua = self.table(self.tabuleiro,
self.TABULEIRO,
mx=margin,
my=margin,
livre=True)
mx, my = self.lado // 3, 0.66 * self.lado
self.tab_topo = self.table(self.tabuleiro, self.MINITAB, 2, 4, 0, 1,
50, 50)
self.tab_lado = self.table(self.tabuleiro, self.MINITAB, 4, 2, 5, 4,
50, 60)
self.pin_topo = Pino.pinos("topo", self.tab_topo)
self.pin_lado = Pino.pinos("lado", self.tab_lado) # , dy=101.5)
def __init__(self):
'''Cria os Elementos principais que aparecerão na tela e seus lugares.
'''
self.inicio = Cena(TELA_INICIAL)
self.pegadinha = Elemento(PEGADINHA,
tit="PLAY",
texto="Não é TOUCH",
x=260,
y=170,
w=50,
h=50,
cena=self.inicio)
self.solucao = Elemento(CLIQUE,
tit="MOUSE",
x=380,
y=285,
w=60,
h=60,
cena=self.inicio)
'''O bind liga um evento a um método
class Eventos:
""" Associa um evento a uma imagem
"""
CENA_corredor_1 = "https://i.imgur.com/L71ZV6Z.png"
CENA_corredor_2 = "https://i.imgur.com/5Qno2fs.png"
CENA_corredor_3 = "https://i.imgur.com/gZ5wc0h.png"
CENA_corredor_4 = "https://i.imgur.com/xI8i7Nc.png"
CENA_corredor_5 = "https://i.imgur.com/GLVctqb.png"
listaFase = [
CENA_corredor_2, #listaFase = [local_imagem_fase,...]
CENA_corredor_3,
CENA_corredor_4,
CENA_corredor_5,
]
BONECO = "https://i.imgur.com/k63kwfa.png"
STYLE["width"] = 640 #tamanho da cena
def __init__(self):
"""Gera o início do jogo com a posição do personagem e a primeira cena
:return: self.boneco com parâmetros (personagem, poisção_x, posição_y, cenário)
"""
self.x1 = 100
self.y1 = 40
self.ambiente = Cena(self.CENA_corredor_1)
self.boneco = Elemento(self.BONECO,
x=self.x1,
y=self.y1,
cena=self.ambiente)
document.bind("keydown",
self.anda_boneco) # captura o evento de teclado
def vai(self):
""" :return: Cenário do labirinto.
"""
self.ambiente.vai()
def anda_boneco(self, ev=None):
matrizPosicaoInicial = [
[60, 280], #matrizPosicaoInicial = [[x_inicial, y_inicial]...]
[450, 50],
[50, 430],
[200, 50]
]
"""" Faz o boneco caminhar com a catura das setas.
:param ev: Importa evento de teclado através do browser.
:retun: self.boneco.x como a posição x do personagem e self.boneco.y como a posição y
"""
key = ev.keyCode # recupera o código da tecla enviada no evento
# os códigos 37 e 38 são a seta para esquerda e para direita
# os códigos 39 e 40 são a seta para cima e para baixo
if key in [37, 39]:
key = (key - 38) * 5
self.boneco.x += key # muda a posição de mais um ou menos um
elif key in [38, 40]:
key = (key - 39) * 5
self.boneco.y += key # muda a posição de mais um ou menos um
#estudo da parede
#if self.boneco.x <= 80
""":if: O personagem atingiu uma porta, muda para a próxima cena
"""
# FALTA mapear os pontos, criar função para passar parametros ou chamar outra classe
#ideia de cria uma matriz com os pontos de localização do portal
if self.boneco.x > 400 and self.boneco.y > 200:
global cont #contador estanciado fora do def para gerar a linha a ser lida na lista/MAtriz
self.ambiente = Cena(
self.listaFase[cont]
) #lê a cena que está descrita no primeiro ítem da lista
STYLE["width"] = 640
self.x2 = int(
matrizPosicaoInicial[cont][0]
) #posição x_inicial da fase, descrita na matriz pela primeira coluna
self.y2 = int(
matrizPosicaoInicial[cont]
[1]) #posição y_inicial da fase descita pela segunda coluna
self.boneco = Elemento(self.BONECO,
x=self.x2,
y=self.y2,
cena=self.ambiente)
""":Contador: cont: Varia a cada momento que o *if* é satisfeito a ser utilizado em cada cenário e posicição
:param self.ambiente: Novos cenários das seguintes fases.
:param self.x2: Posição x inicial das novas fases.
:param self.y2: Posição y inicial das novas fases.
"""
self.boneco.x = self.x2
self.boneco.y = self.y2
self.ambiente.vai()
cont = cont + 1
if cont > 3: #Regulador do contador. Precisa alterar a programação para voltar a fase em um portal de retorno
cont = 0
class JogoDoQuarto:
""" Jogo do Quarto - Jogo de Tabuleiro.
Quarto é um jogo de tabuleiro para dois jogadores inventado pelo matemático suíço Blaise Müller em 1991.
O jogo é jogado em um tabuleiro 4 × 4. Existem 16 peças únicas para brincar, cada uma das quais é:
- alto ou baixo;
- vermelho ou azul (ou um par diferente de cores, por exemplo, madeira manchada de clara ou escura);
- quadrado ou circular; e
- topo oco ou topo sólido.
Os jogadores se revezam na escolha de uma peça que o outro jogador deve colocar no tabuleiro.
Um jogador vence colocando uma peça no tabuleiro que forma uma linha horizontal,
vertical ou diagonal de quatro peças, todas com um atributo em comum
(todas curtas, todas circulares, etc.). Uma regra de variante incluída em muitas edições
fornece uma segunda maneira de ganhar colocando quatro peças correspondentes em um quadrado 2 × 2.
"""
MADEIRA = "https://i.imgur.com/8mPjfYk.jpg" # Textura do fundo do jogo.
TABULEIRO = "https://i.imgur.com/yPFsdKw.png" # Desenho da casa no tabuleiro central.
MINITAB = "https://i.imgur.com/DjKe0KY.png" # Desenho da casa no tabuleiro adjacente.
def __init__(self):
self.lado = TAMANHO // 8
self.tabuleiro = Cena(self.MADEIRA)
margin = self.lado // 3
self.tabua = self.table(self.tabuleiro,
self.TABULEIRO,
mx=margin,
my=margin,
livre=True)
mx, my = self.lado // 3, 0.66 * self.lado
self.tab_topo = self.table(self.tabuleiro, self.MINITAB, 2, 4, 0, 1,
50, 50)
self.tab_lado = self.table(self.tabuleiro, self.MINITAB, 4, 2, 5, 4,
50, 60)
self.pin_topo = Pino.pinos("topo", self.tab_topo)
self.pin_lado = Pino.pinos("lado", self.tab_lado) # , dy=101.5)
def vai(self):
""" Aloca esta cena na página do navegador.
"""
self.tabuleiro.vai()
def table(self,
base,
fundo,
linhas=5,
colunas=5,
dx=0,
dy=3,
mx=0,
my=0,
livre=False):
""" Cria um conjunto de casas de um tipo e aloca na cena dada.
:param base: A cena em que este tabuleiro vai entrar.
:param fundo: A imagem que representa cada casa.
:param livre: Indica se as casas estão livres ou ocupadas quando forem criadas.
:param t: Tamanho (altura e largura do desenho da casa, inicia em um oitavo do tabuleiro.
:param linhas: O número de linhas de casas neste tabuleiro.
:param colunas: O número de colunas de casas neste tabuleiro.
:param dx: O deslocamento horizontal em casas que cada casa tem em relação à esquerda.
:param dy: O deslocamento vertical em casas que cada casa tem em relação ao topo.
:param mx: Ajuste fino horizontal em pixels do posicionamento de cada casa.
:param my: Ajuste fino vertical em pixels do posicionamento de cada casa.
:return: Uma tabela de duas dimensões de casas arranjadas nas posições dadas.
:rtype: Lista de listas contendo instâncias da classe Casa.
"""
return [[
Casa(base, fundo, i, j, dx, dy, mx, my, livre)
for j in range(linhas)
] for i in range(colunas)]
def __init__(self, cenas, tw=None, th=600, nx=4, ny=3, ofx=OFX, ofy=OFY):
class Face(Elemento):
"""Reperesenta a face do cubo.
A face do cubo é sensível ao click em quatro diferentes porções cardeais.
As porções cardeais são delimitadas pela duas diagonais do cubo.
A face pertencente a um cubo do quebra-cabeças.
:param cubo: o cubo ao qual pertence.
:param inx: índice do cubo no quebra-cabeças.
:param face: parte do endereço IMGUR da imagem.
:param kwargs: parâmenteros a serem passados para o elemento 'Vitollino'.
"""
def __init__(self, cubo, inx, face, **kwargs):
"""
"""
self.cubo = cubo
w, h = tw // nx, th // ny
self.dh = h
x, y = (inx % nx) * w, (inx // nx) * h
super().__init__(IMGUR.format(face), x=x + ofx, y=y - OFF + ofy, w=w, h=h,
cena=cena, vai=self.vai,
style={'background-image': "url({})".format(IMGUR.format(face)),
'background-size': f"{tw}px {th}px",
"background-position": f'{-x}px {-y}px'},
**kwargs)
# self.siz = (tw, th)
# self.pos = (-x, -y)
self.yy = y - OFF + ofy
self.xx = x + OFX
self.elt.style.width = f"{w}px"
self.elt.style.height = f"{h}px"
self.elt.html = ""
self.quad = 0
@property
def xx(self):
top = self.elt.style.left[:-2]
return int(top if top else 0)
@xx.setter
def xx(self, value):
self.elt.style.left = "{}px".format(value)
@property
def yy(self):
top = self.elt.style.top[:-2]
return int(top if top else 0)
@yy.setter
def yy(self, value):
self.elt.style.top = "{}px".format(value)
def show(self):
"""Mostra esta face do cubo.
:return: sempre verdadeiro, para indicar que a face está sendo mostrada.
"""
self.yy += OFF if self.yy < -10 else 0
return True
def hide(self):
"""Esconde esta face do cubo.
:return: sempre falso, para indicar que a face está sendo ocultada.
"""
self.yy -= OFF if self.yy > 10 else 0
return False
def orient(self, ori):
""" Reorienta a face para refletir as rolagens do cubo.
:param ori: qudrante da rotação da face, entre 0 e 3.
:return: sempre falso.
"""
self.elt.style.transform = f"rotate({ori * 90}deg)"
return False
def vai(self, evt):
"""Recebe o click na face e calcula qual quadrante cardeal foi clicado.
Calcula a posição relativa do click na face.
Determina o click em relação às duas diagonais da face.
As diagonais são x=-y e x=y+h.
:param evt: evento recebido do nvegador.
:return:
"""
e = evt.target
dim = e.getBoundingClientRect()
x = evt.clientX - dim.left
y = evt.clientY - dim.top
e, n, h = x - y, x + y, self.dh
self.quad = 0 if (e > 0) and (n < h) else 1 if (e > 0) and (n > h) else 2 if (e < 0) and (n > h) else 3
# Cubo.CUBOS.write(f"x: {x} y: {y} qd: {self.quad}")
self.cubo.go(self.quad)
class Cubo:
"""Cubo para formar um quebra-cabeças de seis imagens.
Cada cubo contém um recorte quadrado de cada uma das seis imagens nas suas faces.
O cubo rola quando se clica na face que esta sendo apresentada (virada para cima).
Ao rolar, o cubo vai apresentar uma nova face, dada pela direção indicada na rolagem.
"""
ROLL = [
[[19, 4, 21, 12], [18, 8, 22, 0], [17, 12, 23, 4], [16, 0, 20, 8], [6, 1, 12, 11], [12, 3, 6, 10]],
[[5, 22, 13, 16], [9, 23, 1, 19], [13, 20, 5, 18], [1, 21, 9, 17], [2, 13, 8, 7], [0, 7, 10, 13]],
[[23, 14, 17, 6], [20, 2, 16, 10], [21, 6, 19, 14], [22, 10, 18, 2], [14, 9, 4, 3], [4, 11, 14, 1]],
[[15, 18, 7, 20], [3, 17, 11, 21], [7, 16, 15, 22], [11, 19, 3, 23], [10, 5, 0, 15], [8, 15, 2, 5]],
]
"""Vetor que representa o índice destino da rolagem dado um clique numa face."""
def __init__(self, inx, faces):
"""Cubo que tem os recortes das seis imagens nas suas faces.
:param inx: índice posicional do cubo no quebra-cabeças, no sentido da leitura.
:param faces: lista com as seis imagens que serão apresentadas nas faces do cubo.
"""
self.faces = [Face(cubo=self, inx=inx, face=face) for face in faces]
self.face, self.orient = 0, 0
def roll(self, inx):
"""Rola o dado na direção indicada.
Caso esta rolagem complete uma das imagens do quebra-cabeça, indica sucesso.
:param inx: índice que representa uma combinação da face com a orientação.
:return: None
"""
facer, self.orient = inx // 4, inx % 4
self.face = [face.show() if facer == face_index else face.hide()
for face_index, face in enumerate(self.faces)].index(True)
self.faces[self.face].orient(self.orient)
Cubo.CUBOS.write("completou com sucesso") if Cubo.CUBOS.complete() else None
@property
def inx(self):
"""Índice que representa uma combinação da face com a orientação.
:return: índice que representa uma combinação da face com a orientação.
"""
return self.face * 4 + self.orient
def go(self, inx):
go_face_roll = Cubo.ROLL[self.orient][self.face][inx]
self.roll(go_face_roll)
# fc1, ot1 = self.face, self.orient
# Cubo.CUBOS.write(f"inx: {inx} face: {fc0} ori: {ot0} gfr: {go_face_roll} face: {fc1} ori: {ot1} ")
cena = Cena(IMGUR.format(FUNDO)).vai()
tw, th = (tw, tw // nx * ny) if tw else (th // ny * nx, th)
Cubo.CUBOS = self
self.el = Elemento(IMGUR.format(FUNDO), w=300, h=100, cena=cena, style={"color": "white"})
self.cubos = cubos = [Cubo(inx=inx, faces=cenas) for inx in range(nx * ny)]
[cube.roll(randint(0, 23)) for cube in cubos]