ScriptSorcerer/pixel_tower_defense
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added alot of things, waypoints, grid for editor, game camera system, enemy moving on pre defined waypoint (path)

Browse Source
This commit is contained in:
ScriptSorcerer20
2026-06-07 22:46:47 +02:00
parent 6283fb0d5a
commit 0171a5c845
23 changed files with 432 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files
game/camera.py
+26
View File
@@ -0,0 +1,26 @@
import pygame as pg
class Camera():
def __init__(self):
self.zoom = 1
self.offset = pg.math.Vector2(0, 0)
def world_to_screen(self, pos):
return (
int((pos[0] - self.offset.x) * self.zoom),
int((pos[1] - self.offset.y) * self.zoom)
)
def screen_to_world(self, pos):
return (
pos[0] / self.zoom + self.offset.x,
pos[1] / self.zoom + self.offset.y
)
def move(self, dx, dy):
self.offset.x += dx
self.offset.y += dy
def change_zoom(self, amount):
self.zoom += amount
self.zoom = max(0.5, min(self.zoom, 4.0))
game/enemy.py
+63
View File
@@ -0,0 +1,63 @@
from game.util import *
import pygame as pg
class Enemy(pg.sprite.Group):
def __init__(self, game, speed, health):
super().__init__()
self.game = game
self.waypoints = self.game.tilemap.waypoints
print(self.waypoints)
self.speed = speed
self.health = health
self.image = self.game.assets['enemy']
self.rect = self.image.get_rect()
self.pos = pg.Vector2(
tile_to_pixel(self.waypoints[0], self.game.tilemap.tile_size, True)
)
self.target_index = 1
self.rect.center = self.pos
def update(self):
if self.target_index >= len(self.waypoints):
return
tile_size = self.game.tilemap.tile_size
target = pg.Vector2(
tile_to_pixel(
self.waypoints[self.target_index],
tile_size,
True
)
)
direction = target - self.pos
distance = direction.length()
if distance <= self.speed:
self.pos = target
self.target_index += 1
else:
direction = direction.normalize()
self.pos += direction * self.speed
self.rect.center = self.pos
def render(self, surf, camera):
zoom = camera.zoom
scaled_rect = self.rect.scale_by(zoom)
scaled_image = pg.transform.scale(
self.image,
(scaled_rect.size[0], scaled_rect.size[1])
)
scaled_pos = camera.world_to_screen(self.pos)
scaled_rect.center = scaled_pos
surf.blit(scaled_image, scaled_rect)
game/game.py
+13 -2
View File
@@ -20,12 +20,21 @@ class Game:
self.clock = pygame.time.Clock()
self.ui_manager = pygame_gui.UIManager(
WINDOW_SIZE,
"theme.json"
"assets/theme/theme.json"
)
self.tilemap = Tilemap(self)
self.map = 'test'
self.path = 'assets/maps/' + str(self.map) + '.json'
try:
self.tilemap.load(self.path)
except FileNotFoundError:
print('File not Found')
print(self.tilemap.waypoints)
self.assets={
"base": load_images('/tiles/test')
"base": load_images('/tiles/test'),
"jungle": load_images('/tiles/jungle'),
"enemy": load_image('/entities/enemies/sand_monster.png')
}
self.screens = {
@@ -58,6 +67,8 @@ class Game:
self.ui_manager.process_events(event)
self.current_screen.process_event(event)
self.current_screen.update(dt)
self.ui_manager.update(dt)
game/screens/game_play.py
+44 -9
View File
@@ -1,4 +1,7 @@
from game.screens.base_screen import BaseScreen
from game.enemy import Enemy
from game.camera import Camera
from game.util import *
import pygame as pg
import pygame_gui as pgi
@@ -6,30 +9,62 @@ class GamePlay(BaseScreen):
def __init__(self, game):
super().__init__(game)
self.tile_multiplicator = 2.0
# self.tile_multiplicator = 2.0
self.width, self.height = pg.display.get_surface().get_size()
self.map_screen = pg.surface.Surface((int(self.width/4*3),int(self.height/6*5)))
self.game_surface = pg.surface.Surface((int(self.width/4*3),int(self.height/6*5)))
# self.map_surface = pg.surface.Surface((self.game_surface.get_width()/self.tile_multiplicator,self.game_surface.get_height()/self.tile_multiplicator))
self.scroll = [0, 0]
self.camera = Camera()
self.movment = [False, False, False, False]
self.map = 'test'
self.path = 'assets/maps/' + str(self.map) + '.json'
self.enemy = Enemy(self.game, 0.5, 100)
try:
self.game.tilemap.load(self.path)
except FileNotFoundError:
print('File not Found')
def process_event(self, event):
pass
if event.type == pg.KEYDOWN:
if event.key == pg.K_a:
self.movment[0] = True
if event.key == pg.K_d:
self.movment[1] = True
if event.key == pg.K_w:
self.movment[2] = True
if event.key == pg.K_s:
self.movment[3] = True
if event.key == pg.K_q:
self.camera.change_zoom(-0.25)
if event.key == pg.K_e:
self.camera.change_zoom(0.25)
if event.type == pg.KEYUP:
if event.key == pg.K_a:
self.movment[0] = False
if event.key == pg.K_d:
self.movment[1] = False
if event.key == pg.K_w:
self.movment[2] = False
if event.key == pg.K_s:
self.movment[3] = False
def update(self, dt):
pass
self.enemy.update()
self.camera.move((self.movment[1] - self.movment[0]) * 2, (self.movment[3] - self.movment[2]) * 2)
def draw(self, surface):
self.map_screen.fill((40, 40, 40))
self.game_surface.fill((40, 40, 40))
# self.map_surface.fill((40, 40, 40))
render_scroll = (int(self.scroll[0]), int(self.scroll[1]))
self.game.tilemap.render(self.map_screen, offset=render_scroll)
self.game.tilemap.render_game(self.game_surface, self.camera)
self.enemy.render(self.game_surface, self.camera)
# self.game_surface.blit(pg.transform.scale(self.map_surface, self.game_surface.get_size()))
self.game.window.blit(self.map_screen, (0, self.height/6))
surface.blit(self.game_surface, (0, self.height/6))
game/tilemap.py
+43 -3
View File
@@ -1,14 +1,21 @@
import pygame, json
"""
Todo:
* Add prop system for Trees, etc. (like off_grid), handle blocked with game objects over props
"""
class Tilemap:
def __init__(self, game, tile=16):
self.game = game
self.tile_size = tile
self.tilemap = {}
self.offgrid_tiles = []
self.waypoints=[]
def save(self, path):
f = open(path, 'w')
json.dump({'tilemap': self.tilemap, 'tile_size': self.tile_size}, f)
json.dump({'tilemap': self.tilemap, 'tile_size': self.tile_size, 'waypoints': self.waypoints}, f)
f.close()
def load(self, path):
@@ -17,8 +24,8 @@ class Tilemap:
f.close()
self.tilemap = map_data['tilemap']
self.tile_size = map_data['tile_size']
self.tile_size = map_data['tile_size']
self.waypoints = map_data['waypoints']
def render(self, surf, offset=(0, 0)):
for x in range(offset[0] // self.tile_size, (offset[0] + surf.get_width()) // self.tile_size + 1):
@@ -27,3 +34,36 @@ class Tilemap:
if loc in self.tilemap:
tile = self.tilemap[loc]
surf.blit(self.game.assets[tile['type']][tile['variant']], (tile['pos'][0] * self.tile_size - offset[0], tile['pos'][1] * self.tile_size - offset[1]))
def render_game(self, surf, camera):
tile_size = self.tile_size
zoom = camera.zoom
scaled_tile_size = int(tile_size * zoom)
start_x = int(camera.offset.x // tile_size)
start_y = int(camera.offset.y // tile_size)
end_x = int((camera.offset.x + surf.get_width() / zoom) // tile_size) + 2
end_y = int((camera.offset.y + surf.get_height() / zoom) // tile_size) + 2
for x in range(start_x, end_x):
for y in range(start_y, end_y):
loc = f"{x};{y}"
if loc in self.tilemap:
tile = self.tilemap[loc]
image = self.game.assets[tile["type"]][tile["variant"]]
scaled_image = pygame.transform.scale(
image,
(scaled_tile_size, scaled_tile_size)
)
world_pos = (
tile["pos"][0] * tile_size,
tile["pos"][1] * tile_size
)
screen_pos = camera.world_to_screen(world_pos)
surf.blit(scaled_image, screen_pos)
game/util.py
+13 -1
View File
@@ -11,6 +11,18 @@ def load_image(path, colorkey=(0,0,0)):
def load_images(dir_path):
images = []
for img_name in os.listdir(img_path+dir_path):
for img_name in os.listdir(img_path + dir_path):
images.append(load_image(dir_path + '/' + img_name))
return images
def tile_to_pixel(waypoint, tile_size, center=False):
if center:
return (
waypoint[0] * tile_size + tile_size // 2,
waypoint[1] * tile_size + tile_size // 2
)
else:
return (
waypoint[0] * tile_size,
waypoint[1] * tile_size
)