def main():
printer = Printer.Printer()
printer.mainMenu()
choice = 0
choice = int(input("Please Enter Your Age:"))
if choice < 19:
printer.denyAccess()
return
else:
print("Access Granted")
turn = "player"
player = Player.Player()
ai = Player.Player()
die = Die.Die()
maxTotal = (choice)
while True:
if turn == "player":
print("die rolling \../")
if player.total == 0:
for i in range(2):
die.roll()
player.addToTotal(die.value)
print(player.total)
else:
printer.playerChoice() #adding class to die roll
pick = input("y/n\n")
print("AI is rolling the dice")
if pick == "y":
die.roll()
player.addToTotal(die.value)
printer.printRollValue(die.value, player.total)
if player.total > maxTotal:
print(
"Player has busted and lost, so sad ( >_< -_- >_< -_-)"
)
break
else:
print("Your Total is : " + str(player.total))
turn = "AI"
else: # AI turn logic
printer.dieRoll(die, ai)
if ai.total >= player.total and ai.total <= maxTotal:
print("AI Wins >_< -_- >_< -_-")
break
elif ai.total > maxTotal:
print("AI busted @-@ you got lucky =^_^= ")
break
else:
pass
print("Thanks for playing! Would You Like To Play Again")
pick = input("y/n\n")
if pick == "y":
return main()
else:
return print("Have A Great Day !! See You Soon")
def __init__(self):
# Initialization
libtcodpy.console_set_custom_font('src/arial10x10.png', libtcodpy.FONT_TYPE_GREYSCALE | libtcodpy.FONT_LAYOUT_TCOD)
libtcodpy.console_init_root(settings.SCREEN_WIDTH, settings.SCREEN_HEIGHT, 'ROGuelike TUTorial', False)
libtcodpy.sys_set_fps(settings.LIMIT_FPS)
self.con = libtcodpy.console_new(settings.SCREEN_WIDTH, settings.SCREEN_HEIGHT)
self.game_map = GameMap(self.con)
player_x, player_y = self.game_map.get_staring_position()
# game objects
self.player = Player(
'Player',
self.con,
player_x, player_y, '@',
fighter=Fighter(hp=15, defense=5, power=5, death_function=player_death))
npc_x, npc_y = self.game_map.get_ending_position()
self.npc = Npc('Trader', self.con, npc_x, npc_y, '@')
self.objects = [self.npc, self.player]
self.npcs = [self.npc]
for monster in self.game_map.place_monsters():
self.objects.append(monster)
if hasattr(monster, 'is_selfmoving') and monster.is_selfmoving:
self.npcs.append(monster)
self.game_state = 'playing'
self.player_action = None
def init():
units = []
player = Player(MAP_SIZE)
units.append(player)
player.set_location((random.randint(0, 12) * 5, random.randint(0, 12) * 5))
player.inital_location = player.location
objective = Objective()
units.append(objective)
objective.set_location(player.location)
while (player.location == objective.location):
objective.set_location(
(random.randint(0, 12) * 5, random.randint(0, 12) * 5))
mine_count = 10
mines = []
for x in range(mine_count):
temp_location = player.location
while (temp_location == player.location) or (temp_location
== objective.location):
temp_location = (random.randint(0, 12) * 5,
random.randint(0, 12) * 5)
mines.append(Mine())
units.append(mines[x])
mines[x].set_location(temp_location)
return units
def __init__(self):
super().__init__()
# Load the screen for the current stage
state = Config.state()
entities = (Player(Colors.VIR),
Enemy(state['color'], state['shoot_delay']))
self.screen_intro = ScreenIntro(entities, state['balls'])
if Config.level == 4:
self.screen_play = ScreenHardcore(entities, state['balls'],
state['max_balls'],
state['max_score'])
else:
self.screen_play = ScreenNormal(entities, state['balls'],
state['max_balls'],
state['max_score'])
# Set the current screen
self.current_screen = self.screen_intro
# Pause sound
self.snd_click = SoundManager.load_sound('snd_click.wav')
# Play the background music
SoundManager.load_music('bgm_stage1.ogg')
def __init__(self, update=True):
super().__init__()
# Repeat cutscene
if not update:
Cutscene.current_cutscene -= 1
ScreenDialog.current_dialog -= 1
SoundManager.load_music('bgm_dialog.ogg')
# Change level
if Cutscene.current_cutscene in (4, 6, 8, 11, 14, 17):
Config.level += 1
# Background
state = Config.state()
self.background = ScreenBackground(
(Player(Colors.VIR), Enemy(state['color'], state['shoot_delay'])))
# Transition
self.transition = False
self.transition_delay = 50
self.snd_transition = SoundManager.load_sound('snd_transition1.wav')
# Set the current screen
if Cutscene.current_cutscene in (1, 4, 8, 11, 14, 17):
self.current_screen = ScreenNarrator()
elif Cutscene.current_cutscene in (3, 6, 7, 10, 13, 16, 19):
self.current_screen = ScreenDialog()
SoundManager.load_music('bgm_dialog.ogg')
else:
self.current_screen = ScreenDialog()
def parse_tournaments_per_month(cls, div, year, month):
tournaments = []
for row in filter(bool, div.findAll("tr")):
try:
start, end = row.findChild(
"td", {"class": "title-content"}).findChild(
"span", {"class": "tourney-dates"}).text.split("-")
winners = {}
print row.select(".tourney-details")
for div in row.select(".tourney-details > div"):
if div.text.strip().strip("\t").strip("\n") == "SGL":
winners["single"] = Player(
name=div.findChild("a").text.strip().strip(
"\t").strip("\n"),
atp_url="%s/%s" % (
cls.URL, div.findChild("a").attrs["href"])
)
elif div.text.strip().strip("\t").strip("\n") == "DBL":
winners["double"] = (
Player(
name=a.text.strip().strip(
"\t").strip("\n"),
atp_url="%s/%s" % (
cls.URL, a.attrs["href"])
) for a in div.findChildren("a")
)
tournaments.append(Tournament(
name=row.findChild(
"td", {"class": "title-content"}).findChild("a").text,
year=year,
month=month,
atp_url="%s/%s" % (cls.URL, row.findChild(
"td", {"class": "title-content"}).findChild(
"a").attrs["href"]),
start=start.strip().strip("\t").strip("\n"),
end=end.strip().strip("\t").strip("\n"),
location=row.findChild(
"td", {"class": "title-content"}).findChild(
"span", {
"class": "tourney-location"
}).text.strip().strip("\t").strip("\n"),
winners=winners
))
except (AttributeError, ValueError):
continue
return tournaments
def __init__(self, log, player_count=2):
self.log = log
self.log.info('New session started.')
self.community_cards = []
self.deck = deque(self.ALL_CARDS)
self.players = []
for i in range(player_count):
self.players.append(Player(position=i))
def __init__(self, screen):
super(RunPlay, self).__init__('Run Play')
self.player = Player(coord=player_coord, speed=12, screen=screen)
self.spawner = Spawner()
self.game = game = Game(screen=screen, width=800, length=600)
self.screen = screen
self.time = time.time()
self.score = 0
def run_game_loop(self):
is_game_over = False
x_dir = 1
y_dir = 0
snek = Player(100, 230)
food = Food(400, 230)
while not is_game_over:
for event in pygame.event.get():
if event.type == pygame.QUIT:
is_game_over = True
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
if y_dir != -1:
x_dir = 0
y_dir = 1
elif event.key == pygame.K_DOWN:
if y_dir != 1:
x_dir = 0
y_dir = -1
elif event.key == pygame.K_RIGHT:
if x_dir != -1:
x_dir = 1
y_dir = 0
elif event.key == pygame.K_LEFT:
if x_dir != 1:
x_dir = -1
y_dir = 0
elif event.type == pygame.KEYUP:
pass
self.game_screen.fill(GRAY_COLOR)
snek.draw_snek(self.game_screen)
snek.move(x_dir, y_dir)
food.draw(self.game_screen)
if snek.is_out_of_bounds(self.resolution):
is_game_over = True
pygame.display.update()
clock.tick(self.TICK_RATE)
if snek.is_eating_himself():
is_game_over = True
pygame.display.update()
clock.tick(self.TICK_RATE)
if snek.check_for_food(food):
food.randomize()
#self.TICK_RATE += 1
pygame.display.update()
clock.tick(self.TICK_RATE)
def run_simulation(args):
number_of_players = int(args[0])
rounds = int(args[1])
player_args = [int(i) for i in args[2:]]
players = []
for i in range(number_of_players):
buying_strategy = player_args[i * 3]
upgrading_strategy = player_args[i * 3 + 1]
trading_strategy = player_args[i * 3 + 2]
players.append(
Player(i, buying_strategy, upgrading_strategy, trading_strategy))
game = Game(players, rounds)
game.run()
def create_world():
global pacman, ghost, item_set, world_map, font_guide, font_life
pacman = Player()
ghost = [
Enemy(35, 565, 1),
Enemy(565, 35, 2),
Enemy(565, 565, 3),
Enemy(350, 390, 4)
]
# item_set = [item(100, 100, 0), item(200, 200, 0), item(300, 300, 0), item(400, 400, 0)
# ,item(100, 200, 4), item(200, 300, 5), item(300, 400, 6), item(400, 500, 7)]
world_map = map()
font_guide = load_font('resource/Pixel.ttf', 30)
font_life = load_font('resource/CrackMan.ttf', 30)
def __init__(self, save):
# If save is NONE, __init__ is called for default values, otherwise data are loaded from file.
self.player = Player(save)
self.world = World(save)
#Build GUI
self.gui = GUIWindow(self.world.map)
self.gui.after(int(1000 / 20), self.call)
self.gui.bind('<Key>', self.keypress)
self.gui.map.bind('<B1-Motion>', self.map_pan)
self.gui.map.bind('<MouseWheel>', self.map_zoom)
self.gui.run()
def create_players(world, settings):
players = []
for config in settings['players']:
if config['active']:
codes = []
for key in config['controls']:
code = convert_key(key)
if code is None:
raise RuntimeError('Invalid Key: {}'.format(key))
codes.append(code)
player = Player(world, config['colour'], config['name'], [codes[0:2], codes[2:4]])
world.add_object(player)
players.append(player)
return players
def __init__(self, game_width, game_height, agent, user_agent):
# set the game field
self.game_width = game_width
self.game_height = game_height
self.field = {'width': game_width, 'height': game_height}
self.redisClient = redis.Redis(host='127.0.0.1', port=6379, db=0)
self.agent = agent
self.user_agent = user_agent
# generate the player instance
self.player_agent = Player(random.randint(50, self.game_width - 50),
random.randint(50, self.game_height - 50))
self.player_user = Player(random.randint(50, self.game_width - 50),
random.randint(50, self.game_height - 50))
flag = True
x = random.randint(50, self.game_width - 50)
y = random.randint(50, self.game_height - 50)
while (flag):
flag = False
x = random.randint(50, self.game_width - 50)
y = random.randint(50, self.game_height - 50)
position = {'x': x, 'y': y}
if (util.distance(self.player_agent.position, position) <
self.player_user.radius + self.player_agent.radius):
flag = True
self.player_user.position['x'] = x
self.player_user.position['y'] = y
# initialize the map infomation
self.map_info = {'stuffs': [], 'bullets': []}
# initialize the basic infomation of the game
self.score = 0
self.timeout = False
# initialize the agent action
self.initialize(agent)
def __init__(self, level):
super(Game, self).__init__()
self.level = Level.load_level(level)
self.background = Sprite(source='img/background.PNG')
self.size = self.background.size
self.player = None
self.boxes = []
# Initiate the game by creating tiles
Tile.make_tiles(self.size, self.level)
# Add bg widget first to not cover other sprites
self.add_widget(self.background)
# Add proper widgets for every non-empty tile in the Tile.List
for tile in Tile.List:
if tile.type != 'empty':
if Tile.get_tile(tile.number - Tile.V).walkable:
self.add_widget(Sprite(
source=Tile.image_files[tile.type],
pos=(tile.x, tile.y)), index=2)
else:
self.add_widget(Sprite(
source=Tile.image_files[tile.type + '_edge'],
pos=(tile.x, tile.y - SPRITE_EDGE_OFFSET)))
for tile in self.level.boxspawn:
self.boxes.append(Box(tile, self))
self.player = Player(self.level.playerspawn, self)
self.fps_lab = Label(
text='FPS: ' + str(Clock.get_rfps()),
pos=(2, self.height - 110),
font_name=APP_FONT,
font_size=18,
color=(240, 240, 240, 0.8))
self.add_widget(self.fps_lab)
self.add_widget(Label(
text="Level {}".format(self.level.level),
pos=(0, self.height - 80),
font_name=APP_FONT,
font_size=18,
color=(240, 240, 240, 0.8)))
# Schedule an interval for the game update function
Clock.schedule_interval(self.update, 1.0/60.0)
def __init__(self):
self.score = 0
self.graphic = []
self.objects = []
self.shifty = 0
self.player = Player(20, 75, game=self)
for i in range(0, 20):
for j in range(1, 3):
self.objects.append(Enemy(i * 10, j * 10, game=self))
for i in range(0, 40):
self.graphic.append([])
for j in range(0, 80):
if ((j) % 2 == 0 and i == self.shifty):
self.graphic[i].append("A")
else:
self.graphic[i].append(" ")
def main():
"""
Main function of the game
"""
debug = False
pygame.init()
win = pygame.display.set_mode((500, 500))
pygame.display.set_caption("First Game")
player = Player(x=50, y=50, width=40, height=60, velocity=15)
running = True
while running:
pygame.time.delay(100)
for event in pygame.event.get():
if debug:
print(event)
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYUP and event.key == pygame.K_ESCAPE:
running = False
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
if player.x >= 0:
player.x -= player.velocity
if keys[pygame.K_RIGHT]:
if player.x + player.width <= 500:
player.x += player.velocity
if keys[pygame.K_UP]:
if player.y >= 0:
player.y -= player.velocity
if keys[pygame.K_DOWN]:
if player.y + player.height <= 500:
player.y += player.velocity
win.fill((0, 0, 0))
pygame.draw.rect(win, (255, 0, 0), player.get())
pygame.display.update()
pygame.quit()
def __init__(self):
self.tk = Tk()
self.tk.title('Chrome')
self.tk.resizable(0, 0)
self.canvas = Canvas(self.tk,
width=800,
height=200,
bd=0,
highlightthickness=0)
self.canvas.config(bg='black')
self.canvas.pack()
self.player = Player(self.canvas)
self.floor = Floor(self.canvas)
self.obstacles = []
self.current_speed = 5
self.frame_number = 0
def __init__(self, victory=False):
super().__init__()
# Background
state = Config.state()
self.background = ScreenBackground(
(Player(Colors.VIR), Enemy(state['color'], state['shoot_delay'])))
# Screens
self.screen_menu = ScreenMenu(self)
self.screen_options = ScreenOptions(self)
# Set the current screen
self.current_screen = self.screen_menu
# Play the background music
if victory:
SoundManager.load_music('bgm_victory.ogg')
else:
SoundManager.load_music('bgm_menu.ogg')
def __init__(self, gamefile):
"""
takes path to a xml-gamefile and extracts the world
"""
self.gamefile = gamefile
tree = conv.loadworld(gamefile)
self.properties = conv.unpack_properties(tree)
self.player = Player(tree.find('player'), self)
self.rooms = {}
for room in tree.findall('room'):
self.rooms[room.get('id')] = Room(self, room)
self.connections = {}
for connection in tree.findall('connection'):
self.connections[connection.get('id')] = Connection(connection)
# -- WIP -- #
self.eventhandler = EventHandler(self)
self.events = []
for event in tree.find('events').findall('event'):
self.events.append(event.get('id'))
self.eventhandler.events[event.get('id')] = self.eventhandler.parser.parse_xml(event)
def __init__(self,
resolution=(750, 750),
player_velocity=8,
enemy_velocity=2,
laser_velocity=7,
wave_length=5,
player_color='yellow'):
self.window_width, self.window_height = resolution
self.player_velocity = player_velocity
self.enemy_velocity = enemy_velocity
self.laser_velocity = laser_velocity
self.wave_length = wave_length
self.player = Player(300, 630, player_velocity, laser_velocity,
player_color)
self.enemies = []
self.lasers = []
self.level = 0
self.lives = 3
self.max_lives = 3
self.score = 0
self.lost = False
self.cooldown = 10
def __init__(self, seed, size, volume):
# Константы генерации карты
self.SEED = 15
self.SIZE = int(1024 * size)
self.H_MAX = 20
self.SHARP = 2
self.DEPTH = 100
self.PROBABILITY = 1/2
self.H_0 = 12
self.LAKES_NUMBER = int(10*size)
# Инициализируем пайгейм
pygame.init()
self.screen = pygame.display.set_mode((0,0),pygame.FULLSCREEN)
pygame.display.update()
self.clock = pygame.time.Clock()
# Константы игры
self.FPS = 20
self.finished = False
self.BLOCK_SIZE = 20
self.DO_RADIUS = 140
self.inventory_bool = False
self.volume = volume
# Размеры окна
self.WINDOW_X, self.WINDOW_Y = pygame.display.get_surface().get_size()
self.ORIGINAL_WINDOW_X = 1920
self.ORIGINAL_WINDOW_Y = 1080
self.RATIO_X = self.WINDOW_X/self.ORIGINAL_WINDOW_X
self.RATIO_Y = self.WINDOW_Y/self.ORIGINAL_WINDOW_Y
# Подгружаем текстуры карты
self.dirt_grass = pygame.image.load('resources/map/dirt_grass.png')
self.blocks = [[pygame.image.load('resources/map/dirt.png'),
pygame.image.load('resources/map/stone.png')],
[pygame.image.load('resources/map/snow.png'),
pygame.image.load('resources/map/ice.png')]]
self.water = [pygame.image.load('resources/map/water.png'),
pygame.image.load('resources/map/ice_water.png')]
# Подгружаем текстуры персонажа
self.player_animation = [pygame.image.load('resources/player_animation/player_right.png'),
pygame.image.load('resources/player_animation/move_right_1.png'),
pygame.image.load('resources/player_animation/move_right_2.png'),
pygame.image.load('resources/player_animation/player_left.png'),
pygame.image.load('resources/player_animation/move_left_1.png'),
pygame.image.load('resources/player_animation/move_left_2.png')]
# Подгружаем бэкграунд
self.bg = pygame.image.load('resources/bg.png')
self.bg = pygame.transform.scale(self.bg, (self.WINDOW_X, self.WINDOW_Y))
# Подгружаем текстуры инвентаря
self.inventory_image = pygame.image.load('resources/inventory/inventory.png')
self.INVENTORY_IMAGE_SIZE_X = int(1000*self.RATIO_X)
self.INVENTORY_IMAGE_SIZE_Y = int(100*self.RATIO_Y)
self.inventory_image = pygame.transform.scale(self.inventory_image, (self.INVENTORY_IMAGE_SIZE_X, self.INVENTORY_IMAGE_SIZE_Y))
self.tools_invent = [pygame.image.load('resources/inventory/inventory_image/dirt.png'),
pygame.image.load('resources/inventory/inventory_image/stone.png')]
self.TOOLS_INVENT_SIZE_X = int(100*self.RATIO_X)
self.TOOLS_INVENT_SIZE_Y = int(100*self.RATIO_Y)
for i in range(0, len(self.tools_invent)):
self.tools_invent[i] = pygame.transform.scale(self.tools_invent[i], (self.TOOLS_INVENT_SIZE_X, self.TOOLS_INVENT_SIZE_Y))
self.cell = pygame.image.load('resources/inventory/cell.png')
self.CELL_SIZE_X = int(100*self.RATIO_X)
self.CELL_SIZE_Y = int(120*self.RATIO_Y)
self.cell = pygame.transform.scale(self.cell, (self.CELL_SIZE_X, self.CELL_SIZE_Y))
# Подгружаем текстуры инструментов
self.tools_images = [[pygame.image.load('resources/tools/shovel.png'),
pygame.image.load('resources/tools/pick.png')],
[pygame.image.load('resources/tools/shovel_right.png'),
pygame.image.load('resources/tools/pick_right.png')],
[pygame.image.load('resources/tools/shovel_right_1.png'),
pygame.image.load('resources/tools/pick_right_1.png')],
[pygame.image.load('resources/tools/shovel_right_2.png'),
pygame.image.load('resources/tools/pick_right_2.png')],
[pygame.image.load('resources/tools/shovel_left.png'),
pygame.image.load('resources/tools/pick_left.png')],
[pygame.image.load('resources/tools/shovel_left_1.png'),
pygame.image.load('resources/tools/pick_left_1.png')],
[pygame.image.load('resources/tools/shovel_left_2.png'),
pygame.image.load('resources/tools/pick_left_2.png')]]
for i in range(0, 2):
self.tools_images[0][i] = pygame.transform.scale(self.tools_images[0][i], (self.TOOLS_INVENT_SIZE_X, self.TOOLS_INVENT_SIZE_Y))
self.check = pygame.image.load('resources/tools/check.png')
self.check = pygame.transform.scale(self.check, (self.TOOLS_INVENT_SIZE_X, self.TOOLS_INVENT_SIZE_Y))
# Создаем карту
self.map = generate_map(self.SEED, self.SIZE, self.H_MAX, self.SHARP, self.DEPTH, self.PROBABILITY)
self.biome_map, map = biome_generator(self.SEED, self.DEPTH, self.SIZE, self.map, self.LAKES_NUMBER)
# Создаем персонажа и его рюкзак
self.player = Player(self.SIZE/2, self.H_0, self.DEPTH, self.SIZE, self.WINDOW_X, self.BLOCK_SIZE)
self.player.y_calculation(self.map, self.H_MAX)
self.backpack = Backpack()
# Загружаем музыку
pygame.mixer.music.load('sounds/background_music.wav')
#Загружаем шрифт
pygame.font.init()
self.font_1 = pygame.font.Font(None, 36)
def run_simulation(args):
# Init results class for saving the results
# r = Results()
if args.verbose:
util.verbose = True
# Print start message
dev_print("Starting simulation")
# Set simulation variables
num_of_players = args.players
# Go through set amount of simulations
# Start a new game, run it and save the results
# dev_print(args.trading_range)
# dev_print(args.upgrading_range)
strategy = args.strategy
# for k in range(num_of_players):
# dev_print(np.arange(args.buying_range[k * 3], args.buying_range[k * 3 + 1], args.buying_range[k * 3 + 2]))
# single_player_param_list = []
# for params in player_params:
#
# single_player_param_list.append(generate_combination(num=7, params=params))
# # dev_print(single_player_param_list)
# single_player_list = []
player_combination = None
if args.mode in [1, 3]:
strategy_parameter = [[
args.strategy_parameter[k * 3] +
args.strategy_parameter[k * 3 + 1] * i
for i in range(int(args.strategy_parameter[k * 3 + 2]))
] for k in range(num_of_players)]
income = [[
args.income[k * 3] + args.income[k * 3 + 1] * i
for i in range(int(args.income[k * 3 + 2]))
] for k in range(num_of_players)]
tax = [[
args.tax[k * 3] + args.tax[k * 3 + 1] * i
for i in range(int(args.tax[k * 3 + 2]))
] for k in range(num_of_players)]
b_tax = [[
args.building_tax[k * 3] + args.building_tax[k * 3 + 1] * i
for i in range(int(args.building_tax[k * 3 + 2]))
] for k in range(num_of_players)]
start_capital = [[
args.start_capital[k * 3] + args.start_capital[k * 3 + 1] * i
for i in range(int(args.start_capital[k * 3 + 2]))
] for k in range(num_of_players)]
player_params = [[
strategy_parameter[k], income[k], tax[k], start_capital[k],
b_tax[k]
] for k in range(num_of_players)]
# dev_print(player_params)
if args.mode == 3:
single_player_param_list = []
for params in player_params:
single_player_param_list.append(
generate_combination(num=5, params=params))
# dev_print(single_player_param_list)
single_player_list = []
for num in range(num_of_players):
tmp = []
for p in single_player_param_list[num]:
tmp.append(
Player(num=num,
strategy=strategy[num],
strategy_para=p[0],
income=p[1],
tax=p[2],
start_capital=p[3],
building_tax=p[4]))
single_player_list.append(tmp)
player_combination = generate_combination(
num=num_of_players, params=single_player_list)
elif args.mode == 1:
n = int(args.tax[2])
player_combination = []
for i in range(n):
tmp = []
for num in range(num_of_players):
tmp_player = Player(
num=num,
strategy=strategy[num],
strategy_para=strategy_parameter[num][i],
income=income[num][i],
tax=tax[num][i],
start_capital=start_capital[num][i],
building_tax=b_tax[num][i])
tmp.append(tmp_player)
player_combination.append(tmp)
elif args.mode == 2:
player_combination = []
para_list = [
args.strategy_parameter, args.income, args.tax, args.start_capital,
args.building_tax
]
para_combination = generate_combination(5, para_list)
for p in para_combination:
tmp = []
for i in range(num_of_players):
tmp.append(
Player(num=i,
strategy=args.strategy[0],
strategy_para=p[0],
income=p[1],
tax=p[2],
start_capital=p[3],
building_tax=p[4]))
player_combination.append(tmp)
else:
raise ValueError("Unknown type.")
count = 1
last = time.time()
simulation_list = []
for players in player_combination:
cur_simulation_dic = {"settings": {}, "details": {}, "results": {}}
player_info_lst = []
for i in range(len(players)):
cur_player_dic = {
"strategy": players[i].strategy,
"strategy_para": players[i].strategy_para,
"income": players[i].income,
"tax": players[i].tax,
"start_capital": players[i].start_capital,
"building_tax": players[i].building_tax
}
player_info_lst.append(cur_player_dic)
cur_simulation_dic["settings"] = player_info_lst
total_rounds = 0
valid_simulation = 0
if util.verbose:
log.write("player combination: " + str(players) + "\n")
for i in range(1, args.number + 1):
if util.verbose:
log.write("simulation number" + str(i) + "\n")
for n in players:
n.reset()
g = Game(players, rounds=args.rounds)
tmp_info_dic = g.run()
if tmp_info_dic["end"] != -1:
total_rounds += tmp_info_dic["end"]
valid_simulation += 1
cur_simulation_dic["details"][i] = tmp_info_dic
if i % 100 == 0:
dev_print(
"{} out of {} simulation of combination {} finished.".
format(i, args.number, count))
# r.addHitResults(g.board.hits)
# Calculate the amount of simulations per second
now = time.time()
duration = now - last
avg_time = duration / args.number
try:
avg_round = total_rounds / valid_simulation
except ZeroDivisionError:
avg_round = float("inf")
last = time.time()
cur_simulation_dic["results"]["avg_time"] = avg_time
cur_simulation_dic["results"]["avg_round"] = avg_round
cur_simulation_dic["results"]["total_time"] = duration
cur_simulation_dic["results"][
"end_percent"] = valid_simulation / args.number
# speed = i / (now - start)
dev_print("ended: ", valid_simulation)
dev_print("avg_time: ", avg_time)
dev_print("avg_round: ", avg_round)
# Display the progress every 1/1000 of the way to begin finished
dev_print("{} out of {} combination finished.".format(
count, len(player_combination)))
count += 1
simulation_list.append(cur_simulation_dic)
metadata_dic["simulations"] = simulation_list
prod_print(json.dumps(metadata_dic) + "\n")
# Print that the simulation is finished
dev_print("\nDone!")
sound_btn = Button(sound_on_img, (24, 24), WIDTH - WIDTH // 4 - 18,
HEIGHT // 2 + 50)
# OBJECTS *********************************************************************
tile_group = pygame.sprite.Group()
for i in range(8):
tile = Tile(i, 1, win)
tile_group.add(tile)
tile = Tile(i, 2, win)
tile_group.add(tile)
particle_group = pygame.sprite.Group()
skull_group = pygame.sprite.Group()
p = Player(win, tile_group)
# FUNCTIONS *******************************************************************
deadly_tiles_list = []
def get_index():
if p.tile_type == 1:
indices = [2 * index + 1 for index in range(8)]
elif p.tile_type == 2:
indices = [2 * index for index in range(8)]
index = random.choice(indices)
return index
# SOUNDS **********************************************************************
player_bullet_fx = pygame.mixer.Sound('Sounds/gunshot.wav')
click_fx = pygame.mixer.Sound('Sounds/click.mp3')
collision_fx = pygame.mixer.Sound('Sounds/mini_exp.mp3')
blast_fx = pygame.mixer.Sound('Sounds/blast.wav')
fuel_fx = pygame.mixer.Sound('Sounds/fuel.wav')
pygame.mixer.music.load('Sounds/Defrini - Spookie.mp3')
pygame.mixer.music.play(loops=-1)
pygame.mixer.music.set_volume(0.1)
# GROUPS & OBJECTS ************************************************************
bg = Background(win)
p = Player(144, HEIGHT - 100)
enemy_group = pygame.sprite.Group()
player_bullet_group = pygame.sprite.Group()
enemy_bullet_group = pygame.sprite.Group()
explosion_group = pygame.sprite.Group()
fuel_group = pygame.sprite.Group()
powerup_group = pygame.sprite.Group()
# FUNCTIONS *******************************************************************
def shoot_bullet():
x, y = p.rect.center[0], p.rect.y
if p.powerup > 0:
server = "192.168.0.64"
port = 5555
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.bind((server, port))
except socket.error as e:
str(e)
s.listen(2)
print('Waiting for connection, Server started')
game = Game([
Player(45, 285, 10, 150, (255, 255, 255)),
Player(945, 285, 10, 150, (255, 255, 255))
], Ball(465, 330, 25, (255, 255, 255)), -1, 0, 0)
def threaded_client(conn, player):
global playersCount
conn.send(str.encode(str(player)))
while True:
try:
data = pickle.loads(conn.recv(2048))
if not data:
print('Disconnected')
break
else:
replay_img = pygame.transform.scale(replay_img, (300, 150))
# Music ***************************************
pygame.mixer.music.load('Sounds/rise-and-shine.mp3')
pygame.mixer.music.set_volume(0.5)
pygame.mixer.music.play(loops=-1)
crash_fx = pygame.mixer.Sound('Sounds/car_crash.wav')
horn_fx = pygame.mixer.Sound('Sounds/car_horn.wav')
coin_fx = pygame.mixer.Sound('Sounds/coin_fx.wav')
speeding_fx = pygame.mixer.Sound('Sounds/speeding_fx.wav')
# Objects ***************************************
bg = Background(win)
p = Player(WIDTH // 2 + 50, yoffset + HEIGHT // 2, win)
counter = Counter(win, counter_font)
draw = Draw(win)
# Object positions *******************************
horn_rect = pygame.Rect(xoffset + WIDTH - 50, yoffset + HEIGHT + 20, 85, 80)
start_rect = start_btn.get_rect()
start_rect.x = xoffset + WIDTH // 5
start_rect.y = yoffset + HEIGHT + 50
replay_rect = replay_img.get_rect()
replay_rect.x = xoffset + WIDTH // 4 + 15
sound_on_img = pygame.image.load("Assets/soundOnBtn.png")
# Buttons ********************************************************************
close_btn = Button(close_img, (24, 24), WIDTH // 4 - 18, HEIGHT // 2 + 120)
replay_btn = Button(replay_img, (36, 36), WIDTH // 2 - 18, HEIGHT // 2 + 115)
sound_btn = Button(sound_on_img, (24, 24), WIDTH - WIDTH // 4 - 18,
HEIGHT // 2 + 120)
# GROUP & OBJECTS ************************************************************
flake_group = pygame.sprite.Group()
particle_group = pygame.sprite.Group()
circle_group = pygame.sprite.Group()
p = Player()
d = Dot()
pos = random.randint(0, 11)
# VARIABLES ******************************************************************
clicked = False
rotate = True
shrink = True
sound_on = True
clicks = 0
count = 50
score = 0
high_score = 0
score_list = []
def gen_players(self):
for obj_addr in self.gen_objects_addr():
if self.pm.read_int(obj_addr + Offset.Object.type) == 4:
yield Player(self, obj_addr)
'Right': pygame.Rect(5, 450, 35, 50)
}
# groups
diamond_group = pygame.sprite.Group()
spike_group = pygame.sprite.Group()
plant_group = pygame.sprite.Group()
board_group = pygame.sprite.Group()
chain_group = pygame.sprite.Group()
groups = [diamond_group, spike_group, plant_group, board_group, chain_group]
data = load_level(current_level)
(player_x, player_y), (portal_x, portal_y) = game_data(current_level)
world = World(win, data, groups)
player = Player(win, (player_x, player_y), world, groups)
portal = Portal(portal_x, portal_y, win)
game_started = False
game_over = False
game_won = False
replay_menu = False
sound_on = True
bgx = 0
bgcounter = 0
bgdx = 1
running = True
while running:
win.blit(bg, (bgx, 0))
