0% acharam este documento útil (0 voto)

12 visualizações86 páginas

Ultra Mode 7

Enviado por

Arthur Machado

Direitos autorais

Levamos muito a sério os direitos de conteúdo. Se você suspeita que este conteúdo é seu, reivindique-o aqui.

Formatos disponíveis

Baixe no formato TXT, PDF, TXT ou leia on-line no Scribd

0% acharam este documento útil (0 voto)

12 visualizações86 páginas

Ultra Mode 7

Enviado por

Arthur Machado

Direitos autorais

Levamos muito a sério os direitos de conteúdo. Se você suspeita que este conteúdo é seu, reivindique-o aqui.

Formatos disponíveis

Baixe no formato TXT, PDF, TXT ou leia on-line no Scribd

//============================================== =============================

// Modo Ultra 7
//============================================== =============================

var Importado = Importado || {};

Importado.Blizzard_UltraMode7 = {};
Importado.Blizzard_UltraMode7.VERSION = 220;

/*:
@alvo MZ
@plugindesc Renderiza o tilemap em 3D. Suporta vários parâmetros como rotação de
guinada,
inclinação, campo de visão, etc.
@autor Blizzard
@url [Link]

@help Versão: 2.2.0

- licenciado sob a Licença BSD 2.0

--Licença--

Direitos autorais (c) Boris "Blizzard" Mikić

Redistribuição e uso em formatos de origem e binários, com ou sem

modificação, são permitidas desde que as seguintes condições sejam atendidas:

1. As redistribuições do código-fonte devem manter o aviso de direitos autorais

acima,
esta lista de condições e o seguinte aviso legal.

2. As redistribuições em formato binário devem reproduzir o aviso de direitos

autorais acima,
esta lista de condições e a seguinte isenção de responsabilidade na
documentação
e/ou outros materiais fornecidos com a distribuição.

3. Nem o nome do detentor dos direitos autorais nem os nomes dos seus colaboradores
pode ser usado para endossar ou promover produtos derivados deste software
sem permissão prévia específica por escrito.

ESTE SOFTWARE É FORNECIDO PELOS TITULARES DOS DIREITOS AUTORAIS E COLABORADORES "NO
ESTADO EM QUE SE ENCONTRA" E
QUAISQUER GARANTIAS EXPRESSAS OU IMPLÍCITAS, INCLUINDO, MAS NÃO SE LIMITANDO ÀS
IMPLÍCITAS
GARANTIAS DE COMERCIALIZAÇÃO E ADEQUAÇÃO A UM DETERMINADO FIM SÃO ISENTAS.
EM NENHUMA HIPÓTESE O TITULAR DOS DIREITOS AUTORAIS OU OS COLABORADORES SERÃO
RESPONSÁVEIS POR QUALQUER DANO DIRETO,
DANOS INDIRETOS, INCIDENTAIS, ESPECIAIS, EXEMPLARES OU CONSEQUENCIAIS (INCLUINDO,
MAS NÃO INCLUINDO
NÃO SE LIMITANDO A, AQUISIÇÃO DE BENS OU SERVIÇOS SUBSTITUTOS; PERDA DE USO, DADOS
OU
LUCROS; OU INTERRUPÇÃO DE NEGÓCIOS) INDEPENDENTEMENTE DA CAUSA E DE QUALQUER TEORIA
DE RESPONSABILIDADE,
SEJA POR CONTRATO, RESPONSABILIDADE OBJETIVA OU ATO ILÍCITO (INCLUINDO NEGLIGÊNCIA
OU OUTRO)
DECORRENTE DE QUALQUER FORMA DO USO DESTE SOFTWARE, MESMO QUE AVISADO DA
POSSIBILIDADE DE TAIS DANOS.
--Uso e atribuição de crédito--

Você pode usar este script para produtos comerciais e não comerciais sem
limitações desde que você cumpra as condições apresentadas pela licença acima.
A maneira "completa" de dar crédito é incluir a licença em algum lugar do seu
produto (por exemplo, na tela de créditos), mas uma maneira "simples" também é
aceitável.
A maneira "simples" de dar crédito é a seguinte:

Ultra Mode 7 licenciado sob a Licença BSD 2.0

Direitos autorais (c) Boris "Blizzard" Mikić

Alternativamente, se sua fonte não suporta caracteres diacríticos, você pode usar
isto
variante:

Ultra Mode 7 licenciado sob a Licença BSD 2.0

Direitos autorais (c) Boris "Blizzard" Mikic

Em geral, outras variantes semelhantes são permitidas, desde que fique claro quem é
o
criador é (por exemplo, "Ultra Mode 7 criado pela Blizzard" é aceitável). Mas se
possível, prefira usar uma das duas variantes listadas acima.

Se você não der crédito e/ou alegar que este trabalho foi criado por você, isto
pode resultar em ação legal e/ou pagamento de danos, mesmo que este trabalho seja
gratuito para uso normal.

--Introdução--

O Ultra Mode 7 simula o modo de renderização Mode 7 do SNES usando 3D

renderização. Os sprites são dimensionados apropriadamente e usam código adicional
para
determinar se eles são visíveis, devido à distância de corte. A visão
de um mapa do Modo 7 é definido pelos seguintes parâmetros:

- distância da câmera
- posição Y da câmera
- campo de visão
- ângulo de rotação do passo
- ângulo de rotação de guinada
- coordenada Z máxima

--Registro de alterações--

v2.2.0:
- compatibilidade corrigida com MZ Core 1.7.0 e posterior
- tratamento corrigido da opção LEGACY_SCALING

v2.1.2:
- adicionada opção LOOP_MAPS_EXTEND_TILES_SMART
- problema de configuração corrigido ao atualizar o plugin
- travamento corrigido com mapas em loop e FOV=90
- corrigido um bug na otimização de renderização de mapas em loop

v2.1.1:
- problemas corrigidos com o definidor de cores de fade
- problemas corrigidos com o fade begin setter
- problemas corrigidos com o fade end setter

v2.1.0:
- refatorou algum código para melhorar a compatibilidade geral

v2.0.9:
- bug corrigido com mapas invisíveis em loop

v2.0.8:
- corrigiu alguns novos problemas com os Grid-Free Doodads do Yanfly

v2.0.7:
- alterado NEAR_CLIP_Z para DEFAULT_NEAR_CLIP_Z
- alterado FAR_CLIP_Z para DEFAULT_FAR_CLIP_Z
- parâmetros de mapa adicionados para Near Clip Z e Far Clip Z
- Plugins Terrax personalizados atualizados - Código de compatibilidade do sistema
de iluminação

v2.0.6:
- problemas corrigidos com scripts principais do MZ v1.5.0

v2.0.5:
- adicionada opção CHARACTERS_SHIFT_Y

v2.0.4:
- corrigidos mais alguns problemas de compatibilidade para vários outros plugins

v2.0.3:
- corrigidos pequenos problemas de compatibilidade com vários outros plugins

v2.0.2:
- problema de rotação de rolagem corrigido com ZephAM_YEPDoodadExt
- problemas de desempenho corrigidos em mapas maiores no RPG Maker MZ
- problema corrigido com mapas em loop no RPG Maker MZ
- corrigido pequeno problema de deslocamento com exibição de mapa no RPG Maker MZ
- CHARACTERS_USE_FADE_Z habilitado novamente por padrão (RPG Maker MZ não tem
problemas de desempenho)

v2.0.1:
- corrigiu um pequeno problema de renderização
- estrutura de código de shader unificada melhorada

v2.0.0:
- compatibilidade implementada com RPG Maker MZ

v1.7.6:
- corrigidos pequenos problemas de compatibilidade para Galv Map Projectiles

v1.7.5:
- compatibilidade adicionada para projéteis Galv Map

v1.7.4:
- compatibilidade adicionada para SAN_AnalogMove quando
PLAYER_ADJUST_MOVE_DIRECTION está ativado
- suporte de ângulo de rotação adicionado

v1.7.3:
- problemas de carregamento corrigidos com OcRam_Lights
v1.7.2:
- problemas corrigidos com os Grid-Free Doodads do Yanfly em compilações
implantadas
- problemas corrigidos com luzes de marcação de terreno em OcRam_Lights
- salvaguardas adicionadas para evitar que códigos de compatibilidade defeituosos
afetem outros códigos de compatibilidade
- NEAR_CLIP_Z limitado a um mínimo de 1 devido a problemas com renderização para
valores de 0 ou menos
- CHARACTERS_USE_FADE_Z desabilitado por padrão devido a problemas de desempenho

v1.7.1:
- corrigidos alguns problemas no código de compatibilidade para OcRam_Lights

v1.7.0:
- código de compatibilidade adicionado para OcRam_Lights
- código de compatibilidade aprimorado para KhasUltraLighting

v1.6.5:
- atualizou algumas instruções

v1.6.4:
- corrigidos erros de atribuição de const

v1.6.3:
- posicionamento refatorado em mapas em loop
- posicionamento de sprite corrigido em mapas em loop para Grid-Free Doodads do
Yanfly
- adicionada opção CHARACTERS_USE_FADE_Z
- removido algum código de depuração restante

v1.6.2:
- tentativa de correção nos Grid-Free Doodads do Yanfly para posicionamento de
sprites em mapas em loop

v1.6.1:
- código melhorado que manipula o posicionamento de sprites em mapas em loop

v1.6.0:
- implementou escala aprimorada de sprites no mapa que não é bagunçada por planos
de recorte próximos e distantes
- alterou alguns dos parâmetros padrão para acomodar os problemas de escala
corrigidos
- adicionado parâmetro LEGACY_SCALING para compatibilidade com versões anteriores

v1.5.4:
- bug corrigido com cálculos de tela para mapa ao usar projeção ortogonal

v1.5.3:
- código de compatibilidade aprimorado para KhasUltraLighting

v1.5.2:
- adicionada posição y da câmera

v1.5.1:
- adicionado início de desbotamento de cor para mapear parâmetros
- adicionado fim de desbotamento de cor aos parâmetros do mapa

v1.5.0:
- parâmetros de mapa adicionados para bordas de mapa
v1.4.6:
- compatibilidade adicionada para versões mais recentes do pixi-tilemap

v1.4.5:
- compatibilidade adicionada com Quasi Simple Shadows

v1.4.4:
- compatibilidade adicionada com Thomas Edison MV
- problema corrigido com paralaxe de coordenada fixa não funcionando

v1.4.3:
- NEAR_CLIP_Z alterado de constante para parâmetro de plugin

v1.4.2:
- adicionado novo parâmetro FADE_Z_COLOR
- adicionada opção para configurar cores de desbotamento personalizadas para mapas
específicos
- adicionada opção para alterar a cor de desbotamento a qualquer momento

v1.4.1:
- compatibilidade adicionada com os Grid-Free Doodads da Yanfly
- compatibilidade adicionada com o Character Motion do MOG

v1.4.0:
- adicionada nova licença
- instruções de uso e crédito adicionadas

v1.3.8:
- chamada de script adicionada para habilitar/desabilitar renderização pixelada
durante o tempo de execução
- WEBGL_MAX_VERTICES reduzido para reduzir a possibilidade de renderização com
falhas

v1.3.7:
- adicionada compatibilidade experimental para o plugin BattleLighting

v1.3.6:
- adicionada compatibilidade experimental para o plugin BattleLighting

v1.3.5:
- corrigidos alguns pequenos erros de posicionamento e cálculo de escala
- código de compatibilidade aprimorado para KhasUltraLighting

v1.3.4:
- código de compatibilidade adicionado para KhasUltraLighting
- instruções de compatibilidade adicionadas para Terrax Plugins - Sistema de
iluminação

v1.3.3:
- problema corrigido com visibilidade de eventos nas bordas do mapa ao usar mapas
em loop

v1.3.2:
- adicionado arredondamento de coordenadas para coordenadas X e Y
- código melhorado que manipula a visibilidade do sprite quando fora do frustum da
visualização
- removeu algumas impressões de depuração restantes
v1.3.1:
- corrigiu uma falha com o teste de eventos

v1.3.0:
- implementou a funcionalidade de loop de mapa
- adicionada solução alternativa para o bug do PIXI onde um pico de atraso ocorria
a cada 10 segundos
- problema corrigido onde a direção do sprite não era exibida corretamente em
certos ângulos de guinada
- problema corrigido onde os controles de movimento não se ajustavam ao ângulo de
guinada
- adicionada opção CHARACTERS_ADJUST_SPRITE_DIRECTION
- deslocamento de coordenada fixo ao usar ângulo de guinada

v1.2.4:
- remoção acidental corrigida da função animateCameraDistance

v1.2.3:
- adicionado parâmetro de distância de paralaxe em mapas para movimento de paralaxe
com guinada e inclinação
- renomeou as funções "Camera" para "CameraDistance"
- bug corrigido com rolagem parallax em mapas que não sejam do Modo 7
- bug corrigido com a tela tremendo
- removido limite de FOV e implementada projeção ortogonal com FOV de 0°

v1.2.2:
- corrigiu um erro de sintaxe causado pela limpeza do código

v1.2.1:
- problema de salvar dados corrigido

v1.2.0:
- problema de queda de FPS corrigido durante o movimento

v1.1.0:
- adicionada função de animação para parâmetros
- renomeou a opção RENDER_PIXELATED para TILEMAP_PIXELATED
- adicionada opção CHARACTERS_PIXELATED
- problema corrigido com caracteres flutuantes
- problema corrigido com mapas normais que não funcionavam mais
- adicionado algum código para evitar problemas de compatibilidade com alguns
scripts de mapa

--Como usar--

Mapas separados podem controlar e até mesmo alterar dinamicamente a maioria dos
parâmetros. Em
para transformar um mapa normal em um mapa Modo 7, parâmetros personalizados
precisam ser
definido na seção "Nota" do mapa. Para usar os valores padrão para um
mapa, basta adicionar a seguinte entrada à "nota" do mapa:

Se qualquer outro parâmetro for definido, isso não é necessário. O seguinte

parâmetros podem ser definidos:

- UltraMode7_FOV
- UltraMode7_Pitch
- UltraMode7_Yaw
- UltraMode7_Roll
- UltraMode7_CameraDistance
- UltraMode7_CâmeraY
- UltraMode7_NearClipZ
- UltraMode7_FarClipZ
- UltraMode7_FadeColor
- UltraMode7_ParallaxDistance
- UltraMode7_Border
- UltraMode7_BorderHorizontal
- UltraMode7_BorderVertical
- UltraMode7_BorderLeft
- UltraMode7_BorderRight
- UltraMode7_BorderTop
- UltraMode7_BorderBottom

Exemplo:

<UltraMode7_FOV:50>

Quando vários parâmetros são definidos, basta adicioná-los um após o outro.

Exemplo:

<UltraMode7_Pitch:50>
<UltraMode7_CameraDistance:400>
<UltraMode7_CameraY:20>
<UltraMode7_Yaw:45>
<UltraMode7_Roll:10>
<UltraMode7_FadeColor:1,1,0.5>
<UltraMode7_ParallaxDistance:800>
<UltraMode7_BorderVertical:4>

--Como alterar parâmetros dinamicamente--

Os 4 parâmetros que podem ser definidos na seção de notas de um mapa também podem
pode ser alterado a qualquer momento durante o mapa. As seguintes chamadas estão
disponíveis:

[Link](GRAUS)
[Link](GRAUS)
[Link](GRAUS)
[Link](GRAUS)
[Link](DISTÂNCIA_Z)
[Link](POSIÇÃO_Y)
[Link](NEAR_CLIP_Z)
[Link](FAR_CLIP_Z)
[Link](RGB_COLOR)
[Link](COORDENAÇÃO Z)
[Link](COORDENADA_Z)
[Link](DISTÂNCIA)
[Link](VERDADEIRO_FALSO)

Você também pode obter os valores atuais com estas chamadas:

[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()

Você também pode alterar os valores de forma animada:

[Link](VALOR_ALVO, DURAÇÃO_DE_QUADROS)
[Link](VALOR_ALVO, DURAÇÃO_DE_QUADROS)
[Link](VALOR_ALVO, DURAÇÃO_DE_QUADROS)
[Link](VALOR_ALVO, DURAÇÃO_DE_QUADROS)
[Link](VALOR_ALVO, DURAÇÃO_DE_QUADROS)
[Link](VALOR_ALVO, DURAÇÃO_DE_QUADROS)
[Link](VALOR_ALVO, DURAÇÃO_DE_QUADROS)
[Link](VALOR_ALVO, DURAÇÃO_DE_QUADROS)
[Link](COR_RGB, DURAÇÃO_DE_QUADROS)
[Link](VALOR_ALVO, DURAÇÃO_DE_QUADROS)
[Link](VALOR_ALVO, DURAÇÃO_DE_QUADROS)

Notas:

- A maioria dos valores são inteiros simples ou valores decimais, RGB_COLOR é uma
matriz de 3
valores. por exemplo [1, 1, 0] seria amarelo.
- Todas as durações estão em quadros.

A distância de paralaxe não pode ser animada devido à sua implementação interna
depender
em valores fixos.

--Notas adicionais--

- Ao usar fundos de paralaxe devido à forma como a renderização é feita, é útil

ter uma paralaxe personalizada que desaparece em branco e cria uma imagem
perfeita
transição para os ladrilhos desbotados. Certifique-se de ajustar as mudanças no
ângulo de inclinação também.
- Valores maiores para DEFAULT_NEAR_CLIP_Z podem ajudar a reduzir problemas com
os personagens ficam muito grandes quando estão perto da câmera e se uma baixa
o valor do pitch é usado.
- Valores menores de DEFAULT_FAR_CLIP_Z farão com que os caracteres e o tilemap
para ser cortado antes. Efetivamente, ele move o horizonte de corte para mais
perto.
- Se você não quiser um fade-out branco, defina ambos os valores FADE_Z para um
valor maior
do que DEFAULT_FAR_CLIP_Z.
- Quando o valor de guinada é alterado, os caracteres são girados de acordo, mas
os controles não são alterados.
- Considere usar os mesmos valores para BASE_SCALE_Z e DEFAULT_CAMERA_DISTANCE.
- O Modo Ultra 7 é configurado para exibir o personagem do jogador no meio do
tela com uma escala perfeita de pixels de 1:1. Ao usar DEFAULT_CAMERA_Y, mantenha
tendo em mente que posicionar a câmera acima ou abaixo muda o jogador
posição no espaço 3D e você pode querer considerar usar um valor diferente para
ESCALA_BASE_Z.
- Se você usar um campo de visão de 0, o modo de exibição mudará para projeção
ortogonal.
- Ao usar mapas de loop, a mudança de FOV, distância da câmera e clipe distante
O plano Z pode exigir o recálculo de todo o mapa de blocos e pode causar
quedas momentâneas no desempenho, por isso deve ser usado com moderação.
- Ao usar um sistema em tempo real com transição dia-noite, pode ser melhor
para aplicar a cor de esmaecimento constantemente como um valor derivado do dia-
noite
colorir em vez de usar animação de cores esmaecidas.
- Ao usar UltraMode7_Border, todas as outras opções de borda serão ignoradas.
- Ao usar UltraMode7_BorderHorizontal, UltraMode7_BorderLeft e
UltraMode7_BorderRight será ignorado.
- Ao usar UltraMode7_BorderVertical, UltraMode7_BorderTop e
UltraMode7_BorderBottom será ignorado.
- Mapas em loop ignoram todas as configurações de borda.
- Se estiver usando CHARACTERS_USE_FADE_Z, tenha em mente que outros plugins podem
substituir o valor da cor de mesclagem para o sprite ou ser substituído por
Modo Ultra 7.

--Detalhes técnicos, limitações e compatibilidade--

- Embora o suporte ao RPG Maker MZ esteja disponível no Modo Ultra 7, nem toda a
compatibilidade
o código para esses plugins foi testado com RPG Maker MZ. Por favor, reporte
qualquer
problemas que você possa encontrar para que eles possam ser corrigidos.
- Se você atualizar de uma versão anterior, após substituir o arquivo real,
você deve abrir as configurações do plugin e confirmá-las/fechá-las novamente.
Às vezes, novos recursos e opções são adicionados e isso garante que o
a versão mais recente do plugin não trava ao adicionar as novas opções
configurações do sistema do seu projeto.
- Requer WebGL. Não funciona com canvas e devido a como o canvas funciona,
nunca pode suportar tela.
- Devido ao dimensionamento de sprites, como as folhas de sprites dos personagens
são organizadas e como
a interpolação de pixels é feita quando a escala é aplicada, pode haver artefatos
durante a renderização de caracteres. Manipulando o valor DEFAULT_FAR_CLIP_Z
pode ajudar a remover esses artefatos até certo ponto.
- O tilemap é renderizado em sua totalidade e a matriz de projeção é usada
para limitar a visibilidade. O hardware deve cuidar da otimização da
renderização.
- Devido a um limite rígido de 65536 vértices renderizados de uma vez no WebGL, o
o código foi ajustado para renderizar o tilemap em quantas passagens forem
necessárias.
Como algumas pessoas relataram problemas mesmo com 65536 vértices, um inferior
suave
limit está sendo usado dentro do script.
- Como o mapa de blocos é renderizado totalmente plano, a prioridade de blocos não
é usada.
- No RPG Maker MV a opção TILEMAP_PIXELATED e altere via
[Link]() também afeta mapas que não são do Modo 7.
- A escala foi otimizada para uso de um FOV de 60°. Usando diferentes
valores causarão algumas escalas estranhas sendo usadas para caracteres.
- Usar valores baixos para FOV provavelmente causará problemas de exibição (exceto
para 0°
que ativará a projeção ortogonal).
- Devido à rotação de guinada que requer a rotação dos caracteres, 8 direções
sprites de personagens podem ter suporte limitado.
- Ao usar mapas de looping, não os torne muito pequenos. Posicionamento de eventos
no
caso contrário, a borda do mapa pode causar problemas.
- Devido à forma como o PRG Maker MV trabalha com a mistura de cores e matizes/tons
de cores, usando
CHARACTERS_USE_FADE_Z pode causar problemas de desempenho ao mover verticalmente.
- Possivelmente não é compatível com scripts que manipulam muito os dados do
tilemap
ou muito profundamente.
- Compatível com KhasUltraLighting (MV). Coloque o Ultra Mode 7 ABAIXO desse
plugin.
- Compatível com Grid-Free Doodads (MV) da Yanfly. Coloque o Ultra Mode 7 ABAIXO
desse plugin.
A coordenada "z" em enfeites não é suportada.
- Compatível com o Character Motion (MV) do MOG. Coloque o Ultra Mode 7 ABAIXO
desse plugin.
- Compatível com Thomas Edison MV (MV). Coloque Ultra Mode 7 ABAIXO desse plugin.
- Compatível com Quasi Simple Shadows (MV). Coloque o Ultra Mode 7 ABAIXO desse
plugin.
- Compatível com OcRam_Lights (MV). Coloque Ultra Mode 7 ABAIXO desse plugin.
- Compatível com algumas versões mais recentes do pixi-tilemap (MV).
- Possivelmente não compatível com objetos de caracteres personalizados que não
derivam
de Game_Event.

--Código de compatibilidade personalizado

- Este script pode ser compatível com o script

"Terrax Plugins - Sistema de iluminação", mas devido à forma como é
escrito, a compatibilidade precisa ser feita manualmente. Encontre este segmento
de
código:

se (lanterna == verdadeiro) {
this._maskBitmap.radialgradientFillRect2(lx1, ly1, 0, raio_de_luz,
valor_da_cor, '#000000', ldir, comprimento_do_flash, largura_do_flash);
} outro {
this._maskBitmap.radialgradientFillRect(lx1, ly1, 0, raio_de_luz,
valor_de_cor, '#000000', cintilação_de_objeto, brilho, direção);
}

Substitua por isto:

var visível = verdadeiro;

se ([Link]())
{
const posição = [Link](lx1, ly1 + ph / 2);
se ($gameMap.ultraMode7Fov > 0)
{
const z = posição.z;
se (z <= $gameMap.ultraMode7NearClipZ && z >=
$gameMap.ultraMode7FarClipZ)
{
visível = falso;
}
}
se (visível)
{
const escala = [Link](lx1, ly1);
lx1 = posição.x;
ly1 = posição.y -= ph / 2 * escala;
raio_de_luz *= escala;
}
}
se (visível)
{
se (lanterna === verdadeiro)
{
this._maskBitmap.radialgradientFillRect2(lx1, ly1, 0, raio_de_luz,
valor_da_cor, '#000000', ldir, comprimento_do_flash, largura_do_flash);
}
outro
{
this._maskBitmap.radialgradientFillRect(lx1, ly1, 0, raio_de_luz,
valor_de_cor, '#000000', cintilação_de_objeto, brilho, direção);
}
}

Isso fará com que "Terrax Plugins - Sistema de iluminação" funcione com o Modo
Ultra 7.

@param FADE_Z_COLOR
@desc Define a cor de desbotamento global no mapa de blocos como RGB no intervalo
[0, 1].
@padrão 1,1,1

@param FADE_Z_BEGIN
@desc Define a coordenada Z na qual o desbotamento branco começará no mapa de
blocos.
@padrão 500

@param FADE_Z_END
@desc Define a coordenada Z na qual o desbotamento branco será total no mapa de
blocos.
@padrão 1150

@param ESCALA_BASE_Z
@desc Define a coordenada Z na qual a escala do caractere é 1,0.
@padrão 550

@param ESCALA_LEGADO
@desc Ativa o cálculo de escala de sprites antes da v1.6.0.
ON = verdadeiro, OFF = falso
@padrão falso

@param PARALLAX_SCROLL_X_MULTIPLICADOR
@desc Define o multiplicador para rolagem X de paralaxe.
@padrão 0,5

@param PARALLAX_SCROLL_Y_MULTIPLICADOR
@desc Define o multiplicador para rolagem Y de paralaxe.
@padrão 1.0

@param TILEMAP_PIXELATED
@desc Se o tilemap deve ser renderizado pixelado.
ON = verdadeiro, OFF = falso
@default verdadeiro

@param PERSONAGENS_PIXELADOS
@desc Se os caracteres devem ser renderizados pixelados.
ON = verdadeiro, OFF = falso
@default verdadeiro

@param PERSONAGENS_AJUSTE_DIREÇÃO_DO_SPRITE
@desc Se os personagens devem ter a direção do sprite ajustada ao ângulo de
guinada.
ON = verdadeiro, OFF = falso
@default verdadeiro

@param CARACTERES_USO_FADE_Z
@desc Se algum caractere deve usar a cor fade-z.
ON = verdadeiro, OFF = falso
@default verdadeiro

@param CARACTERES_SHIFT_Y
@desc Quanto o deslocamento shift-Y deve ser aplicado aos caracteres.
@padrão 6

@param AJUSTE_DA_DIREÇÃO_DO_MOVIMENTO_DO_JOGADOR
@desc Se a entrada direcional do jogador deve ser ajustada para o ângulo de
guinada.
ON = verdadeiro, OFF = falso
@default verdadeiro

@param LOOP_MAPS_EXTEND_TILES
@desc Os blocos adicionais que são renderizados em mapas em loop.
@padrão 2

@param LOOP_MAPS_EXTEND_TILES_SMART
@desc Manipulação mais inteligente de blocos adicionais em mapas em loop (apenas
aumentos, em etapas).
@default verdadeiro

@param DEFAULT_FOV
@desc Define o valor padrão para o parâmetro do campo de visão (em graus).
@padrão 60

@param PADRÃO_DEPITCH
@desc Define o valor padrão para o parâmetro do ângulo de rotação do pitch (em
graus).
@padrão 45

@param DEFAULT_YAW
@desc Define o valor padrão para o parâmetro do ângulo de rotação de guinada (em
graus).
@padrão 0

@param DEFAULT_ROLL
@desc Define o valor padrão para o parâmetro do ângulo de rotação do rolo (em
graus).
@padrão 0

@param DISTÂNCIA_PADRÃO_DA_CÂMERA
@desc Define a distância padrão da câmera em relação ao mapa de blocos no espaço da
tela.
@padrão 550

@param DEFAULT_CAMERA_Y
@desc Define a posição y padrão da câmera a partir do mapa de blocos no espaço da
tela.
@padrão 0

@param PADRÃO_PRÓXIMO_CLIP_Z
@desc Define a coordenada Z mínima padrão para visibilidade de blocos e
personagens.
@padrão 100

@param PADRÃO_FAR_CLIP_Z
@desc Define a coordenada Z máxima padrão para visibilidade de blocos e
personagens.
@padrão 1200

@param DISTÂNCIA_PARALLAXE_PADRÃO
@desc Define a distância da paralaxe da posição central da câmera.
@padrão 550

//============================================== =============================
// Vetor3
//============================================== =============================

função Vector3()
{
[Link](this, argumentos);
}

[Link] = função(x, y, z)
{
isto.x = (x || 0);
isto.y = (y || 0);
isto.z = (z || 0);
};

[Link] = função(x, y, z)
{
isto.x = x;
isto.y = y;
isto.z = z;
};

[Link] = função()
{
retornar [Link](isto.x * isto.x + isto.y * isto.y + isto.z * isto.z);
};

[Link] = função()
{
var comprimento = [Link]();
se (comprimento !== 0)
{
comprimento = 1 / comprimento;
this.x *= comprimento;
this.y *= comprimento;
this.z *= comprimento;
}
};
[Link] = função()
{
isto.x = -isto.x;
isto.y = -isto.y;
isto.z = -isto.z;
};

[Link] = função(fator)
{
this.x *= fator;
this.y *= fator;
this.z *= fator;
};

[Link] = função(outro)
{
retornar novo Vector3(this.x + other.x, this.y + other.y, this.z + other.z);
};

[Link] = função(outro)
{
retornar novo Vector3(this.x - other.x, this.y - other.y, this.z - other.z);
};

[Link] = função(outro)
{
retornar novo Vector3((this.x + other.x) / 2, (this.y + other.y) / 2, (this.z
+ other.z) / 2);
};

[Link] = função(outro)
{
retornar (este.x * outro.x + este.y * outro.y + este.z * outro.z);
};

[Link] = função(outro)
{
retornar novo Vector3(este.y * outro.z - este.z * outro.y, este.z * outro.x -
este.x * outro.z, este.x * outro.y - este.y * outro.x);
};

//============================================== =============================
// Matriz4
//============================================== =============================

função Matrix4()
{
[Link](this, argumentos);
}

[Link] = função(dados)
{
se (dados)
{
[Link] = [Link]();
}
outro
{
[Link] = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
}
};

[Link] = função()
{
[Link]();
[Link][0] = [Link][5] = [Link][10] = [Link][15] = 1;
};

[Link] = função()
{
para (var i = 0; i < 16; ++i)
{
[Link][i] = 0;
}
};

[Link] = função(dados)
{
[Link] = [Link]();
};

[Link] = função(vetor)
{
[Link]();
[Link][12] = vetor.x;
[Link][13] = vetor.y;
[Link][14] = vetor.z;
};

[Link] = função(x, y, z)
{
const matriz = nova Matriz4();
[Link](novo Vetor3(x, y, z));
[Link](matriz);
};

[Link] = função(ângulo)
{
const matriz = nova Matriz4();
[Link](ângulo);
[Link](matriz);
};

[Link] = função(ângulo)
{
[Link]();
const rad = [Link](ângulo);
[Link][0] = [Link][15] = 1;
[Link][5] = [Link][10] = [Link](rad);
[Link][6] = [Link](rad);
[Link][9] = -[Link][6];
};

[Link] = função(ângulo)
{
[Link]();
const rad = [Link](ângulo);
[Link][5] = [Link][15] = 1;
[Link][0] = [Link][10] = [Link](rad);
[Link][8] = [Link](rad);
[Link][2] = -[Link][8];
};

[Link] = função(ângulo)
{
[Link]();
const rad = [Link](ângulo);
[Link][10] = [Link][15] = 1;
[Link][0] = [Link][5] = [Link](rad);
[Link][1] = [Link](rad);
[Link][4] = -[Link][1];
};

[Link] = função(outro)
{
[Link]([[Link][0] * [Link][0] + [Link][4] * [Link][1] +
[Link][8] * [Link][2] + [Link][12] * [Link][3],
[Link][1] * [Link][0] + [Link][5] * [Link][1] +
[Link][9] * [Link][2] + [Link][13] * [Link][3],
[Link][2] * [Link][0] + [Link][6] * [Link][1] +
[Link][10] * [Link][2] + [Link][14] * [Link][3],
[Link][3] * [Link][0] + [Link][7] * [Link][1] +
[Link][11] * [Link][2] + [Link][15] * [Link][3],
[Link][0] * [Link][4] + [Link][4] * [Link][5] +
[Link][8] * [Link][6] + [Link][12] * [Link][7],
[Link][1] * [Link][4] + [Link][5] * [Link][5] +
[Link][9] * [Link][6] + [Link][13] * [Link][7],
[Link][2] * [Link][4] + [Link][6] * [Link][5] +
[Link][10] * [Link][6] + [Link][14] * [Link][7],
[Link][3] * [Link][4] + [Link][7] * [Link][5] +
[Link][11] * [Link][6] + [Link][15] * [Link][7],
[Link][0] * [Link][8] + [Link][4] * [Link][9] +
[Link][8] * [Link][10] + [Link][12] * [Link][11],
[Link][1] * [Link][8] + [Link][5] * [Link][9] +
[Link][9] * [Link][10] + [Link][13] * [Link][11],
[Link][2] * [Link][8] + [Link][6] * [Link][9] +
[Link][10] * [Link][10] + [Link][14] * [Link][11],
[Link][3] * [Link][8] + [Link][7] * [Link][9] +
[Link][11] * [Link][10] + [Link][15] * [Link][11],
[Link][0] * [Link][12] + [Link][4] * [Link][13] +
[Link][8] * [Link][14] + [Link][12] * [Link][15],
[Link][1] * [Link][12] + [Link][5] * [Link][13] +
[Link][9] * [Link][14] + [Link][13] * [Link][15],
[Link][2] * [Link][12] + [Link][6] * [Link][13] +
[Link][10] * [Link][14] + [Link][14] * [Link][15],
[Link][3] * [Link][12] + [Link][7] * [Link][13] +
[Link][11] * [Link][14] + [Link][15] * [Link][15]]);
};

[Link] = função(vetor)
{
retornar novo Vector3([Link][0] * vector.x + [Link][4] * vector.y +
[Link][8] * vector.z + [Link][12],
[Link][1] * vetor.x + [Link][5] * vetor.y + [Link][9] *
vetor.z + [Link][13],
[Link][2] * vetor.x + [Link][6] * vetor.y + [Link][10] *
vetor.z + [Link][14]);
};

[Link] = função(olho, alvo, cima)

{
[Link]();
const bz = [Link](alvo);
[Link]();
const bx = para [Link](bz);
[Link]();
const por = [Link](bx);
[Link]();
[Link][0] = bx.x; [Link][1] = por.x; [Link][2] = bz.x;
[Link][4] = bx.y; [Link][5] = por.y; [Link][6] = bz.y;
[Link][8] = bx.z; [Link][9] = por.z; [Link][10] = bz.z;
[Link][15] = 1;
[Link]();
const b = nova Matriz4();
[Link](olho);
[Link](b);
};

[Link] = função()
{
const invDet = 1 / [Link]();
m = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
m[0] = ([Link][5] * [Link][10] - [Link][9] * [Link][6]) *
invDet;
m[1] = -([Link][1] * [Link][10] - [Link][9] * [Link][2])
* invDet;
m[2] = ([Link][1] * [Link][6] - [Link][5] * [Link][2]) *
invDet;
m[4] = -([Link][4] * [Link][10] - [Link][8] * [Link][6])
* invDet;
m[5] = ([Link][0] * [Link][10] - [Link][8] * [Link][2]) *
invDet;
m[6] = -([Link][0] * [Link][6] - [Link][4] * [Link][2]) *
invDet;
m[8] = ([Link][4] * [Link][9] - [Link][8] * [Link][5]) *
invDet;
m[9] = -([Link][0] * [Link][9] - [Link][8] * [Link][1]) *
invDet;
m[10] = ([Link][0] * [Link][5] - [Link][4] * [Link][1]) *
invDet;
m[12] = -([Link][12] * m[0] + [Link][13] * m[4] + [Link][14] *
m[8]);
m[13] = -([Link][12] * m[1] + [Link][13] * m[5] + [Link][14] *
m[9]);
m[14] = -([Link][12] * m[2] + [Link][13] * m[6] + [Link][14] *
m[10]);
retornar nova Matriz4(m);
};

[Link] = função()
{
retornar ([Link][0] * [Link][5] * [Link][10] +
[Link][2] * [Link][4] * [Link][9] +
[Link][1] * [Link][6] * [Link][8] -
[Link][2] * [Link][5] * [Link][8] -
[Link][1] * [Link][4] * [Link][10] -
[Link][0] * [Link][6] * [Link][9]);
};

[Link] = função()
{
[Link]([[Link][0], [Link][4], [Link][8], [Link][12],
[Link][1], [Link][5], [Link][9], [Link][13],
[Link][2], [Link][6], [Link][10], [Link][14],
[Link][3], [Link][7], [Link][11], [Link][15]]);
};

//============================================== =============================
// Modo Ultra 7
//============================================== =============================

(função() {

se (!!Grá[Link] && !Grá[Link]())

{
[Link]("O Ultra Mode 7 requer suporte a WebGL!");
retornar;
}
//============================================== =============================
// Utilitário Blizzard
//============================================== =============================

se (typeof(BlizzardUtility) === "indefinido")

{
BlizzardUtility = função()
{
lançar novo erro("Esta é uma classe estática");
};
}

[Link] = função(graus)
{
retornar (graus * 0,01745329251994329576923690768489);
};

[Link] = função(radianos)
{
retornar (radianos * 57,295779513082320876798154814105);
};

[Link] = função(x, y)
{
retornar [Link](x * x + y * y);
};

[Link] = função(valor, valorpadrão)

{
const resultado = Número(valor);
retornar (resultado || resultado === 0 ? resultado : defaultValue);
};

[Link] = função(valor, valorpadrão)

{
retornar (valor !== indefinido && (valor === "verdadeiro" || valor ===
"falso") ? (valor !== "falso") : valorpadrão);
};

//============================================== =============================
// UltraMode7
//============================================== =============================

UltraMode7 = {};

[Link] = função(mensagem)
{
[Link]("Modo Ultra 7: " + mensagem);
};

// constantes
// OBSERVAÇÃO: Não altere essas informações a menos que você saiba o que está
fazendo!

UltraMode7.WEBGL_MAX_VERTICES = 65520; // fique abaixo do limite do WebGL de 65536

UltraMode7.FLOAT_SIZE = 4;
UltraMode7.MIN_FOV = 0;
UltraMode7.MIN_PITCH = 0;
UltraMode7.MAX_PITCH = 90;
UltraMode7.RMMZ_TEXTURE_SIZE = 2048;
UltraMode7.IS_RMMZ = (Utils.RPGMAKER_NAME === "MZ");
UltraMode7.IS_RMMV = !UltraMode7.IS_RMMZ;

// parâmetros de configuração

const _parameters = [Link]("UltraMode7");

UltraMode7.FADE_Z_COLOR = [Link]("[" + _parameters["FADE_Z_COLOR"] + "]");
UltraMode7.FADE_Z_BEGIN = [Link](_parâmetros["FADE_Z_BEGIN"],
500);
UltraMode7.FADE_Z_END = [Link](_parâmetros["FADE_Z_END"], 1150);
UltraMode7.BASE_SCALE_Z = [Link](_parâmetros["BASE_SCALE_Z"],
550);
UltraMode7.LEGACY_SCALING = [Link](_parameters["LEGACY_SCALING"],
falso);
UltraMode7.PARALLAX_SCROLL_X_MULTIPLIER =
[Link](_parameters["PARALLAX_SCROLL_X_MULTIPLIER"], 0.5);
UltraMode7.PARALLAX_SCROLL_Y_MULTIPLIER =
[Link](_parameters["PARALLAX_SCROLL_Y_MULTIPLIER"], 1.0);
UltraMode7.TILEMAP_PIXELATED =
[Link](_parameters["TILEMAP_PIXELATED"], verdadeiro);
UltraMode7.CHARACTERS_PIXELATED =
[Link](_parameters["CHARACTERS_PIXELATED"], verdadeiro);
UltraMode7.CHARACTERS_ADJUST_SPRITE_DIRECTION =
[Link](_parameters["CHARACTERS_ADJUST_SPRITE_DIRECTION"],
verdadeiro);
UltraMode7.CHARACTERS_USE_FADE_Z =
[Link](_parameters["CHARACTERS_USE_FADE_Z"] , verdadeiro);
UltraMode7.CHARACTERS_SHIFT_Y =
[Link](_parameters["CHARACTERS_SHIFT_Y"], 6);
UltraMode7.PLAYER_ADJUST_MOVE_DIRECTION =
[Link](_parameters["PLAYER_ADJUST_MOVE_DIRECTION"], verdadeiro);
UltraMode7.LOOP_MAPS_EXTEND_TILES =
[Link]([Link](_parameters["LOOP_MAPS_EXTEND_TILES"], 2), 0);
UltraMode7.LOOP_MAPS_EXTEND_TILES_SMART =
[Link](_parameters["LOOP_MAPS_EXTEND_TILES_SMART"], verdadeiro);
UltraMode7.DEFAULT_FOV = [Link](_parameters["DEFAULT_FOV"], 60);
UltraMode7.DEFAULT_PITCH = [Link](_parameters["DEFAULT_PITCH"],
45);
UltraMode7.DEFAULT_YAW = [Link](_parameters["DEFAULT_YAW"], 0);
UltraMode7.DEFAULT_ROLL = [Link](_parameters["DEFAULT_ROLL"], 0);
[Link]ÂNCIA_PADRÃO_DA_CÂMERA =
[Link]([Link](_parameters["DISTÂNCIA_PADRÃO_DA_CÂMERA"], 550),
0);
UltraMode7.DEFAULT_CAMERA_Y =
[Link](_parameters["DEFAULT_CAMERA_Y"], 0);
UltraMode7.DEFAULT_NEAR_CLIP_Z =
[Link]([Link](_parameters["DEFAULT_NEAR_CLIP_Z"], 100), 1);
UltraMode7.DEFAULT_FAR_CLIP_Z =
[Link]([Link](_parameters["DEFAULT_FAR_CLIP_Z"], 1200),
UltraMode7.DEFAULT_NEAR_CLIP_Z + 1);
[Link]ÂNCIA_PARALAXE_PADRÃO =
[Link]([Link](_parameters["DISTÂNCIA_PARALAXE_PADRÃO"], 550),
1);

// validação de parâmetros

[Link] = função(cor)
{
se (![Link](cor) || [Link] !== 3)
{
[Link]("O parâmetro para 'fade Z color' está incorreto! Padrão
de volta para '1,1,1'.");
retornar [1.0, 1.0, 1.0];
}
retornar [cor[0].clamp(0.0, 1.0), cor[1].clamp(0.0, 1.0), cor[2].clamp(0.0,
1.0)];
};

UltraMode7.FADE_Z_COLOR = [Link](UltraMode7.FADE_Z_COLOR);

// código de compatibilidade adicional

se (UltraMode7.IS_RMMV)
{
UltraMode7.NEWER_PIXI_TILEMAP = !!
[Link];
se (UltraMode7.NEWER_PIXI_TILEMAP)
{
[Link]("Detectada uma implementação mais recente de 'pixi-
tilemap', habilitando o código de compatibilidade.");
}
}

// funções de interface para chamadas de plugin

[Link] = função()
{
retornar $gameMap.ultraMode7Fov;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7Fov(valor);
};

[Link] = função()
{
retornar $gameMap.ultraMode7Pitch;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7Pitch(valor);
};

[Link] = função()
{
retornar $gameMap.ultraMode7Yaw;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7Yaw(valor);
};

[Link] = função()
{
retornar $gameMap.ultraMode7Roll;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7Roll(valor);
};

[Link] = função()
{
retornar $gameMap.ultraMode7CameraDistance;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7CameraDistance(valor);
};

[Link] = função()
{
retornar $gameMap.ultraMode7CameraY;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7CameraY(valor);
};

[Link] = função()
{
retornar $gameMap.ultraMode7NearClipZ;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7NearClipZ(valor);
};

[Link] = função()
{
retornar $gameMap.ultraMode7FarClipZ;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7FarClipZ(valor);
};

[Link] = função()
{
retornar $gameMap.ultraMode7ParallaxDistance;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7ParallaxDistance(valor);
};

[Link] = função()
{
retornar UltraMode7.TILEMAP_PIXELATED;
};

[Link] = função(valor)
{
UltraMode7.TILEMAP_PIXELATED = valor;
se (UltraMode7.IS_RMMV)
{
se (valor)
{
[Link].SCALE_MODE = PIXI.SCALE_MODES.NEAREST;
}
outro
{
[Link].SCALE_MODE = PIXI.SCALE_MODES.LINEAR;
}
}
};

[Link] = função()
{
retornar $gameMap.ultraMode7FadeColor;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7FadeColor(valor);
};

[Link] = função()
{
retornar $gameMap.ultraMode7FadeBegin;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7FadeBegin(valor);
};

[Link] = função()
{
retornar $gameMap.ultraMode7FadeEnd;
};

[Link] = função(valor)
{
$gameMap.setUltraMode7FadeEnd(valor);
};

[Link] = função(alvo, frameDuration)

{
$gameMap.animateUltraMode7Fov(alvo, duração do quadro);
};

[Link] = função(alvo, frameDuration)

{
$gameMap.animateUltraMode7Pitch(alvo, duração do quadro);
};
[Link] = função(alvo, frameDuration)
{
$gameMap.animateUltraMode7Yaw(alvo, duração do quadro);
};

[Link] = função(alvo, frameDuration)

{
$gameMap.animateUltraMode7Roll(alvo, duração do quadro);
};

[Link] = função(alvo, frameDuration)

{
$gameMap.animateUltraMode7CameraDistance(alvo, duração do quadro);
};

[Link] = função(alvo, duração do quadro)

{
$gameMap.animateUltraMode7CameraY(alvo, duração do quadro);
};

[Link] = função(alvo, frameDuration)

{
$gameMap.animateUltraMode7NearClipZ(alvo, duração do quadro);
};

[Link] = função(alvo, frameDuration)

{
$gameMap.animateUltraMode7FarClipZ(alvo, frameDuration);
};

[Link] = função(alvo, frameDuration)

{
$gameMap.animateUltraMode7FadeColor(alvo, frameDuration);
};

[Link] = função(alvo, frameDuration)

{
$gameMap.animateUltraMode7FadeBegin(alvo, duração do quadro);
};

[Link] = função(alvo, frameDuration)

{
$gameMap.animateUltraMode7FadeEnd(alvo, frameDuration);
};

// funções

[Link] = função()
{
return (!!$dataMap && !!$gameMap && $gameMap.useUltraMode7);
};

[Link] = função(x, y)
{
// transforma 2 raios pontuais de projeção em mundo
const projectionMatrix = $gameMap.ultraMode7ProjectionMatrix;
const halfWidth = Grá[Link] / 2;
const halfHeight = Grá[Link] / 2;
var origem = novo Vetor3(x - metadeLargura, y - metadeAltura, -1);
var target = novo Vector3(x - meiaLargura, y - meiaAltura, 1);
se ($gameMap.ultraMode7Fov > 0)
{
const scaleZ = projeçã[Link][10];
const offsetZ = projeçã[Link][14];
origem.x = origem.x * (deslocamentoZ - origem.z) / escalaZ /
meiaLargura;
origem.y = origem.y * (deslocamentoZ - origem.z) / escalaZ /
meiaAltura;
alvo.x = alvo.x * (deslocamentoZ - alvo.z) / escalaZ / meia largura;
alvo.y = alvo.y * (deslocamentoZ - alvo.z) / escalaZ / meiaAltura;
const inversedProjectionMatrix = [Link]();
origem = [Link](origem);
alvo = [Link](alvo);
}
const mapWidth = $[Link]() * $[Link]();
const mapHeight = $[Link]() * $[Link]();
// primeiro transforme 4 pontos do modelo para o espaço mundial
const modelviewMatrix = $gameMap.ultraMode7ModelviewMatrix;
const topLeft = [Link](novo Vector3(0, 0, 0));
const topRight = [Link](novo Vector3(mapWidth, 0, 0));
const bottomLeft = [Link](novo Vector3(0, mapHeight, 0));
const bottomRight = [Link](novo Vector3(mapWidth,
mapHeight, 0));
// resolver equação Ax + By + Cz + D = 0
equações const = [
[superiorEsquerda.x, superiorEsquerda.y, superiorEsquerda.z, 0],
[superiorDireita.x, superiorDireita.y, superiorDireita.z, 0],
[inferiorEsquerda.x, inferiorEsquerda.y, inferiorEsquerda.z, 0],
[inferiorDireita.x, inferiorDireita.y, inferiorDireita.z, 0]
];
const fatores =
UltraMode7._solveLinearEquationWithGaussianElimination(equações);
// cria equação plana
const ray = [Link](origem);
const normal = novo Vector3(fatores[0], fatores[1], fatores[2]);
[Link]((fatores[3] - [Link](origem)) / [Link](raio));
const intersecção = [Link](raio);
retornar [Link]().multiplied(intersecção);
};

UltraMode7._solveLinearEquationWithGaussianElimination = função(M)
{
const mLength = [Link];
para (var i = 0; i < mLength; ++i)
{
M[i].push(1);
}
para (var i = 0; i < mLength; ++i)
{
// Pesquisar o máximo nesta coluna
var maxElement = [Link](M[i][i]);
var maxRow = i;
para (var k = i + 1; k < mLength; ++k)
{
const newMax = [Link](M[k][i]);
se (maxElement < newMax)
{
maxElement = novoMax;
maxRow = k;
}
}
// Troca a linha máxima com a linha atual (coluna por coluna)
para (var k = i; k < mLength + 1; ++k)
{
const swap = M[maxRow][k];
M[maxRow][k] = M[i][k];
M[i][k] = troca;
}
se (M[i][i] !== 0)
{
// Torna todas as linhas abaixo desta 0 na coluna atual
para (var k = i + 1; k < mLength; ++k)
{
valor const = -M[k][i] / M[i][i];
para (var j = i; j < mLength + 1; ++j)
{
se (i === j)
{
M[k][j] = 0;
}
outro
{
M[k][j] += valor * M[i][j];
}
}
}
}
}
// Resolva a equação Mx=b para a matriz triangular superior M
resultado = [];
para (var i = mLength - 1; i >= 0; --i)
{
se (M[i][i] === 0)
{
resultado[i] = 1;
}
outro
{
resultado[i] = M[i][mComprimento] / M[i][i];
}
para (var k = i - 1; k >= 0; --k)
{
M[k][mComprimento] -= M[k][i] * resultado[i];
}
}
retornar resultado;
};

[Link] = função(x, y, z)
{
const posição = novo Vector3(x + $[Link]() * $[Link](),
y + $[Link]() * $[Link](), (z || 0));
const worldPosition = $[Link](posição);
const projeção = $gameMap.ultraMode7ProjectionMatrix;
const resultado = projeçã[Link](worldPosition);
// W é necessário para projeção em perspectiva
const vectorW = projeçã[Link][3] * worldPosition.x + projeçã[Link][7] *
worldPosition.y + projeçã[Link][11] * worldPosition.z + projeçã[Link][15];
// calcula a projeção em perspectiva e o deslocamento para as coordenadas da
tela
const halfWidth = Grá[Link] / 2;
const halfHeight = Grá[Link] / 2;
resultado.x = resultado.x * halfWidth / vectorW + halfWidth -
$[Link]();
resultado.y = resultado.y * meiaAltura / vetorW + meiaAltura;
se (!UltraMode7.LEGACY_SCALING)
{
fator const = -[Link][10];
resultado.z = resultado.z / fator + (fator - 1) / fator *
$gameMap.ultraMode7FarClipZ;
}
retornar resultado;
};

[Link] = função(x, y, z)
{
se ($gameMap.ultraMode7Fov <= 0)
{
retornar 1.0;
}
retornar [Link]([Link](x, y, z).z);
};

[Link] = função(z)
{
// fixação em 10000 para segurança infinita
retornar (z !== 0,0 ? UltraMode7.BASE_SCALE_Z / [Link](z).clamp(0,0,
10000,0) : 10000,0);
};

[Link] = função(z)
{
retornar (z > $gameMap.ultraMode7NearClipZ && z <
$gameMap.ultraMode7FarClipZ);
};

[Link] = função(fonte, maxTextures)

{
retornar [Link](/%count%/gi, "" + maxTextures)
.replace(/%textureloop%/gi,
this._generateFragmentShaderTextures(maxTextures));
}

UltraMode7._generateFragmentShaderTextures = função(maxTextures)
{
var resultado = "if (textureId < 0)\n\
{\n\
cor = shadowColor;\n\
}\n";
const texturas = [];
for (var i = 0; i < maxTextures; ++i)
{
[Link]("\
senão se (textureId == " + i + ")\n\
{\n\
cor = textura2D(uSamplers[" + i + "], textureCoord *
uSamplerSize[" + i + "]);\n\
}");
}
resultado += [Link]("\n");
retornar resultado;
}

//============================================== =============================
// Mapa de blocos
//============================================== =============================

Tilemap.ULTRA_MODE_7_VERTEX_SHADER = "\
atributo float aTextureId;\n\
atributo vec4 aFrame;\n\
atributo vec2 aTextureCoord;\n\
atributo vec2 aVertexPosition;\n\
atributo vec2 aAnimation;\n\
\n\
uniforme mat4 uMode7ProjectionMatrix;\n\
uniforme mat4 uMode7ModelviewMatrix;\n\
flutuação uniforme uFadeBegin;\n\
flutuação uniforme uFadeRange;\n\
animação vec2 uniformeFrame;\n\
\n\
variando vec4 vFrame;\n\
variando vec2 vTextureCoord;\n\
variável float vTextureId;\n\
variável float vFade;\n\
\n\
vazio principal(vazio)\n\
{\n\
posição vec4 = uMode7ModelviewMatrix * vec4(aVertexPosition, 0.0,
1.0);\n\
posição = uMode7ProjectionMatrix * vec4(posição.x, posição.y,
posição.z, posição.w);\n\
gl_Position = posição;\n\
vec2 deslocamento = aAnimação * QuadroDeAnimação;\n\
vTextureCoord = aTextureCoord + deslocamento;\n\
vFrame = aFrame + vec4(deslocamento, deslocamento);\n\
vTextureId = aTextureId;\n\
vFade = clamp((posição.z - uFadeBegin) / uFadeRange, 0.0, 1.0);\n\
}\n";

Tilemap.ULTRA_MODE_7_FRAGMENT_SHADER = "\
variando vec4 vFrame;\n\
variando vec2 vTextureCoord;\n\
variável float vTextureId;\n\
variável float vFade;\n\
\n\
uniforme vec4 shadowColor;\n\
uniforme vec3 uFadeColor;\n\
amostrador uniforme2D uSamplers[%count%];\n\
uniforme vec2 uSamplerSize[%count%];\n\
\n\
vazio principal(vazio)\n\
{\n\
vec2 textureCoord = clamp(vTextureCoord, [Link], [Link]);\n\
int textureId = int(piso(vTextureId + 0,5));\n\
cor vec4;\n\
%textureloop%\n\
se (cor.a < 0,01)\n\
{\n\
descartar;\n\
}\n\
vec3 multiplicadoFadeColor = vec3(cor.a, cor.a, cor.a) * uFadeColor;\n\
gl_FragColor = vec4(mix([Link], multiplicadoFadeColor, vFade),
cor.a);\n\
}\n";

[Link]._makeMarginX = função()
{
se ($[Link]())
{
var extendTiles = UltraMode7.LOOP_MAPS_EXTEND_TILES;
se (UltraMode7.LOOP_MAPS_EXTEND_TILES_SMART)
{
estenderTiles *= 2;
}
retornar ($gameMap.ultraMode7LoopMapsExtendX + extendTiles) *
[Link] - Grá[Link] / 2;
}
retornar 0;
};

[Link]._makeMarginY = função()
{
se ($[Link]())
{
var extendTiles = UltraMode7.LOOP_MAPS_EXTEND_TILES;
se (UltraMode7.LOOP_MAPS_EXTEND_TILES_SMART)
{
estenderTiles *= 2;
}
retornar ($gameMap.ultraMode7LoopMapsExtendY + extendTiles) *
[Link] - [Link] / 2;
}
retornar 0;
};

//============================================== =============================
// Código padrão (RMMZ)
//============================================== =============================
se (UltraMode7.IS_RMMZ)
{
//==============================================
=============================
// Mapa de blocos
//==============================================
=============================

const UltraMode7_Tilemap_prototype__createLayers = Mapa de

[Link]._createLayers;
[Link]._createLayers = função()
{
UltraMode7_Tilemap_prototype__createLayers.call(isto);
se ([Link]())
{
esta._camadasuperior.z = 0;
// forçar largura/altura é necessário, porque alguns scripts
manipulam os valores de largura e altura do tilemap
this._width = $[Link]() * $[Link]();
this._height = $[Link]() * $[Link]();
se ($[Link]())
{
this._width += Grá[Link];
}
se ($[Link]())
{
this._height += Grá[Link];
}
}
};

//==============================================
=============================
// Mapa de [Link]
//==============================================
=============================

[Link].ULTRA_MODE_7_VERTEX_STRIDE = [Link].VERTEX_STRIDE + 2 *
UltraMode7.FLOAT_SIZE;

const UltraMode7_Tilemap_Layer_prototype_initialize =
[Link];
[Link] = função()
{
este._quadro_de_animação = 0;
isto._allIndexBuffers = [];
isto._allIndexArrays = [];
isto._allVertexBuffers = [];
isto._allVertexArrays = [];
isto._allVaos = [];
isto._allElements = [];
UltraMode7_Tilemap_Layer_prototype_initialize.call(isto);
};

const UltraMode7_Tilemap_Layer_prototype_destroy =
[Link];
[Link] = função()
{
para (var i = 0; i < this._allVaos.length; ++i)
{
isto._allVaos[i].destroy();
isto._allIndexBuffers[i].destroy();
isto._allVertexBuffers[i].destroy();
}
isto._vao = nulo;
UltraMode7_Tilemap_Layer_prototype_destroy.call(isto);
isto._allVaos.length = 0;
isto._allIndexBuffers.comprimento = 0;
isto._allIndexArrays.comprimento = 0;
isto._allVertexBuffers.comprimento = 0;
isto._allVertexArrays.comprimento = 0;
};

[Link] = função(valor)
{
this._animationFrame = valor;
};

const UltraMode7_Tilemap_Layer_prototype__createVao =
[Link]._createVao;
[Link]._createVao = função()
{
se (![Link]())
{
UltraMode7_Tilemap_Layer_prototype__createVao.call(isto);
retornar;
}
const tipo = [Link];
const stride = [Link].ULTRA_MODE_7_VERTEX_STRIDE;
tamanho const = UltraMode7.FLOAT_SIZE;
const indexBuffer = new [Link](nulo, verdadeiro, verdadeiro);
const vertexBuffer = novo [Link](nulo, verdadeiro, falso);
const geometria = novo [Link]();
const vao = geometria
.addIndex(Buffer de índice)
.addAttribute("aTextureId", vertexBuffer, 1, falso, tipo, passo,
0)
.addAttribute("aFrame", vertexBuffer, 4, falso, tipo, passo, 1 *
tamanho)
.addAttribute("aTextureCoord", vertexBuffer, 2, falso, tipo,
passo, 5 * tamanho)
.addAttribute("aVertexPosition", vertexBuffer, 2, falso, tipo,
passo, 7 * tamanho)
.addAttribute("aAnimation", vertexBuffer, 2, false, tipo, passo,
9 * tamanho);
isto._allIndexBuffers.push(indexBuffer);
isto._allIndexArrays.push(novo Float32Array(0));
isto._allVertexBuffers.push(vertexBuffer);
isto._allVertexArrays.push(novo Float32Array(0));
isto._allVaos.push(vao);
};

const UltraMode7_Tilemap_Layer_prototype__updateVertexBuffer =
[Link]._updateVertexBuffer;
[Link]._updateVertexBuffer = função()
{
se (![Link]())
{

UltraMode7_Tilemap_Layer_prototype__updateVertexBuffer.call(isto);
retornar;
}
const numElementos = this._elementos.length;
const obrigatório = numElements *
[Link].ULTRA_MODE_7_VERTEX_STRIDE;
se (this._vertexArray.length < obrigatório)
{
this._vertexArray = novo Float32Array(obrigatório * 2);
}
var índice = 0;
const dados = this._vertexArray;
const eps = 0,5;
for (var i = 0; i < numElements; ++i)
{
const item = this._elementos[i];
const setNumber = item[0];
const tid = setNumber >> 2;
const sxOffset = 1024 * (setNumber & 1);
const syOffset = 1024 * ((setNumber >> 1) & 1);
const sx = item[1] + sxOffset;
const sy = item[2] + syOffset;
const dx = item[3];
const dy = item[4];
const w = item[5];
const h = item[6];
const ax = item[7];
const ay = item[8];
const frameLeft = sx + eps;
const frameTop = sy + eps;
const frameRight = sx + w - eps;
const frameBottom = sy + h - eps;
dados[índice++] = tid;
dados[índice++] = frameLeft;
dados[índice++] = frameTop;
dados[índice++] = frameRight;
dados[índice++] = frameBottom;
dados[índice++] = sx;
dados[índice++] = sy;
dados[índice++] = dx;
dados[índice++] = dy;
dados[índice++] = ax;
dados[índice++] = ay;
dados[índice++] = tid;
dados[índice++] = frameLeft;
dados[índice++] = frameTop;
dados[índice++] = frameRight;
dados[índice++] = frameBottom;
dados[índice++] = sx + w;
dados[índice++] = sy;
dados[índice++] = dx + w;
dados[índice++] = dy;
dados[índice++] = ax;
dados[índice++] = ay;
dados[índice++] = tid;
dados[índice++] = frameLeft;
dados[índice++] = frameTop;
dados[índice++] = frameRight;
dados[índice++] = frameBottom;
dados[índice++] = sx + w;
dados[índice++] = sy + h;
dados[índice++] = dx + w;
dados[índice++] = dy + h;
dados[índice++] = ax;
dados[índice++] = ay;
dados[índice++] = tid;
dados[índice++] = frameLeft;
dados[índice++] = frameTop;
dados[índice++] = frameRight;
dados[índice++] = frameBottom;
dados[índice++] = sx;
dados[índice++] = sy + h;
dados[índice++] = dx;
dados[índice++] = dy + h;
dados[índice++] = ax;
dados[índice++] = ay;
}
this._vertexBuffer.update(dados);
};

//==============================================
=============================
// [Link]
//==============================================
=============================

// compatibilidade para RMMZ Core v1.7.0 e posterior

se (!![Link])
{
[Link] = função(valor)
{
para (filho const de [Link])
{
se (!!crianç[Link])
{
crianç[Link](valor);
}
}
};

const UltraMode7_Tilemap_CombinedLayer_prototype_addRect =
[Link];
[Link] = função(setNumber, sx, sy, dx,
dy, w, h, ax, ay)
{
se (![Link]())
{

UltraMode7_Tilemap_CombinedLayer_prototype_addRect.call(isto, setNumber, sx,

sy, dx, dy, w, h);
retornar;
}
para (filho const de [Link])
{
se (crianç[Link]() < [Link].MAX_SIZE)
{
crianç[Link](setNumber, sx, sy, dx, dy, w, h, ax,
ay);
quebrar;
}
}
};

//==============================================
=============================
// [Link]
//==============================================
=============================

[Link] = função()
{
[Link](...argumentos);
};

[Link] =
[Link]([Link]);
[Link] =
[Link];

[Link]._createShader = função()
{
const fragmentSource =
[Link](Tilemap.ULTRA_MODE_7_FRAGMENT_SHADER,
[Link].MAX_GL_TEXTURES);
const textureSize = 1 / UltraMode7.RMMZ_TEXTURE_SIZE;
const uniformes = {
uMode7ProjectionMatrix: novo [Link](),
uMode7ModelviewMatrix: novo [Link](),
uFadeBegin: 0,0,
uFadeRange: 0,0,
animationFrame: novo Float32Array([0.0, 0.0]),
shadowColor: novo Float32Array([0.0, 0.0, 0.0, 0.5]),
uFadeColor: novo Float32Array([1.0, 1.0, 1.0])
};
uniformes["uSamplers"] = [];
uniformes["uSamplerSize"] = [];
para (var i = 0; i < [Link].MAX_GL_TEXTURES; ++i)
{
uniformes["uSamplers"].push(i);
uniformes["uSamplerSize"].push(texturaSize);
uniformes["uSamplerSize"].push(texturaSize);
}
retornar novo
[Link]([Link](Tilemap.ULTRA_MODE_7_VERTEX_SHADER, fragmentSource),
uniformes);
};

[Link]._createInternalTextures = função()
{
[Link]._createInternalTextures.call(isto);
this._updateTextureScaleMode(falso);
};

[Link] = função(renderizador)
{
this._updateTextureScaleMode(verdadeiro);
[Link](este, renderizador);
};

[Link]._updateTextureScaleMode =
função(requerAtualização)
{
const scaleMode = (UltraMode7.TILEMAP_PIXELATED ?
PIXI.SCALE_MODES.NEAREST : PIXI.SCALE_MODES.LINEAR);
para (var i = 0; i < this._internalTextures.length; ++i)
{
se (this._internalTextures[i].scaleMode !== scaleMode)
{
isto._internalTextures[i].setStyle(scaleMode);
se (requer atualização)
{
isto._internalTextures[i].update();
}
}
}
};

[Link]("um7tilemap", [Link]);

}
//============================================== =============================
// Código especial para RMMV
//============================================== =============================
senão se (UltraMode7.IS_RMMV)
{
//==============================================
=============================
// Sombreador
//==============================================
=============================
[Link] = (função(_super)
{
__extends(Shader, _super);

função Shader(gl, maxTextures)

{
const fragmentSource =
[Link](Tilemap.ULTRA_MODE_7_FRAGMENT_SHADER,
maxTextures);
const _this = _super.call(this, gl, maxTextures,
Tilemap.ULTRA_MODE_7_VERTEX_SHADER, fragmentSource) || isto;
_this.vertTamanho = 11;
_this.vertPerQuad = 4;
_this.stride = _this.vertSize * UltraMode7.FLOAT_SIZE;
[Link](_this, maxTexturas);
retornar _isto;
};

[Link] = função(renderizador, vb)

{
const gl = [Link];
tamanho const = UltraMode7.FLOAT_SIZE;
[Link].uMode7ProjectionMatrix =
$[Link];
[Link].uMode7ModelviewMatrix =
$[Link];
[Link] = UltraMode7.FADE_Z_BEGIN;
[Link] = UltraMode7.FADE_Z_END -
UltraMode7.FADE_Z_BEGIN;
[Link] = [1.0, 1.0, 1.0];
retornar [Link]()
.addIndex([Link])
.addAttribute(vb, [Link], [Link],
falso, [Link], 0)
.addAttribute(vb, [Link], [Link], false,
[Link], 1 * tamanho)
.addAttribute(vb, [Link], [Link],
false, [Link], 5 * tamanho)
.addAttribute(vb, [Link],
[Link], false, [Link], 7 * tamanho)
.addAttribute(vb, [Link], [Link],
false, [Link], 9 * tamanho)
};

retornar Shader;

}([Link]));

//==============================================
=============================
// [Link]
//==============================================
=============================

se (UltraMode7.TILEMAP_PIXELATED)
{
[Link].SCALE_MODE = PIXI.SCALE_MODES.NEAREST;
}
outro
{
[Link].SCALE_MODE = PIXI.SCALE_MODES.LINEAR;
}

const UltraMode7_PIXI_tilemap_TileRenderer_prototype_onContextChange =
[Link];
[Link] = função()
{

UltraMode7_PIXI_tilemap_TileRenderer_prototype_onContextChange.call(isto);
var maxTextures = [Link];
se (UltraMode7.NEWER_PIXI_TILEMAP)
{
maxTextures = [Link];
}
este._ultraMode7Shader = novo [Link]([Link],
maxTextures);
este._ultraMode7Shader.indexBuffer = [Link];
};

[Link]._glTextures[renderer.CONTEXT_UID].enableNearestScaling();
}
outro
{

[Link]._glTextures[renderizador.CONTEXT_UID].enableLinearScaling();
}
}
}
}
}

const UltraMode7_PIXI_tilemap_TileRenderer_prototype_destroy =
[Link];
[Link] = função()
{
UltraMode7_PIXI_tilemap_TileRenderer_prototype_destroy.call(isto);
este._ultraMode7Shader.destroy();
this._ultraMode7Shader = nulo;
};

const UltraMode7_PIXI_tilemap_TileRenderer_prototype_getShader =
[Link];
[Link] = função(useSquare)
{
se (![Link]())
{
retornar
UltraMode7_PIXI_tilemap_TileRenderer_prototype_getShader.call(this, useSquare);
}
retornar isto._ultraMode7Shader;
};

se (!UltraMode7.NEWER_PIXI_TILEMAP)
{
// isso corrige um bug no PIXI em relação a uma variável com nome
incorreto
const UltraMode7_PIXI_tilemap_TileRenderer_prototype_getVb =
[Link];
[Link] = função(id)
{
const vb =
UltraMode7_PIXI_tilemap_TileRenderer_prototype_getVb.call(isto, id);
se (vb && [Link])
{
[Link] = [Link];
excluir [Link];
}
retornar vb;
};
}

//==============================================
=============================
// [Link]
//==============================================
=============================

se (!UltraMode7.NEWER_PIXI_TILEMAP)
{
const UltraMode7_PIXI_tilemap_RectTileLayer_prototype_renderWebGL =
[Link];
[Link] = função(renderizador,
useSquare)
{
se (![Link]())
{

UltraMode7_PIXI_tilemap_RectTileLayer_prototype_renderWebGL.call(this,
renderizador, useSquare);
retornar;
}
this.ultraMode7Render(renderizador,
[Link]);
};
}
outro
{
const UltraMode7_PIXI_tilemap_RectTileLayer_prototype_renderWebGLCore =
[Link];
[Link] =
função(renderizador, plugin)
{
se (![Link]())
{

UltraMode7_PIXI_tilemap_RectTileLayer_prototype_renderWebGLCore.call(this,
renderizador, plugin);
retornar;
}
this.ultraMode7Render(renderizador, (plugin ||
[Link]));
};

[Link].getUltraMode7Vb =
função(renderizador, vbId)
{
se ([Link])
{
const _vb = [Link][vbId];
se (_vb)
{
se (_vb.rendererSN === [Link])
{
retornar _vb;
}
const otherVb = [Link];
[Link] = _vb;

UltraMode7_PIXI_tilemap_RectTileLayer_prototype_destroyVb.call(isto);
[Link] = outroVb;
}
}
retornar nulo;
};

const UltraMode7_PIXI_tilemap_RectTileLayer_prototype_destroyVb =
[Link];
[Link] = função()
{

UltraMode7_PIXI_tilemap_RectTileLayer_prototype_destroyVb.call(isto);
se ([Link])
{
para (var id em [Link])
{
[Link] = [Link][id];

UltraMode7_PIXI_tilemap_RectTileLayer_prototype_destroyVb.call(isto);
}
[Link] = nulo;
}
};

[Link].ultraMode7Render = função(renderizador,
bloco)
{
const pontos = [Link];
se ([Link] === 0)
{
retornar;
}
const shader = [Link]();
const texturas = [Link];
se ([Link] === 0)
{
retornar;
}
const quadsCount = [Link] / 9;
se (quadsCount === 0)
{
retornar;
}
const gl = [Link];
const comprimento = [Link];
para (var i = 0; i < comprimento; ++i)
{
se (!texturas[i] || !texturas[i].válido)
{
retornar;
}
const textura = texturas[i].baseTexture;
}
se (![Link])
{
[Link] = [];
[Link] = [];
[Link] = [];
[Link] = [];
}
[Link](quadsCount);
[Link](renderizador, shader, texturas);
[Link].uMode7ProjectionMatrix =
$[Link];
[Link].uMode7ModelviewMatrix =
$[Link];
[Link] = $gameMap.ultraMode7FadeBegin;
[Link] = $gameMap.ultraMode7FadeEnd -
$gameMap.ultraMode7FadeBegin;
[Link] = $gameMap.ultraMode7FadeColor;
const maxQuads = UltraMode7.WEBGL_MAX_VERTICES / [Link];
const maxLoops = [Link]((quadsCount + maxQuads - 1) / maxQuads);
for (var j = 0; j <maxLoops; ++j)
{
se (![Link][j])
{
[Link][j] = 0;
[Link][j] = nulo;
[Link]çãoMarcadores[j] = 0;
[Link][j] = nulo;
}
const currentRectsCount = [Link](maxQuads, quadsCount - j *
maxQuads);
var vb = nulo;
se (!UltraMode7.NEWER_PIXI_TILEMAP)
{
vb = [Link]([Link][j]);
}
outro
{
se (![Link])
{
[Link] = {};
}
vb = this.getUltraMode7Vb(tile, [Link][j]);
}
se (!vb)
{
se (!UltraMode7.NEWER_PIXI_TILEMAP)
{
vb = [Link](falso);
}
outro
{
vb = [Link]();
[Link][[Link]] = vb;
}
[Link][j] = [Link];
[Link][j] = nulo;
[Link]çãoMarcadores[j] = 0;
[Link][j] = nulo;
}
const vao = [Link];
[Link](vao);
const vertexBuf = [Link];
vé[Link]();
const currentVertices = currentRectsCount * [Link];
se ([Link][j] !== currentVertices)
{
[Link][j] = vértices atuais;
const vs = [Link] * currentVertices;
se (![Link][j] || [Link][j].byteLength <
vs)
{
var bk = [Link];
enquanto (bk < vs)
{
bk *= 2;
}
[Link][j] = novo ArrayBuffer(bk);
[Link][j] = novo
Float32Array([Link][j]);
[Link]([Link][j], 0, verdadeiro);
}
const dados = [Link][j];
var índice = 0;
const eps = 0,5;
para (i = j * maxQuads * 9; i < [Link] && i < (j +
1) * maxQuads * 9; i += 9)
{
const x = pontos[i + 2];
const y = pontos[i + 3];
const w = pontos[i + 4];
const h = pontos[i + 5];
const u = pontos[i] + 1024 * (pontos[i + 8] & 1);
const v = pontos[i + 1] + 1024 * ((pontos[i + 8] >>
1) & 1);
const animX = pontos[i + 6];
const animY = pontos[i + 7];
const textureId = (pontos[i + 8] >> 2);
dados[índice++] = textureId;
dados[índice++] = u + eps;
dados[índice++] = v + eps;
dados[índice++] = u + w - eps;
dados[índice++] = v + h - eps;
dados[índice++] = u;
dados[índice++] = v;
dados[índice++] = x;
dados[índice++] = y;
dados[índice++] = animX;
dados[índice++] = animY;
dados[índice++] = textureId;
dados[índice++] = u + eps;
dados[índice++] = v + eps;
dados[índice++] = u + w - eps;
dados[índice++] = v + h - eps;
dados[índice++] = u + w;
dados[índice++] = v;
dados[índice++] = x + w;
dados[índice++] = y;
dados[índice++] = animX;
dados[índice++] = animY;
dados[índice++] = textureId;
dados[índice++] = u + eps;
dados[índice++] = v + eps;
dados[índice++] = u + w - eps;
dados[índice++] = v + h - eps;
dados[índice++] = u + w;
dados[índice++] = v + h;
dados[índice++] = x + w;
dados[índice++] = y + h;
dados[índice++] = animX;
dados[índice++] = animY;
dados[índice++] = textureId;
dados[índice++] = u + eps;
dados[índice++] = v + eps;
dados[índice++] = u + w - eps;
dados[índice++] = v + h - eps;
dados[índice++] = u;
dados[índice++] = v + h;
dados[índice++] = x;
dados[índice++] = y + h;
dados[índice++] = animX;
dados[índice++] = animY;
}
[Link](dados, 0, verdadeiro);
}
[Link]([Link], currentRectsCount * 6,
gl.UNSIGNED_SHORT, 0);
}
};

//==============================================
=============================
// Mapa de ShaderTile
//==============================================
=============================

//============================================== =============================
// Mapa_do_jogo
//============================================== =============================

[Link](Mapa_do_jogo.protótipo,
{
useUltraMode7: { obter: função() { retornar this._useUltraMode7; },
configurable: true },
ultraMode7Fov: { obter: função() { retornar this._ultraMode7Fov; },
configurable: true },
ultraMode7Pitch: { obter: função() { retornar this._ultraMode7Pitch; },
configurable: true },
ultraMode7Yaw: { obter: função() { retornar this._ultraMode7Yaw; },
configurable: true },
ultraMode7Roll: { obter: função() { retornar this._ultraMode7Roll; },
configurable: true },
ultraMode7CameraDistance: { obter: função() { retornar
this._ultraMode7CameraDistance; }, configurable: true },
ultraMode7CameraY: { obter: função() { retornar this._ultraMode7CameraY; },
configurable: true },
ultraMode7NearClipZ: { obter: função() { retornar
this._ultraMode7NearClipZ; }, configurable: true },
ultraMode7FarClipZ: { obter: função() { retornar this._ultraMode7FarClipZ; },
configurable: true },
ultraMode7FadeColor: { obter: função() { retornar
this._ultraMode7FadeColor; }, configurable: true },
ultraMode7FadeBegin: { obter: função() { retornar
this._ultraMode7FadeBegin; }, configurable: true },
ultraMode7FadeEnd: { obter: função() { retornar this._ultraMode7FadeEnd; },
configurable: true },
ultraMode7ParallaxDistance: { obter: função() { retornar
this._ultraMode7ParallaxDistance; }, configurable: true },
ultraMode7LoopMapsExtendX: { obter: função() { retornar
this._ultraMode7LoopMapsExtendX; }, configurable: true },
ultraMode7LoopMapsExtendY: { obter: função() { retornar
this._ultraMode7LoopMapsExtendY; }, configurável: verdadeiro },
ultraMode7ProjectionMatrix: { obter: função() { retornar
this._ultraMode7ProjectionMatrix; }, configurable: true },
ultraMode7ModelviewMatrix: { obter: função() { retornar
this._ultraMode7ModelviewMatrix; }, configurable: true }
});

const UltraMode7_Game_Map_prototype_initialize = Mapa_do_jogo.[Link];

Game_Map.[Link] = função()
{
UltraMode7_Game_Map_prototype_initialize.call(isto);
este.initUltraMode7();
};

const UltraMode7_Game_Map_prototype_setup = Mapa_do_jogo.[Link];

Game_Map.[Link] = função(mapId)
{
UltraMode7_Game_Map_prototype_setup.call(isto, mapId);
isto.setupUltraMode7();
};

Game_Map.prototype.initUltraMode7 = função()
{
this._useUltraMode7 = falso;
este._ultraMode7Pitch = 0;
este._ultraMode7Yaw = 0;
este._ultraMode7Roll = 0;
this._ultraMode7CameraDistance = UltraMode7.DEFAULT_CAMERA_DISTANCE;
this._ultraMode7CameraY = UltraMode7.DEFAULT_CAMERA_Y;
este._ultraMode7NearClipZ = UltraMode7.DEFAULT_NEAR_CLIP_Z;
este._ultraMode7FarClipZ = UltraMode7.DEFAULT_FAR_CLIP_Z;
this._ultraMode7ParallaxDistance = UltraMode7.DEFAULT_PARALLAX_DISTANCE;
this._ultraMode7FadeColor = UltraMode7.FADE_Z_COLOR.slice();
este._ultraMode7FadeBegin = UltraMode7.FADE_Z_BEGIN;
este._ultraMode7FadeEnd = UltraMode7.FADE_Z_END;
isto._ultraMode7LoopMapsExtendX = 0;
isto._ultraMode7LoopMapsExtendY = 0;
este._ultraMode7LastLoopMapsExtendX = 0;
este._ultraMode7LastLoopMapsExtendY = 0;
este._ultraMode7BorderLeft = 0;
este._ultraMode7BorderRight = 0;
este._ultraMode7BorderTop = 0;
este._ultraMode7BorderBottom = 0;
this._ultraMode7ProjectionMatrix = nova Matriz4();
this._ultraMode7ModelviewMatrix = nova Matriz4();
const olho = novo Vetor3(0, 0, this._ultraMode7CameraDistance);
const alvo = novo Vetor3(0, 0, 0);
const up = novo Vetor3(0, 1, 0);
this._ultraMode7ModelviewMatrix.lookAt(olho, alvo, cima);
};

Game_Map.prototype.setupUltraMode7 = função()
{
este.initUltraMode7();
se (!$dataMap)
{
lançar novo erro("Os dados do mapa não estão disponíveis");
}
se ($[Link] && ($[Link].UltraMode7 ||
$[Link].UltraMode7_FOV || $[Link].UltraMode7_Pitch ||
$[Link].UltraMode7_Yaw || $[Link].UltraMode7_Roll ||
$[Link].UltraMode7_CameraDistance ||
$[Link].UltraMode7_CameraY || $[Link].UltraMode7_NearClipZ
|| $[Link].UltraMode7_FarClipZ ||
$[Link].UltraMode7_FadeColor ||
$[Link].UltraMode7_ParallaxDistance))
{
this._useUltraMode7 = verdadeiro;
this._ultraMode7Fov =
[Link]([Link]($[Link].UltraMode7_FOV,
UltraMode7.DEFAULT_FOV), UltraMode7.MIN_FOV);
this._ultraMode7Pitch =
[Link]($[Link].UltraMode7_Pitch,
UltraMode7.DEFAULT_PITCH).clamp(UltraMode7.MIN_PITCH, UltraMode7.MAX_PITCH);
este._ultraMode7Yaw =
[Link]($[Link].UltraMode7_Yaw, UltraMode7.DEFAULT_YAW);
este._ultraMode7Roll =
[Link]($[Link].UltraMode7_Roll, UltraMode7.DEFAULT_ROLL);
this._ultraMode7CameraDistance =
[Link]([Link]($[Link].UltraMode7_CameraDistance,
UltraMode7.DEFAULT_CAMERA_DISTANCE), 0);
this._ultraMode7CameraY =
[Link]($[Link].UltraMode7_CameraY,
UltraMode7.DEFAULT_CAMERA_Y);
este._ultraMode7NearClipZ =
[Link]([Link]($[Link].UltraMode7_NearClipZ,
UltraMode7.DEFAULT_NEAR_CLIP_Z), 1);
este._ultraMode7FarClipZ =
[Link]([Link]($[Link].UltraMode7_FarClipZ,
UltraMode7.DEFAULT_FAR_CLIP_Z), este._ultraMode7NearClipZ + 1);
se ($[Link].UltraMode7_FadeColor)
{
this._ultraMode7FadeColor =
[Link]([Link]("[" + $[Link].UltraMode7_FadeColor +
"]"));
}
outro
{
this._ultraMode7FadeColor = UltraMode7.FADE_Z_COLOR.slice();
}
este._ultraMode7FadeBegin =
[Link]([Link]($[Link].UltraMode7_FadeBegin,
UltraMode7.FADE_Z_BEGIN), este._ultraMode7NearClipZ);
este._ultraMode7FadeEnd =
[Link]([Link]([Link]($[Link].UltraMode7_FadeEnd,
UltraMode7.FADE_Z_END), este._ultraMode7FarClipZ), este._ultraMode7FadeBegin);
this._ultraMode7ParallaxDistance =
[Link]([Link]($[Link].UltraMode7_ParallaxDistance,
UltraMode7.DEFAULT_PARALLAX_DISTANCE), 1);
isto._ultraMode7LoopMapsExtendX = 0;
isto._ultraMode7LoopMapsExtendY = 0;
este._ultraMode7LastLoopMapsExtendX = 0;
este._ultraMode7LastLoopMapsExtendY = 0;
// fronteiras
este._ultraMode7BorderLeft = 0;
este._ultraMode7BorderRight = 0;
este._ultraMode7BorderTop = 0;
este._ultraMode7BorderBottom = 0;
var fronteira = 0;
se ($[Link].UltraMode7_Border)
{
borda = [Link]($[Link].UltraMode7_Border,
0);
this._ultraMode7BorderLeft = borda;
this._ultraMode7BorderRight = borda;
this._ultraMode7BorderTop = borda;
this._ultraMode7BorderBottom = borda;
}
outro
{
se ($[Link].UltraMode7_BorderHorizontal)
{
borda =
[Link]($[Link].UltraMode7_BorderHorizontal, 0);
this._ultraMode7BorderLeft = borda;
this._ultraMode7BorderRight = borda;
}
outro
{
este._ultraMode7BorderLeft =
[Link]($[Link].UltraMode7_BorderLeft, 0);
este._ultraMode7BorderRight =
[Link]($[Link].UltraMode7_BorderRight, 0);
}
se ($[Link].UltraMode7_BorderVertical)
{
borda =
[Link]($[Link].UltraMode7_BorderVertical, 0);
this._ultraMode7BorderTop = borda;
this._ultraMode7BorderBottom = borda;
}
outro
{
este._ultraMode7BorderTop =
[Link]($[Link].UltraMode7_BorderTop, 0);
este._ultraMode7BorderBottom =
[Link]($[Link].UltraMode7_BorderBottom, 0);
}
}
isto.refreshUltraMode7View();
}
};

Game_Map.prototype.setUltraMode7Fov = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7Fov = [Link](value, UltraMode7.MIN_FOV); // limite mais ou
menos arbitrário, mas há grandes problemas com valores menores
isto.refreshUltraMode7View();
};

Game_Map.prototype.setUltraMode7Pitch = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7Pitch = [Link](UltraMode7.MIN_PITCH,
UltraMode7.MAX_PITCH);
isto.refreshUltraMode7View();
};

Game_Map.prototype.setUltraMode7Yaw = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7Yaw = valor;
isto.refreshUltraMode7View();
};

Game_Map.prototype.setUltraMode7Roll = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7Roll = valor;
isto.refreshUltraMode7View();
};

Game_Map.prototype.setUltraMode7CameraDistance = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7CameraDistance = [Link](valor, 0);
isto.refreshUltraMode7View();
};

Game_Map.prototype.setUltraMode7CameraY = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7CameraY = valor;
isto.refreshUltraMode7View();
};

Game_Map.prototype.setUltraMode7NearClipY = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7NearClipZ = valor;
isto.refreshUltraMode7View();
};

Game_Map.prototype.setUltraMode7FarClipZ = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7FarClipZ = valor;
isto.refreshUltraMode7View();
};

Game_Map.prototype.setUltraMode7ParallaxDistance = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7ParallaxDistance = [Link](valor, 1);
isto.refreshUltraMode7View();
};

Game_Map.prototype.setUltraMode7FadeColor = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7FadeColor = [Link](valor);
isto.refreshUltraMode7View();
};

Game_Map.prototype.setUltraMode7FadeBegin = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7FadeBegin = valor;
isto.refreshUltraMode7View();
};

Game_Map.prototype.setUltraMode7FadeEnd = função(valor)
{
se (!this._useUltraMode7)
{
retornar;
}
this._ultraMode7FadeEnd = valor;
isto.refreshUltraMode7View();
};

Game_Map.prototype.refreshUltraMode7View = função()
{
se (!this._useUltraMode7)
{
retornar;
}
se (isto.éLoopHorizontal() || isto.éLoopVertical())
{
se (this._ultraMode7Fov < 180)
{
const halfFov = this._ultraMode7Fov * [Link] / 360;
const topVector = this._ultraMode7FarClipZ / [Link](halfFov);
const maxVector = [Link](topVector / [Link](halfFov *
[Link] / [Link]));
const correctedVector = maxVector *
this._ultraMode7CameraDistance / this._ultraMode7FarClipZ;
var newExtendX = [Link](correctedVector / [Link]()) +
1; // +1, porque a coordenada do bloco está centralizada no Modo7
var newExtendY = [Link](correctedVector / [Link]()) +
1; // +1, porque a coordenada do bloco está centralizada no Modo7
se (UltraMode7.LOOP_MAPS_EXTEND_TILES_SMART)
{
se (este._ultraMode7LoopMapsExtendX === 0 || novoExtendX -
este._ultraMode7LoopMapsExtendX >= UltraMode7.LOOP_MAPS_EXTEND_TILES)
{
este._ultraMode7LoopMapsExtendX = novoExtendX;
}
se (este._ultraMode7LoopMapsExtendY === 0 || novoExtendY -
este._ultraMode7LoopMapsExtendY >= UltraMode7.LOOP_MAPS_EXTEND_TILES)
{
este._ultraMode7LoopMapsExtendY = novoExtendY;
}
}
outro
{
este._ultraMode7LoopMapsExtendX = novoExtendX;
este._ultraMode7LoopMapsExtendY = novoExtendY;
}
}
}
outro
{
isto._ultraMode7LoopMapsExtendX = 0;
isto._ultraMode7LoopMapsExtendY = 0;
este._ultraMode7LastLoopMapsExtendX = 0;
este._ultraMode7LastLoopMapsExtendY = 0;
}
// configurar as matrizes
se (this._ultraMode7Fov > 0)
{
este._ultraMode7ProjectionMatrix.setPerspective(este._ultraMode7Fov,
Grá[Link], Grá[Link], este._ultraMode7NearClipZ,
este._ultraMode7FarClipZ);
}
outro
{
this._ultraMode7ProjectionMatrix.setOrthoProjection(0, 0,
Grá[Link], Grá[Link]);
}
const olho = novo Vetor3(0, 0, this._ultraMode7CameraDistance);
const alvo = novo Vetor3(0, 0, 0);
const up = novo Vetor3(0, 1, 0);
this._ultraMode7ModelviewMatrix.lookAt(olho, alvo, cima);
isto._ultraMode7ModelviewMatrix.translate($[Link](), 0, 0);
este._ultraMode7ModelviewMatrix.rotateX(este._ultraMode7Pitch);
este._ultraMode7ModelviewMatrix.rotateY(este._ultraMode7Roll);
este._ultraMode7ModelviewMatrix.rotateZ(este._ultraMode7Yaw);
this._ultraMode7ModelviewMatrix.translate(-Grá[Link] / 2 -
[Link]() * [Link](), -Grá[Link] / 2 - ([Link]() + 0,5)
* [Link](), -this._ultraMode7CameraY);
};

Game_Map.prototype.adjustUltraMode7LoopedPosition = função(x, y)
{
const halfWidth = [Link](Grá[Link] / 2 / [Link]());
const meiaAltura = [Link](Grá[Link] / 2 / [Link]());
x -= this._displayX + meiaLargura;
y -= this._displayY + meiaAltura;
se ([Link]())
{
const largura = [Link]();
se (x < -largura / 2)
{
x += largura;
}
senão se (x > largura / 2)
{
x -= largura;
}
}
se ([Link]())
{
const altura = [Link]();
se (y < -altura / 2)
{
y += altura;
}
senão se (y > altura / 2)
{
y -= altura;
}
}
retornar {x: x + meiaLargura, y: y + meiaAltura};
};

const UltraMode7_Game_Map_prototype_parallaxOx = Mapa_do_jogo.[Link];

Game_Map.[Link] = função()
{
se (!this._useUltraMode7)
{
retornar UltraMode7_Game_Map_prototype_parallaxOx.call(isto);
}
const deslocamento = -2 * UltraMode7.DEFAULT_PARALLAX_DISTANCE * [Link] *
this._ultraMode7Yaw / 360;
se (this._parallaxZero)
{
retornar (this._parallaxX * UltraMode7.PARALLAX_SCROLL_X_MULTIPLIER *
[Link]() + deslocamento);
}
se (this._parallaxLoopX)
{
retornar (this._parallaxX * UltraMode7.PARALLAX_SCROLL_X_MULTIPLIER *
[Link]() / 2 + deslocamento);
}
retornar 0;
};

const UltraMode7_Game_Map_prototype_parallaxOy = Mapa_do_jogo.[Link];

Game_Map.[Link] = função()
{
se (!this._useUltraMode7)
{
retornar UltraMode7_Game_Map_prototype_parallaxOy.call(isto);
}
const deslocamento = -2 * UltraMode7.DEFAULT_PARALLAX_DISTANCE * [Link] *
this._ultraMode7Pitch / 360;
se (this._parallaxZero)
{
retornar (this._parallaxY * UltraMode7.PARALLAX_SCROLL_Y_MULTIPLIER *
[Link]() + deslocamento);
}
se (this._parallaxLoopY)
{
retornar (this._parallaxY * UltraMode7.PARALLAX_SCROLL_Y_MULTIPLIER *
[Link]() / 2 + deslocamento);
}
retornar 0;
};

Game_Map.prototype.clampUltraMode7DisplayX = função(x)
{
const screenTileX = [Link]();
const esquerda = -(screenTileX - 1) * 0,5 + this._ultraMode7BorderLeft;
const direita = [Link]() - (screenTileX + 1) * 0,5 -
this._ultraMode7BorderRight;
const largura = [Link]() - (this._ultraMode7BorderLeft +
this._ultraMode7BorderRight);
retornar (largura < 0 ? largura / 2 : [Link](esquerda, direita));
};

Game_Map.prototype.clampUltraMode7DisplayY = função(y)
{
const screenTileY = [Link]();
const top = -(screenTileY - 1) * 0,5 + this._ultraMode7BorderTop;
const bottom = [Link]() -(screenTileY + 1) * 0,5 -
this._ultraMode7BorderBottom;
const altura = [Link]() - (this._ultraMode7BorderTop +
this._ultraMode7BorderBottom);
retornar (altura < 0 ? altura / 2 : [Link](topo, fundo));
};

const UltraMode7_Game_Map_prototype_scrollDown = Mapa_do_jogo.[Link];

Game_Map.[Link] = função(distância)
{
se (!this._useUltraMode7)
{
UltraMode7_Game_Map_prototype_scrollDown.call(isto, distância);
retornar;
}
se ([Link]())
{
this._displayY = (this._displayY + distância) % $[Link];
se (this._parallaxLoopY)
{
this._parallaxY += distância;
}
}
outro
{
const lastY = this._displayY;
this._displayY = this.clampUltraMode7DisplayY(this._displayY +
distância);
isto._parallaxY += isto._displayY - últimoY;
}
isto.refreshUltraMode7View();
};

const UltraMode7_Game_Map_prototype_scrollLeft = Mapa_do_jogo.[Link];

Game_Map.[Link] = função(distância)
{
se (!this._useUltraMode7)
{
UltraMode7_Game_Map_prototype_scrollLeft.call(isto, distância);
retornar;
}
se ([Link]())
{
this._displayX = (this._displayX + $[Link] - distância) %
$[Link];
se (this._parallaxLoopX)
{
this._parallaxX -= distância;
}
}
outro
{
const lastX = this._displayX;
this._displayX = this.clampUltraMode7DisplayX(this._displayX -
distância);
isto._parallaxX += isto._displayX - últimoX;
}
isto.refreshUltraMode7View();
};

const UltraMode7_Game_Map_prototype_scrollUp = Mapa_do_jogo.[Link];

Game_Map.[Link] = função(distância)
{
se (!this._useUltraMode7)
{
UltraMode7_Game_Map_prototype_scrollUp.call(isto, distância);
retornar;
}
se ([Link]())
{
this._displayY = (this._displayY + $[Link] - distância) %
$[Link];
se (this._parallaxLoopY)
{
this._parallaxY -= distância;
}
}
outro
{
const lastY = this._displayY;
this._displayY = this.clampUltraMode7DisplayY(this._displayY -
distância);
isto._parallaxY += isto._displayY - últimoY;
}
isto.refreshUltraMode7View();
};

const UltraMode7_Game_Map_prototype_update = Mapa_do_jogo.[Link];

Game_Map.[Link] = função(cenaAtiva)
{
UltraMode7_Game_Map_prototype_update.call(this, cenaAtiva);
se (this._useUltraMode7)
{
isto.updateUltraMode7();
}
};

Game_Map.prototype.updateUltraMode7 = função()
{
var needRefresh = falso;
const agitar = $[Link]();
se (this._ultraMode7Shake !== agitar)
{
this._ultraMode7Shake = agitar
precisaAtualizar = verdadeiro;
}
var duração = 0;
se (this._ultraMode7FovDuration !== indefinido && this._ultraMode7FovDuration
> 0)
{
duração = this._ultraMode7FovDuration;
this._ultraMode7Fov = [Link]((this._ultraMode7Fov * (duração - 1) +
this._ultraMode7FovTarget) / duração, UltraMode7.MIN_FOV);
--this._ultraMode7FovDuration;
precisaAtualizar = verdadeiro;
}
se (this._ultraMode7PitchDuration !== indefinido &&
this._ultraMode7PitchDuration > 0)
{
duração = this._ultraMode7PitchDuration;
this._ultraMode7Pitch = ((this._ultraMode7Pitch * (duração - 1) +
this._ultraMode7PitchTarget) / duração).clamp(UltraMode7.MIN_PITCH,
UltraMode7.MAX_PITCH);
--this._ultraMode7PitchDuration;
precisaAtualizar = verdadeiro;
}
se (this._ultraMode7YawDuration !== indefinido && this._ultraMode7YawDuration
> 0)
{
duração = this._ultraMode7YawDuration;
this._ultraMode7Yaw = (this._ultraMode7Yaw * (duração - 1) +
this._ultraMode7YawTarget) / duração;
--this._ultraMode7YawDuration;
precisaAtualizar = verdadeiro;
}
se (this._ultraMode7RollDuration !== indefinido &&
this._ultraMode7RollDuration > 0)
{
duração = this._ultraMode7RollDuration;
this._ultraMode7Roll = (this._ultraMode7Roll * (duração - 1) +
this._ultraMode7RollTarget) / duração;
--this._ultraMode7RollDuration;
precisaAtualizar = verdadeiro;
}
se (this._ultraMode7CameraDistanceDuration !== indefinido &&
this._ultraMode7CameraDistanceDuration > 0)
{
duração = this._ultraMode7CameraDistanceDuration;
this._ultraMode7CameraDistance =
[Link]((this._ultraMode7CameraDistance * (duração - 1) +
this._ultraMode7CameraDistanceTarget) / duração, 0);
--this._ultraMode7DistanceDuration da Câmera;
precisaAtualizar = verdadeiro;
}
se (this._ultraMode7CameraYDuration !== indefinido &&
this._ultraMode7CameraYDuration > 0)
{
duração = this._ultraMode7CameraYDuration;
this._ultraMode7CameraY = (this._ultraMode7CameraY * (duração - 1) +
this._ultraMode7CameraYTarget) / duração;
--this._ultraMode7CameraYDuration;
precisaAtualizar = verdadeiro;
}
se (this._ultraMode7NearClipZDuration !== indefinido &&
this._ultraMode7NearClipZDuration > 0)
{
duração = this._ultraMode7NearClipZDuration;
this._ultraMode7NearClipZ = (this._ultraMode7NearClipZ * (duração - 1)
+ this._ultraMode7NearClipZTarget) / duração;
--this._ultraMode7NearClipZDuration;
precisaAtualizar = verdadeiro;
}
se (this._ultraMode7FarClipZDuration !== indefinido &&
this._ultraMode7FarClipZDuration > 0)
{
duração = this._ultraMode7FarClipZDuration;
this._ultraMode7FarClipZ = (this._ultraMode7FarClipZ * (duração - 1) +
this._ultraMode7FarClipZTarget) / duração;
--this._ultraMode7FarClipZDuration;
precisaAtualizar = verdadeiro;
}
se (this._ultraMode7FadeColorDuration !== indefinido &&
this._ultraMode7FadeColorDuration > 0)
{
duração = this._ultraMode7FadeColorDuration;
para (var i = 0; i < this._ultraMode7FadeColor.length; ++i)
{
this._ultraMode7FadeColor[i] =
[Link]((this._ultraMode7FadeColor[i] * (duração - 1) +
this._ultraMode7FadeColorTarget[i]) / duração, 0);
}
--this._ultraMode7FadeColorDuration;
precisaAtualizar = verdadeiro;
}
se (this._ultraMode7FadeBeginDuration !== indefinido &&
this._ultraMode7FadeBeginDuration > 0)
{
duração = this._ultraMode7FadeBeginDuration;
this._ultraMode7FadeBegin = [Link]((this._ultraMode7FadeBegin *
(duração - 1) + this._ultraMode7FadeBeginTarget) / duração, 0);
--this._ultraMode7FadeBeginDuration;
precisaAtualizar = verdadeiro;
}
se (this._ultraMode7FadeEndDuration !== indefinido &&
this._ultraMode7FadeEndDuration > 0)
{
duração = this._ultraMode7FadeEndDuration;
this._ultraMode7FadeEnd = [Link]((this._ultraMode7FadeEnd * (duração
- 1) + this._ultraMode7FadeEndTarget) / duração, 0);
--this._ultraMode7FadeEndDuration;
precisaAtualizar = verdadeiro;
}
se (precisaAtualizar)
{
isto.refreshUltraMode7View();
}
};

Game_Map.prototype.animateUltraMode7Fov = função(alvo, duração do quadro)

{
this._ultraMode7FovTarget = alvo;
this._ultraMode7FovDuration = duração do quadro;
};

Game_Map.prototype.animateUltraMode7Pitch = função(alvo, duração do quadro)

{
this._ultraMode7PitchTarget = alvo;
this._ultraMode7PitchDuration = duração do quadro;
};

Game_Map.prototype.animateUltraMode7Yaw = função(alvo, duração do quadro)

{
this._ultraMode7YawTarget = alvo;
this._ultraMode7YawDuration = duração do quadro;
};

Game_Map.prototype.animateUltraMode7Roll = função(alvo, duração do quadro)

{
this._ultraMode7RollTarget = alvo;
this._ultraMode7RollDuration = frameDuration;
};

Game_Map.prototype.animateUltraMode7CameraDistance = função(alvo, duração do

quadro)
{
this._ultraMode7CameraDistanceTarget = alvo;
this._ultraMode7CameraDistanceDuration = duração do quadro;
};

Game_Map.prototype.animateUltraMode7CameraY = função(alvo, duração do quadro)

{
this._ultraMode7CameraYTarget = alvo;
this._ultraMode7CameraYDuration = duração do quadro;
};

Game_Map.prototype.animateUltraMode7NearClipZ = função(alvo, duração do quadro)

{
this._ultraMode7NearClipZTarget = alvo;
this._ultraMode7NearClipZDuration = duração do quadro;
};

Game_Map.prototype.animateUltraMode7FarClipZ = função(alvo, duração do quadro)

{
this._ultraMode7FarClipZTarget = alvo;
this._ultraMode7FarClipZDuration = duração do quadro;
};

Game_Map.prototype.animateUltraMode7FadeColor = função(alvo, duração do quadro)

{
this._ultraMode7FadeColorTarget = [Link](alvo);
this._ultraMode7FadeColorDuration = frameDuration;
};

Game_Map.prototype.animateUltraMode7FadeBegin = função(alvo, duração do quadro)

{
this._ultraMode7FadeBeginTarget = alvo;
this._ultraMode7FadeBeginDuration = duração do quadro;
};

Game_Map.prototype.animateUltraMode7FadeEnd = função(alvo, frameDuration)

{
this._ultraMode7FadeEndTarget = alvo;
this._ultraMode7FadeEndDuration = frameDuration;
};

//============================================== =============================
// Base_de_Caracteres_do_Jogo
//============================================== =============================

const UltraMode7_Game_CharacterBase_prototype_shiftY =
Base_de_caracteres_do_jogo.[Link];
Game_CharacterBase.[Link] = função()
{
se (![Link]())
{
retornar UltraMode7_Game_CharacterBase_prototype_shiftY.call(isto);
}
retornar ([Link]() ? 0 : UltraMode7.CHARACTERS_SHIFT_Y);
};

const UltraMode7_Game_CharacterBase_prototype_screenX =
Base_de_caracteres_do_jogo.[Link];
Game_CharacterBase.[Link] = função()
{
const x = UltraMode7_Game_CharacterBase_prototype_screenX.call(isto);
se (![Link]())
{
retornar x;
}
const y = UltraMode7_Game_CharacterBase_prototype_screenY.call(isto);
retornar [Link](x, y).x;
};

const UltraMode7_Game_CharacterBase_prototype_screenY =
Base_de_caracteres_do_jogo.[Link];
Game_CharacterBase.[Link] = função()
{
const y = UltraMode7_Game_CharacterBase_prototype_screenY.call(isto);
se (![Link]())
{
retornar y;
}
const x = UltraMode7_Game_CharacterBase_prototype_screenX.call(isto);
retornar [Link](x, y).y;
};

Game_CharacterBase.[Link] = função()
{
se (![Link]())
{
retornar 1.0;
}
const x = UltraMode7_Game_CharacterBase_prototype_screenX.call(isto);
const y = UltraMode7_Game_CharacterBase_prototype_screenY.call(isto);
retornar [Link](x, y);
};

Game_CharacterBase.[Link] = função()
{
se (![Link]() || !UltraMode7.CHARACTERS_USE_FADE_Z)
{
retornar nulo;
}
const x = UltraMode7_Game_CharacterBase_prototype_screenX.call(isto);
const y = UltraMode7_Game_CharacterBase_prototype_screenY.call(isto);
const z = [Link](x, y).z;
const fadeBegin = $gameMap.ultraMode7FadeBegin;
const fadeEnd = $gameMap.ultraMode7FadeEnd;
const fadeColor = $gameMap.ultraMode7FadeColor;
const resultado = [[Link](fadeColor[0] * 255), [Link](fadeColor[1] *
255), [Link](fadeColor[2] * 255), 0];
se (z >= fadeEnd)
{
resultado[3] = 255;
}
senão se (z > fadeBegin && z < fadeEnd)
{
resultado[3] = [Link]((z - fadeBegin) / (fadeEnd - fadeBegin) *
255);
}
retornar resultado;
};

Game_CharacterBase.prototype.isUltraMode7Visible = função()
{
se (![Link]())
{
retornar verdadeiro;
}
se ($gameMap.ultraMode7Fov <= 0)
{
retornar verdadeiro;
}
const x = UltraMode7_Game_CharacterBase_prototype_screenX.call(isto);
const y = UltraMode7_Game_CharacterBase_prototype_screenY.call(isto);
retornar [Link]([Link](x, y).z);
};

//============================================== =============================
// Jogador_do_jogo
//============================================== =============================

const UltraMode7_Game_Player_prototype_getInputDirection =
Jogador_do_jogo.[Link];
Game_Player.[Link] = função()
{
var resultado =
UltraMode7_Game_Player_prototype_getInputDirection.call(this);
se ([Link]() && resultado > 0 &&
UltraMode7.PLAYER_ADJUST_MOVE_DIRECTION)
{
resultado = [Link](resultado, falso);
}
retornar resultado;
};

//============================================== =============================
// Veículo_de_jogo
//============================================== =============================
Game_Vehicle.[Link] = função()
{
se (![Link]() || !$[Link]())
{
retornar Game_Character.[Link](isto);
}
retornar $gameMap.adjustUltraMode7LoopedPosition(this._realX, this._realY).x;
};

Game_Vehicle.[Link] = função()
{
se (![Link]() || !$[Link]())
{
retornar Game_Character.[Link](isto);
}
retornar $gameMap.adjustUltraMode7LoopedPosition(this._realX, this._realY).y;
};

//============================================== =============================
// Evento_do_jogo
//============================================== =============================

Game_Event.[Link] = função()
{
se (![Link]() || !$[Link]())
{
retornar Game_Character.[Link](isto);
}
retornar $gameMap.adjustUltraMode7LoopedPosition(this._realX, this._realY).x;
};

Evento_jogo.[Link] = função()
{
se (![Link]() || !$[Link]())
{
retornar Game_Character.[Link](isto);
}
retornar $gameMap.adjustUltraMode7LoopedPosition(this._realX, this._realY).y;
};

//============================================== =============================
// Personagem_Sprite
//============================================== =============================

const UltraMode7_Sprite_Character_prototype_updateBitmap =
Sprite_Character.[Link];
Sprite_Character.[Link] = função()
{
const imagemChanged = [Link]();
UltraMode7_Sprite_Character_prototype_updateBitmap.call(isto);
se ([Link]() && imageChanged && [Link])
{
[Link] = !UltraMode7.CHARACTERS_PIXELATED;
}
};

const UltraMode7_Sprite_Character_prototype_characterPatternY =
Sprite_Character.[Link];
Sprite_Character.[Link] = função()
{
se (![Link]() || !UltraMode7.CHARACTERS_ADJUST_SPRITE_DIRECTION)
{
retornar
UltraMode7_Sprite_Character_prototype_characterPatternY.call(this);
}
retornar ([Link](this._character.direction(), verdadeiro)
- 2) / 2;
};

Sprite_Character.prototype._ultraMode7PreUpdate = função()
{
[Link].x = 1;
[Link].y = 1;
[Link]ção = 0;
};

Sprite_Character.prototype._ultraMode7Update = função()
{
const escala = this._character.screenScale();
[Link].x *= escala;
[Link].y *= escala;
[Link]ção += [Link] * $gameMap.ultraMode7Roll / 180;
};

//============================================== =============================
// Destino_Sprite
//============================================== =============================

const UltraMode7_Sprite_Destination_prototype_updatePosition =
Sprite_Destination.[Link];
Sprite_Destination.[Link] = função()
{
UltraMode7_Sprite_Destination_prototype_updatePosition.call(isto);
se (![Link]())
{
retornar;
}
const posição = [Link](this.x, this.y);
isto.x = posição.x;
isto.y = posição.y;
};

//============================================== =============================
// Mapa_de_cenas
//============================================== =============================

//============================================== =============================
// Compatibilidade com o movimento dos personagens do MOG
//============================================== =============================

tente // se isso quebrar por algum motivo, para que não quebre outro código de
compatibilidade
{
se (Importado && Importado.MOG_CharacterMotion)
{
[Link]("Detectado 'Movimento de personagem do MOG', habilitando
código de compatibilidade.");

//==============================================
=============================
// Personagem_Sprite
//==============================================
=============================

const UltraMode7_Sprite_Character_prototype_updateSprParameters =
Parâmetros do caractere [Link];
Sprite_Character.[Link] = função()
{

UltraMode7_Sprite_Character_prototype_updateSprParameters.call(isto);
se (![Link]())
{
retornar;
}
// alguns guardas de segurança
se (!!este._caractere && !!este._caractere.telaBlendColor)
{
const blendColor = this._character.screenBlendColor();
se (blendColor !== nulo)
{
[Link](blendColor);
}
}
}
}
}
pegar (erro)
{
[Link](erro);
}

//============================================== =============================
// Compatibilidade com Grid-Free Doodads da Yanfly
//============================================== =============================

tente // se isso quebrar por algum motivo, para que não quebre outro código de
compatibilidade
{
se (Importado && Importado.YEP_GridFreeDoodads)
{
[Link]("Detectados 'Yanfly's Grid-Free Doodads', habilitando
código de compatibilidade.");

//==============================================
=============================
// Sprite_Doodad
//==============================================
=============================

Sprite_Doodad.prototype._makeLoopedScreenPosition = função()
{
const loopedPosition =
$gameMap.adjustUltraMode7LoopedPosition(este._dados.x / este._tileWidth,
este._dados.y / este._tileHeight);
retornar {x: loopedPosition.x * $[Link](), y:
loopedPosition.y * $[Link]()};
};

Sprite_Doodad.prototype._updateRotation = função()
{
[Link]ção = (este._dados.rotação !== indefinido ?
este._dados.rotação : 0) + [Link] * $gameMap.ultraMode7Roll / 180;
};

const UltraMode7_Sprite_Doodad_prototype_screenX =
Sprite_Doodad.[Link];
Sprite_Doodad.[Link] = função()
{
se (![Link]())
{
retornar
UltraMode7_Sprite_Doodad_prototype_screenX.call(isto);
}
const posição = this._makeLoopedScreenPosition();
retornar [Link](posição.x, posição.y).x;
};

const UltraMode7_Sprite_Doodad_prototype_screenY =
Sprite_Doodad.[Link];
Sprite_Doodad.[Link] = função()
{
se (![Link]())
{
retornar
UltraMode7_Sprite_Doodad_prototype_screenY.call(isto);
}
const posição = this._makeLoopedScreenPosition();
retornar [Link](posição.x, posição.y).y;
};

Sprite_Doodad.[Link] = função()
{
se (![Link]())
{
retornar 1.0;
}
const posição = this._makeLoopedScreenPosition();
retornar [Link](posição.x, posição.y);
};

Sprite_Doodad.[Link] = função()
{
se (![Link]() || !UltraMode7.CHARACTERS_USE_FADE_Z)
{
retornar nulo;
}
const posição = this._makeLoopedScreenPosition();
const z = [Link](posição.x, posição.y).z;
const fadeBegin = $gameMap.ultraMode7FadeBegin;
const fadeEnd = $gameMap.ultraMode7FadeEnd;
const fadeColor = $gameMap.ultraMode7FadeColor;
const resultado = [[Link](fadeColor[0] * 255),
[Link](fadeColor[1] * 255), [Link](fadeColor[2] * 255), 0];
se (z >= fadeEnd)
{
resultado[3] = 255;
}
senão se (z > fadeBegin && z < fadeEnd)
{
resultado[3] = [Link]((z - fadeBegin) / (fadeEnd -
fadeBegin) * 255);
}
retornar resultado;
};

Sprite_Doodad.prototype.isUltraMode7Visible = função()
{
se (![Link]())
{
retornar verdadeiro;
}
se ($gameMap.ultraMode7Fov <= 0)
{
retornar verdadeiro;
}
const posição = this._makeLoopedScreenPosition();
retornar
[Link]([Link](posição.x, posição.y).z);
};

// Correção de compatibilidade ZephAM_YEPDoodadExt

se (Sprite_Doodad.[Link])
{
const UltraMode7_Sprite_Doodad_prototype_extendSettings =
Sprite_Doodad.[Link];
Sprite_Doodad.[Link] = função()
{

UltraMode7_Sprite_Doodad_prototype_extendSettings.call(isto);
isto._updateRotation();
};
}

//==============================================
=============================
// Sprite_DoodadCursor
//==============================================
=============================

if (!!Sprite_DoodadCursor) // esta classe parece não existir em

compilações implantadas
{
const UltraMode7_Sprite_DoodadCursor_prototype_updatePosition =
Sprite_DoodadCursor.[Link];
Sprite_DoodadCursor.[Link] = função()
{

UltraMode7_Sprite_DoodadCursor_prototype_updatePosition.call(isto);
se (![Link]())
{
retornar;
}
const escala = [Link]();
[Link].x = escala * esta._dados.escalaX / 100;
[Link].y = escala * esta._dados.escalaY / 100;
[Link]ção = [Link] * $gameMap.ultraMode7Roll / 180;
};

Sprite_DoodadCursor.[Link] = função()
{
se (![Link]())
{
retornar 1.0;
}
const posição = [Link](this.x, this.y);
const loopedPosition =
$gameMap.adjustUltraMode7LoopedPosition(posição.x / $[Link](), posição.y
/ $[Link]());
const x = [Link](loopedPosition.x *
$[Link]());
const y = [Link](loopedPosition.y *
$[Link]());
retornar [Link](x, y);
};

Sprite_DoodadCursor.prototype.ultraMode7ScreenScale = função(x,
y)
{
se (![Link]())
{
retornar 1.0;
}
retornar [Link](x, y);
};
}

//==============================================
=============================
// Gerenciador de Doodads
//==============================================
=============================

if (!!DoodadManager) // esta classe parece não existir em compilações

implantadas
{
DoodadManager.getUltraMode7DoodadScreenX = função (x)
{
retornar (x - $[Link]() * $[Link]());
};

DoodadManager.getUltraMode7DoodadScreenY = função (y)

{
retornar (y - $[Link]() * $[Link]());
};

const UltraMode7_DoodadManager_addNew = [Link];

[Link] = função(doodad)
{
se ([Link]())
{
posição const =
[Link](DoodadManager.getUltraMode7DoodadScreenX(doodad.x),
DoodadManager.getUltraMode7DoodadScreenY(doodad.y));
bugiganga.x = posição.x;
doodad.y = posição.y;
}
UltraMode7_DoodadManager_addNew.call(este, doodad);
};
}

}
}
pegar (erro)
{
[Link](erro);
}

//============================================== =============================
// Compatibilidade com KhasUltraLighting
//============================================== =============================

tente // se isso quebrar por algum motivo, para que não quebre outro código de
compatibilidade
{
if (Khas && [Link] && [Link] >= 4.2)
{
[Link]("Detectado 'KhasUltraLighting', habilitando código de
compatibilidade.");

//==============================================
=============================
// Base_de_Caracteres_do_Jogo
//==============================================
=============================

Game_CharacterBase.prototype.lightScreenUltraMode7X = função()
{
retornar [Link](([Link]() + 0.5) *
$[Link]() + $[Link]());
};

Game_CharacterBase.prototype.lightScreenUltraMode7Y = função()
{
retornar [Link](([Link]() + 0.5) *
$[Link]());
};

const UltraMode7_Game_CharacterBase_prototype_lightScreenX =
Base_de_caracteres_do_jogo.[Link];
Game_CharacterBase.[Link] = função()
{
se (![Link]())
{
retornar
UltraMode7_Game_CharacterBase_prototype_lightScreenX.call(isto);
}
const x = this.lightScreenUltraMode7X();
const y = this.lightScreenUltraMode7Y() + $[Link]() /
2;
retornar [Link](x, y).x;
};

const UltraMode7_Game_CharacterBase_prototype_lightScreenY =
Base_de_Caracteres_do_Jogo.[Link];
Game_CharacterBase.[Link] = função()
{
se (![Link]())
{
retornar
UltraMode7_Game_CharacterBase_prototype_lightScreenY.call(isto);
}
const halfTileHeight = $[Link]() / 2;
const x = this.lightScreenUltraMode7X();
const y = this.lightScreenUltraMode7Y() + halfTileHeight;
retornar [Link](x, y).y - halfTileHeight *
[Link]();
};
//==============================================
=============================
// Jogo_LightTile
//==============================================
=============================

Game_LightTile.[Link] = função()
{
se (![Link]() || !$[Link]())
{
retornar $[Link](this._realX);
}
retornar $gameMap.adjustUltraMode7LoopedPosition(this._realX,
this._realY).x;
};

Game_LightTile.[Link] = função()
{
se (![Link]() || !$[Link]())
{
retornar $[Link](this._realY);
}
retornar $gameMap.adjustUltraMode7LoopedPosition(this._realX,
this._realY).y;
};

Game_LightTile.prototype.lightScreenUltraMode7X = função()
{
retornar [Link]([Link]() * $[Link]() +
$[Link]());
};

Game_LightTile.prototype.lightScreenUltraMode7Y = função()
{
retornar [Link]([Link]() * $[Link]());
};

Game_LightTile.[Link] = função()
{
se (![Link]())
{
retornar 1.0;
}
const x = this.lightScreenUltraMode7X() + $[Link]() /
2;
const y = this.lightScreenUltraMode7Y() + $[Link]() /
2;
retornar [Link](x, y);
};

Game_LightTile.prototype.isUltraMode7Visible = função()
{
se (![Link]())
{
retornar verdadeiro;
}
se ($gameMap.ultraMode7Fov <= 0)
{
retornar verdadeiro;
}
const x = this.lightScreenUltraMode7X() + $[Link]() /
2;
const y = this.lightScreenUltraMode7Y() + $[Link]() /
2;
retornar [Link]([Link](x, y).z);
};

const UltraMode7_Game_LightTile_prototype_lightScreenX =
Jogo_LightTile.[Link];
Game_LightTile.[Link] = função()
{
se (![Link]())
{
retornar
UltraMode7_Game_LightTile_prototype_lightScreenX.call(isto);
}
const x = this.lightScreenUltraMode7X();
const y = this.lightScreenUltraMode7Y() + $[Link]() /
2;
retornar [Link](x, y).x;
};

const UltraMode7_Game_LightTile_prototype_lightScreenY =
Jogo_LightTile.[Link];
Game_LightTile.[Link] = função()
{
se (![Link]())
{
retornar
UltraMode7_Game_LightTile_prototype_lightScreenY.call(isto);
}
const halfTileHeight = $[Link]() / 2;
const x = this.lightScreenUltraMode7X();
const y = this.lightScreenUltraMode7Y() + halfTileHeight;
retornar [Link](x, y).y - halfTileHeight *
[Link]();
};

//==============================================
=============================
// Luz_Sprite
//==============================================
=============================

const UltraMode7_Sprite_Light_prototype_refreshScreenPosition =
Sprite_Light.[Link];
Sprite_Light.[Link] = função()
{

UltraMode7_Sprite_Light_prototype_refreshScreenPosition.call(isto);
se (![Link]())
{
retornar;
}
// algumas proteções de segurança para garantir compatibilidade
com objetos personalizados
se (!!este._caractere)
{
se (!!this._character.screenScale)
{
const escala = this._character.screenScale();
[Link].x = escala;
[Link].y = escala;
}
[Link]ção = [Link] * $gameMap.ultraMode7Roll / 180;
se (!!this._character.isUltraMode7Visible)
{
[Link]ível = isto._character.isUltraMode7Visible();
}
}
};
}
}
pegar (erro)
{
// pode causar erro simplesmente por não existir, então nenhum registro é
feito
}

tente // se isso quebrar por algum motivo, para que não quebre outro código de
compatibilidade
{
se (Importado && Importado.Soul_ThomasEdisonMV)
{
[Link]("Detectado 'Thomas Edison MV', habilitando código de
compatibilidade.");

//==============================================
=============================
// EdisonLightMVPersonalizado
//==============================================
=============================

//==============================================
=============================
// EdisonLightMV
//==============================================
=============================

}
}
pegar (erro)
{
[Link](erro);
}

//============================================== =============================
// Compatibilidade com sombras quase simples
//============================================== =============================

tente // se isso quebrar por algum motivo, para que não quebre outro código de
compatibilidade
{
se (Importado && [Link])
{
[Link]("Detectadas 'sombras quase simples', habilitando código
de compatibilidade.");

//==============================================
=============================
// Sombra_do_personagem_Sprite
//==============================================
=============================

const UltraMode7_Sprite_CharacterShadow_prototype_updateScaleOpacity =
Sprite_CharacterShadow.[Link];
Sprite_CharacterShadow.[Link] = função()
{

UltraMode7_Sprite_CharacterShadow_prototype_updateScaleOpacity.call(isto);
se (![Link]())
{
retornar;
}
se (!!este._caractere)
{
se (!!this._character.screenScale)
{
const escala = this._character.screenScale();
[Link].x *= escala;
[Link].y *= escala;
}
[Link]ção = [Link] * $gameMap.ultraMode7Roll / 180;
se (!!this._character.screenBlendColor)
{
const blendColor =
this._character.screenBlendColor();
se (blendColor !== nulo)
{
[Link](blendColor);
}
}
}
};

}
}
pegar (erro)
{
[Link](erro);
}

//============================================== =============================
// Compatibilidade com OcRam_Lights
//============================================== =============================

tente // se isso quebrar por algum motivo, para que não quebre outro código de
compatibilidade
{
se (Importado && Importado.OcRam_Core && Importado.OcRam_Lights)
{
[Link]("Detectadas 'Luzes OcRam', habilitando código de
compatibilidade.");

// O CoRam Lights tem uma classe local chamada Light_Data que não é
exposta, portanto não pode ser modificada de fora.
// Felizmente Game_Follower.setupLightData tem uma implementação
simples de instanciação de Light_Data, então isso é usado
// para extrair o construtor de Light_Data para que ele possa ser
modificado pelo Ultra Mode 7 para compatibilidade.
var _dummy = {};
Game_Follower.[Link](_dummy, 1, 1, [255, 255,
255]);
const Light_Data = _dummy._lightData.constructor;
_dummy = indefinido;
// funções utilitárias para posições de terreno

const _terrainScreenX = função()

{
const x = this.UltraMode7_screenX_OC();
se (![Link]())
{
retornar x;
}
retornar [Link](x,
this.UltraMode7_screenY_OC()).x;
};

const _terrainScreenY = função()

{
const y = this.UltraMode7_screenY_OC();
se (![Link]())
{
retornar y;
}
retornar [Link](this.UltraMode7_screenX_OC(),
y).y;
};

//==============================================
=============================
// Base_de_Caracteres_do_Jogo
//==============================================
=============================

const UltraMode7_Game_CharacterBase_prototype_screenX_OC =
Base_de_caracteres_do_jogo.prototype.screenX_OC;
Game_CharacterBase.prototype.screenX_OC = função()
{
const x =
UltraMode7_Game_CharacterBase_prototype_screenX_OC.call(isto);
se (![Link]())
{
retornar x;
}
const y =
UltraMode7_Game_CharacterBase_prototype_screenY_OC.call(isto);
retornar [Link](x, y + OcRam.twh50[0]).x;
};

const UltraMode7_Game_CharacterBase_prototype_screenY_OC =
Base_de_caracteres_do_jogo.prototype.screenY_OC;
Game_CharacterBase.prototype.screenY_OC = função()
{
const y =
UltraMode7_Game_CharacterBase_prototype_screenY_OC.call(isto);
se (![Link]())
{
retornar y;
}
const x =
UltraMode7_Game_CharacterBase_prototype_screenX_OC.call(isto);
retornar [Link](x, y + OcRam.twh50[0]).y;
};
//==============================================
=============================
// Dados_de_luz
//==============================================
=============================

}
}
pegar (erro)
{
[Link](erro);
}
//============================================== =============================
// Compatibilidade com SAN_AnalogMove
//============================================== =============================

tente // se isso quebrar por algum motivo, para que não quebre outro código de
compatibilidade
{
se (Importado && Importado.SAN_AnalogMove)
{
[Link]("Detectado 'SAN AnalogMove', habilitando código de
compatibilidade.");

const UltraMode7_CharacterMover_radToDir8 = CharacterMover.radToDir8;

CharacterMover.radToDir8 = função(radiano)
{
se ([Link]() &&
UltraMode7.PLAYER_ADJUST_MOVE_DIRECTION)
{
radiano = (radiano + [Link] * $gameMap.ultraMode7Yaw /
180);
}
retornar UltraMode7_CharacterMover_radToDir8.call(this, radiano);
};

const UltraMode7_CharacterMover_dir8ToRad = CharacterMover.dir8ToRad;

CharacterMover.dir8ToRad = função(dir8)
{
var resultado = UltraMode7_CharacterMover_dir8ToRad.call(this,
dir8);
se ([Link]() &&
UltraMode7.PLAYER_ADJUST_MOVE_DIRECTION)
{
resultado = (resultado - [Link] * $gameMap.ultraMode7Yaw /
180);
}
retornar resultado;
};

const UltraMode7_CharacterMover_radToDir4 = CharacterMover.radToDir4;

CharacterMover.radToDir4 = função(radiano)
{
se ([Link]() &&
UltraMode7.PLAYER_ADJUST_MOVE_DIRECTION)
{
radiano = (radiano + [Link] * $gameMap.ultraMode7Yaw /
180);
}
retornar UltraMode7_CharacterMover_radToDir4.call(this, radiano);
};

}
}
pegar (erro)
{
[Link](erro);
}

//============================================== =============================
// Mapa Galv Projéteis
//============================================== =============================

tente // se isso quebrar por algum motivo, para que não quebre outro código de
compatibilidade
{
se (Importado && Importado.Galv_MapProjectiles)
{
[Link]("Detectados 'Galv Map Projectiles', habilitando código
de compatibilidade.");

UltraMode7.Galv_MapProjectiles_RANDOM_START_FRAMES = falso;
UltraMode7.Galv_MapProjectiles_Y_OFFSET = 24; // deslocamentos
verticais para que os projéteis não apareçam no chão

//==============================================
=============================
// Mapa_de_cenas
//==============================================
=============================

// desabilita o movimento do mouse para o mapa (novamente) se a

configuração estiver habilitada
se ([Link])
{
Scene_Map.[Link] = função() {};
};

//==============================================
=============================
// [Link]
//==============================================
=============================

const UltraMode7_Galv_PROJ_getTarget = [Link];

[Link] = função(id)
{
se ([Link]() && ![Link](id) && id === 'm')
{
const posição = [Link](TouchInput.x,
TouchInput.y);
retornar {x: [Link](posição.x / [Link]), y:
[Link](posição.y / [Link]), _characterName: true};
}
retornar UltraMode7_Galv_PROJ_getTarget(id);
};

//==============================================
=============================
// Sprite_MapProjectile
//==============================================
=============================

const UltraMode7_Sprite_MapProjectile_setBitmap =
Sprite_MapProjectile.[Link];
Sprite_MapProjectile.[Link] = função()
{
UltraMode7_Sprite_MapProjectile_setBitmap.call(isto);
se (UltraMode7.Galv_MapProjectiles_RANDOM_START_FRAMES &&
este._frames && este._frameSpeed)
{
este._cFrame = [Link](este._frames);
este._fTicker = [Link](este._frameSpeed);
}
};

Sprite_MapProjectile.prototype._makeLoopedScreenPosition = função()
{
// +0,5 necessário devido ao estranho deslocamento de cálculo nas
coordenadas do Galv Map Projectiles
const loopedPosition =
$gameMap.adjustUltraMode7LoopedPosition(this._obj.x / [Link],
this._obj.y / [Link] + 0,5);
retornar {x: loopedPosition.x * [Link], y:
loopedPosition.y * [Link]};
};

const UltraMode7_Sprite_MapProjectile_updateDirection =
Sprite_MapProjectile.[Link];
Sprite_MapProjectile.[Link] = função()
{
UltraMode7_Sprite_MapProjectile_updateDirection.call(isto);
const yo = isto._yo && isto._yoCorrigir ? isto._yo / 48 : 0;
const sMapPosition =
$gameMap.adjustUltraMode7LoopedPosition(this._obj.sTarget.x + 0,5,
this._obj.sTarget.y + 0,5);
const eMapPosition =
$gameMap.adjustUltraMode7LoopedPosition(este._obj.eTarget.x + 0,5,
este._obj.eTarget.y + 0,5);
const sPosition = [Link](sMapPosition.x *
[Link], sMapPosition.y * [Link] + yo);
const ePosition = [Link](eMapPosition.x *
[Link], eMapPosition.y * [Link]);
ângulo constante = Math.atan2(ePosição.y - sPosição.y, ePosição.x
- sPosição.x) * 180 / [Link];
[Link] = (ângulo + 90) * [Link] / 180;
};

Sprite_MapProjectile.[Link] = função()
{
se (![Link]() || !UltraMode7.CHARACTERS_USE_FADE_Z)
{
retornar nulo;
}
const posição = this._makeLoopedScreenPosition();
const z = [Link](posição.x, posição.y).z;
const fadeBegin = $gameMap.ultraMode7FadeBegin;
const fadeEnd = $gameMap.ultraMode7FadeEnd;
const fadeColor = $gameMap.ultraMode7FadeColor;
const resultado = [[Link](fadeColor[0] * 255),
[Link](fadeColor[1] * 255), [Link](fadeColor[2] * 255), 0];
se (z >= fadeEnd)
{
resultado[3] = 255;
}
senão se (z > fadeBegin && z < fadeEnd)
{
resultado[3] = [Link]((z - fadeBegin) / (fadeEnd -
fadeBegin) * 255);
}
retornar resultado;
};

Sprite_MapProjectile.prototype.isUltraMode7Visible = função()
{
se (![Link]())
{
retornar verdadeiro;
}
se ($gameMap.ultraMode7Fov <= 0)
{
retornar verdadeiro;
}
const posição = this._makeLoopedScreenPosition();
retornar
[Link]([Link](posição.x, posição.y).z);
};

}
}
pegar (erro)
{
[Link](erro);
}

//============================================== =============================

})();