SWGame

Para o segundo exercício de código fiz um jogo que tem como principio acabar com o Darth Vader no universo. A pontuação gere-se por diferentes factores de velocidade o que acrescenta um certo dinamismo ao jogo apesar de ainda um pouco rudimentar.

Este slideshow necessita de JavaScript.

PImage img;
PImage player;
float [] x;
float [] y;
float [] dx;
float [] dy;
int numOfBalls = 10;
int numOfBallsRemaning = numOfBalls;
int points = 0;

void setup() {
  size (500, 500);
  frameRate (60);
  img = loadImage("space.jpg");
  player = loadImage ("DV.png");
  x = new float [numOfBalls];
  y = new float [numOfBalls];
  dx = new float [numOfBalls];
  dy = new float [numOfBalls];
  for(int i = 0; i < numOfBalls; i++) {
    x[i] = random(50, 475);
    y[i] = random(50, 475);
    dx[i] = random(-5, 3);
    dy[i] = random(-5, 3);
  }
}
void draw() {
  image (img, 0, 0);
  rectMode(CENTER);
  fill(#ffffff);
  fill(50);
  //stroke(random(0, 250), random(0, 250), random(0, 250));
  //strokeWeight(20);
    for(int i = 0; i < numOfBalls; i = i + 1) {
    //ellipse(x[i],y[i],50,50);
    image (player, x[i],y[i], 75, 75);
    x[i] = x[i] + dx[i];
    y[i] = y[i] + dy[i];
    if ((x[i]+50 > width) || (x[i] < 0)) {
    dx[i] = -dx[i];}
    if ((y[i] > height) || (y[i] < 0)) { 
    dy[i] = -dy[i];}
    }
    textSize(32);
    fill(#ffffff);
    text("Score:" + points, 10, 30);
    if(numOfBallsRemaning == 0) {
      textSize(25);
      fill(random(0, 250), random(0, 250), random(0, 250));
      text("MAY THE FORCE BE WITH YOU!", 68, 250);
      
    }
}
void mousePressed () {
  for(int i = numOfBalls - 1; i >= 0; i--) {
    float dist = sqrt((x[i] - mouseX) * (x[i] - mouseX) + (y[i] - mouseY) * (y[i] - mouseY));
    if(dist <= 75) {
    x[i] = -250;
    y[i] = -250;
    int speedBonus = abs(int(dx[i] + dx[i]));
    int timeBonus = int((20000.0 / millis()) * 10); 
    points = points + 10 + speedBonus + timeBonus;
    numOfBallsRemaning--;
    break;}
  }
}

Referência:
// https://www.youtube.com/watch?v=vZtEKLAyoVI&index=2&list=PLemTjQfN3JmnE_IQBSDms2ASsO8L4KkdE

Elefante

Esta foi a imagem que criei para o primeiro exercício de código.

Elefante

 

size (500, 500);
background (#bc98ed);

strokeWeight(40);
fill (#f48bb2);
quad (100,100,100,200,200,250,200,100);

strokeWeight(40);
fill (#f48bb2);
quad (300,100,300,250,400,200,400,100);

strokeWeight(50);
line (250, 110, 250, 280);

strokeWeight(20);
fill (#000000);
ellipse (225,100, 50, 50);

fill (#000000);
ellipse (275,100, 50, 50);

strokeWeight(40);
fill (#ffffff);
quad (200,100,200,200,300,200,300,100);

strokeWeight(5);
triangle(300,227,300,250,350,237.5);

triangle(350,180,320,230.5,343,237.5);

triangle(200,227,200,250,150,237.5);

triangle(150,180,180,230.5,157,237.5);

strokeWeight(6);
triangle(249,374,228,280,249,280);

triangle(251.99,374,251.99,280,272,280);

ellipse (250, 280, 38, 38);

strokeWeight(7);
fill (#000000);
triangle(346,425,252,399,232,300);

fill (#ffffff);
quad (360,390,316,390,358,428,400,360);

fill (#000000);
quad (360,350,365,387,407,350,380,298);

strokeWeight(2);
fill (#ffffff);
line (200, 150, 300, 150);
line (200, 125, 300, 125);
line (200, 175, 300, 175);
line (200, 137.5, 300, 137.5);
line (200, 162.5, 300, 162.5);

triangle(293,173,280,162.5,305,162.5);
triangle(207,173,220,162.5,195,162.5);

Referências:
https://www.youtube.com/user/shiffman/videos

Filipa Fernandes

Olá, sou a Filipa, tenho 18 anos e sou da Amadora :D 

Estudei Artes Visuais até ao 12º ano e em 2014 entrei em  Design de Equipamento. Gostei do 1 semestre do curso, aprendi a trabalhar madeira, a mexer em máquinas (assustadoras) e aprendi ainda mais sobre desenho digital, que é uma das minhas paixões. No segundo semestre percebi que não estava no sitio certo. E aqui estou eu.

Espero aprender e experimentar muitas coisas ao longo destes 3 anos.

editadaa

(este post encontrava-se neste blog )

Exercício de Animação/Interação

Este é o trabalho que fiz em conjunto com o Tiago. Consiste numa repetição animada de um padrão de quadrados que rodam num vértice e criam um círculo. Quando se clica com o rato, as cores dos quadrados/círculo mudam aleatoriamente. Quando se carrega numa tecla qualquer, é a cor do fundo que muda (portanto, interatividade).

Desenho Individual #2

Eu fiz um segundo desenho, durante a aula de programação, à medida que o programador Pedro ia explicando as variantes de programação.

desenho experimental

 

size(750,750);

color corfixe = color(#70067C);

color corseca = color(#21E8E6);

color cormeh = color(255,201,222);

color cormehh = color(255,201,222,150);

color corhaha = color(#830739);

PImage bebe = loadImage("bebe.jpg");

background(corfixe);

strokeWeight(50);
stroke(corseca);
point(width/2,height/2);
line(750,50,100,750);

strokeWeight(7);
stroke(cormeh);
fill(corseca);
triangle(100,50,150,100,50,150);

strokeWeight(5);
stroke(cormeh);
fill(cormeh);
beginShape();
vertex(100,100);
vertex(500,500);
vertex(250,200);
vertex(300,700);
endShape(CLOSE);

strokeWeight(25);
stroke(corseca);
fill(cormeh);
rect(450,570,200,150);

image(bebe,600,300,100,100);
image(bebe,400,100,200,200);

noStroke();
fill(cormehh);
ellipse(250,250,650,500);

image(bebe,200,200,100,100);

stroke(corhaha);
strokeWeight(10);
line(750,200,250,750);

stroke(corhaha);
strokeWeight(5);
noFill();
triangle(250,150,250,400,450,150);

image(bebe,50,550,150,150);

The catcher in the rye

 

Imagem do jogo

 

Este é o jogo que desenvolvemos, a partir de uma citação do livro “The catcher in the rye” de J.D. Sallinger. O intuito é apanhar as criancas (X) que se atiram para o penhasco.

 <pre>
PImage fundo; // declara imagem do fundo
PImage catcher; // declara imagem da cesta
PImage kid ; // declara imagem das crianças, os X
PImage reset; // declara imagem da seta circular que funciona como botão de reset/restart

PFont font; //declara uma font

int[] xm; // declara vetor da posição x da criança
int[] ym; // declara vetor da posição y da criança
int n; // número de crianças

int xc=1; // declara posicao x da cesta, que se incia com valor 1
int vc=10; // declara e dá valor 5 para a velocidade da cesta
int [] vm; // declara vetor da velocidade da cesta

int pontos = 0; // declara variável que faz contagem das kid que foram apanhadas pela cesta, iniciando com valor zero.
int segundos; // declara variável que marcará o tempo de cada partida
int desconto = 0; // declara variável que vai descontar o tempo ja contado para que a marcação fique a 0 a cada partida

void DesenhaKid (){ // função que posiciona aleatoriamente N crianças no campo
 for(int i=0;i<n;i++){ 
 xm[i]=int(random(20,500)); //sorteia, dentro da área do campo, n posições para as posições no eixo x das crianças
 ym[i]=int(random(60,130)); //sorteia, dentro da área do campo, n posições para as posições no eixo y das maçãs
 }
}


void caiKid(){ // função que dá velocidade às crianças que o mouse clicar sobre, fazendo-as cair.
 for(int i = 0; i<n ; i++){
 if(mousePressed && dist(mouseX, mouseY, xm[i]+10, ym[i]+10)<20){ //condição de mouse pressionado e distância entre o mouse e uma criança
 vm[i] = 15; //que faz com que elas deixem de ter valor nulo de velocidade
 }
 }
}


void catcher (){ // função que faz o movimento de ida e volta da cesta
 image(fundo,0,0); //desenha imagem de fundo, apagando os rastros
 if((xc>0)&&(xc<450)){ //condição que só movimenta a cesta dentro da área da tela do jogo
 image(catcher,xc,550,102,60); //carrega imagem da cesta
 xc = xc + vc; // movimentação da cesta
 }
 else{ //condição que faz a cesta retornar quando alcança o fim da tela
 vc = -vc;
 xc = xc + vc;
 }
}

void encesta(){ // função que faz as crianças serem apanhadas caso elas passem pela posição onde se localiza a cesta
 for(int i = 0 ; i<n ; i++){
 if((ym[i]>390) && (ym[i]<500) && (xm[i] > xc) && (xm[i] < xc+92)){ //se as criancas cruzam a linha superior da cesta elas são apanhadas

 vm[i]= 0; // a velocidade delas é anulada
 ym[i] = 700; // e são mandadas para fora do campo visual da tela

 pontos = pontos + 1; // acrescenta-se uma unidade a variável pontos
 }
 }
}


void reset(){ // função que gera uma nova partida e anula a anterior
 for(int i = 0 ; i<n ; i++){
 if((mousePressed) && (mouseX > 750) && (mouseX < 790) && (mouseY > 535) && (mouseY < 575)){ //condição que verifica se o mouse clicou sobre a imagem
 vm[i] = 0; //a velocidade das crianças anulam se para que parem de cair
 pontos = 0; // a variável pontos é zerada
 DesenhaKid(); // as crianças são novamente sorteadas no campo
 desconto = millis()/1000; // a variável desconto assume o valro atual da contagem do tempo desde a abertura do jogo, ficando a zero a variável segundos
 delay(2); // atraso para não se reiniciar o jogo mais de uma vez num único click
 }
 }
}






void setup(){

 size(525,700); //define tamanho da janela
 noStroke();
 smooth();

 catcher = loadImage ("catcher.png"); //carrega imagem da cesta
 fundo = loadImage ("campo.png"); //carrega imagem do fundo
kid = loadImage ("kid.png"); //carrega imagem da criança
 reset = loadImage ("reset.gif"); //carrega imagem da seta circular

 font = loadFont ("FrenteH1-Regular-38.vlw"); //carrega a font 
 textFont(font, 35); //Define corpo da font para 26 pixels

 n=15; //define que serão 15 crianças
 xm = new int[n]; // vetor da posição x da criança terá n valores
 ym = new int[n]; // vetor da posição y da criança terá n valores
 vm = new int [n]; // vetor da velocidade das crianças terá n valores, que serão ou zero ou 15, dependendo se a criança está caindo ou não

 for (int i = 0; i<n ; i++){ //comando que garante que ao se iniciar o jogo todas as crianças fiquem paradas por terem velocidade nula.
 vm[i]=0;

 }
 DesenhaKid(); //chama função que desenha as criança no campo e começar o jogo
}



void draw(){

 catcher(); //chama e atualiza a função que movimenta a cesta
 caiKid(); //chama e atualiza a função que faz as criancas cairem ao serem clicadas

 for(int i=3;i<n;i++){ //comando que redesenha as crianças a cada quadro
 image(kid,xm[i],ym[i]);
 }

 for (int i = 2; i<n; i++){ //comando que movimenta as crianças em queda até terem valor y maior que 700 pixels, fazendo com que desapareçam
 if(ym[i]<700){
 ym[i] = ym[i] + vm[i];
 }
 }

 image(reset,245,640); // desenha imagem da seta circular

 encesta(); //chama e atualiza a função que faz as maças parecem cair no cesto
 reset(); //chama e atualiza a função que recomeça o jogo

 fill(255); //define a cor dos escritos como preta
 text("KIDS:",120, 700); //gera texto do escrito "Kids:"
 text(pontos, 170, 700); //gera texto que escreve o valor da variavel pontos

 segundos = millis()/1000 - desconto; // define valor da variável segundos, que conta o tempo em segundos desde que um novo jogo é começado
 //através da função millis que conta o tempo em milésimos e um desconto que é aplicado a cada vez
 // que o jogo recomeça
 text("Tempo:", 305, 700); //gera o escrito "Tempo:"
 text(segundos, 370, 700); // gera o texto com o valor da variável segundos

}

</pre>

Jogo CATCH ME IF YOU CAN

Screen Shot 2016-01-05 at 13.19.58

Desenvolvermos este jogo com intuito de desenvolver a destreza manual dos utilizadores do cursor. Tentando assim diminuir o tempo de reacção destes mesmos.
Este trabalho foi realizado por: Catarina Biscaia, Leonor Oliveira e Marta Penaguiao

//interactivos

float x;
float y;
float h;
float w;

color rosa;
color blue;
color yellow;

//PImage quadrado.jpeg;
int score = 0;
int winscore = 10;
int winscore2 = 20;

void setup() {
size(500,500);
rosa = color (#FE2EFF);
blue = color (#2FCEE8);
yellow = color (#E8DF2F);
background(rosa);
x = width/2;
y = height / 2;
textSize(30);
textAlign(CENTER,CENTER);

}

void draw () {

background (rosa);
x = constrain(x + random (-20,20), 0, width);
y = constrain(y + random (-20,20), 0, height);
h = 20;//random (width);
w = 20;//random (width);

if (mouseX>x&&mouseX<x+w&&mouseY>y &&mouseY<y+h)
score = score +1;
background(blue);

rect(x,y,h,w);

score();
gameover();
}

void score(){
fill(255);
text(score, width/2, 100);

}

void gameover () {
if(score == winscore)

text("ALMOST THERE", width/2, 300);
if(score == winscore2)
text("YOU WIN ", width/2, 300);

}

Viagem Atribulada

Para este trabalho de código: interação eu e a minha colega Rebeca Baltazar, decidimos criar um jogo, que consiste na interação entre um boneco voador que tenta evitar os pássaros que se encontram no seu caminho.
Tipo de font usada: game_over.

Capturar 1

 

Personagens do jogo:

 

//música
import ddf.minim.*;
import ddf.minim.analysis.*;
import ddf.minim.effects.*;
import ddf.minim.signals.*;

Minim minim;
AudioPlayer sou;
AudioPlayer smack;

PFont numero;

float Player_x;
float Player_y;
float Player_vx;
float Player_vy;
float Player_width;
float Player_height;
boolean Player_hit;

float Block_y;
float Block_x;
float Block_vy;
float Block_vx;
float Block_height;
float Block_width;

//bloco tipo 2
float Block2_y;
float Block2_x;
float Block2_vy;
float Block2_vx;
float Block2_height;
float Block2_width;

//bloco tipo 3
float Block3_y;
float Block3_x;
float Block3_vy;
float Block3_vx;
float Block3_height;
float Block3_width;


PImage boneco;

float collision_radius;

PImage fundo5;
PImage fundo;
PImage passarobranco;
PImage passaroazul;
PImage passaroamarelo;
PImage gameover;
int contagem = 0;
int stage;  

void setup() {
   stage = 1;
   
  size(900,500); 

  
  numero= loadFont("numero.vlw");
  textFont(numero);
  
 //Música
  minim = new Minim(this);
  sou = minim.loadFile("tetris_original.mp3");
  smack=minim.loadFile ("smack.mp3");

  fundo5= loadImage ("fundo5.png");
  boneco = loadImage ("boneco2.png");
  fundo = loadImage ("fundo.png");
  passarobranco = loadImage ("passarobranco.png");
  passaroazul = loadImage ("passaroazul.png");
  passaroamarelo = loadImage ("passaroamarelo.png");
  gameover = loadImage ("gameover.png");
  
  Player_height = 60;
  Player_width = 60;
  Player_y = height / 2;
  Player_x = width - Player_width -40;
  Player_vy = 0;
  Player_vx = 0;

  Block_height = 90;
  Block_width = 90;
  Block_y = floor (random (100, height));
  Block_x = 0;
  Block_vy = 11;
  Block_vx = 11;
   
// bloco tipo 2
  Block2_height = 90;
  Block2_width = 90;
  Block2_y = floor (random (100, height));
  Block2_x = 0;
  Block2_vy = 9;
  Block2_vx = 9;
  
    // bloco tipo 3
  Block3_height = 90;
  Block3_width = 90;
  Block3_y = floor (random (100, height));
  Block3_x = 0;
  Block3_vy = 7;
  Block3_vx = 7;
  
  collision_radius = 70;
  
  rectMode(CENTER);
}

void draw() {
  
  if (stage==1){
    image (fundo5,0,0,900,500);
    if (mousePressed==true){
      sou.loop();
      stage=2;
    }
  }
  
   if (stage==2){ 
  
  if (keyPressed) {
      Player_y = Player_y - 10;  
    }

  Player_y = constrain (Player_y + 4, 0, height - 120);
  Player_x = constrain(Player_x + Player_vx, 0, width);
  
//bloco tipo 1  
  Block_x = Block_x + Block_vx;
  if (Block_x > width) {
    Block_y = floor (random(0, height));
    Block_x = 0;  
  }
  
//bloco tipo 2
  Block2_x = Block2_x + Block2_vx;
  if (Block2_x > width) {
    Block2_y = floor (random(0, height));
    Block2_x = 0;  
  }
  
//bloco tipo 3
  Block3_x = Block3_x + Block3_vx;
  if (Block3_x > width) {
    Block3_y = floor (random(0, height));
    Block3_x = 0;  
  }

  Player_hit = false;
  
  if (dist (Player_y, Player_x, Block_y, Block_x) < collision_radius) {
    Player_hit = true;
  }
  
  //bloco tipo 2
  if (dist (Player_y, Player_x, Block2_y, Block2_x) < collision_radius) {
    Player_hit = true;
  }
   
   //bloco tipo 3
  if (dist (Player_y, Player_x, Block3_y, Block3_x) < collision_radius) {
    Player_hit = true;
  }
   
  if (Player_hit) {
   // smack.play();
    stage=3;
    
  }
  else {
    background (fundo);
    contagem=contagem+1;
    }
    
  
  
  image (passarobranco, Block_x,Block_y);
  image (passaroazul, Block2_x,Block2_y);
  image (passaroamarelo, Block3_x,Block3_y);
  
  image(boneco, Player_x, Player_y);
  
  
  fill(#030000);
 //textSize(30);
  text("SCORE  "+ contagem, 28,46);
  
 
  }
  
  
if (stage==3){
    background(gameover);
    fill(#FFFFFF);
    text("SCORE  "+ contagem, 238,480);
        if (mousePressed){
          stage=2;
          contagem=0;
    }
  }
 
}

Processing 2 – The little pink square

Este é um trabalho realizado pela Ana Martins e eu.

meios digitais 2

int x = 0;
int y = 0;

float px[];
float py[];
 
int num_particles = 70;


void setup() {
  size(600,600);
  
    px = new float[num_particles];
    py = new float[num_particles];
    
    for (int i = 0; i < num_particles; i++) {
        px[i] = random (width);
        py[i] = random (height);
    }
}

  void keyPressed() {
  if (key == CODED) {
    if (keyCode == UP) {
      y -= 5;
    } else if (keyCode == DOWN) {
      y += 5;
    } else if (keyCode == LEFT) {
      x -= 5;
    } else if (keyCode == RIGHT) {
      x += 5;
    }  
  } 
}

void draw() {
  background(#AEB0E1);
       noStroke();
   fill(#FADEFC);
       rect(x,y,30,30);
   fill(#C5AEE1);
   
   stroke (#FFFFFF);
   fill (#B8FFB7);
   
    for (int i = 0; i < num_particles; i = i+1) {
        px[i] = constrain (px[i] + random (-4, 4), 0, width);
        py[i] = constrain (py[i] + random (-4, 4), 0, height);
        
           if (dist (px[i], py[i], X, Y) < 40) {
            float vx = (px[i] - X);
            float vy = (py[i] - Y);
            
            px[i] = px[i] + vx;
            py[i] = py[i] + vy;
        }
        
         ellipse (px[i], py[i], 7, 7);
         fill (#B8FFB7);
   
  }
}

exercício 1

guy

 

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

background (255);

fill (#F0CD88);
stroke(#F0CD88);
ellipse(300,260,400,325);

fill (255);
ellipse(200,245,90,35);

fill(255);
ellipse(400,245,90,35);

fill (0);
ellipse(200,245,39,35);

fill (0);
ellipse(400,245,39,35);

strokeWeight(6);
stroke(#B7972E);
line(80,410,325,520);

strokeWeight(3);
stroke(0);
line(255,350,345,350);

noFill();
arc(250,92,90,90,0,HALF_PI);

noFill();
arc(255,92,95,100,0,HALF_PI);

noFill();
arc(260,92,100,110,0,HALF_PI);

fill(#FFE68B);
stroke(#FFE68B);
triangle(300,220,260,320,310,310);

stroke(#FFFBCE);
fill(#FFFBCE);
ellipse(181,340,145,130);

stroke(#FFFBCE);
fill(#FFFBCE);
ellipse(419,340,145,130);

fill(#363636);
stroke(#363636);
ellipse(198,248,23,20);

fill(#363636);
stroke(#363636);
ellipse(397,248,23,20);


strokeWeight(6);
stroke(#B7972E);
line(80,410,325,520);

strokeWeight(3);
stroke(0);
line(265,350,250,600);
line(270,350,255,625);
line(278,350,265,600);
line(285,350,275,500);
line(325,350,328,400);

strokeWeight(6);
stroke(#B7972E);
line(90,400,340,500);

}

Parlamento Ucraniano

srdhtgsGrupo composto por: Gonçalo Santos e Guilherme Curado

Link do ficheiro para download

import processing.video.*;

int xPos;
int yPos;
int speed=1;
int xDir=1;
int yDir=1;
int score=0;
int lives=5;
boolean lost=false;
PImage back;
PImage ramo;
PImage ramoto;

Movie movie;

void setup()
{
  size (600,400);
  smooth(2);
  xPos=width/2;
  fill(255);
  textSize(30);
  ramo = loadImage ("ramo.png");
  ramoto = loadImage ("ramoto.jpg");
  rectMode (CENTER);
  
  movie = new Movie(this, "vid.mp4");
  movie.loop();
  
}

void draw()
{
  
  //background (0);

  image(movie, 0, 0, width, height);
  
  image (ramo, xPos, yPos);
  xPos=xPos+(speed*xDir);
  if (xPos > width-185 || xPos height-100 || yPos<-15)
  {
    yDir=-yDir;
  }
  text("score = "+score, 30, 30);
  text("lives = "+lives, width-160, 30);
  if (lives<=0)
  {
    pushMatrix();
    image (ramoto, 0, 0,600,400);
    popMatrix();
    noLoop(); 
    lost=true;
    textSize(30);
  }
}

void mousePressed()
{
  if (dist(mouseX, mouseY, xPos, yPos)<=198 )
  {
    score=score+speed;
    speed=speed+1;
  } else
  {
    if (speed<1)
    {
      speed=speed-1;
    }
    lives=lives-1;
  }
  if (lost==true)
  {
    speed=1;
    lives=5;
    score=0;
    xPos=width/2;
    xDir=1;
    yPos= height/2;
    yDir=1;
    lost=false;
    loop();
  }
}

void movieEvent(Movie m) {
  m.read();
}

Link da inspiração para o tema.

Link de código base.

Jumping Game

Untitled

Este jogo foi inspirado pelo exemplo dado para o trabalho.
Um jogo relativamente simples de saltar obstáculos.
Realizei o meu trabalho individualmente.
Para saltar a tecla de comando é o ‘Spacebar’

// Player Variables
int playerRadius = 20*2;
color playerColor = color(255, 204, 0);
int player_X = 40;
int player_Y;
int playerSpeed = 200;
int player_Y_Pos;

// If player is touching the ground
boolean onGround = true;

// Gravity
int gravity = 5;

// Enemy Variables
int enemyWidth = 30;
color enemyColor = color(255, 0, 0);
int enemy_X;
int enemy_Y;
float enemySpeed;
float maxSpeed = 8;
float minSpeed = 2;

// Hit Counter
int hitCount = 0;
/////////////////////////////////////////////////////////////
// Executes when the program begins
void setup(){
   // Tells the size of the window (x,y)
  size(640,360);
  
  // Removes the outlines (only solid colors)
  noStroke();
  
  // It will place the player at the bottom of the screen minus the player's height
  player_Y = player_Y_Pos = height - playerRadius /2;
  
  // Places the enemy (Watch out! D: )
  ResetEnemy();
}
/////////////////////////////////////////////////////////////

// Is executed until the program stops
void draw(){
  // Applies a background color to the window (R,G,B) or (greyscale)
  background(0);
  
  // Defines the Player's Color Scheme
  fill(playerColor);
  
  // Verifys if the player is not touching the ground
  if(!onGround){
    
    // Makes the gravity pull the player
    player_Y += gravity;
    
    // Checks if the player has reached the ground
    if(player_Y >= player_Y_Pos){
      // Signals the player has touched the ground
      onGround = true;
    
    }
  
  }
  else{
    // Places the player on the start position
    player_Y = player_Y_Pos;
  }

  // Draws an ellipse (x, y, width, height)
  ellipse(player_X, player_Y, playerRadius, playerRadius);
  
  // Moves the enemy (Like Jaeger)
  enemy_X -= enemySpeed;
  
  // Checks if the enemy is colliding with the player
  if(abs(player_X - enemy_X) <= (playerRadius + enemyWidth) /2 && 
     abs(player_Y - enemy_Y) <= (playerRadius + enemyWidth) /2 ){
       
       // Increments the hit counter
       hitCount ++;
       
       // Resets the enemy
       ResetEnemy();
  }
  
  // Writes the hit count
  fill(255);
  text("Hits: " + hitCount, 10, 30);
  
  // Checks if the enemy left the screen
  if(enemy_X <= - enemyWidth){
    
   // Resets the enemy
      ResetEnemy();
    
  }
  
  // Enemy Color
  fill(enemyColor);
  
  // Draws a rectangle (x, y, width, height)
  rect(enemy_X, enemy_Y, enemyWidth, enemyWidth);
}
/////////////////////////////////////////////////////////////
// It will detect the player's input
void keyPressed(){

  // It will verify if the key pressed is A
  /*if (key == 'a'|| key == 'A') {
    println(true);
  }*/
  // Checks if the spacebar is being pressed and the player is still touching the ground
  if(keyCode==32 && onGround){
    
    // Signals the player has jumped
    onGround = false;
    
    // Moves the player up :D
    player_Y -= playerSpeed;
  }

}

/////////////////////////////////////////////////////////////
// Resets the enemies position
void ResetEnemy(){
  // Places the enemy on the right side of the screen
  enemy_X = width + enemyWidth;
  
  // Places the enemy at the bottom of the screen (Because he's a meany)
  enemy_Y = height - enemyWidth;
  
  // Picks a random speed
  enemySpeed = random(minSpeed, maxSpeed);
}

Interacção – Bone, Catch!

Exercício de interacção criado por mim e pelo Diogo. O fundo vai mudando de cores aleatoriamente, o jogador controla o osso e tem de apanhar os cães, o contrário do habitual, em que um cão apanha os ossos.

Transferir ficheiros

 

//fundo
float R=125;
float centerR=125;
float a=PI/2;
float a1=PI;
float a2=3*PI/2;
float pathR=125;
float pathG=125;
float G=125;
float centerG=125;
float pathB=125;
float B=125;
float centerB=125;

int gameScore= 0;

float osso_x;
float osso_y;
float osso_vx;
float osso_vy;
float osso_width;
float osso_height;
boolean osso_hit;

//mia
float mia_x;
float mia_y;
float mia_vx;
float mia_vy;
float mia_width;
float mia_height;

//kee
float kee_x;
float kee_y;
float kee_vx;
float kee_vy;
float kee_width;
float kee_height;

int hit = 0;

PImage mia_img;
PImage osso_img;
PImage patos_img;
PImage kee_img;

float collision_radius;
int background_hit;

void setup() {
size (500,500);

gameScore = 0;

mia_img = loadImage ("mia.png");
kee_img = loadImage ("kee.png");
osso_img = loadImage ("osso.png");
patos_img = loadImage ("patos.jpg");
osso_width = 100;
osso_height = 50;
osso_x = width / 2;
osso_y = height - osso_height;
osso_vx = 0;
osso_vy = 0;

mia_width = 100;
mia_height = 100;
mia_x = floor (random (0, width));
mia_y = 0;
mia_vx = 0;
mia_vy = 5;

kee_width = 100;
kee_height = 100;
kee_x = floor (random (0, width));
kee_y = 0;
kee_vx = 0;
kee_vy = 5;

collision_radius = 50;

background_hit = 0;

rectMode(CENTER);
}

void draw() {

if (keyPressed) {
if (key == 'a') {
osso_vx = - 5;
}
else if (key == 'd') {
osso_vx = 5;
}
}

osso_x = constrain(osso_x + osso_vx, 0, 450);

mia_y = mia_y + mia_vy;
if (mia_y > height) {
mia_x = floor (random(0, width));
mia_y = 0;
}

kee_y = kee_y + kee_vy;
if (kee_y > height) {
kee_x = floor (random(0, width));
kee_y = 0;
}

osso_hit = false;
if (dist (osso_x, osso_y, mia_x, mia_y) < collision_radius){
osso_hit = true;
gameScore += 10;
background_hit = 3;
mia_x = floor (random(0, width));
mia_y = 0;

}
if (dist (osso_x, osso_y, kee_x, kee_y) < collision_radius){
osso_hit = true;
gameScore += 20;
background_hit = 3;
kee_x = floor (random(0, width));
kee_y = 0;
}

if (background_hit > 0) {
imageMode(CORNER);
image (patos_img, 0,0, 500, 500);
background_hit = background_hit - 1;
}
else {
background (pathR,pathG,pathB);
pathR=centerR+R*sin(a);
a=a+.03;

pathG=centerG+G*sin(a1);
a1=a1+.03;

pathB=centerB+B*sin(a2);
a2=a2+.03;
}

imageMode(CENTER);
fill (200, 0, 0);
image (osso_img, osso_x, osso_y, osso_width, osso_height);

fill (0, 200, 0);
image (mia_img,mia_x, mia_y, mia_width, mia_height);

fill (0, 200, 0);
image (kee_img,kee_x, kee_y, kee_width, kee_height);

fill (0);
text("SCORE:"+(nf(gameScore,3)),225,height/10);

}

 

 

 

 

 

Fishbone Catcher

O nosso* jogo, Fishbone Catcher é um jogo simples, praticamente feito apenas com o código dado, como o nome indica, o pretendido é apanharmos as espinhas de peixe. Para dificultar um pouco a interação, inserimos um fundo com pirilampos e pirilampos no próprio jogo, ao apanharmos o pirilampo, cria uma “colisão”. Ainda inserimos uma animação aleatória de pontos brancos como fundo para confundir.

Pretendemos melhorar o nosso jogo, com início, regras, níveis, condições, pontuação e tempo.

(em processo, mas não terminado e realizado como pretendido a tempo da apresentação)

*Filipa Fernandes e Madalena Correia

 

interação0
Início do jogo (melhorado brevemente)
interação1
Apanhar as espinhas de peixe e não os pirilampos.

float x=0;
float y=0;
float Player_x;
float Player_y;
float Player_vx;
float Player_vy;
float Player_width;
float Player_height;
boolean Player_hit;

float Pirilampo_x;
float Pirilampo_y;
float Pirilampo_vx;
float Pirilampo_vy;
float Pirilampo_width;
float Pirilampo_height;
boolean Pirilampo_hit;

float Espinha_x;
float Espinha_y;
float Espinha_vx;
float Espinha_vy;
float Espinha_width;
float Espinha_height;

float collision_radius;

PImage gato;
PImage espinha;
PImage fundo;
PImage titulo;
PImage youloose;
PImage over;
PImage again;
PImage pirilampo;
int contador =0;

void setup() {
  size (500,500);
  
  gato = loadImage("gato.png");
  espinha = loadImage("espinha.png");
  fundo = loadImage("pirilampos.jpg");
  titulo= loadImage("titulo.png");
  pirilampo=loadImage("Pirilampo.png"); 
  
  Player_width =180;
  Player_height = 130;
  Player_x= width/2;
  Player_y = height - Player_height;
  Player_vx = 0;
  Player_vy = 0;
  
 Pirilampo_width = 50;
  Pirilampo_height = 30;
  Pirilampo_x = floor (random (0, width));
  Pirilampo_y= 0;
  Pirilampo_vx = 0;
  Pirilampo_vy = 5;
  
  Espinha_width=40;
  Espinha_height=60;
  Espinha_x= floor(random(0,width));
  Espinha_y=0;
  Espinha_vx=0;
  Espinha_vy=5;
  
  collision_radius = 60;
  
  rectMode(CENTER);
}

void draw() {
  
  if (keyPressed) {
    if(key=='1'){
      Player_vx=-5;
    }
    else if (key=='3'){
      Player_vx=5;
    }
  }
  
  Player_x = constrain(Player_x + Player_vx, 0,width);
  
  Espinha_y=Espinha_y+Espinha_vy;
  if(Espinha_y>height){
    Espinha_x=floor(random(0,width));
    Espinha_y=0;
    Espinha_vy=random(6,6);
  }
  Pirilampo_y = Pirilampo_y + Pirilampo_vy;
  if (Pirilampo_y > height) {
    Pirilampo_x = floor (random(0, width));
    Pirilampo_y = 0;
    Pirilampo_vy=random(5,5);
  }

  Player_hit = false;

  if (dist (Player_x, Player_y,Pirilampo_x, Pirilampo_y) < collision_radius) {
      Player_hit=true;
      Pirilampo_x=floor(random(0,width));
      Pirilampo_y=0;
      Pirilampo_vy=random(5,5);
  }
    if (Player_hit) {
    background (255,0,0);
  }
  
  else {
    background(fundo);
  }
  
 if(dist(Player_x,Player_y, Espinha_x,Espinha_y)<collision_radius){
   Player_hit=true;
   Espinha_x=floor(random(0,width));
   Espinha_y=0;
   Espinha_vy=random(5,5);
 }
 
  fill (200, 0, 0);
  image (gato,Player_x,Player_y,Player_width, Player_height);

  fill (0, 200, 0);
  image (pirilampo,Pirilampo_x, Pirilampo_y, Pirilampo_width, Pirilampo_height);
  
  image(espinha, Espinha_x,Espinha_y,Espinha_width,Espinha_height);
  
   strokeWeight(5);
  stroke(255);
  point(x,y);
  x=random(width);
  y=random(height);
   image (titulo,3,-25);
   
 
}

Espectro da Paranóia(rgb);

espectrodaparanoia

parannnnnioa
::grupo::

Catarina Santos
Joana Borges
Joana Pimentel



::keys::

r: adicionar vermelho
g: adicionar verde
b: adicionar azul
e: subtrair vermelho
f: subtrair verde
v: subtrair azul
+: maior velocidade
-: menor velocidade
rato: girar a forma 



::referências::
RGB Cube
Música


::código::
import ddf.minim.*;
import ddf.minim.analysis.*;
import ddf.minim.effects.*;
import ddf.minim.signals.*;
import ddf.minim.spi.*;
import ddf.minim.ugens.*;

Minim minim; 
AudioPlayer song; 
BeatDetect beat;


float xmag, ymag = 0;
float newXmag, newYmag = 0; 

int x[]; // posicao da coordenada x
int y[]; // posicao da coordenada y
int dh[]; // deslocamento horizontal
int dv[]; // deslocamento vertical
int c[]; // tamanho da bola
int t[]; // transparencia
int r;
int g;
int b; // cores rgb
int h; // valor zero para parar de adicionar cor
int ad; // valor adicionado
int adv; // valor adicionado na velocidade
int n; // numero de bolas
int passou; // confirma se a verificacao ja passou
int o = 0;

void setup() {
  size(599, 423,P3D);
  background (255);
  frameRate(24);
  stroke(1);
  smooth();

  
  
  
  
  
  minim = new Minim(this); 
  song = minim.loadFile("Death Grips - Lost Boys.mp3"); 
  song.play();
  loop();
  
  

  n = 150;
  r = 255;
  g = 255;
  b = 255;
  h = 0;
  ad= 5;
  adv= 0;
  x = new int[n];
  y = new int[n];
  dh = new int[n];
  dv = new int[n];
  c = new int[n];
  t = new int[n];

  for (int i=0; i<n; ++i) {     x[i]=int(random(100 ,423));     y[i]=int(random(100 ,423)); // onde as bolas nascem     c[i]=int(random(10,100)); // raio dos circulos      t[i]=int(random(800,100)); // tranparencia     dh[i]=int(random(1,10));     dv[i]=int(random(1,10)); // velocidade de deslocamento   }   } void draw() {                  translate(width/2,height/2,-300);   rotateY(radians(o));   rotateX(radians(45));   box(100,100,100);   o=o+1;        newXmag = mouseX/float(width) * TWO_PI;   newYmag = mouseY/float(height) * TWO_PI;      float diff = xmag-newXmag;   if (abs(diff) >  0.01) { 
    xmag -= diff/4.0; 
  }
  
  diff = ymag-newYmag;
  if (abs(diff) >  0.01) { 
    ymag -= diff/4.0; 
  }
  
  rotateX(-ymag); 
  rotateY(-xmag); 
  
  passou=0;
  
  for (int i=0; i<n; ++i){
  
  if (x[i] <= c[i]/2 || x[i] >= 599-c[i]/2){
   dh[i]=-dh[i];
   x[i]=x[i]+dh[i];  }
  else {
   x[i]=x[i]+dh[i];  } //deslocamento e rebatimento horizontal
   
  if (y[i] <= c[i]/2 || y[i] >= 599-c[i]/2){
   dv[i]=-dv[i];
   y[i]=y[i]+dv[i];  }
  else {
   y[i]=y[i]+dv[i];  } //deslocamento e rebatimento vertical
   
  if (passou==0){ 
    keyReleased();
    passou=1;} // para testar se ja passou
  key='h'; // parar de adicionar cor

  fill (r,g,b,t[i]);
  
  if (dh[i] > 0){
  dh[i]=dh[i]+adv;}
  if (dv[i] > 0){
  dh[i]=dh[i]-adv;}
  if (dh[i] < 0){
  dv[i]=dv[i]+adv;}
  if (dv[i] < 0){
  dv[i]=dv[i]-adv;} // verifica o sentido do deslocamento para que, apertanto +,
 // adicionar velocidade mesmo se ela for negativa, e vice versa.
 
  
  box(x[i],y[i], c[i]); // desenho da bola
 }
 
adv=0; 

}
  
  void keyReleased() {
    
    if (key == 'r' || key == 'R') {
      fill(r,g-=ad,b-=ad);
    }
    if (key == 'g' || key == 'G') {
      fill(r-=ad,g,b-=ad);
    }
    if (key == 'b' || key == 'B') {
      fill(r-=ad,g-=ad,b);
    }
    
    if (key == 'e' || key == 'E') {
      fill(r,g+=ad,b+=ad);
    }
    if (key == 'f' || key == 'F') {
      fill(r+=ad,g,b+=ad);
    }
    if (key == 'v' || key == 'V') {
      fill(r+=ad,g+=ad,b);
    }
    
    if (key == '+') {
     adv=2;
    }
    
    if (key == '-') {
     adv=-2;
    }
    

  PImage img;
img = loadImage("1210171251533245.jpg");
image(img, 100,-137);

 PImage imge;
imge = loadImage("1210171251533245.jpg");
image(imge, 999,0);

 PImage image;
image = loadImage("1210171251533245.jpg");
image(image, 1900,0);


}


Animação

float x=0;
float y=0;

void setup() {
PImage imagem= loadImage("imagem.jpg");
image(imagem,10,10,490,490);
size(510,510);
frameRate(200);
x=width/2;
y=height/2;
}
void draw(){
  strokeWeight(5);
  stroke(255);
  point(x,y);
  x=random(width);
  y=random(height);
 float nx=x+random(-10,10);
 float ny=y+random(-10,10);
 nx=constrain(nx,0,width);
 ny=constrain(ny,0,height);
 
if(nx<0){nx=0;} if(nx>width){nx=width;}
if(ny<0){ny=0;} if(ny>width){ny=width;}
 
strokeWeight(1);
nx=abs(nx) % width;
ny=abs(ny)% height;
line(x,y,nx,ny);
 
}

Interação e Animação

interaçao

int px = 300;
int py = 1000;

int r1x = 50;
int r1y = 100;
int r1w = 150;
int r1h = 150;
int dx = 2;

int r2x = 100;
int r2y = 350;
int r2w = 150;
int r2h = 150;
int bx = 4;

int r3x = 300;
int r3y = 600;
int r3w = 150;
int r3h = 150;
int cx = 3;

int ex = -5;
int q = 5;
int n = -5;
int m = +5;

int r4x = 0;
int r4y = 850;
int r4w = 300;
int r4h = 50;
int sa = 7;

void setup() {
size(700, 1100);
}

void draw() {

background(0);

fill(#FFA41A);

rect(r1x, r1y, r1w, r1h);
r1x = r1x + dx;
rect(r2x, r2y, r2w, r2h);
r2x = r2x + bx;

rect(r3x, r3y, r3w, r3h);
r3x = r3x + cx;

rect(r4x, r4y, r4w, r4h);
r4x = r4x + sa;

fill(255);
ellipse(px,py,30,30);

//ellipse

if(keyPressed) {
if (key == 'a') {
px = px + ex;

}
}

if(keyPressed) {
if (key == 'd') {
px = px + q;

}
}

if(keyPressed) {
if (key == 'w') {
py = py + n;
}
}

if(keyPressed) {
if (key == 's') {
py = py + m;
}
}

if(py < 30) {
py = 1000;
}

if(py < 30) {
dx = 15;
}

//quadrado 1

if(r1x + r1w > width) {
dx = -2;
}
else if (r1x < 0) {
dx = 2;
}

//quadrado 2

if(r2x + r2w > width) {
bx = -4;
}

else if (r2x < 0) {
bx = 4;
}

//quadrado 3

if(r3x + r3w > width) {
cx = -3;
}

else if (r3x < 0) {
cx = 3;
}

//quadrado 4

if(r4x + r4w > width) {
sa = -7;
}

else if (r4x < 0) {
sa = 7;
}

boolean collision = false;

if (px > r1x && px < r1x + r1w) {
if (py > r1y && py < r1y + r1h) {
collision = true;
}
}

if (px > r2x && px < r2x + r2w) {
if (py > r2y && py < r2y + r2h) {
collision = true;
}
}

if (px > r3x && px < r3x + r3w) {
if (py > r2y && py < r3y + r3h) {
collision = true;
}
}

if (px > r4x && px < r4x + r4w) {
if (py > r4y && py < r4y + r4h) {
collision = true;
}
}

if (collision == true) {
px = 300;
py = 1000;
}
}

Samuel e João

Bananada

Sílvia Pinho e Sara Baptista

//base
float Player_x;
float Player_y;
float Player_vx;
float Player_vy;
float Player_width;
float Player_height;
boolean Player_hit;

float Block_x;
float Block_y;
float Block_vx;
float Block_vy;
float Block_width;
float Block_height;

float collision_radius;

//font
PFont font;

//imagens
PImage pora;
PImage bananada;
PImage bg;

//tempo e pontuação
int timei = 2000;
int pont = 0;
int time = timei;
int tt=0;

void setup() {
  size (500,500);
  
  //imagens
  pora = loadImage("PoraCarinhosa.png");
  bananada = loadImage("bananada.png");
  font = createFont("verdana.ttf",20);
  bg = loadImage("fundinhozito.png");
  
  //boneco
  Player_width = 100;
  Player_height = 100;
  Player_x = width / 2;
  Player_y = height - Player_height;
  Player_vx = 0;
  Player_vy = 0;

  //bananas
  Block_width = 50;
  Block_height = 50;
  Block_x = floor (random (0, width));
  Block_y = 0;
  Block_vx = 0;
  Block_vy = 5;
  
  collision_radius = 50;
  
  rectMode(CENTER);
}

void draw() {
  
  //fundo
  background(bg);
  
  //tempo
  time = time-1;
  tt = time/6;
  
  //controlos
  if (keyPressed) {
    if (keyCode == LEFT) {
      Player_vx = - 5;  
    }
    else if (keyCode == RIGHT) {
      Player_vx = 5;
    }
  }
  
  //boneco
  Player_x = constrain(Player_x + Player_vx, 0, width);
  
  //bananas
  Block_y = Block_y + Block_vy;
  if (Block_y > height) {
    Block_x = floor (random(0, width));
    Block_y = 0;
  }
  
  if (dist (Player_x, Player_y, Block_x, Block_y) < collision_radius) {     if(tt >0){
    Player_hit = true;
    pont = pont+1;}
  }
  else {
    Player_hit = false;
  }
  
 
  if (Player_hit) {
    background (0,255,255);
  }
  else {
    background (bg);
  }
  
  //durante
  if(tt >0){
  fill (255, 10, 10);
  image (pora, Player_x, Player_y, Player_width, Player_height);

  fill (0, 200, 0);
  image (bananada, Block_x, Block_y, Block_width, Block_height);
  
  fill(#024D2D);
  textFont(font);
  text("Pontuação:", 350, 20);
  text(pont, 470, 20);
  text("Tempo:",0,20);
  text(tt, 100, 20);
  }
  
  //fim do jogo
   if (tt <= 0){
   fill(#024D2D);
   textFont(font);
   text("Fim do tempo!", 170, 220);
   text("Pontuação:", 170, 250);
   text(pont, 290, 250);
   text("Tempo:",0,20);
   text(tt, 100, 20);
    time = 0;
    
    //restart
    if (keyPressed) {
    if (key == 'r'){
     time = timei;
     pont = 0;
  }
  }
  }
}

Space Invaders Demo

Neste trabalho tentei explorar um tipo de interação direta com o programa processing e então fazer uma pequena demo do jogo space invaders de 1978.

 

space invaders 3.png

 

space invaders 2.png

space invaders.png

 

// x and y posição do ponto
float x = 250;
float y = 480;

// x and y posição da bala
float bullet_x = 250;
float bullet_y = 480;

void setup()
{
size (500,500);
ellipseMode(CENTER);
rectMode(CENTER);
smooth();
}

void draw()
{
background (0);

// fazer a bola saltar mais acima
bullet_y = bullet_y - 5;

// desenhar bala
fill(255,0,0);
rect(bullet_x, bullet_y, 10, 10);

// desenhar ponto
fill(255);
ellipse (x,y, 20, 20);
}

void keyPressed()
{
// a key pressed - go left
if (key == 'a')
{
x = x - 5;
}
// d key pressed = go right
if (key == 'd')
{
x = x + 5;
}

// disparo da bala
if (key == 'p')
{
bullet_y = y;
bullet_x = x;
}
}

 

 

 

 

 

 

Pacman’s Revenge

Exercício feito por Mikhail Sobolev e Eleutério Parreira.

Imaginamos o que iria acontecer se o Pacman se fartasse de fugir dos fantasmas, e foi assim, que surgiu este jogo.

Música utilizada

Arquivo com os ficheiros do jogo

menu_scrnjogo_scrn

pacmans_revenge.pde

import ddf.minim.*;
import ddf.minim.analysis.*;
import ddf.minim.effects.*;
import ddf.minim.signals.*;
import ddf.minim.spi.*;
import ddf.minim.ugens.*;


//import processing.sound.*;

//SoundFile musica;
Minim minim;
AudioPlayer musica;
boolean game_over = false;
boolean disparado = false;
boolean disparo_fora = true;
ArrayList inimigos;
Disparo disparos;
float jogador_y;
int tempo;
int tempo_lvl = 0;
int estado = 0;
PImage transparente;
PImage pacman;
PImage fundo;
PImage inimigo_1;
PImage inimigo_2;
PImage inimigo_3;
PImage inimigo_4;
PImage menu;
PImage fim;
int score = 0;
PFont fonte;
int pos_fundo = 0;
int dificuldade;

void setup() {
  size(700, 400);
  minim = new Minim(this);
  musica = minim.loadFile("SOAD_8bit.mp3");
  musica.play();
  inimigos = new ArrayList();
  jogador_y = height / 2;
  disparos = new Disparo();
  transparente = loadImage("white.jpg");
  pacman = loadImage("pacman_icon.png");
  fundo = loadImage("fundo_pr2.jpg");
  inimigo_1 = loadImage("blinky.png");
  inimigo_2 = loadImage("clyde.png");
  inimigo_3 = loadImage("inky.png");
  inimigo_4 = loadImage("pinky.png");
  menu = loadImage("menu.jpg");
  fim = loadImage("game_over.jpg");
  fonte = createFont("fonte_letra.ttf", 60);
  //musica = new SoundFile(this, "SOAD_8bit.mp3");
  textFont(fonte);
}

void draw() {
  if (estado == 0) {
    imageMode(CORNER);
    image(menu, 0, 0);
    fill(255);
    text("select difficulty to start:", 211, 180);
    tempo_lvl = millis();
    if ((mouseX > 235) && (mouseX < 465)) { if ((mouseY > 219) && (mouseY < 257)) { fill(255, 30); noStroke(); rectMode(CORNERS); rect(235, 219, 465, 257); } else if ((mouseY > 277) && (mouseY < 315)) { fill(255, 30); noStroke(); rectMode(CORNERS); rect(235, 277, 465, 315); } else if ((mouseY > 335) && (mouseY < 373)) {
        fill(255, 30);
        noStroke();
        rectMode(CORNERS);
        rect(235, 335, 465, 373);
      }
    }
  }
  else if (estado == 1) {
    //musica.play();
    imageMode(CORNER);
    image(fundo, pos_fundo, 0);
    image(fundo, pos_fundo + fundo.width, 0);
    pos_fundo -= 20;
    if (pos_fundo == -1500) {
      pos_fundo = 0;
    }
    image(pacman, 20, jogador_y);
    if (disparado == true) {
      disparos.dis_mov();
    }
    tempo = millis();
    if ((tempo % dificuldade) < 16) {
      inimigos.add(new Inimigo(int(random(1, 5))));
    }
    for (int i = 0; i < inimigos.size(); i++) {
      Inimigo temp = inimigos.get(i);
      temp.ini_mov();
      if (dist(disparos.dis_x, disparos.dis_y, temp.ini_x, temp.ini_y) < 20) { disparado = false; disparo_fora = true; inimigos.remove(i); disparos = new Disparo(); score += 10; } if (game_over == true) { estado = 3; } } fill(255); text("SCORE:", 8, 25); text(score, 90, 25); } else if (estado == 2) { transparente.resize(width, height); tint(255, 126); imageMode(CORNER); image(transparente, 0, 0); text("GAME PAUSED", 268, height/2); noLoop(); } else if (estado == 3) { imageMode(CORNER); image(fim, 0, 0); if ((mouseX > 235) && (mouseX < 465)) { if ((mouseY > 202) && (mouseY < 240)) { fill(255, 30); noStroke(); rectMode(CORNERS); rect(235, 202, 465, 240); } else if ((mouseY > 260) && (mouseY < 298)) {
        fill(255, 30);
        noStroke();
        rectMode(CORNERS);
        rect(235, 260, 465, 298);
      }
    }
  }
}

classes.pde

class Inimigo {
  float ini_x;
  float ini_y;
  int cor;
  
  Inimigo(int c){
    ini_x = width + 15;
    ini_y = random(30, height - 20);
    cor = c;
  }
  
  void ini_mov(){
    ini_x--;
    if (ini_x < 5) { game_over = true; } imageMode(CENTER); if (cor == 1) { image(inimigo_1, ini_x, ini_y); } else if (cor == 2) { image(inimigo_2, ini_x, ini_y); } else if (cor == 3) { image(inimigo_3, ini_x, ini_y); } else if (cor == 4) { image(inimigo_4, ini_x, ini_y); } } } class Disparo { float dis_x; float dis_y; Disparo(){ dis_x = 35; dis_y = jogador_y + 15; } void dis_mov(){ dis_x += 10; if (dis_x > (width - 5)) {
      disparo_fora = true;
    }
    fill(255);
    noStroke();
    rectMode(CENTER);
    rect(dis_x, dis_y, 6, 6);
  }
}

functions.pde

void keyPressed() {
  if (estado == 1) {
    if (key == CODED) {
      if ((keyCode == UP) && (jogador_y > 30)) {
        jogador_y -= 10;
      }
      else if ((keyCode == DOWN) && (jogador_y < (height - 40))) { jogador_y += 10; } } else if ((key == ' ') && (disparo_fora == true)){ disparado = true; disparos = new Disparo(); disparo_fora = false; } else if ((key == 'p') || (key == 'P')){ estado = 2; } } else if (estado == 2) { if ((key == 'p') || (key == 'P')){ noTint(); loop(); estado = 1; } } } void mousePressed() { if (estado == 0) { if ((mouseX > 235) && (mouseX < 465)) { if ((mouseY > 219) && (mouseY < 257)) { dificuldade = 2000; estado = 1; } else if ((mouseY > 277) && (mouseY < 315)) { dificuldade = 1000; estado = 1; } else if ((mouseY > 335) && (mouseY < 373)) { dificuldade = 500; estado = 1; } } } else if (estado == 3) { if ((mouseX > 235) && (mouseX < 465)) { if ((mouseY > 202) && (mouseY < 240)) { limpar_tudo(); estado = 1; } else if ((mouseY > 260) && (mouseY < 298)) { limpar_tudo(); estado = 0; } } } } void limpar_tudo() { for (int i = inimigos.size() - 1; i >= 0; i--) {
    inimigos.remove(i);
  }
  pos_fundo = 0;
  score = 0;
  jogador_y = height / 2;
  game_over = false;
  disparado = false;
  disparo_fora = true;
}

Interação – Flying Burguer

Juntamente com a minha colega Nicolina, fizemos um jogo baseado num código encontrado na internet, sofrendo depois várias alterações.

print          prinht 2

 

int xPos; //Posição
int yPos;
int speed=1; //Rapidez
int xDir=1; //direção
int score=0; //pontuação inicial
int lives=10; //vidas
boolean lost=false;

PImage background;
PImage burger;

void setup()
{
size (400,400);
xPos=width/2;
yPos = height/2;
fill(255, 255, 255);
textSize(19);

background = loadImage("nuvens.jpg");
burger = loadImage("burger.png");
}

void draw()
{
background (#C9E7EA);
imageMode(CORNER);
image(background, 0, 0);
imageMode(CENTER);
image(burger,xPos, yPos,200,200);
xPos=xPos+(speed*xDir);
if (xPos < 0 || xPos > width - 100)
{
xDir=-xDir;
}
text("score = "+score,20,20);
text("lives = "+lives,width-120,20);
if (lives<=0)
{
textSize(20);
text("Click to Restart", 125,100);
noLoop();
lost=true;
textSize(20);
}
}

void mousePressed()
{
if (dist(mouseX, mouseY, xPos,yPos)<=100)
{
score=score+1;
speed=speed+1;
}
else
{
if (speed<1)
{
speed=speed-1;
}
lives=lives-1;
}
if (lost==true)
{
speed=1;
lives=10;
score=0;
xPos=width/2;
xDir=1;
lost=false;
loop();
}
}

Football Pong

Este trabalho foi realizado por mim e pela Constança, é inspirado no jogo Pong, e tentamos recriar o jogo no Processing adicionando e tema do futebol.

Deixo aqui e aqui dois links nos quais nos baseamos para a criar o nosso jogo.

bandicam 2015-12-16 12-02-58-432.jpg

bandicam 2015-12-16 12-03-19-734.jpg

bandicam 2015-12-16 12-03-22-890.jpg

PImage startscreen;
int stage;

int x, y, w, h, speedX, speedY;

int jogadorXL,jogadorYL,jogadorH,jogadorW, jogadorS;
int jogadorXR,jogadorYR;

boolean upL, downL;
boolean upR, downR;

color colorL = color(0,0,255);
color colorR = color(255,0,0);
color preto = color(0);

int scoreL = 0;
int scoreR = 0;

int winscore = 5;



void setup() {
  background(17,131,16); 
  stage = 1;
   size(700,500);
  startscreen = loadImage("GameMenu.png");
  image(startscreen, 0, 0,700,500);
  
  
  
  x = width/2;  
  y = height/2; 
  w = 40; 
  h = 40; 
  speedX = 6;
  speedY = 3;
  
  textSize(40);
  textAlign(CENTER,CENTER);
  rectMode(CENTER);
  jogadorXL = 40;
  jogadorYL = height/2;
  
  
  jogadorXR = width - 40;
  jogadorYR = height/2;
  
  
  jogadorW = 30;
  jogadorH = 100;
  jogadorS = 5;
 
}

void draw(){
  
  if (stage==1){
    
    if(keyPressed == true){
    stage = 2;
    }
  }
  
  if (stage==2){
  
  frameRate(60);
  background(17,131,16); 
  strokeWeight(5); 
  stroke(250);
  line(width/2,0,width/2,500);
  noFill();
  stroke(250);
  ellipse(width/2,height/2,200,200);
  fill(250);
  stroke(250);
  ellipse(width/2,height/2,35,35);
  
  //atalhos para as funções em baixo
  bola();
  mexer_a_bola();
  voltar_na_parede();
  
  desenho_do_jogador();
  mover_jogador();
  regraJogador();
  contactJogador();
  scores();
  gameOver();
 
}
}  


void bola(){
  fill(255);
  stroke(255);
  strokeWeight(10);
  ellipse(x,y,w,h);
}

void mexer_a_bola(){
   x = x + speedX;
   y = y + speedY;
}

void voltar_na_parede (){
   if ( x > width - w/2) { 
   setup();
    speedX = -speedX;
    scoreL = scoreL + 1;
  }
  
  else if( x < 0 + w/2) {       setup();     scoreR = scoreR + 1;   }       if ( y > height - h/2){
    speedY = -speedY;
  }

   else if( y < 0 + h/2) {
    speedY = -speedY;
   }
}

void desenho_do_jogador(){
  fill(0,0,255);
  stroke(0,0,255);
  rect(jogadorXL, jogadorYL, jogadorW,jogadorH);
  fill(255,0,0);
  stroke(255,0,0);
  rect(jogadorXR, jogadorYR, jogadorW,jogadorH);
}

void mover_jogador(){
  if(upL){
    jogadorYL = jogadorYL - jogadorS;
  }
  if(downL){
    jogadorYL = jogadorYL + jogadorS;
  }
   if(upR){
    jogadorYR = jogadorYR - jogadorS;
  }
  if(downR){
    jogadorYR = jogadorYR + jogadorS;
  }
}



void regraJogador(){
  if(jogadorYL - jogadorH/2 < 0){     jogadorYL = jogadorYL + jogadorS;   }   if(jogadorYL + jogadorH/2 > 500){
    jogadorYL = jogadorYL - jogadorS;
  }
  if(jogadorYR - jogadorH/2 < 0){     jogadorYR = jogadorYR + jogadorS;   }   if(jogadorYR + jogadorH/2 > 500){
    jogadorYR = jogadorYR - jogadorS;
  }
}

void contactJogador(){
  if(x - w/2 < jogadorXL + jogadorW/2 && y - h/2 < jogadorYL + jogadorH/2 && y + h/2 > jogadorYL - jogadorH/2){
   if(speedX < 0){     speedX = - speedX;    }   }   else if(x + w/2 > jogadorXR - jogadorW/2 && y - h/2 < jogadorYR + jogadorH/2 && y + h/2 > jogadorYR - jogadorH/2){
    if(speedX > 0){
    speedX = - speedX;
    }
  }
  
}

void scores(){
  fill(255);
  text(scoreL, 100,70);
  text(scoreR, width-100,70);
}
  
 void gameOver(){
    if(scoreL == winscore){
      gameOverPage("Blue Wins",colorL);
  
      
    }
    if(scoreR == winscore){
      gameOverPage("Red Wins", colorR);
  }
  }
  
  void gameOverPage(String text, color c){
    background(17,131,16); 
    strokeWeight(5); 
    stroke(250);
    line(width/2,0,width/2,500);
    noFill();
    stroke(250);
    ellipse(width/2,height/2,200,200);
    fill(250);
    stroke(250);
    ellipse(width/2,height/2,35,35);
    speedX = 0;
    speedY = 0;
    fill(preto);
    textSize(100);
    text("Game Over", width/2, height/2);
    
    
    
    textSize(40);
    fill(c);
    text(text, width/2, height/3 - 60);
    text("Press a key then click to play again", width/2, height/3 + 240);
    if(mousePressed){
     
      scoreR = 0;
      scoreL = 0;
      speedX = 6;
      speedY = 4;
    }
  }
  
  
 


void keyPressed(){
  if(key == 'w' || key == 'W'){
    upL = true;
  }   
   if(key == 's' || key == 'S'){
    downL = true;
   }
     if(keyCode == UP){
    upR = true;
  }   
   if(keyCode == DOWN){
    downR = true;
   }
}
void keyReleased(){
    if(key == 'w' || key == 'W'){
    upL = false;
    }  
   if(key == 's' || key == 'S'){
    downL = false;
   }
    if(keyCode == UP){
    upR = false;
    }  
   if(keyCode == DOWN){
    downR = false;
   }
}
    

1º Exercício – Processing

Esta foi a imagem que eu criei no Processing.

 

Captura de ecrã 2015-12-16, às 11.39.35

 

size(500,500);
background(100);

fill(0);
stroke(1);
strokeWeight(3);
ellipse(150,140,100,100);
fill(0);
stroke(5);
strokeWeight(3);
ellipse(350,140, 100,100);
fill(255);
ellipse(160,120,50,50);
fill(255);
ellipse(360,120,50,50);

fill(25);
noStroke();
ellipse(width/2, 300, 120, 200);

fill(214,145,145);
ellipse(100,250,70,70);
fill(214,145,145);
ellipse(390,250,70,70);