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 __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 __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 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 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 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]))
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 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 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)
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 __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 __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 test_ring_size(self): ring = Ring(1) self.assertEqual(str(ring), '1')
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)
# 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)
def creative(c, background, stock, store): debug(c.DEBUG, "ENTERING: campaign") versionID = stock.getVersion() timeClock = clockCounter() 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. pygame.mixer.music.set_endevent(USEREVENT) 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 countingCircleTime = False countingStarTime = False countingWaitTime = False totalWaitTime = 0 totalCircleTime = 0 totalStarTime = 0 newStartTime = 0 oldStartTime = 0 pause_selection = 0 newCircleColor = '' oldCircleColor = '' newStarAngle = '' oldStarAngle = '' circleWaitStart = 0 circleWaitMade = 0 circleColor = '' starWaitStart = 0 starWaitMade = 0 pauseStartTime = None #datetime variable pauseEndTime = None #datetime variable finishedCircleActions = False finishedStarActions = False circleAction = '_' starAction = '_' counter = 0 starWaiting = False circleWaiting = False countingWaitTime = False r = 0 g = 0 b = 0 paused = 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 newInput = True currentColor = (0, 0, 0) colorList = "" # open the files that we'll be saving to. genFile = os.path.join(c.DATA_DIR, 'creative_commands/genCommands.txt') circleFile = os.path.join(c.DATA_DIR, 'creative_commands/circleCommands.txt') starFile = os.path.join(c.DATA_DIR, 'creative_commands/starCommands.txt') genFile = open(genFile, 'w') circleFile = open(circleFile, 'w') starFile = open(starFile, 'w') """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 stageDisplay = stock.creative["Circle Building"] stageDisplay_rect = stageDisplay.get_rect() stageDisplay_rect.topright = (c.DISPLAY_W, 0) debug(c.DEBUG, "Variable and object instantiating successful.") showSplashScreen(c, stock) load_song(c, "It's Melting.ogg") # stops other music from playing too debug(c.DEBUG, "Stars and Circles ready! ") debug(c.DEBUG, "Now building Circles") # --CIRCLE MAKING Loop//-- going = True pygame.mixer.music.play(0, 0) timeClock.playTimeSet() while going: counter += 1 # Paint the background c.DISPLAYSURFACE.fill((0, 0, 0)) c.DISPLAYSURFACE.blit(background, background_rect) if counter % 5 == 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 * 5): debug(c.DEBUG, ("Average FPS: {0}".format(mean(fpsList)))) debug(c.DEBUG, ("Current Score: {0}".format(scoreboard.scoreString))) counter = 0 pygame.display.set_caption('RGB. FPS: {0}'.format(mean(fpsList))) fpsList = [] #======================================================================= # """Get input to know if we should put in a wait action""" # if total_input == 0: # if not countingWaitTime: # debug(c.DEBUG, "STARTING COUNT WAIT TIME") # countingWaitTime = True # timeClock.setTime(1) #======================================================================= if newCircleColor != '': oldCircleColor = newCircleColor """EVENT HANDLING INPUT""" # grab all the latest input latest_events = pygame.event.get() for event in latest_events: if event.type == QUIT: going = False pygame.quit() sys.exit() elif event.type == KEYDOWN and event.key == K_ESCAPE: if c.DEBUG: going = False pygame.mixer.music.stop() #=============================================================== # else: # # have to time how long pause takes, for the wait. # pauseStartTime = datetime.datetime.now() # pause_selection = pause() # pauseEndTime = datetime.datetime.now() # pauseTotalTime = (pauseEndTime - pauseStartTime) # starWaitStart = starWaitStart + pauseTotalTime # circleWaitStart = circleWaitStart + pauseTotalTime #=============================================================== # --game-play events//-- elif event.type == KEYDOWN and event.key == controls[0]: r = 255 toggle_color_r = True total_input += 1 colorList += 'R' elif event.type == KEYUP and event.key == controls[0]: r = 0 toggle_color_r = False total_input += -1 colorList = colorList.replace('R', '') elif event.type == KEYDOWN and event.key == controls[1]: g = 255 toggle_color_g = True total_input += 1 colorList += 'G' elif event.type == KEYUP and event.key == controls[1]: g = 0 toggle_color_g = False total_input += -1 colorList = colorList.replace('G', '') elif event.type == KEYDOWN and event.key == controls[2]: b = 255 toggle_color_b = True total_input += 1 colorList += 'B' elif event.type == KEYUP and event.key == controls[2]: b = 0 toggle_color_b = False total_input += -1 colorList = colorList.replace('B', '') #==================================== # --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 elif event.type == KEYDOWN and event.key == K_s: # add ten seconds to the total playtime. pygame.mixer.music.stop() newStartTime = (datetime.datetime.now() - timeClock.playTime ).total_seconds() + 10 + oldStartTime # since the song is now 10 seconds ahead, we have to make sure there is a 10 second difference # in recording of actions. timeClock.timeIn = timeClock.timeIn - datetime.timedelta( seconds=10) pygame.mixer.music.play(0, newStartTime) # need to record where we last began. oldStartTime = newStartTime debug(c.DEBUG, "new Start Time: %f" % newStartTime) # if P is pressed, pause game. elif event.type == KEYUP and event.key == controls[7]: None #=============================================================== # # have to time how long pause takes, for the wait. # pauseStartTime = datetime.datetime.now() # pause_selection = pause() # pauseEndTime = datetime.datetime.now() # pauseTotalTime = (pauseEndTime - pauseStartTime) # starWaitStart = starWaitStart + pauseTotalTime # circleWaitStart = circleWaitStart + pauseTotalTime #=============================================================== """LOGGING of inputs""" if event.type == KEYDOWN or event.type == KEYUP: debug(c.DEBUG, (pygame.event.event_name(event.type), event.dict)) debug(c.DEBUG, "NEWINPUT FOUND") newInput = True newCircleColor = colorList # grab color at time of recording. if pygame.event.peek(USEREVENT): going = False if pause_selection == 3: going = False return #if an action has been input, test total_inputs: """Get input to know if we should put in a wait action""" if not (total_input == 0): if countingWaitTime: countingWaitTime = False totalWaitTime = timeClock.getDelta(True) debug(c.DEBUG, "Old wait time recorded") circleFile.write(" W{0} ".format(totalWaitTime + totalCircleTime)) # if it isn't counting wait time, then it IS counting circleTime countingCircleTime = True debug(c.DEBUG, "Now counting circle time") timeClock.setTime(1) # newInput is set to false, since we already know its a new # input based on change in counting. newInput is only # relevant for when the circle color changes without a wait # in between. newInput = False else: if countingCircleTime: if newInput: #first, we must store the old input. totalCircleTime = timeClock.getDelta(True) circleFile.write(" C{0},{1} ".format( oldCircleColor, totalCircleTime)) # a wait time must be introduced so that other circles # don't spawn. circleFile.write(" W{0} ".format(totalCircleTime)) newInput = False debug(c.DEBUG, "Old circle time recorded") debug(c.DEBUG, "New circle time recording") #now we start the new Input recording.. timeClock.setTime(1) else: if not countingWaitTime: if countingCircleTime: totalCircleTime = timeClock.getDelta(True) circleFile.write(" C{0},{1} ".format( oldCircleColor, totalCircleTime)) newInput = False debug(c.DEBUG, "Old circle time recorded") countingCircleTime = False else: debug(c.DEBUG, "Now counting wait time") countingWaitTime = True timeClock.setTime(1) elif not (going): totalWaitTime = timeClock.getDelta(True) circleFile.write(" W{0} ".format(totalWaitTime)) """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) c.DISPLAYSURFACE.blit(stageDisplay, stageDisplay_rect) scoreSprite.draw(c.DISPLAYSURFACE) c.DISPLAYSURFACE.blit(versionID, (0, 0)) """DELAY""" c.FPSCLOCK.tick_busy_loop(c.FPS) """UPDATE""" pygame.display.flip() # update() circleFile.close() if quitGame == 3: return debug(c.DEBUG, "Now building Stars") """Reinitializing Variables.""" newStartTime = 0 oldStartTime = 0 stageDisplay = stock.creative["Star Building"] stageDisplay_rect = stageDisplay.get_rect() stageDisplay_rect.topright = (c.DISPLAY_W, 0) # --STAR MAKING Loop//-- going = True pygame.mixer.music.play(0, 0) timeClock.playTimeSet() while going: counter += 1 # Paint the background c.DISPLAYSURFACE.fill((0, 0, 0)) c.DISPLAYSURFACE.blit(background, background_rect) if counter % 5 == 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 * 5): debug(c.DEBUG, ("Average FPS: {0}".format(mean(fpsList)))) debug(c.DEBUG, ("Current Score: {0}".format(scoreboard.scoreString))) counter = 0 pygame.display.set_caption('RGB. FPS: {0}'.format(mean(fpsList))) fpsList = [] #======================================================================= # """Get input to know wif we should put in a wait action""" # if total_input == 0: # if not countingWaitTime: # debug(c.DEBUG, "STARTING COUNT WAIT TIME") # countingWaitTime = True # timeClock.setTime(1) #======================================================================= if newStarAngle != '': oldStarAngle = newStarAngle """EVENT HANDLING INPUT""" # grab all the latest input latest_events = pygame.event.get() for event in latest_events: if event.type == QUIT: going = False pygame.quit() sys.exit() elif event.type == KEYDOWN and event.key == K_ESCAPE: if c.DEBUG: going = False pygame.mixer.music.stop() else: None #=========================================================== # # have to time how long pause takes, for the wait. # pauseStartTime = datetime.datetime.now() # pause_selection = pause() # pauseEndTime = datetime.datetime.now() # pauseTotalTime = (pauseEndTime - pauseStartTime) # starWaitStart = starWaitStart + pauseTotalTime # circleWaitStart = circleWaitStart + pauseTotalTime #=========================================================== # --game-play events//-- # Ring Spinning elif event.type == KEYDOWN and event.key == controls[5]: total_input += 1 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 total_input += -1 elif event.type == KEYDOWN and event.key == controls[6]: rightHold = True total_input += 1 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 total_input += -1 elif event.type == KEYDOWN and event.key == controls[3]: upHold = True total_input += 1 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 total_input += -1 elif event.type == KEYDOWN and event.key == controls[4]: downHold = True total_input += 1 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 total_input += -1 #==================================== # --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 elif event.type == KEYDOWN and event.key == K_s: # add ten seconds to the total playtime. pygame.mixer.music.stop() newStartTime = (datetime.datetime.now() - timeClock.playTime ).total_seconds() + 10 + oldStartTime # since the song is now 10 seconds ahead, we have to make sure there is a 10 second difference # in recording of actions. timeClock.timeIn = timeClock.timeIn - datetime.timedelta( seconds=10) pygame.mixer.music.play(0, newStartTime) # need to record where we last began. oldStartTime = newStartTime debug(c.DEBUG, "new Start Time: %f" % newStartTime) # if P is pressed, pause game. elif event.type == KEYUP and event.key == controls[7]: None #=============================================================== # # have to time how long pause takes, for the wait. # pauseStartTime = datetime.datetime.now() # pause_selection = pause() # pauseEndTime = datetime.datetime.now() # pauseTotalTime = (pauseEndTime - pauseStartTime) # starWaitStart = starWaitStart + pauseTotalTime # circleWaitStart = circleWaitStart + pauseTotalTime #=============================================================== """LOGGING of inputs""" if event.type == KEYDOWN or event.type == KEYUP: debug(c.DEBUG, (pygame.event.event_name(event.type), event.dict)) debug(c.DEBUG, "NEWINPUT FOUND") newInput = True newStarAngle = ring.angle # grab angle at time of recording. if pygame.event.peek(USEREVENT): pygame.mixer.music.stop() going = False if pause_selection == 3: going = False return #if an action has been input, test total_inputs: """Get input to know if we should put in a wait action""" if not (total_input == 0): if countingWaitTime: countingWaitTime = False totalWaitTime = timeClock.getDelta(True) debug(c.DEBUG, "Old wait time recorded") starFile.write(" W{0} ".format(totalWaitTime + totalStarTime)) # if it isn't counting wait time, then it IS counting circleTime countingStarTime = True debug(c.DEBUG, "Now counting star time") timeClock.setTime(1) # newInput is set to false, since we already know its a new # input based on change in counting. newInput is only # relevant for when the circle color changes without a wait # in between. newInput = False else: if countingStarTime: if newInput: #first, we must store the old input. totalStarTime = timeClock.getDelta(True) starFile.write(" F{0},{1} ".format( oldStarAngle, totalStarTime)) # a wait time must be introduced so that other circles # don't spawn. starFile.write(" W{0} ".format(totalStarTime)) newInput = False debug(c.DEBUG, "Old star time recorded") debug(c.DEBUG, "New star time recording") #now we start the new Input recording.. timeClock.setTime(1) else: if not countingWaitTime: if countingStarTime: totalStarTime = timeClock.getDelta(True) starFile.write(" F{0},{1} ".format(oldStarAngle, totalStarTime)) newInput = False debug(c.DEBUG, "Old star time recorded") countingStarTime = False else: debug(c.DEBUG, "Now counting wait time") countingWaitTime = True timeClock.setTime(1) elif not (going): totalWaitTime = timeClock.getDelta(True) starFile.write(" W{0} ".format(totalWaitTime)) """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) c.DISPLAYSURFACE.blit(stageDisplay, stageDisplay_rect) scoreSprite.draw(c.DISPLAYSURFACE) c.DISPLAYSURFACE.blit(versionID, (0, 0)) """DELAY""" c.FPSCLOCK.tick_busy_loop(c.FPS) """UPDATE""" pygame.display.flip() # update() starFile.close() if quitGame == 3: return debug(c.DEBUG, "Showing built commands") """REINITIALIZING""" stageDisplay = stock.creative["Build Testing"] stageDisplay_rect = stageDisplay.get_rect() stageDisplay_rect.topright = (c.DISPLAY_W, 0) genList = os.path.join(c.DATA_DIR, 'creative commands/genCommands.txt') circleList = os.path.join(c.DATA_DIR, 'creative commands/circleCommands.txt') starList = os.path.join(c.DATA_DIR, 'creative 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] # 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] # --Main Game Loop//-- going = True pygame.mixer.music.play(0, startTime) while going: counter += 1 waitCounterCirc += 1 waitCounterStar += 1 # Paint the background c.DISPLAYSURFACE.fill((0, 0, 0)) c.DISPLAYSURFACE.blit(background, background_rect) if counter % 5 == 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 * 5): debug(c.DEBUG, ("Average FPS: {0}".format(mean(fpsList)))) debug(c.DEBUG, ("Current Score: {0}".format(scoreboard.scoreString))) counter = 0 pygame.display.set_caption('RGB. FPS: {0}'.format(mean(fpsList))) fpsList = [] """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() going = 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() elif starAction[0] == 'WF': pBox.fWait = starAction[1] elif starAction[0] == 'S': pygame.mixer.music.stop() going = 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] / 30.0: 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. # test real quick to see if the song is over. if pygame.event.peek(USEREVENT): pygame.mixer.music.stop() going = False if pause_selection == 3: going = False return """EVENT HANDLING INPUT""" # grab all the latest input latest_events = pygame.event.get() for event in latest_events: 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: # have to time how long pause takes, for the wait. pauseStartTime = datetime.datetime.now() pause_selection = pause() pauseEndTime = datetime.datetime.now() pauseTotalTime = (pauseEndTime - pauseStartTime) starWaitStart = starWaitStart + pauseTotalTime circleWaitStart = circleWaitStart + pauseTotalTime # --game-play events//-- elif event.type == KEYDOWN and event.key == controls[0]: r = 255 toggle_color_r = True total_input += 1 elif event.type == KEYUP and event.key == controls[0]: r = 0 toggle_color_r = False total_input += -1 elif event.type == KEYDOWN and event.key == controls[1]: g = 255 toggle_color_g = True total_input += 1 elif event.type == KEYUP and event.key == controls[1]: g = 0 toggle_color_g = False total_input += -1 elif event.type == KEYDOWN and event.key == controls[2]: b = 255 toggle_color_b = True total_input += 1 elif event.type == KEYUP and event.key == controls[2]: b = 0 toggle_color_b = False total_input += -1 # 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]: # have to time how long pause takes, for the wait. pauseStartTime = datetime.datetime.now() pause_selection = pause() pauseEndTime = datetime.datetime.now() pauseTotalTime = (pauseEndTime - pauseStartTime) starWaitStart = starWaitStart + pauseTotalTime circleWaitStart = circleWaitStart + pauseTotalTime """LOGGING of inputs""" if event.type == KEYDOWN or event.type == KEYUP: debug(c.DEBUG, (pygame.event.event_name(event.type), event.dict)) """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) c.DISPLAYSURFACE.blit(stageDisplay, stageDisplay_rect) scoreSprite.draw(c.DISPLAYSURFACE) c.DISPLAYSURFACE.blit(versionID, (0, 0)) """DELAY""" c.FPSCLOCK.tick_busy_loop(c.FPS) """UPDATE""" pygame.display.flip() # update() return
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 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
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 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()
from threading import Thread from node import Node from ring import Ring from config import bootstrap_ip, bootstrap_port, K_replicas, type_replicas from utils import ( insert_node_to_ring, get_data_from_next_node, get_node_hash_id, between, hashing, hexToInt, call_update_data, forward_replicas_to_next_node, delete_replicas_in_next_nodes ) import requests import argparse app = Flask(__name__) ring = Ring(bootstrap_ip, bootstrap_port) node = Node() @app.route('/insert', methods=['POST']) def insert(): """ This is a route for ALL NODES. The client sends POST requests to this route so that new key-value pairs are inserted. In the case of "eventual consistency", the client gets a response to the request after the primary replica of the key-value pair is inserted. The other replicas are inserted by a thread, without blocking the response to the client.
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
r.split_colors(Colors.RED,Colors.WARMWHITE, start) elif cols == 4: r.split_colors(Colors.BLUE,Colors.WARMWHITE, start) elif cols == 5: r.split_colors(Colors.RED,Colors.GREEN, start) elif cols == 6: r.split_colors(Colors.RED,Colors.BLUE, start) elif cols == 7: r.split_colors(Colors.RED,Colors.YELLOW, start) elif cols == 8: r.split_colors(Colors.BLUE,Colors.YELLOW, start) elif cols == 9: r.split_colors(Colors.ORANGE,Colors.GREEN, start) else: r.split_colors(Colors.BLUE,Colors.BLACK, start) r.set_brightness(get_value(pot1)*.7) elif mode == 4: r.fill(Colors.wheel(get_byte_value(pot2))) r.set_brightness(get_value(pot1)*.7) elif mode == 5: col1 = Colors.wheel(get_byte_value(pot2)) col2 = Colors.wheel(get_byte_value(pot3)) r.blend_colors(col1,col2) r.set_brightness(get_value(pot1)*.7) else: r.fill(Colors.BLACK) if __name__ == '__main__': r = Ring(60) #ready() main()
def set_rings(self, number_of_rings): RING_RANGE = range(number_of_rings + 1, 1, -1) pinOne = self.pins[0] for ring_size in RING_RANGE: ring = Ring(ring_size) pinOne.insert_ring(ring)
def test(): a = Ring(4) a.append([1, 2]) assert np.all(a.raw == [1, 2, 0, 0]) a.append([3, 4]) assert np.all(a.raw == [1, 2, 3, 4]) a.append([5]) assert np.all(a.raw == [5, 2, 3, 4]) a.append([6, 7]) a.append([8, 9]) assert np.all(a.raw == [9, 6, 7, 8]) a.append([10, 11]) assert np.all(a.raw == [9, 10, 11, 8]) # test getitem a = Ring(4) a.append([0, 1, 2, 3]) assert a[0] == 3 assert a[-1] == 2 a.append([4]) assert (np.all(a.raw == [4, 1, 2, 3])) assert (a[0] == 4) assert (a[-1] == 3) assert (np.all(a.recent(0) == [])) assert (np.all(a.recent(1) == [4])) a.append([5]) assert (np.all(a.recent(2) == [4, 5])) # test wrap around assert (np.all(a.recent(3) == [3, 4, 5])) # test RingPosition a = Ring(8) p = a.create_tap() assert p.valid_buffer_length == 1 a.append(np.arange(4)) assert p.valid_buffer_length == 5 p.advance(1) assert p.valid_buffer_length == 4 assert p.index == 0 assert np.all(p.get_samples(4) == [0, 1, 2, 3]) p.advance(2) assert np.all(p.get_samples(2) == [2, 3]) a.append([4, 5, 6, 7, 8]) p.advance(4) assert np.all(p.get_samples(2) == [6, 7]) # test wraping assert np.all(p.get_samples(3) == [6, 7, 8]) p.advance(2) assert (p.valid) assert (a.raw[p.index] == 8) # Ensure that we throw when breaking a ring pointer a = Ring(8) a.append(np.arange(8)) p = a.create_tap() assert (p.get_samples(1)[0] == 7) # pointing to the last item in the sample a.append(np.arange(7)) try: a.append([99]) except RingPointerWarning as e: pass assert p.valid is False a = Ring(8) p = a.create_tap() try: p.advance(2) except RingPointerWarning as e: pass assert p.valid is False return a, p # test rewinding pointer a = Ring(5) a.append(np.arange(2)) assert a.pointer == 2 a.rewind(1) assert a.p == 1 a.rewind(3) assert a.p == 3
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 identify_rings(mol): """ Identify the rings in the system with Zamora's SSSR ring perception algorithm. TODO: Further Documentation. """ def zamora_connectivity(mol): """ Zamora defines a connectivity index for each atom in a molecular graph. This numerical index determines how crowded or connected each atom is, allowing us to start later processing with more central atoms. """ # Mapping of number of neighbors to connectivity values # This is a huristic value assigned to each atom. # TODO: Valency > 4 is not handled by Zamora ki_values = { 0: 0, 1: 0, 2: 1, 3: 8, 4: 64, } # Calculate each atom's connectivity ki = [0 for x in range(mol.size)] for atom in range(mol.size): n = len(mol.alphaAtoms[atom]) ki[atom] = ki_values[n] # Now calculate each atom's neighborhood. # The congestedness of an atom's neighborhood yeilds higher # values for li. li = [0 for x in range(mol.size)] for atom in range(mol.size): ksum = 0 for neighbor in mol.alphaAtoms[atom]: ksum += ki[neighbor] li[atom] = ksum # Final heuristic score is the sum of ki and li. # However, ki is given an additional weight. ci = [0 for x in range(mol.size)] for atom in range(mol.size): ci[atom] = 64 * ki[atom] + li[atom] return ci def phase1(mol): """ Phase One processing takes care of "Type One" ring systems, as well as ring systems that can be reduced to Type One. TODO: Documentation. """ # Connectivity index for each atom connectivity = zamora_connectivity(mol) # List of unused atom labels. (Elements deleted as used.) unusedAtoms = range(mol.size) # XXX: May not be best approach. rings = [] while len(unusedAtoms) > 0: # Find the unused atom with the highest connectivity, then the # smallest (and best) ring that contains it. # TODO/FIXME/XXX: Absolutely need to implement Zamora's heuristics startAtom = connectivity.index(max(connectivity)) ring = _find_smallest_ring(mol, startAtom) if len(ring) < 1: # Atom is not in a ring system. unusedAtoms.remove(startAtom) connectivity[startAtom] = -1 continue rings.append(ring) # Remove used atoms. unusedAtoms = filter(lambda x: x not in ring, unusedAtoms) # Negate connectivity for used atoms. for i in range(len(connectivity)): if i not in unusedAtoms: connectivity[i] = -1 return rings # TODO: Implement phase two and three. rings = phase1(mol) # Return Ring objects. for i in range(len(rings)): rings[i] = Ring(rings[i]) return tuple(rings)
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()