def _regenerate_map():
return_value = False
if c.GEN_DEMO_MODE is False:
maps.load_map(maps.generate_map())
g.force_update = True
return_value = True
else:
if g.map_generator is None:
g.map_generator = maps.generate_map_generator()
try:
maps.load_map(g.map_generator.__next__())
except StopIteration:
g.map_generator = None
return_value = True
g.force_update = True
for i in range(len(g.entity_list) - 1, -1, -1):
del g.entity_list[i]
for key in list(g.special_entity_list.keys())[:]:
if key != "player":
del g.special_entity_list[key]
g.special_entity_list["player"].x = g.player_start_x
g.special_entity_list["player"].y = g.player_start_y
g.special_entity_list["player"].following_entity = None
g.menu_selection = [0, 0]
return return_value
def main():
""" Main function, initializes various variables and contains the main program loop.
Should not be called any other way than running the file or running launch.
Takes no arguments and returns nothing.
"""
# initialize pygame
pygame.init()
# Make map
maps.load_map(maps.generate_map())
# maps.load_map()
# Initiate player
g.special_entity_list["player"] = players.Player(g.player_start_x, g.player_start_y)
# Creates a window just the size to fit all the tiles in the map file.
pygame.display.set_icon(g.images["icon"].get())
pygame.display.set_caption("TileGame by ZeeQyu", "TileGame")
g.screen = pygame.display.set_mode((g.width * c.TILE_SIZE, g.height * c.TILE_SIZE))
# A variable for skipping a single cycle after f.ex. accessing a menu, so that
# the entities won't fly across the screen
skip_cycle = False
# Get time once initially and make time variables
time_last_tick = time_prev = time.clock()
time_start = time_cycles = time_updates = time_last_sleep = 0
# Main loop
while True:
# Make the screen update every frame
if c.FORCE_UPDATE:
g.force_update = True
# Event checker. Allows closing of the program and passes keypresses to the player instance
key_input.event_check()
# Tick: Make sure certain things happen on a more regular basis than every frame
# time_big_diff is the time the cycle took.
# time_diff (defined below) is the simulated time difference that
# the entities move after before ticking again in case of a lag spike.
time_now = time.clock()
time_big_diff = (time_now - time_prev) * c.GAME_SPEED
time_prev = time_now
# Skip the rest of this cycle if a menu was accessed until now
if skip_cycle:
skip_cycle = False
continue
# FPS meter (shown in console).
# checks the amount of times this code is run every second and prints that every second.
time_cycles += 1
if time_start + 1 < time_now:
if time_updates == 1 and time_cycles == 1:
time_updates = 1.0 / time_big_diff
if c.NORMAL_DEBUG:
print(time_start, "seconds from start,", time_cycles, "cycles,", time_updates, "fps")
time_cycles = 0
time_updates = 0
time_start = time_now
# What happens every tick?
while time_big_diff > 0:
if time_big_diff >= c.TICK_FREQ:
time_diff = c.TICK_FREQ
time_big_diff -= time_diff
else:
time_diff = time_big_diff
time_big_diff = 0
if time_last_tick + c.TICK_FREQ <= time_now:
time_last_tick = time_last_tick + c.TICK_FREQ
# Tick all the entities (let them do whatever they do every tick
for i in range(len(g.entity_list) - 1, -1, -1):
entity = g.entity_list[i]
if entity.tick() == "delete":
del g.entity_list[i]
g.force_update = True
for entity in list(g.special_entity_list.values()):
entity.tick()
for tile in g.tick_tiles:
g.map[tile[0]][tile[1]].tick()
# Make sure the loop doesn't go too quickly and bog the processor down
if time_last_sleep < c.SLEEP_TIME:
time.sleep(c.SLEEP_TIME - time_last_sleep)
# update all entities
entity_has_moved = False
if g.entity_list:
for i in range(len(g.entity_list) - 1, -1, -1):
entity = g.entity_list[i]
entity.update(time_diff)
# Check if any of them have moved
if entity.has_moved():
entity_has_moved = True
if g.special_entity_list:
for entity in list(g.special_entity_list.values()):
# Update all entities and check for if any of them is a package that just finished moving.
# If so, skip the has_moved check for that entity.
if entity.update(time_diff) == "deleted":
continue
if entity.has_moved():
entity_has_moved = True
if "tile_target" in g.special_entity_list:
while g.tile_target_selection[0] >= g.width:
g.tile_target_selection[0] -= g.width
while g.tile_target_selection[0] < 0:
g.tile_target_selection[0] += g.width
while g.tile_target_selection[1] >= g.height:
g.tile_target_selection[1] -= g.height
while g.tile_target_selection[1] < 0:
g.tile_target_selection[1] += g.height
g.special_entity_list["tile_target"].x = g.tile_target_selection[0] * c.TILE_SIZE
g.special_entity_list["tile_target"].y = g.tile_target_selection[1] * c.TILE_SIZE
if g.non_entity_list:
for item in list(g.non_entity_list.values()):
try:
if item.update(time_diff):
entity_has_moved = True
except AttributeError:
pass
# Check if any tiles need to be updated.
if g.tile_maker_queue:
while g.tile_maker_queue:
tiles.make_tile(*g.tile_maker_queue.pop())
# Update map buffer if needed
if g.update_map:
g.update_map = False
g.force_update = True
g.map_screen_buffer = maps.update_map()
g.update_microtiles = False
# If any entity moved, redraw the screen
if entity_has_moved or g.force_update:
g.force_update = False
time_updates += 1
g.screen.fill(c.BACKGROUND_COLOR)
# Draw the map buffer on the screen
g.screen.blit(g.map_screen_buffer, (0, 0))
# Draw the objects
for i in range(len(g.entity_list) - 1, -1, -1):
entity = g.entity_list[i]
entity.paint()
for i in range(len(list(g.special_entity_list.values())) - 1, -1, -1):
entity = list(g.special_entity_list.values())[i]
entity.paint()
for i in range(len(list(g.non_entity_list.values())) - 1, -1, -1):
list(g.non_entity_list.values())[i].paint()
del entity
# Update the display
pygame.display.flip()
