171 lines
4.8 KiB
Python
171 lines
4.8 KiB
Python
from engine.resources import res
|
|
from engine.scene import Scene
|
|
from engine.entity import Entity
|
|
from engine.components.sprite import Sprite
|
|
from engine.components.collide_rect import CollideRect
|
|
from engine.servers.graphics import GraphicsServer
|
|
from engine.scene_manager import SceneManager
|
|
from pygame import Rect
|
|
from pygame import image
|
|
from pygame import Surface
|
|
from pygame import draw
|
|
from pygame.locals import *
|
|
from pygame import key
|
|
from itertools import product
|
|
|
|
|
|
S=20
|
|
|
|
|
|
entities=[]
|
|
|
|
|
|
class PacDot(Entity):
|
|
s = Surface((S, S))
|
|
draw.circle(s, (255, 255, 0), (S//2, S//2), S//4)
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
CollideRect(self, Rect(0, 0, S, S),
|
|
static=True, solid=False, cb=self.cb)
|
|
Sprite(self, PacDot.s, 1)
|
|
|
|
def cb(self):
|
|
self.unregister()
|
|
|
|
|
|
def path(start, tgt, x, y, trace, length):
|
|
if start == tgt:
|
|
return length
|
|
if start is None or trace[y][x]:
|
|
return False
|
|
trace[y][x] = True
|
|
u = path(start.up, tgt, x, y-1, trace, length + 1)
|
|
d = path(start.down, tgt, x, y+1, trace, length + 1)
|
|
l = path(start.left, tgt, x-1, y, trace, length + 1)
|
|
r = path(start.right, tgt, x+1, y, trace, length + 1)
|
|
best = None
|
|
for subpath in (u, d, l, r):
|
|
if subpath and (best is None or subpath < best):
|
|
best = subpath
|
|
return best
|
|
|
|
|
|
class Node():
|
|
def __init__(self):
|
|
self.up = None
|
|
self.down = None
|
|
self.left = None
|
|
self.right = None
|
|
|
|
|
|
graph = None
|
|
|
|
|
|
class Level(Entity):
|
|
def __init__(self, path):
|
|
super().__init__()
|
|
desc = image.load(res(path))
|
|
w, h = desc.get_size()
|
|
GraphicsServer().resize((w * S, h * S))
|
|
# graph = [[None for x in range(w)] for y in range(h)]
|
|
self.surf = Surface((w * S, h * S)).convert()
|
|
self.surf.fill((0, 0, 0))
|
|
wall = Surface((S, S)).convert()
|
|
wall.fill((0, 0, 255))
|
|
for x, y in product(range(w), range(h)):
|
|
col = desc.get_at((x, y))
|
|
if col == (0, 0, 255):
|
|
CollideRect(self, Rect(x * S, y * S, S, S))
|
|
self.surf.blit(wall, (x * S, y * S))
|
|
elif col == (139, 139, 139):
|
|
pc = PacDot()
|
|
pc.x = x * S
|
|
pc.y = y * S
|
|
entities.append(pc)
|
|
# elif col == (0, 0, 0):
|
|
# graph[y][x] = Node()
|
|
# for y, line in enumerate(graph):
|
|
# for x, node in enumerate(line):
|
|
# if node is None:
|
|
# continue
|
|
# if x > 0:
|
|
# node.left = graph[y][x-1]
|
|
# if x < w:
|
|
# node.right = graph[y][x+1]
|
|
# if y > 0:
|
|
# node.up = graph[y-1][x]
|
|
# if y < h:
|
|
# node.down = graph[y+1][y]
|
|
Sprite(self, self.surf, 0)
|
|
|
|
|
|
class MovingEntity(Entity):
|
|
def __init__(self, surf):
|
|
super().__init__()
|
|
sprite = Sprite(self, surf, 2)
|
|
self.phys = CollideRect(
|
|
self,
|
|
Rect(self.x, self.y, sprite.width, sprite.width),
|
|
static=False)
|
|
|
|
|
|
class Ghost(MovingEntity):
|
|
def __init__(self):
|
|
super().__init__(image.load(res('ghost.png')).convert())
|
|
self.script = Ghost.script
|
|
|
|
def script(self):
|
|
# cur_node = graph[self.y//S][self.x//S]
|
|
pacman = SceneManager().scene.entities['pacman']
|
|
# pacman_node = graph[pacman.y//S][pacman.x//S]
|
|
x_dist = pacman.x - self.x
|
|
y_dist = pacman.y - self.y
|
|
s = 1
|
|
self.phys.vx = s if x_dist > 0 else -s
|
|
self.phys.vy = s if y_dist > 0 else -s
|
|
|
|
|
|
class Lvl0(Scene):
|
|
def load(self):
|
|
T = 1
|
|
v = 2
|
|
|
|
pac_surf = Surface((S//T, S//T)).convert()
|
|
pac_surf.fill((0, 0, 0))
|
|
draw.circle(pac_surf, (255, 255, 0), (S//(2*T), S//(2*T)), S//(2*T))
|
|
pacman = MovingEntity(pac_surf)
|
|
def pacman_script(entity):
|
|
p = pacman.phys
|
|
inputs = key.get_pressed()
|
|
if T > 1:
|
|
p.vx = 0
|
|
p.vy = 0
|
|
if inputs[K_UP]:
|
|
p.vy = -v
|
|
if inputs[K_DOWN]:
|
|
p.vy = v
|
|
if inputs[K_LEFT]:
|
|
p.vx = -v
|
|
if inputs[K_RIGHT]:
|
|
p.vx = v
|
|
pacman.script = pacman_script
|
|
pacman.x = pacman.phys.rect.x = S*1
|
|
pacman.y = pacman.phys.rect.y = S*1
|
|
|
|
pacman.phys.rect.w = S//T
|
|
pacman.phys.rect.h = S//T
|
|
|
|
self.entities['level'] = Level('lvl0.png')
|
|
for i, entity in enumerate(entities):
|
|
self.entities[f'pacdot-{i}'] = entity
|
|
self.entities['pacman'] = pacman
|
|
self.entities['ghost'] = Ghost()
|
|
self.entities['ghost'].x = S*6
|
|
self.entities['ghost'].y = S*2
|
|
|
|
super().load()
|
|
|
|
|
|
scene = Lvl0()
|