def initialize():
"""
Instantiates objects from actors class, receives verified player name input, and lists enemies in the field
:return: Objects required for main game loop (d6 only used for stats allocation in this version)
"""
# initialize_combatants
d6 = actors.Die(6)
d8 = actors.Die(8)
d20 = actors.Die(20)
# verify player name input
player_name = ''
while not player_name:
player_name = input(
'What is your name? ') # input "Kirito" for thematic continuity
if not player_name:
print('Input not recognized. Please re-enter a name.\n')
player = actors.Player(player_name, d6.stats_rolls())
enemies = [
actors.Combatant('Heathcliffe', d6.stats_rolls()),
actors.Combatant('Oberon', d6.stats_rolls()),
actors.Combatant('Death Gun', d6.stats_rolls()),
]
# display combatants
print("This round's combatants are... \n")
time.sleep(1)
print(player)
player.look(enemies)
return d20, d8, enemies, player
def make_player(self):
""" Instantiate Player object """
self.player = actors.Player((400, 400), self.screen_size,
self.obstacles, self.color_objs)
for i in range(14, 16): # range of x_coord cells where the player spawns
for j in range(10,12): # range of y_coord cells where player spawns
self.grid_cells[(i,j)].occupied = True # marks cells as occupied so that nothing else spawns there
def AddPlayer(self,pos,fire_extinguisher = False,angle=0):
bl = self.absolute.size*pos
player = actors.Player(self.physics,bl,angle)
if fire_extinguisher:
player.EquipFireExtinguisher()
self.players.append(player)
if len(self.players) == 1:
player.Select()
self.selected_player = player
def __init__(self):
self.screen = pg.display.get_surface()
self.screen_rect = self.screen.get_rect()
self.clock = pg.time.Clock()
self.fps = 60
self.done = False
self.all_sprites = pg.sprite.Group()
self.player = actors.Player(self.screen_rect.center, 3)
self.all_sprites.add(self.player)
self.make_npcs()
def __init__(self):
super().__init__()
self.sceneTemplates = []
self.pendingScenes = []
self.state = {}
self.actors = {}
self.player = actors.Player()
self.emperor = actors.Emperor()
self.advisor = actors.Advisor()
def run_main_loop(n):
iter = 1
while (iter <= n):
# assign doors
doors = game.assign_doors()
# get player's name who wants to switch (we'll call player A)
if iter == 1:
player_A_name, player_B_name = get_player_names()
player_A = actors.Player(player_A_name)
player_A.strategy('switch')
player_B = actors.Player(player_B_name)
player_B.strategy('stay')
#get player's choice
door_choice_id = choose_door()
#Reveal goat
goats = get_goats(doors, initial_choice=door_choice_id)
random.shuffle(goats)
goat = goats[0]
#get remaining door
rmn_door = game.remaining_door(door_choice_id, goat, doors)
player_A.door_choice(rmn_door.id)
player_B.door_choice(door_choice_id)
#get winning door
prize_door = winning_door(doors)
#update records
if player_A.choice == prize_door.id:
player_A.num_wins += 1
else:
player_B.num_wins += 1
if iter == n:
return player_A, player_B
iter += 1
def __init__(self, name, parent):
self.size = Point(120, 50)
self.data = [[TileTypes.GRASS for i in xrange(self.size.y)]
for j in xrange(self.size.x)]
self.object_cache = {}
self.object_list = []
self.actors = []
self.doors = []
self.player = None
self.parent = parent
y = self.size.y - 1
player_pos = None
with open(name) as f:
last = None
for line in f:
line = line.strip('\n')
if len(line) < self.size.x:
line += ' ' * (self.size.x - len(line))
if len(line) > self.size.x:
line = line[:self.size.x]
for inv_x, tile in enumerate(line[::-1]):
x = self.size.x - 1 - inv_x
#try:
if 1:
#hack, also give the adjacent tile so we know what kind of background to put it on...
td = TileDataFactory(self, self.input_mapping[tile],
Point(x, y), last, parent)
last = self.input_mapping[tile]
for tile_x in xrange(td.size.x):
for tile_y in xrange(td.size.y):
if self.data[x + tile_x][
y + tile_y] != TileTypes.GRASS:
self.data[x + tile_x][y + tile_y].Delete()
self.data[x +
tile_x][y +
tile_y] = TileTypes.GRASS
if self.data[x + tile_x][
y + tile_y] == TileTypes.GRASS:
self.data[x + tile_x][y + tile_y] = td
if self.input_mapping[tile] == TileTypes.PLAYER:
player_pos = Point(x + 0.2, y)
if self.input_mapping[tile] == TileTypes.ENEMY:
self.parent.enemy_positions.append(
Point(x + 0.2, y))
#except KeyError:
# raise globals.types.FatalError('Invalid map data')
y -= 1
if y < 0:
break
if not player_pos:
raise Exception('No player defined')
self.player = actors.Player(self, player_pos)
self.actors.append(self.player)
def place_sprites(self):
for item in self.tile_map['ItemLayer'].objects:
if item.name == "Start":
self.player = actors.Player(item.position)
self.add(self.player)
if item.name == "Finish":
self.finish_position = item.position
if item.name == "Bone_Normal":
bone_normal = actors.Consumable(item.position, 'assets/bone_basic_small.png')
self.add(bone_normal)
if item.name == "Tree":
tree = actors.Tree(item.position, 'assets/korona.png')
self.add(tree)
def __init__(self):
"""
This is the main class that runs the program.
"""
self.screen = pg.display.get_surface()
self.screen_rect = self.screen.get_rect()
self.clock = pg.time.Clock()
self.fps = 60
self.keys = pg.key.get_pressed()
self.done = False
ship = random.choice(list(prepare.GFX["ships"].values()))
self.player = actors.Player((0, 0), ship)
self.level = level.Level(self.screen_rect.copy(), self.player)
def test_actor(self):
self.player = actors.Player()
self.player.name = 'Player'
self.player.get_component('physics').body.position = (100, 100)
self.actors.add_actor(self.player)
for y in range(350, 600, 50):
block = actors.Block()
block.name = 'Block %d' % y
block.get_component('physics').body.position = (350, y)
self.actors.add_actor(block)
platform = actors.MovingPlatform()
platform.name = 'Platform'
platform.get_component('physics').body.position = (900, 144)
self.actors.add_actor(platform)
def run_main_loop():
# print header
print_header()
#get player name
name = input("What's is your name? ")
player = actors.Player(name=name)
print("Hello, {}!".format(name))
#assign doors
doors = assign_doors()
#ask player to choose a door
first_choice = get_players_first_choice()
player.door_choice(first_choice)
#reveal goat
goat_doors = get_goat_doors(player, doors)
goats = get_goat(goat_doors, first_choice)
goat = goats[0]
print(goat)
#get remaining doors
rmn_door = remaining_door(first_choice, goat, doors)
print("Door {} remains".format(rmn_door.id))
#ask play if he/she would like to switch
answer = decide_to_switch()
player.strategy(answer)
#determine players final choice
final_choice_id = players_final_choice(player, rmn_door)
player.door_choice(final_choice_id)
print("You choice is Door Number {}".format(player.choice))
final_door = get_final_door(player, doors)
#final_door = final_door[0]
print()
print(final_door)
print_outcome(final_door)
def create_player(self):
runner_pos = CellVector(self.get_syms_pos('&')[0])
runner_xy = runner_pos.pos_to_xy()
self.player = actors.Player(runner_xy[0], runner_xy[1] + 44)
self.add(self.player)
def __init__(self, name, parent):
global naked_zombie
self.size = Point(128, 92)
self.data = [[TileTypes.AIR for i in xrange(self.size.y)]
for j in xrange(self.size.x)]
self.object_cache = {}
self.object_list = []
self.actors = []
self.doors = []
self.player = None
self.parent = parent
tc = globals.atlas.TextureSpriteCoords('sky.png')
sky_size = globals.atlas.SubimageSprite('sky.png').size
tc_repeat = self.size.y * globals.tile_dimensions.y / sky_size.y
self.sky_quads = []
for i in xrange(tc_repeat):
q = drawing.Quad(globals.quad_buffer, tc=tc)
bl = (Point(0, self.size.y - 8) * globals.tile_dimensions) + Point(
i * sky_size.x, 0)
tr = bl + sky_size
q.SetVertices(bl, tr, -0.1)
self.sky_quads.append(q)
y = self.size.y - 1
#with open ('level.txt') as f:
if 1:
#for line in f:
for line in self.filedata.splitlines():
line = line.strip('\n')
if len(line) < self.size.x:
line += ' ' * (self.size.x - len(line))
if len(line) > self.size.x:
line = line[:self.size.x]
for inv_x, tile in enumerate(line[::-1]):
x = self.size.x - 1 - inv_x
#try:
if self.input_mapping[tile] in [
TileTypes.ZOMBIE, TileTypes.MUTANT_ZOMBIE
]:
print x, y, self.data[x + 1][y].name
TileData.texture_names[TileTypes.ZOMBIE] = self.data[
x + 1][y].name
TileData.texture_names[
TileTypes.MUTANT_ZOMBIE] = self.data[x + 1][y].name
if self.data[x + 1][y].name == 'air':
naked_zombie = True
else:
naked_zombie = False
td = TileDataFactory(self, self.input_mapping[tile],
Point(x, y))
for tile_x in xrange(td.size.x):
for tile_y in xrange(td.size.y):
if self.data[x + tile_x][y +
tile_y] != TileTypes.AIR:
self.data[x + tile_x][y + tile_y].Delete()
self.data[x + tile_x][y +
tile_y] = TileTypes.AIR
if self.data[x + tile_x][y +
tile_y] == TileTypes.AIR:
self.data[x + tile_x][y + tile_y] = td
if self.input_mapping[tile] == TileTypes.PLAYER:
self.player = actors.Player(self, Point(x + 0.2, y))
self.actors.append(self.player)
if self.input_mapping[tile] == TileTypes.ZOMBIE:
zombie = actors.Zombie(self, Point(x + 0.2, y))
self.actors.append(zombie)
if self.input_mapping[tile] == TileTypes.MUTANT_ZOMBIE:
zombie = actors.MutantZombie(self, Point(x + 0.2, y))
self.actors.append(zombie)
if self.input_mapping[tile] == TileTypes.AXE:
axe = actors.AxeItem(self, Point(x + 0.2, y))
self.actors.append(axe)
if self.input_mapping[tile] == TileTypes.PISTOL:
pistol = actors.PistolItem(self, Point(x + 0.2, y))
self.actors.append(pistol)
if self.input_mapping[tile] == TileTypes.BULLETS:
bullets = actors.BulletsItem(self, Point(x + 0.2, y))
self.actors.append(bullets)
if self.input_mapping[tile] == TileTypes.HEALTH:
health = actors.HealthItem(self, Point(x + 0.2, y))
self.actors.append(health)
if self.input_mapping[tile] == TileTypes.SWITCH:
end = actors.EndItem(self, Point(x + 0.2, y))
self.actors.append(end)
#except KeyError:
# raise globals.types.FatalError('Invalid map data')
y -= 1
if y < 0:
break
for i in xrange(len(self.data)):
for j in xrange(len(self.data[i])):
if not isinstance(self.data[i][j], TileData):
self.data[i][j] = TileDataAir('air', Point(i, j))
def __init__(self, name, parent):
self.size = Point(89, 49)
self.data = [[TileTypes.GRASS for i in xrange(self.size.y)]
for j in xrange(self.size.x)]
self.object_cache = {}
self.object_list = []
self.actors = []
self.doors = []
self.player = None
self.parent = parent
self.filedata = """ c ccccccccccccccccccccccccccccccc
c c c
c c c
c c c
c c c
c c c
c c c
c c c
c c c
c c c
c c c
c c c
c c c
c c c
c c c
c +--------d+ c
c |.........| c
c |.........| c
c |.........| c
c +----x----+ c
c ccccccccccccccccccccccccccccccc
c
c
c +-------W--+----+ +---3--------+---+
c |..........|....| |............|ttt|
c |l.l.l.l.l.|....| |............|ttt|
c |..........|....| |............|ttt|
c |l.l.l.l.l.|....| |w...w...w...+-d-+
c |..........|....| |................|
c |l.l.l.l.l.+d+..| |................|
c |............|..| |................|
c |l.l.l.l.l.l.|..| |w...w...w...w...|
c +----------L-+--+ +---d------------+
c
crrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
crrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
crrMrrMrrMrrMrrMrrMrrMrrMrrMrrMrrMrrMrrMrrMrrMrrMrrrMrrMrrMrrMrrM
crrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
crrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr
c rrrmrrr
cccccccccccccccccccccccccsccccb rccccccccccccccccccccccccccccc
c rrrmrrr c
c rrrrrrr c
c rrrmrrr c
c rrrrrrr c
c rrrmrrr c
c rrrprrr c
c rrrmrrr c
c rrrrrrr c
c rrrmrrr c
c rrrrrrr c
"""
y = self.size.y - 1
for line in self.filedata.splitlines():
line = line.strip('\n')
if len(line) < self.size.x:
line += ' ' * (self.size.x - len(line))
if len(line) > self.size.x:
line = line[:self.size.x]
for inv_x, tile in enumerate(line[::-1]):
x = self.size.x - 1 - inv_x
#try:
if 1:
td = TileDataFactory(self, self.input_mapping[tile],
Point(x, y))
for tile_x in xrange(td.size.x):
for tile_y in xrange(td.size.y):
if self.data[x +
tile_x][y +
tile_y] != TileTypes.GRASS:
self.data[x + tile_x][y + tile_y].Delete()
self.data[x + tile_x][y +
tile_y] = TileTypes.GRASS
if self.data[x +
tile_x][y +
tile_y] == TileTypes.GRASS:
self.data[x + tile_x][y + tile_y] = td
if self.input_mapping[tile] == TileTypes.PLAYER:
self.player = actors.Player(self, Point(x + 0.2, y))
self.actors.append(self.player)
if isinstance(td, Door):
if self.input_mapping[
tile] == TileTypes.DOOR_LOCKED_DISH:
parent.dish_door = td
self.doors.append(td)
#except KeyError:
# raise globals.types.FatalError('Invalid map data')
y -= 1
if y < 0:
break
self.AddObject(Dish(Point(42, 31)))
self.AddObject(Bed(Point(62, 22)))
self.AddObject(Bed(Point(71, 22)))
self.AddObject(Bed(Point(62, 17), direction='down'))
self.AddObject(Car(Point(55, 2)))
self.AddObject(Locker(Point(67, 23), '2212', self.parent))
self.AddObject(
Computer(Point(75, 17), terminal.DomsComputer, self.parent))
self.AddObject(
Computer(Point(39, 23), terminal.LabComputer, self.parent))
self.AddObject(
Computer(Point(36, 23), terminal.SignalComputer, self.parent))
self.AddObject(
Computer(Point(50, 31), terminal.FinalComputer, self.parent))
def create_player(self):
player_start = self.scenario.player_start
x, y = player_start
self.add(actors.Player(x, y, ac.Delay(5)))
