Ejemplo n.º 1
0
 def __init__(self):
     """Constructor of the Game"""
     self._running = True
     self.size = self.width, self.height = 450, 600
     # create main display - 640x400 window
     # try to use hardware acceleration
     self.screen = pygame.display.set_mode((400,200))#, pygame.HWSURFACE
     pygame.display.set_caption('AirHockey Server')
     self.clock = pygame.time.Clock()
     # set default tool
     self.tool = 'run'
     self.player  = Player.Player(1,r = 30 )   # Синий нижний игрок
     self.player.start_pos(self)
     self.cursor1 = Cursor.Cursor(player=self.player,game=self)
     self.player0 = Player.Player(0,r = 30 )    # Красный верхний игрок
     self.player0.start_pos(self)
     self.cursor0 = Cursor.Cursor(player=self.player0,game=self)
     self.players = (self.player0, self.player)
     self.ball    = Ball.Ball(x = self.width/2, y = self.height/2)
     self.ethik   = 10                                                  # Толщина отступов
     self.ecolor = (255,179,0)
     self.gate = 40                                                     # Полудлина ворот
     self.pressed = pygame.key.get_pressed()
     self.cursor_text = 5
     self.start_server()
     self.cursors = (self.cursor0,self.cursor1)
     self.mode = 3
Ejemplo n.º 2
0
def draw(frame_time):
    global objList, map
    clear_canvas()
    map.Draw()
    for k in objList.keys():
        for o in objList[k]:
            o.Draw(frame_time)
    Cursor.draw(frame_time)
    update_canvas()
Ejemplo n.º 3
0
    def battle_init(self):
        self.subphase = None

        # Instanciate the camera handler
        self.camhandler = CameraHandler()

        # Instanciate the keyboard tile traverser
        self.inputs = KeyboardTileTraverser(self)

        # Instanciate the battle graphics
        self.battleGraphics = BattleGraphics(self.party['map'])

        # Light the scene
        self.battleGraphics.lightScene()

        # Display the terrain
        self.battleGraphics.displayTerrain()

        # Play the background music
        self.music = base.loader.loadSfx(GAME + '/music/' +
                                         self.party['map']['music'] + '.ogg')
        self.music.setLoop(True)
        self.music.play()

        # Load sounds
        self.hover_snd = base.loader.loadSfx(GAME + "/sounds/hover.ogg")
        self.clicked_snd = base.loader.loadSfx(GAME + "/sounds/clicked.ogg")
        self.cancel_snd = base.loader.loadSfx(GAME + "/sounds/cancel.ogg")
        self.attack_snd = base.loader.loadSfx(GAME + "/sounds/attack.ogg")
        self.die_snd = base.loader.loadSfx(GAME + "/sounds/die.ogg")

        # Place highlightable tiles on the map
        self.matrix = Matrix(self.battleGraphics, self.party['map'])
        self.matrix.placeChars(self.party['chars'])

        # Instanciate and hide the AT flag
        self.at = AT()
        self.at.hide()

        self.charbars = None
        self.charcard = None
        self.actionpreview = None

        # Generate the sky and attach it to the camera
        self.sky = Sky(self.party['map'])

        # Tasks
        taskMgr.add(self.characterDirectionTask, 'characterDirectionTask')

        # Cursor stuff
        self.cursor = Cursor(self.battleGraphics, self.matrix.container)

        # Add the special effects
        self.battleGraphics.addEffects()

        # Battle intro animation
        SequenceBuilder.battleIntroduction(self).start()
Ejemplo n.º 4
0
	def __init__(self, posx, posy, width, height, cursor_size, background_colour = (255,255,255), buttons = [], text_size = 25):
		self.posx = posx
		self.posy = posy
		self.buttons = buttons
		self.background = pygame.Surface((width, height), pygame.SRCALPHA)
		self.background.fill(background_colour)
		self.option = 0
		self.num_options = 0
		self.text_size = text_size
		self.cursor = Cursor(size = cursor_size)
Ejemplo n.º 5
0
class Menu:
	def __init__(self, posx, posy, width, height, cursor_size, background_colour = (255,255,255), buttons = [], text_size = 25):
		self.posx = posx
		self.posy = posy
		self.buttons = buttons
		self.background = pygame.Surface((width, height), pygame.SRCALPHA)
		self.background.fill(background_colour)
		self.option = 0
		self.num_options = 0
		self.text_size = text_size
		self.cursor = Cursor(size = cursor_size)
	#We need to pass the set of buttons just in case you added a new set for submenues
	def update(self, buttons = None):
		if buttons == None:
			buttons = self.buttons
		button = self.getButton(self.option)
		(surf,rect) = button
		self.cursor.update(rect)
	def render(self, screen, buttons = None):
		if buttons == None:
			buttons = self.buttons
		self.update()
		screen.blit(self.background, (self.posx,self.posy))
		for ((buttonSurf, buttonRect), text) in buttons:
			screen.blit(buttonSurf, buttonRect)
		self.cursor.render(screen)
	def changeOption(self, offset):
		self.option = (self.option + offset)%len(self.buttons)
		if self.option < 0:
			self.option = len(self.buttons)
	def getOption(self):
		return self.option
	def setOption(self, option):
		self.option = option
	def getTextSize(self):
		return self.text_size
	def appendButton(self, text, posx, posy, colour=(255, 255, 255), size = 25, position = TextPosition.left, font = F_DROID_SANS):
		self.buttons.append((writeText(text, posx, posy, colour, size, position, font), text))
		self.num_options += 1
	def getButtonText(self, index = -1):
		if index != -1:
			opt = index
		else:
			opt = self.option
		(button, text) = self.buttons[opt]
		return text
	def getButton(self, index):
		(button, text) = self.buttons[index]
		return button
	def getNumOptions(self):
		return self.num_options
Ejemplo n.º 6
0
def SendMouseClick(a):
    x, y = Recognition.getXYCoord(a)
    print(x,y)
    if (x != -999 & y != -999):
        Cursor.MoveCursor(x,y)
        pyautogui.click(x,y)
        time.sleep(0.5)
Ejemplo n.º 7
0
def schettings(oldSpeed):
    selfIntro = True
    largeText = pygame.font.Font('freesansbold.ttf', 30)
    TextSurfSchpeed, TextRectSchpeed = text_objects("Schpeed", largeText)
    TextRectSchpeed.left = ((width / 4))
    TextRectSchpeed.centery = ((height / 4))
    TextSurfBonus, TextRectBonus = text_objects("Bonus", largeText)
    TextRectBonus.left = ((width / 4))
    TextRectBonus.centery = ((height / 2))
    menuPoints = ((TextSurfSchpeed, TextRectSchpeed, "Schpeed"),
                  (TextSurfBonus, TextRectBonus, "Bonus"))
    cursor = Cursor.Cursor(cursorImage, 10, 10, 25, 25)
    currentCursor = 0
    returnValue = None
    while selfIntro:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
            elif event.type == KEYDOWN:
                if event.key == 13:
                    selfIntro = False
                    returnValue = oldSpeed
                elif event.key == 27:
                    pygame.quit()
                    quit()
                elif event.key == 274:
                    if currentCursor < (len(menuPoints) - 1):
                        currentCursor = currentCursor + 1
                elif event.key == 273:
                    if currentCursor > 0:
                        currentCursor = currentCursor - 1
                elif event.key == 276:
                    oldSpeed = oldSpeed - 1
                elif event.key == 275:
                    oldSpeed = oldSpeed + 1
                elif event.key == 93:
                    oldSpeed = oldSpeed + 10
                elif event.key == 47:
                    oldSpeed = oldSpeed - 10
        screen.fill(black)
        TextSurfSchpeedValue, TextRectSchpeedValue = text_objects(
            str(oldSpeed), largeText)
        TextRectSchpeedValue.left = (width / 1.5)
        TextRectSchpeedValue.centery = (TextRectSchpeed.centery)
        count = 0
        while count < len(menuPoints):
            if currentCursor == count:
                cursor.setPos(menuPoints[count][1].left - 26,
                              menuPoints[count][1].top + 2)
            count = count + 1
        screen.blit(cursor.image, cursor.rectPoint)
        screen.blit(TextSurfSchpeed, TextRectSchpeed)
        screen.blit(TextSurfSchpeedValue, TextRectSchpeedValue)
        screen.blit(TextSurfBonus, TextRectBonus)
        pygame.display.update()
        clock.tick(15)
        if returnValue is not None:
            return returnValue
Ejemplo n.º 8
0
	def battle_init(self):
		self.subphase = None
		
		# Instanciate the camera handler
		self.camhandler = CameraHandler()
		
		# Instanciate the keyboard tile traverser
		self.inputs = KeyboardTileTraverser(self)
		
		# Instanciate the battle graphics
		self.battleGraphics = BattleGraphics(self.party['map'])
		
		# Light the scene
		self.battleGraphics.lightScene()
		
		# Display the terrain
		self.battleGraphics.displayTerrain()
		
		# Play the background music
		self.music = base.loader.loadSfx(GAME+'/music/'+self.party['map']['music']+'.ogg')
		self.music.setLoop(True)
		self.music.play()
		
		# Load sounds
		self.hover_snd   = base.loader.loadSfx(GAME+"/sounds/hover.ogg")
		self.clicked_snd = base.loader.loadSfx(GAME+"/sounds/clicked.ogg")
		self.cancel_snd  = base.loader.loadSfx(GAME+"/sounds/cancel.ogg")
		self.attack_snd  = base.loader.loadSfx(GAME+"/sounds/attack.ogg")
		self.die_snd     = base.loader.loadSfx(GAME+"/sounds/die.ogg")
		
		# Place highlightable tiles on the map
		self.matrix = Matrix(self.battleGraphics, self.party['map'])
		self.matrix.placeChars(self.party['chars'])
		
		# Instanciate and hide the AT flag
		self.at = AT()
		self.at.hide()
		
		self.charbars = None
		self.charcard = None
		self.actionpreview = None
		
		# Generate the sky and attach it to the camera
		self.sky = Sky(self.party['map'])
		
		# Tasks
		taskMgr.add(self.characterDirectionTask , 'characterDirectionTask')
		
		# Cursor stuff
		self.cursor = Cursor(self.battleGraphics, self.matrix.container)
		
		# Add the special effects
		self.battleGraphics.addEffects()
		
		# Battle intro animation
		SequenceBuilder.battleIntroduction(self).start()
Ejemplo n.º 9
0
def gameIntro():
    selfIntro = True
    largeText = pygame.font.Font('freesansbold.ttf', 30)
    TextSurfSchnake, TextRectSchnake = text_objects("Schnake", largeText)
    TextRectSchnake.left = ((width / 4))
    TextRectSchnake.centery = ((height / 4))
    TextSurfSchettings, TextRectSchettings = text_objects(
        "Schettings", largeText)
    TextRectSchettings.left = ((width / 4))
    TextRectSchettings.centery = ((height / 2))
    TextSurfSchcoreboard, TextRectSchcoreboard = text_objects(
        "Schcoreboard", largeText)
    TextRectSchcoreboard.left = ((width / 4))
    TextRectSchcoreboard.centery = ((height / 4 * 3))
    menuPoints = ((TextSurfSchnake, TextRectSchnake, "Schnake"),
                  (TextSurfSchettings, TextRectSchettings, "Schettings"),
                  (TextSurfSchcoreboard, TextRectSchcoreboard, "Schcoreboard"))
    cursor = Cursor.Cursor(cursorImage, 10, 10, 25, 25)
    currentCursor = 0
    returnValue = None
    while selfIntro:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
            elif event.type == KEYDOWN:
                if event.key == 13:
                    selfIntro = False
                    returnValue = menuPoints[currentCursor][2]
                elif event.key == 27:
                    pygame.quit()
                    quit()
                elif event.key == 274:
                    if currentCursor < (len(menuPoints) - 1):
                        currentCursor = currentCursor + 1
                elif event.key == 273:
                    if currentCursor > 0:
                        currentCursor = currentCursor - 1
        screen.fill(black)
        count = 0
        while count < len(menuPoints):
            if currentCursor == count:
                cursor.setPos(menuPoints[count][1].left - 26,
                              menuPoints[count][1].top + 2)
            count = count + 1
        screen.blit(cursor.image, cursor.rectPoint)
        screen.blit(TextSurfSchnake, TextRectSchnake)
        screen.blit(TextSurfSchettings, TextRectSchettings)
        screen.blit(TextSurfSchcoreboard, TextRectSchcoreboard)
        pygame.display.update()
        clock.tick(15)
        if returnValue is not None:
            return returnValue
Ejemplo n.º 10
0
    def __init__(self, options):
        self.options = []
        font = pygame.font.Font("Fonts/dejavu.ttf", 20)
        x = 105
        y = 305
        reference = 1
        self.cursor = Cursor.cursor(x - 30, y, 30)

        for title, function in options:
            self.options.append(
                Option.option(font, title, x, y, reference, function))
            y += 30
            if reference == 1:
                reference = -1
            else:
                reference = 1

        self.select = 0
        self.total = len(self.options)
        self.m_pulse = False
