def __create_random_walls(self): random_walls_return = {} reserved_spaces = [[1, 1], [1, 2], [2, 1], [1, 6], [1, 7], [2, 7], [12, 1], [13, 1], [13, 2], [13, 6], [13, 7], [12, 7], [7, 4]] x = 1 y = 1 n = 0 n_walls = 25 model_wall = self.__model_wall[2] while True: x = randint(1, 13) y = randint(1, 7) if x % 2 == 1 or y % 2 == 1: # fixes walls if [x, y] not in reserved_spaces: n += 1 reserved_spaces.append([x, y]) wall = Wall( 0, [x * Server.wall_factor, y * Server.wall_factor], model_wall.get_id(), [55, 55], 255, self.__create_random_gift()) random_walls_return[wall.get_id()] = wall if n == n_walls: break return random_walls_return
def __init__(self, game_name): self.game_name = game_name # задаємо розміри екрану self.screen_width = 720 self.screen_height = 460 self.play_surface = pygame.display.set_mode( (self.screen_width, self.screen_height)) # необхідні кольори self.red = pygame.Color(255, 0, 0) self.green = pygame.Color(0, 255, 0) self.black = pygame.Color(0, 0, 0) self.white = pygame.Color(255, 255, 255) self.brown = pygame.Color(165, 42, 42) # задає кількість кадрів в секуну self.fps_controller = pygame.time.Clock() # змінна для відображення результату # (скільки їжі зїли) self.score = 0 pygame.display.set_caption(self.game_name) self.snake = Snake(self.green) self.food = Food(self.brown, self.screen_width, self.screen_height) self.wall = Wall(self.white) self.difficulty = 10 self.ratio = 10 self.playername = "Gamer" self.is_wall = False self.wall_start_time = None pygame.init()
def create_chamber(self, chamber): # make top and bottom walls for i in xrange(0, chamber.length): # syntactic sugar fst = chamber.start[0] + i snd = chamber.start[1] wall = Wall(fst * TILE_SIZE, snd * TILE_SIZE) self.walls[fst][snd] = 1 self.wall_list.add(wall) fst = chamber.start[0] + i snd = chamber.start[1] + chamber.height - 1 wall = Wall(fst * TILE_SIZE, snd * TILE_SIZE) self.walls[fst][snd] = 1 self.wall_list.add(wall) # make side walls for i in xrange(0, chamber.height): fst = chamber.start[0] snd = chamber.start[1] + i wall = Wall(fst * TILE_SIZE, snd * TILE_SIZE) self.walls[fst][snd] = 1 self.wall_list.add(wall) fst = chamber.start[0] + chamber.length - 1 snd = chamber.start[1] + i wall = Wall(fst * TILE_SIZE, snd * TILE_SIZE) self.walls[fst][snd] = 1 self.wall_list.add(wall) # fill in floor for x in xrange(1, chamber.length - 1): for y in range(1, chamber.height - 1): self.floor[chamber.start[0] + x][chamber.start[1] + y] = 1
def __init__(self, screen_rect): self.wall_group = list() rect = pygame.rect.Rect((0, 0), (10, screen_rect.h)) rect.topright = screen_rect.topright self.wall_group.append(Wall(rect)) rect = pygame.rect.Rect((0, 0), (screen_rect.w, 10)) rect.bottomleft = screen_rect.bottomleft self.wall_group.append(Wall(rect)) rect = pygame.rect.Rect((0, 0), (10, screen_rect.h)) rect.topleft = screen_rect.topleft self.wall_group.append(Wall(rect)) rect = pygame.rect.Rect((0, 0), (screen_rect.w, 10)) rect.topleft = screen_rect.topleft self.wall_group.append(Wall(rect)) self.ball_group = list() for i in range(50): b = Ball((random.randint(0, screen_rect.w), random.randint(0, screen_rect.h))) if not any(Physics.is_circle_collision(b, ball) for ball in self.ball_group): self.ball_group.append(b) self.physics = Physics() self.physics.solids.extend(self.wall_group) self.physics.mobiles.extend(self.ball_group)
def __init__(self): self.__arena = Arena() self.__wall = Wall(self.__arena) self.__snake = Snake(self.__arena) self.__movement = Movement(self.__arena, self.__snake) self.cls() self.gameloop()
def __init__(self, game): """init and position the wall""" # we use only white dragons for building the wall. We could actually # use any tile because the face is never shown anyway. self.initWindMarkers() game.wall = self Wall.__init__(self, game) self.__square = Board(1, 1, Tileset.current()) self.__square.setZValue(ZValues.markerZ) sideLength = len(self.tiles) // 8 self.__sides = [ UIWallSide(Tileset.current(), boardRotation, sideLength) for boardRotation in self.sideAngles ] for idx, side in enumerate(self.__sides): side.setParentItem(self.__square) side.lightSource = self.lightSource side.windTile = Wind.all4[idx].marker side.windTile.hide() side.message = YellowText(side) side.message.setZValue(ZValues.popupZ) side.message.setVisible(False) side.message.setPos(side.center()) self.__sides[self.Lower].setPos(yWidth=sideLength) self.__sides[self.Left].setPos(xHeight=1) self.__sides[self.Upper].setPos(xHeight=1, xWidth=sideLength, yHeight=1) self.__sides[self.Right].setPos(xWidth=sideLength, yWidth=sideLength, yHeight=1) Internal.scene.addItem(self.__square) Internal.Preferences.addWatch('showShadows', self.showShadowsChanged)
class GameState(object): def __init__(self, screen): self.screen = screen self.score = 0 self.is_gameover = True self.is_paused = False self.time_interval = GameConfig.TIMER_INTERVAL self.piece = None self.next_piece = None self.wall = Wall(self.screen) def new_piece(self): self.piece = self.next_piece shape = GameConfig.SHAPES[random.randint(0, len(GameConfig.SHAPES) - 1)] self.next_piece = Piece(self.screen, shape, self.wall) def add_score(self, elimiate_lines): self.score += elimiate_lines * GameConfig.SCORE_PER_LINE def start(self): self.score = 0 self.is_gameover = False self.is_paused = False self.new_piece() self.new_piece() self.wall.clear() self.set_timer() def restart(self): self.start() def gameover(self): self.is_gameover = True self.clear_timer() def pause(self): self.is_paused = True self.clear_timer() def resume(self): self.is_paused = False self.set_timer() def set_timer(self): pygame.time.set_timer(pygame.USEREVENT, self.time_interval) def clear_timer(self): pygame.time.set_timer(pygame.USEREVENT, 0) def judge(self): elimiate_lines = self.wall.elimiate_lines() self.add_score(elimiate_lines) for i in range(GameConfig.COLUMN_NUM): if self.wall.is_wall(0, i): self.gameover() return self.new_piece()
def open_door(self, player, current_room): if player.rect.x - door[0] > -100: #Door opens if player comes close self.wall_list = None self.wall_list = py.sprite.Group() block = copy.deepcopy(walls) #makes deep copy block.append(secret) #adds secret door #Add list of walls to wall_list from superclass Room for item in block: wall = Wall(item[0], item[1], item[2], item[3], item[4]) self.wall_list.add(wall) #Declare door open self.door_open = True if len(current_room.enemies ) <= 1: #Secret door opens after two orc killed self.wall_list = None self.wall_list = py.sprite.Group() block = copy.deepcopy(walls) #makes deep copy #Add list of walls to wall_list from superclass Room for item in block: wall = Wall(item[0], item[1], item[2], item[3], item[4]) self.wall_list.add(wall) #Declare door open self.secret_open = True
def get_center_wall(ai_settings, screen): """Returns a wall with it's centerx and centery equal to that of the screen's.""" screen_rect = screen.get_rect() center_wall = Wall(ai_settings, screen) center_wall.centerx = screen_rect.centerx center_wall.centery = screen_rect.centery return center_wall
def draw_room_from_point(self, grid, x, y, size): len = size for i in range(len): grid.place_agent(Wall(i, self), (x + i, y)) grid.place_agent(Wall(i, self), (x + i, y - len)) grid.place_agent(Wall(i, self), (x, y - i)) grid.place_agent(Wall(i, self), (x + len, y - i))
def makeMaze(mazeColumn, mazeRow): grid = [[0] * mazeColumn for _ in range(mazeRow)] for r in range(0, mazeRow): for c in range(0, mazeColumn): top, left = Wall(), Wall() if r != 0: top = grid[r - 1][c].getWalls()[2] if c != 0: left = grid[r][c - 1].getWalls()[1] grid[r][c] = Cell([top, Wall(), Wall(), left]) for wall in grid[r][c].getWalls(): wall.addOwner(grid[r][c]) maze = [] wallsToDo = [] random.random() randomCell = grid[random.randint(0, mazeRow - 1)][random.randint(0, mazeColumn - 1)] maze.append(randomCell) for i in range(0, 4): wallsToDo.append(randomCell.getWalls()[i]) while len(maze) < mazeColumn * mazeRow: randomWall = random.choice(wallsToDo) if len(randomWall.owner) > 1 and (maze.count(randomWall.owner[0]) == 0 or maze.count(randomWall.owner[1]) == 0): randomWall.breakWall() newOwner = randomWall.owner[0 if maze.count(randomWall.owner[0]) == 0 else 1] maze.append(newOwner) for i in range(0, 4): if newOwner.getWalls()[i].exists: wallsToDo.append(newOwner.getWalls()[i]) wallsToDo.remove(randomWall) if len(wallsToDo) == 0: print("GOT STUCK") return makeMaze(mazeColumn, mazeRow) return grid
def __init__(self): random.seed(time.time()) random.seed(123) pygame.init() pygame.font.init() self.font = pygame.font.SysFont('Comic Sans MS', 200) self.window = pygame.display.set_mode( (self.WINDOW_LENGTH, self.WINDOW_HEIGHT)) self.clock = pygame.time.Clock() self.running = True self.piecesName = [] self.objects = [] self.objects.append( Player(self.PLAYER1_NAME, self.PLAYER1_START_POS, self.PLAYER1_KEYS, self.PLAYER1_COLOR, self)) self.objects.append( Player(self.PLAYER2_NAME, self.PLAYER2_START_POS, self.PLAYER2_KEYS, self.PLAYER2_COLOR, self)) self.piecesName = [] self.generatePieces() self.objects.append(Wall("LEFT", self.piecesName, self)) self.objects.append(Wall("RIGHT", self.piecesName, self))
def load(self): self._map = {} self._tiles = {} self._attributes = {} file = Files.openFile(self._file) self._attributes = self.loadAttributes('attribs', file) self._enemies = self.loadAttributes('enemies', file) self.w = self.getAttr("w") * const.res self.h = self.getAttr("h") * const.res self._display = Display(Surface((self.w, self.h)), klass=self, transparent=True) file = re.search("map: {(.*?)}", file, flags=re.DOTALL).group(1) for tile in re.finditer(r"\((.*?):(.*?)\)", file): rect, right = tile.group(1), tile.group(2) rect = re.match(r"(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)", rect) if not rect: raise Exception("Unrecognized pattern: {}".format(rect)) details = re.match(r"(\d+),(\d+)$", right) if not details: raise Exception("Unrecognized pattern: {}".format(right)) i, e = int(rect.group(1)), int(rect.group(2)) x, y, w, h = rect.group(3), rect.group(4), rect.group(5), rect.group(6) x, y, w, h = int(x), int(y), int(w), int(h) typ, tile = int(details.group(1)), int(details.group(2)) attrib = {} wall = Wall((x, y, w, h), typ, tile, attrib) wall.subscribe("map", self._updateMap) self._map[(i, e)] = wall self._tiles.setdefault(wall.getType(), []).append(wall)
def play(self): """ Sets up our scene and executes the game loop. """ self.is_running = True self.is_building_wall = False self.balls = [] color = (255, 255, 255) self.walls = [Wall((1, 1), (self.width-1, 1), color), # ceiling Wall((1, 1), (1, self.height-1), color), # left wall Wall((1, self.height-1), (self.width-1, self.height-1), color), # floor Wall((self.width-1, 1), (self.width-1, self.height-1), color)] # right wall last_frame_time = time.time() while self.is_running: time_remaining = 1. / self.frames_per_second - (time.time() - last_frame_time) if time_remaining > 0: time.sleep(time_remaining) current_frame_time = time.time() dt = current_frame_time - last_frame_time dt = max(0.00001, min(dt, 0.1)) last_frame_time = current_frame_time self.event_handler() self.update(dt) self.render()
def create_wall(self, player_number): """ Creates a new wall that the players cannot cross based on the last position that the player turned and the players current position. :param player_number: The index of the player who the wall is being created from. :return: a new Wall object. """ horizontal = self.wall_start[player_number][1] == self.characters[ player_number].get_y_pos() if horizontal: if self.wall_start[player_number][0] < self.characters[ player_number].get_x_pos(): new_wall = Wall(horizontal, self.wall_start[player_number][0], self.characters[player_number].get_x_pos(), self.characters[player_number].get_y_pos(), self.characters[player_number].get_color()) else: new_wall = Wall(horizontal, self.characters[player_number].get_x_pos(), self.wall_start[player_number][0], self.characters[player_number].get_y_pos(), self.characters[player_number].get_color()) else: if self.wall_start[player_number][1] < self.characters[ player_number].get_y_pos(): new_wall = Wall(horizontal, self.wall_start[player_number][0], self.wall_start[player_number][1], self.characters[player_number].get_y_pos(), self.characters[player_number].get_color()) else: new_wall = Wall(horizontal, self.wall_start[player_number][0], self.characters[player_number].get_y_pos(), self.wall_start[player_number][1], self.characters[player_number].get_color()) return new_wall
def __init__(self, game): """init and position the wall""" # we use only white dragons for building the wall. We could actually # use any tile because the face is never shown anyway. game.wall = self Wall.__init__(self, game) self.__square = Board(1, 1, Tileset.activeTileset()) self.__square.setZValue(ZValues.marker) sideLength = len(self.tiles) // 8 self.__sides = [UIWallSide( Tileset.activeTileset(), boardRotation, sideLength) for boardRotation in (0, 270, 180, 90)] for side in self.__sides: side.setParentItem(self.__square) side.lightSource = self.lightSource side.windTile = PlayerWind( East, Internal.scene.windTileset, parent=side) side.windTile.hide() side.nameLabel = QGraphicsSimpleTextItem('', side) side.message = YellowText(side) side.message.setZValue(ZValues.popup) side.message.setVisible(False) side.message.setPos(side.center()) self.__sides[0].setPos(yWidth=sideLength) self.__sides[3].setPos(xHeight=1) self.__sides[2].setPos(xHeight=1, xWidth=sideLength, yHeight=1) self.__sides[1].setPos(xWidth=sideLength, yWidth=sideLength, yHeight=1) self.__findOptimalFontHeight() Internal.scene.addItem(self.__square) Internal.Preferences.addWatch('showShadows', self.showShadowsChanged)
def __init__(self): pygame.init() pygame.display.set_caption("My Pong Game") self.screen = pygame.display.set_mode((800, 600)) self.running = True self.clock = pygame.time.Clock() self.walls = [Wall((10, 10), 780, 10), Wall((10, 580), 780, 10)] # Position and dimensions of walls self.background = pygame.Surface((800, 600)) self.background.fill(pygame.Color("#000000")) self.ball = Ball((400, 300)) self.font = pygame.font.Font(None, 50) control_scheme_1 = ControlScheme() control_scheme_1.up = pygame.K_w control_scheme_1.down = pygame.K_s control_scheme_2 = ControlScheme() control_scheme_2.up = pygame.K_UP control_scheme_2.down = pygame.K_DOWN self.bats = [ Bat((10, 200), 10, 100, control_scheme_1), Bat((780, 200), 10, 100, control_scheme_2) ] # Position and dimensions of paddles, their respective control schemes self.score = Score(self.font)
def __create_walls(self): self.__walls = [] for x in range(self.width()): self.__walls.append(Wall(x, 0)) self.__walls.append(Wall(x, self.height() - 1)) for y in range(1, self.height()): self.__walls.append(Wall(0, y)) self.__walls.append(Wall(self.width() - 1, y))
def create_initial_walls(self): """ Creates walls around the border of the map. :return: None """ self.walls.append(Wall(True, 0, 1280, 0, 'black')) self.walls.append(Wall(True, 0, 1280, 707, 'black')) self.walls.append(Wall(False, 0, 0, 720, 'black')) self.walls.append(Wall(False, 1280, 0, 720, 'black'))
def __init__(self, screen): self.screen = screen self.score = 0 self.is_gameover = True self.is_paused = False self.time_interval = GameConfig.TIMER_INTERVAL self.piece = None self.next_piece = None self.wall = Wall(self.screen)
def __init__(self, initial_wall_bitmap, mine_max_speed, mine_rad, are_mines_magnetic, ball_max_speed, ball_rad, initial_ball_poss, width_in_tiles, height_in_tiles, tile_width, tile_height, power_fill_speed, full_power_level, explosive_power_level, min_spawn_time, max_spawn_time, min_ball_added_mine_dist): self.initial_wall_bitmap = initial_wall_bitmap self.mine_max_speed = mine_max_speed self.mine_rad = mine_rad self.are_mines_magnetic = are_mines_magnetic self.ball_max_speed = ball_max_speed self.ball_rad = ball_rad self.initial_ball_poss = initial_ball_poss self.width_in_tiles = width_in_tiles self.height_in_tiles = height_in_tiles self.tile_width = tile_width self.tile_height = tile_height self.width = width_in_tiles * tile_width self.height = height_in_tiles * tile_height self.power_fill_speed = power_fill_speed self.full_power_level = full_power_level self.explosive_power_level = explosive_power_level self.min_spawn_time = min_spawn_time self.max_spawn_time = max_spawn_time self.min_ball_added_mine_dist = min_ball_added_mine_dist assert (self.min_ball_added_mine_dist > 0.0) assert (self.min_spawn_time > 0.0) assert (self.min_spawn_time <= self.max_spawn_time) assert (self.power_fill_speed > 0.0) assert (self.full_power_level > 0.0) assert (self.explosive_power_level is None or self.explosive_power_level >= self.full_power_level) area_in_tiles = width_in_tiles * height_in_tiles assert (len(initial_wall_bitmap) == area_in_tiles) assert (width_in_tiles > 0) assert (height_in_tiles > 0) assert (tile_width > 0.0) assert (tile_height > 0.0) assert (mine_max_speed > 0.0) assert (ball_max_speed > 0.0) assert (mine_rad > 0.0) assert (ball_rad > 0.0) wall = Wall(self) for i in range(len(initial_ball_poss)): pos = initial_ball_poss[i] assert (wall.is_circle_within_borders(pos, ball_rad)) # REM? assert (not wall.is_circle_collision(pos, ball_rad))
class Game: def __init__(self, preference): self.preference = preference self.display = pygame.display.set_mode(preference.display) pygame.display.set_caption("Bricks") # Game Properties self.running = True self.bricks = pygame.sprite.Group() self.wall = Wall(self) self.bullet = Bullet(self) pygame.init() self.start() self.main_loop() def main_loop(self): def update(): self._update() self._flip() while self.running: for event in pygame.event.get(): if event.type == pygame.QUIT: self.running = False if event.type == pygame.KEYUP and event.key == pygame.K_r: self.start() update() def start(self): brick = self.preference.brick margin = self.preference.margin self.bricks = pygame.sprite.Group() self.wall = Wall(self) self.bullet = Bullet(self) for x in range(self.preference.army[0]): for y in range(self.preference.army[1]): b = Brick(self, x * (brick[0] + margin[0]) + margin[0], y * (brick[1] + margin[1]) + margin[1]) self.bricks.add(b) def _update(self): self.wall.update() self.bricks.update() self.bullet.update() def _flip(self): self.display.fill((255, 255, 255)) self.wall.draw() self.bullet.draw() for brick in self.bricks: brick.draw() pygame.display.flip()
def __init__(self, grid, wall_inverse_ratio=10): self.width = grid.get_width() self.height = grid.get_height() self.grid = grid self.vertical_walls = [[ Wall(0, wall_inverse_ratio) for i in range(self.width + 1) ] for j in range(self.height)] self.horizontal_walls = [[ Wall(1, wall_inverse_ratio) for i in range(self.width) ] for j in range(self.height + 1)]
def create_wall(ai_settings, screen, walls, center_wall, column_number, row_number): """Specify the correct coordinates for the individual walls to spawn and Adds the new wall into the list(walls).""" new_wall = Wall(ai_settings, screen) new_wall.centerx = wall_get_x(ai_settings, new_wall.rect, column_number, center_wall) new_wall.centery = wall_get_y(ai_settings, new_wall.rect, row_number, center_wall) walls.add(new_wall)
def make_walls(self): self.obstacles.append( Wall(Point2D(0, 0), Point2D(self.minuature_width, 0))) self.obstacles.append( Wall(Point2D(0, 0), Point2D(0, self.minuature_height))) self.obstacles.append( Wall(Point2D(self.minuature_width, self.minuature_height), Point2D(self.minuature_width, 0))) self.obstacles.append( Wall(Point2D(self.minuature_width, self.minuature_height), Point2D(0, self.minuature_height)))
def generation_room(x_initial, y_initial, room): x = x_initial y = y_initial for i in range(len(room)): for j in range(len(room[0])): if room[i][j] == "f": pf = Floor(x, y, random.randint(0,5)) layer_0.add(pf) if room[i][j] == "w": pf = Wall(x, y, 4) layer_1.add(pf) if room[i][j] == "d": pf = Wall(x, y, 1) layer_2.add(pf) if room[i][j] == "v": pf = Wall(x, y, 2) layer_2.add(pf) if room[i][j] == "x": pf = Wall(x, y, 0) layer_0.add(pf) wall.append(pf) if room[i][j] == "u": pf = Wall(x, y, 3) layer_1.add(pf) r = random.randint(0, 100) if r <= 5: torch = Torch(x, y, 3) layer_1.add(torch) if room[i][j] == "c": r = random.randint(3, 10) if r >= 5: pf = Floor(x, y, 6) layer_0.add(pf) pf = Chest(x, y-6, random.randint(1, 2)) layer_1.add(pf) chest.append(pf) else: pf = Floor(x, y, 6) layer_0.add(pf) if room[i][j] == "z": pf = Monster_spawn(x, y) layer_0.add(pf) r = random.randint(2, 5) for i in range(r): x_ = random.randint(pf.rect.x-32, pf.rect.x+64) y_ = random.randint(pf.rect.y-32, pf.rect.y+64) pf = Monster(x_, y_, random.randint(1, 4)) layer_1.add(pf) layer_monster.add(pf) layer_all_monster_and_layer.add(pf) x += 32 x = x_initial y += 32
def divide(self): """divides a wall, building a living and and a dead end""" with MoveImmediate(): Wall.divide(self) for uiTile in self.tiles: # update graphics because tiles having been # in kongbox in a previous game # might not be there anymore. This gets rid # of the cross on them. uiTile.update() # move last two tiles onto the dead end: return self._placeLooseTiles()
def divide(self): """divides a wall, building a living end and a dead end""" with AnimationSpeed(): Wall.divide(self) for uiTile in self.tiles: # update graphics because tiles having been # in kongbox in a previous game # might not be there anymore. This gets rid # of the cross on them. uiTile.update() # move last two tiles onto the dead end: return self._placeLooseTiles()
def start(self): brick = self.preference.brick margin = self.preference.margin self.bricks = pygame.sprite.Group() self.wall = Wall(self) self.bullet = Bullet(self) for x in range(self.preference.army[0]): for y in range(self.preference.army[1]): b = Brick(self, x * (brick[0] + margin[0]) + margin[0], y * (brick[1] + margin[1]) + margin[1]) self.bricks.add(b)
def addRegularShape(center, radius, nSides): angleToTurn = 360 / nSides points = [] radiusVector = Vector(radius, 0) for x in range(nSides): point = center + radiusVector points.append(point) radiusVector = radiusVector.rotate(radians(angleToTurn)) for i in range(len(points)-1): walls.append(Wall(points[i], points[i+1], colour=BLACK, width=1)) walls.append(Wall(points[-1], points[0], colour=BLACK, width=1))
def create_map(): map = [] if guy.stage == 1: map_file = open('map1.json', 'r') elif guy.stage == 2: map_file = open('map2.json', 'r') elif guy.stage == 3: map_file = open('map3.json', 'r') map_data = json.load(map_file) map_file.close() tile_width = map_data['layers'][0]['width'] tile_height = map_data['layers'][0]['height'] tile_data = map_data['layers'][0]['data'] count = 0 for tile in tile_data: if tile in range (1,6): wall = Wall() wall.idx = count wall.x = 25 + 50 * (wall.idx % tile_width ) + 1000 wall.y = 25 + 50 * (tile_height - 1 - (wall.idx//tile_width)) + 1000 if tile == 2: wall.shape = wall.DOWN if tile == 3: wall.shape = wall.LEFT if tile == 4: wall.shape = wall.RIGHT if tile == 5: wall.shape = wall.UP map.append(wall) elif tile == 6: portal.x = 25 + 50 * (count % tile_width) + 1000 portal.y = 75 + 50 * (tile_height-1 - count // tile_width) + 1000 portal.dir = 0 elif tile == 7: portal.x = 75 + 50 * (count % tile_width) + 1000 portal.y = 25 + 50 * (tile_height-1 - count // tile_width) + 1000 portal.dir = 1 elif tile == 8: guy.initx = 25 + 50 * (count % tile_width) + 1000 guy.inity = 50 + 50 * (tile_height-1 - (count // tile_width)) + 1000 guy.x = guy.initx guy.y = guy.inity count += 1 return map
def __init__(self, preference): self.preference = preference self.display = pygame.display.set_mode(preference.display) pygame.display.set_caption("Bricks") # Game Properties self.running = True self.bricks = pygame.sprite.Group() self.wall = Wall(self) self.bullet = Bullet(self) pygame.init() self.start() self.main_loop()
def removePlayer(self, player): if abs(self.findDistance(player)) < self._wallSize: if abs(self.getSlope()) >= 1: changeInY = player.getPosition()[1] - self.getPoints()[1][1] player.setPosition( self.__nextWarp.getPoints()[0][0] + changeInY / self.getSlope(), self.__nextWarp.getPoints()[0][1] + changeInY) else: changeInX = player.getPosition()[0] - self.getPoints()[1][0] player.setPosition( self.__nextWarp.getPoints()[0][0] + changeInX, self.__nextWarp.getPoints()[0][1] + self.getSlope() * changeInX) wall = Wall(self.__nextWarp.getPoints()[0][0], self.__nextWarp.getPoints()[0][1], self.__nextWarp.getPoints()[1][0], self.__nextWarp.getPoints()[1][1]) wall.isEnabled(True) wall.removePlayer(player) player.move() wall.isEnabled(False) self.__thisRoom.unloadRoom() # Reloading the room fixes bugs with items being present when they shouldn't be self.__thisRoom.loadRoom() self.__thisRoom.unloadRoom() self.__nextRoom.loadRoom()
def __init__( self ): self.core = Core( 60, 1024, 768, "Ninja" ) self.intro = Intro() self.menu_background = Texture( "menu/background.png" ) self.menu_title = Menu_title() self.menu_play_button = Menu_play_button() self.menu_git_button = Menu_link_button( "menu/git.png", "https://github.com/Adriqun" ) self.menu_google_button = Menu_link_button( "menu/google.png", "https://en.wikipedia.org/wiki/Ninja" ) self.menu_facebook_button = Menu_link_button( "menu/facebook.png", "nothing", True ) self.menu_twitter_button = Menu_link_button( "menu/twitter.png", "nothing", True ) self.menu_music_button = Menu_music_button( "menu/music.png" ) self.menu_chunk_button = Menu_music_button( "menu/chunk.png", 1 ) self.menu_exit_log = Menu_exit_log() self.menu_author_log = Menu_author_log() self.menu_game_log = Menu_link_button( "menu/game.png", "nothing", True ) self.menu_settings_log = Menu_link_button( "menu/settings.png", "nothing", True ) self.menu_score_log = Menu_score_log() self.menu_music = Menu_music( "menu/Rayman Legends OST - Moving Ground.mp3" ) self.wall = Wall() self.hero = Hero() self.menu_log = Menu_log() self.map = Map()
def __init__(self): super(WallGame, self).__init__('Wall', WallGame.BLACK) self.arrow = [] for i in range(10): self.arrow.append(Arrow(key = random.randint(0,25), color = WallGame.WHITE , pos = (random.randint(800,1000), random.randint(50,350)), speed = 1)) self.wall = Wall(pos = (200,0), color = WallGame.WHITE) self.score = 0 self.count_speed_up = 0 self.count_speed_down = 0 self.dead = True
def notice_mail_day(to_id, li): from user_mail import mail_by_user_id to_user = Zsite.mc_get(to_id) name = to_user.name mail = mail_by_user_id(to_id) count = len(li) li_wall = [] _li_wall_reply = defaultdict(list) for from_id, cid, rid in li: from_user = Zsite.mc_get(from_id) if cid == CID_NOTICE_WALL: li_wall.append(from_user) elif cid == CID_NOTICE_WALL_REPLY: o = Wall.mc_get(rid) _li_wall_reply[rid].append(from_user) li_wall_reply = {} for rid, from_list in _li_wall_reply.iteritems(): o = Wall.mc_get(rid) li_wall_reply[o] = from_list if li_wall or li_wall_reply: subject = render_template( '/mail/notice/day_total.txt', count=count, li_wall=li_wall, li_wall_reply=li_wall_reply, ) rendermail( '/mail/notice/day_total.htm', mail, name, to_user=to_user, li_wall=li_wall, li_wall_reply=li_wall_reply, format='html', subject=subject, )
def fromJson(jsonData, player): backgroundTile = jsonData["backgroundTile"] walls = Wall.fromJson(jsonData["walls"]) location = jsonData["locationName"] ov = Overworld(backgroundTile, player, location, walls) for monster in jsonData['monsters']: center = (monster['location'][0] * 32 + 16, monster['location'][1] * 32 + 16) ov.addNPC(load_monster(monster['name'], center=center)) return ov
class Engine: #------------------------------------------------------------------------------------------------------- def __init__( self ): self.core = Core( 60, 1024, 768, "Ninja" ) self.intro = Intro() self.menu_background = Texture( "menu/background.png" ) self.menu_title = Menu_title() self.menu_play_button = Menu_play_button() self.menu_git_button = Menu_link_button( "menu/git.png", "https://github.com/Adriqun" ) self.menu_google_button = Menu_link_button( "menu/google.png", "https://en.wikipedia.org/wiki/Ninja" ) self.menu_facebook_button = Menu_link_button( "menu/facebook.png", "nothing", True ) self.menu_twitter_button = Menu_link_button( "menu/twitter.png", "nothing", True ) self.menu_music_button = Menu_music_button( "menu/music.png" ) self.menu_chunk_button = Menu_music_button( "menu/chunk.png", 1 ) self.menu_exit_log = Menu_exit_log() self.menu_author_log = Menu_author_log() self.menu_game_log = Menu_link_button( "menu/game.png", "nothing", True ) self.menu_settings_log = Menu_link_button( "menu/settings.png", "nothing", True ) self.menu_score_log = Menu_score_log() self.menu_music = Menu_music( "menu/Rayman Legends OST - Moving Ground.mp3" ) self.wall = Wall() self.hero = Hero() self.menu_log = Menu_log() self.map = Map() #------------------------------------------------------------------------------------------------------- def load( self ): self.core.setState( -1 ) self.intro.load( self.core.getWidth(), self.core.getHeight() ) self.menu_title.load( self.core.getWidth() ) self.menu_play_button.load( self.core.getWidth(), self.core.getHeight() ) self.menu_git_button.load( self.core.getWidth(), 10 ) self.menu_google_button.load( self.core.getWidth(), self.menu_git_button.getBot() ) self.menu_facebook_button.load( self.core.getWidth(), self.menu_google_button.getBot() ) self.menu_twitter_button.load( self.core.getWidth(), self.menu_facebook_button.getBot() ) self.menu_music_button.load( 10 ) self.menu_chunk_button.load( self.menu_music_button.getBot() ) self.menu_exit_log.load( self.core.getWidth(), self.core.getHeight() ) self.menu_author_log.load( self.menu_play_button.getLeft()+5, self.core.getWidth(), self.menu_title.getBot() +150, self.menu_play_button.getBot() ) self.menu_game_log.load( self.menu_author_log.getRight(), self.menu_play_button.getBot() +10, True ) self.menu_settings_log.load( self.menu_game_log.getRight(), self.menu_play_button.getBot() +10, True ) self.menu_score_log.load( self.menu_settings_log.getRight(), self.core.getWidth(), self.menu_title.getBot() +150, self.menu_play_button.getBot() ) self.wall.load() self.hero.load( self.core.getWidth(), self.core.getHeight() ) self.menu_log.load( self.core.getWidth(), self.core.getHeight() ) self.map.load() #------------------------------------------------------------------------------------------------------- def handle( self ): for event in pygame.event.get(): if event.type == pygame.QUIT: self.core.setQuit() #------------------------------------------------------------------------------------------------------- if self.core.getState() == 0: if self.menu_play_button.getState() == 0: self.menu_exit_log.handle( event ) #HANDLE IF AUTHOR BUTTON == OFF AND SCORE BUTTON == OFF if self.menu_author_log.getState() == 0 and self.menu_score_log.getState() == 0: self.menu_play_button.handle( event ) self.menu_git_button.handle( event ) self.menu_google_button.handle( event ) self.menu_music_button.handle( event ) self.menu_chunk_button.handle( event ) if self.menu_score_log.getState() == 0: self.menu_author_log.handle( event ) if self.menu_author_log.getState() == 0: self.menu_score_log.handle( event ) #------------------------------------------------------------------------------------------------------- if self.core.getState() == 1: self.menu_log.handle( event ) #HANDLE IF MENU_LOG == OFF if self.menu_log.getState() == 0: self.hero.handle( event ) #------------------------------------------------------------------------------------------------------- def states( self ): #-------------------------------------------------------------------------------------------------------STATE -1 if self.core.getState() == -1: self.intro.draw( self.core.getWindow() ) if self.intro.getQuit(): self.intro.free() del self.intro self.menu_music.play()#MENU MUSIC self.core.setState( 0 ) #-------------------------------------------------------------------------------------------------------STATE 0 if self.core.getState() == 0: #FADE IN if self.menu_play_button.getState() != 1 and self.menu_exit_log.getState() == 0: self.menu_background.fadein( 5 ) self.menu_title.fadein( 5 ) self.menu_play_button.fadein( 5 ) self.menu_git_button.fadein( 5 ) self.menu_google_button.fadein( 5 ) self.menu_facebook_button.fadein( 5 ) self.menu_twitter_button.fadein( 5 ) self.menu_music_button.fadein( 5 ) self.menu_chunk_button.fadein( 5 ) self.menu_author_log.fadein( 5 ) self.menu_game_log.fadein( 5 ) self.menu_settings_log.fadein( 5 ) self.menu_score_log.fadein( 5 ) self.menu_music.setVolume( 1.0 ) #DRAW ALWAYS IN MENU STATE self.menu_background.draw( self.core.getWindow() ) self.menu_title.draw( self.core.getWindow() ) self.menu_exit_log.draw( self.core.getWindow() ) #DRAW IF AUTHOR BUTTON == OFF AND SCORE BUTTON == OFF if self.menu_author_log.getState() == 0 and self.menu_score_log.getState() == 0: self.menu_git_button.draw( self.core.getWindow() ) self.menu_google_button.draw( self.core.getWindow() ) self.menu_facebook_button.draw( self.core.getWindow() ) self.menu_twitter_button.draw( self.core.getWindow() ) self.menu_play_button.draw( self.core.getWindow() ) self.menu_music_button.draw( self.core.getWindow() ) self.menu_chunk_button.draw( self.core.getWindow() ) self.menu_game_log.draw( self.core.getWindow() ) self.menu_settings_log.draw( self.core.getWindow() ) if self.menu_score_log.getState() == 0: self.menu_author_log.draw( self.core.getWindow() ) if self.menu_author_log.getState() == 0: self.menu_score_log.draw( self.core.getWindow() ) #IF USER TURN ON/OFF CHUNKS if self.menu_chunk_button.getState(): self.menu_play_button.setState() self.menu_git_button.setState() self.menu_google_button.setState() self.menu_music_button.setState() self.menu_chunk_button.setState() self.menu_author_log.setState() self.menu_score_log.setState() #IF USER TURN ON/OFF MUSIC if self.menu_music_button.getState(): self.menu_music.pause() #IF USER PRESS Q - EXIT if self.menu_exit_log.getState() == 1: self.menu_background.fadeout( 6, 120 ) self.menu_title.fadeout( 6, 120 ) self.menu_play_button.fadeout( 6, 120 ) self.menu_git_button.fadeout( 6, 120 ) self.menu_google_button.fadeout( 6, 120 ) self.menu_facebook_button.fadeout( 6, 120 ) self.menu_twitter_button.fadeout( 6, 120 ) self.menu_music_button.fadeout( 6, 120 ) self.menu_chunk_button.fadeout( 6, 120 ) self.menu_author_log.fadeout( 6, 120 ) self.menu_game_log.fadeout( 6, 120 ) self.menu_settings_log.fadeout( 6, 120 ) self.menu_score_log.fadeout( 6, 120 ) self.menu_music.setVolume( 0.3 ) elif self.menu_exit_log.getState() == 2: self.menu_background.fadeout( 6 ) self.menu_title.fadeout( 6 ) self.menu_play_button.fadeout( 6 ) self.menu_git_button.fadeout( 6 ) self.menu_google_button.fadeout( 6 ) self.menu_facebook_button.fadeout( 6 ) self.menu_twitter_button.fadeout( 6 ) self.menu_music_button.fadeout( 6 ) self.menu_chunk_button.fadeout( 6 ) self.menu_author_log.fadeout( 6 ) self.menu_game_log.fadeout( 6 ) self.menu_settings_log.fadeout( 6 ) self.menu_score_log.fadeout( 6 ) if self.menu_exit_log.getState() == 2 and self.menu_background.getAlpha() == 0: self.core.setQuit() #IF USER CLICK PLAY BUTTON if self.menu_play_button.getState() == 1: self.menu_background.fadeout( 6 ) self.menu_title.fadeout( 6 ) self.menu_play_button.fadeout( 6 ) self.menu_git_button.fadeout( 6 ) self.menu_google_button.fadeout( 6 ) self.menu_facebook_button.fadeout( 6 ) self.menu_twitter_button.fadeout( 6 ) self.menu_music_button.fadeout( 6 ) self.menu_chunk_button.fadeout( 6 ) self.menu_author_log.fadeout( 6 ) self.menu_game_log.fadeout( 6 ) self.menu_settings_log.fadeout( 6 ) self.menu_score_log.fadeout( 6 ) if self.menu_music.isPaused() == False: self.menu_music.fadeOut() if self.menu_play_button.getAlpha() == 0: self.menu_play_button.setNext( 0 ) self.core.setState( 1 ) #-------------------------------------------------------------------------------------------------------STATE 1 if self.core.getState() == 1: #FADE IN IF PAUSE BUTTON == OFF AND MENU_LOG == OFF if self.menu_log.getState() == 0: self.wall.fadein( 5 ) self.hero.fadein( 5 ) self.map.fadein( 5 ) elif self.menu_log.getState() == 1: self.wall.fadeout( 6, 130 ) self.hero.fadeout( 6, 130 ) self.map.fadeout( 6, 130 ) elif self.menu_log.getState() == 2: self.wall.fadeout( 6 ) self.hero.fadeout( 6 ) self.map.fadeout( 6 ) if self.wall.getAlpha() == 0: self.menu_log.setState( 0 ) if self.menu_music.isPaused() == False: self.menu_music.play() self.core.setState( 0 ) #Back to menu #DRAW self.wall.draw( self.core.getWindow() ) self.hero.draw( self.core.getWindow() ) self.menu_log.draw( self.core.getWindow() ) self.map.draw( self.core.getWindow() ) def loop( self ): while not self.core.isQuit(): self.handle() self.core.fillDisplay() self.states() self.core.tickClock() pygame.display.update() def quit( self ): pygame.quit()
class WallGame(gamelib.SimpleGame): BLACK = pygame.Color('black') WHITE = pygame.Color('white') GREEN = pygame.Color('green') def __init__(self): super(WallGame, self).__init__('Wall', WallGame.BLACK) self.arrow = [] for i in range(10): self.arrow.append(Arrow(key = random.randint(0,25), color = WallGame.WHITE , pos = (random.randint(800,1000), random.randint(50,350)), speed = 1)) self.wall = Wall(pos = (200,0), color = WallGame.WHITE) self.score = 0 self.count_speed_up = 0 self.count_speed_down = 0 self.dead = True def init(self): super(WallGame, self).init() self.render_score() def update(self): if self.dead is True: for i in self.arrow: i.move() if self.is_key_pressed(i.key_press(i.get_key())): i.remove() self.score += 1 self.render_score() self.count_speed_up += 1 if i.get_x() < 200: i.remove() self.score -= 5 self.render_score() self.count_speed_down += 1 if self.count_speed_up == 10: i.speed_up() self.count_speed_up = 0 if self.count_speed_down == 100: i.speed_down() self.count_speed_down = 0 if self.score < 0: self.is_dead() def is_dead(self): self.dead = False self.render_dead() self.score = 0 self.render_score() def render_dead(self): self.dead_image = self.font.render("BooM Your Dead!!!", 0,WallGame.WHITE) def render_score(self): self.score_image = self.font.render("Score = %d" % self.score, 0, WallGame.WHITE) def render_key(self): for i in self.arrow: i.key_image = self.font.render("%c" % i.key_arrow(i.get_key()), 0, WallGame.WHITE) def render(self, surface): surface.blit(self.score_image, (10,10)) if self.dead is False: surface.blit(self.dead_image,(300,150)) self.render_key() for i in self.arrow: surface.blit(i.key_image, (i.get_x(),i.get_y())) self.wall.render(surface)
def update(self): Wall.update(self)
def __init__(self, canvas, jenkins): Wall.__init__(self, canvas, jenkins)
class Game(object): """the game without GUI""" # pylint: disable=R0902 # pylint we need more than 10 instance attributes def __del__(self): """break reference cycles""" self.clearHand() if self.players: for player in self.players[:]: self.players.remove(player) del player self.players = [] self.__activePlayer = None self.prevActivePlayer = None self.__winner = None self.myself = None if self.client: self.client.game = None self.client = None def __init__(self, names, ruleset, gameid=None, wantedGame=None, shouldSave=True, client=None): """a new game instance. May be shown on a field, comes from database if gameid is set Game.lastDiscard is the tile last discarded by any player. It is reset to None when a player gets a tile from the living end of the wall or after he claimed a discard. """ # pylint: disable=R0915 # pylint we need more than 50 statements self.players = Players() # if we fail later on in init, at least we can still close the program self._client = None self.client = client self.rotated = 0 self.notRotated = 0 # counts hands since last rotation self.ruleset = None self.roundsFinished = 0 self._currentHandId = None self._prevHandId = None self.seed = 0 self.randomGenerator = CountingRandom(self) if self.isScoringGame(): self.wantedGame = str(wantedGame) self.seed = wantedGame else: self.wantedGame = wantedGame _ = int(wantedGame.split('/')[0]) if wantedGame else 0 self.seed = _ or int(self.randomGenerator.random() * 10**9) self.shouldSave = shouldSave self.__setHandSeed() self.activePlayer = None self.__winner = None self.moves = [] self.myself = None # the player using this client instance for talking to the server self.gameid = gameid self.playOpen = False self.autoPlay = False self.handctr = 0 self.roundHandCount = 0 self.handDiscardCount = 0 self.divideAt = None self.lastDiscard = None # always uppercase self.visibleTiles = IntDict() self.discardedTiles = IntDict(self.visibleTiles) # tile names are always lowercase self.dangerousTiles = list() self.csvTags = [] self._setGameId() self.__useRuleset(ruleset) # shift rules taken from the OEMC 2005 rules # 2nd round: S and W shift, E and N shift self.shiftRules = 'SWEN,SE,WE' field = Internal.field if field: field.game = self field.startingGame = False field.showWall() # sets self.wall else: self.wall = Wall(self) self.assignPlayers(names) if self.belongsToGameServer(): self.__shufflePlayers() if not self.isScoringGame() and '/' in self.wantedGame: roundsFinished, rotations, notRotated = self.__scanGameOption(self.wantedGame) for _ in range(roundsFinished * 4 + rotations): self.rotateWinds() self.notRotated = notRotated if self.shouldSave: self.saveNewGame() if field: self.__initVisiblePlayers() field.updateGUI() self.wall.decorate() @property def client(self): """hide weakref""" if self._client is not None: return self._client() @client.setter def client(self, value): """hide weakref""" if value is None: self._client = None else: self._client = weakref.ref(value) def __scanGameOption(self, wanted): """scan the --game option. Return roundsFinished, rotations, notRotated""" part = wanted.split('/')[1] roundsFinished = 'ESWN'.index(part[0]) if roundsFinished > self.ruleset.minRounds: logWarning('Ruleset %s has %d minimum rounds but you want round %d(%s)' % ( self.ruleset.name, self.ruleset.minRounds, roundsFinished + 1, part[0])) return self.ruleset.minRounds, 0 rotations = int(part[1]) - 1 notRotated = 0 if rotations > 3: logWarning('You want %d rotations, reducing to maximum of 3' % rotations) return roundsFinished, 3, 0 for char in part[2:]: if char < 'a': logWarning('you want %s, changed to a' % char) char = 'a' if char > 'z': logWarning('you want %s, changed to z' % char) char = 'z' notRotated = notRotated * 26 + ord(char) - ord('a') + 1 return roundsFinished, rotations, notRotated @property def winner(self): """the name of the game server this game is attached to""" return self.__winner @winner.setter def winner(self, value): """the name of the game server this game is attached to""" if self.__winner != value: if self.__winner: self.__winner.invalidateHand() self.__winner = value if value: value.invalidateHand() def addCsvTag(self, tag, forAllPlayers=False): """tag will be written to tag field in csv row""" if forAllPlayers or self.belongsToHumanPlayer(): self.csvTags.append('%s/%s' % (tag, self.handId())) def isFirstHand(self): """as the name says""" return self.roundHandCount == 0 and self.roundsFinished == 0 def handId(self, withAI=True, withMoveCount=False): """identifies the hand for window title and scoring table""" aiVariant = '' if withAI and self.belongsToHumanPlayer(): aiName = self.client.intelligence.name() if aiName != 'Default': aiVariant = aiName + '/' num = self.notRotated charId = '' while num: charId = chr(ord('a') + (num-1) % 26) + charId num = (num-1) / 26 if self.finished(): wind = 'X' else: wind = WINDS[self.roundsFinished] result = '%s%s/%s%s%s' % (aiVariant, self.seed, wind, self.rotated + 1, charId) if withMoveCount: result += '/moves:%d' % len(self.moves) if result != self._currentHandId: self._prevHandId = self._currentHandId self._currentHandId = result return result def _setGameId(self): """virtual""" assert not self # we want it to fail, and quiten pylint def close(self): """log off from the server and return a Deferred""" Internal.autoPlay = False # do that only for the first game self.__hideGame() if self.client: client = self.client self.client = None result = client.logout() client.delete() else: result = succeed(None) return result def __hideGame(self): """remove all visible traces of the current game""" field = Internal.field if isAlive(field): field.setWindowTitle('Kajongg') if field: field.discardBoard.hide() field.selectorBoard.tiles = [] field.selectorBoard.allSelectorTiles = [] if isAlive(field.centralScene): field.centralScene.removeTiles() field.clientDialog = None for player in self.players: if player.handBoard: player.clearHand() player.handBoard.hide() if self.wall: self.wall.hide() self.wall = None self.lastDiscard = None if field: field.actionAutoPlay.setChecked(False) field.startingGame = False field.game = None field.updateGUI() def __initVisiblePlayers(self): """make players visible""" for idx, player in enumerate(self.players): player.front = self.wall[idx] player.clearHand() player.handBoard.setVisible(True) scoring = self.isScoringGame() player.handBoard.setEnabled(scoring or \ (self.belongsToHumanPlayer() and player == self.myself)) player.handBoard.showMoveHelper(scoring) Internal.field.adjustView() def setConcealedTiles(self, allPlayerTiles): """when starting the hand. tiles is one string""" with Animated(False): for playerName, tileNames in allPlayerTiles: player = self.playerByName(playerName) player.addConcealedTiles(self.wall.deal(tileNames)) def playerByName(self, playerName): """return None or the matching player""" if playerName is None: return None for myPlayer in self.players: if myPlayer.name == playerName: return myPlayer logException('Move references unknown player %s' % playerName) def losers(self): """the 3 or 4 losers: All players without the winner""" return list([x for x in self.players if x is not self.__winner]) def belongsToRobotPlayer(self): """does this game instance belong to a robot player?""" return self.client and self.client.isRobotClient() def belongsToHumanPlayer(self): """does this game instance belong to a human player?""" return self.client and self.client.isHumanClient() def belongsToGameServer(self): """does this game instance belong to the game server?""" return self.client and self.client.isServerClient() @staticmethod def isScoringGame(): """are we scoring a manual game?""" return False def belongsToPlayer(self): """does this game instance belong to a player (as opposed to the game server)?""" return self.belongsToRobotPlayer() or self.belongsToHumanPlayer() def assignPlayers(self, playerNames): """the server tells us the seating order and player names""" pairs = [] for idx, pair in enumerate(playerNames): if isinstance(pair, basestring): wind, name = WINDS[idx], pair else: wind, name = pair pairs.append((wind, name)) field = Internal.field if not self.players: if field: self.players = field.genPlayers() else: self.players = Players([Player(self) for idx in range(4)]) for idx, pair in enumerate(pairs): wind, name = pair player = self.players[idx] Players.createIfUnknown(name) player.wind = wind player.name = name else: for idx, pair in enumerate(playerNames): wind, name = pair self.players.byName(name).wind = wind if self.client and self.client.name: self.myself = self.players.byName(self.client.name) self.sortPlayers() def assignVoices(self): """now we have all remote user voices""" assert self.belongsToHumanPlayer() available = Voice.availableVoices()[:] # available is without transferred human voices for player in self.players: if player.voice and player.voice.oggFiles(): # remote human player sent her voice, or we are human and have a voice if Debug.sound and player != self.myself: logDebug('%s got voice from opponent: %s' % (player.name, player.voice)) else: player.voice = Voice.locate(player.name) if player.voice: if Debug.sound: logDebug('%s has own local voice %s' % (player.name, player.voice)) if player.voice: for voice in Voice.availableVoices(): if voice in available and voice.md5sum == player.voice.md5sum: # if the local voice is also predefined, # make sure we do not use both available.remove(voice) # for the other players use predefined voices in preferred language. Only if # we do not have enough predefined voices, look again in locally defined voices predefined = [x for x in available if x.language() != 'local'] predefined.extend(available) for player in self.players: if player.voice is None and predefined: player.voice = predefined.pop(0) if Debug.sound: logDebug('%s gets one of the still available voices %s' % (player.name, player.voice)) def __shufflePlayers(self): """assign random seats to the players and assign winds""" self.players.sort(key=lambda x:x.name) self.randomGenerator.shuffle(self.players) for player, wind in zip(self.players, WINDS): player.wind = wind def __exchangeSeats(self): """execute seat exchanges according to the rules""" windPairs = self.shiftRules.split(',')[(self.roundsFinished-1) % 4] while len(windPairs): windPair = windPairs[0:2] windPairs = windPairs[2:] swappers = list(self.players[windPair[x]] for x in (0, 1)) if self.belongsToPlayer(): # we are a client in a remote game, the server swaps and tells us the new places shouldSwap = False elif self.isScoringGame(): # we play a manual game and do only the scoring shouldSwap = Internal.field.askSwap(swappers) else: # we are the game server. Always swap in remote games. # do not do assert self.belongsToGameServer() here because # self.client might not yet be set - this code is called for all # suspended games but self.client is assigned later shouldSwap = True if shouldSwap: swappers[0].wind, swappers[1].wind = swappers[1].wind, swappers[0].wind self.sortPlayers() def sortPlayers(self): """sort by wind order. If we are in a remote game, place ourself at bottom (idx=0)""" players = self.players if Internal.field: fieldAttributes = list([(p.handBoard, p.front) for p in players]) players.sort(key=lambda x: 'ESWN'.index(x.wind)) if self.belongsToHumanPlayer(): myName = self.myself.name while players[0].name != myName: values0 = players[0].values for idx in range(4, 0, -1): this, prev = players[idx % 4], players[idx - 1] this.values = prev.values players[1].values = values0 self.myself = players[0] if Internal.field: for idx, player in enumerate(players): player.handBoard, player.front = fieldAttributes[idx] player.handBoard.player = player self.activePlayer = self.players['E'] @staticmethod def _newGameId(): """write a new entry in the game table and returns the game id of that new entry""" with Transaction(): query = Query("insert into game(seed) values(0)") gameid, gameidOK = query.query.lastInsertId().toInt() assert gameidOK return gameid def saveNewGame(self): """write a new entry in the game table with the selected players""" if self.gameid is None: return if not self.isScoringGame(): records = Query("select seed from game where id=?", list([self.gameid])).records assert records if not records: return seed = records[0][0] if not Internal.isServer and self.client: host = self.client.connection.url else: host = None if self.isScoringGame() or seed == 'proposed' or seed == host: # we reserved the game id by writing a record with seed == hostname starttime = datetime.datetime.now().replace(microsecond=0).isoformat() args = list([starttime, self.seed, int(self.autoPlay), self.ruleset.rulesetId]) args.extend([p.nameid for p in self.players]) args.append(self.gameid) with Transaction(): Query("update game set starttime=?,seed=?,autoplay=?," \ "ruleset=?,p0=?,p1=?,p2=?,p3=? where id=?", args) if not Internal.isServer: Query('update server set lastruleset=? where url=?', list([self.ruleset.rulesetId, host])) def __useRuleset(self, ruleset): """use a copy of ruleset for this game, reusing an existing copy""" self.ruleset = ruleset self.ruleset.load() query = Query('select id from ruleset where id>0 and hash="%s"' % \ self.ruleset.hash) if query.records: # reuse that ruleset self.ruleset.rulesetId = query.records[0][0] else: # generate a new ruleset self.ruleset.save(copy=True, minus=False) def __setHandSeed(self): """set seed to a reproducable value, independent of what happend in previous hands/rounds. This makes it easier to reproduce game situations in later hands without having to exactly replay all previous hands""" if self.seed is not None: seedFactor = (self.roundsFinished + 1) * 10000 + self.rotated * 1000 + self.notRotated * 100 self.randomGenerator.seed(self.seed * seedFactor) def clearHand(self): """empty all data""" if self.moves: for move in self.moves: del move self.moves = [] for player in self.players: player.clearHand() self.__winner = None self.__activePlayer = None self.prevActivePlayer = None Hand.clearCache(self) self.dangerousTiles = list() self.discardedTiles.clear() assert self.visibleTiles.count() == 0 def prepareHand(self): """prepares the next hand""" self.clearHand() if self.finished(): self.close() else: if not self.isScoringGame(): self.sortPlayers() self.hidePopups() self.__setHandSeed() self.wall.build() def initHand(self): """directly before starting""" Hand.clearCache(self) self.dangerousTiles = list() self.discardedTiles.clear() assert self.visibleTiles.count() == 0 if Internal.field: Internal.field.prepareHand() self.__setHandSeed() def hidePopups(self): """hide all popup messages""" for player in self.players: player.hidePopup() def saveHand(self): """save hand to database, update score table and balance in status line""" self.__payHand() self.__saveScores() self.handctr += 1 self.notRotated += 1 self.roundHandCount += 1 self.handDiscardCount = 0 def __needSave(self): """do we need to save this game?""" if self.isScoringGame(): return True elif self.belongsToRobotPlayer(): return False else: return self.shouldSave # as the server told us def __saveScores(self): """save computed values to database, update score table and balance in status line""" if not self.__needSave(): return scoretime = datetime.datetime.now().replace(microsecond=0).isoformat() for player in self.players: if player.hand: manualrules = '||'.join(x.rule.name for x in player.hand.usedRules) else: manualrules = m18n('Score computed manually') Query("INSERT INTO SCORE " "(game,hand,data,manualrules,player,scoretime,won,prevailing,wind," "points,payments, balance,rotated,notrotated) " "VALUES(%d,%d,?,?,%d,'%s',%d,'%s','%s',%d,%d,%d,%d,%d)" % \ (self.gameid, self.handctr, player.nameid, scoretime, int(player == self.__winner), WINDS[self.roundsFinished % 4], player.wind, player.handTotal, player.payment, player.balance, self.rotated, self.notRotated), list([player.hand.string, manualrules])) if Debug.scores: self.debug('%s: handTotal=%s balance=%s %s' % ( player, player.handTotal, player.balance, 'won' if player == self.winner else '')) for usedRule in player.hand.usedRules: rule = usedRule.rule if rule.score.limits: tag = rule.function.__class__.__name__ if hasattr(rule.function, 'limitHand'): tag = rule.function.limitHand.__class__.__name__ self.addCsvTag(tag) def savePenalty(self, player, offense, amount): """save computed values to database, update score table and balance in status line""" if not self.__needSave(): return scoretime = datetime.datetime.now().replace(microsecond=0).isoformat() with Transaction(): Query("INSERT INTO SCORE " "(game,penalty,hand,data,manualrules,player,scoretime," "won,prevailing,wind,points,payments, balance,rotated,notrotated) " "VALUES(%d,1,%d,?,?,%d,'%s',%d,'%s','%s',%d,%d,%d,%d,%d)" % \ (self.gameid, self.handctr, player.nameid, scoretime, int(player == self.__winner), WINDS[self.roundsFinished % 4], player.wind, 0, amount, player.balance, self.rotated, self.notRotated), list([player.hand.string, offense.name])) if Internal.field: Internal.field.updateGUI() def maybeRotateWinds(self): """rules which make winds rotate""" result = list(x for x in self.ruleset.filterFunctions('rotate') if x.rotate(self)) if result: if Debug.explain: if not self.belongsToRobotPlayer(): self.debug(result, prevHandId=True) self.rotateWinds() return bool(result) def rotateWinds(self): """rotate winds, exchange seats. If finished, update database""" self.rotated += 1 self.notRotated = 0 if self.rotated == 4: if not self.finished(): self.roundsFinished += 1 self.rotated = 0 self.roundHandCount = 0 if self.finished(): endtime = datetime.datetime.now().replace(microsecond=0).isoformat() with Transaction(): Query('UPDATE game set endtime = "%s" where id = %d' % \ (endtime, self.gameid)) elif not self.belongsToPlayer(): # the game server already told us the new placement and winds winds = [player.wind for player in self.players] winds = winds[3:] + winds[0:3] for idx, newWind in enumerate(winds): self.players[idx].wind = newWind if self.roundsFinished % 4 and self.rotated == 0: # exchange seats between rounds self.__exchangeSeats() def debug(self, msg, btIndent=None, prevHandId=False): """prepend game id""" if self.belongsToRobotPlayer(): prefix = 'R' elif self.belongsToHumanPlayer(): prefix = 'C' elif self.belongsToGameServer(): prefix = 'S' else: logDebug(msg, btIndent=btIndent) return logDebug('%s%s: %s' % (prefix, self._prevHandId if prevHandId else self.handId(), msg), withGamePrefix=False, btIndent=btIndent) @staticmethod def __getNames(record): """get name ids from record and return the names""" names = [] for idx in range(4): nameid = record[idx] try: name = Players.allNames[nameid] except KeyError: name = m18n('Player %1 not known', nameid) names.append(name) return names @classmethod def loadFromDB(cls, gameid, client=None): """load game by game id and return a new Game instance""" Internal.logPrefix = 'S' if Internal.isServer else 'C' qGame = Query("select p0,p1,p2,p3,ruleset,seed from game where id = %d" % gameid) if not qGame.records: return None rulesetId = qGame.records[0][4] or 1 ruleset = Ruleset.cached(rulesetId) Players.load() # we want to make sure we have the current definitions game = cls(Game.__getNames(qGame.records[0]), ruleset, gameid=gameid, client=client, wantedGame=qGame.records[0][5]) qLastHand = Query("select hand,rotated from score where game=%d and hand=" "(select max(hand) from score where game=%d)" % (gameid, gameid)) if qLastHand.records: (game.handctr, game.rotated) = qLastHand.records[0] qScores = Query("select player, wind, balance, won, prevailing from score " "where game=%d and hand=%d" % (gameid, game.handctr)) # default value. If the server saved a score entry but our client did not, # we get no record here. Should we try to fix this or exclude such a game from # the list of resumable games? prevailing = 'E' for record in qScores.records: playerid = record[0] wind = str(record[1]) player = game.players.byId(playerid) if not player: logError( 'game %d inconsistent: player %d missing in game table' % \ (gameid, playerid)) else: player.getsPayment(record[2]) player.wind = wind if record[3]: game.winner = player prevailing = record[4] game.roundsFinished = WINDS.index(prevailing) game.handctr += 1 game.notRotated += 1 game.maybeRotateWinds() game.sortPlayers() game.wall.decorate() return game def finished(self): """The game is over after minRounds completed rounds""" if self.ruleset: # while initialising Game, ruleset might be None return self.roundsFinished >= self.ruleset.minRounds def __payHand(self): """pay the scores""" # pylint: disable=R0912 # too many branches winner = self.__winner if winner: winner.wonCount += 1 guilty = winner.usedDangerousFrom if guilty: payAction = self.ruleset.findUniqueOption('payforall') if guilty and payAction: if Debug.dangerousGame: self.debug('%s: winner %s. %s pays for all' % \ (self.handId(), winner, guilty)) guilty.hand.usedRules.append((payAction, None)) score = winner.handTotal score = score * 6 if winner.wind == 'E' else score * 4 guilty.getsPayment(-score) winner.getsPayment(score) return for player1 in self.players: if Debug.explain: if not self.belongsToRobotPlayer(): self.debug('%s: %s' % (player1, player1.hand.string)) for line in player1.hand.explain(): self.debug(' %s' % (line)) for player2 in self.players: if id(player1) != id(player2): if player1.wind == 'E' or player2.wind == 'E': efactor = 2 else: efactor = 1 if player2 != winner: player1.getsPayment(player1.handTotal * efactor) if player1 != winner: player1.getsPayment(-player2.handTotal * efactor) def lastMoves(self, only=None, without=None, withoutNotifications=False): """filters and yields the moves in reversed order""" for idx in range(len(self.moves)-1, -1, -1): move = self.moves[idx] if withoutNotifications and move.notifying: continue if only: if move.message in only: yield move elif without: if move.message not in without: yield move else: yield move def throwDices(self): """sets random living and kongBox sets divideAt: an index for the wall break""" if self.belongsToGameServer(): self.wall.tiles.sort(key=tileKey) self.randomGenerator.shuffle(self.wall.tiles) breakWall = self.randomGenerator.randrange(4) sideLength = len(self.wall.tiles) // 4 # use the sum of four dices to find the divide self.divideAt = breakWall * sideLength + \ sum(self.randomGenerator.randrange(1, 7) for idx in range(4)) if self.divideAt % 2 == 1: self.divideAt -= 1 self.divideAt %= len(self.wall.tiles) def dangerousFor(self, forPlayer, tile): """returns a list of explaining texts if discarding tile would be Dangerous game for forPlayer. One text for each reason - there might be more than one""" if isinstance(tile, Tile): tile = tile.element tile = tile.lower() result = [] for dang, txt in self.dangerousTiles: if tile in dang: result.append(txt) for player in forPlayer.others(): for dang, txt in player.dangerousTiles: if tile in dang: result.append(txt) return result def computeDangerous(self, playerChanged=None): """recompute gamewide dangerous tiles. Either for playerChanged or for all players""" self.dangerousTiles = list() if playerChanged: playerChanged.findDangerousTiles() else: for player in self.players: player.findDangerousTiles() self._endWallDangerous() def _endWallDangerous(self): """if end of living wall is reached, declare all invisible tiles as dangerous""" if len(self.wall.living) <=5: allTiles = [x for x in defaultdict.keys(elements.occurrence) if x[0] not in 'fy'] # see http://www.logilab.org/ticket/23986 invisibleTiles = set(x for x in allTiles if x not in self.visibleTiles) msg = m18n('Short living wall: Tile is invisible, hence dangerous') self.dangerousTiles = list(x for x in self.dangerousTiles if x[1] != msg) self.dangerousTiles.append((invisibleTiles, msg)) def appendMove(self, player, command, kwargs): """append a Move object to self.moves""" self.moves.append(Move(player, command, kwargs))
def __init__(self, names, ruleset, gameid=None, wantedGame=None, shouldSave=True, client=None): """a new game instance. May be shown on a field, comes from database if gameid is set Game.lastDiscard is the tile last discarded by any player. It is reset to None when a player gets a tile from the living end of the wall or after he claimed a discard. """ # pylint: disable=R0915 # pylint we need more than 50 statements self.players = Players() # if we fail later on in init, at least we can still close the program self._client = None self.client = client self.rotated = 0 self.notRotated = 0 # counts hands since last rotation self.ruleset = None self.roundsFinished = 0 self._currentHandId = None self._prevHandId = None self.seed = 0 self.randomGenerator = CountingRandom(self) if self.isScoringGame(): self.wantedGame = str(wantedGame) self.seed = wantedGame else: self.wantedGame = wantedGame _ = int(wantedGame.split('/')[0]) if wantedGame else 0 self.seed = _ or int(self.randomGenerator.random() * 10**9) self.shouldSave = shouldSave self.__setHandSeed() self.activePlayer = None self.__winner = None self.moves = [] self.myself = None # the player using this client instance for talking to the server self.gameid = gameid self.playOpen = False self.autoPlay = False self.handctr = 0 self.roundHandCount = 0 self.handDiscardCount = 0 self.divideAt = None self.lastDiscard = None # always uppercase self.visibleTiles = IntDict() self.discardedTiles = IntDict(self.visibleTiles) # tile names are always lowercase self.dangerousTiles = list() self.csvTags = [] self._setGameId() self.__useRuleset(ruleset) # shift rules taken from the OEMC 2005 rules # 2nd round: S and W shift, E and N shift self.shiftRules = 'SWEN,SE,WE' field = Internal.field if field: field.game = self field.startingGame = False field.showWall() # sets self.wall else: self.wall = Wall(self) self.assignPlayers(names) if self.belongsToGameServer(): self.__shufflePlayers() if not self.isScoringGame() and '/' in self.wantedGame: roundsFinished, rotations, notRotated = self.__scanGameOption(self.wantedGame) for _ in range(roundsFinished * 4 + rotations): self.rotateWinds() self.notRotated = notRotated if self.shouldSave: self.saveNewGame() if field: self.__initVisiblePlayers() field.updateGUI() self.wall.decorate()
def __init__(self, mapSize, display, character_size, theworld): # Initialize the sprite base class super(Map, self).__init__() # Set our image to a new surface, the size of the World Map self.display = display self.mapSize = mapSize logging.debug ("mapSize is {0}".format(self.mapSize)) self.character_size = character_size self.image = Surface(self.mapSize) # Fill the image with a green colour (specified as R,G,B) self.image.fill(colors.BLACK) self.world = theworld self.walls = [] # List to hold the walls self.wallgrid = [[[] for x in range(self.world.cols)] for y in range(self.world.rows)] # [y][x] grid of arrays of walls in that grid square self.arts = [] # list to hold the arts self.shapes = [] # list to hold the shapes #print "DEBUG: Map.__init__(): rendering world:\n{0}".format(theworld.to_s()) self.grid_cellheight = grid_cellheight = int(mapSize[1] / theworld.rows) self.grid_cellwidth = grid_cellwidth = int(mapSize[0] / theworld.cols) logging.debug ("cell size is {0} wide x {1} high".format(grid_cellwidth, grid_cellheight)) self.displayGridSize = (int(display.getDisplaySize()[0] / grid_cellwidth), int(display.getDisplaySize()[1] / grid_cellheight)) # NEXT: render the world map from the 'world' class argument for worldObj in sorted(theworld.objects, key=lambda obj: pacdefs.RENDER_ORDER[obj.type]): pacglobal.checkAbort() logging.debug ("rendering the next world object: {0}".format(worldObj)) if worldObj.type == pacdefs.TYPE_PATH: left = worldObj.left * grid_cellwidth top = worldObj.top * grid_cellheight if worldObj.direction_h: right = (worldObj.left+worldObj.length) * grid_cellwidth bottom = (worldObj.top+worldObj.width) * grid_cellheight else: right = (worldObj.left+worldObj.width) * grid_cellwidth bottom = (worldObj.top+worldObj.length) * grid_cellheight width = right - left height = bottom - top rect = (left, top, width, height) pygame.draw.rect(self.image, (111,111,111), rect) elif worldObj.type == pacdefs.TYPE_ART: # let the sprite manager draw it pass elif worldObj.type == pacdefs.TYPE_INTERSECTION: # draw a grey rectangle left = worldObj.left * grid_cellwidth top = worldObj.top * grid_cellheight width = worldObj.width * grid_cellwidth height = worldObj.height * grid_cellheight #right = (worldObj['left']+worldObj['width']) * grid_cellwidth #bottom = (worldObj['top']+worldObj['length']) * grid_cellheight #topLt = (left, top) #topRt = (right, top) #bottomLt = (left, bottom) #bottomRt = (right, bottom) rect = (left, top, width, height) logging.debug ("intersection rect at {0}".format(rect)) pygame.draw.rect(self.image, (222,222,222), rect) elif worldObj.type == pacdefs.TYPE_FIELD: # draw a brown rectangle left = worldObj.left * grid_cellwidth top = worldObj.top * grid_cellheight width = worldObj.width * grid_cellwidth height = worldObj.height * grid_cellheight rect = (left, top, width, height) #print "DEBUG: field rect at {0}".format(rect) pygame.draw.rect(self.image, (160,82,45), rect) elif worldObj.type == pacdefs.TYPE_ROOM: # calculate corners & dimensions left = worldObj.left * grid_cellwidth top = worldObj.top * grid_cellheight width = worldObj.width * grid_cellwidth height = worldObj.height * grid_cellheight right = left + width bottom = top + height logging.debug ("rendering ROOM {4} [vert={0}..{1}, horiz={2}..{3}]".format(top,bottom,left,right,worldObj.id)) # define interior & paint it rect = (left, top, width, height) #print "DEBUG: room rect at {0}".format(rect) pygame.draw.rect(self.image, colors.BLUE, rect) #DEBUG MODE: draw the objectId in the middle #font = pygame.font.Font(None, 20) #textBitmap = font.render(str(worldObj.id), True, colors.BLACK) #self.image.blit(textBitmap, [left+(width/2), top+(height/2)]) # draw 4 walls roomWalls = {} # dictionary of side to array of wallDefs (each wallDef is a tuple of 2 points, each one an (x,y) tuple) # draw walls that have doors in them #NOTE: assumes no more than one door per wall num_doors = len(worldObj.doors.keys()) if num_doors > 1: logging.debug ("multiple doors! Room has {0} doors.".format(num_doors)) for side,doorpos in worldObj.doors.items(): #need to keep track of which sides have been processed, #add the defaults later for walls with no doors doorx = doorpos[0] doory = doorpos[1] logging.debug ("rendering ROOM {0} has a door at {1} on side {2}".format(worldObj.id,doorpos,side)) if side == pacdefs.SIDE_N: doorLeft = doorx * grid_cellwidth doorRight = (doorx+1) * grid_cellwidth # add 2 walls, on either side of the door roomWalls[side] = [] roomWalls[side].append([(left,top), (doorLeft,top)]) roomWalls[side].append([(doorRight,top), (right,top)]) if side == pacdefs.SIDE_E: doorTop = doory * grid_cellheight doorBottom = (doory+1) * grid_cellheight logging.debug ("rendering ROOM door top/bottom is {0}/{1}".format(doorTop,doorBottom)) # add 2 walls, on either side of the door roomWalls[side] = [] roomWalls[side].append([(right,top), (right,doorTop)]) roomWalls[side].append([(right,doorBottom), (right,bottom)]) if side == pacdefs.SIDE_S: doorLeft = doorx * grid_cellwidth doorRight = (doorx+1) * grid_cellwidth # add 2 walls, on either side of the door roomWalls[side] = [] roomWalls[side].append([(left,bottom), (doorLeft,bottom)]) roomWalls[side].append([(doorRight,bottom), (right,bottom)]) if side == pacdefs.SIDE_W: doorTop = doory * grid_cellheight doorBottom = (doory+1) * grid_cellheight # add 2 walls, on either side of the door roomWalls[side] = [] roomWalls[side].append([(left,top), (left,doorTop)]) roomWalls[side].append([(left,doorBottom), (left,bottom)]) # end of for each door (creating walls w/ doors) # check all directions and add a default wall if none is defined for side in pacdefs.SIDES: if side not in roomWalls.keys() or len(roomWalls[side]) == 0: logging.debug ("drawing default wall for side {0}".format(side)) roomWalls[side] = [] if side == pacdefs.SIDE_N: roomWalls[side].append([(left,top), (right,top)]) if side == pacdefs.SIDE_E: roomWalls[side].append([(right,top), (right, bottom)]) if side == pacdefs.SIDE_S: roomWalls[side].append([(right,bottom), (left,bottom)]) if side == pacdefs.SIDE_W: roomWalls[side].append([(left,bottom), (left,top)]) for walls in roomWalls.values(): for wallPoints in walls: # create the wall def newwall = Wall(self.mapSize, wallPoints[0], wallPoints[1]) # add to walls array self.addWall( newwall ) # draw on image newwall.draw(self.image) # draw a border, registering each line as a wall topLt = (0, 0) topRt = (self.mapSize[0], 0) botLt = (0, self.mapSize[1]) botRt = (self.mapSize[0], self.mapSize[1]) wallDefs = [ (topLt, topRt), (topRt, botRt), (botRt, botLt), (botLt, topLt) ] for wallPoints in wallDefs: newwall = Wall(self.mapSize, wallPoints[0], wallPoints[1]) # create the wall def self.addWall( newwall ) # add to walls array and index newwall.draw(self.image) # draw on image # Create the sprite rectangle from the image self.rect = self.image.get_rect() # holds current effects happening on the map self.effects = [] # array of Effects
def __init__(self, canvas, jenkins_url, views): Wall.__init__(self, canvas, jenkins_url) self.views = views
from Tkinter import * from wall import Wall from table import Table width = 384 height = 512 ball_radius = 16 root = Tk() table = Table(width, height) wall1 = Wall(0,height/5,width*0.6,height*0.8) wall1.setBlockingPixels(ball_radius, table) w = Canvas(root, width=width, height = height) w.create_line(wall1.x1, wall1.y1, wall1.x2, wall1.y2, fill="#1010FF") w.pack() root.mainloop()
def __init__(self, left, top): Wall.__init__(self, left, top) self.image, self.rect = load_image('wall.png', None) self.image = pygame.transform.scale(self.image, cfg.obstacle_size ) self.rect.size = cfg.obstacle_size self.rect.topleft = left, top
def __init__(self, canvas, jenkins_url, score_view, dbname): Wall.__init__(self, canvas, jenkins_url) self.funnycats = FunnyCats(self.jenkins, score_view, dbname) self.funnycats.init() self.users_score = None