Continuando o jogo

Arquivo mapa.c:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mapa.h"

void copiamapa(MAPA* destino, MAPA* origem) {
    destino->linhas = origem->linhas;
    destino->colunas = origem->colunas;

    alocamapa(destino);
    for(int i = 0; i < origem->linhas; i++) {
        strcpy(destino->matriz[i], origem->matriz[i]);
    }
}

void andanomapa(MAPA* m, int xorigem, int yorigem, int xdestino, int ydestino) {
    char personagem = m->matriz[xorigem][yorigem];
    m->matriz[xdestino][ydestino] = personagem;
    m->matriz[xorigem][yorigem] = VAZIO;
}

int ehvalida(MAPA* m, int x, int y) {
    if(x >= m->linhas) 
        return 0;
    if(y >= m->colunas)
        return 0;

    return 1;    
}

int ehvazia(MAPA* m, int x, int y) {
    return m->matriz[x][y] == VAZIO;
}

int encontramapa(MAPA* m, POSICAO* p, char c) {
        // acha a posição do foge foge
    for(int i = 0; i < m->linhas; i++) {
        for(int j = 0; j < m->colunas; j++) {
            if(m->matriz[i][j] == c) {
                p->x = i;
                p->y = j;
                return 1;
            }
        }
    }

    return 0;
}

int ehparede(MAPA* m, int x, int y) {
    return m->matriz[x][y] == PAREDE_VERTICAL ||
        m->matriz[x][y] == PAREDE_HORIZONTAL;
}

int ehpersonagem(MAPA* m, char personagem, int x, int y) {
    
    return m->matriz[x][y] == personagem;
}

int podeandar(MAPA* m, char personagem, int x, int y) {
    return 
        ehvalida(m, x, y) && !ehparede(m, x, y) && !ehpersonagem(m, personagem, x, y);
}

void liberamapa(MAPA* m) {

    for(int i = 0; i < m->linhas; i++) {
    free(m->matriz[i]);
}
    free(m->matriz);

}

void alocamapa(MAPA* m) {

    m->matriz = malloc(sizeof(char*) * m->linhas);
    for(int i = 0; i < m->linhas; i++) {
    m->matriz[i] = malloc(sizeof(char) * (m->colunas + 1));
    }

}

void lemapa(MAPA* m) {

    FILE* f;
    f = fopen("mapas.txt", "r");
    if(f == 0) {
        printf("Erro na leitura do mapa\n");
        exit(1);
    }

    fscanf(f, "%d %d", &(m->linhas), &(m->colunas));

    alocamapa(m);

    for(int i = 0; i < 5; i++) {
        fscanf(f, "%s", m->matriz[i]);
    }   

    fclose(f);

}

void imprimemapa(MAPA* m) {
    for(int i = 0; i < 5; i++) {
        printf("%s\n", m->matriz[i]);
    }
}

Arquivo mapa.h:

#define HEROI '@'
#define VAZIO '.'
#define PAREDE_VERTICAL '|'
#define PAREDE_HORIZONTAL '-'
#define FANTASMA 'F'

struct mapa {
    char** matriz;
    int linhas;
    int colunas;
};

typedef struct mapa MAPA;

struct posicao {
    int x;
    int y;
};

typedef struct posicao POSICAO;

void liberamapa(MAPA* m);
void lemapa(MAPA* m);
void alocamapa(MAPA* m);
void imprimemapa(MAPA* m);
int encontramapa(MAPA* m, POSICAO* p, char c, int x);


int ehvalida(MAPA* m, int x, int y);
int ehvazia(MAPA* m, int x, int y);
void andanomapa(MAPA* m, int xorigem, int yorigem, int xdestino, int ydestino);
void copiamapa(MAPA* destino, MAPA* origem);

int podeandar(MAPA* m, char personagem, int x, int y);

int ehparede(MAPA* m, int x, int y);

int ehpersonagem(MAPA* m, char personagem, int x, int y);

O meu código está correto ?

Oi, Guilherme! Como vai?

Sobre sua dúvida: o código não está 100% correto ainda. Vamos resolver isso. Abaixo estão os ajustes objetivos que você precisa aplicar para o jogo funcionar de forma confiável:

1. Assinatura incoerente de encontramapa no header

• O .h declara uma versão com 4 parâmetros, mas a implementação usa 3.
  Corrija o mapa.h:

Veja este exemplo:
mapa.h (corrigido)

int encontramapa(MAPA* m, POSICAO* p, char c);

1. Validação de limites incompleta (coordenadas negativas)

• Sua ehvalida não verifica x < 0 e y < 0. Isso causa acesso inválido à memória.
  Corrija ehvalida assim:

mapa.c (corrigido)

int ehvalida(MAPA* m, int x, int y) {
    if (x < 0) return 0;
    if (y < 0) return 0;
    if (x >= m->linhas) return 0;
    if (y >= m->colunas) return 0;
    return 1;
}

1. Leitura e impressão do mapa fixas em 5 linhas

• Você está desconsiderando m->linhas e m->colunas. Isso quebra mapas com tamanhos diferentes.
  Use as dimensões lidas do arquivo:

mapa.c (corrigido)

void lemapa(MAPA* m) {
    FILE* f = fopen("mapas.txt", "r");
    if (f == 0) {
        printf("Erro na leitura do mapa\n");
        exit(1);
    }

    fscanf(f, "%d %d", &(m->linhas), &(m->colunas));
    alocamapa(m);

    for (int i = 0; i < m->linhas; i++) {
        fscanf(f, "%s", m->matriz[i]);
    }

    fclose(f);
}

void imprimemapa(MAPA* m) {
    for (int i = 0; i < m->linhas; i++) {
        printf("%s\n", m->matriz[i]);
    }
}

1. Seed do gerador de números aleatórios em lugar indevido

• Você chama srand(time(0)) dentro de praondeofantasmavai. Isso reinicializa a semente várias vezes no mesmo segundo, gerando movimentos repetitivos.
  Semeie uma única vez em main e remova de praondeofantasmavai.

fogefoge.c (trechos corrigidos)

/* Remova um dos #include <stdio.h> (linha duplicada) */

int praondeofantasmavai(int xatual, int yatual, int* xdestino, int* ydestino) {
    int opcoes[4][2] = {
        { xatual   , yatual + 1 },
        { xatual + 1 , yatual   },
        { xatual   , yatual - 1 },
        { xatual - 1 , yatual   }
    };

    /* <-- REMOVIDO: srand(time(0)); */

    for (int i = 0; i < 10; i++) {
        int posicao = rand() % 4;
        if (podeandar(&m, FANTASMA, opcoes[posicao][0], opcoes[posicao][1])) {
            *xdestino = opcoes[posicao][0];
            *ydestino = opcoes[posicao][1];
            return 1;
        }
    }
    return 0;
}

int main() {
    /* Semente global uma única vez */
    srand((unsigned)time(NULL));

    lemapa(&m);
    encontramapa(&m, &heroi, HEROI);

    do {
        imprimemapa(&m);

        char comando;
        scanf(" %c", &comando);
        move(comando);
        fantasmas();

    } while (!acabou());

    liberamapa(&m);
    return 0;
}

1. Pequenos ajustes de limpeza

• Remova o bloco vazio após o while (!acabou()); em main.
• Mantenha apenas um #include <stdio.h> em fogefoge.c.

1. Sobre colisões FANTASMA x HEROI

• Sua lógica atual permite que o fantasma se mova para a mesma célula do herói, substituindo-o na matriz. Isso é válido se a regra de jogo for “encostou, perdeu”.
• Se quiser impedir que o fantasma “pise” no herói, altere podeandar para bloquear quando HEROI estiver no destino (mas aí precisa de uma checagem separada de derrota). Do jeito que você explicou, manter como está está correto para encerrar o jogo ao substituir o herói.

Resumo objetivo

• Corrija a assinatura de encontramapa no header.
• Conserte ehvalida para tratar negativos.
• Use m->linhas/m->colunas em leitura e impressão.
• Semente o RNG uma vez no main e remova de praondeofantasmavai.
• Limpe includes duplicados e bloco vazio.

Ajuste seu código assim e o jogo vai ficar funcional e previsível.

Fico à disposição. Abraços e bons estudos!