Ejemplo n.º 11
0
    def __init__(self):
        self.mode = MODE_COMMANDS  # Other is MODE_USERPLAY where you are in control of the hero

        if CURSES:
            # Initialize curses
            cbreak()
            noecho()

        # Initialize the Kernel
        Kernel()

        # Set's up the socket
        NethackSock()

        # Socket observers
        SocketLogger(
        )  # This should be before other stuff for easier debugging
        FramebufferParser()
        DGLParser()

        # Stuff
        Console()
        Cursor()
        Dungeon()
        Hero()
        MonsterSpoiler()
        ItemDB()
        Inventory()

        # AI
        Personality()
        Senses()
        Pathing()

        # Brains
        curBrain = TestBrain()

        Kernel.instance.Personality.setBrain(curBrain)  # Default brain
Ejemplo n.º 12
0
 # If the map was loaded successfully, finish setting everything up and run the event.
 if not battleGraphics is None:
     # Light the scene
     battleGraphics.lightScene()
     # Bind camera controls to keys.
     camhandler = CameraHandler.CameraHandler()
     camhandler.accept('escape', lambda: sys.exit())
     # Play the background music
     music = base.loader.loadSfx(GAME + '/music/' + mapJSON['music'] +
                                 '.ogg')
     music.setLoop(True)
     music.play()
     # Place highlightable tiles on the map
     matrix = Matrix(battleGraphics, mapJSON)
     # Cursor stuff
     cursor = Cursor(battleGraphics, matrix.container)
     # Add the special effects
     battleGraphics.addEffects()
     try:
         # Load event.
         imp.load_source('event', EVENT)
         #
         print ""
         print ""
         print "Controls: "
         print ""
         print "  G:	Rotate Map Left"
         print "  F:	Rotate Map Right"
         print "  H:	Ascend/Descend"
         print "  D:	Zoom In/Zoom Out"
         print "  ESC:	End Test"
Ejemplo n.º 13
0
    def generic(self):
        logger.info("Generic")
        lord_units = [
            unit for unit in self.allunits
            if unit.position and 'Lord' in unit.tags and unit.team == 'player'
        ]
        lord_position = lord_units[0].position if lord_units else (0, 0)
        # Certain variables change if this is being initialized at beginning of game, and not a save state
        self.phase = CustomObjects.Phase(self)
        self.statedict = {
            'previous_cursor_position': lord_position,
            'levelIsComplete': False,  # Whether the level is complete
            'outroScriptDone': False
        }  # Whether the outro script has been played
        # For hiding menus
        self.hidden_active = None
        self.hidden_child = None
        self.main_menu = None
        # Combat slots
        self.combatInstance = None
        self.levelUpScreen = []
        # Banner slots
        self.banners = []
        # Status slots
        self.status = None
        # AI slots
        self.ai_current_unit = None
        self.ai_unit_list = None
        self.ai_build_flag = True
        # Movement manager
        self.moving_units = set()

        # Handle cursor
        if any(unit.team == 'player' and unit.position
               for unit in self.allunits):
            # cursor_position = [unit.position for unit in self.allunits if unit.team == 'player' and unit.position][0]
            cursor_position = lord_position
        else:
            cursor_position = (0, 0)
        self.cursor = Cursor.Cursor('Cursor', cursor_position)
        self.fake_cursors = []
        self.tutorial_mode = False

        # Handle cameraOffset
        # Track how much camera has moved in pixels:
        self.cameraOffset = CustomObjects.CameraOffset(self.cursor.position[0],
                                                       self.cursor.position[1])
        self.cursor.autocursor(self, force=True)
        # Other slots
        self.highlight_manager = CustomObjects.HighlightController()
        self.allarrows = []
        self.allanimations = []

        # Reset the units updates on load
        # And have the units arrive on map
        for unit in self.allunits:
            unit.resetUpdates()
            if unit.position:
                unit.place_on_map(self)
                unit.arrive(self, serializing=False)

        self.info_menu_struct = {
            'current_state': 0,
            'scroll_units': [],
            'one_unit_only': False,
            'chosen_unit': None
        }
Ejemplo n.º 14
0
import pygame, sys, os, media, Zombie, Hero, Cursor
from pygame.locals import *

FPS = 24

pygame.init()
window = pygame.display.set_mode((media.WINDOW_WIDTH, media.WINDOW_HEIGHT), pygame.DOUBLEBUF)
pygame.mixer.init(11025)
media.prepare()

window.blit(media.BACKGROUND, (0,0))
pygame.display.flip()
pygame.display.set_caption('ZOMBIE')

cursor = Cursor.Cursor()
cgroup = pygame.sprite.RenderUpdates()
cgroup.add(cursor)

zombies = pygame.sprite.RenderUpdates()
heroes = pygame.sprite.RenderUpdates()


for i in xrange(0,1):
  heroes.add(Hero.Hero())

for i in xrange(0,6):
	zombies.add(Zombie.Zombie(heroes))

def update():
	cgroup.clear(window, media.BACKGROUND)
	zombies.clear(window, media.BACKGROUND)
Ejemplo n.º 15
0
    def __init__(self, client, scenario, faction):
        global _gui
        _gui = self

        self.scenario = scenario
        self.client = client
        self.faction = faction
        self.lightEnv = scenario.lightEnvironment()
        self.setLighting()
        self.focusedElement = None
        self.fsm = ScenarioGUIFSM(self)

        self.m = scenario.map()
        m = self.m
        for j in xrange(0, m.height):
            for i in xrange(0, m.width):
                self.compileMapSquareList(m.squares[i][j])

        self._highlightAlpha = 1.0  
        self.camera = Camera.Camera()
        self.lastCameraRotation = None
        self.sortedMapSquares = []

        # FIXME: make a single chatbox object
        textColor = (64, 0, 0)
        self.textEntry = Sprite.TextEntry()
        self.textEntry.setPosn((10, 160))
        self.textEntry.setColor(textColor) # FIXME: 0-255 color
        self.chatBox1 = Sprite.TextDisplayer()
        self.chatBox1.setPosn((10, 60))
        self.chatBox1.setColor(textColor) # FIXME: 0-255 color
        self.chatBox1.setText("")
        self.chatBox2 = Sprite.TextDisplayer()
        self.chatBox2.setPosn((10, 80))
        self.chatBox2.setColor(textColor) # FIXME: 0-255 color
        self.chatBox2.setText("")
        self.chatBox3 = Sprite.TextDisplayer()
        self.chatBox3.setPosn((10, 100))
        self.chatBox3.setColor(textColor) # FIXME: 0-255 color
        self.chatBox3.setText("")
        self.chatBox4 = Sprite.TextDisplayer()
        self.chatBox4.setPosn((10, 120))
        self.chatBox4.setColor(textColor) # FIXME: 0-255 color
        self.chatBox4.setText("")
        self.chatBox5 = Sprite.TextDisplayer()
        self.chatBox5.setPosn((10, 140))
        self.chatBox5.setColor(textColor) # FIXME: 0-255 color
        self.chatBox5.setText("")
        
        self.cursor = Cursor.Cursor(m)
        self.cursorPosnDisplayer = Sprite.CursorPosnDisplayer(self.cursor)
        self.unitNameDisplayer = Sprite.UnitNameDisplayer(self.cursor)
        self.unitMovementDisplayer = Sprite.UnitMovementDisplayer(self.cursor)
        self.unitHPDisplayer = Sprite.UnitHPDisplayer(self.cursor)
        self.unitSPDisplayer = Sprite.UnitSPDisplayer(self.cursor)
        self.unitPhysicalDisplayer = Sprite.UnitPhysicalDisplayer(self.cursor)
        self.unitMagicalDisplayer = Sprite.UnitMagicalDisplayer(self.cursor)
        self.unitClassDisplayer = Sprite.UnitClassDisplayer(self.cursor)
        self.unitSpeedDisplayer = Sprite.UnitSpeedDisplayer(self.cursor)
        tdbWidth = 250
        tdbHeight = 8
        tdbY = MainWindow.get().size()[1] - tdbHeight * 20 - 30
        self.textDisplayerBox = Sprite.TextDisplayerBox([
            self.unitNameDisplayer,
            self.unitClassDisplayer,
            self.unitHPDisplayer,
            self.unitSPDisplayer,
            self.unitMovementDisplayer,
            self.unitSpeedDisplayer,
            self.unitPhysicalDisplayer,
            self.unitMagicalDisplayer,
            ], (10, tdbY) , tdbWidth)
        self._battleMenu = Sprite.BattleMenu((290, tdbY))
        self._specialMenu = Sprite.SpecialMenu((420, tdbY))

        self._centeredTextDisplayer = Sprite.TextDisplayer()
        self._centeredTextDisplayer.setCenterX(True)
        self._centeredTextDisplayer.setCenterY(True)
        self._centeredTextDisplayer.setFont(Resources.font(size=36, bold=True))
        self._centeredTextDisplayer.setPosn((MainWindow.get().size()[0]/2,
                                             MainWindow.get().size()[1]/2))
        self._centeredTextDisplayer.setBorder(True)
        self._centeredTextDisplayer.setEnabled(False)

        self._topTextDisplayer = Sprite.TextDisplayer()
        self._topTextDisplayer.setCenterX(True)
        self._topTextDisplayer.setCenterY(False)
        self._topTextDisplayer.setFont(Resources.font(size=16, bold=True))
        self._topTextDisplayer.setPosn((MainWindow.get().size()[0]/2, 10))
        self._topTextDisplayer.setBorder(True)
        self._topTextDisplayer.setEnabled(False)
        self._topTextDisplayerClearer = None
        
        self.units = scenario.units()
        self.battle = scenario.battle()
        self.unitDisplayers = []
        self.unitDisplayersDict = {}
        for u in self.units:
            ud = Sprite.UnitDisplayer(u)
            self.unitDisplayers.append(ud)
            self.unitDisplayersDict[u] = ud
        self.highlights = {}
        self.cursorHighlightAlpha = 0.0
        self.highlightEnabled = False

        self.normalObjects = [self.cursor]
        self.fgObjects = [self.textEntry,
                          self.chatBox1,
                          self.chatBox2,
                          self.chatBox3,
                          self.chatBox4,
                          self.chatBox5,                          
                          self.cursorPosnDisplayer,
                          self.textDisplayerBox,
                          self._battleMenu,
                          self._specialMenu,
                          self._centeredTextDisplayer,
                          self._topTextDisplayer]
        self.gameObjects = []
        self.gameObjects.extend(self.normalObjects)
        self.gameObjects.extend(self.fgObjects)
        self.gameObjects.extend(self.unitDisplayers)

        # FIXME: rename/remove these
        self._unitMoving = None
        self.unitTarget = None
        self.originalUnitPosn = None
        self.lastUnitMove = None
        self.nextUnitMovePosn = None
        self.unitMoveZDiff = None

        Sound.playMusic(scenario.music())

        (clearr, clearg, clearb) = self.lightEnv.skyColor()
        glClearColor(clearr, clearg, clearb, 0.0)
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)       

        self.scrollTo((self.m.width/2.0, self.m.height/2.0))
Ejemplo n.º 16
0
def main(speed, score):
    print("main")
    intro = True
    screen.fill(black)
    snake = Snake.Snake(snakeImage, 10, 10, 10, 10)
    seperator = Cursor.Cursor(seperatorImage, 0, 410, 450, 10)
    pygame.display.flip()
    direction = (10, 0)
    foodx = (randint(1, 20) - 1) * 10
    foody = (randint(1, 20) - 1) * 10
    food = Food.Food(foodImage, foodx, foody, 10, 10)
    snakeLength = 0
    snakeChain = []
    gameOver = False
    while 1:
        #normal game start
        screen.fill(black)
        if snake.rectPoint[0] == food.rectPoint[0] and snake.rectPoint[
                1] == food.rectPoint[1]:
            food = None
            snakeChainImage = pygame.image.load('snake.png').convert()
            snakeChain.append(
                Snake.Snake(snakeChainImage, snake.rectPoint[0],
                            snake.rectPoint[1], 10, 10))
            snakeLength = snakeLength + 1
            score = score + 1
        if food is None:
            foodx = (randint(1, 20) - 1) * 10
            foody = (randint(1, 20) - 1) * 10
            food = Food.Food(foodImage, foodx, foody, 10, 10)
            food.move(foodx, foody)
            screen.blit(food.image, food.rectPoint)
        else:
            screen.blit(food.image, food.rectPoint)

        clock.tick(speed)
        temp = directionKey(direction)
        if temp is not None:
            direction = temp
        count = snakeLength
        while (count != 0):
            if count == 1:
                snakeChain[count - 1].setPos(snake.rectPoint[0],
                                             snake.rectPoint[1])
            else:
                snakeChain[count - 1].setPos(
                    snakeChain[count - 2].rectPoint[0],
                    snakeChain[count - 2].rectPoint[1])
            screen.blit(snakeChain[count - 1].image,
                        snakeChain[count - 1].rectPoint)
            count = count - 1
        snake.move(direction[0], direction[1])
        if snake.rectPoint[0] < 0 or snake.rectPoint[
                0] > 400 or snake.rectPoint[1] < 0 or snake.rectPoint[1] > 400:
            gameOver = True
        if selfCollision(snake, snakeChain) == True:
            gameOver = True
        screen.blit(snake.image, snake.rectPoint)
        screen.blit(seperator.image, seperator.rectPoint)
        scoreUp(score)
        pygame.display.update()
        if gameOver == True:
            dbconnection = DBConnect.DBConnect("localhost", "schnake",
                                               "schnake", "schnake").connection
            dbcursor = dbconnection.cursor()
            query = (
                "SELECT count(*), min(score_value), score_name FROM scoreboard ORDER BY score_value DESC LIMIT 10"
            )
            insert = (
                "INSERT INTO scoreboard(score_name, score_value) VALUES('REN', "
                + score + ")")
            dbcursor.execute(query)
            for a in dbcursor:
                lowestScore = a[1]
                scoreCount = a[0]
            if score > lowestScore or scoreCount < 10:
                largeText = pygame.font.Font('freesansbold.ttf', 30)
                TextSurfHS, TextRectHS = text_objects("NEW HIGHSCORE",
                                                      largeText)
                TextRectHS.centerx = ((width / 2))
                TextRectHS.centery = ((200))
                screen.blit(TextSurfHS, TextRectHS)

                pygame.display.update()

                dbconnection.close()
                dbcursor.close()
            else:
                largeText = pygame.font.Font('freesansbold.ttf', 30)
                TextSurfGO, TextRectGO = text_objects("Game Over", largeText)
                TextRectGO.centerx = ((width / 2))
                TextRectGO.centery = ((200))
                screen.blit(TextSurfGO, TextRectGO)
                pygame.display.update()
                enter = False
                while enter is not True:
                    for event in pygame.event.get():
                        if event.type == pygame.QUIT:
                            pygame.quit()
                            quit()
                        elif event.type == KEYDOWN:
                            if event.key == 13:
                                enter = True
                break
