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 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 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 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 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 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 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_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 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_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 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 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 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')
