Ejemplo n.º 1
0
    def createList(self, data, location):
        #when there is no linked list and we want to add at a given position
        if (self.head is None and location > 0):
            return ("there is no link list")

        # when there is no node in the linked list
        if (self.head is None and location == 0):
            node1 = node(data)
            self.head = node1
            self.tail = node1
            self.nodeCount += 1
        #when we want to add at the starting of the list
        elif (location == 0):
            node1 = node(data)
            node1.set_next(self.head)
            self.head = node1
            self.nodeCount += 1

        #when we want to add a node at the last position
        elif (location == self.nodeCount and location > 0):
            node1 = node(data)
            self.tail.set_next(node1)
            self.tail = node1
            self.nodeCount += 1
        #when we want to add a node in between head and tail
        else:
            node1 = node(data)
            tempNode = self.head
            for i in range(0, location - 1):
                tempNode = tempNode.get_next()
            node1.set_next(tempNode.get_next())
            tempNode.set_next(node1)
            self.nodeCount += 1
Ejemplo n.º 2
0
def new_stage_incoming(curr_node, node_player0, node_player1, cards):
    # ob novem stagu mora začeti p0 (tudi če je ravno igral)
    if node_player0.infoSet[-1] != '|':
        node_player0.infoSet += "|"
    if node_player1.infoSet[-1] != '|':
        node_player1.infoSet += "|"

    # zdj preeidemo v nov node, ki je vezan na to kakšne karte padejo
    curr_game_stage = curr_node.infoSet.count("|")

    #preflop je stage 0
    if curr_game_stage == 1:
        new_cards_ = "f" + poVrsti([cards[4], cards[5], cards[6]])  # flop
    elif curr_game_stage == 2:
        new_cards_ = "t" + str(cards[7])  # turn
    elif curr_game_stage == 3:
        new_cards_ = "r" + str(cards[8])  # river
    else:
        return "error3"

    # create nodes if necessary --> vedno kreiramo node v p0 in node_betting_map v p1 ker na začetku staga vedno začne p0
    if new_cards_ not in node_player0.new_cards:
        node_player0.new_cards[new_cards_] = nodes.node(node_player0.infoSet)
    if new_cards_ not in node_player1.new_cards:
        node_player1.new_cards[new_cards_] = nodes.node_betting_map(
            node_player1.infoSet)

    return new_cards_
Ejemplo n.º 3
0
def nodeInformation(infoSet, player):
    # v nodemapu je drevo za vsak mozni zacetni hand
    files_curr_dir = [
        f for f in listdir("./") if isfile(join("./", f))
    ]  # --> treba pogledat vsakič sprot ker sproti nastajajo novi fajli...mogoce po nekaj casa lahko zbrisem to vrstico

    if player == 0:
        file_name = "p0_" + infoSet + ".pkl"
        if file_name in files_curr_dir:
            with open(file_name, 'rb') as input:
                newNode = pickle.load(input)
        else:
            newNode = nodes.node_betting_map(
                ""
            )  # --> tuki ne rabmo node, ker p0 avtomatsko na začetku da big blind in dejansko ne začne

    elif player == 1:
        file_name = "p1_" + infoSet + ".pkl"
        if file_name in files_curr_dir:
            with open(file_name, 'rb') as input:
                newNode = pickle.load(input)
        else:
            newNode = nodes.node(
                ""
            )  # --> tuki rabmo node, ker p1 prvi igra v novi igri, saj ima p0 začetno stavo aka BIG BLIND +  # --> b11 = znak za big blind

    else:
        return "error2"

    return newNode
Ejemplo n.º 4
0
    def createList(self, data, location):
        node1 = node(data)
        if (self.head == None and location == 0):
            self.head = node1
            self.tail = node1
            self.nodeCount += 1

        elif (location == 0):
            node1.set_next(self.head)
            self.head.set_prev(node1)
            self.head = node1
            self.nodeCount += 1

        elif (location >= self.nodeCount):
            node1.set_prev(self.tail)
            self.tail.set_next(node1)
            self.tail = node1
            self.nodeCount += 1

        else:
            tempNode = self.head
            for i in range(0, location - 1):
                tempNode = (tempNode.get_next())
            node1.set_next(tempNode.get_next())
            node1.set_prev(tempNode)
            tempNode.set_next(node1)
            node1.get_next().set_prev(node1)
            self.nodeCount += 1
