示例#1
0
def run_game(): 
	print (welcome_message) 
	print ("") 
	print (instructions)
	choice=input("Pick H or T\n")
	while choice.upper() not in ['H', 'T']:
		 choice=input("Invalid input. Please pick H or T\n")

	#flip a coin 
	i=random.randint(0,1) 
	winner='HT'[i] 
	if winner==choice:
		turn='player'
		print ("Congratulations! You go first :)")
	else:
		turn='ai' 
		print ("Sorry, you go second :(")
	
	#game starts 
	game_ongoing=True 
	game_state = game.GameState(turn) #create a new game 

	while game_ongoing:


		if game_state.getTurn()=='ai': #AI's Turn 
			ai_status=ai.play(game_state)
			if ai_status==game.PLAYER_LOST: 
				print ("AI WON!")
				game_ongoing=False 
			if ai_status==game.TIE:
				game_ongoing=False
				print ("TIE!") 

		else: #Player Turn  
			game_state.printBoard() #display board for player 

			move=input("Please pick a tile\n") 
			status=game.update(game_state, move) 

			while status==game.NOT_VALID_MOVE: 
				move=input("Invalid tile. Please pick a tile that isn't occupied\n") 
				status=game.update(game_state, move) 

			#picked a valid tile, game updated accordingly 
			if status==game.PLAYER_WON:
				print ("CONGRATS! YOU WON!")
				game_ongoing=False 

			if status==game.TIE:
				game_ongong=False 
				print ("TIE!")

			
	game_state.printBoard() #display board for player 
示例#2
0
文件: main.py 项目: lumenghe/game
def play_game(config, size, candidate_color):
    game = new_game(config, size, candidate_color)
    board = game['board']
    if candidate_color == 'b':
        print("You start to play !")
    else:
        print("The other side starts to play !")
    while True:
        print_board(board)
        move = ai.play(board, candidate_color)
        try:
            board = new_move(game, move)
        except GameOver as e:
            if e.winner == candidate_color:
                print('Game over: you win ! Congratulation !')
            elif e.winner == ' ':
                print('Game over: draw !')
            else:
                print('Game over: The other side wins !')
            return True
        except InvalidMoveException:
            return False
示例#3
0
文件: go.py 项目: krschmidt/Python-Go
    def playerpass(self):
        """
        Allows a player to pass. If both players pass, ends the game
        """
        if self.passCount == 0:
            self.passCount += 1
            if self.turn:
                self.status.config(text="Black passes!")
            else:
                self.status.config(text="White passes!")
            self.turn = not self.turn
            if not self.turn and self.playComputer:
                #black passed, so white needs to know to go
                stateX, stateY = ai.play(copy.deepcopy(self.state))
                if stateX == -1 and stateY == -1:
                    self.playerpass()
                else:
                    self.click(None, stateX, stateY)

        else:
            self.status.config(text="Game Over!")
            self.findscore()
