Lista 1

exercicio1.py

#exercicio 1
#Escreva um programa que desenha um quadrado onde quer que o mouse esteja na tela, 
#centralizado na posição do mouse. O quadrado deve deixar um rastro na tela 
#quando você mover o mouse.
def setup():
  size(300,300)

def draw():
  tamanhoLado = 30
  rect(mouseX-tamanhoLado/2, mouseY - tamanhoLado/2, tamanhoLado, tamanhoLado)

exercicio2.py

#exercicio 2
#Altere o código da questão 1 para que ao mover o quadrado, ele não deixe um rastro na tela.
def setup():
  size(300,300)

def draw():
  background(0)
  tamanhoLado = 30
  rect(mouseX-tamanhoLado/2, mouseY - tamanhoLado/2, tamanhoLado, tamanhoLado)

exercicio3.py

#exercicio 3
#Escreva um programa que desenha um círculo dentro de um quadrado onde 
#quer que o mouse esteja. Caso o mouse se mova, as figuras devem se 
#mover junto. Não devem deixar rastro.

def setup():
  size(300,300)

def draw():
  background(0)
  tamanhoLado = 30
  rect(mouseX-tamanhoLado/2, mouseY - tamanhoLado/2, tamanhoLado, tamanhoLado)
  ellipse(mouseX, mouseY, tamanhoLado, tamanhoLado)

exercicio4.py

#exercicio 4
#Escreva um programa que desenha uma linha na tela, ligando a 
#posição (0,0) da tela com a posição do mouse. Caso o mouse se 
#mova, a linha deve mudar para acompanhar o movimento do mouse. 
#Não deve deixar rastro.
def setup():
  size(300,300)

def draw():
  background(0)
  stroke(255)
  line(0,0, mouseX, mouseY)

exercicio5.py

#exercicio 5
#Estenda o programa anterior para que sejam desenhadas quatro linhas, 
#agora ligando o mouse aos quatro cantos da tela.

def setup():
  size(300,300)

def draw():
  background(0)
  stroke(255)
  line(0,0, mouseX, mouseY)
  line(width, 0, mouseX, mouseY)
  line(0, height, mouseX, mouseY)
  line(width, height, mouseX, mouseY)

exercicio6.py

# exercicio 6
#Desenhe a figura abaixo usando a chamada à função 
#rect(x, y, largura, altura), sendo invocada exatamente 3 vezes: 
#um quadrado com 9 subquadrados, lembrando um tabuleiro de jogo da velha

def setup():
  size(300,300)
  noFill()

def draw():
  offset = 20
  tamanhoQuadrado = 40
  rect(offset, offset, tamanhoQuadrado*2, tamanhoQuadrado*3)
  rect(offset+tamanhoQuadrado, offset, tamanhoQuadrado*2, tamanhoQuadrado*3)
  rect(offset, offset+tamanhoQuadrado, tamanhoQuadrado*3, tamanhoQuadrado)
  

exercicio7.py

#exercicio 7
#Faça uma animação do PacMan usando a função arc. Como o 
#PacMan se move é uma decisão sua.
x = 0
anguloMaximo = 2*PI/3 #120 graus
anguloAtual = 0
abrindo = True

def setup():
    size (500, 200)
    
def draw():
    global x
    global anguloAtual
    global abrindo
    incrementoAngulo = 2*PI/30 # 1/5 da abertura tutal
    background(125)
    tamanhoCirculo = 30
    if abrindo:
        anguloAtual += incrementoAngulo
        if anguloAtual >= anguloMaximo:
            abrindo = False
    else:
        anguloAtual -= incrementoAngulo
        if anguloAtual <= 0:
            abrindo = True
            
    arc(x, 100, tamanhoCirculo, tamanhoCirculo, anguloAtual/2, 2*PI - anguloAtual/2)
    
    x += 2

exercicio8.py

#exercicio 8
#Use a função arc para criar um gráfico de pizza dividido em 3 
#pedaços: um pedaço com 50% da pizza, outro pedaço com 20% da 
#pizza e um terceiro pedaço com os 30% restantes da pizza. Cada 
#pedaço deve ter cores diferentes.

size(300,300)

xCentro = width/2
yCentro = height/2

diametro = 100

fill(255, 0, 0)
arc(xCentro, yCentro, diametro, diametro, 0, PI)

fill(0, 255, 0)
arc(xCentro, yCentro, diametro, diametro, PI, PI+2*PI/5)

fill(0, 0, 255)
arc(xCentro, yCentro, diametro, diametro, PI+2*PI/5, 2*PI)

exercicio9.py

