Exemplo n.º 1
0
    def __init__(self):
        '''

		'''
        self.outerlines_heurestic = [[7, 6, 5, 4], [6, 4, 3, 3], [5, 3, 2, 2],
                                     [4, 3, 2, 1]]
        self.snake_heurestic = [[16, 15, 14, 13], [9, 10, 11, 12],
                                [8, 7, 6, 5], [1, 2, 3, 4]]
        self.gradient_heurestic = [[7, 6, 5, 4], [6, 5, 4, 3], [5, 4, 3, 2],
                                   [4, 3, 2, 1]]
        self.directions = {1: "RIGHT", 2: "LEFT", 3: "UP", 4: "DOWN"}
        self.logic = Gamelogic()
        self.neighbours = list()
        heapq.heapify(self.neighbours)
Exemplo n.º 2
0
 def move():
     rnd = random.randrange(1000)
     if rnd == 999:
         print("You found a Chest with a chance of 0.01%! But this feature is not implemented yet, so it will do nothing. haha^^")
     elif rnd >= 900 and Player.isLocked == False:
         print("You get to a locked door. You'll have to use the key to open it!")
         Gamelogic.key()
     elif rnd >= 500 and Player.isLocked == False:
         print("You move deeper into the dungeon!")
         Player.room += 1
     elif Player.isLocked == True and Player.hasKey == True:
         Gamelogic.key()
     elif rnd >= 0:
         print("An enemy attacks you!")
         Actions.fight()
Exemplo n.º 3
0
	def __init__(self):
		'''

		'''
		self.outerlines_heurestic = [[7,6,5,4],[6,4,3,3],[5,3,2,2],[4,3,2,1]]
		self.snake_heurestic = [[16,15,14,13],[9,10,11,12],[8,7,6,5],[1,2,3,4]]
		self.gradient_heurestic = [[7,6,5,4],[6,5,4,3],[5,4,3,2],[4,3,2,1]]
		self.directions = {1: "RIGHT", 2: "LEFT", 3: "UP", 4: "DOWN"}
		self.logic = Gamelogic()
		self.neighbours = list()
		heapq.heapify(self.neighbours)
Exemplo n.º 4
0
class Solver():
    '''

	'''
    def __init__(self):
        '''

		'''
        self.outerlines_heurestic = [[7, 6, 5, 4], [6, 4, 3, 3], [5, 3, 2, 2],
                                     [4, 3, 2, 1]]
        self.snake_heurestic = [[16, 15, 14, 13], [9, 10, 11, 12],
                                [8, 7, 6, 5], [1, 2, 3, 4]]
        self.gradient_heurestic = [[7, 6, 5, 4], [6, 5, 4, 3], [5, 4, 3, 2],
                                   [4, 3, 2, 1]]
        self.directions = {1: "RIGHT", 2: "LEFT", 3: "UP", 4: "DOWN"}
        self.logic = Gamelogic()
        self.neighbours = list()
        heapq.heapify(self.neighbours)

    def move(self, direction, board):
        '''

		'''
        return self.logic.move(direction, board)

    def solve(self, board):
        '''

		'''
        if board != None:
            self.neighbours = list()
            heapq.heapify(self.neighbours)
            for neighbour in self.get_neighbours(board):
                heapq.heappush(
                    self.neighbours,
                    (self.expectimax(neighbour, 3, False), neighbour))
            board = heapq.heappop(self.neighbours)[1]
            board = self.logic.append_random_number(board)
            return board

    def get_neighbours(self, board):
        '''

		'''
        neighbours = list()
        for move in self.directions:
            neighbour = self.logic.check_move(self.directions[move],
                                              copy.deepcopy(board))
            if neighbour != None:
                neighbours.append(neighbour)
        return neighbours

    def heuristic(self, board):
        '''

		'''
        h = 9000
        #number of zeros
        for row in board:
            h -= row.count(0)

        #gradient
        '''
		for rotations in range(4):
			gradient_board_score = numpy.array(board) * numpy.rot90(self.outerlines_heurestic, rotations)
		
		gradient_board_score = numpy.array(board) * numpy.array(self.snake_heurestic)
		
		best_h = h
		for row in gradient_board_score:
			for value in row:
				h -= value
			if h < best_h:
				best_h = h
		'''
        return h

    def random_permutations(self, board):
        '''

		'''
        permutations = self.logic.append_all_random_numbers(board)
        return permutations

    def probability_of_reaching_node(self, key, board):
        '''

		'''
        zero_count = 0
        for row in board:
            zero_count += row.count(0)
        if key == 2:
            return 0.9 / zero_count
        elif key == 4:
            return 0.1 / zero_count

    def expectimax(self, board, depth, maximizing_player):
        '''

		'''
        if depth == 0:
            h = self.heuristic(board)
            return h
        if maximizing_player:
            #Return value of maximum-valued child node
            alpha = float("-inf")
            for neighbour in self.get_neighbours(board):
                alpha = max(alpha, self.expectimax(neighbour, depth - 1,
                                                   False))
        elif maximizing_player == False:
            # Return weighted average of all child nodes' values
            alpha = 0
            neighbours = self.logic.append_all_random_numbers(board)
            for key in neighbours.keys():
                for neighbour in neighbours[key]:
                    alpha += (self.probability_of_reaching_node(key, board) *
                              self.expectimax(neighbour, depth - 1, True))
        #print("alpha")
        return alpha