Ejemplo n.º 17
0
class Client(object):
	
	def __init__(self):
		self.music = base.loader.loadSfx(GAME+'/music/24.ogg')
		self.music.setLoop(True)
		self.music.play()
		self.background = GUI.Background(self.loginScreen)
	
	# Display the login window
	def loginScreen(self):
		self.loginwindow = GUI.LoginWindow(self.authenticate)
	
	def processData(self, datagram):
		iterator = PyDatagramIterator(datagram)
		source = datagram.getConnection()
		callback = iterator.getString()
		getattr(globals()[callback], 'execute')(self, iterator)
	
	# This task process data sent by the server, if any
	def tskReaderPolling(self, taskdata):
		if self.cReader.dataAvailable():
			datagram=NetDatagram()
			if self.cReader.getData(datagram):
				self.processData(datagram)
		return Task.cont
	
	# Setup connection and send the LOGIN datagram with credentials
	def authenticate(self):
		login = self.loginwindow.loginEntry.get()
		password = self.loginwindow.passwordEntry.get()
		
		self.cManager  = QueuedConnectionManager()
		self.cListener = QueuedConnectionListener(self.cManager, 0)
		self.cReader   = QueuedConnectionReader(self.cManager, 0)
		self.cReader.setTcpHeaderSize(4)
		
		self.myConnection = self.cManager.openTCPClientConnection(IP, PORT, 5000)
		if self.myConnection:
			self.cReader.addConnection(self.myConnection)
			self.send = Send(self.cManager, self.myConnection)
			print 'Client listening on', IP, ':', PORT
			taskMgr.add(self.tskReaderPolling, "Poll the connection reader")
			
			self.send.LOGIN_MESSAGE(login, password)
			
		else:
			print 'Can\'t connect to server on', IP, ':', PORT
	
	# The battle begins
	def battle_init(self):
		self.subphase = None
		
		# Instanciate the camera handler
		self.camhandler = CameraHandler()
		
		# Instanciate the keyboard tile traverser
		self.inputs = KeyboardTileTraverser(self)
		
		# Instanciate the battle graphics
		self.battleGraphics = BattleGraphics(self.party['map'])
		
		# Light the scene
		self.battleGraphics.lightScene()
		
		# Display the terrain
		self.battleGraphics.displayTerrain()
		
		# Play the background music
		self.music = base.loader.loadSfx(GAME+'/music/'+self.party['map']['music']+'.ogg')
		self.music.setLoop(True)
		self.music.play()
		
		# Load sounds
		self.hover_snd   = base.loader.loadSfx(GAME+"/sounds/hover.ogg")
		self.clicked_snd = base.loader.loadSfx(GAME+"/sounds/clicked.ogg")
		self.cancel_snd  = base.loader.loadSfx(GAME+"/sounds/cancel.ogg")
		self.attack_snd  = base.loader.loadSfx(GAME+"/sounds/attack.ogg")
		self.die_snd     = base.loader.loadSfx(GAME+"/sounds/die.ogg")
		
		# Place highlightable tiles on the map
		self.matrix = Matrix(self.battleGraphics, self.party['map'])
		self.matrix.placeChars(self.party['chars'])
		
		# Instanciate and hide the AT flag
		self.at = AT()
		self.at.hide()
		
		self.charbars = None
		self.charcard = None
		self.actionpreview = None
		
		# Generate the sky and attach it to the camera
		self.sky = Sky(self.party['map'])
		
		# Tasks
		taskMgr.add(self.characterDirectionTask , 'characterDirectionTask')
		
		# Cursor stuff
		self.cursor = Cursor(self.battleGraphics, self.matrix.container)
		
		# Add the special effects
		self.battleGraphics.addEffects()
		
		# Battle intro animation
		SequenceBuilder.battleIntroduction(self).start()
	
	def updateAllSpritesAnimations(self, animation):
		for i,charid in enumerate(self.matrix.sprites):
			Sequence(
				Wait(float(i)/6.0),
				Func(self.updateSpriteAnimation, charid, animation),
			).start()
	
	def end(self):
		taskMgr.remove('characterDirectionTask')
		for child in render.getChildren():
			child.removeNode()
		self.camhandler.destroy()
		self.coords.destroy()
		self.sky.remove()
		self.background = GUI.Background(self.send.GET_PARTIES)
	
	def showMenu(self, charid):
		self.inputs.ignoreAll()
		self.camhandler.ignoreAll()
		
		canmove = self.party['chars'][charid]['canmove']
		canact  = self.party['chars'][charid]['canact']
		
		columns = [ { 'x': -25, 'font': GUI.regularfont, 'align': TextNode.ALeft   }, ]
		
		rows = [
			{ 'cells': ['Move'        ], 'enabled': canmove, 'callback': lambda: self.send.GET_WALKABLES  (charid) },
			{ 'cells': ['Act'         ], 'enabled': canact , 'callback': lambda: self.onAttackClicked(charid) },
			{ 'cells': ['Wait'        ], 'enabled': True   , 'callback': lambda: self.onWaitClicked  (charid) },
			{ 'cells': ['Status'      ], 'enabled': False  , 'callback': lambda: self.onWaitClicked  (charid) },
			{ 'cells': ['Auto-Battle' ], 'enabled': False  , 'callback': lambda: self.onWaitClicked  (charid) },
		]
		
		GUI.ScrollableList(
			'shadowed', 73, -8, 62.0, 91.0, 16, 
			columns, rows, 5, 
			lambda: self.onCancelClicked(charid), 
			'Menu'
		)
	
	def moveCheck(self, charid, orig, origdir, dest):
		self.inputs.ignoreAll()
		self.camhandler.ignoreAll()
		GUI.MoveCheck(
			lambda: self.send.MOVE_TO(charid, dest),
			lambda: self.cancelMove(charid, orig, origdir)
		)
	
	def cancelMove(self, charid, orig, origdir):
		self.matrix.sprites[charid].node.setPos(self.battleGraphics.logic2terrain(orig))
		self.matrix.sprites[charid].setRealDir(origdir)
		self.send.UPDATE_PARTY()
	
	# Makes a character look at another one
	def characterLookAt(self, charid, targetid):
		(x1, y1, z1) = self.matrix.getCharacterCoords(charid)
		(x2, y2, z2) = self.matrix.getCharacterCoords(targetid)
		if x1 > x2:
			self.matrix.sprites[charid].setRealDir(3)
		if x1 < x2:
			self.matrix.sprites[charid].setRealDir(1)
		if y1 > y2:
			self.matrix.sprites[charid].setRealDir(4)
		if y1 < y2:
			self.matrix.sprites[charid].setRealDir(2)
	
	# Update the status (animation) of a sprite after something happened
	def updateSpriteAnimation(self, charid, animation=False):
		if animation:
			self.matrix.sprites[charid].animation = animation
		else:
			stats = self.party['chars'][charid]
			if stats['hp'] >= (stats['hpmax']/2):
				self.matrix.sprites[charid].animation = 'walk'
			if stats['hp'] < (stats['hpmax']/2):
				self.matrix.sprites[charid].animation = 'weak'
			if stats['hp'] <= 0:
				self.matrix.sprites[charid].animation = 'dead'
				self.die_snd.play()
		h = self.camhandler.container.getH()
		self.matrix.sprites[charid].updateDisplayDir( h, True )
	
	def updateCursorPos(self, pos):
		
		self.camhandler.move(self.battleGraphics.logic2terrain(pos))
		
		(x, y, z) = pos
		tile = self.party['map']['tiles'][x][y][z]
		
		self.cursor.move(x, y, z, tile)
		
		if self.charbars:
			self.charbars.hide()
		
		if self.party['map']['tiles'][x][y][z].has_key('char'):
			charid = self.party['map']['tiles'][x][y][z]['char']
			char = self.party['chars'][charid]
			if self.subphase == 'attack':
				self.charbars = GUI.CharBarsRight(char)
			else:
				self.charbars = GUI.CharBarsLeft(char)
		
		try:
			self.coords.update(tile)
		except:
			self.coords = GUI.Coords(tile)
	
### Events
	
	# Battle func
	def setupWalkableTileChooser(self, charid, walkables):
		self.inputs.acceptAll()
		self.camhandler.acceptAll()
		self.subphase = 'move'
		self.matrix.setupWalkableZone(charid, walkables)
		if self.charcard:
			self.charcard.hide()
	
	# Battle func
	def setupAttackableTileChooser(self, charid, attackables):
		self.inputs.acceptAll()
		self.camhandler.acceptAll()
		self.subphase = 'attack'
		self.matrix.setupAttackableZone(charid, attackables)
		if self.charcard:
			self.charcard.hide()
	
	# Battle func
	def setupDirectionChooser(self, charid):
		self.inputs.ignoreAll()
		self.camhandler.acceptAll()
		self.at.hide()
		DirectionChooser(charid, self.matrix.sprites[charid], self.camhandler, self.send.WAIT, self.send.UPDATE_PARTY)
	
	# Attack button clicked
	def onAttackClicked(self, charid):
		self.inputs.ignoreAll()
		self.camhandler.ignoreAll()
		GUI.Help(
			0, 25, 155, 44,
			'shadowed', 'Check',
			'Specify the target with the cursor.\nPress the %c button to select.' % CIRCLE_BTN.upper(),
			lambda: self.send.GET_ATTACKABLES(charid),
			self.send.UPDATE_PARTY,
		)
	
	# Wait menu item chosen
	def onWaitClicked(self, charid):
		self.inputs.ignoreAll()
		self.camhandler.ignoreAll()
		GUI.Help(
			0, 25, 135, 60,
			'shadowed', 'Check',
			'Specify the direction with\nthe Directional buttons.\nPress the %c button to select.' % CIRCLE_BTN.upper(),
			lambda: self.setupDirectionChooser(charid),
			self.send.UPDATE_PARTY,
		)
	
	# Cancel menu item chosen
	def onCancelClicked(self, charid):
		self.inputs.acceptAll()
		self.camhandler.acceptAll()
		if self.charcard:
			self.charcard.hide()
	
	### Tasks
	
	# Updates the displayed direction of a character according to the camera angle
	def characterDirectionTask(self, task):
		h = self.camhandler.container.getH()
		for charid in self.matrix.sprites:
			self.matrix.sprites[charid].updateDisplayDir( h );
		return Task.cont
Ejemplo n.º 18
0
import TitleState as StartStage
import Player
import Object
import Gun
import Monster
import Cursor
import Item
from pico2d import *

open_canvas(sync=True)
# 믹서 채널 할당
Mix_AllocateChannels(50)
# 커서 숨기기
hide_cursor()
# 커서 로딩
Cursor.init()
# 폰트 로딩
game_framework.font = load_font('resource/pf_arma_five.ttf')
# 오브젝트 데이터 로드
with open('resource/player.json', 'r') as f:
    Player.playerData = json.load(f)
with open('resource/monster.json', 'r') as f:
    Monster.monsterData = json.load(f)
with open('resource/teleporter.json', 'r') as f:
    Object.Teleporter.data = json.load(f)
with open('resource/item.json', 'r') as f:
    Item.itemData = json.load(f)
with open('resource/pistol.json', 'r') as f:
    Gun.pistolData = json.load(f)
with open('resource/machine_gun.json', 'r') as f:
    Gun.machineGunData = json.load(f)
menu_img = "menu.jpg"
instructions_img = "instructions.jpg"
game_back_img = "Stock.jpg"
correct_sound_file = "correct_sound_effect.wav"
wrong_sound_file = "wrong_sound_effect.wav"

screen = pygame.display.set_mode((1018,516),0,32)
pygame.display.set_caption('Purple Hammer')
game_back = pygame.image.load(game_back_img).convert()
menu = pygame.image.load(menu_img).convert_alpha()
instructions = pygame.image.load(instructions_img).convert_alpha()
correct_sound = pygame.mixer.Sound(correct_sound_file)
wrong_sound = pygame.mixer.Sound(wrong_sound_file)

cursor = Cursor()
dots = Dots()

cursor.move_cursor(menu, screen, 1, cursor.start_pos_1)

cursor.NavigateOptions(Dots, menu, screen, instructions)
cursor.redraw(dots, screen, game_back, False, "None", True)

count = 1
done = False
first = True

