TRABALHO - Criação do logotipo "Robot Android".

O logotipo "Robot Android" é um robôzinho verde que acompanha a maioria dos produtos da marca Android e ele é formado basicamente por formas geométricas simples (Círculos e Retângulos), porém que juntas criam uma imagem fluída e interessante.

A princípio, para definir meus módulos e como era feito o logo, eu fui no site da google procurar algo sobre o logotipo.. porém eles não tem um "manual" propriamente dito de criação, eles apenas disponibilizam a logotipo em um arquivo editável. Curioso com a forma de criação da logo, eu resolvi tentar me comunicar com a criadora original, a russa Irina Blok, que junto com a equipe de design da google, foi a responsável principal da criação do logo. Então mandei um e-mail para ela perguntando se ela havia usado formas geométricas e matemática na criação do logo... sem muitas esperanças, porém um tempo depois ela me respondeu.

Primeiro e-mail trocado com a criadora da logo.

Segundo e-mail trocado com a criadora da logo.

Então ela me diz que não usou matemática nenhuma para fazer a logo, que as decisões foram feitas visualmente. O que faz com que as medidas da logo tenham valores não muito simétricos, porém não significa que as formas não podem se ligar de alguma maneira.
Utilizando basicamente, círculos e retângulos na figura original, eu consegui achar outras figuras geométricas que se formavam na junção das duas formas principais... consegui estabelecer alguns trapézios e triângulos. Foi usado também diagonal do retângulo para estabelecer o tamanho das antenas.. etc.

Por exemplo:

o retângulo que forma o braço é a base menor de um trapézio retângulo (lado AD), que é igual a: lado AD = R*4;

a distância entre o braço e a esfera da cintura pode ser utilizada a fórmula da distância entre dois pontos:
DC = (AB)² - (BC - AD)³

a distância entre os braços e a cintura e a cintura e a cabeça é o valor do r (raio do olho).

a distância entre as duas extremidades dos olhos define o meio do desenho e o outro lado são basicamente as mesmas formas, só irá mudar o valor das coordenadas.
As coordenadas (x e y) de cada ponto vão ajudar a você estabelecer essas distâncias entre pontos das figuras... após a figura ser divida em módulos.

Para essa divisão de módulos, eu escolhi criar um tela 800x800 e dividir ela igualmente em 15 módulos de valor 50. Após isso eu escolhi meu ponto inicial... e determinei os módulos de cada parte da imagem.. isso vai me ajudar no desenvolvimento do aplicativo que é de recriar o logotipo da Android sem utilizar números específicos, assim se a pessoa quiser criar um logotipo em qualquer coordenada, ou de qualquer tamanho, será possível.

O código:

para a criação do código eu usei apenas as funçoes rect(), arc(), line() e ellipse() e assim criei todas as partes que juntas, formariam o desenho do robô.

int mod = 50;

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

void draw(){
  background(0);
  desenhaCorpo(250,307,mod);
  antenas(250,307, mod);
}


void desenhaCorpo (float x, float y, float modulo){

//cabeça
noStroke();
fill(151,199,24);
arc(x + 3.07*modulo, y - 0.2*modulo, 6.14*modulo, 6.14*modulo, PI, 2*PI, OPEN);

//olhos

fill(255);

ellipse(x + 1.66*modulo, y - 1.62*modulo, 0.52*modulo, 0.52*modulo);
ellipse(x + 4.48*modulo, y - 1.62*modulo, 0.52*modulo, 0.52*modulo);

//pontas das antenas
fill(151,199,24);
ellipse(x + 1.12*modulo, y - 3.64*modulo, 0.16*modulo, 0.16*modulo);
ellipse(x + 5.02*modulo, y - 3.64*modulo, 0.16*modulo, 0.16*modulo);
//braço esquerdo
fill(151,199,24);
ellipse(x + 7.1*modulo, y + 0.58*modulo, 1.4*modulo, 1.4*modulo);
ellipse(x + 7.1*modulo, y + 3.42*modulo, 1.4*modulo, 1.4*modulo);
rect(x + 6.4*modulo, y + 0.58*modulo, 1.4*modulo, 2.8*modulo);
//cintura
rect(x, y, 6.14*modulo, 4.52*modulo);
ellipse(x + 0.7*modulo, y + 4.5*modulo,1.4*modulo, 1.4*modulo);
ellipse(x + 5.44*modulo, y + 4.5*modulo, 1.4*modulo, 1.4*modulo);
rect(x + 0.7*modulo, y + 4.5*modulo, 4.74*modulo, 0.7*modulo);

//braço direito
ellipse(x - 0.96*modulo, y + 0.58*modulo, 1.4*modulo, 1.4*modulo);
ellipse(x - 0.96*modulo, y + 3.42*modulo, 1.4*modulo, 1.4*modulo);
rect(x - 1.66*modulo, y + 0.58*modulo, 1.4*modulo,2.8*modulo);
//pernas
rect(x + 1.22*modulo, y + 4.5*modulo, 1.4*modulo, 2.2*modulo);
rect(x + 3.52*modulo, y + 4.5*modulo, 1.4*modulo, 2.2*modulo);
ellipse( x + 1.92*modulo, y + 6.7*modulo, 1.4*modulo, 1.4*modulo);
ellipse( x + 4.22*modulo, y + 6.7*modulo, 1.4*modulo, 1.4*modulo);
}

