示例#1
0
文件: main.py 项目: CogWorks/pySnake
 def __init__(self, client, actr):
     self.screen = director.get_window_size()
     self.ncells = int(director.settings['board_size'])
     self.scorepad = int(self.screen[1] * .025)
     self.cell = int((self.screen[1]-self.scorepad) / self.ncells * .1) * 10
     print self.cell
     width = self.ncells * self.cell + self.ncells + 1
     
     super(Task, self).__init__(0, 0, 0, 255, width, width)
     self.position = ((self.screen[0]-width)/2, (self.screen[1]-width)/2-self.scorepad)
     
     self.score_layer = Score(width, 2*self.scorepad, self.position[0], self.position[1]+width+self.scorepad/2)
     self.score = 0
     self.food_eaten = 0
     
     self.speed_factor = float(director.settings['speed_factor'])
     
     self.state = self.STATE_INIT
     
     self.snake = None
     self.food = None
     self.ready = False
     
     self.blop = StaticSource(pyglet.resource.media('blop.mp3'))
     self.laugh = StaticSource(pyglet.resource.media('laugh.mp3'))
     
     self.text_batch = BatchNode()
     self.game_over_label = text.Label("GAME OVER", font_size=int(self.cell*3),
                                       x= width / 2, y= width / 2, font_name="Pipe Dream",
                                       color=(255,255,255,255), anchor_x='center', anchor_y='bottom',
                                       batch=self.text_batch.batch)
     self.game_over_label = text.Label("Press Spacebar For New Game", font_size=int(self.cell*1.5),
                                       x= width / 2, y= width / 2, font_name="Pipe Dream",
                                       color=(255,255,255,255), anchor_x='center', anchor_y='top',
                                       batch=self.text_batch.batch)