while True:
    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
Ejemplo n.º 20
0
    def __init__(self, config):

        super(Window, self).__init__()
        self.currentPath = ''
        self._mode = "pan"
        self.photoList = []
        self.pathList = []
        self.tabClosed = False
        self.config = config

        #Defaults
        self.windowDefault = dict(self.config['windowDefault'].items())
        self.propertiesDefault = dict(self.config['propertiesDefault'].items())
        self.canvasDefault = dict(self.config['canvasDefault'].items())
        self.chartDefault = dict(self.config['chartDefault'].items())
        self.HS = int(self.windowDefault['hs'])
        self.VS = int(self.windowDefault['vs'])
        self.energy = int(self.windowDefault['energy'])
        self.azimuth = int(self.windowDefault['azimuth'])
        self.scaleBarLength = int(self.windowDefault['scalebarlength'])
        self.chiRange = int(self.windowDefault['chirange'])
        self.width = float(self.windowDefault['width'])
        self.widthSliderScale = int(self.windowDefault['widthsliderscale'])
        self.radius = int(self.windowDefault['radius'])
        self.radiusMaximum = int(self.windowDefault['radiusmaximum'])
        self.radiusSliderScale = int(self.windowDefault['radiussliderscale'])
        self.tiltAngle = int(self.windowDefault['tiltangle'])
        self.tiltAngleSliderScale = int(
            self.windowDefault['tiltanglesliderscale'])

        #Menu bar
        self.menu = QtWidgets.QMenuBar()
        self.menuFile = self.menu.addMenu("File")
        self.menuPreference = self.menu.addMenu("Preference")
        self.menu2DMap = self.menu.addMenu("2D Map")
        self.menuFit = self.menu.addMenu("Fit")
        self.menuHelp = self.menu.addMenu("Help")
        self.setMenuBar(self.menu)

        #File Menu
        self.openFile = self.menuFile.addAction("Open", self.MenuActions_Open)
        self.export = self.menuFile.addMenu("Export")
        self.saveCanvasAsImage = self.export.addAction(
            "RHEED pattern", self.MenuActions_Save_As_Image)
        self.saveProfileAsText = self.export.addAction(
            "Line Profile", self.MenuActions_Save_As_Text)

        #Preference Menu
        self.defaultSettings = self.menuPreference.addAction("Default Settings",\
                                    self.MenuActions_Preference_DefaultSettings)

        #2D Map Menu
        self.Two_Dimensional_Mapping = self.menu2DMap.addAction("Configuration", \
                                                             self.MenuActions_Two_Dimensional_Mapping)

        self.Three_Dimensional_Graph = self.menu2DMap.addAction("3D Graph", \
                                                                  self.MenuActions_Three_Dimensional_Graph)

        #Help Menu
        self.about = self.menuHelp.addAction("About", self.MenuActions_About)

        #Center Widget
        self.image_crop = [
            1200 + self.VS, 2650 + self.VS, 500 + self.HS, 3100 + self.HS
        ]

        self.mainSplitter = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
        self.mainTab = QtWidgets.QTabWidget()
        self.mainTab.setContentsMargins(0, 0, 0, 0)
        self.mainTab.setTabsClosable(True)
        self.controlPanelFrame = QtWidgets.QWidget(self)
        self.controlPanelGrid = QtWidgets.QGridLayout(self.controlPanelFrame)
        self.controlPanelGrid.setContentsMargins(0, 0, 0, 0)
        self.controlPanelSplitter = QtWidgets.QSplitter(QtCore.Qt.Vertical)
        self.browser = Browser(self)
        self.controlPanelBottomWidget = QtWidgets.QWidget()
        self.controlPanelBottomGrid = QtWidgets.QGridLayout(
            self.controlPanelBottomWidget)
        self.controlPanelBottomGrid.setContentsMargins(0, 0, 2, 0)
        self.properties = Properties(self, self.config)
        self.cursorInfo = Cursor(self)
        self.profile = ProfileChart.ProfileChart(self.config)
        self.controlPanelBottomGrid.addWidget(self.properties, 0, 0)
        self.controlPanelBottomGrid.addWidget(self.cursorInfo, 1, 0)
        self.controlPanelBottomGrid.addWidget(self.profile, 2, 0)
        self.controlPanelSplitter.addWidget(self.browser)
        self.controlPanelSplitter.addWidget(self.controlPanelBottomWidget)

        self.controlPanelSplitter.setSizes([100, 500])
        self.controlPanelSplitter.setStretchFactor(0, 1)
        self.controlPanelSplitter.setStretchFactor(1, 1)
        self.controlPanelSplitter.setCollapsible(0, False)
        self.controlPanelSplitter.setCollapsible(1, False)
        self.controlPanelGrid.addWidget(self.controlPanelSplitter, 0, 0)

        self.mainSplitter.addWidget(self.mainTab)
        self.mainSplitter.addWidget(self.controlPanelFrame)
        self.mainSplitter.setSizes([800, 400])
        self.mainSplitter.setStretchFactor(0, 1)
        self.mainSplitter.setStretchFactor(1, 1)
        self.mainSplitter.setCollapsible(0, False)
        self.mainSplitter.setCollapsible(1, False)

        #Tool bar
        self.toolBar = QtWidgets.QToolBar(self)
        self.toolBar.setFloatable(False)
        self.toolBar.setMovable(False)
        self.open = QtWidgets.QAction(QtGui.QIcon("./icons/open.svg"), "open",
                                      self)
        self.saveAs = QtWidgets.QAction(QtGui.QIcon("./icons/save as.svg"),
                                        "save as", self)
        self.zoomIn = QtWidgets.QAction(QtGui.QIcon("./icons/zoom in.svg"),
                                        "zoom in (Ctrl + Plus)", self)
        self.zoomIn.setShortcut(QtGui.QKeySequence.ZoomIn)
        self.zoomOut = QtWidgets.QAction(QtGui.QIcon("./icons/zoom out.svg"),
                                         "zoom out (Ctrl + Minus)", self)
        self.zoomOut.setShortcut(QtGui.QKeySequence.ZoomOut)
        self.fitCanvas = QtWidgets.QAction(QtGui.QIcon("./icons/fit.svg"),
                                           "fit in view", self)
        self.line = QtWidgets.QAction(QtGui.QIcon("./icons/line.svg"), "line",
                                      self)
        self.line.setCheckable(True)
        self.rectangle = QtWidgets.QAction(
            QtGui.QIcon("./icons/rectangle.svg"), "rectangle", self)
        self.rectangle.setCheckable(True)
        self.arc = QtWidgets.QAction(QtGui.QIcon("./icons/arc.svg"), "arc",
                                     self)
        self.arc.setCheckable(True)
        self.pan = QtWidgets.QAction(QtGui.QIcon("./icons/move.svg"), "pan",
                                     self)
        self.pan.setCheckable(True)
        self.buttonModeGroup = QtWidgets.QActionGroup(self.toolBar)
        self.buttonModeGroup.addAction(self.line)
        self.buttonModeGroup.addAction(self.rectangle)
        self.buttonModeGroup.addAction(self.arc)
        self.buttonModeGroup.addAction(self.pan)
        self.toolBar.addAction(self.open)
        self.toolBar.addAction(self.saveAs)
        self.toolBar.addSeparator()
        self.toolBar.addAction(self.line)
        self.toolBar.addAction(self.rectangle)
        self.toolBar.addAction(self.arc)
        self.toolBar.addAction(self.pan)
        self.toolBar.addSeparator()
        self.toolBar.addAction(self.zoomIn)
        self.toolBar.addAction(self.zoomOut)
        self.toolBar.addAction(self.fitCanvas)
        self.addToolBar(self.toolBar)

        #Status bar
        self.statusBar = QtWidgets.QStatusBar(self)
        self.messageLoadingImage = QtWidgets.QLabel("Processing ... ", self)
        self.messageLoadingImage.setVisible(False)
        self.progressBar = QtWidgets.QProgressBar(self)
        self.progressBar.setMaximumHeight(12)
        self.progressBar.setMaximumWidth(200)
        self.progressBar.setVisible(False)
        self.progressBar.setOrientation(QtCore.Qt.Horizontal)
        self.editPixInfo = QtWidgets.QLabel(self)
        self.editPixInfo.setAlignment(QtCore.Qt.AlignRight)
        self.editPixInfo.setMinimumWidth(150)
        self.statusBar.addWidget(self.messageLoadingImage)
        self.statusBar.insertPermanentWidget(1, self.progressBar)
        self.statusBar.addPermanentWidget(self.editPixInfo)
        self.setStatusBar(self.statusBar)

        #Main Window Settings
        self.setCentralWidget(self.mainSplitter)
        self.mainSplitter.setContentsMargins(2, 2, 0, 0)
        self.setWindowTitle("PyRHEED")

        #Main Tab Connections
        self.mainTab.currentChanged.connect(self.switchTab)
        self.mainTab.tabCloseRequested.connect(self.closeTab)

        #Toolbar Connections
        self.open.triggered.connect(
            lambda path: self.openImage(path=self.getImgPath()))
        self.line.triggered.connect(
            lambda cursormode: self.toggleCanvasMode(cursormode="line"))
        self.rectangle.triggered.connect(
            lambda cursormode: self.toggleCanvasMode(cursormode="rectangle"))
        self.arc.triggered.connect(
            lambda cursormode: self.toggleCanvasMode(cursormode="arc"))
        self.pan.triggered.connect(
            lambda cursormode: self.toggleCanvasMode(cursormode="pan"))

        #Progress Bar Connections
        self.progressAdvance.connect(self.progress)
        self.progressEnd.connect(self.progressReset)
        self.profile.progressAdvance.connect(self.progress)
        self.profile.progressEnd.connect(self.progressReset)

        #Browser Connections
        self.fileOpened.connect(self.browser.treeUpdate)
        self.imgCreated.connect(self.profile.setImg)
        self.browser.fileDoubleClicked.connect(self.openImage)

        #Parameters Page Connections
        self.properties.sensitivityEdit.textChanged.connect(
            self.changeSensitivity)
        self.properties.energyEdit.textChanged.connect(self.changeEnergy)
        self.properties.azimuthEdit.textChanged.connect(self.changeAzimuth)
        self.properties.scaleBarEdit.textChanged.connect(self.changeScaleBar)
        self.properties.labelButton.clicked.connect(self.labelImage)
        self.properties.calibrateButton.clicked.connect(self.calibrateImage)

        #Image Adjust Page Connections
        self.properties.brightnessSlider.valueChanged.connect(
            self.changeBrightness)
        self.properties.blackLevelSlider.valueChanged.connect(
            self.changeBlackLevel)
        self.properties.autoWBCheckBox.stateChanged.connect(self.changeAutoWB)
        self.properties.applyButton2.clicked.connect(self.applyImageAdjusts)
        self.properties.resetButton2.clicked.connect(self.resetImageAdjusts)

        #Profile Options Page Connections
        self.properties.integralHalfWidthSlider.valueChanged.connect(
            self.changeWidth)
        self.properties.chiRangeSlider.valueChanged.connect(
            self.changeChiRange)
        self.properties.radiusSlider.valueChanged.connect(self.changeRadius)
        self.properties.tiltAngleSlider.valueChanged.connect(
            self.changeTiltAngle)
        self.properties.applyButton3.clicked.connect(self.applyProfileOptions)
        self.properties.resetButton3.clicked.connect(self.resetProfileOptions)

        #Cursor Information Connections
        self.cursorInfo.choosedXYEdit.textChanged.connect(self.editChoosedXY)
        self.cursorInfo.startXYEdit.textChanged.connect(self.editStartXY)
        self.cursorInfo.endXYEdit.textChanged.connect(self.editEndXY)
        self.cursorInfo.widthEdit.textEdited.connect(self.editWidth)

        #Profile Canvas Connections
        self.scaleFactorChanged.connect(self.profile.setScaleFactor)
        self.profile.chartMouseMovement.connect(self.photoMouseMovement)

        #Refresh Connections
        self.propertiesRefresh.connect(self.properties.refresh)
        self.chartRefresh.connect(self.profile.refresh)

        self.getScaleFactor()
        self.window_initialized.emit()
