def generate_name(self, type):
syllables = load_cfg("Syllables")[type]
syllable_count = random.randrange(2, 4)
surname, title_pre, title_post, i = "", "", "", 0
apos_used = False
while i < syllable_count:
syl = random.choice(syllables)
if i and not random.randint(0, 10) and not apos_used:
surname += "'"
apos_used = True
# if i and not random.randint(0, 40):
# i -= 1
if syl not in surname:
surname += syl
i += 1
if not random.randint(0, 4):
tp = load_cfg("Syllables")["title_pre"]
title_pre = random.choice(tp)
tp = load_cfg("Syllables")["title_post"]
title_post = random.choice(tp)
if random.randint(0, 3):
fullname = "{0} the {1}{2}".format(
surname.title(),
title_pre.title(),
title_post,
)
else:
fullname = "{0} {1}{2}".format(
surname.title(),
title_pre.title(),
title_post,
)
elif not random.randint(0, 6):
if random.randint(0, 1):
tp = load_cfg("Syllables")["title_pre"]
else:
tp = load_cfg("Syllables")["title_post"]
title_pre = random.choice(tp)
if title_pre[0] == "-":
title_pre = title_pre[1:]
fullname = "{0} the {1}".format(
surname.title(),
title_pre.title(),
)
else:
fullname = surname.title()
if check_consecutive_letters(fullname, 3):
# self.generate_name("surname")
return "ERRORNAME LOL"
else:
return fullname
def __init__(self, game):
# Template for multisampling
self.game = game
self.game.log.debug("Setting gl configuration.")
self.cfg = load_cfg("Window")
gl_template = pyglet.gl.Config(sample_buffers=1,
samples=2,
alpha_size=8,
stencil_size=8)
try: # to enable multisampling
self.game.log.debug("Multisampling enabled.")
gl_config = screen.get_best_config(gl_template)
except pyglet.window.NoSuchConfigException:
self.game.log.warning("Failed to enable multisampling.")
gl_template = pyglet.gl.Config(alpha_size=8)
gl_config = screen.get_best_config(gl_template)
gl_context = gl_config.create_context(None)
self.game.log.info("Initializing main window.")
super(GameWindow, self).__init__(
context=gl_context,
config=gl_config,
resizable=False,
vsync=self.cfg["vsync"],
)
self.apply_settings()
# These have seemingly no effects and are just attempts at fixing
# the blurry texture that happens at random
glEnable(GL_TEXTURE_2D)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
def __init__(self, game):
# Template for multisampling
self.game = game
self.game.log.debug("Setting gl configuration.")
self.cfg = load_cfg("Window")
gl_template = pyglet.gl.Config(
sample_buffers=1,
samples=2,
alpha_size=8,
stencil_size=8
)
try: # to enable multisampling
self.game.log.debug("Multisampling enabled.")
gl_config = screen.get_best_config(gl_template)
except pyglet.window.NoSuchConfigException:
self.game.log.warning("Failed to enable multisampling.")
gl_template = pyglet.gl.Config(alpha_size=8)
gl_config = screen.get_best_config(gl_template)
gl_context = gl_config.create_context(None)
self.game.log.info("Initializing main window.")
super(GameWindow, self).__init__(
context=gl_context,
config=gl_config,
resizable=False,
vsync=self.cfg["vsync"],
)
self.apply_settings()
# These have seemingly no effects and are just attempts at fixing
# the blurry texture that happens at random
glEnable(GL_TEXTURE_2D)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
def __init__(self):
loadstart = time.clock()
self.cfg = load_cfg("Game")
# Initialize a window
self.window = GameWindow()
# Forward window events to gameworld
self.window.on_mouse_motion = self.on_mouse_motion
self.window.on_mouse_press = self.on_mouse_press
self.window.on_mouse_scroll = self.on_mouse_scroll
self.window.on_key_press = self.on_key_press
self.window.on_resize = self.on_resize
# Set default zoom
self.view_area = (
0, self.window.width, 0, self.window.height
)
self.zoom_factor = 1.5
# Create a keyboard input handler for pyglet window
self.input_keys = pyglet.window.key.KeyStateHandler()
self.window.push_handlers(self.input_keys)
self.new_game(load=True)
end = time.clock()
logger.info("Game loaded in {:.3f}s.".format(end - loadstart))
def __init__(
self, game, window=None, x=0, y=0,
modifiers=None
):
super().__init__()
self.game = game
self.x, self.y, self.z = x, y, y
self.rectangle = create_rectangle(x, y, 32, 32)
self.hash_position = self.game.spatial_hash.insert_object_for_point(
(self.x, self.y), self
)
if window:
logging.debug("Adding sprite to enemy.")
self.window = window
sx, sy = self.window.get_windowpos(x, y)
self.sprite = pyglet.sprite.Sprite(
window.textures["goblin"],
x=sx, y=sy,
batch=window.batches["creatures"],
subpixel=True
)
# print(self.sprite.image.z)
else:
logging.info("No window specified, not adding sprite to enemy.")
if modifiers:
self.modifiers = modifiers
else:
self.modifiers = dict(
str=5,
int=5,
cha=5,
agi=5
)
self.base_stats = load_cfg("EnemyBaseStats")
self.active_effects = []
self.auto_attack_target = None
self.attack_cd = 0
self.hp = self.max_hp = self.base_stats["hp"]
self.mp = self.max_mp = self.base_stats["mp"]
self.sta = self.max_sta = self.base_stats["sta"]
self.update_stats()
self.hp = self.max_hp
self.mp = self.max_mp
self.sta = self.max_sta
def __init__(self, input_type):
self.input_type = input_type
if input_type == "kb":
self.mapping = load_cfg("KeyboardMap")
def __init__(
self, game, window=None, x=0, y=0,
modifiers={'str': 5, 'int': 5, 'cha': 5, 'agi': 5}, mainstat="agi"
):
super().__init__()
self.game = game
self.child_objects = []
self.cast_object = None
self.x, self.y = x, y
# self.movement = Movement(self)
self.lhand_offset = (0, 0)
self.rhand_offset = (0, 0)
self.body_offset = (0, 0)
self.child_objects.append(HeadBobbing(self, duration=0.5, amount=3))
if window:
self.windowpos = (window.width // 2, window.height // 2)
logging.debug("Adding sprite to player.")
self.window = window
sprite_x, sprite_y = window.get_windowpos(x, y, precise=True)
self.sprite = pyglet.sprite.Sprite(
window.textures["player_body"],
x=window.width // 2, y=window.height // 2,
batch=window.batches["creatures"], group=window.fg_group
)
self.glow = pyglet.sprite.Sprite(
window.textures["player_body_glow"],
x=window.width // 2, y=window.height // 2,
batch=window.batches["creatures"], group=window.mid_group
)
self.glow.color = (255, 255, 255)
self.glow.opacity = 0
else:
logging.info("No window specified, not adding sprite to player.")
self.limbs = dict(
left=Hand(
self, (-10, 8), window.textures["player_hand"],
glow_texture=window.textures["player_hand_glow"],
glow_color=(20, 160, 120)
),
right=Hand(
self, (10, 8), window.textures["player_hand"],
glow_texture=window.textures["player_hand_glow"],
glow_color=(175, 50, 110)
)
)
self.child_objects.append(Pulse(self.limbs["right"].glow))
self.child_objects.append(
Pulse(self.limbs["left"].glow, frequency=0.3)
)
self.child_objects.append(
Pulse(
self.glow, frequency=2.5,
max_opacity=0.3, min_scale=0.8, max_scale=1.3
)
)
self.action = None
self.actions = dict(
sprint=False,
movement=False,
targeting=False,
)
self.auto_attack_target = None
self.target = None
self.modifiers = modifiers
self.modifiers_items = modifiers
self.mainstat = mainstat
self.move_dir = dict(
left=False,
right=False,
up=False,
down=False
)
self.last_dir = "down"
self.head_dir = (1, 0)
self.base_stats = load_cfg("PlayerBaseStats")
self.base_stats_items = self.base_stats.copy()
self.equipped_items = dict(
head=None,
torso=None,
hands=None,
feet=None,
acc_1=None,
acc_2=None,
weapon_l=None,
weapon_r=None,
weapon_2h=None
)
self.attack_effects = dict(
dmg=30,
dmg_type="physical",
stun=0,
slow=0,
aoe=0,
aoe_dmg=0,
dot=None,
dot_dmg=None,
penetration=0,
crit=10
)
self.stats = StatSystem(self)
self.stats.set_base_attack(self.attack_effects)
self.stats.set_base_stats(self.base_stats)
self.stats.recalculate_items()
self.abilities = dict(
slot1=abilities.FireBall(self),
slot2=abilities.SpreadBalls(self),
slot3=abilities.Blink(self),
slot4=abilities.Spark(self),
)
self.hp = self.max_hp = self.base_stats["hp"]
self.mp = self.max_mp = self.base_stats["mp"]
self.sta = self.max_sta = self.base_stats["sta"]
self.xp = 0
self.attack_cd = 0
self.update_stats()
self.restore_stats()
def __init__(self):
super().__init__()
self.log = logger
self.cfg = load_cfg("Game")
self.log.debug("Registering ebs systems.")
self.start_systems()
self.window = GameWindow(self)
self.window.on_mouse_motion = self.on_mouse_motion
self.window.on_mouse_press = self.on_mouse_press
# self.window.on_mouse_scroll = self.on_mouse_scroll
self.window.on_key_press = self.on_key_press
self.window.on_key_release = self.on_key_release
self.kb_state = pyglet.window.key.KeyStateHandler()
self.window.push_handlers(self.kb_state)
self.mouse_click = None
self.key_press = None
# self.window.on_resize = self.on_resize
s = load_cfg("Window")["scale"]
self.scale = s
if (not self.window.width % s and not self.window.height % s):
self.width = self.window.width // s
self.height = self.window.height // s
self.log.info("Render resolution set to {0}x{1}.".format(
self.width, self.height))
else:
self.width = ((self.window.width - self.window.width % s) // s)
self.height = ((self.window.height - self.window.height % s) // s)
self.log.info(
"Resolution doesn't scale nicely, resized to {0}x{1}.".format(
self.width, self.height))
self.mouse_x, self.mouse_y = self.width // 2, self.height // 2
self.offset_x, self.offset_y = 0, 0
self.map_width = self.cfg["map_width"]
self.map_height = self.cfg["map_height"]
self.log.info("Loading textures...")
self.load_textures()
self.log.info("Loading sounds...")
self.load_sounds()
self.log.debug("Defining graphics batches.")
self.batches = OrderedDict()
self.batches["bg"] = pyglet.graphics.Batch()
self.batches["objects"] = pyglet.graphics.Batch()
self.batches["player"] = pyglet.graphics.Batch()
self.batches["fg"] = pyglet.graphics.Batch()
self.batches["ui_bg"] = pyglet.graphics.Batch()
self.batches["ui_fg"] = pyglet.graphics.Batch()
self.log.info("Initializing media player.")
self.media_player = pyglet.media.Player()
self.sfx_player = pyglet.media.Player()
self.sfx_player.eos_action = self.sfx_player.EOS_STOP
self.bgm_looper = pyglet.media.SourceGroup(
self.sounds["bgm01"].audio_format, None)
self.bgm_looper.loop = True
self.log.debug("Queuing background music...")
self.bgm_looper.queue(self.sounds["bgm01"])
self.media_player.queue(self.bgm_looper)
self.media_player.play() # Playing and pausing the media player
self.media_player.pause() # in order to avoid delay on sfx play
self.log.debug("Loading game editor.")
self.editor = Editor(self)
self.shapes = ShapeGenerator()
self.log.info("Creating physics space.")
self.phys_space = pymunk.Space()
self.phys_space.add_collision_handler(
1, 1, post_solve=self.collision_handler)
self.phys_space.gravity = 0, -(self.cfg["gravity"])
self.log.debug("Loading background and foreground sprites.")
entities.BackgroundImage(self)
entities.GroundBlock(self, x=0, y=0, w=self.width, h=16)
# entities.ForegroundImage(self, 50, 16)
# entities.ForegroundImage(self, 90, 48)
# ddentities.ForegroundImage(self, 180, 48)
self.log.info("Spawning static game objects.")
for i in range(self.width // 4, self.width - self.width // 4, 16):
entities.Block(self, x=i, y=self.height - 64, w=16, h=16)
for i in range(self.width // 4, self.width - self.width // 4, 16):
entities.Block(self, x=i, y=40, w=16, h=16)
self.log.info("Creating outer boundaries for game area.")
static_lines = [
pymunk.Segment(self.phys_space.static_body, (0, 15),
(self.map_width, 15), 1),
pymunk.Segment(self.phys_space.static_body, (0, 0),
(0, self.map_height), 1),
pymunk.Segment(self.phys_space.static_body, (self.map_width, 0),
(self.map_width, self.map_height), 1),
pymunk.Segment(self.phys_space.static_body, (0, self.map_height),
(self.map_width, self.map_height), 1),
# pymunk.Segment(
# self.phys_space.static_body, (100, 400), (400, 600), 5
# )
]
for line in static_lines:
line.collision_type = 1
line.elasticity = 0
line.friction = 1
line.group = 1
self.phys_space.add(static_lines)
self.log.info("Spawning player entity.")
self.player = Player(self)
entities.Player(self, x=32, y=80)
self.timer_enabled = False
def newgame(self, level):
logger.info("Starting new game...")
self.window.flush()
# for i in range(100):
# print(str(i) + ": " + self.generate_name("surname"))
dungeon_cfg = load_cfg("Dungeon2")
self.dungeon = DungeonGenerator(
logger,
dungeon_cfg
)
self.game_size = (
dungeon_cfg["dungeon_size"][0] * 32,
dungeon_cfg["dungeon_size"][1] * 32
)
self.space = pymunk.Space()
self.dungeon.generate()
self.spatial_hash = spatial.SpatialHash()
for w in self.dungeon.walls:
self.spatial_hash.insert_object_for_rect(
w.p1,
w.p2,
w
)
for c in self.dungeon.collidable:
self.spatial_hash.insert_object_for_rect(
c.p1,
c.p2,
c
)
logger.info("Generating dungeon graphics...")
img_grid = self.dungeon.get_tilemap()
grid_to_image(
img_grid, "dungeon", self.game_size
)
dungeon_texture = self.window.load_single_texture(
"dungeon"
)
dungeon_overlay_texture = self.window.load_single_texture(
"dungeon_overlay"
)
self.dungeon_sprite = pyglet.sprite.Sprite(
dungeon_texture,
x=0, y=0,
batch=self.window.batches["dungeon"]
)
self.dungeon_overlay_sprite = pyglet.sprite.Sprite(
dungeon_overlay_texture,
x=0, y=0,
batch=self.window.batches["dungeon_overlay"]
)
logger.info("Done.")
start = self.window.grid_to_window(*self.dungeon.startroom.center)
# self.tiles = tiles.TiledRenderer(self.window, level)
self.spawn_player(start)
# Add a static square for every dungeon wall
for w in self.dungeon.walls:
body = pymunk.Body()
body.position = w.center
box_points = [(-16, -16), (-16, 16), (16, 16), (16, -16)]
shape = pymunk.Poly(body, box_points, (0, 0))
shape.group = 1
self.space.add(shape)
w.body = body
for c in self.dungeon.collidable:
body = pymunk.Body()
body.position = c.center
box_points = [(-16, -16), (-16, 16), (16, 16), (16, -16)]
shape = pymunk.Poly(body, box_points, (0, 0))
shape.group = 1
self.space.add(shape)
c.body = body
# self.space.add_collision_handler(1, 1, post_solve=smack)
self.space.damping = 0.001
itemlist = items.L1_Sword(), items.L1_Armor(), items.L1_Ring()
for i in itemlist:
self.player.equip_item(i)
self.player.update_stats()
self.player.restore_stats()
logger.info("Spawning enemies...")
self.enemies = []
for r in self.dungeon.enemy_rooms:
for spawn in r.spawn_locations:
x, y = self.window.grid_to_window(*spawn)
self.add_enemy(x, y)
i = 0
for e in self.enemies:
e.modifiers["str"] += i
e.update_stats()
e.reset()
i += 3
logger.info("Done.")
if self.window.ui:
self.window.ui.add_stats(
self.player, 0, self.window.height, 120, 240
)
logger.info("Game successfully loaded.")
def __init__(self, window):
self.window = window
self.cfg = load_cfg("Game")
def __init__(self):
# Load config from file
self.cfg = load_cfg("Screen")
# Template for multisampling
gl_template = pyglet.gl.Config(
sample_buffers=1,
samples=2,
alpha_size=8
)
try: # to enable multisampling
gl_config = screen.get_best_config(gl_template)
except pyglet.window.NoSuchConfigException:
gl_template = pyglet.gl.Config(alpha_size=8)
gl_config = screen.get_best_config(gl_template)
logger.debug("Creating OpenGL context")
gl_context = gl_config.create_context(None)
logger.debug("Subclassing pyglet window, setting parameters.")
super(GameWindow, self).__init__(
context=gl_context,
config=gl_config,
resizable=False,
vsync=self.cfg["vsync"],
fullscreen=self.cfg["fullscreen"]
)
if not self.fullscreen:
logger.debug(
"Not fullscreen, setting screen resolution to {0}x{1}.".format(
self.cfg["width"], self.cfg["height"]
)
)
logger.debug("Centering window on screen.")
self.set_location(
(screen.width - self.cfg["width"]) // 2,
(screen.height - self.cfg["height"]) // 2
)
self.width, self.height = self.cfg["width"], self.cfg["height"]
# pyglet.gl.glClearDepth(1.0)
# pyglet.gl.glViewport(0, 0, self.width, self.height)
# pyglet.gl.glMatrixMode(pyglet.gl.GL_PROJECTION)
# pyglet.gl.glLoadIdentity()
# pyglet.gl.glOrtho(0, self.width, 0, self.height, 0.0, 1000)
# pyglet.gl.glMatrixMode(pyglet.gl.GL_MODELVIEW)
self.debug = False
self.logger = logger
self.fps_display = pyglet.clock.ClockDisplay()
self.mouse_pos = (0, 0)
self.selected_object = None
logger.debug("Loading textures from folder \"{0}\".".format(RES_PATH))
self.load_textures()
self.load_animations()
self.fg_group = pyglet.graphics.OrderedGroup(2)
self.mid_group = pyglet.graphics.OrderedGroup(1)
self.bg_group = pyglet.graphics.OrderedGroup(0)
self.batches = OrderedDict()
self.batches["gui0"] = pyglet.graphics.Batch()
self.batches["gui1"] = pyglet.graphics.Batch()
self.batches["gui2"] = pyglet.graphics.Batch()
self.batches["gui3"] = pyglet.graphics.Batch()
self.flush()
self.offset_x, self.offset_y = 0, 0
# GUI
self.build_ui()
self.load_map_files()
self.game = Game(self)
self.game.newgame(self.selected_mapfile)
self.update_offset()
def __init__(self):
super().__init__()
self.log = logger
self.cfg = load_cfg("Game")
self.log.debug("Registering ebs systems.")
self.start_systems()
self.window = GameWindow(self)
self.window.on_mouse_motion = self.on_mouse_motion
self.window.on_mouse_press = self.on_mouse_press
# self.window.on_mouse_scroll = self.on_mouse_scroll
self.window.on_key_press = self.on_key_press
self.window.on_key_release = self.on_key_release
self.kb_state = pyglet.window.key.KeyStateHandler()
self.window.push_handlers(self.kb_state)
self.mouse_click = None
self.key_press = None
# self.window.on_resize = self.on_resize
s = load_cfg("Window")["scale"]
self.scale = s
if (
not self.window.width % s and
not self.window.height % s
):
self.width = self.window.width // s
self.height = self.window.height // s
self.log.info(
"Render resolution set to {0}x{1}.".format(
self.width, self.height
)
)
else:
self.width = (
(self.window.width - self.window.width % s) // s
)
self.height = (
(self.window.height - self.window.height % s) // s
)
self.log.info(
"Resolution doesn't scale nicely, resized to {0}x{1}.".format(
self.width, self.height
)
)
self.mouse_x, self.mouse_y = self.width // 2, self.height // 2
self.offset_x, self.offset_y = 0, 0
self.map_width = self.cfg["map_width"]
self.map_height = self.cfg["map_height"]
self.log.info("Loading textures...")
self.load_textures()
self.log.info("Loading sounds...")
self.load_sounds()
self.log.debug("Defining graphics batches.")
self.batches = OrderedDict()
self.batches["bg"] = pyglet.graphics.Batch()
self.batches["objects"] = pyglet.graphics.Batch()
self.batches["player"] = pyglet.graphics.Batch()
self.batches["fg"] = pyglet.graphics.Batch()
self.batches["ui_bg"] = pyglet.graphics.Batch()
self.batches["ui_fg"] = pyglet.graphics.Batch()
self.log.info("Initializing media player.")
self.media_player = pyglet.media.Player()
self.sfx_player = pyglet.media.Player()
self.sfx_player.eos_action = self.sfx_player.EOS_STOP
self.bgm_looper = pyglet.media.SourceGroup(
self.sounds["bgm01"].audio_format, None
)
self.bgm_looper.loop = True
self.log.debug("Queuing background music...")
self.bgm_looper.queue(self.sounds["bgm01"])
self.media_player.queue(self.bgm_looper)
self.media_player.play() # Playing and pausing the media player
self.media_player.pause() # in order to avoid delay on sfx play
self.log.debug("Loading game editor.")
self.editor = Editor(self)
self.shapes = ShapeGenerator()
self.log.info("Creating physics space.")
self.phys_space = pymunk.Space()
self.phys_space.add_collision_handler(
1, 1, post_solve=self.collision_handler
)
self.phys_space.gravity = 0, -(self.cfg["gravity"])
self.log.debug("Loading background and foreground sprites.")
entities.BackgroundImage(self)
entities.GroundBlock(self, x=0, y=0, w=self.width, h=16)
# entities.ForegroundImage(self, 50, 16)
# entities.ForegroundImage(self, 90, 48)
# ddentities.ForegroundImage(self, 180, 48)
self.log.info("Spawning static game objects.")
for i in range(self.width // 4, self.width - self.width // 4, 16):
entities.Block(self, x=i, y=self.height - 64, w=16, h=16)
for i in range(self.width // 4, self.width - self.width // 4, 16):
entities.Block(self, x=i, y=40, w=16, h=16)
self.log.info("Creating outer boundaries for game area.")
static_lines = [
pymunk.Segment(
self.phys_space.static_body, (0, 15), (self.map_width, 15), 1
),
pymunk.Segment(
self.phys_space.static_body, (0, 0), (0, self.map_height), 1
),
pymunk.Segment(
self.phys_space.static_body,
(self.map_width, 0),
(self.map_width, self.map_height), 1
),
pymunk.Segment(
self.phys_space.static_body,
(0, self.map_height),
(self.map_width, self.map_height), 1
),
# pymunk.Segment(
# self.phys_space.static_body, (100, 400), (400, 600), 5
# )
]
for line in static_lines:
line.collision_type = 1
line.elasticity = 0
line.friction = 1
line.group = 1
self.phys_space.add(static_lines)
self.log.info("Spawning player entity.")
self.player = Player(self)
entities.Player(self, x=32, y=80)
self.timer_enabled = False
def __init__(self, input_type):
self.input_type = input_type
if input_type == "kb":
self.mapping = load_cfg("KeyboardMap")
def new_game(self, load=False):
super().__init__()
self.start_systems()
# self.components = {}
self.window.offset_x, self.window.offset_y = 640, 360
# Create batches and load textures
logger.info("Loading textures...")
start = time.clock()
self.batches = OrderedDict()
self.load_textures()
end = time.clock()
logger.info("Done, {:.3f}s.".format(end - start))
# Setup dungeon configuration
logger.info("Building dungeon...")
start = time.clock()
dungeon_cfg = load_cfg("Dungeon2")
self.dungeon = DungeonGenerator(
logger,
dungeon_cfg
)
self.game_size = (
dungeon_cfg["dungeon_size"][0] * 32,
dungeon_cfg["dungeon_size"][1] * 32
)
if load:
self.dungeon.load("saved.json")
else:
self.dungeon.generate()
end = time.clock()
logger.info("Done, {:.3f}s.".format(end - start))
if not load:
self.dungeon.save("saved.json")
logger.info("Generating dungeon graphics...")
start = time.clock()
if load:
pass
else:
img_grid = self.dungeon.get_tilemap()
grid_to_image(
img_grid, "dungeon", self.game_size
)
dungeon_texture = self.load_single_texture(
"dungeon"
)
dungeon_overlay_texture = self.load_single_texture(
"dungeon_overlay"
)
self.bg = BG(self, dungeon_texture)
self.fg = FG(self, dungeon_overlay_texture)
self.bg.batch = Batch("dungeon")
self.bg.batch.group = 0
self.bg.position.set(0, 0)
self.fg.batch = Batch("dungeon")
self.fg.batch.group = 1
self.fg.position.set(0, 0)
end = time.clock()
logger.info("Done, {:.3f}s.".format(end - start))
# Make physical space for physics engine
logger.info("Setup physics space...")
start = time.clock()
self.phys_space = pymunk.Space()
self.phys_space.damping = 0.001
end = time.clock()
logger.info("Done, {:.3f}s.".format(end - start))
# Add entities to the world
logger.info("Spawning enemies...")
start = time.clock()
self.enemies = []
for r in self.dungeon.enemy_rooms:
for spawn in r.spawn_locations:
x, y = spawn[0] * 32, spawn[1] * 32
e = Enemy(self)
e.position.set(x, y)
self.enemies.append(e)
end = time.clock()
logger.info("Done, {:.3f}s.".format(end - start))
logger.info("Generating wall rectangles...")
start = time.clock()
wall_rects = self.dungeon.wall_rects
self.walls = []
for w in wall_rects:
p1, p2 = w
x = (p1[0] * 32)
y = (p1[1] * 32)
w = p2[0] * 32 - p1[0] * 32 + 32
h = p2[1] * 32 - p1[1] * 32 + 32
# print(p1, p2, x, y, w, h)
wa = Wall(self)
wa.physbody = PhysBody(shape="square", width=w, height=h)
wa.position.set(x, y)
self.walls.append(wa)
end = time.clock()
logger.info("Done, {:.3f}s.".format(end - start))
logger.info("Placing collidable items...")
# self.collidable = []
# for c in self.dungeon.collidable:
# print(c.p1)
# co = Wall(self)
# co.physbody = PhysBody(shape="square", width=32, height=32)
# co.position.set(*c.p1)
# self.collidable.append(co)
logger.info("Spawning player...")
self.spawn_player()
# self.e = Enemy(self)
# self.e.position.set(self.p.position.x + 32, self.p.position.y)
# self.e.followtarget.who = self.p
# self.e.lightsource = LightSource()
self.viewlines = []
