Example #1
0
class MainWidget2(BaseWidget):
    def __init__(self):
        super(MainWidget2, self).__init__()

        # create a clock and a tempo map
        self.clock = Clock()
        self.tempo_map = SimpleTempoMap(120)

        # and text to display our status
        self.label = topleft_label()
        self.add_widget(self.label)

    def on_key_down(self, keycode, modifiers):
        if keycode[1] == 'c':
            self.clock.toggle()

    def on_update(self):

        time = self.clock.get_time()
        tick = self.tempo_map.time_to_tick(time)
        bpm = self.tempo_map.get_tempo()

        self.label.text = 'time:{:.2f}\n'.format(time)
        self.label.text += tick_str(tick) + '\n'
        self.label.text += 'bpm:{}\n'.format(bpm)
        self.label.text += 'c: toggle clock\n'
Example #2
0
class TempoCursorHandler(object):
    """
    Handles the TempoCursor GUI.
    Also stores and updates all currently active TempoCursors.
    """
    def __init__(self,
                 norm,
                 sandbox,
                 mixer,
                 client,
                 client_id,
                 block_handler,
                 tempo=60):
        self.norm = norm
        self.module_name = 'TempoCursor'
        self.sandbox = sandbox
        self.mixer = mixer
        self.client = client
        self.cid = client_id
        self.block_handler = block_handler

        self.tempo = tempo
        self.clock = Clock()
        self.tempo_map = SimpleTempoMap(bpm=self.tempo)

        self.touch_points = {}

        self.cursors = AnimGroup()
        self.sandbox.add(self.cursors)

        self.gui = CursorGUI(norm,
                             pos=self.norm.nt((20, 300)),
                             beat_callback=self.update_touch_points)

        self.delete_mode = {}

    def on_touch_down(self, cid, pos):
        if cid == self.cid:
            self.gui.on_touch_down(pos)

        if not self.sandbox.in_bounds(pos):
            return

        for cursor in self.cursors.objects:
            cursor_pos = (cursor.pos[0] - cursor.size[0] / 2,
                          cursor.pos[1] - cursor.size[1] / 2)
            if in_bounds(pos, cursor_pos, cursor.size):
                if self.delete_mode[cid]:
                    self.cursors.objects.remove(cursor)
                    self.cursors.remove(cursor)
                    return

        if self.delete_mode[cid]:
            return

        touch_points = self.touch_points[cid]

        if len(touch_points) == 0:
            return
        cursor = TempoCursor(self.norm, pos, self.tempo,
                             self.clock, self.tempo_map,
                             copy.deepcopy(touch_points), self.block_handler)
        self.cursors.add(cursor)

    def on_touch_move(self, cid, pos):
        pass

    def on_touch_up(self, cid, pos):
        pass

    def on_key_down(self, cid, key):
        if key == 'p':
            self.clock.toggle()
        if key == 'v' and cid == self.cid:
            self.delete_mode[cid] = not self.delete_mode[cid]
            self.update_server_state(post=True)
        if key == 'up':
            self.tempo += 4
            self.tempo_map.set_tempo(self.tempo)
            self.update_server_state(post=True)
        if key == 'down':
            self.tempo -= 4
            self.tempo_map.set_tempo(self.tempo)
            self.update_server_state(post=True)

    def on_update(self):
        self.cursors.on_update()

    def update_touch_points(self, touch_points):
        self.touch_points[self.cid] = touch_points
        self.update_server_state(post=True)

    def display_controls(self):
        cur_time = self.clock.get_time()
        cur_tick = self.tempo_map.time_to_tick(cur_time)
        info = 'delete mode: {}\n\n'.format(self.delete_mode[self.cid])
        info += 'tempo: {}\n'.format(self.tempo)
        return info

    def update_server_state(self, post=False):
        """Update server state. If post is True, relay this updated state to all clients."""
        state = {
            'touch_points': self.touch_points,
            'delete_mode': self.delete_mode,
            'tempo': self.tempo
        }
        data = {
            'module': self.module_name,
            'cid': self.cid,
            'state': state,
            'post': post
        }
        self.client.emit('update_state', data)

    def update_client_state(self, cid, state):
        """Update this handler's state."""
        if cid != self.cid:  # this client already updated its own state
            self.touch_points = state['touch_points']
            self.delete_mode = state['delete_mode']
            self.tempo = state['tempo']

    def sync_state(self, state):
        """
        Initial sync with the server's copy of module state.
        """
        self.touch_points = state['touch_points']
        self.delete_mode = state['delete_mode']
        self.tempo = state['tempo']

        # after initial sync, add default values for this client
        self.touch_points[self.cid] = []
        self.delete_mode[self.cid] = False

        # update server with these default values
        # post=True here because we want all other clients' states to update with this client's
        # default values.
        self.update_server_state(post=True)
Example #3
0
class Session(GameObject):
    def __init__(self, other_members, tempo, bars, divs, inst_set):
        super(Session, self).__init__()
        self.tempo = tempo
        self.bars = bars
        self.divs = divs
        self.inst_set = inst_set
        spb = 60. / tempo
        beats = bars * 4
        self.seconds = spb * beats
        self.clock = Clock()
        self.temp_map = SimpleTempoMap(bpm=tempo)
        self.sched = Scheduler(self.clock, self.temp_map)
        # self.players = players
        self.IM = InstrumentManager(self.sched)
        self.add(self.IM)

        ### NEW CODE ###
        self.pattern_list = PatternList(self.bars, self.tempo, self.inst_set)
        self.add(self.pattern_list)

        track = Track(num_lanes, self.bars, self.tempo)
        track.position.y = Window.height * 0.025
        controller = InstrumentKeyboard(default_keycodes, lock_in_keycode)
        self.player = Player(controller, track, inst_set)
        self.player.position.x = Window.width - player_size[0] - 20
        self.add(self.player)
        self.vplayers = []
        self.add_band_members(other_members)
        self.IM.add(self.player.instrument)

        self.clock.offset = self.seconds - spb

        self.paused = True
        self.start()

    def add_band_members(self, other_members):
        for other_member in other_members:
            vcontroller = InstrumentController(16, other_member['id'])
            vtrack = VirtualTrack(num_lanes, self.bars, self.tempo)
            vplayer = VirtualPlayer(vcontroller, vtrack)
            self.vplayers.append(vplayer)
            self.add(vplayer)

    def on_key_down(self, event):
        # if event.keycode[1] == 'enter':on
        # 	self.toggle()
        pass

    def toggle(self):
        if self.paused:
            self.paused = False
            self.start()
        else:
            self.paused = True
            self.stop()

    def stop(self):
        self.clock.stop()

    def start(self):
        self.clock.start()

    def next_player(self, sequence):
        if self.current_player < self.num_players:
            self.players[self.current_player].note_sequence = sequence
            self.players[self.current_player].stop_composing()
            self.current_player += 1
        if self.current_player < self.num_players:
            self.players[self.current_player].start_composing()

    def on_lock_in(self, event):
        self.next_player(event.action['sequence'])

    def on_update(self):
        self.sched.on_update()
        # for player in self.players:
        now = self.clock.get_time() % self.seconds
        for vplayer in self.vplayers:
            vplayer.set_now(now)
        self.player.set_now(now)
        self.pattern_list.set_now(self.clock.get_time() % self.seconds)