Ejemplo n.º 21
0
    def paintGL(self):
        """
            first call requires initialization
        """
        if self.initialized == False:
            self.initialized = True
            self.initializeGL()
            print("initialization done")
        """  -----------------  """
        """  >>> main loop <<<  """
        """  -----------------  """
        # keep track of loop frequency
        flagStart = time.clock()
        """
            Events management.
            Keyboard interactions between the user and the software are done here.
        """
        Events.manage()
        """
            Update all entities ID
        """
        ID.setId([
            Avatar.virtuMan.limbs, Avatar.virtuMan.muscles, Sensors.virtuSens,
            Sensors.zoiSens
        ])
        """
            Preprocess entities.
            Store all needed transformations to significantly lower calculation cost when rendering (redundancy otherwise between display buffer, ID buffer and bindings)
        """

        # Preprocess of limbs
        Definitions.modelMatrix.push()
        Definitions.modelMatrix.translate(Avatar.virtuMan.position[0],
                                          Avatar.virtuMan.position[1],
                                          Avatar.virtuMan.position[2])
        R = Definitions.vector4D.Quat2Vec(
            Definitions.vector4D((Avatar.virtuMan.orientation)))
        Definitions.modelMatrix.rotate(R.o, R.x, R.y, R.z)
        Avatar.limb = -1  # initialize the recursivity here
        Sensors.countID = 0
        Graphics.SaturationModelMatrix = []
        Avatar.stick(Avatar.virtuMan)
        Definitions.modelMatrix.pop()

        Avatar.oneMesh(Avatar.virtuMan)

        Muscles.preprocessMuscle(Avatar.virtuMan)

        Scene.preprocessScene()
        """
            update camera
        """
        Definitions.viewMatrix.push()
        Definitions.viewMatrix.translate(0, 0, Events.frontBack_cam)
        Definitions.viewMatrix.rotate(Events.upDown_cam, 1, 0, 0)
        Definitions.viewMatrix.rotate(Events.leftRight_cam, 0, 1, 0)
        if Definitions.lookingAtID != 0:
            Definitions.viewMatrix.translate(-Definitions.lookingAt[0][0],
                                             -Definitions.lookingAt[0][1],
                                             -Definitions.lookingAt[0][2])
        glUniformMatrix4fv(Shaders.view_loc, 1, GL_FALSE,
                           Definitions.viewMatrix.peek())
        Definitions.viewMatrix.pop()
        """ 
            Draw on the ID buffer.
            The ID BUFFER is used for the mouse implementation, to know which entity is targeted with the cursor.
        """
        # bind the ID buffer
        glBindFramebuffer(GL_FRAMEBUFFER, self.idFBO)
        # clear the ID buffer
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        # fill ID buffer

        glViewport(0, 0, Graphics.display[0], Graphics.display[1])

        Graphics.modelView(Graphics.opaque)

        Limbs.drawBodySurface(Avatar.virtuMan, Graphics.idBuffer, Events.SHOW)
        Muscles.drawMuscleSurface(Avatar.virtuMan, Graphics.idBuffer,
                                  Events.SHOW)
        Sensors.drawZoi(Graphics.idBuffer)
        Sensors.drawSensor(Graphics.idBuffer)
        """
            Mouse interaction with ID buffer.
            Read the value of the ID buffer at mouse position, do some stuff.
        """
        dx = -8
        dy = -30
        Cursor.mouse = [
            QtGui.QCursor().pos().x() + dx,
            QtGui.QCursor().pos().y() + dy
        ]
        Cursor.mouseManage()
        """
            Draw on the display buffer.
            The display buffer is what the user will see on his screen.
        """
        # bind the display buffer
        glBindFramebuffer(GL_FRAMEBUFFER, self.displayFBO)

        # clear the display buffer
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
        glViewport(0, 0, Graphics.display[0], Graphics.display[1])

        # draw scene
        Graphics.modelView(Graphics.blending)
        Scene.drawScene()

        # draw saturation balls
        Graphics.modelView(Graphics.blending)
        Saturations.drawSaturationBalls(Avatar.virtuMan)

        # draw FADE body
        Graphics.modelView(Graphics.blending)
        Limbs.drawBodySurface(Avatar.virtuMan, Events.style, Events.FADE)
        # draw FADE muscles
        Graphics.modelView(Events.style)
        Muscles.drawMuscleSurface(Avatar.virtuMan, Events.style, Events.FADE)

        # draw SHOW body
        Graphics.modelView(Events.style)
        Limbs.drawBodySurface(Avatar.virtuMan, Events.style, Events.SHOW)
        Limbs.drawBodyEdge(Avatar.virtuMan, Events.style)
        # draw SHOW muscles
        Graphics.modelView(Events.style)
        Muscles.drawMuscleSurface(Avatar.virtuMan, Events.style, Events.SHOW)
        Muscles.drawMuscleEdge(Avatar.virtuMan, Events.style)

        # draw saturation lines
        Graphics.modelView(Graphics.opaque)
        Saturations.drawSaturationLines(Avatar.virtuMan)

        # draw sensors
        Graphics.modelView(Graphics.opaque)
        Sensors.drawLink(Events.style)
        Sensors.drawZoi(Events.style)
        Sensors.drawSensor(Events.style)
Ejemplo n.º 22
0
 def onVisibilityCursor(self, visibleFlag):
     if not visibleFlag and self.__denyHideCursor:
         return
     Cursor.forceShowCursor(visibleFlag)
     entity = BigWorld.player()
     entity.setFlyMouseInputAllowed(not visibleFlag)
Ejemplo n.º 23
0
def DebugSwitch(event):	# Open or close the debugger window


	try:	# If Debugger window can be destroyed, do so...
		Cfg.debugger.destroy()
		Cfg.debugger = None

	except:	# Otherwise create the debugger window...

	# Create Toplevel window for the debugger
		Cfg.debugger = Toplevel()
		Cfg.debugger.title("Reflection Debugger")
		Cfg.debugger.config(bg="#C0C0C0")
		Cfg.debugger.bind("<F1>", DebugSwitch)
		Cfg.debugger.bind("<F2>", quit)
		userslist = None

	# Create System Frame
		systemframe = LabelFrame(Cfg.debugger, text="System")
		systemframe.pack( side = LEFT, fill = Y  )

		sfb_invert = Button(systemframe, text="Invert background", command=SysBgInvert)
		sfb_invert.pack( side = TOP, fill = X )
		sfb_deluser = Button(systemframe, text = "Delete users", command = api_init3.destroyUsers)
		sfb_deluser.pack( side = TOP, fill = X )
		sfb_username = Entry(systemframe)
		sfb_username.pack( side = TOP, fill = X )
		sfb_newuser = Button(systemframe, text="New user", command= lambda: User_Control.UserCreate(sfb_username.get()))
		sfb_newuser.pack( side = TOP, fill = X )
		sfb_login = Button(systemframe, text="Log in user", command = lambda: User_Control.UserLogIn(userslist.index(ACTIVE)))
		sfb_login.pack( side = TOP, fill = X )
		sfb_cursoron = Button(systemframe, text="Cursor On", command = Cursor.CursorOn)
		sfb_cursoron.pack( side = TOP, fill = X )
		sfb_cursoroff = Button(systemframe, text="Cursor Off", command =  Cursor.CursorOff)
		sfb_cursoroff.pack( side = TOP, fill = X )
		sfb_cursorup = Button(systemframe, text="Cursor Up", command = lambda: Cursor.CursorMove("UP"))
		sfb_cursorup.pack( side = TOP, fill = X )
		sfb_cursordown = Button(systemframe, text="Cursor Down", command = lambda: Cursor.CursorMove("DOWN"))
		sfb_cursordown.pack( side = TOP, fill = X )
		sfb_cursorleft = Button(systemframe, text="Cursor Left", command = lambda: Cursor.CursorMove("LEFT"))
		sfb_cursorleft.pack( side = TOP, fill = X )
		sfb_cursorright = Button(systemframe, text="Cursor Right", command = lambda: Cursor.CursorMove("RIGHT"))
		sfb_cursorright.pack( side = TOP, fill = X )
		sfb_savesettings = Button(systemframe, text="Save Settings", command = User_Control.UserSaveSettings)
		sfb_savesettings.pack( side = TOP, fill = X )
		#sfb_loadsettings = Button(systemframe, text="Load Settings", command = User_Control.UserLogin)
		#sfb_loadsettings.pack( side = TOP, fill = X )


	# Create Users Frame
		usersframe = LabelFrame(Cfg.debugger, text="Users")
		usersframe.pack( side = LEFT, fill = Y   )
		userslist = Listbox(usersframe)
		userslist.pack(side = TOP)
		Users_Fill(userslist)

	# Create Task Controller
		moveframe = LabelFrame(Cfg.debugger, text="Move app")
		moveframe.pack( side = LEFT, fill = Y   )

			# Create place buttons
		cfb_NW = Button(moveframe, text = "NW" , command = lambda: AppControl.App_Move(app_list[taskbox.index(ACTIVE)],NW))
		cfb_NW.grid( row = 0, column = 0 , ipadx=2 )
		cfb_W = Button(moveframe, text = "W" , command = lambda: AppControl.App_Move(app_list[taskbox.index(ACTIVE)],W))
		cfb_W.grid( row = 1, column = 0 , ipadx=6 )
		cfb_SW = Button(moveframe, text = "SW" , command = lambda: AppControl.App_Move(app_list[taskbox.index(ACTIVE)],SW))
		cfb_SW.grid( row = 2, column = 0 , ipadx=4 )
		cfb_NE = Button(moveframe, text = "NE" , command = lambda: AppControl.App_Move(app_list[taskbox.index(ACTIVE)],NE))
		cfb_NE.grid( row = 0, column = 1 , ipadx=4 )
		cfb_E = Button(moveframe, text = "E" , command = lambda: AppControl.App_Move(app_list[taskbox.index(ACTIVE)],E))
		cfb_E.grid( row = 1, column = 1 , ipadx=9 )
		cfb_SE = Button(moveframe, text = "SE" , command = lambda: AppControl.App_Move(app_list[taskbox.index(ACTIVE)],SE))
		cfb_SE.grid( row = 2, column = 1 , ipadx=6 )

	# Create Task Manager
		taskframe = LabelFrame(Cfg.debugger, text="Task manager")
		taskframe.pack( side = LEFT, fill = Y  )

			 # Create new task button
		tfb_new = Button(taskframe, text="Run...", command = Task_New )
		tfb_new.pack( side = TOP, fill = X )

			# Create open tasks listbox
		taskbox = Listbox(taskframe)
		taskbox.pack(side = TOP)
		Fill_Manager(taskbox)

			# Create close task button
		tfb_close = Button(taskframe, text="Close task", command = lambda: Task_Close(taskbox.index(ACTIVE)) )
		tfb_close.pack( side = TOP, fill = X )

	# Make sure that the debugger is in the front
		Cfg.debugger.lift()
Ejemplo n.º 24
0
def initEnvironment():
    global curs

    initPlayers()
    initZombies(ZOMBS)
    curs = Cursor.Cursor()
