Вы находитесь на странице: 1из 22

Tululoo Game

Maker
1.3.0 e 2.0.0
Português
Manual
Traduzido por Bruno Silva
www.arcadotululoo.blogspot.
pt
Este manuel foi escrito em Setembro 2013
Créditos
Este manual é escrito por Bruno Silva.

Programa por Zoltan Percsich.


Manual original por YellowAfterlife.
Manual Traduzido por Bruno Silva
Tutorial básico por Bruno Silva
Extensão de som por: Arkanis

Para mais visite

www.arcadotululoo.blogspot.
pt
www.tululoo.com
Tululoo
Tululoo Game Maker é um ambiente de criação do jogo complexos que permite criar
jogos baseados no navegador. O programa gera um código Javascript que pode ser
jogado em navegadores web usando o HTML5.

Com Tululoo você pode criar jogos para seus dispositivos móveis, como os mais
recentes já suportam os novos padrões HTML5. Tululoo vem com um usuário simpática
gerente de recursos e editor de script, onde você pode importar suas imagens,
backgrounds, sprites animados, sons. Você pode facilmente criar os objetos (atores
como jogador, os inimigos, itens colecionáveis, etc) e você também pode adicionar suas
próprias funções e scripts para os objetos do jogo.

Tululoo usa JavaScript como linguagem de programação, estendendo-o com funções


adicionais, que são destinadas a simplificar o jogo & desenvolvimento do aplicativo.
Por enquanto, ele não contém documentação básica sintaxe, portanto, seria útil que
seguir alguns tutoriais sobre JavaScript antes de programar ativamente Tululoo.
Se você já usou ou GML, Lite-C, ou ActionScript, a aprendizagem deve ser um pouco
mais fácil.

3.1 Básico
Todas as linha de código devem acabar com ( ; )
move;

Uma variável não precisa de ter var atras ou nada do gênero


dinheiro = 400;

Um string guarda texto e números, uma variável tem strings


texto = "Olá Mundo";
vida = 100;

Funções são usadas na grande parte do tempo no Tululoo e devem ser postas assim
Função(parâmetro);

Vários parâmetros são separados por ( , ) virgula


Função(parâmetro1, parâmetro2);

Exemplo de uma função para desenhar um texto


draw_text(x, y, "Olá Portugal");