void antenas(float x, float y, float modulo){
strokeWeight(round(0.16*modulo));
stroke(151,199,24);
line(x + 1.12*modulo, y - 3.64*modulo, x + 1.66*modulo, y - 2.74*modulo);
line(x + 5.02*modulo, y - 3.64*modulo, x + 4.48*modulo, y - 2.74*modulo);

}

Resultado Final:

Atividade 10

- apresentar e discutir todo o processo de construção do jogo desenvolvido, enfatizando o uso de códigos anteriores.

código:

Nessa versão do Breakout foi escolhido apenas um survivor em que a pessoa tem que manter a bola rodando e de acordo que o tempo vai aumentando, a dificuldade també, pois a bola vai ficando mais rápida..

As atividades anteriores utilizadas nesse código foram todas as relacionadas a criação do pong e a criação da "plataforma".

int raio = 10;
int ballX= raio;
int ballY= raio;
float dX=6;
float dY=6;
int xP = 50;
int yP;

void setup()
{
   size(800, 600);
   yP= height -50;
}

void draw()
{
  background(0);
  //noStroke();
  fill(255);
  //Barra
  rect(xP, yP, 100, 20);
  if(keyPressed == true)
  {
    if(keyCode == RIGHT && xP< width - 100)
    xP+=10;
    else if(keyCode == LEFT && xP> 0)
    xP-=10;
  }
  
  
  //Bola
  ellipse(ballX, ballY, 2*raio, 2*raio);
  ballX+=dX;
  ballY+=dY;
  
  //Colisão da bola com a parede
  if(ballX + raio >= width-raio)//movimento horizontal
   dX= -1.01*dX;
  else if(ballX + raio <= raio)
   dX = -1.01*dX;
  if(ballY + raio <= raio)//movimento vertical
   dY = -1.01*dY;
//  else if(ballY + raio >= height-raio)//movimento vertical
//   dY= -1.01*dY;  
   
  //Colisão da bola com a barra
//  if(ballX + raio >= xP && ballX + raio == xP + 100 && ballY + raio == yP)
//  {
//   println(ballY + raio + " " + yP); 
//   dY = -1.01*dY;
//  }
  if(estaDentro(ballX + raio, ballY + raio, xP, yP, xP + 100, yP + 20))
   dY = -1.01*dY;
   println(ballX + raio + " " + xP);
   
   
}

boolean estaDentro(int xP, int yP, int x1 , int y1, int x2, int y2)
{
   if(xP >= x1 && xP <= x2  && yP>= y1 && yP <= y2)
     return true;
   return false;  
}

Atividade 9

- pesquisar e discutir a relação entre os jogos Pong e Breakout e sua ligação com a fundação da empresa Apple.

Steve Jobs foi funcionário da Atari entre 1974 e 1975. Foi a única experiência de Jobs como empregado: ele sairia da empresa de games para montar a Apple, junto com Steve Wozniak. E foi o mesmo Wozniak, na época funcionário da HP, que trabalhou com Jobs no projeto que hoje é emblemático de sua passagem pela Atari: o jogo Breakout, de 1976.

O game foi concebido a partir de uma ideia do fundador da Atari, Nolan Bushnell, que pediu para Jobs desenvolver uma versão single player para o clássico Pong. Jobs então recorreu ao amigo Wozniak para ajudá-lo na programação, episódio que ficou famoso pelo calote que o fundador da Apple deu no amig, Woz recebeu apenas uma pequena parcela dos honorários. Apenas anos depois Wozniak descobriu que graças ao seu trabalho Jobs havia recebido um bônus pela economia de chips em Breakout, sem nunca tê-lo repassado para o parceiro de projeto.

