def update(self): self.move() if self.health <= 0: all_sprites_list.remove(self) Player.update(self)
def throwItem(position,index): #Jette un objet global throw throw = 0 Map.addItem(position,Player.getItem(index)) descript = "You throw " + Player.getItemName(index) + " away." Player.removeItem(index) return descript
def __init__(self, file_path): super(Scene, self).__init__() pygame.mixer.init(44100, -16, 4, 2048) self.position = ['goalkeeper', 'defender', 'midfielder', 'attacker'] self.all_object_list = pygame.sprite.LayeredUpdates() self.selection_circle = [] # Prototype self.left_player = Player() # Prototype self.right_player = Player() # Prototype self.teams = collections.defaultdict(dict) self.field = Object() self.field_border = Object() self.goal = [] self.ball = Ball() self.hud = HUD() self.goal_image = EffectObject() self.formation = {Team_side.LEFT: [1, 4, 3, 3], Team_side.RIGHT: [1, 4, 4, 2]} self.sound_list = dict() # Game config self.game_mode = Game_mode.PvP self.P1_controlled_team = Team_side.LEFT self.P1_controlled_position = 'midfielder' self.P2_controlled_team = Team_side.RIGHT self.P2_controlled_position = 'midfielder' # Load scene's resources self.read_scene(file_path)
def minimaxMove(self, board, ply): """ Choose the best minimax move. Returns (score, move) """ move = -1 score = -INFINITY turn = self for m in board.legalMoves(self): #for each legal move if ply == 0: #if we're at ply 0, we need to call our eval function & return return (self.score(board), m) if board.gameOver(): return (-1, -1) # Can't make a move, the game is over nb = deepcopy(board) #make a new board nb.makeMove(self, m) #try the move opp = Player(self.opp, self.type, self.ply) s = opp.minValue(nb, ply-1, turn) #and see what the opponent would do next if s > score: #if the result is better than our best score so far, save that move,score move = m score = s #return the best score and move so far return score, move
def main(): global flag global count screen=Screen() i=25 j=1 pm=Player(i,j) screen.printpm(i,j,'P') #flag=0 #screen.printScreen() os.system("clear") screen.genCoins() screen.printScreen() while(1): print "Enter Move :", ch=getchar() if(ch=='q'): break pm.move(ch,screen) print "" os.system("clear") screen.printScreen() print "Score :", print screen.getScore() if(screen.getflag1()==1): break print "" print "Game Over!!! Score is:", print screen.getScore()
def alphaBetaMove(self, board, ply): """ Choose a move with alpha beta pruning. Returns (score, move) """ move = -1 score = -INFINITY turn = self alpha = -INFINITY beta = INFINITY for m in board.legalMoves(self): #for each legal move if ply == 0: #if we're at ply 0, we need to call our eval function & return return (self.score(board), m) if board.gameOver(): return (-1, -1) # Can't make a move, the game is over nb = deepcopy(board) #make a new board nb.makeMove(self, m) #try the move opp = Player(self.opp, self.type, self.ply) s = opp.minValueAB(nb, ply-1, alpha, beta, turn) #and see what the opponent would do next if s > score: #if the result is better than our best score so far, save that move,score move = m score = s #return the best score and move so far return score, move print "Alpha Beta Move not yet implemented" #returns the score adn the associated moved return (-1,1)
def listener(self, client, packet): self.serverSocket.serverLock() if isinstance(packet, Packets.PlayerInfoPacket): if packet.getHealth() > 0: if client not in self.players: player = Player( self.getGame(), color=Color( random.randint(127, 255), random.randint(127, 255), random.randint(127, 255) ) ) player.setPlayerId(self.pid) player.setPlayerName(packet.getPlayerName()) self.pid += 1 self.players[client] = player else: player = self.players[client] player.setPosition(packet.getPosition()) player.setAngle(packet.getAngle()) self.packetCount += 1 elif isinstance(packet, Packets.PlayerGunPacket): player = self.players[client] bullets = player.shoot() for bullet in bullets: bullet.setBulletId(self.bid) self.bid += 1 self.bullets += bullets self.packetCount += 1 elif packet is not None: self.packetCount += 1 print("Packet received (type " + str(packet) + ")") self.serverSocket.serverUnlock()
def throwItem(position,index): #Jette un objet global throw throw = 0 Map.addItem(position,Player.getItem(index)) descript = "Vous jetez " + Player.getItemName(index) Player.removeItem(index) return descript
def player_start(cave_list, spawn_list): for item in cave_list: if item.get_pit() == False and item.get_bat() == False and item.get_wumpus() == False: spawn_list.append(item) spawn_room = random.choice(spawn_list) Player.set_room(spawn_room.get_value())
def __init__(self, screen, snake_sleep, quit_page, game_type): self.screen = screen self.snake_sleep = snake_sleep self.quit_page = quit_page self.draw_area = DrawArea(screen) self.players = [] self.map0 = { curses.KEY_UP : 3, curses.KEY_LEFT : 4, curses.KEY_DOWN : 1, curses.KEY_RIGHT : 2} self.player0 = Player(self.draw_area.width / 4,self.draw_area.height / 2, 3, 5, self.map0,self.draw_area,True) self.player0.add_to_obstacles(self.player0.snake) self.egg = Egg(self.draw_area, 9, 9) self.player0.add_to_food(self.egg) if game_type != 1: self.map1 = { ord('w') : 3, ord('a') : 4, ord('s') : 1, ord('d') : 2} self.player1 = Player(9, 9, 1, 5, self.map1, self.draw_area,False) self.player1.add_to_obstacles(self.player0.snake) self.player1.add_to_obstacles(self.player1.snake) self.player1.add_to_food(self.egg) self.player0.add_to_obstacles(self.player1.snake) self.game_type = game_type
def quit(self): # evilynux - self.audio.close() crashes when we attempt to restart if not self.restartRequested: self.audio.close() Player.savePlayers() for t in list(self.tasks + self.frameTasks): self.removeTask(t) self.running = False
def teleport_check(Player, cave_list): copy_cave = cave_list[:] for item in cave_list: if item.get_bat() == True: while item.get_value() == Player.get_room(): copy_cave.remove(item) random_cave = random.choice(copy_cave) Player.set_room(random_cave.get_value())
def test_playerAttack(self): arni = Player("Arni") villi = Player("Villi") pre = Presets() emptyArray = [] arni.mainCard = pre.gc("Charizard") villi.mainCard = pre.gc("Bulbasaur") self.assertTrue(isinstance(arni.attack(2, villi, emptyArray), bool))
def deleteCharacter(self): tsYes = _("Yes") q = Dialogs.chooseItem(self.engine, [tsYes, _("No")], _("Are you sure you want to delete this player?")) if q == tsYes: if self.player: Player.deletePlayer(self.player) self.engine.view.popLayer(self) self.engine.input.removeKeyListener(self)
def registerPlayer(name, tournament_id): """ Adds a player to the tournament database. Args: name = the player's full name (need not be unique). tournament = tournament id where player is to be added to """ Player.addPlayer(name, tournament_id)
def manage_place(self): px = Player.getPlayPos()[0] py = Player.getPlayPos()[1] pos = self.world.grid[px][py] option = "" yes_answer = "" no_aswer = "" flag = False
def reportBye(player, tournament): """ Gives a player a bye Args: player = id of player awarded by a bye tournament = id of tournament where the match took place """ Player.addBye(player, tournament)
def CheckResult(self, not_voted="dont_count", not_voted_spec=None, min_needed=51, only_sure=False): if not_voted not in {"dont_count","yes","no"}: raise ValueError("Invalid value of argument not_voted") if not_voted_spec == None: not_voted_spec=not_voted elif not_voted_spec not in {"dont_count","yes","no"}: raise ValueError("Invalid value of argument not_voted_spec") if min_needed>100: min_needed=100 elif min_needed<0: min_needed=0 yes_count=len(self.__players_voted_yes) no_count=len(self.__players_voted_no) voted_players=self.__players_voted_yes + self.__players_voted_no bots=Player.getBots() cur_mode=None for player in Player.players: if player in bots or Player.players[player].ip in voted_players: continue if Player.players[player].getTeam()==None: # Player is spectating cur_mode=not_voted_spec else: cur_mode=not_voted if cur_mode == "yes": yes_count=yes_count+1 elif cur_mode == "no": no_count=no_count+1 else: pass num_allowed=len(Player.players)-len(Player.getBots()) if not spec_allowed: num_allowed=num_allowed-len([i for i in Player.players.values() if i.getTeam()==None]) if yes_count+no_count==0 or num_allowed==0: percent_yes=0 percent_no=0 elif only_sure==False: percent_yes=yes_count/(yes_count+no_count)*100 percent_no=100-percent_yes else: percent_yes=yes_count/num_allowed*100 percent_no=no_count/num_allowed*100 if num_allowed==1: percent_yes=100 percent_no=0 if percent_yes >= min_needed: log.info("Poll for {0} successed.".format(self.target) ) Armagetronad.SendCommand("CONSOLE_MESSAGE "+Messages.PollSuccessed.format(target=self.target) ) self.action() elif percent_no>(100-min_needed): log.info("Poll for {0} failed.".format(self.target) ) Armagetronad.SendCommand("CONSOLE_MESSAGE "+Messages.PollFailed.format(target=self.target) ) else: return False global current_poll current_poll=None return True
def pickList(): #Renvoie la liste des objets ramassables global items, pick items = Map.isItem(Player.getPosition()) if items == 0: return "Il n'y a pas d'objets dans cette zone." elif Player.isItem() == 6: return "Vous n'avez plus de place dans votre inventaire." else: pick = 1 return "Quel objet voulez-vous ramasser? (Tapez le numero correspondant) ~~~~~~~~~~~~~~~~~~~~~~~~~~ " + Map.getItemList(Player.getPosition())
class Game(object): def __init__(self, screen): self.deaths = 0 self.screen = screen self.level = Level('reallevel') self.spawn() self.game_area = screen.subsurface((0, 40, screen.get_width(), screen.get_height() - 40)) self.cam = Camera(self.player, self.level.bounds, self.game_area.get_size()) self.hud = screen.subsurface((0, 0, screen.get_width(), 40)) self.deathtext = pygame.font.Font(None, 20) def spawn(self): self.player = Player((self.level.spawnPoint), self.level, self) def quit(self): self.done = True def loop(self): self.done = False self.clock = pygame.time.Clock() while not self.done: dt = self.clock.tick(30) #input for event in pygame.event.get(): if event.type == pygame.QUIT: self.quit() elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE: self.quit() elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: self.player.jump() #update self.player.update(dt) self.cam.update(self.player.rect) #draw self.hud.fill((80, 80, 80)) text = self.deathtext.render("deaths: " + str(self.deaths), True, (0, 255, 0)) self.hud.blit(text, (0, 0)) self.game_area.fill((0,0,0)) self.cam.draw_background(self.game_area, self.level.background) self.cam.draw_sprite(self.game_area, self.player) #refresh pygame.display.flip()
def pickItem(position,index): #Ramasse un objet global pick pick = 0 print "add" Player.addItem(Map.getItem(position,index)) print "describe" descript = "Vous ramassez " + Map.getItemName(position,index) print "remove" Map.removeItem(position,index) print "return" return descript
def movement(self, ginput): px = Player.getPlayPos()[0] py = Player.getPlayPos()[1] if ginput == "left" and (self.world.grid[px - 1][py] != "#" or debug.debug): Player.getPlayPos()[0] -= 1 elif ginput == "right" and (self.world.grid[px + 1][py] != "#" or debug.debug): Player.getPlayPos()[0] += 1 elif ginput == "up" and (self.world.grid[px][py - 1] != "#" or debug.debug): Player.getPlayPos()[1] -= 1 elif ginput == "down" and (self.world.grid[px][py + 1] != "#" or debug.debug): Player.getPlayPos()[1] += 1
def choosePC(self): choice = raw_input ("Do you want to play against a friend? Y/N: ") if choice == "Y" or choice == "y": self.playerList[0] = Player.player() self.playerList[1] = Player.player() elif choice == "N" or choice == "n": self.playerList[0] = Player.player() self.playerList[1] = CompPlayer.compPlayer() self.playerList[1].setIsEasy(self.setMode()) else: print ("'" + str(choice) + "' is not an option. Please try again.") self.choosePC()
def pickList(): #Renvoie la liste des objets ramassables global items, pick items = Map.isItem(Player.getPosition()) if Map.isMonster(Player.getPosition()) == 0 : if items == 0: return "Il n'y a pas d'objets dans cette zone." elif Player.isItem() == 6: return "Vous n'avez plus de place dans votre inventaire." else: pick = 1 return "Quel objet voulez-vous ramasser? (Tapez le numero correspondant) ~~~~~~~~~~~~~~~~~~~~~~~~~~ " + Map.getItemList(Player.getPosition()) else : return "Ramasser un objet qu'un adversaire garde n'est jamais une bonne idee. "
def __init__(self, playerName): ''' Initializes the game by - shuffling the deck - initializing a player1 (with given playerName) and dealer object (both are Player objects) ''' self.gamedeck = Deck() self.gamedeck.reset() self.gamedeck.shuffle() self.playerName = playerName self.user = Player(self.playerName) self.dealer = Player("Dealer")
class Control: def __init__(self): print "Control __init__" self.Access = Access() self.Graph = Graph() self.Player = Player() #self.Xml = Xml() self.Access.classAddresses(self.Graph,self.Player,self) self.Graph.classAddresses(self.Access,self.Player,self) self.Player.classAddresses(self.Graph,self.Access,self) #self.Xml.classAddresses(self.Graph,self.Access,self.Player,self) self.Access.start() self.Graph.getCode()
def pickList(): #Renvoie la liste des objets ramassables global items, pick items = Map.isItem(Player.getPosition()) if Map.isMonster(Player.getPosition()) == 0 : if items == 0: return "There aren't any items in this area." elif Player.isItem() == 6: return "Your inventory is already full." else: pick = 1 return "Which item do you want to pick up? (Type in the corresponding number) ~~~~~~~~~~~~~~~~~~~~~~~~~~ " + Map.getItemList(Player.getPosition()) else : return "Trying to take an items guarded by an opponent is never a clever idea. "
def endround(): i = pygame.time.get_ticks() while (pygame.time.get_ticks() - i) < 888: a = 0 p1 = Player(250, 250, math.pi/2, 20, .1, GREEN, mainsurface, time, game_arena.arena_walls) p1.score = p1score p2 = Player(550, 550, -math.pi/2, 20, .1, RED, mainsurface, time, game_arena.arena_walls) p2.score = p2score print p1.ypos print p2.ypos print "***" return p1, p2
class Scene(State): def __init__(self): super(Scene, self).__init__() self.all_object_list = pygame.sprite.Group() self.troll_list = pygame.sprite.Group() self.bullet_list = pygame.sprite.Group() self.player = Player() self.background = Object() self.hud = HUD() self.score = 0 self.game_over = False def init(self): self.read_scene() # Scale background to screen size self.background.image = pygame.transform.scale(self.background.image, (SCREEN_WIDTH, SCREEN_HEIGHT)) def process_events(self, event): if event.type == pygame.MOUSEBUTTONDOWN: return #self.player.change_color(BLUE) elif event.type == pygame.KEYDOWN: if (event.ket == pygame.K_p): self.pause() def update(self): if (not self.is_running): return # TEST pos = pygame.mouse.get_pos() self.player.rect.x = pos[0] self.player.rect.y = pos[1] def draw(self, screen): screen.fill(WHITE) #screen.blit(self.background.image, self.background.rect) self.background.draw(screen) self.all_object_list.draw(screen) def read_scene(self): with open(ResourceManager.scene_path_list[0]) as file: self.read_background(file) self.read_player(file) def read_background(self, file): file.readline() image_id = int(file.readline().strip().split(' ')[1]) self.background.init('Image', None, file_name = ResourceManager.image_path_list[image_id]) def read_player(self, file): file.readline() image_id = int(file.readline().strip().split(' ')[1]) self.player.init('Image', None, file_name = ResourceManager.image_path_list[image_id], alpha = True) self.player.move(*map(int, file.readline().strip().split(' ')[1:])) self.player.rotate(float(file.readline().strip().split(' ')[1])) self.player.scale(*map(int, file.readline().strip().split(' ')[1:])) self.all_object_list.add(self.player)
def pluginControls(self): self.gameDrums = 0 self.gameGuitars = 0 self.gameMics = 0 Player.pluginControls(self.activeGameControls) for i in self.activeGameControls: if self.controls.type[i] == -1: self.gameBots += 1 elif self.controls.type[i] in Player.DRUMTYPES: self.gameDrums += 1 elif self.controls.type[i] in Player.MICTYPES: self.gameMics += 1 elif self.controls.type[i] in Player.GUITARTYPES: self.gameGuitars += 1
def __init__(self, screen): self.screen = screen self.player = Player('Test') self.background = pygame.image.load('data/background.jpg') self.running = True self.main_loop()
#тут читаем поле field = [] with open("polygon.txt", "r") as f: for line in f: field.append(list(line.strip())) entity_id_to_id = {} entities_to_obj = {} #а тут задаем параметры ГГ (кодовое имя --- Курточка) main_field.add_entity('player', entity_id='player', entity_pos=[cellsize * 4, cellsize * 4]) entity_id_to_id['player'] = 0 Jacket = Player.player() Jacket.x, Jacket.y = main_field.get_list_ent( )[0][1][0] + cellsize * 3 // 2, main_field.get_list_ent( )[0][1][1] + cellsize * 3 // 2 Jacket.speed = main_field.get_list_ent()[0][0].max_move_speed Jacket.sprite = os.getcwd() + '/sprites/player.png' #пилим окно root = tkinter.Tk() canvas = tkinter.Canvas(root, width=cellsize * height_f, height=cellsize * width_f) #создаем спрайты Jacketsprite = ImageTk.PhotoImage(Image.open(Jacket.sprite)) Mansprite = ImageTk.PhotoImage(
def test_player_default_initializes_player_hand_object_to_empty(self): player = Player_library.Player() message = "Initialized Player's Hand object's hand_cards should be empty list" self.assertEqual(player.player_hand.hand_cards, [], message)
def find_sim_player(session: GameSession, player: Player) -> Player: # find the player's turn for the current session simulation for sim_player in session.players(): if sim_player.get_id() == player.get_id(): return sim_player
def playGame(): parser = OptionParser() parser.add_option("-d", "--depth", type="int", dest="AIdepth", default=99, help="set maximum AI search depth", metavar="MAXDEPTH") parser.add_option("-w", "--white", dest="white", default="human", help="set white player", metavar="PLAYER") parser.add_option("-b", "--black", dest="black", default="ai", help="set black player", metavar="PLAYER") parser.add_option("-t", "--time", type="int", dest="maxTime", default=5, help="set maximum AI thinking time", metavar="MAXTIME") parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False, help="set verbose AI") parser.add_option("-s", "--simple", action="store_true", dest="textmode", default=False, help="use simple board display") parser.add_option("--singleturn", action="store_true", dest="singleturn", default=False, help="(debug) play a single turn only") (options, args) = parser.parse_args() b = Board.Board(textmode = options.textmode) AIdepth = options.AIdepth maxTime = options.maxTime playertype = [options.white, options.black] players = [] for i in [0,1]: p = playertype[i] if p=="human": players.append( Player.HumanPlayer(i) ) elif p=="ai": players.append( Player.AIPlayer(i, AIdepth, options.verbose) ) elif p=="random": players.append( Player.RandomPlayer(i) ) elif p=="pass": players.append( Player.PassingPlayer(i) ) else: #TODO exception print "Error: unknown player type:", p exit() print "%s is %s." % (playerNames[i], players[i].name), if p=="ai": print "Depth is %s, max thinking time is %ds." % (AIdepth, maxTime) print "" r = Rules.Suicide() b.display() print "" WIN = -1 while True: for col in [0, 1]: # First check for win numpieces = b.getNumPieces(col) valid, capture = r.getAllValidMoves(b, col) if numpieces==0 or len(valid)==0: WIN = col break madeValidMove = False; startTime = time.time() while not madeValidMove: print playerNames[col] + "'s turn" m = players[col].getMove(b, maxTime) # NoneMove -> try again if m==Move.NONE: continue # If retract, we pop two moves and try again if m==Move.RETRACT: lastMoveByThisPlayer = b.getSecondLastMove() if b.retractTurn(): print playerNames[col], "retracts move", lastMoveByThisPlayer else: print "Unable to retract." print "" b.display() print "" continue try: r.validate(m, b, col) madeValidMove = True except Rules.RulesViolation as e: madeValidMove = False print "Invalid move: " + e.value print "Got valid move in ", time.time()-startTime, "s" if m==Rules.Move.RESIGN: print playerNames[col] + " resigns. " WIN = 1-col break b.makeMove(m) print "" b.display() print playerNames[col] + " moved", m print "" if options.singleturn: exit() if not WIN==-1: print playerNames[WIN] + " wins!" exit()
def _calc(self, session: GameSession, player: Player) -> float: num_types = len(set([card for card in player.resource_hand()])) return num_types
def _calc(self, session: GameSession, player: Player) -> float: num_unique_resources = 0 for resource in Consts.ResourceType: if player.resource_hand().cards_of_type(resource).size() > 0: num_unique_resources += 1 return num_unique_resources
class FantasyBoard(object): def __init__(self, available_bank): self.available_bank = available_bank self.position_keys = [] self.all_players = {} self.required_players = {} self.first_run = True self.flex = Player(None, None, None, None) def add_player(self, name, position, points, cost): if position not in self.position_keys: self.position_keys.append(position) self.all_players[position] = [] else: self.all_players[position].append( Player(name, position, points, cost)) def get_required(self): for key in self.position_keys: x = int( input("How Many Players Do You Need to Fill the Position " + key + ": ")) self.required_players[key] = x def get_best(self, key): best_points = 0 best_choice = Player(None, None, None, None) for player in self.all_players[key]: if (player.player_points() > best_points): if (not player.is_used()): if (not player.dont_use_player()): best_points = player.player_points() best_choice = player best_choice.use_player() return best_choice def get_next_best(self, key): best_points = 0 best_choice = Player(None, None, None, None) for player in self.all_players[key]: if (player.player_points() > best_points): if (not player.is_used()): if (not player.dont_use_player()): best_points = player.player_points() best_choice = player return best_choice def print_best_choices(self): print("\n\n:::::: BEST CHOICES ::::::::::::::::::::::::::::::::::::") for key in self.position_keys: print("\nBest Choices for Position: " + key) for player in self.all_players[key]: if player.is_used(): print(key + " choice: " + player.name) print("\nBest Choices for Position: FLEX") print("FLEX choice: " + self.flex.name) def total_cost(self): tot_cost = 0 for key in self.position_keys: for player in self.all_players[key]: if player.is_used(): tot_cost += player.cost tot_cost += self.flex.cost return tot_cost def total_points(self): tot_pts = 0 for key in self.position_keys: for player in self.all_players[key]: if player.is_used(): tot_pts += player.player_points() tot_pts += self.flex.player_points() return tot_pts def make_flex_choice(self): keys = ["WR", "TE", "RB"] best_points = 0 best_choice = Player(None, None, None, None) for key in keys: guess = self.get_next_best(key) if (guess.player_points() > best_points): best_choice = guess best_points = guess.player_points() best_choice.make_flex_choice() self.flex = best_choice def current_best_choice_for_replacement_in_position(self, key): # ROI is best locally used = [] unused = [] replace_this = Player(None, None, None, None) replace_with = Player(None, None, None, None) first_run_local = True min_change_roi = 0 for player in self.all_players[key]: if player.is_used(): used.append(player) else: unused.append(player) for player_used in used: for player_check in unused: if first_run_local: replace_this = player_used replace_with = player_check min_change_roi = replace_this.return_on_investment( ) - replace_with.return_on_investment() first_run_local = False else: if (player_used.return_on_investment() - player_check.return_on_investment() < min_change_roi): replace_this = player_used replace_with = player_check min_change_roi = replace_this.return_on_investment( ) - replace_with.return_on_investment() return min_change_roi, replace_this, replace_with def best_replacement(self): self.flex.no_longer_flex() replace_this = Player(None, None, None, None) replace_with = Player(None, None, None, None) first_run_local = True min_change_roi = 0 for key in self.position_keys: if (first_run_local): min_change_roi, replace_this, replace_with = self.current_best_choice_for_replacement_in_position( key) first_run_local = False else: tmp_min_change_roi, tmp_replace_this, tmp_replace_with = self.current_best_choice_for_replacement_in_position( key) if (tmp_min_change_roi < min_change_roi): min_change_roi = tmp_min_change_roi replace_this = tmp_replace_this replace_with = tmp_replace_with replace_this.dont_use_player() replace_with.use_player() self.make_flex_choice() def get_best_choices(self): if (self.first_run): for key in self.position_keys: for choice in range(self.required_players[key]): new_choice = self.get_best(key) self.first_run = False self.make_flex_choice() else: self.best_replacement() if (self.total_cost() <= self.available_bank): self.print_best_choices() print("\nSpent " + str(self.total_cost())) print("Points " + str(self.total_points())) else: self.print_best_choices() print("Not Enough Bank! Trying to Spend " + str(self.total_cost())) self.get_best_choices()
def __init__(self, playerName): self.deck = Deck.Deck() self.player = Player.Player(playerName, self.deck.drawCard(), self.deck.drawCard()) self.dealer = Dealer.Dealer(self.deck.drawCard(), self.deck.drawCard())
def __init__(self): self.deck = Deck() self.hand = Hand() self.player = Player()
import pygame import config import Player import Terrain import Inventory import showcoords pygame.init() window = pygame.display.set_mode((config.screen_width, config.screen_height)) pygame.display.set_caption("Minecraft2D") terrain = Terrain.Terrain() player = Player.Player(terrain) equipment = Inventory.Inventory() def update(ev): player.update(ev, terrain, equipment) equipment.update(ev) def draw(): window.fill((0, 0, 0)) terrain.draw(window, player) player.draw(window) equipment.draw(window) showcoords.draw(window, player) terrain.create_terrain()
def run(self): # Game Setup player = Player() player_hand = Hand() dealer_hand = Hand() deck = Deck() deck.shuffle_cards() player.place_bet() player_hand.add_card(deck.deal_card()) player_hand.add_card(deck.deal_card()) player_hand.adjust_for_ace() dealer_hand.add_card(deck.deal_card()) dealer_hand.add_card(deck.deal_card()) dealer_hand.adjust_for_ace() player.show_some(player_hand,dealer_hand) # Gameplay player.player_turn(deck,player_hand) while dealer_hand.hand_value not in range(17,22): dealer_hand.add_card(deck.deal_card()) dealer_hand.adjust_for_ace() if dealer_hand.hand_busts(dealer_hand): break if dealer_hand.hand_busts(dealer_hand): player.show_all(player_hand, dealer_hand) print('Dealer busts, Player wins!') player.chips_total += player.bet print('Chip total: {}'.format(player.chips_total)) if player_hand.hand_value == dealer_hand.hand_value: player.show_all(player_hand, dealer_hand) print('Push! Dealer and Player tie!') if player_hand.hand_value > dealer_hand.hand_value and player_hand.hand_busts(player_hand) == False: player.show_all(player_hand, dealer_hand) print('Player wins!') player.chips_total += player.bet print('Chip total: {}'.format(player.chips_total)) if player_hand.hand_value < dealer_hand.hand_value and dealer_hand.hand_busts(dealer_hand) == False: player.show_all(player_hand, dealer_hand) print('Dealer wins!') player.chips_total -= player.bet print('Chip total: {}'.format(player.chips_total)) if self.replay() == 'Y': self.run()
boat = pygame.image.load("Images/boat.png") boatX = width / 4 endCondition = 0 actualWon = False coolFacts = [ r"In 2013 over 90 million pounds of fish were caught", r"About 38.5 million tonnes of bycatch results from current preferred fishing practice each year", r"Over just 40 years there has been a decrease recorded in marine species of 39%", r"Almost 30% of fish stocks commercially fished are over-fished", r"In the North East Atlantic and nearby seas, 39% of fish stocks are classified as overfished. In the Mediterranean Sea and the Black Sea there is sufficient data for 85 stocks, which shows that 88% of these (75) are overfished", r"Today, each person eats on average 19.2kg of fish a year – around twice as much as 50 years ago" ] screen = pygame.display.set_mode(size, pygame.FULLSCREEN) player = Player.player(width / 2, height * 2 / 3, screen, maxDepth) nets = [] bubbles = [] for i in range(0, 20): bubbles.append(Bubble.bubble(width, height, screen)) changeSpriteMaybe = 0 while not done: for event in pygame.event.get(): if event.type == pygame.QUIT: done = True keys = pygame.key.get_pressed() if (control): dists = [0, 0]
def createMatch(players): n = len(players) game = Game.Game(n, "EPD", None) players1 = players match1 = Match.Match(players1, 1000, game) results1 = match1.playGame() print("\nRandom player in position 0") ind = 0 for i in range(len(results1)): if results1[i] > results1[ind]: ind = i print("winner is: " + str(ind)) print(results1) game = Game.Game(n, "EPD", None) playersTraining = players AI = Player.LearningAgent(0, game) # Training the AI for i in range(500): game = Game.Game(n, "EPD", None) matchTraining = Match.Match(playersTraining, 1000, game) output = matchTraining.playLearningMatch(0) AI.updateQScores(output, 0) # Testing the AI game = Game.Game(n, "EPD", None) players2 = playersTraining players2[0] = AI for i in range(n): if (players2[i].playerName == "ExpertLearningPlayer"): players2[i].stopLearning() match2 = Match.Match(players2, 1000, game) results2 = match2.playGame() print("\nAI player in position 0") ind = 0 for i in range(len(results2)): if results2[i] > results2[ind]: ind = i print("winner is: " + str(ind)) print(results2) #comparing to expert learning game = Game.Game(n, "EPD", None) players3 = players2 players3[0] = Player.ExpertAdvicePlayer(0, game) match3 = Match.Match(players3, 1000, game) results3 = match3.playGame() print("\nEL player in position 0") ind = 0 for i in range(len(results3)): if results3[i] > results3[ind]: ind = i print("winner is: " + str(ind)) print(results3) answer = [str(results1), str(results2), str(results3)] if (max(results2) == results2[0]): answer = answer + ["1"] else: answer = answer + ["0"] if (max(results3) == results3[0]): answer = answer + ["1"] else: answer = answer + ["0"] answer = answer + [str(results1[0]), str(results2[0]), str(results3[0])] return answer
import Player import InventionKnowledge import Knowledge import Invention class InventionKnowledgePlayer: def __init__(self, player, inventionKnowledge, nbCube): self.Player = player self.InventionKnowledge = inventionKnowledge self.NombreCube = 0 # TESTS player1 = Player.Player(1, 'thomas') knowledge1 = Knowledge.Knowledge invention1 = Invention.Invention(1, 'invention1', 'classification1') inventionKnowledge1 = InventionKnowledge.InventionKnowledge(knowledge1, invention1, 1) inventionKnowledgePlayer1 = InventionKnowledgePlayer(player1, inventionKnowledge1, 2) print('-') print(inventionKnowledgePlayer1.Player.nom) print(inventionKnowledgePlayer1.InventionKnowledge.Invention.name) print(inventionKnowledgePlayer1.InventionKnowledge.Invention.classification) print(inventionKnowledgePlayer1.InventionKnowledge.Invention.age) print(inventionKnowledgePlayer1.InventionKnowledge.Invention.classification) print(inventionKnowledgePlayer1.InventionKnowledge.Knowledge.Mathematics.value) print('-')
if self.game.legalMove(self.turn, i + 1): moveAgain = self.game.makeMove(self.turn, i + 1) if not moveAgain: self.swapTurns() self.resetStones() else: for i in range(len(self.cups[1])): if self.cups[1][i] == event.widget: index = self.game.NCUPS - i if self.game.legalMove(self.turn, index): moveAgain = self.game.makeMove(self.turn, index) if not moveAgain: self.swapTurns() self.resetStones() if moveAgain: self.enableBoard() else: self.continueGame() def startGame(p1, p2): """ Start the game of Mancala with two players """ root = Tk() app = MancalaWindow(root, p1, p2) root.mainloop() startGame(Player(1, Player.RANDOM), Player(2, Player.MINIMAX, 5))
def _calc(self, session: GameSession, player: Player) -> float: return player.dev_hand().size() + 2 * player.used_dev_hand().size()
import os import sys import random import blessed from Player import * from Monsters import * from Attack import * from debug import * from saveload import * from inventory_player import * from shop import * player = Player() sv = SaveLoad() pinv = P_inv() term = blessed.Terminal() class mainScreen(): def mainLoop(self): while True: os.system('cls') print("1.Play\n2.Load\n3.Exit") ip = input(">>") if(ip== '1'): player_start = playerStart() player_start.char_selection() break if(ip== '2'):
def _calc(self, session: GameSession, player: Player) -> float: return min(player.resource_hand_size(), Consts.MAX_CARDS_IN_HAND)
BACKGROUND.blit(BACKGROUND_TEXTURE, (x, y)) x += BACKGROUND_TEXTURE.get_width() x = 0 y += BACKGROUND_TEXTURE.get_height() display_info = pygame.display.Info() clock = pygame.time.Clock() font = pygame.font.SysFont("Arial", 28) game = True screen_center = screen.get_rect().center pygame.mouse.set_pos(screen_center) background_x = int((screen.get_width() - FIELD_SIZE[0]) / 2) background_y = int((screen.get_height() - FIELD_SIZE[1]) / 2) controller = mousecontroller.MouseController(screen, 50) player = Player.Player(200) while game: for event in pygame.event.get(): if event.type == pygame.QUIT or event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE: game = False mouse_pos = pygame.mouse.get_pos() controller.update_mouse_pos() if controller.get_distance(mouse_pos, screen_center) > 20: background_x -= (mouse_pos[0] - screen_center[0]) // 3 background_y -= (mouse_pos[1] - screen_center[1]) // 3 screen.fill((255, 255, 255)) fps_data = font.render("FPS: " + str(int(clock.get_fps())), True, (0, 0, 0)) screen.blit(BACKGROUND, (background_x, background_y)) angle = -math.degrees(controller.get_angle(screen_center, mouse_pos)) - 90
def _calc(self, session: GameSession, player: Player) -> float: return player.vp()
def won_point(self, player: Player): if player.is_equal(self.__server): self.__server.add_point() else: self.__receiver.add_point()
def _calc(self, session: GameSession, player: Player) -> float: return len(player.harbors())
#-*- coding: utf-8 -*- import Player import LittleCureBottle import Enemys import Theurgy player = Player.Player("wei",10,10, 10,10,10,10,0,10,1) player._exp = 10 player.player_up() print player._level print player._hp, "/", player._maxHp print player._mp, "/", player._maxMp print player._strength player.player_damage(10) print player._hp littleCureBottle = LittleCureBottle.LittleCureBottle() littleCureBottle.use(player) print player._hp enemy = Enemys.Enemy1("a",10,0,0) enemy1 = Enemys.Enemy1("b",20,0,0)
def test(args): player_names = [("Amy", MoveGenerator.TGHuman, { "lang_code": "CH" }), ("Billy", MoveGenerator.RuleBasedAINaive, { "display_step": False, "s_chow": 2, "s_pong": 6, "s_future": 1.5, "s_neighbor_suit": 0, "s_explore": 0, "s_mixed_suit": 0 }), ("Clark", MoveGenerator.RuleBasedAINaive, { "display_step": False, "s_chow": 2, "s_pong": 6, "s_future": 1.5, "s_neighbor_suit": 0, "s_explore": 0, "s_mixed_suit": 0 }), ("Doe", MoveGenerator.RuleBasedAINaive, { "display_step": False, "s_chow": 2, "s_pong": 6, "s_future": 1.5, "s_neighbor_suit": 0, "s_explore": 0, "s_mixed_suit": 0 })] players = [] game = None for player_name, move_generator_class, parameter in player_names: players.append( Player.TGPlayer(move_generator_class, player_name, **parameter)) game = Game.TGGame(players) response, reply = None, None while True: response = game.start_game(response=response) if isinstance(response, TGResponsePromise): print(response.message) response.board.show() i = 0 for text, _ in response.choices: print("%d: %s" % (i, text)) i += 1 while True: try: reply = input("Your choice [0-%d]: " % (len(response.choices) - 1)) reply = int(reply) if reply < 0 or reply >= len(response.choices): raise ValueError break except ValueError: pass response.set_reply(response.choices[reply][1]) else: winner, losers, penalty = response break if winner is None: print("No one wins.") else: print("Winner: %s" % winner.name) print("Loser(s): %s" % (', '.join([player.name for player in losers]))) print("Penalty: %d" % penalty) for item in game.winning_items: print(item)
from Card import * from Deck import * from Player import * deck = Deck() import random random.shuffle(deck) players = [Player("player"+str(i)) for i in range(1,9)] playerCount = len(players) idx = 0 while( deck != []): idx %= playerCount players[idx].getHand().append(deck[0]) deck = deck[1:] idx+=1 del idx for player in players: hand = player.getHand() sameList = {} for i in range(len(Card.Levels())-1): if(not (i in sameList)): sameList[i] = [] for card in hand: if(card.getRawLevel() == i): sameList[i].append(card) if(sameList[i]==[] or len(sameList[i])==1): del sameList[i] for i in sameList: if(sameList[i] !=[] and len(sameList[i])>1):
def test_player_addToScore_adds_correct(self): player = Player_library.Player() self.assertEqual(player.score, 0, "Player score not initialized to 0") player.addToScore() self.assertEqual(player.score, 1, "Player score not adding correctly")
best_move_value = -float('Inf') move = 0 for action in self.root.actions: move_value = self.AlphaBeta(self.root, self.depth, -float('Inf'), float('Inf'), True) if move_value > best_move_value: move = action return move if __name__ == "__main__": board_test = np.array([[0, 0, 0, 0, 0, 0], [0, 1, 7, 3, 4, 0], [0, 2, 7, 1, 3, 0], [0, 4, 7, 4, 1, 0], [0, 1, 7, 2, 2, 0], [0, 0, 0, 0, 0, 0]]) board = Board.Board(4) board.board = board_test Player1 = Player.Player('Max') Player2 = Player.Player('Cam') Game1 = Game.Game([Player1, Player2]) tree = Tree(Game1, 3) AI = MiniMax(tree, 3)
#Main.py import ReverseBoard import Player import ReverseCommon import Game if __name__ == '__main__': black_win = 0 white_win = 0 times = 1 output = True for i in range(times): reverse_board = ReverseBoard.ReverseBoard() black_player = Player.Human(ReverseCommon.BLACK) #black_player = Player.RandomAiKnowGoodMove(ReverseCommon.BLACK) white_player = Player.Human(ReverseCommon.WHITE) #white_player = Player.RandomAiKnowGoodMove(ReverseCommon.WHITE) game = Game.Game(black_player, white_player, reverse_board) game.play(output) if game.get_winner(times) == black_player: black_win += 1 if times == 1: print('[ Winner ]\nBlack') else: white_win += 1 if times == 1: print('[ Winner ]\nWhite') print('[ Total Wins ]') print(f'Black: {black_win}, White: {white_win}')
""" import random from Map_ import * from Player import * from Item import * from Assistant import * from Weapon import * from Bullet import * from Enemy import * from Bag import * import time import os if __name__ == '__main__': birthPoint = (0, 0) player = Player(birthPoint) player.initalizeCharacterStatus() player.getCharacterStatus() cell = Cell() map_ = Map() #map_.mapStructure() #map_.drawMap(cell,birthPoint) itemList = itemList(map_.map, 0.62) itemList.generate() weaponList = weaponList(map_.map, 0.5) weaponList.generate() bulletPackList = bulletPackList(map_.map, 0.52) bulletPackList.generate() enemyList = enemyList(map_.map, 0.7) enemyList.generate(birthPoint) #print(itemList.getList())