def __init__(self, parent=None):
pyqtgraph.setConfigOption('background', 'w')
super(Dynamic_Gui, self).__init__(parent)
self.setupUi(self)
self.grFFTx.plotItem.showGrid(True, True, 0.7)
self.grFFTy.plotItem.showGrid(True, True, 0.7)
self.grFFTz.plotItem.showGrid(True, True, 0.7)
self.grAccX.plotItem.showGrid(True, True, 0.7)
self.grAccY.plotItem.showGrid(True, True, 0.7)
self.grAccZ.plotItem.showGrid(True, True, 0.7)
self.maxFFTx = 0
self.maxFFTy = 0
self.maxFFTz = 0
self.maxAccX = 0
self.maxAccY = 0
self.maxAccZ = 0
self.textEdit = "Hello World!"
#read available com ports
self.data = DataHandling.DataHandling()
self.comboBox.clear()
self.comboBox.addItem("Select...")
for p in self.data.portList():
self.comboBox.addItem(str(p))
self.comboBox.currentIndexChanged.connect(self._connectComPort)
# self.comboBox.highlighted.connect(self._connectComPort)
#connect the buttons
self.btnOpenPort.clicked.connect(self._btnOpenPort)
self.btnStartStream.clicked.connect(self._btnStartStream)
self.btnStopStream.clicked.connect(self._btnStopStream)
# self.actionClose.triggered.connect(QtGui.qApp.quit)
self.actionData_Folder.triggered.connect(self._actionFolderSave)
def __init__(self, controller, multPlayer=False, score1=0, player=1):
#---------------------------------------------
#***Configuraciones de la ventana y Tkinter***
#---------------------------------------------
#Se designa una variable self.master para inicializar la ventana principal del juego.
self.master = Tk()
#Se designa un widget de Canvas para el juego y otro para el HUD.
self.master.geometry("1100x700")
self.master.configure(bg="black")
#self.master.iconbitmap("assets/favicon.ico")
self.w = Canvas(self.master,
width=1100,
height=650,
bg="gray10",
highlightbackground="black")
self.hud = Canvas(self.master,
width=1100,
height=50,
bg="#e8e8e8",
highlightbackground="black")
self.dibujar = Fractal(self.w)
r = lambda: random.randint(0, 300)
self.dibujar.Fractal(None, r(), r(), 'white', 1, 3)
self.controller = controller
self.settings = DataHandling("settings.json").load_data()
self.multPlayer = multPlayer
self.score1 = score1
self.player = player
#Título de la ventana.
self.master.title("Juego")
#Se restringe el tamaño de la ventana al especificado en el widget.
self.master.resizable(width=0, height=0)
self.flag = True
'''
La función verificarCoordenadas se usar para evitar que se creen elementos del juego sobre otros elementos ya creados.
'''
def verificarCoordenadas(rango):
#Este bucle infinito se usa para establecer coordenadas que no estén ocupadas por otros objetivos.
while (True):
x1 = random.randint(100, 1000)
y1 = random.randint(50, 400)
disponible = self.w.find_overlapping(x1 - rango, y1 - rango,
x1 + rango, y1 + rango)
if (len(disponible) == 0):
return x1, y1
'''
La función generarObjetivos crea una lista en la que almacenará listas con las coordenadas, el color
y los puntos de los objetivos, para asignar colores se hace uso de una tupla con los
códigos hexadecimales y se utiliza un número aleatorio para seleccionar. Las coordenadas se
generan con valores aleatorios en un rango específico y los puntajes se definen sumando 4
al número aleatorio del color y multiplicando el resultado por el valor que tenga el multiplicador
dependiendo de la dificultad establecida.
Se retorna una matriz con todos los self.objetivos representados por una fila.
'''
def generarObjetivos(cantidad):
objetivos = []
colores = ("#f48c42", "#bbf441", "#41d0f4", "#f441dc")
for i in range(0, cantidad):
x1, y1 = verificarCoordenadas(15)
valor = random.randint(0, 100)
if (valor >= 0 and valor < 50):
color = 0
elif (valor >= 50 and valor < 75):
color = 1
elif (valor >= 75 and valor < 90):
color = 2
elif (valor >= 90):
color = 3
puntos = (color + 4) * self.mult
objetivos.append([
self.w.create_oval(x1,
y1,
x1 + 30,
y1 + 30,
fill=colores[color],
tags='target'), puntos
])
return objetivos
'''
La función generarObstaculos funciona de manera similar a generarObjetivos, con la diferencia que cada
coordenada tiene un valor diferente para que varíe su forma, se verifica que los obstáculos no estén encima de otros
obstáculos u objetivos.
'''
def generarObstaculos(cantidad):
obstaculos = []
for i in range(0, cantidad):
while (True):
x1 = random.randint(100, 1000)
y1 = random.randint(50, 400)
xa = x1 - random.randint(10, 50)
ya = y1 - random.randint(10, 50)
xb = x1 + random.randint(10, 50)
yb = y1 + random.randint(10, 50)
disponible = self.w.find_overlapping(xa, ya, xb, yb)
if (len(disponible) == 0):
break
obstaculos.append(
self.w.create_rectangle(xa,
ya,
xb,
yb,
fill="black",
tags='obstacle'))
return obstaculos
'''
La función generarPowerUps genera los objetivos que suman tiempo y generará un power up aleatorio
'''
def generarPowerUps(cantidad):
powerUps = []
tipos = (
("#fff9af", "#ff9900", "timer"), ("#800080", "#ff9900",
"+Retrocesos"),
("#fede12", "#ff9900", "Puntos_x2"), ("#ff6666", "#ff9900",
"+Rango"),
("#8c0000", "#ff9900", "-Obstaculo")) #(Relleno, borde, tag)
for i in range(0, cantidad):
x1, y1 = verificarCoordenadas(30)
powerUps.append(
self.w.create_oval(x1,
y1,
x1 + 30,
y1 + 30,
fill=tipos[0][0],
outline=tipos[0][1],
width=3,
tags=tipos[0][2]))
MegapowerUp = random.randint(1, len(tipos) - 1)
x2, y2 = verificarCoordenadas(30)
powerUps.append(
self.w.create_oval(x2,
y2,
x2 + 30,
y2 + 30,
fill=tipos[MegapowerUp][0],
outline=tipos[MegapowerUp][1],
width=3,
tags=tipos[MegapowerUp][2]))
return powerUps
#Se crea un limitador de retrocesos, un multiplicador de puntos y la cantidad de obstáculos dependiendo de la dificultad del juego.
self.dif = self.settings["difficulty"]["value"]
if (self.dif == 1):
self.retrocesosMax = 5
self.cantidadObstaculos = 5
self.mult = 11
self.cantidadPowerUps = 6
elif (self.dif == 2):
self.retrocesosMax = 3
self.cantidadObstaculos = 8
self.mult = 13
self.cantidadPowerUps = 4
elif (self.dif == 3):
self.retrocesosMax = 1
self.cantidadObstaculos = 12
self.mult = 15
self.cantidadPowerUps = 2
else:
self.retrocesosMax = 0
self.cantidadObstaculos = 14
self.mult = 18
self.cantidadPowerUps = 0
#Se define la cantidad de objetivos a generar.
self.cantidadObjetivos = 6
#Se crean los objetivos usando la cantidad especificada anteriormente.
self.objetivos = generarObjetivos(self.cantidadObjetivos)
#Se generan los obstáculos del juego.
self.obstaculos = generarObstaculos(self.cantidadObstaculos)
#Se generan los power ups.
self.powerUps = generarPowerUps(self.cantidadPowerUps)
#Se asigna el tiempo que tendrá el jugador para alcanzar todos los objetivos.
self.tiempo = 30
self.tipoT = 0
#Se define el .puntaje máximo para terminar el juego al alcanzarlo.
self.puntajeMax = 0
for valor in self.objetivos:
self.puntajeMax += valor[1]
#Si es 1 el siguiente objetivo alcanzado dará doble puntaje
self.doblePuntaje = 0
self.w.pack()
self.hud.pack()
#Se define el puntaje con valor inicial de cero y el contador del turno.
self.puntaje = 0
self.movimiento = 0
#Se muestran tanto el puntaje como el número del movimiento y el temporizador en el HUD.
self.marcadorP = self.hud.create_text(30,
22,
text="Puntaje: 000" +
str(self.puntaje),
anchor="w",
font=("", "12", "bold"))
self.hud.create_line(161, 0, 161, 50, width=3)
self.hud.create_line(922, 0, 922, 50, width=3)
self.marcadorM = self.hud.create_text(951,
22,
text="Movimiento #00" +
str(self.movimiento + 1),
anchor="w",
font=("", "12", "bold"))
self.timer = self.hud.create_text((408, 22),
text="Texto",
font=("", "12", "bold"),
fill="#0048b5")
self.hud.create_line(460, 0, 460, 50, width=3)
self.textoPU = self.hud.create_text(530,
22,
text="???",
font=("", "12", "bold"),
fill="black")
self.hud.create_line(600, 0, 600, 50, width=3)
#Rango máximo y mínimo para generar un fractal nuevo.
self.minimo = 25
self.maximo = 40
self.retrocesos = 0
#Se muestra la cantidad de retrocesos en el HUD.
self.marcadorR = self.hud.create_text(195,
22,
text="Retrocesos: " +
str(self.retrocesos) + "/" +
str(self.retrocesosMax),
anchor="w",
font=("", "12", "bold"))
self.hud.create_line(350, 0, 350, 50, width=3)
#Se definen los puntos de inicio de la hitbox.
self.xInicial, self.yInicial = 550, 610
#Se crea una lista que almacenará las acciones realizadas en cada turno.
self.circulos = [[
self.w.create_line(550, 650, 550, 610), self.xInicial,
self.yInicial,
self.w.create_oval(self.xInicial - 2,
self.yInicial - 2,
self.xInicial + 2,
self.yInicial + 2,
fill="black"), self.movimiento, []
]]
#Se reproduce la música de fondo.
if (self.settings["sounds"]["value"] == 1):
try:
winsound.PlaySound("assets/sound.wav", winsound.SND_ASYNC)
except NameError:
pass