def show(self, surface, updated = None):
"""Rysowanie powierzchni na ekranie. Gdy updated jest None rysuje całą powierzchnię, w przeciwnym przypadku rysuje tylko określone prostokąty."""
if updated:
for rect in updated:
self.screen.blit(surface, rect, rect)
if self.options['debug']:
pygame.draw.rect(self._debug, (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)), rect)
if self.options['debug']:
pygame.draw.rect(self._debug, (255, 255, 255), (0, 0, 50, 20))
updated.append(utils.drawText(self._debug, "FPS: %d" % (self.clock.get_fps()), 12, (0, 0, 0), (10, 10)))
self.screen.blit(self._debug, (0, 0))
pygame.display.update(updated)
return True
self.screen.blit(surface, (0, 0))
if self.options['debug']:
pygame.draw.rect(self._debug, (255, 255, 255), (0, 0, 50, 20))
utils.drawText(self._debug, "FPS: %d" % (self.clock.get_fps()), 12, (0, 0, 0), (10, 10))
self.screen.blit(self._debug, (0, 0))
pygame.display.update()
return True
def mouseEvent(self, _event, _pos = None): """Obsługa zdarzeń myszy.""" if not _pos: return if _event.type == MOUSEMOTION: # aktualizuje opisy przedmiotów pygame.draw.rect(self.surface, (0, 0, 0), (120, 4, 64, 64)) self._updated.append((120, 4, 64, 64)) for cell in self._cells: if cell.rect.collidepoint(_pos): _item = cell.getItem() if _item: utils.drawText(self.surface, _item.getDescription(), 8, (255, 255, 255), (152, 36)) break for cell in self._cells: if cell.rect.collidepoint(_pos): cell.mouseEvent(_event) if _event.type == MOUSEBUTTONDOWN and _event.button == 3: # Używanie mikstur prawym przyciskiem myszy for cell in self._cells: if cell.rect.collidepoint(_pos): _item = cell.getItem() if isinstance(_item, Potion): _item.use(self._hero) break
def show(self, surface, updated = None):
"""Rysowanie powierzchni na ekranie. Gdy updated jest None rysuje całą powierzchnię, w przeciwnym przypadku rysuje tylko określone prostokąty."""
if updated:
for rect in updated:
self.screen.blit(surface, rect, rect)
if self.options['debug']:
pygame.draw.rect(self._debug, (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)), rect)
if self.options['debug']:
pygame.draw.rect(self._debug, (255, 255, 255), (0, 0, 50, 20))
updated.append(utils.drawText(self._debug, "FPS: %d" % (self.clock.get_fps()), 12, (0, 0, 0), (10, 10)))
self.screen.blit(self._debug, (0, 0))
pygame.display.update(updated)
return True
self.screen.blit(surface, (0, 0))
if self.options['debug']:
pygame.draw.rect(self._debug, (255, 255, 255), (0, 0, 50, 20))
utils.drawText(self._debug, "FPS: %d" % (self.clock.get_fps()), 12, (0, 0, 0), (10, 10))
self.screen.blit(self._debug, (0, 0))
pygame.display.update()
return True
def draw(self, sm, screen):
# background
screen.fill(globals.DARK_GREY)
utils.drawText(screen, 'Player Select', 50, 50, globals.WHITE, 255)
self.esc.draw(screen)
self.enter.draw(screen)
# draw active players
if globals.player1 in globals.players:
screen.blit(utils.playing, (100,100))
else:
screen.blit(utils.not_playing, (100,100))
if globals.player2 in globals.players:
screen.blit(utils.playing, (150,100))
else:
screen.blit(utils.not_playing, (150,100))
if globals.player3 in globals.players:
screen.blit(utils.playing, (200,100))
else:
screen.blit(utils.not_playing, (200,100))
if globals.player4 in globals.players:
screen.blit(utils.playing, (250,100))
else:
screen.blit(utils.not_playing, (250,100))
def _countdown(self, countdown):
if not self._map and countdown.number == 1:
self._loadMap(countdown.mapSize.x, countdown.mapSize.y)
if self._playerID == None:
self._playerID = countdown.playerId
self.surface = self._background.copy()
utils.drawText(self.surface, 'Gracz %d. >%d<' % (countdown.playerId, countdown.number), 30, (255, 255, 255), (self._resx / 2, self._resy / 2))
def _countdown(self, countdown):
if not self._map and countdown.number == 1:
self._loadMap(countdown.mapSize.x, countdown.mapSize.y)
if self._playerID == None:
self._playerID = countdown.playerId
self.surface = self._background.copy()
utils.drawText(self.surface, 'Gracz %d. >%d<' % (countdown.playerId, countdown.number), 30, (255, 255, 255), (self._resx / 2, self._resy / 2))
def draw(self, sm, screen):
# background y color
screen.fill(globals.GRIS)
utils.drawText(screen, "level select", 50, 50,globals.BLANCO, 255)
self.b1.draw(screen)
self.b2.draw(screen)
self.b3.draw(screen)
self.b4.draw(screen)
self.b5.draw(screen)
self.esc.draw(screen)
def draw(self, screen, alpha=255):
# si esta encendido el boton
if self.on:
# su color es verde
colour = globals.VERDE
else:
# y si no su color es blanco
colour = globals.BLANCO
# dibujar boton
utils.drawText(screen, self.text, self.x, self.y, colour, alpha)
def draw(self, sm, screen):
# background y color
screen.fill(globals.GRIS)
utils.drawText(screen, "CREDITOS", 50, 50,globals.BLANCO, 255)
self.cr1.draw(screen)
self.cr2.draw(screen)
self.cr3.draw(screen)
self.cr1_1.draw(screen)
self.cr2_1.draw(screen)
self.cr3_1.draw(screen)
def draw(self, sm, screen):
# background y color
screen.fill(globals.GRIS)
utils.drawText(screen, "MENU PRINICIPAL", 50, 50,globals.BLANCO, 255)
# dibujar al entrar enter
self.enter.draw(screen)
# dibujar dibujar al salir con escape
self.esc.draw(screen)
# dibujar creditos
self.c.draw(screen)
def draw(self, sm, screen):
if len(sm.scenes) > 1:
sm.scenes[-2].draw(sm, screen)
# draw a transparent bg
bgSurf = pygame.Surface((830,830))
bgSurf.fill((globals.BLACK))
utils.blit_alpha(screen, bgSurf, (0,0), self.alpha * 0.7)
utils.drawText(screen, 'You lose!', 150, 150, globals.WHITE, self.alpha)
self.esc.draw(screen, alpha=self.alpha)
def draw(self, sm, screen):
if len(sm.scenes) > 1:
sm.scenes[-2].draw(sm, screen)
# DIBUJAR UN Bacground opaco
bgSurf = pygame.Surface((1000, 560))
bgSurf.fill((globals.NEGRO))
utils.blit_alpha(screen, bgSurf, (0,0), self.alpha * 0.7)
utils.drawText(screen, "PERDISTE", 250, 250, globals.BLANCO, self.alpha)
self.esc.draw(screen, alpha = self.alpha)
def draw(self, sm, screen):
# background
screen.fill(globals.DARK_GREY)
utils.drawText(screen, 'Level Select', 50, 50, globals.WHITE, 255)
self.esc.draw(screen)
# draw level select menu
for levelNumber in range(1, globals.maxLevel+1):
c = globals.WHITE
if levelNumber == globals.curentLevel:
c = globals.GREEN
a = 255
if levelNumber > globals.lastCompletedLevel:
a = 100
utils.drawText(screen, str(levelNumber), levelNumber*100, 100, c, a)
def drawScore(self, window):
if hasattr(self,'scoreText'):
self.scoreText.string = str(self.score)
else:
self.scoreText = utils.drawText(window, size=25,
font=self.params.font, string=str(self.score))
window.draw(self.scoreText)
def endGame(self):
gameOverText = utils.drawText(self.board.window, string="Game Over", font=self.params.font,
size=60, position='center', color=sf.Color.RED)
oldScore = self.scoreKeeper.checkScore(self.params.playerName, self.params.getDifficulty())
scoreTextYPosition = gameOverText.position[1]+gameOverText.local_bounds.height+10
scoreText = None
if self.score > oldScore:
# display a "New Highscore" screen
self.scoreKeeper.setScore(self.params.playerName, self.score, self.params.getDifficulty())
utils.drawText(self.board.window, string="New High Score! {}".format(self.score),
font=self.params.font, size=30, position='center', yposition=scoreTextYPosition, color=sf.Color.GREEN)
else:
# Display the old highscore
utils.drawText(self.board.window, string="High Score: {}".format(oldScore),
font=self.params.font, size=30, position='center', yposition=scoreTextYPosition, color=sf.Color.WHITE)
utils.drawText(self.board.window, string="Press ENTER to Relplay",
font=self.params.font, size=15, position='center', yposition=self.board.window.height - 20, color=sf.Color.WHITE)
self.board.window.display()
while(True):
for event in self.board.window.events:
if (type(event) is sf.CloseEvent or
(type(event) is sf.KeyEvent and event.code is sf.Keyboard.ESCAPE)):
exit()
if (type(event) is sf.KeyEvent and event.code is sf.Keyboard.RETURN):
# Reset
self.snake = None
self.setup(self.board.window, self.params.getPlayerName())
def draw(self, surface): """Rysuje minimapę na powierzchni.""" surface.blit(self.images['background'], self._pos) pygame.draw.rect(surface, (0, 255, 0), (self._pos[0] + 2, self._pos[1] + 1, max(0, int(62 * self._before[0][0])), 14)) utils.drawText(surface, "%d/%d" % self._before[0][1:3], 10, (0, 0, 0), (self._pos[0] + 32, self._pos[1] + 8)) pygame.draw.rect(surface, (0, 0, 255), (self._pos[0] + 66, self._pos[1], max(0, int(62 * self._before[1][0])), 14)) utils.drawText(surface, "%d/%d" % self._before[1][1:3], 10, (0, 0, 0), (self._pos[0] + 96, self._pos[1] + 8)) surface.blit(self.images['mask'], self._pos) surface.blit(self.images['fire' + (self._spell == hero.MAGIC_FIRE and 'on' or 'off')], (self._pos[0] + 136, self._pos[1])) utils.drawText(surface, "1", 10, (0, 0, 0), (self._pos[0] + 144, self._pos[1] + 8)) surface.blit(self.images['ice' + (self._spell == hero.MAGIC_ICE and 'on' or 'off')], (self._pos[0] + 152, self._pos[1])) utils.drawText(surface, "2", 10, (0, 0, 0), (self._pos[0] + 160, self._pos[1] + 8)) surface.blit(self.images['heal' + (self._spell == hero.MAGIC_HEAL and 'on' or 'off')], (self._pos[0] + 168, self._pos[1])) utils.drawText(surface, "3", 10, (0, 0, 0), (self._pos[0] + 176, self._pos[1] + 8))
def debugDraw(self, track, frameIndex):
if self.debug:
self.context.createOverlayCanvas()
#TODO Also tell how many keys reference missing bones
text = "%s (%s) Speed: %.1f, Frame %s / %i" % (self.tag, track.info.name,
track.info.speed, frameIndex, len(track.animation.frames) - 1)
pos = (10, self.debugY)
color = (0, 0, 0)
self.debugY += utils.drawText(self.context.overlayCanvas, text, pos, color)[1]
def setup(self, startWindow=None, playerName=None):
self.score = 0
self.scoreKeeper = ScoreKeeper()
self.scoreKeeper.setFile('snakeScore.txt')
self.params = GameParams() # To be filled by user input
width = 800
height = 600
font = sf.Font.from_file("rust.ttf")
if startWindow is None:
# startWindow is None unless this is a restart
startWindow = sf.RenderWindow(sf.VideoMode(width, height), "Snake")
startWindow.framerate_limit = 60
startWindow.clear(sf.Color.BLACK)
#Display Welcome
welcomeText = utils.drawText(startWindow, string="Snake", size=60, font=font, position='center')
startWindow.display()
while(True):
setup = False
for event in startWindow.events:
if type(event) is sf.CloseEvent:
exit()
elif (type(event) is sf.MouseButtonEvent or
type(event) is sf.KeyEvent):
setup = True
if setup:
break
#TODO Choose PlayerName
if playerName is None:
playerName = utils.textInput(startWindow, "Enter Name:", font, maxLength=10)
self.params.setPlayerName(playerName)
#Choose Difficulty
difficulty = utils.selectOptions(startWindow, ["Easy", "Medium", "Hard"], [0, 1, 2], font)
frameRates = [20, 25, 30]
self.params.setDifficulty(difficulty)
self.params.setFrameRate(frameRates[difficulty])
#Choose Board Size
boardSize = utils.selectOptions(startWindow, ["Small", "Medium", "Large"], [(40,30), (50,40), (60,50)], font)
self.params.setBoardSize(boardSize)
self.params.setSquareSize(15)
self.params.setFont(font)
self.snake = Snake(5, self.params.squareSize, sf.Vector2(10,10))
self.board = Board(width=self.params.boardWidth, height=self.params.boardHeight,
squareSize=self.params.squareSize, frameRate=self.params.frameRate)
self.board.initSnake(self.snake)
startWindow.close()
self.playGame()
def update(self): """Aktualizuje obrazek.""" if not self.getLogic().getLife(): self.kill() return [] _destination = self._logic.getDestination() _attack = self._logic.getTarget() if _attack and self._state != 'attack': self._state = 'attack' self._frame = 0 if _destination and self._state != 'walk': self._state = 'walk' self._frame = 0 if self._state == 'walk' and not _destination: self._frame = 0 if self._logic.update() or self._refresh: if self._layer: self._layer.clear(self._id) self.image = self.getImage() self.rect.center = self._logic.getPos() self._refresh = False return [tuple(self.rect)] self._cnt += 1 if self._cnt == 90: self._cnt = 0 self.damage.fill((0, 0, 0, 0)) _dmg = self._logic.getDamage() if _dmg: self.damage.fill((0, 0, 0, 0)) utils.drawText(self.damage, "%d" % _dmg, 10, (255, 120, 120), (16, 8)) return [tuple(self.rect)] return []
def mouseEvent(self, _event, _pos = None): """Obsługa zdarzeń myszy.""" if not _pos: return if _event.type == MOUSEMOTION: # Rysowanie opisu przedmiotu pygame.draw.rect(self.surface, (0, 0, 0), (120, 20, 64, 64)) self._updated.append((120, 20, 64, 64)) for cell in self._cells: if cell.rect.collidepoint(_pos): _item = cell.getItem() if _item: utils.drawText(self.surface, _item.getDescription(), 8, (255, 255, 255), (152, 52)) break for cell in self._cells: if cell.rect.collidepoint(_pos): cell.mouseEvent(_event)
def mouseEvent(self, _event, _pos=None):
"""Obsługa zdarzeń myszy."""
if not _pos:
return
if _event.type == MOUSEMOTION: # Rysowanie opisu przedmiotu
pygame.draw.rect(self.surface, (0, 0, 0), (120, 20, 64, 64))
self._updated.append((120, 20, 64, 64))
for cell in self._cells:
if cell.rect.collidepoint(_pos):
_item = cell.getItem()
if _item:
utils.drawText(self.surface, _item.getDescription(), 8,
(255, 255, 255), (152, 52))
break
for cell in self._cells:
if cell.rect.collidepoint(_pos):
cell.mouseEvent(_event)
def update(self): """Aktualizuje obrazek.""" if not self.getLogic().getLife(): # jeśli nie żyje to trzeba go wyrzucić z puli self.kill() return [] _destination = self._logic.getDestination() if _destination and self._state != 'walk': self._state = 'walk' self._frame = 0 if self._state == 'walk' and not _destination: self._frame = 0 if self._logic.update() or self._refresh: if self._layer: self._layer.clear(self._id) self.image = self.getImage() self.rect.center = self._logic.getPos() self._refresh = False return [list(self.rect)] self._cnt += 1 if self._cnt == 90: self._cnt = 0 self.damage.fill((0, 0, 0, 0)) _dmg = self._logic.getDamage() if _dmg: self.damage.fill((0, 0, 0, 0)) utils.drawText(self.damage, "%d" % _dmg, 10, (255, 120, 120), (16, 8)) return [tuple(self.rect)] return []
def draw(self, surface):
"""Rysuje minimapę na powierzchni."""
surface.blit(self.images['background'], self._pos)
pygame.draw.rect(surface, (0, 255, 0),
(self._pos[0] + 2, self._pos[1] + 1,
max(0, int(62 * self._before[0][0])), 14))
utils.drawText(surface, "%d/%d" % self._before[0][1:3], 10, (0, 0, 0),
(self._pos[0] + 32, self._pos[1] + 8))
pygame.draw.rect(surface, (0, 0, 255),
(self._pos[0] + 66, self._pos[1],
max(0, int(62 * self._before[1][0])), 14))
utils.drawText(surface, "%d/%d" % self._before[1][1:3], 10, (0, 0, 0),
(self._pos[0] + 96, self._pos[1] + 8))
surface.blit(self.images['mask'], self._pos)
surface.blit(
self.images['fire' +
(self._spell == hero.MAGIC_FIRE and 'on' or 'off')],
(self._pos[0] + 136, self._pos[1]))
utils.drawText(surface, "1", 10, (0, 0, 0),
(self._pos[0] + 144, self._pos[1] + 8))
surface.blit(
self.images['ice' +
(self._spell == hero.MAGIC_ICE and 'on' or 'off')],
(self._pos[0] + 152, self._pos[1]))
utils.drawText(surface, "2", 10, (0, 0, 0),
(self._pos[0] + 160, self._pos[1] + 8))
surface.blit(
self.images['heal' +
(self._spell == hero.MAGIC_HEAL and 'on' or 'off')],
(self._pos[0] + 168, self._pos[1]))
utils.drawText(surface, "3", 10, (0, 0, 0),
(self._pos[0] + 176, self._pos[1] + 8))
def _finish(self, result):
self.surface = self._background.copy()
utils.drawText(self.surface, 'Gra zakonczona!', 40, (255, 255, 255), (self._resx / 2, self._resy / 2))
if len(result.winners) == 1:
utils.drawText(self.surface, 'Wygral gracz %d!' % result.winners[0], 40, (255, 255, 255), (self._resx / 2, self._resy / 2 + 40))
elif len(result.winners):
utils.drawText(self.surface, 'Wygrali gracze %s!' % (', '.join([str(i) for i in result.winners])), 40, (255, 255, 255), (self._resx / 2, self._resy / 2 + 40))
self._play = False
self._engine.show(self.surface)
def _finish(self, result):
self.surface = self._background.copy()
utils.drawText(self.surface, 'Gra zakonczona!', 40, (255, 255, 255), (self._resx / 2, self._resy / 2))
if len(result.winners) == 1:
utils.drawText(self.surface, 'Wygral gracz %d!' % result.winners[0], 40, (255, 255, 255), (self._resx / 2, self._resy / 2 + 40))
elif len(result.winners):
utils.drawText(self.surface, 'Wygrali gracze %s!' % (', '.join([str(i) for i in result.winners])), 40, (255, 255, 255), (self._resx / 2, self._resy / 2 + 40))
self._play = False
self._engine.show(self.surface)
def show(self):
"""Wyświetlanie menu."""
try:
while self._engine.tick():
for button in self._buttons:
button.update()
for event in self._engine.events():
if event.type == QUIT:
raise engine.EngineQuit()
if event.type == KEYUP:
if event.key == K_ESCAPE:
self._engine.previousModule()
raise MenuQuit()
if event.key in (K_UP, K_DOWN):
_step = event.key == K_UP and -1 or 1
self._focus = (self._focus + _step) % len(
self._buttons)
while not self._buttons[self._focus].active:
self._focus = (self._focus + _step) % len(
self._buttons)
elif event.key == K_RETURN:
self._buttons[self._focus].callback()
self.surface = self._background.copy()
_shift = 300
for n, button in enumerate(self._buttons):
button.update()
x, y, width, height = utils.drawText(
self.surface, button.text, 14,
(self._focus == n and (255, 0, 0))
or (button.active and (255, 255, 255))
or (128, 128, 128), (self._resx / 2, _shift))
_shift += height + 15
self._updated.append((x, y, width, height))
self._engine.show(self.surface, self._updated)
self._before = self._focus
self._updated = []
except MenuQuit:
pass
def show(self):
"""Wyświetlanie menu."""
try:
while self._engine.tick():
for button in self._buttons:
button.update()
for event in self._engine.events():
if event.type == QUIT:
raise engine.EngineQuit()
if event.type == KEYUP:
if event.key == K_ESCAPE:
self._engine.previousModule()
raise MenuQuit()
if event.key in (K_UP, K_DOWN):
_step = event.key == K_UP and -1 or 1
self._focus = (self._focus + _step) % len(self._buttons)
while not self._buttons[self._focus].active:
self._focus = (self._focus + _step) % len(self._buttons)
elif event.key == K_RETURN:
self._buttons[self._focus].callback()
self.surface = self._background.copy()
_shift = 300
for n, button in enumerate(self._buttons):
button.update()
x, y, width, height = utils.drawText(self.surface, button.text, 14, (self._focus == n and (255, 0, 0)) or (button.active and (255, 255, 255)) or (128, 128, 128), (self._resx/2, _shift))
_shift += height + 15
self._updated.append((x, y, width, height))
self._engine.show(self.surface, self._updated)
self._before = self._focus
self._updated = []
except MenuQuit:
pass
def __init__(self, _grid, _hero):
super(IntelligenceCell, self).__init__(_grid)
self.image = utils.loadImage('data/gfx/intelligencecell.png', alpha = True)
self._hero = _hero
self._before = 0
utils.drawText(self.image, "Inteligencja", 9, (0, 0, 0), (16, 6))
def show(self):
if not self._play:
self._engine.previousModule()
return
try:
self._last = time.time()
while self._engine.tick():
_upd = self._client.update(.5/self._engine.options['fps'])
if self._play and _upd != True:
utils.drawText(self.surface, _upd, 20, (255, 255, 255), (self._resx / 2, self._resy / 2))
self._play = False
self._engine.show(self.surface)
time.sleep(5)
self._engine.previousModule()
raise SceneQuit()
if self._client.countdown:
if not self._map:
self._loadMap(self._client.countdown.mapSize.x, self._client.countdown.mapSize.y)
if self._playerID == None:
self._playerID = self._client.countdown.playerId
self.surface = self._background.copy()
utils.drawText(self.surface, 'Gracz %d. >%d<' % (self._client.countdown.playerId, self._client.countdown.number), 30, (255, 255, 255), (self._resx / 2, self._resy / 2))
self._engine.show(self.surface)
continue
if self._client.result:
utils.drawText(self.surface, 'Gra zakonczona!', 40, (255, 255, 255), (self._resx / 2, self._resy / 2))
if len(self._client.result.winners) == 1:
utils.drawText(self.surface, 'Wygral gracz %d!' % self._client.result.winners[0], 40, (255, 255, 255), (self._resx / 2, self._resy / 2 + 40))
elif len(self._client.result.winners):
utils.drawText(self.surface, 'Wygrali gracze %s!' % (', '.join([str(i) for i in self._client.result.winners])), 40, (255, 255, 255), (self._resx / 2, self._resy / 2 + 40))
self._play = False
self._engine.show(self.surface)
time.sleep(10)
self._engine.previousModule()
raise SceneQuit()
if self._client.map:
if not self._map:
self._engine.previousModule()
self._play = False
raise SceneQuit()
for mine in self._client.map.mines:
_id = mine.position.x, mine.position.y
if not self._mineLayer.get(_id):
_mine = ObjectsLayer.Sprite(utils.loadImage('data/gfx/bomb.png', alpha = True))
self._mineLayer.add(_id, _mine)
self._mineLayer.move(_id, _id)
for _id, player in enumerate(self._client.map.playersPositions):
if not self._heroLayer.get(_id):
self._heroLayer.add(_id, ObjectsLayer.Sprite(utils.loadImage('data/gfx/hero/n.png', alpha = True)))
_hero = self._heroLayer.get(_id)
_pos = _hero.getPos()
self._heroLayer.move(_id, (player.x, player.y))
_newpos = _hero.getPos()
if _pos[0] > _newpos[0]:
_hero.changeImage(utils.loadImage('data/gfx/hero/w.png', alpha = True))
if _pos[0] < _newpos[0]:
_hero.changeImage(utils.loadImage('data/gfx/hero/e.png', alpha = True))
if _pos[1] > _newpos[1]:
_hero.changeImage(utils.loadImage('data/gfx/hero/n.png', alpha = True))
if _pos[1] < _newpos[1]:
_hero.changeImage(utils.loadImage('data/gfx/hero/s.png', alpha = True))
if _id == self._playerID:
_, _, w, h = self._map.getRectangle()
self._map.setShift((w / 2 - _newpos[0], h / 2 - _newpos[1]))
for event in self._engine.events():
if event.type == QUIT:
raise engine.EngineQuit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
self._engine.previousModule()
raise SceneQuit()
if event.key in (K_w, K_UP):
self._client.sendAction('u')
self._last = time.time()
elif event.key in (K_s, K_DOWN):
self._client.sendAction('d')
self._last = time.time()
elif event.key in (K_a, K_LEFT):
self._client.sendAction('l')
self._last = time.time()
elif event.key in (K_d, K_RIGHT):
self._client.sendAction('r')
self._last = time.time()
elif event.key in (K_RETURN, K_RCTRL, K_LCTRL):
self._client.sendAction('c')
self._last = time.time()
elif event.key == K_q:
self._client.sendAction('e')
self._last = time.time()
if self._last + 1./self._engine.options['fps'] < time.time():
self._client.sendAction('m')
self._last = time.time()
self.surface = self._background.copy()
if not self._map:
utils.drawText(self.surface, 'Oczekiwanie na graczy!', 20, (255, 255, 255), (self._resx / 2, self._resy / 2))
updated = []
for submodule in self._submodules:
updated.extend(submodule.update())
submodule.draw(self.surface)
if self._refresh:
self._engine.show(self.surface)
self._refresh = False
else:
self._engine.show(self.surface, updated)
except SceneQuit:
pass
def _render(self):
self._engine.tick()
for event in self._engine.events():
if event.type == QUIT:
self._play = False
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self._engine.runLoop = False
from twisted.internet import reactor
reactor.stop()
return
if self._map:
if event.key in (K_w, K_UP):
self._client.sendAction('u')
self._last = time.time()
elif event.key in (K_s, K_DOWN):
self._client.sendAction('d')
self._last = time.time()
elif event.key in (K_a, K_LEFT):
self._client.sendAction('l')
self._last = time.time()
elif event.key in (K_d, K_RIGHT):
self._client.sendAction('r')
self._last = time.time()
elif event.key in (K_RETURN, K_RCTRL, K_LCTRL):
self._client.sendAction('c')
self._last = time.time()
elif event.key == K_q:
self._client.sendAction('e')
self._last = time.time()
if self._map and self._last + 1./self._engine.options['fps'] < time.time():
self._client.sendAction('m')
self._last = time.time()
if not self._map and self._playerID == None:
self.surface = self._background.copy()
utils.drawText(self.surface, 'Oczekiwanie na graczy!', 20, (255, 255, 255), (self._resx / 2, self._resy / 2))
updated = []
if self._play:
for submodule in self._submodules:
updated.extend(submodule.update())
submodule.draw(self.surface)
if self._refresh:
self._engine.show(self.surface)
self._refresh = False
else:
self._engine.show(self.surface, updated)
if not self._play:
time.sleep(5)
self._engine.runLoop = False
from twisted.internet import reactor
reactor.stop()
return
def draw(self, sm, screen):
# background
screen.fill(globals.DARK_GREY)
utils.drawText(screen, 'Main Menu', 50, 50, globals.WHITE, 255)
self.enter.draw(screen)
self.esc.draw(screen)
def show(self):
if not self._play:
self._engine.previousModule()
return
try:
while self._engine.tick():
for event in self._engine.events():
if event.type == QUIT:
raise engine.EngineQuit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
self._engine.previousModule()
raise SceneQuit()
elif event.key in hero.MAGIC_KEYS:
self._hero.setSpell(hero.KEY_MAP[event.key])
if event.type in (MOUSEMOTION, MOUSEBUTTONDOWN,
MOUSEBUTTONUP):
for submodule in self._submodules:
if submodule.getRectangle().collidepoint(
event.pos):
x, y, _, _ = submodule.getRectangle()
_pos = event.pos[0] - x, event.pos[1] - y
else:
_pos = None
submodule.mouseEvent(event, _pos)
if submodule == self._map and event.type == MOUSEBUTTONDOWN and _pos: # obsługa otwierania skrzynki(głównie)
_field = self._map.getLayer('Fields').get(
_pos, True)
if _field:
_field.getLogic().clicked(self, self._hero)
if submodule == self._map and event.type == MOUSEBUTTONUP and event.button == 1 and _pos: # upuszczanie przedmiotu
_field = self._map.getLayer('Fields').get(
_pos, True)
if _field:
_field = _field.getLogic()
if _field and utils.distance(
_field.getGrid()[:2],
self._hero.getGrid()[:2]) <= 1:
for _obj in self._freeobjects:
if not _obj.attach(_field):
_obj.attach(_obj.getAttached())
else:
for _obj in self._freeobjects:
_obj.attach(_obj.getAttached())
if submodule == self.inventory and event.type == MOUSEBUTTONUP and event.button == 1 and _pos: # ↑
for _obj in self._freeobjects:
if not _obj.attach(
self.inventory.getCell(_pos)):
_obj.attach(_obj.getAttached())
if submodule == self.chestitems and event.type == MOUSEBUTTONUP and event.button == 1 and _pos: # ↑
for _obj in self._freeobjects:
if not self.chestitems.opened or not _obj.attach(
self.chestitems.getCell(_pos)):
_obj.attach(_obj.getAttached())
for _obj in self._freeobjects:
_obj.mouseEvent(event)
if event.type == MOUSEBUTTONDOWN and event.button == 3 and self._map.getRectangle(
).collidepoint(event.pos): # rzucanie czaru
self._hero.castSpell()
if event.type == MOUSEBUTTONDOWN and event.button == 1 and self._map.getRectangle(
).collidepoint(event.pos): # atak
self._hero.punch()
if self._hero.getGrid()[2] != self._map.getStorey(
): # zmiana poziomu lochu
self._map.removeLayer('Missiles')
self._map.addLayer('Missiles', 3, MissilesLayer(self._map))
self._map.switchStorey(self._hero.getGrid()[2] -
self._map.getStorey())
self._shadow.clear()
for _id, _ in self._actual:
self._creatureLayer.remove(_id)
self._actual = []
_counter = 0
_storey = self._map.getStorey()
for _name, _monster in self._monsters:
if _monster.getGrid()[2] == _storey:
self._creatureLayer.add(
_name + '_' + str(_counter),
_monster.getSprite(self._creatureLayer, _name +
'_' + str(_counter)))
self._actual.append(
(_name + '_' + str(_counter), _monster))
_monster.move((0, 0, 0))
_counter += 1
else:
for key in hero.DIRECTION_KEYS:
if pygame.key.get_pressed()[key]:
self._hero.move(hero.KEY_MAP[key])
if self._hero.getDestination(
): # przesuwanie mapy za bohaterem
x, y = self._hero.getPos()
_, _, w, h = self._map.getRectangle()
self._map.setShift((w / 2 - x, h / 2 - y))
if not self._hero.getLife(): # przegrana
utils.drawText(self.surface, "Game Over", 40,
(255, 255, 255),
(self._resx / 2, self._resy / 2))
self._play = False
self._engine.show(self.surface)
time.sleep(3)
self._engine.previousModule()
raise SceneQuit()
if not self._monsters: # wygrana
utils.drawText(self.surface, "Win", 50, (255, 255, 255),
(self._resx / 2, self._resy / 2))
self._play = False
self._engine.show(self.surface)
time.sleep(3)
self._engine.previousModule()
raise SceneQuit()
_hero = self._hero.getPos()
_shift = self._map.getShift()
_hero = _hero[0] + _shift[0], _hero[1] + _shift[1]
_mouse = pygame.mouse.get_pos()
_mouse = _mouse[0] - _hero[0], _mouse[1] - _hero[1]
_angle = utils.vectorAngle((0, 1), _mouse)
if -45 <= _angle < 45:
self._hero.setDirection('s')
elif -135 <= _angle < -45:
self._hero.setDirection('e')
elif 45 <= _angle < 135:
self._hero.setDirection('w')
else:
self._hero.setDirection('n')
self._shadow.reveal(self._hero.getPos())
self.surface = self._background.copy()
updated = []
for submodule in self._submodules:
updated.extend(submodule.update())
submodule.draw(self.surface)
for _obj in self._freeobjects:
updated.extend(_obj.update())
_obj.draw(self.surface)
if self._refresh:
self._engine.show(self.surface)
self._refresh = False
else:
self._engine.show(self.surface, updated)
_actual = []
for _id, _monster in self._actual:
if _monster.getGrid()[2] != self._map.getStorey():
self._creatureLayer.remove(_id)
else:
_actual.append((_id, _monster))
self._actual = _actual
for _id, _monster in self._monsters: # umierające potwory dodają exp bohaterowi
if not _monster.getLife():
self._monsters.remove((_id, _monster))
self._hero.addExperience(_monster.stats['experience'])
except SceneQuit:
pass
def show(self):
if not self._play:
self._engine.previousModule()
return
try:
while self._engine.tick():
for event in self._engine.events():
if event.type == QUIT:
raise engine.EngineQuit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
self._engine.previousModule()
raise SceneQuit()
elif event.key in hero.MAGIC_KEYS:
self._hero.setSpell(hero.KEY_MAP[event.key])
if event.type in (MOUSEMOTION, MOUSEBUTTONDOWN, MOUSEBUTTONUP):
for submodule in self._submodules:
if submodule.getRectangle().collidepoint(event.pos):
x, y, _, _ = submodule.getRectangle()
_pos = event.pos[0] - x, event.pos[1] - y
else:
_pos = None
submodule.mouseEvent(event, _pos)
if submodule == self._map and event.type == MOUSEBUTTONDOWN and _pos: # obsługa otwierania skrzynki(głównie)
_field = self._map.getLayer('Fields').get(_pos, True)
if _field:
_field.getLogic().clicked(self, self._hero)
if submodule == self._map and event.type == MOUSEBUTTONUP and event.button == 1 and _pos: # upuszczanie przedmiotu
_field = self._map.getLayer('Fields').get(_pos, True)
if _field:
_field = _field.getLogic()
if _field and utils.distance(_field.getGrid()[:2], self._hero.getGrid()[:2]) <= 1:
for _obj in self._freeobjects:
if not _obj.attach(_field):
_obj.attach(_obj.getAttached())
else:
for _obj in self._freeobjects:
_obj.attach(_obj.getAttached())
if submodule == self.inventory and event.type == MOUSEBUTTONUP and event.button == 1 and _pos: # ↑
for _obj in self._freeobjects:
if not _obj.attach(self.inventory.getCell(_pos)):
_obj.attach(_obj.getAttached())
if submodule == self.chestitems and event.type == MOUSEBUTTONUP and event.button == 1 and _pos: # ↑
for _obj in self._freeobjects:
if not self.chestitems.opened or not _obj.attach(self.chestitems.getCell(_pos)):
_obj.attach(_obj.getAttached())
for _obj in self._freeobjects:
_obj.mouseEvent(event)
if event.type == MOUSEBUTTONDOWN and event.button == 3 and self._map.getRectangle().collidepoint(event.pos): # rzucanie czaru
self._hero.castSpell()
if event.type == MOUSEBUTTONDOWN and event.button == 1 and self._map.getRectangle().collidepoint(event.pos): # atak
self._hero.punch()
if self._hero.getGrid()[2] != self._map.getStorey(): # zmiana poziomu lochu
self._map.removeLayer('Missiles')
self._map.addLayer('Missiles', 3, MissilesLayer(self._map))
self._map.switchStorey(self._hero.getGrid()[2] - self._map.getStorey())
self._shadow.clear()
for _id, _ in self._actual:
self._creatureLayer.remove(_id)
self._actual = []
_counter = 0
_storey = self._map.getStorey()
for _name, _monster in self._monsters:
if _monster.getGrid()[2] == _storey:
self._creatureLayer.add(_name + '_' + str(_counter), _monster.getSprite(self._creatureLayer, _name + '_' + str(_counter)))
self._actual.append((_name + '_' + str(_counter), _monster))
_monster.move((0, 0, 0))
_counter += 1
else:
for key in hero.DIRECTION_KEYS:
if pygame.key.get_pressed()[key]:
self._hero.move(hero.KEY_MAP[key])
if self._hero.getDestination(): # przesuwanie mapy za bohaterem
x, y = self._hero.getPos()
_, _, w, h = self._map.getRectangle()
self._map.setShift((w / 2 - x, h / 2 - y))
if not self._hero.getLife(): # przegrana
utils.drawText(self.surface, "Game Over", 40, (255, 255, 255), (self._resx / 2, self._resy / 2))
self._play = False
self._engine.show(self.surface)
time.sleep(3)
self._engine.previousModule()
raise SceneQuit()
if not self._monsters: # wygrana
utils.drawText(self.surface, "Win", 50, (255, 255, 255), (self._resx / 2, self._resy / 2))
self._play = False
self._engine.show(self.surface)
time.sleep(3)
self._engine.previousModule()
raise SceneQuit()
_hero = self._hero.getPos()
_shift = self._map.getShift()
_hero = _hero[0] + _shift[0], _hero[1] + _shift[1]
_mouse = pygame.mouse.get_pos()
_mouse = _mouse[0] - _hero[0], _mouse[1] - _hero[1]
_angle = utils.vectorAngle((0, 1), _mouse)
if -45 <= _angle < 45:
self._hero.setDirection('s')
elif -135 <= _angle < -45:
self._hero.setDirection('e')
elif 45 <= _angle < 135:
self._hero.setDirection('w')
else:
self._hero.setDirection('n')
self._shadow.reveal(self._hero.getPos())
self.surface = self._background.copy()
updated = []
for submodule in self._submodules:
updated.extend(submodule.update())
submodule.draw(self.surface)
for _obj in self._freeobjects:
updated.extend(_obj.update())
_obj.draw(self.surface)
if self._refresh:
self._engine.show(self.surface)
self._refresh = False
else:
self._engine.show(self.surface, updated)
_actual = []
for _id, _monster in self._actual:
if _monster.getGrid()[2] != self._map.getStorey():
self._creatureLayer.remove(_id)
else:
_actual.append((_id, _monster))
self._actual = _actual
for _id, _monster in self._monsters: # umierające potwory dodają exp bohaterowi
if not _monster.getLife():
self._monsters.remove((_id, _monster))
self._hero.addExperience(_monster.stats['experience'])
except SceneQuit:
pass
def draw(self, screen, alpha=255):
if self.on:
colour = globals.GREEN
else:
colour = globals.WHITE
utils.drawText(screen, self.text, self.x, self.y, colour, alpha)
def blink(source, video_path, output, fps, frame_size):
"""
在视频流中实时检测和计数眨眼次数
"""
# click.echo(click.get_current_context().params)
device_info = getDeviceInfo() # type: dai.DeviceInfo
with dai.Device(create_pipeline(source), device_info) as device:
fps_handler = FPSHandler()
if source:
cap = cv2.VideoCapture(video_path)
frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
frame_shape = [frame_height, frame_width]
print("CAP_PROP_FRAME_SHAPE: %s" % frame_shape)
cap_fps = int(cap.get(cv2.CAP_PROP_FPS))
print("CAP_PROP_FPS: %d" % cap_fps)
mesh_in = device.getInputQueue("mesh_in")
else:
cam_out = device.getOutputQueue("rgb")
mesh_nn = device.getOutputQueue("mesh_nn")
eye_in = device.getInputQueue("eye_in")
eye_nn = device.getOutputQueue("eye_nn")
left_eye_blink = []
right_eye_blink = []
left_number_of_blinks = 0
right_number_of_blinks = 0
def should_run():
if source:
return cap.isOpened()
else:
return True
def get_frame():
if source:
return cap.read()
else:
return True, cam_out.get().getCvFrame()
if output:
output.parent.mkdir(parents=True, exist_ok=True)
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
writer = cv2.VideoWriter(str(output), fourcc, fps, frame_size)
while should_run():
read_correctly, frame = get_frame()
if not read_correctly:
break
frame_debug = frame.copy()
if source:
run_nn(frame_debug, mesh_in, 192, 192)
mesh_data = toTensorResult(mesh_nn.get())
fps_handler.tick("Mesh")
score = mesh_data.get("conv2d_31").reshape((1, ))
if score > 0.5:
mesh = mesh_data.get("conv2d_21").reshape((468, 3))
wh = np.array(frame_debug.shape[:2])[::-1]
mesh *= np.array([*wh / 192, 1])
for v in mesh.astype(int):
cv2.circle(frame_debug, v[:2], 1, (191, 255, 0))
left_eye, left_box = get_mini_box_frame(
frame_debug,
np.array([mesh[71], mesh[107], mesh[116], mesh[197]]),
)
run_nn(left_eye, eye_in, 32, 32)
left_eye_blink.append(
np.argmax(toTensorResult(eye_nn.get()).get("19")))
if (len(left_eye_blink) > 5
and left_eye_blink[-1] not in left_eye_blink[-5:-1]):
left_number_of_blinks += 1
if len(left_eye_blink) > 20:
del left_eye_blink[0]
right_eye, right_box = get_mini_box_frame(
frame_debug,
np.array([mesh[301], mesh[336], mesh[345], mesh[197]]),
)
run_nn(right_eye, eye_in, 32, 32)
right_eye_blink.append(
np.argmax(toTensorResult(eye_nn.get()).get("19")))
if (len(right_eye_blink) > 5
and right_eye_blink[-1] not in right_eye_blink[-5:-1]):
right_number_of_blinks += 1
if len(right_eye_blink) > 20:
del right_eye_blink[0]
cv2.drawContours(frame_debug, [right_box], -1, (0, 139, 0), 2)
cv2.drawContours(frame_debug, [left_box], -1, (0, 139, 0), 2)
cv2.imshow("left", left_eye)
cv2.imshow("right", right_eye)
drawText(
frame_debug,
f"NumberOfBlinksOfRightEye: {right_number_of_blinks}",
(20, 50),
color="red",
)
drawText(
frame_debug,
f"NumberOfBlinksOfLeftEye: {left_number_of_blinks}",
(20, 80),
color="red",
)
cv2.imshow("", frame_debug)
if output:
writer.write(cv2.resize(frame_debug, frame_size))
key = cv2.waitKey(1)
if key in [ord("q"), 27]:
break
elif key == ord("s"):
cv2.imwrite(
"saved_%s.jpg" %
time.strftime("%Y%m%d_%H%M%S", time.localtime()),
frame_debug,
)
fps_handler.printStatus()
if source:
cap.release()
if output:
writer.release()
cv2.destroyAllWindows()
def fire_detection(source, video_path, output, fps, frame_size):
"""
基于深度学习的烟火检测器
"""
# click.echo(click.get_current_context().params)
device_info = getDeviceInfo() # type: dai.DeviceInfo
with dai.Device(create_pipeline(source), device_info) as device:
fps_handler = FPSHandler()
if source:
cap = cv2.VideoCapture(video_path)
frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
frame_shape = [frame_height, frame_width]
print("CAP_PROP_FRAME_SHAPE: %s" % frame_shape)
cap_fps = int(cap.get(cv2.CAP_PROP_FPS))
print("CAP_PROP_FPS: %d" % cap_fps)
fire_in = device.getInputQueue("fire_in")
else:
cam_out = device.getOutputQueue("rgb")
fire_nn = device.getOutputQueue("fire_nn")
def should_run():
if source:
return cap.isOpened()
else:
return True
def get_frame():
if source:
return cap.read()
else:
return True, cam_out.get().getCvFrame()
if output:
output.parent.mkdir(parents=True, exist_ok=True)
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
writer = cv2.VideoWriter(str(output), fourcc, fps, frame_size)
label_map = ["fire", "normal", "smoke"]
while should_run():
read_correctly, frame = get_frame()
if not read_correctly:
break
frame_debug = frame.copy()
if source:
run_nn(frame_debug, fire_in, 224, 224)
fire_data = toTensorResult(fire_nn.get()).get("final_result")
fps_handler.tick("fire")
conf = np.max(fire_data)
if conf > 0.5:
label = label_map[np.argmax(fire_data)]
drawText(frame_debug, f"{label}", (10, 30), "black")
drawText(frame_debug, f"{conf:.2%}", (10, 50), "black")
cv2.imshow("", frame_debug)
if output:
writer.write(cv2.resize(frame_debug, frame_size))
key = cv2.waitKey(1)
if key in [ord("q"), 27]:
break
elif key == ord("s"):
cv2.imwrite(
"saved_%s.jpg" %
time.strftime("%Y%m%d_%H%M%S", time.localtime()),
frame_debug,
)
fps_handler.printStatus()
if source:
cap.release()
if output:
writer.release()
cv2.destroyAllWindows()
def __init__(self, _grid, _hero):
super(StrengthCell, self).__init__(_grid)
self.image = utils.loadImage('data/gfx/strengthcell.png', alpha = True)
self._hero = _hero
self._before = 0
utils.drawText(self.image, "Sila", 9, (0, 0, 0), (16, 6))
def __init__(self, _engine, _editor, _map):
"""_engine - obiekt silnika, _editor - obiekt edytora, _map - obiekt mapy."""
super(TilesGrid, self).__init__()
self.images = {
'hover': utils.loadImage('data/gfx/hover.png', alpha=True),
'normal': utils.loadImage('data/gfx/normal.png', alpha=True),
}
self._engine = _engine
self._editor = _editor
self._map = _map
self._layer = HoverLayer(_map, True)
self._map.addLayer('ToolHover', 5, self._layer)
self._clicked = None
self._hover = None
self._updated = []
self.screenUpdated()
self.surface = pygame.Surface((192, 312))
self.surface.fill((1, 5, 4))
self.surface.set_colorkey((1, 5, 4))
self._tool = Tool(_editor, _map)
self._toolHover = HoverLayer.Sprite()
self._layer.add('tool', self._toolHover)
_tiles = ( # dostępne kafelki
field.Field,
wall.WallTopLeft,
wall.WallTopRight,
wall.WallBottomLeft,
wall.WallBottomRight,
wall.WallHorizontal,
wall.WallVertical,
stairs.StairsUpNorth,
stairs.StairsDownNorth,
stairs.StairsUpSouth,
stairs.StairsDownSouth,
stairs.StairsUpWest,
stairs.StairsDownWest,
stairs.StairsUpEast,
stairs.StairsDownEast,
trap.TrapMoveArrow,
trap.TrapMoveFire,
trap.TrapMoveIce,
trap.TrapTouchArrow,
trap.TrapTouchFire,
trap.TrapTouchIce,
chest.ChestNorth,
chest.ChestSouth,
chest.ChestWest,
chest.ChestEast,
)
_modifiers = (field.MODIFIER_HERO, field.MODIFIER_SPIDER,
field.MODIFIER_SKELETON, field.MODIFIER_MAGE,
field.MODIFIER_TROLL)
# Kafelki
utils.drawText(self.surface, "Kafelki", 22, (255, 255, 255), (96, 10))
self._tiles = pygame.sprite.Group()
for y in xrange(5):
for x in xrange(5):
tile = _tiles[y * 5 + x]
tile = tile.Sprite((x, y), tile)
tile.rect.center = tile.rect.centerx + x * 8, tile.rect.centery + y * 8 + 20
self._tiles.add(tile)
self._tiles.draw(self.surface)
for tile in self._tiles:
self.surface.blit(self.images['hover'], tile.rect.topleft)
self.surface.blit(self.images['normal'], tile.rect.topleft)
# Modyfikatory
utils.drawText(self.surface, "Modyfikatory", 22, (255, 255, 255),
(96, 225))
self._modifiers = pygame.sprite.Group()
for x in xrange(5):
modifier = field.Modifier((x, 0), _modifiers[x])
modifier.rect.center = modifier.rect.centerx + x * 8, modifier.rect.centery + 240
self._modifiers.add(modifier)
self._modifiers.draw(self.surface)
for tile in self._modifiers:
self.surface.blit(self.images['hover'], tile.rect.topleft)
self.surface.blit(self.images['normal'], tile.rect.topleft)
def _render(self):
self._engine.tick()
for event in self._engine.events():
if event.type == QUIT:
self._play = False
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
self._engine.runLoop = False
from twisted.internet import reactor
reactor.stop()
return
if self._map:
if event.key in (K_w, K_UP):
self._client.sendAction('u')
self._last = time.time()
elif event.key in (K_s, K_DOWN):
self._client.sendAction('d')
self._last = time.time()
elif event.key in (K_a, K_LEFT):
self._client.sendAction('l')
self._last = time.time()
elif event.key in (K_d, K_RIGHT):
self._client.sendAction('r')
self._last = time.time()
elif event.key in (K_RETURN, K_RCTRL, K_LCTRL):
self._client.sendAction('c')
self._last = time.time()
elif event.key == K_q:
self._client.sendAction('e')
self._last = time.time()
if self._map and self._last + 1./self._engine.options['fps'] < time.time():
self._client.sendAction('m')
self._last = time.time()
if not self._map and self._playerID == None:
self.surface = self._background.copy()
utils.drawText(self.surface, 'Oczekiwanie na graczy!', 20, (255, 255, 255), (self._resx / 2, self._resy / 2))
updated = []
if self._play:
for submodule in self._submodules:
updated.extend(submodule.update())
submodule.draw(self.surface)
if self._refresh:
self._engine.show(self.surface)
self._refresh = False
else:
self._engine.show(self.surface, updated)
if not self._play:
time.sleep(5)
self._engine.runLoop = False
from twisted.internet import reactor
reactor.stop()
return
def __init__(self, _engine, _editor, _map):
"""_engine - obiekt silnika, _editor - obiekt edytora, _map - obiekt mapy."""
super(TilesGrid, self).__init__()
self.images = {
'hover': utils.loadImage('data/gfx/hover.png', alpha = True),
'normal': utils.loadImage('data/gfx/normal.png', alpha = True),
}
self._engine = _engine
self._editor = _editor
self._map = _map
self._layer = HoverLayer(_map, True)
self._map.addLayer('ToolHover', 5, self._layer)
self._clicked = None
self._hover = None
self._updated = []
self.screenUpdated()
self.surface = pygame.Surface((192, 312))
self.surface.fill((1, 5, 4))
self.surface.set_colorkey((1, 5, 4))
self._tool = Tool(_editor, _map)
self._toolHover = HoverLayer.Sprite()
self._layer.add('tool', self._toolHover)
_tiles = ( # dostępne kafelki
field.Field,
wall.WallTopLeft, wall.WallTopRight, wall.WallBottomLeft, wall.WallBottomRight, wall.WallHorizontal, wall.WallVertical,
stairs.StairsUpNorth, stairs.StairsDownNorth, stairs.StairsUpSouth, stairs.StairsDownSouth, stairs.StairsUpWest, stairs.StairsDownWest, stairs.StairsUpEast, stairs.StairsDownEast,
trap.TrapMoveArrow, trap.TrapMoveFire, trap.TrapMoveIce, trap.TrapTouchArrow, trap.TrapTouchFire, trap.TrapTouchIce,
chest.ChestNorth, chest.ChestSouth, chest.ChestWest, chest.ChestEast,
)
_modifiers = (field.MODIFIER_HERO, field.MODIFIER_SPIDER, field.MODIFIER_SKELETON, field.MODIFIER_MAGE, field.MODIFIER_TROLL)
# Kafelki
utils.drawText(self.surface, "Kafelki", 22, (255, 255, 255), (96, 10))
self._tiles = pygame.sprite.Group()
for y in xrange(5):
for x in xrange(5):
tile = _tiles[y * 5 + x]
tile = tile.Sprite((x, y), tile)
tile.rect.center = tile.rect.centerx + x * 8, tile.rect.centery + y * 8 + 20
self._tiles.add(tile)
self._tiles.draw(self.surface)
for tile in self._tiles:
self.surface.blit(self.images['hover'], tile.rect.topleft)
self.surface.blit(self.images['normal'], tile.rect.topleft)
# Modyfikatory
utils.drawText(self.surface, "Modyfikatory", 22, (255, 255, 255), (96, 225))
self._modifiers = pygame.sprite.Group()
for x in xrange(5):
modifier = field.Modifier((x, 0), _modifiers[x])
modifier.rect.center = modifier.rect.centerx + x * 8, modifier.rect.centery + 240
self._modifiers.add(modifier)
self._modifiers.draw(self.surface)
for tile in self._modifiers:
self.surface.blit(self.images['hover'], tile.rect.topleft)
self.surface.blit(self.images['normal'], tile.rect.topleft)
def __init__(self, _grid, _hero):
super(AgilityCell, self).__init__(_grid)
self.image = utils.loadImage('data/gfx/agilitycell.png', alpha = True)
self._hero = _hero
self._before = 0
utils.drawText(self.image, "Zrecznosc", 9, (0, 0, 0), (16, 6))
def draw(self, surface): surface.blit(self.image, self.rect.topleft) utils.drawText(surface, str(self._hero.stats['agility']) + '%', 12, (255, 255, 255), (self.rect.centerx, self.rect.centery + 6)) if self._hero.stats['points']: utils.drawText(surface, '+', 14, (255, 0, 0), (self.rect.right - 7, self.rect.bottom - 7))
def setup(self, startWindow=None, playerName=None):
self.params = GameParams() # To be filled by user input
# Set up scorekeeping
self.score = 0
self.scoreKeeper = ScoreKeeper()
self.scoreKeeper.setFile('asteroidScore.txt')
# Set up window
width = 800
height = 600
font = sf.Font.from_file("rust.ttf")
self.params.setFont(font)
if startWindow is None:
# startWindow is None unless this is a restart
startWindow = sf.RenderWindow(sf.VideoMode(width, height),
"Asteroids")
startWindow.framerate_limit = 60
startWindow.clear(sf.Color.BLACK)
#Display Welcome
welcomeText = utils.drawText(startWindow,
string="Asteroids",
size=60,
font=font,
position='center')
startWindow.display()
# Wait for any input
while (True):
setup = False
for event in startWindow.events:
if type(event) is sf.CloseEvent:
exit()
elif (type(event) is sf.MouseButtonEvent
or type(event) is sf.KeyEvent):
setup = True
if setup:
break
# Select Player Name
if playerName is None:
playerName = utils.textInput(startWindow,
"Enter Name:",
font,
maxLength=10)
self.params.setPlayerName(playerName.lower())
#Choose Difficulty
difficulty = utils.selectOptions(startWindow,
["Easy", "Medium", "Hard"], [0, 1, 2],
font)
makeTimes = [20, 15, 12]
timeModifiers = [0.98, 0.95, 0.92]
self.params.setDifficulty(difficulty)
self.timeToMakeAsteroid = makeTimes[difficulty]
self.makeTimeModifier = timeModifiers[difficulty]
self.lastAsteroidTime = time.time() - self.timeToMakeAsteroid
self.timeToMakePowerup = 20
self.lastPowerupTime = time.time() - self.timeToMakePowerup
self.powerupProbability = 1 / 600
# Set up Board
self.board = Board(title="Asteroids", width=700, height=700)
# Set up Ship
self.ship = Ship(position=(self.board.getBoundary()[0] / 2,
self.board.getBoundary()[1] / 2))
self.ship.setWrapping(True)
self.ship.setBoundary(self.board.getBoundary())
startWindow.close()
def updateEntity(self, screen, inputStream, entity):
# hacer rectangulo de camara
cameraRect = entity.camera.rect
clipRect = pygame.Rect(cameraRect.x, cameraRect.y, cameraRect.w,
cameraRect.h)
screen.set_clip(clipRect)
# actualizar camara si esta siguiendo la entidad
if entity.camera.entityToTrack is not None:
trackedEntity = entity.camera.entityToTrack
currentX = entity.camera.worldX
currentY = entity.camera.worldY
targetX = trackedEntity.position.rect.x + trackedEntity.position.rect.w / 2
targetY = trackedEntity.position.rect.y + trackedEntity.position.rect.h / 2
#velocidad de delay en el seguimiento de la camara
entity.camera.worldX = (currentX * 0.92) + (targetX * 0.08)
entity.camera.worldY = (currentY * 0.92) + (targetY * 0.08)
# calcular bordes de la camara(offsets)
# borde en x = rectangulo camara en x + la mitad de el ancho del rect de camara - la entidad de la camara en x
offsetX = cameraRect.x + cameraRect.w / 2 - entity.camera.worldX
# borde en x = rectangulo camara en y + la mitad de la altura del rect de camara - la entidad de la camara en y
offsetY = cameraRect.y + cameraRect.h / 2 - entity.camera.worldY
#color fondo de pantalla camara
screen.fill(globals.GRIS)
# renderizar plataformas
for p in globals.world.platforms:
newPosRect = pygame.Rect(p.x + offsetX, p.y + offsetY, p.w, p.h)
screen.blit(platform, (newPosRect))
#renderizar entidades
for e in globals.world.entities:
s = e.state
a = e.animations.animationList[s]
a.draw(screen, e.position.rect.x + offsetX,
e.position.rect.y + offsetY, e.direction == "right", False)
#HUD del jugador
# PUNTAJE
if entity.score is not None:
screen.blit(
utils.coin1,
(entity.camera.rect.x + 10, entity.camera.rect.y + 10))
utils.drawText(screen, str(entity.score.score),
entity.camera.rect.x + 65,
entity.camera.rect.y + 35, globals.BLANCO, 255)
# VIDAS
if entity.battle is not None:
for l in range(entity.battle.lives):
# poner vidas en pantalla en X + repeticion cuantas vidas hayan, y
screen.blit(utils.vida_image,
(entity.camera.rect.x + 10 +
(l * 20), entity.camera.rect.y + 65))
# deshacer rectangulo de camara
screen.set_clip(None)
def _connectionError(self, msg):
self._play = False
utils.drawText(self.surface, str(msg), 10, (255, 255, 255), (self._resx / 2, self._resy - 10))
def _connectionError(self, msg):
self._play = False
utils.drawText(self.surface, str(msg), 10, (255, 255, 255), (self._resx / 2, self._resy - 10))
def setup(self, startWindow=None, playerName=None):
self.params = GameParams() # To be filled by user input
# Set up scorekeeping
self.score = 0
self.scoreKeeper = ScoreKeeper()
self.scoreKeeper.setFile('breakoutScore.txt')
# Set up window
width = 800
height = 600
font = sf.Font.from_file("rust.ttf")
self.params.setFont(font)
if startWindow is None:
# startWindow is None unless this is a restart
startWindow = sf.RenderWindow(sf.VideoMode(width, height),
"Breakout")
startWindow.framerate_limit = 60
startWindow.clear(sf.Color.BLACK)
#Display Welcome
welcomeText = utils.drawText(startWindow,
string="Breakout",
size=60,
font=font,
position='center')
startWindow.display()
# Wait for any input
while (True):
setup = False
for event in startWindow.events:
if type(event) is sf.CloseEvent:
exit()
elif (type(event) is sf.MouseButtonEvent
or type(event) is sf.KeyEvent):
setup = True
if setup:
break
# Select Player Name
if playerName is None:
playerName = utils.textInput(startWindow,
"Enter Name:",
font,
maxLength=10)
self.params.setPlayerName(playerName.lower())
#Choose Difficulty
#difficulty = utils.selectOptions(startWindow, ["Easy", "Medium", "Hard"], [0, 1, 2], font)
#self.params.setDifficulty(difficulty)
# Set up Board
self.board = Board(title="Breakout", width=1000, height=500)
# Set up Paddle
self.paddle = Paddle(boundary=self.board.getBoundary(),
width=75,
height=15)
self.paddle.setMoveSpeed(10)
# Gameplay parameters
self.maxLayers = 5
self.level = 1
startWindow.close()