Ejemplo n.º 25
0
def main():
    State.loadQuater()
    """ Create list of models """
    State.createList()
    State.updateTemplateList()
    """ Create Entities """
    StickMan.virtuMan = StickMan.characteristics(1.7, (0, 0, 0),
                                                 StickMan.parts)
    State.loadModel(StickMan.virtuMan)
    Saturations.preprocessSaturations(StickMan.virtuMan)

    State.loadSensors()
    """ Create a window """
    pygame.init()

    screen = pygame.display.set_mode(
        Events.display, pygame.DOUBLEBUF | pygame.OPENGL | pygame.OPENGLBLIT
        | RESIZABLE | NOFRAME)
    glClearColor(0.0, 0.0, 0.0, 0.0)
    """ texture for ID buffer """
    # create texture
    plane_texture = glGenTextures(1)
    glBindTexture(GL_TEXTURE_2D, plane_texture)
    # texture wrapping parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
    # texture filtering parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                    GL_LINEAR_MIPMAP_LINEAR)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE)
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Events.display[0],
                 Events.display[1], 0, GL_RGBA, GL_UNSIGNED_BYTE, None)
    glBindTexture(GL_TEXTURE_2D, 0)
    """ render buffer for depth for ID buffer """
    # create render buffer
    rbo = glGenRenderbuffers(1)
    glBindRenderbuffer(GL_RENDERBUFFER, rbo)
    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT,
                          Events.display[0], Events.display[1])
    glBindRenderbuffer(GL_RENDERBUFFER, 0)
    """ frame buffer object as ID buffer """
    # create frame buffer
    FBO = glGenFramebuffers(1)
    glBindFramebuffer(GL_FRAMEBUFFER, FBO)
    # attach texture to frame buffer
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                           plane_texture, 0)
    # attach render buffer to frame buffer
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
                              GL_RENDERBUFFER, rbo)
    glBindFramebuffer(GL_FRAMEBUFFER, 0)
    """ Generate the VBOs """
    Graphics.VBO_init()
    """ Create the shaders """
    Shaders.shader = OpenGL.GL.shaders.compileProgram(
        OpenGL.GL.shaders.compileShader(Shaders.vertex_shader,
                                        GL_VERTEX_SHADER),
        OpenGL.GL.shaders.compileShader(Shaders.fragment_shader,
                                        GL_FRAGMENT_SHADER))
    glUseProgram(Shaders.shader)
    """ Enable position attrib ? """
    position = glGetAttribLocation(Shaders.shader, "position")
    glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, 0, None)
    glEnableVertexAttribArray(position)
    """ Initialize some more stuff"""
    glEnable(GL_TEXTURE_2D)
    glDepthFunc(GL_LEQUAL)
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
    """ Shader var. locations """
    Shaders.proj_loc = glGetUniformLocation(Shaders.shader, "projection")
    Shaders.view_loc = glGetUniformLocation(Shaders.shader, "view")
    Shaders.model_loc = glGetUniformLocation(Shaders.shader, "model")
    Shaders.setColor_loc = glGetUniformLocation(Shaders.shader, "setColor")

    Definitions.projectionMatrix.perspectiveProjection(
        90, 0.5 * Events.display[0] / Events.display[1], 0.1, 100.0)
    glUniformMatrix4fv(Shaders.proj_loc, 1, GL_FALSE,
                       Definitions.projectionMatrix.peek())
    glUniformMatrix4fv(Shaders.model_loc, 1, GL_FALSE,
                       Definitions.modelMatrix.peek())
    """ Initialize UI Window """
    #menuWindow.init_window()
    """ Create Sensors Instances"""
    for imu in range(0, NB_IMU):
        IMU.createInstance()

    for emg in range(0, NB_EMG):
        EMG.createInstance()
    """ Initialize Data aquisition """
    Data_aquisition.initSerial()
    #Data_aquisition.initBuffers()
    Data_aquisition.initPoller()
    start_calib = True
    end_init = True
    t_start_init = 10000
    """ >>> main loop <<< """
    glViewport(0, 0, Events.display[0], Events.display[1])
    while True:
        # keep track of loop frequency
        flagStart = time.clock()
        """
            Events management.
            Most interactions between the user and the software is aknowledged here.
        """
        Events.manage()

        refreshId()  # TODO : only when adding/removing sensors
        """ Aquire Data from serial port and update values"""
        Data_aquisition.getData()

        IMU.updateSensors(end_init)
        EMG.updateSensors()
        """ Initiate calibration phase"""
        if start_calib == True:
            t_start_init = timer()
            start_calib = False
            print("START CALIBRATION")

        t_init = timer() - t_start_init
        """ Calibrate EMG during calibration phase"""
        if t_init < CALIB_TIME:
            EMG.calibration()
        """ Terminate calibration phase and set-up EMG data"""
        if t_init >= CALIB_TIME and end_init == True:
            print("END CALIBRATION")
            for imu in IMU.IMUs:
                imu.get_correct()

            for emg in EMG.EMGs:
                emg.updateBoundaries()

            end_init = False
        """ Correct coordinate frame and kinematics"""
        for imu in IMU.IMUs:
            imu.apply_correct()
        """ Apply quaternions to the virtual limbs"""
        armData = [imu.quater for imu in IMU.IMUs if imu.bodyPart == IMU.arm]
        if armData:
            Qarm = Definitions.vector4D([
                imu.quater for imu in IMU.IMUs if imu.bodyPart == IMU.arm
            ][0])  #[1,1,0,0]
            StickMan.virtuMan.parts[StickMan.ARM][StickMan.Data_angle] = [
                Qarm.o, Qarm.x, Qarm.y, Qarm.z
            ]

        forearmData = [
            imu.quater for imu in IMU.IMUs if imu.bodyPart == IMU.forearm
        ]
        if forearmData:
            Qforearm = Definitions.vector4D([
                imu.quater for imu in IMU.IMUs if imu.bodyPart == IMU.forearm
            ][0])  #[1,0,0,0]
            StickMan.virtuMan.parts[StickMan.FOREARM][StickMan.Data_angle] = [
                Qforearm.o, Qforearm.x, Qforearm.y, Qforearm.z
            ]
        #

        handData = [imu.quater for imu in IMU.IMUs if imu.bodyPart == IMU.hand]
        if handData:
            Qhand = Definitions.vector4D([
                imu.quater for imu in IMU.IMUs if imu.bodyPart == IMU.hand
            ][0])
            StickMan.virtuMan.parts[StickMan.HAND][StickMan.Data_angle] = [
                Qhand.o, Qhand.x, Qhand.y, Qhand.z
            ]
        """
            Preprocess entities.
            Store all needed transformations to significantly lower calculation cost when rendering (redundancy otherwise between display buffer, ID buffer and bindings)
        """
        Definitions.modelMatrix.translate(-StickMan.lookingAt[0][0],
                                          -StickMan.lookingAt[0][1],
                                          -StickMan.lookingAt[0][2])
        StickMan.part = -1  # initialize the recursivity here
        Sensors.countID = 0
        Graphics.SaturationModelMatrix = []
        StickMan.stick(
            StickMan.virtuMan,
            (StickMan.virtuMan.x, StickMan.virtuMan.y, StickMan.virtuMan.z))

        i = 0
        for package in Definitions.packagePreprocess:
            j = 0
            for pack in package:
                if pack[Definitions.packParent] == "Ground":
                    Definitions.packageIndices[
                        0] = Definitions.packageIndices[0] + [
                            [i, j],
                        ]
                elif pack[Definitions.packParent] == "Body":
                    Definitions.packageIndices[
                        1] = Definitions.packageIndices[1] + [
                            [i, j],
                        ]
                elif pack[Definitions.packParent] == "Sensor":
                    Definitions.packageIndices[
                        2] = Definitions.packageIndices[2] + [
                            [i, j],
                        ]
                elif pack[Definitions.packParent] == "Link":
                    Definitions.packageIndices[
                        3] = Definitions.packageIndices[3] + [
                            [i, j],
                        ]
                j += 1
            i += 1
        """ 
            Draw on the ID buffer.
            The ID BUFFER is used for the mouse implementation, to know which body/sensor/gui part is targeted with the cursor.
        """
        # bind the ID buffer
        glBindFramebuffer(GL_FRAMEBUFFER, FBO)

        # clear the ID buffer
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        # fill ID buffer
        Graphics.modelView(Graphics.opaque)
        StickMan.drawBodySurface(Graphics.idBuffer)
        Sensors.drawSensor(Graphics.idBuffer)
        """
            Mouse interaction with ID buffer.
            Read the value of the ID buffer at mouse position, do some stuff.
        """
        Cursor.mouseManage()
        """
            Draw on the display buffer.
            The display buffer is what the user will see on his screen.
        """
        # bind the display buffer
        glBindFramebuffer(GL_FRAMEBUFFER, 0)

        # clear the display buffer
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        #draw saturation balls
        Graphics.modelView(Graphics.blending)
        Saturations.drawSaturationBalls()

        # draw body
        Graphics.modelView(Events.style)
        StickMan.drawBodySurface(Events.style)
        StickMan.drawBodyEdge(Events.style)

        #draw saturation balls
        Graphics.modelView(Graphics.opaque)
        Saturations.drawSaturationLines()

        # draw sensors
        Graphics.modelView(Graphics.opaque)
        Sensors.drawSensor(Events.style)
        Sensors.drawDashed(Events.style)

        if Events.style != Graphics.idBuffer:
            """ load matrix in shader """
            I = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0],
                          [0, 0, 0, 1]])
            Definitions.modelMatrix.push()
            Definitions.modelMatrix.set(I)
            Definitions.modelMatrix.translate(0, -0.5, 0)
            Definitions.modelMatrix.scale(1, 0, 1)

            glUniformMatrix4fv(Shaders.model_loc, 1, GL_FALSE,
                               Definitions.modelMatrix.peek())
            """ choose vbo """
            vboId = 0
            vboDraw = Graphics.vboEdges
            """ bind surfaces vbo """
            Graphics.indexPositions[vboId][vboDraw].bind()
            Graphics.vertexPositions[vboId].bind()
            glVertexAttribPointer(0, 3, GL_FLOAT, False, 0, None)
            """ send color to shader """
            r, g, b, a = [255, 255, 255, 255]
            color = np.array([r / 255., g / 255., b / 255., a / 255.],
                             dtype=np.float32)
            glUniform4fv(Shaders.setColor_loc, 1, color)
            Definitions.modelMatrix.pop()
            """ draw vbo """
            glDrawElements(Graphics.styleIndex[vboId][vboDraw],
                           Graphics.nbIndex[vboId][vboDraw], GL_UNSIGNED_INT,
                           None)

        # update screen
        pygame.display.flip()
        """
            empty preprocess package
        """
        i = len(Definitions.packagePreprocess)
        while i > 0:
            i -= 1
            while len(Definitions.packagePreprocess[i]) > 0:
                Definitions.packagePreprocess[
                    i] = Definitions.packagePreprocess[i][:-1]
        i = len(Definitions.packageIndices)
        while i > 0:
            i -= 1
            while len(Definitions.packageIndices[i]) > 0:
                Definitions.packageIndices[i] = Definitions.packageIndices[
                    i][:-1]

        pygame.time.wait(15)
Ejemplo n.º 26
0
import Button
import InputBox

#initialize pygame
pygame.init()
#initialize randomizing
random.seed()
#SETTINGS
holes = [(140,150),(410,150),(680,150),(140,277),(410,277),(680,277),(140,394),(410,394),(680,394)]

#Sprite directories
background =  pygame.image.load(os.path.join("data","background.png"))
mole = Mole.Mole(os.path.join("data","mole.png"))
moleHit = Mole.Mole(os.path.join("data","mole_hit.png"))
cursors = pygame.sprite.Group()
hammer = Cursor.Cursor(os.path.join("data", "hammer.png"))
hammer_hit = Cursor.Cursor(os.path.join("data", "hammer_hit.png"))
menuCursor = Cursor.Cursor(os.path.join("data", "cursor.png"))
cursors.add(hammer,hammer_hit,menuCursor)
startButton = Button.Button(os.path.join("data","start.png"))
quitButton = Button.Button(os.path.join("data","quit.png"))
highscoresButton = Button.Button(os.path.join("data","highscores_box.png"))
livesButton = Button.Button(os.path.join("data","lives_box.png"))
ScoreBoxButton = Button.Button(os.path.join("data","your_score_box.png"))
#Background
gameDisplay = pygame.display.set_mode((800,600))
gameDisplay.blit(background,(0,0))
#Booleans
moleDrawn = False
isGame = True
isStart = False
Ejemplo n.º 27
0
class Client(object):
    def __init__(self):
        self.music = base.loader.loadSfx(GAME + '/music/24.ogg')
        self.music.setLoop(True)
        self.music.play()
        self.background = GUI.Background(self.loginScreen)

    # Display the login window
    def loginScreen(self):
        self.loginwindow = GUI.LoginWindow(self.authenticate)

    def processData(self, datagram):
        iterator = PyDatagramIterator(datagram)
        source = datagram.getConnection()
        callback = iterator.getString()
        getattr(globals()[callback], 'execute')(self, iterator)

    # This task process data sent by the server, if any
    def tskReaderPolling(self, taskdata):
        if self.cReader.dataAvailable():
            datagram = NetDatagram()
            if self.cReader.getData(datagram):
                self.processData(datagram)
        return Task.cont

    # Setup connection and send the LOGIN datagram with credentials
    def authenticate(self):
        login = self.loginwindow.loginEntry.get()
        password = self.loginwindow.passwordEntry.get()

        self.cManager = QueuedConnectionManager()
        self.cListener = QueuedConnectionListener(self.cManager, 0)
        self.cReader = QueuedConnectionReader(self.cManager, 0)
        self.cReader.setTcpHeaderSize(4)

        self.myConnection = self.cManager.openTCPClientConnection(
            IP, PORT, 5000)
        if self.myConnection:
            self.cReader.addConnection(self.myConnection)
            self.send = Send(self.cManager, self.myConnection)
            print 'Client listening on', IP, ':', PORT
            taskMgr.add(self.tskReaderPolling, "Poll the connection reader")

            self.send.LOGIN_MESSAGE(login, password)

        else:
            print 'Can\'t connect to server on', IP, ':', PORT

    # The battle begins
    def battle_init(self):
        self.subphase = None

        # Instanciate the camera handler
        self.camhandler = CameraHandler()

        # Instanciate the keyboard tile traverser
        self.inputs = KeyboardTileTraverser(self)

        # Instanciate the battle graphics
        self.battleGraphics = BattleGraphics(self.party['map'])

        # Light the scene
        self.battleGraphics.lightScene()

        # Display the terrain
        self.battleGraphics.displayTerrain()

        # Play the background music
        self.music = base.loader.loadSfx(GAME + '/music/' +
                                         self.party['map']['music'] + '.ogg')
        self.music.setLoop(True)
        self.music.play()

        # Load sounds
        self.hover_snd = base.loader.loadSfx(GAME + "/sounds/hover.ogg")
        self.clicked_snd = base.loader.loadSfx(GAME + "/sounds/clicked.ogg")
        self.cancel_snd = base.loader.loadSfx(GAME + "/sounds/cancel.ogg")
        self.attack_snd = base.loader.loadSfx(GAME + "/sounds/attack.ogg")
        self.die_snd = base.loader.loadSfx(GAME + "/sounds/die.ogg")

        # Place highlightable tiles on the map
        self.matrix = Matrix(self.battleGraphics, self.party['map'])
        self.matrix.placeChars(self.party['chars'])

        # Instanciate and hide the AT flag
        self.at = AT()
        self.at.hide()

        self.charbars = None
        self.charcard = None
        self.actionpreview = None

        # Generate the sky and attach it to the camera
        self.sky = Sky(self.party['map'])

        # Tasks
        taskMgr.add(self.characterDirectionTask, 'characterDirectionTask')

        # Cursor stuff
        self.cursor = Cursor(self.battleGraphics, self.matrix.container)

        # Add the special effects
        self.battleGraphics.addEffects()

        # Battle intro animation
        SequenceBuilder.battleIntroduction(self).start()

    def updateAllSpritesAnimations(self, animation):
        for i, charid in enumerate(self.matrix.sprites):
            Sequence(
                Wait(float(i) / 6.0),
                Func(self.updateSpriteAnimation, charid, animation),
            ).start()

    def end(self):
        taskMgr.remove('characterDirectionTask')
        for child in render.getChildren():
            child.removeNode()
        self.camhandler.destroy()
        self.coords.destroy()
        self.sky.remove()
        self.background = GUI.Background(self.send.GET_PARTIES)

    def showMenu(self, charid):
        self.inputs.ignoreAll()
        self.camhandler.ignoreAll()

        canmove = self.party['chars'][charid]['canmove']
        canact = self.party['chars'][charid]['canact']

        columns = [
            {
                'x': -25,
                'font': GUI.regularfont,
                'align': TextNode.ALeft
            },
        ]

        rows = [
            {
                'cells': ['Move'],
                'enabled': canmove,
                'callback': lambda: self.send.GET_WALKABLES(charid)
            },
            {
                'cells': ['Act'],
                'enabled': canact,
                'callback': lambda: self.onAttackClicked(charid)
            },
            {
                'cells': ['Wait'],
                'enabled': True,
                'callback': lambda: self.onWaitClicked(charid)
            },
            {
                'cells': ['Status'],
                'enabled': False,
                'callback': lambda: self.onWaitClicked(charid)
            },
            {
                'cells': ['Auto-Battle'],
                'enabled': False,
                'callback': lambda: self.onWaitClicked(charid)
            },
        ]

        GUI.ScrollableList('shadowed', 73, -8, 62.0, 91.0, 16, columns, rows,
                           5, lambda: self.onCancelClicked(charid), 'Menu')

    def moveCheck(self, charid, orig, origdir, dest):
        self.inputs.ignoreAll()
        self.camhandler.ignoreAll()
        GUI.MoveCheck(lambda: self.send.MOVE_TO(charid, dest),
                      lambda: self.cancelMove(charid, orig, origdir))

    def cancelMove(self, charid, orig, origdir):
        self.matrix.sprites[charid].node.setPos(
            self.battleGraphics.logic2terrain(orig))
        self.matrix.sprites[charid].setRealDir(origdir)
        self.send.UPDATE_PARTY()

    # Makes a character look at another one
    def characterLookAt(self, charid, targetid):
        (x1, y1, z1) = self.matrix.getCharacterCoords(charid)
        (x2, y2, z2) = self.matrix.getCharacterCoords(targetid)
        if x1 > x2:
            self.matrix.sprites[charid].setRealDir(3)
        if x1 < x2:
            self.matrix.sprites[charid].setRealDir(1)
        if y1 > y2:
            self.matrix.sprites[charid].setRealDir(4)
        if y1 < y2:
            self.matrix.sprites[charid].setRealDir(2)

    # Update the status (animation) of a sprite after something happened
    def updateSpriteAnimation(self, charid, animation=False):
        if animation:
            self.matrix.sprites[charid].animation = animation
        else:
            stats = self.party['chars'][charid]
            if stats['hp'] >= (stats['hpmax'] / 2):
                self.matrix.sprites[charid].animation = 'walk'
            if stats['hp'] < (stats['hpmax'] / 2):
                self.matrix.sprites[charid].animation = 'weak'
            if stats['hp'] <= 0:
                self.matrix.sprites[charid].animation = 'dead'
                self.die_snd.play()
        h = self.camhandler.container.getH()
        self.matrix.sprites[charid].updateDisplayDir(h, True)

    def updateCursorPos(self, pos):

        self.camhandler.move(self.battleGraphics.logic2terrain(pos))

        (x, y, z) = pos
        tile = self.party['map']['tiles'][x][y][z]

        self.cursor.move(x, y, z, tile)

        if self.charbars:
            self.charbars.hide()

        if self.party['map']['tiles'][x][y][z].has_key('char'):
            charid = self.party['map']['tiles'][x][y][z]['char']
            char = self.party['chars'][charid]
            if self.subphase == 'attack':
                self.charbars = GUI.CharBarsRight(char)
            else:
                self.charbars = GUI.CharBarsLeft(char)

        try:
            self.coords.update(tile)
        except:
            self.coords = GUI.Coords(tile)

