Algoritmo Labirinto Pacman

Nome: Marcus Vinícius Pereira Rocha Curso: Jogos Digitais

Módulo: Habilidades Ano: 2015

Introdução

Irei utilizar um código, que eu mesmo criei em Java na faculdade, para criação de um labirinto do Pac-Man. A construção é fácil quando se entende como funcionam os modos de programação gráfica.

É um modelo bem básico de programação de linhas, utilizando linhas de comando para se construir pontos e liga-los entre si.

Algoritmo do labirinto

Para começar os eixos invertidos, ou seja, de cabeça para baixo. Como mostrado na imagem:

Mas o ponto não é esse e sim como foi construído o labirinto. Para se construir o labirinto, foi necessário criar primeiro o tamanho da tela desejado. O tamanho utilizado foi do de 640x480, um tamanho pequeno e um pouco mais simples de se desenhar o labirinto.

Para se desenhar as peças, foram necessários criar vetores, com valores pré-definidos. Por qual motivo? Pois esses são os valores responsáveis por demonstrar qual é o pixel da tela, que o respectivo ponto está. Mas para se ligar os pontos, deve ser criado para cada peça um vetor para seu eixo X e um para o Y.

Com os vetores já criados é hora de mostrar esse labirinto na tela. Sendo assim, será necessário utilizar um comando, para que a tela seja criada. E em seguida será definido a cor do fundo da tela.

Sempre que um desenho for criado, tem de se usar um comando para que os vetores criados criem seus pontos e que os ligue, para que a forma geométrica ou o desenho criado seja mostrado.

Como foi mostrando no código, foi coloca o eixo X e o Y de cada peça com um número em seguida “linha(ilabvx, ilabvy, 10);”. Esse número é responsável por mostrar ao comando, quando pontos de ligação a peça vai ter, para assim fazer a ligação entre eles e as linhas aparecerem. variaveis int x, y; <- Variáveis responsáveis por guardar os valores de dimensão da tela int largura = 480; <- Variável responsável por guardar a largura int altura = 640; <- Variável responsável por guardar a altura //peças superiores do labirinto. //peças do lado esquerdo. int [] sepx1 = {110, 182, 182, 110, 110}; <- Valores dos pontos X da peça int [] sepy1 = {65, 65, 90, 90, 65}; <- Valores dos pontos Y da peça int [] sepx2 = {110, 182, 182, 110, 110}; int [] sepy2 = {125, 125, 140, 140, 125}; int [] sepx3 = {213, 285, 285, 213, 213}; int [] sepy3 = {65, 65, 90, 90, 65}; int [] sepx4 = {213, 233, 233, 285, 285, 233, 233, 213, 213}; int [] sepy4 = {125, 125, 175, 175, 181, 181, 230, 230, 125}; //peça do meio. int [] smpx = {263, 377, 377, 325, 325, 315, 315, 263, 263}; int [] smpy = {125, 125, 140, 140, 181, 181, 140, 140, 125}; //peças do lado direito int [] sdpx1 = {355, 427, 427, 355, 355}; int [] sdpy1 = {65, 65, 90, 90, 65}; int [] sdpx2 = {457, 529, 529, 457, 457}; int [] sdpy2 = {65, 65, 90, 90, 65}; int [] sdpx3 = {457, 529, 529, 457, 457}; int [] sdpy3 = {125, 125, 140, 140, 125}; int [] sdpx4 = {407, 427, 427, 407, 407, 355, 355, 407, 407}; int [] sdpy4 = {125, 125, 230, 230, 181, 181, 175, 175, 125}; //peça central do labirinto. int [] cpx = {335, 377, 377, 263, 263, 305, 305, 268, 268, 372, 372, 335, 335, 335}; int [] cpy = {211, 211, 275, 275, 211, 211, 216, 216, 270, 270, 216, 216, 216, 211}; //peças inferiores do labirinto. //peças do lado esquerdo int [] iepx1 = {213, 233, 233, 213, 213}; int [] iepy1 = {260, 260, 320, 320, 260}; int [] iepx2 = {115, 182, 182, 145, 145, 115, 115}; int [] iepy2 = {350, 350, 400, 400, 360, 360, 350}; int [] iepx3 = {213, 233, 233, 285, 285, 115, 115, 213, 213}; int [] iepy3 = {390, 390, 430, 430, 435, 435, 430, 430, 390};

