Documentos de Académico
Documentos de Profesional
Documentos de Cultura
INTRODUÇÃO À PROGRAMAÇÃO
COM APLICAÇÕES GRÁFICAS
Introdução........................................................................................................................................ 4
Capítulo 1 ........................................................................................................................................ 5
1. Programação ............................................................................................................................... 5
1.1 Conceitos básicos de programação .......................................................................................... 5
1.2 Tipos de dados .......................................................................................................................... 5
1.3 Operações aritméticas............................................................................................................... 6
1.4 Operadores relacionais.............................................................................................................. 6
1.5 Operadores de incremento e decremento................................................................................. 6
1.6 Funções básicas........................................................................................................................ 7
1.6.1 Função clrscr( )....................................................................................................................... 7
1.6.2 Função printf( ) ....................................................................................................................... 7
1.6.3 Função getch( )....................................................................................................................... 7
1.6.4 Função scanf( )....................................................................................................................... 8
1.6.5 Função for( ) ........................................................................................................................... 9
1.6.6 Função while( ) ....................................................................................................................... 10
1.6.7 Função do while( ) .................................................................................................................. 11
1.6.8 Função if( )....else ................................................................................................................... 12
1.6.9 Função delay( ) ....................................................................................................................... 12
1.6.10 Função sqrt( ) ....................................................................................................................... 13
1.6.11 Função sin().......................................................................................................................... 13
1.6.12 Função cos()......................................................................................................................... 13
1.6.13 Função tan() ......................................................................................................................... 13
1.6.14 Função atan() ....................................................................................................................... 13
1.7 Construção de funções do usuário............................................................................................ 13
1.8 Interface gráfica......................................................................................................................... 14
1.9 Funções gráficas ....................................................................................................................... 14
1.10 Programa de desenho de uma reta e um círculo .................................................................... 17
Capítulo 2 ........................................................................................................................................ 20
2. Aplicações ................................................................................................................................... 20
2.1Programa Parábola..................................................................................................................... 20
2.1.1 O que é uma parábola ............................................................................................................ 20
2.1.2 Elementos da parábola........................................................................................................... 20
2.1.3 Processo de traçado............................................................................................................... 21
2.1.4 Desenvolvimento do algoritimo............................................................................................... 21
2.1.5 Fluxograma............................................................................................................................. 22
2.1.6 O programa básico ................................................................................................................. 22
2.1.7 O programa parábola – versão 1............................................................................................ 23
2.1.8 O programa parábola – versão 2............................................................................................ 24
2.1.9 O programa parábola – versão 3............................................................................................ 25
2.1.10 Comentários ......................................................................................................................... 26
2.2 Programa Elipse ........................................................................................................................ 27
2.2.1 O que é uma elipse................................................................................................................. 27
2.2.2 Elementos de uma elipse ....................................................................................................... 28
2.2.3 Processo dos círculos concêntricos ....................................................................................... 28
2.2.4 Desenvolvimento do algoritimo............................................................................................... 28
2.2.5 Fluxograma do programa ....................................................................................................... 29
2.2.6 Estrutura básica do programa ................................................................................................ 30
2.2.7 Desenvolvimento do programa............................................................................................... 31
2.2.8 Comentários ........................................................................................................................... 34
2.3 Programa espiral de Arquimedes .............................................................................................. 35
2.3.1 O que é uma espiral de Arquimedes ...................................................................................... 35
2.3.2 Elementos de uma espiral de Arquimedes............................................................................. 35
2.3.3 Processo de traçado............................................................................................................... 36
2.3.4 Desenvolvimento do algoritimo............................................................................................... 36
2.3.5 O programa ............................................................................................................................ 37
2.3.6 Comentários ........................................................................................................................... 38
Capítulo 3 ........................................................................................................................................ 73
3. Desafios....................................................................................................................................... 73
3.1 Problemas a serem resolvidos .................................................................................................. 73
BIBLIOGRAFIA................................................................................................................................ 74
INTRODUÇÃO
CAPÍTULO 1
1 - PROGRAMAÇÃO
Nos dias atuais, o uso da informática está em todas as atividades humanas, desde atividades
industriais, comerciais, educacionais e até mesmo dentro de nossas casas, onde vários tipos de
equipamentos já a utilizam sem que sejam percebidos.
Deste modo, é interessante um conhecimento básico de programação para que o indvíduo possa
entender este assunto como algo possível de ser utilizado, e não algo do outro mundo, que somente
está acessível aos indivíduos super dotados.
Os itens de programação aqui apresentados são aqueles necessários ao entendimento dos
programas apresentados.
Deve-se lembrar que a matemática é uma parte muito importante para o entendimento e
execução de um programa de computador.
Na linguagem C, há vários tipos de dados como int, float e char, etc. Os tipos de dados irão
definir os tipos de variáveis que serão utilizadas no programa, o que é feito pelo usuário. A definição
das variáveis é função específica dos dados utilizados para resolver o problema.
int
Define uma variável que armazena um número inteiro. Um número inteiro é definido como:
int num; num é uma variável inteira.
int controle = 2; controle é uma variável inteira e armazena o valor 2.
float
Define uma variável que armazena um número real. Um número real é definido como:
float valores; valores é uma variável real.
float numero = 3.23; numero é uma variável real e armazena o valor 3,23.
Obs.: Ao escrever um programa com número real, a parte inteira é separa da parte decimal por
um ponto (.), e não uma vírgula (,).
char
Define uma variável que armazena um caracter, que pode ser uma letra um número, ou uma cadeia
de caracteres, que é uma palavra. Um char é assim definido:
char nome; nome é uma variável que armazena um caracter.
char letra = ‘d’; letra é uma variável que armazena um caracter e que é o d.
char numero = ‘5’; numero é uma variável que armazena um caracter e que é o 5. Não é
interpretado como o número 5, não podendo ser usado para cálculos.
char nomes[5] = “joao”; nomes é uma variável que armazena um vetor de caracteres (cinco
posições), mas no máximo quatro caracteres podem ser colocados.
( = ) Atribuição
Este sinal corresponde a atribuir um valor da variável do lado direito do sinal para a variável do
lado esquerdo. Onde:
a = b; a variável a assume o valor da variável b, e a variável b ainda permanece com o referido
valor.
( + ) Adição
c = a + b; Executa a adição de duas variáveis, a e b, que são armazenadas em c.
d = a + b + c; Executa a adição de três variáveis, a, b e c, que são armazenadas em d.
( - ) Subtração
c = a - b; Executa a subtração de uma variável da outra (a e b), onde o resultado é armazenado em
c.
c = a – b - d; Subtrair a variável b da variável a, e deste resultado subtrair a variável d.
( * ) Multiplicação
c = a * b; Efetua a multiplicação das duas variáveis a e b, sendo o resultado armazenado em c.
c = a * b * d; Efetua a multiplicação das três variáveis e o resultado é armazenado na variável c.
( / ) Divisão
c = a / b; Efetua a divisão da variável a pela variável b, sendo o resultado armazenado na variável c.
No caso da variável que recebe o resultado de uma operação aritmética, esta deve ser do tipo que
resulta o dado. Uma variável inteira (int) não pode receber um resultado que é uma variável de ponto
flutuante (float), pois a parte fracionária será suprimida.
São funções que executam um conjunto de instruções para o programador. Elas fazem parte da
linguagem de programação utilizada. Na realidade, em diferentes linguagens de programação, os
nomes das funções básicas são semelhantes. Isto permite extender o aprendizado de uma linguagem
para outra.
Especificação da variável:
%d identifica uma variável inteira
%f identifica uma variável real
%c identifica uma variável caracter
%s identifica uma uma variável que tem uma seqüência de caracteres
Caracter de controle:
\n nova linha – inicia o texto a ser escrito na linha seguinte
formato:
printf( < formato> , <var1>, <var2>,...);
<formato> é o campo que especifica a impressão através de uma seqüência de caracteres que inicia
e termina com aspas.
<var1>,<var2>,... são expressões que serão impressas de acordo com a especificação feita em
<formato>.
printf ( “\nescreve o numero real: %f ”,numero ); Antes de imprimir na tela, deve ir para uma nova
linha \n, imprime o texto escreve o numero real:, onde %f diz que a variável numero é um número
real (float), e imprime o que estiver armazenado na variável numero.
printf ( “ escreve caracteres: %s ”,nome ); onde %s diz que a variável nome representa um
caracter (char) ou uma cadeia de caracteres ( char [ ] ). Escreve sem mudar de linha o que estu\iver
armazenado na variável nome.
//
A colocação de duas barras em seqüência, é interpretado que o que está escrito após as duas barras,
e na mesma linha, não seja interpretado pelo programa. Utiliza-se para a colocação de comentários
no programa, ou o cancelamento de partes do programa que não serão usados mas é interessante
que estejam no arquivo do programa.
Digite o programa a seguir e rode no compilador para ver o resultado (ver anexo 3).
Programa exemplo 1
resultado:
escreve o numero real: 3.8
escreve o numero inteiro: 5
escreve o caracter: h
escreve nome completo: joao
formato:
scanf(<formato>,<end1>,<end2>,...);
int num;
printf ( “tecle um numero”);
scanf ( “%d”,&num); (informa o tipo de dado, captura o endereço da variável)
O símbolo & na frente da variável permite que o programa leia o endereço da memória onde está
armazenado o valor da variável.
Programa exemplo 2
#include <stdio.h>
#include <conio.h>
void main()
{
float numero;
int numeroInteiro;
char nome;
char nomeCompleto[10];
getch();
}
resultado:
Digite um numero real: 5.2 ( tecle o número 5.2 e tecle Enter)
Digite um numero inteiro: 3 (tecle o número 3 e tecle Enter)
Digite um caracter: a (tecle o caracter a e tecle Enter)
Digite ate 9 caracteres: abcdefghi (tecle os caracteres abcdefghi e tecle Enter)
int i;
for(i=0;i<10;i++){printf(“\nola!);}
Esta instrução diz para o comando for executar um laço com o que está dentro das chaves, iniciando
o contador i=0; até que o contador i seja menor que dez (i<10), e a cada volta no laço acrescentar o
valor um no contador i (i++). A palavra ola! será escrita dez vezes uma abaixo da outra.
O programa exemplo 3 faz com que o valor do contador i seja multiplicado por 2 a cada laço
executado eplo comando for( ).
Programa exemplo 3
#include <stdio.h>
#include <conio.h>
void main ( )
{
int i;
clrscr();
for (i=0; i<10; i++)
{
printf(“\n i*2= %d”,i*2 );
}
getch();
}
resultado:
i*2= 0
i*2= 2
i*2= 4
i*2= 6
i*2= 8
i*2= 10
i*2= 12
i*2= 14
i*2= 16
i*2= 18
j=0
while(j<10)
printf("ola!")
j++
Programa exemplo 4
#include <stdio.h>
#include <conio.h>
void main ( )
{
int j=0;
clrscr();
while( j<10)
{
printf ( “ olá! ” );
j++;
}
getch();
}
resultado:
ola! ola! ola! ola! ola! ola! ola! ola! ola! ola!
Nesta aplicação, o comando while() fica repetindo a expressão ola enquanto a variável j tem um
valor menor que dez (j<10). A cada repetição, j é incrementado de um (j++;), sendo que j inicia com
valor zero. Se a variável j fosse igual a 10 (j=10), seria impresso apenas uma vez. Como no comando
printf() não há o caracter de controle \n, o resultado é impresso lado a lado.
j=0;
do
printf("ola!");
j++;
while(j<10)
Programa exemplo 5
#include <stdio.h>
#include <conio.h>
void main ( )
{
int j=0;
clrscr();
do
{
printf(“ olá!”);
j++;
} while( j<10);
getch();
}
resultado:
ola! ola! ola! ola! ola! ola! ola! ola! ola! ola!
Nesta aplicação, o comando while() fica repetindo a expressão olá enquanto a variável j tem um
valor menor que dez ( j<10 ). A cada repetição, j é incrementado de um, sendo que j inicia com valor
zero. Se a variável j fosse igual a 10 (j=10), não seria impresso nada.
else{...} if
{...}
...
Programa exemplo:
#include <stdio.h>
#include <conio.h>
void main ( )
{
int x =10, y = 5;
clrscr();
if ( x > y) {printf ( “\n O valor de X é maior que o valor de Y.”);}
else { printf ( “\n O valor de Y é menor que o valor de X.”);}
x=5; y=10;
if ( x > y) {printf ( “\n Agora o valor de X é maior que o valor de Y.”);}
else { printf ( “\n Agora o valor de Y é menor que o valor de X.”);}
getch();
}
resultado:
O valor de X é maior que o valor de Y.
Agora o valor de Y é menor que o valor de X.
Esta função recebe a variável x, e multiplica por ele mesmo, resultando no quadrado do respectivo
número, e devolvendo o resultado. A palavra float, antes do nome da função quad, indica que a
função devolve um valor que é um número real. A expressão float x, indica que a função deve
receber um valor que é um número real, que passa para dentro da função através da variável x. A
expressão return, devolve o resultado do que estiver dentro do parentesis.
Logo, pode-se escrever:
float resultado;
resultado = quad (5 ); Onde o resultado é o valor de 25.
Por exemplo, deve ser colocado um include especial no programa: #include <graphics.h>, que
permite que as instruções gráficas possam ser interpretadas, transformando a tela para formato
gráfico. A tela no formato gráfico é definida como tendo 640x480 pixels, que são pontos na tela que
podem ser acesos.
O sistema de coordenadas da tela gráfica é igual ao sistema de coordenadas cartesiano,
possuindo os eixos X e Y. Porém, possui algumas alterações. Por exemplo, a origem está
posicionada no canto esquerdo superior, sendo o eixo X positivo da esquerda para a direita. Já o eixo
Y positivo, de cima para baixo (figura 1.1).
io
ra
Y (x3,y3)
y1
(x2,y2)
480 pixels
(x1,y1)
reta
x1
640 pixels
Figura 1.1 - Representação da tela gráfica.
(x2,y2)
(x1,y1)
io
ra
(x,y)
FUNÇÂO setbkcolor(int)
Função que seleciona a cor de fundo da tela. O número inteiro pode ser entre 0 e 15, ou o nome da
cor.
# Nome Descrição
FUNÇÃO closegraph( )
Função responsável pela finalização do ambiente gráfico e retorno à tela normal, tela de texto.
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <dos.h>
A função void main(), corresponde ao programa propriamente dito. As instruções escritas entre
as duas chaves definirão o programa.
void main()
{//1
............
............
}//1
A seguir há um espaço onde são definidas as variáveis utilizadas no programa para a identificação
do ambiente gráfico. As variáveis são definidas como números inteiros, int.
No espaço a seguir, estão definidas as variáveis utilizadas no programa, isto por uma questão de
organização, pois na linguagem C, as variáveis podem ser criadas em qualquer parte do programa.
getch();
exit(1); // retorna codigo de erro
}
Nas últimas linhas, o programa espera que seja tocada qualquer tecla, finalizando o ambiente gráfico
e o programa.
getch();
closegraph();
return 0;
}//1
//================ final do arquivo ====================
Comentários:
O programa desenha uma reta e um cículo, apresentando o formato de como deve ser escrito um
programa gráfico.
Na primeira linha do programa está escrito: //Nome do arquivo DESENHA.C, que é
interpretado como um comentário pelo compilador devido as duas barras inclinadas (//), e apenas
indica o nome do programa.
Nas linhas a seguir, estão os #include, que especificam os arquivos do compilador C que devem
ser agregados ao programa para que o compilador possa interpretar as instruções escritas. As linhas
escritas em negrito correspondem ao programa propriamente dito.
Resultado
Após rodar o programa, aparecerá como resultado o desenho de uma reta em amarelo e de um
círculo em vermelho. Experimente alterar o valor das coordenadas nas funções line(), circle() e
setcolor(); comparando os resultados obtidos.
CAPÍTULO 2
2. APLICAÇÕES
Neste capítulo são implementadas as aplicações gráficas que envolvem a definição do problema,
busca da solução, e a solução final que é o programa.
DIRETRIZ
P
(a) (b)
Figura 2.1 - Cone truncado por um plano paralelo a uma geratriz; desenho da parábola.
Obs.: Numa parábola deve ser observada a seguinte condição de distância entre o ponto P da curva
com o foco F e a diretriz. FP = Pdiretriz (figura 2.2).
P raio vetor
diretriz
foco
eixo
F
vértice
parâmetro
Figura 2.2 - Elementos de uma parábola.
2.1.3 - Processo de traçado
A parábola inicia-se com o traçado do eixo e da diretriz, que são perpendiculares entre si (ângulo
de 90°). Após, deve-se marcar o vértice (V) da parábola e o foco (F). Sendo que o vértice está
localizado no ponto médio da distância entre o foco e a diretriz (figura 2.3 (a)).
Como a distância de um ponto (P) da curva ao foco deve ser igual à distância do mesmo ponto
(P) à diretriz, deve-se traçar retas paralelas a diretiz a partir do vértice da parábola. A distância entre
as paralelas é arbitrária e, de preferência, que sejam iguais para facilitar o traçado.
O próximo passo consiste em pegar a distância (d) (figura 2.3(a)) entre a diretriz e a primeira
paralela, com o compasso, e colocar a ponta seca do compasso no foco e traçar um arco que corte a
primeira paralela.
A seguir pegar a distância da diretriz (d1) (figura 2.3(b)) até a segunda paralela. Colocar a ponta
seca do compasso no foco e traçar arco para interseptar a segunda paralela, acima e abaixo do eixo.
Novamente pegar a distância da diretriz (d2) (figura 2.3(c)) até a terceira paralela. Colocar a ponta
seca do compasso no foco e traçar arco para interseptar a terceira paralela, acima e abaixo do eixo.
Repetindo este procedimento, obtém-se os pontos por onde passa a parábola. A curva é então
traçada a mão (figura 2.3(d)).
d2 d2
d1 d1 d1
d d d d
V F V F V F V F
d d d d
d1 d1 d1
d2 d2
d d d
d d1 d1 d1
d2 d2
(a) (b) (c) (d)
Figura 2.3 - Processo de traçado da parábola
Considerando a curva traçada, e analizando um ponto P(x,y) qualquer da curva (figura 2.4), pode-
se verificar que a distância X da diretriz até ponto P(x,y), será exatamente a distância do foco F até o
ponto P(x,y), onde (X = R).
A coordenada Y deste ponto é resultante da dimensão do cateto maior do triângulo, e Dx, o cateto
menor, será função da diferença entre a coordenada X e a distância do foco DF (figura 2.4).
DF
Assim, a distância do vértice até a diretriz é dada por: DV =
2
Dx =| DF − x|, sendo o resultado em módulo. logo, Y = R − Dx
2 2
Considerando (xo,yo) como pontos de referência do sistema, tem-se as coordendas dos seguintes
pontos:
Assim:
P(x) = xo + DV + Dx P(y) = yo + Y
sendo DeltaX um incremento para descrever a curva.
P(x,y)
X Y
R
V F Dx
xo,yo
DF
início
Parâmetros da parábola:
Tocou S
alguma fim
tecla?
incrementa X
N
controle=1 controle>0
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
//========================================================
void main()//define a funcao principal
{
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
getch();
exit(1);// retorna codigo de erro
}
//============= inicia o programa propriamente dito ===========
//PROGRAMA PARABOLA.C
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
//=============================================================
void main() //define a funcao principal
{
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
Comentários
Após compilar e rodar o programa (ctrl-F9), basta tocar uma tecla para que o mesmo volte para o
editor. Neste programa somente apareceu a estrutura para a construção da parábola, o eixo e a
diretriz.
//PROGRAMA PARABOLA.C
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
float quad(float x) // funcao para elevar ao quadrado um numero armazenado na variável X
{
return (x*x);
}
//=============================================================
void main() //define a funcao principal
{
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
while(!kbhit( ))
{
x=x+1;
Dx=abs(focoX-x); //calcula o novo valor de Dx
y=yo-sqrt(quad(x-xo)-quad(Dx)); //calcula a coordenada Y acima do eixo
}
//===================== final do programa propriamente dito ============
getch();
closegraph();
}
//==================== final do arquivo ==================================
Comentários
Nesta outra versão, foi introduzido o comando while( !kbhit( ) ), que faz com que o programa
fique num laço até que seja tocada uma tecla para então sair.
Os novos includes:
#include <math.h> é devido ao uso da função matemática sqrt().
#include <dos.h> é devido ao uso da função matemática delay().
//PROGRAMA PARABOLA.C
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
float quad(float x) // funcao para elevar ao quadrado um numero aramzenado na variável X
{
return (x*x);
}
//=============================================================
void main() //define a funcao principal
{
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
while(!kbhit( ))
{
x=x+1;
Dx=abs(focoX-x); //calcula Dx
y=yo-sqrt(quad(x-xo)-quad(Dx)); //calcula a coordenada Y acima do eixo
xold=x;
yold=y;
2.1.10 - Comentários
Após rodar esta versão, experimente alterar o valor das variáveis para os novos valores escritos a
seguir:
float xo=80; //coordenada X inicial
float yo=240; //coordenada Y inicial
float distanciaFocal=70;
Como resultado, surgirá uma parábola diferente. As variáveis xo e yo, permitem mudar a posição
que a parábola será desenhada. A variável distanciaFocal, permite alterar a forma da parábola.
ELIPSE
Figura 2.7 - Obtenção da elipse por secção de um sólido (a) cilindro - (b) cone.
C
P
A B
F O
F'
D
Figura 2.8 - Elementos da elipse.
C C C
A B A B A B
D D D
Assim, pode-se calcular as coordenadas do ponto P(x,y) (figura 2.10) através das seguintes
relações:
x = Raio . cos α (1)
y = raio . sen α (2)
P(x)=xo+x
P(y)=yo+y
C P(x,y)
Raio
io
ra
y
α
A
B
(xo,yo) x
Figura 2.10 - Determinação das coordenadas de um ponto da curva.
O traçado dos raios vetores, que são na realidade os elementos do traçado pelo processo do fio,
são obtidos unindo cada foco ao ponto da curva em análise. Para isso, é necessário saber a posição
de cada foco que é determinado da seguinte forma (figura 2.11):
FO = AO 2 − CO 2 (3)
Onde FO é denominada de semi-distância focal (figura 2.11).
C
=F
AO
A B
F O
F'
D
Figura 2.11 - Determinação da posição dos focos.
início
Parâmetros da elipse:
Coordenadas do centro (x0,y0)
Diâmetro Maior
Diâmetro Menor
Focos - F1 e F2
Ponto da curva P(x,y)
Tocou S
alguma fim
tecla?
Desenha os diâmetros e os
focos
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//========================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
Versão 1:
Na Versão 1 é feito o desenho do diâmetro maior e do menor da elipse, tomando como referência
o centro da elipse (cruzamento dos diametros (xo,yo))
Deste modo, para dertminar as duas retas a serem desenhadas a partir do centro tem-se (figura
2.13):
xo,yo-DiametroMenor/2
C
xo+DiametroMaior/2,yo
A B
xo,yo
xo-DiametroMaior/2,yo
D
xo,yo+DiametroMenor/2
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
void main() //define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
//=================== final das variaveis do programa===========
int xo=320,yo=240; //coordenadas do centro da elipse
int DiametroMaior=400,DiametroMenor=200; //diametros da elipse
getch();
exit(1);// retorna codigo de erro
}
//===================== inicia o programa propriamente dito ===========
Versão 2:
Na versão é determinada a posição dos dois focos F1 F2, a partir do centro da elipse. Isto pode
ser visto na figura 2.11 e na equação 3. Onde F e F’, podem ser agora denominadas de F1 e F2.
F1 = xo - FO (3)
F2 = xo + FO (4)
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
float dobro(float x)
{
return( x*x);
}
//=============================================================
Versão 3:
Nesta versão, é executado o traçado da elipse, sendo esta executada através de pequenas retas.
A metodologia utilizada para determinar as coordenadas da curva, está explicada no desenvolvimento
do algoritmo, nas equações 1 e 2.
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
void main() //define a funcao principal
{//1
}
//===================== inicia o programa propriamente dito ===========
setlinestyle(SOLID_LINE,SOLID_FILL,THICK_WIDTH);
while(!kbhit())
{
setcolor(WHITE);
line(xo-DiametroMaior/2,yo,xo+DiametroMaior/2,yo); //tracado do diametro maior
line(xo,yo-DiametroMenor/2,xo,yo+DiametroMenor/2); //tracado do dismetro menor
alfa=alfa-Dalfa;
x=xo+(DiametroMaior/2)*cos(alfa); // calculas as coordenadas X
y=yo+(DiametroMenor/2)*sin(alfa); // calculas as coordenadas Y
setcolor(YELLOW);
line(xOld,yOld,x,y); // Desenha a elipse
Basta rodar o programa e ver a formação de uma elipse pelo processo dos círculos concêntricos
(figura 2.14).
2.2.8 - Comentários
Após rodar esta versão, experimente alterar o valor das variáveis para os novos valores escritos a
seguir:
float DiametroMaior=200,DiametroMenor=400;
Como resultado, surgirá uma elipse em posiçao diferente. As variáveis xo e yo, permitem mutar a
posição que a elipse será desenhada.
Experimente alterar DiametroMaior=300 e DiametroMenor=300.
reta em rotação
centro
espira
passo
raio
Variação do raio: ∆raio = raio = raio + ∆raio
numeroPartes
360°
Variação do ângulo: ∆α = α = α + ∆α
numeroPartes
Posição do ponto P a partir do centro da espiral: x = raio.cosα y = raio.sen α
(coordX,coordY)
2.3.5 - O programa
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
setlinestyle(SOLID_LINE,SOLID_FILL,THICK_WIDTH);
setcolor(YELLOW); // especifica a cor amarela para a curva
while(!kbhit())
{
raio=raio+Dpasso; //incrementa o raio
alfa=alfa+Dalfa; //incrementa o angulo alfa
closegraph();
}//1
//================= final do arquivo ==============================
2.3.6 - Comentários
O desenho obtido da espiral de Arquimedes está na figura 2.19.
Após rodar o programa, experimente alterar o valor de algumas variáveis iniciais como:
Passo=60;
divisao=4;
R1
C1 C2 R2
Inicia-se com o traçado a reta que passa pelos pontos P1 e P2 (figura 2.21), os quais determinam
o centro da espiral (figura 2.21(a)). O traçado da espiral é feito considerando que é enrolado um fio
flexível em torno dos pontos P1 e P2, feito o enrolamento no sentido horário, sendo que a ponta do fio
coincide com o ponto P2.
O traçado da espiral corresponde ao desenrolamento do fio no sentido anti-horário (figura 2.21(b)),
o que produz o arco descrito pelo raio R1. Que inicia no ponto P2, centro no pomnto P1, e termina no
prolongamento da reta que passa pelos pontos P1 e P2.
Como o fio vai desenrolando, o centro de traçado do arco R2 (figura 2.21( c)) passa a ser o ponto
P2. O arco é traçado até atingir o prolongamento da reta que passa pelos pontos P1 e P2. No
momento em que o arco atinge esta reta, o centro do arco passa novamente para o ponto P1.
O arco de Raio R3 (figura 2.21(d)), possui agora o centro em P1, e é traçado de modo semelhante
ao arco de raio R1. Se este processo for repedido, obtém-se o traçado de uma falsa espiral de dois
centros.
R3
R1
R1
C1 C2 C1 C2 C1 C2 C1 C2 R2
R2
R1 C1
θ
C1 C2 C2
θ
R2
P2(x,y)
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
while(!kbhit())
{
if(controlaTeta>M_PI)
{
controlaTeta=0;
Raio=Raio+distancia;
if(controlaCentro==1){Cx=C2x;controlaCentro=-1;}
else{Cx=C1x;controlaCentro=1;}
}
circle(C1x,C1y,2);
circle(C2x,C2y,2);
Px=Cx+Raio*cos(teta);
Py=Cy+Raio*sin(teta);
teta=teta+Dteta;
setcolor(YELLOW);
line(POx,POy,Px,Py);
setcolor(WHITE);
POx=Px;
POy=Py;
controlaTeta=controlaTeta+Dteta;
delay(120);
}
2.4.6 - Comentários
Após digitar o programa, execute para ver os resultados. Pode-se experimentar alterar os valores
das variáveis C1x, C2y e distancia. Execute o programa e observe os resultados (figura 2.23).
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
while(!kbhit())
{
if(controle==1)
{
setcolor(BLACK); //troca a cor de desemho
line(Cx,Cy,POx,POy); //desenha a linha agora com a cor de fundo da tela
setcolor(WHITE); //troca a cor de desenho
}
controle=1;
if(controlaTeta>M_PI)
{
controlaTeta=0;
Raio=Raio+distancia;
if(controlaCentro==1){Cx=C2x;controlaCentro=-1;}
else{Cx=C1x;controlaCentro=1;}
}
circle(C1x,C1y,2);
circle(C2x,C2y,2);
Px=Cx+Raio*cos(teta);
Py=Cy+Raio*sin(teta);
teta=teta+Dteta;
setcolor(YELLOW);
line(POx,POy,Px,Py);
setcolor(RED);
line(Cx,Cy,Px,Py);
setcolor(WHITE);
POx=Px;
POy=Py;
controlaTeta=controlaTeta+Dteta;
delay(120);
}
2.4.9 - Comentários
Nesta versão final, o programa apresenta o desenho do traçado da falsa espiral de dois centros, e
apresenta o raio vetor se movimentando, como se fosse um fio enrolado entre o centro da falsa
espiral, como descrito no traçado.
Experimente cancelar o seguinte trecho:
/*if(controle==1)
{
setcolor(BLACK);//troca a cor de desemho
line(Cx,Cy,POx,POy);//desenha a linha agora com a cor de fundo da tela
setcolor(WHITE);//troca a cor de desenho
}*/
Salve o programa e rode para observar o que acontece.
EVOLVENTE
CÍRCULO DE BASE
P(x,y)
RETA
EVOLVENTE
CÍRCULO DE BASE
P(x,y)
FIO ESTICADO
A A A
O algoritmo deve determinar as coordendas do ponto P(x,y) para que possa ser traçada a
evolvente do círculo (figura 2.27).
comprimentoArco
β = α −θ onde θ = arctg
Raio
círculo de base
raioVetor
β
α θ
P(x,y)
Raio
evolvente
comprimento
P1(x1,y1)
do arco
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
double quad(double x) //funcao do usuário
{
return (x*x);
}
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
initgraph(&gdriver,&gmode,"c:\\bc45\\bgi");
errorcode=graphresult();
if(errorcode!=grOk)
{
printf("Erro do adaptador grafico\n");
printf("Falta o arquivo EGAVGA.BGI\n");
printf("Pressione qualquer tecla para retornar");
getch();
exit(1);// retorna codigo de erro
}
//===================== inicia o programa propriamente dito ===========
Dalfa=2*M_PI/48;
alfa=Dalfa;
while(!kbhit())
{
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
double quad(double x)
{
return (x*x);
}
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
while(!kbhit())
{
if(controle==1)
{
setcolor(BLACK);
line(xOld,yOld,x1,y1);
setcolor(WHITE);
}
setcolor(RED);
line(x,y,x1,y1);
setcolor(YELLOW);
line(xOld,yOld,x,y);
2.5.7 - Comentários
Realize alteração no valor das variáveis para verificar o tipo de resultado nos desenhos.
circulo gerador
D
reta diretora
π.D
Figura 2.29 – Ciclóide regular.
2.6.3 – Processo de traçado
O traçado é iniciado com o desenho de um círculo de diâmetro D (figura 2.30). De de uma reta com o
comprimento da circunferência (πD), tangente a este círculo. Após deve-se dividir o c´rculo em partes
iguais, neste caso em 12 partes.
A partir de cada divisão sobre a circunferência, traçar retas horizontais e paralelas a reta que
possui o comprimento.
π.D π.D
A reta que passa pelo centro do circuloo deve ser dividida em 12 partes iguais. Pegando o
compasso com o raio do círculo diretor, deve-se colocá-lo em cada marcação e traçar um arco sobre
uma linha horizontal, simulando o deslocamento do círculo.
A união destes pontos resulta numa ciclóide regular.
π.D π.D
(x,y)
(Cx,Cy)
α
(x1,y1)
Figura 2.32 – Coordenadas do ponto da ciclóide regular.
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
//=================== final das variaveis do programa===========
float x1=50,y1=240;
float x=x1,y=y1;
int Raio=25;
float Dx;
float xOld=x;
int controle=0;
//=================== inicializa ambiente grafico ==============
gdriver=DETECT;
initgraph(&gdriver,&gmode,"c:\\bc45\\bgi");
errorcode=graphresult();
if(errorcode!=grOk)
{
printf("Erro do adaptador grafico\n");
printf("Falta o arquivo EGAVGA.BGI\n");
printf("Pressione qualquer tecla para retornar");
getch();
exit(1);// retorna codigo de erro
}
//===================== inicia o programa propriamente dito ===========
Dx=2*M_PI*Raio/24;
y=y1-Raio;
while(!kbhit())
{
if(controle==1)
{
setcolor(BLACK);
circle(xOld,y1-Raio,Raio);
setcolor(WHITE);
}
line(x1,y1,x1+500,y1);
circle(x,y1-Raio,Raio);
xOld=x;
x=x+Dx;
controle=1;
delay(50);
}
//===================== final do programa propriamente dito ============
getch();
closegraph();
}//1
//================== final do arquivo ==============================
//=============================================================
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
while(!kbhit())
{
if(controle==1)
{
setcolor(BLACK);
circle(xOld,y,Raio);
circle(cxOld,cyOld,2);
setcolor(WHITE);
}
line(x1,y1,x1+500,y1);
circle(x,y,Raio);
setcolor(YELLOW);
cy=y+Raio*cos(alfa);
cx=x-Raio*sin(alfa);
circle(cx,cy,2);
xOld=x;
cxOld=cx;
cyOld=cy;
x=x+Dx;
delay(50);
controle=1;
alfa=alfa+Dalfa;
}
//===================== final do programa propriamente dito ============
getch();
closegraph();
}//1
//================== final do arquivo ==============================
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
//=================== final das variaveis do programa===========
float x1=50,y1=240;
float x=x1,y=y1;
float Raio=25;
float Dx;
float xOld=x;
int controle=0;
float cx=x1,cy=y1;
float alfa,Dalfa;
float cxOld=cx,cyOld=cy;
//=================== inicializa ambiente grafico ==============
gdriver=DETECT;
initgraph(&gdriver,&gmode,"c:\\bc45\\bgi");
errorcode=graphresult();
if(errorcode!=grOk)
{
printf("Erro do adaptador grafico\n");
printf("Falta o arquivo EGAVGA.BGI\n");
printf("Pressione qualquer tecla para retornar");
getch();
exit(1);// retorna codigo de erro
}
//===================== inicia o programa propriamente dito ===========
Dx=2*M_PI*Raio/24;
Dalfa=2*M_PI/24;
alfa=0;
y=y1-Raio;
while(!kbhit())
{
if(controle==1)
{
setcolor(BLACK);
circle(xOld,y,Raio);
circle(cxOld,cyOld,2);
setcolor(WHITE);
}
line(x1,y1,x1+500,y1);
circle(x,y,Raio);
setcolor(YELLOW);
cy=y+Raio*cos(alfa);
cx=x-Raio*sin(alfa);
circle(cx,cy,2);
line(cx,cy,cxOld,cyOld);
xOld=x;
cxOld=cx;
cyOld=cy;
x=x+Dx;
controle=1;
delay(50);
alfa=alfa+Dalfa;
}
//===================== final do programa propriamente dito ============
getch();
closegraph();
}//1
//================== final do arquivo ==============================
2.7.1 - O PROBLEMA
O problema a ser resolvido consiste da construção de um jogo. Neste jogo tem-se uma bola que
se desloca com velocidade constante e que se movimenta em trajetória retilínea até atingir um
obstáculo. Um obstáculo pode ser o limite do jogo (tela do computador delimitada por um retângulo),
ou um objeto interno ao retângulo, que representa uma raquete para rebater a bola (figura 2.34).
A raquete terá movimento vertical em dois sentidos (para cima e para baixo) continuamente,
sendo que o jogador poderá alterar o sentido de deslocamento através do teclado(↑,↓). No momento
em que a raquete atingir o limite superior ou inferior, o sentido de deslocamento deverá inverter,
deslocando-se até o próximo limite, ou até que seja indicada outra ação.
Ao atingir um obstáculo, a bola deve se deslocar numa direção a 90° a partir da trajetória que
originou o choque com obstáculo (figura 2.34). Considerar que não há interferência do atrito e da
energia cinética com relação ao choque.
A resolução será feita em etapas, sendo construído o programa à medida que determinadas
situações são descritas e resolvidas, de modo a se tornar interessante, não ficando enfadonha toda a
demonstração de uma teoria.
Para definir os limites, deve-se considerar a bola nas duas posições extremas. Como a bola é
representada a partir das coordenadas do centro (x,y) e do raio, estes fatores servirão de elementos
para a análise da posição da bola durante o deslocamento.
Na figura 2.36, estão representadas as situações. O limite esquerdo, é definido como sendo a
distância da origem até a borda do retângulo, e mais o raio da do círculo. O limite direito, a dimensão
máxima da tela em X, menos a borda do retângulo e menos o raio da circunferência. Estas duas
considerações permitem definir qual a coordenada X limite que deve ser desenhado o círculo.
Estas considerações geram as seguintes condições:
A seguir é apresentado o programa básico e após a evolução dos vários passos nos programas.
Versão 1
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
Ao rodar o programa, aparecerá uma tela escura, pois não foi ainda programado nada. Toque
uma tecla para sair do programa.
2.7.5 - PROGRAMAÇÃO
Rectangle(10,10,maxX-10,maxY-10)
Onde os valores de maxX e maxY, são capturados através das funções getmaxx() e
getmaxy(), que retornam as coordenadas máxima da tela. Ao mesmo tempo são criadas duas
variáveis para armazenar estes valores, que são: maxX e maxY (figura 2.38). O programa deverá ser
complementado com as linhas escritas em negrito.
Versão 2
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
int maxX,maxY;
//=================== final das variaveis do programa===========
rectangle(10,10,maxX-10,maxY-10);
Ao rodar este programa, deverá aparecer o desenho de um retângulo na tela. A seguir toque
qualquer tecla para o programa terminar.
Versão 3
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
int maxX,maxY;
int x=100,y=100,Raio=25;
//=================== final das variaveis do programa===========
rectangle(10,10,maxX-10,maxY-10);
circle(x,y,Raio);
2.7.7 - ANIMAÇÃO
A animação pode ser obtida através do processo de desenhar e apagar o desenho, e redesenhá-
lo em outra posição. No computador, o processo de apagar corresponde a pintar o desenho da
mesma cor da tela de fundo.
Para isso são implementadas algumas seqüências a serem seguidas. Deve-se cancelar a função
getch().
A função while() permite que o programa fique executando as instruções que estão dentro do
laço, até que uma condição específica ocorra, neste caso, uma tecla seja tocada.
Versão 4
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
int maxX,maxY;
int x=100,y=100,Raio=25; //coordenadas inicias do circulo
int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo
int controle=1; //variavel de controle para apagar o circulo
int xo,yo; //coordenadas anteriores do centro do circulo
while(!kbhit()) //o programa fica dentro do laco at'e uma tecla ser tocada
{
if(controle>1)
{
setcolor(BLACK); //pinta de preto
circle(xo,yo,Raio); // desenha circulo em preto sobre o existente
setcolor(WHITE); // pinta de branco
}
rectangle(10,10,maxX-10,maxY-10);
x=x+valorX; //acrescenta valorX na coordenada X
circle(x,y,Raio);
Ao rodar o programa com a inserção das novas linhas, pode-se observar que o círculo se desloca
para a direita e some da tela, isto ocorre porque não há limites para estabelecer o fim do movimento.
O computador não reconhece o retângulo desenhado como um limite real. É necessário descrever
este limite.
Faça um teste cancelando toda a função if(), verá que serão desenhados um círculo após o outro,
pois o anterior não será apagado.
//if(controle>1) // após o primeiro desenho o programa começa apagar
//{
//setcolor(BLACK); // define a cor de desenho como preta
//circle(xo,yo,R); // desenha o círculo em preto sobre o existente
//}
Versão 5
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
int maxX,maxY;
int x=100,y=100,Raio=25; //coordenadas inicias do circulo
int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo
int controle=1; //variavel de controle para apagar o circulo
int xo,yo; //coordenadas anteriores do centro do circulo
//=================== final das variaveis do programa===========
initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi");
errorcode=graphresult();
if(errorcode!=grOk)
{
printf("Erro do adaptador grafico\n");
printf("Falta o arquivo EGAVGA.BGI\n");
printf("Pressione qualquer tecla para retornar");
getch();
exit(1);// retorna codigo de erro
}
//===================== inicia o programa propriamente dito ===========
maxX=getmaxx(); //captura coordenada maxima de X
maxY=getmaxy(); //captura coordenada maxima de Y
while(!kbhit()) //o programa fica dentro do laco at'e uma tecla ser tocada
{
if(controle>1)
{
setcolor(BLACK); //pinta de preto
circle(xo,yo,Raio); // desenha circulo em preto sobre o existente
setcolor(WHITE); // pinta de branco
}
rectangle(10,10,maxX-10,maxY-10);
if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar
circle(x,y,Raio);
Ao rodar o programa, verá que o círculo ao tocar no lado direito do retângulo, imediatamente
retornará em sentido contrário, em direção ao lado esquerdo, sendo que continuará indefinidamente,
pois não foi estabelecido o respectivo limite. O retorno é feito através do incremento valorX que é –1.
Para estabelecer o limite do lado esquerdo, deve-se observar a situação limite (figura 2.40), onde
a coordenada X do centro do círculo é definida por:
x = 10 + R (figura 2.40), onde se o valor de x for menor que esta coordenada, o círculo deve inverter o
sentido de movimento, devido ao incremento valorX que é 1.
Versão 6
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
int maxX,maxY;
int x=100,y=100,Raio=25; //coordenadas inicias do circulo
int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo
int controle=1; //variavel de controle para apagar o circulo
int xo,yo; //coordenadas anteriores do centro do circulo
rectangle(10,10,maxX-10,maxY-10);
if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar
if(x<=(10+Raio)){valorX=1;} //se atingir o lado esquerdo, deve retornar
circle(x,y,Raio);
Para obter o movimento da bola no sentido vertical, deve-se estabelecer os limites e o seu
deslocamento. Cancele as condições de deslocamento horizontal e implemente as condições
verticais.
Versão 7
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
int maxX,maxY;
int x=100,y=100,Raio=25; //coordenadas inicias do circulo
int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo
int controle=1; //variavel de controle para apagar o circulo
int xo,yo; //coordenadas anteriores do centro do circulo
while(!kbhit()) //o programa fica dentro do laco at'e uma tecla ser tocada
{
if(controle>1)
{
setcolor(BLACK); //pinta de preto
circle(xo,yo,Raio); // desenha circulo em preto sobre o existente
setcolor(WHITE); // pinta de branco
}
rectangle(10,10,maxX-10,maxY-10);
//if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar para esquerda
//if(x<=(10+Raio)){valorX=1;} //se atingir o lado esquerdo, deve retornar para direita
O resultado obtido é o deslocamento da bola somente no sentido vertical dentro dos limites do
retângulo.
Versão 8
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
int maxX,maxY;
int x=100,y=100,Raio=25; //coordenadas inicias do circulo
int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo
int controle=1; //variavel de controle para apagar o circulo
int xo,yo; //coordenadas anteriores do centro do circulo
while(!kbhit()) //o programa fica dentro do laco at'e uma tecla ser tocada
{
if(controle>1)
{
setcolor(BLACK); //pinta de preto
circle(xo,yo,Raio); // desenha circulo em preto sobre o existente
setcolor(WHITE); // pinta de branco
}
rectangle(10,10,maxX-10,maxY-10);
if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar para esquerda
if(x<=(10+Raio)){valorX=1;} //se atingir o lado esquerdo, deve retornar para direita
O resultado após rodar o programa é a obtenção do movimento da bola em um ângulo de 45°. O que
é dado pelos valores de valoX=1 e valorY=1. Se os valores das variáveis forem alterados, outras
trajetórias serão obtidas.
A raquete é representada por um retângulo. Ela terá movimento contínuo entre os lados inferior
(y=maxY-10) e superior (y=10) do retângulo, sendo que o seu sentido poderá ser alterado pelo usuário
quando desejar (figura 2.36).
Para modelar esta situação, considerar o retângulo desenhado a partir da posição x=500 e y=y1
(onde y1 corresponde a uma posição y qualquer). Sendo o comprimento de 50 pixels e a largura de 10
pixels. O retângulo que representa a raquete será então representado por (figura 2.36).
Para ter o controle do sentido de deslocamento da raquete, ou seja, para cima ou para baixo, é
necessário implementar as teclas UpKey ( ↑ ) para subir, DownKey ( ↓ ) para descer e da tecla Esc
para sair do programa. Para isso são necessárias as seguintes definições:
#define UpKey 80
#define DnKey 72
#define EscKey 27
int y1=10;
int valorY1=20;
int y1o;
unsigned char ch;
int teste=0;
if(kbhit()!=0) Esta função é ativada quando uma tecla é tocada, de preferencia se forem uma das
definidas DnKey, UpKey ou Esc.
{
ch=getch(); Esta função faz a leitura da tecla
switch(ch) Função que permite a escolha de uma das opções descritas a seguir
{
case DnKey : valorY1=2; A raquete se desloca para cima dois pixels de cada vez
break;
case UpKey : valorY1=-2; a raquete se desloca para baixo dois pixels de cada vez
break;
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#define UpKey 72
#define DnKey 80
#define EscKey 27
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
int maxX,maxY;
int x=100,y=100,Raio=25; //coordenadas inicias do circulo
int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo
int controle=1; //variavel de controle para apagar o circulo
int xo,yo; //coordenadas anteriores do centro do circulo
int y1=10; //posicao inicial da raquete
int y1o; //coordenada anterior da raquete
int valorY1=1; //incremento de movimento da raquete
unsigned char ch; //define uma variavel para receber o sinal do teclado
int teste=0; //condicao para entrar no loop
while(teste==0) //o programa fica dentro do laco at'e uma tecla ser tocada
{
if(controle>1)
{
setcolor(BLACK); //pinta de preto
circle(xo,yo,Raio); // desenha circulo em preto sobre o existente
rectangle(500,y1o,505,y1o+50); //desenha a raquete sobre a existente
setcolor(WHITE); // pinta de branco
}
rectangle(10,10,maxX-10,maxY-10);
if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar para esquerda
if(x<=(10+Raio)){valorX=1;} //se atingir o lado esquerdo, deve retornar para direita
if(kbhit())
{
ch=getch();
switch(ch)
{
case DnKey: valorY1=1;
break;
y1o=y1;
y1=y1+valorY1; //acrescenta valorY1 na coordenada Y1
x=x+valorX; //acrescenta valorX na coordenada X
y=y+valorY; //acrescenta valorY na coordenada Y
circle(x,y,Raio);
abaixo da posição y1, e também acima da posição (y1+50). Se isto ocorrer, a bola deve retornar no
sentido contrário do deslocamento em x.
Deste modo pode ser escrita seguinte expressão.
if((x>=475 && x<= 476) && (y>=y1) && (y<=y1+50)){valorX=-1;} Esta condição especifica
que o centro do círculo (x,y) deva estar entre as coordenadas do lado da raquete (figura 2.42).
Versão 10
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#define UpKey 72
#define DnKey 80
#define EscKey 27
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
int maxX,maxY;
int x=100,y=100,Raio=25; //coordenadas inicias do circulo
int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo
int controle=1; //variavel de controle para apagar o circulo
int xo,yo; //coordenadas anteriores do centro do circulo
int y1=10; //posicao inicial da raquete
int y1o; //coordenada anterior da raquete
int valorY1=1; //incremento de movimento da raquete
unsigned char ch; //define uma variavel para receber o sinal do teclado
int teste=0; //condicao para entrar no loop
while(teste==0) //o programa fica dentro do laco at'e uma tecla ser tocada
{
if(controle>1)
{
setcolor(BLACK); //pinta de preto
circle(xo,yo,Raio); // desenha circulo em preto sobre o existente
rectangle(500,y1o,505,y1o+50); //desenha a raqute sobre a existente
setcolor(WHITE); // pinta de branco
}
rectangle(10,10,maxX-10,maxY-10);
if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar para esquerda
if(x<=(10+Raio)){valorX=1;} //se atingir o lado esquerdo, deve retornar para direita
if(kbhit())
{
ch=getch();
switch(ch)
{
case DnKey: valorY1=1;
break;
Versão 12
#include <graphics.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#define UpKey 72
#define DnKey 80
#define EscKey 27
//=============================================================
void main()//define a funcao principal
{//1
//=================== definicao das variaveis ==================
int gdriver,gmode,errorcode; //=== variaveis graficas
int maxX,maxY;
int x=100,y=100,Raio=25; //coordenadas inicias do circulo
int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo
int controle=1; //variavel de controle para apagar o circulo
int xo,yo; //coordenadas anteriores do centro do circulo
int y1=10; //posicao inicial da raquete
int y1o; //coordenada anterior da raquete
int valorY1=1; //incremento de movimento da raquete
unsigned char ch; //define uma variavel para receber o sinal do teclado
int teste=0; //condicao para entrar no loop
while(teste==0) //o programa fica dentro do laco at'e uma tecla ser tocada
{
if(controle>1)
{
setcolor(BLACK); //pinta de preto
rectangle(10,10,maxX-10,maxY-10);
if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar para esquerda
if(x<=(10+Raio)){valorX=1;} //se atingir o lado esquerdo, deve retornar para direita
if(kbhit())
{
ch=getch();
switch(ch)
{
case DnKey: valorY1=1;
break;
y1o=y1;
y1=y1+valorY1; //acrescenta valorY1 na coordenada Y1
x=x+valorX; //acrescenta valorX na coordenada X
y=y+valorY; //acrescenta valorY na coordenada Y
circle(x,y,Raio);
Comentários
Este programa apresenta princípios básicos de animação e controle do programa através do teclado.
Este jogo simples demonstra claramente a lógica aplicada em computação para a representação de
imagens simples.
A raquete somente tem efeito quando a bola atinge ela de frente.
Pense em como implementar um placar para que o jogador saiba o status do jogo.
CAPÍTULO 3
3. DESAFIOS
O objetivo deste capítulo é apresentar uma série de problemas que podem ser resolvidos
utilizando os conhecimentos adquiridos no estudo, para instigar o leitor a prosseguir nos estudos.
PROBLEMA 9: Programa de animação para o processo de traçado do raios vetores para a elipse.
PROBLEMA 11: Melhorar o programa jogo de tênis: a) Incluir o deslocamento para a esquerda e para
a direita da rquete; b) um contador de pontos para cada vez que a bola bate no lado direito da tela.
BIBLIOGRAFIA
Arakaki, Reginaldo; Arakaki, Julio;Angerami, Paulo Mattos; Aoki, Osvaldo Luis; Salles, Djalma de
Souza;.-2.ed.-Rio de Janeiro:LTC-Livros Técnicos e Científicos Ed.,1990.
Carvalho, Benjamin de A.. Desenho Geométrico. Editora Ao Livro Técnico. São Paulo, 19..
Fechine, J. Machado, Queiroz, José E. R. Gráficos em C usando Turbo C 3.0. Notas de aula.
Rangel, Alcyr Pinheiro. Curvas. Universidade Federal do Rio de Janeiro, Rio de Janeiro,1982.
b
Função seno: sen α =
c
a
Função cosseno: cos α =
c
b
Função tangente: tan α =
a
Pitágoras : c2 = a2 + b2
c
b
α a
4 5 D 32 Q 16 PgUp 73
5 6 E 18 R 19 PgDn 81
6 7 F 33 S 31 Seta Alto 72
7 8 G 34 T 20 Seta Baixo 80
8 9 H 35 U 22 Seta Esquerda 75
9 10 I 23 V 47 Seta Direita 77
0 11 J 36 X 45 Enter 28
K 37 W 17 Tab 15
L 38 Y 21 Barra Espaço 57
M 20 Z 44
O TURBO C 3.0 é um compilador simples e versátil, ideal para aqueles que pretendem iniciar-se
no aprendizado da linguagem C.
O objetivo desta seção é passar ao usuário os conhecimentos mínimos necessários para que
possa editar, compilar e executar os programas deste livro. Para maiores informações, pode-se
utilizar o próprio Help do TURBO C, ou consultar Arakaki, 1990.
As opções do menu (figura 1) são dispostas horizontalemnte na parte superior do editor. Para
desativar um menu basta teclar ESC.
Na figura 2, a opção ativa do menu é o FILE, o qual abre um menu em cascata que oferece uma
série de opções de comando. Os seguintes comandos estão disponíveis:
OPEN: Carrega um arquivo na janela de edição. Se o arquivo não existir será criado;
SAVE: Salva o arquivo que está sendo editado e, caso o arquivo tenha o nome NONAME.CPP,
um novo nome de arquivo será solicitado para o arquivo ser salvo;
SAVE AS: Salva o arquivo que está sendo editado com um novo nome a ser especificado;
As opções apresentadas junto aos comandos no menu, podem ser ativadas através das teclas
especificadas.
Na figura 5 tem-se:
No menu EDIT, tem-se os seguintes comandos:
PASTE: Cola em posição indicada no trecho de texto cortado como comando CUT;
Na figura 6, tem-se:
No menu RUN, tem-se os seguintes comandos:
GO TO CURSOR: Executa o programa até o comando onde se encontra o cursor na tela de edição;
CONTENTS: Ajuda do do compilador. Basta clicar em cima do texto colorido e teclar Enter.
INDEX: Permite efetuar a busca com o nome dos comandos de programação a partir da digitação do
nome do comando.
CONSTRUINDO UM PROGRAMA
Inicialmente o programa deve ser editado, ou seja, digitado todo o texto que compreende o
programa conforme está descrito no livro.
Logo após o início da digitação, salvar o arquivo no diretório escolhido com um nome definido. É
um bom costume salvar o arquivo de tempos em tempos (tecle F2).
Após o arquivo ser todo digitado, salve-o, e tecle Ctrl-F9, ao mesmo tempo. Deste modo o arquivo
será compilado e executado.
Se o arquivo contiver erros, será apresentada uma janela na parte inferior do editor, que
colocando o cursor e clicando sobre uma linha que indica erro, será apresentado no editor o onde está
o erro encontrado na compilação.
Corrija o erro e rode tecle Ctrl-F9 para compilar o programa novamente. Os erros normalmente
são devidos a digitação. Olhe com atenção o que está escrito no programa no livro e o que foi
digitado.
Podem também ocorrer erros devido ao erro de lógica ou devido a configuração do compilador.