Nome: Marcus Vincius Pereira Rocha

Mdulo: Habilidades

Curso: Jogos Digitais

Ano: 2015
Introduo

Irei utilizar um cdigo, que eu mesmo criei em Java na faculdade, para

criao de um labirinto do Pac-Man. A construo fcil quando se entende
como funcionam os modos de programao grfica.
um modelo bem bsico de programao de linhas, utilizando linhas de
comando para se construir pontos e liga-los entre si.
Algoritmo do labirinto
Para comear os eixos invertidos, ou seja, de cabea para baixo. Como
mostrado na imagem:

Mas o ponto no esse e sim como foi construdo o labirinto. Para se

construir o labirinto, foi necessrio 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 peas, foram necessrios criar vetores, com
valores pr-definidos. Por qual motivo? Pois esses so os valores responsveis
por demonstrar qual o pixel da tela, que o respectivo ponto est. Mas para se
ligar os pontos, deve ser criado para cada pea 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 necessrio 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
geomtrica ou o desenho criado seja mostrado.

Como foi mostrando no cdigo, foi coloca o eixo X e o Y de cada pea

com um nmero em seguida linha(ilabvx, ilabvy, 10);. Esse nmero
responsvel por mostrar ao comando, quando pontos de ligao a pea vai ter,
para assim fazer a ligao entre eles e as linhas aparecerem.
variaveis
int x, y; <- Variveis responsveis por guardar os valores de dimenso da
tela
int largura = 480; <- Varivel responsvel por guardar a largura
int altura = 640; <- Varivel responsvel por guardar a altura
//peas superiores do labirinto.
//peas do lado esquerdo.
int [] sepx1 = {110, 182, 182, 110, 110}; <- Valores dos pontos X da pea
int [] sepy1 = {65, 65, 90, 90, 65}; <- Valores dos pontos Y da pea
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};
//pea do meio.
int [] smpx = {263, 377, 377, 325, 325, 315, 315, 263, 263};
int [] smpy = {125, 125, 140, 140, 181, 181, 140, 140, 125};
//peas 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};
//pea 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};
//peas inferiores do labirinto.
//peas 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};
//peas 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};
//peas 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 responsvel por
criar a tela
definir.cordefundo(Cor.preta); <- Comando responsvel por definir a cor
de fundo da tela
//parte superior do labirinto.
definir.cor(Cor.azul); <- Comando responsvel por definir a cor das linhas
linha(slabvx, slabvy, 10); <- Comando responsvel por mostrar as linhas e
definir o nmero de pontos que o desenho ir ter
linha(slabintvx, slabintvy, 14);

//parte inferior do labirinto.

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

Concluso
Esse um modo bsico 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 vocs o que eu pretendia.
No 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 mo, 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:
O labirinto ir ficar assim:

prpria

Cdigo original (JAVA)

Como prometido, vou anexar ao pdf, o cdigo original de programao
do labirinto. N cdigo contido alguns comandos, que so necessrios para
que o desenho seja mostrado. Mas o algoritmo acima segue a lgica correta do
cdigo original.
O cdigo todo baseado em Orientao a objetos, por exemplo o
g.drawPolyline, a letra g um objetivo utilizado para programao grfica em
Java.
Caso no 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;
//peas superiores do labirinto.
//peas 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};
//pea do meio.
int [] smpx = {263, 377, 377, 325, 325, 315, 315, 263, 263};
int [] smpy = {125, 125, 140, 140, 181, 181, 140, 140, 125};
//peas 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};
//pea 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};
//peas inferiores do labirinto.
//peas 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};
//peas 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};
//peas 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);
//peas superiores do labirinto.

//peas do lado esquerdo.

g.setColor(Color.blue);
g.drawPolyline(sepx1, sepy1, 5);
g.drawPolyline(sepx2, sepy2, 5);
g.drawPolyline(sepx3, sepy3, 5);
g.drawPolyline(sepx4, sepy4, 9);

//pea do meio.
g.setColor(Color.blue);
g.drawPolyline(smpx, smpy, 9);
//peas do lado direito.
g.drawPolyline(sdpx1, sdpy1, 5);
g.drawPolyline(sdpx2, sdpy2, 5);
g.drawPolyline(sdpx3, sdpy3, 5);
g.drawPolyline(sdpx4, sdpy4, 9);
//pea central.
g.setColor(Color.blue);
g.drawPolyline(cpx, cpy, 14);
//peas inferiores do labirinto.
//peas do lado esquerdo.
g.setColor(Color.blue);
g.drawPolyline(iepx1, iepy1, 5);
g.drawPolyline(iepx2, iepy2, 7);
g.drawPolyline(iepx3, iepy3, 9);
g.drawPolyline(iepx4, iepy4, 5);
//peas do meio.
g.drawPolyline(impx1, impy1, 9);
g.drawPolyline(impx2, impy2, 9);
//peas do lado direito.
g.drawPolyline(idpx1, idpy1, 5);
g.drawPolyline(idpx2, idpy2, 5);
g.drawPolyline(idpx3, idpy3, 9);
g.drawPolyline(idpx4, idpy4, 7);
}
public static void main(String args[])
{
Labirinto l=new Labirinto();

}
}