### Events

# Battle func

    def setupWalkableTileChooser(self, charid, walkables):
        self.inputs.acceptAll()
        self.camhandler.acceptAll()
        self.subphase = 'move'
        self.matrix.setupWalkableZone(charid, walkables)
        if self.charcard:
            self.charcard.hide()

    # Battle func
    def setupAttackableTileChooser(self, charid, attackables):
        self.inputs.acceptAll()
        self.camhandler.acceptAll()
        self.subphase = 'attack'
        self.matrix.setupAttackableZone(charid, attackables)
        if self.charcard:
            self.charcard.hide()

    # Battle func
    def setupDirectionChooser(self, charid):
        self.inputs.ignoreAll()
        self.camhandler.acceptAll()
        self.at.hide()
        DirectionChooser(charid, self.matrix.sprites[charid], self.camhandler,
                         self.send.WAIT, self.send.UPDATE_PARTY)

    # Attack button clicked
    def onAttackClicked(self, charid):
        self.inputs.ignoreAll()
        self.camhandler.ignoreAll()
        GUI.Help(
            0,
            25,
            155,
            44,
            'shadowed',
            'Check',
            'Specify the target with the cursor.\nPress the %c button to select.'
            % CIRCLE_BTN.upper(),
            lambda: self.send.GET_ATTACKABLES(charid),
            self.send.UPDATE_PARTY,
        )

    # Wait menu item chosen
    def onWaitClicked(self, charid):
        self.inputs.ignoreAll()
        self.camhandler.ignoreAll()
        GUI.Help(
            0,
            25,
            135,
            60,
            'shadowed',
            'Check',
            'Specify the direction with\nthe Directional buttons.\nPress the %c button to select.'
            % CIRCLE_BTN.upper(),
            lambda: self.setupDirectionChooser(charid),
            self.send.UPDATE_PARTY,
        )

    # Cancel menu item chosen
    def onCancelClicked(self, charid):
        self.inputs.acceptAll()
        self.camhandler.acceptAll()
        if self.charcard:
            self.charcard.hide()


### Tasks

# Updates the displayed direction of a character according to the camera angle

    def characterDirectionTask(self, task):
        h = self.camhandler.container.getH()
        for charid in self.matrix.sprites:
            self.matrix.sprites[charid].updateDisplayDir(h)
        return Task.cont
Ejemplo n.º 28
0
pic = imageio.imread(directory)
pic2 = imageio.imread(directory2)

height = pic.shape[0]
width = pic.shape[1]

x = np.arange(0,width)

if mode == 1:

    fig = plt.figure()
    line_row = pic[row,:,0] + pic[row,:,1] + pic[row,:,2]
    line_row = line_row / np.max(line_row)
    ax = fig.add_subplot(111)
    ax.plot(x, line_row)
    C.FollowDotCursor(ax, x, line_row)
    ax.set_xlabel('Kép szélesség [pixel]')
    ax.set_ylabel('Színerősségátlag [relatív egység]')
    ax.grid()
    fig.show()
    
elif mode == 2:

    fig = plt.figure()
    line_row = pic[row,:,0] + pic[row,:,1] + pic[row,:,2]
    line_row2 = pic2[row,:,0] + pic2[row,:,1] + pic2[row,:,2]
    line_row2 = line_row2 / np.max(line_row)
    line_row = line_row / np.max(line_row)
    ax = fig.add_subplot(111)
    ax.plot(x, line_row, label = 'HgCd')
    ax.plot(x, line_row2, label = 'Na')
