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