Ejemplo n.º 5
0
def openfile(path):
	import nodes as nd
	import csv
	with open(path) as f:
		edges = [tuple(line) for line in csv.reader(f)]
	labels = nd.node(edges)
	idxs = dict(zip(labels, range(len(labels))))
	iedges = [(idxs[e[0]], idxs[e[1]]) for e in edges]
	return iedges
Ejemplo n.º 6
0
def openfile(path):
    import nodes as nd
    import csv
    with open(path) as f:
        edges = [tuple(line) for line in csv.reader(f)]
    labels = nd.node(edges)
    idxs = dict(zip(labels, range(len(labels))))
    iedges = [(idxs[e[0]], idxs[e[1]]) for e in edges]
    return iedges
Ejemplo n.º 7
0
 def addEdge(self, fromNode, toNode):
     node1 = node(toNode)
     if (self.vertexList[fromNode] == None):
         self.vertexList[fromNode] = node1
     else:
         tempNode = self.vertexList[fromNode]
         while (tempNode.get_next() is not None):
             tempNode = tempNode.get_next()
         tempNode.set_next(node1)
Ejemplo n.º 8
0
 def createNode(self, data):
     node1 = node(data)
     if (self.head is None):
         self.head = node1
         self.tail = node1
         self.nodeCount += 1
     else:
         self.tail.set_next(node1)
         self.tail = node1
         self.nodeCount += 1
Ejemplo n.º 9
0
def makerandomtree(pc, maxdepth = 4, fpr = 0.5, ppr = 0.6):
  if random() < fpr and maxdepth > 0:
    f = choice(functions.getFunctions())
    children = [makerandomtree(pc, maxdepth - 1, fpr, ppr)
                for i in range(f.childcount)]
    return nodes.node(f, children)
  elif random() < ppr:
    return nodes.paramnode(randint(0, pc - 1))
  else:
    return nodes.constnode(randint(0, 255))
Ejemplo n.º 10
0
    def createList(self, data, location):
        if (self.head is None and location > 0):
            print("error in circular list creation")
            return

        # when there is no node in list
        elif (self.head is None and location == 0):
            node1 = node(data)
            self.head = node1
            self.tail = node1
            node1.set_next(node1)
            self.nodeCount += 1

        #when we want to add at the first position
        elif (location == 0):
            node1 = node(data)
            node1.set_next(self.head)
            self.head = node1
            self.tail.set_next(node1)
            self.nodeCount += 1

        # when we want to add at the last node
        elif (location == self.nodeCount):
            tempNode = self.head
            node1 = node(data)
            node1.set_next(self.head)
            self.tail.set_next(node1)
            self.tail = node1
            self.nodeCount += 1

        #when we want to add in between head and tail
        else:
            tempNode = self.head
            node1 = node(data)
            for i in range(0, location - 1):
                tempNode = tempNode.get_next()
            node1.set_next(tempNode.get_next())
            tempNode.set_next(node1)
            self.nodeCount += 1
Ejemplo n.º 11
0
Archivo: adjm.py Proyecto: konsbn/graph
def make_adjacency(edges):
	import numpy as np
	import nodes as nd
	nods = nd.node(edges)
	size  = len(nods)
	adjm = np.zeros((size,size))
	#print adjm
	for i in edges:
		c = (i[0], i[1])
		d = (i[1], i[0])
		#print c
		adjm[c] = 1
		adjm[d] = 1
	return adjm