def generate_random_game(rounds, bonus=False, verbatim=True):
    assert 0 < rounds <= TOTAL_TRICKS
    deck = [val+suit for val,suit in itertools.product(VALUES, SUITS)]
    random.shuffle(deck)
    players = [[], [], [], []]
    playergains = copy.deepcopy(players)
    global QScount
    global QSbombed

    global faroff
    global acceptable
    global perfect
    global tscr
    global avscr

    global starthandz
    global scorez

    for i in range(HANDSIZE):
        for j in range(PLAYERS):
            players[j].append(deck.pop())
    prev_tricks = []
    deck_top = [deck.pop()]

    if bonus:
        pred_scores = []
        player_data = []
        for i in range(PLAYERS):
            score = program.predict_score(players[i])
            pred_scores.append(score)
            player_data.append(score)
        pred_scores = tuple(pred_scores)

    prev_winner = 0
    QSstart = None
    for round_id in range(rounds):
        if round_id == 0:
            for hand in players:
                starthandz.append(copy.copy(hand))
            for p in range(4):
                for card in players[p]:
                    if card == 'QS':
                        QSstart = p
                        break
        curr_trick = []
        for j in range(PLAYERS):
            player_id = (prev_winner + j) % PLAYERS
            if bonus:
                card, player_data[player_id] = program.play(curr_trick, players[player_id], prev_tricks, deck_top, player_data=player_data[player_id])
            else:
                card = program.play(curr_trick, players[player_id], prev_tricks, deck_top, suppress_player_data=True)
            curr_trick.append(card)
            playergains[player_id].append(card)
            #print("card = {}".format(card))
            players[player_id].remove(card)
        curr_trick = tuple(curr_trick)
        prev_tricks.append(curr_trick)
        curr_winner, _score = program.get_winner_score(curr_trick, round_id, deck_top)
        prev_winner = (curr_winner + prev_winner) % PLAYERS
        if round_id < PHASE_ONE_TRICKS:
            for j in range(PLAYERS):
                if j == prev_winner:
                    players[j].append(deck_top[round_id])
                else:
                    players[j].append(deck.pop())
            if deck:
                deck_top.append(deck.pop())

    scores = program.score_game(prev_tricks, deck_top)

    if verbatim:
        if bonus:
            #print("PREDICTED SCORES: {}".format(pred_scores))
            #print("ORIGINAL SCORES: {}".format(scores))
            gains = []
            rev_scores = []
            for i in range(PLAYERS):
                diff = scores[i] - pred_scores[i]
                gains.append(diff)
                diff = abs(diff)
                if diff == 0:
                    rev_scores.append(scores[i] - 10)
                    perfect += 1
                elif 1 <= diff <= 2:
                    rev_scores.append(scores[i] - 2)
                    acceptable += 1
                elif 3 <= diff <= 4:
                    rev_scores.append(scores[i])
                    acceptable += 1
                elif 5 <= diff <= 6:
                    rev_scores.append(scores[i] + 2)
                    faroff += 1
                elif 7 <= diff <= 8:
                    rev_scores.append(scores[i] + 4)
                    faroff += 1
                else:
                    rev_scores.append(scores[i] + 10)
                    faroff += 1
            scores = tuple(rev_scores)
            #print("ADJUSTED SCORES: {}".format(scores))
            #print("DIFFERENCE SCORES: {}".format(tuple(gains)))
        else:
            #print("SCORES: {}".format(scores))
            for scr in scores:
                scorez.append(scr)
            temp = 0
            for score in scores:
                tscr += score
                temp += score
            avscr = (avscr + temp/4)/2
            if not QSstart:
                QScount += 1
            for p in range(4):
                for card in playergains[p]:
                    if card == 'QS':
                        if p != QSstart:
                            QSbombed += 1
                        break
示例#5
0
文件: go.py 项目: krschmidt/Python-Go
    def click(self, event=None, cx=None, cy=None):
        """
        Handles normal play
        Verifies that play is allowable
        Makes any possible captures
        Checks for Ko rule. This is not done in ValidPlay(), as we've got
        to make captures first, and there's no real reason to do that twice.
        Finish by redrawing board
        """
        self.status.config(text="")

        if event == None:
            stateX = cx
            stateY = cy
        else:
            #figure out what square we clicked on
            x = (event.x + self.wf) - event.x % self.wf
            y = (event.y + self.hf) - event.y % self.hf
            stateX = event.x / self.wf
            stateY = event.y / self.hf

        possible, message = validPlay(copy.deepcopy(self.state),
                                      self.turn, stateX, stateY)
        self.status.config(text=message)
        if not possible:
            return False

        backup = copy.deepcopy(self.state)
        self.state[stateX][stateY] = 'b' if self.turn else 'w'

        #check for captures
        #store existing prisoners in case we need to roll back
        preb = self.bPrisoners
        prew = self.wPrisoners
        newState, possible, captures = captureHelper(copy.deepcopy(self.state),
                                                     stateX, stateY, self.turn)
        if possible:
            self.state = copy.deepcopy(newState)
            if self.turn:
                self.bPrisoners += captures
            else:
                self.wPrisoners += captures
        self.score.config(text="B: %d W: %d" \
                              % (self.bPrisoners, self.wPrisoners))

        #Check for ko
        if self.state == \
                self.stateHistory[len(self.stateHistory) - 2]['state']:
            self.state = copy.deepcopy(backup)
            self.bPrisoners = preb
            self.wPrisoners = prew
            self.score.config(text="B: %d W: %d" \
                % (self.bPrisoners, self.wPrisoners))
            self.status.config(text="That would be a violation of Ko")
            return False

        self.turn = not self.turn
        self.lastX = stateX
        self.lastY = stateY
        self.stateHistory.append({'state': copy.deepcopy(self.state),
                                  'pass': self.passCount,
                                  'wPrisoners': self.wPrisoners,
                                  'bPrisoners': self.bPrisoners,
                                  'turn': self.turn,
                                  'lastX': stateX,
                                  'lastY': stateY})
        #reset passcount - they'll need to pass twice in a row in order to end
        self.passCount = 0

        #redraw board
        self.resize()
        root.update()

        #if it's whites turn, then do ai stuff
        if not self.turn and self.playComputer:
            stateX, stateY = ai.play(copy.deepcopy(self.state))
            if stateX == -1 and stateY == -1:
                self.playerpass()
            else:
                self.click(None, stateX, stateY)