Em muitas biografias do Steve Jobs, o fato dele ter trabalhado na Atari é quase sempre deixado de lado, talvez não queiram representar que o criador de uma das marcas mais famosas do mundo tenha começado como um produtor de "joguinhos", afinal a história de que ele e Wozniak criaram o Apple I na garagem da sua casa é bem mais apelativa para o público, porém é falsa, como o próprio Wozniak já confirmou. A Atari foi essencial até mesmo para Steve Jobs conseguir o financiamento necessário para poder bancar seus projetos, principalmente o sonhado Apple II, computador pessoal que revolucionou o mercado quando foi lançado. Talvez seja exagero afirmar que a Apple não existiria sem a Atari, porém é evidente que se não fosse por Bushnell (fundador e dono da Atari) e pela passagem pela empresa de games, Jobs e Wozniak teriam tido muito mais dificuldades para chegarem até onde chegaram e até quem sabe, tivessem desistido no meio do caminho. De uma forma ou de outra, tanto Wozniak quanto Jobs começaram suas carreiras como desenvolvedores de games, têm seus nomes na história dos jogos – até mesmo o Apple II foi vendido como uma máquina que rodava jogos.

Atividade 8

- pesquisar e discutir como o Pong original foi "codificado"


- Pesquisa sobre a criação:

http://ethw.org/First-Hand:The_Development_of_Pong:_Early_Days_of_Atari_and_the_Video_Game_Industry

Eu li a história contada sobre o criador do Pong, como o jogo foi desenvolvido e codificado e fiz um pequeno resumo das partes mais importantes, que falam sobre a codificação e o modo que era trabalhado. O resumo está narrado no ponto de vista do criador:

         Nolan me deu este desafio. Ele me atarefou de fazer um jogo de ping-pong numa tela de TV,

ele tinha um contrato para fazer um video game caseiro, e tinha que ser muito barato, eles só teriam

15 dóllares de custos. A minha reação inicial foi "wow, isso vai ser difícil", mas em compensação o jogo era bem simples, apenas um ponto se movendo. Depois de algum tempo foi descoberto que esse contrato não existia, na verdade eu pensava que o jogo que seria feito seria mais complexo, talvez um jogo de corrida ou algo do tipo.

        Nolan me deu algums cópias do esquema do "Computer Space", jogo que ele tinha feito anteriormente, mas eu não entendi nada porque Nolan desenhou eles de uma maneira bizarra, mas em uma conversa ele explicou para o Ted como era feito o circuito de movimentação. Basicamente eles usaram geradores de sincronização trabalhando em frames horizontais e verticais.

E através desses geradores eles conseguiram fazer com que aparecesse um ponto na tela e com que ele se movesse para cima e para baixo.

      O projeto usava muitoss chips, a versão finalizada tinha cerca de 75, e como os chips eram bem baratos, as chances deles darem algum erro era de 1 a 2%, então quando se montava uma placa com 75 chips, haviam chances de haver um chip ruim.

      O jogo tinha um pequeno ponto, um pequeno objeto, um placar, som e etc. Para mostrar o placar existia um chip digital que fazia isso instantaneamente ao invés de decodificar todos os segmentos de um segmento de sete digítos, porém o chip era 5 dolláres, e isso era muito caro, eles não podiam comprar, então eu tive que usar os seus conhecimentos pra decodificar todos os segmentos de um display de sete seguimentos.

      Para fazer o Som foi um pouco complicado, pois o projeto já estava no custo máximo e não sabia como fazer som com os componentes digitais. Então eu cutuquei um gerador de sincronização e achei tons que estavam lá, e foi daí que surgiu os sons do jogo.

      Como Nolan me disse que o jogo tinha que ser para o consumidor, eu achei que o jogo ficaria tedioso se a bola tivesse apenas uma velocidade horizontal, duas pessoas podiam sentar lá e jogar para sempre e isso não seria divertido. Então eu adicionei velocidade, havia um contador e depois

de um certo número de rodadas iria deixar cada vez mais rápido.

      Pong foi um video game inusitado, não havia instruções e precisava de duas pessoas para ser jogado e foi um grande sucesso. O primeiro pong parou de funcionar algumas semanas depois porque os potenciômetros pararam de funcionar, eu fiquei surpreso, mas eu fiz a matemática de quanto tempo seria preciso.