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())
