+++ /dev/null
-import os
-import numpy as np
-
-from Function.createText import createText
-from Setup import *
-
-import tkinter as tk
-from tkinter import filedialog
-
-
-class LevelCreator:
- canvas_layers = 5
- textures = [file[:file.index(".")] for file in listdir("Assets/world/blocks")]
- textures.append("NONE")
-
- def __init__(self):
- self.blocks = {"none": [[] for _ in range(self.canvas_layers)],
- "world": [[] for _ in range(self.canvas_layers)]}
-
- self.grid = Grid()
-
- self.zoom = 1
- self.total_offset = pg.Vector2(0, 0)
- self.world_transform = np.identity(3)
- self.inv_world_transform = np.linalg.inv(self.world_transform)
-
- self.translation_matrix = np.array([[1, 0, self.total_offset.x],
- [0, 1, self.total_offset.y],
- [0, 0, 1]])
- self.translation_back_matrix = np.array([[1, 0, -self.total_offset.x],
- [0, 1, -self.total_offset.y],
- [0, 0, 1]])
-
- self.current_texture = self.textures.index("PLACEHOLDER")
- self.current_layer = 0
- self.show_grid = True
- self.show_hitboxes = False
- self.collision_layer = "world"
-
- self.buttons = [Button((0, 0), "Toggle Grid", self.toggle_grid),
- Button((0, 0), "-Layer", self.decrease_layer),
- Button((0, 0), f"{self.current_layer=}", self.upd_layer),
- Button((0, 0), "+Layer", self.increase_layer),
- Button((0, 0), f"{self.collision_layer=}", self.toggle_collidable),
- Button((0, 0), "Toggle Hitboxes", self.toggle_show_hitboxes),
- Button((0, 0), "Import", self.import_level),
- Button((0, 0), "Export", self.export),
- ]
-
- self.level = -2
-
- def export(self):
- # for layer in out:
- # for i,block in enumerate(layer):
- # layer[i] = Block(block.position,block.collision_layer,block.texture_name)
-
- counter = 1
-
- def get_key(mask):
- for key, value in self.blocks.items():
- if mask == value:
- return key
-
- while True:
- try:
- with open(os.path.join("Levels", f'Level{counter}.txt'), 'x') as f:
- out = ""
- for layer in self.get_canvas_layers():
- t = ""
- pos = ""
- texture = ""
- for block in layer:
- t += f"{get_key(block.collision_layer)}|"
- pos += f"{block.position.x},{block.position.y}|"
- texture += f"{block.texture_name}|"
- out += f"{t[:-1]}\n{pos[:-1]}\n{texture[:-1]}\n"
- f.write(out)
-
- print(f"File saved as Level{counter} in folder Levels")
- break
- except FileExistsError:
- counter += 1
-
- def import_level(self):
- root = tk.Tk()
- root.withdraw()
-
- filename = filedialog.askopenfilename(initialdir="./Levels", title="Select A File",
- filetypes=((".txt", "*.txt"), ("all files", "*.*")))
- if filename == '':
- return
- with open(filename, 'r', encoding='utf-8') as f:
- file_contents = f.read().split("\n")
-
- # with open(path.join("Levels", f'Level{1}.txt'), 'r') as f:
- # file_contents = f.read().split("\n")
-
- for i in range(0, len(file_contents) - 1, 3):
- layer = file_contents[i].split("|")
- pos = file_contents[i + 1].split("|")
- texture = file_contents[i + 2].split("|")
-
- for l, p, t in zip(layer, pos, texture):
- if p == "":
- break
- x, y = p.split(',')
- self.add_block(self.apply_transformations((float(x), float(y))), self.blocks[l], t, i)
-
- def toggle_collidable(self):
- if self.collision_layer == "none":
- self.collision_layer = "world"
- else:
- self.collision_layer = "none"
- button = self.buttons[4]
- button.upd_text(button.position, f"{self.collision_layer=}")
-
- def toggle_show_hitboxes(self):
- self.show_hitboxes = not self.show_hitboxes
-
- def toggle_grid(self):
- self.show_grid = not self.show_grid
-
- def decrease_layer(self):
- self.current_layer = max(self.current_layer - 1, 0)
- self.upd_layer()
-
- def increase_layer(self):
- self.current_layer = min(self.current_layer + 1, self.canvas_layers - 1)
- self.upd_layer()
-
- def upd_layer(self):
- button = self.buttons[2]
- button.__init__(button.position, f"{self.current_layer=}", self.upd_layer)
-
- def fit_to_grid(self, pt, use_floor=True):
- pos = self.reverse_transformations(pg.Vector2(pt))
- if use_floor:
- return pg.Vector2((pos.x // EditorBlock.width) * EditorBlock.width,
- (pos.y // EditorBlock.height) * EditorBlock.height)
- else:
- return pg.Vector2(round(pos.x / EditorBlock.width) * EditorBlock.width,
- round(pos.y / EditorBlock.height) * EditorBlock.height)
-
- def apply_rect_transformations(self, rect):
- top_left = np.array([rect.left, rect.top, 1])
- bottom_right = np.array([rect.right, rect.bottom, 1])
-
- top_left = pg.Vector2(tuple((self.world_transform @ self.translation_matrix @ top_left)[0:2]))
- bottom_right = pg.Vector2(tuple((self.world_transform @ self.translation_matrix @ bottom_right)[0:2]))
-
- return pg.Rect(top_left, bottom_right - top_left)
-
- def add_block(self, pos, mask, texture, canvas_layer):
- pos = self.fit_to_grid(pos)
- for m in self.blocks.values():
- for i, block in enumerate(m[canvas_layer]):
- if block.position == pos:
- del m[canvas_layer][i]
- break
- if texture != "NONE":
- mask[canvas_layer].append(EditorBlock(pos, mask, texture))
-
- def calculate_transformations(self, current_frame_zoom):
- mouse_pos = pg.Vector2(pg.mouse.get_pos())
-
- translation_matrix = np.array([[1, 0, mouse_pos.x],
- [0, 1, mouse_pos.y],
- [0, 0, 1]])
- translation_back_matrix = np.array([[1, 0, -mouse_pos.x],
- [0, 1, -mouse_pos.y],
- [0, 0, 1]])
- scale_matrix = np.array([[current_frame_zoom, 0, 0],
- [0, current_frame_zoom, 0],
- [0, 0, 1]])
- self.world_transform = translation_matrix @ scale_matrix @ translation_back_matrix @ self.world_transform
- self.inv_world_transform = np.linalg.inv(self.world_transform)
-
- def apply_transformations(self, pt):
- point = pg.Vector2(pt)
- point = np.array([point.x, point.y, 1])
- return pg.Vector2(tuple((self.world_transform @ self.translation_matrix @ point)[0:2]))
-
- def reverse_transformations(self, pt):
- point = pg.Vector2(pt)
- point = np.array([point.x, point.y, 1])
- return pg.Vector2(tuple((self.translation_back_matrix @ self.inv_world_transform @ point)[0:2]))
-
- def update(self, delta):
- current_frame_zoom = 1
- for event in pg.event.get((pg.MOUSEBUTTONDOWN, pg.MOUSEWHEEL, pg.KEYUP)):
- if event.type == pg.MOUSEBUTTONDOWN:
- if event.button == 1:
- pg.mouse.get_rel()
- if event.type == pg.MOUSEWHEEL:
- if event.y < 0:
- current_frame_zoom *= 0.75
- self.zoom *= 0.75
- elif event.y > 0:
- current_frame_zoom *= 1.25
- self.zoom *= 1.25
- if event.type == pg.KEYUP:
- if event.key in [pg.K_a, pg.K_s, pg.K_LEFT, pg.K_DOWN]:
- self.current_texture = (self.current_texture - 1) % len(self.textures)
- elif event.key in [pg.K_d, pg.K_w, pg.K_RIGHT, pg.K_UP]:
- self.current_texture = (self.current_texture + 1) % len(self.textures)
-
- mouse_pressed = pg.mouse.get_pressed(3)
- if mouse_pressed[0]:
- mouse_rel = pg.mouse.get_rel()
- self.total_offset += pg.Vector2(mouse_rel[0] / self.zoom, mouse_rel[1] / self.zoom)
- if mouse_pressed[2]:
- self.add_block(pg.mouse.get_pos(), self.blocks[self.collision_layer], self.textures[self.current_texture],
- self.current_layer)
-
- self.translation_matrix = np.array([[1, 0, self.total_offset.x],
- [0, 1, self.total_offset.y],
- [0, 0, 1]])
- self.translation_back_matrix = np.array([[1, 0, -self.total_offset.x],
- [0, 1, -self.total_offset.y],
- [0, 0, 1]])
-
- self.calculate_transformations(current_frame_zoom)
-
- self.grid.update(delta, self.world_transform, self.inv_world_transform, self.total_offset, self.zoom)
-
- for mask in self.blocks.values():
- for layer in mask:
- for block in layer:
- block.update(delta, self.world_transform, self.total_offset)
-
- prev_x = 0
- for button in self.buttons:
- button.update(delta, dx=prev_x)
- prev_x += button.width + 10
-
- def get_canvas_layers(self):
- out = [[] for _ in range(self.canvas_layers)]
- for mask in self.blocks.values():
- for i, layer in enumerate(mask):
- out[i] += layer
- return out
-
- def draw(self, surf):
- surf.fill((0, 0, 0))
- if self.show_grid:
- self.grid.draw(surf)
-
- for i, layer in enumerate(self.get_canvas_layers()):
- if i <= self.current_layer:
- for block in layer:
- block.draw(surf)
- if self.show_hitboxes:
- block.show_hitbox(surf, self.blocks["world"])
-
- pg.draw.line(surf, (255, 0, 0), self.apply_transformations((self.reverse_transformations((0, 0)).x, 0)),
- self.apply_transformations((self.reverse_transformations((SCREEN_WIDTH, 0)).x, 0)),
- math.ceil(self.zoom * 5))
- pg.draw.line(surf, (255, 0, 0), self.apply_transformations((0, self.reverse_transformations((0, 0)).y)),
- self.apply_transformations((0, self.reverse_transformations((0, SCREEN_HEIGHT)).y)),
- math.ceil(self.zoom * 5))
-
- display_img = EditorBlock.textures[self.textures[self.current_texture]].copy()
- display_img.set_alpha(100)
- surf.blit(pg.transform.scale(display_img, self.apply_rect_transformations(display_img.get_rect()).size),
- self.apply_transformations(self.fit_to_grid(pg.mouse.get_pos(), use_floor=True)))
- for button in self.buttons:
- button.draw(surf)
-
-
-class Grid:
- thickness = 2
- colour = (100, 100, 100)
-
- def __init__(self):
- self.zoom = 1
- self.world_transform = np.identity(3)
- self.inv_world_transform = np.linalg.inv(self.world_transform)
- self.total_offset = pg.Vector2(0, 0)
- self.translation_matrix = np.array([[1, 0, self.total_offset.x],
- [0, 1, self.total_offset.y],
- [0, 0, 1]])
- self.translation_back_matrix = np.array([[1, 0, -self.total_offset.x],
- [0, 1, -self.total_offset.y],
- [0, 0, 1]])
-
- def update(self, delta, world_transform, inv_world_transform, total_offset, zoom):
- self.zoom = zoom
- self.world_transform = world_transform
- self.inv_world_transform = inv_world_transform
- self.total_offset = total_offset
- self.translation_matrix = np.array([[1, 0, self.total_offset.x],
- [0, 1, self.total_offset.y],
- [0, 0, 1]])
- self.translation_back_matrix = np.array([[1, 0, -self.total_offset.x],
- [0, 1, -self.total_offset.y],
- [0, 0, 1]])
-
- def apply_transformations(self, pt):
- point = pg.Vector2(pt)
- point = np.array([point.x, point.y, 1])
- return pg.Vector2(tuple((self.world_transform @ self.translation_matrix @ point)[0:2]))
-
- def reverse_transformations(self, pt):
- point = pg.Vector2(pt)
- point = np.array([point.x, point.y, 1])
- return pg.Vector2(tuple((self.translation_back_matrix @ self.inv_world_transform @ point)[0:2]))
-
- def draw(self, surf):
- start = self.reverse_transformations((0, 0))
- end = self.reverse_transformations(dimensions)
-
- start = pg.Vector2(start.x // EditorBlock.width, start.y // EditorBlock.width)
- end = pg.Vector2(end.x // EditorBlock.height, end.y // EditorBlock.height)
-
- for i in range(math.floor(start.x), math.floor(end.x) + 1):
- pg.draw.line(surf, self.colour,
- self.apply_transformations((i * EditorBlock.width, start.y * EditorBlock.height)),
- self.apply_transformations((i * EditorBlock.width, (end.y + 1) * EditorBlock.height)),
- math.ceil(self.thickness * self.zoom))
- for i in range(math.floor(start.y), math.floor(end.y) + 1):
- pg.draw.line(surf, self.colour,
- self.apply_transformations((start.x * EditorBlock.width, i * EditorBlock.height)),
- self.apply_transformations(((end.x + 1) * EditorBlock.width, i * EditorBlock.height)),
- math.ceil(self.thickness * self.zoom))
-
-
-class EditorBlock:
- textures = {file[:file.index(".")]: pg.transform.scale(
- pg.image.load(path.join("Assets/world/blocks", file)), (50, 50)) for
- file in listdir("Assets/world/blocks")}
- width, height = textures["PLACEHOLDER"].get_size()
-
- def __init__(self, pos, collision_layer, texture="PLACEHOLDER"):
- self.position = pg.Vector2(pos)
- self.texture = self.textures[texture]
- self.texture_name = texture
-
- self.collision_layer = collision_layer
-
- self.world_transform = np.identity(3)
- self.total_offset = pg.Vector2(0, 0)
- self.translation_matrix = np.array([[1, 0, self.total_offset.x],
- [0, 1, self.total_offset.y],
- [0, 0, 1]])
-
- def update(self, delta, world_transform, total_offset):
- self.world_transform = world_transform
- self.total_offset = total_offset
- self.translation_matrix = np.array([[1, 0, self.total_offset.x],
- [0, 1, self.total_offset.y],
- [0, 0, 1]])
-
- def apply_transformations(self, rect):
- top_left = np.array([rect.left, rect.top, 1])
- bottom_right = np.array([rect.right, rect.bottom, 1])
-
- top_left = pg.Vector2(tuple((self.world_transform @ self.translation_matrix @ top_left)[0:2]))
- bottom_right = pg.Vector2(tuple((self.world_transform @ self.translation_matrix @ bottom_right)[0:2]))
-
- return pg.Rect(top_left, bottom_right - top_left)
-
- def get_display_rect(self):
- return self.apply_transformations(pg.Rect(self.position, (self.width, self.height)))
-
- def draw(self, surf):
- display_rect = self.get_display_rect()
- surf.blit(pg.transform.scale(self.texture, display_rect.size), display_rect)
-
- def show_hitbox(self, surf, collision_layer):
- if collision_layer == self.collision_layer:
- pg.draw.rect(surf, (255, 0, 0), self.get_display_rect(), 3)
-
-
-class Button:
-
- def __init__(self, pos, msg, func):
- self.position = pg.Vector2(pos)
- self.text, self.rect = createText(self.position.x * 2, self.position.y, 20, (200, 200, 200), "Regular", msg)
- self.width, self.height = self.text.get_size()
- self.func = func
- self.msg = msg
- self.cooldown = 500
-
- def upd_text(self, pos, msg):
- self.position = pg.Vector2(pos)
- self.text, self.rect = createText(self.position.x * 2, self.position.y, 20, (200, 200, 200), "Regular", msg)
- self.width, self.height = self.text.get_size()
- self.msg = msg
-
- def update(self, delta, dx):
- self.upd_text((dx, self.position.y), self.msg)
- mouse_pos = pg.mouse.get_pos()
- if self.cooldown == 0:
- if pg.mouse.get_pressed(3)[0]:
- if (self.position.x <= mouse_pos[0] <= self.position.x + self.width and
- self.position.y <= mouse_pos[1] <= self.position.y + self.height):
- self.func()
- self.cooldown = 500
- self.cooldown = max(self.cooldown - delta, 0)
-
- def draw(self, surf):
- pg.draw.rect(surf, (80, 80, 80), pg.Rect(self.position, self.text.get_size()), border_radius=3)
- pg.draw.rect(surf, (120, 120, 120), pg.Rect(self.position, self.text.get_size()), 1, border_radius=3)
- surf.blit(self.text, self.rect)
projects / Pygame-Jam.git / commitdiff
