Introdução Bem-vindo Como Começar Meu Primeiro Programa     Resolvendo Problemas e Distribuindo Tranformando Dados Programas Interativos     Exercícios de Programação     Fazendo Games
Documentação Declarações     Procedimentos     Variáveis Construtores     Controle de Fluxo Expressões Bibliotecas     Print     IO     Random     Game Engine
Tutoriais Tutoriais Completos     Introdução à Programação     Guia Rápido     Exercícios de Programação     Programando Games

BIBLIOTECA: GAME ENGINE


Tudo Sobre a Biblioteca Game Engine (Motor de Jogos) no Vizzcode





Sobre a Biblioteca Game Engine

A biblioteca Game Engine é sua caixa de ferramentas completa para fazer jogos dentro do Vizzcode.
Ela possui todos os tipos de recursos para te ajudar a transformar sua imaginação virar realidade, programando jogos de verdade que você pode jogar e distribuir. Tudo desde renderização, áudio, sistemas de objetos, detecção de colisão e assim por diante. Essa biblioteca foi feita especificamente para ensiná-lo os fundamentos de programação de jogos. É essencial conhecer esses fundamentos, indepentende da engine que você possa vir a usar no futuro.

Essa página foca em mostrar tudo que está dentro da biblioteca, de uma forma mais técnica. Se você quiser aprender a fazer jogos, você pode conferir a página Fazendo Jogos ou os Tutoriais Completos.




Como Usar

Primeiro, você precisa importar a biblioteca:

#import
"GameEngine"

Ao fazer isso, o programa se torna uma aplicação de janela (em contrate com o modo padrão de aplicação de console). Isso significa que o prompt de comando não aparece mais quando você executar o programa, mas também significa que você tem possui formas diferentes de deixar seu software interativo.

Loop do Jogo

Conforme foi explicado com mais detalhes na página Fazendo Jogos e nos Tutoriais Completos, por conta dos jogadores interagirem de forma contínua com o jogo, você precisa criar um loop básico para o jogo.
O Loop do Jogo (Game Loop) é responsável por gerar um frame que o usuário vai ver na tela e atualizar o jogo de acordo com a entrada (input). O Loop do Jogo usando a biblioteca Game Engine fica dessa forma:
#import
"GameEngine"


main
:: () {
    
while
game_is_running
() {
    }
}

Criando um Game Loop com programação visual no Vizzcode

A ideia básica é que enquanto o jogo tiver rodando (while the game is running), certas coisas vão acontecer. O que vai acontecer depende do jogo, pode ser atirar uma bala, pode ser testar se o inimigo está morto e assim por diante
Não deixe de conferir a página Fazendo Jogos e os Tutoriais Completos para exemplos e tutoriais.

As seções a seguir vão explicar em detalhe cada procedimento que você pode usar para interagir com a biblioteca Game Engine.




API Parte 1: Recursos Básicos e Entrada de Dados

game_is_running

