def test_vb(): resolution=200 alpha=0.25 grid_x = field.UniformPeriodicGrid(resolution, 20) grid_y = field.UniformPeriodicGrid(resolution, 20) domain = field.Domain((grid_x, grid_y)) x, y = domain.values() IC = np.exp(-(x+(y-10)**2-14)**2/8)*np.exp(-((x-10)**2+(y-10)**2)/10) u = field.Field(domain) v = field.Field(domain) X = field.FieldSystem([u,v]) u.data[:] = IC v.data[:] = IC nu = 1e-2 error2 = np.max(np.abs(v.data)) vb_problem = equations.ViscousBurgers2D(X,nu,8) dt = alpha*grid_x.dx while vb_problem.t < 1-1e-5: vb_problem.step(dt) error1 = np.max(np.abs(u.data)) assert (error1,error2)==(0,0)
class ECC_Ed25519(ECC_Curve25519): curve = curve.TwistedEdwardsCurve( -1, field.Field(2**255 - 19).div(-121665, 121666), field.Field(2**255 - 19)) base_point = ( 15112221349535400772501151409588531511454012693041857206046113283949847762202L, 46316835694926478169428394003475163141307993866256225615783033603165251855960L )
def __init__(self, connection, is_server): self.connection = connection self.is_server = is_server self.priority = random.randint(-32767, 32768) self.enemy_priority = None self.phase = GamePhase.WAIT_FOR_CONNECTION self.ships_size = [4, 3, 3, 2, 2, 2, 1, 1, 1, 1] self.ship_orientation = Orientation.HORIZONTAL self.my_field = field.Field() self.enemy_field = field.Field() self.update_pending = False
def test_scare(self): gh = g.Ghost('blinky', 16, 16) gh.target = (0, 0) self.assertEqual(gh.target, (0, 0)) gh.scared = True gh.update(f.Field('tests/lvl1.txt')) self.assertTrue(gh.scared) self.assertNotEqual(gh.target, (0, 0)) gh.alive = False gh.rect.x = gh.rect.y = 16 gh.update(f.Field('tests/lvl1.txt')) self.assertFalse(gh.scared)
def init_game(self): if self.game.state == e.States.MENU: self.set_background('img/menu2.png') self.canvas.create_text(230, 340, text="Start Game", fill='white', font='arial 50') self.canvas.create_text(230, 410, text="Game Rules", fill='white', font='arial 30') elif self.game.state == e.States.MAP: self.board = [] self.game.flag_selected = False self.game.trap_selected = False self.set_background('img/map.png') self.game.hint_text_place_flag_id = self.canvas.create_text( 600, 700, text="PLACE YOUR FLAG!", fill='white', font='arial 30') for row in range(mapSettings.MAP_ROWS): fields = [] for col in range(mapSettings.MAP_COLUMNS): from_x = mapSettings.MAP_LEFT_EDGE_X + mapSettings.MAP_FIELD_A * col to_x = mapSettings.MAP_LEFT_EDGE_X + ( mapSettings.MAP_FIELD_A * col + mapSettings.MAP_FIELD_A) from_y = mapSettings.MAP_TOP_EDGE_Y + mapSettings.MAP_FIELD_A * row to_y = mapSettings.MAP_TOP_EDGE_Y + ( mapSettings.MAP_FIELD_A * row + mapSettings.MAP_FIELD_A) if row == 0 or row == 1: fields.append( field.Field(e.Player.BOT, e.Weapons.NOTHING, from_x, to_x, from_y, to_y)) elif row == 4 or row == 5: fields.append( field.Field(e.Player.PLAYER, e.Weapons.NOTHING, from_x, to_x, from_y, to_y)) else: fields.append( field.Field(e.Player.NOBODY, e.Weapons.NOBODY, from_x, to_x, from_y, to_y)) self.board.append(fields)
def test_update(self): field = f.Field('tests/lvl1.txt') field.hero.energizer = True field.hero.timer = t.Timer(0) field.hero.update(field) self.assertFalse(field.hero.energizer) self.assertIsNone(field.hero.timer)
def test_collides(self): field = f.Field('tests/lvl4.txt') field.hero.next_dir = 'up' for i in range(9): field.hero.update_move() field.hero.collide(field) self.assertEqual(field.hero.eated_dots_count, 1) self.assertCountEqual(field.dots, {}) self.assertCountEqual(field.energizers, {}) self.assertTrue(field.hero.energizer) self.assertIsNone(field.hero.current_dir) self.assertIsNone(field.hero.next_dir) field.hero.current_dir = 'right' field.hero.update_move() field.hero.collide(field) field.hero.current_dir = 'left' field.hero.update_move() field.hero.collide(field) field.hero.current_dir = 'down' for i in range(9): field.hero.update_move() field.hero.collide(field) field.hero.current_dir = 'down' field.hero.next_dir = 'right' field.hero.update_move() field.hero.collide(field) self.assertEqual(field.hero.current_dir, 'right')
def __init__(self, window, player): super().__init__(window) self.iterator = 0 self.gameField = field.Field() self.hp = 4 self.isSettingDirection = False self.newImage = [] self.iteratorForSettingDirection = 0 self.isGame = False self.sound = QSound("res/sound/shot2.wav", self) self.miss_label = [] self.iteratorForShooting = 0 self.who = player self.Xpos = 0 self.Ypos = 0 self.canUserClick = True self.canTextEdit = True for i in range(0, 10): self.newImage.append(QLabel(self)) for i in range(0, 101): self.miss_label.append(QLabel(self)) self.setPixmap(self.gameField.fieldUI) self.ships = [] for i in range(0, 10): self.ships.append(QLabel(self)) if player == "Enemy": self.automatic_setting_field()
def run(): pygame.init() board_size = (30, 15) size = (board_size[0] * 20 + 200, board_size[1] * 20 + 200) screen = pygame.display.set_mode(size) clock = pygame.time.Clock() game = field.Field(board_size[0], board_size[1], 1) total = 0 done = False while not done: time_passed_seconds = clock.tick(60) / 1000.0 total += time_passed_seconds for event in pygame.event.get(): if event.type == pygame.QUIT: done = True if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: done = True screen.fill((0, 0, 0)) if total >= .1: total = 0 game.draw(screen, True) else: game.draw(screen) pygame.display.flip() pygame.quit()
def __init__(self, blue_robots=None, yellow_robots=None, ball_pos=(0, 0)): if yellow_robots is None: yellow_robots = [] if blue_robots is None: blue_robots = [] self.message = [] self.field = field.Field() self.ball = ball.Ball(pos=ball_pos) self.robots = [] self.running = False for robot_ in blue_robots: self.robots.append( robot.Robot('blue', self.field, robot_['start_position'], robot_['orientation'], radio_id=robot_['radio_id'], vision_id=robot_['vision_id'])) for robot_ in yellow_robots: self.robots.append( robot.Robot('yellow', self.field, robot_['start_position'], robot_['orientation'], radio_id=robot_['radio_id'], vision_id=robot_['vision_id']))
def test_nu_BDF5_wave(resolution, spatial_order): grid = field.UniformPeriodicGrid(resolution, 2 * np.pi) x = grid.values IC = np.exp(-(x - np.pi)**2 * 8) u = field.Field(grid, IC) target = np.exp(-(x - np.pi + 2 * np.pi * 0.2)**2 * 8) d = spatial.FiniteDifferenceUniformGrid(1, spatial_order, grid, stencil_type='centered') ts = timesteppers.BackwardDifferentiationFormula(u, d, 5) alpha = 0.5 num_periods = 1.2 ts.evolve(0.5 * np.pi * num_periods, alpha * grid.dx) ts.evolve(1.25 * np.pi * num_periods, alpha * grid.dx / 3) ts.evolve(2 * np.pi * num_periods, alpha * grid.dx / 2) error = np.max(np.abs(u.data - target)) error_est = error_nu_BDF5_wave[(resolution, spatial_order)] assert error < error_est
def test_nu_BDF4_diff(resolution, spatial_order): grid = field.UniformPeriodicGrid(resolution, 50) x = grid.values IC = np.exp(-(x - 30)**2 / 4) u = field.Field(grid, IC) target = 1 / np.sqrt(5) * np.exp(-(x - 30)**2 / 20) d = spatial.FiniteDifferenceUniformGrid(2, spatial_order, grid, stencil_type='centered') ts = timesteppers.BackwardDifferentiationFormula(u, d, 4) alpha = 0.2 ts.evolve(1, alpha * grid.dx / 2) ts.evolve(3, alpha * grid.dx / 3) ts.evolve(4, alpha * grid.dx) error = np.max(np.abs(u.data - target)) error_est = error_nu_BDF4_diff[(resolution, spatial_order)] assert error < error_est
def test_reaction_diffusion(resolution, alpha): grid_x = field.UniformPeriodicGrid(resolution, 20) grid_y = field.UniformPeriodicGrid(resolution, 20) domain = field.Domain((grid_x, grid_y)) x, y = domain.values() IC = np.exp(-(x+(y-10)**2-14)**2/8)*np.exp(-((x-10)**2+(y-10)**2)/10) c = field.Field(domain) X = field.FieldSystem([c]) c.data[:] = IC D = 1e-2 dcdx2 = spatial.FiniteDifferenceUniformGrid(2, 8, c, 0) dcdy2 = spatial.FiniteDifferenceUniformGrid(2, 8, c, 1) rd_problem = equations.ReactionDiffusion2D(X, D, dcdx2, dcdy2) dt = alpha*grid_x.dx while rd_problem.t < 1-1e-5: rd_problem.step(dt) try: solution = np.loadtxt('c_%i.dat' % resolution) except: solution = np.loadtxt('answers2/c_%i.dat' % resolution) error = np.max(np.abs(solution - c.data)) error_est = error_RD[(resolution,alpha)] assert error < error_est
def get_new_fields(x, y): fieldList = [] for i in range(y): for n in range(x): f = field.Field(n, i, False) fieldList.append(f) return fieldList
def test_RK_3_2(resolution): grid = field.UniformPeriodicGrid(resolution, 2 * np.pi) x = grid.values IC = np.exp(-(x - np.pi)**2 * 8) u = field.Field(grid, IC) target = np.exp(-(x - np.pi - 2 * np.pi * 0.2)**2 * 8) d = spatial.FiniteDifferenceUniformGrid(1, 2, grid, stencil_type='centered') stages = 3 a = np.array([[0, 0, 0], [1 / 2, 0, 0], [-1, 2, 0]]) b = np.array([1, 4, 1]) / 6 ts = timesteppers.Multistage(u, d, stages, a, b) alpha = 0.5 num_periods = 1.8 ts.evolve(2 * np.pi * num_periods, alpha * grid.dx) error = np.max(np.abs(u.data - target)) error_est = error_RK_3_2[resolution] assert error < error_est
def start_game(field): '''Основной метод, отвечающий за работу и завершение игры''' timer = pygame.time.Clock() levels = {'big_map', 'big_map1', 'small', 'almost_stand', 'long'} pygame.init() pygame.mixer.init() field.music_channel = field.music.play(loops=-1) field.music_channel.set_volume(0.5) while field.active: timer.tick(25) field.update() pygame.display.update() if field.won: field.music_channel.set_volume(0.0) pygame.mixer.Sound('sounds/end_lvl.wav').play() current_score = field.score.get(field) current_lifes_count = field.hero.lifes_count pygame.time.wait(6000) if levels != set(): sound = field.sound_icon field = fid.Field('levels/' + levels.pop() + '.txt', current_score, current_lifes_count) field.music_channel = field.music.play(loops=-1) field.music_channel.set_volume(0.5) if not sound.active: field.sound_icon.change_mod(field) else: Game.add_result(field) Game.end_game(field, True) raise SystemExit('YOU WON!!!')
def test_diffusion_equation(resolution, alpha, spatial_order): grid_x = field.UniformNonPeriodicGrid(resolution, (0, 2 * np.pi)) grid_y = field.UniformPeriodicGrid(resolution, 2 * np.pi) domain = field.Domain([grid_x, grid_y]) x, y = domain.values() c = field.Field(domain) X = field.FieldSystem([c]) D = 1 r = np.sqrt((x - 3 * np.pi / 4)**2 + (y - np.pi / 2)**2) IC = np.exp(-r**2 * 16) c.data[:] = IC diff = equations.DiffusionBC(X, D, spatial_order) dt = alpha * grid_y.dx while diff.t < 3 * np.pi / 4 - 1e-5: diff.step(dt) try: c_target = np.loadtxt('c_%i.dat' % resolution) except: c_target = np.loadtxt('answers3/c_%i.dat' % resolution) error = np.max(np.abs(c.data - c_target)) error_est = error_diffusion[(resolution, alpha, spatial_order)] assert error < error_est
def test_AB_4_4(resolution): grid = field.UniformPeriodicGrid(resolution, 2 * np.pi) x = grid.values IC = np.exp(-(x - np.pi)**2 * 8) u = field.Field(grid, IC) target = np.exp(-(x - np.pi + 2 * np.pi * 0.2)**2 * 8) d = spatial.FiniteDifferenceUniformGrid(1, 4, grid, stencil_type='centered') steps = 4 alpha = 0.25 num_periods = 1.2 ts = timesteppers.AdamsBashforth(u, d, steps, alpha * grid.dx) ts.evolve(2 * np.pi * num_periods, alpha * grid.dx) error = np.max(np.abs(u.data - target)) error_est = error_AB_4_4[resolution] print(error) assert error < error_est
def __init__(self, x) -> None: """ This is the constructor for the MyFrame class Args: Standard Returns: None """ super().__init__(x) self.TEST = False self.plotSensors = False directoryName = str( QFileDialog.getExistingDirectory( self, "Select Directory with Robot classes:")) self.directory = os.fsencode(directoryName) self.fw = self.frameRect().width() self.fh = self.frameRect().height() #print("Pre field initialization") self.field = fld.Field(100, 100, 10) self.robots = rbs.Robots() print("Done initializing frame")
def index(): message = '' try: with open("game.pickle", 'rb') as f: field = pickle.load(f) except FileNotFoundError: field = field_.Field() bot = bot_.Bot('O') if request.method == 'POST': x = int(request.form['x']) y = int(request.form['y']) try: field[x, y] = "X" except: message = 'Cell is occupied' if field.is_win('X'): os.remove("game.pickle") return "You won!" if field.is_draw(): os.remove("game.pickle") return "Draw game" field[bot.move(field)] = 'O' if field.is_win("O"): os.remove("game.pickle") return "I won!" with open('game.pickle', 'wb') as f: pickle.dump(field, f) return render_template("index.html", field=field, message=message)
def __init__(self): self.board = [ field.Field(number) for number in range(field.Field.get_field_count()) ] self.chance_cards = ChanceDeck() self.chance_cards.shuffle_chance_cards()
def infection_analysis(trajectory_list, p,d, runs): result = [] i = infection.Infection(p, d) f = field.Field(trajectory_list, i) for i in range(runs): time = f.run() result.append(time) return np.array(result)
def __init__(self, *args, **kwargs): tk.Tk.__init__(self, *args, **kwargs) self.field = field.Field(self) self.field.pack(side=tk.BOTTOM) self.controls = controls.Controls(self) self.controls.pack(side=tk.TOP, expand=True, fill=tk.X)
def test_init_map(self): field = f.Field('tests/lvl1.txt') self.assertEqual(field.exits, []) self.assertEqual(field.gates, (232, -16)) self.assertEqual(len(field.dots), 1) self.assertEqual(len(field.energizers), 0) self.assertEqual(len(field.platforms), 4) self.assertEqual((field.hero.rect.x, field.hero.rect.y), (160, 0))
def test_remove(self): field = f.Field('levels/standart.txt') self.assertIsNone(field.candy) field.candy = c.Candy(1, 1) self.assertIsNotNone(field.candy) field.candy.timer = t.Timer(0) field.candy.check_time(field) self.assertIsNone(field.candy)
def test_blinky(self): gh = g.Ghost('blinky', 10, 10, 20, 20) self.assertEqual(gh.target, (-124, -16)) gh.target = (-100000, -100000000) field = f.Field('tests/lvl1.txt') gh.change_target(field, 7) self.assertEqual(gh.target, gh.default_target) gh.change_target(field, 0) self.assertEqual(gh.target, (field.hero.rect.x, field.hero.rect.y))
def test_generate_graph(): import field f = field.Field((15, 7), walkable='-@0123456789abcdefghijklmnopqrstuvwxyz') f.field = [ '#' * 15, '# #', '### ###### ###', '### ####### ###', '### ####### ###', '### #', '#' * 15 ] g1 = generate_graph(f, (1, 1), (8, 1), debug=True) g1_expected = Graph() g1.verts = { 0: (1, 1), 1: (8, 1), 2: (3, 1), 3: (3, 2), 4: (4, 1), 5: (11, 5), 6: (11, 1) } g1.edges = { 0: Graph.Edge(v1=0, v2=2, dir1='r', dir2='l'), 1: Graph.Edge(v1=2, v2=3, dir1='d', dir2='u'), 2: Graph.Edge(v1=2, v2=4, dir1='r', dir2='l'), 3: Graph.Edge(v1=3, v2=4, dir1='r', dir2='d'), 4: Graph.Edge(v1=1, v2=4, dir1='l', dir2='r'), 5: Graph.Edge(v1=3, v2=5, dir1='d', dir2='l'), 6: Graph.Edge(v1=5, v2=6, dir1='u', dir2='d'), 7: Graph.Edge(v1=1, v2=6, dir1='r', dir2='l') } #print(g1.verts == g1_expected.verts and g1.edges == g1_expected.edges) #print('press enter'); input() f.field = [ '#' * 15, '# # #', '# # # ### ### #', '# # # #', '### ### ### # #', '### #', '#' * 15 ] g2 = generate_graph(f, (1, 1), (8, 1), debug=True) #print('press enter'); input() f.field = [ '#' * 15, '# # #', '# # # # ### #', '# # # # #', '### ### ### # #', '### #', '#' * 15 ] g3 = generate_graph(f, (1, 1), (8, 1), debug=True) #print('press enter'); input() try: import labyrinth except Exception as e: print(e) return f = labyrinth.Labyrinth() #f.walkable += '0123456789abcdefghijklmnopqrstuvwxyz@-' f.walkable += '@-' t = time.time() g4 = generate_graph(f, (1, 1), f.exit_coords, ignored=[(f.exit_coords[0] - 2, f.exit_coords[1] - 1)], debug=False) tt = time.time()
def test_CFD2_r2(): grid = field.UniformPeriodicGrid(100, 2 * np.pi) f = field.Field(grid, np.sin(grid.values)) d = spatial.CompactFiniteDifferenceUniformGrid(2, 5, 3, grid) df = d.operate(f) df0 = -np.sin (grid.values) error = np.max(np.abs(df.data - df0)) print(error) assert error < error_bound_2[2]
def __init__(self): random.seed(settings['random_seed']) pygame.init() self.field = field.Field(self, settings['field_width'], settings['field_height']) self.checkpoint = f"checkpoints/checkpoint_{settings['checkpoint']}.pkl" self.gen_counter = 0 self.ind_counter = 0 self.pop_length = 0
def test_wave(): resolution = 100 spatial_order = 2 grid_x = field.UniformNonPeriodicGrid(resolution, (0, 2 * np.pi)) grid_y = field.UniformPeriodicGrid(resolution, 2 * np.pi) domain = field.Domain([grid_x, grid_y]) x, y = domain.values() xm, ym = domain.plotting_arrays() ux = field.Field(domain) uy = field.Field(domain) p = field.Field(domain) X = field.FieldSystem([ux, uy, p]) r = np.sqrt((x - 3 * np.pi / 4)**2 + (y - np.pi / 2)**2) IC = np.exp(-r**2 * 16) p.data[:] = IC ux.data[:] = 0.01 uy.data[:] = 0.01 wave = equations.Wave2DBC(X, spatial_order) ts = timesteppers.PredictorCorrector(wave) alpha = 0.1 dt = grid_x.dx * alpha fig = plt.figure(figsize=(4, 3)) ax = fig.add_subplot(111) pcm = ax.pcolormesh(xm, ym, p.data) ax.set_aspect(1) fig.colorbar(pcm) ax.set_xlabel('x') ax.set_ylabel('y') fig.canvas.draw() while ts.t < 2 * np.pi: ts.step(dt) if ts.iter % 50 == 0: pcm.set_array(np.ravel(p.data)) fig.canvas.draw() fig.canvas.show() assert ts.t > 1