Ordem da Desordem

Seja bem-vindo. Smile
Registre-se ou faça Login para ter acesso completo ao fórum.

Participe do fórum, é rápido e fácil

Ordem da Desordem

Seja bem-vindo. Smile
Registre-se ou faça Login para ter acesso completo ao fórum.

Ordem da Desordem

Gostaria de reagir a esta mensagem? Crie uma conta em poucos cliques ou inicie sessão para continuar.
Ordem da Desordem

OdD > VSQS


    Trabalho de programação

    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº1

    Trabalho de programação Empty Trabalho de programação

    Mensagem por Convidado 2011-06-14, 12:19 am

    Ae, trabalho pra entregar dia 25:

    fazer algo semelhante ao pac man em C


    Construir um conjunto de funções em linguagem C que permita a implementação do jogo
    PacMan. O jogo consiste de um caçador de tesouros que deve coletar moedas de ouro em um
    labirinto enquanto é perseguido por assaltantes. O caçador de tesouros vence o jogo se capturar
    todas as moedas. Caso ele não consiga obter todas as moedas ou seja atingido por um assaltante,
    perde.
    O tabuleiro do jogo deve ser implementado por meio de uma matriz binária, onde o valor 1
    indica parede e o valor 0 indica passagem. O tabuleiro dever´a ser exibido na tela a cada movimento,
    permitindo o acompanhamento visual do desenrolar do jogo.

    eu Posso usar a biblioteca gráfica se eu quiser, mas é opcional.

    e ele nem deu tanta matéria assim pra pedir algo nesse nível(sim, ele atrasou a turma PRA CARALEO pra querer pedir isso)
    não ensinaram nem ponteiros ainda D:

    não precisa fazer o algoritmo pra mim, mas pra dar uma luz mesmo, por onde começo, o que fazer, etc


    piada previsível: birger postando uma foto de uma lâmpada, ou algo luminoso e falando "aqui sua luz ehueuheuheuheuhe brbrbrbr"
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº2

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-14, 12:38 am

    Internerd tá cheio de implementações e dicas para Pac Man. O básico é ter uma função para criar o mapa na matriz (faça um mapa pré-desenhado, na mão mesmo, já é bem foda randomizar), função para movimentação por coordenadas da matriz (mais tarde tem que levar em conta a temporização dessa movimentação usando função rest(), já que andar 20 pontos da matriz em 1s é inviável para um jogo) e IA dos fantasmas, que pode usar algoritmos A Pathfinding.

    Acho sacanagem o professor dar um trabalho desses com pouco tempo, mas só se aprende a programar na base do "se vira" mesmo, vai perder umas noites de sono aí. Ainda bem que tem internet. Não precisa necessariamente de ponteiros, só seria útil para implementar a IA dos fantasmas (menor caminho de Dijkstra), mas não é necessário.
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº3

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-14, 8:01 am

    Meu professor uma vez mandou fazer um jogo também, mas no Sketch.

    Puta troço esquisito.

    Se fosse para fazer em C, eu taria fodido. Laughing
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº4

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-14, 9:12 am

    Vou dar dicas mais específicas e os passos para ajudar melhor:

    - Comece desenhando o mapa. Pegue alguma versão de pac-man e desenhe em um papel quadriculado o mapa mais básica, para depois jogar os dados na matriz. Salve essa matriz para iniciá-la no começo do jogo. Defina também como diferenciará um frame da matriz livre, com uma bolinha pequena ou uma bolinha grande (pontuação), se necessário.

    - Comece a definir a movimentação do personagem. Se for usar alguma ferramenta gráfica, pense em definir o Pac-Man como um vetor com parâmetros "coordenada", "sentido" e "direção". Isso para que você sempre mantenha o sprite virado para o lado certo. A partir disso, trabalhe na movimentação baseado em coordenadas XY. Por exemplo, nos jogos clássicos de PM, ele anda automaticamente, mesmo sem interferência do jogador, e faz isso para o sentido/direção do vetor sprite. Com um simples incremento de eixo e uma temporização (você pode usar rest() ou sincronizar com o relógio da linguagem, pesquise sobre), vai deixar a movimentação no ritmo certo. Trabalhe também com as possibilidade: se o frame a frente for parede, não irá conseguir incrementar 1. É daí por diante, pense em todas possibilidades antes de implementar e leve em conta as entradas do teclado (dá para usar o get() nas teclas "AWSD"). Se tiver algum conhecimento de Álgebra Linear, agora pode ser a hora de aplicar alguns conceitos básicos.

    - Aí vem a parte mais difícil: definir a IA dos inimigos. Existem algoritmos para isso, aí em cima passei um artigo sobre algoritmos A. É preciso um pouco de conhecimento sobre o funcionamento deles antes de implementar. Eu prefiro o menor caminho de djikistra, mas ele é melhor implementado com ponteiros, não sei como ficaria usando coordenadas em uma estrutura de matriz. Preste atenção para os valores iniciais e o fator randômico dessas IA's. Um fantasma tem que percorrer um caminho diferente que outros, ou todos ficarão sempre colados uns aos outros. Penso que dê para resolver isso com fantasmas "sólidos" (não seria permitido um ocupar o frame do outro). Quando os fantasmas ficam "comíveis", pode-se usar o mesmo algoritmo só que fazendo eles voltarem a um ponto específico do centro.

    - Deixe a parte gráfica (sprites) para o fim. Ela é chata, mas se faltar tempo dá para fazer qualquer merda (ou nem fazer, já que é opcional). Se usar um vetor para representar sprites, existem fórmulas matemáticas para definir coisas como ângulos e velocidade para a virada do sprite, depois posso te passar.




    Bom trabalho aí.
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº5

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-14, 10:34 pm

    bom, é mais foda do que pensei
    mas da pra fazer
    vlws

    Struct não ajudaria não?
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº6

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-14, 10:39 pm

    BAH

    Não posso te ajudar, tive um trabalho assim e me ralei muuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuito!

    Use conio2.h e seja feliz

    edit: é interface gráfica mesmo? ou o o jogo pode ser por caracteres?
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº7

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-14, 10:43 pm

    Código:
    // BIBLIOTECAS UTILIZADAS:

    #include <conio2.h>
    #include <ctype.h>
    #include <math.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <windows.h>

    // TECLAS DE INTERAÇÃO COM O JOGO:

    #define BAIXO 'x'
    #define CIMA 'w'
    #define DIREITA 'd'
    #define ESQUERDA 'a'
    #define PAUSE 'p'
    #define STOP 's'

    // CARACTERES UTILIZADOS NO LABIRINTO:

    #define FANTASMA 'X'
    #define LIVRE ' '
    #define MOEDA '*'
    #define PACMAN 'Q'
    #define PAREDE 219

    // DEFINIÇÕES BÁSICAS DO JOGO:

    #define COLUNAS 80
    #define LINHAS 25
    #define MAX_FANTASMAS 5
    #define NOME_ARQUIVO "labirinto.txt"

    // CONFIGURAÇÕES DE CORES DO JOGO:

    #define COR_FANTASMA textcolor(WHITE)
    #define COR_LABIRINTO textbackground(BLACK)
    #define COR_MOEDA textcolor(LIGHTGRAY)
    #define COR_PACMAN textcolor(LIGHTGREEN)
    #define COR_PAREDE textcolor(LIGHTGRAY)
    #define COR_TEXTO1 textcolor(LIGHTGRAY)
    #define COR_TEXTO2 textcolor(DARKGRAY)

    // ESTRUTURAS:

    struct posicao /* armazena a posição xy do pacman e dos fantasmas no labirinto */
    {
        int x, y;
    };
    struct posicao pacman, fantasma[MAX_FANTASMAS];

    struct distancia /* armazena a direção e a distância de cada fantasma até o pacman */
    {
        char dir;
        float val;
    };

    // MATRIZ ONDE SERÁ CARREGADA O LABIRINTO:

    unsigned char labirinto[LINHAS][COLUNAS];

    // PROTÓTIPOS DAS FUNÇÕES UTILIZADAS NO JOGO:

    char colisao(int pos_x, int pos_y);
    int fim(int score, int gameover);
    int mover_fantasma(int n);
    int mover_pacman(int *dir, int *dir_press, int *score, int vel_p);
    void carregar_labirinto(char arquivo[]);
    void detectar_posicoes(int *nro_fantasmas, int *nro_moedas);
    void imprimir_labirinto();
    void inicio(int *vel_p, int *vel_f);

    // ROTEIRO:

    int main()
    {
        SetConsoleTitle("PacMan");
       
        char arquivo[24] = NOME_ARQUIVO;
        int flag, flag_p; /* utilizadas para ajustar a velocidade dos fantasmas em relação ao pacman */
        int dir, dir_press; /* direção atual e direção de espera do pacman */
        int i, gameover, nro_fantasmas, nro_moedas, score, vel_f, vel_p;
       
        do /* executa o jogo tantas vezes quantas o usuário solicitar */
        {
            flag = 0;
            flag_p = 10;
            gameover = 0;
            nro_fantasmas = 0;
            nro_moedas = 0;
            score = 0;
           
            inicio(&vel_p, &vel_f);
            carregar_labirinto(arquivo);
            detectar_posicoes(&nro_fantasmas, &nro_moedas);
            imprimir_labirinto();
           
            do /* detecta a primeira tecla de movimento pressionada */
            {
                dir = getch();
                dir = tolower(dir);
                dir_press = dir;
            }
            while(dir != ESQUERDA && dir != DIREITA && dir != CIMA && dir != BAIXO);
           
            while(score < nro_moedas && !gameover) /* laço de movimentação do pacman e dos fantasmas */
            {
                if(flag_p == 10)
                {
                    gameover = mover_pacman(&dir, &dir_press, &score, vel_p);
                    flag_p = 0;
                }
                flag_p++;
                if(flag == vel_f)
                {
                    for(i = 0; i < nro_fantasmas; i++)
                        if(!gameover)
                            gameover = mover_fantasma(i);
                    flag = 0;
                }
                flag++;
            }
        }
        while(!fim(score, gameover));
       
        return 0;
    }

    // FUNÇÕES:

    char colisao(int pos_x, int pos_y)
    {
        char col = 0;
       
        if(labirinto[pos_y][pos_x] != LIVRE && labirinto[pos_y][pos_x] != MOEDA)
            col = labirinto[pos_y][pos_x];
       
        return col;
    }

    /* -------------------------------------------------------------------------- */

    int fim(int score, int gameover)
    {
        char continuar;
        int end = 0;
        fflush(stdin);
       
        Sleep(500);
        clrscr();
       
        COR_TEXTO1;
        if(!gameover)
        {
            printf("\n  Parabens! Voce completou todas as ");
            COR_TEXTO2;
            printf("%d ", score);
            COR_TEXTO1;
            printf("moedas!");
        }
        else
        {
            printf("\n  Voce perdeu!");
            printf("\n  Score: ");
            COR_TEXTO2;
            printf("%d", score);
        }
       
        COR_TEXTO1;
        printf("\n\n  Deseja jogar novamente? <S/N>\n\n  ");
        COR_TEXTO2;
        scanf("%c", &continuar);
       
        if(tolower(continuar) == 's')
            end = 0;
        else
            end = 1;
       
        return end;
    }

    /* -------------------------------------------------------------------------- */

    int mover_fantasma(int n)
    {
        char dir, dir_aux;
        float dist_aux;
        int i, j, gameover = 0;
        struct distancia dist[4];
       
        // CALCULA AS DISTÂNCIAS DO FANTASMA N ATÉ O PACMAN E SUAS RESPECTIVAS DIREÇÕES:
       
        dist[0].val = sqrt(pow(pacman.y - fantasma[n].y, 2) + pow(pacman.x - (fantasma[n].x - 1), 2));
        dist[1].val = sqrt(pow(pacman.y - fantasma[n].y, 2) + pow(pacman.x - (fantasma[n].x + 1), 2));
        dist[2].val = sqrt(pow(pacman.y - (fantasma[n].y - 1), 2) + pow(pacman.x - fantasma[n].x, 2));
        dist[3].val = sqrt(pow(pacman.y - (fantasma[n].y + 1), 2) + pow(pacman.x - fantasma[n].x, 2));
       
        dist[0].dir = ESQUERDA;
        dist[1].dir = DIREITA;
        dist[2].dir = CIMA;
        dist[3].dir = BAIXO;
       
        // ORGANIZA AS DISTÂNCIAS E SUAS RESPECTIVAS DIREÇÕES EM ORDEM CRESCENTE NOS VETORES:
       
        for(i = 0; i < 3; i++)
            for(j = 0; j < 3; j++)
                if(dist[j].val > dist[j + 1].val)
                {
                    dist_aux = dist[j].val;
                    dist[j].val = dist[j + 1].val;
                    dist[j + 1].val = dist_aux;
                   
                    dir_aux = dist[j].dir;
                    dist[j].dir = dist[j + 1].dir;
                    dist[j + 1].dir = dir_aux;
                }
       
        // VERIFICA SE EXISTE COLISÃO EM CADA DIREÇÃO, DA MAIOR PARA A MENOR DISTÂNCIA:
       
        for(i = 3; i >= 0; i--) /* ao final do laço a variável "dir" recebe a menor direção disponível, livre de colisões */
        {
            if(dist[i].dir == ESQUERDA && !colisao(fantasma[n].x - 1, fantasma[n].y))
                dir = ESQUERDA;
            if(dist[i].dir == DIREITA && !colisao(fantasma[n].x + 1, fantasma[n].y))
                dir = DIREITA;
            if(dist[i].dir == CIMA && !colisao(fantasma[n].x, fantasma[n].y - 1))
                dir = CIMA;
            if(dist[i].dir == BAIXO && !colisao(fantasma[n].x, fantasma[n].y + 1))
                dir = BAIXO;
        }
       
        // MOVIMENTA O FANTASMA N:
       
        switch(dir)
        {
            case CIMA:
                labirinto[fantasma[n].y][fantasma[n].x] = labirinto[fantasma[n].y - 1][fantasma[n].x];
                labirinto[fantasma[n].y - 1][fantasma[n].x] = FANTASMA;
               
                gotoxy(fantasma[n].x + 1, fantasma[n].y + 1);
                COR_MOEDA;
                printf("%c", labirinto[fantasma[n].y][fantasma[n].x]);
               
                fantasma[n].y--;
               
                gotoxy(fantasma[n].x + 1, fantasma[n].y + 1);
                COR_FANTASMA;
                printf("%c", labirinto[fantasma[n].y][fantasma[n].x]);
               
                if(colisao(fantasma[n].x, fantasma[n].y - 1) == PACMAN)
                    gameover = 1;
                break;
           
            case ESQUERDA:
                labirinto[fantasma[n].y][fantasma[n].x] = labirinto[fantasma[n].y][fantasma[n].x - 1];
                labirinto[fantasma[n].y][fantasma[n].x - 1] = FANTASMA;
               
                gotoxy(fantasma[n].x + 1, fantasma[n].y + 1);
                COR_MOEDA;
                printf("%c", labirinto[fantasma[n].y][fantasma[n].x]);
               
                fantasma[n].x--;
               
                gotoxy(fantasma[n].x + 1, fantasma[n].y + 1);
                COR_FANTASMA;
                printf("%c", labirinto[fantasma[n].y][fantasma[n].x]);
               
                if(colisao(fantasma[n].x - 1, fantasma[n].y) == PACMAN)
                    gameover = 1;
                break;
           
            case DIREITA:
                labirinto[fantasma[n].y][fantasma[n].x] = labirinto[fantasma[n].y][fantasma[n].x + 1];
                labirinto[fantasma[n].y][fantasma[n].x + 1] = FANTASMA;
               
                gotoxy(fantasma[n].x + 1, fantasma[n].y + 1);
                COR_MOEDA;
                printf("%c", labirinto[fantasma[n].y][fantasma[n].x]);
               
                fantasma[n].x++;
               
                gotoxy(fantasma[n].x + 1, fantasma[n].y + 1);
                COR_FANTASMA;
                printf("%c", labirinto[fantasma[n].y][fantasma[n].x]);
               
                if(colisao(fantasma[n].x + 1, fantasma[n].y) == PACMAN)
                    gameover = 1;
                break;
           
            case BAIXO:
                labirinto[fantasma[n].y][fantasma[n].x] = labirinto[fantasma[n].y + 1][fantasma[n].x];
                labirinto[fantasma[n].y + 1][fantasma[n].x] = FANTASMA;
               
                gotoxy(fantasma[n].x + 1, fantasma[n].y + 1);
                COR_MOEDA;
                printf("%c", labirinto[fantasma[n].y][fantasma[n].x]);
               
                fantasma[n].y++;
               
                gotoxy(fantasma[n].x + 1, fantasma[n].y + 1);
                COR_FANTASMA;
                printf("%c", labirinto[fantasma[n].y][fantasma[n].x]);
               
                if(colisao(fantasma[n].x, fantasma[n].y + 1) == PACMAN)
                    gameover = 1;
                break;
        }
       
        return gameover;
    }

    /* -------------------------------------------------------------------------- */

    int mover_pacman(int *dir, int *dir_press, int *score, int vel_p)
    {
        int dir_aux = *dir, gameover = 0, pos_x = pacman.x, pos_y = pacman.y, sleep = 1;
       
        // DETECTA SE ALGUMA TECLA FOI PRESSIONADA:
       
        if(kbhit())
        {
            *dir_press = getch();
            *dir_press = tolower(*dir_press); /* armazena a tecla pressionada na variável "dir_press" */
        }
       
        // ATUALIZA AS VARIÁVEIS "pos_x" OU "pos_y", QUE SERÃO UTILIZADAS PARA VERIFICAR POSSÍVEL COLISÃO:
       
        switch(*dir_press)
        {
            case CIMA:
                pos_y = pacman.y - 1;
                break;
           
            case ESQUERDA:
                pos_x = pacman.x - 1;
                break;
           
            case DIREITA:
                pos_x = pacman.x + 1;
                break;
           
            case BAIXO:
                pos_y = pacman.y + 1;
                break;
        }
       
        // VERIFICA SE EXISTE COLISÃO NA DIREÇÃO DA ÚLTIMA TECLA PRESSIONADA:
       
        if(!colisao(pos_x, pos_y) || *dir_press == PAUSE || *dir_press == STOP)
            *dir = *dir_press; /* atualiza a direção de movimentação do pacman */
       
        // MOVIMENTA O PACMAN:
       
        switch(*dir)
        {
            case CIMA:
                if(!colisao(pacman.x, pacman.y - 1))
                {
                    if(labirinto[pacman.y - 1][pacman.x] == MOEDA)
                        *score = *score + 1;
                   
                    labirinto[pacman.y][pacman.x] = LIVRE;
                    labirinto[pacman.y - 1][pacman.x] = PACMAN;
                   
                    gotoxy(pacman.x + 1, pacman.y + 1);
                    printf("%c", labirinto[pacman.y][pacman.x]);
                   
                    pacman.y--;
                   
                    gotoxy(pacman.x + 1, pacman.y + 1);
                    COR_PACMAN;
                    printf("%c", labirinto[pacman.y][pacman.x]);
                }
                if(colisao(pacman.x, pacman.y - 1) == FANTASMA)
                    gameover = 1;
                break;
           
            case ESQUERDA:
                if(!colisao(pacman.x - 1, pacman.y))
                {
                    if(labirinto[pacman.y][pacman.x - 1] == MOEDA)
                        *score = *score + 1;
                   
                    labirinto[pacman.y][pacman.x] = LIVRE;
                    labirinto[pacman.y][pacman.x - 1] = PACMAN;
                   
                    gotoxy(pacman.x + 1, pacman.y + 1);
                    printf("%c", labirinto[pacman.y][pacman.x]);
                   
                    pacman.x--;
                   
                    gotoxy(pacman.x + 1, pacman.y + 1);
                    COR_PACMAN;
                    printf("%c", labirinto[pacman.y][pacman.x]);
                }
                if(colisao(pacman.x - 1, pacman.y) == FANTASMA)
                    gameover = 1;
                break;
           
            case DIREITA:
                if(!colisao(pacman.x + 1, pacman.y))
                {
                    if(labirinto[pacman.y][pacman.x + 1] == MOEDA)
                        *score = *score + 1;
                   
                    labirinto[pacman.y][pacman.x] = LIVRE;
                    labirinto[pacman.y][pacman.x + 1] = PACMAN;
                   
                    gotoxy(pacman.x + 1, pacman.y + 1);
                    printf("%c", labirinto[pacman.y][pacman.x]);
                   
                    pacman.x++;
                   
                    gotoxy(pacman.x + 1, pacman.y + 1);
                    COR_PACMAN;
                    printf("%c", labirinto[pacman.y][pacman.x]);
                }
                if(colisao(pacman.x + 1, pacman.y) == FANTASMA)
                    gameover = 1;
                break;
           
            case BAIXO:
                if(!colisao(pacman.x, pacman.y + 1))
                {
                    if(labirinto[pacman.y + 1][pacman.x] == MOEDA)
                        *score = *score + 1;
                   
                    labirinto[pacman.y][pacman.x] = LIVRE;
                    labirinto[pacman.y + 1][pacman.x] = PACMAN;
                   
                    gotoxy(pacman.x + 1, pacman.y + 1);
                    printf("%c", labirinto[pacman.y][pacman.x]);
                   
                    pacman.y++;
                   
                    gotoxy(pacman.x + 1, pacman.y + 1);
                    COR_PACMAN;
                    printf("%c", labirinto[pacman.y][pacman.x]);
                }
                if(colisao(pacman.x, pacman.y + 1) == FANTASMA)
                    gameover = 1;
                break;
           
            case PAUSE:
                do
                    *dir_press = getch();
                while(*dir_press != PAUSE);
               
                *dir_press = dir_aux;
                break;
           
            case STOP:
                break;
           
            default:
                sleep = 0;
                *dir = dir_aux;
                break;
        }
       
        Sleep(vel_p); /* reduz a velocidade do pacman de acordo com a velocidade escolhida */
       
        return gameover;
    }

    /* -------------------------------------------------------------------------- */

    void carregar_labirinto(char arquivo[])
    {
        int i, j;
        FILE *arq;
       
        clrscr();
       
        while(!(arq = fopen(arquivo, "r")))
        {
            COR_TEXTO1;
            printf("\n  Impossivel carregar o arquivo ");
            COR_TEXTO2;
            puts(arquivo);
           
            COR_TEXTO1;
            printf("\n  Digite o nome do arquivo que contem o labirinto: ");
            COR_TEXTO2;
            fflush(stdin);
            gets(arquivo);
            printf("\n");
        }
        for(i = 0; i < LINHAS; i++)
            for(j = 0; j < COLUNAS; j++)
            {
                fscanf(arq, "%c\n", &labirinto[i][j]);
                if(labirinto[i][j] == '#')
                    labirinto[i][j] = PAREDE;
            }
        fclose(arq);
    }

    /* -------------------------------------------------------------------------- */

    void detectar_posicoes(int *nro_fantasmas, int *nro_moedas)
    {
        int i, j;
       
        for(i = 0; i < LINHAS; i++)
            for(j = 0; j < COLUNAS; j++)
            {
                if(labirinto[i][j] == 'Q')
                {
                    pacman.x = j;
                    pacman.y = i;
                }
                if(labirinto[i][j] == 'X' && *nro_fantasmas < MAX_FANTASMAS)
                {
                    fantasma[*nro_fantasmas].x = j;
                    fantasma[*nro_fantasmas].y = i;
                    *nro_fantasmas = *nro_fantasmas + 1;
                }
                if(labirinto[i][j] == MOEDA)
                    *nro_moedas = *nro_moedas + 1;
            }
    }

    /* -------------------------------------------------------------------------- */

    void imprimir_labirinto()
    {
        int i, j;
       
        clrscr();
       
        for(i = 0; i < LINHAS; i++)
            for(j = 0; j < COLUNAS; j++)
            {
                COR_LABIRINTO;
                if(labirinto[i][j] == FANTASMA)
                    COR_FANTASMA;
                if(labirinto[i][j] == MOEDA)
                    COR_MOEDA;
                if(labirinto[i][j] == PACMAN)
                    COR_PACMAN;
                if(labirinto[i][j] == PAREDE)
                    COR_PAREDE;
                printf("%c", labirinto[i][j]);
            }
       
        gotoxy(1,1);
    }

    /* -------------------------------------------------------------------------- */

    void inicio(int *vel_p, int *vel_f)
    {
        clrscr();
       
        COR_TEXTO1;
        printf("\n  Velocidade do PacMan: ");
        printf("\n\n  [1] ");
        COR_TEXTO2;
        printf("Muito lenta");
        COR_TEXTO1;
        printf("\n  [2] ");
        COR_TEXTO2;
        printf("Lenta");
        COR_TEXTO1;
        printf("\n  [3] ");
        COR_TEXTO2;
        printf("Media");
        COR_TEXTO1;
        printf("\n  [4] ");
        COR_TEXTO2;
        printf("Rapida");
        COR_TEXTO1;
        printf("\n  [5] ");
        COR_TEXTO2;
        printf("Muito rapida");
       
        COR_TEXTO1;
        printf("\n\n  Velocidade dos fantasmas: ");
        printf("\n\n  [1] ");
        COR_TEXTO2;
        printf("Muito lenta");
        COR_TEXTO1;
        printf("\n  [2] ");
        COR_TEXTO2;
        printf("Lenta");
        COR_TEXTO1;
        printf("\n  [3] ");
        COR_TEXTO2;
        printf("Media");
        COR_TEXTO1;
        printf("\n  [4] ");
        COR_TEXTO2;
        printf("Rapida");
        COR_TEXTO1;
        printf("\n  [5] ");
        COR_TEXTO2;
        printf("Muito rapida");
       
        do
        {
            gotoxy(25,2);
            scanf("%d", vel_p);
            if(*vel_p < 1 || *vel_p > 5)
            {
                gotoxy(3,18);
                COR_TEXTO2;
                printf("Digite um valor de velocidade entre 1 e 5");
            }
        }
        while(*vel_p < 1 || *vel_p > 5);
       
        gotoxy(3,18);
        printf("                                        ");
       
        do
        {
            gotoxy(29,10);
            scanf("%d", vel_f);
            if(*vel_f < 1 || *vel_f > 5)
            {
                gotoxy(3,18);
                COR_TEXTO2;
                printf("Digite um valor de velocidade entre 1 e 5");
            }
        }
        while(*vel_f < 1 || *vel_f > 5);
       
        switch(*vel_p)
        {
            case 1:
                *vel_p = 130;
                break;
            case 2:
                *vel_p = 110;
                break;
            case 3:
                *vel_p = 90;
                break;
            case 4:
                *vel_p = 70;
                break;
            case 5:
                *vel_p = 50;
                break;
        }
        switch(*vel_f)
        {
            case 1:
                *vel_f = 33; /* 30% da velocidade do pacman */
                break;
            case 2:
                *vel_f = 25; /* 40% da velocidade do pacman */
                break;
            case 3:
                *vel_f = 20; /* 50% da velocidade do pacman */
                break;
            case 4:
                *vel_f = 14; /* 70% da velocidade do pacman */
                break;
            case 5:
                *vel_f = 11; /* 90% da velocidade do pacman */
                break;
        }
    }




    Não se isso é certo, esse é o trabalho meu e da minha dupla semestre passado, dá pra achar muita coisa na net, mas acho que isso te ajuda. Wink
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº8

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-14, 11:56 pm

    eu queria ver como ficou esse ae
    mas nem ta compilando D:
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº9

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-15, 12:02 am

    suponho que não tenho a coni2 instalada, baixa na net, e pesquisa como instalá-la, tem um procedimentozinho que esqueci.
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº10

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-15, 12:31 am

    instalei e deu um erro diferente
    edit:
    ta faltando o labirint.txt
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº11

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-15, 12:51 am

    Bob Joe escreveu:Eu prefiro o menor caminho de djikistra

    Só passei aqui pra perguntar COMO DIABOS se pronuncia o nome desse maluco.


    No mais, boa sorte e libera o joguinho pra nois depois.
    • Ir para o topo
    Nightmare Elf
    Nightmare Elf
    Nightmare Elf
    Admin OdD
    Admin OdD


    MBTI : INTJ
    Mensagens : 5728
    Data de inscrição : 22/08/2009
    • Mensagem nº12

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Nightmare Elf 2011-06-15, 12:55 am

    Mig Master escreveu:
    Bob Joe escreveu:Eu prefiro o menor caminho de djikistra

    Só passei aqui pra perguntar COMO DIABOS se pronuncia o nome desse maluco.


    No mais, boa sorte e libera o joguinho pra nois depois.

    Na minha faculdade se fala "dastra", mas não sei.

    Ask, cria o labirint.txt, nao parece ser dificil rs
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº13

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-15, 1:01 am

    http://www.4shared.com/file/W5W1WbMs/pac.html

    jogo em .exe + labirinto em txt

    O código era pra gerar isso, vou mimir, até amanhã.
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº14

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-15, 8:18 am

    @Ask
    Não é tão difícil, cara. Só é trabalhoso. Depois que você define a maioria das coisas, é questão de codding.

    Nerf escreveu:suponho que não tenho a coni2 instalada, baixa na net, e pesquisa como instalá-la, tem um procedimentozinho que esqueci.
    Conio?!

    Portabilidade kd? Laughing

    Mig Master escreveu:Só passei aqui pra perguntar COMO DIABOS se pronuncia o nome desse maluco.

    Um professor meu que fez doutorado na Holanda (e o Dijkstra é holandês) diz que o "j" não se pronuncia. Então é "Díquistra" ou em inglês "daiquistra".
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº15

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-15, 5:02 pm

    Bob Joe escreveu:@Ask
    Não é tão difícil, cara. Só é trabalhoso. Depois que você define a maioria das coisas, é questão de codding.

    Nerf escreveu:suponho que não tenho a coni2 instalada, baixa na net, e pesquisa como instalá-la, tem um procedimentozinho que esqueci.
    Conio?!

    Portabilidade kd? Laughing

    Mig Master escreveu:Só passei aqui pra perguntar COMO DIABOS se pronuncia o nome desse maluco.

    Um professor meu que fez doutorado na Holanda (e o Dijkstra é holandês) diz que o "j" não se pronuncia. Então é "Díquistra" ou em inglês "daiquistra".

    Pô, "fessora" pediu. Lol Negro



    Pensei que Dijkstra era árabe e achava que se pronunciava "dijistrica".



    Bigode
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº16

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-15, 10:20 pm

    ele disse na aula hj que tem que rodar no linux
    okay =(
    • Ir para o topo
    Nightmare Elf
    Nightmare Elf
    Nightmare Elf
    Admin OdD
    Admin OdD


    MBTI : INTJ
    Mensagens : 5728
    Data de inscrição : 22/08/2009
    • Mensagem nº17

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Nightmare Elf 2011-06-15, 10:45 pm

    Askarar escreveu:ele disse na aula hj que tem que rodar no linux
    okay =(

    voce vai fazer em C, filho. tanto faz compilar no gcc ou no visual studio.
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº18

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-15, 11:15 pm

    Depende, tem professor que exije o Makefile.

    O meu de Estrutura sempre pedia nos trabalhos dele.
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº19

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-16, 1:22 am

    Nightmare Elf escreveu:
    Askarar escreveu:ele disse na aula hj que tem que rodar no linux
    okay =(

    voce vai fazer em C, filho. tanto faz compilar no gcc ou no visual studio.

    ele disse que tem que rodar no linux
    pq mimimi faculdade só usa linux mimimi software livre mimimi comunismo

    dai não pode usar usar essa conio, por exemplo, pq não tem no linux(me disseram)
    • Ir para o topo
    Convidado
    avatar
    Convidado
    Convidado


    • Mensagem nº20

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Convidado 2011-06-16, 7:19 am

    Askarar escreveu:ele disse que tem que rodar no linux
    pq mimimi faculdade só usa linux mimimi software livre mimimi comunismo

    dai não pode usar usar essa conio, por exemplo, pq não tem no linux(me disseram)

    Exato.

    E cara, quando você fizer Sistemas Operacionais vai ver porque o Linux (e sistemas UNIX em geral) é tão aclamado na área de computação, principalmente para quem é desenvolvedor. Não é apenas por ser "livre".
    • Ir para o topo
    Conteúdo patrocinado

    Conteúdo patrocinado


    • Mensagem nº21

    Trabalho de programação Empty Re: Trabalho de programação

    Mensagem por Conteúdo patrocinado

    • Ir para o topo
      Data/hora atual: 2024-05-19, 2:17 am