Arrays - azevedolab.net

1
© 2015 Dr. Walter F. de Azevedo Jr.
azevedolab.net
Arrays
Programa: flying_saucer0.pde
FlyingSaucer mySaucer;
float speed;
float score;
// Declares an object
// speed of flying saucer
// score
void setup() {
size(200, 480);
mySaucer = new FlyingSaucer(100, 0, 20, 20);// Initializes object
speed = 0;
}
void draw() {
background(255);
// Calls method updateY() on object mySaucer
mySaucer.updateY();
// Calls method drawFlyingSaucer() on object mySaucer
mySaucer.drawFlyingSaucer();
// Calls method gameOver() on object mySaucer
mySaucer.gameOver();
// Calls method updateScore() on object mySaucer
mySaucer.myScore();
}
void mousePressed() {
speed = speed * -0.45;
println("Your score", score);
}
www.processing.org
As primeiras linhas indicam a
definição do objeto mySaucer da
classe
FlyingSaucer() e das
variáveis globais.
Depois temos a função setup(),
onde definimos o tamanho da
tela, inicializamos o objeto
mySaucer e atribuímos valor
inicial a variável global speed.
Na função draw(), definimos a cor
de fundo e chamamos os
métodos
sobre
o
objeto
mySaucer.
Agora
temos
a
função
mousePressed(),
que
é
executada no evento do mouse
ser pressionado. Assim, ela não
fica incorporada como método e
2
sim uma função à parte.
Programa: flying_saucer0.pde
class FlyingSaucer {
float x;
float y;
float gravity;
float r;
float g;
float b;
float score_antigrav;
float maxHeight;
float cockpitX;
float cockpitY;
float saucerX;
float saucerY;
//
//
//
//
//
//
//
//
//
//
//
//
x location of flying saucer
y location of flying saucer
gravity acting on the flying saucer
intensity for red
intensity for green
intensity for blue
Initial cutoff value for antigrav
Maximum height
Cockpit length
Cockpit height
Saucer length
Saucer height
FlyingSaucer(float tempX, float tempY, float tempCockpitX, float
tempCockpitY) {
// Constructor
cockpitX = tempCockpitX;
// Initial value for cockpit
length
cockpitY = tempCockpitY;
// Initial value for cockpit
height
saucerX = cockpitX + 100.0;
// Initial value for saucer
length
saucerY = cockpitY;
// Initial value for saucer
height
x = tempX;
// Initial value for x coordinate
y = tempY;
// Initial value for y coordinate
gravity = 0.1;
// Initial value for gravity
score_antigrav = 2000;
// Initial value for
score_antigrav
maxHeight = 480;
// Initial value for maxHeight
}
www.processing.org
Na classe FlyingSaucer() as
primeiras linhas indicam as
variáveis. Em seguida definimos
o construtor da classe, onde os
valores iniciais são atribuídos a
algumas variáveis, previamente
definidas no início da classe.
Agora
temos
variáveis
temporárias na definição do
construtor, que permitem que
usemos
esta
classe
para
construirmos
discos
com
diferentes posições iniciais na
tela.
3
Programa: flying_saucer0.pde
www.processing.org
Olhando-se os detalhes do código do construtor, vemos que temos variáveis para os
valores iniciais das coordenadas x e y (tempX e tempY), bem como para valores iniciais
da largura e altura do cockpit do disco voador, variáveis tempCockpitX e tempCockpitY.
Usando-se este recurso, podemos montar diversos discos, quando inicializamos o
objeto no setup().
FlyingSaucer(float tempX, float
cockpitX = tempCockpitX;
cockpitY = tempCockpitY;
saucerX = cockpitX + 100.0;
saucerY = cockpitY;
x = tempX;
y = tempY;
gravity = 0.1;
score_antigrav = 2000;
maxHeight = 480;
}
tempY, float tempCockpitX, float tempCockpitY) {
// Initial value for cockpit length
// Initial value for cockpit height
// Initial value for saucer length
// Initial value for saucer height
// Initial value for x coordinate
// Initial value for y coordinate
// Initial value for gravity
// Initial value for score_antigrav
// Initial value for maxHeight
// Constructor
4
Programa: flying_saucer0.pde
void drawFlyingSaucer() {
// Function to display the flying saucer
noStroke();
ellipseMode(CENTER);
r = random(1, 256);
g = random(1, 256);
b = random(1, 256);
fill(color(r, g, b));
// Cockpit
ellipse(x, y, cockpitX, cockpitY);
fill(175);
// Saucer
ellipse(x, y+10, saucerX, saucerY);
}
www.processing.org
Depois temos o métodos vistos
na aula anterior.
void updateY() {
y = y + speed;
speed = speed + gravity;
}
void gameOver() {
if (y > maxHeight) {
println("Your score ", score);
println("Game Over!");
noLoop();
}
}
void myScore() {
if (y < maxHeight) {
score = score + 1;
}
// If score > score_antigrav increase height
if (score > score_antigrav ) {
println("Super antigrav!");
y = y -300;
score_antigrav = 1.05*score_antigrav + 2000;
}
}}
5
Exercício de Programação: two_flying_saucers0.pde
www.processing.org
Exercício de programação: Modifique o código do programa flying_saucer0.pde, de
forma que tenhamos dois discos voadores. Dica: Declarem dois objetos, como indicado
abaixo.
FlyingSaucer mySaucer1;
FlyingSaucer mySaucer2;
.....
// Declares first object
// Declares second object
6
Arrays
www.processing.org
Poderíamos usar o código two_flying_saucers0.py como protótipo para criamos um
código com uma invasão de discos voadores, por exemplo 100 discos na tela. Uma
forma de fazermos, não estou afirmando que devemos, seria repetirmos a declaração
de objeto 100 vezes. Imaginem como ficaria a chamada dos métodos para os 100
objetos!
FlyingSaucer mySaucer1;
FlyingSaucer mySaucer2;
FlyingSaucer mySaucer3;
.....
// Declares first object
// Declares second object
// Declares third object
7
Arrays
www.processing.org
Uma forma elegante de superarmos este problema, é por meio do uso de arrays. Vimos
em Python que arrays são variáveis indexadas, onde podemos acessar um valor
específico dentro de uma lista de valores. Em Python, usamos arrays da biblioteca
NumPy. Em Processing podemos definir arrays, como indicado abaixo. A variável
myArray é um array de inteiros.
int[] myArray;
Nome do array
Os dois colchetes indicam que é um array
Tipo do array
8
Arrays
www.processing.org
Usamos o operador “new”, para definirmos o tamanho do array, ou seja, quantos
elementos ele contém. Uma vez definido o número de elementos do array, não
podemos mudar este número.
Operador “new” significa que
estamos fazendo um novo array
Tipo do array
Tamanho do array
int[] myArray = new int [42];
Nome do array
Os dois colchetes indicam que é um array
Tipo do array
9
Arrays
www.processing.org
Para inicializamos arrays, podemos atribuir os valores, como indicado abaixo.
Lista com os valores a serem
atribuídos ao array
int[] myArray = { 1, 5, 8, 9, 4, 5 };
Nome do array
Os dois colchetes indicam que é um array
Tipo do array
10
Arrays
www.processing.org
Os valores podem ser atribuídos especificamente para um elemento do array, por
exemplo, queremos atribuir o número 9 ao quarto elemento do array, o código está
indicado abaixo.
myArray[3] = 9;
O número 3 indica o quarto elemento do array.
Começamos a contar o zero, a primeira posição
tem índice zero.
Nome do array
11
Arrays
www.processing.org
Bem, ainda não resolvemos nosso problema inicial da repetição. Se tivermos a seguinte
situação, queremos um array com 1000 elementos do tipo float, com números aleatórios
entre 0 e 10. Poderíamos fazer o seguinte:
float[] values = new float[1000];
values[0] = random(0,10);
values[1] = random(0,10);
values[2] = random(0,10);
values[3] = random(0,10);
values[4] = random(0,10);
values[5] = random(0,10);
......
12
Arrays
www.processing.org
Ou podemos usar um loop for, como indicado abaixo. Usamos values.length para
acessar uma propriedade que todo array tem, ou seja, número de elementos,
values.length retorna o número de elementos do array values, que foi definido na
primeira linha do código.
float[] values = new float[1000];
for (int i = 0; i < values.length; i + + ) {
values[i] = 0;
}
13
Programa: one_car0.pde
Car myCar1;
void setup() {
size(200, 200);
myCar1 = new Car(color(255, 0, 0), 0, 100, 2);
}
void draw() {
background(255);
myCar1.move();
myCar1.display();
}
class Car {
color c;
float xpos;
float ypos;
float xspeed;
Car(color tempC, float tempXpos, float tempYpos, float
tempXspeed) {
c = tempC;
xpos = tempXpos;
ypos = tempYpos;
xspeed = tempXspeed;
}
void display() {
stroke(0);
fill(c);
rectMode(CENTER);
rect(xpos, ypos, 20, 10);
}
void move() {
xpos = xpos + xspeed;
if (xpos > width) {
xpos = 0;
}
}
}
www.processing.org
Ao lado temos o código
one_car0.pde, que gera um
objeto da classe Car. O
construtor da classe Car tem
variáveis para a cor (tempC),
posição (tempX e tempY) e
velocidade
(tempSpeed).
Podemos modificar o código
one_car0.pde, para termos um
código que gere dois carros.
14
Programa: two_cars0.pde
Car myCar1;
Car myCar2;
void setup() {
size(200, 200);
myCar1 = new Car(color(255, 0, 0), 0, 100, 2);
myCar2 = new Car(color(0, 0, 255), 0, 10, 1);
}
void draw() {
background(255);
myCar1.move();
myCar1.display();
myCar2.move();
myCar2.display();
}
class Car {
color c;
float xpos;
float ypos;
float xspeed;
Car(color tempC, float tempXpos, float tempYpos, float
tempXspeed) {
c = tempC;
xpos = tempXpos;
ypos = tempYpos;
xspeed = tempXspeed;
}
void display() {
stroke(0);
fill(c);
rectMode(CENTER);
rect(xpos, ypos, 20, 10);
}
void move() {
xpos = xpos + xspeed;
if (xpos > width) {
xpos = 0;
}}}
www.processing.org
Para
dois
carros,
basta
acrescentar a declaração de um
novo
objeto,
myCar2,
a
inicialização do novo objeto, bem
como as respectivas chamadas
de métodos, indicadas em
vermelho.
15
Arrays de Objetos
www.processing.org
Podemos usar o que aprendemos sobre arrays, para criamos um array de objetos.
Podemos modificar o programa one_car0.pde, para que tenhamos agora 100 carros.
Inicialmente declaramos um array com 100 objetos, com Car[] cars = new
Car[100] ; . Em seguida usamos loops for para inicializarmos os objetos e para os
métodos. O código segue no próximo slide.
16
Programa: cars100.pde
Car[] cars = new Car[100] ;
void setup() {
size(200, 200);
smooth();
for (int i = 0; i < cars.length; i++ ) {
cars[i] = new Car(color(i*2), 0, i*2, i/20.0);
}
}
void draw() {
background(255);
for (int i = 0; i < cars.length; i++ ) {
cars[i].move();
cars[i].display();
}
}
class Car {
color c;
float xpos;
float ypos;
float xspeed;
Car(color c_, float xpos_, float ypos_, float xspeed_) {
c = c_;
xpos = xpos_;
ypos = ypos_;
xspeed = xspeed_;
}
void display() {
rectMode(CENTER);
stroke(0);
fill(c);
rect(xpos, ypos, 20, 10);
}
void move() {
xpos = xpos + xspeed;
if (xpos > width) {
xpos = 0;
}}}
www.processing.org
Criamos 100 objetos da classe
Car. Depois usamos um loop for
para inicializarmos 100 objetos.
No draw() usamos outro loop for
para os métodos. Vejam, uma
vez definida a classe, podemos
fazer uso de arrays e loops para
expandirmos
para
qualquer
número
de
objetos.
Uma
facilidade
da
programação
orientada a objetos.
17
Exercício de Programação: flying_saucers100.pde
www.processing.org
Exercício de programação: Modifique o código do programa flying_saucer0.pde, de
forma que tenhamos 100 discos voadores.
18
Referências
www.processing.org
-MODEL, Mitchell L. Bioinformatics Programming Using Python. Sebastopol: O’Reilly Media, Inc., 2011. 1584 p.
-REAS, Casey & FRY, Bem. Geeting Started with Processing. Sebastopol: O’Reilly Media, Inc., 2010. 194 p.
-SHIFFMAN, Daniel. Learning Processing. A Beginner’s Guide to Programming Images, Animation, and Interaction.
Burlington: Morgan Kaufmann, 2008. 453 p.
-SHIFFMAN, Daniel. The Nature of Code: Simulating Natural Systems with Processing. Mountain View: The Nature of Code,
2012. 498 p.
Última atualização: 05 de outubro de 2015.
19