├── _config.yml ├── docs ├── exemplos │ ├── README.md │ ├── cata-poti │ │ └── README │ ├── index.md │ └── cata-estrelas │ │ ├── Nave.png │ │ ├── poti.png │ │ ├── v1.PNG │ │ ├── v3.PNG │ │ ├── Space.png │ │ ├── Estrela.png │ │ ├── camadas.png │ │ ├── potigol.png │ │ ├── v1.poti │ │ ├── v2.poti │ │ ├── v3.poti │ │ ├── estrela.poti │ │ ├── v4.poti │ │ ├── v5.poti │ │ ├── v13.poti │ │ ├── v6.poti │ │ ├── jogador.poti │ │ ├── v7.poti │ │ ├── v8.poti │ │ ├── v10.poti │ │ ├── v9.poti │ │ ├── v11.poti │ │ ├── v12.poti │ │ ├── v14.poti │ │ ├── v15.poti │ │ └── index.md ├── _config.yml ├── relogio.md ├── cor.md ├── teclado.md ├── mouse.md ├── index.md ├── fonte.md ├── imagem.md └── jogo.md ├── project ├── plugins.sbt ├── build.properties ├── assembly.sbt └── eclipse.sbt ├── README.md ├── potigol ├── Nave.png ├── beep.wav ├── Space.png ├── space.wav ├── Estrela.png ├── potigol.png └── CataEstrela.poti ├── src ├── exemplo │ ├── Nave.png │ ├── Space.png │ ├── Estrela.png │ ├── potigol.png │ └── CataEstrela.scala └── main │ └── scala │ └── jerimum │ ├── Arquivo.scala │ ├── package.scala │ ├── Relogio.scala │ ├── Animacao.scala │ ├── Tela.scala │ ├── Cor.scala │ ├── Desenho.scala │ ├── Fonte.scala │ ├── Mouse.scala │ ├── Teclado.scala │ ├── Imagem.scala │ ├── Jogo.scala │ └── Som.scala ├── .gitignore └── LICENSE /_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-dinky -------------------------------------------------------------------------------- /docs/exemplos/README.md: -------------------------------------------------------------------------------- 1 | # README 2 | -------------------------------------------------------------------------------- /project/plugins.sbt: -------------------------------------------------------------------------------- 1 | logLevel := Level.Warn -------------------------------------------------------------------------------- /docs/exemplos/cata-poti/README: -------------------------------------------------------------------------------- 1 | # Cata Poti 2 | -------------------------------------------------------------------------------- /project/build.properties: -------------------------------------------------------------------------------- 1 | sbt.version = 1.11.5 -------------------------------------------------------------------------------- /docs/exemplos/index.md: -------------------------------------------------------------------------------- 1 | # Exemplos 2 | 3 | + Cata Estrelas 4 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Jerimum 2 | Biblioteca de Jogos para a Linguagem Potigol 3 | -------------------------------------------------------------------------------- /project/assembly.sbt: -------------------------------------------------------------------------------- 1 | addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.3.1") -------------------------------------------------------------------------------- /potigol/Nave.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/potigol/Nave.png -------------------------------------------------------------------------------- /potigol/beep.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/potigol/beep.wav -------------------------------------------------------------------------------- /potigol/Space.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/potigol/Space.png -------------------------------------------------------------------------------- /potigol/space.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/potigol/space.wav -------------------------------------------------------------------------------- /potigol/Estrela.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/potigol/Estrela.png -------------------------------------------------------------------------------- /potigol/potigol.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/potigol/potigol.png -------------------------------------------------------------------------------- /project/eclipse.sbt: -------------------------------------------------------------------------------- 1 | addSbtPlugin("com.typesafe.sbteclipse" % "sbteclipse-plugin" % "5.2.4") -------------------------------------------------------------------------------- /src/exemplo/Nave.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/src/exemplo/Nave.png -------------------------------------------------------------------------------- /src/exemplo/Space.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/src/exemplo/Space.png -------------------------------------------------------------------------------- /src/exemplo/Estrela.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/src/exemplo/Estrela.png -------------------------------------------------------------------------------- /src/exemplo/potigol.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/src/exemplo/potigol.png -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/Nave.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/docs/exemplos/cata-estrelas/Nave.png -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/poti.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/docs/exemplos/cata-estrelas/poti.png -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v1.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/docs/exemplos/cata-estrelas/v1.PNG -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v3.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/docs/exemplos/cata-estrelas/v3.PNG -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/Space.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/docs/exemplos/cata-estrelas/Space.png -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/Estrela.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/docs/exemplos/cata-estrelas/Estrela.png -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/camadas.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/docs/exemplos/cata-estrelas/camadas.png -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/potigol.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/potigol/Jerimum/HEAD/docs/exemplos/cata-estrelas/potigol.png -------------------------------------------------------------------------------- /docs/_config.yml: -------------------------------------------------------------------------------- 1 | remote_theme: rundocs/jekyll-rtd-theme 2 | 3 | title: Biblioteca Jerimum 4 | description: Documentação da biblioteca de jogos 2D - Jerimum 5 | 6 | readme_index: 7 | with_frontmatter: true 8 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v1.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | atualize() 4 | # Código para atualizar o jogo 5 | fim 6 | 7 | desenhe() 8 | # código para desenhar o jog 9 | fim 10 | 11 | jogo.iniciar("Título", 640, 480, atualize, desenhe) 12 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | *.log 3 | 4 | # sbt specific 5 | .cache 6 | .history 7 | .lib/ 8 | dist/* 9 | target/ 10 | lib_managed/ 11 | src_managed/ 12 | project/boot/ 13 | project/plugins/project/ 14 | 15 | # Scala-IDE specific 16 | .scala_dependencies 17 | .worksheet 18 | -------------------------------------------------------------------------------- /src/main/scala/jerimum/Arquivo.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | 3 | import br.edu.ifrn.potigol.Potigolutil._ 4 | import scala.io.Source 5 | 6 | object Arquivo { 7 | def leia(caminho: Texto): Lista[Texto] = { 8 | Lista(Source.fromFile(caminho).getLines().toList) 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v2.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | fundo = Imagem("Space.png") 4 | 5 | atualize() 6 | # Código para atualizar o jogo 7 | fim 8 | 9 | desenhe() 10 | fundo.desenhe(0, 0, 0) 11 | fim 12 | 13 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 14 | -------------------------------------------------------------------------------- /src/main/scala/jerimum/package.scala: -------------------------------------------------------------------------------- 1 | 2 | package object jerimum { 3 | val jogo = Jogo 4 | val mouse = Mouse 5 | val teclado = Teclado 6 | val relógio = Relogio 7 | val relogio = Relogio 8 | val Relógio = Relogio 9 | val cor = Cor 10 | type Música = Musica 11 | val Música = Musica 12 | } -------------------------------------------------------------------------------- /src/main/scala/jerimum/Relogio.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | import java.util.Date 3 | 4 | import br.edu.ifrn.potigol.Potigolutil.{ Inteiro, Real } 5 | 6 | object Relogio { 7 | private[this] val inicio = new Date().getTime; 8 | def agora: Real = new Date().getTime 9 | def milisegundos: Inteiro = (System.currentTimeMillis() - inicio).toInt 10 | } -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v3.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | fundo = Imagem("Space.png") 4 | nave_imagem = Imagem("nave.png") 5 | 6 | atualize() 7 | # Código para atualizar o jogo 8 | fim 9 | 10 | desenhe() 11 | fundo.desenhe(0, 0, 0) 12 | nave_imagem.desenhe(300, 200, 2) 13 | fim 14 | 15 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 16 | -------------------------------------------------------------------------------- /docs/relogio.md: -------------------------------------------------------------------------------- 1 | # Relógio 2 | 3 | ## Atributos do Tipo 4 |
5 |
agora: Real
6 |
Horário no momento.
7 | Exemplo: hora = Relógio.agora
8 |
milisegundos: Inteiro
9 |
Quantidade de milisegundos desde o dia 1/1/2000.
10 | Exemplo: ms = Relógio.milisegundos
11 |
12 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/estrela.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | tipo Estrela 4 | cor = Cor.BRANCO 5 | x = aleatório(jogo.largura) 6 | y = aleatório(jogo.altura) 7 | imagens = Imagem("Estrela.png").fatie(25, 25) 8 | 9 | desenhe() 10 | n = (Relógio.milisegundos div 100) mod imagens.tamanho + 1 11 | img = imagens[n] 12 | img.desenhe_centralizado(x, y, 1, 0) 13 | fim 14 | fim 15 | -------------------------------------------------------------------------------- /src/main/scala/jerimum/Animacao.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | 3 | import br.edu.ifrn.potigol.Potigolutil.{ Inteiro, Lista } 4 | 5 | case class Animacao(velocidade: Inteiro, imagens: Lista[Imagem]) { 6 | private[this] val inicio = System.currentTimeMillis() 7 | private[this] val tamanho = imagens.length 8 | 9 | def imagem(): Imagem = { 10 | val indice = ((System.currentTimeMillis() - inicio) / velocidade % tamanho).toInt 11 | imagens(indice) 12 | } 13 | } -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v4.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | fundo = Imagem("Space.png") 4 | nave_imagem = Imagem("nave.png") 5 | var nave_x = 300 6 | 7 | atualize() 8 | se Teclado.TECLA_PARA_DIREITA então 9 | nave_x := nave_x + 10 10 | fim 11 | se Teclado.TECLA_PARA_ESQUERDA então 12 | nave_x := nave_x - 10 13 | fim 14 | fim 15 | 16 | desenhe() 17 | fundo.desenhe(0, 0, 0) 18 | nave_imagem.desenhe(nave_x, 200, 2) 19 | fim 20 | 21 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 22 | -------------------------------------------------------------------------------- /docs/cor.md: -------------------------------------------------------------------------------- 1 | # Cor 2 | 3 | ## Atributos 4 |
5 |
AMARELO, AZUL, BRANCO, CIANO, CINZA, CINZA_CLARO, CINZA_ESCURO, LARANJA, MAGENTA, PRETO, ROSA, VERDE, VERMELHO: Cor
6 |
Cores predefinidas.
7 | Exemplo: fonte.desenhe("Texto", 10, 20, Cor.AMARELO)
8 |
9 | 10 | ## Métodos 11 |
12 |
Cor(vermelho, verde, azul: Inteiro)
13 |
Construtor: Cria uma nova cor passando os componentes vermelho, verde e azul.
14 | Exemplo: cor = Cor(10, 120, 240)
15 |
16 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v5.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | fundo = Imagem("Space.png") 4 | nave_imagem = Imagem("nave.png") 5 | var nave_x = jogo.largura / 2 6 | 7 | atualize() 8 | se Teclado.TECLA_PARA_DIREITA então 9 | nave_x := nave_x + 10 10 | se nave_x > jogo.largura - 40 então 11 | nave_x := jogo.largura - 40 12 | fim 13 | fim 14 | se Teclado.TECLA_PARA_ESQUERDA então 15 | nave_x := nave_x - 10 16 | se nave_x < 10 então nave_x := 10 fim 17 | fim 18 | fim 19 | 20 | desenhe() 21 | fundo.desenhe(0, 0, 0) 22 | nave_imagem.desenhe(nave_x, 200, 2) 23 | fim 24 | 25 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 26 | -------------------------------------------------------------------------------- /docs/teclado.md: -------------------------------------------------------------------------------- 1 | # Teclado 2 | 3 | Verifica se alguma tecla está pressionada. 4 | 5 | # Atributos 6 | 7 |
8 |
TECLA_A, TECLA_B, TECLA_C, TECLA_D, TECLA_E, TECLA_F, TECLA_G, TECLA_H, TECLA_I, TECLA_J, TECLA_K, TECLA_L, TECLA_M, 9 | TECLA_N, TECLA_O, TECLA_P, TECLA_Q, TECLA_R, TECLA_S, TECLA_T, TECLA_U, TECLA_V, TECLA_W, TECLA_X, TECLA_Y, TECLA_Z 10 | TECLA_0, TECLA_1, TECLA_2, TECLA_3, TECLA_4, TECLA_5, TECLA_6, TECLA_7, TECLA_8, TECLA_9 11 | TECLA_ESPAÇO, TECLA_ENTER, TECLA_PARA_CIMA, TECLA_PARA_BAIXO, TECLA_PARA_ESQUERDA, TECLA_PARA_DIREITA: Lógico
12 |
Indica se uma tecla específica foi pressionada.
13 | Exemplo: se Teclado.TECLA_PARA_DIREITA então x := x + 1 fim
14 |
15 | -------------------------------------------------------------------------------- /docs/mouse.md: -------------------------------------------------------------------------------- 1 | # Mouse 2 | 3 | Verifica se algum botão do mouse está pressionado. 4 | 5 | ## Atributos do Tipo 6 |
7 |
BOTÃO_ESQUERDO: Lógico
8 |
Indica se o botão esquerdo do mouse está pressionado.
9 | Exemplo: se Mouse.BOTÃO_ESQUERDO então x := x - 1 fim
10 |
BOTÃO_DIREITO: Lógico
11 |
Indica se o botão direito do mouse está pressionado.
12 | Exemplo: se Mouse.BOTÃO_DIREITO então x := x + 1 fim
13 |
x: Inteiro
14 |
A posição do mouse no eixo X.
15 | Exemplo: pos_x := Mouse.x
16 |
y: Inteiro
17 |
posição do mouse no eixo Y.
18 | Exemplo: pos_y := Mouse.y
19 |
20 | -------------------------------------------------------------------------------- /docs/index.md: -------------------------------------------------------------------------------- 1 | # Biblioteca Jerimum 2 | 3 | Exemplos: [Cata Estrelas](https://potigol.github.io/Jerimum/exemplos/cata-estrelas/), [Labirinto](https://ifrn.github.io/jerimum/) 4 | 5 | Para usar a biblioteca Jerimum comece o programa com a instrução `use "jerimum"` 6 | 7 | ````python 8 | use "jerimum" 9 | 10 | atualize() 11 | # Código para atualizar o jogo 12 | fim 13 | 14 | desenhe() 15 | # código para desenhar o jogo 16 | fim 17 | 18 | jogo.iniciar("Título", 640, 480, atualize, desenhe, 60) 19 | ```` 20 | 21 | 22 | ## Recursos 23 | 24 | - [Jogo](jogo.md) Cria, define o tamanho da tela e inicia o jogo 25 | - [Imagem](imagem.md) Carrega e exibe imagens 26 | - [Teclado](teclado.md) Eventos do teclado 27 | - [Mouse](mouse.md) Eventos do Mouse 28 | - [Fonte](fonte.md) Exibe texto na tela 29 | - [Cor](cor.md) Define as cores 30 | - [Relógio](relogio.md) Temporizador 31 | -------------------------------------------------------------------------------- /src/main/scala/jerimum/Tela.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | 3 | import java.awt.{ Canvas, Dimension } 4 | 5 | import br.edu.ifrn.potigol.Potigolutil.{ Inteiro, Texto } 6 | import javax.swing.{JFrame, WindowConstants} 7 | import javax.imageio.IIOException 8 | 9 | class Tela(titulo: Texto, largura: Inteiro, altura: Inteiro) { 10 | private[this] val dim = new Dimension(largura, altura) 11 | val canvas = new Canvas() { 12 | setPreferredSize(dim) 13 | setMaximumSize(dim) 14 | setMinimumSize(dim) 15 | setFocusable(false) 16 | } 17 | val frame = new JFrame(titulo) { 18 | setIconImage(Imagem("potigol.png").buffer) 19 | setSize(dim) 20 | setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE) 21 | setResizable(false) 22 | setLocationRelativeTo(null) 23 | setVisible(true) 24 | add(canvas) 25 | pack() 26 | } 27 | } -------------------------------------------------------------------------------- /docs/fonte.md: -------------------------------------------------------------------------------- 1 | # Fonte 2 | 3 | Usado para escrever textos na tela 4 | 5 | ## Atributos 6 |
7 |
tamanho: Inteiro
8 |
Tamanho da letra
9 | Exemplo: a = fonte.tamanho
10 |
11 | 12 | ## Métodos 13 |
14 |
Fonte(tamanho: Inteiro)
15 |
Construtor: Cria uma nova fonte passando o tamanho.
16 | Exemplo: f = Fonte(16)
17 |
desenhe(texto: Texto, x, y: Real, z: Inteiro)
18 |
Escreve um texto na tela na posição (x, y), camada z.
19 | Exemplo: fonte.desenhe("Texto", 100, 120, 3)
20 |
desenhe_centralizado(texto: Texto, x, y: Real, z: Inteiro)
21 |
Escreve um texto na tela centralizado no ponto (x, y), camada z.
22 | Exemplo: fonte.desenhe_centralizado("Texto", 100, 120, 3)
23 |
24 | -------------------------------------------------------------------------------- /src/main/scala/jerimum/Cor.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | 3 | import java.awt.Color 4 | import br.edu.ifrn.potigol.Potigolutil._ 5 | 6 | case class Cor(vermelho: Inteiro, verde: Inteiro, azul: Inteiro) { 7 | def color = new Color(vermelho, verde, azul) 8 | def this(color: Color) = this(color.getRed, color.getGreen, color.getBlue) 9 | } 10 | 11 | object Cor { 12 | val AMARELO = new Cor(Color.yellow) 13 | val AZUL = new Cor(Color.blue) 14 | val BRANCO = new Cor(Color.white) 15 | val CIANO = new Cor(Color.cyan) 16 | val CINZA = new Cor(Color.gray) 17 | val CINZA_CLARO = new Cor(Color.lightGray) 18 | val CINZA_ESCURO = new Cor(Color.darkGray) 19 | val LARANJA = new Cor(Color.orange) 20 | val MAGENTA = new Cor(Color.magenta) 21 | val PRETO = new Cor(Color.black) 22 | val ROSA = new Cor(Color.pink) 23 | val VERDE = new Cor(Color.green) 24 | val VERMELHO = new Cor(Color.red) 25 | } 26 | -------------------------------------------------------------------------------- /src/main/scala/jerimum/Desenho.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | 3 | import java.awt.{ Graphics2D, RenderingHints } 4 | 5 | import scala.collection.SortedMap 6 | 7 | import br.edu.ifrn.potigol.Potigolutil.Inteiro 8 | 9 | object Desenho { 10 | private[this] val vazia = SortedMap[Inteiro, List[Graphics2D => Unit]]() 11 | private[this] var camadas = vazia 12 | private[this] def todos = camadas.values.flatten 13 | 14 | private[this] val rh = new RenderingHints( 15 | RenderingHints.KEY_TEXT_ANTIALIASING, 16 | RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB) 17 | 18 | def desenhe(g: Graphics2D): Unit = { 19 | g match { 20 | case g: Graphics2D => 21 | g.setRenderingHints(rh) 22 | } 23 | todos.foreach(f => f(g)) 24 | camadas = vazia 25 | } 26 | 27 | def incluir(z: Inteiro, funcao: Graphics2D => Unit) = { 28 | camadas += z -> (funcao :: camadas.getOrElse(z, Nil)) 29 | } 30 | } -------------------------------------------------------------------------------- /src/main/scala/jerimum/Fonte.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | 3 | import br.edu.ifrn.potigol.Potigolutil.{ Inteiro, Real, Texto } 4 | import java.awt.Font 5 | 6 | object Fonte { 7 | 8 | } 9 | 10 | case class Fonte(tamanho: Inteiro) { 11 | private[this] val font = new Font("Dialog", Font.BOLD, tamanho); 12 | 13 | def desenhe_centralizado(msg: Texto, x: Real, y: Real, z: Inteiro, cor: Cor = Cor.BRANCO) = { 14 | Desenho.incluir(z, g => { 15 | g.setColor(cor.color) 16 | g.setFont(font) 17 | val largura = g.getFontMetrics.stringWidth(msg) 18 | val altura = g.getFontMetrics.getHeight 19 | g.drawString(msg, x.toInt - largura / 2, y.toInt - altura / 2) 20 | }) 21 | 22 | } 23 | 24 | def desenhe(msg: Texto, x: Real, y: Real, z: Inteiro, cor: Cor = Cor.BRANCO) = { 25 | Desenho.incluir(z, g => { 26 | g.setColor(cor.color) 27 | g.setFont(font) 28 | g.drawString(msg, x.toInt, y.toInt) 29 | }) 30 | } 31 | } -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v13.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | use "jogador.poti" 3 | use "estrela.poti" 4 | 5 | fundo = Imagem("Space.png") 6 | nave = Jogador(jogo.largura / 2, jogo.altura / 2) 7 | var estrelas = Lista(0, Estrela()) 8 | fonte = Fonte(16) 9 | 10 | atualize() 11 | estrelas := nave.cate_estrelas(estrelas) 12 | se estrelas.tamanho < 25 e aleatório(100) < 4 então 13 | estrelas := Estrela() :: estrelas 14 | fim 15 | se Teclado.TECLA_PARA_DIREITA então 16 | nave.girar_direita 17 | fim 18 | se Teclado.TECLA_PARA_ESQUERDA então 19 | nave.girar_esquerda 20 | fim 21 | se Teclado.TECLA_PARA_CIMA então 22 | nave.acelerar 23 | fim 24 | nave.mover 25 | fim 26 | 27 | desenhe() 28 | fundo.desenhe(0, 0, 0) 29 | nave.desenhe 30 | para estrela em estrelas faça 31 | estrela.desenhe 32 | fim 33 | fonte.desenhe("Placar: {nave.placar}", 10, 20, 3, Cor.AMARELO) 34 | fim 35 | 36 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 37 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v6.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | fundo = Imagem("Space.png") 4 | nave_imagem = Imagem("nave.png") 5 | var nave_x = jogo.largura / 2 6 | var nave_y = jogo.altura / 2 7 | 8 | atualize() 9 | se Teclado.TECLA_PARA_DIREITA então 10 | nave_x := nave_x + 10 11 | se nave_x > jogo.largura - 40 então 12 | nave_x := jogo.largura - 40 13 | fim 14 | fim 15 | se Teclado.TECLA_PARA_ESQUERDA então 16 | nave_x := nave_x - 10 17 | se nave_x < 10 então nave_x := 10 fim 18 | fim 19 | se Teclado.TECLA_PARA_BAIXO então 20 | nave_y := nave_y + 10 21 | se nave_y > jogo.altura - 40 então 22 | nave_y := jogo.altura - 40 23 | fim 24 | fim 25 | se Teclado.TECLA_PARA_CIMA então 26 | nave_y := nave_y - 10 27 | se nave_y < 10 então nave_y := 10 fim 28 | fim 29 | fim 30 | 31 | desenhe() 32 | fundo.desenhe(0, 0, 0) 33 | nave_imagem.desenhe(nave_x, nave_y, 2) 34 | fim 35 | 36 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 37 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/jogador.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | tipo Jogador 4 | var x, y: Real 5 | imagem = Imagem("nave.png") 6 | var ângulo, vel_x, vel_y := 0.0 7 | var placar := 0 8 | 9 | cate_estrelas(estrelas: Lista[Estrela]) 10 | n = estrelas.tamanho 11 | estrelas_catadas = estrelas.selecione( 12 | estrela => Jogo.distância(x, y, estrela.x, estrela.y) > 35 13 | ) 14 | placar := placar + (n - estrelas_catadas.tamanho) * 10 15 | estrelas_catadas 16 | fim 17 | 18 | desenhe() 19 | imagem.desenhe_centralizado(x, y, 2, ângulo) 20 | fim 21 | 22 | girar_direita() 23 | ângulo := ângulo + 5 24 | fim 25 | 26 | girar_esquerda() 27 | ângulo := ângulo - 5 28 | fim 29 | 30 | acelerar() 31 | vel_x := vel_x + Jogo.projeção_X(ângulo, 0.5) 32 | vel_y := vel_y + Jogo.projeção_Y(ângulo, 0.5) 33 | fim 34 | 35 | mover() 36 | x := x + vel_x 37 | y := y + vel_y 38 | x := (x + 640) mod 640 39 | y := (y + 480) mod 480 40 | vel_x := vel_x * 0.95 41 | vel_y := vel_y * 0.95 42 | fim 43 | fim 44 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 Potigol 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /docs/imagem.md: -------------------------------------------------------------------------------- 1 | # Imagem 2 | 3 | Permite carregar imagens de arquivos e exibir na tela. 4 | 5 | ## Atributo 6 |
7 |
largura: Inteiro
8 |
Largura da imagem
9 |
altura: Inteiro
10 |
Altura da imagem
11 |
12 | 13 | ## Métodos 14 |
15 |
Imagem(caminho: Texto)
16 |
Construtor
17 | Exemplo: img = Imagem("jogador.png")
18 |
desenhe(x, y: Real, z: Inteiro, angulo: Real = 0.0, scala_X, scala_Y: Real = 1.0)
19 |
Desenha uma imagem na tela tendo (x, y) como ponto superior esquerdo.
20 | Exemplo: img.desenhe(20, 30, 1)
21 |
desenhe_centralizado(x, y: Real, z: Inteiro, angulo: Real = 0.0, scala_Y: Real = 1.0)
22 |
Desenha uma imagem na tela tendo (x, y) como ponto central.
23 | Exemplo: img.desenhe_centralizado(20, 30, 1)
24 |
fatie(x, y: Inteiro): Lista[Imagem]
25 |
Recorta uma imagem em imagens menores formando uma lista.
26 | Exemplo: imagens = Imagem("sprite.png").fatie(30, 30)
27 |
28 | -------------------------------------------------------------------------------- /src/main/scala/jerimum/Mouse.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | 3 | import java.awt.event.{ MouseEvent, MouseListener, MouseMotionListener } 4 | 5 | import br.edu.ifrn.potigol.Potigolutil.{ Inteiro, Lógico } 6 | 7 | object Mouse extends MouseListener with MouseMotionListener { 8 | private[this] val botoes = new Array[Boolean](4) 9 | private[this] var _x, _y: Int = 0 10 | def BOTAO_ESQUERDO: Lógico = botoes(1) 11 | def BOTAO_DIREITO: Lógico = botoes(3) 12 | 13 | private[this] def update(e: MouseEvent, valor: Boolean) = { 14 | val botao = e.getButton() 15 | if (botao == MouseEvent.BUTTON1) 16 | botoes(1) = valor 17 | if (botao == MouseEvent.BUTTON3) 18 | botoes(3) = valor 19 | } 20 | 21 | override def mousePressed(e: MouseEvent) = this(e) = true 22 | override def mouseReleased(e: MouseEvent) = this(e) = false 23 | 24 | override def mouseMoved(e: MouseEvent) = { 25 | _x = e.getX() 26 | _y = e.getY() 27 | } 28 | 29 | def x: Inteiro = _x 30 | def y: Inteiro = _y 31 | 32 | override def mouseDragged(e: MouseEvent) = {} 33 | override def mouseClicked(e: MouseEvent) = {} 34 | override def mouseEntered(e: MouseEvent) = {} 35 | override def mouseExited(e: MouseEvent) = {} 36 | } -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v7.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | tipo Jogador 4 | var x, y: Real 5 | imagem = Imagem("nave.png") 6 | 7 | desenhe() 8 | imagem.desenhe_centralizado(x, y, 2) 9 | fim 10 | 11 | mover_direita() 12 | x := x + 10 13 | se x > jogo.largura - 20 então 14 | x := jogo.largura - 20 15 | fim 16 | fim 17 | 18 | mover_esquerda() 19 | x := x - 10 20 | se x < 20 então 21 | x := 20 22 | fim 23 | fim 24 | 25 | mover_baixo() 26 | y := y + 10 27 | se y > jogo.altura - 20 então 28 | y := jogo.altura - 20 29 | fim 30 | fim 31 | 32 | mover_cima() 33 | y := y - 10 34 | se y < 20 então 35 | y := 20 36 | fim 37 | fim 38 | fim 39 | 40 | fundo = Imagem("Space.png") 41 | nave = Jogador(jogo.largura / 2, jogo.altura / 2) 42 | 43 | atualize() 44 | se Teclado.TECLA_PARA_DIREITA então 45 | nave.mover_direita 46 | fim 47 | se Teclado.TECLA_PARA_ESQUERDA então 48 | nave.mover_esquerda 49 | fim 50 | se Teclado.TECLA_PARA_CIMA então 51 | nave.mover_cima 52 | fim 53 | se Teclado.TECLA_PARA_BAIXO então 54 | nave.mover_baixo 55 | fim 56 | fim 57 | 58 | desenhe() 59 | fundo.desenhe(0, 0, 0) 60 | nave.desenhe 61 | fim 62 | 63 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 64 | -------------------------------------------------------------------------------- /docs/jogo.md: -------------------------------------------------------------------------------- 1 | # Jogo 2 | 3 | 4 | ## Atributos 5 |
6 |
largura: Inteiro
7 |
Largura da janela do jogo (em pixels)
8 | Exemplo: x = jogo.largura 9 |
10 | 11 |
altura: Inteiro
12 |
Altura da janela do jogo (em pixels)
13 | Exemplo: y = jogo.largura
14 | 15 |
título: Texto
16 |
Texto que aparece na barra de título da janela
17 | Exemplo: s = jogo.título 18 |
19 | 20 |
fps: Inteiro
21 |
Taxa de atualização do jogo em quadros por segundo
22 | Exemplo: a = jogo.fps
23 |
24 | 25 | ## Métodos 26 | 27 |
28 |
iniciar(titulo: Texto, largura: Inteiro, altura: Inteiro, atualize, desenhe, fps: Inteiro = 60)
29 |
Iniciar o jogo.
30 | Exemplo: jogo.iniciar("Título", 640, 480, atualize, desenhe)
31 | 32 |
distância(x1, y1, x2, y2: Real): Real
33 |
Distância entre dois pontos (x1,y1) e (x2,y2).
34 | Exemplo: Jogo.distância(10, 10, 20, 30)
35 | 36 |
projeção_X(angulo: Real, módulo: Real): Real
37 |
Projeção do vetor dado pelo módulo e ângulo no eixo x.
38 | Exemplo: dx = Jogo.projeção_X(30, 5)
39 | 40 |
projeção_Y(angulo: Real, módulo: Real): Real
41 |
Projeção do vetor dado pelo módulo e ângulo no eixo y.
42 | Exemplo: dy = Jogo.projeção_Y(30, 5)
43 | 44 |
45 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v8.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | tipo Jogador 4 | var x, y: Real 5 | imagem = Imagem("nave.png") 6 | 7 | desenhe() 8 | imagem.desenhe_centralizado(x, y, 2) 9 | fim 10 | 11 | mover_direita() 12 | x := x + 10 13 | se x > jogo.largura - 20 então 14 | x := jogo.largura - 20 15 | fim 16 | fim 17 | mover_esquerda() 18 | x := x - 10 19 | se x < 20 então 20 | x := 20 21 | fim 22 | fim 23 | mover_baixo() 24 | y := y + 10 25 | se y > jogo.altura - 20 então 26 | y := jogo.altura - 20 27 | fim 28 | fim 29 | mover_cima() 30 | y := y - 10 31 | se y < 20 então 32 | y := 20 33 | fim 34 | fim 35 | fim 36 | 37 | tipo Estrela 38 | x = aleatório(jogo.largura) 39 | y = aleatório(jogo.altura) 40 | imagens = Imagem("Estrela.png").fatie( 25, 25) 41 | 42 | desenhe() 43 | img = imagens[1] 44 | img.desenhe_centralizado(x, y, 1, 0) 45 | fim 46 | fim 47 | 48 | fundo = Imagem("Space.png") 49 | nave = Jogador(jogo.largura / 2, jogo.altura / 2) 50 | var estrelas = Lista(25, Estrela()) 51 | 52 | atualize() 53 | se Teclado.TECLA_PARA_DIREITA então 54 | nave.mover_direita 55 | fim 56 | se Teclado.TECLA_PARA_ESQUERDA então 57 | nave.mover_esquerda 58 | fim 59 | se Teclado.TECLA_PARA_CIMA então 60 | nave.mover_cima 61 | fim 62 | se Teclado.TECLA_PARA_BAIXO então 63 | nave.mover_baixo 64 | fim 65 | fim 66 | 67 | desenhe() 68 | fundo.desenhe(0, 0, 0) 69 | nave.desenhe 70 | para estrela em estrelas faça 71 | estrela.desenhe 72 | fim 73 | fim 74 | 75 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 76 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v10.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | tipo Jogador 4 | var x, y: Real 5 | imagem = Imagem("nave.png") 6 | var ângulo, vel_x, vel_y := 0.0 7 | 8 | cate_estrelas(estrelas: Lista[Estrela]) 9 | estrelas.selecione( 10 | estrela => Jogo.distância(x, y, estrela.x, estrela.y) > 35 11 | ) 12 | fim 13 | 14 | desenhe() 15 | imagem.desenhe_centralizado(x, y, 2, ângulo) 16 | fim 17 | 18 | girar_direita() 19 | ângulo := ângulo + 5 20 | fim 21 | 22 | girar_esquerda() 23 | ângulo := ângulo - 5 24 | fim 25 | 26 | acelerar() 27 | vel_x := vel_x + Jogo.projeção_X(ângulo, 0.5) 28 | vel_y := vel_y + Jogo.projeção_Y(ângulo, 0.5) 29 | fim 30 | 31 | mover() 32 | x := x + vel_x 33 | y := y + vel_y 34 | x := (x + 640) mod 640 35 | y := (y + 480) mod 480 36 | vel_x := vel_x * 0.95 37 | vel_y := vel_y * 0.95 38 | fim 39 | fim 40 | 41 | tipo Estrela 42 | cor = Cor.BRANCO 43 | x = aleatório(jogo.largura) 44 | y = aleatório(jogo.altura) 45 | imagens = Imagem.fatie("Estrela.png", 25, 25) 46 | 47 | desenhe() 48 | img = imagens[1] 49 | img.desenhe_centralizado(x, y, 1, 0) 50 | fim 51 | fim 52 | 53 | fundo = Imagem("Space.png") 54 | nave = Jogador(jogo.largura / 2, jogo.altura / 2) 55 | var estrelas = Lista(0, Estrela()) 56 | 57 | atualize() 58 | estrelas := nave.cate_estrelas(estrelas) 59 | se estrelas.tamanho < 25 e aleatório(100) < 4 então 60 | estrelas := Estrela() :: estrelas 61 | fim 62 | se Teclado.TECLA_PARA_DIREITA então 63 | nave.girar_direita 64 | fim 65 | se Teclado.TECLA_PARA_ESQUERDA então 66 | nave.girar_esquerda 67 | fim 68 | se Teclado.TECLA_PARA_CIMA então 69 | nave.acelerar 70 | fim 71 | nave.mover 72 | fim 73 | 74 | desenhe() 75 | fundo.desenhe(0, 0, 0) 76 | nave.desenhe 77 | para estrela em estrelas faça 78 | estrela.desenhe 79 | fim 80 | fim 81 | 82 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 83 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v9.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | tipo Jogador 4 | var x, y: Real 5 | imagem = Imagem("nave.png") 6 | 7 | cate_estrelas(estrelas: Lista[Estrela]) 8 | estrelas.selecione( 9 | estrela => Jogo.distância(x, y, estrela.x, estrela.y) > 35 10 | ) 11 | fim 12 | 13 | desenhe() 14 | imagem.desenhe_centralizado(x, y, 2) 15 | fim 16 | 17 | mover_direita() 18 | x := x + 10 19 | se x > jogo.largura - 20 então 20 | x := jogo.largura - 20 21 | fim 22 | fim 23 | mover_esquerda() 24 | x := x - 10 25 | se x < 20 então 26 | x := 20 27 | fim 28 | fim 29 | mover_baixo() 30 | y := y + 10 31 | se y > jogo.altura - 20 então 32 | y := jogo.altura - 20 33 | fim 34 | fim 35 | mover_cima() 36 | y := y - 10 37 | se y < 20 então 38 | y := 20 39 | fim 40 | fim 41 | fim 42 | 43 | tipo Estrela 44 | x = aleatório(jogo.largura) 45 | y = aleatório(jogo.altura) 46 | imagens = Imagem.fatie("Estrela.png", 25, 25) 47 | 48 | desenhe() 49 | img = imagens[1] 50 | img.desenhe_centralizado(x, y, 1, 0) 51 | fim 52 | fim 53 | 54 | fundo = Imagem("Space.png") 55 | nave = Jogador(jogo.largura / 2, jogo.altura / 2) 56 | var estrelas = Lista(0, Estrela()) 57 | 58 | atualize() 59 | estrelas := nave.cate_estrelas(estrelas) 60 | se estrelas.tamanho < 25 e aleatório(100) < 4 então 61 | estrelas := Estrela() :: estrelas 62 | fim 63 | se Teclado.TECLA_PARA_DIREITA então 64 | nave.mover_direita 65 | fim 66 | se Teclado.TECLA_PARA_ESQUERDA então 67 | nave.mover_esquerda 68 | fim 69 | se Teclado.TECLA_PARA_CIMA então 70 | nave.mover_cima 71 | fim 72 | se Teclado.TECLA_PARA_BAIXO então 73 | nave.mover_baixo 74 | fim 75 | 76 | fim 77 | 78 | desenhe() 79 | fundo.desenhe(0, 0, 0) 80 | nave.desenhe 81 | para estrela em estrelas faça 82 | estrela.desenhe 83 | fim 84 | fim 85 | 86 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 87 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v11.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | tipo Jogador 4 | var x, y: Real 5 | imagem = Imagem("nave.png") 6 | var ângulo, vel_x, vel_y := 0.0 7 | 8 | cate_estrelas(estrelas: Lista[Estrela]) 9 | estrelas.selecione( 10 | estrela => Jogo.distância(x, y, estrela.x, estrela.y) > 35 11 | ) 12 | fim 13 | 14 | desenhe() 15 | imagem.desenhe_centralizado(x, y, 2, ângulo) 16 | fim 17 | 18 | girar_direita() 19 | ângulo := ângulo + 5 20 | fim 21 | 22 | girar_esquerda() 23 | ângulo := ângulo - 5 24 | fim 25 | 26 | acelerar() 27 | vel_x := vel_x + Jogo.projeção_X(ângulo, 0.5) 28 | vel_y := vel_y + Jogo.projeção_Y(ângulo, 0.5) 29 | fim 30 | 31 | mover() 32 | x := x + vel_x 33 | y := y + vel_y 34 | x := (x + 640) mod 640 35 | y := (y + 480) mod 480 36 | vel_x := vel_x * 0.95 37 | vel_y := vel_y * 0.95 38 | fim 39 | fim 40 | 41 | tipo Estrela 42 | cor = Cor.BRANCO 43 | x = aleatório(jogo.largura) 44 | y = aleatório(jogo.altura) 45 | imagens = Imagem.fatie("Estrela.png", 25, 25) 46 | 47 | desenhe() 48 | n = (Relógio.milisegundos div 100) mod imagens.tamanho + 1 49 | img = imagens[n] 50 | img.desenhe_centralizado(x, y, 1, 0) 51 | fim 52 | fim 53 | 54 | fundo = Imagem("Space.png") 55 | nave = Jogador(jogo.largura / 2, jogo.altura / 2) 56 | var estrelas = Lista(0, Estrela()) 57 | 58 | atualize() 59 | estrelas := nave.cate_estrelas(estrelas) 60 | se estrelas.tamanho < 25 e aleatório(100) < 4 então 61 | estrelas := Estrela() :: estrelas 62 | fim 63 | se Teclado.TECLA_PARA_DIREITA então 64 | nave.girar_direita 65 | fim 66 | se Teclado.TECLA_PARA_ESQUERDA então 67 | nave.girar_esquerda 68 | fim 69 | se Teclado.TECLA_PARA_CIMA então 70 | nave.acelerar 71 | fim 72 | nave.mover 73 | fim 74 | 75 | desenhe() 76 | fundo.desenhe(0, 0, 0) 77 | nave.desenhe 78 | para estrela em estrelas faça 79 | estrela.desenhe 80 | fim 81 | fim 82 | 83 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 84 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v12.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | tipo Jogador 4 | var x, y: Real 5 | imagem = Imagem("nave.png") 6 | var ângulo, vel_x, vel_y := 0.0 7 | var placar := 0 8 | 9 | cate_estrelas(estrelas: Lista[Estrela]) 10 | n = estrelas.tamanho 11 | estrelas_catadas = estrelas.selecione( 12 | estrela => Jogo.distância(x, y, estrela.x, estrela.y) > 35 13 | ) 14 | placar := placar + (n - estrelas_catadas.tamanho) * 10 15 | estrelas_catadas 16 | fim 17 | 18 | desenhe() 19 | imagem.desenhe_centralizado(x, y, 2, ângulo) 20 | fim 21 | 22 | girar_direita() 23 | ângulo := ângulo + 5 24 | fim 25 | 26 | girar_esquerda() 27 | ângulo := ângulo - 5 28 | fim 29 | 30 | acelerar() 31 | vel_x := vel_x + Jogo.projeção_X(ângulo, 0.5) 32 | vel_y := vel_y + Jogo.projeção_Y(ângulo, 0.5) 33 | fim 34 | 35 | mover() 36 | x := x + vel_x 37 | y := y + vel_y 38 | x := (x + 640) mod 640 39 | y := (y + 480) mod 480 40 | vel_x := vel_x * 0.95 41 | vel_y := vel_y * 0.95 42 | fim 43 | fim 44 | 45 | tipo Estrela 46 | cor = Cor.BRANCO 47 | x = aleatório(jogo.largura) 48 | y = aleatório(jogo.altura) 49 | imagens = Imagem.fatie("Estrela.png", 25, 25) 50 | 51 | desenhe() 52 | n = (Relógio.milisegundos div 100) mod imagens.tamanho + 1 53 | img = imagens[n] 54 | img.desenhe_centralizado(x, y, 1, 0) 55 | fim 56 | fim 57 | 58 | fundo = Imagem("Space.png") 59 | nave = Jogador(jogo.largura / 2, jogo.altura / 2) 60 | var estrelas = Lista(0, Estrela()) 61 | fonte = Fonte(16) 62 | 63 | atualize() 64 | estrelas := nave.cate_estrelas(estrelas) 65 | se estrelas.tamanho < 25 e aleatório(100) < 4 então 66 | estrelas := Estrela() :: estrelas 67 | fim 68 | se Teclado.TECLA_PARA_DIREITA então 69 | nave.girar_direita 70 | fim 71 | se Teclado.TECLA_PARA_ESQUERDA então 72 | nave.girar_esquerda 73 | fim 74 | se Teclado.TECLA_PARA_CIMA então 75 | nave.acelerar 76 | fim 77 | nave.mover 78 | fim 79 | 80 | desenhe() 81 | fundo.desenhe(0, 0, 0) 82 | nave.desenhe 83 | para estrela em estrelas faça 84 | estrela.desenhe 85 | fim 86 | fonte.desenhe("Placar: {nave.placar}", 10, 20, 3, Cor.AMARELO) 87 | fim 88 | 89 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 90 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v14.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | use "jogador.poti" 3 | use "estrela.poti" 4 | 5 | fundo = Imagem("Space.png") 6 | nave = Jogador(jogo.largura / 2, jogo.altura / 2) 7 | var estrelas := Lista(0, Estrela()) 8 | fonte = Fonte(16) 9 | var tempo := 0.0 10 | INICIO, JOGANDO, FIM = 1, 2, 3 11 | var estado := INICIO 12 | 13 | atualize() 14 | escolha estado 15 | caso INICIO => atualize_inicio 16 | caso JOGANDO => atualize_jogando 17 | caso FIM => atualize_fim 18 | fim 19 | fim 20 | 21 | desenhe() 22 | fundo.desenhe(0, 0, 0) 23 | escolha estado 24 | caso INICIO => desenhe_inicio 25 | caso JOGANDO => desenhe_jogando 26 | caso FIM => desenhe_fim 27 | fim 28 | fim 29 | 30 | # Estado Inicio 31 | atualize_inicio() 32 | se Teclado.TECLA_I então 33 | estado := JOGANDO 34 | fim 35 | fim 36 | 37 | desenhe_inicio() 38 | msg = "PRESSIONE [I] PARA COMECAR" 39 | a = jogo.largura / 2 40 | b = jogo.altura / 2 41 | fonte.desenhe_centralizado(msg, a, b, 3, Cor.AMARELO) 42 | fim 43 | 44 | # Estado Jogando 45 | atualize_jogando() 46 | estrelas := nave.cate_estrelas(estrelas) 47 | se estrelas.tamanho < 25 e aleatório(100) < 4 então 48 | estrelas := Estrela() :: estrelas 49 | fim 50 | se Teclado.TECLA_PARA_DIREITA então 51 | nave.girar_direita 52 | fim 53 | se Teclado.TECLA_PARA_ESQUERDA então 54 | nave.girar_esquerda 55 | fim 56 | se Teclado.TECLA_PARA_CIMA então 57 | nave.acelerar 58 | fim 59 | nave.mover 60 | tempo := tempo + 1.0 / 60.0 61 | se tempo >= 30.0 então 62 | estado := FIM 63 | fim 64 | fim 65 | 66 | desenhe_jogando() 67 | nave.desenhe 68 | para estrela em estrelas faça 69 | estrela.desenhe 70 | fim 71 | fonte.desenhe("Placar: {nave.placar}", 10, 20, 3, Cor.AMARELO) 72 | fonte.desenhe("Tempo: {tempo.inteiro}s", 10, 40, 3, Cor.AMARELO) 73 | fim 74 | 75 | #estado fim 76 | atualize_fim() 77 | se Teclado.TECLA_R então 78 | estrelas := Lista(0, Estrela()) 79 | tempo := 0.0 80 | estado := JOGANDO 81 | jogador.placar := 0 82 | fim 83 | fim 84 | 85 | desenhe_fim() 86 | msg = "FIM DE JOGO, VOCE FEZ {nave.placar} PONTOS" 87 | msg2 = "PRESSIONE [R] PARA RECOMECAR" 88 | a = jogo.largura / 2 89 | b = jogo.altura / 2 90 | fonte.desenhe_centralizado(msg, a, b, 3, Cor.AMARELO) 91 | fonte.desenhe_centralizado(msg2, a, b + 20, 3, Cor.AMARELO) 92 | fim 93 | 94 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 95 | -------------------------------------------------------------------------------- /src/main/scala/jerimum/Teclado.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | 3 | import java.awt.event.{ KeyEvent, KeyListener } 4 | import br.edu.ifrn.potigol.Potigolutil._ 5 | 6 | object Teclado extends KeyListener with TecladoLetras { 7 | protected[this] val teclas = new Array[Boolean](256) 8 | 9 | private[this] def update(e: KeyEvent, valor: Boolean) = { 10 | val cod = e.getKeyCode() 11 | if (cod >= 0 && cod < teclas.length) 12 | teclas(cod) = valor 13 | } 14 | 15 | override def keyPressed(e: KeyEvent) = this(e) = true 16 | 17 | override def keyReleased(e: KeyEvent) = this(e) = false 18 | 19 | override def keyTyped(e: KeyEvent) = {} 20 | } 21 | 22 | trait TecladoLetras { 23 | protected[this] val teclas: Array[Boolean] 24 | import java.awt.event.KeyEvent._ 25 | def TECLA_A: Lógico = teclas(VK_A) 26 | def TECLA_B: Lógico = teclas(VK_B) 27 | def TECLA_C: Lógico = teclas(VK_C) 28 | def TECLA_D: Lógico = teclas(VK_D) 29 | def TECLA_E: Lógico = teclas(VK_E) 30 | def TECLA_F: Lógico = teclas(VK_F) 31 | def TECLA_G: Lógico = teclas(VK_G) 32 | def TECLA_H: Lógico = teclas(VK_H) 33 | def TECLA_I: Lógico = teclas(VK_I) 34 | def TECLA_J: Lógico = teclas(VK_J) 35 | def TECLA_K: Lógico = teclas(VK_K) 36 | def TECLA_L: Lógico = teclas(VK_L) 37 | def TECLA_M: Lógico = teclas(VK_M) 38 | def TECLA_N: Lógico = teclas(VK_N) 39 | def TECLA_O: Lógico = teclas(VK_O) 40 | def TECLA_P: Lógico = teclas(VK_P) 41 | def TECLA_Q: Lógico = teclas(VK_Q) 42 | def TECLA_R: Lógico = teclas(VK_R) 43 | def TECLA_S: Lógico = teclas(VK_S) 44 | def TECLA_T: Lógico = teclas(VK_T) 45 | def TECLA_U: Lógico = teclas(VK_U) 46 | def TECLA_V: Lógico = teclas(VK_V) 47 | def TECLA_W: Lógico = teclas(VK_W) 48 | def TECLA_X: Lógico = teclas(VK_X) 49 | def TECLA_Y: Lógico = teclas(VK_Y) 50 | def TECLA_Z: Lógico = teclas(VK_Z) 51 | def TECLA_0: Lógico = teclas(VK_0) 52 | def TECLA_1: Lógico = teclas(VK_1) 53 | def TECLA_2: Lógico = teclas(VK_2) 54 | def TECLA_3: Lógico = teclas(VK_3) 55 | def TECLA_4: Lógico = teclas(VK_4) 56 | def TECLA_5: Lógico = teclas(VK_5) 57 | def TECLA_6: Lógico = teclas(VK_6) 58 | def TECLA_7: Lógico = teclas(VK_7) 59 | def TECLA_8: Lógico = teclas(VK_8) 60 | def TECLA_9: Lógico = teclas(VK_9) 61 | def TECLA_ESPACO: Lógico = teclas(VK_SPACE) 62 | def TECLA_ESPAÇO: Lógico = TECLA_ESPACO 63 | def TECLA_ENTER: Lógico = teclas(VK_ENTER) 64 | def TECLA_PARA_CIMA: Lógico = teclas(VK_UP) 65 | def TECLA_PARA_BAIXO: Lógico = teclas(VK_DOWN) 66 | def TECLA_PARA_ESQUERDA: Lógico = teclas(VK_LEFT) 67 | def TECLA_PARA_DIREITA: Lógico = teclas(VK_RIGHT) 68 | } -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/v15.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | use "jogador.poti" 3 | use "estrela.poti" 4 | 5 | fundo = Imagem("Space.png") 6 | nave1, nave2 = Jogador(jogo.largura / 2, jogo.altura / 2) 7 | var estrelas := Lista(0, Estrela()) 8 | fonte = Fonte(16) 9 | var tempo := 0.0 10 | INICIO, JOGANDO, FIM = 1, 2, 3 11 | var estado := INICIO 12 | 13 | atualize() 14 | escolha estado 15 | caso INICIO => atualize_inicio 16 | caso JOGANDO => atualize_jogando 17 | caso FIM => atualize_fim 18 | fim 19 | fim 20 | 21 | desenhe() 22 | fundo.desenhe(0, 0, 0) 23 | escolha estado 24 | caso INICIO => desenhe_inicio 25 | caso JOGANDO => desenhe_jogando 26 | caso FIM => desenhe_fim 27 | fim 28 | fim 29 | 30 | # Estado Inicio 31 | atualize_inicio() 32 | se Teclado.TECLA_I então 33 | estado := JOGANDO 34 | fim 35 | fim 36 | 37 | desenhe_inicio() 38 | msg = "PRESSIONE [I] PARA COMECAR" 39 | a = jogo.largura / 2 40 | b = jogo.altura / 2 41 | fonte.desenhe_centralizado(msg, a, b, 3, Cor.AMARELO) 42 | fim 43 | 44 | # Estado Jogando 45 | atualize_jogando() 46 | estrelas := nave1.cate_estrelas(estrelas) 47 | estrelas := nave2.cate_estrelas(estrelas) 48 | se estrelas.tamanho < 25 e aleatório(100) < 4 então 49 | estrelas := Estrela() :: estrelas 50 | fim 51 | # jogador 1 52 | se Teclado.TECLA_PARA_DIREITA então 53 | nave1.girar_direita 54 | fim 55 | se Teclado.TECLA_PARA_ESQUERDA então 56 | nave1.girar_esquerda 57 | fim 58 | se Teclado.TECLA_PARA_CIMA então 59 | nave1.acelerar 60 | fim 61 | 62 | #jogador 2 63 | se Teclado.TECLA_W então 64 | nave2.acelerar 65 | fim 66 | se Teclado.TECLA_A então 67 | nave2.girar_esquerda 68 | fim 69 | se Teclado.TECLA_D então 70 | nave2.girar_direita 71 | fim 72 | 73 | nave1.mover 74 | nave2.mover 75 | tempo := tempo + 1.0 / 60.0 76 | se tempo >= 30.0 então 77 | estado := FIM 78 | fim 79 | fim 80 | 81 | desenhe_jogando() 82 | nave1.desenhe 83 | nave2.desenhe 84 | para estrela em estrelas faça 85 | estrela.desenhe 86 | fim 87 | fonte.desenhe("Placar 1: {nave1.placar}", 10, 20, 3, Cor.AMARELO) 88 | fonte.desenhe("Tempo: {tempo.inteiro}s", 10, 40, 3, Cor.AMARELO) 89 | fonte.desenhe("Placar 2: {nave2.placar}", 10, 60, 3, Cor.AMARELO) 90 | fim 91 | 92 | #estado fim 93 | atualize_fim() 94 | se Teclado.TECLA_R então 95 | estrelas := Lista(0, Estrela()) 96 | tempo := 0.0 97 | estado := JOGANDO 98 | fim 99 | fim 100 | 101 | desenhe_fim() 102 | msg = "FIM DE JOGO, JOGADOR FEZ {nave1.placar} PONTOS" 103 | msg1 = "FIM DE JOGO, JOGADOR FEZ {nave2.placar} PONTOS" 104 | msg2 = "PRESSIONE [R] PARA RECOMECAR" 105 | a = jogo.largura / 2 106 | b = jogo.altura / 2 107 | fonte.desenhe_centralizado(msg, a, b, 3, Cor.AMARELO) 108 | fonte.desenhe_centralizado(msg1, a, b + 20, 3, Cor.AMARELO) 109 | fonte.desenhe_centralizado(msg2, a, b + 40, 3, Cor.AMARELO) 110 | fim 111 | 112 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 113 | -------------------------------------------------------------------------------- /src/main/scala/jerimum/Imagem.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | 3 | import java.awt.Graphics2D 4 | import java.awt.image.BufferedImage 5 | 6 | import scala.util.{ Failure, Success, Try } 7 | 8 | import br.edu.ifrn.potigol.Potigolutil.{ Inteiro, Lista, Real, Texto } 9 | import javax.imageio.ImageIO 10 | import java.io.File 11 | 12 | object Imagem { 13 | private[this] val vazia = new Imagem(new BufferedImage(200, 200, BufferedImage.TYPE_INT_RGB)) 14 | 15 | private[this] val imagens = collection.mutable.Map[String, Imagem]() 16 | private val listas = collection.mutable.Map[String, List[Imagem]]() 17 | 18 | def apply(caminho: Texto): Imagem = { 19 | imagens.get(caminho).getOrElse { 20 | Try { 21 | ImageIO.read(new File(caminho)) 22 | } map (new Imagem(_, caminho)) match { 23 | case Success(img) => 24 | imagens(caminho) = img 25 | img 26 | case Failure(msg) => 27 | println(msg) 28 | this.vazia 29 | } 30 | } 31 | } 32 | 33 | def fatie(caminho: Texto, x: Inteiro, y: Inteiro): Lista[Imagem] = { 34 | val id = s"$caminho $x $y" 35 | val l = listas.getOrElse(id, { 36 | val img = Imagem(caminho).buffer 37 | val lista = for ( 38 | j <- 0 until img.getHeight by y if (j + y <= img.getHeight); 39 | i <- 0 until img.getWidth by x if (i + x <= img.getWidth) 40 | ) yield { 41 | new Imagem(img.getSubimage(i, j, x, y)) 42 | } 43 | listas(id) = lista.toList 44 | listas(id) 45 | }) 46 | Lista(l) 47 | } 48 | } 49 | 50 | class Imagem(val buffer: BufferedImage, val caminho: String = "") { 51 | def largura = buffer.getWidth 52 | def altura = buffer.getHeight 53 | 54 | def fatie(x: Inteiro, y: Inteiro): Lista[Imagem] = { 55 | val id = s"$caminho $x $y" 56 | val l = Imagem.listas.getOrElse(id, { 57 | val img = buffer 58 | val lista = for ( 59 | j <- 0 until img.getHeight by y if (j + y <= img.getHeight); 60 | i <- 0 until img.getWidth by x if (i + x <= img.getWidth) 61 | ) yield { 62 | new Imagem(img.getSubimage(i, j, x, y)) 63 | } 64 | Imagem.listas(id) = lista.toList 65 | Imagem.listas(id) 66 | }) 67 | Lista(l) 68 | } 69 | 70 | private[this] def girar(g: Graphics2D, angulo: Double, x: Double, y: Double, scalaX: Double, scalaY: Double)(desenho: => Unit): Unit = { 71 | val old = g.getTransform() 72 | if (angulo != 0.0) g.rotate(Math.toRadians(angulo), x + buffer.getWidth / 2, y + buffer.getHeight / 2) 73 | desenho 74 | g.setTransform(old) 75 | } 76 | 77 | def desenhe(x: Real, y: Real, z: Inteiro, angulo: Real = 0.0, scalaX: Double = 1.0, scalaY: Double = 1.0): Unit = { 78 | Desenho.incluir(z, g => { 79 | girar(g, angulo, x, y, scalaX, scalaY) { 80 | val largura = (buffer.getWidth * scalaX).toInt 81 | val altura = (buffer.getHeight * scalaY).toInt 82 | val deltaX = if (largura < 0) -largura else 0 83 | val deltaY = if (altura < 0) -altura else 0 84 | g.drawImage(buffer, x.toInt + deltaX, y.toInt + deltaY, largura, altura, null) 85 | } 86 | }) 87 | } 88 | 89 | def desenhe_centralizado(x: Real, y: Real, z: Inteiro, angulo: Real = 0.0, scalaX: Double = 1.0, scalaY: Double = 1.0) = { 90 | desenhe(x - buffer.getWidth / 2, y - buffer.getHeight / 2, z, angulo, scalaX, scalaY) 91 | } 92 | } -------------------------------------------------------------------------------- /src/main/scala/jerimum/Jogo.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | 3 | import java.awt.Graphics2D 4 | 5 | import scala.util.{ Failure, Try } 6 | 7 | import br.edu.ifrn.potigol.Potigolutil.{ Inteiro, Real, Texto } 8 | 9 | object Jogo extends Runnable { 10 | var titulo: Texto = "Sem Nome" 11 | var largura: Inteiro = 640 12 | var altura: Inteiro = 480 13 | var fps: Inteiro = 60 14 | private[this] var display: Tela = _ 15 | private[this] var running = false 16 | private[this] var thread: Thread = _ 17 | 18 | private[this] var desenhe, atualize = () => {} 19 | 20 | private[this] def init() = { 21 | display = new Tela(titulo, largura, altura) { 22 | frame.addKeyListener(Teclado) 23 | frame.addMouseListener(Mouse) 24 | frame.addMouseMotionListener(Mouse) 25 | canvas.addMouseListener(Mouse) 26 | canvas.addMouseMotionListener(Mouse) 27 | } 28 | } 29 | 30 | private[this] def draw() = { 31 | Option(display.canvas.getBufferStrategy) match { 32 | case None => 33 | display.canvas.createBufferStrategy(3) 34 | case Some(strategy) => strategy.getDrawGraphics match { 35 | case g: Graphics2D => 36 | g.clearRect(0, 0, largura, altura) 37 | Desenho.desenhe(g) 38 | strategy.show 39 | g.dispose() 40 | } 41 | } 42 | } 43 | 44 | override def run() = { 45 | init() 46 | val frequencia = 1000000000.0 / fps 47 | var delta = 0.0 48 | var ultimo = System.nanoTime() 49 | var tempo = 0L 50 | var ciclos = 0 51 | while (running) { 52 | val agora = System.nanoTime() 53 | delta += (agora - ultimo) / frequencia 54 | tempo += agora - ultimo 55 | ultimo = agora 56 | if (delta >= 1) { 57 | atualize() 58 | draw() 59 | desenhe() 60 | ciclos += 1 61 | delta -= 1 62 | } 63 | if (tempo >= 1000000000) { 64 | ciclos = 0 65 | tempo = 0 66 | } 67 | } 68 | parar() 69 | } 70 | 71 | def iniciar(titulo: Texto = "Potigol com Jerimum", largura: Inteiro = 640, 72 | altura: Inteiro = 480, atualize: => Unit = {}, 73 | desenhe: => Unit = {}, fps: Inteiro = 60) = synchronized { 74 | this.titulo = titulo 75 | this.largura = largura 76 | this.altura = altura 77 | this.fps = fps 78 | this.atualize = atualize _ 79 | this.desenhe = desenhe _ 80 | if (!running) { 81 | running = true 82 | thread = new Thread(this) { 83 | start() 84 | } 85 | } 86 | } 87 | 88 | private[this] def parar() = synchronized { 89 | if (running) { 90 | running = false 91 | Try(thread.join()) match { 92 | case Failure(e) => e.printStackTrace() 93 | case _ => 94 | } 95 | } 96 | } 97 | 98 | def distância(x1: Real, y1: Real, x2: Real, y2: Real): Real = { 99 | Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2)) 100 | } 101 | val distancia = distância _ 102 | 103 | def projeção_X(angulo: Real, valor: Real): Real = { 104 | Math.sin(angulo * Math.PI / 180) * valor 105 | 106 | } 107 | 108 | def projeção_Y(angulo: Real, valor: Real): Real = { 109 | -Math.cos(angulo * Math.PI / 180) * valor 110 | } 111 | 112 | val projecao_X = projeção_X _ 113 | val projeçao_X = projeção_X _ 114 | val projecão_X = projeção_X _ 115 | val projecao_Y = projeção_Y _ 116 | val projeçao_Y = projeção_Y _ 117 | val projecão_Y = projeção_Y _ 118 | 119 | } -------------------------------------------------------------------------------- /src/main/scala/jerimum/Som.scala: -------------------------------------------------------------------------------- 1 | package jerimum 2 | 3 | import javax.sound.sampled.Clip 4 | import javax.sound.sampled.AudioSystem 5 | import br.edu.ifrn.potigol.Potigolutil._ 6 | import javax.sound.sampled.AudioInputStream 7 | import java.io.File 8 | import br.edu.ifrn.potigol.Potigolutil._ 9 | import javax.sound.sampled.AudioFormat 10 | import javax.sound.sampled.LineListener 11 | import javax.sound.sampled.LineEvent 12 | 13 | case class Musica(arquivo: Texto) extends AutoCloseable { 14 | private val original = AudioSystem.getAudioInputStream(new File(arquivo)) 15 | private val pcm = Musica.paraPcm16(original) 16 | private val clip = AudioSystem.getClip 17 | 18 | clip.open(pcm) 19 | 20 | private var posicaoPausada: Int = 0 21 | private var emLoop: Boolean = false 22 | 23 | clip.addLineListener(new LineListener { 24 | override def update(ev: LineEvent): Unit = { 25 | if (ev.getType == LineEvent.Type.STOP && !emLoop && 26 | clip.getFramePosition >= clip.getFrameLength) { 27 | clip.setFramePosition(0) 28 | } 29 | } 30 | }) 31 | 32 | def toque(loop: Lógico = verdadeiro): Unit = synchronized { 33 | emLoop = loop 34 | clip.stop() 35 | clip.setFramePosition(0) 36 | clip.loop(if (emLoop) Clip.LOOP_CONTINUOUSLY else 0) 37 | clip.start() 38 | } 39 | 40 | def tocando: Lógico = synchronized { clip.isRunning } 41 | 42 | def pare: Unit = synchronized { 43 | if (clip.isRunning) clip.stop() 44 | clip.setFramePosition(0) 45 | posicaoPausada = 0 46 | } 47 | 48 | def pause: Unit = synchronized { 49 | if (clip.isRunning) { 50 | posicaoPausada = clip.getFramePosition 51 | clip.stop() 52 | } 53 | } 54 | 55 | def pausado: Lógico = synchronized { 56 | !clip.isRunning && 57 | posicaoPausada > 0 && 58 | posicaoPausada < clip.getFrameLength 59 | } 60 | 61 | def continue: Unit = synchronized { 62 | if (!clip.isRunning) { 63 | if (posicaoPausada > 0 && posicaoPausada < clip.getFrameLength) { 64 | clip.setFramePosition(posicaoPausada) 65 | } else if (clip.getFramePosition >= clip.getFrameLength) { 66 | clip.setFramePosition(0) 67 | } 68 | clip.loop(if (emLoop) Clip.LOOP_CONTINUOUSLY else 0) 69 | clip.start() 70 | } 71 | } 72 | 73 | def feche(): Unit = close() 74 | 75 | override def close(): Unit = { 76 | try clip.stop() catch { case _: Throwable => } 77 | try clip.close() catch { case _: Throwable => } 78 | try pcm.close() catch { case _: Throwable => } 79 | try original.close() catch { case _: Throwable => } 80 | } 81 | } 82 | 83 | object Musica { 84 | def paraPcm16(in: AudioInputStream): AudioInputStream = { 85 | val f0 = in.getFormat 86 | val precisa = 87 | f0.getEncoding != AudioFormat.Encoding.PCM_SIGNED || 88 | f0.getSampleSizeInBits != 16 || 89 | f0.isBigEndian || 90 | f0.getFrameSize != f0.getChannels * 2 91 | 92 | if (!precisa) in 93 | else { 94 | val destino = new AudioFormat( 95 | AudioFormat.Encoding.PCM_SIGNED, 96 | f0.getSampleRate, 97 | 16, 98 | f0.getChannels, 99 | f0.getChannels * 2, 100 | f0.getSampleRate, 101 | false 102 | ) 103 | AudioSystem.getAudioInputStream(destino, in) 104 | } 105 | } 106 | } 107 | 108 | 109 | case class Som(arquivo: Texto) { 110 | private val original = AudioSystem.getAudioInputStream(new File(arquivo)) 111 | private val pcm = Musica.paraPcm16(original) 112 | private val clip = AudioSystem.getClip 113 | clip.open(pcm) 114 | 115 | def toque(): Unit = synchronized { 116 | clip.stop() 117 | clip.setFramePosition(0) 118 | clip.start() 119 | } 120 | 121 | def tocando: Lógico = synchronized { clip.isRunning } 122 | 123 | def pare: Unit = synchronized { 124 | if (clip.isRunning) clip.stop() 125 | } 126 | 127 | } 128 | 129 | -------------------------------------------------------------------------------- /potigol/CataEstrela.poti: -------------------------------------------------------------------------------- 1 | use "jerimum" 2 | 3 | beep = Som("beep.wav") 4 | som_fundo = Musica("space.wav") 5 | som_fundo.toque() 6 | 7 | # Tipos 8 | tipo Jogador 9 | var x, y: Real 10 | imagem = Imagem("Nave.png") 11 | var placar = 0 12 | var vel_x, vel_y = 0.0 13 | var angulo = 0.0 14 | 15 | desenhe() 16 | imagem.desenhe_centralizado(x, y, 3, angulo) 17 | fim 18 | 19 | girar_direita() 20 | angulo := angulo + 5.0 21 | fim 22 | 23 | girar_esquerda() 24 | angulo := angulo - 5.0 25 | fim 26 | 27 | acelerar() 28 | vel_x := vel_x + Jogo.projecao_X(angulo, 0.5) 29 | vel_y := vel_y + Jogo.projecao_Y(angulo, 0.5) 30 | fim 31 | 32 | mover() 33 | x := x + vel_x 34 | y := y + vel_y 35 | x := (jogo.largura + x) mod jogo.largura 36 | y := (jogo.altura + y) mod jogo.altura 37 | vel_x := vel_x * 0.95 38 | vel_y := vel_y * 0.95 39 | fim 40 | 41 | catar_estrelas(estrelas: Lista[Estrela]) 42 | catado = estrelas.selecione( 43 | estrela => Jogo.distância(x, y, estrela.x, estrela.y) >= 35 44 | ) 45 | n = estrelas.tamanho - catado.tamanho 46 | placar := placar + n * 10 47 | se n > 0 então 48 | beep.toque 49 | fim 50 | catado 51 | fim 52 | fim 53 | 54 | tipo Estrela 55 | cor: Cor 56 | x = aleatório(jogo.largura) 57 | y = aleatório(jogo.altura) 58 | imagens = Imagem.fatie("Estrela.png", 25, 25) 59 | 60 | desenhe() 61 | img = imagens[Relogio.milisegundos div 100 mod imagens.tamanho + 1] 62 | img.desenhe_centralizado(x, y, 1, 0) 63 | fim 64 | fim 65 | 66 | imagem_fundo = Imagem("Space.png") 67 | nave = Jogador(40, 40) 68 | var estado = "INICIO" 69 | var tempo := 0.0 70 | fonte = Fonte(16) 71 | 72 | var estrelas = Lista(1,Estrela(Cor.BRANCO)) 73 | 74 | para i de 1 até 10 faça 75 | estrelas := Estrela(Cor.BRANCO) :: estrelas 76 | fim 77 | 78 | desenhe() 79 | imagem_fundo.desenhe(0, 0, 0) 80 | escolha estado 81 | caso "INICIO" => desenhe_inicio 82 | caso "JOGANDO" => desenhe_jogando 83 | caso _ => desenhe_fim 84 | fim 85 | fim 86 | 87 | atualize() 88 | escolha estado 89 | caso "INICIO" => atualize_inicio 90 | caso "JOGANDO" => atualize_jogando 91 | caso _ => atualize_fim 92 | fim 93 | fim 94 | 95 | # Estado: inicio do jogo 96 | atualize_inicio() 97 | se Teclado.TECLA_I então estado := "JOGANDO" fim 98 | fim 99 | 100 | desenhe_inicio() 101 | msg = "PRESSIONE [I] PARA COMEÇAR" 102 | fonte.desenhe_centralizado(msg, jogo.largura / 2, jogo.altura / 2, 3, Cor.AMARELO) 103 | fim 104 | 105 | # Estado: JOGANDO 106 | atualize_jogando() 107 | # eventos 108 | se Teclado.TECLA_PARA_DIREITA então nave.girar_direita fim 109 | se Teclado.TECLA_PARA_ESQUERDA então nave.girar_esquerda fim 110 | se Teclado.TECLA_PARA_CIMA então nave.acelerar fim 111 | # inserir novas estrelas estrelas se necessario 112 | se aleatório(100) < 4 e estrelas.tamanho < 25 então 113 | estrelas := Estrela(Cor.BRANCO) :: estrelas 114 | fim 115 | 116 | estrelas := nave.catar_estrelas(estrelas) # catar estrelas 117 | nave.mover # atualizar a posicao do jogador 118 | tempo := tempo + 1.0/60.0 # incrementar o tempo 119 | se tempo.inteiro >= 30 então estado := "FIM" fim # terminar o jogo depois de 30 segundos 120 | fim 121 | 122 | desenhe_jogando() 123 | nave.desenhe 124 | para estrela em estrelas faça 125 | estrela.desenhe 126 | fim 127 | fonte.desenhe("Placar: {nave.placar}", 10, 20, 3, Cor.AMARELO) 128 | fonte.desenhe("Tempo: {tempo.inteiro}s", 10, 40, 3, Cor.AMARELO) 129 | fim 130 | 131 | # Estado: fim do jogo 132 | desenhe_fim() 133 | msg = "FIM DE JOGO, VOCE FEZ {nave.placar} PONTOS" 134 | fonte.desenhe_centralizado(msg, jogo.largura/2, jogo.altura/2, 3, Cor.AMARELO) 135 | fim 136 | 137 | atualize_fim() 138 | som_fundo.pare 139 | fim 140 | 141 | # Jogo 142 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 143 | -------------------------------------------------------------------------------- /src/exemplo/CataEstrela.scala: -------------------------------------------------------------------------------- 1 | package exemplo 2 | import jerimum._ 3 | import scala.util.Random 4 | import br.edu.ifrn.potigol.Potigolutil._ 5 | import br.edu.ifrn.potigol.Matematica._ 6 | 7 | object CataEstrela extends App { 8 | 9 | case class Jogador(var x: Real, var y: Real) { 10 | val imagem = Imagem("Nave.png") 11 | var placar = 0 12 | var vel_x, vel_y = 0.0 13 | var angulo = 0.0 14 | 15 | def desenhe() = { 16 | imagem.desenhe_centralizado(x, y, 3, angulo) 17 | } 18 | 19 | def girar_direita() = { 20 | angulo = angulo + 5.0 21 | } 22 | 23 | def girar_esquerda() = { 24 | angulo = angulo - 5.0 25 | } 26 | 27 | def acelerar() = { 28 | vel_x = vel_x + Jogo.projeção_X(angulo, 0.5) 29 | vel_y = vel_y + Jogo.projeção_Y(angulo, 0.5) 30 | } 31 | 32 | def mover() = { 33 | x = x + vel_x 34 | y = y + vel_y 35 | x = (jogo.largura + x) % jogo.largura 36 | y = (jogo.altura + y) % jogo.altura 37 | vel_x = vel_x * 0.95 38 | vel_y = vel_y * 0.95 39 | } 40 | 41 | def catar_estrelas(estrelas: Lista[Estrela]) = { 42 | val catado = estrelas.selecione { 43 | estrela => Jogo.distância(x, y, estrela.x, estrela.y) >= 35 44 | } 45 | val n = estrelas.size - catado.size 46 | placar = placar + n * 10 47 | catado 48 | } 49 | } 50 | 51 | case class Estrela() { 52 | val x = aleatório(jogo.largura) 53 | val y = aleatório(jogo.altura) 54 | val cor = Cor(aleatório(216) + 40, aleatório(216) + 40, aleatório(216) + 40) 55 | val imagens = Imagem.fatie("Estrela.png", 25, 25) 56 | val i = aleatório(imagens.tamanho) 57 | 58 | def desenhe() = { 59 | val imagem = imagens((Relogio.milisegundos / 100 + i) % imagens.tamanho) 60 | imagem.desenhe_centralizado(x, y, 1) 61 | } 62 | } 63 | 64 | val imagem_fundo = Imagem("Space.png") 65 | val nave = Jogador(jogo.largura / 2, jogo.altura / 2) 66 | var tempo = 0.0 67 | var estrelas = Lista(0, Estrela()) 68 | var estado = "INICIO" 69 | val fonte = Fonte(16) 70 | 71 | def atualize() = { 72 | estado match { 73 | case "INICIO" => atualize_inicio 74 | case "JOGANDO" => atualize_jogando 75 | case _ => atualize_fim 76 | } 77 | } 78 | 79 | def desenhe() = { 80 | imagem_fundo.desenhe(0, 0, 0) 81 | estado match { 82 | case "INICIO" => desenhe_inicio 83 | case "JOGANDO" => desenhe_jogando 84 | case _ => desenhe_fim 85 | } 86 | } 87 | 88 | // Estado Inicio 89 | def atualize_inicio() = { 90 | if (Teclado.TECLA_I) estado = "JOGANDO" 91 | } 92 | 93 | def desenhe_inicio() = { 94 | val msg = "PRESSIONE [ I ] PARA COMEÇAR" 95 | fonte.desenhe_centralizado(msg, jogo.largura / 2, jogo.altura / 2, 3, Cor.AMARELO) 96 | } 97 | 98 | // Estado Jogando 99 | def atualize_jogando() = { 100 | // eventos 101 | if (Teclado.TECLA_PARA_DIREITA) nave.girar_direita 102 | if (Teclado.TECLA_PARA_ESQUERDA) nave.girar_esquerda 103 | if (Teclado.TECLA_PARA_CIMA) nave.acelerar 104 | // inserir novas estrelas estrelas se necessario 105 | if (aleatório(100) < 4 && estrelas.tamanho < 25) { 106 | estrelas = Estrela() :: estrelas 107 | } 108 | 109 | estrelas = nave.catar_estrelas(estrelas) // catar estrelas 110 | nave.mover // atualizar a posicao do jogador 111 | tempo = tempo + 1.0 / 60.0 // incrementar o tempo 112 | if (tempo.inteiro >= 30) { 113 | estado = "FIM" // terminar o jogo depois de 30 segundos 114 | } 115 | } 116 | 117 | def desenhe_jogando() = { 118 | nave.desenhe 119 | for (estrela <- estrelas) { 120 | estrela.desenhe 121 | } 122 | fonte.desenhe(s"Placar: ${nave.placar}", 10, 20, 3, Cor.AMARELO) 123 | fonte.desenhe(s"Tempo: ${tempo.toInt}s", 10, 40, 3, Cor.AMARELO) 124 | } 125 | 126 | // Estado: fim do jogo 127 | def desenhe_fim() = { 128 | val msg = s"FIM DE JOGO, VOCE FEZ ${nave.placar} PONTOS" 129 | fonte.desenhe_centralizado(msg, jogo.largura / 2, jogo.altura / 2, 3, Cor.AMARELO) 130 | } 131 | 132 | def atualize_fim() = {} 133 | 134 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 135 | } 136 | -------------------------------------------------------------------------------- /docs/exemplos/cata-estrelas/index.md: -------------------------------------------------------------------------------- 1 | # Cata Estrelas 2 | 3 | 4 | 5 | ## Estrutura básica 6 | 7 | A estrutura básica de um jogo: 8 | 9 | - Um jogo que usa a biblioteca de jogos 2D Jerimum deve começar com a instrução `use "jerimum"` 10 | - O jogo precisa ter pelo menos duas funções. Uma chamada de `atualize()`, responsável pelo controle do jogo, e outra chamada `desenhe()` que é chamada para exibir os elementos gráficos na tela. 11 | - Para iniciar o jogo chamamos a função `iniciar` do objeto jogo informando o título, o tamanho da janela e as duas funções. 12 | 13 | ````scala 14 | use "jerimum" 15 | 16 | atualize() 17 | # Código para atualizar o jogo 18 | fim 19 | 20 | desenhe() 21 | # Código para desenhar o jogo 22 | fim 23 | 24 | jogo.iniciar("Título", 640, 480, atualize, desenhe) 25 | ```` 26 | Para executar digite `potigol v1.poti` na linha de comando. 27 | 28 | 29 | 30 | [código fonte](https://github.com/potigol/Jerimum/blob/master/docs/exemplos/cata-estrelas/v1.poti) 31 | 32 | 33 | 34 | ## Imagem 35 | 36 | Para carregar uma imagem usamos o tipo Imagem(arquivo: Texto), passando o nome do arquivo. O tipo Imagem possui uma operação chamada `desenhe(x, y: Real, z: Inteiro)` para desenhar a imagem em uma posição x, y na camada z. 37 | 38 | ### Camadas 39 | 40 | As camadas servem para definir a ordem de exibição das imagens. A Camada 0 é a que está mais ao fundo. As camadas maiores são 41 | desenhadas em cima das menores. 42 | 43 | Primeiro é desenhada a imagem de fundo, depois a imagem da nave. 44 | 45 | 46 | 47 | ````ruby 48 | use "jerimum" 49 | 50 | fundo = Imagem("Space.png") 51 | nave_imagem = Imagem("nave.png") 52 | 53 | atualize() 54 | fim 55 | 56 | desenhe() 57 | fundo.desenhe(0, 0, 0) 58 | nave_imagem.desenhe(300, 200, 2) 59 | fim 60 | 61 | jogo.iniciar("Título", 640, 480, atualize, desenhe) 62 | ```` 63 | 64 | 65 | 66 | [código fonte](https://github.com/potigol/Jerimum/blob/master/docs/exemplos/cata-estrelas/v3.poti) 67 | 68 | ## Movimento 69 | 70 | ````scala 71 | var nave_x = 300 72 | 73 | atualize() 74 | se Teclado.TECLA_PARA_DIREITA então 75 | nave_x := nave_x + 10 76 | fim 77 | se Teclado.TECLA_PARA_ESQUERDA então 78 | nave_x := nave_x - 10 79 | fim 80 | fim 81 | 82 | desenhe() 83 | nave_imagem.desenhe(nave_x, 200, 2) 84 | fim 85 | ```` 86 | [código fonte](v4.poti) 87 | 88 | ## Limitando os movimentos 89 | 90 | ````scala 91 | var nave_x = jogo.largura / 2 92 | 93 | atualize() 94 | se Teclado.TECLA_PARA_DIREITA então 95 | nave_x := nave_x + 10 96 | se nave_x > jogo.largura - 40 então 97 | nave_x := jogo.largura - 40 98 | fim 99 | fim 100 | se Teclado.TECLA_PARA_ESQUERDA então 101 | nave_x := nave_x - 10 102 | se nave_x < 10 então nave_x := 10 fim 103 | fim 104 | fim 105 | ```` 106 | [código fonte](v5.poti) 107 | 108 | ## Definindo Tipos 109 | 110 | ````scala 111 | tipo Jogador 112 | var x, y: Real 113 | imagem = Imagem("nave.png") 114 | 115 | desenhe() 116 | imagem.desenhe_centralizado(x, y, 2) 117 | fim 118 | 119 | mover_direita() 120 | x := x + 10 121 | se x > jogo.largura - 20 então 122 | x := jogo.largura - 20 123 | fim 124 | fim 125 | 126 | mover_esquerda() 127 | x := x - 10 128 | se x < 20 então 129 | x := 20 130 | fim 131 | fim 132 | fim 133 | 134 | nave = Jogador(jogo.largura / 2, jogo.altura / 2) 135 | 136 | atualize() 137 | se Teclado.TECLA_PARA_DIREITA então 138 | nave.mover_direita 139 | fim 140 | se Teclado.TECLA_PARA_ESQUERDA então 141 | nave.mover_esquerda 142 | fim 143 | fim 144 | 145 | desenhe() 146 | nave.desenhe 147 | fim 148 | ```` 149 | [código fonte](v7.poti) 150 | 151 | ## Listas 152 | 153 | ````scala 154 | tipo Estrela 155 | x = aleatório(jogo.largura) 156 | y = aleatório(jogo.altura) 157 | imagens = Imagem("Estrela.png").fatie(25, 25) 158 | 159 | desenhe() 160 | img = imagens[1] 161 | img.desenhe_centralizado(x, y, 1, 0) 162 | fim 163 | fim 164 | 165 | tipo Jogador 166 | cate_estrelas(estrelas: Lista[Estrela]) 167 | retorne estrelas.selecione(estrela => Jogo.distância(x, y, estrela.x, estrela.y) > 35) 168 | fim 169 | fim 170 | 171 | var estrelas = Lista(25, Estrela()) 172 | 173 | atualize() 174 | estrelas := nave.cate_estrelas(estrelas) 175 | se estrelas.tamanho < 25 e aleatório(100) < 4 então 176 | estrelas := Estrela() :: estrelas 177 | fim 178 | fim 179 | 180 | desenhe() 181 | para estrela em estrelas faça 182 | estrela.desenhe 183 | fim 184 | fim 185 | ```` 186 | [código fonte](v9.poti) 187 | 188 | ## Girando imagens 189 | 190 | ````scala 191 | tipo Jogador 192 | var ângulo, vel_x, vel_y := 0.0 193 | 194 | desenhe() 195 | imagem.desenhe_centralizado(x, y, 2, ângulo) 196 | fim 197 | 198 | girar_direita() 199 | ângulo := ângulo + 5 200 | fim 201 | 202 | girar_esquerda() 203 | ângulo := ângulo - 5 204 | fim 205 | 206 | acelerar() 207 | vel_x := vel_x + Jogo.projeção_X(ângulo, 0.5) 208 | vel_y := vel_y + Jogo.projeção_Y(ângulo, 0.5) 209 | fim 210 | 211 | mover() 212 | x := (x + vel_x + 640) mod 640 213 | y := (y + vel_y + 480) mod 480 214 | vel_x := vel_x * 0.95 215 | vel_y := vel_y * 0.95 216 | fim 217 | fim 218 | 219 | atualize() 220 | se Teclado.TECLA_PARA_DIREITA então 221 | nave.girar_direita 222 | fim 223 | se Teclado.TECLA_PARA_ESQUERDA então 224 | nave.girar_esquerda 225 | fim 226 | se Teclado.TECLA_PARA_CIMA então 227 | nave.acelerar 228 | fim 229 | nave.mover 230 | fim 231 | ```` 232 | [código fonte](v10.poti) 233 | 234 | ## Animação 235 | 236 | ````scala 237 | tipo Estrela 238 | imagens = Imagem.fatie("Estrela.png", 25, 25) 239 | 240 | desenhe() 241 | n = (Relógio.milisegundos div 100) mod imagens.tamanho + 1 242 | img = imagens[n] 243 | img.desenhe_centralizado(x, y, 1, 0) 244 | fim 245 | fim 246 | ```` 247 | [código fonte](v11.poti) 248 | 249 | ## Escrevendo na tela o placar 250 | 251 | ````scala 252 | tipo Jogador 253 | var placar := 0 254 | 255 | cate_estrelas(estrelas: Lista[Estrela]) 256 | n = estrelas.tamanho 257 | estrelas_catadas = estrelas.selecione( 258 | estrela => Jogo.distância(x, y, estrela.x, estrela.y) > 35 259 | ) 260 | placar := placar + (n - estrelas_catadas.tamanho) * 10 261 | retorne estrelas_catadas 262 | fim 263 | fim 264 | 265 | fonte = Fonte(16) 266 | 267 | atualize() 268 | estrelas := nave.cate_estrelas(estrelas) 269 | fim 270 | 271 | desenhe() 272 | fonte.desenhe("Placar: {nave.placar}", 10, 20, 3, Cor.AMARELO) 273 | fim 274 | ```` 275 | [código fonte](v12.poti) 276 | 277 | ## Separando o jogo em arquivos 278 | 279 | ### Arquivo `principal.poti` 280 | ````scala 281 | use "jerimum" 282 | use "jogador.poti" 283 | use "estrela.poti" 284 | 285 | fundo = Imagem("Space.png") 286 | nave = Jogador(jogo.largura / 2, jogo.altura / 2) 287 | var estrelas = Lista(0, Estrela()) 288 | fonte = Fonte(16) 289 | 290 | atualize() 291 | estrelas := nave.cate_estrelas(estrelas) 292 | se estrelas.tamanho < 25 e aleatório(100) < 4 então 293 | estrelas := Estrela() :: estrelas 294 | fim 295 | se Teclado.TECLA_PARA_DIREITA então 296 | nave.girar_direita 297 | fim 298 | se Teclado.TECLA_PARA_ESQUERDA então 299 | nave.girar_esquerda 300 | fim 301 | se Teclado.TECLA_PARA_CIMA então 302 | nave.acelerar 303 | fim 304 | nave.mover 305 | fim 306 | 307 | desenhe() 308 | fundo.desenhe(0, 0, 0) 309 | nave.desenhe 310 | para estrela em estrelas faça 311 | estrela.desenhe 312 | fim 313 | fonte.desenhe("Placar: {nave.placar}", 10, 20, 3, Cor.AMARELO) 314 | fim 315 | 316 | jogo.iniciar("Cata Estrelas", 640, 480, atualize, desenhe) 317 | ```` 318 | [código fonte](v13.poti) 319 | 320 | ### Arquivo `jogador.poti` 321 | ````scala 322 | tipo Jogador 323 | ... 324 | fim 325 | ```` 326 | [jogador.poti](jogador.poti) 327 | 328 | ### Arquivo `estrela.poti` 329 | ````scala 330 | tipo Estrela 331 | ... 332 | fim 333 | ```` 334 | [estrela.poti](estrela.poti) 335 | 336 | ## Fases 337 | 338 | ````scala 339 | INICIO, JOGANDO, FIM = 1, 2, 3 340 | var estado := INICIO 341 | 342 | atualize() 343 | escolha estado 344 | caso INICIO => atualize_inicio 345 | caso JOGANDO => atualize_jogando 346 | caso FIM => atualize_fim 347 | fim 348 | fim 349 | 350 | desenhe() 351 | fundo.desenhe(0, 0, 0) 352 | escolha estado 353 | caso INICIO => desenhe_inicio 354 | caso JOGANDO => desenhe_jogando 355 | caso FIM => desenhe_fim 356 | fim 357 | fim 358 | 359 | # Estado Inicio 360 | atualize_inicio() 361 | se Teclado.TECLA_I então 362 | estado := JOGANDO 363 | fim 364 | fim 365 | 366 | desenhe_inicio() 367 | msg = "PRESSIONE [I] PARA COMECAR" 368 | a = jogo.largura / 2 369 | b = jogo.altura / 2 370 | fonte.desenhe_centralizado(msg, a, b, 3, Cor.AMARELO) 371 | fim 372 | 373 | # Estado Jogando 374 | atualize_jogando() 375 | estrelas := nave.cate_estrelas(estrelas) 376 | se estrelas.tamanho < 25 e aleatório(100) < 4 então 377 | estrelas := Estrela() :: estrelas 378 | fim 379 | se Teclado.TECLA_PARA_DIREITA então 380 | nave.girar_direita 381 | fim 382 | se Teclado.TECLA_PARA_ESQUERDA então 383 | nave.girar_esquerda 384 | fim 385 | se Teclado.TECLA_PARA_CIMA então 386 | nave.acelerar 387 | fim 388 | nave.mover 389 | tempo := tempo + 1.0 / 60.0 390 | se tempo >= 30.0 então 391 | estado := FIM 392 | fim 393 | fim 394 | 395 | desenhe_jogando() 396 | nave.desenhe 397 | para estrela em estrelas faça 398 | estrela.desenhe 399 | fim 400 | fonte.desenhe("Placar: {nave.placar}", 10, 20, 3, Cor.AMARELO) 401 | fonte.desenhe("Tempo: {tempo.inteiro}s", 10, 40, 3, Cor.AMARELO) 402 | fim 403 | 404 | #estado fim 405 | atualize_fim() 406 | se Teclado.TECLA_R então 407 | estrelas := Lista(0, Estrela()) 408 | tempo := 0.0 409 | estado := JOGANDO 410 | jogador.placar := 0 411 | fim 412 | fim 413 | 414 | desenhe_fim() 415 | msg = "FIM DE JOGO, VOCE FEZ {nave.placar} PONTOS" 416 | msg2 = "PRESSIONE [R] PARA RECOMECAR" 417 | a = jogo.largura / 2 418 | b = jogo.altura / 2 419 | fonte.desenhe_centralizado(msg, a, b, 3, Cor.AMARELO) 420 | fonte.desenhe_centralizado(msg2, a, b + 20, 3, Cor.AMARELO) 421 | fim 422 | ```` 423 | [código fonte](v14.poti) 424 | 425 | ## Dois jogadores 426 | 427 | ````scala 428 | nave1, nave2 = Jogador(jogo.largura / 2, jogo.altura / 2) 429 | 430 | # Estado Jogando 431 | atualize_jogando() 432 | estrelas := nave1.cate_estrelas(estrelas) 433 | estrelas := nave2.cate_estrelas(estrelas) 434 | # jogador 1 435 | se Teclado.TECLA_PARA_DIREITA então 436 | nave1.girar_direita 437 | fim 438 | se Teclado.TECLA_PARA_ESQUERDA então 439 | nave1.girar_esquerda 440 | fim 441 | se Teclado.TECLA_PARA_CIMA então 442 | nave1.acelerar 443 | fim 444 | 445 | #jogador 2 446 | se Teclado.TECLA_W então 447 | nave2.acelerar 448 | fim 449 | se Teclado.TECLA_A então 450 | nave2.girar_esquerda 451 | fim 452 | se Teclado.TECLA_D então 453 | nave2.girar_direita 454 | fim 455 | 456 | nave1.mover 457 | nave2.mover 458 | fim 459 | 460 | desenhe_jogando() 461 | nave1.desenhe 462 | nave2.desenhe 463 | fonte.desenhe("Placar 1: {nave1.placar}", 10, 20, 3, Cor.AMARELO) 464 | fonte.desenhe("Tempo: {tempo.inteiro}s", 10, 40, 3, Cor.AMARELO) 465 | fonte.desenhe("Placar 2: {nave2.placar}", 10, 60, 3, Cor.AMARELO) 466 | fim 467 | 468 | desenhe_fim() 469 | msg = "FIM DE JOGO, JOGADOR FEZ {nave1.placar} PONTOS" 470 | msg1 = "FIM DE JOGO, JOGADOR FEZ {nave2.placar} PONTOS" 471 | msg2 = "PRESSIONE [R] PARA RECOMECAR" 472 | a = jogo.largura / 2 473 | b = jogo.altura / 2 474 | fonte.desenhe_centralizado(msg, a, b, 3, Cor.AMARELO) 475 | fonte.desenhe_centralizado(msg1, a, b + 20, 3, Cor.AMARELO) 476 | fonte.desenhe_centralizado(msg2, a, b + 40, 3, Cor.AMARELO) 477 | fim 478 | ```` 479 | [código fonte](v15.poti) 480 | --------------------------------------------------------------------------------