def parse_levels():
# Chaeck if the level file exists
__level_file_name = 'levels.lvl'
__level_folder = Path('levels')
__level_path = Path('%s/%s' % (__level_folder.name, __level_file_name))
__new_file = False
__file_exists = __level_folder.exists() and __level_folder.is_dir(
) and __level_path.exists() and __level_path.is_file()
if not __file_exists:
if VERBOSE: print('Level file doesn\'t exist, making new')
if not exists(__level_folder.name) and not isdir(__level_folder.name):
os.mkdir(__level_folder.name)
__level_path.touch()
__new_file = True
if not __new_file:
if VERBOSE: print('Level file exists')
with __level_path.open(mode='r') as f:
file = str(f.read())
levels = file.split('*LEVEL*\n')
del levels[0]
for l in levels:
if VERBOSE: 'Parsing new level'
lines = l.split('\n')
del lines[len(lines) - 1]
level = Level(screen, NOAUDIO)
# Loop through all lines
for line in lines:
if VERBOSE: print('Parsing line: %s') % line
item = line.split('$')
coords = json.loads('{"d":' + item[1] + '}')['d']
if item[0] == 'PLA':
level.add_platform(
Platform(coords, int(item[2]), int(item[3]),
pygame.Color(item[4]), screen))
elif item[0] == 'PLS':
level.player_start = coords
elif item[0] == 'ENE':
level.enemies.add(Enemy(coords, screen))
elif item[0] == 'OBJ':
level.add_object(Movable_Object(coords))
elif item[0] == 'END':
level.set_ending(Ending(coords, screen))
level.calc_max_values()
__levels.append(level)
class Editor:
def __init__(self):
# init mixer first to prevent audio delay
pygame.mixer.pre_init(44100, -16, 2, 2048)
pygame.mixer.init()
pygame.init()
pygame.display.set_caption('NEXTGAME')
self.option_handler = optionhandler.OptionHandler()
mode = 0
if self.option_handler.fullscreen:
mode = pygame.FULLSCREEN
self.screen = pygame.display.set_mode(self.option_handler.resolution,
mode)
self.image_handler = imagehandler.ImageHandler()
self.input_handler = inputhandler.InputHandler()
self.clock = pygame.time.Clock()
self.time_step = 15.0 / self.option_handler.fps
self.font = pygame.font.Font(None, 30)
self.level = Level()
self.grid_color = [150, 150, 150]
self.wall_start = None
self.grabbed_object = None
self.grab_offset = np.zeros(2)
self.object_types = ['wall', 'platform']
self.type_index = 0
self.camera = Camera([0, 0], self.option_handler.resolution)
def main_loop(self):
while not self.input_handler.quit:
self.input_handler.update(self.camera)
self.input()
if self.grabbed_object is not None:
w = self.grabbed_object.collider.half_width
h = self.grabbed_object.collider.half_height
pos = np.floor(self.input_handler.mouse_position +
self.grab_offset - np.floor(w) - np.floor(h))
self.grabbed_object.set_position(pos + w + h)
self.screen.fill((50, 50, 50))
self.draw_grid(1.0)
self.level.draw(self.screen, self.camera, self.image_handler)
for p in self.level.player_spawns:
p.draw(self.screen, self.camera, self.image_handler)
self.draw_selection()
type_str = self.font.render(self.object_types[self.type_index],
True, self.image_handler.debug_color)
self.screen.blit(type_str, (50, 50))
pygame.display.update()
self.clock.tick(self.option_handler.fps)
def input(self):
if self.input_handler.mouse_pressed[0]:
for obj in self.level.walls + self.level.player_spawns + list(self.level.objects.values()) + \
[self.level.scoreboard]:
if obj.collider.point_inside(
self.input_handler.mouse_position):
self.grabbed_object = obj
self.grab_offset = self.grabbed_object.position - self.input_handler.mouse_position
break
else:
self.wall_start = np.round(self.input_handler.mouse_position)
if self.input_handler.mouse_released[0]:
if self.grabbed_object is not None:
if isinstance(self.grabbed_object, Weapon):
for obj in self.level.objects.values():
if type(obj) is Crate and obj.collider.point_inside(
self.input_handler.mouse_position):
obj.loot_list.append(type(obj))
del self.grabbed_object
break
self.grabbed_object = None
else:
end = np.round(self.input_handler.mouse_position)
pos = 0.5 * (self.wall_start + end)
size = np.abs(end - self.wall_start)
if np.all(size):
if self.type_index == 0:
self.level.add_wall(pos, size[0], size[1])
else:
self.level.add_platform(pos, size[0])
self.wall_start = None
if self.input_handler.mouse_down[1]:
self.camera.position -= self.input_handler.mouse_change
if self.input_handler.mouse_pressed[2]:
for w in self.level.walls:
if w.collider.point_inside(self.input_handler.mouse_position):
self.level.walls.remove(w)
for w in self.level.player_spawns:
if w.collider.point_inside(self.input_handler.mouse_position):
self.level.player_spawns.remove(w)
for k in list(self.level.objects.keys()):
if self.level.objects[k].collider.point_inside(
self.input_handler.mouse_position):
del self.level.objects[k]
if self.input_handler.mouse_pressed[3]:
self.camera.zoom *= 1.5
if self.input_handler.mouse_pressed[4]:
self.camera.zoom /= 1.5
if self.input_handler.keys_pressed[pygame.K_s]:
for i, o in enumerate(self.level.objects.values()):
o.id = i
with open('data/levels/lvl.pickle', 'wb') as f:
pickle.dump(self.level.get_data(), f)
if self.input_handler.keys_pressed[pygame.K_l]:
with open('data/levels/lvl.pickle', 'rb') as f:
data = pickle.load(f)
self.level.clear()
self.level.apply_data(data)
if self.input_handler.keys_pressed[pygame.K_DELETE]:
self.level.clear()
if self.input_handler.keys_pressed[pygame.K_w]:
if self.type_index == len(self.object_types) - 1:
self.type_index = 0
else:
self.type_index += 1
pos = np.floor(self.input_handler.mouse_position) + np.array(
[0.5, 0.501])
if self.input_handler.keys_pressed[pygame.K_p]:
self.level.player_spawns.append(PlayerSpawn(pos))
if self.input_handler.keys_pressed[pygame.K_c]:
self.level.add_object(Crate(pos))
if self.input_handler.keys_pressed[pygame.K_b]:
self.level.add_object(Ball(pos))
if self.input_handler.keys_pressed[pygame.K_g]:
self.level.add_object(Shotgun(pos))
if self.input_handler.keys_pressed[pygame.K_t]:
self.level.walls.append(Basket(pos))
if self.input_handler.keys_pressed[pygame.K_i]:
self.level.scoreboard = Scoreboard(pos)
def draw_grid(self, size):
x_min = math.floor(self.camera.position[0] -
self.camera.half_width[0] / self.camera.zoom)
x_max = math.ceil(self.camera.position[0] +
self.camera.half_width[0] / self.camera.zoom)
y_min = math.floor(self.camera.position[1] -
self.camera.half_height[1] / self.camera.zoom)
y_max = math.ceil(self.camera.position[1] +
self.camera.half_height[1] / self.camera.zoom)
for x in np.linspace(x_min, x_max, int(abs(x_max - x_min) / size) + 1):
if x % 5 == 0:
width = 3
else:
width = 1
pygame.draw.line(self.screen, self.grid_color,
self.camera.world_to_screen([x, y_min]),
self.camera.world_to_screen([x, y_max]), width)
for y in np.linspace(y_min, y_max, int(abs(y_max - y_min) / size) + 1):
if y % 5 == 0:
width = 3
else:
width = 1
pygame.draw.line(self.screen, self.grid_color,
self.camera.world_to_screen([x_min, y]),
self.camera.world_to_screen([x_max, y]), width)
def draw_selection(self):
if self.wall_start is not None:
end = np.round(self.input_handler.mouse_position)
size = self.camera.zoom * (end - self.wall_start)
size[1] *= -1
pos = self.camera.world_to_screen(self.wall_start)
rect = pygame.rect.Rect(pos[0], pos[1], size[0], size[1])
pygame.draw.rect(self.screen, [255, 255, 255], rect, 5)