Ejemplo n.º 29
0
def main():
    pygame.init()
    pygame.mixer.init()
    sonido_01 = PlayAudio("fondo.wav")    
    pantalla = pygame.display.set_mode([900,600])
    logo = pygame.image.load("./images/logo.png")
    pygame.display.set_icon(logo)
    pygame.display.set_caption("Mas Alla Del Espacio")    
    reloj1 = pygame.time.Clock()
    fuente1 = pygame.font.SysFont("BadaBoom BB",42,False,False)
    fuente2 = pygame.font.SysFont("BadaBoom BB",300,False,False)    
    
    active_on = pygame.image.load("./images/sound_on_active.png")
    passive_on = pygame.image.load("./images/sound_on_passive.png")
    active_off = pygame.image.load("./images/sound_off_active.png")    
    passive_off = pygame.image.load("./images/sound_off_passive.png")
    help_on = pygame.image.load("./images/help_active.png")
    help_off = pygame.image.load("./images/help_passive.png")
    back_on = pygame.image.load("./images/back_active.png")
    back_off = pygame.image.load("./images/back.png")
    sound_button = Boton(passive_on,active_on,820,30)
    help = Boton(help_off,help_on,760,30)
    back = Boton(back_off,back_on,50,520)
    cursor = Cursor()    
    
    contador = 0    

    salir = False
    iniciar = True
    advertencia = False
    primeraVez = True
    bloqueo_tecla_space = False
    una_opcion = False
    audio = None
    sonido_fondo = True
    activar_ayuda = False
    tmp = None
    global sonido_03
    global instruccion
    global instruccion_sonando
    
    fondo = Fondo(1)      
    
    while salir != True:        
        for event in pygame.event.get():
            #Cerrar ventana
            if event.type == pygame.QUIT:
                salir = True                    
            
            #Presionar un boton 
            if event.type == pygame.MOUSEBUTTONDOWN:
                if cursor.colliderect(help.rect):                    
                    tmp = fondo
                    fondo = Fondo(6)                    
                    activar_ayuda = True
                if cursor.colliderect(back.rect):
                    back = Boton(back_off,back_on,50,520)
                    activar_ayuda = False
                    fondo = tmp                
                if cursor.colliderect(sound_button.rect):
                    if sonido_fondo:
                        sound_button = Boton(passive_off,active_off,820,30)
                        sonido_fondo = False
                        sonido_01.stop()
                    else:
                        sound_button = Boton(passive_on,active_on,820,30)
                        sonido_fondo = True                        
                        sonido_01 = pygame.mixer.Sound("./sounds/fondo.wav")
                        sonido_01.play(-1)                                
            #Presionar cualquier tecla
            if event.type == pygame.KEYDOWN:
                #Presionar la tecla espacio
                if event.key == pygame.K_SPACE:
                    back = Boton(back_off,back_on,50,520)
                    activar_ayuda = False                    
                    if not bloqueo_tecla_space:
                        if not primeraVez:
                            advertencia = True                                        
                        if iniciar:                            
                            fondo = Fondo(2)
                            pantalla.blit(fondo,(0,0))
                            pygame.display.update()                            
                            iniciar = False                        
                            fondo = Fondo(3) 
                            time.sleep(3)
                            sonido_02 = PlayAudio("advertencia.wav")
                            if primeraVez:
                                primeraVez = False
                        if advertencia:
                            sonido_02.stop()
                            fondo = Fondo(4)
                            pantalla.blit(fondo,(0,0))
                            pygame.display.update()
                            bloqueo_tecla_space = True                            
                            audio = 1
                            PlayAudio("pagina01.wav")
                            global audio_disponible
                            audio_disponible = True
                            global instruccion_disponible
                            instruccion_disponible = True
                            global instruccion
                            instruccion = "esfera_01.wav"
                            global instruccion_sonando
                            instruccion_sonando = False                            
                
                #Presionar la tecla 'Up'                
                if event.key == pygame.K_UP:
                    if audio_disponible:                        
                        RepeatAudio()                        
                
                #Presionar la tecla 'O'                
                if event.key == pygame.K_o:
                    if instruccion_disponible:                        
                        PlayInstruction(instruccion)
                        instruccion_sonando = True                             
                            
                #Presionar la tecla 'Down'                
                if event.key == pygame.K_DOWN:
                    if una_opcion:
                        if audio is not "fin":
                            contador = contador + 1
                            StopAudios()
                        if audio == 99:
                            una_opcion = False                                            
                            fondo = Fondo(4)
                            PlayAudio("pagina01.wav")
                            instruccion = "esfera_01.wav"                     
                            audio = 1
                        if audio == 59:
                            una_opcion = False                            
                            fondo = Fondo(4)
                            PlayAudio("pagina60.wav")
                            instruccion = "esfera_60.wav"
                            audio = 60
                        if audio == 67:
                            una_opcion = False                      
                            fondo = Fondo(4)
                            PlayAudio("pagina02.wav")
                            instruccion = "esfera_02.wav"                    
                            audio = 2                        
                        if audio == 48:
                            una_opcion = False                      
                            PlayAudio("pagina02.wav")
                            instruccion = "esfera_02.wav"
                            fondo = Fondo(4)                            
                            audio = 2
                        if audio == 45:
                            una_opcion = False                      
                            PlayAudio("pagina62.wav")
                            instruccion = "esfera_62.wav"
                            fondo = Fondo(4)                            
                            audio = 62
                        if audio == 43:
                            una_opcion = False                      
                            PlayAudio("pagina03.wav")
                            instruccion = "esfera_03.wav"
                            fondo = Fondo(4)                            
                            audio = 3
                        if audio == 39:
                            una_opcion = False                      
                            fondo = Fondo(4)        
                            PlayAudio("pagina40.wav")
                            instruccion = "esfera_40.wav"                    
                            audio = 40
                        if audio == 22:
                            una_opcion = False                                                
                            PlayAudio("pagina03.wav")
                            instruccion = "esfera_03.wav"
                            fondo = Fondo(4)                            
                            audio = 3
                        if audio == 16:
                            una_opcion = False                            
                            fondo = Fondo(4)
                            PlayAudio("pagina17.wav")
                            instruccion = "esfera_17.wav"
                            audio = 17
                        if audio == 33:
                            una_opcion = False                            
                            fondo = Fondo(4)
                            PlayAudio("pagina34.wav")
                            instruccion = "esfera_34.wav"
                            audio = 34
                            
                #Presionar la tecla 'Left'
                if event.key == pygame.K_LEFT:                       
                    if bloqueo_tecla_space:
                        if audio is not "fin":
                            contador = contador + 1
                            StopAudios()
                        if audio == 82:                                            
                            fondo = Fondo('n')
                            PlayAudio("pagina113.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 80:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina111.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 79:                            
                            fondo = Fondo('n')                                                        
                            PlayAudio("pagina109.wav")
                            instruccion = "fin.wav"
                            audio = "fin"
                        if audio == 91:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina102.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 90:                      
                            fondo = Fondo('n')
                            PlayAudio("pagina101.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 84:                            
                            fondo = Fondo('n')      
                            PlayAudio("pagina115.wav")
                            instruccion = "fin.wav"                      
                            audio = "fin"
                        if audio == 60:                            
                            PlayAudio("pagina80.wav")
                            instruccion = "esfera_80.wav"                                                        
                            audio = 80
                        if audio == 93:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina107.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 56:                      
                            fondo = Fondo('n')
                            PlayAudio("pagina78.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 55:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina76.wav")
                            instruccion = "fin.wav"
                            audio = "fin"
                        if audio == 70:                            
                            fondo = Fondo(5)
                            una_opcion = True
                            PlayAudio("pagina99.wav")
                            instruccion = "abajo.wav"
                            audio = 99
                        if audio == 69:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina97.wav")
                            instruccion = "fin.wav"
                            audio = "fin"
                        if audio == 74:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina92.wav")
                            instruccion = "fin.wav"
                            audio = "fin"
                        if audio == 72:                            
                            PlayAudio("pagina90.wav")
                            instruccion = "esfera_90.wav"                                                        
                            audio = 90
                        if audio == 64:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina86.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 61:                                                
                            fondo = Fondo('n')
                            PlayAudio("pagina83.wav")
                            instruccion = "fin.wav"
                            audio = "fin"
                        if audio == 40:                            
                            PlayAudio("pagina55.wav")
                            instruccion = "esfera_55.wav"                                                        
                            audio = 55
                        if audio == 52:                            
                            PlayAudio("pagina69.wav")
                            instruccion = "esfera_69.wav"                                                        
                            audio = 69
                        if audio == 51:                            
                            fondo = Fondo(5)
                            una_opcion = True       
                            PlayAudio("pagina67.wav")
                            instruccion = "esfera_67.wav"                                                 
                            audio = 67
                        if audio == 54:                      
                            PlayAudio("pagina74.wav")
                            instruccion = "esfera_74.wav"                                                        
                            audio = 74
                        if audio == 53:                            
                            PlayAudio("pagina72.wav")
                            instruccion = "esfera_72.wav"                                                        
                            audio = 72
                        if audio == 62:                            
                            fondo = Fondo('n')
                            PlayAudio("fin.wav")
                            instruccion = "fin.wav"
                            audio = "fin"
                        if audio == 44:                            
                            una_opcion = True
                            fondo = Fondo(5)
                            PlayAudio("pagina59.wav")
                            instruccion = "abajo.wav"
                            audio = 59
                        if audio == 28:                                                    
                            PlayAudio("pagina44.wav")
                            instruccion = "esfera_44.wav"                                                        
                            audio = 44
                        if audio == 42:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina57.wav")
                            instruccion = "fin.wav"
                            audio = "fin"
                        if audio == 38:                            
                            PlayAudio("pagina51.wav")
                            instruccion = "esfera_51.wav"                                                        
                            audio = 51
                        if audio == 36:                            
                            PlayAudio("pagina53.wav")
                            instruccion = "esfera_53.wav"                                                        
                            audio = 53
                        if audio == 27:                      
                            PlayAudio("pagina42.wav")
                            instruccion = "esfera_42.wav"                                                        
                            audio = 42
                        if audio == 23:                            
                            una_opcion = True
                            fondo = Fondo(5)
                            PlayAudio("pagina39.wav")
                            instruccion = "abajo.wav"
                            audio = 39
                        if audio == 20:                            
                            PlayAudio("pagina36.wav")
                            instruccion = "esfera_36.wav"                                                        
                            audio = 36
                        if audio == 14:                            
                            PlayAudio("pagina28.wav")
                            instruccion = "esfera_28.wav"                                                        
                            audio = 28
                        if audio == 12:                                                
                            fondo = Fondo('n')
                            PlayAudio("pagina24.wav")
                            instruccion = "fin.wav"
                            audio = "fin"
                        if audio == 11:                            
                            PlayAudio("pagina23.wav")
                            instruccion = "esfera_23.wav"                                                        
                            audio = 23
                        if audio == 10:                            
                            PlayAudio("pagina20.wav")
                            instruccion = "esfera_20.wav"                                                        
                            audio = 20
                        if audio == 6:                            
                            PlayAudio("pagina12.wav")
                            instruccion = "esfera_12.wav"
                            audio = 12
                        if audio == 4:                      
                            PlayAudio("pagina10.wav")
                            instruccion = "esfera_10.wav"                                                        
                            audio = 10
                        if audio == 2:                            
                            PlayAudio("pagina04.wav")
                            instruccion = "esfera_04.wav"                                                        
                            audio = 4
                        if audio == 88:
                            fondo = Fondo('n')      
                            PlayAudio("pagina94.wav")
                            instruccion = "fin.wav"                      
                            audio = "fin"                         
                        if audio == 65:                            
                            PlayAudio("pagina88.wav")
                            instruccion = "esfera_88.wav"                            
                            audio = 88
                        if audio == 46:                      
                            PlayAudio("pagina65.wav")
                            instruccion = "esfera_65.wav"                            
                            audio = 65
                        if audio == 32:
                            PlayAudio("pagina46.wav")
                            instruccion = "esfera_46.wav"                            
                            audio = 46
                        if audio == 34:                                             
                            fondo = Fondo(5)
                            una_opcion = True   
                            PlayAudio("pagina48.wav")
                            instruccion = "abajo.wav"                         
                            audio = 48
                        if audio == 17:                                                  
                            fondo = Fondo(5)
                            una_opcion = True 
                            PlayAudio("pagina33.wav")
                            instruccion = "abajo.wav"                           
                            audio = 33
                        if audio == 15:                                                        
                            fondo = Fondo('n')      
                            PlayAudio("pagina30.wav")
                            instruccion = "fin.wav"                      
                            audio = "fin"                         
                        if audio == 7:                            
                            PlayAudio("pagina15.wav")
                            instruccion = "esfera_15.wav"                            
                            audio = 15
                        if audio == 8:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina18.wav")
                            instruccion = "fin.wav"                            
                            audio = "fin"
                        if audio == 3:                            
                            PlayAudio("pagina07.wav")
                            instruccion = "esfera_07.wav"                            
                            audio = 7                            
                        if audio == 1:                                                    
                            PlayAudio("pagina02.wav")
                            instruccion = "esfera_02.wav"                            
                            audio = 2
                
                #Presionar la tecla 'Right'                            
                if event.key == pygame.K_RIGHT:
                    if bloqueo_tecla_space:
                        if audio is not "fin":
                            contador = contador + 1
                            StopAudios()
                        if audio == 90:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina106.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 91:                                                        
                            fondo = Fondo('n')
                            PlayAudio("pagina105.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 79:                                                    
                            fondo = Fondo('n')
                            PlayAudio("pagina110.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 80:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina112.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 82:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina114.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 84:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina116.wav")
                            instruccion = "fin.wav"                                                  
                            audio = "fin"
                        if audio == 60:                            
                            PlayAudio("pagina82.wav")
                            instruccion = "esfera_82.wav"                                                        
                            audio = 82
                        if audio == 56:                            
                            PlayAudio("pagina79.wav")
                            instruccion = "esfera_79.wav"                                                        
                            audio = 79
                        if audio == 55:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina77.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 70:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina100.wav")
                            instruccion = "fin.wav"                            
                            audio = "fin"
                        if audio == 69:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina98.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 93:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina108.wav")
                            instruccion = "fin.wav"
                            audio = "fin"
                        if audio == 74:                                                                                
                            audio = 93
                            PlayAudio("pagina93.wav")
                            instruccion = "esfera_93.wav"
                        if audio == 72:                            
                            PlayAudio("pagina91.wav")
                            instruccion = "esfera_91.wav"                                                        
                            audio = 91
                        if audio == 64:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina87.wav")
                            instruccion = "esfera_87.wav"                                                  
                            audio = "fin"
                        if audio == 61:                            
                            PlayAudio("pagina84.wav")
                            instruccion = "esfera_84.wav"                                                        
                            audio = 84
                        if audio == 40:                            
                            PlayAudio("pagina56.wav")
                            instruccion = "esfera_56.wav"                                                        
                            audio = 56
                        if audio == 52:                            
                            PlayAudio("pagina70.wav")
                            instruccion = "esfera_70.wav"                                                        
                            audio = 70
                        if audio == 51:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina68.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 54:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina75.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"                     
                        if audio == 53:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina73.wav")
                            instruccion = "fin.wav"
                            audio = "fin"
                        if audio == 62:                            
                            PlayAudio("pagina64.wav")
                            instruccion = "esfera_64.wav"                                                        
                            audio = 64
                        if audio == 44:                            
                            PlayAudio("pagina61.wav")
                            instruccion = "esfera_61.wav"                                                        
                            audio = 61
                        if audio == 28:                            
                            fondo = Fondo(5)
                            una_opcion = True 
                            PlayAudio("pagina45.wav")
                            instruccion = "abajo.wav"                                                       
                            audio = 45
                        if audio == 42:                            
                            fondo = Fondo('n')      
                            PlayAudio("pagina58.wav")
                            instruccion = "fin.wav"                                                  
                            audio = "fin"
                        if audio == 38:                            
                            PlayAudio("pagina52.wav")
                            instruccion = "esfera_52.wav"                                                        
                            audio = 52
                        if audio == 36:                            
                            PlayAudio("pagina54.wav")
                            instruccion = "esfera_54.wav"                                                        
                            audio = 54
                        if audio == 27:                            
                            fondo = Fondo(5)
                            una_opcion = True       
                            PlayAudio("pagina43.wav")
                            instruccion = "abajo.wav"                                                 
                            audio = 43
                        if audio == 23:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina41.wav")
                            instruccion = "esfera_41.wav"
                            audio = 41
                        if audio == 20:                            
                            PlayAudio("pagina38.wav")
                            instruccion = "esfera_38.wav"                                                        
                            audio = 38
                        if audio == 14:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina29.wav")
                            instruccion = "fin.wav"
                            audio = "fin"
                        if audio == 12:                            
                            PlayAudio("pagina27.wav")
                            instruccion = "esfera_27.wav"                                                        
                            audio = 27
                        if audio == 11:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina26.wav")
                            instruccion = "fin.wav"                                                        
                            audio = "fin"
                        if audio == 10:                            
                            fondo = Fondo(5)
                            una_opcion = True
                            PlayAudio("pagina22.wav")
                            instruccion = "abajo.wav"
                            audio = 22
                        if audio == 6:                            
                            PlayAudio("pagina14.wav")
                            instruccion = "esfera_14.wav"                                                        
                            audio = 14
                        if audio == 4:                            
                            PlayAudio("pagina11.wav")
                            instruccion = "esfera_11.wav"                                                        
                            audio = 11
                        if audio == 2:                            
                            PlayAudio("pagina06.wav")
                            instruccion = "esfera_06.wav"                                                        
                            audio = 6
                        if audio == 88:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina96.wav")
                            instruccion = "fin.wav"                            
                            audio = "fin"                         
                        if audio == 65:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina89.wav")
                            instruccion = "fin.wav"                            
                            audio = "fin"                         
                        if audio == 46:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina66.wav")
                            instruccion = "fin.wav"                        
                            audio = "fin"                         
                        if audio == 32:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina49.wav")
                            instruccion = "fin.wav"                            
                            audio = "fin"                         
                        if audio == 34:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina50.wav")
                            instruccion = "fin.wav"                            
                            audio = "fin"
                        if audio == 17:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina35.wav")
                            instruccion = "fin.wav"
                            audio = "fin"                         
                        if audio == 15:                            
                            PlayAudio("pagina32.wav")
                            instruccion = "esfera_32.wav"
                            audio = 32                        
                        if audio == 7:                            
                            fondo = Fondo(5)                            
                            una_opcion = True                                                        
                            PlayAudio("pagina16.wav")
                            instruccion = "abajo.wav"
                            audio = 16
                        if audio == 8:                            
                            fondo = Fondo('n')
                            PlayAudio("pagina19.wav")
                            instruccion = "fin.wav"
                            audio = "fin"                         
                        if audio == 3:  
                            PlayAudio("pagina08.wav")
                            instruccion = "esfera_08.wav"
                            audio = 8
                        if audio == 1:                                                                        
                            PlayAudio("pagina03.wav")
                            instruccion = "esfera_03.wav"
                            audio = 3                        
        reloj1.tick(20)
        pantalla.blit(fondo,(0,0))
        if advertencia and audio is not "fin":
            texto1 = fuente1.render("Pasos dados:",0,(255,255,255))
            texto2 = fuente2.render(str(contador),0,(255,255,255)) 
            if not activar_ayuda:            
                pantalla.blit(texto1,(100,80))                    
                pantalla.blit(texto2,(370,165))
        if audio is "fin":
            texto1 = fuente1.render("Score: " + str(contador) + " pasos dados!",0,(255,255,255))
            if not activar_ayuda:
                pantalla.blit(texto1,(80,530))
        cursor.update()
        sound_button.update(pantalla,cursor)
        help.update(pantalla,cursor)
        if activar_ayuda:
            back.update(pantalla,cursor)
        pygame.display.update()
    pygame.quit()