int [] iepx4 = {213, 285, 285, 213, 213}; int [] iepy4 = {350, 350, 360, 360, 350}; //peças do meio. int [] impx1 = {263, 377, 377, 325, 325, 315, 315, 263, 263}; int [] impy1 = {390, 390, 400, 400, 435, 435, 400, 400, 390}; int [] impx2 = {263, 377, 377, 325, 325, 315, 315, 263, 263}; int [] impy2 = {305, 305, 320, 320, 360, 360, 320, 320, 305}; //peças do lado direito. int [] idpx1 = {407, 427, 427, 407, 407}; int [] idpy1 = {260, 260, 320, 320, 260}; int [] idpx2 = {355, 427, 427, 355, 355}; int [] idpy2 = {350, 350, 360, 360, 350}; int [] idpx3 = {407, 427, 427, 525, 525, 355, 355, 407, 407}; int [] idpy3 = {390, 390, 430, 430, 435, 435, 430, 430, 390}; int [] idpx4 = {457, 525, 525, 495, 495, 457, 457}; int [] idpy4 = {350, 350, 360, 360, 400, 400, 350}; //parte inferior externa do labirinto. int [] ilabvx = {50, 177, 177, 75, 75, 565, 565, 462, 462, 590}; int [] ilabvy = {265, 265, 315, 315, 470, 470, 315, 315, 265, 265}; //parte inferior interna do labirinto. int [] ilabintvx = {50, 182, 182, 80, 80, 115, 115, 80, 80, 560, 560, 525, 525, 560, 560, 457, 457, 590}; int [] ilabintvy = {260, 260, 320, 320 , 390, 390, 400, 400, 465, 465, 400, 400, 390, 390, 320, 320 , 260, 260}; // parte superior interna do labirinto. int [] slabintvx = {50, 182, 182, 80, 80, 315, 315, 325, 325, 560, 560, 457, 457, 590}; int [] slabintvy = {230, 230, 170, 170, 35, 35, 90, 90, 35, 35, 170, 170, 230, 230}; // parte superior externa do labirinto. int [] slabvx = {50, 177, 177, 75, 75, 565, 565, 462, 462, 590}; int [] slabvy = {225, 225, 175, 175, 30, 30, 175, 175, 225, 225}; Inicio definir.tamanhodatela(altura, largura); <- Esse comando é responsável por criar a tela definir.cordefundo(Cor.preta); <- Comando responsável por definir a cor de fundo da tela //parte superior do labirinto. definir.cor(Cor.azul); <- Comando responsável por definir a cor das linhas linha(slabvx, slabvy, 10); <- Comando responsável por mostrar as linhas e definir o número de pontos que o desenho irá ter linha(slabintvx, slabintvy, 14);

//parte inferior do labirinto. linha(ilabvx, ilabvy, 10); linha(ilabintvx, ilabintvy, 18); //peças superiores do labirinto. //peças do lado esquerdo. definir.cor(Cor.azul); linha(sepx1, sepy1, 5); linha(sepx2, sepy2, 5); linha(sepx3, sepy3, 5); linha(sepx4, sepy4, 9); //peça do meio. definir.cor(Cor.azul); linha(smpx, smpy, 9); //peças do lado direito. definir.cor(Cor.azul); linha(sdpx1, sdpy1, 5); linha(sdpx2, sdpy2, 5); linha(sdpx3, sdpy3, 5); linha(sdpx4, sdpy4, 9); //peça central. definir.cor(Cor.azul); linha(cpx, cpy, 14); //peças inferiores do labirinto. //peças do lado esquerdo. definir.cor(Cor.azul); linha(iepx1, iepy1, 5); linha(iepx2, iepy2, 7); linha(iepx3, iepy3, 9); linha(iepx4, iepy4, 5); //peças do meio. definir.cor(Cor.azul); linha(impx1, impy1, 9); linha(impx2, impy2, 9); //peças do lado direito. definir.cor(Cor.azul); linha(idpx1, idpy1, 5); linha(idpx2, idpy2, 5); linha(idpx3, idpy3, 9); linha(idpx4, idpy4, 7); fimalgoritmo

