Python Board.canMove方法代码示例

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import canMove [as 别名]
def game_arrow(message):
    try:
        
        con = sqlite3.connect('2048.db')
        chat_id = str(message.chat.id)
        with con:
            cur = con.cursor()
            cur.execute('SELECT board, score FROM users WHERE id='+chat_id+';')
        data_from_db = cur.fetchone()
        
        list_from_db = []

        if data_from_db:
            list_from_db = data_from_db[0].split(',')
        else: 
            list_from_db = "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0".split(',')
        if data_from_db[1]:
            score = int(data_from_db[1])
        else:
            score = 0

        board = Board()
        array_x = range(board.size())
        for x in array_x:
            print 'list from db'
            print list_from_db
            j = []
            for y in array_x:
                j.append(int(list_from_db[4*x+y]))
            print j
            if (j!=''):
                board.setCol(x, j)
        if message.text == chr_UP:
#            print 'UP'
            score += board.move(Board.UP)
        if message.text == chr_DOWN:
#            print 'DOWN'
            score += board.move(Board.DOWN)
        if message.text == chr_RIGHT:
            score += board.move(Board.RIGHT)
        if message.text == chr_LEFT:
            score += board.move(Board.LEFT)
        
        with con:
            cur = con.cursor()
            cur.execute('INSERT or REPLACE INTO users (id, board, score) VALUES ('+chat_id+', "'+boardToStringBD(board)+'", "'+str(score)+'");')
        con.close()
        
        s = boardToString(board)
        if board.canMove():
            tb.send_message(message.chat.id,  "Score: "+ str(score) +"\n" +"```" + s + "```", parse_mode = "Markdown")
        else:
            score = 0
            tb.send_message(message.chat.id, "Game Over\nYou can start new game, if click /game")
    except Exception,e:
        print e
        print 'wtf!'
        send_welcome(message)

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import canMove [as 别名]
def run(ai_function, times=1,  **kws):
    results = []
    states_encountered = {}
    prev_states = 0
    while(times > 0):
        score = 0
        moves = 0
        board = Board(**kws)
        while True:
            if board.won() or not board.canMove():
                break

            move = ai_function(board,score)
            score += board.move(move)
            moves += 1

        results.append((moves, largest_tile(board), score))
        times -= 1
    return results

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import canMove [as 别名]

