def setup(self):
self.dungeon = Dungeon("map.txt")
self.hero = Hero("Geralt", "white wolf", 150, 150, 5)
self.hero.equip(Weapon("Sword", 30))
self.hero.learn(Spell("wolf's attack", 20, 20, 2))
self.dungeon.spawn(self.hero)
self.command = None
def get_get_reponse(self, intent_request, session):
data = {
"card_title": "Get Request",
"card_output": "Get card output",
"request_name": "get",
"should_end_session": False,
"speech_output": "",
"session_attributes": {},
}
item_name = intent_request["intent"]["slots"]["Item"]["value"]
session_attributes = session["attributes"]
dungeon = Dungeon(session_attributes["dungeon_data"])
player = Player(session_attributes["player_data"])
pos = player.data["position"]
if dungeon.item_is_available(item_name, pos):
item = dungeon.take_item(item_name, pos)
player.add_item(item)
data["speech_output"] = "You take the " + item_name
else:
data["speech_output"] = "You cannot take the " + item_name
session_attributes["player_data"] = player.data
session_attributes["dungeon_data"] = dungeon.data
data["session_attributes"] = session_attributes
return data
def make_dungeon_from_dict(self, dungeon_dict):
self.dungeon = Dungeon(dungeon_dict['name'], dungeon_dict['theme'],
dungeon_dict['next'], dungeon_dict['x'],
dungeon_dict['y'], dungeon_dict['roomstr'],
dungeon_dict['d_id'])
self.enable_room_icons(True)
self.view_dungeon_grid()
def main():
hero_name = input("Enter hero's name: ")
hero_title = input("Enter hero's title: ")
hero = Hero(hero_name, hero_title, 150, 150, 5)
hero.equip(Weapon("Sword", 30))
hero.learn(Spell("KillALL", 35, 30, 3))
dungeon = Dungeon("map.txt", "basic_loot_list_example.json")
dungeon.spawn(hero)
dict_commands = {"mu": "up", "md": "down", "ml": "left", "mr": "right", "au": "up", "ad": "down", "al": "left", "ar": "right", "h": "help"}
dict_commands_move = {"mu": "up", "md": "down", "ml": "left", "mr": "right"}
dict_commands_attack = {"au": "up", "ad": "down", "al": "left", "ar": "right"}
index_of_hero = [1, 1]
print_commands()
while not dungeon.end_of_game:
dungeon.print_map()
print()
player_input = ""
while player_input not in dict_commands.keys():
player_input = str(input(">>> "))
if player_input == "h":
print_commands()
if player_input in dict_commands_move.keys():
dungeon.move_hero(dict_commands_move[player_input])
if player_input in dict_commands_attack.keys():
dungeon.hero_atack(dict_commands_attack[player_input])
if dungeon.end_of_game:
break
class SUD:
def __init__(self):
self.myDungeon = 0
def Run(self):
self.myDungeon = Dungeon()
self.myDungeon.Init()
while True:
self.Process()
def Process(self):
self.myDungeon.DisplayCurrentRoom()
key = input(">")
user_input = key.split(' ')
user_input = [x for x in user_input if x != '']
if user_input[0].lower() == 'help':
print("do help")
else:
if user_input[0].lower() == 'go':
if self.myDungeon.isValidMove(user_input[1].lower()):
self.myDungeon.MovePlayer(user_input[1].lower())
else:
self.handleBadInput()
else:
self.handleBadInput()
def handleBadInput(self):
print("\nERROR")
print("Press any key to continue")
input()
def create_dungeon_cb(self, widget, data):
name = data['name'].get_text()
theme = data['theme'].get_active() #.get_active_text()
next = find_key(data['d_list'], data['next_dungeon'].get_active_text())
width = data['width'].get_value_as_int()
height = data['height'].get_value_as_int()
self.dungeon = Dungeon(name, theme, next, width, height)
self.enable_room_icons(True)
self.view_dungeon_grid()
def test_entrance_location_is_positive(self):
"""
This tests whether the entrance location is positive
"""
try:
dungeon = Dungeon(6, 6)
temp4 = dungeon.entrance_generator()
self.assertGreaterEqual(temp4, [0, 0],
"entrance location is positive")
except ValueError as value_error:
self.assertEqual(True, True)
class Game:
def __init__(self):
print("Starting server...")
# Init vars
Global.is_server = True # Used for local client spawning
# Initialise the database system
Database.startup()
# Create the dungeon
self.dungeon = Dungeon()
# Create the server interface
self.server = Server(self.dungeon)
# Create a client for the local player (for testing).
self.do_shutdown = False
#self.create_local_client() # Comment this out unless a test client is desired
# Run the game loop
self.game_loop()
# Shut down the database
Database.shutdown()
"""The main game loop. This updates the dungeons and all player events"""
def game_loop(self):
while not self.do_shutdown:
# Update the game
self.dungeon.update()
time.sleep(0.1)
self.dungeon.destroy()
"""Creates the local client for testing"""
def create_local_client(self):
# Start the client thread
threading.Thread(target=self.local_client_thread, daemon=True).start()
"""Local client thread for testing"""
def local_client_thread(self):
# Create a local client!
from ClientApp import ClientApp
ClientApp()
# Client has closed, shutdown
self.do_shutdown = True
def setUp(self):
path = open("path.txt", "w")
self.dung_map = """S.##......
#.##..###
#.###.###.
#.....###
###.####S"""
path.write(self.dung_map)
path.close()
self.dungeon = Dungeon("path.txt")
self.bron = Hero("Bron", 100, "DragonSlayer")
self.orc = Orc("orc", 90, 1.4)
self.bron.equip_weapon(Weapon("Mighty Axe", 25, 0.2))
self.orc.equip_weapon(Weapon("basher", 16, 0.75))
def new(self):
"""Game class method to start a new game.
"""
# start a new game
# initialise sprite groups
self.all_sprites = pygame.sprite.LayeredUpdates()
self.walls = pygame.sprite.LayeredUpdates()
self.gui = pygame.sprite.LayeredUpdates()
self.enemies = pygame.sprite.LayeredUpdates()
self.item_drops = pygame.sprite.LayeredUpdates()
# instantiate dungeon
self.dungeon = Dungeon(self, cfg.DUNGEON_SIZE)
if self.loaded:
self.dungeon.tileset = self.saveGame.data['tileset']
else:
self.dungeon.create()
self.WSign = self.imageLoader.WarnSign
self.WSign2 = self.imageLoader.WarnSign2
self.inventory = Inventory(self)
# spawn the player in the middle of the room
self.player = Player(self, (cfg.WIDTH // 2, cfg.TILESIZE * 12))
self.currentpistol = Pistol(self, self.player)
self.currentmachine = MachineGun(self, self.player)
if self.pistolpick == True:
self.player.itemA = self.currentpistol
elif self.machinegunpick == True:
self.player.itemA = self.currentmachine
# load settings
if self.loaded:
self.loadSavefile()
# spawn the new objects (invisible)
self.prev_room = self.dungeon.current_room_index
self.transitRoom(self, self.dungeon)
# create a background image from the tileset for the current room
self.background = self.tileRoom(self, self.imageLoader.tileset,
self.dungeon.current_room_index)
self.run()
def test_check_for_enemy_down(self):
d = Dungeon('map.txt', 'basic_loot_list_example.json')
d.spawn(Hero("nz", "nz", 200, 120, 2))
d.hero.learn(Spell("idk", 20, 20, 2))
d.hero_place = [0, 5]
d.change_map("H")
result = d.check_for_enemy("down")
self.assertEqual(result, 2)
def create_dungeons(world):
for dungeon_info in dungeon_table:
name = dungeon_info['name']
hint = dungeon_info['hint'] if 'hint' in dungeon_info else name
if world.settings.logic_rules == 'glitched':
if not world.dungeon_mq[name]:
dungeon_json = os.path.join(data_path('Glitched World'),
name + '.json')
else:
dungeon_json = os.path.join(data_path('Glitched World'),
name + ' MQ.json')
else:
if not world.dungeon_mq[name]:
dungeon_json = os.path.join(data_path('World'), name + '.json')
else:
dungeon_json = os.path.join(data_path('World'),
name + ' MQ.json')
world.load_regions_from_json(dungeon_json)
boss_keys = ItemFactory(['Boss Key (%s)' % name] *
dungeon_info['boss_key'])
if not world.dungeon_mq[dungeon_info['name']]:
small_keys = ItemFactory(['Small Key (%s)' % name] *
dungeon_info['small_key'])
else:
small_keys = ItemFactory(['Small Key (%s)' % name] *
dungeon_info['small_key_mq'])
dungeon_items = ItemFactory(
['Map (%s)' % name, 'Compass (%s)' % name] *
dungeon_info['dungeon_item'])
world.dungeons.append(
Dungeon(world, name, hint, boss_keys, small_keys, dungeon_items))
def make_dungeon_from_dict(self, dungeon_dict):
self.dungeon = Dungeon( dungeon_dict['name'], dungeon_dict['theme'],
dungeon_dict['next'], dungeon_dict['x'],
dungeon_dict['y'], dungeon_dict['roomstr'],
dungeon_dict['d_id'])
self.enable_room_icons(True)
self.view_dungeon_grid()
def create_dungeons(world):
for dungeon_info in dungeon_table:
name = dungeon_info['name']
hint = dungeon_info['hint'] if 'hint' in dungeon_info else name
font_color = dungeon_info['font_color'] if 'font_color' in dungeon_info else 'White'
if world.settings.logic_rules == 'glitched':
if not world.dungeon_mq[name]:
dungeon_json = os.path.join(data_path('Glitched World'), name + '.json')
else:
dungeon_json = os.path.join(data_path('Glitched World'), name + ' MQ.json')
else:
if not world.dungeon_mq[name]:
dungeon_json = os.path.join(data_path('World'), name + '.json')
else:
dungeon_json = os.path.join(data_path('World'), name + ' MQ.json')
world.load_regions_from_json(dungeon_json)
boss_keys = ItemFactory(['Boss Key (%s)' % name] * dungeon_info['boss_key'])
if not world.dungeon_mq[dungeon_info['name']]:
small_keys = ItemFactory(['Small Key (%s)' % name] * dungeon_info['small_key'])
else:
small_keys = ItemFactory(['Small Key (%s)' % name] * dungeon_info['small_key_mq'])
dungeon_items = ItemFactory(['Map (%s)' % name,
'Compass (%s)' % name] * dungeon_info['dungeon_item'])
if world.settings.shuffle_mapcompass in ['any_dungeon', 'overworld']:
for item in dungeon_items:
item.priority = True
world.dungeons.append(Dungeon(world, name, hint, font_color, boss_keys, small_keys, dungeon_items))
def setUp(self):
self.my_hero = Hero("Bron", "Dragonslayer", 100, 50, 2)
self.my_map = [['S', '.', '#', '#', '.', '.', '.', '.', '.', 'T'],
['#', 'T', '#', '#', '.', '.', '#', '#', '#', '.'],
['#', '.', '#', '#', '#', 'E', '#', '#', '#', 'E'],
['#', '.', 'E', '.', '.', '.', '#', '#', '#', '.'],
['#', '#', '#', 'T', '#', '#', '#', '#', '#', 'G']]
self.my_dungeon = Dungeon(self.my_hero, self.my_map)
def reset(self):
with open(self.filename) as file:
line = file.readline()
dimL = line.split(" ")
n = int(dimL[0])
m = int(dimL[1])
self.Dungeon = Dungeon(n, m)
self.X = self.Dungeon.size_x
self.Y = self.Dungeon.size_y
self.start_position = self.Dungeon.start_position
for i in range(n):
line = file.readline()
ElemL = line.split(" ")
for j in range(m):
elmnt = ElemL[j][:1]
self.add_element(elmnt, i, j)
self.Adventurer = Adventurer(self)
def main():
c_bid = 0.1
random.seed(0)
dungeon = Dungeon(30, 40)
random.seed()
simulator1 = RoomGraphSimulator(dungeon)
simulator2 = CellMoveSimulator({}, dungeon)
simulator3 = Simulator2({}, dungeon)
destination_map = learn_room_move(simulator1)
print(destination_map)
q = np.random.random((5, 13, 12, 5, 5, 5, 5, 5))
eps = np.full((5, 13, 12, 5, 5, 5, 5), 0.99)
max_step = 400000
file = open('profit_sharing_log_0_.csv', "w")
for step in range(max_step):
state = simulator2.info()
sum_reward = 0
turn = 0
rules = []
while not state['isEnd']:
s = state_tuple(state)
action = int(select_action(q[s], eps[s]))
eps[s] *= 0.99
rules.append((*s, action))
reward = simulator2.action({
'action':
action,
'nextRoomId':
destination_map[state['roomId']]
})
if reward == -1:
sum_reward += reward
else:
sum_reward += reward
state = simulator2.info()
turn += 1
for rule in rules:
q[rule] = q[rule] + c_bid * (sum_reward - q[rule])
simulator2.reset()
print(step, '/', max_step, 'reward:', sum_reward, 'turn:', turn)
file.write(f'{step},{sum_reward},{turn}\n')
if step % (max_step // 10) == 0:
test(simulator3, q)
file.close()
np.save('q_table1_0_.npy', destination_map)
np.save('q_table2_0_.npy', q)
for _ in range(15):
test(simulator3, q)
time.sleep(1)
def __load_dungeon(self, id):
self.position = (-1, -1)
self.playerFacing = NORTH
d = self.game_engine.get_object('dungeon')
self.dungeon_id = id
d.remove_from_engine()
self.game_engine.remove_object('dungeon')
self.game_engine.add_object('dungeon', Dungeon(self.dungeon_id))
self.remove_keys()
def setUpClass(cls):
"""
This class method setup the dungeon generator once and it can be used
in the test classes below. Otherwise it generates every time and because
there is a random generation in the dungeon generator and it saves time.
"""
cls.nrows = 20
cls.ncols = 20
cls.dungeon = Dungeon(cls.nrows, cls.ncols)
cls.dungeon.dungeon_generator()
def create_dungeon_cb(self, widget, data):
name = data['name'].get_text()
theme = data['theme'].get_active() #.get_active_text()
next = find_key( data['d_list'], data['next_dungeon'].get_active_text())
width = data['width'].get_value_as_int()
height = data['height'].get_value_as_int()
self.dungeon = Dungeon( name, theme, next, width, height )
self.enable_room_icons(True)
self.view_dungeon_grid()
def main():
inp = input(
"Please write how many rows and how many columns you want in the format: rows cols ").split(' ')
dung = Dungeon.generate_map(int(inp[0]), int(inp[1]))
while True:
direction = input(
"Please write down a direction (up, down, left, right) or 'fight' to kill the closest enemy: ")
if not dung.move_hero(direction):
print("Cannot move that way!")
def enterAction(self):
super(InitializationMode, self).enterAction()
try:
del (self.game.dungeon)
except:
pass
self.game.dungeon = Dungeon(self.game.screen.get_width(),
self.game.screen.get_height(), 10, 10)
pass
def get_show_exits_response(self, intent_request, session):
data = {
"card_title": "Show Exits Request",
"card_output": "Show Exits card output",
"request_name": "show_exits",
"should_end_session": False,
"speech_output": "",
"session_attributes": {},
}
session_attributes = session["attributes"]
dungeon = Dungeon(session_attributes["dungeon_data"])
player = Player(session_attributes["player_data"])
data["speech_output"] = dungeon.get_room_layout_text(player.data["position"])
data["session_attributes"] = session_attributes
return data
def __init__(self, param, dungeon=None):
self.random_enemy = param.get('randomEnemy', False)
if dungeon is None:
self.dungeon = Dungeon(30, 40, no_generate_enemy=self.random_enemy)
else:
self.dungeon = dungeon
self.is_end = False
self.friend_agent: Friend = None
self.turn = 0
self.first_room = param.get('firstRoom', None)
self.no_enemy = param.get('noEnemy', False)
self.max_turn = param.get('maxTurn', 1500)
self.map = self.dungeon.floor_map.copy()
self.map[self.map == CellInfo.PROTECTED] = CellInfo.ROOM
self.map[self.map == CellInfo.ENEMY] = CellInfo.ROOM
self.enemy_list = [Enemy(-1, -1), Enemy(-1, -1)]
self.reset()
class SUD:
def __init__(self):
self.myDungeon = 0
# start the dungeon loop
def Run(self):
self.myDungeon = Dungeon()
self.myDungeon.Init()
while True:
self.Process()
def Process(self):
# on server
self.myDungeon.DisplayCurrentRoom() #-> send text to client
# on client
key = input(">")
#on server
user_input = key.split(' ')
user_input = [x for x in user_input if x != '']
if user_input[0].lower() == 'help':
print("do help")
else:
if user_input[0].lower() == "go":
if self.myDungeon.isValidMove(user_input[1].lower()):
self.myDungeon.MovePlayer(user_input[1].lower())
else:
self.handleBadInput()
else:
self.handleBadInput()
# on server #-> send text to client
def handleBadInput(self):
print("\n ERROR")
print("press any key to continue")
input()
def create_quest(self, loc_id, player_id):
dungeonInst = Dungeon()
charInst = Character()
level = charInst.get_char_level(18)
dung_id = dungeonInst.create_dungeon(level, loc_id, player_id)
reward = randint(50, 200)
typeInt = randint(1, 3)
#set the type
if (typeInt == 1):
typeChar = 'K'
description = "Kill this monster"
elif (typeInt == 2):
typeChar = 'F'
description = "Fetch an item for me"
elif (typeInt == 3):
typeChar = 'R'
description = "Rescue my buddy"
#set the experience
if (level < 5):
experience = randint(100, 800)
else:
experience = randint(1000, 3000)
self.connection.cursor.execute(
"""CALL Test.create_quest('{}','{}', '{}', '{}', '{}', '{}')""".
format(reward, description, typeChar, loc_id, experience, dung_id))
self.connection.conn.commit()
self.connection.cursor.execute(
"""SELECT quest_id FROM Quest WHERE Quest.dungeon_id = {}""".
format(dung_id))
quest_id = self.connection.cursor.fetchall()[0][0]
self.connection.cursor.execute(
"""INSERT INTO Quest_log (character_id, quest_id) VALUES ({}, {})"""
.format(player_id, quest_id))
self.connection.conn.commit()
return description
def __init__(self, row=30, column=40):
self.dungeon = Dungeon(row, column)
self.is_end = False
self.friend_agent = None
# 保護解除したマップ
self.map = self.dungeon.floor_map.copy()
self.map[self.map == CellInfo.PROTECTED] = CellInfo.ROOM
self.map[self.map == CellInfo.ENEMY] = CellInfo.ROOM
self.enemy_list = []
self.reset()
def get_go_response(self, intent_request, session):
data = {
"card_title": "Go Request",
"card_output": "Go card output",
"request_name": "go",
"should_end_session": False,
"speech_output": "",
"session_attributes": {},
}
direction = intent_request["intent"]["slots"]["Direction"]["value"]
session_attributes = session["attributes"]
dungeon = Dungeon(session_attributes["dungeon_data"])
player = Player(session_attributes["player_data"])
pos = player.data["position"]
if dungeon.move_is_allowed(pos, direction):
if direction == "north":
pos["y"] = pos["y"] - 1
if direction == "south":
pos["y"] = pos["y"] + 1
if direction == "east":
pos["x"] = pos["x"] + 1
if direction == "west":
pos["x"] = pos["x"] - 1
player.data["position"] = pos
session_attributes["player_data"] = player.data
data["speech_output"] = dungeon.get_room_entry_text(pos)
else:
data["speech_output"] = "You cannot travel " + direction + ". "
data["session_attributes"] = session_attributes
return data
def setUp(self):
path = open("path.txt", "w")
self.dung_map = """S.##......
#.##..###
#.###.###.
#.....###
###.####S"""
path.write(self.dung_map)
path.close()
self.dungeon = Dungeon("path.txt")
self.bron = Hero("Bron", 100, "DragonSlayer")
self.orc = Orc("orc", 90, 1.4)
self.bron.equip_weapon(Weapon("Mighty Axe", 25, 0.2))
self.orc.equip_weapon(Weapon("basher", 16, 0.75))
def on_launch(self, launch_request, session):
card_title = 'Launch'
card_output = 'Launch card'
speech_output = ''
reprompt_text = 'I\'m sorry, I didn\'t quite catch that.'
should_end_session = False
dungeon = Dungeon(None)
player = Player(None)
text = 'You find yourself in a dark room. It is cold. You are alone. '
text = text + dungeon.get_room_look_text(player.data['position'])
text = text + dungeon.get_room_layout_text(player.data['position'])
speech_output = text
session_attributes = {
'dungeon_data': dungeon.data,
'player_data': player.data,
}
speechlet = self._build_speechlet_response(card_title, card_output, speech_output, reprompt_text, should_end_session)
return self._build_response(session_attributes, speechlet)
def __init__(self):
print("Starting server...")
# Init vars
Global.is_server = True # Used for local client spawning
# Initialise the database system
Database.startup()
# Create the dungeon
self.dungeon = Dungeon()
# Create the server interface
self.server = Server(self.dungeon)
# Create a client for the local player (for testing).
self.do_shutdown = False
#self.create_local_client() # Comment this out unless a test client is desired
# Run the game loop
self.game_loop()
# Shut down the database
Database.shutdown()
def __init__(self, dungeon=None):
if dungeon is None:
self.dungeon = Dungeon(30, 40)
else:
self.dungeon = dungeon
self.is_end = False
# 部屋のグラフを指す隣接行列
self.map = [[0] * 5 for _ in range(5)]
for road in self.dungeon.roads:
room1_id = road.connected_rooms[0].id
room2_id = road.connected_rooms[1].id
self.map[room1_id][room2_id] = len(road.cells)
self.map[room2_id][room1_id] = len(road.cells)
self.goal_room_id = self.dungeon.goal_room_index
self.first_room_index_candidate = list(range(5))
self.first_room_index_candidate.remove(self.goal_room_id)
self.agent_room_id = random.choice(self.first_room_index_candidate)
def test_extract_loot(self):
e = None
expected = {
"loot": {
"weapons": {
"0": {
"name": "Winter",
"damage": 45
},
"1": {
"name": "Quickfang",
"damage": "AARD"
}
},
"spells": {
"0": {
"name": "AARD",
"damge": 20,
"mana_cost": 10,
"cast_range": 3
},
"1": {
"name": "IGNI",
"damge": 50,
"mana_cost": 30,
"cast_range": 1
}
}
}
}
try:
res = Dungeon.extract_loot_dictionary("basic_loot_list_example.json")
except Exception as exc:
e = exc
self.assertIsNone(e)
self.assertEqual(res, expected)
def __init__(self):
GameEngineElement.__init__(self, has_draw=False, has_event=True)
self.add_to_engine()
game_size_ratio_x = self.game_engine.width/1200.0
game_size_ratio_y = self.game_engine.height/900.0
term_width_offset = game_size_ratio_x * 200
term_height = game_size_ratio_y * 200
term_height_offset = game_size_ratio_y * 700
term_width = game_size_ratio_x * 1000
"""
term_width_offset = self.game_engine.width/4
term_height = self.game_engine.height/6
term_height_offset = self.game_engine.height - term_height
term_width = self.game_engine.width - term_width_offset
"""
self.game_engine.add_object('mesg', TermBox(term_width_offset, term_height_offset,term_width,term_height,5) )
self.game_engine.get_object('mesg').add_line("Welcome to Fortune Hunter")
self.game_engine.add_object('dungeon', Dungeon( self.game_engine.get_object('profile').dungeon_id))
def parse(inputStream):
dungeon = Dungeon()
start_point = None
end_point = None
for line in inputStream:
if line == '\n':
continue
line = line.replace('\n', '')
# parse start_point and end_point
if re.match(r'^\S+ \S+$',
line) and start_point is None and end_point is None:
start_point, end_point = line.split()
# parse edge with type
elif re.match(
r'^\S+ \S+ \d+ [ud]$',
line) and start_point is not None and end_point is not None:
start, end, dist, edge_type = line.split()
try:
dungeon.add_edge(start, end, int(dist), edge_type)
except Exception as msg:
return dungeon, start_point, end_point, msg
# parse edge without type (by default, the edge is oriented)
elif re.match(
r'^\S+ \S+ \d+$',
line) and start_point is not None and end_point is not None:
start, end, dist = line.split()
try:
dungeon.add_edge(start, end, int(dist))
except Exception as msg:
return dungeon, start_point, end_point, msg
else:
return dungeon, start_point, end_point, 'Invalid input'
if start_point is None or end_point is None:
return dungeon, start_point, end_point, 'Invalid input'
return dungeon, start_point, end_point, None
def test_pick_treasure(self):
my_dict = Dungeon.load_treasure_file("treasures.json")
x = self.my_dungeon.pick_treasure(my_dict)
x = x[:15]
needed = "Bron's treasure"
self.assertEqual(x, needed)
class Game:
"""This class is main Game class.
"""
def __init__(self):
"""__init__ method for Game class.
"""
# initialise game window, settings etc.
pygame.mixer.pre_init(44100, -16, 2, 2048)
pygame.mixer.init()
pygame.init()
pygame.mouse.set_visible(False)
pygame.key.set_repeat(10, cfg.KEY_DELAY)
self.actual_screen = pygame.display.set_mode(
(cfg.S_WIDTH, cfg.S_HEIGHT))
#self.actual_screen = pygame.display.set_mode((cfg.S_WIDTH, cfg.S_HEIGHT), pygame.FULLSCREEN)
self.screen = pygame.Surface((cfg.WIDTH, cfg.HEIGHT))
self.clock = pygame.time.Clock()
self.running = True
self.loaded = False
self.dircheck = None
# booleans for drawing the hit rects and other debug stuff
self.debug = False
self.draw_vectors = False
self.show_player_stats = False
self.caption = ''
self.key_down = None
self.state = 'GAME'
self.in_transition = False
self.loadAssets()
self.clearcount = 0
self.check = True
self.timer = 0
self.levelcleared = 1
self.pistolpick = True
self.machinegunpick = False
self.lastweapon = 'MachineGun'
self.spritecheck = []
def keyDown(self, events, game):
"""Game class method for checking keys presses.
Args:
events (<Event>): key press events.
game (Integrate.Game): Integrate.Game class object.
"""
for event in events:
if event.type == pygame.KEYUP:
if event.key == cfg.KEY_RIGHT:
game.player.RightCheck = False
if event.key == cfg.KEY_UP:
game.player.UpCheck = False
if event.key == cfg.KEY_LEFT:
game.player.LeftCheck = False
if event.key == cfg.KEY_DOWN:
game.player.DownCheck = False
def transitRoom(self, game, dungeon, offset=pygame.math.Vector2(0, 0)):
"""Game class method for room transition.
Args:
game (Integrate.Game): Integrate.Game class object.
dungeon (Dungeon.Dungeon): Dungeon.Dungeon object
"""
# get the index of the next and the previous room
index_next = dungeon.current_room_index
index_prev = game.prev_room
# select the rooms based on the indices
room_prev = dungeon.room_matrix[index_prev[0]][index_prev[1]]
room_next = dungeon.room_matrix[index_next[0]][index_next[1]]
# remove all sprite from the previous room
room_prev.object_data = []
for sprite in game.all_sprites:
if sprite != game.player and sprite not in game.item_drops:
if hasattr(sprite, 'data'):
room_prev.object_data.append(sprite.data)
sprite.kill()
if room_next.visited == False:
# if room not visited, get the object data from the initial layout
data = room_next.layout
for d in data:
try:
if offset == (0, 0):
self.create(game, d)
else:
self.create(game, d, offset)
except Exception:
traceback.print_exc()
pass
room_next.visited = True
else:
# if room already visited, get the objects from the stored data
data = room_next.object_data
for d in data:
try:
if offset == (0, 0):
self.create(game, d)
else:
self.create(game, d, offset)
except Exception:
traceback.print_exc()
pass
# set the dungeon's current room based on room index
dungeon.room_current = dungeon.room_matrix[
dungeon.current_room_index[0]][dungeon.current_room_index[1]]
def create(self, game, data, offset=pygame.math.Vector2(0,
cfg.GUI_HEIGHT)):
"""Game class method for room transition.
Args:
game (Integrate.Game): Integrate.Game class object.
data (dict{'id', 'name', 'x', 'y', 'width', 'height'}): objects data
"""
# takes a dictionary of sprite properties
name = data['name']
# capitalizing first letter
name_1 = name[0].capitalize()
name_2 = name[1:]
name = name_1 + name_2
#instantiate the sprite
spr = module_dict[name](game,
(data['x'] + offset.x, data['y'] + offset.y),
(data['width'], data['height']))
for key, value in data.items():
try:
setattr(spr, key, value)
except:
print('cant set value of {0} for {1}'.format(key, spr))
if hasattr(spr, 'on_create'):
# do initialisation stuff after ___init__()
spr.on_create()
spr.data = data
def loadAssets(self):
"""Game class method to load all assets.
"""
#loading assets (images, sounds)
self.imageLoader = ImageLoader(self)
self.soundLoader = snd.Sound()
try:
self.imageLoader.load_assets()
self.soundLoader.load()
except Exception:
traceback.print_exc()
self.running = False
def new(self):
"""Game class method to start a new game.
"""
# start a new game
# initialise sprite groups
self.all_sprites = pygame.sprite.LayeredUpdates()
self.walls = pygame.sprite.LayeredUpdates()
self.gui = pygame.sprite.LayeredUpdates()
self.enemies = pygame.sprite.LayeredUpdates()
self.item_drops = pygame.sprite.LayeredUpdates()
# instantiate dungeon
self.dungeon = Dungeon(self, cfg.DUNGEON_SIZE)
if self.loaded:
self.dungeon.tileset = self.saveGame.data['tileset']
else:
self.dungeon.create()
self.WSign = self.imageLoader.WarnSign
self.WSign2 = self.imageLoader.WarnSign2
self.inventory = Inventory(self)
# spawn the player in the middle of the room
self.player = Player(self, (cfg.WIDTH // 2, cfg.TILESIZE * 12))
self.currentpistol = Pistol(self, self.player)
self.currentmachine = MachineGun(self, self.player)
if self.pistolpick == True:
self.player.itemA = self.currentpistol
elif self.machinegunpick == True:
self.player.itemA = self.currentmachine
# load settings
if self.loaded:
self.loadSavefile()
# spawn the new objects (invisible)
self.prev_room = self.dungeon.current_room_index
self.transitRoom(self, self.dungeon)
# create a background image from the tileset for the current room
self.background = self.tileRoom(self, self.imageLoader.tileset,
self.dungeon.current_room_index)
self.run()
def checkFight(self, game):
"""Game class method to check distance from door and closes the doors
and opens them when player defeats all enemies in the room
"""
room = game.dungeon.room_current
if len(game.enemies) > 0:
room.cleared = False
else:
if not room.is_doors_shut:
room.cleared = True
return
# check if the room's doors are closed
if room.is_doors_shut == False:
# check player's position
margin_x = 5 * cfg.TILESIZE_SMALL
margin_y = 5.5 * cfg.TILESIZE_SMALL + cfg.GUI_HEIGHT
rect = pygame.Rect((margin_x, margin_y),
(cfg.WIDTH - 2 * margin_x,
cfg.HEIGHT - cfg.GUI_HEIGHT - margin_y))
if rect.colliderect(game.player.hit_rect):
# player is far enough in the room to shut the doors
room.shut_doors()
game.soundLoader.get['roomLocked'].play()
else:
if len(game.enemies) == 0:
# if all enemies are defeated, open the doors
room.open_doors()
game.soundLoader.get['roomCleared'].play()
room.cleared = True
def get_inputs(self, game):
"""Game class method to load all assets store keyboard inputs in a key map
"""
game.keys = {
'A': False,
'B': False,
'X': False,
'Y': False,
'L': False,
'BACK': False,
'START': False,
'STICK_L_PRESSED': False,
'STICK_R_PRESSED': False,
'STICK_R': pygame.math.Vector2(0, 0),
'STICK_L': pygame.math.Vector2(0, 0),
'DPAD': pygame.math.Vector2(0, 0),
'DPAD_MENU': pygame.math.Vector2(0, 0)
}
key = game.keys
# get keyboard keys
get_keys = pygame.key.get_pressed()
if get_keys[cfg.KEY_RIGHT]:
game.player.RightCheck = True
elif get_keys[cfg.KEY_LEFT]:
game.player.LeftCheck = True
if get_keys[cfg.KEY_DOWN]:
game.player.DownCheck = True
elif get_keys[cfg.KEY_UP]:
game.player.UpCheck = True
get_mkeys = pygame.mouse.get_pressed()
key['A'] = get_mkeys == cfg.KEY_A or key['A']
key['B'] = game.key_down == cfg.KEY_B or key['B']
key['X'] = game.key_down == cfg.KEY_ENTER or key['X']
key['START'] = get_keys[cfg.KEY_MENU]
def run(self):
"""Game class method to start running infinite loop until quit.
"""
# game loop
self.playing = True
while self.playing:
#reset game screen
self.screen = pygame.Surface((cfg.WIDTH, cfg.HEIGHT))
self.dt = self.clock.tick(cfg.FPS) / 1000
self.events()
self.get_inputs(self)
self.update()
self.draw()
def events(self):
"""Game class method to loop game events.
"""
# game loop events
self.event_list = pygame.event.get()
for event in self.event_list:
if event.type == pygame.QUIT:
if self.playing:
self.playing = False
self.running = False
pygame.quit()
quit()
if event.type == pygame.KEYDOWN:
# Key events
if event.key == pygame.K_r and self.debug:
self.loaded = False
self.new()
if event.key == pygame.K_h:
self.debug = not self.debug
if event.key == pygame.K_k and self.debug:
# kill all enemies
for e in self.enemies:
e.hp = 0
def screenWrap(self, player, dungeon):
"""Game class method to check if the player goes outside the screen
if they do, set their new position based on where they went
"""
index = list(dungeon.current_room_index)
direction = ''
new_pos = pygame.math.Vector2(player.hit_rect.center)
if player.hit_rect.left < cfg.TILESIZE:
direction = (-1, 0)
player.vel = pygame.math.Vector2(0, 0)
new_pos.x = cfg.WIDTH - player.hit_rect.width - cfg.TILESIZE
index[1] -= 1
elif player.hit_rect.right > cfg.WIDTH - cfg.TILESIZE:
player.vel = pygame.math.Vector2(0, 0)
direction = (1, 0)
new_pos.x = player.hit_rect.width + cfg.TILESIZE
index[1] += 1
elif player.hit_rect.top < cfg.GUI_HEIGHT + cfg.TILESIZE:
player.vel = pygame.math.Vector2(0, 0)
direction = (0, -1)
new_pos.y = cfg.HEIGHT - player.hit_rect.height - cfg.TILESIZE
index[0] -= 1
elif player.hit_rect.bottom > cfg.HEIGHT - cfg.TILESIZE:
player.vel = pygame.math.Vector2(0, 0)
direction = (0, 1)
new_pos.y = player.hit_rect.height + cfg.GUI_HEIGHT + cfg.TILESIZE
index[0] += 1
try:
return direction, index, new_pos
except Exception:
traceback.print_exc()
def update(self):
"""Game class method update game situation.
"""
if self.pistolpick == True:
self.player.itemA = self.currentpistol
elif self.machinegunpick == True:
self.player.itemA = self.currentmachine
if self.debug:
self.caption = (str(round(self.clock.get_fps(), 2)))
else:
self.caption = cfg.TITLE
pygame.display.set_caption(self.caption)
# check for key presses
self.key_down = self.keyDown(self.event_list, self)
if self.state == 'GAME':
pygame.mouse.set_visible(False)
self.all_sprites.update()
self.inventory.update()
# check for room transitions on screen exit (every frame)
self.direction, self.new_room, self.new_pos = self.screenWrap(
self.player, self.dungeon)
if self.direction == UP:
self.dircheck = UP
elif self.direction == DOWN:
self.dircheck = DOWN
elif self.direction == LEFT:
self.dircheck = LEFT
elif self.direction == RIGHT:
self.dircheck = RIGHT
if self.new_room != self.dungeon.current_room_index:
self.prev_room = self.dungeon.current_room_index
self.dungeon.current_room_index = self.new_room
self.state = 'TRANSITION'
# When in a fight, shut the doors:
if not self.dungeon.room_current.cleared:
self.checkFight(self)
if self.check:
if self.dungeon.room_current.cleared:
a = self.clearcount
self.clearcount = self.clearcount + 1
self.spritecheck = []
if a + 1 == self.clearcount:
self.check = False
elif self.state == 'MENU' or self.state == 'MENU_TRANSITION':
pygame.mouse.set_visible(True)
self.inventory.update()
elif self.state == 'TRANSITION':
#self.RoomTransition(self.new_pos, self.direction)
# ^this went into draw()
pass
elif self.state == 'CUTSCENE':
self.walls.update()
def WinSit(self):
"""Game class method to check if player won then show next screen.
"""
global Dx, Dy
if self.dungeon.room_current.type == "endboss" and self.dungeon.room_current.cleared:
pygame.mouse.set_visible(True)
self.state = 'WIN'
self.actual_screen.blit(self.imageLoader.WinImg, (0, 0))
self.Quitbtn = Button(400, 450, 150, 50, 'Quit', (200, 20, 20, 0),
(180, 0, 0, 0), self.imageLoader.font1,
self.imageLoader.font2)
self.Nextbtn = Button(200, 450, 150, 50, 'Next', (200, 20, 20, 0),
(180, 0, 0, 0), self.imageLoader.font1,
self.imageLoader.font2)
self.Quitbtn.show(self.imageLoader.WinImg)
self.Nextbtn.show(self.imageLoader.WinImg)
if self.Quitbtn.is_mouse_clicked():
pygame.quit()
quit()
if self.Nextbtn.is_mouse_clicked():
self.levelcleared += 1
self.clearcount = 0
self.check = True
cfg.DUNGEON_SIZE = (Dx, Dy)
self.state = 'GAME'
self.new()
Dx = Dx + 1
Dy = Dy + 1
def GameOverr(self):
"""Game class method to check if player is dead and game is over.
"""
global Dx, Dy
if self.player.Dead == True:
self.state = 'GAME OVER'
pygame.mouse.set_visible(True)
self.actual_screen.blit(self.imageLoader.GameOverImg, (0, 0))
self.Quitbtn = Button(400, 450, 150, 50, 'Quit', (200, 20, 20, 0),
(180, 0, 0, 0), self.imageLoader.font1,
self.imageLoader.font2)
self.Nextbtn = Button(200, 450, 150, 50, 'Restart',
(200, 20, 20, 0), (180, 0, 0, 0),
self.imageLoader.font1,
self.imageLoader.font2)
self.Quitbtn.show(self.imageLoader.GameOverImg)
self.Nextbtn.show(self.imageLoader.GameOverImg)
if self.Quitbtn.is_mouse_clicked():
pygame.quit()
quit()
if self.Nextbtn.is_mouse_clicked():
self.levelcleared = 1
self.clearcount = 0
Dx = 5
Dy = 5
self.pistolpick = True
self.machinegunpick = False
self.check = True
cfg.DUNGEON_SIZE = (Dx, Dy)
self.state = 'GAME'
self.new()
def draw(self):
"""Game class method to draw
"""
if self.state != 'TRANSITION':
# draw the background (tilemap)
self.screen.blit(self.background, (0, cfg.GUI_HEIGHT))
# call additional draw methods (before drawing)
for sprite in self.all_sprites:
if hasattr(sprite, 'draw_before'):
sprite.draw_before()
# draw the sprites
self.all_sprites.draw(self.screen)
for sprite in self.all_sprites:
if hasattr(sprite, 'draw_after'):
sprite.draw_after()
# for machine gun with player
if self.machinegunpick and self.player.itemA == self.currentmachine:
if self.player.itemA.check and self.player.mana < 9.8:
self.WSignRect = self.WSign.get_rect()
self.WSignRect.center = pygame.mouse.get_pos(
) - pygame.math.Vector2(0, 30)
self.screen.blit(self.WSign, self.WSignRect)
if self.player.itemA.check and self.player.mana > 9.8:
self.WSignRect = self.WSign2.get_rect()
self.WSignRect.center = pygame.mouse.get_pos(
) - pygame.math.Vector2(0, 30)
self.screen.blit(self.WSign2, self.WSignRect)
if self.player.mana < 0.2:
self.cursor = self.imageLoader.CursorMain1
elif self.player.mana < 1.4:
self.cursor = self.imageLoader.cursor[0]
elif self.player.mana < 2.8:
self.cursor = self.imageLoader.cursor[1]
elif self.player.mana < 4.2:
self.cursor = self.imageLoader.cursor[2]
elif self.player.mana < 5.6:
self.cursor = self.imageLoader.cursor[3]
elif self.player.mana < 7:
self.cursor = self.imageLoader.cursor[4]
elif self.player.mana < 8.4:
self.cursor = self.imageLoader.cursor[5]
elif self.player.mana < 9.8:
self.cursor = self.imageLoader.cursor[6]
elif self.player.mana < 11.4:
self.cursor = self.imageLoader.cursor[7]
self.cursorrect = self.cursor.get_rect()
self.cursorrect.center = pygame.mouse.get_pos()
self.screen.blit(self.cursor, self.cursorrect)
else:
self.cursor = self.imageLoader.CursorMain1
self.cursorrect = self.cursor.get_rect()
self.cursorrect.center = pygame.mouse.get_pos()
self.screen.blit(self.cursor, self.cursorrect)
else:
self.RoomTransition(self.new_pos, self.direction)
if not self.dungeon.room_current.cleared:
self.check = True
# ----- DEBUG STUFF ----- #
# draw hitboxes in debug mode
if self.debug:
for sprite in self.all_sprites:
if hasattr(sprite, 'hit_rect'):
pygame.draw.rect(self.screen, cfg.CYAN, sprite.hit_rect, 1)
if hasattr(sprite, 'interact_rect'):
pygame.draw.rect(self.screen, cfg.GREEN,
sprite.interact_rect, 1)
# draw the inventory
self.drawGUI()
self.screen = pygame.transform.scale(self.screen,
(cfg.S_WIDTH, cfg.S_HEIGHT))
self.actual_screen.blit(self.screen, (0, 0))
self.WinSit()
self.GameOverr()
pygame.display.update()
def drawGUI(self):
"""Game class method draw inventory with map.
"""
self.inventory.map_img = self.dungeon.render_rooms_map()
self.inventory.draw()
def tileRoom(self, game, tileset, index):
"""Game class method render room tiles.
"""
image = pygame.Surface((cfg.WIDTH, cfg.HEIGHT - cfg.GUI_HEIGHT))
data = game.dungeon.room_matrix[index[0]][index[1]].tiles
for i in range(len(data)):
for j in range(len(data[i])):
x = j * cfg.TILESIZE
y = i * cfg.TILESIZE
try:
image.blit(tileset[data[i][j]], (x, y))
except Exception:
traceback.print_exc()
return
return image
def RoomTransition(self, new_pos, direction):
"""Game class method for room transition.
Args:
new_pos (tuple): tuple with x,y corrdinates for the new room for player
direction (Up, DOWN, LEFT OR RIGHT): direction of start in new room
"""
if not self.in_transition:
# store the old background image temporarily
self.old_background = self.background
# blit the background and sprites to prevent flickering
self.screen.blit(self.old_background, (0, cfg.GUI_HEIGHT))
self.all_sprites.draw(self.screen)
# build the new room
self.background = self.tileRoom(self, self.imageLoader.tileset,
self.dungeon.current_room_index)
# scroll the new and old background
# start positions for the new bg are based on the direction the
# player is moving
start_positions = {
UP: pygame.math.Vector2(0, -(cfg.HEIGHT - cfg.GUI_HEIGHT * 2)),
DOWN: pygame.math.Vector2(0, cfg.HEIGHT),
LEFT: pygame.math.Vector2(-cfg.WIDTH, cfg.GUI_HEIGHT),
RIGHT: pygame.math.Vector2(cfg.WIDTH, cfg.GUI_HEIGHT)
}
self.bg_pos1 = start_positions[direction]
# pos2 is the old bg's position that gets pushed out of the screen
self.bg_pos2 = pygame.math.Vector2(0, cfg.GUI_HEIGHT)
self.in_transition = True
self.transitRoom(self, self.dungeon, self.bg_pos1)
else:
if self.bg_pos1 != (0, cfg.GUI_HEIGHT):
# moves the 2 room backrounds until the new background is at (0,0)
# PROBLEM: Only works with certain scroll speeds!
# calculate the move vector based on the direction
move = (pygame.math.Vector2(0, 0) -
direction) * cfg.SCROLLSPEED
# move the background surfaces
self.bg_pos1 += move
self.bg_pos2 += move
if direction == UP:
self.bg_pos1.y = min(cfg.GUI_HEIGHT, self.bg_pos1.y)
elif direction == DOWN:
self.bg_pos1.y = max(cfg.GUI_HEIGHT, self.bg_pos1.y)
elif direction == LEFT:
self.bg_pos1.x = min(0, self.bg_pos1.x)
elif direction == RIGHT:
self.bg_pos1.x = max(0, self.bg_pos1.x)
# move the sprites during transition
for sprite in self.all_sprites:
sprite.rect.topleft += move
sprite.hit_rect.topleft += move
sprite.pos += move
self.screen.blit(self.old_background, self.bg_pos2)
self.screen.blit(self.background, self.bg_pos1)
self.all_sprites.draw(self.screen)
else:
# update the player's position
self.player.pos = pygame.math.Vector2(new_pos)
self.player.hit_rect.center = pygame.math.Vector2(new_pos)
self.player.spawn_pos = pygame.math.Vector2(new_pos)
self.player.rect.bottom = self.player.hit_rect.bottom
# end transtition
self.in_transition = False
self.state = 'GAME'
# blit the background and sprites to prevent flickering
self.screen.blit(self.background, (0, cfg.GUI_HEIGHT))
self.all_sprites.draw(self.screen)
def main (self, Surface):
while True:
Surface.fill((0,0,0))
dt = self.time
self.mainClock.tick(30)
for cell in self.tilemap.layers['triggers'].collide(self.player.collisionRect, 'Porta'):
self.tilemap.StopSounds()
self.Escroto.SaveTilemap(self.Location+'.tilemap', self.tilemap)
if self.Location == 'Caverna' and cell['Porta'] == 'Dungeon' or self.Location == 'Dungeon' and cell['Porta'] == 'Caverna':
play(pygame.mixer.Sound(resources.file_path('sfx_teleporte.ogg', 'Musica')), 1, self.musicPlaying)
self.Location = cell['Porta']
NewSurface = pygame.Surface.copy(Surface)
self.tilemap.draw(NewSurface)
del self.tilemap
if self.Location == 'Campo':
self.tilemap = Campo(self.width, self.height, self)
elif self.Location == 'Caverna':
self.tilemap = Caverna(self.width, self.height, self)
elif self.Location == 'Dungeon':
self.tilemap = Dungeon(self.width, self.height, self)
else:
self.tilemap = SalaDoChefe(self.width, self.height, self)
self.player.Reset((cell['PlayerX'] - 16, cell['PlayerY']-28))
self.player.kill()
self.player.add([self.tilemap.SpritesToChoose])
self.tilemap.set_focus(self.player.collisionRect.centerx, self.player.collisionRect.centery)
if self.Location != 'Sala do Mestre':
self.tilemap.Reload(self, (cell['PlayerX']-16, cell['PlayerY']-28))
for sprite in np.array(self.tilemap.Holes):
if self.player.collisionRect.colliderect(sprite.rect):
sprite.kill()
del sprite
FadeOut(self, NewSurface, Surface)
self.ResizeScreen(Surface.get_width(), Surface.get_height())
self.Pause = True
self.first = True
if self.Master:
self.Location = 'Dungeon'
play(self.Sounds['Jóia'], 1, self.musicPlaying)
NewSurface = pygame.Surface.copy(Surface)
NewSurface.blit(self.tilemap.images['background'], ((self.width-WIDTH)//2,0))
self.tilemap.draw(NewSurface)
del self.tilemap
self.tilemap = Dungeon(self.width, self.height, self)
self.tilemap.Reload(self, (664, 28))
self.tilemap.set_focus(self.player.collisionRect.centerx, self.player.collisionRect.centery)
FadeOut(self,NewSurface, Surface)
for sprite in self.tilemap.Holes:
if self.player.collisionRect.colliderect(sprite.rect):
sprite.kill()
del sprite
self.Pause = True
self.first = True
bloqueio = Pilastra(self.tilemap.images['bloqueio'], 'bloqueio', (656, 12), (self.tilemap.SpritesToChoose, self.tilemap.Pilastras))
for cell in self.tilemap.layers['triggers'].collide(bloqueio.rect, 'block'):
if 'a' in cell['block']:
cell['block'] = 'ftlrb'
for event in pygame.event.get():
BASIC_GAME_Events(self, event, Surface)
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
play(self.Sounds['MenuSelect'], 1, self.musicPlaying)
if self.Pause:
if self.menu:
if self.Menu.name == 'Escroto':
self.menu = False
self.Pause = False
self.tilemap.UnpauseSounds()
else:
self.Menu = self.Escroto
else:
if (self.Location == 'Campo' and not self.tilemap.Moshiro.talking and not self.tilemap.Lisa.talking) or self.Location != 'Campo':
self.Pause = True
self.menu = True
self.Menu = self.Escroto
self.tilemap.PauseSounds()
if event.key == K_RETURN:
#Menu de Gente Grande
play(self.Sounds['MenuSelect'], 1, self.musicPlaying)
if self.Pause:
if self.menu:
if self.Menu.name == 'ItemMenu':
if self.Menu.menu == 'Ferramenta':
for key in self.Menu.Itens:
if self.Menu.Itens[key]['Coluna'] == self.Menu.selected[0] and self.Menu.Itens[key]['Linha'] == self.Menu.selected[1]:
self.Menu.Itens[self.Menu.using]['Usando'] = False
self.Menu.Itens[key]['Usando'] = True
self.Menu.using = key
self.player.item = key
self.Pause = False
self.menu = False
self.tilemap.UnpauseSounds()
else:
self.Menu = self.ItemMenu
else:
if (self.Location == 'Campo' and not self.tilemap.Moshiro.talking and not self.tilemap.Lisa.talking) or self.Location != 'Campo':
self.Pause = True
self.menu = True
self.Menu = self.ItemMenu
self.tilemap.PauseSounds()
if event.key == K_a:
if not self.Pause:
self.tilemap.EventGet(self)
else:
if self.Menu.name == 'Escroto':
play(self.Sounds['MenuSelect'], 1, self.musicPlaying)
if self.Menu.selected == 0 or self.Menu.selected == 4 or self.Menu.selected == 5:
self.Menu.selected = 0
self.Menu.Max = 2
self.Menu.Min = 0
self.menu = False
self.Pause = False
self.tilemap.UnpauseSounds()
elif self.Menu.selected == 1 and self.Location != 'Sala do Mestre':
self.Menu.selected = 3
self.Menu.salvando = True
elif self.Menu.selected == 2:
self.Menu.selected = 5
self.Menu.Max = 6
self.Menu.Min = 5
elif self.Menu.selected == 6:
terminate()
if event.key == K_s and not self.player.atking and not self.Pause:
tileX = testX1 = (self.player.collisionRect.centerx // 16)*16
tileY = testY1 = (self.player.collisionRect.centery // 12)*12
if self.player.direction == 0:
testY1 += 12
elif self.player.direction == 2:
testY1 -= 12
elif self.player.direction == 3:
testX1 -= 16
else:
testX1 += 16
colide = False
for enemie in self.tilemap.Enemies:
if pygame.rect.Rect(testX1, testY1, 16,12).colliderect(enemie.collisionRect):
colide = True
break
if not colide:
if self.player.item == 'Pá':
self.player.spritesheet = self.player.PaSheet
self.player.number_of_sprite = 0
self.player.cont = 0
self.player.image = self.player.spritesheet[self.player.direction
][self.player.number_of_sprite]
self.player.digging = True
self.player.collisionRect.centerx = tileX + 8
self.player.collisionRect.centery = tileY + 6
self.player.rect = pygame.rect.Rect(self.player.rect.left - 16,
self.player.rect.top - 20,
48, 44)
for hole in self.tilemap.Holes:
if pygame.rect.Rect(testX1, testY1, 16,12).colliderect(hole.rect):
colide = True
break
if self.player.item == 'Bomba' and len(self.tilemap.Bombas) == 0 and not colide:
if len(self.tilemap.Bombas) == 0:
play(self.Sounds['Bomba'], 1, self.musicPlaying)
if len(self.tilemap.layers['triggers'].collide(pygame.rect.Rect(testX1 + 7, testY1 + 5, 1,1), 'block')) == 0:
Pilastra(self.images['Bomba'], 'Bomba', (testX1, testY1), (self.tilemap.Bombas, self.tilemap.SpritesToChoose))
self.player.collisionRect.centerx = tileX + 8
self.player.collisionRect.centery = tileY + 6
else:
Pilastra(self.images['Bomba'], 'Bomba', (tileX, tileY), (self.tilemap.Bombas, self.tilemap.SpritesToChoose))
self.player.collisionRect.centerx = tileX + (tileX - testX1) + 8
self.player.collisionRect.centery = tileY + (tileY - testY1) + 6
if self.player.item == 'Martelo':
self.player.spritesheet = self.player.MarteloSheet
self.player.number_of_sprite = 0
self.player.cont = 0
self.player.image = self.player.spritesheet[
self.player.direction][self.player.number_of_sprite]
self.player.martelando = True
self.player.collisionRect.centerx = tileX + 8
self.player.collisionRect.centery = tileY + 6
if self.menu:
play(self.Sounds['MenuMove'], 1, self.musicPlaying)
if self.Menu.name == 'ItemMenu':
if event.key == K_UP:
self.Menu.selected[1] -= 1
if event.key == K_DOWN:
self.Menu.selected[1] += 1
if event.key == K_LEFT:
self.Menu.selected[0] -= 1
if event.key == K_RIGHT:
self.Menu.selected[0] += 1
else:
if event.key == K_UP:
if self.Menu.selected < self.Menu.Max + 1:
self.Menu.selected -= 1
if event.key == K_DOWN:
if self.Menu.selected < self.Menu.Max + 1:
self.Menu.selected += 1
#if self.selected == 3:
#self.selected = 0
self.tilemap.Actions(self)
if self.first:
if self.Location == 'Sala do Mestre':
NewSurface.fill((0,0,0))
NewSurface.blit(self.tilemap.images['background'], (((self.width-WIDTH)//2,0)))
self.tilemap.draw(NewSurface)
FadeIn(self,NewSurface, Surface)
del NewSurface
self.first = False
self.second = True
if self.Master:
self.Master = False
self.Escroto.SaveGame(self,'CheckPoint.save', 0 ,2,0)
elif self.second:
self.Pause = False
self.second = False
if self.musicPlaying:
self.tilemap.InicializeSounds()
if self.Location == 'Sala do Mestre':
pygame.mixer.Sound(resources.file_path('sfx_mestre_intro.ogg','Musica')).play(0)
if not self.Pause:
self.tilemap.update(dt, self)
if self.Location == 'Sala do Mestre':
Surface.fill((0,0,0))
Surface.blit(self.tilemap.images['background'], ((self.width-WIDTH)//2,0))
self.tilemap.draw(Surface)
if self.menu:
self.Menu.update(dt, self)
if self.menu:
self.Menu.draw(self, Surface)
else:
BlitLife(Surface, self, self.Heart, self.images['Stamina'], self.tools[0][self.choosed[self.player.item]])
if self.PegouJóia:
play(self.Sounds['Jóia'], 1, self.musicPlaying)
self.Escroto.SaveGame(self,'CheckPoint.save', 0 ,2,0)
self.PegouJóia = False
TransformSurfaceScale(Surface, self.width, self.height, self.rect)
pygame.display.update()
if self.Location == 'Campo':
self.tilemap.SetSound(self)
for npc in self.tilemap.NPCs:
if npc.talking:
self.tilemap.PauseEspecial()
npc.display(Surface, self)
if self.player.vida <= 0:
self.tilemap.StopSounds()
self.Died(Surface)
elif 0 < self.player.vida <= 2:
if self.musicPlaying:
if self.Sounds['Morrendo'].get_num_channels() == 0:
self.Sounds['Morrendo'].play(-1)
else:
if self.Sounds['Morrendo'].get_num_channels() > 0:
self.Sounds['Morrendo'].stop()
class FortuneMaker(Activity):
def __init__(self, handle):
Activity.__init__(self, handle)
self.dungeon = None
self.active_room = None
self.action_but_group = None
# INITIALIZE GUI
################
self.set_title('FortuneMaker')
# Create Toolbox
self.build_toolbars()
self.enable_room_icons(False)
self.show_home()
def build_toolbars(self):
self.dungeon_buttons = {}
self.dungeon_bar = gtk.Toolbar()
self.view_bar = gtk.Toolbar()
# BUILD CUSTOM TOOLBAR
# Dungeon Bar
self.dungeon_buttons['new'] = ToolButton('add')
self.dungeon_buttons['new'].set_tooltip(_("New Dungeon"))
self.dungeon_buttons['new'].connect("clicked", self.view_change_cb, 'new')
self.dungeon_bar.insert(self.dungeon_buttons['new'], -1)
self.dungeon_buttons['load'] = ToolButton('fileopen')
self.dungeon_buttons['load'].set_tooltip(_("Open Dungeon"))
self.dungeon_buttons['load'].connect("clicked", self.view_change_cb, 'load')
self.dungeon_bar.insert(self.dungeon_buttons['load'], -1)
self.dungeon_buttons['save'] = ToolButton('filesave')
self.dungeon_buttons['save'].set_tooltip( _("Export dungeon file to journal") )
self.dungeon_buttons['save'].connect("clicked", self.view_change_cb, 'export')
self.dungeon_bar.insert(self.dungeon_buttons['save'], -1)
self.dungeon_buttons['save'].set_sensitive( False )
# VIEW BAR
self.dungeon_buttons['home'] = ToolButton('go-home')
self.dungeon_buttons['home'].set_tooltip(_("Welcome Screen"))
self.dungeon_buttons['home'].connect("clicked", self.view_change_cb, 'home')
self.view_bar.insert(self.dungeon_buttons['home'], -1)
self.dungeon_buttons['settings'] = ToolButton('view-spiral')
self.dungeon_buttons['settings'].set_tooltip(_("View Dungeon Settings"))
self.dungeon_buttons['settings'].connect("clicked", self.view_change_cb, 'settings')
self.view_bar.insert(self.dungeon_buttons['settings'], -1)
self.dungeon_buttons['settings'].set_sensitive( False )
self.dungeon_buttons['layout'] = ToolButton('view-freeform')
self.dungeon_buttons['layout'].set_tooltip(_("View Dungeon Layout"))
self.dungeon_buttons['layout'].connect("clicked", self.view_change_cb, 'layout')
self.view_bar.insert(self.dungeon_buttons['layout'], -1)
self.dungeon_buttons['layout'].set_sensitive( False )
self.toolbox = ActivityToolbox(self)
# Remove Share Bar
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar.remove(activity_toolbar.share)
activity_toolbar.share = None
#Add our custom items to the toolbar
self.toolbox.add_toolbar(_("Dungeon"), self.dungeon_bar)
self.toolbox.add_toolbar(_("View"), self.view_bar)
self.set_toolbox(self.toolbox)
self.toolbox.show()
def enable_room_icons(self, dn=True):
self.dungeon_buttons['settings'].set_sensitive( dn )
self.dungeon_buttons['save'].set_sensitive( dn )
self.dungeon_buttons['layout'].set_sensitive( dn )
def view_change_cb(self, widget, view=None):
if view == 'layout':
self.view_dungeon_grid()
elif view == 'export':
self.export_view()
elif view == 'new':
self.set_create_dungeon_settings()
elif view == 'load':
self.show_dungeon_selection()
elif view == 'settings':
self.show_dungeon_settings()
elif view == 'home':
self.show_home()
def show_home(self):
window_container = gtk.VBox()
label = gtk.Label(_("Welcome to Fortune Maker"))
window_container.pack_start(label, False)
# New Dungeon
button = gtk.Button()
button.set_image( Icon( icon_name="add" ) )
button.set_label( _("New Dungeon") )
button.set_alignment(0.0,0.5)
button.connect( 'clicked', self.view_change_cb, 'new')
window_container.pack_start(button, False)
# load fileopen
button = gtk.Button()
button.set_image( Icon( icon_name="fileopen" ) )
button.set_label( _("Load Exported Dungeon") )
button.set_alignment(0.0,0.5)
button.connect( 'clicked', self.view_change_cb, 'load')
window_container.pack_start(button, False)
#HELP EXAMPLES
label = gtk.Label(_("Dungeon Toolbar") )
label.set_alignment( 0, 0.5 )
window_container.pack_start(gtk.Label(" "), False)
window_container.pack_start(label, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="add" ), False )
label = gtk.Label( _("Creates New Dungeon") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="fileopen" ), False )
label = gtk.Label( _("Opens existing dungeon file") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="filesave" ), False )
label = gtk.Label( _("Export dungeon file to journal") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
# View Bar Help
label = gtk.Label(_("View Toolbar") )
label.set_alignment( 0, 0.5 )
window_container.pack_start(gtk.Label(" "), False)
window_container.pack_start(label, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="go-home" ), False )
label = gtk.Label( _("Display this home screen") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="view-spiral" ), False )
label = gtk.Label( _("Shows the dungeon settings") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
row = gtk.HBox()
row.pack_start( Icon( icon_name="view-freeform" ), False )
label = gtk.Label( _("Shows the dungeon layout") )
label.set_alignment( 0, 0.5 )
row.pack_start(gtk.Label(" "), False)
row.pack_start( label )
window_container.pack_start(row, False)
window_container.pack_start( gtk.Label(" "), False )
label = gtk.Label(_("Dungeons must be exported before they\n" +
"may be loaded into Fortune Hunter\n" +
"or linked as a next dungeon."))
window_container.pack_start( label, False)
room_center = gtk.HBox()
room_center.pack_start( gtk.Label() )
room_center.pack_start( window_container )
room_center.pack_start( gtk.Label() )
self.set_gui_view( room_center )
def export_view(self):
if self.dungeon.valid_dungeon():
data = self.dungeon.export()
filename = self.dungeon.name
JournalIntegration.export_textfile( self, filename, self.dungeon.id, data )
self._alert( _( "Dungeon Exported to Journal"), filename )
else:
self._alert( _( "Export Failed"), _("Invalid dungeon configuration") )
def set_gui_view(self, view):
self.set_canvas( view )
self.show_all()
def show_dungeon_selection(self):
window_container = gtk.VBox()
frame = gtk.Frame( _("Load Dungeon") )
file_container = gtk.VBox()
##LOAD FILE LIST HERE
file_list = JournalIntegration.list_fh_files()
for dfile in file_list:
row = gtk.HBox()
label = gtk.Label(dfile.metadata['title'])
row.pack_start( label, False )
button = gtk.Button(_("Load"))
button.connect( 'clicked', self.load_dungeon, dfile )
row.pack_end(button, False)
file_container.pack_start( row, False )
frame.add( make_it_scroll( file_container ) )
window_container.pack_start( frame )
room_center = gtk.HBox()
room_center.pack_start( gtk.Label() )
room_center.pack_start( window_container )
room_center.pack_start( gtk.Label() )
self.set_gui_view( room_center )
def show_dungeon_settings(self):
window_container, name, theme, next_dungeon, file_list_map = self._get_dungeon_prop_box(False)
save_dungeon = gtk.Button(_("Save Dungeon Settings"))
save_dungeon.connect("clicked", self.edit_dungeon_cb, {'name':name,
'theme':theme, 'next_dungeon':next_dungeon,
'd_list':file_list_map})
window_container.pack_start( save_dungeon, False )
room_center = gtk.HBox()
room_center.pack_start( gtk.Label() )
room_center.pack_start( window_container )
room_center.pack_start( gtk.Label() )
self.set_gui_view( room_center )
def _get_dungeon_prop_box(self, new_prop=True):
window_container = gtk.VBox()
## Dungeon Properties
###############
frame = gtk.Frame(_("Dungeon Properties"))
container = gtk.VBox()
# Name
row = gtk.HBox()
label = gtk.Label(_("Name:"))
label.set_alignment( 0, 0.5)
row.pack_start( label )
name = gtk.Entry()
row.pack_end( name )
container.pack_start( row, False )
# Theme
row = gtk.HBox()
label = gtk.Label(_("Theme:"))
label.set_alignment( 0, 0.5)
row.pack_start( label )
theme = gtk.combo_box_new_text()
for option in THEME_NAME:
theme.append_text( option )
theme.set_active( 0 )
row.pack_end( theme )
container.pack_start( row, False )
# Next Dungeon
row = gtk.HBox()
label = gtk.Label(_("Next Dungeon:"))
label.set_alignment( 0, .5)
row.pack_start( label )
next_dungeon = gtk.combo_box_new_text()
file_list = JournalIntegration.list_fh_files()
file_list_map = {}
file_list_map["0"] = _("None")
next_dungeon.append_text( file_list_map["0"] )
next_dungeon.set_active(0)
order_map = ["0"]
for dfile in file_list:
file_list_map[dfile.metadata['FM_UID']] = dfile.metadata['title']
next_dungeon.append_text( dfile.metadata['title'] )
order_map.append( dfile.metadata['FM_UID'] )
row.pack_start(next_dungeon)
container.pack_start( row, False )
frame.add( container )
window_container.pack_start( frame, False )
if not new_prop and self.dungeon:
name.set_text( self.dungeon.name )
theme.set_active( self.dungeon.theme )
next_dungeon.set_active( order_map.index( self.dungeon.next ) )
return (window_container, name, theme, next_dungeon, file_list_map)
def set_create_dungeon_settings(self, trash=None, trash2=None):
window_container, name, theme, next_dungeon, file_list_map = self._get_dungeon_prop_box(True)
## Dungeon Size
###############
frame = gtk.Frame(_("Dungeon Size"))
# Width
widthADJ = gtk.Adjustment(MIN_GRID_WIDTH, MIN_GRID_WIDTH, MAX_GRID_WIDTH, 1.0, 5.0, 0.0)
widthspin = gtk.SpinButton(widthADJ, 0, 0)
container = gtk.VBox()
row = gtk.HBox()
label = gtk.Label(_("Width:") )
label.set_alignment( 0, 0.5)
row.pack_start( label)
row.pack_end( widthspin )
container.pack_start( row, False )
# Height
heightADJ = gtk.Adjustment(MIN_GRID_HEIGHT, MIN_GRID_HEIGHT, MAX_GRID_HEIGHT, 1.0, 5.0, 0.0)
heightspin = gtk.SpinButton(heightADJ, 0, 0)
row = gtk.HBox()
label = gtk.Label(_("Height:") )
label.set_alignment( 0, 0.5)
row.pack_start( label )
row.pack_end( heightspin )
container.pack_start( row, False )
frame.add( container )
window_container.pack_start( frame, False )
## Make Dungeon Button
make_dungeon = gtk.Button(_("Create Dungeon"))
make_dungeon.connect("clicked", self.create_dungeon_cb, {'name':name,
'theme':theme,'width':widthspin, 'height':heightspin,
'next_dungeon':next_dungeon, 'd_list':file_list_map})
window_container.pack_start( make_dungeon, False )
room_center = gtk.HBox()
room_center.pack_start( gtk.Label() )
room_center.pack_start( window_container )
room_center.pack_start( gtk.Label() )
self.set_gui_view( room_center )
def load_dungeon(self, widget, file_data):
#try:
dungeon_dict = JournalIntegration.load_dungeon( file_data )
self.make_dungeon_from_dict( dungeon_dict )
#except:
# pass
def make_dungeon_from_dict(self, dungeon_dict):
self.dungeon = Dungeon( dungeon_dict['name'], dungeon_dict['theme'],
dungeon_dict['next'], dungeon_dict['x'],
dungeon_dict['y'], dungeon_dict['roomstr'],
dungeon_dict['d_id'])
self.enable_room_icons(True)
self.view_dungeon_grid()
def edit_dungeon_cb(self, widget, data):
self.dungeon.name = data['name'].get_text()
self.dungeon.theme = data['theme'].get_active()
self.dungeon.next = find_key( data['d_list'], data['next_dungeon'].get_active_text())
self._alert(_("Dungeon Setting Saved"), self.dungeon.theme)
def create_dungeon_cb(self, widget, data):
name = data['name'].get_text()
theme = data['theme'].get_active() #.get_active_text()
next = find_key( data['d_list'], data['next_dungeon'].get_active_text())
width = data['width'].get_value_as_int()
height = data['height'].get_value_as_int()
self.dungeon = Dungeon( name, theme, next, width, height )
self.enable_room_icons(True)
self.view_dungeon_grid()
def _draw_room_button_grid(self):
# Setup Room Panel
room_array = self.dungeon.get_room_array()
box = gtk.VBox()
for row_array in room_array:
row = gtk.HBox()
box.pack_start( row, False )
for room in row_array:
room_gui = room.render_room()
room_gui.connect('button-press-event', self.add_prop_to_room, room, room_gui)
row.pack_start( room_gui, False )
if self._pane2:
self.edit_pane.remove( self._pane2 )
self._pane2 = make_it_scroll( box )
self._pane2.show_all()
self.edit_pane.add2( self._pane2 )
def view_dungeon_grid(self):
self.edit_pane = gtk.HPaned()
self._pane2 = None
# Setup Button Panel
listbox = gtk.VBox()
lbl = gtk.RadioButton(None,_('Remove Enemy'))
lbl.track_mode = 'REM_ENEMY'
listbox.pack_start( lbl, False )
lbl = gtk.RadioButton(lbl,_('Remove Item'))
lbl.track_mode = 'REM_ITEM'
listbox.pack_start( lbl, False )
# Doors
exp = gtk.Expander(_("Doors"))
box = gtk.VBox()
doors = DOOR_FLAGS.values()
doors.sort()
for val in doors:
door_mode_key = find_key( DOOR_FLAGS, val )
lbl = gtk.RadioButton(lbl,val)
lbl.track_mode = 'DOOR'
lbl.track_flag = door_mode_key
box.pack_start(lbl, False)
exp.add( box )
listbox.pack_start( exp, False )
# Room Properties
exp = gtk.Expander(_("Room Flags"))
box = gtk.VBox()
flags = SPEC_FLAGS.values()
flags.sort()
for val in flags:
flag_key = find_key( SPEC_FLAGS, val )
lbl = gtk.RadioButton(lbl, val)
lbl.track_mode = 'SPEC_FLAG'
lbl.track_flag = flag_key
box.pack_start(lbl, False)
exp.add( box )
listbox.pack_start( exp, False )
# Enemies
exp = gtk.Expander(_("Enemies"))
box = gtk.VBox()
enemies = ENEM_INDEX.values()
enemies.sort()
for val in enemies:
enemy_key = find_key( ENEM_INDEX, val )
# Ignore None Key
if enemy_key != '0':
lbl = gtk.RadioButton(lbl, val)
lbl.track_mode = 'ENEMY'
lbl.track_flag = enemy_key
box.pack_start(lbl, False)
exp.add( box )
listbox.pack_start( exp, False )
# Items
exp = gtk.Expander(_("Items"))
box = gtk.VBox()
items = ITEM_INDEX.values()
items.sort()
for val in items:
item_key = find_key( ITEM_INDEX, val )
# Ignore None Key
if item_key != '0':
lbl = gtk.RadioButton(lbl,val)
lbl.track_mode = 'ITEM'
lbl.track_flag = item_key
box.pack_start(lbl, False)
exp.add(box)
listbox.pack_start( exp, False )
# Save the button group
self.action_but_group = lbl.get_group()
# Make Legend
legendBox = gtk.VBox()
legendBox.pack_start(gtk.Label(_("Door Legend")),False)
for door_key in DOOR_FLAGS:
if door_key != '0':
row = gtk.HBox()
colorbox = gtk.EventBox()
colorbox.add( gtk.Label(" ") )
colorbox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(DOOR_COLOR[door_key]))
row.pack_start(colorbox, False)
row.pack_start( gtk.Label(" "), False )
label = gtk.Label(DOOR_FLAGS[door_key])
label.set_alignment( 0, 0.5 )
row.pack_start( label )
legendBox.pack_start(row, False)
legendBox.pack_start(gtk.Label(_("Room Legend")),False)
for spec_key in SPEC_FLAGS:
if spec_key != '0':
row = gtk.HBox()
colorbox = gtk.EventBox()
colorbox.add( gtk.Label(" ") )
colorbox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(SPEC_COLOR[spec_key]))
row.pack_start(colorbox, False)
row.pack_start( gtk.Label(" "), False )
label = gtk.Label(SPEC_FLAGS[spec_key])
label.set_alignment( 0, 0.5 )
row.pack_start( label )
legendBox.pack_start(row, False)
split = gtk.VBox()
split.pack_start( make_it_scroll( listbox, False ) )
exp = gtk.Expander(_("Legend"))
exp.add(legendBox)
split.pack_end( exp, False )
self.edit_pane.add1( split )
self._draw_room_button_grid()
self.set_gui_view( self.edit_pane )
def set_active_room(self, widgit, room):
self.active_room = room
self.view_room()
def add_prop_to_room(self, widget, event, room, room_gui):
self.active_room = room
for but in self.action_but_group:
if but.get_active():
if but.track_mode == 'VIEW':
self.view_room()
return
elif but.track_mode == 'REM_ENEMY':
dialog = gtk.Dialog(_("Remove Enemy"), buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
def rem_enm(widget, pos, row):
room.set_enemy( pos, '0')
row.hide()
display_box = False
for i in range(0,4):
if room.enemy[i] != '0':
display_box = True
row = gtk.HBox()
label = gtk.Label( ENEM_INDEX[room.enemy[i]] )
label.set_alignment(0.0,0.5)
row.pack_start(label)
but = gtk.Button(_("Remove"))
but.connect('clicked', rem_enm, i, row)
row.pack_end(but, False)
dialog.vbox.pack_start(row, False)
if display_box:
dialog.show_all()
result = dialog.run()
else:
self._alert(_("No enemies found in this room"))
dialog.destroy()
elif but.track_mode == 'REM_ITEM':
dialog = gtk.Dialog(_("Remove Item"), buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
def rem_enm(widget, pos, row):
room.set_item( pos, '0', '0')
row.hide()
display_box = False
for i in range(0,4):
if room.item[i][0] != '0':
display_box = True
row = gtk.HBox()
label = gtk.Label( ITEM_INDEX[room.item[i][0]] )
label.set_alignment(0.0,0.5)
row.pack_start(label)
but = gtk.Button(_("Remove"))
but.connect('clicked', rem_enm, i, row)
row.pack_end(but, False)
dialog.vbox.pack_start(row, False)
if display_box:
dialog.show_all()
result = dialog.run()
else:
self._alert(_("No items found in this room"))
dialog.destroy()
elif but.track_mode == 'DOOR':
door_pos = room.get_door_from_click( event.x, event.y )
if not door_pos:
return
if but.track_flag == '0':
self.active_room.remove_door( door_pos )
try:
adj_room = self.dungeon.get_adj_room( room, door_pos )
if door_pos == "N":
adj_room.remove_door( "S" )
elif door_pos == "E":
adj_room.remove_door( "W" )
elif door_pos == "S":
adj_room.remove_door( "N" )
elif door_pos == "W":
adj_room.remove_door( "E" )
adj_room._room_gui.queue_draw()
except:
pass
else:
# If not e or x, add door to adjoining room
if not (but.track_flag == 'e' or but.track_flag == 'x'):
adj_room = self.dungeon.get_adj_room( room, door_pos )
if adj_room:
self.active_room.add_door( door_pos, but.track_flag )
if door_pos == "N":
adj_room.add_door( "S", but.track_flag)
elif door_pos == "E":
adj_room.add_door( "W", but.track_flag)
elif door_pos == "S":
adj_room.add_door( "N", but.track_flag)
elif door_pos == "W":
adj_room.add_door( "E", but.track_flag)
adj_room._room_gui.queue_draw()
else:
self._alert( _("Door Not Added"), _("This door can not be placed at edge of dungeon"))
else:
if not self.dungeon.has_door_type( but.track_flag ):
self.active_room.add_door( door_pos, but.track_flag )
else:
self._alert( _("Door Not Added"), _("The dungeon can only have one %s") % DOOR_FLAGS[but.track_flag] )
elif but.track_mode == 'SPEC_FLAG':
self.active_room.set_room_flag( but.track_flag )
elif but.track_mode == 'ENEMY':
if not self.active_room.add_enemy( but.track_flag ):
self._alert( _("Enemy not added to room"), _("Room can not hold any more enemies"))
elif but.track_mode == 'ITEM':
def add_item(click, flag):
if not self.active_room.add_item( but.track_flag, flag ):
self._alert( _("Item not added to room"), _("Room can not hold any more items"))
self.dungeon.update_room( self.active_room )
room_gui.queue_draw()
menu = gtk.Menu()
for flag in ITEM_FLAGS:
if flag != '0':
opt = gtk.MenuItem(ITEM_FLAGS[flag])
opt.connect("activate", add_item, flag)
menu.append(opt)
menu.show_all()
menu.popup(None, None, None, event.button, event.get_time())
return
self.dungeon.update_room( self.active_room )
room_gui.queue_draw()
#self._draw_room_button_grid()
break
def _alert(self, title, text=None, timeout=5):
alert = NotifyAlert(timeout=timeout)
alert.props.title = title
alert.props.msg = text
self.add_alert(alert)
alert.connect('response', self._alert_cancel_cb)
alert.show()
def _alert_cancel_cb(self, alert, response_id):
self.remove_alert(alert)
def can_close( self ):
if self.metadata['mime_type'] == JournalIntegration.FILE_MIME and self.dungeon:
if not self.dungeon.valid_dungeon():
self._alert(_("Dungeon Invalid"),_("Dungeon must be valid to save to an exported dungeon"))
return False
return True
def read_file(self, file_path):
if hasattr(self, "SHUT_UP_XO_CALLING_ME"):
print "CALLED YET AGAIN! (%s)"%file_path
return
self.SHUT_UP_XO_CALLING_ME = True
dgnFile=open(file_path,'r')
try:
dungeon_dict = JournalIntegration.do_load( dgnFile )
self.make_dungeon_from_dict( dungeon_dict )
except:
pass
dgnFile.close()
return
def write_file(self, file_path):
if self.dungeon:
f = open( file_path, 'w' )
f.write( self.dungeon.export() )
f.close()
else:
# Basically touch file to prevent it from keep error
open( file_path, 'w' ).close()
class MyGame(arcade.Window):
def __init__(self, width, height, title):
super().__init__(width, height, title)
self.dungeon = None
self.hero = None
self.left_pressed = False
self.right_pressed = False
self.up_pressed = False
self.down_pressed = False
self.move_char = (".", [0, 0])
self.fight = Fight()
arcade.set_background_color((59, 68, 75))
def setup(self):
self.dungeon = Dungeon("map.txt")
self.hero = Hero("Geralt", "white wolf", 150, 150, 5)
self.hero.equip(Weapon("Sword", 30))
self.hero.learn(Spell("wolf's attack", 20, 20, 2))
self.dungeon.spawn(self.hero)
self.command = None
def on_draw(self):
arcade.start_render()
x = self.dungeon.borders[1] * 20 + LEFT_MARGIN - 20
y = 260
arcade.draw_rectangle_filled(x, y, 410, 410, (135, 169, 107))
arcade.draw_rectangle_outline(x, y, 420, 420, (105, 53, 156), 10)
arcade.draw_text("To move pres the keybord arrows.\nTo attack first you should choose\ndirection. Press on of the keys:\n 'u' for up, 'd' for down,\n 'l' for left, 'r' for right\n......................................",\
x - 200, y + 100, (55, 3, 106), 14)
# Prints the map
for row in range(self.dungeon.borders[0]):
# Loop for each column
for column in range(self.dungeon.borders[1]):
# Calculate our location
x = column * COLUMN_SPACING + LEFT_MARGIN
y = (self.dungeon.borders[0] - row -
1) * ROW_SPACING + BOTTOM_MARGIN
# Draw the item
if (self.dungeon.matrix[row][column] == "#"):
arcade.draw_rectangle_filled(x, y, 30, 30, (191, 79, 81))
elif (self.dungeon.matrix[row][column] == "-"):
if row == 0 or row == self.dungeon.borders[0] - 1:
if column == 0 or column == self.dungeon.borders[1] - 1:
arcade.draw_rectangle_filled(
x, y, 30, 30, (59, 68, 75))
else:
arcade.draw_rectangle_filled(
x, y, 50, 30, (59, 68, 75))
if column == 0 or column == self.dungeon.borders[1] - 1:
if row == 0 or row == self.dungeon.borders[0] - 1:
arcade.draw_rectangle_filled(
x, y, 30, 30, (59, 68, 75))
else:
arcade.draw_rectangle_filled(
x, y, 30, 50, (59, 68, 75))
elif (self.dungeon.matrix[row][column] == "H"):
arcade.draw_rectangle_filled(x, y, 30, 30, (79, 134, 247))
arcade.draw_text("H", x - 10, y - 20, arcade.color.BLUE,
28)
elif (self.dungeon.matrix[row][column] == "E"):
arcade.draw_rectangle_filled(x, y, 30, 30, (255, 117, 24))
arcade.draw_text("E", x - 10, y - 20, arcade.color.RED, 28)
elif (self.dungeon.matrix[row][column] == "T"):
arcade.draw_rectangle_filled(x, y, 30, 30, (150, 120, 182))
arcade.draw_text("T", x - 10, y - 20, (55, 3, 106), 28)
elif (self.dungeon.matrix[row][column] == "G"):
arcade.draw_rectangle_filled(x, y, 30, 30, (153, 230, 179))
arcade.draw_text("G", x - 10, y - 20, (0, 130, 127), 28)
else:
arcade.draw_rectangle_filled(x, y, 30, 30, (135, 169, 107))
x = self.dungeon.borders[1] * 20 + LEFT_MARGIN - 20
y = self.dungeon.borders[1] * 10 + BOTTOM_MARGIN
arcade.draw_rectangle_outline(x, y, 420, 220, (105, 53, 156), 10)
def on_update(self, delta_time):
"""
if self.up_pressed and not self.down_pressed:
self.dungeon.move_hero("up")
elif self.down_pressed and not self.up_pressed:
self.dungeon.move_hero("down")
if self.left_pressed and not self.right_pressed:
self.dungeon.move_hero("left")
elif self.right_pressed and not self.left_pressed:
self.dungeon.move_hero("left")
"""
def on_key_press(self, key, modifiers):
"""Called whenever a key is pressed. """
if key == arcade.key.UP:
self.move_char = self.dungeon.move_hero("up")
print("HERREEEEERERERER") #, self.move_hero)
self.check_move()
#self.up_pressed = True
elif key == arcade.key.DOWN:
self.move_char = self.dungeon.move_hero("down")
self.check_move()
#self.down_pressed = True
elif key == arcade.key.LEFT:
self.move_char = self.dungeon.move_hero("left")
self.check_move()
# self.left_pressed = True
elif key == arcade.key.RIGHT:
self.move_char = self.dungeon.move_hero("right")
self.check_move()
# self.right_pressed = True
elif key == arcade.key.NUM_1 or key == arcade.key.KEY_1:
self.command = self.fight.get_hero_command(1)
elif key == arcade.key.NUM_2 or key == arcade.key.KEY_2:
print('hhhhhhh')
self.command = self.fight.get_hero_command(2)
print(self.command)
elif key == arcade.key.NUM_3 or key == arcade.key.KEY_3:
self.command = self.fight.get_hero_command(3)
elif key == arcade.key.NUM_4 or key == arcade.key.KEY_4:
self.command = self.fight.get_hero_command(4)
def on_key_release(self, key, modifiers):
"""Called when the user releases a key. """
if key == arcade.key.UP:
self.up_pressed = False
elif key == arcade.key.DOWN:
self.down_pressed = False
elif key == arcade.key.LEFT:
self.left_pressed = False
elif key == arcade.key.RIGHT:
self.right_pressed = False
def check_move(self):
print("nznznz", self.move_char)
if self.move_char[0] == "E":
print("WTF???")
#fight = Fight()
self.dungeon.hero = self.battle(1)
if self.dungeon.hero.is_alive():
self.dungeon.change_map(".")
self.dungeon.hero_place[self.move_char[1]] = self.move_char[2]
self.dungeon.change_map("H")
else:
return "Hero made move."
def battle(self, distance):
enemy = self.dungeon.enemies.pop()
self.fight.start_fight(self.dungeon.hero, enemy, distance)
while self.dungeon.hero.is_alive() and enemy.is_alive():
# the desition of the player
# self.fight.distance = distance
if self.dungeon.hero.is_alive():
print(self.command)
if self.command is not None:
if enemy.is_alive():
print(self.fight.hero_attack())
if not enemy.is_alive():
print("Enemy is dead.")
if self.enemy.is_alive():
if self.hero.is_alive():
print(self.fight.enemy_attack())
if not self.dungeon.hero.is_alive():
print("Hero is dead")
return self.hero
class Game(object):
def main (self, Surface):
while True:
Surface.fill((0,0,0))
dt = self.time
self.mainClock.tick(30)
for cell in self.tilemap.layers['triggers'].collide(self.player.collisionRect, 'Porta'):
self.tilemap.StopSounds()
self.Escroto.SaveTilemap(self.Location+'.tilemap', self.tilemap)
if self.Location == 'Caverna' and cell['Porta'] == 'Dungeon' or self.Location == 'Dungeon' and cell['Porta'] == 'Caverna':
play(pygame.mixer.Sound(resources.file_path('sfx_teleporte.ogg', 'Musica')), 1, self.musicPlaying)
self.Location = cell['Porta']
NewSurface = pygame.Surface.copy(Surface)
self.tilemap.draw(NewSurface)
del self.tilemap
if self.Location == 'Campo':
self.tilemap = Campo(self.width, self.height, self)
elif self.Location == 'Caverna':
self.tilemap = Caverna(self.width, self.height, self)
elif self.Location == 'Dungeon':
self.tilemap = Dungeon(self.width, self.height, self)
else:
self.tilemap = SalaDoChefe(self.width, self.height, self)
self.player.Reset((cell['PlayerX'] - 16, cell['PlayerY']-28))
self.player.kill()
self.player.add([self.tilemap.SpritesToChoose])
self.tilemap.set_focus(self.player.collisionRect.centerx, self.player.collisionRect.centery)
if self.Location != 'Sala do Mestre':
self.tilemap.Reload(self, (cell['PlayerX']-16, cell['PlayerY']-28))
for sprite in np.array(self.tilemap.Holes):
if self.player.collisionRect.colliderect(sprite.rect):
sprite.kill()
del sprite
FadeOut(self, NewSurface, Surface)
self.ResizeScreen(Surface.get_width(), Surface.get_height())
self.Pause = True
self.first = True
if self.Master:
self.Location = 'Dungeon'
play(self.Sounds['Jóia'], 1, self.musicPlaying)
NewSurface = pygame.Surface.copy(Surface)
NewSurface.blit(self.tilemap.images['background'], ((self.width-WIDTH)//2,0))
self.tilemap.draw(NewSurface)
del self.tilemap
self.tilemap = Dungeon(self.width, self.height, self)
self.tilemap.Reload(self, (664, 28))
self.tilemap.set_focus(self.player.collisionRect.centerx, self.player.collisionRect.centery)
FadeOut(self,NewSurface, Surface)
for sprite in self.tilemap.Holes:
if self.player.collisionRect.colliderect(sprite.rect):
sprite.kill()
del sprite
self.Pause = True
self.first = True
bloqueio = Pilastra(self.tilemap.images['bloqueio'], 'bloqueio', (656, 12), (self.tilemap.SpritesToChoose, self.tilemap.Pilastras))
for cell in self.tilemap.layers['triggers'].collide(bloqueio.rect, 'block'):
if 'a' in cell['block']:
cell['block'] = 'ftlrb'
for event in pygame.event.get():
BASIC_GAME_Events(self, event, Surface)
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
play(self.Sounds['MenuSelect'], 1, self.musicPlaying)
if self.Pause:
if self.menu:
if self.Menu.name == 'Escroto':
self.menu = False
self.Pause = False
self.tilemap.UnpauseSounds()
else:
self.Menu = self.Escroto
else:
if (self.Location == 'Campo' and not self.tilemap.Moshiro.talking and not self.tilemap.Lisa.talking) or self.Location != 'Campo':
self.Pause = True
self.menu = True
self.Menu = self.Escroto
self.tilemap.PauseSounds()
if event.key == K_RETURN:
#Menu de Gente Grande
play(self.Sounds['MenuSelect'], 1, self.musicPlaying)
if self.Pause:
if self.menu:
if self.Menu.name == 'ItemMenu':
if self.Menu.menu == 'Ferramenta':
for key in self.Menu.Itens:
if self.Menu.Itens[key]['Coluna'] == self.Menu.selected[0] and self.Menu.Itens[key]['Linha'] == self.Menu.selected[1]:
self.Menu.Itens[self.Menu.using]['Usando'] = False
self.Menu.Itens[key]['Usando'] = True
self.Menu.using = key
self.player.item = key
self.Pause = False
self.menu = False
self.tilemap.UnpauseSounds()
else:
self.Menu = self.ItemMenu
else:
if (self.Location == 'Campo' and not self.tilemap.Moshiro.talking and not self.tilemap.Lisa.talking) or self.Location != 'Campo':
self.Pause = True
self.menu = True
self.Menu = self.ItemMenu
self.tilemap.PauseSounds()
if event.key == K_a:
if not self.Pause:
self.tilemap.EventGet(self)
else:
if self.Menu.name == 'Escroto':
play(self.Sounds['MenuSelect'], 1, self.musicPlaying)
if self.Menu.selected == 0 or self.Menu.selected == 4 or self.Menu.selected == 5:
self.Menu.selected = 0
self.Menu.Max = 2
self.Menu.Min = 0
self.menu = False
self.Pause = False
self.tilemap.UnpauseSounds()
elif self.Menu.selected == 1 and self.Location != 'Sala do Mestre':
self.Menu.selected = 3
self.Menu.salvando = True
elif self.Menu.selected == 2:
self.Menu.selected = 5
self.Menu.Max = 6
self.Menu.Min = 5
elif self.Menu.selected == 6:
terminate()
if event.key == K_s and not self.player.atking and not self.Pause:
tileX = testX1 = (self.player.collisionRect.centerx // 16)*16
tileY = testY1 = (self.player.collisionRect.centery // 12)*12
if self.player.direction == 0:
testY1 += 12
elif self.player.direction == 2:
testY1 -= 12
elif self.player.direction == 3:
testX1 -= 16
else:
testX1 += 16
colide = False
for enemie in self.tilemap.Enemies:
if pygame.rect.Rect(testX1, testY1, 16,12).colliderect(enemie.collisionRect):
colide = True
break
if not colide:
if self.player.item == 'Pá':
self.player.spritesheet = self.player.PaSheet
self.player.number_of_sprite = 0
self.player.cont = 0
self.player.image = self.player.spritesheet[self.player.direction
][self.player.number_of_sprite]
self.player.digging = True
self.player.collisionRect.centerx = tileX + 8
self.player.collisionRect.centery = tileY + 6
self.player.rect = pygame.rect.Rect(self.player.rect.left - 16,
self.player.rect.top - 20,
48, 44)
for hole in self.tilemap.Holes:
if pygame.rect.Rect(testX1, testY1, 16,12).colliderect(hole.rect):
colide = True
break
if self.player.item == 'Bomba' and len(self.tilemap.Bombas) == 0 and not colide:
if len(self.tilemap.Bombas) == 0:
play(self.Sounds['Bomba'], 1, self.musicPlaying)
if len(self.tilemap.layers['triggers'].collide(pygame.rect.Rect(testX1 + 7, testY1 + 5, 1,1), 'block')) == 0:
Pilastra(self.images['Bomba'], 'Bomba', (testX1, testY1), (self.tilemap.Bombas, self.tilemap.SpritesToChoose))
self.player.collisionRect.centerx = tileX + 8
self.player.collisionRect.centery = tileY + 6
else:
Pilastra(self.images['Bomba'], 'Bomba', (tileX, tileY), (self.tilemap.Bombas, self.tilemap.SpritesToChoose))
self.player.collisionRect.centerx = tileX + (tileX - testX1) + 8
self.player.collisionRect.centery = tileY + (tileY - testY1) + 6
if self.player.item == 'Martelo':
self.player.spritesheet = self.player.MarteloSheet
self.player.number_of_sprite = 0
self.player.cont = 0
self.player.image = self.player.spritesheet[
self.player.direction][self.player.number_of_sprite]
self.player.martelando = True
self.player.collisionRect.centerx = tileX + 8
self.player.collisionRect.centery = tileY + 6
if self.menu:
play(self.Sounds['MenuMove'], 1, self.musicPlaying)
if self.Menu.name == 'ItemMenu':
if event.key == K_UP:
self.Menu.selected[1] -= 1
if event.key == K_DOWN:
self.Menu.selected[1] += 1
if event.key == K_LEFT:
self.Menu.selected[0] -= 1
if event.key == K_RIGHT:
self.Menu.selected[0] += 1
else:
if event.key == K_UP:
if self.Menu.selected < self.Menu.Max + 1:
self.Menu.selected -= 1
if event.key == K_DOWN:
if self.Menu.selected < self.Menu.Max + 1:
self.Menu.selected += 1
#if self.selected == 3:
#self.selected = 0
self.tilemap.Actions(self)
if self.first:
if self.Location == 'Sala do Mestre':
NewSurface.fill((0,0,0))
NewSurface.blit(self.tilemap.images['background'], (((self.width-WIDTH)//2,0)))
self.tilemap.draw(NewSurface)
FadeIn(self,NewSurface, Surface)
del NewSurface
self.first = False
self.second = True
if self.Master:
self.Master = False
self.Escroto.SaveGame(self,'CheckPoint.save', 0 ,2,0)
elif self.second:
self.Pause = False
self.second = False
if self.musicPlaying:
self.tilemap.InicializeSounds()
if self.Location == 'Sala do Mestre':
pygame.mixer.Sound(resources.file_path('sfx_mestre_intro.ogg','Musica')).play(0)
if not self.Pause:
self.tilemap.update(dt, self)
if self.Location == 'Sala do Mestre':
Surface.fill((0,0,0))
Surface.blit(self.tilemap.images['background'], ((self.width-WIDTH)//2,0))
self.tilemap.draw(Surface)
if self.menu:
self.Menu.update(dt, self)
if self.menu:
self.Menu.draw(self, Surface)
else:
BlitLife(Surface, self, self.Heart, self.images['Stamina'], self.tools[0][self.choosed[self.player.item]])
if self.PegouJóia:
play(self.Sounds['Jóia'], 1, self.musicPlaying)
self.Escroto.SaveGame(self,'CheckPoint.save', 0 ,2,0)
self.PegouJóia = False
TransformSurfaceScale(Surface, self.width, self.height, self.rect)
pygame.display.update()
if self.Location == 'Campo':
self.tilemap.SetSound(self)
for npc in self.tilemap.NPCs:
if npc.talking:
self.tilemap.PauseEspecial()
npc.display(Surface, self)
if self.player.vida <= 0:
self.tilemap.StopSounds()
self.Died(Surface)
elif 0 < self.player.vida <= 2:
if self.musicPlaying:
if self.Sounds['Morrendo'].get_num_channels() == 0:
self.Sounds['Morrendo'].play(-1)
else:
if self.Sounds['Morrendo'].get_num_channels() > 0:
self.Sounds['Morrendo'].stop()
def ResizeScreen(self, newWidth, newHeight):
"""
Função que faz o resize da jogo
de forma que o jogo seja compátivel com qualquer modo de tela entre 4:3 e 16:9
"""
#precisamos primeiro calcular o tamanho da imagem que será disponibilizada no novo
#tamanho de tela
#Formato 16:9 ou 4:3
#Usaremos a altura como padrão
Hfator_widscreen = newHeight/9
Hfator_oldscreen = newHeight/3
#Teste, tela 200/120
MAXW_widscreen = 16*Hfator_widscreen #213,33333
MAXW_oldscreen = 4*Hfator_oldscreen #160
if newWidth > MAXW_widscreen:
self.width = self.tilemap.view_w = round(16*HEIGHT/9)
elif newWidth <= MAXW_widscreen and newWidth >= MAXW_oldscreen:
#Se isso for verdade devemos modificar o tamanho e posição
#de algumas sprites do jogo
#Antes, vamos calcular o novo tamanho de tela no tilemap
self.width = round(newWidth/(newHeight/HEIGHT))
self.tilemap.view_w = self.width
else:
self.width = WIDTH
self.tilemap.view_w = WIDTH
self.rect = pygame.rect.Rect((0,0), (self.width, self.height))
self.tilemap.viewport = Rect((0,0), (self.width, self.height))
self.tilemap.set_focus(self.player.collisionRect.centerx, self.player.collisionRect.centery, True)
self.ModificaTamanho()
def ModificaTamanho(self):
#Vamos centralizar as posições dos menus
for key in self.ItemMenu.Itens:
self.ItemMenu.Itens[key]['Posição'][0] = self.ItemMenu.Itens[key]['Posição Inicial'] + (self.width-WIDTH)//2
self.Escroto.x = (self.width-WIDTH)//2
#Vamos agora ampliar algumas as imagens transparentes
self.InvisivelCima = pygame.transform.scale(self.InvisivelCima, (self.width, self.InvisivelCima.get_height()))
self.ItemMenu.escuro = pygame.transform.scale(self.ItemMenu.escuro, (self.width, self.ItemMenu.escuro.get_height()))
self.rect = pygame.rect.Rect((0,0), (self.width, self.height))
self.tilemap.viewport = Rect((0,0), (self.width, self.height))
self.tilemap.set_focus(self.player.collisionRect.centerx, self.player.collisionRect.centery, True)
def CreateGame(self, music):
self.mainClock = pygame.time.Clock()
self.FPS = 30
self.musicPlaying = music
self.Pause = False
self.menu = False
self.Menu = None
self.Master = False
self.width = WIDTH
self.height = HEIGHT
self.rect = pygame.rect.Rect(0, 0, self.width, self.height)
self.first = self.second = False
self.time = 0.033
self.menuHeart = load_sheet('menu_pause_coracao.png', 'Menus', 9, 8)
self.Heart = load_sheet('menu_hud_coracao.png', 'Imagens', 9, 8)
self.InvisivelCima = pygame.image.load(resources.file_path('menu_hud_escuro.png', 'Imagens')).convert_alpha()
self.tools = load_sheet('menu_hud_ferramenta.png', 'Imagens', 26, 8)
self.images = {'Player': {'MoveSheet': load_sheet('spr_pla_andando.png','Imagens', 48, 60),
'AtkSheet': load_sheet('spr_pla_ataque.png','Imagens', 48, 60),
'StopSheet': load_sheet('spr_pla_parado.png','Imagens', 48, 60)},
'EnemyDeath': load_sheet('spr_obj_inimigomorto.png', 'Imagens', 16, 20),
'Sword': load_sheet('spr_pla_espada.png','Imagens', 48, 60),
'Hole': pygame.image.load(resources.file_path('spr_obj_buraco.png', 'Imagens')).convert_alpha(),
'Rachadura': pygame.image.load(resources.file_path('spr_obj_rachadura.png', 'Imagens')).convert_alpha(),
'Bomba': load_sheet('spr_obj_bomba.png', 'Imagens',16,12),
'Explosion': load_sheet('spr_obj_explosao.png', 'Imagens',48,36),
'Stamina': pygame.image.load(resources.file_path('menu_hud_stamina.png', 'Imagens')).convert_alpha(),
'StaminaMenu': pygame.image.load(resources.file_path('menu_pause_stamina.png', 'Menus')).convert_alpha(),
'Coracao': pygame.image.load(resources.file_path('spr_obj_coracao.png', 'Imagens')).convert_alpha(),
'FalaEscuro': pygame.transform.scale(self.InvisivelCima, (178, 36)).convert_alpha()}
self.Sounds = {'Espada': {'Swing': pygame.mixer.Sound(resources.file_path('sfx_espada.ogg', 'Musica')),
'Parede': pygame.mixer.Sound(resources.file_path('sfx_wallhit.ogg', 'Musica')),
'Acertou': pygame.mixer.Sound(resources.file_path('sfx_acertando.ogg', 'Musica'))},
'Bomba': pygame.mixer.Sound(resources.file_path('sfx_bomba.ogg', 'Musica')),
'Moshiro': 'ost_moshiro.ogg',
'Cavando': pygame.mixer.Sound(resources.file_path('sfx_cavando.ogg', 'Musica')),
'MenuSelect':pygame.mixer.Sound(resources.file_path('sfx_menu_select.ogg', 'Musica')),
'MenuMove': pygame.mixer.Sound(resources.file_path('sfx_menu_move.ogg', 'Musica')),
'Jóia': pygame.mixer.Sound(resources.file_path('sfx_joia.ogg', 'Musica')),
'Morrendo':pygame.mixer.Sound(resources.file_path('sfx_morrendo.ogg', 'Musica')),
'Martelo': pygame.mixer.Sound(resources.file_path('sfx_martelo.ogg', 'Musica')),
'Buraco': pygame.mixer.Sound(resources.file_path('sfx_cavando.ogg', 'Musica')),
'Coração': pygame.mixer.Sound(resources.file_path('sfx_heart.ogg', 'Musica'))}
self.choosed = {'Pá': 0, 'Martelo': 1, 'Bomba': 2}
self.ItemMenu = ItemMenu()
self.Escroto = Escroto()
self.Campo = Campo(self.width, self.height, self)
self.Dungeon = Dungeon(self.width, self.height, self)
self.Caverna = Caverna(self.width, self.height, self)
self.player = Player(self.images['Player'], (self.Campo.start_cell.px - 16, self.Campo.start_cell.py-28), [self.Campo.SpritesToChoose])
self.Location = 'Campo'
self.tilemap = self.Campo
self.Delivered = 0
self.PegouJóia = False
#Vampos criar os canais onde os efeitos sonoros devem ser colocados
def NewGame(self, Surface, music):
self.CreateGame(music)
if self.musicPlaying:
self.tilemap.InicializeSounds()
self.tilemap.SetSound(self)
self.Pause = True
dt = self.time
self.ResizeScreen(Surface.get_width(), Surface.get_height())
self.tilemap.update(dt, self)
self.tilemap.Lisa.image = self.tilemap.Lisa.spritesheet[self.tilemap.Lisa.AllDirection['Up']][self.tilemap.Lisa.number_of_sprite]
self.tilemap.Moshiro.display(Surface, self, False)
self.tilemap.Moshiro.MoshiroAndando(Surface, self)
self.tilemap.Lisa.image = self.tilemap.Lisa.spritesheet[self.tilemap.Lisa.AllDirection['Left']][self.tilemap.Lisa.number_of_sprite]
self.tilemap.Lisa.display(Surface, self, False)
self.Pause = False
self.SaveTilemaps()
self.Escroto.SaveGame(self,'CheckPoint.save',0,2,0)
self.main(Surface)
def LoadGame(self, Surface, music, Things_To_Dump, died = False):
self.CreateGame(music)
self.Location = Things_To_Dump[0]
if self.Location == 'Campo':
self.tilemap = self.Campo
elif self.Location == 'Dungeon':
self.tilemap = self.Dungeon
else:
self.tilemap = self.Caverna
self.player.kill()
self.player.add([self.tilemap.SpritesToChoose])
#Agora vamos atualizar as informações do tilemap onde o player se encontra
#Primeiro as informações do Player
self.player.direction = Things_To_Dump[2][0]
self.player.number_of_sprite= Things_To_Dump[2][1]
self.player.collisionRect = Things_To_Dump[2][2]
self.player.placedPositions = Things_To_Dump[2][3]
self.player.Justdied = Things_To_Dump[2][4]
self.player.vida = Things_To_Dump[2][5]
self.player.vx = Things_To_Dump[2][6]
self.player.vy = Things_To_Dump[2][7]
self.player.cooldown = Things_To_Dump[2][8]
self.player.imunity = Things_To_Dump[2][9]
self.player.alive = Things_To_Dump[2][10]
self.player.atking = Things_To_Dump[2][11]
self.player.digging = Things_To_Dump[2][12]
self.player.digged = Things_To_Dump[2][13]
self.player.first_pressed = Things_To_Dump[2][14]
self.player.pressed = Things_To_Dump[2][15]
self.player.cont = Things_To_Dump[2][16]
self.player.cont2 = Things_To_Dump[2][17]
self.player.numbX = Things_To_Dump[2][18]
self.player.numbY = Things_To_Dump[2][19]
self.player.item = Things_To_Dump[2][20]
self.player.Undelivered = Things_To_Dump[2][21]
if self.player.atking:
self.player.spritesheet = self.player.atkSheet
elif self.player.digging:
self.player.spritesheet = self.player.PaSheet
elif self.player.vx != 0 or self.player.vy != 0:
self.player.spritesheet = self.player.MoveSheet
else:
self.player.spritesheet = self.player.StopSheet
#Construimos as Espadas do jogo
for SwordInfo in Things_To_Dump[3]:
sword = Sword(self.images['Sword'], (self.player.rect.x - 16, self.player.rect.y - 20), 'Sword', self.player.direction, (self.tilemap.SpritesToChoose, self.tilemap.Swords))
sword.number_of_sprite = SwordInfo[0]
sword.image = sword.spritesheet[sword.direction][sword.number_of_sprite]
sword.cont = SwordInfo[1]
sword.rect = SwordInfo[2]
#Construimos os inimigos do jogo
for EnemieInfo in Things_To_Dump[4]:
if 'Lesma' == EnemieInfo[0]:
inimigo = Lesma(self.tilemap.images['Lesma'], (0,0), 'Lesma', (self.tilemap.SpritesToChoose, self.tilemap.Enemies))
elif 'Bitch' == EnemieInfo[0]:
inimigo = Bitch(self.tilemap.images['Bitch'], (0,0), 'Bitch', (self.tilemap.SpritesToChoose, self.tilemap.Enemies))
elif 'Planta' == EnemieInfo[0]:
inimigo = Planta(self.tilemap.images['Planta'], (0,0), 'Planta', (self.tilemap.SpritesToChoose, self.tilemap.Enemies))
elif 'Sniper' == EnemieInfo[0]:
inimigo = Sniper(self.tilemap.images['Sniper'], (0,0), 'Sniper', (self.tilemap.SpritesToChoose, self.tilemap.Enemies))
else:
inimigo = Zumbi(self.tilemap.images['Zumbi'], (0,0), 'Zumbi', (self.tilemap.SpritesToChoose, self.tilemap.Enemies))
inimigo.burn = EnemieInfo[1]
inimigo.collisionRect = EnemieInfo[2]
inimigo.direction = EnemieInfo[3]
inimigo.number_of_sprite = EnemieInfo[4]
inimigo.vida = EnemieInfo[5]
inimigo.cooldown = EnemieInfo[6]
inimigo.Max = EnemieInfo[7]
inimigo.vy = EnemieInfo[8]
inimigo.vx = EnemieInfo[9]
inimigo.alive = EnemieInfo[10]
inimigo.cont = EnemieInfo[11]
inimigo.numbX = EnemieInfo[12]
inimigo.numbY = EnemieInfo[13]
inimigo.atking = EnemieInfo[14]
inimigo.originalPosition = EnemieInfo[15]
if not inimigo.alive:
if inimigo.burn:
inimigo.image = inimigo.cinzas
else:
inimigo.image = inimigo.deadImage
#Construcao de Bombas
for BombaInfo in Things_To_Dump[5]:
Bomba = Pilastra(self.images['Bomba'], 'Bomba', (0,0), (self.tilemap.SpritesToChoose, self.tilemap.Bombas))
Bomba.cont = BombaInfo[0]
Bomba.number_of_sprite = BombaInfo[1]
Bomba.rect = BombaInfo[2]
#Construcao de Explosoes
for ExploInfo in Things_To_Dump[6]:
Explosion = Explosion(self.images['Explosion'], (0,0), 'Explosion', 0, (self.tilemap.Bombas, self.tilemap.SpritesToChoose))
Explosion.cont = ExploInfo[0]
Explosion.number_of_sprite = ExploInfo[1]
Explosion.rect = ExploInfo[2]
#Contrucao de Animacoes
for AniInfo in Things_To_Dump[7]:
Animation = DeathAnimation(self.images[AniInfo[0]], (0,0), AniInfo[0], [self.tilemap.SpritesToChoose])
Animation.rect = AniInfo[1]
Animation.image = AniInfo[2]
Animation.number_of_sprite = AniInfo[3]
Animation.cont = AniInfo[4]
#Construcao de Atks
for ATKinfo in Things_To_Dump[8]:
if ATKinfo[0] == 'AtkZumbi':
ATK = ZumbiAtk(self.tilemap.images['Zumbi']['Atk'], (0,0), ATKinfo[4], ATKinfo[0], [self.tilemap.SpritesToChoose], [enemy for enemy in self.tilemap.Enemies if enemy.nome == 'Zumbi'][0])
else:
if 'Sniper' in ATKinfo[0]:
ATK = Atk(self.tilemap.images['Sniper']['Atk'], (0,0), ATKinfo[4], ATKinfo[0], ATKinfo[1], [self.tilemap.SpritesToChoose])
else:
ATK = Atk(self.tilemap.images['Planta']['Atk'], (0,0), ATKinfo[4], ATKinfo[0], ATKinfo[1], [self.tilemap.SpritesToChoose])
ATK.number_of_sprite = ATKinfo[2]
ATK.alive = ATKinfo[3]
ATK.rect = ATKinfo[5]
ATK.Max = ATKinfo[6]
ATK.cont = ATKinfo[7]
#Colocando o menu de Itens
self.ItemMenu.Itens = Things_To_Dump[9].Itens
self.ItemMenu.selected = Things_To_Dump[9].selected
self.ItemMenu.using = Things_To_Dump[9].using
self.ItemMenu.menu = Things_To_Dump[9].menu
self.ItemMenu.Fala = Things_To_Dump[9].Fala
self.Campo.AdjustTileHoleAndRachadura(Things_To_Dump[1][0], self)
self.Campo.AdjustJewels(Things_To_Dump[1][0], self)
self.Caverna.AdjustTileHoleAndRachadura(Things_To_Dump[1][1], self)
self.Caverna.AdjustJewels(Things_To_Dump[1][1], self)
self.Dungeon.AdjustTileHoleAndRachadura(Things_To_Dump[1][2], self)
self.Dungeon.AdjustJewels(Things_To_Dump[1][2], self)
#Verificamos o numero de joias devolvidas
self.Delivered = Things_To_Dump[10]
#E por ultimo vemos se ja dialogamos com o sr moshiro ou nao
self.Campo.Moshiro.first = Things_To_Dump[11]
self.tilemap.set_focus(self.player.collisionRect.centerx, self.player.collisionRect.centery)
if not died:
self.Escroto.SaveGame(self,'CheckPoint.save', 0, 2,0)
if self.musicPlaying:
self.tilemap.InicializeSounds()
self.tilemap.SetSound(self)
self.SaveTilemaps()
#self.ItemMenu.Itens['Safira']['Possui'] = True
#self.ItemMenu.Itens['Safira']['Delivered'] = True
#self.Delivered += 1
self.ResizeScreen(Surface.get_width(), Surface.get_height())
self.main(Surface)
def SaveTilemaps(self):
self.Escroto.SaveTilemap('Campo.tilemap', self.Campo)
self.Escroto.SaveTilemap('Caverna.tilemap', self.Caverna)
self.Escroto.SaveTilemap('Dungeon.tilemap', self.Dungeon)
del self.Campo
del self.Caverna
del self.Dungeon
def winGame(self, Surface):
#self.tilemap.Moshiro.display(Surface, self, music = False)
pygame.mixer.music.load(resources.file_path('ost_moshiro_presto.ogg', 'Musica'))
pygame.mixer.music.play(-1, 0.0)
if self.player.collisionRect.x != 448 or self.player.collisionRect.y != 144:
self.MovePlayer(Surface)
self.tilemap.Moshiro.moshiroAndandoFinal(Surface, self)
self.player.image = self.player.StopSheet[2][0]
self.tilemap.Moshiro.display(Surface, self, False, False)
for pilastra in self.tilemap.Pilastras:
if pilastra.nome == 'RuinaFinal':
pilastra.number_of_sprite = 1
pilastra.image = pilastra.spritesheet[0][pilastra.number_of_sprite]
contador = 0
limite = 2
self.tilemap.StopSounds()
pygame.mixer.music.load(resources.file_path('ost_ending.ogg', 'Musica'))
pygame.mixer.music.play(0, 0.0)
while contador < limite:
contador += self.mainClock.tick(30)/1000
for event in pygame.event.get():
QUIT_Event(event)
Surface = VIDEORESIZE_Event(self, event, Surface)
self.tilemap.draw(Surface)
TransformSurfaceScale(Surface, self.width, self.height, self.rect)
pygame.display.flip()
#Fade para o Branco
NewSurface = pygame.Surface.copy(Surface)
NewSurface.fill((255,255,255))
FadeIn(self,NewSurface, Surface)
selected = 0
self.images['Ending'] = load_sheet('menu_final.png', 'Menus', MAXWIDTH, HEIGHT)
while True:
for event in pygame.event.get():
if event.type == QUIT:
terminate ()
if event.type == KEYUP:
if event.key == ord('m'):
if self.musicPlaying:
pygame.mixer.music.stop()
else:
pygame.mixer.music.play(-1, 0.0)
self.musicPlaying = not self.musicPlaying
if event.type == KEYDOWN:
if event.key == K_a:
if selected < len(self.images['Ending'][0]) - 1:
selected += 1
else:
terminate()
Surface = VIDEORESIZE_Event(self, event, Surface)
Surface.blit(self.images['Ending'][0][selected], (- (MAXWIDTH-self.width)//2,0))
TransformSurfaceScale(Surface, self.width, self.height, self.rect)
pygame.display.flip()
self.mainClock.tick(self.FPS)
def MovePlayer(self, Surface):
#É preciso calcular a tragetória do player para que ele fique de frente para
#o sr moshiro (432, 144) 432 + 16 = 448
posY = self.tilemap.Moshiro.collisionRect.bottom
posX = self.tilemap.Moshiro.collisionRect.right
tileX = (self.player.collisionRect.centerx // 16)
tileY = (self.player.collisionRect.centery // 12)
distY = posY - self.player.collisionRect.bottom
#Temos que olhar para posição do retângulo do player como um todo
#Caso o player esteja na linha dos tilesY 11 precisamos ver se
#o fundo dele nao encosta na tile block
if tileY == 11:
#Caso o player esteja na linha dos tilesY 11 precisamos ver se
#o fundo dele nao encosta na tile block
if self.player.collisionRect.bottom > 144:
self.player.AndaAutomatico(2, (self.player.collisionRect.x, 144), self, Surface)
elif tileY == 12:
#Caso o player esteja na linha de tilesY 12 ele precisa se deslocar para cima
#ou para baixo dependendo do valor da distância em y
if self.player.collisionRect.x < posX:
if distY <= 0:
self.player.AndaAutomatico(0, (self.player.collisionRect.x, posY+12), self, Surface)
else:
self.player.AndaAutomatico(2, (self.player.collisionRect.x, posY-12), self, Surface)
else:
#Neste último caso ele só pode estar na linha de 13 e logo devemos ver se o topo dele nao bate no block
if self.player.collisionRect.bottom < posY+12 and self.player.collisionRect.x < posX:
self.player.AndaAutomatico(0, (self.player.collisionRect.x, posY+12), self, Surface)
#Em seguida é preciso fazer o player se mover horizontalmente
self.player.AndaAutomatico(1, (posX, self.player.collisionRect.bottom), self, Surface)
#E por fim move-lo verticalmente novamente
distY = posY - self.player.collisionRect.bottom
if distY > 0:
self.player.AndaAutomatico(0, (self.player.collisionRect.x, posY), self, Surface)
else:
self.player.AndaAutomatico(2, (self.player.collisionRect.x, posY), self, Surface)
def Died(self, Surface):
#Leva o player girando para o centro da Tela
if self.musicPlaying:
pygame.mixer.Sound(resources.file_path('ost_gameover.ogg', 'Musica')).play()
cont = 0
dt = self.time
self.mainClock.tick(30)
girando = load_sheet('spr_pla_olhosfechados.png', 'Imagens', 48,60)
caindo = load_sheet('spr_pla_morto.png', 'Imagens', 48,60)
sr_moshiro = load_sheet('menu_gameover_moshiro.png', 'Menus', MAXWIDTH,HEIGHT)
menu = load_sheet('menu_gameover.png', 'Menus', WIDTH, HEIGHT)
numero_da_imagem = 0
Max = len(girando)
self.ResizeScreen(Surface.get_width(), Surface.get_height())
#Começa a mostrar a animação do player girando
while cont < 2:
dt = 2*self.time
self.mainClock.tick(self.FPS//2)
imagem = girando[numero_da_imagem][0]
numero_da_imagem += 1
if numero_da_imagem == Max:
numero_da_imagem = 0
Surface.fill((0,0,0))
Surface.blit(imagem, (56+ + (self.width - WIDTH)//2,34))
TransformSurfaceScale(Surface, self.width, self.height, self.rect)
pygame.display.flip()
cont += dt
#Passa a Fazer o player cai
numero_da_imagem = 0
Max = len(caindo[0])
while numero_da_imagem != Max:
dt = 4*self.time
self.mainClock.tick(self.FPS//4)
imagem = caindo[0][numero_da_imagem]
numero_da_imagem += 1
Surface.fill((0,0,0))
Surface.blit(imagem, (56 + (self.width - WIDTH)//2,34))
TransformSurfaceScale(Surface, self.width, self.height, self.rect)
pygame.display.update()
pygame.time.wait(1000)
#Fade para o Branco
NewSurface = pygame.Surface.copy(Surface)
NewSurface.fill((255,255,255))
FadeIn(self,NewSurface, Surface)
#Sr.Moshiro Falando
texto = "Estou decepcionado com você"
font = pygame.font.SysFont("Calibri", 14)
display = TextHandler(texto, pygame.rect.Rect(20, 85, 123, 35), Surface, self, font,[[sr_moshiro, [-(MAXWIDTH - self.width)//2,0], 0, 3*self.time, 0], [pygame.transform.scale(self.images['FalaEscuro'], (214, 36)).convert_alpha(), (0, 84)]], life = False)
del display
#Colocando o Menu de Escolha
Choose = False
self.selected = 0
while not Choose:
for event in pygame.event.get():
if event.type == QUIT:
terminate()
if event.type == KEYDOWN:
if event.key == K_DOWN:
self.selected += 1
if event.key == K_UP:
self.selected -= 1
if event.key == K_a:
if self.selected == 0:
Archive = open('CheckPoint.save', 'rb')
Things_to_Dump = pickle.load(Archive)
self.LoadGame(Surface, self.musicPlaying, Things_to_Dump, died = True)
else:
terminate ()
if self.selected > 1:
self.selected = 0
if self.selected < 0:
self.selected = 1
Surface.fill((0,0,0))
Surface.blit(menu[0][self.selected], ((self.width - WIDTH)//2,0))
TransformSurfaceScale(Surface, self.width, self.height, self.rect)
pygame.display.update()
from hero_class import Hero
from enemy_class import Enemy
from Dungeon import Dungeon
import os
if __name__ == '__main__':
our_hero = Hero(name="Bron", title="Dragonslayer", health=100, mana=100, mana_regeneration_rate=2)
game_dungeon = Dungeon.load_from_file("level1.txt")
print("Welcome to Dungeons and Pythons!")
print("You can move your hero by using the W(up), A(left), S(down) and D(right) keys on your keyboard.")
print("To attack your enemies, use L.")
print("Have fun! ;)\n")
player_choice = input("Do you want to start a new game?[y/n]: ")
# if player_choice == "H" or player_choice == "h":
# print("Dungeons and Pythons' rules:")
# print("Your hero is {}".format(our_hero.known_as()) + ". ")
# print("Starting health: {}".format(our_hero.get_health()))
# print("Starting mana: {}".format(our_hero.get_mana) + "\n")
#
# print("You can move your hero up, down, left and right across the ", )
# print("map using the keys on your keyboard.", )
# print("")
if player_choice == "Y" or player_choice == "y":
game_dungeon.spawn(our_hero)
def test_map_reading(self):
self.assertEqual(Dungeon.map_reading("game_map.txt"), self.my_map)
class Test_Dungeon(unittest.TestCase):
def setUp(self):
self.map = Dungeon("level1.txt")
self.h = Hero(name="Bron", title="Dragonslayer",
health=100, mana=100, mana_regeneration_rate=2)
def test_init(self):
self.assertEqual(self.map.get_map(), [['S', '.', '#', '#', '.', '.', 'S', '.', '.', 'T'], ['#', 'T', '#', '#', '.', '.', '#', '#', '#', '.'], [
'#', '.', '#', '#', '#', 'E', '#', '#', '#', 'E'], ['#', '.', 'E', '.', '.', '.', '#', '#', '#', '.'], ['#', '#', '#', 'T', '#', '#', '#', '#', '#', 'G']])
self.assertEqual(self.map.get_enemies(), [[2, 5], [2, 9], [3, 2]])
def test_spawn(self):
self.map.spawn(self.h)
self.assertEqual(self.h.mana, self.h.starting_mana)
self.assertEqual(self.h.health, self.h.starting_health)
self.assertEqual(self.map.get_hero_x(), 0)
self.assertEqual(self.map.get_hero_y(), 0)
self.assertTrue(self.map.spawn(self.h))
def test_move(self):
self.map.spawn(self.h)
self.h.take_damage(90)
self.assertFalse(self.map.move_hero(self.h, 'up'))
self.assertTrue(self.map.move_hero(self.h, 'right'))
with self.assertRaises(Wrong_direction):
self.assertTrue(self.map.move_hero(self.h, 'hihihi'))
self.assertEqual(1, self.map.get_hero_x())
self.assertEqual(0, self.map.get_hero_y())
self.assertFalse(self.map.move_hero(self.h, 'right'))
self.assertEqual(1, self.map.get_hero_x())
self.assertEqual(0, self.map.get_hero_y())
# self.map.move_hero(self.h, 'down')
def test_spell_or_weapon(self):
self.h.equip(Weapon(name="The Axe of Destiny", damage=20))
self.h.learn(
Spell(name="Fireball", damage=30, mana_cost=50, cast_range=2))
self.assertTrue(isinstance(self.map.spell_or_weapon(self.h), Spell))
self.h.equip(Weapon(name="The Axe of Destiny", damage=120))
self.assertTrue(isinstance(self.map.spell_or_weapon(self.h), Weapon))
def test_hero_attack(self):
self.h.equip(Weapon(name="The Axe of Destiny", damage=20))
self.h.learn(
Spell(name="Fireball", damage=30, mana_cost=50, cast_range=2))
self.map.spawn(self.h)
self.map.print_map()
self.map.move_hero(self.h, 'right')
self.map.print_map()
self.map.move_hero(self.h, 'down')
self.map.print_map()
self.map.move_hero(self.h, 'down')
self.map.print_map()
self.map.move_hero(self.h, 'down')
self.map.print_map()
# self.assertEqual(self.map.move_hero(self.h, 'right'), True)
self.map.hero_attack(self.h)
self.map.print_map()
for x in range(5):
self.map.move_hero(self.h, 'right')
self.map.print_map()
self.map.move_hero(self.h, 'up')
self.map.print_map()
self.map.spawn(self.h)
self.map.print_map()
self.map.move_hero(self.h, 'left')
self.map.move_hero(self.h, 'down')
self.map.move_hero(self.h, 'down')
self.map.print_map()
def setUp(self):
self.map = Dungeon("level1.txt")
self.h = Hero(name="Bron", title="Dragonslayer",
health=100, mana=100, mana_regeneration_rate=2)
def main(self):
"""
This is the main method.
"""
global my_image, adventurer_i_index, adventurer_j_index, dng, exit_i_index, exit_j_index, n_rows, n_cols
adventurer_i_index = 0
adventurer_j_index = 0
# Create tk windows and bind key strokes
DungeonGui.create_tk_windows(self)
# Create GUI rooms
dungeon = DungeonGui(n_rows, n_cols)
dungeon.create_rooms()
# Populate the GUI rooms with dungeon content
dng = Dungeon(n_rows, n_cols)
dng.dungeon_generator()
print(dng)
for i in range(0, n_rows):
for j in range(0, n_cols):
row_index = i
col_index = j
content = dng.room_list[i][j].room_content
if content == 'i':
dungeon.create_content(row_index, col_index, content)
if content == 'O':
dungeon.create_content(row_index, col_index, content)
east_door_symbol = dng.room_list[i][j].room_matrix[1][2]
# dungeon.create_east_door(row_index, col_index, east_door_symbol)
west_door_symbol = dng.room_list[i][j].room_matrix[1][0]
# dungeon.create_west_door(row_index, col_index, west_door_symbol)
north_door_symbol = dng.room_list[i][j].room_matrix[0][1]
# dungeon.create_north_door(row_index, col_index, north_door_symbol)
south_door_symbol = dng.room_list[i][j].room_matrix[2][1]
# dungeon.create_south_door(row_index, col_index, south_door_symbol)
if content == 'i':
adventurer_i_index = i
adventurer_j_index = j
my_image = dungeon.create_adventurer(
adventurer_j_index * 100 + 32,
adventurer_i_index * 100 + 32)
if content == 'O':
exit_i_index = i
exit_j_index = j
#print(exit_i_index,exit_j_index)
"""
Displays
"""
label1a = tk.Label(my_window, text='INSTRUCTIONS:', fg="blue")
label1a.config(font=('Arial', 15))
my_canvas.create_window(950, 50, window=label1a)
label1b = tk.Label(my_window, text='Use Keyboard Arrow Keys')
label1b.config(font=('Arial', 15))
my_canvas.create_window(950, 75, window=label1b)
label2 = tk.Label(my_window, text='Entrance: i, Exit: O')
label2.config(font=('Arial', 15))
my_canvas.create_window(950, 100, window=label2)
label3 = tk.Label(my_window, text='Pillars and Doors Hidden')
label3.config(font=('Arial', 15))
my_canvas.create_window(950, 150, window=label3)
label3 = tk.Label(my_window, text='Gather Pillars and Reach O')
label3.config(font=('Arial', 15))
my_canvas.create_window(950, 180, window=label3)
label7 = tk.Label(my_window, text=' SCORE:', fg='blue')
label7.config(font=('Arial', 15))
my_canvas.create_window(950, 300, window=label7)
my_window.mainloop() # enter main loop
class TestDungeon(unittest.TestCase):
def setUp(self):
self.my_hero = Hero("Bron", "Dragonslayer", 100, 50, 2)
self.my_map = [['S', '.', '#', '#', '.', '.', '.', '.', '.', 'T'],
['#', 'T', '#', '#', '.', '.', '#', '#', '#', '.'],
['#', '.', '#', '#', '#', 'E', '#', '#', '#', 'E'],
['#', '.', 'E', '.', '.', '.', '#', '#', '#', '.'],
['#', '#', '#', 'T', '#', '#', '#', '#', '#', 'G']]
self.my_dungeon = Dungeon(self.my_hero, self.my_map)
def test_map_reading(self):
self.assertEqual(Dungeon.map_reading("game_map.txt"), self.my_map)
def test_initialisation(self):
self.assertTrue(isinstance(self.my_dungeon, Dungeon))
def test_spawn(self):
with self.assertRaises(NotAHero):
self.my_dungeon.spawn(10)
self.my_dungeon.map_reading("game_map.txt")
self.assertTrue(self.my_dungeon.spawn(self.my_hero))
self.assertEqual(self.my_dungeon.hero_position_x, 0)
self.assertEqual(self.my_dungeon.hero_position_y, 0)
def test_move_hero_falses(self):
self.my_dungeon.map_reading("game_map.txt")
self.my_dungeon.spawn(self.my_hero)
self.assertFalse(self.my_dungeon.move_hero("up"))
self.assertFalse(self.my_dungeon.move_hero("left"))
self.my_dungeon.hero_position_x = 4
self.my_dungeon.hero_position_y = 9
self.assertFalse(self.my_dungeon.move_hero("down"))
self.assertFalse(self.my_dungeon.move_hero("right"))
def test_move_hero(self):
self.my_dungeon.map_reading("game_map.txt")
self.my_dungeon.hero_position_y = 1
self.my_dungeon.hero_position_x = 0
self.assertTrue(self.my_dungeon.move_hero("left"))
self.my_dungeon.hero_position_x = 1
self.my_dungeon.hero_position_y = 1
self.assertTrue(self.my_dungeon.move_hero("up"))
self.my_dungeon.hero_position_x = 0
self.my_dungeon.hero_position_y = 1
self.assertTrue(self.my_dungeon.move_hero("down"))
def test_changing_pos(self):
self.my_dungeon.changing_pos_func(0, 1)
self.assertEqual(self.my_dungeon.hero_position_x, 0)
self.assertEqual(self.my_dungeon.hero_position_y, 1)
def test_pick_treasure(self):
my_dict = Dungeon.load_treasure_file("treasures.json")
x = self.my_dungeon.pick_treasure(my_dict)
x = x[:15]
needed = "Bron's treasure"
self.assertEqual(x, needed)
def test_print_map(self):
pass
class Test_dungeon(unittest.TestCase):
def setUp(self):
path = open("path.txt", "w")
self.dung_map = """S.##......
#.##..###
#.###.###.
#.....###
###.####S"""
path.write(self.dung_map)
path.close()
self.dungeon = Dungeon("path.txt")
self.bron = Hero("Bron", 100, "DragonSlayer")
self.orc = Orc("orc", 90, 1.4)
self.bron.equip_weapon(Weapon("Mighty Axe", 25, 0.2))
self.orc.equip_weapon(Weapon("basher", 16, 0.75))
def test_dungeon_init(self):
self.assertEqual(self.dungeon.map, self.dung_map)
def test_spawn_hero(self):
self.assertTrue(self.dungeon.spawn("hero", self.bron))
self.dung_map = """H.##......
#.##..###
#.###.###.
#.....###
###.####S"""
self.assertEqual(self.dungeon.map, self.dung_map)
def test_spawn_hero_and_orc(self):
self.assertTrue(self.dungeon.spawn("hero", self.bron))
self.assertTrue(self.dungeon.spawn("orc", self.orc))
self.dung_map = """H.##......
#.##..###
#.###.###.
#.....###
###.####O"""
self.assertEqual(self.dungeon.map, self.dung_map)
def test_spawn_no_free_start_postion(self):
self.dungeon.spawn("hero", self.bron)
self.dungeon.spawn("hero2", self.bron)
self.assertFalse(self.dungeon.spawn("heroo", self.orc))
def test_move_possible(self):
self.dungeon.spawn("hero", self.bron)
self.assertTrue(self.dungeon.move("hero", "right"))
self.dung_map = """.H##......
#.##..###
#.###.###.
#.....###
###.####S"""
self.assertEqual(self.dungeon.map, self.dung_map)
def test_move_imposible(self):
self.dungeon.spawn("hero", self.bron)
self.assertFalse(self.dungeon.move("hero", "left"))
self.dung_map = """H.##......
#.##..###
#.###.###.
#.....###
###.####S"""
self.assertEqual(self.dungeon.map, self.dung_map)
def test_move_fight(self):
self.dungeon.map = """SS##......
#.##..###
#.###.###.
#.....###
###.####S"""
self.dungeon.spawn("hero", self.bron)
self.dungeon.spawn("orc", self.orc)
self.dung_map = """.O##......
#.##..###
#.###.###.
#.....###
###.####S"""
self.dungeon.move("hero", "right")
self.assertEqual(self.dungeon.map, self.dung_map)
def tearDown(self):
os.remove("path.txt")
class CellMoveSimulator(Simulator):
def __init__(self, param, dungeon=None):
self.random_enemy = param.get('randomEnemy', False)
if dungeon is None:
self.dungeon = Dungeon(30, 40, no_generate_enemy=self.random_enemy)
else:
self.dungeon = dungeon
self.is_end = False
self.friend_agent: Friend = None
self.turn = 0
self.first_room = param.get('firstRoom', None)
self.no_enemy = param.get('noEnemy', False)
self.max_turn = param.get('maxTurn', 1500)
self.map = self.dungeon.floor_map.copy()
self.map[self.map == CellInfo.PROTECTED] = CellInfo.ROOM
self.map[self.map == CellInfo.ENEMY] = CellInfo.ROOM
self.enemy_list = [Enemy(-1, -1), Enemy(-1, -1)]
self.reset()
def reset(self):
self.is_end = False
self.turn = 0
if self.first_room is None or self.first_room < 0:
first_room: Room = random.choice(self.dungeon.rooms)
else:
first_room: Room = self.dungeon.rooms[self.first_room]
first_room_map = self.dungeon.get_room_map(first_room)
index = random.choice(
np.where(first_room_map.reshape(-1) == CellInfo.ROOM)[0])
y = int(index / first_room_map.shape[1] + first_room.origin[0])
x = int(index % first_room_map.shape[1] + first_room.origin[1])
self.friend_agent = Friend(y, x, first_room.id)
self._load_enemy(first_room.id)
def action(self, action):
self.turn += 1
next_room_id = -1
if type(action) == dict:
next_room_id = action['nextRoomId']
action = action['action']
before_point = (self.friend_agent.x, self.friend_agent.y)
if action == 0:
for v in FOUR_DIRECTION_VECTOR:
x = self.friend_agent.x + v[0]
y = self.friend_agent.y + v[1]
e = [
enemy for enemy in self.enemy_list
if enemy.x == x and enemy.y == y
]
if len(e) >= 1:
e[0].x = -1
e[0].y = -1
break
elif action == 1:
self.friend_agent.y -= 1
elif action == 2:
self.friend_agent.x += 1
elif action == 3:
self.friend_agent.y += 1
elif action == 4:
self.friend_agent.x -= 1
if self.map[self.friend_agent.y][self.friend_agent.x] == CellInfo.WALL:
self.friend_agent.x = before_point[0]
self.friend_agent.y = before_point[1]
if any([(enemy.x, enemy.y) == (self.friend_agent.x,
self.friend_agent.y)
for enemy in self.enemy_list]):
self.friend_agent.x = before_point[0]
self.friend_agent.y = before_point[1]
self._enemy_action()
if self.turn > self.max_turn:
self.is_end = True
return -100
if self.is_end:
return -100
if self.map[self.friend_agent.y][self.friend_agent.x] == CellInfo.ROAD:
road = [
road
for road in self.dungeon.rooms[self.friend_agent.room_id].roads
if (self.friend_agent.x, self.friend_agent.y) in road.ends
][0]
end_position = [
end for end in road.ends
if end != (self.friend_agent.x, self.friend_agent.y)
][0]
for v in FOUR_DIRECTION_VECTOR:
if self.map[end_position[1] + v[1],
end_position[0] + v[0]] == CellInfo.ROOM:
self.friend_agent.x = end_position[0] + v[0]
self.friend_agent.y = end_position[1] + v[1]
self.friend_agent.room_id = \
[room for room in road.connected_rooms if room.id != self.friend_agent.room_id][0].id
break
self._load_enemy(self.friend_agent.room_id)
if self.friend_agent.room_id == next_room_id:
return 100
else:
return -100
if self.map[self.friend_agent.y][self.friend_agent.x] == CellInfo.GOAL:
self.is_end = True
return 100
return -1
def _load_enemy(self, room_id):
if self.no_enemy:
return
if self.random_enemy:
room = self.dungeon.rooms[room_id]
for e in self.enemy_list:
room_map = self.dungeon.get_room_map(room)
index = random.choice(
np.where(room_map.reshape(-1) == CellInfo.ROOM)[0])
y = int(index / room_map.shape[1] + room.origin[0])
x = int(index % room_map.shape[1] + room.origin[1])
e.x = x
e.y = y
else:
for p, e in zip(
self.dungeon.rooms[room_id].initial_enemy_positions,
self.enemy_list):
e.x = p[0]
e.y = p[1]
def _enemy_action(self):
enemy_positions = set()
for enemy in self.enemy_list:
action_candidates = self._search(enemy.x, enemy.y)
next_position_list = []
distance = 1000000
for _ in range(len(action_candidates)):
action_candidate = heappop(action_candidates)
if action_candidate[0] == 0:
self.is_end = True
return
else:
next_position = (action_candidate[1], action_candidate[2])
if action_candidate[0] > distance:
break
distance = action_candidate[0]
if next_position in enemy_positions:
continue
next_position_list.append(next_position)
if next_position_list:
next_position = random.choice(next_position_list)
enemy.x = next_position[0]
enemy.y = next_position[1]
enemy_positions.add(next_position)
def _search(self, x, y):
list_ = []
for v in FOUR_DIRECTION_VECTOR:
x2 = x + v[0]
y2 = y + v[1]
if self.map[y2][x2] != CellInfo.ROOM:
continue
distance = abs(self.friend_agent.x -
x2) + abs(self.friend_agent.y - y2)
heappush(list_, (distance, x2, y2))
return list_
def info(self):
agent_position_inner_room = self._get_agent_position_inner_room()
return {
"isEnd":
self.is_end,
"roomId":
self.friend_agent.room_id,
"x":
agent_position_inner_room[0],
"y":
agent_position_inner_room[1],
"enemies": [{
"x":
max(
e.x -
self.dungeon.rooms[self.friend_agent.room_id].origin[1],
-1),
"y":
max(
e.y -
self.dungeon.rooms[self.friend_agent.room_id].origin[0],
-1),
} for e in self.enemy_list],
"map": {
"cells": [[e.value for e in line] for line in self.map],
"rooms": [room.info() for room in self.dungeon.rooms],
}
}
def _get_agent_position_inner_room(self):
x = self.friend_agent.x - self.dungeon.rooms[
self.friend_agent.room_id].origin[1]
y = self.friend_agent.y - self.dungeon.rooms[
self.friend_agent.room_id].origin[0]
return x, y
