Exemplo n.º 1
0
    def __init__(self, path, auto):
        self.path = path
        self.auto = auto

        unshuffled = ticketdeckunshuffled()
        self.tickets = unshuffled.cards
        shuffle(self.tickets)
        self.discardedtickets = []

        self.visibleTrains = [0, 1, 2, 3, 4]

        self.claimCount = 0

        self.graph = nx.read_edgelist(self.path + 'edgelist.txt', nodetype=int, data=(('weight', int), ('length', int), ('cols', str), ('claimed', int), ('whenclaimed', int),))

        self.trains = []
        for i in range(0, 7):
            self.trains += [i] * 12;
        self.trains += [8] * 14;
        shuffle(self.trains);

        self.usedtrains = []

#         print("Cards in (supposedly) full ticket deck: ")
#         print(len(self.tickets))
#
#         print("Cards in (supposedly) full train deck: ")
#         print(len(self.trains))

        print("Initializing visible deck")
        for i in range(0, 5):
            self.visibleTrains[i] = self.nextTrain()
Exemplo n.º 2
0
    def returnUnwantedTickets(self):
        self.returningtickets = 1
        u = ticketdeckunshuffled()
        for i in range(0, 3):
            self.pars[i] = u.cards.index(self.newTickets[i])
        self.setupIn()

        done = False
        out = -1
        while not done:
            out = self.getBrainAction(self.nnin)
            if 1 <= out < 8:  # don't allow removing all cards
                done = True
            else:
                self.brainBackwards(self.rewards['illegalmove'])
        # Get a binary representation that tells what cards to get rid of
        out -= 1
        binary = "{0:03b}".format(out)

        for i in reversed(range(0, 3)):
            if binary[i] == '1':
                x = self.newTickets.pop(i)
                self.logger.info("Returning: " + str(x))
                self.board.returnTicket(x)
Exemplo n.º 3
0
    def setupIn(self):
        # input setup:
        # step (starts at 0)
        # move type (-1 for step 0)
        # move par 1
        # move par 2
        # move par 3
        # edge lengths
        # edge color 1
        # edge color 2 (-1 for n/a)
        # when edges were claimed (-1 if n/a)
        # who claimed edges (-1 for n/a)
        # train car hand (how many of each))
        # ticket hand (30 cards slots, stored as the two then from for each
        # card, -1 for empty)

        #         self.nnin = [self.moveillegal, self.step, self.movetype]
        self.nnin = [self.moveillegal, self.returningtickets]
        self.nnin += [self.m0s2, self.m1s2]
        self.nnin += self.pars
        self.nnin.append(self.trainsleft)

        ticketdecklen = -1
        if len(self.board.tickets) + len(self.board.discardedtickets) < 3:
            ticketdecklen = 1
        self.nnin.append(ticketdecklen)

        traindecklen = -1
        if len(self.board.trains) < 2:
            traindecklen = 1
        self.nnin.append(traindecklen)

        othertrains = [-1] * 4
        otherpoints = [-1] * 4
        for i, j in enumerate(self.players):
            othertrains[i] = j.trainsleft
            otherpoints[i] = j.points
        self.nnin += othertrains
        self.nnin.append(self.points)
        self.nnin += otherpoints

        if self.board.auto and False:
            self.nnin.append(
                len(self.board.tickets) + len(self.board.discardedtickets))
            self.nnin.append(sum(self.board.trains))
        else:
            self.nnin.append(-1)
            self.nnin.append(-1)
        self.nnin += self.board.visibleTrains
        self.nnin += self.board.trackpts

        trainsIn = self.trains

        u = ticketdeckunshuffled()
        ticketsIn = [-1] * 30
        for i in self.tickets:
            ticketsIn[u.cards.index(i)] = 1

#         index = 0
#         for i in self.tickets:
#             #             self.print_func(str(i))
#             ticketsIn[index]=i[0]
#             ticketsIn[index+1]=i[1]
#             index+=2
#             if index>58:
#                 break

        self.nnin += trainsIn
        self.nnin += ticketsIn

#         self.nnin += [i[2] for i in self.board.graph.edges_iter(data='weight', default=-1)]
        self.nnin += [i[2]
                      for i in self.board.graph.edges_iter(data='length', default=-1)]
#         print([i for i in self.board.graph.edges_iter(data='length', default=-1)])

        for i in self.board.graph.edges_iter(data='cols', default=-1):
            val = getColInt(i[2][0])
            if len(i[2]) > 1:
                val *= 10
                val += getColInt(i[2][1])
            self.nnin.append(val)

#         for i in self.board.graph.edges_iter(data='cols', default=-1):
#             self.nnin.append(getColInt(i[2][0])
#         for i in self.board.graph.edges_iter(data='cols', default=-1):
#             if(len(i[2])<2):
#                 self.nnin.append(-1)
#             else:
#                 self.nnin.append(getColInt(i[2][1]))

#         self.nnin += [i[2] for i in self.board.graph.edges_iter(data='whenclaimed', default=-1)]
        self.nnin += [i[2]
                      for i in self.board.graph.edges_iter(data='claimed', default=-1)]