Essa é a declaração do procedimento game_is_running:
game_is_running
:: () -> is_running :
bool
{

Esse procedimento deve ser chamado no início de cada interação do Loop do Jogo.
Ele atualiza as entidades conforme específico no frame anterior, gera e mostra o frame e lê a entrada de dados para o próximo frame.
Ele retorna se o jogo deve continuar rodando ou não. O jogo para de rodar se o usuário fechar a janela, por exemplo.

Você pode usá-lo dessa forma:
#import
"GameEngine"


main
:: () {
    
while
game_is_running
() {
    }
}

Criando um Game Loop com programação visual no Vizzcode



set_window_options

Essa é a declaração do procedimento set_window_options:
set_window_options
:: (title :=
"Game"
, full_screen :=
false
, tamanho_x :=
1280
, tamanho_y :=
720
) {

A declaração do procedimento set_window_options

Esse procedimento deve ser chamado antes da primeira interação do Loop do Jogo (antes de chamar o game_is_running pela primeira vez).
Ele pode definir várias configurações da janela.
O parâmetro title (título) muda o nome da janela.
O parâmetro full_screen (tela cheia) específica se o jogo deve ser aberto no modo de tela cheia. (Se não, ele abre como uma janela sobreposta.
Os valores size_x (tamanho_x) e size_y (tamanho_y) são usados para definir o tamanho da janela. Eles são ignorados se a janela abrir em tela toda.
#import
"GameEngine"


main
:: () {
    
set_window_options
(
"Meu Jogo Incrível!"
,
true
);
    
while
game_is_running
() {
    }
}



Configurando as opções da janela no Motor de Jogos do Vizzcode

hide_cursor

Essa é a declaração do procedimento hide_cursor:
hide_cursor
:: () {

Esse procedimento é usado para esconder o cursor (pontinho do mouse) padrão do sistema operacional.
A posição do cursos ainda pode ser consultada com o get_mouse_position e set_mouse_position, bem como o object_is_under_cursor.
É comum em jogos esconder o cursor padrão do sistema operacional e desenhar um bitmap(draw_bitmap) próprio na posição do cursor.
#import
"GameEngine"


main
:: () {
    
hide_cursor
();
    
while
game_is_running
() {
    }
}

Escondendo o cursor no Motor de Jogos do Vizzcode



get_delta_seconds

Essa é a declaração do procedimento get_delta_seconds:
get_delta_seconds
:: () -> delta_seconds :
float
{

Esse procedimento retorna quanto tempo passou (em segundos) na última vez que o Loop do Jogo rodou.
Ele foi feito para ser chamado dentro do Loop do Jogo. Na primeira interação do loop ele retorna o valor 0.01666 porque rodar o monitor na frequência de 60Hz é o mais comum na configuração dos usuários.

O valor de delta_seconds deve ser usado para fazer um movimento independente do frame-rate. Por exemplo: Se você mover uma unidade para a direita todo frame o movimento vai depender de como o usuário está rodando o jogo (frame rates maiores iriam resultar em objetos mais rápidos). Para evitar isso, você pode multiplicar a unidade por delta_seconds resultando em quantas unidades o objeto move em um segundo.
Outro uso bem importante de delta_seconds é a criação de cronômetros. Ao adicionar esse valor em uma variável todo segundo você cria um cronômetro.
Note que os valores de delta_seconds são limitados em 0.05s. Isso significa que mesmo que por alguma razão um frame demore mais que isso, esse é o valor que vai ser retornado. Isso é feito para evitar que valores muito grandes estraguem a atualização da física.

Aqui está um exemplo de seu uso:
#import
"GameEngine"


main
:: () {
    
while
game_is_running
() {
        delta_seconds :=
get_delta_seconds
();
    }
}

Usando o procedimento get_delta_seconds na Game Engine do Vizzcode



get_current_time

Essa é a declaração do procedimento get_current_time:
get_current_time
:: () -> game_time_in_seconds :
float
{

Esse procedimento retorna quanto tempo passou desde o início do jogo.
Se você adicionar o delta_seconds (veja get_delta_seconds) todo frame, você deve encontrar o mesmo valor.
Ele foi feito para ser chamado dentro do Loop do Jogo.
Esse valor é bem útil para a criação de cronômetros.
#import
"GameEngine"


main
:: () {
    
while
game_is_running
() {
        tempo_que_passou :=
get_current_time
();
    }
}


random_int_in_range

Essa é a declaração do procedimento random_int_in_range:
random_int_in_range
:: (min_incluindo :=
0
, max_incluindo :=
10
) -> valor_aleatorio :
int
{

Esse procedimento é exatamente o mesmo que na biblioteca Random.
Esse procedimento gera e retorna um número inteiro aleatório dentro do intervalo especificado.
O intervalo é inclusivo, o que significa que o número mínimo e máximo do intervalo pode aparecer no resultado aleatório.
#import
"GameEngine"


main
:: () {
    aleatorio :=
random_int_in_range
(
0
,
10
);
}

Um exemplo de random_int_in_range



random_float_in_range

Essa é a declaração do procedimento random_float_in_range:
random_float_in_range
:: (min_incluindo :=
0.0
, max_incluindo :=
1.0
) -> valor_aleatorio :
float
{

Esse procedimento é exatamente o mesmo que na biblioteca Random.
Esse procedimento gera e retorna um número float aleatório dentro de um intervalo especificado.
O intervalo é inclusivo, o que significa que o número mínimo e máximo do intervalo podem aparecer no resultado aleatório.
Ele funciona da mesma forma que o procedimento random_int_in_range.
#import
"GameEngine"


main
:: () {
    aleatorio :=
random_float_in_range
(
-10.0
,
10.0
);
}

Um exemplo de random_float_in_range



button_is_down

Essa é a declaração do procedimento button_is_down:
button_is_down
:: (button :=
"space"
) -> is_down :
bool
{

Esse é um dos três procedimentos para consultar a entrada do teclado (e do botão do mouse). Os outros são button_pressed e button_released.
O parâmetro é um valor do tipo string contendo um dos seguintes valores:
  • up: A seta do teclado para CIMA
  • down: A seta do teclado para BAIXO
  • left: A seta do teclado para a ESQUERDA
  • right: A seta do teclado para a DIREITA
  • w: A tecla W
  • a: A tecla A
  • s: A tecla S
  • d: A tecla D
  • f: A tecla F
  • r: A tecla R
  • e: A tecla E
  • q: A tecla Q
  • z: A tecla Z
  • c: A tecla C
  • x: A tecla X
  • v: A tecla V
  • 1: A tecla 1
  • 2: A tecla 2
  • 3: A tecla 3
  • 4: A tecla 4
  • 5: A tecla 5
  • 6: A tecla 6
  • 7: A tecla 7
  • 8: A tecla 8
  • 9: A tecla 9
  • 0: A tecla 0
  • space: A tecla BARRA DE ESPAÇO
  • shift: A tecla SHIFT
  • ctrl: A tecla CTRL
  • enter: A tecla ENTER
  • tab: A tecla TAB
  • escape: A tecla ESQ
  • lmb: O BOTÃO ESQUERDO DO MOUSE
  • rmb: O BOTÃO DIREITO DO MOUSE
O procedimento retorno true (verdadeiro) se o usuário estiver apertando o botão naquele frame.
Por exemplo, se o usuário segurar a Tecla por 10 frames consecutivos, o procedimento vai retornar true para esses 10 frames e false para o resto dos frames (porque o botão não está apertado – button_is_down).
Ele foi feito para ser chamado dentro do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    
while
game_is_running
() {
        
if
button_is_down
(
"enter"
) {
            
draw_rectangle
();
        }
    }
}

Lendo input do usuário dentro do game



button_pressed

Essa é a declaração do procedimento button_pressed:
button_pressed
:: (button :=
"space"
) -> pressed :
bool
{

Esse é um dos três procedimentos para consultar a entrada do teclado (e botão do mouse). Os outros são button_is_down e button_released.
O parâmetro é uma string contend um dos seguintes valores:
  • up: A seta do teclado para CIMA
  • down: A seta do teclado para BAIXO
  • left: A seta do teclado para a ESQUERDA
  • right: A seta do teclado para a DIREITA
  • w: A tecla W
  • a: A tecla A
  • s: A tecla S
  • d: A tecla D
  • f: A tecla F
  • r: A tecla R
  • e: A tecla E
  • q: A tecla Q
  • z: A tecla Z
  • c: A tecla C
  • x: A tecla X
  • v: A tecla V
  • 1: A tecla 1
  • 2: A tecla 2
  • 3: A tecla 3
  • 4: A tecla 4
  • 5: A tecla 5
  • 6: A tecla 6
  • 7: A tecla 7
  • 8: A tecla 8
  • 9: A tecla 9
  • 0: A tecla 0
  • space: A tecla BARRA DE ESPAÇO
  • shift: A tecla SHIFT
  • ctrl: A tecla CTRL
  • enter: A tecla ENTER
  • tab: A tecla TAB
  • escape: A tecla ESQ
  • lmb: O BOTÃO ESQUERDO DO MOUSE
  • rmb: O BOTÃO DIREITO DO MOUSE
O procedimento retorna true (verdadeiro) no frame que o usuário começou a apertar o botão.
Por exemplo, se o usuário segurar a tecla por 10 frames consecutivos, o procedimento vai retornar true no primeiro frame nessa sequência de 10 frames (o frame que o usuário começou a apertar o botão) e false nos resto dos frames.
Ele foi feito para ser chamado dentro do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    ...
    
while
game_is_running
() {
        
if
button_pressed
(
"enter"
) {
            
spawn_particles
(...);
        }
    }
}



button_released

Essa é a declaração do procedimento button_released:
button_released
:: (button :=
"space"
) -> released :
bool
{

Esse é um dos três procedimentos para consultar a entrada do teclado (e do botão do mouse). Os outros são button_is_down e button_pressed.
O parâmetro é uma string contendo um dos seguintes valores:
  • up: A seta do teclado para CIMA
  • down: A seta do teclado para BAIXO
  • left: A seta do teclado para a ESQUERDA
  • right: A seta do teclado para a DIREITA
  • w: A tecla W
  • a: A tecla A
  • s: A tecla S
  • d: A tecla D
  • f: A tecla F
  • r: A tecla R
  • e: A tecla E
  • q: A tecla Q
  • z: A tecla Z
  • c: A tecla C
  • x: A tecla X
  • v: A tecla V
  • 1: A tecla 1
  • 2: A tecla 2
  • 3: A tecla 3
  • 4: A tecla 4
  • 5: A tecla 5
  • 6: A tecla 6
  • 7: A tecla 7
  • 8: A tecla 8
  • 9: A tecla 9
  • 0: A tecla 0
  • space: A tecla BARRA DE ESPAÇO
  • shift: A tecla SHIFT
  • ctrl: A tecla CTRL
  • enter: A tecla ENTER
  • tab: A tecla TAB
  • escape: A tecla ESQ
  • lmb: O BOTÃO ESQUERDO DO MOUSE
  • rmb: O BOTÃO DIREITO DO MOUSE
O procedimento retorna true (verdadeiro) no frame que o usuário soltar o botão.
Por exemplo, se o usuário segurar o botão por 10 frames consecutivos, e depois soltar o botão no frame de número 11, o procedimento vai retornar true somente no frame número 11 (o frame que o usuário soltou o botão depois de segurar por um tempo) e false nos outros frames.
Ele foi feito para ser chamado dentro do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    ...
    
while
game_is_running
() {
        
if
button_released
(
"enter"
) {
            
spawn_particles
(...);
        }
    }
}



get_mouse_position

Essa é a declaração do procedimento get_mouse_position:
get_mouse_position
:: () -> position_x :
float
, position_y :
float
{

O procedimento retorna a posição x e y de tipo float do cursos do mouse naquele frame.
Ele está com as unidades padrão (espaço do mundo), e não no espaço de pixel.
Para recuperar ambos os valores retornados (como sempre) você precisa usar uma declaração composta. Você pode aprender sobre múltiplos valores retornados aqui. Você pode definir o cursor do mouse com o procedimento set_mouse_position.
Ele foi feito para ser chamado dentro do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    
while
game_is_running
() {
        mouse_x, mouse_y :=
get_mouse_position
();
        
draw_rectangle
(mouse_x, mouse_y);
    }
}

Pegando a posição do mouse



set_mouse_position

Essa é a declaração do procedimento set_mouse_position:
set_mouse_position
:: (x :=
0.0
, y :=
0.0
) {

O procedimento move o cursor do mouse para a posição especificada.
Ele está com as unidades padrão (espaço do mundo), e não no espaço de pixel.
Se você definir a posição do cursor do mouse todo frame, você vai “bloquear” o cursor do mouse em um lugar.
É muito comum usar isso em jogos para bloquear o mouse no centro da tela (0,0) e apenas considerar o movimento delta do mouse. Isso vai garantir que o mouse nunca fique “preso” em uma das bordas da tela, porque ele é “resetado” todo frame para o centro.

Você pode obter o cursor do mouse com o procedimento get_mouse_position.
Ele foi feito para ser chamado dentro do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    
while
game_is_running
() {
        
set_mouse_position
();
    }
}





API Parte 2: Desenho Imediato

clear_screen

Essa é a declaração do procedimento clear_screen:
clear_screen
:: (color_red :=
1.0
, color_green :=
1.0
, color_blue :=
1.0
) {

Pintando a tela com uma cor sólida no jogo

Esse procedimento pinta imediatamente a área inteira da tela com uma cor sólida.
Ele usa as cores RGB de 0 a 1.
Assim como as outras rotinas de desenho imediato, esse procedimento é desenhado no momento que ele for chamado dentro do frame, antes de desenhar os objetos.
Ele foi feito para ser chamado dentro do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    
while
game_is_running
() {
        
clear_screen
(
.2
,
1
,
.75
);
    }
}


draw_rectangle

Essa é a declaração do procedimento draw_rectangle:
draw_rectangle
:: (position_x :=
0.0
, position_y :=
0.0
, size_x :=
5.0
, size_y :=
5.0
, color_red :=
1.0
, color_green :=
1.0
, color_blue :=
1.0
, color_alpha :=
1.0
) {


Como desenhar um retângulo na tela no Vizzcode

Esse procedimento desenha imediatamente um retângulo na tela com uma cor sólida.
Ele usa coordenadas padrão (do mundo). As cores são cores RGB de 0 a 1.
O componente alfa da cor controla a opacidade do retângulo - onde 0.0 é totalmente transparente e 1.0 totalmente opaco.
Assim com as outras rotinas de desenho imediato, esse procedimento é desenhado no momento que é chamado dentro do frame, antes de desenhar os objetos.
Ele foi feito para ser chamado dentro do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    
while
game_is_running
() {
        
draw_rectangle
(posicao_x=
10
, posicao_y=
-5.5
, tamanho_x=
2
, tamanho_y=
8
, cor_vermelha=
0.5
, cor_verde=
1
, cor_azul=
0.25
, cor_alfa=
0.5
);
    }
}


draw_bitmap

Essa é a declaração do procedimento draw_bitmap:
draw_bitmap
:: (file_name :=
"file.png"
, position_x :=
0.0
, position_y :=
0.0
, size :=
5.0
) {


Como desenhar uma imagem na tela do usuário com o Vizzcode

Esse procedimento desenha imediatamente uma imagem específica na tela.
A imagem precisa estar no formato .png.
A imagem procura pela imagem no caminho específico relativo ao executável (ou onde o diretório da aplicação estiver). Se nenhuma imagem PNG válida for encontrada, o procedimento não desenha nada.
Esse procedimento usa coordenadas padrão (do mundo).
Esse procedimento é ótimo para desenhar elementos de background (fundo de tela).
Eles também são muito úteis se você quiser a Game Engine como uma ferramenta de renderização e desconsiderar seu sistema de objetos completamente.
Assim como outras rotinas de desenho imediato, esse procedimento é desenhado no momento que for chamado dentro do frame, antes de desenhar os objetos.
Ele foi feito para ser chamado dentro do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    
while
game_is_running
() {
        
draw_image
(
"assets/background.png"
);
    }
}


draw_text

Essa é a declaração do procedimento draw_text:
draw_text
:: (text :=
"Hello!"
, position_x :=
0.0
, position_y :=
0.0
, size :=
5.0
) {

Como desenhar um texto na tela no Vizzcode

Esse procedimento desenha imediatamente uma string de texto em uma localização específica da tela.
Ele usa coordenadas padrão (do mundo).
Esse procedimento é ótimo para prototipar menus e interfaces de usuário antes de implementar a arte final (que pode ser uma imagem png, por exemplo).
Assim como as outras rotinas de desenho imediato, esse procedimento é desenhado no momento que for chamado dentro do frame, antes de desenhar os objetos.
Ele foi feito para ser chamado dentro do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    
while
game_is_running
() {
        
draw_text
(
"Texto Bacana!"
);
    }
}


draw_int

Essa é a declaração do procedimento draw_int:
draw_int
:: (value_to_draw :
int
, position_x :=
0.0
, position_y :=
0.0
, size :=
5.0
) {

Como desenhar um número na tela do usuário com o Vizzcode

Esse procedimento desenha imediatamente qualquer valor inteiro em uma localização específica da tela.
Ele usa coordenadas padrão (do mundo).
Assim como as outras rotinas de desenho imediato, esse procedimento é desenhado no momento que for chamado dentro do frame, antes de desenhar os objetos.
Ele foi feito para ser chamado dentro do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    resultado :=
0
;
    
while
game_is_running
() {
        
draw_int
(resultado);
    }
}


draw_float

Essa é a declaração do procedimento draw_float:
draw_float
:: (value_to_draw :
float
, position_x :=
0.0
, position_y :=
0.0
, size :=
5.0
, number_of_decimals :=
2
) {

Como desenhar um número decimal (float) na tela do usuário com o Vizzcode

Esse procedimento desenha imediatamente qualquer valor do tipo float em uma localização específica da tela.
Ele usa coordenadas padrão (do mundo).
Você pode especificar o número de dígitos decimais que deseja mostrar.
Assim como as outras rotinas de desenho imediato, esse procedimento é desenhado no momento que for chamado dentro do frame, antes de desenhar os objetos.
Ele foi feito para ser chamado dentro do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    algum_float :=
random_float_in_range
(
1.0
,
2.0
);
    
while
game_is_running
() {
        
draw_float
(algum_float);
    }
}




API Parte 3: Som e Sistema Básico de Objetos

play_sound

Essa é a declaração do procedimento play_sound:
play_sound
:: (file_name :=
"file.wav"
, looping_sound :=
false
, variation :=
0.0
, volume :=
1.0
) -> sound_id :
int
{

Como tocar um arquivo de áudio no jogo com o Vizzcode

Esse procedimento toca um arquivo de som, com várias opções.
O arquivo de som precisa estar no formato PCM .wav, codificado a 44.110Hz com 1 ou 2 canais.
O procedimento procura pelo arquivo de som no caminho especificado relativo ao executável (ou onde o diretório da aplicação está). Se nenhum arquivo de som WAV válido for encontrado, o procedimento não toca nada.
Você pode definir o parâmetro som_em_loop para verdadeiro e o som vai recomeçar quando ele terminar. Esse parâmetro é ótimo para arquivos de música que devem ficar tocando enquanto o jogo tiver rodando.
O parâmetro variação vai adicionar um valor aleatório para o volume e para o pitch do som. Esse parâmetro é bem útil para sons repetidos (como tiros, explosões, etc) para que o sons não fiquem repetitivos e maçante. A variação do pitch vai acelerar ou desacelerar o som para atingir a mudança do pitch desejada. O parâmetro do volume deve ser definido de 0 (completamente mudo) até 1 (volume normal) ou um pouco maior que 1 para soar mais alto. Se você definir o volume para um valor muito maior, ele pode começar a “clipar”.
O procedimento retorna um ID para o som (também referido como handle (lidar com)). Esse ID pode ser passado para o set_sound_volume para mudar o volume de um som existente.
Esse procedimento pode ser chamado em qualquer lugar do programa.
#import
"GameEngine"


main
:: () {
    
play_sound
(
"epic_music.wav"
);
    
while
game_is_running
() {
    }
}


set_sound_volume

Essa é a declaração do procedimento set_sound_volume:
set_sound_value
:: (sound_id :
int
, volume :=
0.0
, fading_speed :=
3.0
) {

Como mudar o volume de um som que está tocando com o Vizzcode

Esse procedimento muda o volume de um som que está tocando.
O som já precisa estar tocando com o procedimento play_sound. O valor retornado de play_sound é o valor que precisa ser passado como o parâmetro id_som para modificar o som.
O parâmetro do volume funciona da mesma forma que o parâmetro play_sound: ele precisa ser definido de 0 (completamente mudo) até 1 (volume normal) ou um pouco maior que 1 para soar mais alto. Se você definir o volume para um valor muito maior, ele pode começar a “clipar”.
O parâmetro velocidade_de_fading pode ser mudado para fazer o volume mudar mais rápido ou devagar. Quanto maior o parâmetro velocidade_de_fading, mais rápido o som vai caminhar para o novo volume especificado.
Esse procedimento pode ser chamado em qualquer lugar do programa.
#import
"GameEngine"


main
:: () {
    musica :=
play_sound
(
"musica_epica.wav"
);
    
while
game_is_running
() {
        
if
button_pressed
() {
            
set_sound_volume
(musica,
0
);
        }
    }
}


create_object

Essa é a declaração do procedimento create_object:
create_object
:: (size_x :
5.0
, size_y :=
5.0
) -> object_id :
int
{

Como criar um object no jogo usando Vizzcode

Esse é o procedimento base para usar o sistema de objetos da Game Engine.
O sistema de objetos é muito útil para gerenciar objetos no jogo. Esses objetos (também conhecidos com atores ou entidades) podem ser especificados e depois simulados pela game engine. Você pode, em seguida, consultar a colisão desses objetos, especificar como eles se parecem ou movem.

O procedimento create_object é o primeiro procedimento a ser chamado para usar o sistema de objetos.
Você pode especificar o tamanho do objeto com esse procedimento. (Se você associar uma imagem com esse objeto mais para frente, você pode usar as dimensões da imagem; nesse caso você pode ignorar o tamanho do create_object.
Esse procedimento retornar o id do objeto (também conhecido como handle (lidar com)). Salvar esse id em uma variável é extremamente importante para ser capaz de especificar parâmetros adicionais para o objeto bem como criar (spwan) ele.

Spawning (Criar) o objeto é uma parte extremamente necessária do sistema de objetos, o procedimento create_object apenas cria um “canvas em branco” para você especificar parâmetros adicionais para o objeto bem como criar (spawn) ele.
Esse procedimento deve ser chamado antes do Loop do Jogo.
#import
"GameEngine"


main
:: () {
    game_object :=
create_object
();
    
while
game_is_running
() {
    }
}


spawn_object

Essa é a declaração do procedimento spawn_object:
spawn_object
:: (object_id :
int
, position_x :=
0.0
, position_y :=
0.0
) -> instance_id :
int
{

Como instanciar um objecto no jogo usando o Vizzcode

Esse procedimento cria uma instância de um objeto no mundo do jogo.
O objeto já precisa ter sido criado com o procedimento create_object. O valor retornado do create_object deve ser enviado para o parâmetro id_objeto.

Ao chamar o spawn_object, uma instância do objeto vai ser criada no mundo na posição especificada.
Esse procedimento pode ser chamado em qualquer lugar do programa.
#import
"GameEngine"


main
:: () {
    objeto_do_jogo :=
create_object
();
    
spawn_object
(objeto_do_jogo,
10
,
-20
);
    
while
game_is_running
() {
    }
}


destroy_instance

Essa é a declaração do procedimento destroy_instance:
destroy_instance
:: (instance_id :
int
) {

Como destruir um objeto no jogo usando o Vizzcode

Esse procedimento destrói uma instância de um objeto que existe no mundo do jogo.
Você pode obter o id da instância salvando o valor retornado do spawn_object ou chamando algum dos procedimentos de consulta de instância (get_first_instance, get_random_instance, get_next_instance).
#import
"GameEngine"


main
:: () {
    objeto_do_jogo :=
create_object
();
    id_instancia :=
spawn_object
(objeto_do_jogo,
10
,
-20
);
    
while
game_is_running
() {
        
if
button_pressed
() {
            
destroy_instance
(id_instancia);
        }
    }
}

Um exemplo funcional de um jogo onde você destrói objetos



get_instance_count

Essa é a declaração do procedimento get_instance_count:
get_instance_count
:: (object_id :
int
) -> instance_count :
int
{

Esse procedimento retorna o número de instâncias ativas que foram criadas (spwan) no mundo do jogo de um certo objeto.
Você precisa passar um id_objeto que foi retornando de um procedimento create_object.
#import
"GameEngine"


main
:: () {
    objeto_do_jogo :=
create_object
();
    
spawn_object
(objeto_do_jogo,
10
,
-20
);
    
while
game_is_running
() {
        contador_instancia :=
get_instance_count
(objeto_do_jogo);
        
draw_int
(contador_instancia);
    }
}

Um exemplo do procedimento get_instance_count



get_first_instance

Essa é a declaração do procedimento get_first_instance:
get_first_instance
:: (object_id :
int
) -> instance_id :
int
{

Esse procedimento retorna o id_instancia da primeira instância criada de um certo id_objeto.
Você precisa passar um id_objeto que foi retornando de um procedimento create_object.
Isso é particularmente útil para ser usado em objetos que possuem apenas uma instância criada (como um objeto do jogador, por exemplo).
#import
"GameEngine"


main
:: () {
    objeto_do_jogo :=
create_object
();
    
spawn_object
(objeto_do_jogo,
10
,
-20
);
    
while
game_is_running
() {
        
if
button_pressed
() {
            
destroy_instance
(
get_first_instance
(objeto_do_jogo));
        }
    }
}

Como pegar a primeira instância de um objeto do jogo



get_random_instance

Essa é a declaração do procedimento get_random_instance:
get_random_instance
:: (object_id :
int
) -> instance_id :
int
{

A declaração do get_random_instance

Esse procedimento retorna o id_instancia de uma instância ativa aleatória de um certo id_objeto.
Você precisa passar um id_objeto que foi retornando de um procedimento create_object.
#import
"GameEngine"


main
:: () {
    objeto_do_jogo :=
create_object
();
    
spawn_object
(objeto_do_jogo,
10
,
-20
);
    
while
game_is_running
() {
        
if
button_pressed
() {
            
destroy_instance
(
get_random_instance
(objeto_do_jogo));
        }
    }
}


get_next_instance

Essa é a declaração do procedimento get_next_instance:
get_next_instance
:: (object_id :
int
) -> instance_id :
int
{

A declaração de get_next_instance

Esse procedimento é usado para receber incrementalmente o id de todas as instâncias de um certo objeto.
Por exemplo, em um certo frame, chamar o get_next_instance pela primeira vez naquele frame vai retornar o id da primeira instância criada.
A segunda vez, vai retornar o id da segunda instância criada. A terceira vez, a terceira instância, e assim por diante .
Quando o id de todas as instâncias válidas forem retornadas naquele frame, o procedimento vai retornar zero.
Quando o frame for recomeçado, o contador da próxima instância é reiniciado – fazendo com que ele retorne o id da primeira instância criada novamente. Você pode reiniciar manualmente o contador interno com o reset_next_instance_counter.

Esse procedimento é particularmente útil para iterar por todas as instâncias criadas de um objeto.
#import
"GameEngine"


main
:: () {
    objeto_do_jogo :=
create_object
();
    
spawn_object
(objeto_do_jogo,
10
,
-20
);
    
while
game_is_running
() {
        instancia :=
get_next_instance
(objeto_do_jogo);
        
while
instancia !=
0
{
            ...
            instancia =
get_next_instance
(objeto_do_jogo);
        }
    }
}


reset_next_instance_counter

Essa é a declaração do procedimento reset_next_instance_counter:
reset_next_instance_counter
:: (object_id :
int
) {

A declaração de reset_next_instance_counter

Esse projeto reinicia o contador interno do procedimento get_next_instance.
O procedimento get_next_instance retorna de forma iterativa os ids de todas as instâncias de um objeto. Quando todas as instâncias do objeto forem retornadas, o procedimento get_next_instance retorna zero (índice inválido).
Ao chamar o reset_next_instance_counter o procedimento get_next_instance vai reiniciar e retornar o id da primeira instância novamente.
Ao final de todo frame o next_instance_counter vai reiniciar automaticamente.
#import
"GameEngine"


main
:: () {
    objeto_do_jogo :=
create_object
();
    
spawn_object
(objeto_do_jogo,
10
,
-20
);
    
while
game_is_running
() {
        instancia :=
get_next_instance
(objeto_do_jogo);
        
while
instancia !=
0
{
            ...
            instance =
get_next_instance
(objeto_do_jogo);
        }
        
        
reset_next_instance_counter
(objeto_do_jogo);
        
        instancia =
get_next_instance
(objeto_do_jogo);
        
while
instancia !=
0
{
            ...
            instancia =
get_next_instance
(objeto_do_jogo);
        }
    }
}




API Parte 4: Parâmetros de Objetos

set_object_bitmap

Essa é a declaração do procedimento set_object_bitmap:
set_object_bitmap
:: (object_id :
int
, file_name :=
"file.png"
, update_object_size :=
true
, new_size :=
5.0
) {

A declaração de set_object_bitmap

Esse procedimento configura um certo objeto para usar uma imagem quando esse objeto for renderizado.
A imagem precisa estar no formato .png.
O procedimento procura pela imagem no caminho especificado relativo ao executável (ou onde o diretório da aplicação estiver). Se nenhuma imagem PNG válida for encontrada, o procedimento não desenha nada.
Se você definir o parâmetro atualizar_tamanho_objeto para falso, o tamanho do objeto não vai mudar e o parâmetro novo_tamanho é ignorado. A imagem pode ficar distorcida se o tamanho do objeto tiver uma proporção de tela diferente.
Se você definir o atualizar_tamanho_objeto para true (verdadeiro), o tamanho do objeto vai ser sobrescrito pelo parâmetro novo_tamanho. Existe apenas um valor de tamanho (em contraste com ter os tamanhos x e y, como em create_object) porque a proporção da imagem é mantida. O parâmetro novo_tamanho vai ser usado como o menor tamanho da imagem. O outro tamanho é calculado para ser maior, de maneira a manter a proporção da imagem. Por exemplo: se a imagem tiver 320x160 pixels e você definir o novo_tamanho para 5 unidades, o tamanho do objeto vai ser 10x5 unidades, mantendo o tamanho 5 no menor eixo e definindo o outro eixo para um valor que mantenha a proporção da imagem (10 unidades nesse caso).
#import
"GameEngine"


main
:: () {
    objeto_do_jogo :=
create_object
();
    
set_object_bitmap
(objeto_do_jogo,
"object_image.png"
,
true
,
15.0
);
    
spawn_object
(objeto_do_jogo);
    
while
game_is_running
() {
    }
}


set_object_color

Essa é a declaração do procedimento set_object_color:
set_object_color
:: (object_id :
int
, color_red :=
1.0
, color_green :=
1.0
, color_blue :=
1.0
, color_alpha :=
1.0
) {

A declaração de set_object_color

Esse procedimento configura a cor do objeto a ser usada quando renderizado.
Se você definir um bitmap do objeto com set_object_bitmap, a cor que você define com set_object_color vai ser multiplicada pela imagem.
Se não tiver um bitmap definido, a cor vai ser usada como a cor de preenchimento do retângulo.
As cores são cores RGB de 0 até 1.
O componente alfa da cor controla a opacidade do objeto - onde 0.0 é totalmente transparente e 1.0 é totalmente opaco.
#import
"GameEngine"


main
:: () {
    objeto_do_jogo :=
create_object
();
    
set_object_color
(objeto_do_jogo,
1.0
,
.25
,
.75
,
0.5
);
    
spawn_object
(objeto_do_jogo);
    
while
game_is_running
() {
    }
}


set_object_color_as_random_color

Essa é a declaração do procedimento set_object_color_as_random_color:
set_object_color_as_random_color
:: (object_id :
int
, min_color_red :=
1.0
, min_color_green :=
1.0
, min_color_blue :=
1.0
, min_color_alpha :=
1.0
, max_color_red :=
1.0
, max_color_green :=
1.0
, max_color_blue :=
1.0
, max_color_alpha :=
1.0
) {

A declaração de set_object_color_as_random_color

Esse procedimento configura um intervalo de cores para o objeto usar quando tiver renderizando.
Cada instância do objeto vai selecionar uma cor aleatório dentro desse intervalo.
Se você definir o bitmap de um objeto com set_object_bitmap, a cor que você definir com set_object_color_as_random_color vai ser multiplicada pela imagem.
Se não tiver bitmap definido, a cor vai ser usada como a cor de preenchimento do retângulo.
A cores são cores RGB de 0 até 1.
O componente alfa da cor controla a opacidade do objeto - onde 0.0 é totalmente transparente e 1.0 é totalmente opaco.
#import
"GameEngine"


main
:: () {
    objeto_do_jogo :=
create_object
();
    
set_object_color_as_random_color
(objeto_do_jogo,
1.0
,
0
,
1
,
0.5
);
    
spawn_object
(objeto_do_jogo);
    
spawn_object
(objeto_do_jogo,
10
);
    
spawn_object
(objeto_do_jogo,
20
);
    
while
game_is_running
() {
    }
}


set_object_particle_trail

Essa é a declaração do procedimento set_object_particle_trail:
set_object_particle_trail
:: (object_id :
int
, particle_object_id :
int
, particles_per_second :=
10.0
, outward_velocity :=
2.0
, outward_velocity_randomness :=
1.5
, size_randomness :=
2.0
, position_deviation :=
1.0
, lifetime_in_seconds :=
1.0
, lifetime_randomness :=
0.5
) {

A declaração de set_object_particle_trail

Esse procedimento configura certos objetos para serem emissores de partículas.
Esse objeto vai criar constantemente novos objetos (chamados partículas) em uma certa velocidade.
As partículas vão seguir certas regras de movimento (especificadas nos parâmetros). Essas regras vão ser adicionadas pelos parâmetros do outro movimento especificados no objeto da partícula (com procedimentos como set_object_constance_acceleration).

Parâmetros:
id_objeto: o ID do objeto emissor
id_particula_do_objeto: o ID do objeto que vai ser criado como partícula
particulas_por_segundo: o número de partículas que vão ser emitidas pelo objeto por segundo
velocidade_externa: esse parâmetro controla a velocidade das partículas que estão movendo para fora do emissor
aleatoriedade_velocidade_externa: para fazer as partículas ficarem melhor e mais imprevisíveis, é muito útil adicionar uma aleatoriedade para o movimento das partículas. Esse parâmetro adiciona um fator de aleatoriedade para a velocidade externa
aleatoriedade_tamanho: um fator de aleatoriedade que vai ser adicionado para a localização de criação da partícula (variando da posição do objeto emissor)
desvio_da_posicao: um fator de aleatoriedade que vai ser adicionado para a localização da criação da partícula (variando da posição do objeto emissor)
tempo_de_vida_em_segundos: quantos segundos a partícula vai durar antes de ser destruída – a partícula vai desaparecendo aos poucos durante seu tempo de vida
aleatoriedade_tempo_de_vida: um fator de aleatoriedade que vai ser adicionado ou (subtraído do) tempo de vida da partícula

#import
"GameEngine"


main
:: () {
    emissor :=
create_object
();
    particula :=
create_object
();
    
set_object_particle_trail
(emissor, particula);
    
spawn_object
(emissor);
    
while
game_is_running
() {
    }
}


set_object_movement

Essa é a declaração do procedimento set_object_movement:
set_object_movement
:: (object_id :
int
, movement :=
"player_all_directions"
) {

Esse procedimento configura um certo objeto para ter um comportamento de movimento pré-determinado.
Ele é particularmente útil para movimento do jogador e comportamento de “seguir”.
Se você especificar o movimento do jogador com esse procedimento, você pode configurar seus parâmetros (como aceleração e fricção) com o procedimento set_player_control.
Se você especificar um movimento de seguir, você precisa especificar seus parâmetros (o alvo a ser seguido, bem como a aceleração e fricção).
Essa é uma explicação de todas as strings de movimentos possíveis que você pode passar para esse procedimento:
  • player_up_down: permite o jogador controlar esse objeto movimentando up (para cima) e down (para baixo) com as setas do teclado para CIMA/BAIXO ou as teclas W/S
  • player_left_right: permite o jogador controlar esse objeto movimentando left (para esquerda) e right (para direita) com as setas do teclado para ESQUERDA/DIREITA ou as teclas A/D
  • player_all_directions: permite o jogador controlar esse objeto movimentando left (para esquerda), right (para direita), up (para cima) e down (para baixo) com a setas do teclado para ESQUERDA/DIREITA/CIMA/BAIXO e as tecladas W/A/S/D

  • player_up_down_wasd_only: permite o jogador controlar esse objeto movimentando up (para cima) e down (para baixo) com as teclas W/S
  • player_left_right_wasd_only: permite o jogador controlar esse objeto movimentando left (para esquerda) e right (para direita) com as teclas A/D
  • player_all_directions_wasd_only: permite o jogador controlar esse objeto movimentando left (para esquerda), right (para direita), up (para cima) e down (para baixo) com as teclas W/A/S/D

  • player_up_down_arrow_only: permite o jogador controlar esse objeto movimentando up (para cima) e down (para baixo) com as setas do teclado para CIMA/BAIXO
  • player_left_right_arrow_only: permite o jogador controlar esse objeto movimentando left (para esquerda) e right (para direita) com as setas do teclado para ESQUERDA/DIREITA
  • player_all_directions_arrow_only: permite o jogador controlar esse objeto movimentando left (para esquerda), right (para direita), up (para cima) e down (para baixo) com as setas do teclado para ESQUERDA/DIREITA/CIMA/BAIXO

  • follow_up_down: define o objeto como um seguidor no eixo y (seguindo o alvo up (para cima) e down (para baixo))
  • follow_left_right: define o objeto como um seguidor no eixo x (seguindo o alvo left (para esquerda) e right (para direita))
  • follow_all_directions: define o objeto como um seguidor em todas as direções (seguindo o alvo up (para cima), down (para baixo), left (para esquerda) e right (para direita))
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    
set_object_movement
(objeto,
"player_all_directions"
);
    
spawn_object
(objeto);
    
while
game_is_running
() {
    }
}

Um exemplo de jogo onde o jogador controla um quadrado na tela

#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    alvo :=
create_object
();
    
set_object_movement
(objeto,
"follow_left_right"
);
    
set_object_follow_options
(objeto, alvo);
    
spawn_object
(objeto,
-20
,
-20
);
    
spawn_object
(alvo,
20
,
20
);
    
while
game_is_running
() {
    }
}

Um exemplo de jogo onde um inimigo segue um algo



set_player_control

Essa é a declaração do procedimento set_player_control:
set_player_control
:: (object_id :
int
, acceleration :=
1500.0
, friction :=
10.0
) {

A declaração de set_player_control

Esse procedimento configura a aceleração e a fricção do movimento do jogador.
Ele só funciona se o movimento do objeto tiver sido definido para um movimento do “jogador” antes de chamar esse procedimento. Você pode definir o movimento usando o procedimento set_object_movement.
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    
set_object_movement
(objeto,
"player_all_directions"
);
    
set_player_control
(objeto,
600
,
5
);
    
spawn_object
(objeto);
    
while
game_is_running
() {
    }
}


set_object_follow_options

Essa é a declaração do procedimento set_object_follow_options:
set_object_follow_options
:: (object_id :
int
, target_object_or_instance_id :
int
, acceleration :=
1000.0
, friction :=
10.0
) {

A declaração de set_object_follow_options

Esse procedimento configura o alvo e também a aceleração e fricção de um movimento de seguir.
Ele só funciona se o movimento do objeto foi definido para o movimento de “seguir” antes de chamar esse procedimento. Na verdade, configurar o alvo com set_object_follow_options é necessário depois de definir o movimento de um objeto para “seguir”. Você pode definir o movimento usando o procedimento set_object_movement.
A opção do alvo pode ser um id de objeto ou o id de uma instância. Se for um id de objeto, a primeira instância daquele objeto vai ser usada como alvo.
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    alvo :=
create_object
();
    
set_object_movement
(objeto,
"follow_left_right"
);
    
set_object_follow_options
(objeto, alvo);
    
spawn_object
(objeto,
-20
,
-20
);
    
spawn_object
(alvo,
20
,
20
);
    
while
game_is_running
() {
    }
}


set_object_constant_acceleration

Essa é a declaração do procedimento set_object_constant_acceleration:
set_object_constant_acceleration
:: (object_id :
int
, acceleration_x :=
0.0
, acceleration_y :=
0.0
) {

A declaração de set_object_constant_acceleration

Esse procedimento configura a aceleração constante que vai ser aplicada ao objeto.
Esse procedimento é ótimo para adicionar movimento de “gravidade” ou “vento” para um objeto, ou qualquer movimento baseado em aceleração.
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    
set_object_constant_velocity
(objeto, aceleracao_y=
-20
);
    
spawn_object
(objeto,
-20
,
-20
);
    
while
game_is_running
() {
    }
}


set_object_constant_velocity

Essa é a declaração do procedimento set_object_constant_velocity:
set_object_constant_velocity
:: (object_id :
int
, velocity_x :=
0.0
, velocity_y :=
0.0
) {

A declaração de set_object_constant_velocity

Esse procedimento configura a velocidade constante que vai ser aplicada ao objeto.
Esse procedimento é ótimo para criar movimentos lineares, como um projétil; ou adicionar um movimento de repente, como um pulo.
Esse valor pode ser consultado usando get_object_constant_velocity.
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    
set_object_constant_velocity
(objeto,
-5
,
10
);
    
spawn_object
(objeto,
-20
,
-20
);
    
while
game_is_running
() {
    }
}


get_object_constant_velocity

Essa é a declaração do procedimento get_object_constant_velocity:
set_object_constant_velocity
:: (object_id :
int
) -> velocity_x :
float
, velocity_y :
float
{

a declaração de get_object_constant_velocity

Esse procedimento retorna a velocidade constante de um certo objeto.
O valor que esse procedimento retorna é o valor que foi definido usando o set_object_constant_velocity.
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    
set_object_constant_velocity
(objeto,
100
);
    
spawn_object
(objeto,
-20
,
-20
);
    
while
game_is_running
() {
        velocidade_x, velocidade_y :=
get_object_constant_velocity
(objeto);
    }
}




API Parte 5: Dados de Instâncias, Colisões, Sistema de Cena e Partículas

get_instance_position

Essa é a declaração do procedimento get_instance_position:
get_instance_position
:: (instance_id :
int
) -> position_x :
float
, position_y :
float
{

Esse procedimento retorna a posição atual de uma instância que foi criada no mundo.
Ele usa coordenadas padrão (do mundo).
Você recebe o id da instância salvando o valor de um spawn_object ou chamando um dos procedimentos de consulta de instâncias (get_first_instance, get_random_instance, get_next_instance).
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    instancia :=
spawn_object
(objeto,
-20
,
-20
);
    
while
game_is_running
() {
        posicao_x, posicao_y :=
get_instance_position
(instancia);
    }
}

Como pegar a posição de um objeto no Vizzcode



set_instance_position

Essa é a declaração do procedimento set_instance_position:
set_instance_positoin
:: (instance_id :
int
, position_x :=
0.0
, position_y :=
0.0
) {

Esse procedimento define a posição de uma instância que foi criada no mundo.
Ele usa coordenadas padrão (do mundo).
Ela é particularmente útil para criar movimento customizados para objetos – sem usar os procedimentos padrões de movimento.
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    instancia :=
spawn_object
(objeto);
    
while
game_is_running
() {
        
set_instance_position
(instancia,
-10
,
10
);
    }
}

Como mudar a posição de um objeto no Vizzcode



set_instance_velocity

Essa é a declaração do procedimento set_instance_velocity:
set_instance_velocity
:: (instance_id :
int
, velocity_x :=
0.0
, velocity_y :=
0.0
) {

Esse procedimento define a velocidade constante de uma instância criada no mundo.
A velocidade da instância definida com esse procedimento é adicionada a velocidade do objeto definida com o procedimento set_object_constant_velocity.
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    instancia :=
spawn_object
(objeto);
    
set_instance_velocity
(instancia, -10);
    
while
game_is_running
() {
    }
}

Como mudar a velocidade de uma instância no Vizzcode



objects_collided

Essa é a declaração do procedimento objects_collided:
objects_collided
:: (object_1_id :
int
, object_2_id :
int
) -> collided :
bool
, instance_1_id :
int
, instance_2_id :
int
{

Como chamar objects_collided (colisão entre objetos)

Esse procedimento recebe dois ids de objetos e consulta informações sobre colisões entre instâncias desses objetos que aconteceram no último frame.
Por exemplo, se tiverem asteroides voando pela cena (instâncias do objeto asteroide) e o jogador (instância do objeto do jogador), você pode ver se teve colisão entre o jogador e qualquer asteroide com o procedimento objects_collided.

Se tiver existido uma colisão, o valor retornando colidiu retorna true e o id_instancia_1 retorna o id da instância do objeto id_objeto_1 que colidiu com uma instância do outro objeto. Da mesma forma, o id_instancia_2 retorna o id da instância do objeto id_objeto_2 que colidiu com uma instância do primeiro objeto. Com essa informação, você pode agir de forma seletiva em uma instância especifica que colidiu, como destruindo ela, consultando sua posição, ou qualquer outra coisa.
Se não tiver tido colisão, o valor retornado colidiu retorna false e os outros valores retornados possuem ids inválidos neles.

Se tiver tido múltiplas colisões, você pode usar esse procedimento para consultar todas elas.
A primeira vez que você chamar objects_collided no frame, ele vai retornar informação sobre a primeira colisão. A segunda vez que você chamar ele, ele vai retornar informação sobre a segunda colisão. Na terceira vez, a terceira colisão. E assim por diante. Até que todas as colisões foram consultadas. Depois de retornar informação sobre todas as colisões que aconteceram no frame, o procedimento vai retornar informação de não colisão (colidiu definido como false e valores inválidos dos ids id_instancia_1 e id_instancia_2).
Isso é muito útil para processar todas as colisões que aconteceram entre dois objetos específicos que aconteceram em um frame específico. Você pode fazer isso chamando o procedimento de forma repetida (dentro de um loop while, por exemplo) e dar um “break” (sair) do loop quando o valor retornando colidiu for definido como false.
#import
"GameEngine"


main
:: () {
    objeto1 :=
create_object
();
    
spawn_object
(objeto1);
    objeto2 :=
create_object
();
    
spawn_object
(objeto2);
    
while
game_is_running
() {
        colidiu, instancia_do_objeto_1, instancia_do_objeto_2 :=
objects_collided
(objeto1, objeto2);
        ...
    }
}


object_is_under_cursor

Essa é a declaração do procedimento object_is_under_cursor:
object_is_under_cursor
:: (object_id :
int
) -> collided :
bool
, instance_id :
int
{


Como saber se o jogador está clicando em um objeto? Use object_is_under_cursor

Esse procedimento recebe um id_objeto e consulta informações sobre as instâncias desse objeto que estavam sob o cursor do mouse no último frame.

Se tiver uma instância desse objeto sob o cursor do mouse (colidindo com o ponto que ela está localizada), o valor retornando colidiu retorna true e o id_instancia retorna o id da instância do objeto id_objeto que colidiu com o cursor do mouse.
Se não tiver tido colisão, o valor retornando colidiu retorna false e o valor retornando id_instancia retorna um id inválido.

Se tiver tido várias instâncias desse objeto em particular sob o cursor do mouse, você pode usar esse procedimento para consultar todos eles.
A primeira vez que você chamar o object_is_under_cursor no frame, ele vai retornar informação sobre a primeira colisão. A segunda vez que você chamar, ele vai retornar informação sobre a segunda colisão. A terceira vez, sobre a terceira colisão. E assim por diante. Até que todas as colisões forem consultadas. Depois de retornar informação sobre todas as colisões daquele frame, o procedimento vai retornar nenhuma informação de colisão (colidiu definido como false e os valores dos ids id_instancia_1 e id_instancia_2 como inválidos).
Isso é muito útil para processar todas as colisões entre um objeto específico e o cursor do mouse que aconteceram em um frame especifico. Você pode fazer isso chamando o procedimento de forma repetida (dentro de um loop while, por exemplo) e dar um “break” (sair) do loop quando o valor retornado colidiu for definido como false.
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    
spawn_object
(objeto);
    
while
game_is_running
() {
        colidiu, id_instancia :=
object_is_under_cursor
(objeto);
        ...
    }
}


get_current_scene

Essa é a declaração do procedimento get_current_scene:
get_current_scene
:: () -> scene_index :
int
{

Esse procedimento é uma das formas que você pode usar o sistema de cenas dentro da Game Engine.
Cenas são simplesmente estados do mundo (ou uma foto do mundo) que contém dados sobre quais instâncias de objetos foram criados no mundo. Você pode salvar, definir/reiniciar, limpar e receber cenas – cada um com seu procedimento respectivo.

O procedimento get_current_scene retorna um indice_cena da cena atual.
Se nenhuma cena for definida/reiniciada, ele retorna o id da cena padrão.
Esse procedimento é muito útil para testar os estados atuais do jogo, por exemplo, se a cena atual for a cena do gameplay, talvez você queira ter um comportamento, se for a cena do menu, outro comportamento, e assim por diante.

O código a seguir cria uma instância de um objeto no mundo e salva a foto desse mundo como cena_1. O get_current_scene retorna o valor da variável cena_1.
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    
spawn_object
(objeto);
    cena_1 :=
save_scene
();
    
while
game_is_running
() {
        cena_atual :=
get_current_scene
();
        
if
cena_atual == cena_1 {
            ...
        }
    }
}


save_scene

Essa é a declaração do procedimento save_scene:
save_scene
:: () -> scene_index :
int
{

Esse procedimento é uma das formas de usar o sistema de cenas dentro da Game Engine.
Cenas são simplesmente estados do mundo (ou uma foto do mundo) que contém dados sobre quais instâncias de objetos foram criadas no mundo. Você pode salvar, definir/reiniciar, limpar e receber cenas – cada um com seu procedimento respectivo.

O procedimento save_scene salva a cena (o estado do mundo, ou, uma foto do mundo) e retorna o índice_cena daquela cena. Você pode guardar esse indíce da cena em uma variável para reiniciar o mundo para aquela cena (com o procedimento reset_scene), comparar ele com a cena atual (retornando pelo get_current_scene) e assim por diante.

O código a seguir cria uma instância de um objeto no mundo do jogo e salva essa foto do mundo como cena_1. O botão esquerdo do mouse destrói o objeto e o botão direito do mouse reinicia a cena para a cena salva (retornando a instância do objeto para seu lugar quando a cena foi salva).
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    
spawn_object
(objeto);
    cena_1 :=
save_scene
();
    
while
game_is_running
() {
        
if
button_pressed
(
"lmb"
)
            
destroy_instance
(
get_first_instance
(objeto));
        
if
button_pressed
(
"rmb"
)
            
reset_scene
(cena_1);
    }
}

Um exemplo de programa que usa o sistema de cena da Game Engine do Vizzcode



clear_scene

Essa é a declaração do procedimento clear_scene:
clear_scene
:: () {

Esse procedimento é uma das formas de usar o sistema de cenas dentro da Game Engine.
Cenas são simplesmente estados do mundo (ou uma foto do mundo) que contém dados sobre quais instâncias de objetos foram criadas no mundo. Você pode salvar, definir/reiniciar, limpar e receber cenas – cada um com seu procedimento respectivo.

O procedimento clear_scene simplesmente destrói todas as instâncias (e partículas) que existem atualmente no mundo.
Ela é particularmente útil quando estiver criando e salvando múltiplas cenas no início. Por exemplo, você pode criar diversos objetos e salvar essa cena, depois limpar a cena e criar objetos totalmente diferentes, para salvar eles como uma outra cena. O código a seguir faz exatamente isso.

#import
"GameEngine"


main
:: () {
    objeto_1 :=
create_object
();
    objeto_2 :=
create_object
();

    
spawn_object
(objeto_1);
    cena_1 :=
save_scene
();

    
clear_scene
();

    
spawn_object
(objeto_2);
    cena_2 :=
save_scene
();
    
while
game_is_running
() {
        ...
    }
}


reset_scene

Essa é a declaração do procedimento reset_scene:
reset_scene
:: (scene_to_reset :=
-1
) {

Esse procedimento é uma das formas de usar o sistema de cenas dentro da Game Engine.
Cenas são simplesmente estados do mundo (ou uma foto do mundo) que contém dados sobre quais instâncias de objetos foram criadas no mundo. Você pode salvar, definir/reiniciar, limpar e receber cenas – cada um com seu procedimento respectivo.

O procedimento reset_scene recebe uma cena para reiniciar o mundo para.
Por exemplo, se a cena_1 contém uma instância de um objeto; chamar reset_scene(cena_1) vai limpar a cena (assim como o procedimento clear_scene faz) e restaurar essa cena – inserindo a instância salva.

O procedimento pode ser chamado com o argumento padrão -1 para reiniciar a current_scene.
Se nenhuma cena tiver sido salva, ele restaura as instâncias no mundo para o ponto que eles estavam logo antes do começo do loop do jogo (a primeira chamada para game_is_running).
#import
"GameEngine"


main
:: () {
    objeto :=
create_object
();
    
set_object_constant_velocity
(objeto,
10
);
    
spawn_object
(objeto);
    
while
game_is_running
() {
        
if
button_pressed
(
"enter"
)
            
reset_scene
();
    }
}


spawn_particles

Essa é a declaração do procedimento spawn_particles:
spawn_particles
:: (particle_object_id :
int
, position_x :=
0.0
, position_y :=
0.0
, amount :=
20
, outward_velocity :=
5.0
, outward_velocity_randomness :=
2.0
, size_randomness :=
2.0
, lifetime_in_seconds :=
1.0
, lifetime_randomness :=
0.5
) {

Como eu posso criar partículas para o meu jogo no Vizzcode

Esse procedimento emite uma explosão de partículas em uma localização especificada por parâmetro.
A explosão de partículas é um evento que acontece uma única vez, bem como uma explosão mesmo: ele só vai criar partículas no momento que você chamar o procedimento. Mas você pode chamar o spawn_particles de forma bem frequente para simular um rastro de partículas.
As partículas vão seguir uma certa regra de movimentação (especificada nos parâmetros). Essas regras vão ser adicionadas pelos outros parâmetros de movimento especificados no objeto da partícula (com procedimento como set_object_constance_acceleration).

Parâmetros:
id_objeto_particula: o ID do objeto que vai ser criada como uma partícula
posicao_x: a posição X do centro da explosão da partícula
posicao_y: a posição Y do centro da explosão da partícula
quantidade: a quantidade de partículas que vão ser criadas
velocidade_externa : esse parâmetro controla a velocidade que as partículas vão movimentar para fora do centro
aleatoriedade_velocidade_externa: para fazer as partículas ficarem mais reais e mais imprevisíveis, é muito útil adicionar um fator de aleatoriedade para o movimento das partículas. Esse parâmetro adiciona um fator aleatório para a velocidade externa
aleatoriedade_tamanho : um fator de aleatoriedade que vai ser adicionado para o tamanho do objeto da partícula
tempo_de_vida_em_segundos : quantos segundos a partícula vai durar antes de ser destruída – a partícula vai sumindo aos poucos durante seu tempo de vida
aleatoriedade_tempo_de_vida : um fator de aleatoriedade que vai ser adicionado ao (ou subtraído do) tempo de vida da partícula

#import
"GameEngine"


main
:: () {
    particula :=
create_object
();
    
while
game_is_running
() {
        
if
button_pressed
()
            
spawn_particles
(particula);
    }
}