def generate_sector(self, pos):
self.generated_sectors.append(pos)
#print("gen:Generating sector ", pos)
#print("gen:user:"******"," + str(pos[1])
#print("gen:index:",group)
self.sector_walls[group] = []
# decide on vertical sections
for y in range(0, 10):
x_used = []
for x in range(0, 10):
dice = random.random()
if dice > .9 or (dice > .3 and x - 1 in x_used):
x_used.append(x)
w = wall.Wall(self, self.game, group, ((pos[0]*1000 + x*100), (pos[1]*1000 + y*100)), ((pos[0]*1000 + (x+1)*100), (pos[1]*1000 + y*100)))
self.sector_walls[group].append(w)
self.game.register_actor(w)
#print((w in self.actors))
# decide on horizontal sections
for x in range(0, 10):
for y in range(0, 10):
y_used = []
dice = random.random()
if dice > .8 or (dice > .3 and y - 1 in y_used):
y_used.append(y)
w = wall.Wall(self, self.game, group, ((pos[0]*1000 + x*100), (pos[1]*1000 + y*100)), ((pos[0]*1000 + x*100), (pos[1]*1000 + (y+1)*100)))
self.sector_walls[group].append(w)
self.game.register_actor(w)
def gameLoop(screen):
clock = pygame.time.Clock()
global gameScreen
black = 0, 0, 0
# Moving sprites group
movingSprites = Group()
playerSprite = player.Player()
movingSprites.add(playerSprite)
# Group which contains the wall class
walls = Group()
newWall = wall.Wall(150, 200, 50, 50, (255, 255, 0))
walls.add(newWall)
newWall = wall.Wall(50, 200, 32, 32, (2, 255, 0))
walls.add(newWall)
newWall = wall.Wall(250, 200, 64, 64, (255, 25, 0))
walls.add(newWall)
while gameScreen:
clock.tick(60)
screen.fill(black)
movingSprites.draw(screen)
walls.draw(screen)
# Basic event if statement block
for event in pygame.event.get():
if event.type == QUIT or (event.type == KEYUP
and event.key == K_ESCAPE):
gameScreen = False
quit()
if event.type == KEYDOWN:
if event.key == K_RIGHT or event.key == K_d:
playerSprite.move(2, 0)
if event.key == K_LEFT or event.key == K_a:
playerSprite.move(-2, 0)
if event.key == K_UP or event.key == K_w:
playerSprite.move(0, -2)
if event.key == K_DOWN or event.key == K_s:
playerSprite.move(0, 2)
if event.type == KEYUP:
if event.key == K_RIGHT or event.key == K_d:
playerSprite.move(-2, 0)
if event.key == K_LEFT or event.key == K_a:
playerSprite.move(2, 0)
if event.key == K_UP or event.key == K_w:
playerSprite.move(0, 2)
if event.key == K_DOWN or event.key == K_s:
playerSprite.move(0, -2)
playerSprite.update([width, height], walls)
pygame.display.flip()
def __init__(self, width, height):
self.mWidth = width
self.mHeight = height
score_width = 80
score_height = 40
score_x = self.mWidth / 2 - score_width / 2
score_y = 40
self.mScoreBoard = score_board.ScoreBoard(
score_x, score_y, score_width, score_height)
wall_size = 10
self.mLeftWall = wall.Wall(0, 0, wall_size, self.mHeight)
self.mRightWall = wall.Wall(
self.mWidth-wall_size, 0, wall_size, self.mHeight)
self.mTopWall = wall.Wall(0, 0, self.mWidth, wall_size)
self.mBottomWall = wall.Wall(
0, self.mHeight-wall_size, self.mWidth, wall_size)
paddle_margin = 20
paddle_width = 20
paddle_height = 100
paddle_speed = self.mHeight / 1.25
self.mLeftPaddle = paddle.Paddle(self.mLeftWall.getRightX() + paddle_margin,
self.mHeight / 2 - paddle_height / 2,
paddle_width, paddle_height,
paddle_speed,
self.mTopWall.getBottomY(),
self.mBottomWall.getY())
self.mLeftPaddle.setColor(( 0, 89, 179))
self.mRightPaddle = paddle.Paddle(self.mRightWall.getX() - paddle_margin - paddle_width,
self.mHeight / 2 - paddle_height / 2,
paddle_width, paddle_height,
paddle_speed,
self.mTopWall.getBottomY(),
self.mBottomWall.getY())
self.mRightPaddle.setColor((196, 2, 51))
size = 20
self.mBall = ball.Ball(size,
self.mLeftWall.getRightX(),
self.mRightWall.getX(),
self.mTopWall.getBottomY(),
self.mBottomWall.getY(),
self.mLeftPaddle.getRightX(),
self.mRightPaddle.getX())
self.serveBall()
self.mBall.setLeftPaddleY(
self.mLeftPaddle.getY(), self.mLeftPaddle.getBottomY())
self.mBall.setRightPaddleY(
self.mRightPaddle.getY(), self.mRightPaddle.getBottomY())
return
def testWallBuilder(self):
wall_builder = wall.WallBuilder((0, 50), (100, 150), (200, 250))
walls = wall_builder.build()
expected_walls = [
wall.Wall((0, 50), (100, 150)),
wall.Wall((100, 150), (200, 250)),
wall.Wall((200, 250), (0, 50))
]
self.assertEqual(expected_walls, walls)
def __init__(self):
self.objects = []
self.width = 600
self.height = 600
self.screen = pygame.display.set_mode((self.width, self.height))
self.player = player.Player(self, 100, 100)
self.view = (0, 0)
for x in xrange(0, 320, 32):
wall.Wall(self, x, 640)
for y in xrange(0, 640, 32):
wall.Wall(self, 0, y)
wall.Wall(self, 160, y)
def draw(self): # consider the DOWN and RIGHT edge of each box
for i in range(self.numRows):
for j in range(self.numCols):
if (self.doorMap[i][j][0]): # DOWN
w = wall.Wall(
(self.originX + j * self.wallLength, self.originY +
(i + 1) * self.wallLength), 'h', self.color)
w.draw()
if (self.doorMap[i][j][1]): # RIGHT
w = wall.Wall((self.originX + (j + 1) * self.wallLength,
self.originY + i * self.wallLength), 'v',
self.color)
w.draw()
def createOffice(self): self.tiles=[] for line in self.office_file: self.tiles.append(list(line.rstrip())) self.office_file.close() self.wall_list=[] self.floor_list=[] for row in range(len(self.tiles)): for col in range(len(self.tiles[row])): if self.tiles[row][col]=="1": self.wall_list.append(wall.Wall(row*self.x_tile_size,col*self.y_tile_size, 'brown-rect.jpg')) elif self.tiles[row][col]=="0": self.floor_list.append(wall.Wall(row*self.x_tile_size,col*self.y_tile_size, 'wood-background.png')) return self.wall_list, self.floor_list
def load_data(self):
self.enemy = units.DummyTank((600,300))
for i in range(5,11):
self.spawn(units.Crate((i*100,700)))
w = wall.Wall((100,100), pygame.image.load("images/wall-test.png"))
self.spawn(w)
self.spawn(self.enemy)
def load_data(self):
self.enemy = units.DummyTank((600,300))
self.spawn(units.Crate((700,500)))
self.spawn(units.Crate((800,400)))
w = wall.Wall((100,100), pygame.image.load("images/wall-test.png"))
self.spawn(w)
self.spawn(self.enemy)
def __init__(self):
global winsPos
global checkpointsPos
wall.walls = []
checkpoint.checkpoints = []
win.wins = []
level_map = st.level_map
with open(level_map, 'r') as f:
level_map = f.read().split('\n')
x = y = 0
for row in level_map:
for col in row:
if col == 'x':
wall.Wall((x, y))
if col == 'W' or col == 'w':
win.Win((x, y))
winsPos.append((x, y))
if col == 'C' or col == 'c':
checkpoint.Checkpoint((x, y))
checkpointsPos.append((x, y))
if col == 'O' or col == 'o':
self.rect = pygame.Rect(x, y, st.playerLength,
st.playerLength)
x += st.blockLength
y += st.blockLength
x = 0
def setUp(self):
self.expected_x = 125
self.expected_y = 250
self.expected_width = 400
self.expected_height = 200
self.wall = wall.Wall(self.expected_x, self.expected_y,
self.expected_width, self.expected_height)
return
def __init__(self, settings=Settings()):
pygame.init()
self.score = 0
self.loadSettings(settings)
self.clock = pygame.time.Clock()
self.snakeParts = [snake.SnakePart(400, 300, self.background, "red")]
self.snakeParts[0].isHead = True
self.gameObjects = [self.snakeParts[0]]
for i in range(0, 820, 20):
self.gameObjects.append(wall.Wall(i, -10, self.background))
for i in range(0, 820, 20):
self.gameObjects.append(wall.Wall(i, 590, self.background))
self.sprites = pygame.sprite.RenderPlain(self.gameObjects)
self.move_timer = 0
self.score = 0
self.food_timer = random.randint(100, 200)
def define_maze(s, maze):
walls = []
for (x, y), value in numpy.ndenumerate(maze):
wall = w.Wall(s, (x * s.maze_block_width), (y * s.maze_block_height))
if value == 1:
walls.append(wall)
if value == 2:
start = wall
elif value == 3:
end = wall
return walls, start, end
def populate_walls(self, soup):
self.walls = []
for cur_wall in soup.find_all('Wall'):
line = cur_wall.line
ax = float(line.p1.x.get_text())
ay = float(line.p1.y.get_text())
bx = float(line.p2.x.get_text())
by = float(line.p2.y.get_text())
new_wall = wall.Wall(ax, ay, bx, by)
self.walls.append(new_wall)
def __init__(self, width, height):
self.width = width
self.height = height
self.bullet = bullet.Bullet(self.width / 2, self.height / 2,
self.width, self.height)
self.cannon = cannon.Cannon(self.width, self.height, self.width / 2,
self.height / 2)
self.wall = wall.Wall(self.width, self.height, self.width / 2,
self.height / 2)
def __init__(self, width, height):
self.window_width = width
self.window_height = height
self.color = 1
self.blockSize = 5
pyxel.init(self.window_width, self.window_height, scale=SCALE)
# self.GenerateMaze(ROW_MAX, COL_MAX)
self.wall = wl.Wall(self.width, self.height, self.color)
def __init__(self):
scenes.Scene.__init__(self)
self.game_ball = ball.Ball()
self.game_player = player.Player()
self.game_wall = wall.Wall(50)
self.player_points = 0
self.vidas = 3
self.wait_init = True
pygame.key.set_repeat(c.player_accuracy)
self.img_bg = pygame.image.load(
'assets\imagens\Bg.png').convert_alpha()
self.font = pygame.font.SysFont('Arial', 20)
def __init__(self, maze_size):
"""
Initializes everything that is needed to start a new game.
maze_size -- Size in which maze will be created. Only odd sizes are possible.
"""
self.treasures = {}
self.level = level.Level(maze_size)
self.player = player.Player(self.level, self.treasures, maze_size)
self.start_writer = writers.StartWriter(maze_size)
self.wall = wall.Wall()
self.maze_size = maze_size
def black_tile(environmentdata):
global tasks
global current_tile
global status
if environmentdata['floor'] == 'black':
print("Black tile")
current_tile.set_type('black')
print("Changed type")
current_tile.set_top(wall.Wall())
print("Top locked")
current_tile.set_rgt(wall.Wall())
print("Right locked")
current_tile.set_but(wall.Wall())
print("Down locked")
current_tile.set_lft(wall.Wall())
print("Left locked")
tasks.add(history.get_last_tile())
print("Added reverse to stack")
print(tasks)
print(tasks.all())
status = 1
def __init__(self):
"""Initialize class instance."""
self.screen = pygame.display.set_mode(Pong.WINSIZE)
self.label = pygame.freetype.SysFont('Sans', 35)
self.lw = wall.Wall(vector.Vector(0),
pygame.Rect(-20, 0, 20, Pong.HEIGHT), Pong.BGCOLOR)
self.rw = wall.Wall(vector.Vector(180),
pygame.Rect(Pong.WIDTH, 0, 20, Pong.HEIGHT),
Pong.BGCOLOR)
self.tw = wall.Wall(vector.Vector(270),
pygame.Rect(0, 0, Pong.WIDTH, 20), Pong.BGCOLOR)
self.bw = wall.Wall(vector.Vector(90),
pygame.Rect(0, Pong.HEIGHT - 20, Pong.WIDTH, 20),
Pong.BGCOLOR)
self.pl = wall.Player(
vector.Vector(90),
pygame.Rect(Pong.WIDTH / 2 - 80 / 2, Pong.HEIGHT - 20, 80, 20),
Pong.PLCOLOR)
self.en = wall.Player(vector.Vector(270),
pygame.Rect(Pong.WIDTH / 2 - 80 / 2, 0, 80, 20),
Pong.ENCOLOR)
self.ba = wall.Ball(
vector.Vector(270, 10),
pygame.Rect(Pong.WIDTH / 2 - 20 / 2, Pong.HEIGHT / 2 - 20 / 2, 20,
20), Pong.BACOLOR)
self.sc = score.Score()
self.message = ''
self.make_ready()
def __init__(self, name, player_direction, logger=None):
self.logger = logger or logging.getLogger(__name__)
self.logger.info("player created with name: {}".format(name))
self.name = name
# create walls
self.walls = [
wall.Wall(wall.TYPE_PLAYER, i) for i in range(NUMBER_OF_WALLS)
]
# create pawn
self.pawn = pawn.Pawn(board.PAWN_INIT_POS[player_direction])
self.board = None
self.player_direction = player_direction
# at_move
self._active = False
def load_map():
global walls, main_batch
x = 0
y = 0
x1 = 0
y1 = 0
x2 = 0
y2 = 0
f = open("resources/map.map", "r")
for s in f.read():
if s == '\n':
x = -50
y += 50
if s == "1":
walls.append(wall.Wall(x - 25, y - 25, x + 25, y + 25, batch=main_batch))
x += 50
f.close()
def reset(self):
# draw a map
self.all_wall.empty() # To clear a group of sprites
for wall in [[175, 25], [275, 25], [525, 25], [575, 25], [625, 25], [125, 75], [275, 75], [475, 75], [575, 75],
[675, 25], [725, 75], [75, 125], [125, 125], [175, 125], [225, 125], [275, 125], [325, 125],
[425, 125], [475, 125], [525, 125], [575, 125], [675, 125], [25, 175], [75, 175], [125, 175],
[575, 175], [625, 175], [675, 175], [725, 175], [775, 175], [25, 225], [75, 225], [175, 225],
[225, 225], [325, 225], [375, 225], [425, 225], [525, 225], [775, 225], [175, 275], [175, 275],
[325, 275], [375, 275], [475, 275], [525, 275], [575, 275], [625, 275], [725, 275], [225, 325],
[275, 325], [325, 325], [525, 325], [725, 325], [25, 375], [125, 375], [175, 375], [475, 375],
[525, 375], [625, 375], [675, 375], [775, 375], [125, 425], [175, 425], [225, 425], [325, 425],
[375, 425], [425, 425], [475, 425], [525, 425], [625, 425], [675, 425], [725, 425], [775, 425],
[25, 475], [75, 475], [175, 475], [325, 475], [625, 475], [675, 475], [75, 525], [175, 525],
[225, 525], [275, 525], [375, 525], [425, 525], [525, 525], [575, 525], [675, 525], [775, 525],
[125, 575], [225, 575], [325, 575], [525, 575], [625, 575], [675, 575], [725, 575], [75, 625],
[175, 625], [225, 625], [325, 625], [525, 625], [575, 625], [725, 625]]:
self.all_wall.add(_wall.Wall(wall, self.photo_wall))
# player
self.my_tank.empty()
self.player = _player.MyTank([425, 325], self.photo_player, self.all_wall)
self.my_tank.add(self.player)
# enemy tanks
self.enemy_tanks.empty()
for tank in self.tanks:
self.enemy_tanks.add(
_enemy_tank.EnemyTank(tank, self.photo_enemy_tank, self.all_wall, self.enemy_bullet, self.photo_bullet))
# Bullets
self.my_bullet.empty()
self.enemy_bullet.empty()
# Play time
self.time = FPS * 120
self.done = False
# my_coord, my_bullet, enemy_coord, enemy_bullet, wall_coord = self.get_obs()
#
# return my_coord, my_bullet, enemy_coord, enemy_bullet, wall_coord
# observation = self.get_obs()
self.screen_data = pygame.surfarray.array3d(self.screen)
return self.screen_data
def _init_terrain(self):
floor_width = 19
floor_height = 19
x_room = 1
y_room = 1
w_room = 5
h_room = 5
for x in range(0, floor_width):
for y in range(0, floor_height):
position = map_position.MapPosition(x, y)
new_terrain = wall.Wall(self.level.terrain_map, position)
for x in range(0, floor_width):
for y in range(0, floor_height):
position = map_position.MapPosition(x, y)
if x >= x_room and x < x_room + w_room and y >= y_room and y < y_room + h_room:
new_terrain = floor.Floor(self.level.terrain_map, position)
position = self._drop_stairs()
new_terrain = stairs_down.StairsDown(self.level.terrain_map, position)
def interpret_wall_from_verteces(self, vertex1, vertex2):
length = 0
dir = 5
print vertex1
print vertex2
if vertex1[0] == vertex2[0]: #if on same x line
if vertex1[1] == vertex2[1]: #if same y line
dir = 5 #then same point, return junk
length = 0
elif vertex1[1] > vertex2[1]: #if v2 is up
dir = 8 #up
length = vertex1[1] - vertex2[1] #length is deltaY
elif vertex1[1] < vertex2[1]: #if v2 is down
dir = 2 #down
length = vertex2[1] - vertex1[1] #length is deltaY
elif vertex1[0] > vertex2[0]: #if v2 is left
if vertex1[1] == vertex2[1]: #if same y line
dir = 4 #left
length = vertex1[0] - vertex2[0] #deltaX
elif vertex1[1] > vertex2[1]: #if v2 is up
dir = 7 #left up
length = vertex1[1] - vertex2[1] #length is deltaY
elif vertex1[1] < vertex2[1]: #if v2 is down
dir = 1 #down
length = vertex2[1] - vertex1[1] #length is deltaY
elif vertex1[0] < vertex2[0]: #if v2 is right
if vertex1[1] == vertex2[1]: #if same y line
dir = 6 #right
length = vertex2[0] - vertex1[0] #deltaX
elif vertex1[1] > vertex2[1]: #if v2 is up
dir = 9 #up right
length = vertex1[1] - vertex2[1] #length is deltaY
elif vertex1[1] < vertex2[1]: #if v2 is down
dir = 3 #down right
length = vertex2[1] - vertex1[1] #length is deltaY
print dir
length += 1
return wall.Wall(vertex1[0], vertex1[1], 'R', self.color, length, dir)
def main():
# create render window
window = grapher.Grapher()
# create cube models
render_models = list()
render_models.append(cube.Cube())
render_models.append(cube.Cube())
render_models.append(cube.Cube())
render_models.append(cube.Cube())
render_models[0].set_pos(5, 0, 10)
render_models[1].set_pos(-5, 0, 10)
render_models[2].set_pos(5, -4, 13)
render_models[3].set_pos(-5, -7, 10)
# create walls
render_models.append(wall.Wall())
render_models[4].set_pos(0, -8, 25)
render_models[4].scale = 8
render_models.append(wall.Wall())
render_models[5].set_pos(16, -8, 9)
render_models[5].set_rot(0, 90, 0)
render_models[5].scale = 8
# create camera
cam = camera.Camera()
# temp
r = 0
s = 0.2
# main loop
try:
while True:
# clear grapher
window.clear()
# render models in render_models list
for rm in render_models:
# set global model-space stuff here
rm.set_rot_delta(r, r, r)
# transform model and get transformed coordinate pairs
coords = rm.process(cam, fov)
# render segments from coordinate pair list
for i in coords:
# gather depth coordinates
sz = i[0][2]
ez = i[1][2]
# if segment is completely behind player, skip rendering
if sz < 0 and ez < 0:
continue
# gather transformed coordinates
startx = i[0][0]
starty = i[0][1]
endx = i[1][0]
endy = i[1][1]
# if segment is partially behind player, clip segment to camera's field of view
if sz < 0 or ez < 0:
# ffffuuuuuuu
pass
# draw segment
window.draw_line(startx, starty, endx, endy)
# draw debug text
coords = "Player: (%f, %f, %f)" % (cam.pos_x, cam.pos_y, cam.pos_z)
pang = "Player angle: %f" % cam.angle
options = "Options: ROT: %d, SPD: %d" % (r, s)
window.console_out("3D Engine test - HalfBurntToast")
window.console_out(coords)
window.console_out(pang)
window.console_out(options)
# update grapher
window.update()
# get command input
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_r:
r = int(not r)
if event.key == pygame.K_p:
cam.reset()
print("Reset")
# get movement input
keys = pygame.key.get_pressed()
if keys[pygame.K_w]:
ang = numpy.deg2rad(numpy.abs(360 - cam.angle))
cam.pos_z -= numpy.cos(ang) * s
cam.pos_x -= numpy.sin(ang) * s
if keys[pygame.K_s]:
ang = numpy.deg2rad(numpy.abs(360 - cam.angle))
cam.pos_z += numpy.cos(ang) * s
cam.pos_x += numpy.sin(ang) * s
if keys[pygame.K_a]:
ang = numpy.deg2rad(numpy.abs(360 - (cam.angle - 90)))
cam.pos_z += numpy.cos(ang) * s
cam.pos_x += numpy.sin(ang) * s
if keys[pygame.K_d]:
ang = numpy.deg2rad(numpy.abs(360 - (cam.angle - 90)))
cam.pos_z -= numpy.cos(ang) * s
cam.pos_x -= numpy.sin(ang) * s
if keys[pygame.K_e]:
cam.angle = (cam.angle - 0.6) % 360
if keys[pygame.K_q]:
cam.angle = (cam.angle + 0.6) % 360
# if not using any input handling, uncommon the line below
#pygame.event.pump()
# temp delay. TODO: replace with FPS regulator
pygame.time.delay(10)
except KeyboardInterrupt:
pygame.quit()
import pyglet
import player
import wall
window = pyglet.window.Window(width=640, height=360, resizable=True)
player = player.Player(window)
entityList = []
entityList.append(player)
entityList.append(wall.Wall(64, 64))
entityList.append(wall.Wall(64, 128))
entityList.append(wall.Wall(128, 64))
entityList.append(wall.Wall(128, 128))
entityList.append(wall.Wall(256, 128))
entityList.append(wall.Wall(512, 128))
entityList.append(wall.Wall(1024, 128))
pyglet.gl.glClearColor(1, 1, 1, 1)
@window.event
def on_resize(x, y):
player.resize(x, y)
@window.event
def on_draw():
window.clear()
for entity in entityList:
entity.draw()
def __init__(self, tpr):
self.extend([
# The MD/EM/... integrator; index to enum
("integrator", Integer(tpr)),
# Number of steps to run
("nsteps", Integer(tpr) if tpr.version < 62 else Long(tpr)),
# Starting step of run (part)
("init_step", Integer(tpr) if tpr.version < 62 else Long(tpr)),
# Number of simulation part
("simulation_part", Integer(tpr) if tpr.version >= 58 else None),
# Frequency of calculating energies
("nstcalcenergy", Integer(tpr) if tpr.version >= 67 else None),
# Type of periodic boundary conditions; index to enum
("pbc", Integer(tpr) if tpr.version < 53 else None),
# Molecules wrapping over PBC no/yes
("periodic_molecules", Integer(tpr) if
(45 <= tpr.version < 53) else None),
# Cutoff scheme; index to enum
("cutoff_scheme", Integer(tpr) if tpr.version >= 80 else None),
# Neighbour search type; index to enum
("ns_type", Integer(tpr)),
# Frequency of neighbour list update
("nstlist", Integer(tpr)),
# Number of cells per rlong
("ndelta", Integer(tpr)),
("dummy", Integer(tpr) if tpr.version < 41 else None),
("dummy", Integer(tpr) if tpr.version < 41 else None),
# Test particle insertion radius
("rtpi", Real(tpr) if tpr.version >= 45 else None),
("nstcomm", Integer(tpr)),
("comm_mode", Integer(tpr) if tpr.version > 34 else None),
("nstcheckpoint", Integer(tpr) if tpr.version > 25
and tpr.version < versions.RemoveObsoleteParameters1 else None),
# Frequency of steepest descents steps when doing CG
("nstcgsteep", Integer(tpr)),
# NBFG-S minimization
("nbfgscorr", Integer(tpr) if tpr.version >= 30 else None),
# Frequency of writing to log
("nstlog", Integer(tpr)),
# Frequency of writing coordinates to TRR
("nstxout", Integer(tpr)),
# Frequency of writing velocities to TRR
("nstvout", Integer(tpr)),
# Frequency of writing forces to TRR
("nstfout", Integer(tpr)),
# Frequency of writing energies to EDR
("nstenergy", Integer(tpr)),
# Frequency of writing coordinates to XTC
("nstxtcout", Integer(tpr)),
# Starting time
("tinit", Real(tpr) if tpr.version < 59 else Double(tpr)),
# Time step
("dt", Real(tpr) if tpr.version < 59 else Double(tpr)),
# Precision of XTC file
("xtc_precision", Real(tpr)),
("dummy", Integer(tpr) if tpr.version < 19 else None),
("dummy", Integer(tpr) if tpr.version < 19 else None),
("dummy", Integer(tpr) if tpr.version < 18 else None),
# Allowed energy drift due to the Verlet buffer in kJ/mol/ps per atom,
# a value of -1 means: use rlist
("verlet_buffer_drift", Real(tpr) if tpr.version >= 80 else None),
# Neighbour list cut-off
("rlist", Real(tpr)),
# Long-range cut-off for switched potentials
("rlistlong", Real(tpr) if tpr.version >= 67 else None),
# Frequency of long-range cut-off calculation
("nstcalclr",
Integer(tpr) if tpr.version >= 82 and tpr.version != 90 else None
),
# Treatment of electrostatic interactions; index to enum
("coulombtype", Integer(tpr)),
# Modifier for electrostatic interactions; index to enum
("coulomb_modifier", Integer(tpr) if tpr.version >= 81 else None),
# Radius to start switching coulomb interactions
("rcoulomb_switch", Real(tpr)),
# Cut-off radius for coulomb interactions
("rcoulomb", Real(tpr)),
# Treatment of vanderwaals interactions; index to enum
("vdwtype", Integer(tpr)),
# Modifier for vanderwaals interactions; index to enum
("vdw_modifier", Integer(tpr) if tpr.version >= 81 else None),
# Radius to start switching vanderwaals interactions
("rvdw_switch", Real(tpr)),
# Cut-off radius for vanderwaals interactions
("rvdw", Real(tpr)),
# Apply long range dispersion corrections for Energy and Pressure
("eDispCorr", Integer(tpr)),
# Dielectric constant of medium
("epsilon_r", Real(tpr)),
# Dielectric constant of reaction field
("epsilon_rf", Real(tpr) if tpr.version >= 37 else None),
# Extension of the potential lookup tables beyond the cut-off
("table_extension", Real(tpr) if tpr.version >= 29 else None),
# Algorithm for calculating Born radii
("gb_algorithm", Integer(tpr) if tpr.version >= 25 else None),
# Frequency of calculating the Born radii inside rlist
("nstgbradii", Integer(tpr) if tpr.version >= 25 else None),
# Cutoff for Born radii calculation# the contribution from atoms
# between rlist and rgbradii is updated every nstlist steps
("rgbradii", Real(tpr) if tpr.version >= 25 else None),
# Salt concentration in M for Generalized Born models
("gb_saltconc", Real(tpr) if tpr.version >= 25 else None),
# Implicit solvent algorithm; index to enum.
("implicit_solvent", Integer(tpr) if tpr.version >= 25 else None),
# Dielectric coefficient of the implicit solvent
("gb_epsilon_solvent", Real(tpr) if tpr.version >= 55 else None),
# Scaling factors used in the OBC GB model. Default values are OBC(II)
("gb_obc_alpha", Real(tpr) if tpr.version >= 55 else None),
("gb_obc_beta", Real(tpr) if tpr.version >= 55 else None),
("gb_obc_gamma", Real(tpr) if tpr.version >= 55 else None),
("gb_dielectric_offset", Real(tpr) if tpr.version >= 60 else None),
# Algorithm for non-polar part of GBSA; index to enum
("sa_algorithm", Integer(tpr) if tpr.version >= 60 else None),
# Surface tension (kJ/mol/nm^2) for the SA (nonpolar surface) part of GBSA
# The value -1 will set default value for Still/HCT/OBC GB-models.
("sa_surface_tension", Real(tpr) if tpr.version >= 55 else None),
# Spacing for the PME/PPPM FFT grid
("fourierspacing", Real(tpr) if tpr.version >= 80 else None),
# FFT grid size, when a value is 0 fourierspacing will be used
("fourier_nx", Integer(tpr)),
("fourier_ny", Integer(tpr)),
("fourier_nz", Integer(tpr)),
# EWALD/PME/PPPM parameters
("pme_order", Integer(tpr)),
("ewald_rtol", Real(tpr)),
("ewald_rtol_lj", Real(tpr) if tpr.version >= 93 else None),
# Index to enum
("ewald_geometry", Integer(tpr) if tpr.version >= 24 else None),
("dummy", Integer(tpr) if tpr.version == 17 else None),
("epsilon_surface", Real(tpr) if tpr.version > 17 else None),
# Boolean for optimization of FFT settings
("optimize_fft", Integer(tpr)
if tpr.version < versions.RemoveObsoleteParameters1 else None),
("ljpmeCombRule", Integer(tpr) if tpr.version >= 93 else None),
# Boolean for continuation of run (no constraints in first step)
("continuation", Integer(tpr)),
# Temperature coupling algorithm; index to enum
("tcoupl", Integer(tpr)),
# ...
("print_nose_hoover_chain_variables",
Integer(tpr) if tpr.version >= 79 else None),
# Frequency of applying temperature coupling correction
("nsttcouple", Integer(tpr) if tpr.version >= 71 else None),
("dummy", Integer(tpr) if tpr.version <= 15 else None),
("epct", Integer(tpr) if tpr.version <= 17 else None),
("dummy", Integer(tpr) if tpr.version <= 15 else None),
# Pressure coupling method; index to enum
("pcoupl", Integer(tpr) if tpr.version > 17 else None),
# Type of pressure coupling (Isotropic, Semiisotropci, Anisotropic); index to enum
("pcoupltype", Integer(tpr) if tpr.version > 17 else None),
# Frequency of pressure coupling
("nstpcouple", Integer(tpr) if tpr.version >= 71 else None),
# Relaxation time for pressure coupling
("tau_p", Real(tpr)),
# Reference pressure
("ref_p", RealVector(tpr) if tpr.version <= 15 else RealMatrix(tpr)
),
# Compressibility of the system
("compressibility",
RealVector(tpr) if tpr.version <= 15 else RealMatrix(tpr)),
# Scaling of reference coordinates with pressure coupling; index to enum
("refcoord_scaling", Integer(tpr) if tpr.version >= 47 else None),
("posres_com", RealVector(tpr) if tpr.version >= 47 else None),
("posres_comB", RealVector(tpr) if tpr.version >= 47 else None),
("andersen_seed", Integer(tpr) if
(25 < tpr.version < 79) else None),
("bSimAnn", Integer(tpr) if tpr.version < 26 else None),
("zerotemptime", Real(tpr) if tpr.version < 26 else None),
("dummy", Real(tpr) if tpr.version < 37 else None),
# Relative tolerance of SHAKE
("shake_tol", Real(tpr)),
("fudgeQQ", Real(tpr) if tpr.version < 54 else None),
("efep", fep.FEP(tpr)),
])
self.extend([
("simtemp", tpr.version >= 79
and fep.SimTemp(tpr, self.efep.n_lambda)),
("expanded", tpr.version >= 79 and fep.Expanded(tpr, self.efep)),
# Distance restraints
("disre", Integer(tpr) if tpr.version >= 57 else None),
("disre_weighting", Integer(tpr)),
("bDisreMixed", Integer(tpr)),
("disre_fc", Real(tpr)),
("disre_tau", Real(tpr)),
("nstdisreout", Integer(tpr)),
# Orientation restraints
("orire_fc", Real(tpr) if tpr.version >= 22 else None), #
("orire_tau", Real(tpr) if tpr.version >= 22 else None), #
("nstorireout", Integer(tpr) if tpr.version >= 22 else None), #
# Dihedral restraint force constant
("dihre_fc", Real(tpr) if 26 <= tpr.version < 79 else None), #
("dummy", Real(tpr) if 26 <= tpr.version < 56 else None), #
("dummy", Integer(tpr) if 26 <= tpr.version < 56 else None), #
# Initial stepsize for EM
("emstep", Real(tpr)),
# Force tolerance for EM
("emtol", Integer(tpr)),
("bShakeSOR", Integer(tpr) if tpr.version >= 22 else None),
# Max number of iterations in relax-shells
("niter", Integer(tpr) if tpr.version >= 11 else None),
# Step size (ps^2) for minimization of flexible constraints
("fcstep", Real(tpr) if tpr.version >= 21 else None),
# Constraint algorithm; index to enum
("eConstrAlg", Integer(tpr)),
# Projection order of LINCS
("lincs_order", Integer(tpr)), #
# LINCS warns if angle changes more than this
("lincs_warnangle", Real(tpr)), #
("dummy", Integer(tpr) if tpr.version <= 14 else None), #
# Number of iterations in final step of LINCS
("lincs_iter", Integer(tpr) if tpr.version >= 26 else None), #
# ...
("bd_temp", Real(tpr) if tpr.version < 33 else None), #
# Brownian Dynamics friction
("bd_fric", Real(tpr)),
# Langevin Dynamics random seed
("ld_seed", Long(tpr)
if tpr.version >= versions.Use64BitRandomSeed else Integer(tpr)),
# Deformation matrix (Non-equilibrium MD)
("deform", RealMatrix(tpr) if tpr.version >= 33 else None),
# Cosine shaped acceleration (Non-equilibrium MD)
("cos_acceleration", Real(tpr) if tpr.version >= 14 else None),
# User definable parameters
("userint1", Integer(tpr)),
("userint2", Integer(tpr)),
("userint3", Integer(tpr)),
("userint4", Integer(tpr)),
("userreal1", Float(tpr, tpr.precision)),
("userreal2", Float(tpr, tpr.precision)),
("userreal3", Float(tpr, tpr.precision)),
("userreal4", Float(tpr, tpr.precision)),
])
self.extend([
("adress", adress.AdResS(tpr)),
("pull", pull.Pull(tpr)),
("rot", rotate.Rotate(tpr)),
("imd", imd.InteractiveMD(tpr)),
("opts", Opts(tpr)),
("wall", wall.Wall(tpr)),
("efield", efield.Efield(tpr)),
("swapcoords", elphys.SwapCoords(tpr)),
("qmmm", qmmm.QMMM(tpr)),
])
pygame.display.set_caption("Arkanoid")
game_clock = pygame.time.Clock()
pygame.key.set_repeat(c.player_accuracy)
onGame = True
img_bg = pygame.image.load('assets\imagens\Bg.png').convert_alpha()
game_ball = ball.Ball()
game_player = player.Player()
player_points = 0
font = pygame.font.SysFont('Arial', 20)
vidas = 3
wait_init = True
game_wall = wall.Wall(50)
while onGame:
game_clock.tick(c.game_FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
game_player.playerWorks(event)
if wait_init == True and event.key == pygame.K_SPACE:
wait_init = False
if game_ball.rect.centerx < c.display_heigth / 2:
game_ball.speed = [-3, 3]
def __init__(self, color):
self.color = color
self.towers = [tower.Tower(self.color)] * 100
self.walls = [wall.Wall(self.color)] * 100
