def initThings(self):
WIDTH, HEIGHT = self.state.size
self.player1 = c.Player(Game.color1, WIDTH / 2 - WIDTH / 4, HEIGHT / 2,
180, 'left')
self.player2 = c.Player(Game.color2, WIDTH / 2 + WIDTH / 4, HEIGHT / 2,
0, 'right')
self.blackhole = c.GravityWell(WIDTH / 2, HEIGHT / 2, 15, 5.5)
self.things = [self.player1, self.player2, self.blackhole]
def createPlayers(amountOfPlayers):
allPlayers.append(
classes.Player(input('Enter the name of player 1: '), True))
for i in range(amountOfPlayers - 1):
allPlayers.append(
classes.Player(
input('Enter the name of player ' + str(i + 2) + ' : '),
False))
def capture_data():
for i in range(10000):
game = classes.Game()
players = [classes.Player("P1"), classes.Player("P2")]
game.start_game(players)
game_result, turn_results = game.run_game(players)
for c in game_cols:
game_data[c].append(game_result[c])
del game
del players
def test_no_winner(noWinnerInputSequence):
player1 = classes.Player("Henk", "X")
player2 = classes.Player("Ali", "O")
player1.otherPlayer = player2
player2.otherPlayer = player1
game = classes.Game(player1, player2)
def mock_input(s):
return noWinnerInputSequence.pop(0)
classes.input = mock_input
game.play()
assert game.getWinner() == None
def choosePlayer():
try:
os.system('clear')
name = input('Please enter your name: ')
os.system('clear')
print('''
1. Basic Player: Damage:{} Damage Varience:{} Health:{} Stamina:{} Max Stamina:{} Desc:{}
'''.format(classes.Player.damage, classes.Player.damageVar, classes.Player.health, classes.Player.stamina, classes.Player.max_stamina, classes.Player.desc))
print('''
2. Brute: Damage:{} Damage Varience:{} Health:{} Stamina:{} Max Stamina:{} Desc:{}
'''.format(classes.Brute.damage, classes.Brute.damageVar, classes.Brute.health, classes.Brute.stamina, classes.Brute.max_stamina, classes.Brute.desc))
print('''
3. Agile: Damage:{} Damage Varience:{} Health:{} Stamina:{} Max Stamina:{} Desc:{}
'''.format(classes.Agile.damage, classes.Agile.damageVar, classes.Agile.health, classes.Agile.stamina, classes.Agile.max_stamina, classes.Agile.desc))
action = input("Please select your class: ")
if action == '1':
player = classes.Player(str(name))
if action == '2':
player = classes.Brute(str(name))
if action == '3':
player = classes.Agile(str(name))
return player
except Exception as e:
print('menu.py - choosePlayer')
print('Exception:',e)
input('Press enter to continue')
def proccesCharacter(x, y):
if level[y][x] == '#':
classes.Wall(x * 32, y * 32)
elif level[y][x] == '@':
classes.Player(x * 32, y * 32)
elif level[y][x] == 'M':
classes.Monster(x * 32, y * 32)
def AfterLife():
# Screen setup
screen = window.setWindow()
player = classes.Player()
stage = classes.Stage()
enemy = classes.Enemy()
# Screen update rate
clock = pygame.time.Clock()
# Main game loop
running = True
while running:
# Screen update rate
clock.tick(60)
# Event listener loop
for event in pygame.event.get():
# Game controls
player.movimientos(event, stage)
# Terminate game when window is closed
if event.type == pygame.QUIT:
running = False
# Game Graphics
stage.pintarFondo(stage.fondos, screen)
enemy.spawn(stage, player)
enemy.pintarEnemigo(screen, stage, player)
player.pintarJugador(player.estado, screen, stage)
enemy.move(screen, stage, player)
player.HUD(screen, stage, enemy)
pygame.display.update()
def test_occupied_state():
player = classes.Player("testplayer", "x")
field = classes.Field()
field.occupy(player)
assert field.isOccupied()
assert field.isOccupiedByPlayer(player)
async def add_players(ctx, *, arg):
global sess
if sess == None or sess.phase != 0:
return
player_list = [x.strip() for x in arg.split(',')]
for p in player_list:
sess.players.append(classes.Player(p))
await ctx.send(f'Successfully added to the player list.')
def test_is_not_winner(field1, field2, field3):
player = classes.Player("testplayer", "x")
fields = [classes.Field() for i in range(9)]
fields[field1].occupy(player)
fields[field2].occupy(player)
fields[field3].occupy(player)
assert not player.isWinner(fields)
def load_level(self, level_json):
self.filename = level_json
with open(level_json, "r") as f:
jsondata = json.load(f)
self.mapobj.set_map(jsondata["map"])
if "objects" in jsondata.keys():
self.process_objects(jsondata["objects"])
self.player = classes.Player(jsondata["spawn_point"][0],
jsondata["spawn_point"][1])
def fight():
global q, player, monster
load.load_game()
player = cl.Player()
monster = cl.Dragon()
while True:
if player.hp < 1:
print(c.yellow + "You Died!")
t.sleep(1)
ter = input("Do you want to keep playing, or quit? (1), (2)" +
c.reset + " >>>" + c.violet).strip()
if ter == '1':
break
elif ter == '2':
exit()
else:
break
elif monster.hp < 1:
print(c.yellow + "You won!")
cl.Player.gold += 100000
save.save_game()
t.sleep(1)
print("Blinding light begins too engulf you.")
t.sleep(1.25)
print(c.clear)
print(".")
t.sleep(1)
print(c.clear)
print("..")
t.sleep(1)
print(c.clear)
print("...")
t.sleep(1)
print(c.clear)
print("You awaken.")
t.sleep(1.5)
print(c.clear)
credits.roll()
exit()
else:
print(c.clear)
print(c.blue + player.name + str(" HP = ") + str(player.hp) +
str(": ") + player.name + str(" MP = ") + str(player.mp))
print(c.red + monster.mname +
str(" HP = " + str(monster.hp) + str(": ") + monster.mname +
str(" MP = ") + str(monster.mp)))
q = input(c.reset + "Attack(1) or Heal(2)? >>>" +
c.violet).strip().lower()
if player.agi >= monster.agi:
pmove()
scanner()
ai()
elif monster.agi > player.agi:
ai()
scanner()
pmove()
def initThings(self):
WIDTH, HEIGHT = self.state.size
self.things = []
holes = random.randrange(1, 4)
for i in range(holes + 1):
(x, y) = self.getLocation()
rad = random.randrange(0, 30)
pow = random.uniform(2.5, 7.5)
self.things.append(c.GravityWell(x, y, rad, pow))
(x, y) = self.getLocation()
rot = random.randrange(0, 360)
self.player1 = c.Player(Game.color1, x, y, rot, 'left')
self.things.append(self.player1)
(x, y) = self.getLocation()
rot = random.randrange(0, 360)
self.player2 = c.Player(Game.color2, x, y, rot, 'right')
self.things.append(self.player2)
def start_game():
"""Основной цикл игры"""
music_repeat = pygame.USEREVENT + 1
time_spawn_enemy = pygame.USEREVENT + 2
level_end_timer = pygame.USEREVENT + 3
can_end_level = True
init_music()
pygame.time.set_timer(music_repeat, 42736)
pygame.time.set_timer(time_spawn_enemy, 10000)
global_perms.PLAYER = classes.Player(0, 0)
enemy_pos, base, count_enemy = launch_level()
while global_perms.GAME_RUNNING:
for event in pygame.event.get():
if event.type == pygame.QUIT:
terminate()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pause_game()
else:
global_perms.PLAYER.action = event.key
elif event.type == pygame.KEYUP:
if event.key == global_perms.PLAYER.action:
global_perms.PLAYER.action = None
elif event.type == level_end_timer:
pygame.time.set_timer(level_end_timer, 0)
global_perms.LEVEL_ID += 1
if global_perms.LEVEL_ID == global_perms.MAX_LEVEL:
global_perms.GAME_RUNNING = False
else:
end_level_screen()
can_end_level = True
enemy_pos, base, count_enemy = launch_level()
elif event.type == time_spawn_enemy:
i = len(
enemy_pos) if len(enemy_pos) < count_enemy else count_enemy
for j in range(i):
pos = enemy_pos[j]
classes.Enemy(pos[0] * 32, pos[1] * 32,
global_perms.ALL_SPRITES,
global_perms.ENEMY_GROUP)
count_enemy -= 1
elif event.type == music_repeat:
pygame.mixer.music.play()
if len(global_perms.ENEMY_GROUP) == count_enemy == 0 and can_end_level:
pygame.time.set_timer(level_end_timer, 5000)
can_end_level = False
update_and_draw_screen()
draw_texts(count_enemy)
pygame.display.flip()
global_perms.CLOCK.tick(global_perms.FPS)
if global_perms.IS_GAME_OVER:
return 1
else:
return 0
def add_to_db(self, name, group):
self.root.admin['1'].latest_key += 1
if group == "Building":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Building()
elif group == "Location":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Location()
elif group == "Lodging":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Lodging()
elif group == "Player":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Player()
elif group == "NonPlayer":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.NonPlayer()
elif group == "Monster":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Monster()
elif group == "Animal":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Animal()
elif group == "Armour":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Armour()
elif group == "Weapon":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Weapon()
elif group == "Gear":
self.root.mainline[str(self.root.admin['1'].latest_key)] = c.Gear()
elif group == "Food":
self.root.mainline[str(self.root.admin['1'].latest_key)] = c.Food()
elif group == "Magic":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Magic()
elif group == "Spell":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Spell()
elif group == "Skill":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Skill()
elif group == "Quest":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Quest()
elif group == "Encounter":
self.root.mainline[str(
self.root.admin['1'].latest_key)] = c.Encounter()
else:
print("group unknown")
self.root.mainline[str(self.root.admin['1'].latest_key)].name = name
transaction.commit()
def main():
""" Fonction principal du programme """
pygame.init()
pygame.display.set_caption("Projet 3: Aide Mc Gyver")
background = pygame.image.load("Pictures/Background.bmp")
cote = pygame.image.load("Pictures/font_cote.bmp")
size = (550, 450)
window = pygame.display.set_mode(size)
window.blit(background, (0, 0))
window.blit(cote, (450, 0))
grille = json.load(open("grille.json"))
func.draw_grille(window, grille)
player = classes.Player()
player.generate_player(window)
item = classes.Item()
item.generate_item(window, grille)
game = True
while game:
for event in pygame.event.get():
if event.type == pygame.QUIT:
game = False
elif event.type == pygame.KEYDOWN:
window.blit(background, (0, 0))
func.draw_grille(window, grille)
if event.key == K_RIGHT:
player.move_player(window, 30, 0, grille, item.win)
elif event.key == K_LEFT:
player.move_player(window, -30, 0, grille, item.win)
elif event.key == K_UP:
player.move_player(window, 0, -30, grille, item.win)
elif event.key == K_DOWN:
player.move_player(window, 0, 30, grille, item.win)
if player.wins is False:
item.check_item(
(player.coord_player[0], player.coord_player[1]))
item.draw_item(window)
if player.wins is True:
game = False
pygame.display.flip()
time.sleep(3)
pygame.quit()
def return_players(self):
"""
:return:
"""
playerlist = []
for player in self.playersTable.all():
lname = player['lname'].capitalize()
fname = player['fname'].capitalize()
bdate = player['bdate']
genre = player['genre']
elo = player['elo']
playerlist.append(classes.Player(fname, lname, bdate,
genre, elo))
return playerlist
def __init__(self):
pygame.init()
self.window = pygame.display.set_mode(
(game_settings.WIDTH, game_settings.HEIGHT))
self.clock = pygame.time.Clock()
self.dimension = None
self.map_array = map_world.map_array
self.player = classes.Player(
(game_settings.WIDTH // 2, game_settings.HEIGHT // 2), 4, 0.04)
self.walls = map_world.walls
self.walls_cords = map_world.walls_cord
self.rays = []
self.floor = classes.Floor(game_settings.COLORS['orange'])
def process_objects(self, json_objects, load=False):
objects = []
for obj in json_objects:
tile = classes.Tile(0, 0)
if obj["tile"] == "Player":
tile = classes.Player(obj["x"], obj["y"])
self.player = tile
else:
print("obj:", obj)
tile = getattr(sys.modules[obj["module"]],
obj["tile"])(obj["x"], obj["y"])
if load:
tile.load_json(obj)
objects.append(tile)
self.level.objects = objects
def setUpPlayer(playerNr):
playerName = ""
playerMark = ""
def PlayerNamePattern():
return re.compile("^[a-zA-Z]+$")
def PlayerMarkPattern():
return re.compile("^.{1}$")
while not PlayerNamePattern().match(playerName):
playerName = input(f"Player {playerNr} name (just letters):")
while not PlayerMarkPattern().match(playerMark):
playerMark = input(f"Player {playerNr} choose mark (1 char):")
return classes.Player(playerName, playerMark)
def main():
global player
player = c.Player("Иван", "Иванов", 1, 100, 2)
player.print_stats()
def fight():
def create_enemy():
global enemy
enemy = c.Enemy(1)
enemy.print_stats()
def battle(player, enemy):
enemy.change_stats(player.attack)
create_enemy()
battle(player, enemy)
fight()
def reset_level(*args):
"""
respawn player and rebuild player if player dies
:param args:
:return:
"""
# unpackage arguments
screen, player, level, current_level, platforms, bullets, blocks,\
entities, enemies, enemy_sprites, Platform,\
block_types, collision_blocks, collision_block_sprites, indestructibles, SPAWN_POINT_LEVEL,\
coins, coin_sprites = (x for x in args)
# reset sprites and re-add player to game
platforms = []
indestructibles.empty()
entities.empty()
blocks.empty()
bullets.empty()
collision_blocks = []
collision_block_sprites.empty()
enemy_sprites.empty()
enemies = []
coins = []
coin_sprites.empty()
# build up arg list for build_level function
args = current_level, level, enemies, enemy_sprites, platforms, blocks,\
entities, Platform, block_types, collision_blocks,\
collision_block_sprites, indestructibles, coins, coin_sprites
# rebuild level
platforms, blocks, entities, enemies, enemy_sprites,\
collision_block_sprites, indestructibles, collision_blocks,\
coins, coin_sprites = build_level(*args)
# respawn player at these coordinates
player.kill()
x, y = SPAWN_POINT_LEVEL[current_level][0], SPAWN_POINT_LEVEL[current_level][1]
player = classes.Player(x, y)
entities.add(player)
return player, platforms, blocks, collision_blocks, collision_block_sprites,\
entities, enemies, enemy_sprites, indestructibles, coins, coin_sprites
def get_players(n_players):
"""Return dictionary with list of 2 to 8 players.
Parameter
---------
n_players : int
Number of players in game
Return
------
dict
Dictionary of players
"""
if n_players < 2 or 8 < n_players:
raise ValueError(
'A game must have between 2 to 8 players. You input {} players.'.
format(n_players))
return {classes.Player(p) for p in range(n_players)}
def rankTeamList(teamFile):
ranking = []
teams = open(teamFile, "r")
teamNumber = -1
for line in teams:
if "|" not in line:
if teamNumber >= 0:
ranking[teamNumber][0].calculateRank()
ranking[teamNumber][1] = ranking[teamNumber][0].getRank()
team = classes.Team(line)
teamData = [team, 0]
ranking.append(teamData)
teamNumber += 1
else:
playerData = line.split("|")
player = classes.Player(playerData[0], int(playerData[1]))
ranking[teamNumber][0].addMember(player)
ranking[teamNumber][0].calculateRank()
ranking[teamNumber][1] = ranking[teamNumber][0].getRank()
return sorted(ranking, key=lambda tup: tup[1])
def dict_to_session(dct):
"""Converts a session JSON dict back to a session object."""
session = classes.Session(dct['name'])
session.sets = set(dct['sets'])
session.banlist = set(dct['banlist'])
session.players = []
for p in dct['players']:
player = classes.Player(p['name'])
player.uid = p['uid']
player.sets = set(p['sets'])
player.decklist = p['decklist']
session.players.append(player)
session.pick_draft = dct['pick_draft']
session.exclusives = dct['exclusives']
session.taken = dct['taken']
session.num_picks = dct['num_picks']
session.round_num = dct['round_num']
session.pick_num = dct['pick_num']
session.curr_player = dct['curr_player']
session.dl_submissions = dct['dl_submissions']
session.phase = dct['phase']
return session
def testCards():
noCards = cl.Deck.MIN_NO_CARDS
player1 = cl.Player(name='Player1', deck=Deck(noCards))
player2 = cl.Player(name='PlayerC', deck=Deck(noCards), computer=True)
def init_player(starting_room):
""" Initializes player object """
player = classes.Player("Ilswyn", starting_room)
return player
" MP: " + str(player.mpu)) #player's color theme is blue
print(c.red + enemy.name + " HP: " + str(enemy.hp) + " " + enemy.name +
" MP: " + str(enemy.mpu)) #enemy's is red
global prompt
prompt = input(c.yellow + "Attack(1), Heal(2) " + c.base2 + ">>>" +
c.magenta).strip()
agiScan()
def enemyMove():
move = randint(1, 2)
if move == 1:
enemyAttack()
elif move == 2:
enemyHeal()
def run():
global player, monster
while True:
fight()
if __name__ == "__main__":
cl.Player = cl.DefaultPlayer
cl.Enemy = cl.Slime
player = cl.Player()
enemy = cl.Enemy()
player.name = "Jon Appleseed" #if player doesn't have a name, make it Jon Appleseed.
run()
import functions
import embeds
logging.basicConfig(level=logging.INFO)
try:
discord.opus.load_opus('libopus-0.x64.dll')
except Exception:
discord.opus.load_opus('libopus-0.x86.dll')
Bot = commands.Bot(command_prefix=config.prefix,
description=config.description)
Bot.owner_id = config.OwnerID
Bot.remove_command('help')
Player = classes.Player()
@Bot.event
async def on_ready():
'''Executes when the is up and running'''
musicSpamChannel = Bot.get_channel(config.MusicSpamChannelID)
print('{} reporting for duty!'.format(Bot.user.display_name))
await musicSpamChannel.send('{} reporting for duty!'.format(
Bot.user.display_name))
@Bot.event
async def on_command_error(ctx, exception):
'''Prints the command exception to the console'''
print(exception)
h = 600
win = pg.display.set_mode((w, h))
pg.display.set_caption(
"La vague 126 vas vous surprendre !!! Je n'y aurai jamais cru")
pg.display.set_icon(ressources.iconeI.convert_alpha())
clock = pg.time.Clock()
gameManager = classes.GameManager()
bckgrd = ressources.bckgI.convert()
run = True
gameRunning = True
while run:
#Initialisation du jeu
gameOverRun = True
player = classes.Player(w / 2, h / 2, w, h)
enemies = []
blyat = []
cooldown = 0
omg = classes.OMG()
circle = classes.Circle()
scared = classes.ScaredSmiley()
#Affiche le background
win.blit(bckgrd, (0, 0))
pg.display.flip()
#vagues
wave = 0
waveFinished = False
