def main():
fn = sys.argv[1]
db_print('user folder is :', fn)
if os.path.exists(fn):
db_print(os.path.basename(fn), 'exists') # file exists
s = Scene(fn)
e = Engine(s, duration=70)
e.run()
def test_name_generator(self):
prefix = 'test'
eng = Engine(Cam())
name = eng.generate_name(prefix)
self.assertEqual(prefix + ' 1', name)
eng.figures[prefix + ' 1'] = None
name = eng.generate_name(prefix)
self.assertEqual(prefix + ' 2', name)
def inline_7_4_3():
return Engine(idle_rpm=800,
limiter_rpm=9000,
strokes=4,
cylinders=7,
timing=[180, 90, 180, 270] + [240] * 3,
fire_snd=_fire_snd,
between_fire_snd=synth.silence(1))
def __init__(self, *args, **kwargs):
self.engine = Engine(*args, **kwargs)
self.done = False
self.Q = []
self.W = []
self._first_render = True
self._plot_data_persistent = {"r":[]}
self._max_episode_steps = 100000
def v_8_FP_TVR():
return Engine(idle_rpm=800,
limiter_rpm=7000,
strokes=4,
cylinders=8,
timing=[75] * 8,
fire_snd=_fire_snd,
between_fire_snd=synth.silence(1))
def inline_1():
return Engine(idle_rpm=800,
limiter_rpm=7000,
strokes=4,
cylinders=1,
timing=[720],
fire_snd=_fire_snd,
between_fire_snd=synth.silence(1))
def test_change_turn(self):
game = Engine()
turn = game.turn
game.change_turn()
new_turn = game.turn
self.assertTrue(
all(map(isinstance, (turn, new_turn),
(Player2Piece, Player1Piece))))
def __init__(self,configdir):
self.load_configuration(configdir)
self.__view = None
self.__engine = Engine()
self.__lan_device = self.__config.get('lan','lan_device')
self.__src_rs_address = self.__config.get('lan', 'source_rs')
self.__mac_address = self.__config.get('lan', 'mac_address')
self.__aprovado = None
def __init__(self, id1: 'int' = 1, id2: 'int' = 2):
self.__database = Database()
self.__manager1 = Manager(id1, self.__database.before_game(id1))
self.__manager2 = Manager(id2, self.__database.before_game(id2))
self.__overs = 20
self.__engine = Engine()
self.__scoreboard = ScoreBoard(self.__manager1.get_team(),
self.__manager2.get_team())
def create_app(spark, dataset_path, tmdb_key):
global engine
engine = Engine(spark, dataset_path, tmdb_key)
engine.load_rating()
engine.train()
app = Flask(__name__)
app.register_blueprint(main)
return app
def __init__(self):
self.c = config.Configuration()
keyFile = open('api_credentials.txt', 'r')
self.key = keyFile.readline().rstrip()
self.secret = keyFile.readline().rstrip()
self.base_url = 'https://api.binance.com'
self.trade_engine = Engine()
self.performance = per.Performance()
def test_shouldReadMotorSpeedFactorFromSettings(self):
# given
# when
self.engine = Engine(self.settings)
# then
self.settings.getMotorSpeedFactor.assert_called_once()
def main():
# define layout
layout = create_layout()
# initialize search engine
engine = Engine(data='./dataset/10k/finaldata.xlsx',
vocabs='./dataset/10k/tokDict_10k.pkl',
postings='./dataset/10k/tokPostings_10k.pkl')
# create window
window = sg.Window(title='Find Unicorn',
layout=layout,
size=(1900, 2048),
auto_size_text=True)
# event loop
outputs = {
'-VECTOR-SPACE-OUTPUT-': None,
'-HITS-OUTPUT-': None,
'-PAGE-RANK-OUTPUT': None,
'-GOOGLE-OUTPUT-': None,
'-BING-OUTPUT-': None
}
while True:
event, values = window.read()
# end program if user closes window
if event == sg.WIN_CLOSED:
break
elif event == '-SEARCH-BUTTON-':
#outputs['-VECTOR-SPACE-OUTPUT-'] = parse_output(
engine.search(values['-IN-'])
elif event == '-VECTOR-SPACE-BUTTON-':
# own engine output
window['-VECTOR-SPACE-OUTPUT-'].update(
parse_output(engine.search(values['-IN-'])))
elif event == '-HITS-BUTTON-':
window['-HITS-OUTPUT-'].update(parse_output(engine.hits()))
elif event == '-PAGE-RANK-BUTTON-':
window['-PAGE-RANK-OUTPUT-'].update(parse_output(
engine.pagerank()))
elif event == '-GOOGLE-BUTTON-':
# Google engine output
window['-GOOGLE-OUTPUT-'].update(parse_output(engine.google()))
elif event == '-BING-BUTTON-':
# bing engine output
window['-BING-OUTPUT-'].update(parse_output(engine.bing()))
elif event == '-MORE-BUTTON-':
engine.search_page += 1
# close GUI
window.close()
def main() -> None:
# Declare the size of the window
screen_width = 80
screen_height = 50
map_width = 80
map_height = 45
room_max_size = 10
room_min_size = 6
max_rooms = 30
# We need to set what font/tileset we're using
# The most common is CHARMAP_CP437 (16x16 grid, previously "ASCII_INROW")
tileset = tcod.tileset.load_tilesheet(
"fonts/CGA8x8thick.png", # font file
16, # how many rows across
16, # how many columns
tcod.tileset.CHARMAP_CP437)
# Let's process some events! How vague.
event_handler = EventHandler()
# Let's create the player object
player = Entity(int(screen_width / 2), int(screen_height / 2), "@",
(255, 255, 255))
entities = {player}
game_map = generate_dungeon(max_rooms=max_rooms,
room_min_size=room_min_size,
room_max_size=room_max_size,
map_width=map_width,
map_height=map_height,
player=player)
engine = Engine(entities=entities,
event_handler=event_handler,
game_map=game_map,
player=player)
with tcod.context.new_terminal(
screen_width,
screen_height,
tileset=tileset,
title="ultima frog",
vsync=True,
) as context:
# The main off-screen console that we'll draw things to.
# It will only temporarily have everything drawn to it directly.
root_console = tcod.Console(screen_width, screen_height, order="F")
while True:
engine.render(console=root_console, context=context)
events = tcod.event.wait()
engine.handle_events(events)
def messageCB(session, mess):
text = mess.getBody()
user = mess.getFrom()
logging.debug("MSG: %s from %s" % (text, user))
if text is None: return
logging.debug("dispatching to parser engine")
engine = Engine(user.getStripped())
msg = engine.parse(text)
session.send(xmpp.Message(user, msg))
def run(self):
"""
run
"""
engine = Engine(None, None)
engine.set_config(self.config)
engine.run()
engine.report_strategy()
def __init__(self, pieces, size, pc):
''' Creates the board and the engine '''
self.board = Board(size, pieces)
self.engine = Engine()
self.pc = pc
# to go backwards
self.history = []
self.back = False
def main():
sys.setrecursionlimit(500000)
engine = gtp.Engine(Engine(30, resnet.Policy()))
while True:
cmd = sys.stdin.readline()
if cmd:
engine_reply = engine.send(cmd)
print(engine_reply)
sys.stdout.flush()
def v_twin_90_deg():
'''Suzuki SV650/SV1000, Yamaha MT-07'''
return Engine(idle_rpm=1000,
limiter_rpm=10500,
strokes=4,
cylinders=2,
timing=[270, 450],
fire_snd=_fire_snd,
between_fire_snd=synth.silence(1))
def main() -> None:
"""
Play a game between two players
"""
engine = Engine([Player0(0), Player1(1)])
view = BoardView()
engine.view = view
engine.run_game()
def test_only_model():
rmtpp_hawkes_params = get_argparse_parser_params('rmtpp',
'simulated_hawkes')
rmtpp_hawkes_params.skiptrain = True
engine = Engine(
rmtpp_hawkes_params,
"singletrained_g1_do0.5_b16_h256_l20.0_l20_gn10.0_lr0.001_c10_s1_tlintensity_ai40.pt"
)
engine.run()
def testUrlCanonicalize(self):
e = Engine(None, None, None)
for url in self._urlList:
print(url["input"])
canonical = e._urlCanonicalize(self._urlBase, url["input"])
print(canonical)
self.assertTrue(canonical == url["output"])
self.assertTrue(
e._isOnlyFragment(url["input"]) == url["is_only_fragment"])
def main():
fn = sys.argv[1]
# TODO : use getopt?
db_print('user folder is :', fn)
if os.path.exists(fn):
db_print(os.path.basename(fn), 'exists') # file exists
parse_folder(fn)
e = Engine(actors=Actor.registry)
e.run()
def boxer_4_half():
whynot = 2
return Engine(idle_rpm=800,
limiter_rpm=6700,
strokes=4,
cylinders=whynot,
timing=[180, 180],
fire_snd=_fire_snd,
between_fire_snd=synth.silence(1))
def inline_5_crossplane():
whynot = 5
return Engine(idle_rpm=800,
limiter_rpm=9000,
strokes=4,
cylinders=whynot,
timing=[180, 90, 180, 90, 180],
fire_snd=_fire_snd,
between_fire_snd=synth.silence(1))
def inline_any():
whynot = 5
return Engine(idle_rpm=800,
limiter_rpm=9000,
strokes=4,
cylinders=whynot,
timing=[720 / whynot] * whynot,
fire_snd=_fire_snd,
between_fire_snd=synth.silence(1))
def main() -> None:
screen_width = 80
screen_height = 50
map_width = 80
map_height = 43
room_max_size = 10
room_min_size = 6
max_rooms = 30
max_monsters_per_room = 2
tileset = tcod.tileset.load_tilesheet(
"assets/dejavu10x10_gs_tc.png", 32, 8, tcod.tileset.CHARMAP_TCOD
)
player = copy.deepcopy(entity_factories.player)
engine = Engine(player=player)
engine.game_map = generate_dungeon(
max_rooms=max_rooms,
room_min_size=room_min_size,
room_max_size=room_max_size,
map_width=map_width,
map_height=map_height,
max_monsters_per_room=max_monsters_per_room,
engine=engine,
)
engine.update_fov()
engine.message_log.add_message(
"Hello and welcome, adventurer, to yet another dungeon!", color.welcome_text
)
with tcod.context.new_terminal(
screen_width,
screen_height,
tileset=tileset,
title="Yet Another Roguelike Tutorial",
vsync=True,
) as context:
root_console = tcod.Console(screen_width, screen_height, order="F")
while True:
root_console.clear()
engine.event_handler.on_render(console=root_console)
context.present(root_console)
try:
for event in tcod.event.wait():
context.convert_event(event)
engine.event_handler.handle_events(event)
except Exception: # handle exceptions in game.
traceback.print_exc() # print error to stderr
# Then print the error to the message log.
engine.message_log.add_message(traceback.format_exc(), color.error)
def read_rocket_xml(xml_path: str):
"""
Reads rocket's XML data file.
:param xml_path: rocket's XML file's path
:return: StartConds, list[Compartment], Constraints, Engine, Parameters
"""
root = etree.ElementTree(file=xml_path)
if check_rocket_xml(root) is False:
print("Error in <scene>: invalid rocket's XML file structure!")
exit(-1)
# Starting conditions
node = root.find('StartConds')
coords = Coordinates(
np.array([float(node.get('x')) * 1e3,
float(node.get('y')) * 1e3]))
s_conds = StartConds(float(node.get('t')), coords, float(node.get('V')),
float(node.get('mu')),
np.deg2rad(float(node.get('Theta'))))
# Compartments
node = root.find('Compartments')
compartments = [
Compartment(child.get('name'), float(child.get('mass')))
for child in node
]
# Constraints
node = root.find('Constraints')
constraints = Constraints(
float(node.get('max_dist')) * 1e3,
float(node.get('max_height')) * 1e3, float(node.get('max_ny')))
# Engine
eta, imp1, p0, p_outlet, k, break_mu = [], [], [], [], [], []
node = root.find('Engine')
sub_nodes = node.findall('Mode')
for sub_node in sub_nodes:
for child in sub_node:
if child.tag == 'eta':
eta.append(float(child.text))
elif child.tag == 'imp1':
imp1.append(float(child.text))
elif child.tag == 'p0':
p0.append(float(child.text) * 1e6)
elif child.tag == 'p_outlet':
p_outlet.append(float(child.text) * 1e6)
elif child.tag == 'k':
k.append(float(child.text))
elif child.tag == 'break_mu':
break_mu.append(float(child.text))
else:
continue
engine = Engine(np.array(eta), np.array(imp1), np.array(p0),
np.array(p_outlet), np.array(k), np.array(break_mu))
# Parameters
node = root.find('Parameters')
params = Parameters(float(node.get('icx')), float(node.get('beta')),
float(node.get('q_m')), float(node.get('lambda_l')))
return s_conds, compartments, constraints, engine, params
def __init__(self):
self.engine = Engine(24, 68)
gravity = 0.25
maxfallspeed = 200
maxspeed = 80
jumpforce = 300
acceleration = 10
# Sprites
# thing = Thing(self)
# ui = Sprite('ui', 0, 0)
ui = UI(self)
ui.setName('Fin The Human')
ui.setLocation('Land of Ooo')
ui.setHP(10)
ui.setMP(10)
background = Sprite(self, 'background', 0, 0)
cloud = Sprite(self, 'cloud', 0, 0)
ground = Sprite(self, 'ground', 0, 14)
character = Character(self, 2, 8)
background.add(layer='bg')
cloud.add(layer='bg')
ground.add(layer='fg')
character.add(layer='fg')
kb = Controller()
self.engine.tick()
while True:
time.sleep(1 / 60)
character.down(gravity)
cloud.pos_x += 0.05
self.engine.tick()
if kb.kbhit():
c = kb.getch()
if ord(c) == 27: # ESC
break
elif c == 'w':
character.jump()
elif c == 'a':
character.move_L(1)
elif c == 's':
character.pos_y += 1
elif c == 'd':
character.move_R(1)
else:
character.idle()
kb.set_normal_term()
def main(rounds: int, flavor: str):
flavor_rules = get_game_rules(flavor)
engine = Engine(
rounds=rounds,
game_rules=flavor_rules,
user_choice=ConsoleUserChoice(),
result_handler=ConsoleResultHandler(),
)
engine.play_n_rounds(rounds)
print('That was fun ! bye !')
