def specialize(fn, python_values, types = None): if types is None: abstract_values = from_python_list(python_values) else: # if types are given, assume that the values # are already converted to Parakeet's internal runtime # representation abstract_values = [] for (t, internal_value) in zip(types, python_values): abstract_values.append(from_internal_repr(t, internal_value)) key = (fn.cache_key, tuple(abstract_values)) if key in _cache: return _cache[key] elif any(has_unit_stride(v) for v in abstract_values): specializer = StrideSpecializer(abstract_values) transforms = Phase([specializer, Simplify, DCE], memoize = False, copy = True, name = "StrideSpecialization for %s" % abstract_values) new_fn = transforms.apply(fn) else: new_fn = fn _cache[key] = new_fn return new_fn
def main(seqFilepath, overlapFilepath, outFilepath): seqRec_dct = {} for seqRec in SeqIO.parse(seqFilepath, "fasta"): seqRec_dct[seqRec.id] = seqRec overlap_df = pd.read_csv(overlapFilepath) dct_lst = [] for overlapId in overlap_df["overlap_id"]: print(overlapId) dct = {} dct["overlap_id"] = overlapId qseq_dna = seqRec_dct["{}:qseq_dna".format(overlapId)].seq sseq_dna = seqRec_dct["{}:sseq_dna".format(overlapId)].seq qseq_pro = seqRec_dct["{}:qseq_pro".format(overlapId)].seq sseq_pro = seqRec_dct["{}:sseq_pro".format(overlapId)].seq # get 6 frame translation of qseq_dna qtrans_lst = [] for strand in [1, -1]: for gap in range(3): start = gap end = gap + int(math.floor(len(qseq_dna) - gap) / 3) * 3 seq = qseq_dna[gap:end] if strand == -1: seq = seq.reverse_complement() qtrans_lst.append( str(seq.translate(table=11)).replace('*', 'X')) assert len(qtrans_lst) == 6 qscore_lst = [] sscore_lst = [] for qtrans in qtrans_lst: alns_pro = pairwise2.align.globalds(qtrans, qseq_pro, matrix, -10, -0.5) qscore_lst.append(alns_pro[0][2]) alns_pro = pairwise2.align.globalds(qtrans, sseq_pro, matrix, -10, -0.5) sscore_lst.append(alns_pro[0][2]) for i in range(6): dct["qscore{}".format(i)] = qscore_lst[i] dct["sscore{}".format(i)] = sscore_lst[i] phase = Phase() dct["relative"] = phase.phase_lst[phase.relative_int( np.argmax(qscore_lst), np.argmax(sscore_lst))] dct_lst.append(dct) out_df = pd.DataFrame(dct_lst) columns_lst = ["overlap_id"] for i in range(6): columns_lst.append("qscore{}".format(i)) for i in range(6): columns_lst.append("sscore{}".format(i)) columns_lst.append("relative") out_df = out_df[columns_lst] out_df.to_csv(outFilepath, index=False) print("OUTPUT to {}".format(outFilepath))
def main(): phaser = Phase(sample_file_name='capercaillie_sample.wav', start_pad_duration=0.024, end_pad_duration=0.024) phaser.phase(output_file_name='output.wav', n_tracks=5, gap=0.18, repeat_count=10, end_align=True)
def test_add_pig(self): phase = Phase() self.assertListEqual([], phase._pigs) pig = Pig() phase.add_pigs(pig) self.assertListEqual([pig], phase._pigs) pig1, pig2 = Pig(), Pig() phase.add_pigs(pig1, pig2) self.assertListEqual([pig, pig1, pig2], phase._pigs)
def test_add_bird(self): phase = Phase() self.assertListEqual([], phase._birds) bird = RedBird() phase.add_birds(bird) self.assertListEqual([bird], phase._birds) bird1, bird2 = RedBird(), YellowBird() phase.add_birds(bird1, bird2) self.assertListEqual([bird, bird1, bird2], phase._birds)
def test_add_obstacles(self): phase = Phase() self.assertListEqual([], phase._obstacles) obstacle = Obstacle() phase.add_obstacles(obstacle) self.assertListEqual([obstacle], phase._obstacles) obstacle1, obstacle2 = Obstacle(), Obstacle() phase.add_obstacles(obstacle1, obstacle2) self.assertListEqual([obstacle, obstacle1, obstacle2], phase._obstacles)
def make_phases_databunch(dl, bs=32, n_jobs=0, disp_batch=5): """ make phases builds the dataloaders for each training phase and implements flags for some callback methods. """ print(dl.train_dl) return[ Phase('train', dl.train_dl), Phase('valid', dl.valid_dl, grad=False), Phase('test', dl.valid_dl, grad=False), ]
def make_phases(dataset, training, valid, test, bs=32, n_jobs=0, disp_batch=5): """ make phases builds the dataloaders for each training phase and implements flags for some callback methods. """ return [ Phase('train', DataLoader(dataset, bs, sampler=training, num_workers=n_jobs)), Phase('valid', DataLoader(dataset, bs, sampler=valid, num_workers=n_jobs), grad=False), Phase('test', DataLoader(dataset, disp_batch, sampler=test, num_workers=n_jobs), grad=False), ]
def test_apply_1(self): x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] y = [] pipeline = Phase() pipeline.add(lambda x: x**2) for i in x: y.append(pipeline.apply(i)) for i in range(0, len(x)): self.assertEqual(x[i]**2, y[i])
def test_non_default_clash_interval(self): phase = Phase(30) bird = YellowBird(1, 1) phase.add_birds(bird) pig = Pig(31, 31) phase.add_pigs(pig) phase.calculate_points(0) self.assertEqual(DESTROYED, bird.status) self.assertEqual(DESTROYED, pig.status)
def __init__(self, phases_settings): self.phases = [Phase( channels=[ Channel(deepcopy(phase_settings['channel_dist'])) for _ in xrange(phase_settings['channels_count']) ], hoarder=Hoarder(volume=phase_settings['hoarder_volume']), ) for phase_settings in phases_settings]
def main(): global fase, passaros, porcos, obstaculos fase = Phase(clash_interval=32) passaros = [RedBird(30, 30), YellowBird(30, 30), YellowBird(30, 30)] porcos = [Pig(750, 1), Pig(700, 1)] obstaculos = [Obstacle(310, 100)] fase.add_obstacles(*obstaculos) fase.add_birds(*passaros) fase.add_pigs(*porcos) rodar_fase(fase)
def test_default_clash_interval(self): phase = Phase() bird = YellowBird(1, 1) phase.add_birds(bird) porco = Pig(2, 2) phase.add_pigs(porco) phase.calculate_points(0) self.assertEqual(DESTROYED, bird.status) self.assertEqual(DESTROYED, porco.status)
def teste_intervalo_de_colisao_nao_padrao(self): ''' Método que testa se o intervalo de colisão da Phase é repassado aos atores. valor testado: 31 ''' fase = Phase(30) passaro = YellowBird(1, 1) fase.add_birds(passaro) porco = Pig(31, 31) fase.add_pigs(porco) fase.calculate_points(0) self.assertEqual(DESTROYED, passaro.status) self.assertEqual(DESTROYED, porco.status)
def add_phase(self): self.phase = Phase(0, self.cof.cm.start_cm.index, self.cof.cm.start_cm.index, self.cof.cm.rel_pt.index, self.cof.cm.rel_pt.index, self.cof.max_vel.index, self.cof.max_vel.index, self.end_drop_median + 100) if self.cof.cm.rel_pt.index - self.cof.cm.start_cm.index < 0: self.cof.cm.plot() # print('p1_len', self.cof.cm.start_cm.index, 0, self.cof.cm.start_cm.index) # print('p2_len', self.cof.cm.rel_pt.index-self.cof.cm.start_cm.index, self.cof.cm.start_cm.index, self.cof.cm.rel_pt.index) # print('p3_len', self.cof.max_vel.index- self.cof.cm.rel_pt.index, self.cof.cm.rel_pt.index, self.cof.max_vel.index) # print('p4_len', self.cof.max_amp.index- self.cof.max_vel.index, self.cof.max_vel.index, self.cof.max_amp.index) if self.cof.cm.have_cm: if self.cof.max_amp.index - self.cof.max_vel.index <= 15: # self.cof.max_vel.plot() # self.cof.max_amp.plot() pass self.phase.get_normalize_data_from_move(deepcopy(self))
def criar_fase_exemplo(multiplicador=1): fase_exemplo = Phase(1 if multiplicador == 1 else 32) passaros = [RedBird(3 * multiplicador, 3 * multiplicador), YellowBird(3 * multiplicador, 3 * multiplicador), YellowBird(3 * multiplicador, 3 * multiplicador)] porcos = [Pig(78 * multiplicador, multiplicador), Pig(70 * multiplicador, multiplicador)] obstaculos = [Obstacle(31 * multiplicador, 10 * multiplicador)] fase_exemplo.add_birds(*passaros) fase_exemplo.add_pigs(*porcos) fase_exemplo.add_obstacles(*obstaculos) return fase_exemplo
def run(self): """Main loop of a Mahjong game""" phase = Phase(Winds.EAST, 1, 0) self.current_phase = phase while True: player_hands = self.rebuild_walls() for player, hand in zip(self.players, player_hands): player.hand = PlayerHand(hand) # TODO: something interaction update_dealer, increment_counter = True, False self.on_finished_hand() self.cleanup_phase() if self.is_finished(update_dealer): break phase.proceed(update_dealer, increment_counter) self.rotate_seat_winds(phase)
def create_phase(multplier=1): example_phase = Phase(1 if multplier == 1 else 32) birds = [ RedBird(3 * multplier, 3 * multplier), YellowBird(3 * multplier, 3 * multplier), YellowBird(3 * multplier, 3 * multplier) ] pigs = [Pig(78 * multplier, multplier), Pig(70 * multplier, multplier)] obstacles = [Obstacle(31 * multplier, 10 * multplier)] example_phase.add_birds(*birds) example_phase.add_pigs(*pigs) example_phase.add_obstacles(*obstacles) return example_phase
def create_phase(multplier=1): example_phase = Phase(1 if multplier == 1 else 32) birds = [RedBird(3 * multplier, 3 * multplier), YellowBird(3 * multplier, 3 * multplier), YellowBird(3 * multplier, 3 * multplier)] pigs = [Pig(78 * multplier, multplier), Pig(70 * multplier, multplier)] obstacles = [Obstacle(31 * multplier, 10 * multplier)] example_phase.add_birds(*birds) example_phase.add_pigs(*pigs) example_phase.add_obstacles(*obstacles) return example_phase
def teste_lancar_passaro_sem_erro_quando_nao_existe_passaro(self): passaro_vermelho, passaro_amarelo = RedBird(1, 1), YellowBird(1, 1) fase = Phase() fase.add_birds(passaro_vermelho, passaro_amarelo) self.assertFalse(passaro_vermelho.launched()) self.assertFalse(passaro_amarelo.launched()) fase.launch(90, 1) fase.launch(45, 3) fase.launch(31, 5) # testando que lançar passaros depios de todos lançados não causa erro self.assertTrue(passaro_vermelho.launched()) self.assertEqual(math.radians(90), passaro_vermelho._launch_angle) self.assertEqual(1, passaro_vermelho._launch_time) self.assertTrue(passaro_amarelo.launched()) self.assertEqual(math.radians(45), passaro_amarelo._launch_angle) self.assertEqual(3, passaro_amarelo._launch_time)
def test_launch_without_error_when_there_is_no_bird_to_be_launch(self): red_bird, yellow_bird = RedBird(1, 1), YellowBird(1, 1) phase = Phase() phase.add_birds(red_bird, yellow_bird) self.assertFalse(red_bird.launched()) self.assertFalse(yellow_bird.launched()) phase.launch(90, 1) phase.launch(45, 3) phase.launch(31, 5) # There is no bird to launch here self.assertTrue(red_bird.launched()) self.assertEqual(math.radians(90), red_bird._launch_angle) self.assertEqual(1, red_bird._launch_time) self.assertTrue(yellow_bird.launched()) self.assertEqual(math.radians(45), yellow_bird._launch_angle) self.assertEqual(3, yellow_bird._launch_time)
def teste_adicionar_porco(self): fase = Phase() self.assertListEqual([], fase._pigs) porco = Pig() fase.add_pigs(porco) self.assertListEqual([porco], fase._pigs) porco1, porco2 = Pig(), Pig() fase.add_pigs(porco1, porco2) self.assertListEqual([porco, porco1, porco2], fase._pigs)
def teste_adicionar_obstaculo(self): fase = Phase() self.assertListEqual([], fase._obstacles) obstaculo = Obstacle() fase.add_obstacles(obstaculo) self.assertListEqual([obstaculo], fase._obstacles) obstaculo1, obstaculo2 = Obstacle(), Obstacle() fase.add_obstacles(obstaculo1, obstaculo2) self.assertListEqual([obstaculo, obstaculo1, obstaculo2], fase._obstacles)
def teste_adicionar_passaro(self): fase = Phase() self.assertListEqual([], fase._birds) passaro = RedBird() fase.add_birds(passaro) self.assertListEqual([passaro], fase._birds) passaro1, passaro2 = RedBird(), YellowBird() fase.add_birds(passaro1, passaro2) self.assertListEqual([passaro, passaro1, passaro2], fase._birds)
def start_battle(self): """ 決闘を開始する カードを3枚ドロー マリガン(未実装) 先手の開始フェーズ実行 """ # 決闘開始前の3枚ドローとマリガン Phase.setup_phase(self.board) # 決闘開始 while True: self.turn += 1 if self.turn >= 3: Phase.opening_phase(self.board) Phase.main_phase(self.board) Phase.closing_phase(self.board)
def test_000_positive_test(self): begin_phase = Phase('Announcement') amount = 1000 fee = 1 # generate fake signing keys G = generator_secp256k1 _r = G.order() number_of_players = 4 players_pvks = [ ecdsa.util.randrange(pow(2, 256)) % _r for i in range(number_of_players) ] players_ecks = [ EC_KEY(number_to_string(pvk, _r)) for pvk in players_pvks ] players_new_pvks = [ ecdsa.util.randrange(pow(2, 256)) % _r for i in range(number_of_players) ] players_change_pvks = [ ecdsa.util.randrange(pow(2, 256)) % _r for i in range(number_of_players) ] players_changes = [ public_key_to_p2pkh(point_to_ser(pvk * G, True)) for pvk in players_change_pvks ] players_new_addresses = [ public_key_to_p2pkh(point_to_ser(pvk * G, True)) for pvk in players_new_pvks ] players_pks = [eck.get_public_key(True) for eck in players_ecks] players = dict(zip(range(number_of_players), players_pks)) print("\n") # serverThread = fakeServerThread(HOST, PORT, number_of_players = number_of_players) #( host, port, vk, amount, fee, sk, addr_new, change) playerThreads = [ protocolThread(HOST, PORT, players[player], amount, fee, players_ecks[player], players_new_addresses[player], players_changes[player]) for player in players ] # serverThread.start() for thread in playerThreads: thread.start() # serverThread.join() self.assertTrue(True)
def get_event_df(dot_df, comp_ddct): phase=Phase() ddct_lst=[] for _, family_lst in comp_ddct.items(): assert len(family_lst)>=2 tmp_df=dot_df[dot_df["qfamily"].isin(family_lst)] f2p={} #family to phase for _, row in tmp_df.iterrows(): if (row["qfamily"] in f2p.keys()) and (row["sfamily"] in f2p.keys()): qp=f2p[row["qfamily"]] sp=f2p[row["sfamily"]] assert phase.relative(qp, sp)==row["relative"] elif (row["qfamily"] in f2p.keys()) and not(row["sfamily"] in f2p.keys()): qp=f2p[row["qfamily"]] sp=phase.operate(qp, row["relative"]) f2p[row["sfamily"]]=sp elif not(row["qfamily"] in f2p.keys()) and (row["sfamily"] in f2p.keys()): sp=f2p[row["sfamily"]] revop=phase.relative(row["relative"], "+0")# revops の関数をphaseに作るべき qp=phase.operate(sp, revop) f2p[row["qfamily"]]=qp else: f2p[row["qfamily"]]="+0" f2p[row["sfamily"]]=row["relative"] ddct=defaultdict(list) for f, p in f2p.items(): ddct[p].append(f) ddct_lst.append(ddct) dct_lst=[] for ddct in ddct_lst: dct={} for k,v in ddct.items(): dct[k]=",".join(v) dct_lst.append(dct) out_df=pd.DataFrame(dct_lst) return out_df
def main(): phaser = Phase(sample_file_name='master_sample.wav', output_file_name='output.wav', start_pad_duration=0.910, end_pad_duration=0.116) track_a_file = phaser.temp_folder + 'arch-track-a.wav' track_b_file = phaser.temp_folder + 'arch-track-b.wav' phaser.phase(output_file_name=track_a_file, n_tracks=9, gap=0.03, repeat_count=172) phaser.phase(output_file_name=track_b_file, n_tracks=12, gap=0.012, repeat_count=20, end_align=True) cbn = phaser.sox.Combiner() cbn.build([track_a_file, track_b_file], phaser.output_file_name, 'concatenate')
def run(self): self.commutator.start() self.messages.make_greeting(self.vk) msg = self.messages.packets.SerializeToString() # self.commutator.send(msg) self.income.send(msg) # req = self.commutator.recv() req = self.outcome.recv() # print(req) self.messages.packets.ParseFromString(req) self.session = self.messages.packets.packet[-1].packet.session self.number = self.messages.packets.packet[-1].packet.number if self.session != '': # print("Player #" + str(self.number)+" get session number.\n") self.logger.send("Player #" + str(self.number) + " get session number.\n") # # Here is when announcment should begin # req = self.commutator.recv() req = self.outcome.recv() self.messages.packets.ParseFromString(req) phase = self.messages.get_phase() number = self.messages.get_number() if phase == 1 and number > 0: self.logger.send("player #" + str(self.number) + " is about to share verification key with " + str(number) + " players.\n") self.number_of_players = number #Share the keys self.messages.clear_packets() self.messages.packets.packet.add() self.messages.packets.packet[-1].packet.from_key.key = self.vk self.messages.packets.packet[-1].packet.session = self.session self.messages.packets.packet[-1].packet.number = self.number shared_key_message = self.messages.packets.SerializeToString() # self.commutator.send(shared_key_message) self.income.send(shared_key_message) messages = '' for i in range(number): # messages += self.commutator.recv() messages += self.outcome.recv() self.messages.packets.ParseFromString(messages) self.players = { packet.packet.number: str(packet.packet.from_key.key) for packet in self.messages.packets.packet } if self.players: print('player #' + str(self.number) + " get " + str(len(self.players)) + ".\n") # coin = Coin() crypto = Crypto() self.messages.clear_packets() # log_chan = fakeLogChannel(prefix = str(self.number) + ": ") # self.commutator.debuger = log_chan begin_phase = Phase('Announcement') # Make Round protocol = Round(coin, crypto, self.messages, self.outcome, self.income, self.logger, self.session, begin_phase, self.amount, self.fee, self.sk, self.players, self.addr_new, self.change) protocol.protocol_definition() # time.sleep(120) self.commutator.join()
def _setup_hand(self, prevalent_wind, new_hand): """Initialize a hand""" self.current_phase = Phase(prevalent_wind, new_hand, 0)
# -*- coding: utf-8 -*- from os import path import sys project_dir = path.dirname(__file__) project_dir = path.join('..') sys.path.append(project_dir) from actors import YellowBird, RedBird, Obstacle, Pig from phase import Phase from graphics_tk import rodar_fase if __name__ == '__main__': fase = Phase(intervalo_de_colisao=32) # Adicionar Pássaros Vermelhos for i in range(5): fase.add_birds(RedBird(30, 30)) # Adicionar Pássaros Amarelos for i in range(30): fase.add_birds(YellowBird(30, 30)) # Obstaculos for i in range(30, 480, 32): fase.add_obstacles(Obstacle(300, i)) # Porcos for i in range(30, 300, 32): fase.add_pigs(Pig(600, i))
from redundant_load_elim import RedundantLoadElimination from scalar_replacement import ScalarReplacement from shape_elim import ShapeElimination from simplify import Simplify from simplify_array_operators import SimplifyArrayOperators from specialize_fn_args import SpecializeFnArgs #################################### # # # HIGH LEVEL OPTIMIZATIONS # # # #################################### normalize = Phase([Simplify], memoize=True, copy=False, cleanup=[], name="Normalize") fusion_opt = Phase(Fusion, config_param='opt_fusion', memoize=False, copy=False, run_if=contains_adverbs) inline_opt = Phase(Inliner, config_param='opt_inline', cleanup=[], run_if=contains_calls, memoize=False, copy=False)
# -*- coding: utf-8 -*- from os import path import sys import math project_dir = path.dirname(__file__) project_dir = path.join('..') sys.path.append(project_dir) from actors import YellowBird, Obstacle, Pig from phase import Phase from graphics_tk import rodar_fase from random import randint if __name__ == '__main__': fase = Phase(intervalo_de_colisao=32) # Adicionar Pássaros Amarelos for i in range(80): fase.add_birds(YellowBird(30, 30)) # Obstaculos theta = 270 h = 12 k = 7 step = 32 r = 50 while theta < 480:
def main(): # Track 1 # { # "end_align": false, # "end_pad_duration": 0.0, # "fade": "in-out", # "gap": 0.25, # "initial_gap": 0, # "input_file": "/Users/jmarmor/repos/jonathanmarmor/phase/py/test_input_files/CPEFlute1.wav", # "n_tracks": 24, # "output_folder": "output/", # "quietest": -40.0, # "repeat_count": 40, # "start_pad_duration": 0.0, # "temp_folder": "tmp/" # } # track1 = Phase( # 'input_files/CPEFlute1.wav', # n_tracks=24, # gap=0.25, # # initial_gap=0.0, # repeat_count=36, # end_align=False, # start_pad_duration=0.0, # end_pad_duration=0.0, # fade='in-out', # quietest=-39.0, # These values (-39, -4.9) for quietest and gain are good for n_tracks=24, gap=0.25 # gain=-4.9, # trim_start=False, # trim_end=False, # # solo_repetition_number=0, # # solo_track_number=0, # ) # { # "end_align": false, # "end_pad_duration": 0.75, # "fade": "in-out", # "gap": 0.16, # "initial_gap": 0, # "input_file": "/Users/jmarmor/repos/jonathanmarmor/phase/py/test_input_files/CPEFlute2.wav", # "n_tracks": 32, # "output_folder": "output/", # "quietest": -60.0, # "repeat_count": 40, # "start_pad_duration": 0.75, # "temp_folder": "tmp/" # } track2 = Phase( 'input_files/CPEFlute2.wav', n_tracks=32, gap=0.16, # initial_gap=0.0, repeat_count=40, end_align=False, start_pad_duration=0.75, end_pad_duration=0.75, fade='in-out', quietest=-50.0, gain=-7.0, trim_start=False, trim_end=False)
def test_status(self): phase = Phase() pigs = [Pig(1, 1) for i in range(2)] birds = [YellowBird(1, 1) for i in range(2)] phase.add_pigs(*pigs) phase.add_birds(*birds) self.assertEqual(ON_GOING, phase.status()) for bird, pig in zip(birds, pigs): bird.clash(pig, 3) self.assertEqual(VICTORY, phase.status(), 'Without active pigs game should end with victory') phase.add_obstacles(Obstacle()) self.assertEqual(VICTORY, phase.status(), 'Obstacle must not interfere on game result') pig = Pig() phase.add_pigs(pig) self.assertEqual(DEFEAT, phase.status(), 'With Active Pig and with no Active bird, game should end with defeat') phase.add_birds(YellowBird()) self.assertEqual(ON_GOING, phase.status(), 'With active pig and birds, game should not end') pig.clash(pig, 3) self.assertEqual(VICTORY, phase.status(), 'Without active pigs game should end with victory')
def test_game_over_with_pigs_and_birds(self): phase = Phase() pigs = [Pig(1, 1) for i in range(2)] # creating 2 pigs birds = [YellowBird(1, 1) for i in range(2)] # criating 2 birds phase.add_pigs(*pigs) phase.add_birds(*birds) self.assertEqual(ON_GOING, phase.status()) # clashing bird against pig on time 3 for bird, pig in zip(birds, pigs): bird.clash(pig, 3) self.assertEqual(VICTORY, phase.status()) phase.add_obstacles(Obstacle()) self.assertEqual(VICTORY, phase.status(), 'Obstacle must not interfere on game result') phase.add_pigs(Pig()) self.assertEqual(DEFEAT, phase.status(), 'With no active birds and one Pig active, player should lose') phase.add_birds(YellowBird()) self.assertEqual(ON_GOING, phase.status(), 'With one pig and bird both active, game should still going on')
def test_game_over_without_pigs(self): phase = Phase() self.assertEqual(VICTORY, phase.status())
def teste_acabou_sem_porcos(self): fase = Phase() self.assertEqual(VICTORY, fase.status())
# -*- coding: utf-8 -*- from actors import RedBird, YellowBird, Pig, Obstacle from phase import Phase import placa_grafica fase_exemplo = Phase() passaros = [RedBird(3, 3), YellowBird(3, 3), YellowBird(3, 3)] porcos = [Pig(78, 1), Pig(70, 1)] obstaculos = [Obstacle(31, 10)] fase_exemplo.add_birds(*passaros) fase_exemplo.add_pigs(*porcos) fase_exemplo.add_obstacles(*obstaculos) # Solução para ganhar # fase_exemplo.lancar(45, 1) # fase_exemplo.lancar(63, 3) # fase_exemplo.lancar(23, 4) if __name__ == '__main__': placa_grafica.animar(fase_exemplo)
# -*- coding: utf-8 -*- from os import path import sys project_dir = path.dirname(__file__) project_dir = path.join('..') sys.path.append(project_dir) from actors import YellowBird, Pig from phase import Phase from graphics_tk import run_phase if __name__ == '__main__': fase = Phase(intervalo_de_colisao=10) deltax_gambi=80 # Adicionar Pássaros Amarelos for i in range(100): fase.add_birds(YellowBird(30, 30)) # linhas verticais for i in range(30, 300, 32): fase.add_pigs(Pig(700-deltax_gambi, i)) fase.add_pigs(Pig(200-deltax_gambi, i)) # linhas horizontais for i in range(240, 680, 32): fase.add_pigs(Pig(i-deltax_gambi, 30)) fase.add_pigs(Pig(i-deltax_gambi, 286))
def teste_status(self): fase = Phase() porcos = [Pig(1, 1) for i in range(2)] passaros = [YellowBird(1, 1) for i in range(2)] fase.add_pigs(*porcos) fase.add_birds(*passaros) self.assertEqual(ON_GOING, fase.status()) for passaro, porco in zip(passaros, porcos): passaro.clash(porco, 3) self.assertEqual(VICTORY, fase.status(), 'Sem porcos ativos o jogo deveria terminar com vitória') fase.add_obstacles(Obstacle()) self.assertEqual(VICTORY, fase.status(), 'Obstáculo não interfere para definir vitória') porco = Pig() fase.add_pigs(porco) self.assertEqual(DEFEAT, fase.status(), 'Com Pig ativo e sem pássaro para lançar, o jogo deveria acabar em derrota') fase.add_birds(YellowBird()) self.assertEqual(ON_GOING, fase.status(), 'Com Pig ativo e com pássaro para lançar, o jogo não deveria acabar') porco.clash(porco, 3) self.assertEqual(VICTORY, fase.status(), 'Sem porco ativo, o jogo deveria acabar com vitória')
def teste_acabou_com_porcos_e_passaros(self): fase = Phase() porcos = [Pig(1, 1) for i in range(2)] # criando 2 porcos passaros = [YellowBird(1, 1) for i in range(2)] # criando 2 pássaros fase.add_pigs(*porcos) fase.add_birds(*passaros) self.assertEqual(ON_GOING, fase.status()) # colidindo cada passaro com um porco no tempo 3 for passaro, porco in zip(passaros, porcos): passaro.clash(porco, 3) self.assertEqual(VICTORY, fase.status()) fase.add_obstacles(Obstacle()) self.assertEqual(VICTORY, fase.status(), 'Obstáculo não interfere no fim do jogo') fase.add_pigs(Pig()) self.assertEqual(DEFEAT, fase.status(), 'Com Pig ativo e sem pássaro para lançar, o jogo deveria acabar') fase.add_birds(YellowBird()) self.assertEqual(ON_GOING, fase.status(), 'Com Pig ativo e com pássaro para lançar, o jogo não deveria acabar')