Conclusão

Esse é um modo básico de desenho, aplicado em Java. Como eu nunca havia feito esse tipo de algoritmo em Portugol e Visualg. Espero que eu tenha conseguido demonstrar para vocês o que eu pretendia.

Não é algo simples é trabalhoso, pois tem de se definir cada ponto exato para que o desenho tenha a forma desejada. Eu por exemplo, utilizei de um papel quadriculado e fiz todo o labirinto com seus pontos à mão, para assim depois passar para o programa e corrigir alguns erros, como linhas tortas por exemplo.

Fonte da imagem: Eixos: http://1.bp.blogspot.com/-Lh9aKOLdP44/T_WLQN1904I/AAAAAAAAAIQ/IGJCg8yN6cU/s1600/eixos.png Labirinto: própria O labirinto irá ficar assim:

Código original (JAVA)

Como prometido, vou anexar ao pdf, o código original de programação

do labirinto. Nó código é contido alguns comandos, que são necessários para

que o desenho seja mostrado. Mas o algoritmo acima segue a lógica correta do

código original.

O código é todo baseado em Orientação a objetos, por exemplo o

g.drawPolyline, a letra “g” é um objetivo utilizado para programação gráfica em

Java.

Caso não entenda o que esteja acontecendo, só entrar em contato.

import javax.swing.*;

import java.awt.*;

import java.awt.event.*;

class Labirinto extends JFrame

