Não se move

def pintar(self, tela):
        for numero_linha, linha in enumerate(self.matriz):
            self.pintar_linha(tela, numero_linha, linha)
        self.pintar_pontos(tela)

    def get_direcoes(self, linha, coluna):
        direcoes = []
        if self.matriz[int(linha - 1)][int(coluna)] != 2:
            direcoes.append(ACIMA)
        if self.matriz[int(linha + 1)][int(coluna)] != 2:
            direcoes.append(ABAIXO)
        if self.matriz[int(linha)][int(coluna - 1)] != 2:
            direcoes.append(ESQUERDA)
        if self.matriz[int(linha)][int(coluna + 1)] != 2:
            direcoes.append(DIREITA)

        return direcoes

    def calcular_regras(self):
        direcoes = self.get_direcoes(self.fantasma.linha, self.fantasma.coluna)
        if len(direcoes) >= 3:
            self.fantasma.esquina(direcoes)
        col = self.pacman.coluna_intencao
        lin = self.pacman.linha_intencao
        if 0 <= col < 28 and 0 <= lin < 29 and self.matriz[lin][col] != 2:
            self.pacman.aceitar_movimento()
            if self.matriz[lin][col] == 1:
                self.pontos += 1
                self.matriz[lin][col] = 0

        col = int(self.fantasma.coluna_intencao)
        print(col)
        lin = int(self.fantasma.linha_intencao)
        if 0 <= col <= 28 and 0 <= lin <= 29 and self.matriz[lin][col] != 2:
            self.fantasma.aceitar_movimento()
        else:
            self.fantasma.recusar_movimento(direcoes)

    def processar_eventos(self, evts):
        for e in evts:
            if e.type == pygame.QUIT:
                exit()


class Pacman(ElementoJogo):
    def __init__(self, tamanho):
        self.coluna = 1
        self.linha = 1
        self.centro_x = 400
        self.centro_y = 300
        self.tamanho = tamanho
        self.vel_x = 0
        self.vel_y = 0
        self.raio = self.tamanho // 2
        self.coluna_intencao = self.coluna
        self.linha_intencao = self.linha

    def calcular_regras(self):
        self.coluna_intencao = self.coluna + self.vel_x
        self.linha_intencao = self.linha + self.vel_y
        self.centro_x = int(self.coluna * self.tamanho + self.raio)
        self.centro_y = int(self.linha * self.tamanho + self.raio)

    def pintar(self, tela):
        # Desenhar o corpo do Pacman
        pygame.draw.circle(tela, AMARELO, (self.centro_x, self.centro_y), self.raio, 0)

        # Desenho da boca do Pacman
        canto_boca = (self.centro_x, self.centro_y)
        labio_superior = (self.centro_x + self.raio, self.centro_y - self.raio)
        labio_inferior = (self.centro_x + self.raio, self.centro_y)
        pontos = [canto_boca, labio_superior, labio_inferior]
        pygame.draw.polygon(tela, PRETO, pontos, 0)

        # Olho do Pacman
        olho_x = int(self.centro_x + self.raio / 3)
        olho_y = int(self.centro_y - self.raio * 0.7)
        olho_raio = int(self.raio / 10)
        pygame.draw.circle(tela, PRETO, (olho_x, olho_y), olho_raio, 0)

    def processar_eventos(self, evsts):
        for e in eventos:
            if e.type == pygame.KEYDOWN:
                if e.key == pygame.K_RIGHT:
                    self.vel_x = VELOCIDADE
                elif e.key == pygame.K_LEFT:
                    self.vel_x = -VELOCIDADE
                elif e.key == pygame.K_UP:
                    self.vel_y = -VELOCIDADE
                elif e.key == pygame.K_DOWN:
                    self.vel_y = VELOCIDADE

            elif e.type == pygame.KEYUP:
                if e.key == pygame.K_RIGHT or e.key == pygame.K_LEFT:
                    self.vel_x = 0
                elif e.key == pygame.K_UP or e.key == pygame.K_DOWN:
                    self.vel_y = 0

    def aceitar_movimento(self):
        self.linha = self.linha_intencao
        self.coluna = self.coluna_intencao