#.........这里部分代码省略.........

    def hideCursor(self):
        """
        Hide the cursor. Don't forget to call ``showCursor`` to restore
        the normal shell behavior. This is a no-op if ``clear_screen`` is
        falsy.
        """
        if not self.clear_screen:
            return
        if not self.__is_windows:
            sys.stdout.write('\033[?25l')

    def showCursor(self):
        """Show the cursor."""
        if not self.__is_windows:
            sys.stdout.write('\033[?25h')

    #### HERE STARTS THE AI STUFF ####

    def ai_loop(self, ai_function):
        """
        Loop to use with AI.
        Input function (ai_function) need to return value from [Board.UP, Board.DOWN..]
        as input ai_function recives current board object and current score.
        """
        margins = {'left': 4, 'top': 4, 'bottom': 4}

        atexit.register(self.showCursor)

        self.hideCursor()
        while True:
            self.clearScreen()
            print(self.__str__(margins=margins))
            if self.board.won() or not self.board.canMove():
                break

            m = ai_function(self.board, self.score)
            self.incScore(self.board.move(m))

        print('You won!' if self.board.won() else 'Game Over')
        return self.score

    ### HERE ENDS AI STUFF #####################

    def loop(self):
        """
        main game loop. returns the final score.
        """
        pause_key = self.board.PAUSE
        margins = {'left': 4, 'top': 4, 'bottom': 4}

        atexit.register(self.showCursor)

        moves = 0

        try:
            self.hideCursor()
            while True:
                self.clearScreen()
                print(self.__str__(margins=margins))
                if self.board.won() or not self.board.canMove():
                    break
                m = self.readMove()

                if (m == pause_key):
                    self.saveBestScore()

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import canMove [as 别名]
class Game:
    """
    A 2048 game
    """

    __dirs = {
        keypress.UP:    Board.UP,
        keypress.DOWN:  Board.DOWN,
        keypress.LEFT:  Board.LEFT,
        keypress.RIGHT: Board.RIGHT,
    }

    __clear = 'cls' if os.name == 'nt' else 'clear'

    __colors = {
           2: Fore.GREEN,
           4: Fore.BLUE,
           8: Fore.CYAN,
          16: Fore.RED,
          32: Fore.MAGENTA,
          64: Fore.CYAN,
         128: Fore.BLUE,
         256: Fore.MAGENTA,
         512: Fore.GREEN,
        1024: Fore.RED,
        2048: Fore.YELLOW,
    }

    SCORES_FILE = '%s/.term2048.scores' % os.path.expanduser('~')

    def __init__(self, scores_file=SCORES_FILE, **kws):
        self.board = Board(**kws)
        self.score = 0
        self.scores_file = scores_file
        self.loadBestScore()

    def loadBestScore(self):
        """
        load local best score from the default file
        """
        if self.scores_file is None or not os.path.exists(self.scores_file):
            self.best_score = 0
            return
        try:
            f = open(self.scores_file, 'r')
            self.best_score = int(f.readline(), 10)
            f.close()
        except:
            pass # fail silently

    def saveBestScore(self):
        """
        save current best score in the default file
        """
        if self.score > self.best_score:
            self.best_score = self.score
        try:
            f = open(self.scores_file, 'w')
            f.write(str(self.best_score))
            f.close()
        except:
            pass # fail silently

    def end(self):
        """
        return True if the game is finished
        """
        return not (self.board.won() or self.board.canMove())

    def readMove(self):
        """
        read and return a move to pass to a board
        """
        k = keypress.getArrowKey()
        return Game.__dirs.get(k)

    def loop(self):
        """
        main game loop
        """
        while True:
            os.system(Game.__clear)
            print self.__str__(margins={'left':4, 'top':4, 'bottom':4})
            if self.board.won() or not self.board.canMove():
                break
            try:
                m = self.readMove()
            except KeyboardInterrupt:
                self.saveBestScore()
                return
            self.score += self.board.move(m)
            if self.score > self.best_score:
                self.best_score = self.score

        self.saveBestScore()
        print 'You won!' if self.board.won() else 'Game Over'

    def getCellStr(self, x, y):
        """
        return a string representation of the cell located at x,y.
#.........这里部分代码省略.........

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import canMove [as 别名]

#.........这里部分代码省略.........
        avoid yellow, to give a few examples.
        """
        rp = Game.__color_modes.get(mode, {})
        for k, color in self.__colors.items():
            self.__colors[k] = rp.get(color, color)

    def loadBestScore(self):
        """
        load local best score from the default file
        """
        if self.scores_file is None or not os.path.exists(self.scores_file):
            self.best_score = 0
            return
        try:
            f = open(self.scores_file, 'r')
            self.best_score = int(f.readline(), 10)
            f.close()
        except:
            pass # fail silently

    def saveBestScore(self):
        """
        save current best score in the default file
        """
        if self.score > self.best_score:
            self.best_score = self.score
        try:
            f = open(self.scores_file, 'w')
            f.write(str(self.best_score))
            f.close()
        except:
            pass # fail silently

    def end(self):
        """
        return True if the game is finished
        """
        return not (self.board.won() or self.board.canMove())

    def readMove(self):
        """
        read and return a move to pass to a board
        """
        k = keypress.getArrowKey()
        return Game.__dirs.get(k)

    def loop(self):
        """
        main game loop
        """
        while True:
            os.system(Game.__clear)
            print self.__str__(margins={'left':4, 'top':4, 'bottom':4})
            if self.board.won() or not self.board.canMove():
                break
            try:
                m = self.readMove()
            except KeyboardInterrupt:
                self.saveBestScore()
                return
            self.score += self.board.move(m)
            if self.score > self.best_score:
                self.best_score = self.score

        self.saveBestScore()
        print 'You won!' if self.board.won() else 'Game Over'

    def getCellStr(self, x, y):
        """
        return a string representation of the cell located at x,y.
        """
        c = self.board.getCell(x, y)
        if c == 0:
            return '  .'

        if c == 1024:
            s = ' 1k'
        elif c == 2048:
            s = ' 2k'
        else:
            s = '%3d' % c
        return self.__colors.get(c, Fore.RESET) + s + Fore.RESET

    def boardToString(self, margins={}):
        """
        return a string representation of the current board.
        """
        b = self.board
        rg = xrange(b.size())
        left = ' '*margins.get('left', 0)
        s = '\n'.join(
            [left + ' '.join([self.getCellStr(x, y) for x in rg]) for y in rg])
        return s

    def __str__(self, margins={}):
        b = self.boardToString(margins=margins)
        top = '\n'*margins.get('top', 0)
        bottom = '\n'*margins.get('bottom', 0)
        scores = ' \tScore: %5d  Best: %5d\n' % (self.score, self.best_score)
        return top + b.replace('\n', scores, 1) + bottom

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import canMove [as 别名]
class Game(object):
    #Asignacion de teclas de direccion
    __dirs = {
        keypress.UP:      Board.UP,
        keypress.DOWN:    Board.DOWN,
        keypress.LEFT:    Board.LEFT,
        keypress.RIGHT:   Board.RIGHT,
    }
    #Diccionario con los colores:
    COLORS = {
        2:    Fore.GREEN,
        4:    Fore.BLUE + Style.BRIGHT,
        8:    Fore.CYAN,
        16:   Fore.RED,
        32:   Fore.MAGENTA,
        64:   Fore.CYAN,
        128:  Fore.BLUE + Style.BRIGHT,
        256:  Fore.MAGENTA,
        512:  Fore.GREEN,
        1024: Fore.RED,
        2048: Fore.YELLOW,
        4096: Fore.RED,
        8192: Fore.CYAN,
    }

    def __init__(self, colors=COLORS, clear_screen=True, azmode=False):
        #Inicializa el juego
        self.board = Board()
        self.score = 0
        self.clear_screen = clear_screen
        self.__colors = colors
        self.__azmode = azmode

    def updateScore(self, pts):
        self.score += pts


    def readMove(self):
        #Lee un movimiento y lo pasa al tablero
        k = keypress.getKey()
        return Game.__dirs.get(k)

    def clearScreen(self):
        #Limpia la pantalla:
        if self.clear_screen:
            os.system('clear')
        else:
            print('\n')

    def loop(self):
        #Inicializa el juego:
        margins = {'left': 3, 'top': 3, 'bottom': 3}
        try:
            while True:
                self.clearScreen()
                print(self.__str__(margins=margins))
                if self.board.win() or not self.board.canMove():
                    break
                direction = self.readMove()
                self.updateScore(self.board.move(direction))

        except KeyboardInterrupt:
            return

        print('You win!' if self.board.win() else 'Game Over')
        return self.score

    def getCellStr(self, x, y):  # TODO: refactor regarding issue #11
        """
        return a string representation of the cell located at x,y.
        """
        c = self.board.getCell(x, y)

        if c == 0:
            return '.' if self.__azmode else '  .'

        elif self.__azmode:
            az = {}
            for i in range(1, int(math.log(self.board.goal(), 2))):
                az[2 ** i] = chr(i + 96)

            if c not in az:
                return '?'
            s = az[c]
        elif c == 1024:
            s = ' 1k'
        elif c == 2048:
            s = ' 2k'
        else:
            s = '%3d' % c

        return self.__colors.get(c, Fore.RESET) + s + Style.RESET_ALL

    def boardToString(self, margins={}):
        """
        return a string representation of the current board.
        """
        b = self.board
        rg = range(b.size())
        left = ' '*margins.get('left', 0)
#.........这里部分代码省略.........