Tarefa 11 - Função vs Procedimento

Nessa tarefa deveremos discutir o uso da função e do procedimento como recurso indispensável para a construção de um código. Para fazermos a análise, precisamos inicialmente, conceituar cada um deles.

Função ou function:

Toda função que é criada por obrigação tem que ter um retorno. Utilizamos funções geralmente quando precisamos calcular  algo, retornar algum valor verdadeiro, ou retornar algum teste.

Ex.

boolean colisao(int xP, int x1, int x2) {

  if ((xP <= x1) || (xP >= x2)) {

    return false;

  } else {

    return true;

  }

}

Procedimento ou Procedure:

É quase igual a uma função, mas não precisa necessariamente ter retorno algum. Geralmente utilizamos procedimentos quando precisamos utilizar alguns códigos que vamos ter que ficar repetindo direto, sendo assim uma procedure concentra nossos códigos e podemos a qualquer momento chama-los.

Ex. 

void mostraGrade(){

  for (int i = 0 ;i < 12;i++){

  line(i*50,0,i*50,600);

  stroke(0, 150, 136);

  }

Assim, é fácil perceber que ao criarmos um procedimento ou função, estamos justamente clarificando e simplificando o nosso código, permitindo assim a criação de módulos que irão facilitar e muito nossa intervenção nesse código.

Jogo PONG - Tarefa 10

Tarefa: considerando também a movimentação vertical, criar uma versão simplificada do jogo Pong, com um único ponto disputado.

int r = 10;

int xC = 10;

int yC = 10;

int dX = 2;

int dY = 2;

int pontoD = 0;

int pontoE = 0;

int yBD = height/2 + 40;

int yBE = height/2 + 40;

boolean z;

boolean e;

boolean w;

boolean p;

void setup() {

  size(320, 240);

  background(0);

}

boolean colisao(int xP, int x1, int x2) {

  if ((xP <= x1) || (xP >= x2)) {

    return false;

  } else {

    return true;

  }

}

void draw() {

  background(197, 202, 233);

  

  if(keyPressed == true) if(keyCode == UP) yBD--;

  if(keyPressed == true) if(keyCode == DOWN) yBD++;

  if(keyPressed == true) if(keyCode == SHIFT) yBE--;

  if(keyPressed == true) if(keyCode == CONTROL) yBE++;

  

  

  fill(63, 81, 181);

  noStroke();

  rect (width - 40, yBD, 20, 80);

  rect (20, yBE, 20 ,80);

fill(255, 64, 129);

ellipse(xC, yC, r*2, r*2);

  

   xC = xC + dX;

   yC = yC + dY;

  

  

  if (xC >=width-r){

   

    pontoE = 1;

    dX = -dX;

  }else if(xC<=r){

    

    pontoD = 1;

    dX = -dX;

  }

  if (yC >=height-r){

    

    dY = -dY;

  }else if(yC<=r){

    dY = -dY;

  }

  

 z = colisao(xC, width - 40, width - 20);

 e = colisao(yC, yBD, yBD + 80);

 if ((z == true) && (e == true)){

   dX = -dX;

 }

 w = colisao(xC, 20, 40);

 p = colisao(yC, yBE, yBE + 80);

 if ((w == true) && (p == true)){

   dX = -dX;

 }

 

 if (pontoD == 1) {

    background(0,0,0,25);

    fill(255);

    text("O lado direito ganhou!", width/3.5, height/2);

  } else if (pontoE == 1) {

    background(0,0,0,25);

    fill(255);

    text("O lado esquerdo ganhou!", width/3.5, height/2);

  }

 if ((colisao(xC, width - 40 - r, width - 20) == true) && (colisao(yC, yBD, yBD + 80) == true)){

  println("direita");

}

  if ((colisao(xC, 20, 40)== true) && (colisao(yC, yBE, yBE + 80) == true)){

  println("esquerda");

}

 

}

Tarefa 09 - Bola quicando = aumento de velocidade

A tarefa de hoje é bem simples, temos que aumentar a velocidade de uma elipse em movimento em 1% toda vez que a mesma colidir com as bordas. Podemos relacionar esse trabalho com o conteúdo de M.R.U.V. ao perceber que há uma variação uniforme na velocidade do movimento da bola.

Assim, para realizarmos essa atividade, se faz necessário criar algumas variáveis, específicas para os eixos de movimentação da bola: eixo X e Y. Após, incrementamos condições para movimentação da bola, indicando que a mesma ao colidir com a parede (width e height) sua velocidade será aumentada em 1%.
Eis o código:
int r = 50;
float bolaX = 50;
float bolaY = 50;
float dX = 5;
float dY = 5;

void setup(){
  size(800,600);
}

void draw(){
  background(0);
  fill(255);
  ellipse(bolaX,bolaY,r*2,r*2);
  
  bolaX = bolaX + dX;
  bolaY = bolaY + dY;
  
  if (bolaX >= width - r){
    dX = dX + (dX/100);
    dX = -dX;
  }
  else if(bolaX <= r){
    dX = dX + (dX/100);
    dX = -dX;
  }
  
  if (bolaY >= height - r){
    dY = dY + (dY/100);
    dY = -dY;
  }
  else if(bolaY <= r){
    dY = dY + (dY/100);
    dY = -dY;
  }
  
  println(dX,dY);
  

}

Tarefa 08 - Cores de círculos

Tarefa: criar e discutir uma aplicação que muda individualmente a cor do preenchimento de dois círculos, com raios e centros randômicos, sempre que o cursor do mouse passar sobre os mesmos

float distancia1D(float x1,float x2){
  return (int)sqrt(pow(x2 - x1,2));
}
float distancia2D(float x1, float y1, int x2, int y2){
  int a2;
  float b = distancia1D(x1,x2);
  float c = distancia1D(y1,y2);
  a2 = (int)sqrt(b*b + c*c);
  return a2;
}
float x1 = random(1,550);
float x2 = random(1,550);
float y1 = random(1,550);
float y2 = random(1,550);
float r1 = random(50,200);
float r2 = random(50,200);
void mudaCor(){
  if(distancia2D(x1,y1,mouseX,mouseY) <= r1/2){
    fill(255,0,0);
    ellipse(x1,y1,r1,r1);
  }else{
    fill(0,0,255);
    ellipse(x1,y1,r1,r1);
  }
    if(distancia2D(x2,y2,mouseX,mouseY) <= r2/2){
    fill(244,231,0);
    ellipse(x2,y2,r2,r2);
  }else{
    fill(0,135,56);
    ellipse(x2,y2,r2,r2);
  }
  }
void setup(){
  size(600,600);
}
void draw(){
  background(0);
  mudaCor();
  textSize(16);
  fill(255);
  text("d círculo 1: " + distancia2D(x1,y1,mouseX,mouseY),mouseX+20,mouseY+20);
  text("d círculo 2: " + distancia2D(x2,y2,mouseX,mouseY),mouseX+20,mouseY+40);
  text("círculo 1",x1 - r1/4,y1 - (r1/2 + 20));
  text("círculo 2",x2 - r2/4,y2 - (r2/2 + 20));
  stroke(255);
  line(x1,y1,mouseX,mouseY);
  line(x2,y2,mouseX,mouseY);
}

Tarefa 07 - o A do Braun

Tarefa: fazer o “A" da Braun continuamente aumentar e diminuir de tamanho no centro da tela.

Para realizar essa tarefa, busquei o logo da Braun, para através da análise proporcionada pelo Professor Clemilson na aula fazer com que o A da logo ficasse se movimentando.

Observando a logo, podemos perceber que o A possui um tamanho maior que as demais letras. Assim, seguindo as proporções determinadas em sala, obtivemos o seguinte resultado:

float x = 137.5;

float y = 200;

int aux = 0;

boolean chave;

void setup(){

  background(255);

  size(275,400);

  frameRate(100);

}

void mostraA(int a){

float m = a / 8;

println(m);

float l = 3.3 * m;

println(l);

fill(0);

rect(x - 1.65 * m, y - 3*m,m,7*m);//retangulo esquerda

rect(x + 0.65 * m, y - 3*m,m,7*m);//retangulo direita

rect(x - 0.65*m,y + 0.5*m,1.3*m,m);//retangulo centro inferior

rect(x - 0.65*m,y - 4*m,1.3*m,2*m);//retangulo centro superior

arc(x - 0.65 * m, y - 3*m, 2 * m, 2*m,PI,3*HALF_PI);//arco superior esquerdo

arc(x + 0.65 * m, y - 3*m, 2 * m, 2*m,3*HALF_PI,2 * PI);//arco superior direito

//area inderior do A

fill(255);

noStroke();

ellipse(x + 0.4*m,y - 2.75*m,0.5*m,0.5*m);

ellipse(x - 0.4*m,y - 2.75*m,0.5*m,0.5*m);

}

void chave(){

  if(aux == 0){

    chave = true;

  }else if(aux == 400){

    chave = false;

  }

}

void draw(){

  background(255);

  chave();

  

    if(chave == true){

      aux++;

    }else{

      aux--;

    }

  mostraA(aux);

}

Tarefa 06 - Bandeira do Brasil

Considerando a Lei Federal Nº 5.700, criar a função mostraBandeiraBrasil(x, y, l) e discutir o resultado em seu blog:

De acordo com a lei, temos o seguinte:

Art. 5º A feitura da Bandeira Nacional obedecerá às seguintes regras (Anexo nº 2):

I - Para cálculo das dimensões, tomar-se-á por base a largura desejada, dividindo-se esta em 14  (quatorze) partes iguais. Cada uma das partes será considerada uma medida ou módulo.

II - O comprimento será de vinte módulos (20M).

III - A distância dos vértices do losango amarelo ao quadro externo será de um módulo e sete décimos (1,7M).

IV - O círculo azul no meio do losango amarelo terá o raio de três módulos e meio (3,5M).

V - O centro dos arcos da faixa branca estará dois módulos (2M) à esquerda do ponto do encontro do prolongamento do diâmetro vertical do círculo com a base do quadro externo (ponto C indicado no Anexo nº 2).

VI - O raio do arco inferior da faixa branca será de oito módulos (8M); o raio do arco superior da faixa branca será de oito módulos e meio (8,5M).

VII - A largura da faixa branca será de meio módulo (0,5M).

Sabendo dessa informação temos a criação do seguinte código:

void setup(){

  size(600, 420);

  background(255);

}

void mostraBandeiraBrasil(float x, float y, float l){ //função para mostrar a bandeira do Brasil

 //Seguindo as proporções da lei:

 float m = l / 14;  

 float c = 20 * m;

 noStroke();

 fill(0,135,56);

 rect(c - c, l - l, c, l);

 fill(244,231,0);

 quad((1.7 * m), l/2, c/2, (1.7 * m), c - (1.7 * m), l/2, c/2, l - (1.7 * m));

 fill(11,38,117);

 ellipse(c/2, l/2, m * 7, m * 7);

}

void draw(){

  mostraBandeiraBrasil(300, 210, 420);

}

  

  Esse foi o resultado:

Trabalho Final de Matemática Aplicada à Multimídia

Olá Povo...

O trabalho final consistia em criar um vídeo explicativo sobre a criação ou melhor apropriação de uma imagem ou obra de arte ou de design a sua escolha.

Eis  o vídeo...

Se o vídeo não abrir, clique aqui!

Abs e até a AF... hehehehehehe