class Fantasma(ElementoJogo):
    def __init__(self, cor, tamanho):
        self.coluna = 6.0
        self.linha = 2.0
        self.linha_intencao = self.linha
        self.coluna_intencao = self.coluna
        self.velocidade = 1
        self.direcao = 0
        self.tamanho = tamanho
        self.cor = cor

    def pintar(self, tela):
        fatia = self.tamanho // 8  # 2.5
        px = int(self.coluna * self.tamanho)  # 15
        py = int(self.linha * self.tamanho)   # 20
        contorno = [(px, py + self.tamanho),  # x = 15, y = 40
                    (px + fatia, py + fatia * 2),  # x = 35, y = 25
                    (px + fatia * 2, py + fatia // 2),  # x = 20, y = 21
                    (px + fatia * 3, py),  # x = 22.5, y = 20
                    (px + fatia * 5, py),  # x = 27.5, y = 20
                    (px + fatia * 6, py + fatia // 2),  # x = 30, y = 21
                    (px + fatia * 7, py + fatia * 2),  # x = 32.5, y = 25
                    (px + self.tamanho, py + 20),  # x = 35, y = 40
                    (px + self.tamanho - 5, py + 15),  # x = 30, y = 35
                    (px + self.tamanho - 7, py + 20),  # x = 28, y = 40
                    (px + self.tamanho - 12, py + 15),  # x = 23, y = 35
                    (px + self.tamanho - 14, py + 20),  # x = 21, y = 40
                    (px + self.tamanho - 19, py + 15)]  # x = 16, y = 35

        pygame.draw.polygon(tela, self.cor, contorno, 0)

        olho_raio_ext = fatia
        olho_raio_int = fatia // 2

        olho_e_x = int(px + fatia * 2.5)
        olho_e_y = int(py + fatia * 2.5)

        olho_d_x = int(px + fatia * 5.5)
        olho_d_y = int(py + fatia * 2.5)

        pygame.draw.circle(tela, BRANCO, (olho_e_x, olho_e_y), olho_raio_ext, 0)
        pygame.draw.circle(tela, PRETO, (olho_e_x, olho_e_y), olho_raio_int, 0)
        pygame.draw.circle(tela, BRANCO, (olho_d_x, olho_d_y), olho_raio_ext, 0)
        pygame.draw.circle(tela, PRETO, (olho_d_x, olho_d_y), olho_raio_int, 0)

    def calcular_regras(self):
        if self.direcao == ACIMA:
            self.linha_intencao -= self.velocidade
        elif self.direcao == ABAIXO:
            self.linha_intencao += self.velocidade
        elif self.direcao == ESQUERDA:
            self.coluna_intencao -= self.velocidade
        elif self.direcao == DIREITA:
            self.coluna_intencao += self.velocidade

        print(self.direcao)


    def mudar_direcao(self, direcoes):
        self.direcao = random.choice(direcoes)

    def esquina(self, direcoes):
        self.mudar_direcao(direcoes)

    def aceitar_movimento(self):
        self.linha = self.linha_intencao
        self.coluna = self.coluna_intencao

    def recusar_movimento(self, direcoes):
        self.linha_intencao = self.linha
        self.coluna_intencao = self.coluna
        self.mudar_direcao(direcoes)

    def processar_eventos(self, evts):
        pass


if __name__ == "__main__":
    size = 600 // 30
    pacman = Pacman(size)
    blinky = Fantasma(VERMELHO, size)
    cenario = Cenario(size, pacman, blinky)

    while True:
        # Calcular as regras
        pacman.calcular_regras()
        blinky.calcular_regras()
        cenario.calcular_regras()

        # Pintar a tela
        screen.fill(PRETO)
        cenario.pintar(screen)
        pacman.pintar(screen)
        blinky.pintar(screen)
        pygame.display.update()
        pygame.time.delay(100)

        # Captura os eventos
        eventos = pygame.event.get()
        pacman.processar_eventos(eventos)
        cenario.processar_eventos(eventos)

Olá, tudo bem com você?

Analisando o código apresentado, será necessário realizar uma modificação na classe Fantasma, em seu método inicializador devemos informar uma direção inicial de deslocamento para o fantasma, no código apresentado o atributo self.direcao está recebendo o valor 0 (zero), informando que o fantasma deve permanecer parado.

Basta atribuir uma das constantes de direção para o atributo self.direcao, assim o fantasma terá uma direção de movimentação inicial declarada. As constantes disponíveis são ACIMA, ABAIXO, DIREITA e ESQUERDA, na aula foi utilizado a constante ABAIXO.

A classe Fantasma tem seu método inicializador declarado da seguinte forma.

class Fantasma(ElementoJogo):
    def __init__(self, cor, tamanho):
        self.coluna = 6.0
        self.linha = 2.0
        self.linha_intencao = self.linha
        self.coluna_intencao = self.coluna
        self.velocidade = 1
        self.direcao = ABAIXO
        self.tamanho = tamanho
        self.cor = cor

Note a declaração do atributo de direção, self.direcao = ABAIXO.

Peço que realize a mudança proposta acima, e execute o código.

Caso o erro permaneça ou tenha dúvidas, fico à disposição.

Abraços e bons estudos.

Muito boa a sua dica!!!! Mas eu pensei em não inicializar ele se movendo em uma única direções e aí eu pensei nessa possibilidade:

class Fantasma(ElementoJogo, Movivel):
    def __init__(self, cor, tamanho):
        self.coluna = 21.0
        self.linha = 2.0
        self.linha_intencao = 0
        self.coluna_intencao = 0
        self.velocidade = 1
        self.direcao = 0
        self.tamanho = tamanho
        self.cor = cor

Eu modifiquei self.linha_intencao e self.coluna_intencao para que recebam zero e não self.linha ou self.coluna, então o erro seria aqui, pois ao colocar em uma esquina funciona, significando que se não for ele sempre vai sortear um que não seja a esquina, colocando os fantasmas em loop de imoviveis. Então queria saber se está corretamente pensar dessa forma... E se sim, então eu posso modificar o códico de recusar o movimento que usa o código self.linha_intencao = self.linha como na coluna, para self.linha_intencao = 0 como na coluna, pois assim poderia evitar aonde estaria o erro, certo?

Olá, existem diversas formas de se chegar a um resultado e esta que você apresentou é sim um bom caminho, não está se equivocando. Aproveito a oportunidade para parabenizar sua dedicação em ir além do proposto nas aulas e além disso, compartilhar na comunidade do fórum para que outros alunos e alunas conheçam e se inspirem através do seu código.

Conte sempre com a Alura para evoluir seus estudos.

Grande abraço!