def spawn_bomb(self):
if self.player.bomb_timer <= 0 and self.player.data.bombs > 0:
original = self.player.data.bombs
self.player.data.bombs -= 1
self.player.event_bus.send.append(
Event(
{
'type': PlayerEventType.BOMBS_CHANGED,
'original': original,
'amount': -1,
'new': self.player.data.bombs
}, EventType.PLAYER))
self.player.bomb_timer = constants.BOMB_COOLDOWN
bomb = self.player.world.create_entity_with(
*loader.load("entity", "bomb")[0])
transform = self.player.world.component_for_entity(bomb, Transform)
transform.position.x = self.player.transform.position.x
transform.position.y = self.player.transform.position.y
script = self.player.world.component_for_entity(
bomb, ScriptComponent).script
script.damage_data = self.player.data.get_explosion_damage(
transform.position)
def hurt(self, amount, knockback):
if self.hurt_cooldown > 0:
return
self.hurt_cooldown = constants.HURT_COOLDOWN
original = self.data.health
self.data.health -= amount
if self.data.health <= 0:
gameover = self.world.create_entity_with(
*loader.load("entity", "gameover")[0])
script = self.world.component_for_entity(gameover,
ScriptComponent).script
script.player_pos = self.transform.position
self.data = PlayerData()
else:
self.collision.velocity.x += knockback.x
self.collision.velocity.y += knockback.y
self.sound_hurt.play()
self.event_bus.send.append(
Event(
{
'type': PlayerEventType.HEALTH_CHANGED,
'original': original,
'amount': amount,
'new': self.data.health
}, EventType.PLAYER))
def on_death(self):
drop = self.world.create_entity_with(
*loader.load("entity", "drops/arrow")[0])
transform = self.world.component_for_entity(drop, Transform)
transform.position.x = self.transform.position.x
transform.position.y = self.transform.position.y
def draw_hearts(self, amount):
self.clear_hearts()
for i in range(amount):
heart_entity = self.world.create_entity_with(*loader.load("entity", "ui/overworld/heart")[0])
transform = self.world.component_for_entity(heart_entity, Transform)
transform.position.x = 5 + i * 17
transform.position.y = 5
self._hearts.append(heart_entity)
def start(self, entity, world):
self.entity = entity
self.world = world
self.sprite = self.world.component_for_entity(self.entity, Sprite)
self.load_circle = self.world.create_entity_with(
*loader.load("entity", "load_circle")[0])
self.load_circle_sprite = self.world.component_for_entity(
self.load_circle, Sprite)
def __init__(self, player):
super().__init__(player)
self.sound = pygame.mixer.Sound(paths.SOUNDS +
"player/sword_attack.wav")
self.timer = 0
dir = self.player.facer.get_dir()
if dir == None:
dir = Direction.DOWN
self.real_sword_entity = self.player.world.create_entity_with(
*loader.load("entity", "sword_collision")[0])
sword_script = SwordScript(self.player.data.get_sword_damage(dir),
self.player)
self.player.world.add_component(self.real_sword_entity,
ScriptComponent(sword_script))
self.sword_entity = self.player.world.create_entity_with(
*loader.load("entity", "sword")[0])
def create_player(self):
self.player_gameover = self.world.create_entity_with(
*loader.load("entity", "player_gameover")[0])
transform = self.world.component_for_entity(self.player_gameover,
Transform)
transform.position.x = self.player_pos.x
transform.position.y = self.player_pos.y
animation = self.world.component_for_entity(self.player_gameover,
AnimationSets)
animation.current = "still"
def start(self):
from game import loader
from game.system import AnimationSystem, CollisionSystem, EventBusSystem, EventSystem, MusicSystem, RenderSystem, ScriptSystem, UiSystem
for entity_info in loader.load("scene", "overworld"):
self.world.create_entity_with(*entity_info)
self.world.add_system(AnimationSystem(), 1)
self.world.add_system(CollisionSystem())
self.world.add_system(EventBusSystem())
self.world.add_system(EventSystem())
self.world.add_system(MusicSystem())
self.world.add_system(RenderSystem(self.game.window))
self.world.add_system(ScriptSystem())
self.world.add_system(UiSystem())
def load(loot_name):
loot_data = loader.load("data", "loot/" + loot_name)
items = []
for item_data in loot_data.get('item', []):
drop = Drop.from_data(item_data['drop'])
chance = item_data['chance']
level_factor = item_data.get('level_factor', 1)
level_add = item_data.get('level_add', 0)
items.append(LootItem(drop, chance, level_factor, level_add))
return LootData(items)
def create_text(self):
self.notify.text_entity = self.notify.world.create_entity_with(
*loader.load("entity", "ui/overworld/notification_text")[0])
self.notify.world.remove_component(self.notify.text_entity, Sprite)
sprite = Sprite.new_text(self.notify.queue[0].text, (255, 255, 255),
16)
self.notify.world.add_component(self.notify.text_entity, sprite)
self.text_transform = self.notify.world.component_for_entity(
self.notify.text_entity, Transform)
self.text_transform.position.x = constants.WIDTH / 2 - (
sprite.texture.get_width() * self.text_transform.scale.x) / 2
self.text_transform.position.y = self.notify.transform.position.y + constants.NOTIFY_TEXT_DISTANCE
def die(self):
if self.enemy._dead:
return
self.enemy.on_death()
self.enemy._dead = True
self.enemy.event_bus.send.append(Event({
'type': PlayerEventType.ADD_XP,
'amount': self.enemy.xp_amount
}, EventType.PLAYER, True))
poof_entity = self.enemy.world.create_entity_with(*loader.load("entity", "poof")[0])
poof_transform = self.enemy.world.component_for_entity(poof_entity, Transform)
poof_transform.position = self.enemy.transform.position
def update_action(self):
if self.text_entity != None:
self.world.delete_entity(self.text_entity)
self.text_entity = None
self.sprite.visible = True
self.text_entity = self.world.create_entity_with(
*loader.load("entity", "ui/overworld/action_text")[0])
sprite = Sprite.new_text(self.cur_text, (255, 255, 255), 20)
self.world.add_component(self.text_entity, sprite)
transform = self.world.component_for_entity(self.text_entity,
Transform)
transform.position.x = constants.WIDTH / 2 - sprite.texture.get_width(
) / 2
transform.position.y = 320
def update_text(self, new):
if self.text_entity != None:
self.world.delete_entity(self.text_entity)
self.text_entity = None
self.text_entity = self.world.create_entity_with(*loader.load("entity", "ui/overworld/arrow_text")[0])
transform = self.world.component_for_entity(self.text_entity, Transform)
transform.position.x = self.transform.position.x + 16
transform.position.y = self.transform.position.y + 18
self.world.remove_component(self.text_entity, Sprite)
new_sprite = Sprite.new_text(str(new), (255, 255, 255), 14)
self.world.add_component(self.text_entity, new_sprite)
def update(self, dt):
self.timer += dt
if self.timer >= constants.BOMB_TIME:
self.world.delete_entity(self.entity)
explosion = self.world.create_entity_with(
*loader.load("entity", "explosion")[0])
sprite = self.world.component_for_entity(explosion, Sprite)
transform = self.world.component_for_entity(explosion, Transform)
transform.position.x = (self.transform.position.x + 16) - (
sprite.frame_width * transform.scale.x) / 2
transform.position.y = (self.transform.position.y + 16) - (
sprite.frame_height * transform.scale.y) / 2
self.world.component_for_entity(
explosion,
ScriptComponent).script.damage_data = self.damage_data
def do_gen(self):
for went in self.world.get_all_entities():
if went == self.entity:
continue
if self.world.has_component(went, Tag):
tag = self.world.component_for_entity(went, Tag)
if not "system" in tag.tags:
self.world.delete_entity(went)
else:
self.world.delete_entity(went)
for components in loader.load("entity", "OVERWORLD"):
self.world.create_entity_with(*components)
ld = loader.load_entities_into("loading", self.world)
self.world.add_component(ld,
ScriptComponent(LoadScript(self.generate())))
pygame.mixer.Sound(paths.SOUNDS + "player/climb.wav").play()
def setup_bow(self):
self.bow_entity = self.player.world.create_entity_with(
*loader.load("entity", "bow")[0])
animation = self.player.world.component_for_entity(
self.bow_entity, AnimationSets)
script = self.player.world.component_for_entity(
self.bow_entity, ScriptComponent)
transform = self.player.world.component_for_entity(
self.bow_entity, Transform)
dir = self.player.facer.get_dir()
if dir == None:
dir = Direction.DOWN
script.script.damage_data = self.player.data.get_bow_damage(dir)
script.script.player = self.player
dir = self.player.facer.get_dir()
if dir == Direction.UP:
transform.position.x = self.player.transform.position.x
transform.position.y = self.player.transform.position.y
transform.layer = 9
animation.current = "up"
script.script.dir = Direction.UP
elif dir == Direction.LEFT:
transform.position.x = self.player.transform.position.x - 8
transform.position.y = self.player.transform.position.y
animation.current = "left"
script.script.dir = Direction.LEFT
elif dir == Direction.RIGHT:
transform.position.x = self.player.transform.position.x + self.player.sprite.bounds.width + 4
transform.position.y = self.player.transform.position.y
animation.current = "right"
script.script.dir = Direction.RIGHT
else:
transform.position.x = self.player.transform.position.x
transform.position.y = self.player.transform.position.y + self.player.sprite.bounds.height
animation.current = "down"
script.script.dir = Direction.DOWN
def generate(self):
# TODO
gen = Generator(32, 32)
basicmap = gen.create_dungeon()
yield
tilemap = [0 for i in range(len(basicmap))]
for y in range(0, 32):
for x in range(0, 32):
if gen.get_tile(x, y) == 1:
tilemap[x + y * 32] = -1
continue
n = gen.get_tile(x, y - 1)
ne = gen.get_tile(x + 1, y - 1)
e = gen.get_tile(x + 1, y)
se = gen.get_tile(x + 1, y + 1)
s = gen.get_tile(x, y + 1)
sw = gen.get_tile(x - 1, y + 1)
w = gen.get_tile(x - 1, y)
nw = gen.get_tile(x - 1, y - 1)
sprite_number = 0
if n == 0:
sprite_number += 1
if ne == 0:
sprite_number += 2
if e == 0:
sprite_number += 4
if se == 0:
sprite_number += 8
if s == 0:
sprite_number += 16
if sw == 0:
sprite_number += 32
if w == 0:
sprite_number += 64
if nw == 0:
sprite_number += 128
tilemap[x + y * 32] = tilemappings.get(sprite_number)
yield
populator = Populator(tilemap, 32, 32)
tilemap = populator.populate(5, True)
yield
tile_mappings = loader.load("data", "tiles")
for y in range(0, 32):
for x in range(0, 32):
tile_type = type(tilemap[x + y * 32])
if tile_type == int:
if tilemap[x + y * 32] > -1:
collision = CollisionComponent(
size=pygame.math.Vector2(16, 16), solid=True)
sprite = loader.load("sprite", "bricks")
transform = Transform(position=pygame.math.Vector2(
x * 16 * 2, y * 16 * 2),
scale=pygame.math.Vector2(2, 2))
sprite.start = tilemap[x + y * 32]
sprite.end = sprite.start + 1
self.world.create_entity_with(collision, sprite,
transform)
else:
chance_list = tile_mappings[tilemap[x + y * 32]]
weights = list(
map(lambda x: x.get('chance', 1), chance_list))
choice = random.choices(chance_list, weights)
entity_path = choice[0]['entity']
entities = loader.load("entity", entity_path)
for components in entities:
for component in components:
if type(component) == Transform:
component.position.x = x * 16 * 2
component.position.y = y * 16 * 2
component.scale.x = 2
component.scale.y = 2
self.world.create_entity_with(*components)
yield
floor_sprite = loader.load("sprite", "tiles/floor").repeated(32, 32)
floor_transform = Transform(scale=pygame.math.Vector2(2, 2), layer=-1)
self.world.create_entity_with(floor_sprite, floor_transform)
yield
self.event_bus.send.append(
Event(
{
'type': CameraEventType.SET_BOUNDS,
'x': 0,
'y': 0,
'width': 16 * 2 * 32,
'height': 16 * 2 * 32 + 80
}, EventType.CAMERA))
self.event_bus.send.append(
Event(
{
'type': MusicEventType.PLAY,
'path': "background/background",
'id': constants.MUSIC_BG
}, EventType.MUSIC))
raise StopIteration
def main():
print("Hello from your game's main()")
print(loader.load("sample.txt").read())
pygame.init()
pygame.freetype.init()
pygame.display.set_caption("Amazing Game 10/10") # changes name of pygame window
screen = pygame.display.set_mode((width, height))
clock = pygame.time.Clock()
manager = pygame_gui.UIManager((width, height))
newspaper = popups.Newspaper(
"Ant Colony Overruns Granary! City Officials Scramble."
)
food = 50
population = 50
territory = 50
# creates the Resources object, which can be accessed from anywhere as Resources.instance
Resources(manager, food, population, territory)
# example decisions
theft_decision = events.Decision("theft")
theft_decision.text = (
"An ant was found stealing from the colony's food supply! How do you respond?"
)
theft_decision.options = ["Banish the ant", "Do nothing"]
theft_decision.outcomes = [
"Angry at your decision, several of the banished ant's friends leave with them",
"Seeing there are no conequences, more ants begin to steal food",
]
theft_decision.impacts = [[0, -5, 0], [-10, 0, 0]]
theft_decision.ready() # builds the UI stuff
war_decision = events.Decision("war")
war_decision.text = "The beetles have been encroaching on your territory recently. Should we go to war to teach them a lesson?"
war_decision.options = ["Yes, war!", "No, peace"]
war_decision.outcomes = [
"Your soldiers attack the beetles, sucessfully pushing them back and gaining territory. You do face some losses though",
"The beetles continue to take your land",
]
war_decision.impacts = [[0, -10, 5], [0, 0, -20]]
war_decision.ready() # builds the UI stuff
#example events
spoiled_food_event = events.Event("spoiled food")
spoiled_food_event.text = (
"Some food in storage has spoiled!"
)
spoiled_food_event.impacts = [-5, 0, 0]
spoiled_food_event.ready()
new_land_event = events.Event("new land")
new_land_event.text = (
"Your scouts have found some new uninhabitaded land!"
)
new_land_event.impacts = [0, 0, 5]
new_land_event.ready()
event_queue = [war_decision, spoiled_food_event, newspaper, theft_decision, new_land_event]
current_decision = event_queue.pop(0)
# displayDecision(manager, decision_textbox, decision_buttons, current_decision)
image = pygame.image.load (loader.filepath("Queen's room.png"))
image = pygame.transform.scale(image,(1280,720))
sounds = Sound.Sound(manager, width, height)
sounds.displayVolumeButton()
sounds.playMusic()
while True:
time_delta = clock.tick(60) / 1000
if sounds.volumeButton.check_pressed() and sounds.slidesDisplayed == False:
sounds.displayVolumeSlides()
if sounds.volumeButton.check_pressed() and sounds.slidesDisplayed:
sounds.killVolumeSlides()
sounds.displayVolumeButton()
if sounds.slidesDisplayed:
sounds.updateVolume()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
raise SystemExit
if event.type == pygame.USEREVENT:
pass
manager.process_events(event)
current_decision.process_events(event, sounds)
manager.update(time_delta)
screen.fill(bgcolor)
screen.blit(image,(0,0))
if current_decision.display(time_delta):
if len(event_queue) > 0:
current_decision = event_queue.pop(0)
else:
current_decision = events.NoDecision()
print("no more decisions")
manager.draw_ui(screen)
pygame.display.flip()
def update(self, dt):
for event in self.event_bus.get_events():
if event.ty == EventType.MUSIC:
if event.data['type'] == MusicEventType.PLAY:
if self.cur_slot == None or event.data[
'id'] != self.cur_slot.id:
info = loader.load("music", event.data['path'])
self.cur_slot = MusicSlot(
event.data['id'], info,
event.data.get('lifetime', None))
self.cur_slot.play()
elif self.cur_slot != None and event.data[
'id'] == self.cur_slot.id:
if event.data.get('lifetime', None) != None:
self.cur_slot.lifetime = event.data.get(
'lifetime', None)
elif event.data['type'] == MusicEventType.PUSH:
if self.cur_slot == None or event.data[
'id'] != self.cur_slot.id:
info = loader.load("music", event.data['path'])
if self.cur_slot != None:
self.cur_slot.stamp = pygame.mixer.music.get_pos()
self.cur_slot = MusicSlot(
event.data['id'], info,
event.data.get('lifetime', None), self.cur_slot)
self.cur_slot.play()
elif self.cur_slot != None and event.data[
'id'] == self.cur_slot.id:
if event.data.get('lifetime', None) != None:
self.cur_slot.lifetime = event.data.get(
'lifetime', None)
elif event.data['type'] == MusicEventType.POP:
self.stopping = True
if event.data.get('fade', False):
pygame.mixer.music.fadeout(event.data['fade_time'])
else:
pygame.mixer.music.stop()
if self.cur_slot != None:
self.cur_slot = self.cur_slot.prev
if self.cur_slot != None:
self.cur_slot.play()
if self.cur_slot.stamp != None:
pygame.mixer.music.rewind()
pygame.mixer.music.set_pos(
self.cur_slot.stamp / 1000)
elif event.data['type'] == MusicEventType.CLEAR:
pygame.mixer.music.stop()
self.cur_slot = None
elif event.ty == EventType.PYGAME:
if event.data.type == 32:
if self.cur_slot != None and not self.stopping:
self.cur_slot.next()
self.cur_slot.play()
if self.stopping:
self.stop_counter -= dt
if self.stop_counter <= 0:
self.stopping = False
self.stop_counter = 1
else:
self.stop_counter = 1
if self.cur_slot != None and self.cur_slot.lifetime != None:
self.cur_slot.lifetime -= dt
if self.cur_slot.lifetime <= 0:
self.event_bus.send.append(
Event({
'type': MusicEventType.POP,
'id': self.cur_slot.id
}, EventType.MUSIC))