Exemplo n.º 5
0
        '''

		'''
        if depth == 0:
            h = self.heuristic(board)
            return h
        if maximizing_player:
            #Return value of maximum-valued child node
            alpha = float("-inf")
            for neighbour in self.get_neighbours(board):
                alpha = max(alpha, self.expectimax(neighbour, depth - 1,
                                                   False))
        elif maximizing_player == False:
            # Return weighted average of all child nodes' values
            alpha = 0
            neighbours = self.logic.append_all_random_numbers(board)
            for key in neighbours.keys():
                for neighbour in neighbours[key]:
                    alpha += (self.probability_of_reaching_node(key, board) *
                              self.expectimax(neighbour, depth - 1, True))
        #print("alpha")
        return alpha


if __name__ == "__main__":
    solver = Solver()
    logic = Gamelogic()
    print("-----------")
    board = [[2, 0, 0, 0], [0, 2, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
    neighbours = solver.get_neighbours(board)
    #print(neighbours)
Exemplo n.º 6
0
 def __init__(self):
     gamedata.board = Board()
     self.board_surf = DrawBoardData()
     self.gamelg = Gamelogic()
     self.selected_token = []
     self.selected_joker = False
Exemplo n.º 7
0
class GamePlay():
    def __init__(self):
        gamedata.board = Board()
        self.board_surf = DrawBoardData()
        self.gamelg = Gamelogic()
        self.selected_token = []
        self.selected_joker = False

    def update(self):

        #update board and set button
        self.board_surf.update(gamedata.board,gamedata.players)
        self.bnoble = [Button(noble[0],noble[1]) for noble in self.board_surf.nobles]
        self.bdeck1 = Button(self.board_surf.deck1[0],self.board_surf.deck1[1])
        self.btier1 = [Button(card[0],card[1]) for card in self.board_surf.tier1]
        self.bdeck2 = Button(self.board_surf.deck2[0],self.board_surf.deck2[1])
        self.btier2 = [Button(card[0],card[1]) for card in self.board_surf.tier2]
        self.bdeck3 = Button(self.board_surf.deck3[0],self.board_surf.deck3[1])
        self.btier3 = [Button(card[0],card[1]) for card in self.board_surf.tier3]
        self.btokenpool = [Button(token[0],token[1]) for token in self.board_surf.tokenpool]
        self.bjoker = Button(self.board_surf.joker[0],self.board_surf.joker[1])

        self.bplayercard = [[Button(card[0],card[1]) for card in player[0].holdcards] for player in self.board_surf.players]
        self.bplayertoken = [[Button(token[0][0],token[0][1]) for token in player[0].token] for player in self.board_surf.players]
        self.bplayerjoker = [Button(player[0].jokericon[0],player[0].jokericon[1]) for player in self.board_surf.players]

        for player in range(len(gamedata.players)):
            if gamedata.players[player].isplaying:
                self.player = gamedata.players[player]
                self.playernum = player

    #click and hover function

        for card in range(len(self.bplayercard[self.playernum])):
            if self.bplayercard[self.playernum][card].isclicked():
                self.gamelg.player_buy_hold_card(self.player,card)
        for token in range(len(self.bplayertoken[self.playernum])):
            if self.bplayertoken[self.playernum][token].isclicked():
                self.gamelg.player_convert_joker(self.player,token)
        if self.bplayerjoker[self.playernum].isclicked():
            self.gamelg.player_reset_joker(self.player)

        for bnoble in self.bnoble:
            if bnoble.isclicked():
                pass

        if self.bdeck1.ishovered():
            print("deck1 is hovered")
        for card in range(len(self.btier1)):
            if self.btier1[card].isclicked():
                print('tier1 '+str(card))
                if self.selected_joker:
                    self.gamelg.player_take_card(gamedata.board,gamedata.board.tier1,gamedata.board.deck1,card,self.player)
                    self.selected_joker = False
                else:
                    self.gamelg.player_buy_card(self.player,gamedata.board.deck1,gamedata.board.tier1,card)
        if self.bdeck2.ishovered():
            print("deck2 is hovered")
        for card in range(len(self.btier2)):
            if self.btier2[card].isclicked():
                print('tier2 '+str(card))
                if self.selected_joker:
                    self.gamelg.player_take_card(gamedata.board,gamedata.board.tier2,gamedata.board.deck2,card,self.player)
                    self.selected_joker = False
                else:
                    self.gamelg.player_buy_card(self.player,gamedata.board.deck2,gamedata.board.tier2,card)
        if self.bdeck3.ishovered():
            print("deck3 is hovered")
        for card in range(len(self.btier3)):
            if self.btier3[card].isclicked():
                print('tier3 '+str(card))
                if self.selected_joker:
                    self.gamelg.player_take_card(gamedata.board,gamedata.board.tier3,gamedata.board.deck3,card,self.player)
                    self.selected_joker = False
                else:
                    self.gamelg.player_buy_card(self.player,gamedata.board.deck3,gamedata.board.tier3,card)

        #click token
        for btoken in range(len(self.btokenpool)):
            if self.btokenpool[btoken].isclicked():
                if not(len(self.selected_token) == 2 and btoken in self.selected_token) and not(self.selected_joker):
                    if gamedata.board.tokenpool.asList()[btoken] > 0:
                        self.selected_token.append(btoken)
                if self.selected_token.count(btoken) == 2 and len(self.selected_token) == 2:
                    if gamedata.board.tokenpool.asList()[btoken] > 3:
                        self.gamelg.player_take_two(self.selected_token,self.player)
                        self.selected_token = []
                    else:
                        self.selected_token.pop()
                if len(self.selected_token) == 3:
                    self.gamelg.player_take_three(self.selected_token,self.player)
                    self.selected_token = []
            if self.btokenpool[btoken].isRclicked():
                if btoken in self.selected_token:
                    self.selected_token.remove(btoken)
        #click joker
        if self.bjoker.isclicked():
            if self.selected_token == []:
                self.selected_joker = True
        if self.bjoker.isRclicked():
            self.selected_joker = False

        #render
        gamedata.listRender.append((self.board_surf.boardbg,(0,0)))
        gamedata.listRender.append(self.board_surf.deck1)
        gamedata.listRender.append(self.board_surf.deck2)
        gamedata.listRender.append(self.board_surf.deck3)
        for player in self.board_surf.players:
            gamedata.listRender.append(player[0].bg)
            for token in player[0].token:
                for surf in token:
                    gamedata.listRender.append(surf)
            for holdcard in player[0].holdcards:
                gamedata.listRender.append(holdcard)
            gamedata.listRender.append(player[0].jokericon)
            gamedata.listRender.append(player[0].jokerscore)
            gamedata.listRender.append(player[0].pvicon)
            gamedata.listRender.append(player[0].pvscore)
        for bnoble in self.bnoble:
            bnoble.render()
        for btier1 in self.btier1:
            btier1.render()
        for btier2 in self.btier2:
            btier2.render()
        for btier3 in self.btier3:
            btier3.render()
        for btoken in range(len(self.btokenpool)):
            if btoken in self.selected_token:
                self.btokenpool[btoken].renderselected()
            else:
                self.btokenpool[btoken].render()
        if self.selected_joker:
            self.bjoker.renderselected()
        else:
            self.bjoker.render()
Exemplo n.º 8
0
class Solver():
	'''

	'''


	def __init__(self):
		'''

		'''
		self.outerlines_heurestic = [[7,6,5,4],[6,4,3,3],[5,3,2,2],[4,3,2,1]]
		self.snake_heurestic = [[16,15,14,13],[9,10,11,12],[8,7,6,5],[1,2,3,4]]
		self.gradient_heurestic = [[7,6,5,4],[6,5,4,3],[5,4,3,2],[4,3,2,1]]
		self.directions = {1: "RIGHT", 2: "LEFT", 3: "UP", 4: "DOWN"}
		self.logic = Gamelogic()
		self.neighbours = list()
		heapq.heapify(self.neighbours)

	def move(self, direction, board):
		'''

		'''
		return self.logic.move(direction, board)

	def solve(self, board):
		'''

		'''
		if board != None:
			self.neighbours = list()
			heapq.heapify(self.neighbours)
			for neighbour in self.get_neighbours(board):
				heapq.heappush(self.neighbours, (self.expectimax(neighbour, 3, False), neighbour))
			board = heapq.heappop(self.neighbours)[1]
			board = self.logic.append_random_number(board)
			return board

	def get_neighbours(self, board):
		'''

		'''
		neighbours = list()
		for move in self.directions:
			neighbour = self.logic.check_move(self.directions[move], copy.deepcopy(board))
			if neighbour != None:
				neighbours.append(neighbour)
		return neighbours

	def heuristic(self, board):
		'''

		'''
		h = 9000
		#number of zeros
		for row in board:
			h -= row.count(0)

		#gradient
		'''
		for rotations in range(4):
			gradient_board_score = numpy.array(board) * numpy.rot90(self.outerlines_heurestic, rotations)
		
		gradient_board_score = numpy.array(board) * numpy.array(self.snake_heurestic)
		
		best_h = h
		for row in gradient_board_score:
			for value in row:
				h -= value
			if h < best_h:
				best_h = h
		'''
		return h

	def random_permutations(self, board):
		'''

		'''
		permutations = self.logic.append_all_random_numbers(board)
		return permutations

	def probability_of_reaching_node(self, key, board):
		'''

		'''
		zero_count = 0
		for row in board:
			zero_count += row.count(0)
		if key == 2:
			return 0.9 / zero_count
		elif key == 4:
			return 0.1 / zero_count

	def expectimax(self, board, depth, maximizing_player):
		'''

		'''
		if depth == 0:
			h = self.heuristic(board)
			return h
		if maximizing_player:
			#Return value of maximum-valued child node
			alpha = float("-inf")
			for neighbour in self.get_neighbours(board):
				alpha = max(alpha, self.expectimax(neighbour, depth - 1, False))
		elif maximizing_player == False:
			# Return weighted average of all child nodes' values
			alpha = 0
			neighbours = self.logic.append_all_random_numbers(board)
			for key in neighbours.keys():
				for neighbour in neighbours[key]:
					alpha += (self.probability_of_reaching_node(key, board) * self.expectimax(neighbour, depth - 1, True))
		#print("alpha")
		return alpha