def test_init():
p = Player(0)
assert p.id == 0
assert not p.turn
assert not p.is_my_turn()
p.toggle_turn()
assert p.turn
assert p.symbol == '-'
def __init__(self, **kw):
super(Engine, self).__init__(**kw)
self.player = Player()
self.monsters = [genmonster(self._level) for i in range(self._level)]
self._map = Map(player=self.player,
monsters=self.monsters,
_level=self._level,
_Z=self._maze)
def test_init():
p = Player(0)
assert p.id == 0
assert not p.turn
assert not p.is_my_turn()
p.toggle_turn()
assert p.turn
assert p.symbol == '-'
def main():
print_header()
rolls = build_the_three_rolls()
name = get_player_name()
player1 = Player(name)
player2 = Player("computer")
game_loop(player1, player2, rolls)
def main():
print_header()
rolls = read_rolls()
name = get_players_name()
player1 = Player(name)
player2 = Player("computer")
game_loop(player1, player2, rolls)
def game():
print_header()
rolls = build_three_rolls()
name = get_players_name()
player1 = Player(name)
player2 = Player('Laptop')
game_loop(player1, player2, rolls)
def game_loop():
creatures = [
Creature('Toad', 1),
Creature('Tiger', 12),
Creature('Bat', 3),
Creature('Dragon', 50),
Creature('Evil Wizard', 1000),
]
hero = Player('Gandolf', 75)
while True:
active_creature = choice(creatures)
print(f'A {active_creature.name} of level {active_creature.level} has appeared from a dark and foggy forest...')
print()
cmd = input('Do you [a]ttack, [r]unaway, or [l]ook around? ')
if cmd == 'a':
print(f'The hero has {hero.hp} hit points')
print(f'The {active_creature.name} has {active_creature.hp} hit points')
while hero.is_alive() and active_creature.is_alive() and input('Continue? (y/n)').strip().lower() == 'y':
hero.attack(active_creature)
if not active_creature.is_alive():
print(f'The wizard has killed the {active_creature.name}')
creatures.remove(active_creature)
break
active_creature.attack(hero)
if not hero.is_alive():
print(f'The wizard was killed by the {active_creature.name}')
hero.heal(hero.max_hp)
break
print(f'The hero has {hero.hp} hit points')
print(f'The {active_creature.name} has {active_creature.hp} hit points')
elif cmd == 'r':
hero.heal(hero.max_hp)
print(f'The wizard has healed')
elif cmd == 'l':
print(f'The wizard {hero.name} takes in the surroundings and sees:')
for c in creatures:
print(f' * A {c.name} of level {c.level}')
else:
print('Ok, exiting game... bye!')
break
if not creatures:
print('You have defeated all the creates, well done!')
break
print()
def __init__(self):
super(Dugeon, self).__init__()
self.cells_count = 100
self.rooms_group = pg.sprite.LayeredDirty()
self.doors_group = pg.sprite.LayeredDirty()
self.backgound = pg.sprite.LayeredDirty()
self.visible_sprites = pg.sprite.LayeredDirty()
self.doors = []
self.cells = []
while (len(self.cells) < self.cells_count):
c = Cell()
self.cells.append(c)
self.rooms = self.select_main_rooms(self.cells)
area, min_x, min_y = self.separate_cells(self.rooms)
print("Dugeon dimentions With: %s Heigth: %s" % area)
w = area[0] + MAX_ROOM_W * TS2 + TS2
h = area[1] + MAX_ROOM_H * TS2 + TS2
self.image = pg.Surface((w, h))
self.image.fill((0, 0, 0))
self.bg_image = pg.Surface((SCREEN_RECT.w, SCREEN_RECT.h))
self.bg_image.fill((0, 0, 0))
self.rect = self.image.get_rect()
self.clip_rooms(min_x, min_y)
self.halls = self.connet_rooms(self.rooms)
self.initial_room = random.choice(self.rooms)
self.initial_room.spawed = True
self.walls = []
self.make_walls()
# self.remove_useless_doors()
self.fix_walls()
self.player = Player(self.initial_room.rect.center, ALL_SPRITES)
self.viewport = Viewport()
self.viewport.update(self.player, self.rect)
# Custom Cursor
pg.mouse.set_visible(False)
self.cursor = Cursor((0, 0), ALL_SPRITES)
self.cursor.update(self.viewport)
ALL_SPRITES.change_layer(self.cursor, 9)
def test_player_get_damage_alive(self):
player = Player('Robin Hood', ARCHER)
player.health = 20
player.get_damage(15)
self.assertTrue(player.is_alive())
def main():
print('======== RPG ===========')
player_name = input('Elige el nombre de tu personaje: ')
player_class = input('Elige entre Arquero(1) y Guerrero(2): ')
player = Player(player_name, player_class)
room_count = 1
enemy_count = 0
while True:
player.has_fled = False
navigation_action = choose_action()
encounter = decide_encounter(navigation_action)
if has_enemy_in_encounter(encounter):
enemy = create_enemy(encounter)
print('Un {} salvaje aparecio'.format(enemy))
while is_battle_active(player, enemy):
print("\nTURNO DE", player_name)
action = input('Elige accion: (1) Atacar, (2) Huir: ')
print('Procesando acción...')
time.sleep(1)
player.attack(action, enemy)
enemy.attack(player)
enemy_count += 1
print('derrotaste a {} enemigos'.format(enemy_count))
room_count += 1
print('Has pasado por la habitación nº', room_count)
if not player.is_alive():
print('Tu puntuación es de {} salas'.format(room_count))
print('GAME OVERRRRRRR!!')
break
def test_player_get_damage_dead(self):
player = Player('Robin Hood', ARCHER)
player.health = 14
player.get_damage(15)
self.assertFalse(player.is_alive())
import pygame
from time import sleep
from random import randint
from board import Square, Grid, Column
from actors import Player, Game
pygame.init()
WIDTH, HEIGHT = 640, 640
SIZE = 3
DISPLAY_SURF = pygame.display.set_mode((WIDTH, HEIGHT))
FONTOBJ = pygame.font.Font('lato.ttf', 48)
#players = Player(0, 'X'), Player(1, 'O'), Player(2, 'W'), Player(3, 'H')
players = Player(0, 'X'), Player(1, 'O')
white = 204, 204, 204
black = 54, 54, 54
tblack = 54, 54, 54, 128
def random_color():
return randint(1, 192), randint(1, 192), randint(1, 192)
class Tile(Square):
def __init__(self, display, *args, **kwargs):
b_size = WIDTH / SIZE
Square.__init__(self, *args, **kwargs)
self.rect = pygame.Rect(self.x * b_size, self.y * b_size, b_size,
class Engine(EventDispatcher):
"""This needs a docstring"""
_level = NumericProperty(1)
_map = ObjectProperty(None)
monsters = ListProperty([])
player = ObjectProperty(None, allownone=True)
debug = BooleanProperty(False)
outputfunc = ObjectProperty(None)
_maze = ObjectProperty(None, force_dispatch=True)
def __init__(self, **kw):
super(Engine, self).__init__(**kw)
self.player = Player()
self.monsters = [genmonster(self._level) for i in range(self._level)]
self._map = Map(player=self.player,
monsters=self.monsters,
_level=self._level,
_Z=self._maze)
def __setstate__(self, state):
self._map.__setstate__(state["map"])
self.player.__setstate__(state["player"])
self._level = state["level"]
for monster, mstate in zip(self.monsters, state["monsters"]):
monster.__setstate__(mstate)
def __getstate__(self):
return {
"map": self._map.__getstate__(),
"player": self.player.__getstate__(),
"monsters": [m.__getstate__() for m in self.monsters],
"level": self._level
}
def parse(self, text):
if text in "adsw":
self.move("adsw".index(text))
if text in "f":
for x, y in self.player.loe:
if self._map[x, y]:
break
for m in self.monsters:
if m.coords == [x, y]:
self.attack(self.player, m)
break
def nxtlevel(self):
self._level += 1
self.reset(False)
self.player.xp += 10
self.player.torches += 2
def cleanup(self):
""""""
for monster in self.monsters:
if monster.hp <= 0:
self.player.xp += (monster.level * 5) * self.player.exp
self.player.gold += (monster.level * 10) * self.player.goldplus
if dLife.roll() == 1:
life = 20
maxhp = getattr(self.player, "maxhp")
while True:
if self.player.hp + life > maxhp:
life -= 1
else:
break
if life > 0:
pass
self.outputfunc("+{} hp".format(life))
self.player.hp += life
self.monsters = filter(lambda m: m.hp > 0, self.monsters)
self._map.monsters = self.monsters
if self.player.coords == self._map.exit:
self.nxtlevel()
return
if self.player.hp <= 0:
self.player._alive = False
#player dead
#replay = raw_input("Retry? y/n: ")
#if replay == "y":
# self.reset(True)
# self._map.reset(1)
#else:
# sys.exit()
else:
self.player.lvlup()
def reset(self, player):
if player:
self.player.reset()
self.monsters = [genmonster(self._level) for i in range(self._level)]
self._map.monsters = self.monsters
self._map.reset(self._level)
def attack(self, atk, defend):
""""""
if ranf() <= atk.accuracy:
hit = atk.attack - defend.defense
if type(atk) == Player and self.player.equipped["Weapon"].stat.get(
"backstab", 0) == 1:
hit = atk.attack * 3
if ranf < 0.05:
hit = hit * 2
if hit < 0:
hit = 0
defend.hp -= hit
self.outputfunc(" A Hit! {} has {} hp remaining".format(
defend.name, defend.hp))
else:
self.outputfunc("{} missed!".format(atk.name))
def move(self, direction):
dx, dy = facing(self.player, direction)
if not self._map.passable(self.player.mapx + dx,
self.player.mapy + dy):
return
if (self.player.mapx + dx,
self.player.mapy + dy) == self._map.entrance:
self.outputfunc("You bang on the door")
return
if (self.player.mapx + dx,
self.player.mapy + dy) == self._map.exit and direction != 3:
return
self.player.move(dx, dy)
def monaction(self):
for monster in self.monsters:
monster.ai(self._map, self)
def test_is_attack_avoided(self):
player = Player('Robin Hood', ARCHER)
player.health = 13
player.get_damage(15)
player.is_attack_avoided = 100
def main_loop():
loop_counter = 0
loop_counter += 1
if loop_counter == 1:
atr = wiz_atr()
name = atr[0]
char = atr[1]
level = atr[2]
shield = atr[3]
hero = Player(name, level, shield, char)
# if you want new enemei just add it belov
# name, atc, def, win text, lose text, atk_descr
special_moves_list = ["stomp", "gromp", "bomb", "swomp", "chew"]
special_move = random.choice(special_moves_list)
enemies = [
Humans('funny face', 2, 1, "whos laughin now, you stinky bastard?",
"wizard cant beat face? at least you can"
" beat his meat", "laughing at wizard very hardr"),
Humans('happy lovers', 4, 2, "why they should be happy?",
"they was so happy and cute so wizard kill himself"
" to death", "kissing each other"),
Humans('math teacher', 6, 1, "this is sweat revenge",
"math teacher just beat wizrad till ded",
"teach you about algoritms"),
Monsters('fat mom', 5, 9,
"she was so fat so she nearly kill you, when falling dead",
"fat mom lay at wizard when he was casting majik spells",
"trying talk shit about wizzards"),
Monsters('satan, the third', 7, 7, "at least it wasn't his brother",
"wizrds soul forever will be in hell and die",
"casting big fireball"),
Monsters('giant spider bus', 8, 6, "no one seen such a glorious death",
"wizord've been drove to death", "riding in the storm"),
Robots('two big shrobots with shoots', 6, 9, "GET OUT OF HERE TIN CAN",
"wizard was shooted with shoots", "peu-peu big shoots-whoots"),
Robots('robo dragon', 8, 10,
"its time to get over with that japanies bullshit",
"robo dragon was too cute so weezart melted because fire",
"eating wizrados brain"),
Robots(
'robo slime of exquisite depravity', 12, 8,
"yeah! get your stubid metal slime things off",
"robo slime take out wizard to a date, he was cute and then die and you die too because cry and sad",
"trying to gift metal roses to you"),
Boss(
'your social anxiety', 15, 15,
"you win the battle, but not the war",
f"Brave {hero.name} can resist fire and ice, but never can go out home and play with bois",
"happens", special_move),
Boss('wizard laziness', 16, 16,
'wizard cant resist and lay down for relax',
'meh, too lazy to write', 'wizzrd just lay down and sleep',
'just relax bro')
]
encouters = [
'appears from the sky', 'materialise right in front of you',
'got out from earth', 'commin from local subway', 'croos the road'
]
atack_starter = [
"its your chance for atac", "do smthng you dumbo", "FIGHT", "STRIFE!"
]
# print(enemies)
while True:
active_creature = random.choice(enemies)
current_encounter = random.choice(encouters)
atack_start = random.choice(atack_starter)
print(f"Beware! {hero.char} {hero.name} countinue his wey\r\n")
while True:
cmd1 = (
input("[G]O FIND SMTHN, [I]NVENTORY AND STATS\r\n")).lower()
if cmd1.find('g') != -1 or cmd1.find('go') != -1:
print(
f"You moving forwrd and {active_creature.name} {current_encounter}. "
f"It has lvl {active_creature.level}")
print(f"{atack_start}")
break
elif cmd1.find('i') != -1 or cmd1.find('inventory') != -1:
hero.show_inventory()
cmd2 = (input("[A]TACC, [C]RY, [R]UN, [Q]EXIT\r\n")).lower()
if cmd2.find('a') != -1 or cmd2.find('atacc') != -1:
while True:
if hero.attack(active_creature):
enemies.remove(active_creature)
print("encrease your lvl and protection\r\n")
hero.level += 1
hero.shield += 1
break
else:
a = hero.protecc(active_creature)
if a == False:
break
elif cmd2.find('s') != -1 or cmd2.find('cry') != -1:
hero.cry(active_creature)
enemies.remove(active_creature)
elif cmd2.find('r') != -1 or cmd2.find('run') != -1:
hero.run(active_creature)
enemies.remove(active_creature)
elif cmd2.find('q') != -1 or cmd2.find('quit') != -1:
quit()
else:
print('WHAT')
if not enemies:
print(
f"You defleat all enemies. Congrats {hero.name} {hero.char}, you complete teh gaem "
f"your end gaaem majik lvl is {hero.level} with protection {hero.shield}\r\n"
)
input("SORRY NOTHING")
quit()
def run_sim(time=300):
global total_dmg, sim_list
total_dmg = 0
clock = 0
clock_tick = 0.1
gcd1a = gcd1
gcd2a = gcd2
gcd3a = gcd3
char = Player(att_pwr=1171,
ele=1.4464,
c_rate=0.5523,
c_dmg=2.5,
skill_list=[
rosethorn, sunflower, super_sunflower, thorn_strike,
petal_storm, burr_toss, grasping_roots, flying_nettles
])
cosmic = soul()
soul_buff = Buff(ap=cosmic.ap,
c_rate=cosmic.crit_buff,
c_dmg=cosmic.crit_dmg_buff,
duration=5,
name="soul")
while clock < time:
apl = []
apl.append(apl_item(skill=flying_nettles, conditions=[clock < 5]))
apl.append(
apl_item(skill=grasping_roots,
conditions=[
all([
True if not poison.name == db.name else False
for db in target.debuffs
])
]))
apl.append(apl_item(skill=thorn_strike))
apl.append(
apl_item(skill=flying_nettles,
conditions=[
any([
True if magnum_final.name == buff.name else False
for buff in char.buffs
])
]))
apl.append(
apl_item(
skill=burr_toss,
conditions=[
any([
True if burr_available.name == buff.name else False
for buff in char.buffs
])
]))
apl.append(
apl_item(skill=petal_storm,
conditions=[
all([
True if not buff.name == bracelet.name else False
for buff in char.buffs
])
]))
apl.append(apl_item(skill=super_sunflower))
apl.append(apl_item(skill=sunflower))
apl.append(apl_item(skill=rosethorn))
#this is where the APL comes in
if cosmic.remaining_cooldown <= 0:
soul_buff.duration = cosmic.duration
char.buffs.append(soul_buff)
cosmic.remaining_cooldown = cosmic.cooldown
cosmic.remaining_duration = cosmic.duration
# print(clock, "add soul buff")
for i, item in enumerate(apl):
if item.can_use(item.skill.can_use(char, target)):
print(round(clock, 2),
i,
item.skill.name,
char.current_focus,
sep=' | ')
total_dmg += item.skill.cast(char, target)
print([(buff.name, buff.stacks) for buff in char.buffs])
print([(db.name, round(db.remaining, 2))
for db in target.debuffs])
print([(sk.name, round(sk.remaining_cd, 2))
for sk in char.skills])
print("---------------")
break
clock += clock_tick
for ability in char.skills:
ability.remaining_cd -= clock_tick
cosmic.remaining_cooldown -= clock_tick
cosmic.remaining_duration -= clock_tick
for buf in char.buffs:
buf.duration -= clock_tick
if buf.duration <= 0 or buf.stacks <= 0:
char.buffs.remove(buf)
# print(clock, "remove buff: ", buf.name)
for debuff in target.debuffs:
debuff.remaining -= clock_tick
if debuff.remaining % debuff.tick_interval == 0:
total_dmg += char.attack_power * char.elemental * debuff.damage
if debuff.remaining <= 0:
target.debuffs.remove(debuff)
gcd1a.wait_time -= clock_tick
gcd2a.wait_time -= clock_tick
gcd3a.wait_time -= clock_tick
# sim_list.append(total_dmg/clock)
sim_list.append(SimResult(damage=total_dmg, time=clock,
skills=char.skills))
def player1():
return Player('Player 1')
class Dugeon(object):
"""docstring for Dugeon"""
def __init__(self):
super(Dugeon, self).__init__()
self.cells_count = 100
self.rooms_group = pg.sprite.LayeredDirty()
self.doors_group = pg.sprite.LayeredDirty()
self.backgound = pg.sprite.LayeredDirty()
self.visible_sprites = pg.sprite.LayeredDirty()
self.doors = []
self.cells = []
while (len(self.cells) < self.cells_count):
c = Cell()
self.cells.append(c)
self.rooms = self.select_main_rooms(self.cells)
area, min_x, min_y = self.separate_cells(self.rooms)
print("Dugeon dimentions With: %s Heigth: %s" % area)
w = area[0] + MAX_ROOM_W * TS2 + TS2
h = area[1] + MAX_ROOM_H * TS2 + TS2
self.image = pg.Surface((w, h))
self.image.fill((0, 0, 0))
self.bg_image = pg.Surface((SCREEN_RECT.w, SCREEN_RECT.h))
self.bg_image.fill((0, 0, 0))
self.rect = self.image.get_rect()
self.clip_rooms(min_x, min_y)
self.halls = self.connet_rooms(self.rooms)
self.initial_room = random.choice(self.rooms)
self.initial_room.spawed = True
self.walls = []
self.make_walls()
# self.remove_useless_doors()
self.fix_walls()
self.player = Player(self.initial_room.rect.center, ALL_SPRITES)
self.viewport = Viewport()
self.viewport.update(self.player, self.rect)
# Custom Cursor
pg.mouse.set_visible(False)
self.cursor = Cursor((0, 0), ALL_SPRITES)
self.cursor.update(self.viewport)
ALL_SPRITES.change_layer(self.cursor, 9)
def separate_cells(self, cells):
"""based on http://fisherevans.com/blog/post/dungeon-generation
"""
touching = True
interation = 0
min_x = 0
max_x = 0
min_y = 0
max_y = 0
while touching:
touching = False
for i in range(len(cells)):
a = cells[i]
for j in range(i + 1, len(cells)):
b = cells[j]
if a.rect.colliderect(b.rect.inflate(TS4, TS4)):
touching = True
dx = min(a.rect.right - b.rect.left + TS4,
a.rect.left - b.rect.right - TS4)
dy = min(a.rect.bottom - b.rect.top + TS4,
a.rect.top - b.rect.bottom - TS4)
if (abs(dx) < abs(dy)):
dy = 0
else:
dx = 0
dxa = -dx / 2
dxb = dx + dxa
dya = -dy / 2
dyb = dy + dya
dxa = math.floor(((dxa + TS4 - 1) / TS4)) * TS4
dxb = math.floor(((dxb + TS4 - 1) / TS4)) * TS4
dya = math.floor(((dya + TS4 - 1) / TS4)) * TS4
dyb = math.floor(((dyb + TS4 - 1) / TS4)) * TS4
a.pos[0] += dxa
a.pos[1] += dya
b.pos[0] += dxb
b.pos[1] += dyb
min_x = min(min_x, a.pos[0], b.pos[0])
min_y = min(min_y, a.pos[1], b.pos[1])
max_x = max(max_x, a.pos[0], b.pos[0])
max_y = max(max_y, a.pos[1], b.pos[1])
a.rect.topleft = a.pos
b.rect.topleft = b.pos
area = ((max_x - min_x), (max_y - min_y))
return area, min_x, min_y
def select_main_rooms(self, cells):
seleted = []
for room in cells:
if (room.rect.w > MIN_ROOM_W * TS2
and room.rect.h > MIN_ROOM_H * TS2):
room.seleted = True
room.generate_image()
seleted.append(room)
room.add(ALL_SPRITES, self.rooms_group, self.backgound)
print("Rooms selected as main rooms %s" % len(seleted))
return seleted
def connet_rooms(self, rooms):
paths = []
for i in range(len(rooms)):
a = rooms[i]
for j in range(i + 1, len(rooms)):
skip = False
b = rooms[j]
ab_dist = math.pow(a.rect.centerx-b.rect.centerx, 2) + \
math.pow(a.rect.centery-b.rect.centery, 2)
for k in range(len(rooms)):
if (k == i or k == j):
continue
c = rooms[k]
ac_dist = math.pow(a.rect.centerx-c.rect.centerx, 2) + \
math.pow(a.rect.centery-c.rect.centery, 2)
bc_dist = math.pow(b.rect.centerx-c.rect.centerx, 2) + \
math.pow(b.rect.centery-c.rect.centery, 2)
if (ac_dist < ab_dist and bc_dist < ab_dist):
skip = True
if not skip:
ps = self.create_path(a.rect.center, b.rect.center)
paths += ps
return paths
def create_path(self, p1, p2):
# A always left o B
if (p1[0] < p2[0]):
a = p1
b = p2
else:
a = p2
b = p1
a = list(a)
b = list(b)
w = h = TS2
# magic o make the perfect centered hallways
a[0] -= TILE_SIZE
a[1] -= TILE_SIZE
b[0] -= TILE_SIZE
b[1] -= TILE_SIZE
a[0] = math.floor(((a[0] + TS2 - 1) / TS2)) * TS2
a[1] = math.floor(((a[1] + TS2 - 1) / TS2)) * TS2
b[0] = math.floor(((b[0] + TS2 - 1) / TS2)) * TS2
b[1] = math.floor(((b[1] + TS2 - 1) / TS2)) * TS2
clockwise = random.randint(0, 1) == 1
dx = b[0] - a[0]
# A avobe B
if (a[1] < b[1]):
dy = b[1] - a[1]
if clockwise:
r1 = pg.Rect(a[0], a[1], dx + w, h)
r2 = pg.Rect(b[0], a[1], w, dy)
else:
r1 = pg.Rect(a[0], a[1], w, dy + h)
r2 = pg.Rect(a[0], b[1], dx + w, h)
else:
dy = a[1] - b[1]
if clockwise:
r1 = pg.Rect(b[0], b[1], w, dy + h)
r2 = pg.Rect(a[0], a[1], dx + w, h)
else:
r1 = pg.Rect(a[0], b[1], dx + w, h)
r2 = pg.Rect(a[0], b[1], w, dy + h)
h1 = Hallway(r1, ALL_SPRITES, self.backgound)
h2 = Hallway(r2, ALL_SPRITES, self.backgound)
return [h1, h2]
def clip_rooms(self, min_x, min_y):
for r in self.rooms:
r.pos[0] += abs(min_x) + TS2
r.pos[1] += abs(min_y) + TS2
r.rect.topleft = r.pos
def make_walls(self):
for room in self.rooms:
x, y = room.rect.topleft
w = int(room.rect.w / TS2)
h = int(room.rect.h / TS2)
old_hall = None
for i in range(w):
for j in range(h):
if (j > 0 and j < h - 1) and (i > 0 and i < w - 1):
y += TS2
continue
wall = Wall((x, y), i, j, w, h)
hit_walls = pg.sprite.spritecollideany(wall, self.walls)
hit_rooms = pg.sprite.spritecollideany(
wall, self.rooms_group)
if not hit_walls or not hit_rooms:
hall = pg.sprite.spritecollideany(wall, self.halls)
if hall:
if old_hall != hall:
door = Door((x, y), i, j, w, h)
door.add(self.doors_group, ALL_SPRITES)
ALL_SPRITES.change_layer(door, 6)
self.doors.append(door)
door.room = room
room.doors.append(door)
old_hall = hall
else:
self.walls.append(wall)
ALL_SPRITES.add(wall)
y += TS2
x += TS2
y = room.rect.top
for hall in self.halls:
x, y = hall.rect.topleft
x -= TS2
y -= TS2
w = int(hall.rect.w / TS2) + 2
h = int(hall.rect.h / TS2) + 2
for i in range(w):
for j in range(h):
if (j > 0 and j < h - 1) and (i > 0 and i < w - 1):
y += TS2
continue
wall = Wall((x, y), i, j, w, h)
if not pg.sprite.spritecollideany(wall, ALL_SPRITES):
self.walls.append(wall)
ALL_SPRITES.add(wall)
ALL_SPRITES.change_layer(wall, 3)
else:
old_wall = pg.sprite.spritecollideany(wall, self.walls)
if old_wall:
old_wall.need_fix = True
y += TS2
x += TS2
y = hall.rect.top - TS2
def remove_useless_doors(self):
for i in range(len(self.doors)):
a = self.doors[i]
a.rect.inflate_ip(TS2, 0)
walls_around = pg.sprite.spritecollide(a, self.walls, False)
a.rect.inflate_ip(-TS2, TS2)
if len(walls_around) < 2:
walls_around = pg.sprite.spritecollide(a, self.walls, False)
if len(walls_around) < 2:
a.kill()
continue
a.rect.inflate_ip(TS2, 0)
for j in range(i + 1, len(self.doors)):
b = self.doors[j]
if pg.sprite.collide_rect(a, b) and not b.locked:
b.kill()
a.rect.inflate_ip(-TS2, -TS2)
def fix_walls(self):
pass
# a = self.walls[0]
# a.rect.inflate_ip(TS2, TS2)
# walls_around = pg.sprite.spritecollide(a, self.walls, False)
# for w in walls_around:
# a.rect.inflate_ip(-TS2, -TS2)
def handle_input(self, event):
self.player.handle_input(event)
# if event.type == pg.MOUSEMOTION:
# print(x1+x2, y1+y2)
def update(self, dt):
visible_walls = pg.sprite.spritecollide(self.viewport, self.walls,
False)
self.player.update(dt, self.walls, self.doors_group, self.cursor)
self.viewport.update(self.player, self.rect)
self.cursor.update(self.viewport)
# BULLETS_GROUP.update(dt)
ENEMIES_GROUP.update(dt, self.player)
self.rooms_group.update()
visible_sprites = pg.sprite.spritecollide(self.viewport, ALL_SPRITES,
False)
self.visible_sprites.add(visible_sprites)
for sprite in self.visible_sprites.sprites():
if not sprite in self.backgound:
self.visible_sprites.change_layer(sprite, sprite.rect.centery)
else:
self.visible_sprites.change_layer(sprite, sprite.layer)
self.visible_sprites.change_layer(self.cursor, 9999)
if sprite not in visible_sprites:
self.visible_sprites.remove(sprite)
def render(self, surface):
# ALL_SPRITES.repaint_rect(self.viewport)
self.image.blit(self.bg_image, (self.viewport.rect))
self.visible_sprites.draw(self.image)
BULLETS_GROUP.draw(self.image)
ENEMIES_GROUP.draw(self.image)
DECORATOR_GROUP.draw(self.image)
surface.blit(self.image, (0, 0), self.viewport)
self.viewport.render(surface)
def get_players_name():
name = input('What is your name? ')
p1 = Player(name)
print('Welcome {}!'.format(p1.name))
p2 = Player('Computer')
return (p1, p2)
def player2():
return Player('Player 2')
print('Please choose a valid option')
if not self.player.is_alive():
print('Oh no! You lose!')
break
self.print_linebreak()
self.player.stats()
for e in self.enemies:
e.stats()
self.print_linebreak()
if not self.enemies:
print('You have won! Congratulations!')
break
if __name__ == '__main__':
enemies = [
Ogre('Bob', 1, 3),
Imp('Alice', 1)
]
player = Player('Hercules', 1)
Game(player, enemies).main()
#
def main():
"""
Sets up all the relevent object needed to run the game. This includes the
game engine, player, and all enemies in the game. The player and enemies load
thier sprites from a list of paths in a json file that is loaded and referenced
in a dict at the start. Once initalization finishes the game loop is run until
the user exits.
"""
engine = neon_engine.NeonEngine('Neon Souls')
engine.init_pygame()
with open('player_sprites.json', 'r') as p_file:
player_sprites = json.load(p_file)
with open('sentinal_sprites.json') as file:
sentinal_sprites = json.load(file)
player_static = player_sprites['static_sprites']
player_walking = player_sprites['walking_sprites']
player_running = player_sprites['running_sprites']
sentinal_sprites = sentinal_sprites['sprite_list']
player = Player(player_static, player_walking, player_running, (128, 128),
'default', 2, 300, 400)
engine.player_instance = player
sentinal1 = SentinalEnemy(sentinal_sprites, (100, 100), [(400, 500),
(600, 500)],
engine.kill_enemy, 2, 300, 475)
sentinal2 = SentinalEnemy(sentinal_sprites, (100, 100), [(1100, 0),
(1300, 0)],
engine.kill_enemy, 2, 1200, 400)
sentinal3 = SentinalEnemy(sentinal_sprites, (100, 100), [(1500, 0),
(1700, 0)],
engine.kill_enemy, 2, 1600, 450)
engine.enemy_list.append(sentinal1)
engine.enemy_list.append(sentinal2)
engine.enemy_list.append(sentinal3)
gravity_manager = GravityManager()
gravity_manager.add_gravity('default', (0, 15))
gravity_manager.add_object(player)
# create background and level
init_map(engine, player, gravity_manager)
overlay = Overlay(player)
engine.objects.append(overlay)
engine.drawables.add(overlay)
pygame.time.set_timer(pygame.USEREVENT + 1,
1000 // league.Settings.gameTimeFactor)
engine.movement_function = player.move_player
engine.action_function = fire
engine.physics_functions.append(player.process_gravity)
engine.events[pygame.QUIT] = engine.stop
engine.run()
def __init__(self, height, width, robot_info, drone_info, num_obstacles,
drone_latency):
super(PMGridEnv, self).__init__()
# Define action and observation space
self.action_space = spaces.Discrete(N_DISCRETE_ACTIONS)
# using image as input (can be channel-first or channel-last):
self.observation_space = spaces.Box(low=0,
high=255,
shape=(height, width, 3),
dtype=np.uint8)
# To convert integer actions into string
self.action_list = ['up', 'down', 'left', 'right']
## Canvas is the grid we are going to use
self.canvas = Canvas(height, width)
self.latency_factor = drone_latency
## Create the robots
self.playerList = []
for i in range(len(robot_info) // 3):
x_loc, y_loc, size = robot_info[3 * i:3 * (i + 1)]
self.playerList.append(
Player(pos=[x_loc, y_loc], color='g', size=size))
### Add drone to the environememnt
self.droneList = []
for i in range(len(drone_info) // 3):
x_loc, y_loc, size = drone_info[3 * i:3 * (i + 1)]
self.droneList.append(
Drone(pos=[x_loc, y_loc], color='b', size=size))
## Create the obstacle at random locations
self.n_obj = num_obstacles # number of objects
self.obstacleList = []
r_coords = np.random.randint(0, self.canvas.height,
(self.n_obj)) # random rows
c_coords = np.random.randint(0, self.canvas.width,
(self.n_obj)) # random columns
# Width and height would be chosen from 10,15,20,25,30 randomly
for i in range(len(r_coords)):
self.obstacleList.append(
Obstacle(pos=[r_coords[i], c_coords[i]],
size=[
np.random.choice([10, 15, 20, 25, 30]),
np.random.choice([10, 15, 20, 25, 30])
]))
### Environement image as a numpy array
self.env_img = np.zeros(self.canvas.grid.shape + (3, ), dtype=np.uint8)
### Coverage information
self.coverage = np.zeros(self.canvas.grid.shape, dtype=np.uint8)
### Obstacle map information
self.obstacle_map = np.zeros(self.canvas.grid.shape, dtype=np.uint8)
#### Drone Map
self.drone_map = np.zeros(self.canvas.grid.shape + (3, ),
dtype=np.uint8)
#### Saving initial state for resets
self.inital_state = [
self.playerList.copy(),
self.droneList.copy(),
self.obstacleList.copy()
]
#### Initializing locaal info for each robot
for player in self.playerList:
player.info = self.env_img.copy()
### Update entites in screen
self.update_all()
self.process_screen()
def player():
return Player('John')
class GameState():
stage = GameStage.start
bullets = []
asteroids = []
initials = ''
level = 1
score = 0
lives = 3
player = None
leader_board = {}
game = GameState()
game.player = Player(pos=(WIDTH / 2, HEIGHT / 2))
stars = create_star_scape(WIDTH, HEIGHT)
max_distance = min(WIDTH, HEIGHT) * .95
life_pos = 10
life_icons = []
for _ in range(3):
icon = Actor('player', topleft=(life_pos, 10))
life_pos += 32
life_icons.append(icon)
def create_asteroids():
game.asteroids = []
for i in range(2 + game.level):
game.asteroids.append(Asteroid((WIDTH, HEIGHT)))
def __init__(self, **kw):
super(Engine,self).__init__(**kw)
self.player = Player()
self.monsters = [genmonster(self._level) for i in range(self._level)]
self._map = Map(player = self.player,monsters = self.monsters,
_level = self._level,_Z = self._maze)
class Engine(EventDispatcher):
"""This needs a docstring"""
_level = NumericProperty(1)
_map = ObjectProperty(None)
monsters = ListProperty([])
player = ObjectProperty(None,allownone = True)
debug = BooleanProperty(False)
outputfunc = ObjectProperty(None)
_maze = ObjectProperty(None,force_dispatch = True)
def __init__(self, **kw):
super(Engine,self).__init__(**kw)
self.player = Player()
self.monsters = [genmonster(self._level) for i in range(self._level)]
self._map = Map(player = self.player,monsters = self.monsters,
_level = self._level,_Z = self._maze)
def __setstate__(self,state):
self._map.__setstate__(state["map"])
self.player.__setstate__(state["player"])
self._level = state["level"]
for monster,mstate in zip(self.monsters,state["monsters"]):
monster.__setstate__(mstate)
def __getstate__(self):
return {"map":self._map.__getstate__(),"player":self.player.__getstate__(),
"monsters":[m.__getstate__() for m in self.monsters],"level":self._level}
def parse(self,text):
if text in "adsw":
self.move("adsw".index(text))
if text in "f":
for x,y in self.player.loe:
if self._map[x,y]:
break
for m in self.monsters:
if m.coords == [x,y]:
self.attack(self.player,m)
break
def nxtlevel(self):
self._level += 1
self.reset(False)
self.player.xp += 10
self.player.torches += 2
def cleanup(self):
""""""
for monster in self.monsters:
if monster.hp <= 0:
self.player.xp += (monster.level * 5) * self.player.exp
self.player.gold += (monster.level * 10) * self.player.goldplus
if dLife.roll() == 1:
life = 20
maxhp = getattr(self.player,"maxhp")
while True:
if self.player.hp + life > maxhp:
life -= 1
else:
break
if life > 0:
pass
self.outputfunc("+{} hp".format(life))
self.player.hp += life
self.monsters = filter(lambda m: m.hp > 0,self.monsters)
self._map.monsters = self.monsters
if self.player.coords == self._map.exit:
self.nxtlevel()
return
if self.player.hp <= 0:
self.player._alive = False
#player dead
#replay = raw_input("Retry? y/n: ")
#if replay == "y":
# self.reset(True)
# self._map.reset(1)
#else:
# sys.exit()
else:
self.player.lvlup()
def reset(self,player):
if player:
self.player.reset()
self.monsters = [genmonster(self._level) for i in range(self._level)]
self._map.monsters = self.monsters
self._map.reset(self._level)
def attack(self,atk,defend):
""""""
if ranf() <= atk.accuracy:
hit = atk.attack - defend.defense
if type(atk) == Player and self.player.equipped["Weapon"].stat.get("backstab",0) == 1:
hit = atk.attack*3
if ranf < 0.05:
hit = hit*2
if hit < 0:
hit = 0
defend.hp -= hit
self.outputfunc(" A Hit! {} has {} hp remaining".format(defend.name,defend.hp))
else:
self.outputfunc("{} missed!".format(atk.name))
def move(self, direction):
dx,dy = facing(self.player,direction)
if not self._map.passable(self.player.mapx + dx,self.player.mapy + dy):
return
if (self.player.mapx + dx,self.player.mapy + dy) == self._map.entrance:
self.outputfunc("You bang on the door")
return
if (self.player.mapx + dx,self.player.mapy + dy) == self._map.exit and direction != 3:
return
self.player.move(dx, dy)
def monaction(self):
for monster in self.monsters:
monster.ai(self._map,self)
WIDTH = 600
HEIGHT = 480
FPS = 60
# Screen
screen = pygame.display.set_mode((WIDTH, HEIGHT))
clock = pygame.time.Clock()
# Title and icon of the windows
pygame.display.set_caption("Space Invaders")
# Instantiate sprites
player = Player(path='media/link',
tiles_per_move=8,
frames=5,
speed=5,
inf_scroll=False,
surface=screen,
pos=(100, 100))
enemy = Enemy(screen, inf_scroll=True)
enemies = pygame.sprite.Group(enemy)
all_sprites = pygame.sprite.Group(player, enemies)
# Game loop
running = True
iddle_move = 'IDDLE_DOWN'
while running:
# Set the FPS
clock.tick(FPS)