def get_game_variables(constants):
fighter_component = Fighter(hp=100, defense=1, power=2)
inventory_component = Inventory(26)
level_component = Level()
equipment_component = Equipment()
skill_list_component = SkillList()
learnable_skills_component = ['Shoulder Charge', 'Cloak of Quills', 'Throw Rock']
player = Entity(0, 0, CustomTile.PLAYER0, libtcod.white, 'Player', blocks=True, render_order=RenderOrder.ACTOR,
fighter=fighter_component, inventory=inventory_component, level=level_component,
equipment=equipment_component, skill_list=skill_list_component,
learnable_skills=learnable_skills_component)
entities = [player]
equippable_component = Equippable(EquipmentSlots.MAIN_HAND, power_bonus=2)
sharp_rock = Entity(0, 0, CustomTile.SHARP_ROCK, libtcod.sky, 'Sharp Rock', equippable=equippable_component)
player.inventory.add_item(sharp_rock)
player.equipment.toggle_equip(sharp_rock)
game_map = GameMap(constants['map_width'], constants['map_height'])
game_map.make_map(constants['max_rooms'], constants['room_min_size'], constants['room_max_size'],
constants['map_width'], constants['map_height'], player, entities)
message_log = MessageLog(constants['message_x'], constants['message_width'], constants['message_height'])
game_state = GameStates.PLAYERS_TURN
return player, entities, game_map, message_log, game_state
def create_skill(self, character, skill_name, **kwargs):
results = []
if skill_name == 'Cloak of Quills':
skill_component = Skills(use_function=cast_quills,
damage=40,
maximum_range=5)
Quills = Entity(0,
0,
'*',
libtcod.sky,
'Cloak of Quills',
skill=skill_component)
character.skill_list.add_skill(results, Quills)
character.learnable_skills.remove('Cloak of Quills')
character.learnable_skills.append('Cloak of Quills 2')
elif skill_name == 'Shoulder Charge':
skill_component = Skills(use_function=cast_shoulder_charge,
damage=40,
maximum_range=5)
Shoulder_Charge = Entity(0,
0,
'*',
libtcod.sky,
'Shoulder Charge',
skill=skill_component)
character.skill_list.add_skill(results, Shoulder_Charge)
character.learnable_skills.remove('Shoulder Charge')
character.learnable_skills.append('Shoulder Charge 2')
elif skill_name == 'Throw Rock':
skill_component = Skills(
use_function=cast_throw_rock,
damage=40,
maximum_range=3,
targeting=True,
targeting_message=Message(
'Left-click on a enemy to throw rock, or right-click to cancel.'
))
Throw_Rock = Entity(0,
0,
'*',
libtcod.sky,
'Throw Rock',
skill=skill_component)
character.skill_list.add_skill(results, Throw_Rock)
character.learnable_skills.remove('Throw Rock')
character.learnable_skills.append('Throw Rock 2')
return results
def target_address(self, new_target_address):
# Target unchanged
if new_target_address == self._target_address:
return
# Target changed
if self.target and self._target_address:
# Unregister existing target
if self.address != self._target_address:
MemoryWatch.unregister_by_address(self._target_address)
self.target = None
# Create new entity
if new_target_address:
self.target = Entity(new_target_address)
self._target_address = new_target_address
def generate(self, intent_name, utterance_sample, slots):
"""
parse and generate from slots
:param utterance_sample:
:param slots:
:return: A list of entities
"""
if self.contains_slots(utterance_sample):
slots_all = []
for slot_value in self.get_slots(utterance_sample):
slots_lst = []
if self.is_builtin_entity(slot_value):
for slot in get_builtin_resources(self.language,
slot_value):
slots_lst += [(slot_value, slot)]
else:
for slot in slots.get(slot_value, []):
slots_lst += [(slot_value, slot)]
slots_all += [slots_lst]
all_combinations = itertools.product(*slots_all)
for poss_combs in all_combinations:
utterance = utterance_sample
entities = []
for slot_value, value in poss_combs:
utterance = utterance.replace('{%s}' % (slot_value), value)
slot_type, slot_name = Slot(slot_value).parse()
start_index = utterance.find(value)
end_index = start_index + len(value)
entities.append(
Entity(slot_name, slot_type, value, start_index,
end_index))
yield Utterance(intent=intent_name,
utterance_sample=utterance,
entities=entities)
else:
yield Utterance(intent=intent_name,
utterance_sample=utterance_sample,
entities=[])
def get_entity_list(self):
player_address = multi_level_pointers.entity_base.address
entity_ptr_value = read_address(player_address, c_ulonglong())
assert entity_ptr_value, 'Player base not found...?!'
# Start with a fresh list
self._clear_entities_from_memory()
# Start at first non-self entity
entity_address = player_address + entity_size
entity_list = []
# Get all entities
for _ in xrange(ENTITY_LIST_SIZE):
new_entity = Entity(entity_address)
entity_list.append(new_entity)
entity_address += entity_size
self.entity_address_list = [e.address for e in entity_list]
# Pause for MemoryWatch to gather data
time.sleep(.05)
return entity_list
def start():
key_bindings = [[pygame.K_a], [pygame.K_d], [pygame.K_w], [pygame.K_s]]
pygame.init()
size = width, height = (640, 480)
game = Game(size)
game.add_component(ExitOnEscape())
scene = game.scene
map1 = "G GGG\n G\nGGGGGGG G\n F"
map2 = "GGGGGGGG G\nG \nGGGGGGGG G\n G"
tiles = {" ": AirTile, "G": GrassTile, "F": FinishTile}
tile_map = Entity()
player = Entity()
scene.add_entity(tile_map)
tile_map.add_component(
TransformComponent(pygame.Rect(0, 0, width, height)))
tile_map.add_component(TileMap())
tile_map.add_component(TileLoader(map1, tiles))
tile_map.add_component(
MapSwap(pygame.K_f, map1, map2, tiles, [tile_map, player]))
tile_map.add_component(RendererComponent(TileRenderer()))
scene.add_entity(player)
player.add_component(
TransformComponent(pygame.Rect(width // 2, height // 2, 50, 50)))
player.add_component(MoveComponent(1, 4))
player.add_component(
ScreenBoundsCollisionHandler(pygame.Rect(0, 0, width, height)))
player.add_component(
TileMapCollisionHandler(tile_map.get_component(TileMap),
{AirTile}))
player.add_component(KeyControlComponent(key_bindings))
player.add_component(RendererComponent(SmileRenderer()))
player.add_component(ResetWhenSwapAndCollideComponent(tile_map))
game.add_component(ResetGameComponent(tile_map, player))
start_text = Entity()
scene.add_entity(start_text)
start_text.add_component(
TransformComponent(
pygame.Rect(width // 2 - 200, height // 2, 400, 50)))
start_text.add_component(
RendererComponent(TextRenderer("Smile Dimensions", 40)))
controls_text = "WASD - to move, F - swap dimension, Enter - continue"
controls = Entity()
scene.add_entity(controls)
controls.add_component(
TransformComponent(
pygame.Rect(width // 2 - 200, height // 2 + 50, 400, 20)))
controls.add_component(
RendererComponent(TextRenderer(controls_text, 14)))
rules = "If you collide with wall in other dimension, game will be reset"
rules_text = Entity()
scene.add_entity(rules_text)
rules_text.add_component(
TransformComponent(
pygame.Rect(width // 2 - 220, height // 2 + 70, 450, 20)))
rules_text.add_component(RendererComponent(TextRenderer(rules, 14)))
game.add_component(
HideOnKeyComponent([start_text, controls, rules_text],
pygame.K_RETURN))
game.run()
def make_map(self, max_rooms, room_min_size, room_max_size, map_width,
map_height, player, entities):
rooms = []
num_rooms = 0
center_of_last_room_x = None
center_of_last_room_y = None
for r in range(max_rooms):
# random width and height
w = randint(room_min_size, room_max_size)
h = randint(room_min_size, room_max_size)
# random position without going out of the boundaries of the map
x = randint(0, map_width - w - 1)
y = randint(0, map_height - h - 1)
# "Rect" class makes rectangles easier to work with
new_room = Rect(x, y, w, h)
# run through the other rooms and see if they intersect with this one
for other_room in rooms:
if new_room.intersect(other_room):
break
else:
# this means there are no intersections, so this room is valid
# "paint" it to the map's tiles
self.create_room(new_room)
# center coordinates of new room, will be useful later
(new_x, new_y) = new_room.center()
center_of_last_room_x = new_x
center_of_last_room_y = new_y
if num_rooms == 0:
# this is the first room, where the player starts at
player.x = new_x
player.y = new_y
else:
# all rooms after the first:
# connect it to the previous room with a tunnel
# center coordinates of previous room
(prev_x, prev_y) = rooms[num_rooms - 1].center()
# flip a coin (random number that is either 0 or 1)
if randint(0, 1) == 1:
# first move horizontally, then vertically
self.create_h_tunnel(prev_x, new_x, prev_y)
self.create_v_tunnel(prev_y, new_y, new_x)
else:
# first move vertically, then horizontally
self.create_v_tunnel(prev_y, new_y, prev_x)
self.create_h_tunnel(prev_x, new_x, new_y)
self.place_entities(new_room, entities)
# finally, append the new room to the list
rooms.append(new_room)
num_rooms += 1
stairs_component = Stairs(self.dungeon_level + 1)
down_stairs = Entity(center_of_last_room_x,
center_of_last_room_y,
CustomTile.DOWN_ARROW,
libtcod.white,
'Stairs',
render_order=RenderOrder.STAIRS,
stairs=stairs_component)
entities.append(down_stairs)
def place_entities(self, room, entities):
max_monsters_per_room = from_dungeon_level([[2, 1], [3, 4], [5, 6]],
self.dungeon_level)
max_items_per_room = from_dungeon_level([[1, 1], [2, 4]],
self.dungeon_level)
# Get a random number of monsters
number_of_monsters = randint(0, max_monsters_per_room)
# Get a random number of items
number_of_items = randint(0, max_items_per_room)
monster_chances = {
'wolf':
80,
'bear':
from_dungeon_level([[15, 3], [30, 5], [60, 7]], self.dungeon_level)
}
item_chances = {
'healing_herbs': 35,
'sharp_stick': from_dungeon_level([[5, 4]], self.dungeon_level),
'shield': from_dungeon_level([[15, 8]], self.dungeon_level),
'lightning_scroll': from_dungeon_level([[25, 4]],
self.dungeon_level),
'fire_oil': from_dungeon_level([[25, 6]], self.dungeon_level),
'confusion_scroll': from_dungeon_level([[10, 2]],
self.dungeon_level)
}
for i in range(number_of_monsters):
# Choose a random location in the room
x = randint(room.x1 + 1, room.x2 - 1)
y = randint(room.y1 + 1, room.y2 - 1)
# Check if an entity is already in that location
if not any([
entity
for entity in entities if entity.x == x and entity.y == y
]):
monster_choice = random_choice_from_dict(monster_chances)
if monster_choice == 'wolf':
fighter_component = Fighter(hp=20,
defense=0,
power=4,
xp=35)
ai_component = BasicMonster()
skill_list_component = SkillList()
monster = Entity(x,
y,
CustomTile.WOLF0,
libtcod.white,
'Wolf',
blocks=True,
render_order=RenderOrder.ACTOR,
fighter=fighter_component,
ai=ai_component,
skill_list=skill_list_component)
else:
fighter_component = Fighter(hp=30,
defense=2,
power=8,
xp=100)
ai_component = BasicMonster()
skill_list_component = SkillList()
monster = Entity(x,
y,
CustomTile.BEAR0,
libtcod.white,
'Bear',
blocks=True,
fighter=fighter_component,
render_order=RenderOrder.ACTOR,
ai=ai_component,
skill_list=skill_list_component)
entities.append(monster)
for i in range(number_of_items):
x = randint(room.x1 + 1, room.x2 - 1)
y = randint(room.y1 + 1, room.y2 - 1)
if not any([
entity
for entity in entities if entity.x == x and entity.y == y
]):
item_choice = random_choice_from_dict(item_chances)
if item_choice == 'healing_herbs':
item_component = Item(use_function=heal, amount=40)
item = Entity(x,
y,
CustomTile.HEALING_HERBS,
libtcod.white,
'Healing Herbs',
render_order=RenderOrder.ITEM,
item=item_component)
elif item_choice == 'sharp_stick':
equippable_component = Equippable(EquipmentSlots.MAIN_HAND,
power_bonus=3)
item = Entity(x,
y,
CustomTile.SHARP_STICK,
libtcod.white,
'Sharp Stick',
equippable=equippable_component)
elif item_choice == 'shield':
equippable_component = Equippable(EquipmentSlots.OFF_HAND,
defense_bonus=1)
item = Entity(x,
y,
'[',
libtcod.darker_orange,
'Shield',
equippable=equippable_component)
elif item_choice == 'fire_oil':
item_component = Item(
use_function=cast_fireball,
targeting=True,
targeting_message=Message(
'Left-click a target tile for the fireball, or right-click to cancel.',
libtcod.light_cyan),
damage=25,
radius=3)
item = Entity(x,
y,
CustomTile.FIRE_OIL,
libtcod.white,
'Fire Oil',
render_order=RenderOrder.ITEM,
item=item_component)
elif item_choice == 'confusion_scroll':
item_component = Item(
use_function=cast_confuse,
targeting=True,
targeting_message=Message(
'Left-click an enemy to confuse it, or right-click to cancel.',
libtcod.light_cyan))
item = Entity(x,
y,
'#',
libtcod.light_pink,
'Confusion Scroll',
render_order=RenderOrder.ITEM,
item=item_component)
else:
item_component = Item(use_function=cast_lightning,
damage=40,
maximum_range=5)
item = Entity(x,
y,
'#',
libtcod.yellow,
'Lightning Scroll',
render_order=RenderOrder.ITEM,
item=item_component)
entities.append(item)
def __init__(self):
Entity.__init__(self)
self.recipes = {Spear(None): ['sharp_stone', 'stick', 'liana'],
Axe(None): ['sharp_stone', 'log', 'liana']}
def __init__(self, pos, text=''):
Entity.__init__(self)
self.pos = pos
self.text = text
self.font = pygame.font.SysFont("monospace", 18)
def start():
pygame.init()
pygame.display.set_caption('PyDungeon')
size = width, height = (640, 480)
game = Game()
game.setup_default_components(size)
scene = game.scene
tilemap = Entity()
scene.add_entity(tilemap)
tilemap.add_component(NameComponent("tilemap"))
tilemap.add_component(TransformComponent(Vector2(0, 0)))
ts = TileSet()
ts.load("assets/tileset.png", "assets/tileinfo.info")
tm = TileMap(ts, size)
mp = [[["floor_" + str(random.randrange(1, 8))] for _ in range(24)]
for _ in range(24)]
PyDungeons.build_wall_rect(mp, pygame.Rect(2, 2, 10, 10))
tm.load_letters(mp)
tilemap.add_component(tm)
tilemap.add_component(
TileMapCollider(
tm, ["wall_mid", "wall_side_mid_right", "wall_side_mid_left"]))
tilemap.add_component(RendererComponent(TileMapRenderer(), size))
player = Entity()
scene.add_entity(player)
player.add_component(NameComponent("player"))
key_bindings = [[pygame.K_a], [pygame.K_d], [pygame.K_w], [pygame.K_s]]
player.add_component(MoveComponent(1, 2))
player.add_component(KeyControlComponent(key_bindings))
#player.add_component(ScreenBoundsCollisionHandler(pygame.Rect(0, 0, width, height)))
player.add_component(TransformComponent(Vector2(100, 100)))
player.add_component(BoxCollider((16 * 2, 22 * 2), Vector2(0, 12)))
player.add_component(
RendererComponent(TileRenderer(ts.tiles["knight_f_idle_anim"], ts),
(16 * 2, 28 * 2)))
#player.add_component(RendererComponent(ImageRenderer("assets/tileset.png"), (1000, 1000)))
game.add_component(ExitOnEscape())
game.run()
def arg(): # Fonction d'entrée des arguments
def errMsg():
print(f"{Icons.warn}Il y a pas de map sauvegardée portant ce nom")
print(
f'{Icons.info}Créer une nouvelle map avec "python main.py -n <mapName> <x> <y>"'
)
return (False)
args = {
"prefix":
((("-a", "--add"), '<mapName> "[(x, y), ...]"'),
(("-A", "--add-entity"), "<mapName> <type> <x> <y>"),
(("-d", "--display"), "<mapName>"), (("-n", "--new"),
"<mapName> <x> <y>"),
(("-r", "--reset"), "<mapName>"), (("-s", "--start"), "<mapName>"),
(("-h", "--help"), ""), (("-v", "--version"), "")),
"descriptions":
("\tInsérer une ou plusieurs cellules", "Insérer une entité",
"\t\tAfficher la map enregistrée", "\t\tCréer une nouvelle map",
"\t\t\tRéinitialiser une map", "\t\t\tJouer une map\n",
"\t\t\t\tAffichage du menu d'aide",
"\t\t\t\tAffichage de la version du programme\n")
}
if (argv[1] in args["prefix"][-2][0]):
print(" Le jeu de la vie de John Horton Conway")
print(" Lancement: python main.py <arg>\n")
print(" Arguments:")
for i in range(0, len(args["prefix"])):
print(
f' {args["prefix"][i][0][0]}, {args["prefix"][i][0][1]} {args["prefix"][i][1]}\t{args["descriptions"][i]}'
)
elif (argv[1] in args["prefix"][-1][0]):
print(" conwayGameOfLife.py 2.1 - Florian Cardinal\n")
if (not (argv[1] in args["prefix"][-2][0])
and not (argv[1] in args["prefix"][-1][0])):
try:
map = Map(str(argv[2]))
except Exception:
print(f"{Icons.warn}Aucun nom de map n'a été entrer")
return (False)
if (argv[1] in args["prefix"][0][0]):
if (map.loaded):
try:
map.addCells(eval(argv[3]))
map.display()
except Exception:
print(f"{Icons.warn}Coordonnées manquantes ou incorrectes")
return (False)
else:
return (errMsg())
elif (argv[1] in args["prefix"][1][0]):
if (map.loaded):
entities = Entity()
try:
x = int(argv[4])
y = int(argv[5])
except Exception:
print(
f"{Icons.warn}Les coordonnées de position sont incorrectes"
)
return (False)
if (entities.loaded):
if (argv[3] in entities.getEntitiesName()):
map.addCells(entities.get(argv[3], (x, y)))
map.display()
else:
print(f"{Icons.warn}Entitée non reconnue")
else:
print(f"{Icons.warn}Le fichier d'entités est introuvables")
return (False)
else:
return (errMsg())
elif (argv[1] in args["prefix"][2][0]):
if (map.loaded):
map.display()
else:
return (errMsg())
elif (argv[1] in args["prefix"][3][0]):
try:
map.initMap(int(argv[3]), int(argv[4]))
map.display()
except Exception:
print(f"{Icons.warn}Spécifier les dimension <x> et <y>")
return (False)
elif (argv[1] in args["prefix"][4][0]):
if (map.loaded):
map.reset()
map.display()
else:
return (errMsg())
elif (argv[1] in args["prefix"][5][0]):
if (map.loaded):
map.start()
else:
return (errMsg())
return (True)
