def __init__(self, tap): """ tap (RingPosition): the starting point where our stretch begins """ self.__in_tap = tap self.__buffer = Ring(2**16) self.__fading_out = False
def __init__(self): """ The constructor and initiator. :return: """ # initial setup super(mainWindow, self).__init__() self.setupUi(self) # create an instance of the table data and give yourself as UI Interface self.ame_data = AMEData(self) # take care about ring combo self.ring_dict = Ring.get_ring_dict() keys = list(self.ring_dict.keys()) keys.sort() self.comboBox_ring.addItems(keys) self.current_ring_name = '' self.comboBox_ring.setCurrentIndex(4) self.on_comboBox_ring_changed(4) # fill combo box with names self.comboBox_name.addItems(self.ame_data.names_list) # UI related stuff self.setup_table_view() self.connect_signals() # A particle to begin with self.particle = None self.comboBox_name.setCurrentIndex(6) self.reinit_particle()
def __init__(self, expression): FieldItem.__init__(self) # Parse Expression if needed if type(expression) is str: expression = parse(expression) debug(2, 'init Figure', expression) self.expression = expression.withRoot() # History of Expression self.history = history.History() # Colorspace self.detColorSpace() # Size of Figure self.sizeRing = Ring( (0, 0), 1.0) # Ring for setting size of Figure (used in morphing) self.refreshTransform() self.groups = [] self.buildGroups() self.buildGeometry() self.history.step(self.expression.copy()) # Eating Act self.eating = None
def prepare(self): ame_data = AMEData(DummyIFace()) # create reference particle p = Particle(6, 6, ame_data, Ring('ESR', 108.5)) p.qq = 3 p.ke_u = 422 p.path_length_m = 108.5 p.f_analysis_mhz = 245 p.i_beam_uA = 1.2 print('Reference particle:', p) print('Isobars:') for pp in p.get_isobars(): print(pp) # get some nuclides # nuclides = p.get_all_in_all() nuclides = p.get_nuclides(57, 59, 81, 83, 2) #nuclides = p.get_nuclides(20, 92, 40, 143, 10) self.n_rows = int(len(nuclides)) self.nuclidic_data = np.array([]) self.nuclidic_labels = [] for pp in nuclides: pp.calculate_revolution_frequency() brho = pp.get_magnetic_rigidity() values = [pp.revolution_frequency, brho] self.n_cols = len(values) self.nuclidic_data = np.append(self.nuclidic_data, values) self.nuclidic_labels.append(pp.get_short_name()) # print(self.nuclidic_labels) self.nuclidic_data = np.reshape(self.nuclidic_data, (self.n_rows, self.n_cols))
def packetizerReset(self): """ To be called on an error; flush out the packetizer and return it to its normal state. """ self._state = self.FRAME self._ring = Ring()
def key_listener(self, event): key = repr(event.char) if key == "'q'": self.entities.append(Ring("blue", self)) else: for i in self.entities: if type(i) is Ring: ring = i print("Ring pos: " , ring.y) msg = self.check_accuracy(ring.y)
def __init__(self): # Group Topology self.parent = None # Noke # not Bubble: for Group.buildGeometry() self.childs = [] # Nokes self.upper = False # Upper level - first child self.group = None # Parent Group of Bubble # Geometry and Correction self.ring = Ring((0, 0), 1) # For building Geometry self.tight = 0 # Left (Parents) and right (Childs) Tights self.corr = 0 # Correction of Radius self.angles = {} # dict {Bubble:angle} # Eating self.fading = None # Fading object
def testNecklace(self): testMetal: str = "platinum" testGem: str = "ruby" testSize: int = 8 ring = Ring(metal=testMetal, gem=testGem, size=testSize) self.assertEqual(ring.gem, "ruby") self.assertEqual(ring.metal, "platinum") ring.gem = "pearl" ring.metal = "titanium" ring.size = 7 self.assertEqual(ring.gem, "pearl") self.assertEqual(ring.metal, "titanium") ring.wear() self.assertEqual(ring.polished, False) ring.polish() self.assertEqual(ring.polished, True)
def testRing(self): ring = Ring() self.assertEqual(ring.polished, True) ring.wear() self.assertEqual(ring.polished, False) ring.polish() self.assertEqual(ring.polished, True)
def start_draft( self, users: t.Iterable[AbstractUser], pool_specification: PoolSpecification, infinites: Infinites, draft_format: str, reverse: bool, finished_callback: t.Callable[[Draft], None], ) -> t.Tuple[t.Tuple[AbstractUser, Drafter], ...]: drafters = tuple( ( user, Drafter( user, str(uuid.uuid4()), ), ) for user in users ) drafters_ring = Ring( drafter for _, drafter in drafters ) def _finished_callback(_draft: Draft): self.draft_complete(_draft) finished_callback(_draft) draft = Draft( key = str(uuid.uuid4()), drafters = drafters_ring, pool_specification = pool_specification, infinites = infinites, draft_format = draft_format, finished_callback = _finished_callback, reverse = reverse, ) draft.start() with self._lock: self._drafts.add(draft) for drafter in drafters_ring.all: self._drafters[drafter.key] = draft.get_draft_interface(drafter) return drafters
def __init__(self, env, inner_circle_len, outer_circle_len): # Test circle lengths for circle_len in (inner_circle_len, outer_circle_len): assert circle_len >= 16, 'Circle lenght has to be at least 16' assert circle_len % 4 == 0, 'Circle lenght must be divisible by 4' self.env = env # Generate circles of Resources self.inner_circle = Ring([ simpy.resources.resource.PriorityResource(env, capacity=1) for i in range(inner_circle_len) ]) self.outer_circle = Ring([ simpy.resources.resource.PriorityResource(env, capacity=1) for i in range(outer_circle_len) ]) # Create indices of exit slots (exit pointers) self.inner_exits_indices = RoundAbout.Exits( *RoundAbout.calculate_exit_indices(inner_circle_len)) self.outer_exits_indices = RoundAbout.Exits( *RoundAbout.calculate_exit_indices(outer_circle_len))
def test_tap_activation(): a = Ring(16) t = a.create_tap() t.deactivate() assert t.name in a.inactive_taps assert t.name not in a.active_taps a.append(np.arange(15)) a.append([99]) t.activate() assert t.name in a.active_taps assert t.name not in a.inactive_taps s = t.get_samples(1) assert s[0] == 99
def getBounding(bubbles): "Returns Bounding Ring of Bubbles in Group" center = Vector2((0, 0)) ws = 0 for b in bubbles: weight = b.ring.r**2 center += b.ring.pos * weight ws += 1.0 * weight center /= ws radius = max([ Vector2( center, b.ring.pos ).length() + b.ring.r \ for b in bubbles ]) return Ring(center, radius)
class EggRing(object): def __init__(self, x, y, t, sp): self.ovoid = Egg(x, y, t, sp) self.circle = Ring() self.circle.start(x, y - sp / 2) def transmit(self): self.ovoid.wobble() self.ovoid.display() self.circle.grow() self.circle.display() if self.circle.on == False: self.circle.on = True
def __init__( self ): # Group Topology self.parent = None # Noke # not Bubble: for Group.buildGeometry() self.childs = [] # Nokes self.upper = False # Upper level - first child self.group = None # Parent Group of Bubble # Geometry and Correction self.ring = Ring((0,0),1) # For building Geometry self.tight = 0 # Left (Parents) and right (Childs) Tights self.corr = 0 # Correction of Radius self.angles = {} # dict {Bubble:angle} # Eating self.fading = None # Fading object
class Node(object): def __init__(self, is_leader, leader_hostname, my_hostname, tcp_port=13337, sloppy_Qsize=5, sloppy_R=3, sloppy_W=3): self.ongoing_requests = [] self.is_leader = is_leader self.leader_hostname = leader_hostname self.hostname = my_hostname self.tcp_port = tcp_port self.my_address = (self.hostname, self.tcp_port) self.membership_ring = Ring(replica_count=sloppy_Qsize - 1) # Other nodes in the membership if self.is_leader: self.membership_ring.add_node(leader_hostname) # todo: look into this, do we need both? self.bootstrapping = True self.is_member = False # Flag to keep track of a add-node is underway self._membership_in_progress = False self.sloppy_Qsize = sloppy_Qsize # total members to replicate on # number of peers required for a read or write to succeed. self.sloppy_R = sloppy_R self.sloppy_W = sloppy_W # Book keeping for membership messages self._req_responses = defaultdict(set) self._sent_req_messages = {} self._received_req_messages = {} self._req_sender = {} # Keeps track to sender for add and delete requests self.current_view = 0 # increment this on every leader election self.membership_request_id = 0 # increment this on every request sent to peers # Maintains handoff messages to be sent # IP : set(handoff messages) self._handoff_messages = defaultdict(set) self.handoff_timer = None self.create_handoff_timer = lambda: Timer(5, self.try_sending_handoffs) self.log_prefix = os.getcwd() self.ring_log_file = os.path.join(self.log_prefix, self.hostname + '.ring') self.db_path = os.path.join(self.log_prefix, self.hostname + '.db') self.handoff_log = os.path.join(self.log_prefix, self.hostname + '.pickle') try: with open(self.ring_log_file, 'r') as f: hosts = f.readlines() for h in hosts: self.membership_ring.add_node(h.strip()) print("Restored membership information from %s" % self.ring_log_file) except FileNotFoundError: pass try: with open(self.handoff_log, 'rb') as f: self._handoff_messages = pickle.loads(f.read()) if len(self._handoff_messages) > 0: self.handoff_timer = self.create_handoff_timer() self.handoff_timer.start() print("Restored hand off messages from %s" % self.handoff_log) except FileNotFoundError: pass self.request_timelimit = 2.0 self.req_message_timers = {} self.db = Storage(self.db_path) # set up sqlite table # create tcp socket for communication with peers and clients self.tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp_socket.setblocking(False) # Non-blocking socket self.tcp_socket.bind((self.hostname, self.tcp_port)) self.tcp_socket.listen(10) # has hostnames mapped to open sockets self.connections = {} self.client_list = set() def accept_connections(self): incoming_connections = {self.tcp_socket} print("Accepting connections...") while True: readable, _, _ = select.select(incoming_connections, [], [], 0) for s in readable: if s is self.tcp_socket: connection, client_address = s.accept() connection.setblocking(False) incoming_connections.add(connection) self.connections[client_address[0]] = connection else: try: header = s.recv(5) except: print("Connection reset.") continue if not header: # remove for connection pool and close socket incoming_connections.remove(s) # del self.connections[s.getpeername()[0]] s.close() else: message_len = struct.unpack('!i', header[1:5])[0] data = b'' while len(data) < message_len: try: data += s.recv(message_len - len(data)) except socket.error as err: pass self._process_message(header + data, s.getpeername()[0]) # addr is a tuple of hostname and port def _process_message(self, data, sender): message_type, data_tuple = messages._unpack_message(data) message_type_mapping = { b'\x00': self._process_command, b'\x01': self._process_req_message, b'\x10': self._membership_change_message, b'\xff': self._process_ok_message, b'\x07': self.perform_operation, b'\x08': self.perform_operation, b'\x70': self.update_request, b'\x80': self.update_request, b'\x0B': self.update_request, b'\x0A': self.handle_forwarded_req, b'\x0C': self.handle_handoff } message_type_mapping[message_type](data_tuple, sender) return def _process_command(self, user_input, sendBackTo): """Process commands""" self.client_list.add(sendBackTo) # Maps command to the corresponding function. # Command arguments are passed as the first argument to the function. command_registry = { # Possible commands: "add-node": self.add_node, # 1. add node to membership "remove-node": self.remove_node, # 2. remove node from membership "put": self.put_data, # 3. put data "get": self.get_data, # 4. get data } if not user_input: self._send_req_response_to_client(sendBackTo, "User input empty") # First word is command. Rest are then arguments. command, *data = user_input.split(" ") if command not in command_registry: self._send_req_response_to_client(sendBackTo, "Invalid command") # Call the function associated with the command in command_registry return command_registry[command](data, sendBackTo) def handle_handoff(self, data, sendBackTo): # data should have (message, list of hosts to hand data off to) for h in data[1]: print("Storing hand off message for %s" % h) self._handoff_messages[h].add(data[0]) # Save handoff messages to disk self.sync_handoffs_to_disk() # check and start timer if not self.handoff_timer: self.handoff_timer = self.create_handoff_timer() self.handoff_timer.start() def try_sending_handoffs(self): print("Attempting to send hand off messages...") updated_handoff_messages = defaultdict(set) for (host, msgs) in self._handoff_messages.items(): for msg in msgs: fail = self.broadcast_message([host], msg) if fail: updated_handoff_messages[host].add(msg) self._handoff_messages = updated_handoff_messages self.sync_handoffs_to_disk() if len(self._handoff_messages) > 0: print("Undelivered hand offs. Restarting timer") self.handoff_timer = self.create_handoff_timer() self.handoff_timer.start() return print("Sent all hand off messages.") self.handoff_timer = None def sync_handoffs_to_disk(self): # Save hand off messages to disk with open(self.handoff_log, 'wb') as f: f.write(pickle.dumps(self._handoff_messages)) def add_node(self, data, sender): """Add node to membership. data[0] must be the hostname. Initiates 2PC.""" if not self.is_leader: self._send_req_response_to_client(sender, "Error: This is not the leader") return if not data: self._send_req_response_to_client(sender, "Error: hostname required") return if self._membership_in_progress: self._send_req_response_to_client(sender, "Membership operation in progress. Try again") return if data[0] in self.membership_ring: self._send_req_response_to_client(sender, "Already in the membership") return self._membership_in_progress = True print("Starting add-node operation for %s" % data[0]) new_peer_message = messages.reqMessage(self.current_view, self.membership_request_id, 1, data[0]) # associate hostname to (view_id, req_id) self._sent_req_messages[(self.current_view, self.membership_request_id)] = (data[0], 1) self._req_sender[(self.current_view, self.membership_request_id)] = sender # broadcast to all but leader. nodes_to_broadcast = self.membership_ring.get_all_hosts() nodes_to_broadcast.remove(self.hostname) nodes_to_broadcast.add(data[0]) # Add new host to broadcast list self.broadcast_message(nodes_to_broadcast, new_peer_message) t = Timer(self.request_timelimit, self._req_timeout, args=[(self.current_view, self.membership_request_id)]) self.req_message_timers[(self.current_view, self.membership_request_id)] = t t.start() self.membership_request_id += 1 # Send a remove node message to everyone and if you are that node, shutdown def remove_node(self, data, sender): if not self.is_leader: self._send_req_response_to_client(sender, "Error: This is not the leader") return if not data: self._send_req_response_to_client(sender, "Error: hostname required") return if self._membership_in_progress: self._send_req_response_to_client(sender, "Membership operation in progress. Try again") return if data[0] not in self.membership_ring: self._send_req_response_to_client(sender, "Cannot remove. Node not in membership") return self._membership_in_progress = True print("Starting remove-node operation for %s" % data[0]) new_peer_message = messages.reqMessage(self.current_view, self.membership_request_id, 2, data[0]) # associate hostname to (view_id, req_id) self._sent_req_messages[(self.current_view, self.membership_request_id)] = (data[0], 2) self._req_sender[(self.current_view, self.membership_request_id)] = sender # broadcast to all but leader. nodes_to_broadcast = self.membership_ring.get_all_hosts() nodes_to_broadcast.remove(self.hostname) nodes_to_broadcast.add(data[0]) # Add new host to broadcast list self.broadcast_message(nodes_to_broadcast, new_peer_message) t = Timer(self.request_timelimit, self._req_timeout, args=[(self.current_view, self.membership_request_id)]) self.req_message_timers[(self.current_view, self.membership_request_id)] = t t.start() self.membership_request_id += 1 # self.membership_ring.remove_node(data[0]) def put_data(self, data, sendBackTo): if len(data) != 3: return "Error: Invalid operands\nInput: (<key>,<prev version>,<value>)" data = [data[0], json.loads(data[1]), data[2]] key = data[0] prev = data[1] value = data[2] target_node = self.membership_ring.get_node_for_key(data[0]) if not self.is_leader: # forward request to leader for client return self._send_data_to_peer(self.leader_hostname, data, sendBackTo) else: # I am the leader if target_node == self.hostname: # I'm processing a request for a client directly self.start_request('put', data, sendBackTo=sendBackTo) return else: # I am forwarding a request from the client to the correct node return self._send_data_to_peer(target_node, data, sendBackTo) def get_data(self, data, sendBackTo): """Retrieve V for given K from the database. data[0] must be the key""" if not data: return "Error: key required" target_node = self.membership_ring.get_node_for_key(data[0]) # if I can do it myself if target_node == self.hostname: # I am processing a request for a client directly self.start_request('get', data[0], sendBackTo=sendBackTo) else: # forward the client request to the peer incharge of req self._request_data_from_peer(target_node, data[0], sendBackTo) def _process_req_message(self, data, sender): # data = (view_id, req_id, operation, address) (view_id, req_id, operation, address) = data print("Processed request message to add %s" % address) # save the message type self._received_req_messages[(view_id, req_id)] = (address, operation) ok_message = messages.okMessage(view_id, req_id) self.connections.get(sender, self._create_socket(sender)).sendall(ok_message) def _process_ok_message(self, data, sender): self._req_responses[data].add(sender) (new_peer_hostname, operation) = self._sent_req_messages[data] required_responses = len(self.membership_ring) if operation == 1 else (len(self.membership_ring) - 1) # number of replies equal number of *followers* already in the ring, add peer to membership if len(self._req_responses[data]) == required_responses: # Cancel timer t = self.req_message_timers.get(data, None) if not t: return t.cancel() # Send newViewMessage # self.current_view += 1 if operation == 1: # adding new node self.membership_ring.add_node(new_peer_hostname) hosts_to_send = self.membership_ring.get_all_hosts() nodes_to_broadcast = self.membership_ring.get_all_hosts() else: hosts_to_send = (new_peer_hostname, ) nodes_to_broadcast = self.membership_ring.get_all_hosts() nodes_to_broadcast.remove(new_peer_hostname) self.membership_ring.remove_node(new_peer_hostname) membership_change_msg = messages.membershipChange(self.current_view, operation, hosts_to_send) nodes_to_broadcast.remove(self.hostname) self.broadcast_message(nodes_to_broadcast, membership_change_msg) print("Successfully %s %s." % ("added" if operation == 1 else "removed", new_peer_hostname)) client = self._req_sender.get(data, None) self._send_req_response_to_client(client, "Successfully %s %s." % ("added" if operation == 1 else "removed", new_peer_hostname)) self._membership_in_progress = False # reset state to accept new connections def _membership_change_message(self, data, sender): (view_id, operation, peers) = data # self.current_view = view_id if operation == 1: # add nodes for p in peers: if p not in self.membership_ring: self.membership_ring.add_node(p) if operation == 2: for p in peers: if p in self.membership_ring: self.membership_ring.remove_node(p) with open(self.ring_log_file, 'w') as f: for node in self.membership_ring.get_all_hosts(): f.write(node + '\n') print("Successfully modified membership ring. Total members: %d" % len(self.membership_ring.get_all_hosts())) print("Current members: %s" % ", ".join(self.membership_ring.get_all_hosts())) print("Keys to manage: ", self.membership_ring.get_key_range(self.hostname)) def _req_timeout(self, req_id): print("Error adding node to network. One or more nodes is offline.") # failed_hosts = set(self.membership_ring.get_all_hosts()) - self._req_responses[req_id] # failed_hosts.remove() sender = self._req_sender.get(req_id, None) self._send_req_response_to_client(sender, "Failed to add node to the network") self._membership_in_progress = False def _send_req_response_to_client(self, client, message): msg = messages.responseForForward(message) self.broadcast_message([client], msg) # request format: # object which contains # type # sendBackTo # forwardedTo =None if type is not for_* # hash # value =None if type is get or forget # context =None if type is get or forget # responses = { sender:msg, sender2:msg2... } # args format is determined by type: # type='get', args='hash' # type='put', args=('hash','value',{context}) # type='for_get', args=(target_node,'hash') # type='for_put', args=(target_node, 'hash','value',{context}) # Type can be 'put', 'get', 'for_put', 'for_get' # 'for_*' if for requests that must be handled by a different peer # then when the response is returned, complete_request will send the # output to the correct client or peer (or stdin) def start_request(self, rtype, args, sendBackTo, prev_req=None): print("%s request from %s: %s" % (rtype, sendBackTo, args)) req = Request(rtype, args, sendBackTo, previous_request=prev_req) # create request obj self.ongoing_requests.append(req) # set as ongoing target_node = self.membership_ring.get_node_for_key(req.hash) replica_nodes = self.membership_ring.get_replicas_for_key(req.hash) T = Timer(self.request_timelimit + (1 if rtype[:3] == 'for' else 0), self.complete_request, args=[req], kwargs={"timer_expired": True} ) T.start() self.req_message_timers[req.time_created] = T # Find out if you can respond to this request if rtype == 'get': # add my information to the request result = self.db.getFile(args) my_resp = messages.getFileResponse(args, result, req.time_created) self.update_request(messages._unpack_message(my_resp)[1], socket.gethostbyname(self.hostname), req) # send the getFile message to everyone in the replication range msg = messages.getFile(req.hash, req.time_created) # this function will need to handle hinted handoff print("Sending getFile message to %s" % ", ".join(replica_nodes)) fails = self.broadcast_message(replica_nodes, msg) if fails: print("Failed to send get msg to %s" % ', '.join(fails)) elif rtype == 'put': self.db.storeFile(args[0], socket.gethostbyname(self.hostname), args[1], args[2]) my_resp = messages.storeFileResponse(args[0], args[1], args[2], req.time_created) # add my information to the request self.update_request(messages._unpack_message(my_resp)[1], socket.gethostbyname(self.hostname), req) # send the storeFile message to everyone in the replication range msg = messages.storeFile(req.hash, req.value, req.context, req.time_created) # this function will need to handle hinted handoff print("Sending storeFile message to %s" % ", ".join(replica_nodes)) fails = self.broadcast_message(replica_nodes, msg) if fails: print("Failed to send put msg to %s" % ', '.join(fails)) else: msg = messages.forwardedReq(req) # forward message to target node # self.connections[req.forwardedTo].sendall(msg) if self.broadcast_message([req.forwardedTo], msg): self.leader_to_coord(req) else: print("Forwarded Request to %s" % req.forwardedTo) def leader_to_coord(self, req): print("Leader is assuming role of coordinator") replica_nodes = self.membership_ring.get_replicas_for_key(req.hash) req.type = req.type[4:] if req.type == 'get': msg = messages.getFile(req.hash, req.time_created) else: msg = messages.storeFile(req.hash, req.value, req.context, req.time_created) self.broadcast_message(replica_nodes, msg) def find_req_for_msg(self, req_ts): return list(filter( lambda r: r.time_created == req_ts, self.ongoing_requests )) # after a \x70, \x80 or \x0B is encountered from a peer, this method is called def update_request(self, msg, sender, request=None): print("Updating Request with message ", msg, " from ", sender) if isinstance(msg, tuple): if not request: request = self.find_req_for_msg(msg[-1]) min_num_resp = self.sloppy_R if len(msg) == 3 else self.sloppy_W else: request = self.find_req_for_msg(msg.previous_request.time_created) min_num_resp = 1 if not request: print("No request found, ", sender, " might have been too slow") return elif isinstance(request, list): request = request[0] request.responses[sender] = msg if len(request.responses) >= min_num_resp: self.complete_request(request) def coalesce_responses(self, request): resp_list = list(request.responses.values()) # check if you got a sufficient number of responses if len(resp_list) < self.sloppy_R: return None results = [] for resp in resp_list: # print(resp) results.extend([ tup for tup in resp[1] if tup not in results ]) return self.db.sortData(results) def complete_request(self, request, timer_expired=False): failed = False if request.type == 'get': # if sendbackto is a peer if request.sendBackTo not in self.client_list: # this is a response to a for_* # send the whole request object back to the peer msg = messages.responseForForward(request) else: # compile results from responses and send them to client # send message to client msg = messages.getResponse(request.hash, ( self.coalesce_responses(request) if not failed else "Error" )) elif request.type == 'put': if len(request.responses) >= self.sloppy_W: print("Successful put completed for ", request.sendBackTo) if request.sendBackTo not in self.client_list: # this is a response to a for_* # send the whole request object back to the peer msg = messages.responseForForward(request) else: # send success message to client # check if you were successful msg = messages.putResponse(request.hash, ( request.value if len(request.responses) >= self.sloppy_W and not failed else "Error" ), request.context) # if len(request.responses) >= self.sloppy_W and timer_expired: if timer_expired and len(request.responses) < self.sloppy_Qsize: target_node = self.membership_ring.get_node_for_key(request.hash) replica_nodes = self.membership_ring.get_replicas_for_key(request.hash) all_nodes = set([target_node] + replica_nodes) missing_reps = set([self.membership_ring.hostname_to_ip[r] for r in all_nodes]) - set(request.responses.keys()) handoff_store_msg = messages.storeFile(request.hash, request.value, request.context, request.time_created) handoff_msg = messages.handoff( handoff_store_msg, missing_reps ) hons = [ self.membership_ring.get_handoff_node(r) for r in missing_reps ] print("Handing off messages for %s to %s" % (", ".join(missing_reps), ", ".join(hons))) if self.hostname in hons: self.handle_handoff((handoff_store_msg, missing_reps), self.hostname) hons.remove(self.hostname) self.broadcast_message(hons, handoff_msg) else: # request.type == for_* # unpack the forwarded request object data = list(request.responses.values()) if not data: # del self.req_message_timers[request.time_created] # request.time_created=time.time() self.leader_to_coord(request) T = Timer(self.request_timelimit, self.complete_request, args=[request], kwargs={"timer_expired": True} ) T.start() self.req_message_timers[request.time_created] = T return else: data = data[0] # if sendbackto is a peer if request.sendBackTo not in self.client_list: # unpickle the returned put request data.previous_request = data.previous_request.previous_request # send the response object you got back to the peer # from request.responses (it is the put or get they need) # if you need to, make req.prev_req = req.prev_req.prev_req # so it looks like you did the request yourself msg = messages.responseForForward(data) elif request.type == 'for_put': msg = messages.putResponse(request.hash, ( request.value if data and len(data.responses) >= self.sloppy_W and not failed else "Error" ), request.context) else: # for_get msg = messages.getResponse(request.hash, ( self.coalesce_responses(data) if not failed else "Error" )) # send msg to request.sendBackTo # if request.sendBackTo not in self.client_list: if not request.responded: print("Sending response back to ", request.sendBackTo) self.broadcast_message([request.sendBackTo], msg) request.responded = True if timer_expired: # remove request from ongoing list self.ongoing_requests = list(filter( lambda r: r.time_created != request.time_created, self.ongoing_requests )) def perform_operation(self, data, sendBackTo): if len(data) == 2: # this is a getFile msg print("%s is asking me to get %s" % (sendBackTo, data[0])) msg = messages.getFileResponse(data[0], self.db.getFile(data[0]), data[1]) else: # this is a storeFile print("%s is asking me to store %s" % (sendBackTo, data[0])) self.db.storeFile(data[0], sendBackTo, data[1], data[2]) msg = messages.storeFileResponse(*data) self.broadcast_message([sendBackTo], msg) def handle_forwarded_req(self, prev_req, sendBackTo): target_node = self.membership_ring.get_node_for_key(prev_req.hash) print("Handling a forwarded request [ %s, %f ]" % (prev_req.type, prev_req.time_created)) if time.time() - prev_req.time_created < self.request_timelimit: # someone forwarded you a put request # if you are the leader, check if you can takecare of it, else, # start a new put request with this request as the previous one if prev_req.type == 'put' or prev_req.type == 'for_put': if self.is_leader: if target_node == self.hostname: args = (prev_req.hash, prev_req.value, prev_req.context) self.start_request('put', args, sendBackTo, prev_req=prev_req) else: args = (target_node, prev_req.hash, prev_req.value, prev_req.context ) self.start_request('for_put', args, sendBackTo, prev_req) else: # the leader is forwarding you a put args = (prev_req.hash, prev_req.value, prev_req.context) self.start_request('put', args, sendBackTo, prev_req=prev_req) # someone forwarded you a get request, you need to take care of it # start new get request with this as the previous one else: # type is get or for_get self.start_request('get', prev_req.hash, sendBackTo, prev_req) def _send_data_to_peer(self, target_node, data, sendBackTo): # create for_put request self.start_request('for_put', [target_node] + data, sendBackTo=sendBackTo) def _request_data_from_peer(self, target_node, data, sendBackTo): self.start_request('for_get', (target_node, data), sendBackTo=sendBackTo) def _create_socket(self, hostname): """Creates a socket to the host and adds it connections dict. Returns created socket object.""" s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setblocking(False) s.settimeout(1) # 10 seconds try: s.connect((hostname, self.tcp_port)) self.connections[socket.gethostbyname(hostname)] = s return s except Exception as e: if hostname not in self.client_list: print("Error creating connection to %s: %s" % (hostname, e)) return None # this is where we need to handle hinted handoff if a # peer is not responsive by asking another peer to hold the # message until the correct node recovers def broadcast_message(self, nodes, msg): fails = [] for node in nodes: c = self.connections.get(node, self._create_socket(node)) if not c: fails.append(node) continue c.sendall(msg) return fails
def __init__(self, ring_name, module_id): Ring.__init__(self, ring_name, module_id, StatusMessage)
def test_ring_size(self): ring = Ring(1) self.assertEqual(str(ring), '1')
def validateRings(self, ringContent): if self.dbwritten: self.webclient.sendMessage(WebSocketMessage.create("local","TTTS_GAME_OVER_MSGS","Rings verification cancelled, results already written to DB")) return ring = json.loads(ringContent) result = ring['result'] sha256 = ring['sha256'] ringsignature = ring['sign'] testsha256 = hashlib.sha256(result).hexdigest() if testsha256 != sha256: print "ERROR: The hashes %s and %s are not equal"%(testsha256,sha256) return; result = json.loads(result.replace("'", "\"").replace("\n", "$")) p1 = result['player1'] p2 = result['player2'] s1 = result['spectator'] result['player1'][1] = result['player1'][1].replace("$", "\n") result['player2'][1] = result['player2'][1].replace("$", "\n") result['spectator'][1] = result['spectator'][1].replace("$", "\n") p1key = RSA.importKey(result['player1'][1]) p2key = RSA.importKey(result['player2'][1]) s1key = RSA.importKey(result['spectator'][1]) ringGroupStr = ringsignature.keys()[0] ringGroup = ringGroupStr.split(":") if ringGroup[0] == "player1": firstkey = p1key; elif ringGroup[0] == "player2": firstkey = p2key; elif ringGroup[0] == "spectator": firstkey = s1key else: print "Signature label unknown: " + ringGroup[1] if ringGroup[1] == "player1": secondkey = p1key; elif ringGroup[1] == "player2": secondkey = p2key; elif ringGroup[1] == "spectator": secondkey = s1key else: print "Signature label unknown: " + ringGroup[1] testring = Ring([firstkey, secondkey], 2048) verify = testring.verify(sha256, ringsignature[ringsignature.keys()[0]] ) if (verify): added = False for (k, r) in self.validrings: if k == ringGroupStr: added = True if not added: ring['result'] = result; self.validrings.append((ringGroupStr, ring)) else: print "Ring verification failed " self.webclient.sendMessage(WebSocketMessage.create("local","TTTS_GAME_OVER_MSGS","Verification of a ring failed")) verif = str(len(self.validrings)) + " rings verified" print verif self.webclient.sendMessage(WebSocketMessage.create("local","TTTS_GAME_OVER_MSGS", verif)) self.storeifthree()
class Packetizer (log.Base): """ A packetizer that is used to read and write to an underlying stream (like a Transport). Should be inherited by such a class. The subclass should implement: rawWrite(msg) --- write this msg to the stream. Typically handled at the Transport level (2 classes higher) packetizeError(e) --- report an error with the stream. Typically handled by the dispatcher (1 class higher). dispatch(msg) --- emit a packetized imcoming message. Typically handled by the Dispatcher (1 class higher) The subclass should call packetizeData(m) whenever it has data to stuff in to the packetizer's input path, and call send(m) whenever it wants to stuff data into the packetizer's output path. """ #------------------------------- # The two states we can be in FRAME = 1 DATA = 2 # Results of getting OK = 0 WAIT = 1 ERR = -1 #------------------------------- def __init__ (self, log_obj): self._ring = Ring() self._state = self.FRAME self._next_msg_len = 0 log.Base.__init__(self, log_obj) #------------------------------- def send (self, msg): b2 = msgpack.packb(msg) b1 = msgpack.packb(len(b2)) self.rawWrite(b1) self.rawWrite(b2) #------------------------------- def __getFrame (self): """ Internal method: get the frame part of a stream. """ if len(self._ring) is 0: return self.WAIT f0 = self._ring.grab(1) if not f0: return self.WAIT frame_len = msgpackFrameLen(ord(f0)) if not frame_len: self.packetizeError("Bad frame header received") return self.ERR # Now we know have many bytes to grab for real. It's a function # of the first byte of the stream.... f_full = self._ring.grab(frame_len) if not f_full: return self.WAIT try: r = unpackType(f_full, int) # pull the frame out of the input stream... self._ring.consume(frame_len) self._next_msg_len = r self._state = self.DATA return self.OK except UnpackValueError: self.packetizeError("Bad decoding in frame header; unpackb failed") except UnpackTypeError as e: self.packetizeError("Bad data type in frame header: {0}".format(e)) return self.ERR #------------------------------- def __getPayload(self): """ Internal method: get the msg part of the stream. """ l = self._next_msg_len if l > len(self._ring): return self.WAIT buf = self._ring.grab(l) if not buf: return self.WAIT try: msg = unpackType(buf, list) self._ring.consume(l) self._state = self.FRAME self.dispatch(msg) return self.OK except UnpackValueError: self.packetizeError("Bad encoding found in data; len={0}" .format(l)) except UnpackTypeError as e: self.packetizeError("In data: {0}".format(e)) return self.ERR #------------------------------- def packetizeData(self, msg): """ To be called wheneve new data arrives on the transport. This method will stuff the new data into the bufffer ring and then attempt to fetch as many messages as possible from the stream, stopping if either there's a wait condition or if an error occurred. """ self._ring.buffer(msg) go = self.OK while go is self.OK: if self._state is self.FRAME: go = self.__getFrame() else: go = self.__getPayload() #------------------------------- def packetizerReset(self): """ To be called on an error; flush out the packetizer and return it to its normal state. """ self._state = self.FRAME self._ring = Ring()
def __init__ (self, log_obj): self._ring = Ring() self._state = self.FRAME self._next_msg_len = 0 log.Base.__init__(self, log_obj)
class Bubble: @staticmethod def getDir(key): # key is pair of Bubbles return Vector2(key[0].ring.pos, key[1].ring.pos).unit() @staticmethod def getArc(key): # key is pair of Bubbles a, b = key[0].ring, key[1].ring return math.asin(1.0 * b.r / (a.r + b.r)) dirs = None # Cache arcs = None def __init__(self): # Group Topology self.parent = None # Noke # not Bubble: for Group.buildGeometry() self.childs = [] # Nokes self.upper = False # Upper level - first child self.group = None # Parent Group of Bubble # Geometry and Correction self.ring = Ring((0, 0), 1) # For building Geometry self.tight = 0 # Left (Parents) and right (Childs) Tights self.corr = 0 # Correction of Radius self.angles = {} # dict {Bubble:angle} # Eating self.fading = None # Fading object def __repr__(self): return 'Bubble: %s' % self.ring def neighbor(self, n): "Returns previous or next neighbor (or parent if not); n = -1 or 1" if self.parent: nokes = self.parent().childs + [self.parent] bubbles = map(Noke.get, nokes) return nokes[bubbles.index(self) + n] def neighbors(self): "Iterates all neighbor Nokes" if self.childs: for n in self.childs: yield n if self.parent: yield self.parent for n in (-1, 1): neighbor = self.neighbor(n) if neighbor != self.parent: yield neighbor #def strongParents( self ): # "Skips first Parent if Bubble is not on upper level" # return self.parents[ self.upper^1 :] def lightCopy(self): "Copies main attributes of Bubble" bubble = Bubble() bubble.group = self.group bubble.ring = self.ring.copy() bubble.fading = self.fading return bubble def markUpperChilds(self, mark): self.upper = mark if self.childs: upper = self.childs[0] for c in self.childs: c().markUpperChilds(c == upper) def detTights(self): def arc(noke): return Bubble.arcs[(self, noke())] if self.parent: self.tight += arc(self.neighbor(-1)) self.tight += arc(self.neighbor(1)) if self.childs: self.tight += arc(self.childs[0]) self.tight += arc(self.childs[-1]) if not self.upper: a = self.parent() # Bubbles: Parent c = self.neighbor(-1)() # Prev Neighbor ra = c.ring.r + self.ring.r # Radiuses rb = a.ring.r + c.ring.r rc = a.ring.r + self.ring.r # Cosines ca = 1.0 * (rb**2 + rc**2 - ra**2) / (2 * rb * rc) cc = 1.0 * (ra**2 + rb**2 - rc**2) / (2 * ra * rb) aa = math.acos(ca) # Angles ac = math.acos(cc) ab = math.pi - (aa + ac) a.tight += aa # Increase Tights c.tight += ac self.tight += ab # Save angle aa for detPosition() a.angles[self] = aa def detCorrections(self): "Dets Correction values. Returns False if Correction is not needed." if not (self.parent or self.childs): # Skip single Bubbles return False minChink = math.pi * 0.2 # ?? maybe to Constants # Set tight as chink self.tight = math.pi * 2 - self.tight self.tight /= 2 if self.tight < minChink: # Correction needed self.corr += 2 for n in self.neighbors(): n( ).corr -= 0.2 # ?? Here may be wrong values, and some Figures may be unbuildable return True return False # Correction is not needed def correct(self): "Corrects Radius of Ring." if self.corr: self.ring.r *= math.exp(self.corr * 0.06) def detPosition(self): "Dets Position of Bubble. Calculates initial values of Chinks." if self.upper: if not self.parent: # Root of Group self.ring.pos = Vector2((0, 0)) return else: parent = self.parent() # Parent Bubble if not parent.parent: dir = Vector2((1, 0)) # Default direction else: parent1 = parent.neighbor(-1)() a = parent.tight + Bubble.arcs[ (parent, self)] + Bubble.arcs[(parent, parent1)] - math.pi dir = Bubble.dirs[(parent1, parent)] dir = dir.rotate(Vector2(angle=-a)) # Det direction else: parent = self.parent() prev = self.neighbor(-1)() a = parent.angles[self] dir = Bubble.dirs[(parent, prev)] dir = dir.rotate(Vector2(angle=-a)) # Det direction Bubble.dirs[(parent, self)] = dir self.ring.pos = parent.ring.pos + dir * (parent.ring.r + self.ring.r) def transform(self): """ Returns transformation Matrix of Bubble, includes transformation Matrix of Group if is. """ # Default transformation is Unit # (Variable or Lambda inside another Lambda) matrix = TransformMatrix() matrix.unit() # Group reference may not exist # (Variable or Lambda inside fading Let-Bound Variable ??) if self.group: matrix *= self.group.transformMatrix if self.ring: matrix *= TransformMatrix(ring=self.ring) return matrix
def remove_entity(self, key): self.entities.remove(key) root = tk.Tk() canvas = Canvas(root, width=500, height=500) canvas.pack() canvas.create_text(100, 100, anchor=W, font="Purisa", text="{}".format("asd")) app = Application(canvas, master=root) app.add_entity(Ring("#264348", app)) continuing_game = True while continuing_game: root.update_idletasks() root.update() time.sleep(1 / 15) try: app.update() except: print("Program terminated") continuing_game = False
def __init__(self, NOTES, FREQ): self.ring = Ring() self.setNotes(NOTES) self.setAlternateNoteDict() self.accents = ['+', '-', ',', '.', '_', '^'] self.setFrequencyDictionary(self.CFreq_4, FREQ)
def __init__(self, x, y, t, sp): self.ovoid = Egg(x, y, t, sp) self.circle = Ring() self.circle.start(x, y - sp / 2)
def __init__(self, is_leader, leader_hostname, my_hostname, tcp_port=13337, sloppy_Qsize=5, sloppy_R=3, sloppy_W=3): self.ongoing_requests = [] self.is_leader = is_leader self.leader_hostname = leader_hostname self.hostname = my_hostname self.tcp_port = tcp_port self.my_address = (self.hostname, self.tcp_port) self.membership_ring = Ring(replica_count=sloppy_Qsize - 1) # Other nodes in the membership if self.is_leader: self.membership_ring.add_node(leader_hostname) # todo: look into this, do we need both? self.bootstrapping = True self.is_member = False # Flag to keep track of a add-node is underway self._membership_in_progress = False self.sloppy_Qsize = sloppy_Qsize # total members to replicate on # number of peers required for a read or write to succeed. self.sloppy_R = sloppy_R self.sloppy_W = sloppy_W # Book keeping for membership messages self._req_responses = defaultdict(set) self._sent_req_messages = {} self._received_req_messages = {} self._req_sender = {} # Keeps track to sender for add and delete requests self.current_view = 0 # increment this on every leader election self.membership_request_id = 0 # increment this on every request sent to peers # Maintains handoff messages to be sent # IP : set(handoff messages) self._handoff_messages = defaultdict(set) self.handoff_timer = None self.create_handoff_timer = lambda: Timer(5, self.try_sending_handoffs) self.log_prefix = os.getcwd() self.ring_log_file = os.path.join(self.log_prefix, self.hostname + '.ring') self.db_path = os.path.join(self.log_prefix, self.hostname + '.db') self.handoff_log = os.path.join(self.log_prefix, self.hostname + '.pickle') try: with open(self.ring_log_file, 'r') as f: hosts = f.readlines() for h in hosts: self.membership_ring.add_node(h.strip()) print("Restored membership information from %s" % self.ring_log_file) except FileNotFoundError: pass try: with open(self.handoff_log, 'rb') as f: self._handoff_messages = pickle.loads(f.read()) if len(self._handoff_messages) > 0: self.handoff_timer = self.create_handoff_timer() self.handoff_timer.start() print("Restored hand off messages from %s" % self.handoff_log) except FileNotFoundError: pass self.request_timelimit = 2.0 self.req_message_timers = {} self.db = Storage(self.db_path) # set up sqlite table # create tcp socket for communication with peers and clients self.tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp_socket.setblocking(False) # Non-blocking socket self.tcp_socket.bind((self.hostname, self.tcp_port)) self.tcp_socket.listen(10) # has hostnames mapped to open sockets self.connections = {} self.client_list = set()
class Bubble: @staticmethod def getDir( key ): # key is pair of Bubbles return Vector2( key[0].ring.pos, key[1].ring.pos ).unit() @staticmethod def getArc( key ): # key is pair of Bubbles a,b = key[0].ring, key[1].ring return math.asin( 1.0 * b.r / (a.r + b.r) ) dirs = None # Cache arcs = None def __init__( self ): # Group Topology self.parent = None # Noke # not Bubble: for Group.buildGeometry() self.childs = [] # Nokes self.upper = False # Upper level - first child self.group = None # Parent Group of Bubble # Geometry and Correction self.ring = Ring((0,0),1) # For building Geometry self.tight = 0 # Left (Parents) and right (Childs) Tights self.corr = 0 # Correction of Radius self.angles = {} # dict {Bubble:angle} # Eating self.fading = None # Fading object def __repr__( self ): return 'Bubble: %s' % self.ring def neighbor( self, n ): "Returns previous or next neighbor (or parent if not); n = -1 or 1" if self.parent: nokes = self.parent().childs + [self.parent] bubbles = map( Noke.get, nokes ) return nokes[ bubbles.index( self ) + n ] def neighbors( self ): "Iterates all neighbor Nokes" if self.childs: for n in self.childs: yield n if self.parent: yield self.parent for n in (-1,1): neighbor = self.neighbor( n ) if neighbor != self.parent: yield neighbor #def strongParents( self ): # "Skips first Parent if Bubble is not on upper level" # return self.parents[ self.upper^1 :] def lightCopy( self ): "Copies main attributes of Bubble" bubble = Bubble() bubble.group = self.group bubble.ring = self.ring.copy() bubble.fading = self.fading return bubble def markUpperChilds( self, mark ): self.upper = mark if self.childs: upper = self.childs[0] for c in self.childs: c().markUpperChilds( c == upper ) def detTights( self ): def arc( noke ): return Bubble.arcs[ ( self,noke() ) ] if self.parent: self.tight += arc( self.neighbor(-1) ) self.tight += arc( self.neighbor( 1) ) if self.childs: self.tight += arc( self.childs[ 0] ) self.tight += arc( self.childs[-1] ) if not self.upper: a = self.parent() # Bubbles: Parent c = self.neighbor(-1)() # Prev Neighbor ra = c.ring.r + self.ring.r # Radiuses rb = a.ring.r + c.ring.r rc = a.ring.r + self.ring.r # Cosines ca = 1.0 * ( rb**2 + rc**2 - ra**2 ) / ( 2 * rb * rc ) cc = 1.0 * ( ra**2 + rb**2 - rc**2 ) / ( 2 * ra * rb ) aa = math.acos( ca ) # Angles ac = math.acos( cc ) ab = math.pi - (aa + ac) a .tight += aa # Increase Tights c .tight += ac self.tight += ab # Save angle aa for detPosition() a.angles[ self ] = aa def detCorrections( self ): "Dets Correction values. Returns False if Correction is not needed." if not ( self.parent or self.childs ): # Skip single Bubbles return False minChink = math.pi * 0.2 # ?? maybe to Constants # Set tight as chink self.tight = math.pi*2 - self.tight self.tight /= 2 if self.tight < minChink: # Correction needed self.corr += 2 for n in self.neighbors(): n().corr -= 0.2 # ?? Here may be wrong values, and some Figures may be unbuildable return True return False # Correction is not needed def correct( self ): "Corrects Radius of Ring." if self.corr: self.ring.r *= math.exp( self.corr * 0.06 ) def detPosition( self ): "Dets Position of Bubble. Calculates initial values of Chinks." if self.upper: if not self.parent: # Root of Group self.ring.pos = Vector2((0,0)) return else: parent = self.parent() # Parent Bubble if not parent.parent: dir = Vector2((1,0)) # Default direction else: parent1 = parent.neighbor( -1 )() a = parent.tight + Bubble.arcs[(parent,self)] + Bubble.arcs[(parent,parent1)] - math.pi dir = Bubble.dirs[(parent1,parent)] dir = dir.rotate( Vector2( angle= -a ) ) # Det direction else: parent = self.parent() prev = self.neighbor(-1)() a = parent.angles[ self ] dir = Bubble.dirs[(parent,prev)] dir = dir.rotate( Vector2( angle= -a ) ) # Det direction Bubble.dirs[(parent,self)] = dir self.ring.pos = parent.ring.pos + dir * (parent.ring.r + self.ring.r) def transform( self ): """ Returns transformation Matrix of Bubble, includes transformation Matrix of Group if is. """ # Default transformation is Unit # (Variable or Lambda inside another Lambda) matrix = TransformMatrix() matrix.unit() # Group reference may not exist # (Variable or Lambda inside fading Let-Bound Variable ??) if self.group: matrix *= self.group.transformMatrix if self.ring: matrix *= TransformMatrix( ring= self.ring ) return matrix
class Stretcher(object): """ Given a tap pointer in a Ring buffer, generate the stretched audio """ def __init__(self, tap): """ tap (RingPosition): the starting point where our stretch begins """ self.__in_tap = tap self.__buffer = Ring(2**16) self.__fading_out = False def step(self, windowsize, *args, **kwargs): results = self.stretch(windowsize, *args, **kwargs) return results def stretch(self, windowsize, stretch_amount=4): """ Run paulstretch once from the current location of the tap point """ sw = get_strech(windowsize) audio_in = self.__in_tap.get_samples(sw.size) # Magnitude spectrum of windowed samples mX = np.abs(fft.rfft(audio_in * sw.window)) # Randomise the phases for each bin between 0 and 2pi pX = np.random.uniform(0, 2 * np.pi, len(mX)) * 1j # use e^x to Convert our array of random values from 0 to 2pi to an # array of cartesian style real+imag vales distributed around the unit # circle. Then multiply with magnitude spectrum to rotate the magnitude # spectrum around the circle. freq = mX * np.exp(pX) # Get the audio samples with randomized phase. When we randomized the # phase, we changed the waveform so it no longer starts and ends at # zero. We will need to apply another window -- however do not know the # size of the next window, so instead of applying the full window to # our audio samples, we will close the window from the previous step, # and open the window on our current samples. audio_phased = fft.irfft(freq) # counter the tremelo for both halves of the audio snippet audio_phased *= sw.double_hinv_buf # Open the window to the newly generated audio sample audio_phased *= sw.open_window # Next we will do the overlap/add with the tail of our local buffer. # First, retrive the the samples, apply the closing window previous = self.__buffer.recent(sw.half) * sw.close_window # overlap add this the newly generated audio with the closing tail of # the previous signal audio_phased[:sw.half] += previous # replace the tail end of the output buffer with the new signal self.__buffer.rewind(sw.half) self.__buffer.append(audio_phased) # The last <sw.half> samples are not valid (the window has not yet # been closed). These will be closed the next time we call step. # Advance our input tap self.__in_tap.advance(sw.hopsize(stretch_amount)) # append the audio output to our output buffer self.__buffer.append(audio_phased) return audio_phased[:sw.half] def fade_out(self): """Begin fading the stretch with each .step() .step should deactivate Caution: fade_out is currently implemeted in StretchGroup. See: https://github.com/CharlesHolbrow/realtime-fft-experiment/issues/4 """ self.__fading_out = True def activate(self): self.__fading_out = False self.tap.activate() def deactivate(self): self.clear() self.tap.deactivate() @property def fading_out(self): return self.__fading_out @fading_out.setter def fading_out(self, val): self.__fading_out = bool(val) @property def tap(self): return self.__in_tap def clear(self): self.__buffer.raw.fill(0.)
def campaign(c, background, stock, store): debug(c.DEBUG, "ENTERING: campaign") load_song(c, "It's Melting.ogg") versionID = stock.getVersion() # pygame.key.set_repeat(0, 0) allSprites = pygame.sprite.Group() ringSprite = pygame.sprite.GroupSingle() circSprites = pygame.sprite.LayeredUpdates() buttonSprites = pygame.sprite.Group() # @UnusedVariable starSprites = pygame.sprite.LayeredUpdates() caughtSprite = pygame.sprite.GroupSingle() dieingSprites = pygame.sprite.GroupSingle() scoreSprite = pygame.sprite.GroupSingle() pBox = playBox() # a jukebox for handling music settings. ring = Ring(c.CENTER, stock.campaign["Ring"], stock.campaign["Ring Glow"], c.FULLSCREEN) '''CREATE IMAGES''' ring.add(ringSprite, allSprites) scoreboard = Scoreboard(c.DISPLAY_W, c.DISPLAY_H) scoreboard.add(scoreSprite, allSprites) box_img = stock.campaign["RGB Light"] background_rect = background.get_rect() background_rect.center = c.CENTER OGBackground = background.copy() '''INSTANTIATING OTHER VARIABLES''' rotAngle = 0 # background rotation angle waitCounterCirc = 0 waitCounterStar = 0 circleWaitStart = 0 circleWaitMade = 0 starWaitStart = 0 starWaitMade = 0 finishedCircleActions = False finishedStarActions = False circleAction = '_' starAction = '_' counter = 0 starWaiting = False circleWaiting = False pauseStartTime = None #datetime variable pauseEndTime = None #datetime variable r = 0 g = 0 b = 0 pause_selection = 0 gamePaused = False total_input = 0 fpsList = [] toggle_color_r = False toggle_color_g = False toggle_color_b = False display_sprites = True controls = c.CONTROL_LIST leftHold = False rightHold = False upHold = False downHold = False #quitGame = False # if user returns a True from pause, we quit game, etc. startTime = 0 genList = os.path.join(c.DATA_DIR, 'campaign_commands/genCommands.txt') circleList = os.path.join(c.DATA_DIR, 'campaign_commands/circleCommands.txt') starList = os.path.join(c.DATA_DIR, 'campaign_commands/starCommands.txt') genList, circleList, starList = commander(c, genList, circleList, starList) # commander takes the # commands.txt and converts it into a formatted list. circleList, starList = iter(circleList), iter(starList) # take in the genList parameters now, before the level begins. for loop in range(len(genList)): setting = genList[loop] if setting[0] == 'B': # if the command is BPM, set the proper variables. pBox.cWait = setting[1] pBox.fWait = setting[2] pBox.cSpeed = setting[3] pBox.fSpeed = setting[4] elif setting[0] == 'J': __startTime = setting[1] #different startTime, unused # change the general speed for circles/stars elif setting[0][0] == 'W': if setting[0] == 'WG': pBox.cWait = setting[1] pBox.fWait = setting[1] elif setting[0] == 'WC': pBox.cWait = setting[1] elif setting[0] == 'WF': pBox.fWait = setting[1] """BUTTON / SPRITE RENDERING""" r_letter = c.FONT_LARGE.render('R', True, c.RED) r_letter.scroll(2, 0) r_letter_rect = r_letter.get_rect() r_letter_rect.center = (c.CENTER_X - 50, (c.CENTER_Y * 2) - 20) box_rectR = r_letter_rect g_letter = c.FONT_LARGE.render('G', True, c.GREEN) g_letter.scroll(1, 0) g_letter_rect = g_letter.get_rect() g_letter_rect.center = (c.CENTER_X, (c.CENTER_Y * 2) - 20) box_rectG = g_letter_rect b_letter = c.FONT_LARGE.render('B', True, c.BLUE) b_letter.scroll(2, 0) b_letter_rect = b_letter.get_rect() b_letter_rect.center = (c.CENTER_X + 50, (c.CENTER_Y * 2) - 20) box_rectB = b_letter_rect debug(c.DEBUG, "Variable and object instantiating successful.") showSplashScreen(c, stock) songLength = store.music["Spicy Chips"].get_length() #pygame.mixer.music.set_endevent(USEREVENT) debug(c.DEBUG, "Song loading successful, main game loop about to begin.") # --Main Game Loop//-- playing_campaign = True startTime = datetime.datetime.now() pygame.mixer.music.play() while playing_campaign: counter += 1 waitCounterCirc += 1 waitCounterStar += 1 # Paint the background c.DISPLAYSURFACE.fill((0, 0, 0)) #c.DISPLAYSURFACE.blit(background, background_rect) #if not c.FULLSCREEN: # if counter%2 == 0: # background, background_rect, rotAngle = \ # rotateBackground(c.CENTER, OGBackground, counter, rotAngle) """LOGGING output information: FPS, event info, AA, etc.""" # for every 30 or FPS number of frames, print an average fps. fpsList.append(c.FPSCLOCK.get_fps()) if counter == (c.FPS): AverageFPS = mean(fpsList) debug(c.DEBUG, ("Average FPS: {0}".format(AverageFPS))) debug(c.DEBUG, ("Current Score: {0}".format(scoreboard.scoreString))) counter = 0 pygame.display.set_caption('RGB. FPS: {0}'.format(mean(fpsList))) fpsList = [] #=================================================================== # this includes other things that i feel like should only be done # once a second, to save computation time, such as song ending check #=================================================================== # test real quick to see if the song is over. deltaTime = (datetime.datetime.now() - startTime).total_seconds() if deltaTime > songLength: timeMessage = "SongTime: {0}, GameTIme: {1}".format( songLength, deltaTime) debug(c.DEBUG, timeMessage) pygame.mixer.music.stop() playing_campaign = False debug(c.DEBUG, "MUSIC ENDED, CAMPAIGN SESSION OVER") """TAKE ACTION COMMAND LIST""" # for every new action, if the wait was long enough, perform the action if not circleWaiting: if not finishedCircleActions: try: circleAction = circleList.next() except: finishedCircleActions = True # if the circleAction is to spawn a circle/star, gotta que it up. if circleAction[0] == 'C': circleWaiting = True # change the general speed for circles/stars elif circleAction[0] == 'CS': if circleAction[0] == 'CS': pBox.cSpeed = circleAction[1] elif circleAction[0][0] == 'W': if circleAction[0] == 'W': circleWaitStart = datetime.datetime.now() circleWaiting = True circleWaitMade = datetime.datetime.now( ) # time started waiting elif circleAction[0] == 'WC': pBox.cWait = circleAction[1] elif circleAction[0] == 'S': pygame.mixer.music.stop() playing_campaign = False if circleWaiting: # All main actions have to wait before they can be performed, # so once an action is read, waiting becomes True, and we test to # see if the time passed is valid for the given wait time. if circleAction[0] == 'C': if waitCounterCirc >= pBox.cWait: if circleAction[2] == '': # if there is no given speed, then it's the global # speed. . . tempSpeed = pBox.cSpeed else: tempSpeed = circleAction[2] tempColor = circleAction[1] debug(c.DEBUG, ("{0}'s speed: {1}".format(tempColor, tempSpeed))) tempCirc = Circle(stock.campaign['Circle'], c.CENTER, tempSpeed, tempColor, pBox.layer) tempCirc.add(circSprites, allSprites) circMade = datetime.datetime.now() #for debugging pBox.layer += 1 #determines which get drawn on top circleWaiting = False waitCounterCirc = 0 elif circleAction[0] == 'W': change = datetime.datetime.now() - circleWaitStart # if the action is to JUST wait x amount of time if change.total_seconds() >= circleAction[1] / c.FPS: circleWaiting = False totalWaitTime = datetime.datetime.now() - circleWaitMade debug(c.DEBUG, ("Wait Time: ", totalWaitTime.total_seconds())) waitCounterCirc = 0 if not starWaiting: if not finishedStarActions: try: starAction = starList.next() except: finishedStarActions = True if starAction[0] == 'F': starWaiting = True # change the general speed for circles/stars elif starAction[0] == 'FS': pBox.fSpeed = starAction[1] elif starAction[0][0] == 'W': if starAction[0] == 'W': starWaitStart = datetime.datetime.now() starWaiting = True starWaitMade = datetime.datetime.now( ) # for debug purposes elif starAction[0] == 'WF': pBox.fWait = starAction[1] elif starAction[0] == 'S': pygame.mixer.music.stop() playing_campaign = False if starWaiting: if starAction[0] == 'F': if waitCounterStar >= pBox.fWait: if starAction[2] == '': tempSpeed = pBox.fSpeed else: tempSpeed = starAction[2] tempAngle = starAction[1] images = (stock.campaign['Star Lit'], stock.campaign['Star Unlit']) tempStar = Star(images, c.CENTER, tempSpeed, tempAngle) tempStar.add(starSprites, allSprites) # no longer waiting, bring on the next starAction! starWaiting = False waitCounterStar = 0 elif starAction[0] == 'W': change = datetime.datetime.now() - starWaitStart # if the starAction is to JUST wait x amount of time if change.total_seconds() >= starAction[1] / c.FPS: starWaiting = False totalWaitTime = datetime.datetime.now() - starWaitMade debug(c.DEBUG, ("Wait Time: ", totalWaitTime.total_seconds())) waitCounterStar = 0 # we must also set the wait for the next starAction to 0, # or else the wait would be Wx + Wcircle/star. """EVENT HANDLING INPUT""" # grab all the latest input latest_events = pygame.event.get() for event in latest_events: if event.type == QUIT: playing_campaign = False pygame.quit() sys.exit() elif event.type == KEYDOWN and event.key == K_ESCAPE: if c.DEBUG: # quit game playing_campaign = False pygame.mixer.music.stop() else: # have to time how long pause takes, for the wait. pauseStartTime = datetime.datetime.now() pause_selection = pause(c, stock, c.DISPLAYSURFACE) pauseEndTime = datetime.datetime.now() pauseTotalTime = (pauseEndTime - pauseStartTime) starWaitStart += pauseTotalTime circleWaitStart += pauseTotalTime # --game-play events//-- elif event.type == KEYDOWN and event.key == controls[0]: r = 255 toggle_color_r = True total_input += 1 ring.glowColor((r, g, b)) elif event.type == KEYUP and event.key == controls[0]: r = 0 toggle_color_r = False total_input += -1 ring.glowColor((r, g, b)) elif event.type == KEYDOWN and event.key == controls[1]: g = 255 toggle_color_g = True total_input += 1 ring.glowColor((r, g, b)) elif event.type == KEYUP and event.key == controls[1]: g = 0 toggle_color_g = False total_input += -1 ring.glowColor((r, g, b)) elif event.type == KEYDOWN and event.key == controls[2]: b = 255 toggle_color_b = True total_input += 1 ring.glowColor((r, g, b)) elif event.type == KEYUP and event.key == controls[2]: b = 0 toggle_color_b = False total_input += -1 ring.glowColor((r, g, b)) # Ring Spinning elif event.type == KEYDOWN and event.key == controls[5]: leftHold = True if upHold: ring.spin('upleft') elif downHold: ring.spin('downleft') else: ring.spin('left') elif event.type == KEYUP and event.key == controls[5]: leftHold = False elif event.type == KEYDOWN and event.key == controls[6]: rightHold = True if upHold: ring.spin('upright') elif downHold: ring.spin('downright') else: ring.spin('right') elif event.type == KEYUP and event.key == controls[6]: rightHold = False elif event.type == KEYDOWN and event.key == controls[3]: upHold = True if leftHold: ring.spin('upleft') elif rightHold: ring.spin('upright') else: ring.spin('up') elif event.type == KEYUP and event.key == controls[3]: upHold = False elif event.type == KEYDOWN and event.key == controls[4]: downHold = True if leftHold: ring.spin('downleft') elif rightHold: ring.spin('downright') else: ring.spin('down') elif event.type == KEYUP and event.key == controls[4]: downHold = False #==================================== # --non-game-play events//-- #==================================== # if O is pressed, toggle context display -------TO BE REMOVED SOON elif event.type == KEYDOWN and event.key == K_o: if display_sprites == True: display_sprites = False else: display_sprites = True # if P is pressed, pause game. elif event.type == KEYUP and event.key == controls[7]: gamePaused = True """LOGGING of inputs""" if event.type == KEYDOWN or event.type == KEYUP: debug(c.DEBUG, (pygame.event.event_name(event.type), event.dict)) if pause_selection == 3: pygame.mixer.music.stop() playing_campaign = False return """CATCH CIRCLES MATCHING COLORS""" # catch matching circles!! for circle in circSprites.sprites(): if circle.catchable: # catchable becomes true when the circle comes in contact # with the ring. debug(c.DEBUG, (circle.color, (r, g, b))) circle.add(caughtSprite) circle.remove(circSprites) circle.catch() totalCircTime = datetime.datetime.now() - circMade """REPEATED POINTS HOLDING COLORS CAUGHT""" # every .1 seconds should add or remove points based on accuracy if not (caughtSprite.sprite is None): for circle in caughtSprite.sprites(): if circle.color == (r, g, b) and not (circle.dieing): debug(c.DEBUG, ("CIRCTIME: ", totalCircTime.total_seconds())) #if the circle is more than 1 color, than we give bonus if circle.color[0] + circle.color[1] + circle.color[ 2] > 255: scoreboard.addScore(40) else: scoreboard.addScore(20) circle.remove(caughtSprite) circle.add(dieingSprites) else: circle.remove(caughtSprite) circle.add(dieingSprites) scoreboard.addScore(-10) # a circle begins in circSprites, then hits the ring, gets caught, and # goes into "caughtSprite" group. From there, it tries to match with # the user's input, then dies and goes into the "dieingCircs" group. # the purpose of the last group is just to have it animate the fading # or "dieing" sequence before disappearing. for circle in dieingSprites.sprites(): circle.death() """DELETE FREE STARS SHOOTING""" for star in starSprites.sprites(): if star.travDist >= (264 - star.speed) and not (star.shooting): # this tests the stars' distance, once it's close enough. . . if not ((ringSprite.sprite.angle) % 360 == (star.angleDeg) % 360): debug(c.DEBUG, "Star Died at:") debug(c.DEBUG, ("Ring Angle: ", ringSprite.sprite.angle)) debug(c.DEBUG, ("Star Angle: ", star.angleDeg)) star.kill() scoreboard.addScore(-30) else: debug(c.DEBUG, "Star Made it at:") debug(c.DEBUG, ("Ring Angle: ", ringSprite.sprite.angle)) debug(c.DEBUG, ("Star Angle: ", star.angleDeg)) if star.shooting: # debug(c.DEBUG, 'I AM SHOOTING1!') # if the star has gone off the screen in the x or y direction # kill it and add points!! if star.pos[0] > c.DISPLAY_W or star.pos[0] < 0: star.kill() # debug(c.DEBUG, 'KILLED A STAR') scoreboard.addScore(50) elif star.pos[1] > c.DISPLAY_H or star.pos[1] < 0: star.kill() # debug(c.DEBUG, 'KILLED A STAR') scoreboard.addScore(50) # debug(c.DEBUG, ('Stars #: {0}'.format(len(starSprites.sprites()))) """DISPLAY SPRITE TOGGLE""" allSprites.update() if display_sprites == True: dieingSprites.draw(c.DISPLAYSURFACE) caughtSprite.draw(c.DISPLAYSURFACE) circSprites.draw(c.DISPLAYSURFACE) starSprites.draw(c.DISPLAYSURFACE) ringSprite.draw(c.DISPLAYSURFACE) if toggle_color_r: c.DISPLAYSURFACE.blit(r_letter, r_letter_rect) if toggle_color_g: c.DISPLAYSURFACE.blit(g_letter, g_letter_rect) if toggle_color_b: c.DISPLAYSURFACE.blit(b_letter, b_letter_rect) c.DISPLAYSURFACE.blit(box_img, box_rectR) c.DISPLAYSURFACE.blit(box_img, box_rectG) c.DISPLAYSURFACE.blit(box_img, box_rectB) scoreSprite.draw(c.DISPLAYSURFACE) c.DISPLAYSURFACE.blit(versionID, (0, 0)) """DELAY""" c.FPSCLOCK.tick_busy_loop(c.FPS) """UPDATE""" pygame.display.flip() # update() # have to time how long pause takes, for the wait. if gamePaused: pauseStartTime = datetime.datetime.now() pause_selection = pause(c, stock, pygame.display.get_surface()) pauseEndTime = datetime.datetime.now() pauseTotalTime = (pauseEndTime - pauseStartTime) starWaitStart += pauseTotalTime circleWaitStart += pauseTotalTime gamePaused = False return
def __init__(self, ring_name, module_id): Ring.__init__(self, ring_name, module_id, Tracebuf2Message)
# game object, use ring to keep game running from card import Deck, Cards from player import Player from ring import Ring from time import sleep deck = Deck() disP = Cards() p1 = Player("A", deck, disP) p2 = Player("B", deck, disP) players = Ring([p1, p2]) turn = 0 while True: turn = turn + 1 print("turn#%d " % turn, end='') players.now().action() players.goNext() sleep(1)
from kuju import Kuju from ruut import Ruut from kolmnurk import Kolmnurk from ring import Ring kuju = Kuju() ruut = Ruut(2) kolmnurk = Kolmnurk(5, 2) ring = Ring(5) print(kuju) print(ruut) print(kolmnurk) print(ring) print("kuju pindala " + str(kuju.pindala())) print("ruut pindala " + str(ruut.pindala())) print("kolmnurga pindala " + str(kolmnurk.pindala())) print("ringi pindala " + str(ring.pindala()))
def add_ring(self): r = Ring(self.size) r.position = (self.size.width + self.new_pipe_trigger / 2 + Pipe.blocksize / 2, r.position.y) self.add_child(r) self.rings.append(r)
from ring import Ring inp = [int(l.strip()) for l in open('input.txt').read()] inp.extend(range(max(inp) + 1, 10**6 + 1)) r = Ring(inp) curr = r.find(inp[0]) inp_min = min(inp) for i in range(10**7): tmp = r.remove(curr.nxt.val, 2) destination_val = curr.val - 1 while not r.has(destination_val): destination_val -= 1 if destination_val < inp_min: destination_val = r.get_max_val() break r.insert(destination_val, tmp) curr = curr.nxt one = r.find(1) print(one.nxt.val * one.nxt.nxt.val)
def gameSummary(self, p1peer, p2peer, s1peer, winner): p1key = p1peer[2].publickey if p1peer[2] is not None else self.main.getPublicKey() p2key = p2peer[2].publickey if p2peer[2] is not None else self.main.getPublicKey() s1key = s1peer[2].publickey if s1peer[2] is not None else self.main.getPublicKey() scoreJsonHash, scoreJson = self.createScoreFile(p1peer, p2peer, s1peer, winner) myprivateKey = self.main.rsaKey; if p1peer[2] is None: #create two ring with both player and sign it and send it to the other two ringP1P2 = Ring([p1key, p2key], 2048) ringP1S1 = Ring([p1key, s1key], 2048) signp1p2 = ringP1P2.sign(scoreJsonHash, myprivateKey); signp1s1 = ringP1S1.sign(scoreJsonHash, myprivateKey); signs = [{"player1:player2": signp1p2}, {"player1:spectator": signp1s1}] if p2peer[2] is None: ringP1P2 = Ring([p1key, p2key], 2048) ringP2S1 = Ring([p2key, s1key], 2048) signp1p2 = ringP1P2.sign(scoreJsonHash, myprivateKey); signp2s1 = ringP2S1.sign(scoreJsonHash, myprivateKey); signs = [{"player1:player2": signp1p2}, {"player2:spectator": signp2s1}] if s1peer[2] is None: ringP1S1 = Ring([p1key, s1key], 2048) ringP2S1 = Ring([p2key, s1key], 2048) signp1s1 = ringP1S1.sign(scoreJsonHash, myprivateKey); signp2s1 = ringP2S1.sign(scoreJsonHash, myprivateKey); signs = [{"player1:spectator": signp1s1}, {"player2:spectator": signp2s1}] self.summary = [{"result": scoreJson, "sha256": scoreJsonHash, "sign": signs[0] },{"result": scoreJson, "sha256": scoreJsonHash, "sign": signs[1] }] print ">>>>>>>Summary ready<<<<<<<"; self.webclient.sendMessage(WebSocketMessage.create ("local","TTTS_GAME_OVER_MSGS","Game Result Object [" + str(scoreJsonHash) + "] created and signed")) #print "<<Results>>" #print summary #print if p1peer[2] is None: self.main.sendMulticast("SIGN_RESULT") signedResults = self.summary self.main.sendMulticast("RESULT_RING " + json.dumps(signedResults[0])) self.main.sendMulticast("RESULT_RING " + json.dumps(signedResults[1]))
class Note(object): # CONSTANTS semitoneFactor = math.exp(math.log(2)/12.0) middleCFreq = 261.62556530059868 CFreq_1 = middleCFreq/2 # 130.81278265029934 Hertz CFreq_2 = CFreq_1/2 # 65.40639132514967 Hertz CFreq_3 = CFreq_2/2 # 32.70319566257484 Hertz CFreq_4 = CFreq_3/2 # 16.351597831287421 Hertz alternateNoteDict = { } def __init__(self, NOTES, FREQ): self.ring = Ring() self.setNotes(NOTES) self.setAlternateNoteDict() self.accents = ['+', '-', ',', '.', '_', '^'] self.setFrequencyDictionary(self.CFreq_4, FREQ) def setNotes(self, NOTES): # List of note names self.notes = NOTES self.ring.pushList(self.notes) # return unique numerical index for each note token def index(self, token): # scale length: SL = len(self.notes) # parse root, infix, suffix = trisectToken(token) root = self.normalizedNote(root) # print "trisection["+token+"]:", root, infix, suffix # get index of bare note k = self.ring.index(root) if k < 0: return -1000 # add octave shifts if len(infix) > 0: octave = int(infix) - 1 else: octave = 0 octave += count('^', suffix) octave -= count('_', suffix) k = k + SL*octave # add semitione shifts s = count('+', suffix) s -= count('-', suffix) k += s return k def note(self, j): # return normalized note of index j # scale length: SL = len(self.notes) k = j % SL octave = j // SL if octave == 0: return self.notes[k] else: octave = octave + 1 return self.notes[k]+`octave` def isNote(self, token): root, suffix = splitToken(token) a = alphaPrefix(root) a = self.normalizedNote(a) if a in self.notes: return True else: return False def setAlternateNoteDict(self): self.alternateNoteDict = { "de":"ti", "ra":"di", "me":"ri", "fe":"mi", "se":"fi", "le":"si", "te":"li" } self.alternateNotes = self.alternateNoteDict.keys() def normalizedNoteData(self, x): y = alphaPrefix(x) root, suffix = splitToken(x) if y in self.alternateNoteDict.keys(): return self.alternateNoteDict[y]+suffix else: return y, suffix def normalizedNote(self, x): y = alphaPrefix(x) root, suffix = splitToken(x) if y in self.alternateNoteDict.keys(): return self.alternateNoteDict[y]+suffix else: return y+suffix def setFrequencyDictionary(self, baseFrequency, FREQ): self.noteFreq = FREQ self.noteFreq["x"] = 0.0 # x = rest def freq(self, token, nSemitoneShifts, octaveNumber): # Return frequency of note defined by token # base calculation root, suffix = splitToken(token) a = alphaPrefix(root) a = self.normalizedNote(a) f = self.noteFreq[a] # apply octave number for i in range(0, octaveNumber): f = 2*f # apply transpose register factor = pow(self.semitoneFactor, nSemitoneShifts); # print "factor:", factor f = f*factor # process upward octave shifts n = 0 np = numPrefix(token[len(a):]) if len(np) > 0: n = int(np[0:1])-1 else: n = 0 n += count('^', suffix) for i in range(0, n): f = 2.0*f # process downward octave shifts n = count('_', suffix) if n > 0: for i in range(0,n): f = f/2.0 # process semitone shifts n = count('+', suffix) - count('-', suffix) if n > 0: for i in range(0,n): f = f*self.semitoneFactor if n < 0: for i in range(0,-n): f = f/self.semitoneFactor return f, root, suffix # print dictionary def printNoteFreq(): j = 0 for N in note: print j, N, noteFreq[N] j = j + 1
def creative(c, background): debug(c.DEBUG, "ENTERING: creative") # display the version ID font_renderObj = c.FONT_SMALL.render(c.VERSION, False, c.BLACK, c.WHITE) versionID_SurfaceObj = font_renderObj versionID_RectObj = versionID_SurfaceObj.get_rect() versionID_RectObj.topleft = (0, 0) # pygame.key.set_repeat(0, 0) allSprites = pygame.sprite.Group() ringSprite = pygame.sprite.GroupSingle() scoreSprite = pygame.sprite.GroupSingle() '''CREATE IMAGES''' ring = Ring(c, c.CENTER) ring.add(ringSprite, allSprites) scoreboard = Scoreboard(c.DISPLAY_W, c.DISPLAY_H) scoreboard.add(scoreSprite, allSprites) box_img, _box_rect = load_image(c, 'letter_box.png') background_rect = background.get_rect() background_rect.center = c.CENTER OGBackground = background.copy() logging = False '''INSTANTIATING OTHER VARIABLES''' dataDir = os.path.join(c.DATA_DIR, 'newCommands.txt') frameCount = 0 # tracks the number of frames passed. bgRotAngle = 0 # background rotation angle logFile = file testFrame = 0 newAction = True r = 0 g = 0 b = 0 paused = False fpsList = [] toggle_color_r = False toggle_color_g = False toggle_color_b = False display_sprites = True controls = c.CONTROL_LIST leftHold = False rightHold = False upHold = False downHold = False quitGame = False # if user returns a True from pause, we quit game, etc. firstAction = True """BUTTON / SPRITE RENDERING""" r_letter = c.FONT_LARGE.render('R', True, c.RED) r_letter.scroll(2, 0) r_letter_rect = r_letter.get_rect() r_letter_rect.center = (c.CENTER_X - 50, (c.CENTER_Y * 2) - 20) box_rectR = r_letter_rect g_letter = c.FONT_LARGE.render('G', True, c.GREEN) g_letter.scroll(1, 0) g_letter_rect = g_letter.get_rect() g_letter_rect.center = (c.CENTER_X, (c.CENTER_Y * 2) - 20) box_rectG = g_letter_rect b_letter = c.FONT_LARGE.render('B', True, c.BLUE) b_letter.scroll(2, 0) b_letter_rect = b_letter.get_rect() b_letter_rect.center = (c.CENTER_X + 50, (c.CENTER_Y * 2) - 20) box_rectB = b_letter_rect # throw down splash screen before beginning splashInfo, splashInfo_rect = load_image(c, 'splashInfo.png') # adjusting image cuz i can't make images. splashInfo_rect.center = (c.CENTER_X - 50, c.CENTER_Y) # fade info in and out fade = 0 pgext.color.setAlpha(splashInfo, fade, 1) pygame.event.clear() # fade in inInfoScreen = True for fade in range(255): c.DISPLAYSURFACE.fill((0, 0, 0)) c.DISPLAYSURFACE.blit(splashInfo, splashInfo_rect) pgext.color.setAlpha(splashInfo, fade, 1) c.DISPLAYSURFACE.blit(versionID_SurfaceObj, versionID_RectObj) pygame.display.flip() if pygame.event.poll().type != NOEVENT: inInfoScreen = False break # if the info is still being read/no button pressed, just wait. while inInfoScreen: if pygame.event.poll().type != NOEVENT: inInfoScreen = False fade = 255 pgext.color.setAlpha(splashInfo, fade, 1) load_song(c, "It's Melting.ogg") # stops other music from playing too cmdFile = open(dataDir, 'w') cmdFile.write("BPM60 Play:") # --Main Game Loop//-- going = True while going: # Paint the background c.DISPLAYSURFACE.fill((0,0,0)) c.DISPLAYSURFACE.blit(background, background_rect) """ROTATION TESTING""" # rotate the background, but only 15 times/second, not 30. # if the frame rate is 30/sec, then rotate when its an odd frame. if frameCount%3 == 0: bgRotAngle += .03 background = pygame.transform.rotozoom(OGBackground, bgRotAngle%360 , 1) background_rect = background.get_rect() background_rect.center = c.CENTER frameCount += 1 """LOGGING output information: FPS, event info, AA, etc.""" # for every 30 or FPS number of frames, print an average fps. fpsList.append(c.FPSCLOCK.get_fps()) if testFrame == c.FPS: debug(c.DEBUG, ("Average FPS: {0}".format(mean(fpsList)))) debug(c.DEBUG, ("Current Score: {0}".format(scoreboard.scoreString))) testFrame = 0 pygame.display.set_caption('RGB. FPS: {0}'.format(mean(fpsList))) fpsList = [] """Start the Song!""" beginning = True if beginning: pygame.mixer.music.play() beginning = False # record the beginning, since no action causes a new time recording counter.setTime(1) """EVENT HANDLING INPUT""" # grab all the latest input latest_events = pygame.event.get() for event in latest_events: if (event.type == KEYDOWN or event.type == KEYUP) and \ (event.key in controls) and firstAction: # this is the very first action, and its a correct input, # we put a Wait action in, since there was nothing before the # first action to tell us otherwise. cmdFile.write(' W%d'%counter.getDelta(True)) # so we write how long it took to do the action above counter.setTime(1) # if any button is pressed, a change must be written in. . . firstAction = False if event.type == QUIT: going = False pygame.quit() sys.exit() elif event.type == KEYDOWN and event.key == K_ESCAPE: if c.DEBUG: going = False else: paused = True # --game-play events//-- elif event.type == KEYDOWN and event.key == controls[0]: # default key is R r = 255 toggle_color_r = True elif event.type == KEYUP and event.key == controls[0]: r = 0 toggle_color_r = False elif event.type == KEYDOWN and event.key == controls[1]: # default key is G g = 255 toggle_color_g = True elif event.type == KEYUP and event.key == controls[1]: g = 0 toggle_color_g = False elif event.type == KEYDOWN and event.key == controls[2]: # default key is B b = 255 toggle_color_b = True elif event.type == KEYUP and event.key == controls[2]: b = 0 toggle_color_b = False # Ring Spinning elif event.type == KEYDOWN and event.key == controls[5]: leftHold = True if upHold: ring.spin('upleft') elif downHold: ring.spin('downleft') else: ring.spin('left') elif event.type == KEYUP and event.key == controls[5]: leftHold = False elif event.type == KEYDOWN and event.key == controls[6]: rightHold = True if upHold: ring.spin('upright') elif downHold: ring.spin('downright') else: ring.spin('right') elif event.type == KEYUP and event.key == controls[6]: rightHold = False elif event.type == KEYDOWN and event.key == controls[3]: upHold = True if leftHold: ring.spin('upleft') elif rightHold: ring.spin('upright') else: ring.spin('up') elif event.type == KEYUP and event.key == controls[3]: upHold = False elif event.type == KEYDOWN and event.key == controls[4]: downHold = True if leftHold: ring.spin('downleft') elif rightHold: ring.spin('downright') else: ring.spin('down') elif event.type == KEYUP and event.key == controls[4]: downHold = False #==================================== # --non-game-play events//-- #==================================== # if O is pressed, toggle context display -------TO BE REMOVED SOON elif event.type == KEYDOWN and event.key == K_o: if display_sprites == True: display_sprites = False else: display_sprites = True # if P is pressed, pause game. elif event.type == KEYUP and event.key == controls[7]: paused = True """LOGGING of inputs""" if event.type == KEYDOWN or event.type == KEYUP: debug(c.DEBUG, event.dict) """DISPLAY SPRITE TOGGLE""" allSprites.update() if display_sprites == True: if toggle_color_r: c.DISPLAYSURFACE.blit(r_letter, r_letter_rect) if toggle_color_g: c.DISPLAYSURFACE.blit(g_letter, g_letter_rect) if toggle_color_b: c.DISPLAYSURFACE.blit(b_letter, b_letter_rect) c.DISPLAYSURFACE.blit(box_img, box_rectR) c.DISPLAYSURFACE.blit(box_img, box_rectG) c.DISPLAYSURFACE.blit(box_img, box_rectB) scoreSprite.draw(c.DISPLAYSURFACE) c.DISPLAYSURFACE.blit(versionID_SurfaceObj, versionID_RectObj) """DELAY""" c.FPSCLOCK.tick_busy_loop(c.FPS) """PAUSE UNPAUSE""" if paused: pygame.mixer.music.pause() quitGame = pauseScreen(c) if quitGame == 3: going = False pygame.mixer.music.unpause() paused = False """UPDATE""" pygame.display.flip() # update() try: cmdFile.close() except Exception: debug(c.DEBUG, "File never opened") return
from neuron import h from neuron.units import ms, mV import matplotlib.pyplot as plt from ring import Ring ring = Ring() pc = h.ParallelContext() pc.set_maxstep(10 * ms) t = h.Vector().record(h._ref_t) h.finitialize(-65 * mV) pc.psolve(100 * ms) # send all spike time data to node 0 local_data = {cell._gid: list(cell.spike_times) for cell in ring.cells} all_data = pc.py_alltoall([local_data] + [None] * (pc.nhost() - 1)) if pc.id() == 0: # combine the data from the various processes data = {} for process_data in all_data: data.update(process_data) # plot it plt.figure() for i, spike_times in data.items(): plt.vlines(spike_times, i + 0.5, i + 1.5) plt.show() pc.barrier() pc.done()