# exercicio 9
#Escreva um programa que realize desenhos simétricos usando elipses. 
#A cada frame, desenhe uma elipse na posição do mouse e a espelhe 
#verticalmente na metade direita da tela. As elipses só devem ser 
#desenhadas quando o mouse for pressionado.

largura = 500

def setup():
    size(largura, 500)
    
def draw():
    if mousePressed:
        ellipse(mouseX, mouseY, 10, 10)
        ellipse(largura-mouseX, mouseY, 10, 10)

pacman.py

pacman = None
largura = 500
altura = 500
  

def setup():
    # global eh necessario para acessar a variavel chamada pacman de escopo global
    global pacman
    
    # variaveis usadas para configuracao 
    anguloMaximo = 2*PI/3 #120 graus
    tamanhoCirculo = 30
    velocidadeMaxima = 2
    
    # inicializacao dos parametros globais de tela e pintura
    size(largura, altura)
    noStroke()
    
    #criacao do objeto que vai armazenar o as informacoes sobre o pacman
    pacman = PacMan(velocidadeMaxima, tamanhoCirculo, anguloMaximo, largura/2, altura/2)


def draw():
    global pacman
    
    #limpando a tela a cada frame
    background(120)
    
    #atualizando a posicao do pacman e mandando ele ser pintado na nova posicao
    pacman.atualizar()
    pacman.pintar()
    
#classe que define o que eh o pacman
class PacMan(object):
    # vetores de localizacao, velocidade e aceleracao do pacman
    localizacao = None
    velocidade = None
    aceleracao = None
    
    tamanhoCirculo = 0 #diametro do pacman
    anguloZero = 0 #angulo usado como referencia para a abertura da boca
    
    anguloMaximo = 0 #angulo maximo de abertura da boca
    anguloAtual = anguloMaximo #angulo atual de abertuda da boca; comeca aberta no maximo
    abrindo = True #variavel que define se a boca esta abrindo ou fechando
    incrementoAngulo = 0 # o incremento ou decremento da abertura da boca a cada frame
    
    
    def __init__(self, velocidadeMaxima, tamanhoCirculo, anguloMaximo, xCentro, yCentro):
        self.velocidadeMaxima = velocidadeMaxima
        self.anguloMaximo = anguloMaximo
        self.anguloAtual = anguloMaximo
        self.incrementoAngulo = anguloMaximo/10 #1/10 da abertura maxima da boca
        self.tamanhoCirculo = tamanhoCirculo
        #inicializacao dos vetores posicional e de deslocamento
        self.localizacao = PVector(xCentro, yCentro)
        self.velocidade = PVector(1, 1)
        self.aceleracao = PVector(random(-1,1), random(-1,1)) # inicia com um valor aleatorio entre -1 e 1 para ambas as direcoes
        self.aceleracao.normalize() #normaliza para vetores de tamanho 1, mantendo a direcao
    
    def atualizar(self):
        alvo = PVector(mouseX, mouseY) #para onde o pacman deve olhar e se mover
        direcao = PVector.sub(alvo, self.localizacao)#calculo da direcao para onde o pacman vai olhar e se mover
    
        direcao.normalize() #normaliza o vetor para ter tamanho 1, mantendo a sua direcao 
        direcao.mult(5) #depois de normalizar, faco ela ter tamanho 5
        self.aceleracao = direcao #a aceleracao eh o resultado destas operacoes
        
        #determinando se o pacman ainda deve se mover ou apenas parar se chegou perto do mouse 
        if PVector.dist(self.localizacao, alvo) > 10:
            self.velocidade.add(self.aceleracao) #determina o novo valor da velocidade baseado na aceleracao
            self.velocidade.limit(self.velocidadeMaxima) #limita à maxima velocidade permitida
        else:
            #para o pacman
            self.aceleracao = PVector(0,0)
            self.velocidade = PVector(0,0)
            
        #decidindo se o pacman esta abrindo ou fechando a boca e atualizando
        #o angulo da abertura para cada caso
        if self.abrindo:
            self.anguloAtual += self.incrementoAngulo
            if self.anguloAtual >= self.anguloMaximo:
                self.abrindo = False
        else:
            self.anguloAtual -= self.incrementoAngulo
            if self.anguloAtual <= 0:
                self.abrindo = True
        
        #atualizando a localizacao de acordo com a aceleracao e velocidades calculadas
        self.localizacao.add(self.velocidade)
        
        #determinando para onde o pacman deve olhar
        self.anguloZero = direcao.heading()
        
    def pintar(self):
        #pintar o arc, que representa o pacman em si
        arc(self.localizacao.x, self.localizacao.y, self.tamanhoCirculo, self.tamanhoCirculo, self.anguloZero + self.anguloAtual/2, 
            self.anguloZero + 2*PI - self.anguloAtual/2)