Comentário são feitos usando ( // )


//descrição do sistema

Array são uteis para fazer HUD e mochilas de itens elas se escrevem assim
array = [];

Condições são usam if no começo sempre.


if ( qualquer_coisas == 100 ) {
alert( "correto" );
} else {
alert( "não correto" );
}

{ quer dizer então e } termina


if xxxxxx {
faz coisas
}

____________________________________________________________________________

Exemplo de um Olá Mundo


alert ("Olá Mundo");

HUD Super básica


//Este var deve estar guardada nas globais
vida = 100;

//Desenha HUD
draw_set_font(font do text);
draw_text(x,y,"Vida " + var_vida);

Movimento básico de uma personagem


//Andar
if ( keyboard_check( vk_d)) {
move_towards_point(x + 5,y,280);
}

if ( keyboard_check( vk_a )) {
move_towards_point(x - 5,y,280);
}

if ( keyboard_check( vk_w )) {
move_towards_point(x,y - 5,280);
}

if ( keyboard_check( vk_s )) {
move_towards_point(x,y + 5,280);
}

3.2 Cálculos

choose(arg1, arg2, ..., argN) - retorna aleatoriamente um de fornecer argumentos.


degtorad(degree) - Converte graus em radianos.
radtodeg(radian) - converte radianos em graus.
abs(x) - retorna o valor absoluto de x.
sign(x) - retorna sinal de x (1, 0 ou -1).
min(arg1, arg2, ..., argN) - retorna o menor de fornecer argumentos (atalho para
Math.min).
max(arg1, arg2, ..., argN) - retorna o maior de fornecer argumentos (atalho para
Math.max).
random(value) -retorna numeros inteiros flutuando entre 0 (inclusivo) e valor
(exclusivo).
irandom(value) - retorna numero inteiro aleatório entre 1 (inclusivo) e valor (inclusivo).
point_direction(x1, y1, x2, y2) - retorna direção entre dois pontos.
point_distance(x1, y1, x2, y2) - retorna dinstancia entre dois pontos.
lengthdir_x(length, direction) - retorna à horizontal x-componente do vector
determinado pelo comprimento e direcção indicada.
lengthdir_y(length, direction) - retorna à horizontal y-componente do vector
determinado pelo comprimento e direcção indicada.
Você também pode utilizar as seguintes funções do objeto "Math" JS (ou incluindo extensões
"Funções matemáticas" importadas para o Tululoo):
Math.abs(x) - devolve o valor absoluto de x.
Math.min(arg1, arg2, ..., argN) - retorna o menor dos argumentos providenciais.
Math.max(arg1, arg2, ..., argN) - retorna o maior dos argumentos providenciais.
Math.random() - retorna um número aleatório entre 0 e 1. (ex: 0.000001, 0.900000,
0.5313452)

Math.round(x) - retorna x, arredondado para o número inteiro mais próximo


Math.floor(x) - retorna x, para baixo arredondado para o número inteiro mais próximo.
Math.ceil(x) - retorna x, para baixo arredondado para o número inteiro mais próximo.

Math.sqrt(x) - retorna a raiz quadrada de x.


Math.pow(x, y) - retorna x ao poder do y.
Math.exp(x) - retorna E o poder de x.
Math.log(x) - retorna logaritmo natural (base E) de x.

Math.sin(x) - devolve o seno de x (x está em radianos).


Math.cos(x) - devolve o co-seno de x (x está em radianos).
Math.tan(x) - retorna a tangente de x (x está em radianos).

Math.acos(x) - retorna o arco cosseno de x, em radianos.


Math.asin(x) - devolve o seno de x, em radianos.
Math.atan(x) - devolve o arco de tangente de x, em radianos.
Math.atan2(y, x) - retorna o arco tangente do quociente de seus argumentos.

3.3 Interação com o Usuário

keyboard_check(key) - Retorna se a tecla especificada é carregada


keyboard_check_pressed(key) - Retorna se a tecla especificada é precionada
keyboard_check_released(key) - Retorna se a tecla especificada é solta
mouse_x - indica posição do mouse X
mouse_y - indica posição do mouse X
mouse_check() - Retorna se botão do mouse esquerdo é carregado
mouse_check_pressed() - Retorna se botão do mouse esquerdo é presionado
mouse_check_released() - Retorna se botão do mouse esquerdo é solto

key_down[key] - indica se a tecla especificada é carregada


key_pressed[key] - indica se tecla chave especificada é presionada
key_released[key] - indica se tecla chave especificada é solta
mouse_down - indica se o botão esquerdo do mouse é carregado
mouse_pressed - indica se o botão esquerdo do mouse é pressionado
mouse_released - indica se o botão esquerdo do mouse é solto

hide_mouse() - esconde o mouse.


show_mouse() - mostra o mouse.
pause_game(key) - Suspende (coloca em pausa) a execução do jogo até tecla
especificada é pressionada. Com mais detalhes jogo será pausado após compilação do
bloco de código em execução no momento, por isso não usá-lo como função de atraso no
meio do código.

3.4 Interação com o Usuário (dispositivos móveis)

Como você deve saber, os jogos em HTML5 pode ser jogado em dispositivos móveis
(se o navegador usar HTML5). Esses jogos também pode ser criado com Tululoo.
Quando no dispositivo móvel, a posição do mouse e estado é atualizado
automaticamente - posição do cursor é calculado como uma média entre todos os
pontos que tocou.
Para criar teclas ou seja botões virtuais na tela, a seguinte rotina existe:

vkey_add(x, y, width, height, index) -adiciona uma tecla virtual com os parâmetros
especificados. Índice de parâmetro indica o índice da tecla a ser simulado quando a tecla
virtual é pressionada (ou seja VK_ENTER)
A função retorna um objeto virtual, que tem os seguintes parâmetros:
left - teclas virtuais min X
top - teclas virtuais min Y
right - teclas virtuais max X
bottom - teclas virtuais max Y
key - índice da tecla, ligado à tecla virtual
active - indica se a tecla virtual é ativa, portanto, pode ser pressionado
3.5 Instâncias

The following routines exist for manipulating instances:


instance_create(x, y, object) - cria uma nova instância do objeto especificado nas
coordenadas.
instance_number(object) - retorna o número de tipo de objeto especificado na sala atual.
instance_list(object) -retorna um array com todos os objetos do tipo especificado na sala
atual.
instance_destroy() - destrói a instância chamada.
move_towards_point(x, y, speed) - instância se move para o ponto especificado.
place_meeting(x, y, object) -retorna objeto de determinado tipo (ou nulo) que colide com
chamando instância em uma determinada posição.
Os objetos têm as seguintes propriedades, que podem ser acessados via instância
x - Posição x
y - Posição y
xstart - começando x posição
ystart - começando y posição
xprevious - posição x anterior
yprevious - posição y anterior
direction - direção do movimento.
speed - a velocidade de movimento.
As seguintes propriedades são para a aparência e animação do objeto:
depth - profundidade (ordem do sprite)
visible - indica se o objeto é visível (assim, se o evento for executado)
sprite_index - indica sprite do objeto. Sprite afeta desenho e comportamentos de
colisão.
image_index - número do frame atual.
image_speed - velocidade da animação, em frames por etapa.
image_single - definir esta opção como valor, diferente de -1, vai parar de animação e
exibir o frame especificado.
image_angle - valor do gráfico de rotação.
image_alpha - transparência do gráfico (0 .. 1).

As seguintes propriedades especiais são aconselhados a ser apenas lidas.


Modificando estes podem causar comportamentos no programa compilado, então tenha cuidado.
id - contém referência à instância.
other - é modificado em eventos de colisão, indica colidindo a instância.
object_index - contém «type» de exemplo, que pode ser usado em funções de criação e
de verificação de colisão.
parent - parentar um objeto, isto significa que um outro objeto X fica com a mesma
coisas

3.6 Desenho/Drawing

draw_line(x1, y1, x2, y2) - desenha uma linha entre as coordenadas especificadas
draw_rectangle(x1, y1, x2, y2) - desenha um retângulo entre as coordenadas
especificadas (superior esquerdo - canto inferior direito)
draw_circle(x, y, radius, outline) - desenha um círculo em coordenadas especificadas
com raio escolhido. 'outline' Parâmetro indica se deve ser preenchido (0) ou não (1).
draw_sprite(sprite, frame, x, y) - chama a moldura escolhida de sprite especificado em
determinadas coordenadas.
draw_sprite_ext(sprite, frame, x, y, xscale, yscale, direction, alpha) - chama a sprite
especificado com determinados parâmetros de dimensionamento, rotação e alfa em
determinadas coordenadas.
As seguintes funções afeta as configurações utilizados por funções acima:
draw_set_color(r, g, b) - muda de cor o desejado texto, sprite e outros (0 .. 255)
draw_set_alpha(alpha) - altera a transparência para as operações de desenho subseqüentes (0 ..
1)
draw_set_linewidth(width) - altera a largura das linhas para operações de desenho.

3.7 Texto

draw_text(x, y, text) - desenha texto a coordenadas desejadas


Esta função pode ser modificada com:
draw_set_font(font) - escolher a font da letra (tem que estar presente no quadro de fonts
do tululoo)
draw_set_halign(halign) - Mudanças da font horizontal para alinhar as operações de
desenho
draw_set_valign(valign) - Mudanças da font vertical para alinhar as operações de
desenho subseqüentes.

bold - bold
italic - italico
size - tamanho
family -tipo de letra ("Arial", "Sans", etc.)

3.8 Sprites
Os Objetos pode ser referenciado através do seu nome, desenhado, e designado como
sprite_index às instâncias.
Eles têm os seguintes campos:
collision_left - indica min. x limites de colisão.
collision_top - indica min. y dos limites de colisão.
collision_right - indica max. x limites de colisão.
collision_bottom - Indica max. y dos limites de colisão.
collision_shape - indica colisão tipo do sprite ("Box" ou "Circle") Na versão 2.0.0 foi adicionado
"Shape"
height - indicates sprite height
width - indica a largura do sprite
xoffset - indica Sprite x deslocamento (origem)
yoffset - indica duende y deslocamento (origem).

3.9 Audio + Extensão

Existem as seguintes funções para lidar com a reprodução de som \ música:


sound_play(sound) - reproduz o som especificado.
sound_loop(sound) - faz loop do som escolhido
sound_stop(sound) - para o som escolhido
sound_stop_all(sound) - para todos os sons escolhidos
sound_volume(sound, volume) - muda o volume do som escolhido

Se está recomenda uma extenção de som pois o tululoo é muito imcompleto em termos de
som:
é feito por Arkanis

Copie para o isto extension maker


ou faça download da extenção aqui http://percsich.hu/tgmforum/index.php?topic=496.0

[EXTENSION]
Music

[AUTHOR]
Ivan Hayward - AC Arcana

[DESCRIPTION]
This extension is meant to
facilitate easier control of music
elements in games.
[HELP]
music_prepare(track) - Sets a track to play
music_play() - Plays a track if one is already set
music_play(track) - Starts the passed sound
music_pause() - Pauses the current track
music_is_paused() - Returns true of the track is paused, false if it is playing, and null if no track
is set
music_toggle_pause() - Toggles whether the current track is paused
music_resume() - Resumes a paused track
music_stop() - Stops the track if it is playing and resets its time to 0
music_stop_and_clear() - Stops the track and clears the current track
music_is_playing() - Return true if the track is playing, false if not, null if no track is set
music_loop(track) - Starts the passed sound looping
music_loop(boolean) - Sets looping to the passed value when passed a boolean
music_loop() - Sets the current track to loop
music_unloop() - Sets the current track to stop looping
music_toggle_loop() - Toggles the loop state of a track
music_is_loop() - Returns true if music is looped, false if not, and null if no track is set
music_volume(volume) - Sets the volume of the current track ( 0 = silent, 100 = full volume )
music_get_volume() - Returns the current volume of the track, or null if no track is set
music_increase_volume() - Increases volume by 1
music_increase_volume(volume) - Increases volume by the passed amount
music_decrease_volume() - Decreases volume by 1
music_decrease_volume(volume) - Decreases volume by the passed amount
music_mute(boolean) - Sets whether the current track is muted
music_mute() - Mutes the current track
music_unmute() - Unmutes the current track
music_toggle_mute() - Toggles the current mute state
music_is_muted() - Returns true if the music is muted, false if it is not, and null if no track is set
music_current_time(time) - Sets the current time for the track in seconds
music_get_current_time() - Returns the current time for the track, or null if no track is set
music_percent(percent) - Sets the current position of the track to the passed percentage
music_get_percent(percent) - Returns the current time's percentage of the track duration
music_get_duration() - Returns the duration of the track or null if no track is set
music_playback_rate(rate) - Sets the current track's playback rate
music_get_playback_rate() - Returns the current track's playback rate, or null if no track is set
music_is_ended() - Returns true of the music has ended, false if not, and null if no track is set
music_get_played() - Returns a TimeRanges object representing the played parts of the audio, or
null if no track is set
music_get() - Returns the currently set track or null if no track set
music_get_error() - Returns any recorded errors for the track or null if no track set
music_fade_in(duration) - Fades a track in to full volume over the passed duration in
milliseconds
music_fade_in(duration, volume) - Fades a track in to the passed volume over the passed duration
in milliseconds
music_fade_in(duration, volume, callback) - Fades a track in to the passed volume over the
passed duration in milliseconds, and calls the function passed in callback when done
music_fade_out(duration) - Fades a track out to silence over the passed duration in milliseconds
music_fade_out(duration, volume) - Fades a track out to passed volume over the passed duration
in milliseconds
music_fade_out(duration, volume, callback) - Fades a track out to passed volume over the passed
duration in milliseconds, and calls the function passed in callback when done
music_fade_to(duration, volume) - Fades the track in or out to the passed volume over the passed
duration
music_fade_to(duration, volume, callback) - Fades the track in or out to the passed volume over
the passed duration, and calls the function passed in callback when done
music_fade_with(track, duration, crossfade) - Fades the current track out and the pased track in
over the passed duration. The passed track will become the currently set track. If crossfade is true
they will fade at the same time, otherwise they will fade individually
music_fade_with(track, duration, crossfade, volume) - Fades the current track out and the pased
track in to the passed volume over the passed duration. The passed track will become the
currently set track. If crossfade is true they will fade at the same time, otherwise they will fade
individually
music_fade_with(track, duration, crossfade, volume, callback1, callback2) - Fades the current
track out and the pased track in to the passed volume over the passed duration. The passed track
will become the currently set track. If crossfade is true they will fade at the same time, otherwise
they will fade individually, when the first track fades out callback1 is called, when the second
track fades in callback2 is called
music_bind_event(event, callback) - Binds a standard music event to the function passed
Standard music events: abort, canplay, canplaythrough, durationchange, emptied, ended, error,
loadeddata, loadedmetadata, loadstart, pause, play, playing, progress, ratechange, seeked,
seeking, stalled, suspend, timeupdate, volumechange, waiting
music_unbind_event(event, callback) - Unbinds the chosen event and passed function

[CODE]
function music_loop(track) {
if(track === undefined){
if(typeof window.music !== "undefined")
window.music.loop = true;
}
else if(typeof track === "boolean") {
if(typeof window.music !== "undefined")
window.music.loop = track;
}
else {
window.music = track.audio;
window.music.loop = true;
window.music.play();
}
}
function music_play(track) {
if(track === undefined) {
if(typeof window.music !== "undefined")
window.music.play();
}
else {
window.music = track.audio;
window.music.play();
}
}
function music_is_playing() {
if(typeof window.music !== "undefined") {
if(window.music.currentTime == 0)
return false;
else if(window.music.paused)
return false;
else
return true;
}
return null;
}
function music_prepare(track) {
window.music = track.audio;
}
function music_stop() {
if(typeof window.music !== "undefined") {
window.music.pause();
window.music.currentTime = 0;
}
}
function music_stop_and_clear() {
if(typeof window.music !== "undefined") {
window.music.pause();
window.music = undefined;
}
}
function music_unloop() {
if(typeof window.music !== "undefined")
window.music.loop = false;
}
function music_toggle_loop() {
if(typeof window.music !== "undefined")
window.music.loop = !window.music.loop;
}
function music_is_looped() {
if(typeof window.music !== "undefined")
return window.music.loop;
else
return null;
}
function music_pause() {
if(typeof window.music !== "undefined")
window.music.pause();
}
function music_is_paused() {
if(typeof window.music !== "undefined")
return window.music.paused;
else
return null;
}
function music_toggle_pause() {
if(typeof window.music !== "undefined") {
if(window.music.paused)
window.music.play();
else
window.music.pause();
}
}
function music_resume() {
if(typeof window.music !== "undefined")
window.music.play();
}
function music_mute(boolean) {
if(typeof window.music !== "undefined") {
if(boolean === undefined)
window.music.muted = true;
else
window.music.muted = boolean;
}
}
function music_unmute() {
if(typeof window.music !== "undefined")
window.music.muted = false;
}
function music_toggle_mute() {
if(typeof window.music !== "undefined")
window.music.muted = !window.music.muted;
}
function music_is_muted() {
if(typeof window.music !== "undefined")
return window.music.muted;
return null;
}
function music_time(time) {
if(typeof window.music !== "undefined")
window.music.currentTime = time;
}
function music_get_time() {
if(typeof window.music !== "undefined")
return window.music.currentTime;
return null;
}
function music_get_duration() {
if(typeof window.music !== "undefined")
return window.music.duration;
return null;
}
function music_playback_rate(rate) {
if(typeof window.music !== "undefined")
window.music.playbackRate = rate;
}
function music_get_playback_rate() {
if(typeof window.music !== "undefined")
return window.music.playbackRate;
else
return null;
}
function music_is_ended() {
if(typeof window.music !== "undefined")
return window.music.ended;
}
function music_get_played() {
if(typeof window.music !== "undefined")
return window.music.played;
else
return null;
}
function music_volume(volume) {
if(typeof window.music !== "undefined")
window.music.volume = volume / 100;
}
function music_get_volume() {
if(typeof window.music !== "undefined")
return Math.round(window.music.volume * 100);
else
return null;
}
function music_increase_volume(volume) {
if(typeof window.music !== "undefined") {
if(volume === undefined) {
if(window.music.volume <= 0.99)
window.music.volume += 0.01;
else
window.music.volume = 1;
}
else {
if(window.music.volume + (volume / 100) <= 1)
window.music.volume += (volume / 100);
else
window.music.volume = 1;
}
}
}
function music_decrease_volume(volume) {
if(typeof window.music !== "undefined") {
if(volume === undefined) {
if(window.music.volume >= 0.01)
window.music.volume -= 0.01;
else
window.music.volume = 0;
}
else {
if(window.music.volume - (volume / 100) >= 0)
window.music.volume -= (volume / 100);
else
window.music.volume = 0;
}
}
}
function music_get() {
if(typeof window.music !== "undefined")
return window.music;
else
return null;
}
function music_get_error() {
if(typeof window.music !== "undefined")
return window.music.error;
else
return null;
}
function music_fade_in(duration, volume, callback) {
if(volume === undefined)
volume = 1;
else
volume = volume / 100;
if(typeof window.music !== "undefined") {
if(window.music.paused)
window.music.play();
var interval = setInterval(function() {
if (window.music.volume + 0.05 <= volume)
window.music.volume += 0.05;
else {
window.music.volume = volume;
if(callback !== undefined)
callback();
clearInterval(interval);
}
}, duration / ((volume - window.music.volume) / 0.05));
}
}
function music_fade_out(duration, volume, callback) {
if(volume === undefined)
volume = 0;
else
volume = volume / 100;
if(typeof window.music !== "undefined") {
if(window.music.paused)
window.music.play();
var interval = setInterval(function() {
if (window.music.volume - 0.05 > volume)
window.music.volume -= 0.05;
else {
window.music.volume = volume;
if(callback !== undefined)
callback();
clearInterval(interval);
}
}, duration / ((window.music.volume - volume) / 0.05));
}
}
function music_fade_to(duration, volume, callback) {
volume = volume / 100;
if(typeof window.music !== "undefined") {
if(window.music.paused)
window.music.play();
if(window.music.volume > volume) {
var interval = setInterval(function() {
if (window.music.volume - 0.05 > volume)
window.music.volume -= 0.05;
else {
window.music.volume = volume;
if(callback !== undefined)
callback();
clearInterval(interval);
}
}, duration / ((window.music.volume - volume) / 0.05));
}
else if(window.music.volume < volume) {
var interval = setInterval(function() {
if (window.music.volume + 0.05 < volume)
window.music.volume += 0.05;
else {
window.music.volume = volume;
if(callback !== undefined)
callback();
clearInterval(interval);
}
}, duration / ((volume - window.music.volume) / 0.05));
}
}
}
function music_fade_with(track, duration, crossfade, volume, callback1, callback2) {
if(volume === undefined)
volume = 1;
else
volume = volume / 100;
if(typeof window.music !== "undefined") {
if(crossfade) {
if(window.music.paused)
window.music.play();
track.audio.volume = 0;
track.audio.play();
var interval = setInterval(function() {
if (window.music.volume - 0.05 > 0)
window.music.volume -= 0.05;
else {
window.music.volume = 0;
if(callback1 !== undefined)
callback1();
}
if(track.audio.volume + 0.05 < volume)
track.audio.volume += 0.05;
else
track.audio.volume = volume;
if(window.music.volume == 0 && track.audio.volume == volume)
{
window.music.volume = 0;
track.audio.volume = volume;
window.music = track.audio;
if(callback2 !== undefined)
callback2();
clearInterval(interval);
}
}, duration / (window.music.volume / 0.05));
}
else {
if(window.music.paused)
window.music.play();
track.audio.volume = 0;
var interval = setInterval(function() {
if (window.music.volume - 0.05 > 0)
window.music.volume -= 0.05;
else if(track.audio.paused || track.audio.currentTime == 0)
track.audio.play();
else if(track.audio.volume + 0.05 < volume)
track.audio.volume += 0.05;
else {
track.audio.volume = volume;
window.music = track.audio;
clearInterval(interval);
}
}, duration / ((window.music.volume + volume) / 0.05));
}
}
}
function music_bind_event(event, callback) {
if(typeof window.music !== "undefined") {
window.music.addEventListener(event, callback);
}
}
function music_unbind_event(event, callback) {
if(typeof window.music !== "undefined") {
window.music.removeEventListener(event, callback);
}
}
function music_percent(percent) {
if(typeof window.music !== "undefined")
window.music.currentTime = (percent / 100) * window.music.duration;
}
function music_get_percent() {
if(typeof window.music !== "undefined")
return (window.music.currentTime / window.music.duration) * 100;
else
return null;
}

3.10 Room/Cenas

cena/quarto/room/sala é a mesma coisa você pode chamar o que quiser

room_current - indica índice sala atual.


room_width - indica a largura do quarto atual.
room_height - indica a largura do quarto atual.
room_speed - indica framerate alvo da sala atual.
fps - indica framerate atual.
As seguintes propriedades afetam as Cenas viewport:
room_viewport_x - indica x posição da janela na sala atual.
room_viewport_y - indica a posição y da janela na sala atual.
room_viewport_width - indica a largura da janela na sala atual.
room_viewport_height - indica a altura da janela na sala atual.
room_viewport_object - indica o índice objeto a ser seguido pela janela na sala atual.
room_viewport_hborder - indica horizontal 'border', quando a janela está seguindo
objeto na sala atual.
room_viewport_vborder -indica vertical "border", quando o visor está seguindo objeto
na sala atual.
As seguintes propriedades afetam o fundo da sala/room/Cena:
room_background - indica a imagem da sala atual fundo.
room_background_color_red - indica o fundo cor vermelha.
room_background_color_green - indica fundo cor verde.
room_background_color_blue - indica fundo cor azul.
room_background_tile_stretch - indica se a imagem de fundo deve ser esticada sobre
toda a área do room.
room_background_tile_x - indica se o tile no fundo deve estar horizontalmente.
room_background_tile_y - indica se o tile no fundo deve estar na vertical.
Existem as seguintes rotinas para a Cena:
room_goto(room) - muda de Cena para outra escolhida
room_restart() - faz reset da Cena
room_goto_next() - muda para a proxima cena
room_goto_previous() - muda para a cena anterior
room_goto_first() - muda para a primeira cena do jogo (ordem do editor)
room_goto_last() - muda para a ultima cena do jogo (orem do editor)

3.11 Tiles/tilesets

tile_add(background, left, top, width, height, x, y, depth) - adiciona uma novo tile e
retorna objeto tile (veja abaixo).
tile_delete(tile) - remove tile da cena
tile_find(x, y, width, height, depth) - retorna um array, contendo todas as peças que
cruzam a região especificada.
Objeto tile tem as seguintes propriedades:
source - fundo, a partir do qual imagem o tile é tomado.
x - x posição no palco.
y - y posição no palco.
left - posição x de parte para exibir (no fundo).
top - posição x de parte para exibir (no fundo).
width - largura da parte para exibir (no fundo).
height - altura da parte para exibir (no fundo).
width2 - 'on-screen " largura do tile. Tendo esta diferente de propriedade de largura, vai
esticar o tile.
height2 - 'on-screen' altura do tile. Tendo esta diferente da propriedade altura vai esticar o
tile

3.12 Local storage

Muito útil para criar saves e tabelas de pontos online, todo gravado num servidor depois.

Armazenamento web local pode ser usado para armazenar informações entre o jogo\sessões do
programa.
load_web_data(key) - cargas e retorna uma variável de armazenamento local
load_web_integer(key) - cargas e retorna um inteiro de armazenamento local
load_web_float(key) - cargas e retorna um valor de ponto flutuante de armazenamento
local
load_web_string(key) - cargas e retorna uma string de armazenamento local
Existem as seguintes rotinas para gravar informações para o armazenamento local:
save_web_data(key, value) - salva uma variável para armazenamento local.
save_web_integer(key, value) - salva um integer para armazenamento local.
save_web_float(key, value) - salva o valor de ponto flutuante para armazenamento
local.
save_web_string(key, value) - salva um string em armazenamento local.
Existem as seguintes rotinas para remover a informação existente do armazenamento local:
delete_web_data(key) - remove variável de armazenamento local.
delete_web_integer(key) - remove integer de armazenamento local.
delete_web_float(key) - remove o valor de ponto flutuante de armazenamento local.
delete_web_string(key) - remove o string do armazenamento local.
Existem as seguintes rotinas para a realização de outras operações com armazenamento local:
web_data_number() - retorna o número total de campos guardados no armazenamento
local.
clear_web_data() - apaga todos os dados do armazenamento local.

3.13 Sistema
Além de variáveis e funções que podem ser encontrados em tópicos
acima, Tululoo contém um quadro da sua própria, que também tem as
suas próprias variáveis e funções. Estes não podem ser necessários para o
uso 'cotidiano', e estão documentadas aqui principalmente para
extensões.
var_override(object, property, getfunction, setfunction) - especificada variável 'overrides'
para o objeto, adicionando uma função setter e getter. Estes podem ser ambas as referências, ou
funções inline. Exemplo de uso:
var_override(this, 'rdirection',
function() { return tu_d2r * this.direction; },
function(value) { this.direction = value * tu_r2d; });

Todas as referências posteriores a variável object.rdirection voltará a sua direção atual,


convertido para radianos.
Alterar rdirection mudaria direção atual do objeto de acordo.
Setters & Getters pode ser usado para simplificar a sincronização variável

Math:
tu_2pi - contém o valor de 2 Math.PI (círculo completo em radianos).
tu_r2d - multiplicar um ângulo radiano por esta constante para convertê-lo em graus.
tu_d2r - multiplicar um ângulo por esta constante para convertê-lo em radianos.
tu_elapsed - indica o tempo (em ms) passou de ciclo jogo anterior.

Resources:
tu_idle - "boneco" (vazio) função, que pode ser utilizado como valor padrão para
variáveis de função.
tu_sprites - array, que contém todos os recursos do sprite do jogo.
tu_backgrounds - array, que contém todos os recursos do fundo do jogo.
tu_fonts - array, que contém todas as fonts do jogo.
tu_scenes - array, que contém todos as salas do jogo.
tu_audios - array, que contém toda a trilha sonora do jogo.

Instances:
tu_depth, tu_depthi - arrays, contendo a lista de instâncias classificadas por valor de
profundidade. Para obter instâncias em certa profundidade, use
tu_depth[tu_depthi.indexOf(depth)]
tu_types - array, contendo listas de instâncias por sua herança objeto. Use tu_types
[object_index] para obter todas as instâncias que são (ou são filhos de) casos de tipo
especificado.
Drawing:
tu_canvas - contém um ponteiro para HTML5 canvas, que Tululoo usa para o desenho.
tu_context - contém um apontador para "contexto" do tu_canvas.
Sound & Music: tu_wav_supported - indica se os sons WAV são suportados pelo
browser.
tu_ogg_supported - indica se os sons OGG são suportados pelo browser.
tu_mp3_supported - indica se os sons MP3 são suportados pelo browser.

Вам также может понравиться