def test_controls(self):
'''Fake some key ups and key downs then check that changes control booleans'''
self.screen = pygame.display.set_mode((50, 50), pygame.RESIZABLE)
test_controls = Controls(verbose=False)
test_controls.path = test_controls.path.replace(
'static', 'test/static')
events = [pygame.event.Event(pygame.KEYDOWN, key=control, mod=4096)
for control in test_controls.control_lookup]
test_controls.get_events(events, self.screen, 50, 50)
for key in test_controls.buttons:
self.assertTrue(test_controls.buttons[key])
events = [pygame.event.Event(pygame.KEYUP, key=control, mod=4096)
for control in test_controls.control_lookup]
test_controls.get_events(events, self.screen, 50, 50)
for key in test_controls.buttons:
self.assertFalse(test_controls.buttons[key])
def test_controls(self):
'''Fake some key ups and key downs then check that changes control booleans'''
self.screen = pygame.display.set_mode((50, 50), pygame.RESIZABLE)
test_controls = Controls(verbose=False)
test_controls.path = test_controls.path.replace(
'static', 'test/static')
events = [
pygame.event.Event(pygame.KEYDOWN, key=control, mod=4096)
for control in test_controls.control_lookup
]
test_controls.get_events(events, self.screen, 50, 50)
for key in test_controls.buttons:
self.assertTrue(test_controls.buttons[key])
events = [
pygame.event.Event(pygame.KEYUP, key=control, mod=4096)
for control in test_controls.control_lookup
]
test_controls.get_events(events, self.screen, 50, 50)
for key in test_controls.buttons:
self.assertFalse(test_controls.buttons[key])
class Game(object):
def __init__(self, verbose=False, path=path):
self.levels = {}
self.home = os.environ['HOME']
self.path = path if path else os.environ['PWD']
self.game = pygame.init()
self.game_exit = False
self.current_level = "0-0"
self.levels_loaded = False
self.main_character_loaded = False
self.clock = pygame.time.Clock()
self.verbose = verbose
self.width = 0
self.height = 0
self.scalar = 70
self.screen = None
self.controls = Controls(path=path)
self.game_locations = {}
def load_levels(self):
print self.path
for path, directory, levels in os.walk(self.path + "/assets/levels/"):
for level in levels:
match = re.match("(.*)\.lvl", level)
if match:
level_name = match.group(1)
file_name = path + match.group(0)
with open(file_name, "r") as level_content:
self.levels[level_name] = Level(level_name, level_content.read(
), clock=self.clock, scalar=self.scalar, verbose=self.verbose)
self.width = self.levels[level_name].block_width * self.scalar if self.levels[
level_name].block_width * self.scalar > self.width else self.width
self.height = self.levels[level_name].block_height * self.scalar if self.levels[
level_name].block_height * self.scalar > self.height else self.height
self.levels_loaded = True
def log(self, message):
pprint(message) if self.verbose else None
def load_characters(self):
self.main_character = Character(
"dave", screen=self.screen, scalar=self.scalar, clock=self.clock)
self.main_character_loaded = True
def valid_level(self, level):
return True if self.levels.get(level, False) else False
def go_direction(self, vector, direction, limit1, limit2, oldlimit1, oldlimit2):
vectors = self.current_level.split('-')
vectors[vector] = str(int(vectors[vector]) + direction)
new_level = vectors[0] + '-' + vectors[1]
if self.valid_level(new_level):
self.current_level = vectors[0] + '-' + vectors[1]
self.main_character.log('entered ' + self.current_level)
self.main_character.old_position[vector] = limit1
self.main_character.position[vector] = limit2
else:
self.main_character.old_position[vector] = oldlimit1
self.main_character.position[vector] = oldlimit2
def go_right(self):
self.go_direction(0, 1, -1, 0, self.levels[
self.current_level].block_width - 1, self.levels[self.current_level].block_width - 1)
def go_left(self):
self.go_direction(0, -1, self.levels[self.current_level].block_width, self.levels[
self.current_level].block_width - 1, 0, 0)
def go_up(self):
self.go_direction(1, 1, self.levels[self.current_level].block_height, self.levels[
self.current_level].block_height - 1, 0, 0)
def go_down(self):
self.go_direction(1, -1, -1, 0, self.levels[
self.current_level].block_height - 1, self.levels[self.current_level].block_height - 1)
def save_screen(self):
pygame.image.save(self.screen, self.home + '/current_screen.jpg')
def main_loop(self):
if not self.levels_loaded:
self.load_levels()
if not self.main_character_loaded:
self.load_characters()
count = 0
self.screen = pygame.display.set_mode((self.width, self.height), pygame.RESIZABLE)
while not self.game_exit:
try:
self.main_character.blocks.remove(tuple(self.main_character.position))
except KeyError:
pass
events = pygame.event.get()
self.last_level = self.current_level
self.levels[self.current_level].draw_level()
self.main_character.blocks = self.levels[self.current_level].blocks
self.main_character.water_blocks = self.levels[
self.current_level].water_blocks
self.controls.get_events(events, self.screen, self.levels[self.current_level], self.main_character)
self.main_character.check_movement()
self.main_character.draw_character()
self.levels[self.current_level].draw_foreground()
pygame.display.update()
self.levels[self.current_level].slow_clock()
self.clock.tick(60)
if self.main_character.position[0] > self.levels[self.current_level].block_width - 1:
self.go_right()
if self.main_character.position[0] < 0:
self.go_left()
if self.main_character.position[1] < 0:
self.go_up()
if self.main_character.position[1] > self.levels[self.current_level].block_height - 1:
self.go_down()
self.main_character.blocks.add(tuple(self.main_character.position))
class Game(object):
def __init__(self, verbose=True, path=False, width=WIDTH, height=HEIGHT):
self.verbose = verbose
self.logger = Logerer()
self.controls = Controls(verbose=self.verbose)
self.path = self.controls.path if not path else path
self.log("Game started in " + self.path)
self.levels = {}
self.current_level = (0, 0)
self.width = width
self.height = height
self.size = self.width, self.height
self.slow_clock = 90
self.screen = pygame.display.set_mode(
(self.width, self.height), pygame.RESIZABLE)
self.npcs_loaded = False
def log(self, message):
if self.verbose:
self.logger.log(__name__, message)
def load_levels(self):
suffix = '/static/levels/'
levels = [f for f in os.walk(self.path + suffix)][0][2]
self.log(str(levels))
for level in levels:
self.log(level + " loaded")
level_path = self.path + suffix + level
level_string = open(level_path, 'r').read()
level_tup = tuple([int(string)
for string in level.replace('.lvl', '').split('-')])
self.levels[level_tup] = Background(
level, level_string=level_string, screen=self.screen, verbose=self.verbose)
def load_main_character(self):
self.main_character = Character(
"Dave", screen=self.screen, verbose=self.verbose)
def load_npcs(self):
self.npcs = {}
if self.levels[self.current_level].npcs and not self.npcs_loaded:
npcs = self.levels[self.current_level].npcs
for npc in npcs:
position = npcs[npc]["position"]
position = [int(v) for v in position]
self.npcs[npc] = NPC(
npc, screen=self.screen, position=position, verbose=self.verbose)
self.log(str(self.npcs[npc]))
self.npcs_loaded = True
return True
def main(self):
self.load_levels()
self.load_main_character()
self.load_new_level(self.current_level)
self.clock = pygame.time.Clock()
self.loop()
def handle_size(self):
self.width, self.height = self.controls.get_events(
events=self.events, screen=self.screen, width=self.width, height=self.height, character=self.main_character)
if self.size != (self.width, self.height):
self.log(str((self.width, self.height)))
self.screen = pygame.display.set_mode(
(self.width, self.height), pygame.RESIZABLE)
def load_new_level(self, level_name):
self.blocks = self.levels[level_name].blocks
self.liquid = self.levels[level_name].liquid
self.current_level = level_name
self.load_npcs()
def next_level(self, vector, direction):
self.log(str(vector) + " going " + str(direction))
change = [0, 0]
change[vector] = direction
new_level = tuple(add(self.current_level, change))
if self.levels.get(new_level, False):
self.npcs_loaded = False
self.load_new_level(new_level)
if self.main_character.position[vector] < 0:
self.main_character.position[vector] = self.levels[
self.current_level].block_vectors[vector]
else:
self.main_character.position[vector] = 0
else:
self.log("level " + str(new_level) + " not available")
def handle_npcs(self):
for char in self.npcs:
self.npcs[char].blocks = set(self.temp_blocks)
if not self.npcs[char].can_swim:
self.npcs[char].blocks.update(self.liquid)
self.npcs[char].draw_character(
self.levels[self.current_level].hs, self.levels[self.current_level].vs)
self.temp_blocks.add(tuple(self.npcs[char].position))
if self.counter == self.slow_clock:
choice((self.npcs[char].dummy, self.npcs[char].move_rand))()
def handle_character_position(self):
for vector in range(2):
if self.main_character.position[vector] > self.levels[self.current_level].block_vectors[vector]:
self.next_level(vector, +1)
elif self.main_character.position[vector] < 0:
self.next_level(vector, -1)
def loop(self):
self.counter = 0
while True:
self.temp_blocks = set(self.blocks)
self.size = self.width, self.height
self.events = pygame.event.get()
self.handle_size()
self.levels[self.current_level].draw_level(self.width, self.height)
self.main_character.draw_character(
self.levels[self.current_level].hs, self.levels[self.current_level].vs)
self.temp_blocks.add(tuple(self.main_character.position))
if self.levels[self.current_level].npcs:
self.handle_npcs()
self.main_character.blocks = self.temp_blocks
if not self.main_character.can_swim:
print "main character can't swim"
self.main_character.blocks.update(self.liquid)
self.handle_character_position()
self.clock.tick(60)
pygame.display.update()
self.clock.tick(60)
if self.counter == self.slow_clock:
self.counter = 0
self.counter += 1
