def get(self, lotID):
if 'authenticatedtoken' not in self.session:
return self.redirect('http://' + wlnet + "/CLOT/Auth?p=856960317&state=join/" + str(long(lotID)))
container = lot.getLot(lotID)
inviteToken = self.session['authenticatedtoken']
#Call the warlight API to get the name, color, and verify that the invite token is correct
apiret = hitapi('/API/ValidateInviteToken', { 'Token': inviteToken })
if not "tokenIsValid" in apiret:
return self.response.write('The supplied invite token is invalid. Please contact the CLOT author for assistance.')
#Check if this invite token is new to us
player = Player.query(Player.inviteToken == inviteToken).get()
if player is None:
data = json.loads(apiret)
player = Player(inviteToken=inviteToken, name=data['name'], color=data['color'])
player.put()
logging.info("Created player " + unicode(player))
#Set them as participating in the current lot
addIfNotPresent(container.lot.playersParticipating, player.key.id())
container.players[player.key.id()] = player
container.lot.put()
container.changed()
logging.info("Player " + unicode(player) + " joined " + unicode(container.lot))
self.response.write(get_template('join.html').render({ 'container': container }))
def server_tick():
while True:
try:
Player.send_all({'type': 'serverTick',
'locations': get_all_player_locations(),
})
gevent.sleep(0.1)
except WebSocketError:
pass
def get(self, playerID, lotID):
playerID = long(playerID)
p = Player.get_by_id(playerID)
games = Game.query(Game.players == playerID)
container = lot.getLot(lotID)
currentPlayer = None
if 'authenticatedtoken' in self.session:
inviteToken = self.session['authenticatedtoken']
currentPlayer = Player.query(Player.inviteToken == inviteToken).get()
self.response.write(get_template('viewplayer.html').render({'player': p, 'games': games, 'currentPlayer': currentPlayer, 'container':container}))
def __init__(self):
"""
Initialize a :class:`Game` object.
"""
self.board = Board([1, 2, 3, 4, 5, 6, 7, 8, 9],
[8, 1, 6, 3, 5, 7, 4, 9, 2])
self.magic_square = self.board.magic_square
self.playerX = Player("Player X", "x")
self.playerO = Player("Player O", "o")
self._play = 0
self._win = 1
self._tie = 2
def basicSpriteFactory(self, layername, tileid, x, y, img=None):
if img is None: img = self.sheet[tileid]
if layername == "joueur":
imglist = [self.sheet[i, j] for i, j in ((10, 0), (8, 0), (9, 0), (11, 0))]
p = Player(layername, tileid, x, y, imglist)
if tileid[0] in [10, 8, 9, 11]:
p.translate_sprite(0, 0, 90 * [10, 8, 9, 11].index(tileid[0]))
return p
elif layername == "personnage":
return MovingSprite(layername, tileid, x, y, [img])
else:
return SpriteBuilder.basicSpriteFactory(self, layername, tileid, x, y, img)
def post(self, lotID):
if not TestMode:
return self.response.write("api.TestMode is not enabled. This page should only be used while testing.")
container = lot.getLot(lotID)
if 'ClearData' in self.request.POST:
#User clicked Clear Data, delete all games and players
ndb.delete_multi([o.key for o in Game.query(Game.lotID == container.lot.key.id())])
container.lot.playersParticipating = []
container.lot.playerRanks = []
container.lot.put()
container.changed()
memcache.flush_all()
TestPage.renderPage(self, lotID, 'Deleted all games and players')
elif 'RunCron' in self.request.POST:
#Just execute the same thing that we'd do if we hit /cron, but also time it
start = datetime.now()
cron.execute(self.request, container)
TestPage.renderPage(self, lotID, 'Cron finished in ' + unicode(datetime.now() - start))
elif 'AddPlayers' in self.request.POST:
#Add some dummy player data. It won't work on warlight.net of course, but if TestMode is enabled it won't ever be passed there. Just be sure and delete it before disabling TestMode.
numPlayers = long(self.request.POST["NumPlayers"])
for z in range(numPlayers):
name = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(5))
p = Player(name=name, inviteToken=name, color="#0000FF")
p.put()
container.lot.playersParticipating.append(p.key.id())
container.lot.put()
container.changed()
TestPage.renderPage(self, lotID, 'Added ' + str(numPlayers) + ' fake players')
elif 'FlushCache' in self.request.POST:
if memcache.flush_all():
TestPage.renderPage(self, lotID, 'Deleted everything from cache')
else:
TestPage.renderPage(self, lotID, 'Error while trying to flush cache')
elif 'Test' in self.request.POST:
#Just a blank space for testing random stuff
TestPage.renderPage(self, lotID, 'Ran test code')
else:
self.response.write("No handler")
def get(self, lotID):
currentPlayer = None
if 'authenticatedtoken' in self.session:
inviteToken = self.session['authenticatedtoken']
currentPlayer = Player.query(Player.inviteToken == inviteToken).get()
container = lot.getLot(lotID)
self.response.write(get_template('viewlot.html').render({'container': container, 'currentPlayer': currentPlayer, 'lotrendered': container.render('renderlot.html') }))
def ski_ws_handler(ws):
player = None
try:
player = Player._init(ws)
while True:
m = ws.receive()
if m:
try:
m = json.loads(m)
except ValueError:
err = 'Not valid JSON: %s' % m
print err
player.error(err)
if isinstance(m, dict) and 'type' in m:
route_typed_message(player, m)
finally:
if player:
Player._cleanup(player)
def __init__(self):
# Create the deck
self.deck = Deck(6)
# Create the player
self.player = Player(self.deck)
# Create the dealer
self.dealer = Dealer(self.deck, [self.player])
def get(self, lotID):
if 'authenticatedtoken' not in self.session:
############################################### SET TO main before going live ##################################
# main - 5015900432
# test - 314032996
return self.redirect('http://' + wlnet + "/CLOT/Auth?p=3022124041&state=join/" + str(long(lotID)))
container = lot.getLot(lotID)
inviteToken = self.session['authenticatedtoken']
templates = [655094]
templateIDs = ','.join(str(template) for template in templates)
logging.info("current templates in use : " + templateIDs)
#Call the warlight API to get the name, color, and verify that the invite token is correct
tempapiret = hitapi('/API/ValidateInviteToken', { 'Token': inviteToken, 'TemplateIDs': templateIDs})
logging.info('tempapi return value' + str(tempapiret))
logging.info("invite token = " + inviteToken)
if (not "tokenIsValid" in tempapiret) or ("CannotUseTemplate" in tempapiret):
return self.response.write('The supplied invite token is invalid. Please contact the CLOT author for assistance.')
#Check if this invite token is new to us
player = Player.query(Player.inviteToken == inviteToken).get()
data = json.loads(tempapiret)
currentColor = data['color']
currentName = data['name']
if player is None:
player = Player(inviteToken=inviteToken, name=currentName, color=currentColor, customProperties = {}, numberOfGamesAtOnce=5)
player.put()
logging.info("Created player " + unicode(player))
else:
# Update player details
if currentColor != player.color:
player.color = currentColor
if currentName != player.name:
player.name = currentName
player.put()
logging.info("Update player metadata for " + unicode(player))
#Set them as participating in the current lot
addIfNotPresent(container.lot.playersParticipating, player.key.id())
container.players[player.key.id()] = player
container.lot.put()
container.changed()
logging.info("Player " + unicode(player) + " joined " + unicode(container.lot))
self.response.write(get_template('join.html').render({ 'container': container }))
def connect(self, name):
# require character name
if not name:
self.write("Character name required. Disconnecting...")
self.close()
#self.write("Character creation currently disabled. Sorry!")
#self.disconnect()
# initialize player
self.player = Player(self, name)
self.player.init()
def get(self):
gs = Game.all()
games_info = []
for g in gs:
players = Player.gql('WHERE gid = :1', g.key().id())
maxTime = 0
if players:
maxTime = max(map(lambda x: x.lastCheckin, players))
games_info.append((g.key().id(), maxTime, players.count()))
self.response.out.write(json.dumps(games_info))
def get(self):
gid = long(self.request.get('gid'))
lat = self.request.get('lat')
lng = self.request.get('lng')
pacman = True
if self.request.get('pacman') == 'false':
pacman = False
p = Player()
p.gid = gid
p.lat = long(lat)
p.lng = long(lng)
p.isPacman = bool(pacman)
p.lastCheckin = long(time.time() * 1000)
p.put()
dotdict = Dot.dotsAsDict(gid)
response = {'pid' : p.key().id(), 'dots' : dotdict}
self.response.out.write(json.dumps(response))
def get(self, lotID):
if 'authenticatedtoken' not in self.session:
return self.redirect('http://' + wlnet + "/CLOT/Auth?p=3022124041&state=leave/" + str(long(lotID)))
container = lot.getLot(lotID)
inviteToken = self.session['authenticatedtoken']
#Find the player by their token
player = Player.query(Player.inviteToken == inviteToken).get()
if not player:
return self.response.write("Invite token is invalid. Please contact the CLOT author for assistance.")
#When they leave, remove them from this lot
if player.key.id() in container.lot.playersParticipating:
container.lot.playersParticipating.remove(player.key.id())
container.lot.put()
container.changed()
logging.info("Player left LOT " + unicode(player))
self.response.write(get_template('leave.html').render({ 'container': container }))
def get(self, playerID, lotID, numberOfGames):
playerID = long(playerID)
if 'authenticatedtoken' not in self.session:
return self.redirect('/')
inviteToken = self.session['authenticatedtoken']
player = Player.query(Player.inviteToken == inviteToken).get()
if player.key.id() != playerID :
''' Not the logged in user'''
return self.redirect('/lot/'+ lotID)
container = lot.getLot(lotID)
if numberOfGames != None:
player.numberOfGamesAtOnce = int(numberOfGames)
player.put()
container.players[player.key.id()] = player
container.changed()
self.redirect('/player/playerId=' + str(playerID) + '&&lotId=' + lotID)
def test_get_hand_value(self):
p = Player()
p.add_card_to_hand(3)
self.assertEqual(p.get_hand_value(), 3)
p.add_card_to_hand(4)
self.assertEqual(p.get_hand_value(), 7)
p.add_card_to_hand(2)
self.assertEqual(p.get_hand_value(), 9)
def test_get_hand_len(self):
p = Player()
p.add_card_to_hand(3)
self.assertEqual(p.get_hand_len(), 1)
p.add_card_to_hand(4)
self.assertEqual(p.get_hand_len(), 2)
p.add_card_to_hand(4)
self.assertEqual(p.get_hand_len(), 3)
class Client(Dispatcher):
def __init__(self, server, sock):
# initialize dispatcher
Dispatcher.__init__(self, sock)
# assign instance properties
self.server = server
self.player = None
# greet player
self.write("Welcome to the MUD!")
self.prompt("Please enter your name: ", self.connect)
def connect(self, name):
# require character name
if not name:
self.write("Character name required. Disconnecting...")
self.close()
#self.write("Character creation currently disabled. Sorry!")
#self.disconnect()
# initialize player
self.player = Player(self, name)
self.player.init()
def read(self):
# read data from dispatcher
data = Dispatcher.read(self)
# return if player is not authenticated
if not self.player.authed: return
# return prompt if no data was returned
if not data:
self.write_prompt()
return
# split data by words
words = data.strip().split(' ')
# return if no human readable input was found
if not words:
self.write_prompt("What?")
return
# determine command
command = words[0].lower()
# attempt to import command module
try:
module = importlib.import_module('commands.%s' % command)
except ImportError:
self.write_prompt("What?")
return
# determine command class object
module = getattr(module, command, None)
if not module:
logger.error("Command module '%s' found but no class defined!" % command)
self.write_prompt("What?")
return
# initialize command
command = module(self.player)
# execute command
command(' '.join(words[1:]))
# output player prompt
self.write_prompt()
# # TODO: working
# line = self.chat.get_line(words[0])
# if line: # and Player.level >= chat_line[0][0]
# self.chat.send(line[0][1], ' '.join(words[1:]))
# # TODO: end working
def write_prompt(self, msg=None):
# output message if requested
if msg: self.write(msg)
# output player prompt
self.write("%s > " % self.player.prompt, False)
import datetime as dt
from games import Game
from players import Player
game = Game("NFL", dt.datetime.now())
print(game)
player = Player("Veena", 0)
print(player)
deal(deck, starter.next_player)
play_game(table, discards, deck, dealer.next_player)
# Welcome message
print "------------------"
print "WELCOME TO HEARTS!"
print "By: Andrew Lawson"
print "------------------"
time.sleep(2)
# Initialize table
table = []
discards = []
# Initialize players
# Temporary global var (will remove)
global human
human = Player('Player', 0)
cpuOne = Player('CPU1', 0)
cpuTwo = Player('CPU2', 0)
cpuThree = Player('CPU3', 0)
human.next_player = cpuOne
cpuOne.next_player = cpuTwo
cpuTwo.next_player = cpuThree
cpuThree.next_player = human
# Intialize deck
cards = []
for suit in ['C', 'H', 'D', 'S']:
for value in range(2, 15):
card = Card(suit, value)
cards.append(card)
deck = Deck(cards)
play_game(table, discards, deck, human)
__author__ = 'luke'
import random
from deck import Deck
from hand import Hand
from cards import Card
from players import Player
# get shuffeled deck
deck = Deck()
# get Players
luke = Player("luke")
toni = Player("toni")
# deal cards
while len(deck.cards) > 0:
luke.recive_card(deck.deal_one())
toni.recive_card(deck.deal_one())
print("lukes cards" + str(luke.deck))
print("deck" + str(deck.cards))
# start playing hands
count = 0
luke_max_cards = 0
pile = []
while (len(toni.deck) > 0) and (count < 2000000) and (len(luke.deck) > 0):
lukes_card = Card(luke.top_card())
tonis_card = Card(toni.top_card())
print(lukes_card.name + " vs " + tonis_card.name)
def example_players_4(example_board):
players_4 = []
for i in range(4):
players_4.append(Player(i, 15, example_board))
return players_4
def __init__(self, num_shuffles=1):
self.num_shuffles = num_shuffles
self.dealer = Dealer(name='Dealer')
self.player = Player(name='1')
self.game_over = False
return temp
deck.shuffleDeck()
playerData = []
handName = []
name = 65
suit = {'s':'Spades','c':'Clubs','h':'Hearts','d':'Diamonds','j':11,'t':10,'k':13,'q':12,'a':14,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
# card = [['ts','js','qs','ks','as'],['9s','9h','9d','9c','8s'],['8h','8d','8c','7s','7h'],['6s','6h','6d','5s','4s']]
# card = [['ts','js','qh','as','kh'],['3d','3s','3h','2h','2s'],['jc','qc','kc','7c','8c'],['2c','3c','4c','5c','6c']]
card = [['ah','3h','4h','9h','th'],['8h','8s','jh','jd','4c'],['2s','2d','2c','2h','3s'],['jc','js','5h','5c','3d']]
for player in card:
h = []
for i in player:
h.append(Card(suit[i[0]],suit[i[1]]))
playerData.append(Player(chr(name),Hand(h)))
name += 1
# hand = [deck.pickACard() for i in range(5)]
# playerData.append(Player(chr(name),hand))
# name=name+1
# for i in playerData:
# print(i,i.handScore,i.hand)
print(sortDict(playerData))
for i in playerData:
print(i,i.hand)
"""
def setup(self, player, deck):
self.player = [Player(),
Dealer()]
self.deck = deck
print ("\nYOU LOSE! YOU BUSTED! ¯\_(ツ)_/¯\n")
sys.exit()
elif user_hand.get_value() == dealer_hand.get_value():
print("\nIT'S A TIE! DEALER WINS!\n")
sys.exit()
elif dealer_hand.get_value() > user_hand.get_value():
print("\nDEALER WINS!!!\n")
sys.exit()
elif user_hand.get_value() > dealer_hand.get_value():
print("\nYOU WIN!\n")
sys.exit()
# game = Game()
while True:
game = Game()
user = Player("Danielle")
dealer = Player("Dealer")
deck = Deck()
deck.shuffle_deck()
user_hand = Hand(user)
dealer_hand = Hand(dealer)
print("{}'s hand is".format("Your"))
user_hand.add_card(deck.deal_card())
user_hand.add_card(deck.deal_card())
user_hand.show()
print("\n{}'s hand is".format("Dealer"))
dealer_hand.add_card(deck.deal_card())
dealer_hand.add_card(deck.deal_card())
dealer_hand.show()
print("\n")
from turtle import Screen
from players import Player
from cars import CarManager
from scoreboard import Score
import time
screen = Screen()
screen.screensize(600, 600)
screen.tracer(0)
player = Player()
cars = CarManager()
score = Score()
screen.listen()
screen.onkey(player.move_up, "Up")
screen.onkey(player.move_down, "Down")
game_on = True
while game_on:
screen.update()
time.sleep(0.1)
cars.create_car()
cars.move_car()
if player.level_up():
player.go_to_start()
cars.speed_up()
score.points()
for car in cars.all_cars:
from config import App
from players import Player, Enemy
SCREEN_WIDTH = App.config("SCREEN_WIDTH")
SCREEN_HEIGHT = App.config("SCREEN_HEIGHT")
BG_COLOUR = App.config("BG_COLOUR")
pg.init()
screen = pg.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
clock = pg.time.Clock()
ADD_ENEMY = pg.USEREVENT + 1
pg.time.set_timer(ADD_ENEMY, 250)
player = Player()
enemies = pg.sprite.Group()
all_sprites = pg.sprite.Group()
all_sprites.add(player)
running = True
while running:
for event in pg.event.get():
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
running = False
elif event.type == QUIT:
running = False
def getPlayerName(self):
player = input("Enter your nickname> ")
session.add(Player(name=player))
session.commit()
print("Player added succesfully to the DB")
def example_player(example_board):
return Player(0, 15, example_board)
from board import Board
from players import Player
board = Board()
player_x = Player(" X ")
player_y = Player(" O ")
current_player = player_x
game = True
while game:
square_number = current_player.put_mark(current_player.mark,board)
board.squares[square_number] = current_player.mark
board.draw_board()
if board.check_win(current_player.mark):
print(f"Player {current_player.mark} wins!!!")
game = False
if current_player == player_x:
current_player = player_y
elif current_player == player_y:
current_player = player_x
def example_players_6(example_board):
players_6 = []
for i in range(6):
players_6.append(Player(i, 12, example_board))
return players_6
pass
else:
instructions()
print(start_text)
board = board_at_start
while not game_winner:
if (move % 2) == 0:
playing_player = player2
else:
playing_player = player1
print_board(board)
board = player_move(playing_player, board)
board = check_if_player_has_a_queen(playing_player, board)
game_winner = check_if_player_won(player1, player2, board)
move += 1
print("Congratulations, " + game_winner.name + ", you won!!!! ")
print(game_winner.color + """ o
o^/|\\^o
o_^|\\/*\\/|^_o
o\\*`'.\\|/.'`*/o
\\\\\\\\\\\\|//////
{><><@><><}
`\"\"\"\"\"\"\"\"\"`""" + Style.end)
if __name__ == "__main__":
red_player = Player(Style.Foreground.red, "Red", DIRECTIVE_DOWN)
blue_player = Player(Style.Foreground.blue, "Blue", DIRECTIVE_UP)
main(red_player, blue_player)
def basicPlayerFactory(self, tileid=None, x=0.0, y=0.0, img=None):
assert not img is None
return Player("joueur", tileid, x, y, [img])
lvl_p_win1 = pygame.image.load('lvl_p.jpg')
tutor = pygame.image.load('tutor.jpg')
player2 = ('find1.png')
player1 = ('geo.png')
pl1win = pygame.image.load('1win.jpg')
pl2win = pygame.image.load('2win.jpg')
limit = ('lim.png') # Картинка для платформы
x1 = 5
y1 = 655
up1 = False # Переменная, отвечающаяя на вопрос, находится ли игрок1 в прыжке
x2 = 5
y2 = 655
up2 = False # Переменная, отвечающаяя на вопрос, находится ли игрок2 в прыжке
# След. две переменные запихиваем в класс Player
# (соотв-но они теперь обладают всеми свойствами класса)
pl2 = Player(x2, y2, player2)
pl1 = Player(x1, y1, player1)
# ============================================================================
left1 = left2 = right1 = right2 = False # переменные, отвечающие, движется
# ли игрок вправо/влево
# Intro ======================================================================
pygame.mixer.music.load('opening.mp3')
pygame.mixer.music.play(-1)
skip = 0
while skip < 450: # 450
win.blit(logo, (0, 0))
pygame.display.update()
skip += 1
skip = 0
# Чудесная композиция ========================================================
class GamePlay:
def __init__(self):
self.player_1 = None
self.player_2 = None
self.board = Board()
self.note = LogLog()
def get_color(self):
if self.player_1.color == 4:
return 3
return 4
def start(self):
self.player_1 = Player()
self.player_2 = SmartRandom(self.get_color(), self.board)
if self.player_1.color == 4:
print('\nВы играете за БЕЛЫХ!\n')
k = 1 # Определяет очередность хода
else:
print('\nВы играете за ЧЕРНЫХ!\n')
k = 0 # Определяет очередность хода
load('loading')
print('x - Пустые черные клетки\nБ - белая шашка\nЧ - черная шашка\n'
'\nh1 - поставить шашку в клетку h1'
'\nb1->c2 - ход из клетки b1 в клетку c2\n'
'd3->f5 - бой из клетки d3 через клетку e4 в клетку f5\n')
print('Всё понятно?\n')
input_()
load('\nЗагружаю доску')
self.board.render()
print(' |----------- Давайте расставим шашки -----------|\n')
self.fill(k)
winner, log_ = self.game(k)
if winner == 'w4' and self.player_1.color == 4 or winner == 'w3' and self.player_1.color == 3:
print('\n |' + 47 * '*' + '|')
print(' |------------------- ПОБЕДА! -------------------|')
print(' |' + 47 * '*' + '|')
else:
print('\n |----- Вы проиграли. Повезет в другой раз! -----|\n')
try:
self.log(log_)
except IndexError:
self.note.write('Случилась партия без ходов')
self.end()
def fill(self, k):
def queue(self, k):
if k % 2: # человек
self.player_1.step()
place = self.player_1.placement()
while not self.board.fill(self.player_1.color, place):
incorrect_()
place = self.player_1.placement()
else: # робот
self.player_2.step()
place = self.player_2.placement()
print('Робот:', place)
self.board.fill(self.player_2.color, place)
k += 1
self.board.render()
return k
if k == 1:
while k != 13:
k = queue(self, k)
else:
while k != 12:
k = queue(self, k)
def game(self, k):
print('\n |----------------- Начало игры -----------------|\n')
color = 4
status = self.board.peek(color)
cmd = ''
command = ''
while status != 'w3' or status != 'w4':
cmd += command + ' '
if k % 2: # человек
color = self.player_1.color
status = self.board.peek(color)
if status != 'w3' and status != 'w4':
self.player_1.step()
command = self.player_1.move()
step = self.board.check(color, command)
if step == 1:
self.board.render()
elif step == 0:
while step != 1:
incorrect_()
command = self.player_1.move()
step = self.board.check(color, command)
self.board.render()
elif isinstance(step, tuple):
while step != 1:
try:
print(f'Нужно бить! Подсказка: {step[1]}')
except TypeError:
incorrect_()
command = self.player_1.move()
step = self.board.check(color, command)
self.board.render()
else:
return status, cmd[1:-1]
else: # робот
color = self.player_2.color
status = self.board.peek(color)
if status != 'w3' and status != 'w4':
self.player_2.step()
command = self.player_2.move()
print('Робот:', command)
self.board.check(color, command)
self.board.render()
else:
return status, cmd[1:-1]
status = self.board.peek(color)
k += 1
return status, cmd[1:-1] + ' ' + command
def end(self):
while True:
print(
'\n!log - показать журнал игры\n!export - сохранить журнал игры'
'\n!exit - вернуться в главное меню\n')
command = input_()
if command == '!log':
print('\nЖУРНАЛ ИГРЫ\n')
print(self.note.log)
elif command == '!export':
self.note.export()
print(
'\nЖурнал сохранен в текущей директории с именем game_log.txt'
)
elif command == '!exit':
load('Выход')
return
else:
incorrect_()
def log(self, s: str):
"""Преобразование команд в необходимый формат и запись в журнал игры"""
c = ''
def reformat(c):
tmp = c.split('->')
if abs(int(tmp[0][-1]) - int(tmp[1][-1])) == 2:
return ':'.join(tmp)
return '-'.join(tmp)
if len(s) == 6:
self.note.write(reformat(s) + 'X')
return
s = s.split(' ')
for i in range(len(s) - 1):
if i % 2 == 0:
c += reformat(s[i]) + ' ' + reformat(s[i + 1]) + ' '
if len(s) % 2:
c += reformat(s[-1]) + ' '
c = c[:-1] + 'X'
c = c.split(' ')
for i in range(len(c) - 1):
if i % 2 == 0:
self.note.write(c[i] + ' ' + c[i + 1])
if len(c) % 2:
self.note.write(c[-1])
def basicPlayerFactory(self,tileid,x=0.0,y=0.0):
imglist = [self.sheet[i, j] for i, j in ((10, 0), (8, 0), (9, 0), (11, 0))]
p = Player("joueur", tileid, x, y, imglist)
if tileid is not None and tileid[0] in [10, 8, 9, 11]:
p.translate_sprite(0, 0, 90 * [10, 8, 9, 11].index(tileid[0]))
return p
def test_set_get_wager(self):
p = Player()
for x in range(1, 10):
p.set_wager(x)
self.assertEqual(x, p.get_wager())
def test_set_get_wager(self):
p = Player()
self.assertRaises(ValueError, p.set_wager(0))
self.assertRaises(ValueError, p.set_wager(-1))
class BlackJack:
"""Main class of pyBlackJack. Define a BlackJack game with a 6-deck shoe, one player and one dealer."""
def __init__(self):
# Create the deck
self.deck = Deck(6)
# Create the player
self.player = Player(self.deck)
# Create the dealer
self.dealer = Dealer(self.deck, [self.player])
def start(self):
"""Starts the game. A game ends when the player has no more chips."""
# Print game's title
asciiArts.print_title()
utils.print_separator()
# While the player has enough money to play
while self.player.get_bankroll() > 0:
# Display player's bankroll
print("Your current bankroll is: " + str(self.player.get_bankroll())) + " chips."
# Play a game
self.play()
# End
self.end()
print("Thank you for playing pyBlackJack!")
def play(self):
"""Play a round. The player first bets and then play his hand(s)."""
# Clear player's and dealer's hand
self.player.clear()
self.dealer.clear()
#################
# Ask for a bet #
#################
bet = self.bet_step()
# Register player's bet
self.player.bet(bet)
##############
# Deal cards #
##############
# If the dealer has dealt 75% of the cards, then shuffle a new deck
if self.deck.get_number_of_cards_left() < 78:
self.deck = Deck(6)
print("Dealing...")
self.dealer.deal()
utils.print_separator()
self.print_dealer_hand(False)
#########
# Split #
#########
self.split_step()
##############
# Play Hands #
##############
for i in range(len(self.player.hands)):
self.player.hand = self.player.hands[i]
self.play_hand(i)
def end(self):
"""End of player's turn. The dealer plays and unveils his cards. The results are then displayed."""
self.dealer.unveil_cards()
self.dealer.hit_long()
self.print_dealer_hand(True)
self.display_results()
def bet_step(self):
"""The player choses how many chips he wants to bet."""
while True:
# Ask for the bet
bet = utils.read_integer("Enter your bet (1 chip minimum): ")
bankroll = self.player.get_bankroll()
# If the bet is less than player's bankroll and higher than 1 chip, play the round
if bet <= bankroll and bet >= 1:
return bet
# The bet is higher than player's bankroll
elif bet >= bankroll:
print("You cannot bet more than your current bankroll!")
continue
# The bet is lower than 1 chip
elif bet < 1:
print("The minimum bet is 1 chip!")
continue
# Other cases
else:
print("Wrong bet. Please enter a positive number greater than 1.")
continue
def split_step(self):
"""If player's hand is a pair, he has to choose whether he wants to split it or not."""
for i in range(len(self.player.hands)):
self.player.hand = self.player.hands[i]
# Check if player's hand is splittable (Player can play a maximum of 4 hands at the same time)
if self.player.hand.is_splittable() and len(self.player.hands) < 4:
# Print player's hand
utils.print_separator()
print("Player's hand #" + str(i) + ":\n")
self.print_player_hand()
# Ask player whether he wants to split the hand or not
do_split = utils.read_boolean("Do you want to split? (Y/N)")
if do_split:
# Check if player has enough chips to split
if self.player.can_split():
# Split the hand
self.player.split()
# Recursive call of split_bet to check if the new hands can also be split
self.split_step()
break
else:
print("Sorry, you don't have enough chips to split!")
def play_hand(self, i):
"""Play a hand."""
# Print player's hand
utils.print_separator()
print("Player's hand #" + str(i) + ":\n")
self.print_player_hand()
# Check if the hand is a BlackJack
if self.player.hand.is_blackJack():
self.player.hand.status = "blackjack"
print("Congratulations! You got a Blackjack!\n")
else:
while self.player.hand.status == "active":
# Ask for player's next move
action = utils.multiple_choice_question("[H]it or [S]tand? (H/S): ", ["h", "s"])
utils.print_separator()
# If he stands
if action == "s":
# Finish the current hand
self.player.hand.status = "finished"
# If he hits
elif action == "h":
# Hit
self.player.hit()
self.print_player_hand()
# Check if player is busted
if self.player.is_busted():
self.player.hand.status = "busted"
print("You bust!\n")
def display_results(self):
"""Compute player's gain and display results at the end of the round."""
gain = 0
# Check if dealer is busted
if self.dealer.is_busted():
print("Dealer is busted!\n")
# Compute player's gain. Loop through player's hands
for hand in self.player.hands:
if hand.is_blackJack():
gain += 2.5 * self.player.get_bet()
elif hand.status == "finished":
gain += 2 * self.player.get_bet()
# Dealer got a BlackJack
elif self.dealer.hand.is_blackJack():
print("Dealer got a BlackJack!\n")
# Compute player's gain. Loop through player's hands
for hand in self.player.hands:
if hand.is_blackJack():
gain += self.player.get_bet()
# Dealer has neither busted nor got a BlackJack
else:
# Compute player's gain. Loop through player's hands
for hand in self.player.hands:
if hand.is_blackJack():
gain += 2.5 * self.player.get_bet()
elif hand.status == "finished":
if hand.get_value() > self.dealer.hand.get_value():
gain += 2 * self.player.get_bet()
elif hand.get_value() == self.dealer.hand.get_value():
gain += self.player.get_bet()
# Add gain to player's account
self.player.bankroll += gain
# Player wins chips
if gain > 0:
print(
"You won " + str(gain) + " chip(s)! Your new bankroll is: " + str(self.player.get_bankroll())
) + " chips."
# Player loses chips
else:
loss = len(self.player.hands) * self.player.get_bet()
print(
"You lost " + str(loss) + " chip(s)... Your new bankroll is: " + str(self.player.get_bankroll())
) + " chips."
utils.print_separator()
utils.print_separator()
def print_dealer_hand(self, with_value):
"""Print dealer's hand."""
print("Dealer's hand:\n")
if with_value:
print("value: " + str(self.dealer.hand.get_value()) + "\n" + str(self.dealer.hand))
else:
print(str(self.dealer.hand))
def print_player_hand(self):
"""Print player's current hand."""
hand = self.player.hand
print("value: " + str(hand.get_value()) + "\n" + str(hand))
def test_default_player_yards(self):
player = Player(name='Dude')
self.assertEqual(player.yards, 120)
"""
# Create array to hold players
players = []
board = GameBoard()
print "\nWelcome to the TIC-TAC-TOE game!\n"
# Hard code this for now - will prompt later
num_players = get_num_humans()
player_cnt = 0
# Prompt for player's names and then create player
while player_cnt < num_players:
# Use static method to get name
name = Player.get_player_name()
# Create player and add to player list
players.append(Player(name, board, player_cnt))
player_cnt += 1
# If only one human player, will need to add a computer player.
if len(players) == 1:
players.append(ComputerPlayer("Computer", board, player_cnt))
playing_game = True
while playing_game:
# Randomly select first player
set_play_order(players)
print "\nMATCH: %s vs. %s" % (players[0].get_name(), players[1].get_name())
def test_player_yards_set_to(self):
player = Player(name='OtherDude', yards=150)
self.assertEqual(player.yards, 150)
clear_screen()
print("#" * 20)
print("GAME OVER: FINAL SCORE BELOW")
for ply in players:
print(ply)
print("{} Your board below".format(ply.player_name))
ply.print_board(1)
print("\n")
if players[0].occupied_cords:
print("Winner is {} Good job".format(players[0].player_name))
else:
print("Winner is {}. Great!!".format(players[1].player_name))
break
if __name__ == "__main__":
player_1 = Player()
player_2 = Player()
players = [player_1, player_2]
game_loop(players)
while True:
clear_screen()
prompt = input("All ships on board now. Hit ENTER to start attacking")
if not prompt:
break
else:
continue
attack(players)
class Raffle(object):
"""This class represents a game from begging to the end. It inits instance of Dealer and Player classes,
list of unique numbers from 1 to 90, counts of rounds played, list of selected numbers and flag is_game_over.
Methods of this class includes:
- random selection of a number for a round,
- steps that need to be done to play one round of a game,
- evaluation is game is over,
- printout to console information about selected number, which includes number of a round played, selected number
and a "funny" name of this number,
- printout a game-over message.
"""
def __init__(self):
self.my_card = Player()
self.comp_card = Dealer()
self.qt_rounds_played = 0
self.numbers_left = list(range(1, 91))
self.numbers_played = []
self.is_game_over = False
def number_selection(self):
"""This method selects a random number from the list of available for this game. Every time it "shakes" or
shuffle the list to make the choice more random. To maintain the uniqueness selected number is removed from
list of available. It also keep tracking the qt of rounds played and updates list of numbers_played.
:return: number: int
"""
random.shuffle(self.numbers_left)
try:
self.number = self.numbers_left.pop()
self.numbers_played.append(self.number)
self.qt_rounds_played += 1
except IndexError:
print("Боченков не осталось!")
self.number = None
return self.number
def print_selected_number(self):
"""Prints to console selected number and info about qt numbers left in pretty way.
"""
print()
print(f"РАУНД {self.qt_rounds_played}")
try:
print(
f"Выпало число: {self.number}! {str(number_names[self.number])}"
)
except KeyError:
print(f"Выпало число: {self.number}!")
print(f"Осталось {len(self.numbers_left)} боченков \n")
def play_a_round(self):
"""This method defines sequence of needed methods in every round of the game. This sequence is repeated untill
the game is over.
"""
number = self.number_selection()
self.print_selected_number()
self.comp_card.print_a_card()
self.my_card.print_a_card()
self.comp_card.find_the_num_in_card(number)
self.my_card.underline_number(number, self)
self.findout_is_gameover()
def findout_is_gameover(self):
"""This method checks if all numbers in players's cards are guessed.
"""
if not self.is_game_over:
self.is_game_over = True if (
self.my_card.number_guessed == 15
or self.comp_card.number_guessed == 15) else False
return self.is_game_over
def print_endgame_message(self):
"""This method evaluates the message that should be printed according to who has won the game in a pretty way.
It also prints statistic information about the game:
- how many rounds were played,
- what numbers were selected,
- how many numbers have left,
- what are these left numbers.
"""
message = "Вы выиграли!" if self.my_card.number_guessed == 15 else "Компьютер выиграл!"
print(message)
end_message = f"Игра закончена!\n" \
f"В игре прошло {self.qt_rounds_played} раундов \n" \
f"Выпали числа: {self.numbers_played} \n" \
f"Осталось {len(self.numbers_left)} чисел \n" \
f"{self.numbers_left}"
print(end_message)
def game_loop2(rolls):
computer_score = 0
user_score = 0
#for val in rolls:
# print(str(val.name) + str(val.defeats) + str(val.loses))
print(header)
print(intro)
print(footer)
value = input("What is your name? ")
program_log.trace("Username is {}".format(value))
player = Player(value)
print(f'Welcome {value}!\n')
rounds = int(input("How many rounds would you like to play? "))
program_log.trace("The user chose {} rounds".format(rounds))
i = 0
while i < rounds:
chosen_roll = input(
"\nPlease play Rock, Gun, Lightning, Devil, Dragon, Water, Air, Paper, Sponge, Wolf, Tree, Human, Snake, Scissors or Fire "
)
chosen_roll = chosen_roll.lower()
if any(x.name == chosen_roll for x in rolls):
program_log.trace("Roll number {} the player chose {}".format(
i + 1, chosen_roll))
print("")
else:
program_log.warn(
"The User did not choose a valid value: {}".format(
chosen_roll))
chosen_roll = process_roll(chosen_roll, rolls)
computer_roll = random.choice(rolls)
if chosen_roll in computer_roll.loses:
print("Your {} beat their {}".format(chosen_roll,
computer_roll.name))
user_score += 1
i += 1
elif computer_roll.name == chosen_roll:
print("Your {} tied their {}".format(chosen_roll,
computer_roll.name))
i += 1
rounds += 1
elif chosen_roll in computer_roll.defeats:
print("Your {} lost to their {}".format(chosen_roll,
computer_roll.name))
i += 1
computer_score += 1
print("\nUser Score: " + str(user_score))
print("Computer Score: " + str(computer_score))
if user_score > computer_score:
print("\nYou won :)")
elif computer_score > user_score:
print("\nYou lost :(")
else:
print("\nYou tied the computer")
self.DealersHand.remove(Pass[0])
self.DealersHand.remove(Pass[1])
Player.pDeck.extend(Pass)
def Flop(self, Table):
Reset = self.DealersHand
Pass = choices(Reset, k=3)
for i in range(3):
self.DealersHand.remove(Pass[i])
Table.Cardsout.extend(Pass)
def Turn_and_River(self, Table):
Reset = self.DealersHand
Pass = choices(Reset, k=1)
self.DealersHand.remove(Pass)
Table.Cardsout.extend(Pass)
Ajani = Player("Ajani")
Tam = Dealer("Tam")
Suite = Deck("Suite")
Tam.EquipDeck(Suite)
Tam.ShuffleNPass(Ajani)
from cards import Card, Deck
from players import AI, Player
print "Welcome to the Hearts Game."
print "Setting up..."
deck = Deck()
player = Player()
cpus = [AI("CPU 1"), AI("CPU 2"), AI("CPU 3")] # The CPUs are each in a list, making them easier to be referred to
for i in cpus:
deck = i.deal(deck, 52 / 4) # Deal to CPU
deck = player.deal(deck, 52 / 4) # Deal to player
done = False
playerOrder = [player, cpus[0], cpus[1], cpus[2]]
heartsBroken = False
while not done: # main loop
cardsPlayed = []
leading = True # being lazy here
print "\n--- New Trick ---\n"
for i in playerOrder:
if len(i.hand) == 0:
done = True
break
play = i.play(leading, heartsBroken, cardsPlayed, 4)
print play[0]
cardsPlayed.append(play[1])
leading = False
class Game(object):
"""
A :class:`Game` object which instantiates
the other objects and contains the business logic.
"""
def __init__(self):
"""
Initialize a :class:`Game` object.
"""
self.board = Board([1, 2, 3, 4, 5, 6, 7, 8, 9],
[8, 1, 6, 3, 5, 7, 4, 9, 2])
self.magic_square = self.board.magic_square
self.playerX = Player("Player X", "x")
self.playerO = Player("Player O", "o")
self._play = 0
self._win = 1
self._tie = 2
def start(self):
"""
Assign players based on user input.
"""
player = self.board.assign_player_input()
if player == 'x':
player = self.playerX
self.play(player)
elif player == 'o':
player = self.playerX
self.adjust_lists(player, 4)
self.board.print_board()
player = self.playerO
self.play(player)
def play(self, player):
"""
Start playing the game.
"""
do = True
while do is True:
space = self.board.move_input()
if type(space) == int:
move = self.eval_move(player, space)
self.board.print_board()
do = True
def eval_move(self, player, move):
"""
Figure out which player moves first.
"""
if player.name == "Player X":
return self.move_playerX(move)
else:
return self.move_playerO(move)
def move_playerX(self, move):
"""
Move the person-controlled player.
"""
self.adjust_lists(self.playerX, move)
result = self.playerX.check_game_over()
if result == self._play:
return self.move_ai(self.playerO)
else:
self.print_result(self.playerX.name)
def move_playerO(self, move):
"""
Move the person-controlled player.
"""
self.adjust_lists(self.playerO, move)
result = self.playerO.check_game_over()
if result == self._play:
return self.move_ai(self.playerX)
else:
self.print_result(self.playerO.name)
def move_ai(self, player):
"""
Move the ai-controlled player.
"""
opp_player = self.opp_player(player)
# First check to see if the ai player has a winning move
result, move = player.check_for_winning_move(self.magic_square)
# If the ai player has a winning move, make it and print results
if result == self._win and type(move) is int:
self.adjust_lists(player, move)
self.print_result(player.name)
# If there are no winning moves for the ai player,
# then check to see if there are any wins for the opponent.
elif result == self._play and move is None:
result, move =\
opp_player.check_for_winning_move(self.magic_square)
# If there are, then block the opponent's winning move
if result == self._win and type(move) is int:
self.adjust_lists(player, move)
# If that was the last move on the board, end game
if len(opp_player.player) + len(player.player) == 9:
self.print_result("Cat")
# Else keep playing
return self._play
# Otherwise, hand the player off to the non-winning logic
elif result == self._play and move is None:
result = self.strategy(player)
# If the ai player found a move and made it...
if result == self._play:
# Check to see if there are any more moves on the board...
if len(opp_player.player) + len(player.player) == 9:
self.print_result("Cat")
# If there are, keep playing
return self._play
else:
self.print_result("Cat")
else:
print "Error\n"
self.end_game()
else:
print "Error\n"
self.end_game()
def strategy(self, player):
"""
Blocking strategies for the ai player.
"""
# If the center square is empty, move there.
if type(self.board.values[4]) is int:
self.adjust_lists(player, 4)
return self._play
# Certain strategies are only relevent
# if the opposing player
# has made exactly two moves.
if len(self.opp_player(player).player) == 2:
# First check the diagonals.
if not self.diagonal(player):
return self._play
# Next check for opposing player moves in opposite corners.
if not self.check_opposite_corner(self.opp_player(player).player):
return self._play
# Next check for opposing player moves in checkerboard pattern
# on the edge squares.
if not self.check_edge(self.opp_player(player)):
return self._play
# Move to the first available even square.
if not self.even_squares(player):
return self._play
# Move to the first available off square.
if not self.odd_squares(player):
return self._play
# If we haven't found a move, then the cat won the game.
return 2
def even_squares(self, player):
"""
Find the first free even-indexed square and
add it to the ai player's list.
"""
for idx, val in enumerate(self.board.values[::2]):
if type(val) is int:
self.adjust_lists(player, idx*2)
return self._play
return 1
def odd_squares(self, player):
"""
Find the first free odd-indexed square and
add it to the ai player's list.
"""
for idx, val in enumerate(self.board.values[1::2]):
if type(val) is int:
self.adjust_lists(player, idx*2+1)
return self._play
return 1
def check_opposite_corner(self, player):
"""
Next check for opposing player moves in opposite corners.
"""
if player[0] % 2 == 0 and player[1] % 2 == 0:
if player[0] + player[1] == 10:
# If opposite corners are filled, then the ai player moves
# to an odd-indexed square.
return self.odd_squares(player)
return 1
def check_edge(self, player):
"""
Check for a checkboard pattern.
If that pattern is found, then the ai player moves
to a corner square.
"""
if player.player[0] % 2 != 0 and player.player[1] % 2 != 0:
if abs(player.player[0] - player.player[1]) == 2 or\
abs(player.player[0] - player.player[1]) == 6:
# If that pattern is found, then the ai player moves
# to corner square.
return self.corner_squares(player)
return 1
def diagonal(self, player):
"""
Check for an occupied diagonal.
"""
opp_player = self.opp_player(player).player
if player.player[0] == 5:
if player.player[0] + opp_player[0] + opp_player[1] == 15:
# If a diagonal is filled, then the ai player moves
# to an even-indexed square.
return self.odd_squares(player)
return 1
def corner_squares(self, player):
"""
Check for a checkboard pattern.
If that pattern is found, then the ai player looks for
the correct corner and moves there.
"""
opp_player = self.opp_player(player)
player = player.player
if player[0] + player[1] == 4 and type(self.board.values[0]) is int:
self.adjust_lists(opp_player, 0)
return self._play
elif player[0] + player[1] == 8 and type(self.board.values[2]) is int:
self.adjust_lists(opp_player, 2)
return self._play
elif player[0] + player[1] == 12 and type(self.board.values[6]) is int:
self.adjust_lists(opp_player, 6)
return self._play
elif player[0] + player[1] == 16 and type(self.board.values[8]) is int:
self.adjust_lists(opp_player, 8)
return self._play
else:
return 1
def adjust_lists(self, player, move):
"""
Add the values related to the square to the lists.
"""
player.add_move(self.magic_square[move])
self.board.add_move(move, player.move_type)
self.board.remove_value(move)
def print_result(self, name):
"""
Print the board, winner, and exit the program.
"""
self.board.print_board()
self.board.print_winner(name)
self.end_game()
def end_game(self):
"""
Exit the program.
"""
sys.exit(0)
def opp_player(self, player):
"""
Return the other player based on the current player's name.
"""
if player.name == "Player X":
return self.playerO
else:
return self.playerX
plus the timestamp (as the first column).
:param nof_opponents: int, the number of opponents
:param w_L: str, "win" or "loss"
:param count_t1: int, how many of the opponents are of type 1
:param count_t2: int, how many of the opponents are of type 2
:param lost_to_t1: int, to how many opponents of type 1 the human has lost to
(e.g. if 2 opponents and the player outplays only one of them, then the human lost to 1)
:param lost_to_t2: int, to how many opponents of type 2 the human has lost to
:return: None
"""
# time, nof_opponents, w_L, count_t1, count_t2, lost_to_t1, lost_to_t2
f_name = "stats.csv"
with open(f_name, "a+") as f:
f.write(time.ctime() + "," + str(nof_opponents) + "," + str(w_L) +
"," + str(count_t1) + "," + str(count_t2) + "," +
str(lost_to_t1) + "," + str(lost_to_t2) + "\n")
if __name__ == '__main__':
g = Game()
from players import PlayerAImk2
print g.add_players(player_list=[
Player(nof_dice=5, player_id=1),
PlayerHuman(nof_dice=5, player_id=2),
PlayerAIsimple(nof_dice=5, player_id=3),
PlayerAImk2(nof_dice=5, player_id=4)
])
if self.history_enabled:
self._history.push(prev_state)
if __name__ == "__main__":
# take in arguments and setup defaults if necessary
if len(sys.argv) > 1:
game_var = sys.argv[1]
if not game_var:
sys.exit()
else:
game_var = "chess"
if len(sys.argv) > 2:
player1 = Player.create_player(sys.argv[2])
if not player1:
sys.exit()
else:
player1 = Player.create_player("human")
if len(sys.argv) > 3:
player2 = Player.create_player(sys.argv[3])
if not player2:
sys.exit()
else:
player2 = Player.create_player("human")
history = len(sys.argv) > 4 and sys.argv[4] == "on"
# create driver and start game
game = GameDriver(game_var, player1, player2, history)
def __init__(self, *args, **kwargs):
Player.__init__(self, *args)
self.maxloss = kwargs.get('maxloss',3)
self.timeout = kwargs.get('timeout',1)
class Game:
"""
Docstrings
"""
switchColor = {'white' : 'black', 'black' : 'white'}
def __init__(self, color='white'):
self.player1 = Player(color, player=1)
self.player2 = Robot(self.switchColor[color], player=2)
self.board = Board(self.player1, self.player2)
self.gamestate = list(chain(self.player1.pieces, self.player2.pieces))
self.history = History()
def mainloop(self):
"""
Docstrings
"""
window = Window(self.player1, self.player2)
click1 = Position((0, 0))
click2 = Position((0, 0))
self.player1.turn = True
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.MOUSEBUTTONDOWN:
if not click1.x or not click1.y:
click1.x, click1.y = event.pos
elif click1.x and click1.y:
click2.x, click2.y = event.pos
pos1 = click1.convert_inBoardCoordinate()
pos2 = click2.convert_inBoardCoordinate()
try:
if self.player1.turn:
opponent = [(piece.pos.x, piece.pos.y) for piece in self.player2.pieces]
if pos2 in opponent:
self.player1.eat(self.player2, pos1, pos2, self.gamestate)
else:
self.player1.move(pos1, pos2, self.gamestate)
except ChessError as error:
print(error)
click1.x, click1.y, click2.x, click2.y = 0, 0, 0, 0
else:
print(self.board)
click1.x, click1.y, click2.x, click2.y = 0, 0, 0, 0
self.player1.turn = True
self.player2.turn = True
self.history.addMove(self.player1, (pos1, pos2))
window.redraw()
pygame.quit()
"Jenny Frame": 1042,
"Hooper Hibblethwaite": 1031,
"Wandril Gudgeon": 910,
"Vernon Mann": 906,
"Craig Kassel": 882,
"Jasmine Minge": 858,
"Elsbeth Bethels": 756,
"Functional Glibro": 713,
"Patricia Partridge": 653,
"Stefan Funke": 581,
"Jim Dynamo": 410,}
# Transform dict into list of player objects
list_of_players = []
for player in players.items():
p = Player(player[0], player[1])
list_of_players.append(p)
# Sort players by starting Elo rating for initial seeding
sorted_players = sorted(list_of_players, key=attrgetter('current_rating'), reverse=True)
# TODO Handle the case where all or some players are unrated!
# Set seeding; likely a better way of doing this
# Seeding is permanent for the tournament
seed_rank = 1
for player in sorted_players:
player.seed = seed_rank
seed_rank += 1
# Print out first round matches and note who has played / got a bye
def get(self, playerID):
playerID = long(playerID)
p = Player.get_by_id(playerID)
games = Game.query(Game.players == playerID)
self.response.write(get_template('viewplayer.html').render({'player': p, 'games': games}))