Ejemplo n.º 12
0
Archivo: adjm.py Proyecto: konsbn/graph
def make_adjacency(edges):
    import numpy as np
    import nodes as nd

    nods = nd.node(edges)
    size = len(nods)
    adjm = np.zeros((size, size))
    # print adjm
    for i in edges:
        c = (i[0], i[1])
        d = (i[1], i[0])
        # print c
        adjm[c] = 1
        adjm[d] = 1
    return adjm
Ejemplo n.º 13
0
    def createList(self, value, location):
        node1 = node(value)
        if (self.head == None and location > 0):
            print("no link list found to add the node at given location")

        #when there is no node in the list
        elif (self.head == None and location == 0):
            self.head = node1
            self.tail = node1
            node1.set_next(node1)
            node1.set_prev(node1)
            self.nodeCount += 1

        # when we want to add a node in 0th position
        elif (location == 0):
            node1.set_next(self.head)
            node1.set_prev(self.tail)
            self.head.set_prev(node1)
            self.tail.set_next(node1)
            self.nodeCount += 1

        #when we want to add at last position
        elif (location >= self.nodeCount):
            node1.set_prev(self.tail)
            self.tail.set_next(node1)
            self.head.set_prev(node1)
            node1.set_next(self.head)
            self.tail = node1
            self.nodeCount += 1

        #when we want to add node in between
        else:
            tempNode = self.head
            for i in range(0, location - 1):
                tempNode = tempNode.get_next()
            node1.set_next(tempNode.get_next())
            node1.set_prev(tempNode)
            tempNode.set_next(node1)
            node1.get_next().set_prev(node1)
            self.nodeCount += 1