{

Polygon v;

int x, y;

int width = 480;

int height = 640;

//peças superiores do labirinto.

//peças do lado esquerdo.

int [] sepx1 = {110, 182, 182, 110, 110};

int [] sepy1 = {65, 65, 90, 90, 65};

int [] sepx2 = {110, 182, 182, 110, 110};

int [] sepy2 = {125, 125, 140, 140, 125};

int [] sepx3 = {213, 285, 285, 213, 213};

int [] sepy3 = {65, 65, 90, 90, 65};

int [] sepx4 = {213, 233, 233, 285, 285, 233, 233, 213, 213};

int [] sepy4 = {125, 125, 175, 175, 181, 181, 230, 230, 125};

//peça do meio.

int [] smpx = {263, 377, 377, 325, 325, 315, 315, 263, 263};

int [] smpy = {125, 125, 140, 140, 181, 181, 140, 140, 125};

//peças do lado direito

int [] sdpx1 = {355, 427, 427, 355, 355};

int [] sdpy1 = {65, 65, 90, 90, 65};

int [] sdpx2 = {457, 529, 529, 457, 457};

int [] sdpy2 = {65, 65, 90, 90, 65};

int [] sdpx3 = {457, 529, 529, 457, 457};

int [] sdpy3 = {125, 125, 140, 140, 125};

int [] sdpx4 = {407, 427, 427, 407, 407, 355, 355, 407, 407};

int [] sdpy4 = {125, 125, 230, 230, 181, 181, 175, 175, 125};

//peça central do labirinto.

int [] cpx = {335, 377, 377, 263, 263, 305, 305, 268, 268, 372, 372, 335, 335,

335};

int [] cpy = {211, 211, 275, 275, 211, 211, 216, 216, 270, 270, 216, 216, 216,

211};

//peças inferiores do labirinto.

//peças do lado esquerdo

int [] iepx1 = {213, 233, 233, 213, 213};

int [] iepy1 = {260, 260, 320, 320, 260};

int [] iepx2 = {115, 182, 182, 145, 145, 115, 115};

int [] iepy2 = {350, 350, 400, 400, 360, 360, 350};

int [] iepx3 = {213, 233, 233, 285, 285, 115, 115, 213, 213};

int [] iepy3 = {390, 390, 430, 430, 435, 435, 430, 430, 390};

int [] iepx4 = {213, 285, 285, 213, 213};

int [] iepy4 = {350, 350, 360, 360, 350};

//peças do meio.

int [] impx1 = {263, 377, 377, 325, 325, 315, 315, 263, 263};

int [] impy1 = {390, 390, 400, 400, 435, 435, 400, 400, 390};

int [] impx2 = {263, 377, 377, 325, 325, 315, 315, 263, 263};

int [] impy2 = {305, 305, 320, 320, 360, 360, 320, 320, 305};

//peças do lado direito.

int [] idpx1 = {407, 427, 427, 407, 407};

int [] idpy1 = {260, 260, 320, 320, 260};

int [] idpx2 = {355, 427, 427, 355, 355};

int [] idpy2 = {350, 350, 360, 360, 350};

int [] idpx3 = {407, 427, 427, 525, 525, 355, 355, 407, 407};

int [] idpy3 = {390, 390, 430, 430, 435, 435, 430, 430, 390};

int [] idpx4 = {457, 525, 525, 495, 495, 457, 457};

int [] idpy4 = {350, 350, 360, 360, 400, 400, 350};

//parte inferior externa do labirinto.

int [] ilabvx = {50, 177, 177, 75, 75, 565, 565, 462, 462, 590};

int [] ilabvy = {265, 265, 315, 315, 470, 470, 315, 315, 265, 265};

//parte inferior interna do labirinto.

int [] ilabintvx = {50, 182, 182, 80, 80, 115, 115, 80, 80, 560, 560, 525, 525,

560, 560, 457, 457, 590};

int [] ilabintvy = {260, 260, 320, 320 , 390, 390, 400, 400, 465, 465, 400, 400,

390, 390, 320, 320 , 260, 260};

// parte superior interna do labirinto.

int [] slabintvx = {50, 182, 182, 80, 80, 315, 315, 325, 325, 560, 560, 457,

457, 590};

int [] slabintvy = {230, 230, 170, 170, 35, 35, 90, 90, 35, 35, 170, 170, 230,

230};

// parte superior externa do labirinto.

int [] slabvx = {50, 177, 177, 75, 75, 565, 565, 462, 462, 590};

int [] slabvy = {225, 225, 175, 175, 30, 30, 175, 175, 225, 225};

Labirinto()

{

super();

setSize(height, width);

setBackground(Color.black);

x=48;

y=64;

setVisible(true);

setResizable(false);

repaint();

}

public void paint(Graphics g)

{

g.setColor(Color.black);

g.fillRect(0, 0, 640, 480);

g.setColor(Color.blue);

//parte superior do labirinto.

g.drawPolyline(slabvx, slabvy, 10);

g.drawPolyline(slabintvx, slabintvy, 14);

//parte inferior do labirinto.

g.drawPolyline(ilabvx, ilabvy, 10);

g.drawPolyline(ilabintvx, ilabintvy, 18);

//peças superiores do labirinto.



g.drawPolyline(sepx1, sepy1, 5);




//peça do meio.


g.drawPolyline(smpx, smpy, 9);


g.drawPolyline(sdpx1, sdpy1, 5);




//peça central.


g.drawPolyline(cpx, cpy, 14);

//peças inferiores do labirinto.



g.drawPolyline(iepx1, iepy1, 5);




//peças do meio.

g.drawPolyline(impx1, impy1, 9);

g.drawPolyline(impx2, impy2, 9);


g.drawPolyline(idpx1, idpy1, 5);




}

public static void main(String args[])

{

Labirinto l=new Labirinto();

}

}

Documents

Algoritmo Labirinto Pacman