def run(self):
while True:
self.event()
self.show()
self.level.traffic(self.player)
if self.level.failed(self.player):
pygame.mixer.Sound.play(self.l_sound)
if not self.health.loose_health():
self.reset_game()
else:
time.sleep(1)
self.player.reset()
self.level = Level(self.screen, self.player,
self.path_height)
self.clean_events()
self.player.image = self.player.u_image
pygame.mixer.Sound.stop(self.l_sound)
if self.player.player_won():
self.score.add_score()
self.creat_text("Level completed!", (0, 255, 0))
pygame.mixer.Sound.play(self.w_sound)
time.sleep(1)
self.player.reset()
self.level = Level(self.screen, self.player, self.path_height)
self.player.image = self.player.u_image
def GameEntry():
pygame.init()
size = (RESOLUTION_X, RESOLUTION_Y)
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Port in a Storm")
clock = pygame.time.Clock()
levelProps = LevelProperties("Test level", 1)
initialLevel = Level(levelProps, 15, 11, [], "levels/level1.tmx",
"dialog/01begin.txt", None) # hardcoding rip
levelProps2 = LevelProperties("Test level", 1)
initialLevel2 = Level(levelProps2, 15, 11, [], "levels/level2.tmx",
"dialog/02begin.txt", None) # hardcoding rip
levelProps3 = LevelProperties("Test level", 1)
initialLevel3 = Level(levelProps3, 15, 11, [], "levels/level3.tmx",
"dialog/03begin.txt", None) # hardcoding rip
levelProps4 = LevelProperties("Test level", 1)
initialLevel4 = Level(levelProps4, 15, 11, [], "levels/001.tmx", None,
None) # hardcoding rip
levelProps5 = LevelProperties("Test level", 1)
initialLevel5 = Level(levelProps5, 15, 11, [], "levels/level_a1.tmx",
"dialog/dialog_test.txt",
"dialog/dialog_test_end.txt") # hardcoding rip
# levelProps6 = LevelProperties("Test level", 1)
# initialLevel6 = Level(levelProps6, 15, 11, [], "levels/003.tmx", "dialog/dialog_test.txt", "dialog/dialog_test_end.txt") # hardcoding rip
game = Game([
initialLevel, initialLevel2, initialLevel3, initialLevel4,
initialLevel5
])
# --- Main event loop
while True:
if not game.HandleInputEvents():
break
game.GameTick()
game.Render(screen)
clock.tick(60)
pygame.quit()
def get_users_level() -> Level:
try:
level = int(input("In what level do you want to play? Type in the number(1 for level 1, 2 for...): "))
if not 1 <= level <= 5:
print("there are only levels from one to five\n")
return Level(is_valid=False)
except ValueError:
print("We did not understand your input.")
return Level(is_valid=False)
return Level(
level=level,
limits=get_level_limits(level),
user_lives=get_users_lives(level),
is_valid=True
)
def _initLevel(self):
Game.currentLevel = Level('default', ['objects.dat'])
columnCount = int(
math.ceil(Game.currentLevel.rect.width / Game.CollisionBlockSize))
rowCount = int(
math.ceil(Game.currentLevel.rect.height / Game.CollisionBlockSize))
for row in range(rowCount):
blocks = []
for col in range(columnCount):
blocks.append(set([]))
Game.CollisionMap.append(blocks)
Game.Player = Player(ObjectType.ObjectTypes['player'], flipped=False)
self._mapObject(
Object(ObjectType.ObjectTypes['block'], position=(0, 512)))
self._mapObject(
Object(ObjectType.ObjectTypes['block'], position=(150, 450)))
self._mapObject(
Object(ObjectType.ObjectTypes['block'], position=(150, 450 - 88)))
self._mapObject(
Object(ObjectType.ObjectTypes['block'], position=(150, 450 - 176)))
self._mapObject(
Object(ObjectType.ObjectTypes['block'], position=(500, 300)))
self._mapObject(
Object(ObjectType.ObjectTypes['block'], position=(600, 520)))
self._mapObject(
Object(ObjectType.ObjectTypes['block'], position=(660, 300)))
self._mapObject(Game.Player)
Game.Player.objectType.width -= 1
Game.Player.objectType.height -= 2
def test_graph():
level = Level([
[1, 0, 3],
[6, 0, 2],
[0, 0, 0]
])
assert list(level.graph.nodes) == [(0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
def load_level(path: str) -> Level:
blocks = pygame.sprite.Group()
length = 0
spawn = (0, 0)
y = -1
with open(path) as f:
for row in f:
y += 1
x = -1
for block in row:
x += 1
rect = pygame.Rect(x * BLOCK_SIZE, y * BLOCK_SIZE,
BLOCK_SIZE, BLOCK_SIZE)
if block == '1':
image = IMAGE_SOLID
elif block == '2':
image = IMAGE_DEADLY
elif block == 'x':
spawn = (x * BLOCK_SIZE, y * BLOCK_SIZE)
continue
else:
continue
sprite = Block(int(block), rect, image)
blocks.add(sprite)
if x > length:
length = x
return Level(blocks, length * BLOCK_SIZE, spawn)
def addOrder(self,
isBuy=None,
orderId=None,
price=None,
qty=None,
peakSize=None,
order=None):
'''| TODO
| Creates and adds an order to the map of orders. In addition, pointer to the order is added to the proper map (bid/ask) and
| vector (price level). The maps are ordered, therefore, inserting elements with price as keys, automatically builds a correct
| depth of the book.
| Note: best bid is the last element (price level) of the bid map; best ask is the first element (price level) of the ask map.
|________'''
# Already checked that an order with the same Id is not present in the book
myOrder = Order(isBuy, orderId, price, qty,
peakSize) if order == None else order
self.activeOrders[myOrder.orderId] = myOrder
# TODO: Where do we deal with int*100 price as keys?
key_price = int(myOrder.price * 100)
level = self.bid if myOrder.isBuy else self.ask
if key_price not in level:
level[key_price] = Level()
level[key_price].addOrder(myOrder)
def redrawAll(self, screen):
screen.blit(self.background, [-150, 0])
self.mouse = pygame.mouse.get_pos()
self.click = pygame.mouse.get_pressed()
if 540 > self.mouse[0] > 390 and 640 > self.mouse[1] > 580:
pygame.draw.rect(self.screen, (153, 153, 255), (390, 580, 150, 60))
if self.click[0] == 1:
Level().run()
else:
pygame.draw.rect(self.screen, (0, 102, 204), (390, 580, 150, 60))
#hover over instruction
if 320 > self.mouse[0] > 190 and 640 > self.mouse[1] > 580:
pygame.draw.rect(self.screen, (153, 153, 255), (190, 580, 130, 60))
if self.click[0] == 1:
Instructions().run()
else:
pygame.draw.rect(self.screen, (0, 102, 204), (190, 580, 130, 60))
self.buttonFont = pygame.font.Font("freesansbold.ttf", 20)
self.buttonText = self.buttonFont.render("Choose Level", True,
(0, 0, 255))
self.screen.blit(self.buttonText, (400, 600))
self.instruction = self.buttonFont.render("Instruction", True,
(0, 0, 255))
self.screen.blit(self.instruction, (200, 600))
def __init__(self):
# Initialization
pygame.init()
self.DISPSURF = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
self.FPSCLOCK = pygame.time.Clock()
# Load the level
levelFile = open('level1.txt')
levelData = levelFile.read()
self.level = Level(levelData)
# Create pacman and the ghosts
self.pac = Pacman()
blinky = Blinky()
pinky = Pinky()
inky = Inky()
clyde = Clyde()
self.entities = {
self.pac.name: self.pac,
blinky.name: blinky,
clyde.name: clyde,
inky.name: inky,
pinky.name: pinky
}
# Scatter timer
pygame.time.set_timer(USEREVENT + 1, 5000)
self.quit = False
def __init__(self):
pygame.init()
pygame.mixer.init()
self.screen = pygame.display.set_mode((896, 896))
self.screen_rect = self.screen.get_rect()
self.font = pygame.font.Font(None, 50)
self.font2 = pygame.font.Font(None, 25)
self.won = False
self.lost = False
pygame.display.set_caption("Bobby The Destroyer")
self.clock = pygame.time.Clock()
this_folder = os.path.dirname(os.path.abspath(__file__))
my_file = os.path.join(this_folder, 'maze_old.txt')
self.level = Level(self.screen, my_file)
self.player = Player(self.screen, 1, 1, self.level)
self.guard = Guard(self.screen, 12, 1, self.player, self.level)
self.bombs = []
self.numfin = 0
self.bombs.append(Bomb(self.screen, 3, 5, self.player, self.guard))
self.bombs.append(Bomb(self.screen, 3, 8, self.player, self.guard))
self.bombs.append(Bomb(self.screen, 10, 7, self.player, self.guard))
self.bombs.append(Bomb(self.screen, 10, 6, self.player, self.guard))
self.bombs.append(Bomb(self.screen, 12, 2, self.player, self.guard))
self.bombs.append(Bomb(self.screen, 12, 10, self.player, self.guard))
self.bombs.append(Bomb(self.screen, 7, 3, self.player, self.guard))
self.bombs.append(Bomb(self.screen, 7, 10, self.player, self.guard))
self.game_active = True
self.bg = PhotoRect(self.screen, "background", 896, 896)
def __init__(self):
self.pencil = Pencil()
self.level = Level(1)
self.affichage = Affichage()
self.player = self.get_user()
self.nb_python = 0
self.db = Database()
def __init__(self, withinTTH=False):
FSM.__init__(self, "FNAFBase")
self.withinTTH = withinTTH
if not self.withinTTH:
base.cogFont = loader.loadFont('data/vtRemingtonPortable.ttf')
base.accept("escape", self.handleEsc)
base.accept("f9", self.screenshot)
else:
from toontown.toonbase import ToontownGlobals
base.cogFont = ToontownGlobals.getSuitFont()
base.level = Level()
base.timer = Timer()
base.camControls = CameraControls()
if not self.withinTTH:
self.handleGotPhases()
self.ray = CollisionRay()
cNode = CollisionNode('mousePicker')
cNode.addSolid(self.ray)
cNode.setCollideMask(BitMask32(8))
self.cnp = base.cam.attachNewNode(cNode)
self.handler = CollisionHandlerQueue()
self.clickTrav = CollisionTraverser('cTrav')
self.clickTrav.addCollider(self.cnp, self.handler)
base.accept('mouse1', self.__handleClick)
self.night = 1
def resetGame(mySnake):
# Recreate Level 1
nibble.level = 1
global currentLevel
currentLevel = Level(1, nibble.total_columns, nibble.total_lines)
# Draw level
nibble.drawLevel(currentLevel)
# Zero out total score
nibble.score = 0
# Reset snake's attributes
mySnake.resetSnake(nibble.center_x, nibble.center_y)
mySnake.lives = 3
# Zero the apples eaten
global apples_eaten
apples_eaten = 0
# Show the first Apple
global apple
apple = Apple(nibble.total_columns, nibble.total_lines, currentLevel,
mySnake)
pygame.draw.rect(
nibble.screen, (0, 255, 0),
pygame.Rect(apple.getX(), apple.getY(), mySnake.size, mySnake.size), 0)
def __init__(self):
#*************** основное window ***************
self.win_width = settings.WIDTH_WIN # Ширина окна
self.win_height = settings.HEIGHT_WIN # Высота окна
self.win_display = (self.win_width, self.win_height) # Компановка
self.timer = pygame.time.Clock() # Таймер кадров
#*************** инициализация объектов ***************
self.left = self.right = self.up = self.down = self.space = False
self.exit_ = True # флаг для выхода
self.windows = Windows() # инициализируем Windows
self.TARGET = pygame.USEREVENT
self.level1 = Level(settings.LEVEL_1) # Инициализируем level1
self.level1.load_level()
self.player = Player(
self.level1.ret_A()) # инициализируем Tank по карте
self.enemy = Enemy(self.level1.ret_B())
self.platforms = self.level1.ret_tiles()
self.end = (self.player.ret_topleft()[0] / 32,
self.player.ret_topleft()[1] / 32)
self.start = (self.level1.ret_B()[0] / 32, self.level1.ret_B()[1] / 32)
#*************** блоки спрайтов ***************
self.block_list = pygame.sprite.Group(
) #Это список спрайтов. Каждый блок добавляется в этот список.
self.all_sprites_list = pygame.sprite.Group(
) # # Это список каждого спрайта. Все блоки, а также блок игрока.
self.bullet_list = pygame.sprite.Group() #тес массив спрайтов пули
self.block_list.add(self.platforms)
self.all_sprites_list.add(self.player, self.enemy)
self.walls = []
for i in self.block_list:
x, y = i.rect.topleft
self.walls.append((x / 32, y / 32))
def make_levels(self):
""" Loop over files to visualize and make levels out of them """
dir = "./levels/"
levels = []
for file in os.listdir(dir):
src_lines = []
with open(dir + file) as src:
src_lines = [
x.replace("\t", " ").rstrip() for x in src.readlines()
] # Replace tabs with 2 spaces
sprites = self.make_platform_dimensions(src_lines)
enemies = self.make_enemy_dimensions(src_lines)
level_end = -(sprites[-1][2] + sprites[-1][0])
levels.append(Level(self.player, sprites, enemies, level_end,
file))
levels.append(Level(self.player, [], [], 0, ""))
return levels
def initLevel(level_set, level):
# Create an instance of this Level
global myLevel
myLevel = Level(level_set, level)
# Draw this level
gui.drawLevel(myLevel.getMatrix())
def startGame(self):
self.gameOverScreen.hide()
self.cleanup()
self.player = Player()
self.currentLevel = Level("testLevel")
def extract_levels_from_content(self, file):
self.levels = []
content = self.file_reader.read_content(file)
levels = self.load_levels(content)
for level in levels:
level_object = Level()
level_object.create_level(content, level)
self.levels.append(level_object)
return self.levels
def __init__(self, main):
self.main = main
self.levels = os.listdir(LEVEL_PATH)
self.levels.sort()
self.levelObjs = []
for level in self.levels:
self.levelObjs.append(Level(level, main))
for level in self.levelObjs:
level.data.load()
def test_move_enemies():
wyb = WatchYourBack(Level([[1, 0, 3], [6, 0, 2], [0, 0, 0]]))
wyb.move_enemies()
assert wyb.level.get_cell(1, 1) == ENEMY_ANT
assert wyb.status == GameStatus.ONGOING
wyb.move_enemies()
assert wyb.level.get_cell(1, 2) == ENEMY_ANT
assert wyb.status == GameStatus.PLAYER_LOST
def __init__(self):
self.levels = []
for i in blocksList:
for j in blocksList:
self.levels.append(Level(i, j))
self.levelCurrent = self.levels[0]
self.indexLevel = 1
self.maxLevel = len(self.levels)
self.status = GAME
def create_population(self):
ret = []
for i in range(self.population_size):
new_player = Player(step_size=self.step_size,
game=WatchYourBack(
Level(deepcopy(self.level_data))),
genes=None,
mutation_rate=self.mutation_rate)
ret.append(new_player)
return ret
def loadRandomLevel():
global current_level
global last_level
# TODO: Make more levels by rotation and mirroring
last_level = current_level
current_level = random.randint(min_level, max_level)
matrix = Level(level_set, current_level).matrix
matrix.moves = 0
matrix.actions = ""
return matrix
def initLevel(level_set, level):
# Create an instance of this Level
global myLevel
myLevel = Level(level_set, level)
# Draw this level
drawLevel(myLevel.getMatrix())
global target_found
target_found = False
def __init__(self):
self.screen = Screen(300, 300, 20)
self.level = Level(self.screen.sprite, self.screen)
self.level.items_cord()
self.guardian = Guardian(self.level)
self.player = Player(self.level, self.screen.sprite, self.screen, self.guardian)
self.needle = Items(self.level, "ressource/aiguille.png")
self.ether = Items(self.level, "ressource/ether.png")
self.syringue = Items(self.level, "ressource/seringue.png")
self.pipe = Items(self.level, "ressource/tube_plastique.png")
def test_move_player_without_enemy():
game = WatchYourBack(Level([[0, 0, 3], [2, 0, 0], [0, 0, 0]]))
player = Player(
step_size=3,
game=game,
genes=[PlayerAction.RIGHT, PlayerAction.RIGHT, PlayerAction.UP])
for i in range(0, 3):
assert player.status == GameStatus.ONGOING
player.move()
assert player.status == GameStatus.PLAYER_WON
def main():
""" Main loop """
continue_game = 1
while continue_game:
pygame.init()
w = pygame.display.set_mode((SIDE_PIXEL, SIDE_PIXEL))
continue_menu = 1
while continue_menu:
pygame.time.Clock().tick(30)
for event in pygame.event.get():
if event.type == QUIT:
continue_menu = 0
continue_game = 0
choice = 0
elif event.type == KEYDOWN:
if event.key == K_1:
continue_menu = 0
choice = "l1"
elif event.key == K_2:
continue_menu = 0
choice = "l2"
if choice != 0:
a = Level()
a.load_maze_from_file("resource\labyrinthe.txt")
a.randomize_item_maze(w)
mac_gyver = PersoMG("M")
guardian = Perso("G")
mac_gyver.get_position(a.structure)
guardian.get_position(a.structure)
a.display_maze(w)
pygame.display.flip()
continue_party = 1
while continue_party:
for event in pygame.event.get():
if event.type == QUIT:
continue_party = 0
continue_game = 0
if event.type == KEYDOWN:
if event.key == K_DOWN:
mac_gyver.move_position(a.structure, "low")
if event.key == K_UP:
mac_gyver.move_position(a.structure, "high")
if event.key == K_LEFT:
mac_gyver.move_position(a.structure, "left")
if event.key == K_RIGHT:
mac_gyver.move_position(a.structure, "right")
if a.check_position(mac_gyver, guardian, mac_gyver.pocket):
break
a.display_maze(w)
pygame.display.flip()
def utest_CheckLevels():
print '-- CheckLevels function --',
l1, l2 = [Level() for i in range(2)]
b1, a1 = createOrders()
l1.addOrder(b1)
l1.addOrder(a1)
b2, a2 = createOrders()
l2.addOrder(b2)
l2.addOrder(a2)
checkLevels(l1, l2)
print 'OK'
def load_levels(self, verbose=False):
#characters
dirs, curr_path = ut.get_dirs("/bin/levels")
for i in dirs:
if verbose:
print(i)
ok = curr_path + i + "/"
print(ok)
self.game_levels[i] = Level(i, curr_path + i + "/", self)
pass
def create_test_game(self, width, height, static_objects, moving_objects):
level = Level()
level.width = width
level.height = height
level.element_size = 1
level.red_ghost = None
level.map = [[None for _ in range(width)] for _ in range(height)]
for obj, coords in static_objects.items():
level.map[coords.y][coords.x] = obj
level.moving_objects = moving_objects
return Game(level)