Ejemplo n.º 14
0
def generate(num_of_games=100000):

    file_path = "Analysis/Bot/datasets/dataset.txt"

    cards = [2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10,
             10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14]

    # Ta node uporabimo ko naš node ni naučen --> z več učenja tega ne bomo več potrebovali
    node_random = nodes.node("b1")
    for i in range(len(node_random.strategySum)):
        node_random.strategySum[i] = 1 / len(node_random.strategySum)


    #print("How many games do we generate?")
    counter = 0

    start_time = time.time()
    while counter < int(num_of_games):
        counter += 1
        print(counter)

        # ponastavimo infoset
        max_pot = 2 * ZACETNO_STANJE    # več od tega ne more biti, ker sta oba bota porabila svoj denar

        #zmešamo in razdelimo karte
        random.shuffle(cards)
        old_pot = BIG_BLIND  # p0 big blind
        new_pot = BIG_BLIND

        # Write to file
        f = open(file_path, "a")
        f.write("Game started at: " + str(datetime.datetime.now()) + "\n")
        f.write("Game ID: " + str(counter) + " " + str(SMALL_BLIND) + "/" + str(BIG_BLIND) + "   Hold'em\n")
        f.write("Seat 1 is the button")
        f.write("Seat 1: Bot1 (50).\n")
        f.write("Seat 2: Bot2 (50).\n")
        f.write("Player Bot1 has big blind (1)\n")
        f.write("Player Bot1 received a card " + num_to_card(cards[0]) + ".\n")
        f.write("Player Bot1 received a card " + num_to_card(cards[1]) + ".\n")
        f.write("Player Bot2 received a card " + num_to_card(cards[2]) + ".\n")
        f.write("Player Bot2 received a card " + num_to_card(cards[3]) + ".\n")
        f.close()


        #init the bots
        bot_0_cards = cfr_poker.poVrsti([cards[0], cards[1]])
        bot_1_cards = cfr_poker.poVrsti([cards[2], cards[3]])

        try:
            bot_0_node = cfr_poker.nodeInformation(bot_0_cards, 0)
        except:
            bot_0_node = node_random
        try:
            bot_1_node = cfr_poker.nodeInformation(bot_1_cards, 1)
        except:
            bot_1_node = node_random

        bot_in_action = 1   # ker ima p0 big blind

        # Init the variables
        global game_infoset
        game_infoset = ""
        opponent_bet = 0
        isRiver = False
        game_ended = False
        winner = "none"

        global better_cards_p0
        better_cards_p0 = cfr_poker.betterCards(cards, 0)
        a = better_cards_p0
        global better_cards_p1
        better_cards_p1 = cfr_poker.betterCards(cards, 1)



        #smo v tem loopu, dokler player spet ni konec igre
        while(not game_ended):
            debug = game_infoset

            if payoff(game_infoset, old_pot) != "continue":
                payoff_value = payoff(game_infoset, old_pot)
                winner = bot_in_action if payoff_value > 0 else (1-bot_in_action)
                #f.write("Bot" + str(winner) + " won")
                # glede na playerja veš kdo je zmagu
                game_ended = True
                break

            elif nodes.isNewStage(game_infoset):
                # Dodamo '|' v novem stagu
                game_infoset += "|"
                # Pokazemo nove karte
                curr_node = bot_0_node if bot_in_action == 0 else bot_1_node
                try:
                    new_cards_ = cfr_poker.new_stage_incoming(curr_node, bot_0_node, bot_1_node, cards)
                except: new_cards_ = "err"
                try:
                    bot_0_node = bot_0_node.new_cards[new_cards_]
                except: bot_0_node = node_random
                try:
                    bot_1_node = bot_1_node.new_cards[new_cards_]
                except: bot_1_node = node_random


                # Ponastavimo variable
                bot_in_action = 0
                opponent_bet = 0
                bot_bet = 0
                # Zapišemo v file
                game_stage = game_infoset.count("|")
                f = open(file_path, "a")
                if game_stage == 1: f.write("*** FLOP ***: [" + num_to_card(cards[4]) + " " + num_to_card(cards[5]) + " " + num_to_card(cards[6]) + "]\n")
                if game_stage == 2: f.write("*** TURN ***: [" + num_to_card(cards[7]) + "]\n")
                if game_stage == 3:
                    f.write("*** RIVER ***: [" + num_to_card(cards[8]) + "]\n")
                    isRiver = True
                f.close()

            # Tukaj sedaj zamenjamo node
            node = bot_0_node if bot_in_action == 0 else bot_1_node
            bot_action, action_info, bot_bet = bot_action_fun(node, old_pot, opponent_bet)
            action_num = int(action_info[-1])
            old_pot, new_pot = cfr_poker.new_pot_amount(game_infoset, old_pot, new_pot, action_num)
            if new_pot*2 >= 100:
                bot_action = "allin"

            f = open(file_path, "a")
            f.write("Player Bot" + str(bot_in_action) + " " + bot_action + "s")
            f.write(" (" + str(bot_bet) + ")\n") if (bot_action != "fold" and bot_action != "check") else f.write("\n")
            f.close()
            game_infoset += action_info

            # Posodobimo node
            debug = game_infoset
            try:
                bot_0_node = bot_0_node.betting_map[action_info]
            except: bot_0_node = node_random

            try:
                bot_1_node = bot_1_node.betting_map[action_info]
            except: bot_1_node = node_random

            opponent_bet = bot_bet
            bot_bet = 0
            bot_in_action = 1 - bot_in_action

        # Zaključena igra, sedaj napišemo summary
        f = open(file_path, "a")
        f.write("------ Summary ------\n")
        f.write("Board: [" + num_to_card(cards[4]) + " " + num_to_card(cards[5]) + " " + num_to_card(cards[6]) + " " + num_to_card(cards[7]) + " " + num_to_card(cards[8]) + "]\n")
        if isRiver:
            winner_cards = num_to_card(cards[0]) + ", " + num_to_card(cards[1]) if winner==0 else num_to_card(cards[2]) + ", " + num_to_card(cards[3])
            f.write("Player Bot" + str(winner) + " shows cards: " + winner_cards + "\n")
            f.write("Player Bot" + str(1-winner) + " does not show cards\n")
        else:
            f.write("Player Bot" + str(winner) + " does not show cards\n")
            f.write("Player Bot" + str(1-winner) + " does not show cards\n")
        f.write("Game ended at: " + str(datetime.datetime.now()) + "\n\n")
        f.close()

    print("Čas izvajanja programa: ", (time.time() - start_time), " sekund. To je ", (time.time() - start_time)/60," minut, kar je ", (time.time() - start_time)/60/int(num_of_games), "minut na igro")