示例#2
0
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.wnd.mouse_exclusivity = False
        self.bpm = 242  # Hardcode bpm from info.dat
        self.camera = KeyboardCamera(self.wnd.keys,
                                     fov=60,
                                     near=1.0,
                                     far=1000.0)
        self.camera.velocity = 50
        self.camera_enabled = False

        meta = self.load_json('megalovania_remix/info.dat')
        self.map = BSScene(
            self.load_scene('bs_map3.glb'),
            self.camera,
            BSTrack('megalovania_remix/Expert.dat', meta['_beatsPerMinute']),
        )

        self.quad_fs = geometry.quad_fs()

        # Postprocess programs
        self.copy_prog = self.load_program('programs/copy.glsl')
        self.copy_greyscale_prog = self.load_program(
            'programs/copy_greyscale.glsl')
        self.blur_h_prog = self.load_program('programs/blur_h.glsl')
        self.blur_v_prog = self.load_program('programs/blur_v.glsl')
        self.combine = self.load_program('programs/combine.glsl')
        self.combine['texture1'] = 1

        # blur stuff
        self.offscreen_texture = self.ctx.texture(
            (self.wnd.buffer_width, self.wnd.buffer_height), 4)
        self.offscreen_depth = self.ctx.depth_texture(
            (self.wnd.buffer_width, self.wnd.buffer_height))
        self.offscreen = self.ctx.framebuffer(
            color_attachments=[self.offscreen_texture],
            depth_attachment=self.offscreen_depth,
        )
        bd = 1
        self.blur_h_texture = self.ctx.texture(
            (self.wnd.buffer_width // bd, self.wnd.buffer_height // bd), 4)
        self.blur_h_texture.repeat_x = False
        self.blur_h_texture.repeat_y = False
        self.blur_h = self.ctx.framebuffer(
            color_attachments=[self.blur_h_texture])
        self.blur_v_texture = self.ctx.texture(
            (self.wnd.buffer_width // bd, self.wnd.buffer_height // bd), 4)
        self.blur_v_texture.repeat_x = False
        self.blur_v_texture.repeat_y = False
        self.blur_v = self.ctx.framebuffer(
            color_attachments=[self.blur_v_texture])

        self.music_player = Player()
        self.music_source = StaticSource(
            load(RESOURCE_DIR / 'megalovania_remix/song.wav'))
        self.music_player.queue(self.music_source)
        self.music_player.play()
        # self.music_player.seek(60.0 * 4 + 50)
        self.music_player.volume = 1.0
示例#3
0
 def __init__(self, images, x, y):
     self.images = images
     super(Mole, self).__init__(self.images[0], anchor=(0,0), position=(x,y))
     self.position_out = self.position
     self.position_in = (self.position[0],self.position[1]-130)
     self.position = self.position_in
     self.bottom = self.position_in[1] + 200
     self.cshape = self
     self.active = False
     
     self.player_thump = StaticSource(pyglet.resource.media('ow.mp3'))
     self.player_laugh = StaticSource(pyglet.resource.media('laugh.mp3'))
     
     self.STATE_IDLE = 0
     self.STATE_HIT = 1
     self.STATE_MISS = 2
     self.state = self.STATE_IDLE
示例#4
0
    def sound(self, source: StaticSource, loop: bool = False,
              interupt:  bool = True):
        """Play +source+.
        
        +loop+ Loop if true
        +interupt+ True to stop any current sound and play +source+. False to 
            not play +source+ if any other sound is already playing.
        """
        if not interupt:
            try:
                if self.sound_playing:
                    return
            except AttributeError:
                pass

        try:
            self._snd_player.pause()
        except AttributeError:
            pass
        
        self._snd_player = source.play()
        if loop:
            self._snd_player.loop = True
示例#5
0
class Mole(Sprite, AARectShape):
    
    def __init__(self, images, x, y):
        self.images = images
        super(Mole, self).__init__(self.images[0], anchor=(0,0), position=(x,y))
        self.position_out = self.position
        self.position_in = (self.position[0],self.position[1]-130)
        self.position = self.position_in
        self.bottom = self.position_in[1] + 200
        self.cshape = self
        self.active = False
        
        self.player_thump = StaticSource(pyglet.resource.media('ow.mp3'))
        self.player_laugh = StaticSource(pyglet.resource.media('laugh.mp3'))
        
        self.STATE_IDLE = 0
        self.STATE_HIT = 1
        self.STATE_MISS = 2
        self.state = self.STATE_IDLE
        
    def __getattribute__(self,name):
        if name=='center':
            return (self.position[0]+89, (self.position[1]+self.bottom+200)/2 - 20)
        elif name=='rx':
            return 89
        elif name=='ry':
            return (self.position[1]+200-self.bottom)/2 + 20
        else:
            return object.__getattribute__(self, name)
        
    def setImage(self, index):
        self.image = self.images[index]
        
    def setImageFunc(self, index):
        return CallFunc(self.setImage, index)
    
    def checkHitState(self):
        if self.state == self.STATE_IDLE:
            self.laugh()
            self.state = self.STATE_MISS
    
    def setActive(self, value):
        self.active = value
        
    def setState(self, value):
        self.state = value
    
    def waitDone(self):
        self.checkHitState()
        self.do(AccelDeccel(MoveTo(self.position_in, self.t)) + CallFunc(self.setActive, False) + CallFunc(self.setState, 0))
    
    def upDone(self):
        self.do(RandomDelay(.25,.5) + CallFunc(self.waitDone))
        
    def up(self):
        self.t = random.uniform(.25,1.0)
        self.setImage(0)
        self.position = self.position_in
        self.setActive(True)
        self.do(RandomDelay(0.0,0.2) + AccelDeccel(MoveTo(self.position_out, self.t)) + CallFunc(self.upDone))
        
    def laugh(self):
        self.player_laugh.play()
        self.do(self.setImageFunc(1)+Delay(.1)+
                self.setImageFunc(2)+Delay(.1)+
                self.setImageFunc(3)+Delay(.1)+
                self.setImageFunc(2)+Delay(.1)+
                self.setImageFunc(3)+Delay(.1)+
                self.setImageFunc(1)+Delay(.1))
        
    def down_fast(self):
        self.do(Accelerate(MoveTo(self.position_in, self.t/2)) + CallFunc(self.setActive, False) + CallFunc(self.setState, 0))
        
    def thump(self):
        self.player_thump.play()
        self.stop()
        self.down_fast()
        self.do(self.setImageFunc(4)+Delay(.1)+
                self.setImageFunc(5)+Delay(.1)+
                self.setImageFunc(6)+Delay(.1)+
                self.setImageFunc(4)+Delay(.1)+
                self.setImageFunc(5)+Delay(.1)+
                self.setImageFunc(6)+Delay(.1))
示例#6
0
    def __init__(self):
        self.map = None
        self.layout = None
        self.end_staircase = None
        self.stage = 1
        self.game_window = None
        self.pc = None
        self.next_stage = False
        self.move_timeout = True
        self.timeout_limit = 1  # sekundy
        self.enemies = set()
        self.consumables = set()
        self.equippables = set()
        self.sprites = Batch()
        self.items = Batch()
        self.stages = 5
        self.cell_size = 5
        self.width = 45  # w tile-ach, wielokrotność 3*sell_size
        self.height = 30  # wielokrotność cell_size
        self.status_bar = None
        self.difficulty = 0
        self.groups = [OrderedGroup(0), OrderedGroup(1)]

        self.tileset = TextureGrid(ImageGrid(load_image('img/tiles.png'), 5,
                                             5))

        self.tile_textures = {
            'floor': self.tileset.get(4, 0).get_image_data(),
            'wall': self.tileset.get(4, 1).get_image_data(),
            'bars': self.tileset.get(4, 2).get_image_data(),
            'rubble': self.tileset.get(4, 3).get_image_data(),
            'stairs': self.tileset.get(4, 4).get_image_data(),
        }

        self.sprite_textures = {
            'bandit_dig': self.tileset.get(0, 0),
            'bandit_disg': self.tileset.get(0, 1),
            'bandit_fierce': self.tileset.get(0, 2),
            'bandit_wander': self.tileset.get(0, 3),
            'bandit_wary': self.tileset.get(0, 4),
            'bandit_aggr': self.tileset.get(1, 2),
            'bandit_coward': self.tileset.get(1, 3),
            'bandit_def': self.tileset.get(1, 4),
            'guard_glass': self.tileset.get(1, 0),
            'guard_unlk': self.tileset.get(1, 1),
            'guard': self.tileset.get(2, 0),
            'guard_angry': self.tileset.get(2, 1),
            'guard_blnk': self.tileset.get(2, 2),
            'guard_chase': self.tileset.get(2, 3),
            'guard_def': self.tileset.get(2, 4),
            'player': self.tileset.get(3, 0),
            'player_h': self.tileset.get(3, 1),
            'player_d': self.tileset.get(3, 2),
            'player_dh': self.tileset.get(3, 3),
            'item': self.tileset.get(3, 4),
        }

        self.sounds = {
            'player_hit': StaticSource(load_media('sound/player_hit.wav')),
            'bandit_hit': StaticSource(load_media('sound/bandit_hit.wav')),
            'guard_hit': StaticSource(load_media('sound/guard_hit.wav')),
        }
示例#7
0
文件: main.py 项目: CogWorks/pySnake
class Task(ColorLayer, pyglet.event.EventDispatcher):
    
    d = Dispatcher()
    actr_d = JNI_Dispatcher()
    
    states = ["INIT", "WAIT_ACTR_CONNECTION", "WAIT_ACTR_MODEL", "CALIBRATE", 
              "IGNORE_INPUT", "PLAY", "GAME_OVER"]
    STATE_INIT = 0
    STATE_WAIT_ACTR_CONNECTION = 1
    STATE_WAIT_ACTR_MODEL = 2
    STATE_CALIBRATE = 3
    STATE_IGNORE_INPUT = 4
    STATE_PLAY = 5
    STATE_GAME_OVER = 6
    
    is_event_handler = True
    
    def __init__(self, client, actr):
        self.screen = director.get_window_size()
        self.ncells = int(director.settings['board_size'])
        self.scorepad = int(self.screen[1] * .025)
        self.cell = int((self.screen[1]-self.scorepad) / self.ncells * .1) * 10
        print self.cell
        width = self.ncells * self.cell + self.ncells + 1
        
        super(Task, self).__init__(0, 0, 0, 255, width, width)
        self.position = ((self.screen[0]-width)/2, (self.screen[1]-width)/2-self.scorepad)
        
        self.score_layer = Score(width, 2*self.scorepad, self.position[0], self.position[1]+width+self.scorepad/2)
        self.score = 0
        self.food_eaten = 0
        
        self.speed_factor = float(director.settings['speed_factor'])
        
        self.state = self.STATE_INIT
        
        self.snake = None
        self.food = None
        self.ready = False
        
        self.blop = StaticSource(pyglet.resource.media('blop.mp3'))
        self.laugh = StaticSource(pyglet.resource.media('laugh.mp3'))
        
        self.text_batch = BatchNode()
        self.game_over_label = text.Label("GAME OVER", font_size=int(self.cell*3),
                                          x= width / 2, y= width / 2, font_name="Pipe Dream",
                                          color=(255,255,255,255), anchor_x='center', anchor_y='bottom',
                                          batch=self.text_batch.batch)
        self.game_over_label = text.Label("Press Spacebar For New Game", font_size=int(self.cell*1.5),
                                          x= width / 2, y= width / 2, font_name="Pipe Dream",
                                          color=(255,255,255,255), anchor_x='center', anchor_y='top',
                                          batch=self.text_batch.batch)
        
    def get_move_by(self):
        if self.movement_direction == 1:
            return (0, 1)
        elif self.movement_direction == 2:
            return (1, 0)
        elif self.movement_direction == 3:
            return (0, -1)
        elif self.movement_direction == 4:
            return (-1, 0)
        
    def move_snake_body(self, dt):
        mod = self.get_move_by()
        c,r = self.snake[0].grid_loc
        nc = c + mod[0]
        nr = r + mod[1]
        
        # First check if new head location is out of bounds
        if nc < 1 or nc > self.ncells or nr < 1 or nr > self.ncells:
            self.game_over()
            return
        
        # Now check to see if next cell is food. If it is, make the food location
        # the new head of the snake.
        if (nc,nr) == self.food.grid_loc:
            self.food_eaten += 1
            self.score += int(math.ceil((self.food_eaten-1) * 1.5 + 10))
            self.score_layer.set_score(self.score)
            self.blop.play()
            self.food.color = (255,255,255)
            self.snake = [self.food] + self.snake
            self.spawn_food()
            self.speed = self.speed * self.speed_factor
            
        # Otherwise move snake
        else:
            # starting at the tail and moving towards the head, move each body
            # segment to the preceeding body segment location
            for i in range(1,len(self.snake))[::-1]:
                self.snake[i].set_grid_loc(self.snake[i-1].grid_loc)
            # finally move the snake head to the new location
            self.snake[0].set_grid_loc((nc,nr))
        
            # Now check to see if there is a body collision
            if duplicates([tuple(cell.grid_loc) for cell in self.snake]):
                self.game_over()
                return
        
        pyglet.clock.schedule_once(self.move_snake_body, self.speed)
        self.ready = True
        
    def game_over(self):
        self.laugh.play()
        self.state = self.STATE_GAME_OVER
        self.snake[0].stop()
        self.ready = False
        self.clear()
        self.add(self.text_batch, z=1)
        
    def spawn_food(self):
        cont = True
        while cont:
            cont = False
            c = (choice(range(0, self.ncells)) + 1)
            r = (choice(range(0, self.ncells)) + 1)
            for s in self.snake:
                if s.grid_loc == (c,r):
                    cont = True
                    break
            if not cont:
                self.food = GridSquare(c, r, self.cell, color=(255, 0, 0))
                self.add(self.food)
        
    def clear(self):
        if self.snake:
            map(self.remove, self.snake)
            self.snake = None
        if self.food:
            self.remove(self.food)
            self.food = None
        
    def reset(self):
        self.movement_direction = 1
        self.speed = .1
        
        self.score = 0
        self.score_layer.set_score(self.score)
        
        self.clear()
        
        center = int(self.ncells/2) + 1
        self.snake = [GridSquare(center, center, self.cell)]
        self.add(self.snake[0])
        
        for r in range(1, 3):
            self.snake.append(GridSquare(center, center-r, self.cell))
            self.add(self.snake[-1])
            
        self.spawn_food()
        
        self.state = self.STATE_PLAY
        pyglet.clock.schedule_once(self.move_snake_body, 2)
        
    def one_time(self):
        if director.settings['eyetracker'] and director.settings['fixation_overlay']:
            self.dispatch_event("show_fixation")
            
    def on_enter(self):
        if isinstance(director.scene, TransitionScene): return
        super(Task, self).on_enter()
        
        if director.settings['eyetracker']:
            self.state = self.STATE_CALIBRATE
            self.dispatch_event("start_calibration", self.calibration_ok, self.calibration_bad)
        else:
            self.reset()
            
    def calibration_ok(self):
        self.dispatch_event("stop_calibration")
        self.one_time()
        self.reset()
        
    def calibration_bad(self):
        self.dispatch_event("stop_calibration")
        director.scene.dispatch_event("show_intro_scene")
        
    def on_exit(self):
        if isinstance(director.scene, TransitionScene): return
        super(Task, self).on_exit()
        self.clear()
        if director.settings['eyetracker'] and director.settings['fixation_overlay']:
            self.dispatch_event("hide_fixation")
        
    if ACTR6:
        @actr_d.listen('connectionMade')
        def ACTR6_JNI_Event(self, model, params):
            pass
            
        @actr_d.listen('connectionLost')
        def ACTR6_JNI_Event(self, model, params):
            pass
            
        @actr_d.listen('reset')
        def ACTR6_JNI_Event(self, model, params):
            pass
            
        @actr_d.listen('model-run')
        def ACTR6_JNI_Event(self, model, params):
            pass
            
        @actr_d.listen('model-stop')
        def ACTR6_JNI_Event(self, model, params):
            pass

        @actr_d.listen('gaze-loc')
        def ACTR6_JNI_Event(self, model, params):
            pass
            
        @actr_d.listen('attention-loc')
        def ACTR6_JNI_Event(self, model, params):
            pass

        @actr_d.listen('keypress')
        def ACTR6_JNI_Event(self, model, params):
            pass

        @actr_d.listen('mousemotion')
        def ACTR6_JNI_Event(self, model, params):
            pass

        @actr_d.listen('mouseclick')
        def ACTR6_JNI_Event(self, model, params):
            pass
    
    if eyetracking:
        @d.listen('ET_FIX')
        def iViewXEvent(self, inResponse):
            pass
            
        @d.listen('ET_SPL')
        def iViewXEvent(self, inResponse):
            pass
        
    def on_mouse_press(self, x, y, buttons, modifiers):
        pass

    def on_mouse_motion(self, x, y, dx, dy):
        pass
        
    def on_key_press(self, symbol, modifiers):
        if self.state < self.STATE_IGNORE_INPUT: return
        if symbol == key.W and (modifiers & key.MOD_ACCEL):
            director.scene.dispatch_event("show_intro_scene")
            True
        if self.state == self.STATE_PLAY:
            if self.ready:
                self.ready = False
                if symbol == key.UP:
                    if self.movement_direction == 2 or self.movement_direction == 4:
                        self.movement_direction = 1
                elif symbol == key.DOWN:
                    if self.movement_direction == 2 or self.movement_direction == 4:
                        self.movement_direction = 3
                elif symbol == key.RIGHT:
                    if self.movement_direction == 1 or self.movement_direction == 3:
                        self.movement_direction = 2
                elif symbol == key.LEFT:
                    if self.movement_direction == 1 or self.movement_direction == 3:
                        self.movement_direction = 4
        elif self.state == self.STATE_GAME_OVER:
            if symbol == key.SPACE:
                self.remove(self.text_batch)
                self.reset()