def render(self):
""" Affichage des éléments du jeu """
if self.cinematiqueIsPlaying is False and not self.dead:
self.map.render()
self.player.render()
self.batch.draw()
for ent in self.level.enemies:
ent.render()
for item in self.level.items:
item.render()
self.ui.render(self.camera.x, self.camera.y, self.player)
elif self.cinematiqueIsPlaying and self.level.cinematique:
width, height = gameEngine.getDinamicWindowSize()
self.camera.setPos(width / 2, height / 2)
self.cinematiqueIsPlaying = self.level.cinematique.run()
elif self.dead:
width, height = gameEngine.getDinamicWindowSize()
self.camera.setPos(width / 2, height / 2)
self.deadLabel.x, self.deadLabel.y = width / 2 + 50, height / 2
self.deadLabel.draw()
return self.returnState
def on_key_press(self, symbol, modifiers):
if symbol == key.ESCAPE:
width, height = gameEngine.getDinamicWindowSize()
self.returnState = "menu"
# - Key interaction on the inputs -
elif self.exportMapBox.show:
if symbol == key.RETURN:
# close the export menu, then export the map
self.exportMapBox.toggle()
self.set_focus(None)
if self.exportMapBox.widgets[0].document.text != "":
fixOffset(self.map, self.levelItemList)
exportMap(self.map, self.exportMapBox.widgets[0].document.text)
else:
self.exportMapBox.widgets[0].rectangle.vertex_list.colors[:16] = [255, 0, 0, 255] * 4
elif self.exportLevelBox.show:
if symbol == key.RETURN:
# close the export menu, then export the map
self.exportLevelBox.toggle()
self.set_focus(None)
if self.exportLevelBox.widgets[0].document.text != "":
fixOffset(self.map, self.levelItemList)
w = self.exportLevelBox.widgets
exportLevel(w[0].document.text, w[2].document.text, w[3].document.text, w[1].document.text, self.levelItemList)
else:
self.exportLevelBox.widgets[0].rectangle.vertex_list.colors[:16] = [255, 0, 0, 255] * 4
# - Change from map editor to level editor -
elif symbol == key.TAB:
if self.selectedEditor == "map":
self.selectedEditor = "level"
else:
self.selectedEditor = "map"
# - Specific action for map editor -
elif self.selectedEditor == "map":
# - Export map -
if symbol == key.RETURN:
# - Toggle the state of the exportbox
self.exportMapBox.toggle()
# - Center position to map origin -
if symbol == key.O:
width, height = gameEngine.getDinamicWindowSize()
self.offsetPos.set(-width/2, -height/2)
# - Specific actions for level editor -
elif self.selectedEditor == "level":
if symbol == key.RETURN:
self.exportLevelBox.toggle()
def __init__(self, ch=None, path=None, x=250, y=250, w=48, h=48):
"""
Dessine une image "path" a la position (x,y)
Si il y a une balise <move x="350" y="325" timeStart="2" timeStop="3"/>
l'image bouge jusqu'en (x,y) a partir du temps timeStart jusqu'au temps timeStop
:param batch: Batch dans lequel inserer notre sprite
:param ch: Enfants, pour avoir les transitions
:param path: Chemin vers l'image
:param x: x initial
:param y: y initial
:type batch: Batch
:type ch: XML
:type path: str
:type x: str | int
:type y: str | int
"""
self.animation = animation.AnimationGroup()
self.animation.createFromImage(pyglet.image.load(path), int(w), int(h))
self.animation.setFrameRate(4.0/50.0)
self.animation.selectAnimation(3)
self.animation.setIdleState()
self.centerX, self.centerY = gameEngine.getDinamicWindowSize()[0] / 2, gameEngine.getDinamicWindowSize()[1] / 2
# - Position -
self.dx = int(x)
self.dy = int(y)
self.width = int(w)
self.height = int(h)
# Pour garder une vitesse constante
self.startX = self.dx
self.startY = self.dy
# - Temps -
self.time = 0
# - Animation -
self.moveNb = 0
self.mvtDone = False
self.elmt = ""
# - Parsage des enfants avec des petits pois -
self.toDoMovement = {}
for elmt in ch:
if elmt.tag == "move": # Si on demande de move
attrib = {}
for i in elmt.attrib:
attrib[i] = elmt.attrib[i]
self.toDoMovement[elmt.attrib['timeStart']] = attrib # Alors on le mets dans le todo
self.keylist = self.toDoMovement.keys()
self.keylist.sort()
def animate(self, dt):
"""
Anime le tout selon les parametres definis auparavant
"""
self.W_WIDTH, self.W_HEIGHT = gameEngine.getDinamicWindowSize() # Actualisation de la taille
self.height = self.W_HEIGHT / 5
self.width = self.W_WIDTH
self.time += dt
# On simule
if(self.pos == "bot"): # Bordure en bas
self.y = (- self.W_HEIGHT / 5) + self.dy
if(int(self.y) < self.maxY):
self.dy += self.velY * dt
else:
self.y = self.maxY
elif(self.pos == "top"): # En haut
self.maxY = 4 * self.W_HEIGHT / 5 + 2
self.y = self.W_HEIGHT - self.dy
if(int(self.y) > self.maxY):
self.dy += self.velY * dt
else:
self.y = self.maxY
if(self.text is not None): # Si il y a du texte
for elmt in self.toDoChangeText:
if(int(self.time) >= int(elmt)):
self.text.text = self.toDoChangeText[elmt] # On le change
self.text.y = self.y + self.height / 2 # Et on le place au centre
self.text.x = self.x + self.width / 2
def refresh(self, dt, keysHandler):
"""
Check if the user is pressing movement keys. If he does
then we update the gloval offsetPos and the camera position
"""
width, height = gameEngine.getDinamicWindowSize()
# - block the update of the offset exporting -
if not self.exportLevelBox.show and not self.exportMapBox.show:
# - Acceleration with spacebar -
if keysHandler[key.SPACE]:
speed = int(1500 * dt)
else:
speed = int(1000 * dt)
# - up and down movement -
if keysHandler[key.Z]:
self.offsetPos.y += speed
elif keysHandler[key.S]:
self.offsetPos.y -= speed
# - left and right movement -
if keysHandler[key.Q]:
self.offsetPos.x -= speed
elif keysHandler[key.D]:
self.offsetPos.x += speed
# - Update camera pos -
self.camera.setPos(self.offsetPos.x + width/2, self.offsetPos.y + height/2)
def __init__(self):
# - Input handler -
# self.keysHandler = pyglet.window.key.KeyStateHandler()
# self.push_handlers(self.keysHandler)
# - variables -
width, height = gameEngine.getDinamicWindowSize()
self.offsetPos = Pos(-width / 2, -height / 2)
self.camera = Camera()
self.cursorPos = Pos(0, 0)
self.selectedCase = Pos(0, 0)
self.map = []
self.batch = pyglet.graphics.Batch()
self.levelBatch = pyglet.graphics.Batch()
self.returnState = "creator"
self.focus = None
self.selectedEditor = "map"
self.levelItemList = []
# Export Boxes
self.exportMapBox = ExportBox("map")
self.exportLevelBox = ExportBox("level")
# Selector
self.selector = Selector()
self.selector.selected = 10
def render(self, editorOffsetX, editorOffsetY):
if self.show:
width, height = gameEngine.getDinamicWindowSize()
# calculate tu position of the bottom left corner of the box
boxPos = Pos(editorOffsetX + width/2 - self.width/2, editorOffsetY + height/2 - self.height/2)
# - update label and sprite pos -
self.title.x, self.title.y = boxPos.x + 10, boxPos.y + self.height - 25
for i in xrange(len(self.fieldsTitle)):
self.fieldsTitle[i].x = boxPos.x + 10
self.fieldsTitle[i].y = boxPos.y + self.height - i * 50 - 50
for i in xrange(len(self.widgets)):
self.widgets[i].updatePos(boxPos.x + 10, boxPos.y + self.height - i * 50 - 75)
# - Draw the background box -
pyglet.gl.glColor4f(0, 0, 0, 0.5)
pyglet.gl.glBegin(pyglet.gl.GL_QUADS)
pyglet.gl.glVertex2i(boxPos.x, boxPos.y)
pyglet.gl.glVertex2i(boxPos.x + self.width, boxPos.y)
pyglet.gl.glVertex2i(boxPos.x + self.width, boxPos.y + self.height)
pyglet.gl.glVertex2i(boxPos.x, boxPos.y + self.height)
pyglet.gl.glEnd()
self.batch.draw()
def setPos(self, x, y):
self.x = x
self.y = y
width, height = gameEngine.getDinamicWindowSize()
pyglet.gl.glLoadIdentity()
pyglet.gl.glTranslated(width/2 - x, height/2 - y, 0)
def __init__(self):
# Vérification de l'existance d'une sauvegarde.
if os.path.isfile("data/save/save.data"):
self.existingSave = True
else:
self.existingSave = False
# général
width, height = gameEngine.getDinamicWindowSize()
self.returnState = "menu"
self._batch = pyglet.graphics.Batch()
self.colors = [[[33, 33, 33], [77, 77, 77]], [[77, 77, 77], [33, 33, 33]]]
self.bg = pyglet.sprite.Sprite(pyglet.image.load("data/sprites/fond.png"))
# Définition des couleurs
self.newColor = 0
self.continueColor = 0
self.rapidColor = 0
self.quitColor = 0
self.editColor = 0
# Texte
self.principalMenuText = pyglet.text.Label("Menu principal", font_size=40, batch=self._batch, anchor_x="center", anchor_y="top", x=width / 2, y=height - 10, color=(255, 255, 255, 255))
self.newText = pyglet.text.Label("Nouvelle partie", font_size=20, batch=self._batch, anchor_x="center", anchor_y="top", x=width / 2, y=self.principalMenuText.y - 160, color=(255, 255, 255, 255))
self.continueText = pyglet.text.Label("Continuer", font_size=20, batch=self._batch, anchor_x="center", anchor_y="top", x=width / 2, y=self.newText.y - 50, color=(255, 255, 255, 255))
self.rapidText = pyglet.text.Label("Partie rapide", font_size=20, batch=self._batch, anchor_x="center", anchor_y="top", x=width / 2, y=self.continueText.y - 50, color=(255, 255, 255, 255))
self.editText = pyglet.text.Label("Editeur", font_size=20, batch=self._batch, anchor_x="center", anchor_y="top", x=width / 2, y=self.rapidText.y - 50, color=(255, 255, 255, 255))
self.quitText = pyglet.text.Label("Quitter", font_size=20, batch=self._batch, anchor_x="center", anchor_y="top", x=width / 2, y=self.editText.y - 50, color=(255, 255, 255, 255))
if not self.existingSave:
self.rapidText.y = self.newText.y - 50
self.continueText.text = ""
def __init__(self, ch=None, text="", textSize="24", pos="bot", velY=80):
"""
Dessine une bordure noire a l'écran a la position pos
Si il y a une balise <textChange time="5">Text</textChange>, "Text" sera placé au milieu de la bordure a partir de la seconde 5
:param textSize: Taille de la police
:param height: Hauteur de la bordure
:param width: Largeur
:param velY: Vitesse en Y
:type textSize: int
:type height: int
:type width: int
:type velY: int|float
"""
# - Constantes -
self.W_WIDTH, self.W_HEIGHT = gameEngine.getDinamicWindowSize()
self.batch = pyglet.graphics.Batch()
# - Temps -
self.time = 0
# - Vitesse -
self.velY = int(velY)
# - Position -
self.pos = pos
self.x = 0
self.dy = 0
if(pos == "bot"):
self.y = -self.W_HEIGHT / 4
self.maxY = 0
elif(pos == "top"):
self.maxY = 3 * self.W_HEIGHT / 4 + 2
self.y = self.W_HEIGHT
self.height = self.W_HEIGHT / 4
self.width = self.W_WIDTH
# - Texte -
if(text is not None):
# - Contenu -
self.textContent = text
# - Size -
self.textSize = int(textSize)
self.text = pyglet.text.Label(self.textContent, font_size=self.textSize, batch=self.batch, anchor_x="center", anchor_y="center", x=self.width/2, y=self.height/2, color=(255, 255, 255, 255))
else:
self.text = None
# Parsage des childs avec des petits oignons
self.toDoChangeText = {}
for elmt in ch:
if elmt.tag == "textChange":
self.toDoChangeText[int(elmt.attrib['time'])] = elmt.text
self.toDoChangeText = collections.OrderedDict(sorted(self.toDoChangeText.iteritems()))
def render(self, offsetPos, state):
width, height = gameEngine.getDinamicWindowSize()
# - Background Selector -
pyglet.gl.glBegin(pyglet.gl.GL_POLYGON)
pyglet.gl.glColor4f(0, 0, 0, 0.75)
pyglet.gl.glVertex2i(offsetPos.x, offsetPos.y)
pyglet.gl.glVertex2i(offsetPos.x + TILE_SIZE/2 + 30, offsetPos.y)
pyglet.gl.glVertex2i(offsetPos.x + TILE_SIZE + 15, offsetPos.y + height/2 - TILE_SIZE/2 - 10)
pyglet.gl.glVertex2i(offsetPos.x + TILE_SIZE + 15, offsetPos.y + height/2 + TILE_SIZE/2 + 10)
pyglet.gl.glVertex2i(offsetPos.x + TILE_SIZE/2 + 30, offsetPos.y + height)
pyglet.gl.glVertex2i(offsetPos.x, offsetPos.y + height)
pyglet.gl.glEnd()
# - selected item background -
pyglet.gl.glBegin(pyglet.gl.GL_QUADS)
pyglet.gl.glColor4f(0, 0, 0, 1)
pyglet.gl.glVertex2i(offsetPos.x, offsetPos.y + height/2 - (10 + TILE_SIZE / 2))
pyglet.gl.glVertex2i(offsetPos.x + TILE_SIZE + 25, offsetPos.y + height/2 - (10 + TILE_SIZE / 2))
pyglet.gl.glVertex2i(offsetPos.x + TILE_SIZE + 25, offsetPos.y + height/2 + (10 + TILE_SIZE / 2))
pyglet.gl.glVertex2i(offsetPos.x, offsetPos.y + height/2 + (10 + TILE_SIZE / 2))
pyglet.gl.glColor4f(1, 1, 1, 1)
pyglet.gl.glEnd()
# - selected item white lines -
pyglet.gl.glBegin(pyglet.gl.GL_LINE_STRIP)
pyglet.gl.glColor4f(1, 1, 1, 1)
pyglet.gl.glVertex2i(offsetPos.x, offsetPos.y + height/2 - (10 + TILE_SIZE / 2))
pyglet.gl.glVertex2i(offsetPos.x + TILE_SIZE + 25, offsetPos.y + height/2 - (10 + TILE_SIZE / 2))
pyglet.gl.glVertex2i(offsetPos.x + TILE_SIZE + 25, offsetPos.y + height/2 + (10 + TILE_SIZE / 2))
pyglet.gl.glVertex2i(offsetPos.x, offsetPos.y + height/2 + (10 + TILE_SIZE / 2))
pyglet.gl.glColor4f(1, 1, 1, 1)
pyglet.gl.glEnd()
# on récupere les items du selector qui correspondent
# a l'éditeur actuel.
try:
itemList = self.items[state]
except:
return -1
# - Draw the textures in the selection panel -
for i in range(self.selected - 5, self.selected + 6):
sprite = pyglet.sprite.Sprite(itemList[i % len(itemList)].image)
# the textures proportinaly to there distance to the selected one.
sprite.scale = 1 - abs(self.selected - i) / 10.0
# Set position
sprite.x = offsetPos.x + 10
sprite.y = offsetPos.y + height / 2 - (self.selected - i) * (TILE_SIZE + 12) - TILE_SIZE/2 * sprite.scale
# Draw
sprite.draw()
def animate(self, dt):
"""
Anime le tout selon les parametres definis auparavant
"""
self.centerX, self.centerY = gameEngine.getDinamicWindowSize()[0] / 2, gameEngine.getDinamicWindowSize()[1] / 2
self.time += dt
try:
self.elmt = self.toDoMovement[self.keylist[self.moveNb]]
if(float(self.elmt['timeStop']) >= float(self.time) >= float(self.elmt['timeStart'])):
self.animation.unsetIdleState()
self.mvtDone = True
self.dx += dt * ((int(self.elmt['x']) - self.startX)) / (int(self.elmt['timeStop']) - int(self.elmt['timeStart']))
self.dy += dt * ((int(self.elmt['y']) - self.startY)) / (int(self.elmt['timeStop']) - int(self.elmt['timeStart']))
else:
if self.mvtDone:
self.startX = self.dx
self.startY = self.dy
self.animation.setIdleState()
self.moveNb += 1
self.mvtDone = False
except:
pass
def update(self, scroll, pos):
"""
Met à jour les informations de position de l'élément, afin de prendre en compte
le scroll.
:param scroll: Le scroll dans le selecteur, afin de calculer les positions.
:param pos: ni plus ni moins que l'index de l'item dans le tableaux des items du selecteur
:type scroll: int
:type pos: int
"""
width, height = gameEngine.getDinamicWindowSize()
height -= scroll + 5
self.vertex_list.vertices = [width / 4, height - self.HEIGHT * pos - 2, 3 * width / 4, height - self.HEIGHT * pos - 2, 2 * width / 3, height - self.HEIGHT * (pos + 1) + 2, width / 4, height - self.HEIGHT * (pos + 1) + 2]
self.label.x = width / 4 + 10
self.label.y = height - self.HEIGHT * pos - (self.HEIGHT - 4) / 2
def aim(self, x, y):
"""
Détermine le vecteur directeur de la droite passant par
le centre de l'écran et le pointeur de la souris.
On le détermine en divisant le vecteur défini
par le centre de l'écran et le curseur par sa norme.
:param x: coordonnée en x de la souris
:param y: coordonnée en y de la souris
:type x: int
:type y: int
"""
width, height = gameEngine.getDinamicWindowSize()
centerX = width / 2
centerY = height / 2 + self.mouthOffset
self.aimVector.set(x-centerX, y-centerY)
self.aimVector = self.aimVector.getUnitary()
def render(self):
"""
Update screen.
Daw map, grid, interface, texture selector.
"""
width, height = gameEngine.getDinamicWindowSize()
self.batch.draw()
self.levelBatch.draw()
# - Highlight the selected case -
pyglet.gl.glBegin(pyglet.gl.GL_QUADS)
pyglet.gl.glColor4f(1, 1, 1, 0.2)
pyglet.gl.glVertex2i(self.selectedCase.x * TILE_SIZE, self.selectedCase.y * TILE_SIZE)
pyglet.gl.glVertex2i(self.selectedCase.x * TILE_SIZE + TILE_SIZE, self.selectedCase.y * TILE_SIZE)
pyglet.gl.glVertex2i(self.selectedCase.x * TILE_SIZE + TILE_SIZE, self.selectedCase.y * TILE_SIZE + TILE_SIZE)
pyglet.gl.glVertex2i(self.selectedCase.x * TILE_SIZE, self.selectedCase.y * TILE_SIZE + TILE_SIZE)
pyglet.gl.glColor4f(1, 1, 1, 1)
pyglet.gl.glEnd()
# - Display a grid over the map -
pyglet.gl.glBegin(pyglet.gl.GL_LINES)
for i in xrange(self.offsetPos.x, self.offsetPos.x + width):
# we draw all vertical lines with a gap of TILE_SIZE between them
# according to the offsetPos
if i % TILE_SIZE == 0:
# Draw red line on the x=0 pos
if i == 0:
pyglet.gl.glColor4f(1, 0, 0, 1)
else:
pyglet.gl.glColor4f(0, 0, 0, 1)
pyglet.gl.glVertex2i(i, self.offsetPos.y)
pyglet.gl.glVertex2i(i, self.offsetPos.y + height)
for i in xrange(self.offsetPos.y, self.offsetPos.y + height):
# Same as previous for loop, but for horizontal lines
if i % TILE_SIZE == 0:
# draw a red line on y=0 pos
if i == 0:
pyglet.gl.glColor4f(1, 0, 0, 1)
else:
pyglet.gl.glColor4f(0, 0, 0, 1)
pyglet.gl.glVertex2i(self.offsetPos.x, i)
pyglet.gl.glVertex2i(self.offsetPos.x + width, i)
pyglet.gl.glEnd()
# - Draw the selector -
self.selector.render(self.offsetPos, self.selectedEditor)
# - Draw the export boxes -
self.exportLevelBox.render(self.offsetPos.x, self.offsetPos.y)
self.exportMapBox.render(self.offsetPos.x, self.offsetPos.y)
if self.returnState == "menu":
self.camera.setPos(width / 2, height / 2)
return self.returnState
def reset(self):
width, height = gameEngine.getDinamicWindowSize()
self.setPos(width / 2, height / 2)
def render(self):
width, height = gameEngine.getDinamicWindowSize()
# - mise a jour des positions -
self.principalMenuText.x, self.principalMenuText.y = width/2, height-10
self.newText.x, self.newText.y = width/2, self.principalMenuText.y - 160
self.continueText.x, self.continueText.y = width/2, self.newText.y - 50
self.rapidText.x, self.rapidText.y = width / 2, self.continueText.y - 50
if not self.existingSave:
self.rapidText.y = self.newText.y - 50
self.editText.x, self.editText.y = width/2, self.rapidText.y - 50
self.quitText.x, self.quitText.y = width/2, self.editText.y - 50
# mise a jour des position du fond d'écran lors du redimentionement de la fenètre
self.bg.y = height / 2 - self.bg.height / 2
self.bg.x = width / 2 - self.bg.width / 2
self.bg.draw()
# - New -
pyglet.gl.glBegin(pyglet.gl.GL_QUADS)
pyglet.gl.glColor3ub(self.colors[self.newColor][0][0], self.colors[self.newColor][0][1], self.colors[self.newColor][0][2])
pyglet.gl.glVertex2i(self.newText.x - 180, self.newText.y - 37)
pyglet.gl.glVertex2i(self.newText.x + 180, self.newText.y - 37)
pyglet.gl.glColor3ub(self.colors[self.newColor][1][0], self.colors[self.newColor][1][1], self.colors[self.newColor][1][2])
pyglet.gl.glVertex2i(self.newText.x + 180, self.newText.y + 1)
pyglet.gl.glVertex2i(self.newText.x - 180, self.newText.y + 1)
pyglet.gl.glEnd()
# - Continue -
if self.existingSave:
pyglet.gl.glBegin(pyglet.gl.GL_QUADS)
pyglet.gl.glColor3ub(self.colors[self.continueColor][0][0], self.colors[self.continueColor][0][1], self.colors[self.continueColor][0][2])
pyglet.gl.glVertex2i(self.continueText.x - 180, self.continueText.y - 37)
pyglet.gl.glVertex2i(self.continueText.x + 180, self.continueText.y - 37)
pyglet.gl.glColor3ub(self.colors[self.continueColor][1][0], self.colors[self.continueColor][1][1], self.colors[self.continueColor][1][2])
pyglet.gl.glVertex2i(self.continueText.x + 180, self.continueText.y - 1)
pyglet.gl.glVertex2i(self.continueText.x - 180, self.continueText.y - 1)
pyglet.gl.glEnd()
# - Rapid -
pyglet.gl.glBegin(pyglet.gl.GL_QUADS)
pyglet.gl.glColor3ub(self.colors[self.rapidColor][0][0], self.colors[self.rapidColor][0][1], self.colors[self.rapidColor][0][2])
pyglet.gl.glVertex2i(self.rapidText.x - 180, self.rapidText.y - 37)
pyglet.gl.glVertex2i(self.rapidText.x + 180, self.rapidText.y - 37)
pyglet.gl.glColor3ub(self.colors[self.rapidColor][1][0], self.colors[self.rapidColor][1][1], self.colors[self.rapidColor][1][2])
pyglet.gl.glVertex2i(self.rapidText.x + 180, self.rapidText.y - 1)
pyglet.gl.glVertex2i(self.rapidText.x - 180, self.rapidText.y - 1)
pyglet.gl.glEnd()
# - Edit -
pyglet.gl.glBegin(pyglet.gl.GL_QUADS)
pyglet.gl.glColor3ub(self.colors[self.editColor][0][0], self.colors[self.editColor][0][1], self.colors[self.editColor][0][2])
pyglet.gl.glVertex2i(self.editText.x - 180, self.editText.y - 37)
pyglet.gl.glVertex2i(self.editText.x + 180, self.editText.y - 37)
pyglet.gl.glColor3ub(self.colors[self.editColor][1][0], self.colors[self.editColor][1][1], self.colors[self.editColor][1][2])
pyglet.gl.glVertex2i(self.editText.x + 180, self.editText.y - 1)
pyglet.gl.glVertex2i(self.editText.x - 180, self.editText.y - 1)
pyglet.gl.glEnd()
#-Quitter
pyglet.gl.glBegin(pyglet.gl.GL_QUADS)
pyglet.gl.glColor3ub(self.colors[self.quitColor][0][0], self.colors[self.quitColor][0][1], self.colors[self.quitColor][0][2])
pyglet.gl.glVertex2i(self.quitText.x - 180, self.quitText.y - 37)
pyglet.gl.glVertex2i(self.quitText.x + 180, self.quitText.y - 37)
pyglet.gl.glColor3ub(self.colors[self.quitColor][1][0], self.colors[self.quitColor][1][1], self.colors[self.quitColor][1][2])
pyglet.gl.glVertex2i(self.quitText.x + 180, self.quitText.y - 1)
pyglet.gl.glVertex2i(self.quitText.x - 180, self.quitText.y - 1)
pyglet.gl.glEnd()
self._batch.draw()
return self.returnState
def hit_test(self, x, y, offset):
width, height = gameEngine.getDinamicWindowSize()
sl = self.layout
ox = offset.x
oy = offset.y
return (sl.x - ox < x < sl.x - ox + sl.width and sl.y - oy < y < sl.y - oy + sl.height)
def render(self, x, y, player):
"""
:param x: Position centrale de l'écran en x
:param y: Position centrale de l'écran en y
:param player: Le joueur, afin de récupérer ses caractéristiques
:type x: int
:type y: int
:type player: Player
"""
# - Définition des origines -
width, height = gameEngine.getDinamicWindowSize()
originX = int(x - width/2)
originY = int(y - height/2)
# - Barre de vie -
self.drawBar(originX + self.hpPos["x"], originY + self.hpPos["y"], self.hpSize["x"], self.hpSize["y"], (1, 0, 0), 3, player.hp/player.maxHp)
if int(player.shield) > 0:
self.drawBar(originX + 5, originY + self.shieldPos["y"], self.shieldSize["x"], self.shieldSize["y"], (0.10, 0.5, 1), 3, player.shield/player.shieldCapacity)
# - Mucus -
self.mucusTextShadow.x = originX + width - 3
self.mucusTextShadow.y = originY + 13
self.mucusTextShadow.text = "%i / %i " % (player.mucus, player.mucusMax)
self.mucusText.x = originX + width - 5
self.mucusText.y = originY + 15
self.mucusText.text = "%i / %i " % (player.mucus, player.mucusMax)
if self.menuOpened:
# Le panel d'info sur la gauche
pyglet.gl.glBegin(pyglet.gl.GL_QUADS)
pyglet.gl.glColor4f(0, 0, 0, 0.33)
pyglet.gl.glVertex2i(originX, y - self.sidePanelHeight/2)
pyglet.gl.glVertex2i(originX + self.sidePanelWidth, y - self.sidePanelHeight / 2)
pyglet.gl.glVertex2i(originX + self.sidePanelWidth, y + self.sidePanelHeight / 2)
pyglet.gl.glVertex2i(originX, y + self.sidePanelHeight / 2)
pyglet.gl.glEnd()
# bordure du panel
pyglet.gl.glBegin(pyglet.gl.GL_LINE_STRIP)
pyglet.gl.glColor4f(0, 0, 0, 1)
pyglet.gl.glVertex2i(originX, y - self.sidePanelHeight / 2)
pyglet.gl.glVertex2i(originX + self.sidePanelWidth, y - self.sidePanelHeight / 2)
pyglet.gl.glVertex2i(originX + self.sidePanelWidth, y + self.sidePanelHeight / 2)
pyglet.gl.glVertex2i(originX, y + self.sidePanelHeight/2)
pyglet.gl.glEnd()
# - Update des positions et valeurs des infos panel -
self.panelTitle.x = originX + self.sidePanelWidth / 2
self.panelTitle.y = originY + gameEngine.GameEngine.W_HEIGHT / 2 + self.sidePanelHeight / 2 - 20
panelTop = originY + gameEngine.GameEngine.W_HEIGHT/2 + self.sidePanelHeight / 2
self.attackText.x = originX + 5
self.attackText.y = panelTop - 50
self.attackText.text = "Attaque: %i" % player.attack
self.resistanceText.x = originX + 5
self.resistanceText.y = panelTop - 75
self.resistanceText.text = "Resistance: %i" % player.resistance
self.speedText.x = originX + 5
self.speedText.y = panelTop - 100
self.speedText.text = "Vitesse: %i" % player.speed
self.batchPanel.draw()
# - Redéfinition des positions du texte -
self.hpLabel.x, self.hpLabel.y = originX + self.hpPos["x"] + self.hpSize["x"] - 6, originY + self.hpPos["y"] + self.hpSize["y"] / 2
self.shieldLabel.x, self.shieldLabel.y = originX + self.shieldPos["x"] + self.shieldSize["x"] - 6, originY + self.shieldPos["y"] + self.shieldSize["y"] / 2
self.hpLabel.text = str(int(player.hp)) + " / " + str(int(player.maxHp))
if int(player.shield) > 0:
self.shieldLabel.text = str(int(player.shield)) + " / " + str(int(player.shieldCapacity))
else:
self.shieldLabel.text = ""
# - update des outils devs -
if self.showDevTool:
fps = str(round(pyglet.clock.get_fps(), 2))
self.fpsShadow.x = originX + 3
self.fpsShadow.y = originY + height - 1
self.fpsShadow.text = "Fps: %s" % fps
self.fps.x = originX + 2
self.fps.y = originY + height
self.fps.text = "Fps: %s" % fps
# On draw a la main, les batchs sont foieux.
self.fpsShadow.draw()
self.fps.draw()
self.batch.draw()