Ejemplo n.º 15
0
 def __init__(self, edges):
     import nodes as nd
     self.nodes = nd.node(edges)
     self.edges = edges
Ejemplo n.º 16
0
	def __init__(self, edges):
		import nodes as nd
		self.nodes = nd.node(edges)
		self.edges = edges
Ejemplo n.º 17
0
def path_find(the_map, xA, yA, thetaA, actionA, xB, yB, thetaB, actionB):
    closed_nodes_map = np.zeros(shape=the_map.shape)
    open_nodes_map = np.zeros(shape=the_map.shape)
    dir_map = {}
    explored_nodes_count = 0
    pq = [[], []]
    pqi = 0
    n0 = node(xA, yA, thetaA, actionA)
    n0.updatePriority(xB, yB, thetaB, actionB)
    heappush(pq[pqi], n0)
    open_nodes_map[actionA][thetaA][yA][xA] = n0.priority
    while len(pq[pqi]) > 0:
        n1 = pq[pqi][0]
        n0 = node(n1.x, n1.y, n1.theta, n1.action, n1.distance, n1.priority)
        x = n0.x
        y = n0.y
        theta = n0.theta
        action = n0.action
        heappop(pq[pqi])
        open_nodes_map[action][theta][y][x] = 0
        closed_nodes_map[action][theta][y][x] = 1
        if x == xB and y == yB and theta == thetaB:
            path = []
            while not (x == xA and y == yA and theta == thetaA and action == actionA):
                td_node = dir_node(x, y, theta, action)
                parent = dir_map[td_node]
                path.append(parent)
                x = parent.x
                y = parent.y
                theta = parent.theta
                action = parent.action

            return (path, explored_nodes_count)
        dx, dy, dtheta, daction = n0.get_transition_states()
        for i in range(len(dx)):
            xdx = dx[i]
            ydy = dy[i]
            thetadtheta = dtheta[i]
            actiondaction = daction[i]
            if not (xdx < 0 or xdx > the_map.shape[3] - 1 or ydy < 0 or ydy > the_map.shape[2] - 1 or the_map[actiondaction][thetadtheta][ydy][xdx] == 1 or closed_nodes_map[actiondaction][thetadtheta][ydy][xdx] == 1):
                m0 = node(xdx, ydy, thetadtheta, actiondaction, n0.distance, n0.priority)
                m0.nextMove(action, i)
                m0.updatePriority(xB, yB, thetaB, actionB)
                if open_nodes_map[actiondaction][thetadtheta][ydy][xdx] == 0:
                    explored_nodes_count += 1
                    open_nodes_map[actiondaction][thetadtheta][ydy][xdx] = m0.priority
                    heappush(pq[pqi], m0)
                    md_node = dir_node(m0.x, m0.y, m0.theta, m0.action)
                    nd_node = dir_node(n0.x, n0.y, n0.theta, n0.action)
                    dir_map[md_node] = nd_node
                elif open_nodes_map[actiondaction][thetadtheta][ydy][xdx] > m0.priority:
                    open_nodes_map[actiondaction][thetadtheta][ydy][xdx] = m0.priority
                    md_node = dir_node(m0.x, m0.y, m0.theta, m0.action)
                    nd_node = dir_node(n0.x, n0.y, n0.theta, n0.action)
                    dir_map[md_node] = nd_node
                    while not (pq[pqi][0].x == xdx and pq[pqi][0].y == ydy):
                        heappush(pq[1 - pqi], pq[pqi][0])
                        heappop(pq[pqi])

                    heappop(pq[pqi])
                    if len(pq[pqi]) > len(pq[1 - pqi]):
                        pqi = 1 - pqi
                    while len(pq[pqi]) > 0:
                        heappush(pq[1 - pqi], pq[pqi][0])
                        heappop(pq[pqi])

                    pqi = 1 - pqi
                    heappush(pq[pqi], m0)

    return ('', explored_nodes_count)
