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