Ejemplo n.º 18
0
    def kreiraj_sinove(self, curr_node, node_player0, node_player1,
                       p0_nextTurn, player):

        # Če so nodi computerani, potem ne kreiramo na novo dreves
        # Še vseeno moramo kreirati drevesa v non_curr_node, saj proti drugemu playerju lahko ta player z drugačnimi kartami igra drugače --> zato njih moramo brisat
        is_not_computed = not curr_node.computed_node

        num_actions = nodes.num_actions(curr_node.infoSet, self.NUM_ACTIONS)
        for i in range(num_actions):
            oznaka_stave = "b" + str(i)
            new_infoset = curr_node.infoSet + oznaka_stave

            new_p0_nextTurn = p0_nextTurn
            if new_p0_nextTurn == False:
                new_p0_nextTurn = nodes.isNewStage(new_infoset)

            if player == 0:
                if isTerminalState(
                        new_infoset):  #terminal state --> naredimo payoff node
                    if oznaka_stave not in node_player0.betting_map and is_not_computed:
                        node_player0.betting_map[
                            oznaka_stave] = nodes.node_payoff(new_infoset)
                    if oznaka_stave not in node_player1.betting_map:
                        node_player1.betting_map[
                            oznaka_stave] = nodes.node_payoff(new_infoset)
                elif nodes.isNewStage(
                        new_infoset
                ):  #new stage state --> naredimo new cards infose
                    if oznaka_stave not in node_player0.betting_map and is_not_computed:
                        node_player0.betting_map[
                            oznaka_stave] = nodes.node_new_cards(new_infoset)
                    if oznaka_stave not in node_player1.betting_map:
                        node_player1.betting_map[
                            oznaka_stave] = nodes.node_new_cards(new_infoset)
                else:  #sicer naredimo navaden betting node
                    if oznaka_stave not in node_player0.betting_map and is_not_computed:
                        node_player0.betting_map[oznaka_stave] = nodes.node(
                            new_infoset
                        ) if new_p0_nextTurn else nodes.node_betting_map(
                            new_infoset)
                    if oznaka_stave not in node_player1.betting_map:
                        node_player1.betting_map[oznaka_stave] = nodes.node(
                            new_infoset
                        ) if not new_p0_nextTurn else nodes.node_betting_map(
                            new_infoset)
            elif player == 1:
                if isTerminalState(
                        new_infoset):  #terminal state --> naredimo payoff node
                    if oznaka_stave not in node_player0.betting_map:
                        node_player0.betting_map[
                            oznaka_stave] = nodes.node_payoff(new_infoset)
                    if oznaka_stave not in node_player1.betting_map and is_not_computed:
                        node_player1.betting_map[
                            oznaka_stave] = nodes.node_payoff(new_infoset)
                elif nodes.isNewStage(
                        new_infoset
                ):  #new stage state --> naredimo new cards infose
                    if oznaka_stave not in node_player0.betting_map:
                        node_player0.betting_map[
                            oznaka_stave] = nodes.node_new_cards(new_infoset)
                    if oznaka_stave not in node_player1.betting_map and is_not_computed:
                        node_player1.betting_map[
                            oznaka_stave] = nodes.node_new_cards(new_infoset)
                else:  #sicer naredimo navaden betting node
                    if oznaka_stave not in node_player0.betting_map:
                        node_player0.betting_map[oznaka_stave] = nodes.node(
                            new_infoset
                        ) if new_p0_nextTurn else nodes.node_betting_map(
                            new_infoset)
                    if oznaka_stave not in node_player1.betting_map and is_not_computed:
                        node_player1.betting_map[oznaka_stave] = nodes.node(
                            new_infoset
                        ) if not new_p0_nextTurn else nodes.node_betting_map(
                            new_infoset)